react-native-quick-crypto 0.6.1 → 0.7.0-rc.1

package/lib/module/index.js

@@ -1,14 +1,10 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 import { QuickCrypto } from './QuickCrypto';
-import FallbackCrypto from 'crypto-browserify'; // @ts-expect-error Buffer does not match exact same type definition.
 
+// @ts-expect-error Buffer does not match exact same type definition.
 global.Buffer = Buffer;
-const crypto = { ...FallbackCrypto,
-  ...QuickCrypto
-}; // for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16
-// @ts-expect-error QuickCrypto is missing `subtle` and `randomUUID`
 
-global.crypto = crypto;
-module.exports = crypto;
-export default crypto;
+// @ts-expect-error subtle isn't full implemented and Cryptokey is missing
+global.crypto = QuickCrypto;
+export default QuickCrypto;
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"names":["Buffer","QuickCrypto","FallbackCrypto","global","crypto","module","exports"],"mappings":"AAAA,SAASA,MAAT,QAAuB,gCAAvB;AACA,SAASC,WAAT,QAA4B,eAA5B;AACA,OAAOC,cAAP,MAA2B,mBAA3B,C,CAEA;;AACAC,MAAM,CAACH,MAAP,GAAgBA,MAAhB;AAEA,MAAMI,MAAM,GAAG,EAAE,GAAGF,cAAL;AAAqB,KAAGD;AAAxB,CAAf,C,CAEA;AACA;;AACAE,MAAM,CAACC,MAAP,GAAgBA,MAAhB;AAEAC,MAAM,CAACC,OAAP,GAAiBF,MAAjB;AACA,eAAeA,MAAf","sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\nimport { QuickCrypto } from './QuickCrypto';\nimport FallbackCrypto from 'crypto-browserify';\n\n// @ts-expect-error Buffer does not match exact same type definition.\nglobal.Buffer = Buffer;\n\nconst crypto = { ...FallbackCrypto, ...QuickCrypto };\n\n// for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16\n// @ts-expect-error QuickCrypto is missing `subtle` and `randomUUID`\nglobal.crypto = crypto;\n\nmodule.exports = crypto;\nexport default crypto;\n"]}
+{"version":3,"names":["Buffer","QuickCrypto","global","crypto"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":"AAAA,SAASA,MAAM,QAAQ,gCAAgC;AACvD,SAASC,WAAW,QAAQ,eAAe;;AAE3C;AACAC,MAAM,CAACF,MAAM,GAAGA,MAAM;;AAEtB;AACAE,MAAM,CAACC,MAAM,GAAGF,WAAW;AAE3B,eAAeA,WAAW","ignoreList":[]}

package/lib/module/keys.js

@@ -1,48 +1,69 @@
-import { binaryLikeToArrayBuffer, isStringOrBuffer } from './Utils'; // On node this value is defined on the native side, for now I'm just creating it here in JS
+import { binaryLikeToArrayBuffer, isStringOrBuffer } from './Utils';
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+export const kNamedCurveAliases = {
+  'P-256': 'prime256v1',
+  'P-384': 'secp384r1',
+  'P-521': 'secp521r1'
+};
+// On node this value is defined on the native side, for now I'm just creating it here in JS
 // TODO(osp) move this into native side to make sure they always match
-
-var KFormatType;
-
-(function (KFormatType) {
+export let KFormatType = /*#__PURE__*/function (KFormatType) {
   KFormatType[KFormatType["kKeyFormatDER"] = 0] = "kKeyFormatDER";
   KFormatType[KFormatType["kKeyFormatPEM"] = 1] = "kKeyFormatPEM";
   KFormatType[KFormatType["kKeyFormatJWK"] = 2] = "kKeyFormatJWK";
-})(KFormatType || (KFormatType = {}));
+  return KFormatType;
+}({});
 
-var KeyInputContext;
+// Same as KFormatType, this enum needs to be defined on the native side
+export let KeyType = /*#__PURE__*/function (KeyType) {
+  KeyType[KeyType["Secret"] = 0] = "Secret";
+  KeyType[KeyType["Public"] = 1] = "Public";
+  KeyType[KeyType["Private"] = 2] = "Private";
+  return KeyType;
+}({});
 
-(function (KeyInputContext) {
+// Same as KFormatType, this enum needs to be defined on the native side
+export let KWebCryptoKeyFormat = /*#__PURE__*/function (KWebCryptoKeyFormat) {
+  KWebCryptoKeyFormat[KWebCryptoKeyFormat["kWebCryptoKeyFormatRaw"] = 0] = "kWebCryptoKeyFormatRaw";
+  KWebCryptoKeyFormat[KWebCryptoKeyFormat["kWebCryptoKeyFormatPKCS8"] = 1] = "kWebCryptoKeyFormatPKCS8";
+  KWebCryptoKeyFormat[KWebCryptoKeyFormat["kWebCryptoKeyFormatSPKI"] = 2] = "kWebCryptoKeyFormatSPKI";
+  KWebCryptoKeyFormat[KWebCryptoKeyFormat["kWebCryptoKeyFormatJWK"] = 3] = "kWebCryptoKeyFormatJWK";
+  return KWebCryptoKeyFormat;
+}({});
+export let WebCryptoKeyExportStatus = /*#__PURE__*/function (WebCryptoKeyExportStatus) {
+  WebCryptoKeyExportStatus[WebCryptoKeyExportStatus["OK"] = 0] = "OK";
+  WebCryptoKeyExportStatus[WebCryptoKeyExportStatus["INVALID_KEY_TYPE"] = 1] = "INVALID_KEY_TYPE";
+  WebCryptoKeyExportStatus[WebCryptoKeyExportStatus["FAILED"] = 2] = "FAILED";
+  return WebCryptoKeyExportStatus;
+}({});
+var KeyInputContext = /*#__PURE__*/function (KeyInputContext) {
   KeyInputContext[KeyInputContext["kConsumePublic"] = 0] = "kConsumePublic";
   KeyInputContext[KeyInputContext["kConsumePrivate"] = 1] = "kConsumePrivate";
   KeyInputContext[KeyInputContext["kCreatePublic"] = 2] = "kCreatePublic";
   KeyInputContext[KeyInputContext["kCreatePrivate"] = 3] = "kCreatePrivate";
-})(KeyInputContext || (KeyInputContext = {}));
-
-var KeyEncoding;
-
-(function (KeyEncoding) {
+  return KeyInputContext;
+}(KeyInputContext || {});
+export let KeyEncoding = /*#__PURE__*/function (KeyEncoding) {
   KeyEncoding[KeyEncoding["kKeyEncodingPKCS1"] = 0] = "kKeyEncodingPKCS1";
   KeyEncoding[KeyEncoding["kKeyEncodingPKCS8"] = 1] = "kKeyEncodingPKCS8";
   KeyEncoding[KeyEncoding["kKeyEncodingSPKI"] = 2] = "kKeyEncodingSPKI";
   KeyEncoding[KeyEncoding["kKeyEncodingSEC1"] = 3] = "kKeyEncodingSEC1";
-})(KeyEncoding || (KeyEncoding = {}));
-
+  return KeyEncoding;
+}({});
 const encodingNames = {
   [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',
   [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',
   [KeyEncoding.kKeyEncodingSPKI]: 'spki',
   [KeyEncoding.kKeyEncodingSEC1]: 'sec1'
 };
-
 function option(name, objName) {
   return objName === undefined ? `options.${name}` : `options.${objName}.${name}`;
 }
-
 function parseKeyFormat(formatStr, defaultFormat, optionName) {
   if (formatStr === undefined && defaultFormat !== undefined) return defaultFormat;else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;else if (formatStr === 'der') return KFormatType.kKeyFormatDER;else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;
-  throw new Error(`Invalid key format str: ${optionName}`); // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);
+  throw new Error(`Invalid key format str: ${optionName}`);
+  // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);
 }
-
 function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
   if (typeStr === undefined && !required) {
     return undefined;
@@ -50,7 +71,6 @@ function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
     if (keyType !== undefined && keyType !== 'rsa') {
       throw new Error(`Crypto incompatible key options: ${typeStr} can only be used for RSA keys`);
     }
-
     return KeyEncoding.kKeyEncodingPKCS1;
   } else if (typeStr === 'spki' && isPublic !== false) {
     return KeyEncoding.kKeyEncodingSPKI;
@@ -60,13 +80,10 @@ function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
     if (keyType !== undefined && keyType !== 'ec') {
       throw new Error(`Incompatible key options ${typeStr} can only be used for EC keys`);
     }
-
     return KeyEncoding.kKeyEncodingSEC1;
   }
-
   throw new Error(`Invalid option ${optionName} - ${typeStr}`);
 }
-
 function parseKeyFormatAndType(enc, keyType, isPublic, objName) {
   const {
     format: formatStr,
@@ -81,27 +98,24 @@ function parseKeyFormatAndType(enc, keyType, isPublic, objName) {
     type
   };
 }
-
 function parseKeyEncoding(enc, keyType, isPublic, objName) {
   // validateObject(enc, 'options');
+
   const isInput = keyType === undefined;
   const {
     format,
     type
   } = parseKeyFormatAndType(enc, keyType, isPublic, objName);
   let cipher, passphrase, encoding;
-
   if (isPublic !== true) {
     ({
       cipher,
       passphrase,
       encoding
     } = enc);
-
     if (!isInput) {
       if (cipher != null) {
         if (typeof cipher !== 'string') throw new Error(`Invalid argument ${option('cipher', objName)}: ${cipher}`);
-
         if (format === KFormatType.kKeyFormatDER && (type === KeyEncoding.kKeyEncodingPKCS1 || type === KeyEncoding.kKeyEncodingSEC1)) {
           throw new Error(`Incompatible key options ${encodingNames[type]} does not support encryption`);
         }
@@ -109,12 +123,10 @@ function parseKeyEncoding(enc, keyType, isPublic, objName) {
         throw new Error(`invalid argument ${option('cipher', objName)}: ${cipher}`);
       }
     }
-
     if (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase) || !isInput && cipher != null && !isStringOrBuffer(passphrase)) {
       throw new Error(`Invalid argument value ${option('passphrase', objName)}: ${passphrase}`);
     }
   }
-
   if (passphrase !== undefined) passphrase = binaryLikeToArrayBuffer(passphrase, encoding);
   return {
     format,
@@ -123,7 +135,6 @@ function parseKeyEncoding(enc, keyType, isPublic, objName) {
     passphrase
   };
 }
-
 function prepareAsymmetricKey(key, ctx) {
   // TODO(osp) check, KeyObject some node object
   // if (isKeyObject(key)) {
@@ -142,9 +153,10 @@ function prepareAsymmetricKey(key, ctx) {
   } else if (typeof key === 'object') {
     const {
       key: data,
-      encoding // format
-
-    } = key; // // The 'key' property can be a KeyObject as well to allow specifying
+      encoding
+      // format
+    } = key;
+    // // The 'key' property can be a KeyObject as well to allow specifying
     // // additional options such as padding along with the key.
     // if (isKeyObject(data)) return { data: getKeyObjectHandle(data, ctx) };
     // else if (isCryptoKey(data))
@@ -152,39 +164,263 @@ function prepareAsymmetricKey(key, ctx) {
     // else if (isJwk(data) && format === 'jwk')
     //   return { data: getKeyObjectHandleFromJwk(data, ctx), format: 'jwk' };
     // Either PEM or DER using PKCS#1 or SPKI.
-
     if (!isStringOrBuffer(data)) {
       throw new Error('prepareAsymmetricKey: key is not a string or ArrayBuffer');
     }
-
     const isPublic = ctx === KeyInputContext.kConsumePrivate || ctx === KeyInputContext.kCreatePrivate ? false : undefined;
     return {
       data: binaryLikeToArrayBuffer(data, encoding),
       ...parseKeyEncoding(key, undefined, isPublic)
     };
   }
-
   throw new Error('[prepareAsymetricKey] Invalid argument key: ${key}');
-} // TODO(osp) any here is a node KeyObject
-
+}
 
+// TODO(osp) any here is a node KeyObject
 export function preparePrivateKey(key) {
   return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);
-} // TODO(osp) any here is a node KeyObject
+}
 
+// TODO(osp) any here is a node KeyObject
 export function preparePublicOrPrivateKey(key) {
   return prepareAsymmetricKey(key, KeyInputContext.kConsumePublic);
-} // Parses the public key encoding based on an object. keyType must be undefined
+}
+
+// Parses the public key encoding based on an object. keyType must be undefined
 // when this is used to parse an input encoding and must be a valid key type if
 // used to parse an output encoding.
-
 export function parsePublicKeyEncoding(enc, keyType, objName) {
   return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);
-} // Parses the private key encoding based on an object. keyType must be undefined
+}
+
+// Parses the private key encoding based on an object. keyType must be undefined
 // when this is used to parse an input encoding and must be a valid key type if
 // used to parse an output encoding.
