react-native-quick-crypto 1.0.0-beta.2 → 1.0.0-beta.21

package/lib/module/keys/classes.js

@@ -0,0 +1,241 @@
+"use strict";
+
+import { Buffer } from 'buffer';
+import { NitroModules } from 'react-native-nitro-modules';
+import { KeyType, KFormatType, KeyEncoding } from '../utils';
+import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+export class CryptoKey {
+  constructor(keyObject, keyAlgorithm, keyUsages, keyExtractable) {
+    this.keyObject = keyObject;
+    this.keyAlgorithm = keyAlgorithm;
+    this.keyUsages = keyUsages;
+    this.keyExtractable = keyExtractable;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  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;
+  }
+}
+export class KeyObject {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export(_options) {
+    // This is a placeholder and should be overridden by subclasses.
+    throw new Error('export() must be implemented by subclasses');
+  }
+  constructor(type, handleOrKey) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private') throw new Error(`invalid KeyObject type: ${type}`);
+    if (handleOrKey instanceof ArrayBuffer) {
+      this.handle = NitroModules.createHybridObject('KeyObjectHandle');
+      let keyType;
+      switch (type) {
+        case 'public':
+          keyType = KeyType.PUBLIC;
+          break;
+        case 'private':
+          keyType = KeyType.PRIVATE;
+          break;
+        case 'secret':
+          keyType = KeyType.SECRET;
+          break;
+        default:
+          // Should not happen
+          throw new Error('invalid key type');
+      }
+      this.handle.init(keyType, handleOrKey);
+    } else {
+      this.handle = handleOrKey;
+    }
+    this.type = type;
+  }
+
+  // static from(key) {
+  //   if (!isCryptoKey(key))
+  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
+  //   return key[kKeyObject];
+  // }
+
+  static createKeyObject(type, key, format, encoding) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private') throw new Error(`invalid KeyObject type: ${type}`);
+    const handle = NitroModules.createHybridObject('KeyObjectHandle');
+    let keyType;
+    switch (type) {
+      case 'public':
+        keyType = KeyType.PUBLIC;
+        break;
+      case 'private':
+        keyType = KeyType.PRIVATE;
+        break;
+      case 'secret':
+        keyType = KeyType.SECRET;
+        break;
+      default:
+        throw new Error('invalid key type');
+    }
+
+    // If format and encoding are explicitly provided, use them
+    if (format && encoding && (keyType === KeyType.PUBLIC || keyType === KeyType.PRIVATE)) {
+      const kFormat = format === 'der' ? KFormatType.DER : KFormatType.PEM;
+      const kEncoding = encoding === 'spki' ? KeyEncoding.SPKI : encoding === 'pkcs8' ? KeyEncoding.PKCS8 : encoding === 'sec1' ? KeyEncoding.SEC1 : KeyEncoding.SEC1;
+      handle.init(keyType, key, kFormat, kEncoding);
+    } else {
+      handle.init(keyType, key);
+    }
+
+    // For asymmetric keys, return the appropriate subclass
+    if (type === 'public' || type === 'private') {
+      try {
+        handle.getAsymmetricKeyType();
+        // If we get here, it's an asymmetric key - return the appropriate subclass
+        if (type === 'public') {
+          return new PublicKeyObject(handle);
+        } else {
+          return new PrivateKeyObject(handle);
+        }
+      } catch {
+        // Not an asymmetric key, fall through to regular KeyObject
+      }
+    }
+
+    // For secret keys, return SecretKeyObject
+    if (type === 'secret') {
+      return new SecretKeyObject(handle);
+    }
+
+    // Return regular KeyObject for symmetric keys or if asymmetric detection failed
+    return new KeyObject(type, handle);
+  }
+  getAsymmetricKeyType() {
+    return undefined;
+  }
+  getAsymmetricKeyDetails() {
+    return undefined;
+  }
+}
+export class SecretKeyObject extends KeyObject {
+  constructor(handle) {
+    super('secret', handle);
+  }
+
+  // get symmetricKeySize() {
+  //   return this.handle.getSymmetricKeySize();
+  // }
+
+  export(options) {
+    if (options?.format === 'pem' || options?.format === 'jwk') {
+      throw new Error(`SecretKey export for ${options.format} is not supported`);
+    }
+    const key = this.handle.exportKey();
+    return Buffer.from(key);
+  }
+}
+
+// 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;
+// }
+
+export class AsymmetricKeyObject extends KeyObject {
+  constructor(type, handle) {
+    super(type, handle);
+  }
+  get asymmetricKeyType() {
+    if (!this._asymmetricKeyType) {
+      this._asymmetricKeyType = this.handle.getAsymmetricKeyType();
+    }
+    return this._asymmetricKeyType;
+  }
+  get asymmetricKeyDetails() {
+    if (!this._asymmetricKeyDetails) {
+      this._asymmetricKeyDetails = this.handle.keyDetail();
+    }
+    return this._asymmetricKeyDetails;
+  }
+  get namedCurve() {
+    return this.asymmetricKeyDetails?.namedCurve;
+  }
+}
+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');
+    }
+    const {
+      format,
+      type
+    } = parsePublicKeyEncoding(options, this.asymmetricKeyType);
+    const key = this.handle.exportKey(format, type);
+    const buffer = Buffer.from(key);
+    if (options?.format === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
+  }
+}
+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');
+    }
+    const {
+      format,
+      type,
+      cipher,
+      passphrase
+    } = parsePrivateKeyEncoding(options, this.asymmetricKeyType);
+    const key = this.handle.exportKey(format, type, cipher, passphrase);
+    const buffer = Buffer.from(key);
+    if (options?.format === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
+  }
+}
+//# sourceMappingURL=classes.js.map

