react-native-quick-crypto 0.6.0 → 0.7.0-rc.0

package/lib/commonjs/keys.js

@@ -3,57 +3,75 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.WebCryptoKeyExportStatus = exports.SecretKeyObject = exports.PublicKeyObject = exports.PrivateKeyObject = exports.KeyType = exports.KeyEncoding = exports.KWebCryptoKeyFormat = exports.KFormatType = exports.CryptoKey = void 0;
+exports.createSecretKey = createSecretKey;
+exports.kNamedCurveAliases = void 0;
 exports.parsePrivateKeyEncoding = parsePrivateKeyEncoding;
 exports.parsePublicKeyEncoding = parsePublicKeyEncoding;
 exports.preparePrivateKey = preparePrivateKey;
 exports.preparePublicOrPrivateKey = preparePublicOrPrivateKey;
-
 var _Utils = require("./Utils");
-
+var _NativeQuickCrypto = require("./NativeQuickCrypto/NativeQuickCrypto");
+const kNamedCurveAliases = exports.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) {
+let KFormatType = exports.KFormatType = /*#__PURE__*/function (KFormatType) {
   KFormatType[KFormatType["kKeyFormatDER"] = 0] = "kKeyFormatDER";
   KFormatType[KFormatType["kKeyFormatPEM"] = 1] = "kKeyFormatPEM";
   KFormatType[KFormatType["kKeyFormatJWK"] = 2] = "kKeyFormatJWK";
-})(KFormatType || (KFormatType = {}));
-
-var KeyInputContext;
-
-(function (KeyInputContext) {
+  return KFormatType;
+}({}); // Same as KFormatType, this enum needs to be defined on the native side
+let KeyType = exports.KeyType = /*#__PURE__*/function (KeyType) {
+  KeyType[KeyType["Secret"] = 0] = "Secret";
+  KeyType[KeyType["Public"] = 1] = "Public";
+  KeyType[KeyType["Private"] = 2] = "Private";
+  return KeyType;
+}({}); // Same as KFormatType, this enum needs to be defined on the native side
+let KWebCryptoKeyFormat = exports.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;
+}({});
+let WebCryptoKeyExportStatus = exports.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 || {});
+let KeyEncoding = exports.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;
@@ -61,7 +79,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;
@@ -71,13 +88,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,
@@ -92,27 +106,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`);
         }
@@ -120,12 +131,10 @@ function parseKeyEncoding(enc, keyType, isPublic, objName) {
         throw new Error(`invalid argument ${option('cipher', objName)}: ${cipher}`);
       }
     }
-
     if (isInput && passphrase !== undefined && !(0, _Utils.isStringOrBuffer)(passphrase) || !isInput && cipher != null && !(0, _Utils.isStringOrBuffer)(passphrase)) {
       throw new Error(`Invalid argument value ${option('passphrase', objName)}: ${passphrase}`);
     }
   }
-
   if (passphrase !== undefined) passphrase = (0, _Utils.binaryLikeToArrayBuffer)(passphrase, encoding);
   return {
     format,
@@ -134,7 +143,6 @@ function parseKeyEncoding(enc, keyType, isPublic, objName) {
     passphrase
   };
 }
-
 function prepareAsymmetricKey(key, ctx) {
   // TODO(osp) check, KeyObject some node object
   // if (isKeyObject(key)) {
@@ -153,9 +161,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))
@@ -163,42 +172,265 @@ 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 (!(0, _Utils.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: (0, _Utils.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
 function preparePrivateKey(key) {
   return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);
-} // TODO(osp) any here is a node KeyObject
-
+}
 
+// TODO(osp) any here is a node KeyObject
 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.
-
-
 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.
-
-
 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 (0, _Utils.binaryLikeToArrayBuffer)(key, encoding);
+  }
+  throw new Error('invalid argument type "key"');
+}
+function createSecretKey(key, encoding) {
+  const k = prepareSecretKey(key, encoding, true);
+  const handle = _NativeQuickCrypto.NativeQuickCrypto.webcrypto.createKeyObjectHandle();
+  handle.init(KeyType.Secret, k);
+  return new SecretKeyObject(handle);
+}
+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',
+//   },
+// });
+exports.CryptoKey = 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',
+//   },
+// });
+
+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;
+// }
+exports.SecretKeyObject = SecretKeyObject;
+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 {};
+  //   }
+  // }
+}
+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);
+  }
+}
+exports.PublicKeyObject = PublicKeyObject;
+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);
+  }
+}
+exports.PrivateKeyObject = PrivateKeyObject;
 //# sourceMappingURL=keys.js.map

package/lib/commonjs/keys.js.map

@@ -1 +1 @@
-{"version":3,"sources":["keys.ts"],"names":["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;;AAEA;AACA;IACKA,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,CAAC,6BAAiBsB,UAAjB,CAAzC,IACC,CAACJ,OAAD,IAAYG,MAAM,IAAI,IAAtB,IAA8B,CAAC,6BAAiBC,UAAjB,CAFlC,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,GAAG,oCAAwBA,UAAxB,EAAoCC,QAApC,CAAb;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,MAAI,6BAAiBD,GAAjB,CAAJ,EAA2B;AACzB;AACA,WAAO;AACLT,MAAAA,MAAM,EAAE3B,WAAW,CAACgB,aADf;AAELsB,MAAAA,IAAI,EAAE,oCAAwBF,GAAxB;AAFD,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,CAAC,6BAAiBE,IAAjB,CAAL,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,EAAE,oCAAwBA,IAAxB,EAA8BJ,QAA9B,CADD;AAEL,SAAGH,gBAAgB,CAACK,GAAD,EAAMzB,SAAN,EAAiBa,QAAjB;AAFd,KAAP;AAID;;AAED,QAAM,IAAIL,KAAJ,CAAU,oDAAV,CAAN;AACD,C,CAED;;;AACO,SAASsB,iBAAT,CACLL,GADK,EAUL;AACA,SAAOD,oBAAoB,CAACC,GAAD,EAAMnC,eAAe,CAACsC,eAAtB,CAA3B;AACD,C,CAED;;;AACO,SAASG,yBAAT,CACLN,GADK,EAIL;AACA,SAAOD,oBAAoB,CAACC,GAAD,EAAMnC,eAAe,CAAC0C,cAAtB,CAA3B;AACD,C,CAED;AACA;AACA;;;AACO,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;;;AACO,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":["_Utils","require","_NativeQuickCrypto","kNamedCurveAliases","exports","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","isStringOrBuffer","binaryLikeToArrayBuffer","prepareAsymmetricKey","key","ctx","data","kConsumePrivate","kCreatePrivate","preparePrivateKey","preparePublicOrPrivateKey","kConsumePublic","parsePublicKeyEncoding","parsePrivateKeyEncoding","prepareSecretKey","bufferOnly","KeyObject","handle","CryptoKey","keyObject","ArrayBuffer","createSecretKey","k","NativeQuickCrypto","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":"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"}

package/lib/commonjs/pbkdf2.js

@@ -4,17 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.pbkdf2 = pbkdf2;
+exports.pbkdf2DeriveBits = pbkdf2DeriveBits;
 exports.pbkdf2Sync = pbkdf2Sync;
-
 var _NativeQuickCrypto = require("./NativeQuickCrypto/NativeQuickCrypto");
-
 var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
-
 var _Utils = require("./Utils");
-
+var _util = require("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 (0, _Utils.binaryLikeToArrayBuffer)(input);
@@ -22,16 +19,12 @@ function sanitizeInput(input, errorMsg) {
     throw errorMsg;
   }
 }
-
 const nativePbkdf2 = _NativeQuickCrypto.NativeQuickCrypto.pbkdf2;
-
 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;
     }
@@ -40,25 +33,58 @@ 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 = (0, _Utils.normalizeHashName)(digest, _Utils.HashContext.Node);
+  nativePbkdf2.pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, normalizedDigest).then(res => {
     callback(null, _reactNativeBuffer.Buffer.from(res));
   }, e => {
     callback(e);
   });
 }
-
 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 ? (0, _Utils.normalizeHashName)(digest, _Utils.HashContext.Node) : 'sha1';
   let result = nativePbkdf2.pbkdf2Sync(sanitizedPassword, sanitizedSalt, iterations, keylen, algo);
   return _reactNativeBuffer.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 = (0, _util.promisify)(pbkdf2WithDigest);
+async function pbkdf2DeriveBits(algorithm, baseKey, length) {
+  const {
+    iterations,
+    hash,
+    salt
+  } = algorithm;
+  const normalizedHash = (0, _Utils.normalizeHashName)(hash);
+  if (!normalizedHash) {
+    throw (0, _Utils.lazyDOMException)('hash cannot be blank', 'OperationError');
+  }
+  if (!iterations || iterations === 0) {
+    throw (0, _Utils.lazyDOMException)('iterations cannot be zero', 'OperationError');
+  }
+  if (!salt) {
+    throw (0, _Utils.lazyDOMException)(WRONG_SALT, 'OperationError');
+  }
+  const raw = baseKey.keyObject.export();
+  if (length === 0) throw (0, _Utils.lazyDOMException)('length cannot be zero', 'OperationError');
+  if (length === null) throw (0, _Utils.lazyDOMException)('length cannot be null', 'OperationError');
+  if (length % 8) {
+    throw (0, _Utils.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 (0, _Utils.lazyDOMException)('received bad result from pbkdf2()', 'OperationError');
+  }
+  return (0, _Utils.bufferLikeToArrayBuffer)(result);
+}
 //# sourceMappingURL=pbkdf2.js.map

package/lib/commonjs/pbkdf2.js.map

@@ -1 +1 @@
-{"version":3,"sources":["pbkdf2.ts"],"names":["WRONG_PASS","WRON_SALT","sanitizeInput","input","errorMsg","e","nativePbkdf2","NativeQuickCrypto","pbkdf2","password","salt","iterations","keylen","arg0","arg1","digest","callback","undefined","Error","sanitizedPassword","sanitizedSalt","then","res","Buffer","from","pbkdf2Sync","algo","result"],"mappings":";;;;;;;;AAAA;;AACA;;AACA;;AAEA,MAAMA,UAAU,GACd,kEADF;AAEA,MAAMC,SAAS,GAAI,8DAAnB;;AAMA,SAASC,aAAT,CAAuBC,KAAvB,EAA0CC,QAA1C,EAAyE;AACvE,MAAI;AACF,WAAO,oCAAwBD,KAAxB,CAAP;AACD,GAFD,CAEE,OAAOE,CAAP,EAAe;AACf,UAAMD,QAAN;AACD;AACF;;AAED,MAAME,YAAY,GAAGC,qCAAkBC,MAAvC;;AAiBO,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,GAAGjB,aAAa,CAACO,QAAD,EAAWT,UAAX,CAAvC;AACA,QAAMoB,aAAa,GAAGlB,aAAa,CAACQ,IAAD,EAAOT,SAAP,CAAnC;AAEAK,EAAAA,YAAY,CACTE,MADH,CACUW,iBADV,EAC6BC,aAD7B,EAC4CT,UAD5C,EACwDC,MADxD,EACgEG,MADhE,EAEGM,IAFH,CAGKC,GAAD,IAAsB;AACpBN,IAAAA,QAAQ,CAAE,IAAF,EAAQO,0BAAOC,IAAP,CAAYF,GAAZ,CAAR,CAAR;AACD,GALL,EAMKjB,CAAD,IAAc;AACZW,IAAAA,QAAQ,CAAEX,CAAF,CAAR;AACD,GARL;AAUD;;AACM,SAASoB,UAAT,CACLhB,QADK,EAELC,IAFK,EAGLC,UAHK,EAILC,MAJK,EAKLG,MALK,EAMG;AACR,QAAMI,iBAAiB,GAAGjB,aAAa,CAACO,QAAD,EAAWT,UAAX,CAAvC;AACA,QAAMoB,aAAa,GAAGlB,aAAa,CAACQ,IAAD,EAAOT,SAAP,CAAnC;AAEA,QAAMyB,IAAI,GAAGX,MAAM,GAAGA,MAAH,GAAY,MAA/B;AACA,MAAIY,MAAmB,GAAGrB,YAAY,CAACmB,UAAb,CACxBN,iBADwB,EAExBC,aAFwB,EAGxBT,UAHwB,EAIxBC,MAJwB,EAKxBc,IALwB,CAA1B;AAQA,SAAOH,0BAAOC,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","require","_reactNativeBuffer","_Utils","_util","WRONG_PASS","WRONG_SALT","sanitizeInput","input","errorMsg","binaryLikeToArrayBuffer","e","nativePbkdf2","NativeQuickCrypto","pbkdf2","password","salt","iterations","keylen","arg0","arg1","digest","callback","undefined","Error","sanitizedPassword","sanitizedSalt","normalizedDigest","normalizeHashName","HashContext","Node","then","res","Buffer","from","pbkdf2Sync","algo","result","pbkdf2WithDigest","pbkdf2Promise","promisify","pbkdf2DeriveBits","algorithm","baseKey","length","hash","normalizedHash","lazyDOMException","raw","keyObject","export","bufferLikeToArrayBuffer"],"sourceRoot":"../../src","sources":["pbkdf2.ts"],"mappings":"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"}