-
 export function parsePrivateKeyEncoding(enc, keyType, objName) {
   return parseKeyEncoding(enc, keyType, false, objName);
 }
+function prepareSecretKey(key,
+//KeyObject | CryptoKey | string,
+encoding, bufferOnly = false) {
+  if (!bufferOnly) {
+    // TODO: maybe use `key.constructor.name === 'KeyObject'` ?
+    if (key instanceof KeyObject) {
+      if (key.type !== 'secret') throw new Error(`invalid KeyObject type: ${key.type}, expected 'secret'`);
+      return key.handle;
+    }
+    // TODO: maybe use `key.constructor.name === 'CryptoKey'` ?
+    else if (key instanceof CryptoKey) {
+      if (key.type !== 'secret') throw new Error(`invalid CryptoKey type: ${key.type}, expected 'secret'`);
+      return key.keyObject.handle;
+    }
+  }
+  if (key instanceof ArrayBuffer) {
+    return key;
+  }
+  if (typeof key === 'string') {
+    return binaryLikeToArrayBuffer(key, encoding);
+  }
+  throw new Error('invalid argument type "key"');
+}
+export function createSecretKey(key, encoding) {
+  const k = prepareSecretKey(key, encoding, true);
+  const handle = NativeQuickCrypto.webcrypto.createKeyObjectHandle();
+  handle.init(KeyType.Secret, k);
+  return new SecretKeyObject(handle);
+}
+export class CryptoKey {
+  constructor(keyObject, keyAlgorithm, keyUsages, keyExtractable) {
+    this.keyObject = keyObject;
+    this.keyAlgorithm = keyAlgorithm;
+    this.keyUsages = keyUsages;
+    this.keyExtractable = keyExtractable;
+  }
+  inspect(_depth, _options) {
+    throw new Error('CryptoKey.inspect is not implemented');
+    // if (depth < 0) return this;
+
+    // const opts = {
+    //   ...options,
+    //   depth: options.depth == null ? null : options.depth - 1,
+    // };
+
+    // return `CryptoKey ${inspect(
+    //   {
+    //     type: this.type,
+    //     extractable: this.extractable,
+    //     algorithm: this.algorithm,
+    //     usages: this.usages,
+    //   },
+    //   opts
+    // )}`;
+  }
+  get type() {
+    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');
+    return this.keyObject.type;
+  }
+  get extractable() {
+    return this.keyExtractable;
+  }
+  get algorithm() {
+    return this.keyAlgorithm;
+  }
+  get usages() {
+    return this.keyUsages;
+  }
+}
+
+// ObjectDefineProperties(CryptoKey.prototype, {
+//   type: kEnumerableProperty,
+//   extractable: kEnumerableProperty,
+//   algorithm: kEnumerableProperty,
+//   usages: kEnumerableProperty,
+//   [SymbolToStringTag]: {
+//     __proto__: null,
+//     configurable: true,
+//     value: 'CryptoKey',
+//   },
+// });
+
+class KeyObject {
+  type = 'unknown';
+  export(_options) {
+    return new ArrayBuffer(0);
+  }
+  constructor(type, handle) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private') throw new Error(`invalid KeyObject type: ${type}`);
+    this.handle = handle;
+    this.type = type;
+  }
+
+  // get type(): string {
+  //   return this.type;
+  // }
+
+  // static from(key) {
+  //   if (!isCryptoKey(key))
+  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
+  //   return key[kKeyObject];
+  // }
+
+  // equals(otherKeyObject) {
+  //   if (!isKeyObject(otherKeyObject)) {
+  //     throw new ERR_INVALID_ARG_TYPE(
+  //       'otherKeyObject',
+  //       'KeyObject',
+  //       otherKeyObject
+  //     );
+  //   }
+
+  //   return (
+  //     otherKeyObject.type === this.type &&
+  //     this[kHandle].equals(otherKeyObject[kHandle])
+  //   );
+  // }
+}
+
+// ObjectDefineProperties(KeyObject.prototype, {
+//   [SymbolToStringTag]: {
+//     __proto__: null,
+//     configurable: true,
+//     value: 'KeyObject',
+//   },
+// });
+
+export class SecretKeyObject extends KeyObject {
+  constructor(handle) {
+    super('secret', handle);
+  }
+
+  // get symmetricKeySize() {
+  //   return this[kHandle].getSymmetricKeySize();
+  // }
+
+  export(options) {
+    if (options !== undefined) {
+      if (options.format === 'jwk') {
+        throw new Error('SecretKey export for jwk is not implemented');
+        // return this.handle.exportJwk({}, false);
+      }
+    }
+    return this.handle.export();
+  }
+}
+
+// const kAsymmetricKeyType = Symbol('kAsymmetricKeyType');
+// const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails');
+
+// function normalizeKeyDetails(details = {}) {
+//   if (details.publicExponent !== undefined) {
+//     return {
+//       ...details,
+//       publicExponent: bigIntArrayToUnsignedBigInt(
+//         new Uint8Array(details.publicExponent)
+//       ),
+//     };
+//   }
+//   return details;
+// }
+
+class AsymmetricKeyObject extends KeyObject {
+  constructor(type, handle) {
+    super(type, handle);
+  }
+  get asymmetricKeyType() {
+    return this.asymmetricKeyType || this.handle.getAsymmetricKeyType();
+  }
+
+  // get asymmetricKeyDetails() {
+  //   switch (this.asymmetricKeyType) {
+  //     case 'rsa':
+  //     case 'rsa-pss':
+  //     case 'dsa':
+  //     case 'ec':
+  //       return (
+  //         this[kAsymmetricKeyDetails] ||
+  //         (this[kAsymmetricKeyDetails] = normalizeKeyDetails(
+  //           this[kHandle].keyDetail({})
+  //         ))
+  //       );
+  //     default:
+  //       return {};
+  //   }
+  // }
+}
+export class PublicKeyObject extends AsymmetricKeyObject {
+  constructor(handle) {
+    super('public', handle);
+  }
+  export(options) {
+    if (options?.format === 'jwk') {
+      throw new Error('PublicKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const {
+      format,
+      type
+    } = parsePublicKeyEncoding(options, this.asymmetricKeyType);
+    return this.handle.export(format, type);
+  }
+}
+export class PrivateKeyObject extends AsymmetricKeyObject {
+  constructor(handle) {
+    super('private', handle);
+  }
+  export(options) {
+    if (options?.format === 'jwk') {
+      if (options.passphrase !== undefined) {
+        throw new Error('jwk does not support encryption');
+      }
+      throw new Error('PrivateKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const {
+      format,
+      type,
+      cipher,
+      passphrase
+    } = parsePrivateKeyEncoding(options, this.asymmetricKeyType);
+    return this.handle.export(format, type, cipher, passphrase);
+  }
+}
 //# sourceMappingURL=keys.js.map

package/lib/module/keys.js.map

@@ -1 +1 @@
-{"version":3,"sources":["keys.ts"],"names":["binaryLikeToArrayBuffer","isStringOrBuffer","KFormatType","KeyInputContext","KeyEncoding","encodingNames","kKeyEncodingPKCS1","kKeyEncodingPKCS8","kKeyEncodingSPKI","kKeyEncodingSEC1","option","name","objName","undefined","parseKeyFormat","formatStr","defaultFormat","optionName","kKeyFormatPEM","kKeyFormatDER","kKeyFormatJWK","Error","parseKeyType","typeStr","required","keyType","isPublic","parseKeyFormatAndType","enc","format","type","isInput","isRequired","parseKeyEncoding","cipher","passphrase","encoding","prepareAsymmetricKey","key","ctx","data","kConsumePrivate","kCreatePrivate","preparePrivateKey","preparePublicOrPrivateKey","kConsumePublic","parsePublicKeyEncoding","parsePrivateKeyEncoding"],"mappings":"AAAA,SAAqBA,uBAArB,EAA8CC,gBAA9C,QAAsE,SAAtE,C,CAEA;AACA;;IACKC,W;;WAAAA,W;AAAAA,EAAAA,W,CAAAA,W;AAAAA,EAAAA,W,CAAAA,W;AAAAA,EAAAA,W,CAAAA,W;GAAAA,W,KAAAA,W;;IAMAC,e;;WAAAA,e;AAAAA,EAAAA,e,CAAAA,e;AAAAA,EAAAA,e,CAAAA,e;AAAAA,EAAAA,e,CAAAA,e;AAAAA,EAAAA,e,CAAAA,e;GAAAA,e,KAAAA,e;;IAOAC,W;;WAAAA,W;AAAAA,EAAAA,W,CAAAA,W;AAAAA,EAAAA,W,CAAAA,W;AAAAA,EAAAA,W,CAAAA,W;AAAAA,EAAAA,W,CAAAA,W;GAAAA,W,KAAAA,W;;AAOL,MAAMC,aAAa,GAAG;AACpB,GAACD,WAAW,CAACE,iBAAb,GAAiC,OADb;AAEpB,GAACF,WAAW,CAACG,iBAAb,GAAiC,OAFb;AAGpB,GAACH,WAAW,CAACI,gBAAb,GAAgC,MAHZ;AAIpB,GAACJ,WAAW,CAACK,gBAAb,GAAgC;AAJZ,CAAtB;;AAOA,SAASC,MAAT,CAAgBC,IAAhB,EAA8BC,OAA9B,EAA2D;AACzD,SAAOA,OAAO,KAAKC,SAAZ,GACF,WAAUF,IAAK,EADb,GAEF,WAAUC,OAAQ,IAAGD,IAAK,EAF/B;AAGD;;AAED,SAASG,cAAT,CACEC,SADF,EAEEC,aAFF,EAGEC,UAHF,EAIE;AACA,MAAIF,SAAS,KAAKF,SAAd,IAA2BG,aAAa,KAAKH,SAAjD,EACE,OAAOG,aAAP,CADF,KAEK,IAAID,SAAS,KAAK,KAAlB,EAAyB,OAAOb,WAAW,CAACgB,aAAnB,CAAzB,KACA,IAAIH,SAAS,KAAK,KAAlB,EAAyB,OAAOb,WAAW,CAACiB,aAAnB,CAAzB,KACA,IAAIJ,SAAS,KAAK,KAAlB,EAAyB,OAAOb,WAAW,CAACkB,aAAnB;AAC9B,QAAM,IAAIC,KAAJ,CAAW,2BAA0BJ,UAAW,EAAhD,CAAN,CANA,CAOA;AACD;;AAED,SAASK,YAAT,CACEC,OADF,EAEEC,QAFF,EAGEC,OAHF,EAIEC,QAJF,EAKET,UALF,EAME;AACA,MAAIM,OAAO,KAAKV,SAAZ,IAAyB,CAACW,QAA9B,EAAwC;AACtC,WAAOX,SAAP;AACD,GAFD,MAEO,IAAIU,OAAO,KAAK,OAAhB,EAAyB;AAC9B,QAAIE,OAAO,KAAKZ,SAAZ,IAAyBY,OAAO,KAAK,KAAzC,EAAgD;AAC9C,YAAM,IAAIJ,KAAJ,CACH,oCAAmCE,OAAQ,gCADxC,CAAN;AAGD;;AACD,WAAOnB,WAAW,CAACE,iBAAnB;AACD,GAPM,MAOA,IAAIiB,OAAO,KAAK,MAAZ,IAAsBG,QAAQ,KAAK,KAAvC,EAA8C;AACnD,WAAOtB,WAAW,CAACI,gBAAnB;AACD,GAFM,MAEA,IAAIe,OAAO,KAAK,OAAZ,IAAuBG,QAAQ,KAAK,IAAxC,EAA8C;AACnD,WAAOtB,WAAW,CAACG,iBAAnB;AACD,GAFM,MAEA,IAAIgB,OAAO,KAAK,MAAZ,IAAsBG,QAAQ,KAAK,IAAvC,EAA6C;AAClD,QAAID,OAAO,KAAKZ,SAAZ,IAAyBY,OAAO,KAAK,IAAzC,EAA+C;AAC7C,YAAM,IAAIJ,KAAJ,CACH,4BAA2BE,OAAQ,+BADhC,CAAN;AAGD;;AACD,WAAOnB,WAAW,CAACK,gBAAnB;AACD;;AAED,QAAM,IAAIY,KAAJ,CAAW,kBAAiBJ,UAAW,MAAKM,OAAQ,EAApD,CAAN;AACD;;AAED,SAASI,qBAAT,CACEC,GADF,EASEH,OATF,EAUEC,QAVF,EAWEd,OAXF,EAYE;AACA,QAAM;AAAEiB,IAAAA,MAAM,EAAEd,SAAV;AAAqBe,IAAAA,IAAI,EAAEP;AAA3B,MAAuCK,GAA7C;AAEA,QAAMG,OAAO,GAAGN,OAAO,KAAKZ,SAA5B;AACA,QAAMgB,MAAM,GAAGf,cAAc,CAC3BC,SAD2B,EAE3BgB,OAAO,GAAG7B,WAAW,CAACgB,aAAf,GAA+BL,SAFX,EAG3BH,MAAM,CAAC,QAAD,EAAWE,OAAX,CAHqB,CAA7B;AAMA,QAAMoB,UAAU,GACd,CAAC,CAACD,OAAD,IAAYF,MAAM,KAAK3B,WAAW,CAACiB,aAApC,KACAU,MAAM,KAAK3B,WAAW,CAACkB,aAFzB;AAIA,QAAMU,IAAI,GAAGR,YAAY,CACvBC,OADuB,EAEvBS,UAFuB,EAGvBP,OAHuB,EAIvBC,QAJuB,EAKvBhB,MAAM,CAAC,MAAD,EAASE,OAAT,CALiB,CAAzB;AAOA,SAAO;AAAEiB,IAAAA,MAAF;AAAUC,IAAAA;AAAV,GAAP;AACD;;AAED,SAASG,gBAAT,CACEL,GADF,EASEH,OATF,EAUEC,QAVF,EAWEd,OAXF,EAYE;AACA;AAEA,QAAMmB,OAAO,GAAGN,OAAO,KAAKZ,SAA5B;AAEA,QAAM;AAAEgB,IAAAA,MAAF;AAAUC,IAAAA;AAAV,MAAmBH,qBAAqB,CAC5CC,GAD4C,EAE5CH,OAF4C,EAG5CC,QAH4C,EAI5Cd,OAJ4C,CAA9C;AAOA,MAAIsB,MAAJ,EAAYC,UAAZ,EAAwBC,QAAxB;;AACA,MAAIV,QAAQ,KAAK,IAAjB,EAAuB;AACrB,KAAC;AAAEQ,MAAAA,MAAF;AAAUC,MAAAA,UAAV;AAAsBC,MAAAA;AAAtB,QAAmCR,GAApC;;AAEA,QAAI,CAACG,OAAL,EAAc;AACZ,UAAIG,MAAM,IAAI,IAAd,EAAoB;AAClB,YAAI,OAAOA,MAAP,KAAkB,QAAtB,EACE,MAAM,IAAIb,KAAJ,CACH,oBAAmBX,MAAM,CAAC,QAAD,EAAWE,OAAX,CAAoB,KAAIsB,MAAO,EADrD,CAAN;;AAGF,YACEL,MAAM,KAAK3B,WAAW,CAACiB,aAAvB,KACCW,IAAI,KAAK1B,WAAW,CAACE,iBAArB,IACCwB,IAAI,KAAK1B,WAAW,CAACK,gBAFvB,CADF,EAIE;AACA,gBAAM,IAAIY,KAAJ,CACH,4BAA2BhB,aAAa,CAACyB,IAAD,CAAO,8BAD5C,CAAN;AAGD;AACF,OAdD,MAcO,IAAIK,UAAU,KAAKtB,SAAnB,EAA8B;AACnC,cAAM,IAAIQ,KAAJ,CACH,oBAAmBX,MAAM,CAAC,QAAD,EAAWE,OAAX,CAAoB,KAAIsB,MAAO,EADrD,CAAN;AAGD;AACF;;AAED,QACGH,OAAO,IAAII,UAAU,KAAKtB,SAA1B,IAAuC,CAACZ,gBAAgB,CAACkC,UAAD,CAAzD,IACC,CAACJ,OAAD,IAAYG,MAAM,IAAI,IAAtB,IAA8B,CAACjC,gBAAgB,CAACkC,UAAD,CAFlD,EAGE;AACA,YAAM,IAAId,KAAJ,CACH,0BAAyBX,MAAM,CAAC,YAAD,EAAeE,OAAf,CAAwB,KAAIuB,UAAW,EADnE,CAAN;AAGD;AACF;;AAED,MAAIA,UAAU,KAAKtB,SAAnB,EACEsB,UAAU,GAAGnC,uBAAuB,CAACmC,UAAD,EAAaC,QAAb,CAApC;AAEF,SAAO;AAAEP,IAAAA,MAAF;AAAUC,IAAAA,IAAV;AAAgBI,IAAAA,MAAhB;AAAwBC,IAAAA;AAAxB,GAAP;AACD;;AAED,SAASE,oBAAT,CACEC,GADF,EAIEC,GAJF,EAUE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAItC,gBAAgB,CAACqC,GAAD,CAApB,EAA2B;AACzB;AACA,WAAO;AACLT,MAAAA,MAAM,EAAE3B,WAAW,CAACgB,aADf;AAELsB,MAAAA,IAAI,EAAExC,uBAAuB,CAACsC,GAAD;AAFxB,KAAP;AAID,GAND,MAMO,IAAI,OAAOA,GAAP,KAAe,QAAnB,EAA6B;AAClC,UAAM;AACJA,MAAAA,GAAG,EAAEE,IADD;AAEJJ,MAAAA,QAFI,CAGJ;;AAHI,QAIFE,GAJJ,CADkC,CAMlC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAI,CAACrC,gBAAgB,CAACuC,IAAD,CAArB,EAA6B;AAC3B,YAAM,IAAInB,KAAJ,CACJ,0DADI,CAAN;AAGD;;AAED,UAAMK,QAAQ,GACZa,GAAG,KAAKpC,eAAe,CAACsC,eAAxB,IACAF,GAAG,KAAKpC,eAAe,CAACuC,cADxB,GAEI,KAFJ,GAGI7B,SAJN;AAMA,WAAO;AACL2B,MAAAA,IAAI,EAAExC,uBAAuB,CAACwC,IAAD,EAAOJ,QAAP,CADxB;AAEL,SAAGH,gBAAgB,CAACK,GAAD,EAAMzB,SAAN,EAAiBa,QAAjB;AAFd,KAAP;AAID;;AAED,QAAM,IAAIL,KAAJ,CAAU,oDAAV,CAAN;AACD,C,CAED;;;AACA,OAAO,SAASsB,iBAAT,CACLL,GADK,EAUL;AACA,SAAOD,oBAAoB,CAACC,GAAD,EAAMnC,eAAe,CAACsC,eAAtB,CAA3B;AACD,C,CAED;;AACA,OAAO,SAASG,yBAAT,CACLN,GADK,EAIL;AACA,SAAOD,oBAAoB,CAACC,GAAD,EAAMnC,eAAe,CAAC0C,cAAtB,CAA3B;AACD,C,CAED;AACA;AACA;;AACA,OAAO,SAASC,sBAAT,CACLlB,GADK,EAQLH,OARK,EASLb,OATK,EAUL;AACA,SAAOqB,gBAAgB,CAACL,GAAD,EAAMH,OAAN,EAAeA,OAAO,GAAG,IAAH,GAAUZ,SAAhC,EAA2CD,OAA3C,CAAvB;AACD,C,CAED;AACA;AACA;;AACA,OAAO,SAASmC,uBAAT,CACLnB,GADK,EAQLH,OARK,EASLb,OATK,EAUL;AACA,SAAOqB,gBAAgB,CAACL,GAAD,EAAMH,OAAN,EAAe,KAAf,EAAsBb,OAAtB,CAAvB;AACD","sourcesContent":["import { BinaryLike, binaryLikeToArrayBuffer, isStringOrBuffer } from './Utils';\n\n// On node this value is defined on the native side, for now I'm just creating it here in JS\n// TODO(osp) move this into native side to make sure they always match\nenum KFormatType {\n  kKeyFormatDER,\n  kKeyFormatPEM,\n  kKeyFormatJWK,\n}\n\nenum KeyInputContext {\n  kConsumePublic,\n  kConsumePrivate,\n  kCreatePublic,\n  kCreatePrivate,\n}\n\nenum KeyEncoding {\n  kKeyEncodingPKCS1,\n  kKeyEncodingPKCS8,\n  kKeyEncodingSPKI,\n  kKeyEncodingSEC1,\n}\n\nconst encodingNames = {\n  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',\n  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',\n  [KeyEncoding.kKeyEncodingSPKI]: 'spki',\n  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',\n};\n\nfunction option(name: string, objName: string | undefined) {\n  return objName === undefined\n    ? `options.${name}`\n    : `options.${objName}.${name}`;\n}\n\nfunction parseKeyFormat(\n  formatStr: string | undefined,\n  defaultFormat: KFormatType | undefined,\n  optionName?: string\n) {\n  if (formatStr === undefined && defaultFormat !== undefined)\n    return defaultFormat;\n  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;\n  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;\n  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;\n  throw new Error(`Invalid key format str: ${optionName}`);\n  // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);\n}\n\nfunction parseKeyType(\n  typeStr: string | undefined,\n  required: boolean,\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  optionName: string\n) {\n  if (typeStr === undefined && !required) {\n    return undefined;\n  } else if (typeStr === 'pkcs1') {\n    if (keyType !== undefined && keyType !== 'rsa') {\n      throw new Error(\n        `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`\n      );\n    }\n    return KeyEncoding.kKeyEncodingPKCS1;\n  } else if (typeStr === 'spki' && isPublic !== false) {\n    return KeyEncoding.kKeyEncodingSPKI;\n  } else if (typeStr === 'pkcs8' && isPublic !== true) {\n    return KeyEncoding.kKeyEncodingPKCS8;\n  } else if (typeStr === 'sec1' && isPublic !== true) {\n    if (keyType !== undefined && keyType !== 'ec') {\n      throw new Error(\n        `Incompatible key options ${typeStr} can only be used for EC keys`\n      );\n    }\n    return KeyEncoding.kKeyEncodingSEC1;\n  }\n\n  throw new Error(`Invalid option ${optionName} - ${typeStr}`);\n}\n\nfunction parseKeyFormatAndType(\n  enc: {\n    key: any;\n    type?: string;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  objName: string | undefined\n) {\n  const { format: formatStr, type: typeStr } = enc;\n\n  const isInput = keyType === undefined;\n  const format = parseKeyFormat(\n    formatStr,\n    isInput ? KFormatType.kKeyFormatPEM : undefined,\n    option('format', objName)\n  );\n\n  const isRequired =\n    (!isInput || format === KFormatType.kKeyFormatDER) &&\n    format !== KFormatType.kKeyFormatJWK;\n\n  const type = parseKeyType(\n    typeStr,\n    isRequired,\n    keyType,\n    isPublic,\n    option('type', objName)\n  );\n  return { format, type };\n}\n\nfunction parseKeyEncoding(\n  enc: {\n    key: any;\n    type?: string;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  objName?: string | undefined\n) {\n  // validateObject(enc, 'options');\n\n  const isInput = keyType === undefined;\n\n  const { format, type } = parseKeyFormatAndType(\n    enc,\n    keyType,\n    isPublic,\n    objName\n  );\n\n  let cipher, passphrase, encoding;\n  if (isPublic !== true) {\n    ({ cipher, passphrase, encoding } = enc);\n\n    if (!isInput) {\n      if (cipher != null) {\n        if (typeof cipher !== 'string')\n          throw new Error(\n            `Invalid argument ${option('cipher', objName)}: ${cipher}`\n          );\n        if (\n          format === KFormatType.kKeyFormatDER &&\n          (type === KeyEncoding.kKeyEncodingPKCS1 ||\n            type === KeyEncoding.kKeyEncodingSEC1)\n        ) {\n          throw new Error(\n            `Incompatible key options ${encodingNames[type]} does not support encryption`\n          );\n        }\n      } else if (passphrase !== undefined) {\n        throw new Error(\n          `invalid argument ${option('cipher', objName)}: ${cipher}`\n        );\n      }\n    }\n\n    if (\n      (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) ||\n      (!isInput && cipher != null && !isStringOrBuffer(passphrase))\n    ) {\n      throw new Error(\n        `Invalid argument value ${option('passphrase', objName)}: ${passphrase}`\n      );\n    }\n  }\n\n  if (passphrase !== undefined)\n    passphrase = binaryLikeToArrayBuffer(passphrase, encoding);\n\n  return { format, type, cipher, passphrase };\n}\n\nfunction prepareAsymmetricKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; passphrase?: string },\n  ctx: KeyInputContext\n): {\n  format: KFormatType;\n  data: ArrayBuffer;\n  type?: any;\n  passphrase?: any;\n} {\n  // TODO(osp) check, KeyObject some node object\n  // if (isKeyObject(key)) {\n  //   // Best case: A key object, as simple as that.\n  //   return { data: getKeyObjectHandle(key, ctx) };\n  // } else\n  // if (isCryptoKey(key)) {\n  //   return { data: getKeyObjectHandle(key[kKeyObject], ctx) };\n  // } else\n  if (isStringOrBuffer(key)) {\n    // Expect PEM by default, mostly for backward compatibility.\n    return {\n      format: KFormatType.kKeyFormatPEM,\n      data: binaryLikeToArrayBuffer(key),\n    };\n  } else if (typeof key === 'object') {\n    const {\n      key: data,\n      encoding,\n      // format\n    } = key;\n    // // The 'key' property can be a KeyObject as well to allow specifying\n    // // additional options such as padding along with the key.\n    // if (isKeyObject(data)) return { data: getKeyObjectHandle(data, ctx) };\n    // else if (isCryptoKey(data))\n    //   return { data: getKeyObjectHandle(data[kKeyObject], ctx) };\n    // else if (isJwk(data) && format === 'jwk')\n    //   return { data: getKeyObjectHandleFromJwk(data, ctx), format: 'jwk' };\n    // Either PEM or DER using PKCS#1 or SPKI.\n    if (!isStringOrBuffer(data)) {\n      throw new Error(\n        'prepareAsymmetricKey: key is not a string or ArrayBuffer'\n      );\n    }\n\n    const isPublic =\n      ctx === KeyInputContext.kConsumePrivate ||\n      ctx === KeyInputContext.kCreatePrivate\n        ? false\n        : undefined;\n\n    return {\n      data: binaryLikeToArrayBuffer(data, encoding),\n      ...parseKeyEncoding(key, undefined, isPublic),\n    };\n  }\n\n  throw new Error('[prepareAsymetricKey] Invalid argument key: ${key}');\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePrivateKey(\n  key:\n    | BinaryLike\n    | {\n        key: any;\n        encoding?: string;\n        format?: any;\n        padding?: number;\n        passphrase?: string;\n      }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePublicOrPrivateKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; padding?: number }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePublic);\n}\n\n// Parses the public key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePublicKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);\n}\n\n// Parses the private key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePrivateKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, false, objName);\n}\n"]}
+{"version":3,"names":["binaryLikeToArrayBuffer","isStringOrBuffer","NativeQuickCrypto","kNamedCurveAliases","KFormatType","KeyType","KWebCryptoKeyFormat","WebCryptoKeyExportStatus","KeyInputContext","KeyEncoding","encodingNames","kKeyEncodingPKCS1","kKeyEncodingPKCS8","kKeyEncodingSPKI","kKeyEncodingSEC1","option","name","objName","undefined","parseKeyFormat","formatStr","defaultFormat","optionName","kKeyFormatPEM","kKeyFormatDER","kKeyFormatJWK","Error","parseKeyType","typeStr","required","keyType","isPublic","parseKeyFormatAndType","enc","format","type","isInput","isRequired","parseKeyEncoding","cipher","passphrase","encoding","prepareAsymmetricKey","key","ctx","data","kConsumePrivate","kCreatePrivate","preparePrivateKey","preparePublicOrPrivateKey","kConsumePublic","parsePublicKeyEncoding","parsePrivateKeyEncoding","prepareSecretKey","bufferOnly","KeyObject","handle","CryptoKey","keyObject","ArrayBuffer","createSecretKey","k","webcrypto","createKeyObjectHandle","init","Secret","SecretKeyObject","constructor","keyAlgorithm","keyUsages","keyExtractable","inspect","_depth","_options","extractable","algorithm","usages","export","options","AsymmetricKeyObject","asymmetricKeyType","getAsymmetricKeyType","PublicKeyObject","PrivateKeyObject"],"sourceRoot":"../../src","sources":["keys.ts"],"mappings":"AAAA,SAEEA,uBAAuB,EACvBC,gBAAgB,QACX,SAAS;AAEhB,SAASC,iBAAiB,QAAQ,uCAAuC;AAEzE,OAAO,MAAMC,kBAAkB,GAAG;EAChC,OAAO,EAAE,YAAY;EACrB,OAAO,EAAE,WAAW;EACpB,OAAO,EAAE;AACX,CAAU;AA8EV;AACA;AACA,WAAYC,WAAW,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA;;AAMvB;AACA,WAAYC,OAAO,0BAAPA,OAAO;EAAPA,OAAO,CAAPA,OAAO;EAAPA,OAAO,CAAPA,OAAO;EAAPA,OAAO,CAAPA,OAAO;EAAA,OAAPA,OAAO;AAAA;;AAMnB;AACA,WAAYC,mBAAmB,0BAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAA,OAAnBA,mBAAmB;AAAA;AAO/B,WAAYC,wBAAwB,0BAAxBA,wBAAwB;EAAxBA,wBAAwB,CAAxBA,wBAAwB;EAAxBA,wBAAwB,CAAxBA,wBAAwB;EAAxBA,wBAAwB,CAAxBA,wBAAwB;EAAA,OAAxBA,wBAAwB;AAAA;AAInC,IAEIC,eAAe,0BAAfA,eAAe;EAAfA,eAAe,CAAfA,eAAe;EAAfA,eAAe,CAAfA,eAAe;EAAfA,eAAe,CAAfA,eAAe;EAAfA,eAAe,CAAfA,eAAe;EAAA,OAAfA,eAAe;AAAA,EAAfA,eAAe;AAOpB,WAAYC,WAAW,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA;AA4CvB,MAAMC,aAAa,GAAG;EACpB,CAACD,WAAW,CAACE,iBAAiB,GAAG,OAAO;EACxC,CAACF,WAAW,CAACG,iBAAiB,GAAG,OAAO;EACxC,CAACH,WAAW,CAACI,gBAAgB,GAAG,MAAM;EACtC,CAACJ,WAAW,CAACK,gBAAgB,GAAG;AAClC,CAAC;AAED,SAASC,MAAMA,CAACC,IAAY,EAAEC,OAA2B,EAAE;EACzD,OAAOA,OAAO,KAAKC,SAAS,GACvB,WAAUF,IAAK,EAAC,GAChB,WAAUC,OAAQ,IAAGD,IAAK,EAAC;AAClC;AAEA,SAASG,cAAcA,CACrBC,SAA6B,EAC7BC,aAAsC,EACtCC,UAAmB,EACnB;EACA,IAAIF,SAAS,KAAKF,SAAS,IAAIG,aAAa,KAAKH,SAAS,EACxD,OAAOG,aAAa,CAAC,KAClB,IAAID,SAAS,KAAK,KAAK,EAAE,OAAOhB,WAAW,CAACmB,aAAa,CAAC,KAC1D,IAAIH,SAAS,KAAK,KAAK,EAAE,OAAOhB,WAAW,CAACoB,aAAa,CAAC,KAC1D,IAAIJ,SAAS,KAAK,KAAK,EAAE,OAAOhB,WAAW,CAACqB,aAAa;EAC9D,MAAM,IAAIC,KAAK,CAAE,2BAA0BJ,UAAW,EAAC,CAAC;EACxD;AACF;AAEA,SAASK,YAAYA,CACnBC,OAA2B,EAC3BC,QAAiB,EACjBC,OAA2B,EAC3BC,QAA6B,EAC7BT,UAAkB,EACO;EACzB,IAAIM,OAAO,KAAKV,SAAS,IAAI,CAACW,QAAQ,EAAE;IACtC,OAAOX,SAAS;EAClB,CAAC,MAAM,IAAIU,OAAO,KAAK,OAAO,EAAE;IAC9B,IAAIE,OAAO,KAAKZ,SAAS,IAAIY,OAAO,KAAK,KAAK,EAAE;MAC9C,MAAM,IAAIJ,KAAK,CACZ,oCAAmCE,OAAQ,gCAC9C,CAAC;IACH;IACA,OAAOnB,WAAW,CAACE,iBAAiB;EACtC,CAAC,MAAM,IAAIiB,OAAO,KAAK,MAAM,IAAIG,QAAQ,KAAK,KAAK,EAAE;IACnD,OAAOtB,WAAW,CAACI,gBAAgB;EACrC,CAAC,MAAM,IAAIe,OAAO,KAAK,OAAO,IAAIG,QAAQ,KAAK,IAAI,EAAE;IACnD,OAAOtB,WAAW,CAACG,iBAAiB;EACtC,CAAC,MAAM,IAAIgB,OAAO,KAAK,MAAM,IAAIG,QAAQ,KAAK,IAAI,EAAE;IAClD,IAAID,OAAO,KAAKZ,SAAS,IAAIY,OAAO,KAAK,IAAI,EAAE;MAC7C,MAAM,IAAIJ,KAAK,CACZ,4BAA2BE,OAAQ,+BACtC,CAAC;IACH;IACA,OAAOnB,WAAW,CAACK,gBAAgB;EACrC;EAEA,MAAM,IAAIY,KAAK,CAAE,kBAAiBJ,UAAW,MAAKM,OAAQ,EAAC,CAAC;AAC9D;AAEA,SAASI,qBAAqBA,CAC5BC,GAAoB,EACpBH,OAAgB,EAChBC,QAAkB,EAClBd,OAAgB,EAChB;EACA,MAAM;IAAEiB,MAAM,EAAEd,SAAS;IAAEe,IAAI,EAAEP;EAAQ,CAAC,GAAGK,GAAG;EAEhD,MAAMG,OAAO,GAAGN,OAAO,KAAKZ,SAAS;EACrC,MAAMgB,MAAM,GAAGf,cAAc,CAC3BC,SAAS,EACTgB,OAAO,GAAGhC,WAAW,CAACmB,aAAa,GAAGL,SAAS,EAC/CH,MAAM,CAAC,QAAQ,EAAEE,OAAO,CAC1B,CAAC;EAED,MAAMoB,UAAU,GACd,CAAC,CAACD,OAAO,IAAIF,MAAM,KAAK9B,WAAW,CAACoB,aAAa,KACjDU,MAAM,KAAK9B,WAAW,CAACqB,aAAa;EAEtC,MAAMU,IAAI,GAAGR,YAAY,CACvBC,OAAO,EACPS,UAAU,EACVP,OAAO,EACPC,QAAQ,EACRhB,MAAM,CAAC,MAAM,EAAEE,OAAO,CACxB,CAAC;EACD,OAAO;IAAEiB,MAAM;IAAEC;EAAK,CAAC;AACzB;AAEA,SAASG,gBAAgBA,CACvBL,GAAoB,EACpBH,OAAgB,EAChBC,QAAkB,EAClBd,OAAgB,EAChB;EACA;;EAEA,MAAMmB,OAAO,GAAGN,OAAO,KAAKZ,SAAS;EAErC,MAAM;IAAEgB,MAAM;IAAEC;EAAK,CAAC,GAAGH,qBAAqB,CAC5CC,GAAG,EACHH,OAAO,EACPC,QAAQ,EACRd,OACF,CAAC;EAED,IAAIsB,MAAM,EAAEC,UAAU,EAAEC,QAAQ;EAChC,IAAIV,QAAQ,KAAK,IAAI,EAAE;IACrB,CAAC;MAAEQ,MAAM;MAAEC,UAAU;MAAEC;IAAS,CAAC,GAAGR,GAAG;IAEvC,IAAI,CAACG,OAAO,EAAE;MACZ,IAAIG,MAAM,IAAI,IAAI,EAAE;QAClB,IAAI,OAAOA,MAAM,KAAK,QAAQ,EAC5B,MAAM,IAAIb,KAAK,CACZ,oBAAmBX,MAAM,CAAC,QAAQ,EAAEE,OAAO,CAAE,KAAIsB,MAAO,EAC3D,CAAC;QACH,IACEL,MAAM,KAAK9B,WAAW,CAACoB,aAAa,KACnCW,IAAI,KAAK1B,WAAW,CAACE,iBAAiB,IACrCwB,IAAI,KAAK1B,WAAW,CAACK,gBAAgB,CAAC,EACxC;UACA,MAAM,IAAIY,KAAK,CACZ,4BAA2BhB,aAAa,CAACyB,IAAI,CAAE,8BAClD,CAAC;QACH;MACF,CAAC,MAAM,IAAIK,UAAU,KAAKtB,SAAS,EAAE;QACnC,MAAM,IAAIQ,KAAK,CACZ,oBAAmBX,MAAM,CAAC,QAAQ,EAAEE,OAAO,CAAE,KAAIsB,MAAO,EAC3D,CAAC;MACH;IACF;IAEA,IACGH,OAAO,IAAII,UAAU,KAAKtB,SAAS,IAAI,CAACjB,gBAAgB,CAACuC,UAAU,CAAC,IACpE,CAACJ,OAAO,IAAIG,MAAM,IAAI,IAAI,IAAI,CAACtC,gBAAgB,CAACuC,UAAU,CAAE,EAC7D;MACA,MAAM,IAAId,KAAK,CACZ,0BAAyBX,MAAM,CAAC,YAAY,EAAEE,OAAO,CAAE,KAAIuB,UAAW,EACzE,CAAC;IACH;EACF;EAEA,IAAIA,UAAU,KAAKtB,SAAS,EAC1BsB,UAAU,GAAGxC,uBAAuB,CAACwC,UAAU,EAAEC,QAAQ,CAAC;EAE5D,OAAO;IAAEP,MAAM;IAAEC,IAAI;IAAEI,MAAM;IAAEC;EAAW,CAAC;AAC7C;AAEA,SAASE,oBAAoBA,CAC3BC,GAOK,EACLC,GAAoB,EAMpB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,IAAI3C,gBAAgB,CAAC0C,GAAG,CAAC,EAAE;IACzB;IACA,OAAO;MACLT,MAAM,EAAE9B,WAAW,CAACmB,aAAa;MACjCsB,IAAI,EAAE7C,uBAAuB,CAAC2C,GAAG;IACnC,CAAC;EACH,CAAC,MAAM,IAAI,OAAOA,GAAG,KAAK,QAAQ,EAAE;IAClC,MAAM;MACJA,GAAG,EAAEE,IAAI;MACTJ;MACA;IACF,CAAC,GAAGE,GAAG;IACP;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAI,CAAC1C,gBAAgB,CAAC4C,IAAI,CAAC,EAAE;MAC3B,MAAM,IAAInB,KAAK,CACb,0DACF,CAAC;IACH;IAEA,MAAMK,QAAQ,GACZa,GAAG,KAAKpC,eAAe,CAACsC,eAAe,IACvCF,GAAG,KAAKpC,eAAe,CAACuC,cAAc,GAClC,KAAK,GACL7B,SAAS;IAEf,OAAO;MACL2B,IAAI,EAAE7C,uBAAuB,CAAC6C,IAAI,EAAEJ,QAAQ,CAAC;MAC7C,GAAGH,gBAAgB,CAACK,GAAG,EAAEzB,SAAS,EAAEa,QAAQ;IAC9C,CAAC;EACH;EAEA,MAAM,IAAIL,KAAK,CAAC,oDAAoD,CAAC;AACvE;;AAEA;AACA,OAAO,SAASsB,iBAAiBA,CAACL,GAAiC,EAAE;EACnE,OAAOD,oBAAoB,CAACC,GAAG,EAAEnC,eAAe,CAACsC,eAAe,CAAC;AACnE;;AAEA;AACA,OAAO,SAASG,yBAAyBA,CACvCN,GAEmE,EACnE;EACA,OAAOD,oBAAoB,CAACC,GAAG,EAAEnC,eAAe,CAAC0C,cAAc,CAAC;AAClE;;AAEA;AACA;AACA;AACA,OAAO,SAASC,sBAAsBA,CACpClB,GAAoB,EACpBH,OAA2B,EAC3Bb,OAAgB,EAChB;EACA,OAAOqB,gBAAgB,CAACL,GAAG,EAAEH,OAAO,EAAEA,OAAO,GAAG,IAAI,GAAGZ,SAAS,EAAED,OAAO,CAAC;AAC5E;;AAEA;AACA;AACA;AACA,OAAO,SAASmC,uBAAuBA,CACrCnB,GAAoB,EACpBH,OAA2B,EAC3Bb,OAAgB,EAChB;EACA,OAAOqB,gBAAgB,CAACL,GAAG,EAAEH,OAAO,EAAE,KAAK,EAAEb,OAAO,CAAC;AACvD;AAEA,SAASoC,gBAAgBA,CACvBV,GAAQ;AAAE;AACVF,QAAiB,EACjBa,UAAU,GAAG,KAAK,EACb;EACL,IAAI,CAACA,UAAU,EAAE;IACf;IACA,IAAIX,GAAG,YAAYY,SAAS,EAAE;MAC5B,IAAIZ,GAAG,CAACR,IAAI,KAAK,QAAQ,EACvB,MAAM,IAAIT,KAAK,CACZ,2BAA0BiB,GAAG,CAACR,IAAK,qBACtC,CAAC;MACH,OAAOQ,GAAG,CAACa,MAAM;IACnB;IACA;IAAA,KACK,IAAIb,GAAG,YAAYc,SAAS,EAAE;MACjC,IAAId,GAAG,CAACR,IAAI,KAAK,QAAQ,EACvB,MAAM,IAAIT,KAAK,CACZ,2BAA0BiB,GAAG,CAACR,IAAK,qBACtC,CAAC;MACH,OAAOQ,GAAG,CAACe,SAAS,CAACF,MAAM;IAC7B;EACF;EAEA,IAAIb,GAAG,YAAYgB,WAAW,EAAE;IAC9B,OAAOhB,GAAG;EACZ;EAEA,IAAI,OAAOA,GAAG,KAAK,QAAQ,EAAE;IAC3B,OAAO3C,uBAAuB,CAAC2C,GAAG,EAAEF,QAAQ,CAAC;EAC/C;EAEA,MAAM,IAAIf,KAAK,CAAC,6BAA6B,CAAC;AAChD;AAEA,OAAO,SAASkC,eAAeA,CAACjB,GAAQ,EAAEF,QAAiB,EAAE;EAC3D,MAAMoB,CAAC,GAAGR,gBAAgB,CAACV,GAAG,EAAEF,QAAQ,EAAE,IAAI,CAAC;EAC/C,MAAMe,MAAM,GAAGtD,iBAAiB,CAAC4D,SAAS,CAACC,qBAAqB,CAAC,CAAC;EAClEP,MAAM,CAACQ,IAAI,CAAC3D,OAAO,CAAC4D,MAAM,EAAEJ,CAAC,CAAC;EAC9B,OAAO,IAAIK,eAAe,CAACV,MAAM,CAAC;AACpC;AAEA,OAAO,MAAMC,SAAS,CAAC;EAMrBU,WAAWA,CACTT,SAAoB,EACpBU,YAA6B,EAC7BC,SAAqB,EACrBC,cAAuB,EACvB;IACA,IAAI,CAACZ,SAAS,GAAGA,SAAS;IAC1B,IAAI,CAACU,YAAY,GAAGA,YAAY;IAChC,IAAI,CAACC,SAAS,GAAGA,SAAS;IAC1B,IAAI,CAACC,cAAc,GAAGA,cAAc;EACtC;EAEAC,OAAOA,CAACC,MAAc,EAAEC,QAAa,EAAO;IAC1C,MAAM,IAAI/C,KAAK,CAAC,sCAAsC,CAAC;IACvD;;IAEA;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;EACF;EAEA,IAAIS,IAAIA,CAAA,EAAG;IACT;IACA,OAAO,IAAI,CAACuB,SAAS,CAACvB,IAAI;EAC5B;EAEA,IAAIuC,WAAWA,CAAA,EAAG;IAChB,OAAO,IAAI,CAACJ,cAAc;EAC5B;EAEA,IAAIK,SAASA,CAAA,EAAG;IACd,OAAO,IAAI,CAACP,YAAY;EAC1B;EAEA,IAAIQ,MAAMA,CAAA,EAAG;IACX,OAAO,IAAI,CAACP,SAAS;EACvB;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,MAAMd,SAAS,CAAC;EAEdpB,IAAI,GAAgD,SAAS;EAC7D0C,MAAMA,CAACJ,QAA0B,EAAe;IAC9C,OAAO,IAAId,WAAW,CAAC,CAAC,CAAC;EAC3B;EAEAQ,WAAWA,CAAChC,IAAY,EAAEqB,MAAuB,EAAE;IACjD,IAAIrB,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,SAAS,EAC9D,MAAM,IAAIT,KAAK,CAAE,2BAA0BS,IAAK,EAAC,CAAC;IACpD,IAAI,CAACqB,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACrB,IAAI,GAAGA,IAAI;EAClB;;EAEA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO,MAAM+B,eAAe,SAASX,SAAS,CAAC;EAC7CY,WAAWA,CAACX,MAAuB,EAAE;IACnC,KAAK,CAAC,QAAQ,EAAEA,MAAM,CAAC;EACzB;;EAEA;EACA;EACA;;EAEAqB,MAAMA,CAACC,OAAwB,EAAE;IAC/B,IAAIA,OAAO,KAAK5D,SAAS,EAAE;MACzB,IAAI4D,OAAO,CAAC5C,MAAM,KAAK,KAAK,EAAE;QAC5B,MAAM,IAAIR,KAAK,CAAC,6CAA6C,CAAC;QAC9D;MACF;IACF;IACA,OAAO,IAAI,CAAC8B,MAAM,CAACqB,MAAM,CAAC,CAAC;EAC7B;AACF;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,MAAME,mBAAmB,SAASxB,SAAS,CAAC;EAC1CY,WAAWA,CAAChC,IAAY,EAAEqB,MAAuB,EAAE;IACjD,KAAK,CAACrB,IAAI,EAAEqB,MAAM,CAAC;EACrB;EAEA,IAAIwB,iBAAiBA,CAAA,EAAsB;IACzC,OAAO,IAAI,CAACA,iBAAiB,IAAI,IAAI,CAACxB,MAAM,CAACyB,oBAAoB,CAAC,CAAC;EACrE;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;AACF;AAEA,OAAO,MAAMC,eAAe,SAASH,mBAAmB,CAAC;EACvDZ,WAAWA,CAACX,MAAuB,EAAE;IACnC,KAAK,CAAC,QAAQ,EAAEA,MAAM,CAAC;EACzB;EAEAqB,MAAMA,CAACC,OAAwB,EAAE;IAC/B,IAAIA,OAAO,EAAE5C,MAAM,KAAK,KAAK,EAAE;MAC7B,MAAM,IAAIR,KAAK,CAAC,6CAA6C,CAAC;MAC9D;IACF;IACA,MAAM;MAAEQ,MAAM;MAAEC;IAAK,CAAC,GAAGgB,sBAAsB,CAC7C2B,OAAO,EACP,IAAI,CAACE,iBACP,CAAC;IACD,OAAO,IAAI,CAACxB,MAAM,CAACqB,MAAM,CAAC3C,MAAM,EAAEC,IAAI,CAAC;EACzC;AACF;AAEA,OAAO,MAAMgD,gBAAgB,SAASJ,mBAAmB,CAAC;EACxDZ,WAAWA,CAACX,MAAuB,EAAE;IACnC,KAAK,CAAC,SAAS,EAAEA,MAAM,CAAC;EAC1B;EAEAqB,MAAMA,CAACC,OAAwB,EAAE;IAC/B,IAAIA,OAAO,EAAE5C,MAAM,KAAK,KAAK,EAAE;MAC7B,IAAI4C,OAAO,CAACtC,UAAU,KAAKtB,SAAS,EAAE;QACpC,MAAM,IAAIQ,KAAK,CAAC,iCAAiC,CAAC;MACpD;MACA,MAAM,IAAIA,KAAK,CAAC,8CAA8C,CAAC;MAC/D;IACF;IACA,MAAM;MAAEQ,MAAM;MAAEC,IAAI;MAAEI,MAAM;MAAEC;IAAW,CAAC,GAAGY,uBAAuB,CAClE0B,OAAO,EACP,IAAI,CAACE,iBACP,CAAC;IACD,OAAO,IAAI,CAACxB,MAAM,CAACqB,MAAM,CAAC3C,MAAM,EAAEC,IAAI,EAAEI,MAAM,EAAEC,UAAU,CAAC;EAC7D;AACF","ignoreList":[]}

package/lib/module/pbkdf2.js

@@ -1,9 +1,9 @@
 import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
 import { Buffer } from '@craftzdog/react-native-buffer';
-import { binaryLikeToArrayBuffer } from './Utils';
+import { binaryLikeToArrayBuffer, lazyDOMException, bufferLikeToArrayBuffer, normalizeHashName, HashContext } from './Utils';
+import { promisify } from 'util';
 const WRONG_PASS = 'Password must be a string, a Buffer, a typed array or a DataView';
-const WRON_SALT = `Salt must be a string, a Buffer, a typed array or a DataView`;
-
+const WRONG_SALT = `Salt must be a string, a Buffer, a typed array or a DataView`;
 function sanitizeInput(input, errorMsg) {
   try {
     return binaryLikeToArrayBuffer(input);
@@ -11,15 +11,12 @@ function sanitizeInput(input, errorMsg) {
     throw errorMsg;
   }
 }
-
 const nativePbkdf2 = NativeQuickCrypto.pbkdf2;
 export function pbkdf2(password, salt, iterations, keylen, arg0, arg1) {
-  let digest = 'sha1';
+  let digest = 'SHA-1';
   let callback;
-
   if (typeof arg0 === 'string') {
     digest = arg0;
-
     if (typeof arg1 === 'function') {
       callback = arg1;
     }
@@ -28,14 +25,13 @@ export function pbkdf2(password, salt, iterations, keylen, arg0, arg1) {
       callback = arg0;
     }
   }
-
   if (callback === undefined) {
     throw new Error('No callback provided to pbkdf2');
   }
-
   const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
-  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);
-  nativePbkdf2.pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, digest).then(res => {
+  const sanitizedSalt = sanitizeInput(salt, WRONG_SALT);
+  const normalizedDigest = normalizeHashName(digest, HashContext.Node);
+  nativePbkdf2.pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, normalizedDigest).then(res => {
     callback(null, Buffer.from(res));
   }, e => {
     callback(e);
@@ -43,9 +39,44 @@ export function pbkdf2(password, salt, iterations, keylen, arg0, arg1) {
 }
 export function pbkdf2Sync(password, salt, iterations, keylen, digest) {
   const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
-  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);
-  const algo = digest ? digest : 'sha1';
+  const sanitizedSalt = sanitizeInput(salt, WRONG_SALT);
+  const algo = digest ? normalizeHashName(digest, HashContext.Node) : 'sha1';
   let result = nativePbkdf2.pbkdf2Sync(sanitizedPassword, sanitizedSalt, iterations, keylen, algo);
   return Buffer.from(result);
 }
+
+// We need this because the typescript  overload signatures in pbkdf2() above do
+// not play nice with promisify() below.
+const pbkdf2WithDigest = (password, salt, iterations, keylen, digest, callback) => pbkdf2(password, salt, iterations, keylen, digest, callback);
+const pbkdf2Promise = promisify(pbkdf2WithDigest);
+export async function pbkdf2DeriveBits(algorithm, baseKey, length) {
+  const {
+    iterations,
+    hash,
+    salt
+  } = algorithm;
+  const normalizedHash = normalizeHashName(hash);
+  if (!normalizedHash) {
+    throw lazyDOMException('hash cannot be blank', 'OperationError');
+  }
+  if (!iterations || iterations === 0) {
+    throw lazyDOMException('iterations cannot be zero', 'OperationError');
+  }
+  if (!salt) {
+    throw lazyDOMException(WRONG_SALT, 'OperationError');
+  }
+  const raw = baseKey.keyObject.export();
+  if (length === 0) throw lazyDOMException('length cannot be zero', 'OperationError');
+  if (length === null) throw lazyDOMException('length cannot be null', 'OperationError');
+  if (length % 8) {
+    throw lazyDOMException('length must be a multiple of 8', 'OperationError');
+  }
+  const sanitizedPassword = sanitizeInput(raw, WRONG_PASS);
+  const sanitizedSalt = sanitizeInput(salt, WRONG_SALT);
+  let result = await pbkdf2Promise(sanitizedPassword, sanitizedSalt, iterations, length / 8, normalizedHash);
+  if (!result) {
+    throw lazyDOMException('received bad result from pbkdf2()', 'OperationError');
+  }
+  return bufferLikeToArrayBuffer(result);
+}
 //# sourceMappingURL=pbkdf2.js.map

package/lib/module/pbkdf2.js.map

@@ -1 +1 @@
-{"version":3,"sources":["pbkdf2.ts"],"names":["NativeQuickCrypto","Buffer","binaryLikeToArrayBuffer","WRONG_PASS","WRON_SALT","sanitizeInput","input","errorMsg","e","nativePbkdf2","pbkdf2","password","salt","iterations","keylen","arg0","arg1","digest","callback","undefined","Error","sanitizedPassword","sanitizedSalt","then","res","from","pbkdf2Sync","algo","result"],"mappings":"AAAA,SAASA,iBAAT,QAAkC,uCAAlC;AACA,SAASC,MAAT,QAAuB,gCAAvB;AACA,SAAqBC,uBAArB,QAAoD,SAApD;AAEA,MAAMC,UAAU,GACd,kEADF;AAEA,MAAMC,SAAS,GAAI,8DAAnB;;AAMA,SAASC,aAAT,CAAuBC,KAAvB,EAA0CC,QAA1C,EAAyE;AACvE,MAAI;AACF,WAAOL,uBAAuB,CAACI,KAAD,CAA9B;AACD,GAFD,CAEE,OAAOE,CAAP,EAAe;AACf,UAAMD,QAAN;AACD;AACF;;AAED,MAAME,YAAY,GAAGT,iBAAiB,CAACU,MAAvC;AAiBA,OAAO,SAASA,MAAT,CACLC,QADK,EAELC,IAFK,EAGLC,UAHK,EAILC,MAJK,EAKLC,IALK,EAMLC,IANK,EAOC;AACN,MAAIC,MAAM,GAAG,MAAb;AACA,MAAIC,QAAJ;;AACA,MAAI,OAAOH,IAAP,KAAgB,QAApB,EAA8B;AAC5BE,IAAAA,MAAM,GAAGF,IAAT;;AACA,QAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;AAC9BE,MAAAA,QAAQ,GAAGF,IAAX;AACD;AACF,GALD,MAKO;AACL,QAAI,OAAOD,IAAP,KAAgB,UAApB,EAAgC;AAC9BG,MAAAA,QAAQ,GAAGH,IAAX;AACD;AACF;;AACD,MAAIG,QAAQ,KAAKC,SAAjB,EAA4B;AAC1B,UAAM,IAAIC,KAAJ,CAAU,gCAAV,CAAN;AACD;;AAED,QAAMC,iBAAiB,GAAGhB,aAAa,CAACM,QAAD,EAAWR,UAAX,CAAvC;AACA,QAAMmB,aAAa,GAAGjB,aAAa,CAACO,IAAD,EAAOR,SAAP,CAAnC;AAEAK,EAAAA,YAAY,CACTC,MADH,CACUW,iBADV,EAC6BC,aAD7B,EAC4CT,UAD5C,EACwDC,MADxD,EACgEG,MADhE,EAEGM,IAFH,CAGKC,GAAD,IAAsB;AACpBN,IAAAA,QAAQ,CAAE,IAAF,EAAQjB,MAAM,CAACwB,IAAP,CAAYD,GAAZ,CAAR,CAAR;AACD,GALL,EAMKhB,CAAD,IAAc;AACZU,IAAAA,QAAQ,CAAEV,CAAF,CAAR;AACD,GARL;AAUD;AACD,OAAO,SAASkB,UAAT,CACLf,QADK,EAELC,IAFK,EAGLC,UAHK,EAILC,MAJK,EAKLG,MALK,EAMG;AACR,QAAMI,iBAAiB,GAAGhB,aAAa,CAACM,QAAD,EAAWR,UAAX,CAAvC;AACA,QAAMmB,aAAa,GAAGjB,aAAa,CAACO,IAAD,EAAOR,SAAP,CAAnC;AAEA,QAAMuB,IAAI,GAAGV,MAAM,GAAGA,MAAH,GAAY,MAA/B;AACA,MAAIW,MAAmB,GAAGnB,YAAY,CAACiB,UAAb,CACxBL,iBADwB,EAExBC,aAFwB,EAGxBT,UAHwB,EAIxBC,MAJwB,EAKxBa,IALwB,CAA1B;AAQA,SAAO1B,MAAM,CAACwB,IAAP,CAAYG,MAAZ,CAAP;AACD","sourcesContent":["import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';\nimport { Buffer } from '@craftzdog/react-native-buffer';\nimport { BinaryLike, binaryLikeToArrayBuffer } from './Utils';\n\nconst WRONG_PASS =\n  'Password must be a string, a Buffer, a typed array or a DataView';\nconst WRON_SALT = `Salt must be a string, a Buffer, a typed array or a DataView`;\n\ntype Password = BinaryLike;\ntype Salt = BinaryLike;\ntype Pbkdf2Callback = (err: Error | null, derivedKey?: Buffer) => void;\n\nfunction sanitizeInput(input: BinaryLike, errorMsg: string): ArrayBuffer {\n  try {\n    return binaryLikeToArrayBuffer(input);\n  } catch (e: any) {\n    throw errorMsg;\n  }\n}\n\nconst nativePbkdf2 = NativeQuickCrypto.pbkdf2;\n\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  digest: string,\n  callback: Pbkdf2Callback\n): void;\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  callback: Pbkdf2Callback\n): void;\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  arg0?: unknown,\n  arg1?: unknown\n): void {\n  let digest = 'sha1';\n  let callback: undefined | Pbkdf2Callback;\n  if (typeof arg0 === 'string') {\n    digest = arg0;\n    if (typeof arg1 === 'function') {\n      callback = arg1 as Pbkdf2Callback;\n    }\n  } else {\n    if (typeof arg0 === 'function') {\n      callback = arg0 as Pbkdf2Callback;\n    }\n  }\n  if (callback === undefined) {\n    throw new Error('No callback provided to pbkdf2');\n  }\n\n  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);\n  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);\n\n  nativePbkdf2\n    .pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, digest)\n    .then(\n      (res: ArrayBuffer) => {\n        callback!(null, Buffer.from(res));\n      },\n      (e: Error) => {\n        callback!(e);\n      }\n    );\n}\nexport function pbkdf2Sync(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  digest?: string\n): Buffer {\n  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);\n  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);\n\n  const algo = digest ? digest : 'sha1';\n  let result: ArrayBuffer = nativePbkdf2.pbkdf2Sync(\n    sanitizedPassword,\n    sanitizedSalt,\n    iterations,\n    keylen,\n    algo\n  );\n\n  return Buffer.from(result);\n}\n"]}
+{"version":3,"names":["NativeQuickCrypto","Buffer","binaryLikeToArrayBuffer","lazyDOMException","bufferLikeToArrayBuffer","normalizeHashName","HashContext","promisify","WRONG_PASS","WRONG_SALT","sanitizeInput","input","errorMsg","e","nativePbkdf2","pbkdf2","password","salt","iterations","keylen","arg0","arg1","digest","callback","undefined","Error","sanitizedPassword","sanitizedSalt","normalizedDigest","Node","then","res","from","pbkdf2Sync","algo","result","pbkdf2WithDigest","pbkdf2Promise","pbkdf2DeriveBits","algorithm","baseKey","length","hash","normalizedHash","raw","keyObject","export"],"sourceRoot":"../../src","sources":["pbkdf2.ts"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,uCAAuC;AACzE,SAASC,MAAM,QAAQ,gCAAgC;AACvD,SAEEC,uBAAuB,EACvBC,gBAAgB,EAChBC,uBAAuB,EACvBC,iBAAiB,EACjBC,WAAW,QACN,SAAS;AAEhB,SAASC,SAAS,QAAQ,MAAM;AAEhC,MAAMC,UAAU,GACd,kEAAkE;AACpE,MAAMC,UAAU,GAAI,8DAA6D;AAMjF,SAASC,aAAaA,CAACC,KAAiB,EAAEC,QAAgB,EAAe;EACvE,IAAI;IACF,OAAOV,uBAAuB,CAACS,KAAK,CAAC;EACvC,CAAC,CAAC,OAAOE,CAAM,EAAE;IACf,MAAMD,QAAQ;EAChB;AACF;AAEA,MAAME,YAAY,GAAGd,iBAAiB,CAACe,MAAM;AAiB7C,OAAO,SAASA,MAAMA,CACpBC,QAAkB,EAClBC,IAAU,EACVC,UAAkB,EAClBC,MAAc,EACdC,IAAc,EACdC,IAAc,EACR;EACN,IAAIC,MAAqB,GAAG,OAAO;EACnC,IAAIC,QAAoC;EACxC,IAAI,OAAOH,IAAI,KAAK,QAAQ,EAAE;IAC5BE,MAAM,GAAGF,IAAqB;IAC9B,IAAI,OAAOC,IAAI,KAAK,UAAU,EAAE;MAC9BE,QAAQ,GAAGF,IAAsB;IACnC;EACF,CAAC,MAAM;IACL,IAAI,OAAOD,IAAI,KAAK,UAAU,EAAE;MAC9BG,QAAQ,GAAGH,IAAsB;IACnC;EACF;EACA,IAAIG,QAAQ,KAAKC,SAAS,EAAE;IAC1B,MAAM,IAAIC,KAAK,CAAC,gCAAgC,CAAC;EACnD;EAEA,MAAMC,iBAAiB,GAAGhB,aAAa,CAACM,QAAQ,EAAER,UAAU,CAAC;EAC7D,MAAMmB,aAAa,GAAGjB,aAAa,CAACO,IAAI,EAAER,UAAU,CAAC;EACrD,MAAMmB,gBAAgB,GAAGvB,iBAAiB,CAACiB,MAAM,EAAEhB,WAAW,CAACuB,IAAI,CAAC;EAEpEf,YAAY,CACTC,MAAM,CACLW,iBAAiB,EACjBC,aAAa,EACbT,UAAU,EACVC,MAAM,EACNS,gBACF,CAAC,CACAE,IAAI,CACFC,GAAgB,IAAK;IACpBR,QAAQ,CAAE,IAAI,EAAEtB,MAAM,CAAC+B,IAAI,CAACD,GAAG,CAAC,CAAC;EACnC,CAAC,EACAlB,CAAQ,IAAK;IACZU,QAAQ,CAAEV,CAAC,CAAC;EACd,CACF,CAAC;AACL;AAEA,OAAO,SAASoB,UAAUA,CACxBjB,QAAkB,EAClBC,IAAU,EACVC,UAAkB,EAClBC,MAAc,EACdG,MAAsB,EACT;EACb,MAAMI,iBAAiB,GAAGhB,aAAa,CAACM,QAAQ,EAAER,UAAU,CAAC;EAC7D,MAAMmB,aAAa,GAAGjB,aAAa,CAACO,IAAI,EAAER,UAAU,CAAC;EAErD,MAAMyB,IAAI,GAAGZ,MAAM,GAAGjB,iBAAiB,CAACiB,MAAM,EAAEhB,WAAW,CAACuB,IAAI,CAAC,GAAG,MAAM;EAC1E,IAAIM,MAAmB,GAAGrB,YAAY,CAACmB,UAAU,CAC/CP,iBAAiB,EACjBC,aAAa,EACbT,UAAU,EACVC,MAAM,EACNe,IACF,CAAC;EAED,OAAOjC,MAAM,CAAC+B,IAAI,CAACG,MAAM,CAAC;AAC5B;;AAEA;AACA;AACA,MAAMC,gBAAgB,GAAGA,CACvBpB,QAAkB,EAClBC,IAAU,EACVC,UAAkB,EAClBC,MAAc,EACdG,MAAqB,EACrBC,QAAwB,KACrBR,MAAM,CAACC,QAAQ,EAAEC,IAAI,EAAEC,UAAU,EAAEC,MAAM,EAAEG,MAAM,EAAEC,QAAQ,CAAC;AAEjE,MAAMc,aAAa,GAAG9B,SAAS,CAAC6B,gBAAgB,CAAC;AACjD,OAAO,eAAeE,gBAAgBA,CACpCC,SAA0B,EAC1BC,OAAkB,EAClBC,MAAc,EACQ;EACtB,MAAM;IAAEvB,UAAU;IAAEwB,IAAI;IAAEzB;EAAK,CAAC,GAAGsB,SAAS;EAC5C,MAAMI,cAAc,GAAGtC,iBAAiB,CAACqC,IAAI,CAAC;EAC9C,IAAI,CAACC,cAAc,EAAE;IACnB,MAAMxC,gBAAgB,CAAC,sBAAsB,EAAE,gBAAgB,CAAC;EAClE;EACA,IAAI,CAACe,UAAU,IAAIA,UAAU,KAAK,CAAC,EAAE;IACnC,MAAMf,gBAAgB,CAAC,2BAA2B,EAAE,gBAAgB,CAAC;EACvE;EACA,IAAI,CAACc,IAAI,EAAE;IACT,MAAMd,gBAAgB,CAACM,UAAU,EAAE,gBAAgB,CAAC;EACtD;EACA,MAAMmC,GAAG,GAAGJ,OAAO,CAACK,SAAS,CAACC,MAAM,CAAC,CAAC;EAEtC,IAAIL,MAAM,KAAK,CAAC,EACd,MAAMtC,gBAAgB,CAAC,uBAAuB,EAAE,gBAAgB,CAAC;EACnE,IAAIsC,MAAM,KAAK,IAAI,EACjB,MAAMtC,gBAAgB,CAAC,uBAAuB,EAAE,gBAAgB,CAAC;EACnE,IAAIsC,MAAM,GAAG,CAAC,EAAE;IACd,MAAMtC,gBAAgB,CAAC,gCAAgC,EAAE,gBAAgB,CAAC;EAC5E;EAEA,MAAMuB,iBAAiB,GAAGhB,aAAa,CAACkC,GAAG,EAAEpC,UAAU,CAAC;EACxD,MAAMmB,aAAa,GAAGjB,aAAa,CAACO,IAAI,EAAER,UAAU,CAAC;EACrD,IAAI0B,MAA0B,GAAG,MAAME,aAAa,CAClDX,iBAAiB,EACjBC,aAAa,EACbT,UAAU,EACVuB,MAAM,GAAG,CAAC,EACVE,cACF,CAAC;EACD,IAAI,CAACR,MAAM,EAAE;IACX,MAAMhC,gBAAgB,CACpB,mCAAmC,EACnC,gBACF,CAAC;EACH;EACA,OAAOC,uBAAuB,CAAC+B,MAAM,CAAC;AACxC","ignoreList":[]}