package/lib/module/keys/classes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Buffer","NitroModules","KeyType","KFormatType","KeyEncoding","parsePrivateKeyEncoding","parsePublicKeyEncoding","CryptoKey","constructor","keyObject","keyAlgorithm","keyUsages","keyExtractable","inspect","_depth","_options","Error","type","extractable","algorithm","usages","KeyObject","export","handleOrKey","ArrayBuffer","handle","createHybridObject","keyType","PUBLIC","PRIVATE","SECRET","init","createKeyObject","key","format","encoding","kFormat","DER","PEM","kEncoding","SPKI","PKCS8","SEC1","getAsymmetricKeyType","PublicKeyObject","PrivateKeyObject","SecretKeyObject","undefined","getAsymmetricKeyDetails","options","exportKey","from","AsymmetricKeyObject","asymmetricKeyType","_asymmetricKeyType","asymmetricKeyDetails","_asymmetricKeyDetails","keyDetail","namedCurve","buffer","toString","passphrase","cipher"],"sourceRoot":"../../../src","sources":["keys/classes.ts"],"mappings":";;AAAA,SAASA,MAAM,QAAQ,QAAQ;AAC/B,SAASC,YAAY,QAAQ,4BAA4B;AASzD,SAASC,OAAO,EAAEC,WAAW,EAAEC,WAAW,QAAQ,UAAU;AAC5D,SAASC,uBAAuB,EAAEC,sBAAsB,QAAQ,SAAS;AAEzE,OAAO,MAAMC,SAAS,CAAC;EAMrBC,WAAWA,CACTC,SAAoB,EACpBC,YAA6B,EAC7BC,SAAqB,EACrBC,cAAuB,EACvB;IACA,IAAI,CAACH,SAAS,GAAGA,SAAS;IAC1B,IAAI,CAACC,YAAY,GAAGA,YAAY;IAChC,IAAI,CAACC,SAAS,GAAGA,SAAS;IAC1B,IAAI,CAACC,cAAc,GAAGA,cAAc;EACtC;EACA;EACAC,OAAOA,CAACC,MAAc,EAAEC,QAAiB,EAAW;IAClD,MAAM,IAAIC,KAAK,CAAC,sCAAsC,CAAC;IACvD;;IAEA;IACA;IACA;IACA;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;EACF;EAEA,IAAIC,IAAIA,CAAA,EAAG;IACT;IACA,OAAO,IAAI,CAACR,SAAS,CAACQ,IAAI;EAC5B;EAEA,IAAIC,WAAWA,CAAA,EAAG;IAChB,OAAO,IAAI,CAACN,cAAc;EAC5B;EAEA,IAAIO,SAASA,CAAA,EAAG;IACd,OAAO,IAAI,CAACT,YAAY;EAC1B;EAEA,IAAIU,MAAMA,CAAA,EAAG;IACX,OAAO,IAAI,CAACT,SAAS;EACvB;AACF;AAEA,OAAO,MAAMU,SAAS,CAAC;EAOrB;EACAC,MAAMA,CAACP,QAA0B,EAAmB;IAClD;IACA,MAAM,IAAIC,KAAK,CAAC,4CAA4C,CAAC;EAC/D;EAIAR,WAAWA,CAACS,IAAY,EAAEM,WAA0C,EAAE;IACpE,IAAIN,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,SAAS,EAC9D,MAAM,IAAID,KAAK,CAAC,2BAA2BC,IAAI,EAAE,CAAC;IAEpD,IAAIM,WAAW,YAAYC,WAAW,EAAE;MACtC,IAAI,CAACC,MAAM,GAAGxB,YAAY,CAACyB,kBAAkB,CAAC,iBAAiB,CAAC;MAChE,IAAIC,OAAgB;MACpB,QAAQV,IAAI;QACV,KAAK,QAAQ;UACXU,OAAO,GAAGzB,OAAO,CAAC0B,MAAM;UACxB;QACF,KAAK,SAAS;UACZD,OAAO,GAAGzB,OAAO,CAAC2B,OAAO;UACzB;QACF,KAAK,QAAQ;UACXF,OAAO,GAAGzB,OAAO,CAAC4B,MAAM;UACxB;QACF;UACE;UACA,MAAM,IAAId,KAAK,CAAC,kBAAkB,CAAC;MACvC;MACA,IAAI,CAACS,MAAM,CAACM,IAAI,CAACJ,OAAO,EAAEJ,WAAW,CAAC;IACxC,CAAC,MAAM;MACL,IAAI,CAACE,MAAM,GAAGF,WAAW;IAC3B;IACA,IAAI,CAACN,IAAI,GAAGA,IAAuC;EACrD;;EAEA;EACA;EACA;EACA;EACA;;EAEA,OAAOe,eAAeA,CACpBf,IAAY,EACZgB,GAAgB,EAChBC,MAAsB,EACtBC,QAAoC,EACzB;IACX,IAAIlB,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,SAAS,EAC9D,MAAM,IAAID,KAAK,CAAC,2BAA2BC,IAAI,EAAE,CAAC;IAEpD,MAAMQ,MAAM,GAAGxB,YAAY,CAACyB,kBAAkB,CAC5C,iBACF,CAAoB;IACpB,IAAIC,OAAgB;IACpB,QAAQV,IAAI;MACV,KAAK,QAAQ;QACXU,OAAO,GAAGzB,OAAO,CAAC0B,MAAM;QACxB;MACF,KAAK,SAAS;QACZD,OAAO,GAAGzB,OAAO,CAAC2B,OAAO;QACzB;MACF,KAAK,QAAQ;QACXF,OAAO,GAAGzB,OAAO,CAAC4B,MAAM;QACxB;MACF;QACE,MAAM,IAAId,KAAK,CAAC,kBAAkB,CAAC;IACvC;;IAEA;IACA,IACEkB,MAAM,IACNC,QAAQ,KACPR,OAAO,KAAKzB,OAAO,CAAC0B,MAAM,IAAID,OAAO,KAAKzB,OAAO,CAAC2B,OAAO,CAAC,EAC3D;MACA,MAAMO,OAAO,GAAGF,MAAM,KAAK,KAAK,GAAG/B,WAAW,CAACkC,GAAG,GAAGlC,WAAW,CAACmC,GAAG;MACpE,MAAMC,SAAS,GACbJ,QAAQ,KAAK,MAAM,GACf/B,WAAW,CAACoC,IAAI,GAChBL,QAAQ,KAAK,OAAO,GAClB/B,WAAW,CAACqC,KAAK,GACjBN,QAAQ,KAAK,MAAM,GACjB/B,WAAW,CAACsC,IAAI,GAChBtC,WAAW,CAACsC,IAAI;MAC1BjB,MAAM,CAACM,IAAI,CAACJ,OAAO,EAAEM,GAAG,EAAEG,OAAO,EAAEG,SAAS,CAAC;IAC/C,CAAC,MAAM;MACLd,MAAM,CAACM,IAAI,CAACJ,OAAO,EAAEM,GAAG,CAAC;IAC3B;;IAEA;IACA,IAAIhB,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,SAAS,EAAE;MAC3C,IAAI;QACFQ,MAAM,CAACkB,oBAAoB,CAAC,CAAC;QAC7B;QACA,IAAI1B,IAAI,KAAK,QAAQ,EAAE;UACrB,OAAO,IAAI2B,eAAe,CAACnB,MAAM,CAAC;QACpC,CAAC,MAAM;UACL,OAAO,IAAIoB,gBAAgB,CAACpB,MAAM,CAAC;QACrC;MACF,CAAC,CAAC,MAAM;QACN;MAAA;IAEJ;;IAEA;IACA,IAAIR,IAAI,KAAK,QAAQ,EAAE;MACrB,OAAO,IAAI6B,eAAe,CAACrB,MAAM,CAAC;IACpC;;IAEA;IACA,OAAO,IAAIJ,SAAS,CAACJ,IAAI,EAAEQ,MAAM,CAAC;EACpC;EAEAkB,oBAAoBA,CAAA,EAAc;IAChC,OAAOI,SAAS;EAClB;EAEAC,uBAAuBA,CAAA,EAAc;IACnC,OAAOD,SAAS;EAClB;AACF;AAEA,OAAO,MAAMD,eAAe,SAASzB,SAAS,CAAC;EAC7Cb,WAAWA,CAACiB,MAAuB,EAAE;IACnC,KAAK,CAAC,QAAQ,EAAEA,MAAM,CAAC;EACzB;;EAEA;EACA;EACA;;EAMAH,MAAMA,CAAC2B,OAAyB,EAAU;IACxC,IAAIA,OAAO,EAAEf,MAAM,KAAK,KAAK,IAAIe,OAAO,EAAEf,MAAM,KAAK,KAAK,EAAE;MAC1D,MAAM,IAAIlB,KAAK,CACb,wBAAwBiC,OAAO,CAACf,MAAM,mBACxC,CAAC;IACH;IACA,MAAMD,GAAG,GAAG,IAAI,CAACR,MAAM,CAACyB,SAAS,CAAC,CAAC;IACnC,OAAOlD,MAAM,CAACmD,IAAI,CAAClB,GAAG,CAAC;EACzB;AACF;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO,MAAMmB,mBAAmB,SAAS/B,SAAS,CAAC;EACjDb,WAAWA,CAACS,IAAY,EAAEQ,MAAuB,EAAE;IACjD,KAAK,CAACR,IAAI,EAAEQ,MAAM,CAAC;EACrB;EAIA,IAAI4B,iBAAiBA,CAAA,EAAsB;IACzC,IAAI,CAAC,IAAI,CAACC,kBAAkB,EAAE;MAC5B,IAAI,CAACA,kBAAkB,GAAG,IAAI,CAAC7B,MAAM,CAACkB,oBAAoB,CAAC,CAAC;IAC9D;IACA,OAAO,IAAI,CAACW,kBAAkB;EAChC;EAIA,IAAIC,oBAAoBA,CAAA,EAAG;IACzB,IAAI,CAAC,IAAI,CAACC,qBAAqB,EAAE;MAC/B,IAAI,CAACA,qBAAqB,GAAG,IAAI,CAAC/B,MAAM,CAACgC,SAAS,CAAC,CAAC;IACtD;IACA,OAAO,IAAI,CAACD,qBAAqB;EACnC;EAEA,IAAIE,UAAUA,CAAA,EAAuB;IACnC,OAAO,IAAI,CAACH,oBAAoB,EAAEG,UAAU;EAC9C;AACF;AAEA,OAAO,MAAMd,eAAe,SAASQ,mBAAmB,CAAC;EACvD5C,WAAWA,CAACiB,MAAuB,EAAE;IACnC,KAAK,CAAC,QAAQ,EAAEA,MAAM,CAAC;EACzB;EAKAH,MAAMA,CAAC2B,OAAwB,EAAmB;IAChD,IAAIA,OAAO,EAAEf,MAAM,KAAK,KAAK,EAAE;MAC7B,MAAM,IAAIlB,KAAK,CAAC,6CAA6C,CAAC;IAChE;IACA,MAAM;MAAEkB,MAAM;MAAEjB;IAAK,CAAC,GAAGX,sBAAsB,CAC7C2C,OAAO,EACP,IAAI,CAACI,iBACP,CAAC;IACD,MAAMpB,GAAG,GAAG,IAAI,CAACR,MAAM,CAACyB,SAAS,CAAChB,MAAM,EAAEjB,IAAI,CAAC;IAC/C,MAAM0C,MAAM,GAAG3D,MAAM,CAACmD,IAAI,CAAClB,GAAG,CAAC;IAC/B,IAAIgB,OAAO,EAAEf,MAAM,KAAK,KAAK,EAAE;MAC7B,OAAOyB,MAAM,CAACC,QAAQ,CAAC,OAAO,CAAC;IACjC;IACA,OAAOD,MAAM;EACf;AACF;AAEA,OAAO,MAAMd,gBAAgB,SAASO,mBAAmB,CAAC;EACxD5C,WAAWA,CAACiB,MAAuB,EAAE;IACnC,KAAK,CAAC,SAAS,EAAEA,MAAM,CAAC;EAC1B;EAKAH,MAAMA,CAAC2B,OAAwB,EAAmB;IAChD,IAAIA,OAAO,EAAEf,MAAM,KAAK,KAAK,EAAE;MAC7B,IAAIe,OAAO,CAACY,UAAU,KAAKd,SAAS,EAAE;QACpC,MAAM,IAAI/B,KAAK,CAAC,iCAAiC,CAAC;MACpD;MACA,MAAM,IAAIA,KAAK,CAAC,8CAA8C,CAAC;IACjE;IACA,MAAM;MAAEkB,MAAM;MAAEjB,IAAI;MAAE6C,MAAM;MAAED;IAAW,CAAC,GAAGxD,uBAAuB,CAClE4C,OAAO,EACP,IAAI,CAACI,iBACP,CAAC;IACD,MAAMpB,GAAG,GAAG,IAAI,CAACR,MAAM,CAACyB,SAAS,CAAChB,MAAM,EAAEjB,IAAI,EAAE6C,MAAM,EAAED,UAAU,CAAC;IACnE,MAAMF,MAAM,GAAG3D,MAAM,CAACmD,IAAI,CAAClB,GAAG,CAAC;IAC/B,IAAIgB,OAAO,EAAEf,MAAM,KAAK,KAAK,EAAE;MAC7B,OAAOyB,MAAM,CAACC,QAAQ,CAAC,OAAO,CAAC;IACjC;IACA,OAAOD,MAAM;EACf;AACF","ignoreList":[]}

package/lib/module/keys/generateKeyPair.js

@@ -0,0 +1,96 @@
+"use strict";
+
+import { ed_generateKeyPair } from '../ed';
+import { kEmptyObject, validateFunction } from '../utils';
+import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+export const generateKeyPair = (type, options, callback) => {
+  validateFunction(callback);
+  internalGenerateKeyPair(true, type, options, callback);
+};
+
+// Promisify generateKeyPair
+// (attempted to use util.promisify, to no avail)
+export const generateKeyPairPromise = (type, options) => {
+  return new Promise((resolve, reject) => {
+    generateKeyPair(type, options, (err, publicKey, privateKey) => {
+      if (err) {
+        reject([err, undefined]);
+      } else {
+        resolve([undefined, {
+          publicKey,
+          privateKey
+        }]);
+      }
+    });
+  });
+};
+
+// generateKeyPairSync
+
+export function generateKeyPairSync(type, options) {
+  const [err, publicKey, privateKey] = internalGenerateKeyPair(false, type, options, undefined);
+  if (err) {
+    throw err;
+  }
+  return {
+    publicKey,
+    privateKey
+  };
+}
+function parseKeyPairEncoding(keyType, options = kEmptyObject) {
+  const {
+    publicKeyEncoding,
+    privateKeyEncoding
+  } = options;
+  let publicFormat, publicType;
+  if (publicKeyEncoding == null) {
+    publicFormat = publicType = -1;
+  } else if (typeof publicKeyEncoding === 'object') {
+    ({
+      format: publicFormat,
+      type: publicType
+    } = parsePublicKeyEncoding(publicKeyEncoding, keyType, 'publicKeyEncoding'));
+  } else {
+    throw new Error('Invalid argument options.publicKeyEncoding', publicKeyEncoding);
+  }
+  let privateFormat, privateType, cipher, passphrase;
+  if (privateKeyEncoding == null) {
+    privateFormat = privateType = -1;
+  } else if (typeof privateKeyEncoding === 'object') {
+    ({
+      format: privateFormat,
+      type: privateType,
+      cipher,
+      passphrase
+    } = parsePrivateKeyEncoding(privateKeyEncoding, keyType, 'privateKeyEncoding'));
+  } else {
+    throw new Error('Invalid argument options.privateKeyEncoding', publicKeyEncoding);
+  }
+  return {
+    publicFormat,
+    publicType,
+    privateFormat,
+    privateType,
+    cipher,
+    passphrase
+  };
+}
+function internalGenerateKeyPair(isAsync, type, options, callback) {
+  const encoding = parseKeyPairEncoding(type, options);
+  switch (type) {
+    case 'ed25519':
+    case 'ed448':
+    case 'x25519':
+    case 'x448':
+      return ed_generateKeyPair(isAsync, type, encoding, callback);
+    default:
+    // fall through
+  }
+  const err = new Error(`
+    Invalid Argument options: '${type}' scheme not supported for
+    generateKeyPair(). Currently not all encryption methods are supported in
+    this library.  Check docs/implementation_coverage.md for status.
+  `);
+  return [err, undefined, undefined];
+}
+//# sourceMappingURL=generateKeyPair.js.map

package/lib/module/keys/generateKeyPair.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ed_generateKeyPair","kEmptyObject","validateFunction","parsePrivateKeyEncoding","parsePublicKeyEncoding","generateKeyPair","type","options","callback","internalGenerateKeyPair","generateKeyPairPromise","Promise","resolve","reject","err","publicKey","privateKey","undefined","generateKeyPairSync","parseKeyPairEncoding","keyType","publicKeyEncoding","privateKeyEncoding","publicFormat","publicType","format","Error","privateFormat","privateType","cipher","passphrase","isAsync","encoding"],"sourceRoot":"../../../src","sources":["keys/generateKeyPair.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/keys/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import { AsymmetricKeyObject, CryptoKey, KeyObject, SecretKeyObject, PublicKeyObject, PrivateKeyObject } from './classes';
+import { generateKeyPair, generateKeyPairSync } from './generateKeyPair';
+// import { sign, verify } from './signVerify';
+import { isCryptoKey, parseKeyEncoding, parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+import { binaryLikeToArrayBuffer as toAB } from '../utils';
+function createSecretKey(key) {
+  const keyBuffer = toAB(key);
+  return KeyObject.createKeyObject('secret', keyBuffer);
+}
+export {
+// Node Public API
+createSecretKey,
+// createPublicKey,
+// createPrivateKey,
+CryptoKey, generateKeyPair, generateKeyPairSync, AsymmetricKeyObject, KeyObject,
+// InternalCryptoKey,
+// sign,
+// verify,
+
+// Node Internal API
+parsePublicKeyEncoding, parsePrivateKeyEncoding, parseKeyEncoding,
+// preparePrivateKey,
+// preparePublicOrPrivateKey,
+// prepareSecretKey,
+SecretKeyObject, PublicKeyObject, PrivateKeyObject,
+// isKeyObject,
+isCryptoKey
+// importGenericSecretKey,
+};
+//# sourceMappingURL=index.js.map

package/lib/module/keys/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AsymmetricKeyObject","CryptoKey","KeyObject","SecretKeyObject","PublicKeyObject","PrivateKeyObject","generateKeyPair","generateKeyPairSync","isCryptoKey","parseKeyEncoding","parsePrivateKeyEncoding","parsePublicKeyEncoding","binaryLikeToArrayBuffer","toAB","createSecretKey","key","keyBuffer","createKeyObject"],"sourceRoot":"../../../src","sources":["keys/index.ts"],"mappings":";;AAAA,SACEA,mBAAmB,EACnBC,SAAS,EACTC,SAAS,EACTC,eAAe,EACfC,eAAe,EACfC,gBAAgB,QACX,WAAW;AAClB,SAASC,eAAe,EAAEC,mBAAmB,QAAQ,mBAAmB;AACxE;AACA,SACEC,WAAW,EACXC,gBAAgB,EAChBC,uBAAuB,EACvBC,sBAAsB,QACjB,SAAS;AAEhB,SAASC,uBAAuB,IAAIC,IAAI,QAAQ,UAAU;AAE1D,SAASC,eAAeA,CAACC,GAAe,EAAmB;EACzD,MAAMC,SAAS,GAAGH,IAAI,CAACE,GAAG,CAAC;EAC3B,OAAOb,SAAS,CAACe,eAAe,CAAC,QAAQ,EAAED,SAAS,CAAC;AACvD;AAEA;AACE;AACAF,eAAe;AACf;AACA;AACAb,SAAS,EACTK,eAAe,EACfC,mBAAmB,EACnBP,mBAAmB,EACnBE,SAAS;AACT;AACA;AACA;;AAEA;AACAS,sBAAsB,EACtBD,uBAAuB,EACvBD,gBAAgB;AAChB;AACA;AACA;AACAN,eAAe,EACfC,eAAe,EACfC,gBAAgB;AAChB;AACAG;AACA;AAAA","ignoreList":[]}

package/lib/module/keys/signVerify.js

@@ -0,0 +1,41 @@
+// import { KeyObject, PublicKeyObject, PrivateKeyObject } from '.';
+// import { ed25519 } from '../ed25519';
+// import type {
+//   BinaryLike,
+//   BinaryLikeNode,
+//   SignCallback,
+//   VerifyCallback,
+// } from '../utils';
+
+// export function sign(
+//   algorithm: string | null | undefined,
+//   data: BinaryLike,
+//   key: BinaryLikeNode | KeyObject,
+//   callback: SignCallback,
+// ): ArrayBuffer {
+//   console.log('sign  ', algorithm, data, key, callback);
+//   return new ArrayBuffer(32);
+// }
+
+// export function verify(
+//   algorithm: string | null | undefined,
+//   data: BinaryLike,
+//   key: BinaryLikeNode | KeyObject,
+//   signature: ArrayBuffer,
+//   callback: VerifyCallback,
+// ): boolean {
+//   if (!algorithm) {
+//     if (key instanceof PublicKeyObject) {
+//       switch (key.asymmetricKeyType) {
+//         case 'ed25519':
+//         case 'ed448':
+//         case 'x25519':
+//         case 'x448': {
+//           return ed25519.verify(signature, data, key);
+//         }
+//     }
+//   }
+//   throw new Error('Verify not implemented', algorithm, data, key, signature, callback);
+// }
+"use strict";
+//# sourceMappingURL=signVerify.js.map

package/lib/module/keys/signVerify.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["keys/signVerify.ts"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA","ignoreList":[]}

package/lib/module/keys/utils.js

@@ -0,0 +1,114 @@
+"use strict";
+
+import { binaryLikeToArrayBuffer, isStringOrBuffer, KeyEncoding, KFormatType } from '../utils';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isCryptoKey = obj => {
+  return obj !== null && obj?.keyObject !== undefined;
+};
+export function getCryptoKeyPair(key) {
+  if ('publicKey' in key && 'privateKey' in key) return key;
+  throw new Error('Invalid CryptoKeyPair');
+}
+
+/**
+ * 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
+ * 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);
+}
+export 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.DER && (type === KeyEncoding.PKCS1 || type === KeyEncoding.SEC1)) {
+          throw new Error(`Incompatible key options ${encodingNames[type]} does not support encryption`);
+        }
+      } else if (passphrase !== undefined) {
+        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,
+    type,
+    cipher,
+    passphrase
+  };
+}
+const encodingNames = {
+  [KeyEncoding.PKCS1]: 'pkcs1',
+  [KeyEncoding.PKCS8]: 'pkcs8',
+  [KeyEncoding.SPKI]: 'spki',
+  [KeyEncoding.SEC1]: '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.PEM;else if (formatStr === 'der') return KFormatType.DER;else if (formatStr === 'jwk') return KFormatType.JWK;
+  throw new Error(`Invalid key format str: ${optionName}`);
+}
+function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
+  if (typeStr === undefined && !required) {
+    return undefined;
+  } else if (typeStr === 'pkcs1') {
+    if (keyType !== undefined && keyType !== 'rsa') {
+      throw new Error(`Crypto incompatible key options: ${typeStr} can only be used for RSA keys`);
+    }
+    return KeyEncoding.PKCS1;
+  } else if (typeStr === 'spki' && isPublic !== false) {
+    return KeyEncoding.SPKI;
+  } else if (typeStr === 'pkcs8' && isPublic !== true) {
+    return KeyEncoding.PKCS8;
+  } else if (typeStr === 'sec1' && isPublic !== true) {
+    if (keyType !== undefined && keyType !== 'ec') {
+      throw new Error(`Incompatible key options ${typeStr} can only be used for EC keys`);
+    }
+    return KeyEncoding.SEC1;
+  }
+  throw new Error(`Invalid option ${optionName} - ${typeStr}`);
+}
+function parseKeyFormatAndType(enc, keyType, isPublic, objName) {
+  const {
+    format: formatStr,
+    type: typeStr
+  } = enc;
+  const isInput = keyType === undefined;
+  const format = parseKeyFormat(formatStr, isInput ? KFormatType.PEM : undefined, option('format', objName));
+  const isRequired = (!isInput || format === KFormatType.DER) && format !== KFormatType.JWK;
+  const type = parseKeyType(typeStr, isRequired, keyType, isPublic, option('type', objName));
+  return {
+    format,
+    type
+  };
+}
+//# sourceMappingURL=utils.js.map

package/lib/module/keys/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["binaryLikeToArrayBuffer","isStringOrBuffer","KeyEncoding","KFormatType","isCryptoKey","obj","keyObject","undefined","getCryptoKeyPair","key","Error","parsePublicKeyEncoding","enc","keyType","objName","parseKeyEncoding","parsePrivateKeyEncoding","isPublic","isInput","format","type","parseKeyFormatAndType","cipher","passphrase","encoding","option","DER","PKCS1","SEC1","encodingNames","PKCS8","SPKI","name","parseKeyFormat","formatStr","defaultFormat","optionName","PEM","JWK","parseKeyType","typeStr","required","isRequired"],"sourceRoot":"../../../src","sources":["keys/utils.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/pbkdf2.js

@@ -0,0 +1,83 @@
+"use strict";
+
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { NitroModules } from 'react-native-nitro-modules';
+import { HashContext, binaryLikeToArrayBuffer, bufferLikeToArrayBuffer, lazyDOMException, normalizeHashName } from './utils';
+import { promisify } from 'util';
+const WRONG_PASS = 'Password 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`;
+// to use native bits in sub-functions, use getNative(). don't call it at top-level!
+let native;
+function getNative() {
+  if (native == null) {
+    // lazy-load the Nitro HybridObject
+    native = NitroModules.createHybridObject('Pbkdf2');
+  }
+  return native;
+}
+function sanitizeInput(input, errorMsg) {
+  try {
+    return binaryLikeToArrayBuffer(input);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (_e) {
+    throw new Error(errorMsg);
+  }
+}
+export function pbkdf2(password, salt, iterations, keylen, digest, callback) {
+  if (callback === undefined || typeof callback !== 'function') {
+    throw new Error('No callback provided to pbkdf2');
+  }
+  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
+  const sanitizedSalt = sanitizeInput(salt, WRONG_SALT);
+  const normalizedDigest = normalizeHashName(digest, HashContext.Node);
+  getNative();
+  native.pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, normalizedDigest).then(res => {
+    callback(null, Buffer.from(res));
+  }, e => {
+    callback(e);
+  });
+}
+export function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
+  const sanitizedSalt = sanitizeInput(salt, WRONG_SALT);
+  const algo = digest ? normalizeHashName(digest, HashContext.Node) : 'sha1';
+  getNative();
+  const result = native.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);
+  const 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

@@ -0,0 +1 @@
+{"version":3,"names":["Buffer","NitroModules","HashContext","binaryLikeToArrayBuffer","bufferLikeToArrayBuffer","lazyDOMException","normalizeHashName","promisify","WRONG_PASS","WRONG_SALT","native","getNative","createHybridObject","sanitizeInput","input","errorMsg","_e","Error","pbkdf2","password","salt","iterations","keylen","digest","callback","undefined","sanitizedPassword","sanitizedSalt","normalizedDigest","Node","then","res","from","e","pbkdf2Sync","algo","result","pbkdf2WithDigest","pbkdf2Promise","pbkdf2DeriveBits","algorithm","baseKey","length","hash","normalizedHash","raw","keyObject","export"],"sourceRoot":"../../src","sources":["pbkdf2.ts"],"mappings":"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","ignoreList":[]}