@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/dist/module/keys/classes.js

@@ -0,0 +1,261 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Buffer } from 'buffer';
+import { NitroModules } from 'react-native-nitro-modules';
+import { KeyType } from '../utils';
+import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+export class CryptoKey {
+  get [Symbol.toStringTag]() {
+    return 'CryptoKey';
+  }
+  constructor(keyObject, keyAlgorithm, keyUsages, keyExtractable) {
+    _defineProperty(this, "keyObject", void 0);
+    _defineProperty(this, "keyAlgorithm", void 0);
+    _defineProperty(this, "keyUsages", void 0);
+    _defineProperty(this, "keyExtractable", void 0);
+    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 {
+  get [Symbol.toStringTag]() {
+    return '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');
+  }
+  equals(otherKeyObject) {
+    if (!(otherKeyObject instanceof KeyObject)) {
+      throw new TypeError('otherKeyObject must be a KeyObject');
+    }
+    return this.handle.keyEquals(otherKeyObject.handle);
+  }
+  constructor(type, handleOrKey) {
+    _defineProperty(this, "handle", void 0);
+    _defineProperty(this, "type", void 0);
+    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 (!(key instanceof CryptoKey)) {
+      throw new TypeError(`The "key" argument must be an instance of CryptoKey. Received ${typeof key}`);
+    }
+    return key.keyObject;
+  }
+  toCryptoKey(algorithm, extractable, keyUsages) {
+    return new CryptoKey(this, algorithm, keyUsages, extractable);
+  }
+  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 is provided, use it (encoding is optional)
+    if (format !== undefined) {
+      handle.init(keyType, key, format, encoding);
+    } 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 === null || options === void 0 ? void 0 : options.format) === 'pem' || (options === null || options === void 0 ? void 0 : 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);
+    _defineProperty(this, "_asymmetricKeyType", void 0);
+    _defineProperty(this, "_asymmetricKeyDetails", void 0);
+  }
+  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() {
+    var _this$asymmetricKeyDe;
+    return (_this$asymmetricKeyDe = this.asymmetricKeyDetails) === null || _this$asymmetricKeyDe === void 0 ? void 0 : _this$asymmetricKeyDe.namedCurve;
+  }
+}
+export class PublicKeyObject extends AsymmetricKeyObject {
+  constructor(handle) {
+    super('public', handle);
+  }
+  export(options) {
+    if ((options === null || options === void 0 ? void 0 : options.format) === 'jwk') {
+      return this.handle.exportJwk({}, false);
+    }
+    const {
+      format,
+      type
+    } = parsePublicKeyEncoding(options, this.asymmetricKeyType);
+    const key = this.handle.exportKey(format, type);
+    const buffer = Buffer.from(key);
+    if ((options === null || options === void 0 ? void 0 : options.format) === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
+  }
+}
+export class PrivateKeyObject extends AsymmetricKeyObject {
+  constructor(handle) {
+    super('private', handle);
+  }
+  export(options) {
+    if ((options === null || options === void 0 ? void 0 : options.format) === 'jwk') {
+      if (options.passphrase !== undefined) {
+        throw new Error('jwk does not support encryption');
+      }
+      return this.handle.exportJwk({}, false);
+    }
+    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 === null || options === void 0 ? void 0 : options.format) === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
+  }
+}
+//# sourceMappingURL=classes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Buffer","NitroModules","KeyType","parsePrivateKeyEncoding","parsePublicKeyEncoding","CryptoKey","Symbol","toStringTag","constructor","keyObject","keyAlgorithm","keyUsages","keyExtractable","_defineProperty","inspect","_depth","_options","Error","type","extractable","algorithm","usages","KeyObject","export","equals","otherKeyObject","TypeError","handle","keyEquals","handleOrKey","ArrayBuffer","createHybridObject","keyType","PUBLIC","PRIVATE","SECRET","init","from","key","toCryptoKey","createKeyObject","format","encoding","undefined","getAsymmetricKeyType","PublicKeyObject","PrivateKeyObject","SecretKeyObject","getAsymmetricKeyDetails","symmetricKeySize","getSymmetricKeySize","options","exportKey","AsymmetricKeyObject","asymmetricKeyType","_asymmetricKeyType","asymmetricKeyDetails","_asymmetricKeyDetails","keyDetail","namedCurve","_this$asymmetricKeyDe","exportJwk","buffer","toString","passphrase","cipher"],"sources":["classes.ts"],"sourcesContent":["import { Buffer } from 'buffer';\r\nimport { NitroModules } from 'react-native-nitro-modules';\r\nimport type {\r\n  AsymmetricKeyType,\r\n  EncodingOptions,\r\n  JWK,\r\n  KeyDetail,\r\n  KeyObjectHandle,\r\n  KeyUsage,\r\n  SubtleAlgorithm,\r\n} from '../utils';\r\nimport { KeyType, KFormatType, KeyEncoding } from '../utils';\r\nimport { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';\r\n\r\nexport class CryptoKey {\r\n  keyObject: KeyObject;\r\n  keyAlgorithm: SubtleAlgorithm;\r\n  keyUsages: KeyUsage[];\r\n  keyExtractable: boolean;\r\n\r\n  get [Symbol.toStringTag](): string {\r\n    return 'CryptoKey';\r\n  }\r\n\r\n  constructor(\r\n    keyObject: KeyObject,\r\n    keyAlgorithm: SubtleAlgorithm,\r\n    keyUsages: KeyUsage[],\r\n    keyExtractable: boolean,\r\n  ) {\r\n    this.keyObject = keyObject;\r\n    this.keyAlgorithm = keyAlgorithm;\r\n    this.keyUsages = keyUsages;\r\n    this.keyExtractable = keyExtractable;\r\n  }\r\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n  inspect(_depth: number, _options: unknown): unknown {\r\n    throw new Error('CryptoKey.inspect is not implemented');\r\n    // if (depth < 0) return this;\r\n\r\n    // const opts = {\r\n    //   ...options,\r\n    //   depth: options.depth == null ? null : options.depth - 1,\r\n    // };\r\n\r\n    // return `CryptoKey ${inspect(\r\n    //   {\r\n    //     type: this.type,\r\n    //     extractable: this.extractable,\r\n    //     algorithm: this.algorithm,\r\n    //     usages: this.usages,\r\n    //   },\r\n    //   opts\r\n    // )}`;\r\n  }\r\n\r\n  get type() {\r\n    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');\r\n    return this.keyObject.type;\r\n  }\r\n\r\n  get extractable() {\r\n    return this.keyExtractable;\r\n  }\r\n\r\n  get algorithm() {\r\n    return this.keyAlgorithm;\r\n  }\r\n\r\n  get usages() {\r\n    return this.keyUsages;\r\n  }\r\n}\r\n\r\nexport class KeyObject {\r\n  handle: KeyObjectHandle;\r\n  type: 'public' | 'secret' | 'private';\r\n\r\n  get [Symbol.toStringTag](): string {\r\n    return 'KeyObject';\r\n  }\r\n\r\n  export(options: { format: 'pem' } & EncodingOptions): string | Buffer;\r\n  export(options?: { format: 'der' } & EncodingOptions): Buffer;\r\n  export(options?: { format: 'jwk' } & EncodingOptions): JWK;\r\n  export(options?: EncodingOptions): string | Buffer | JWK;\r\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n  export(_options?: EncodingOptions): string | Buffer | JWK {\r\n    // This is a placeholder and should be overridden by subclasses.\r\n    throw new Error('export() must be implemented by subclasses');\r\n  }\r\n\r\n  equals(otherKeyObject: KeyObject): boolean {\r\n    if (!(otherKeyObject instanceof KeyObject)) {\r\n      throw new TypeError('otherKeyObject must be a KeyObject');\r\n    }\r\n    return this.handle.keyEquals(otherKeyObject.handle);\r\n  }\r\n\r\n  constructor(type: string, handle: KeyObjectHandle);\r\n  constructor(type: string, key: ArrayBuffer);\r\n  constructor(type: string, handleOrKey: KeyObjectHandle | ArrayBuffer) {\r\n    if (type !== 'secret' && type !== 'public' && type !== 'private')\r\n      throw new Error(`invalid KeyObject type: ${type}`);\r\n\r\n    if (handleOrKey instanceof ArrayBuffer) {\r\n      this.handle = NitroModules.createHybridObject('KeyObjectHandle');\r\n      let keyType: KeyType;\r\n      switch (type) {\r\n        case 'public':\r\n          keyType = KeyType.PUBLIC;\r\n          break;\r\n        case 'private':\r\n          keyType = KeyType.PRIVATE;\r\n          break;\r\n        case 'secret':\r\n          keyType = KeyType.SECRET;\r\n          break;\r\n        default:\r\n          // Should not happen\r\n          throw new Error('invalid key type');\r\n      }\r\n      this.handle.init(keyType, handleOrKey);\r\n    } else {\r\n      this.handle = handleOrKey;\r\n    }\r\n    this.type = type as 'public' | 'secret' | 'private';\r\n  }\r\n\r\n  static from(key: CryptoKey): KeyObject {\r\n    if (!(key instanceof CryptoKey)) {\r\n      throw new TypeError(\r\n        `The \"key\" argument must be an instance of CryptoKey. Received ${typeof key}`,\r\n      );\r\n    }\r\n    return key.keyObject;\r\n  }\r\n\r\n  toCryptoKey(\r\n    algorithm: SubtleAlgorithm,\r\n    extractable: boolean,\r\n    keyUsages: KeyUsage[],\r\n  ): CryptoKey {\r\n    return new CryptoKey(this, algorithm, keyUsages, extractable);\r\n  }\r\n\r\n  static createKeyObject(\r\n    type: string,\r\n    key: ArrayBuffer,\r\n    format?: KFormatType,\r\n    encoding?: KeyEncoding,\r\n  ): KeyObject {\r\n    if (type !== 'secret' && type !== 'public' && type !== 'private')\r\n      throw new Error(`invalid KeyObject type: ${type}`);\r\n\r\n    const handle = NitroModules.createHybridObject(\r\n      'KeyObjectHandle',\r\n    ) as KeyObjectHandle;\r\n    let keyType: KeyType;\r\n    switch (type) {\r\n      case 'public':\r\n        keyType = KeyType.PUBLIC;\r\n        break;\r\n      case 'private':\r\n        keyType = KeyType.PRIVATE;\r\n        break;\r\n      case 'secret':\r\n        keyType = KeyType.SECRET;\r\n        break;\r\n      default:\r\n        throw new Error('invalid key type');\r\n    }\r\n\r\n    // If format is provided, use it (encoding is optional)\r\n    if (format !== undefined) {\r\n      handle.init(keyType, key, format, encoding);\r\n    } else {\r\n      handle.init(keyType, key);\r\n    }\r\n\r\n    // For asymmetric keys, return the appropriate subclass\r\n    if (type === 'public' || type === 'private') {\r\n      try {\r\n        handle.getAsymmetricKeyType();\r\n        // If we get here, it's an asymmetric key - return the appropriate subclass\r\n        if (type === 'public') {\r\n          return new PublicKeyObject(handle);\r\n        } else {\r\n          return new PrivateKeyObject(handle);\r\n        }\r\n      } catch {\r\n        // Not an asymmetric key, fall through to regular KeyObject\r\n      }\r\n    }\r\n\r\n    // For secret keys, return SecretKeyObject\r\n    if (type === 'secret') {\r\n      return new SecretKeyObject(handle);\r\n    }\r\n\r\n    // Return regular KeyObject for symmetric keys or if asymmetric detection failed\r\n    return new KeyObject(type, handle);\r\n  }\r\n\r\n  getAsymmetricKeyType(): undefined {\r\n    return undefined;\r\n  }\r\n\r\n  getAsymmetricKeyDetails(): undefined {\r\n    return undefined;\r\n  }\r\n}\r\n\r\nexport class SecretKeyObject extends KeyObject {\r\n  constructor(handle: KeyObjectHandle) {\r\n    super('secret', handle);\r\n  }\r\n\r\n  get symmetricKeySize(): number {\r\n    return this.handle.getSymmetricKeySize();\r\n  }\r\n\r\n  export(options: { format: 'pem' } & EncodingOptions): never;\r\n  export(options: { format: 'der' } & EncodingOptions): Buffer;\r\n  export(options: { format: 'jwk' } & EncodingOptions): never;\r\n  export(options?: EncodingOptions): Buffer;\r\n  export(options?: EncodingOptions): Buffer {\r\n    if (options?.format === 'pem' || options?.format === 'jwk') {\r\n      throw new Error(\r\n        `SecretKey export for ${options.format} is not supported`,\r\n      );\r\n    }\r\n    const key = this.handle.exportKey();\r\n    return Buffer.from(key);\r\n  }\r\n}\r\n\r\n// const kAsymmetricKeyType = Symbol('kAsymmetricKeyType');\r\n// const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails');\r\n\r\n// function normalizeKeyDetails(details = {}) {\r\n//   if (details.publicExponent !== undefined) {\r\n//     return {\r\n//       ...details,\r\n//       publicExponent: bigIntArrayToUnsignedBigInt(\r\n//         new Uint8Array(details.publicExponent)\r\n//       ),\r\n//     };\r\n//   }\r\n//   return details;\r\n// }\r\n\r\nexport class AsymmetricKeyObject extends KeyObject {\r\n  constructor(type: string, handle: KeyObjectHandle) {\r\n    super(type, handle);\r\n  }\r\n\r\n  private _asymmetricKeyType?: AsymmetricKeyType;\r\n\r\n  get asymmetricKeyType(): AsymmetricKeyType {\r\n    if (!this._asymmetricKeyType) {\r\n      this._asymmetricKeyType = this.handle.getAsymmetricKeyType();\r\n    }\r\n    return this._asymmetricKeyType;\r\n  }\r\n\r\n  private _asymmetricKeyDetails?: KeyDetail;\r\n\r\n  get asymmetricKeyDetails() {\r\n    if (!this._asymmetricKeyDetails) {\r\n      this._asymmetricKeyDetails = this.handle.keyDetail();\r\n    }\r\n    return this._asymmetricKeyDetails;\r\n  }\r\n\r\n  get namedCurve(): string | undefined {\r\n    return this.asymmetricKeyDetails?.namedCurve;\r\n  }\r\n}\r\n\r\nexport class PublicKeyObject extends AsymmetricKeyObject {\r\n  constructor(handle: KeyObjectHandle) {\r\n    super('public', handle);\r\n  }\r\n\r\n  export(options: { format: 'pem' } & EncodingOptions): string;\r\n  export(options: { format: 'der' } & EncodingOptions): Buffer;\r\n  export(options: { format: 'jwk' } & EncodingOptions): JWK;\r\n  export(options: EncodingOptions): string | Buffer | JWK {\r\n    if (options?.format === 'jwk') {\r\n      return this.handle.exportJwk({}, false);\r\n    }\r\n    const { format, type } = parsePublicKeyEncoding(\r\n      options,\r\n      this.asymmetricKeyType,\r\n    );\r\n    const key = this.handle.exportKey(format, type);\r\n    const buffer = Buffer.from(key);\r\n    if (options?.format === 'pem') {\r\n      return buffer.toString('utf-8');\r\n    }\r\n    return buffer;\r\n  }\r\n}\r\n\r\nexport class PrivateKeyObject extends AsymmetricKeyObject {\r\n  constructor(handle: KeyObjectHandle) {\r\n    super('private', handle);\r\n  }\r\n\r\n  export(options: { format: 'pem' } & EncodingOptions): string;\r\n  export(options: { format: 'der' } & EncodingOptions): Buffer;\r\n  export(options: { format: 'jwk' } & EncodingOptions): JWK;\r\n  export(options: EncodingOptions): string | Buffer | JWK {\r\n    if (options?.format === 'jwk') {\r\n      if (options.passphrase !== undefined) {\r\n        throw new Error('jwk does not support encryption');\r\n      }\r\n      return this.handle.exportJwk({}, false);\r\n    }\r\n    const { format, type, cipher, passphrase } = parsePrivateKeyEncoding(\r\n      options,\r\n      this.asymmetricKeyType,\r\n    );\r\n    const key = this.handle.exportKey(format, type, cipher, passphrase);\r\n    const buffer = Buffer.from(key);\r\n    if (options?.format === 'pem') {\r\n      return buffer.toString('utf-8');\r\n    }\r\n    return buffer;\r\n  }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/module/keys/generateKeyPair.js

@@ -0,0 +1,148 @@
+import { ed_generateKeyPair } from '../ed';
+import { rsa_generateKeyPairNode, rsa_generateKeyPairNodeSync } from '../rsa';
+import { ec_generateKeyPairNode, ec_generateKeyPairNodeSync } from '../ec';
+import { dsa_generateKeyPairNode, dsa_generateKeyPairNodeSync } from '../dsa';
+import { dh_generateKeyPairNode, dh_generateKeyPairNodeSync } from '../dhKeyPair';
+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);
+    case 'rsa':
+    case 'rsa-pss':
+    case 'dsa':
+    case 'ec':
+    case 'dh':
+      break;
+    default:
+      {
+        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];
+      }
+  }
+  if (isAsync) {
+    const impl = async () => {
+      try {
+        let result;
+        if (type === 'rsa' || type === 'rsa-pss') {
+          result = await rsa_generateKeyPairNode(type, options, encoding);
+        } else if (type === 'ec') {
+          result = await ec_generateKeyPairNode(options, encoding);
+        } else if (type === 'dsa') {
+          result = await dsa_generateKeyPairNode(options, encoding);
+        } else if (type === 'dh') {
+          result = await dh_generateKeyPairNode(options, encoding);
+        } else {
+          throw new Error(`Unsupported key type: ${type}`);
+        }
+        return [undefined, result.publicKey, result.privateKey];
+      } catch (error) {
+        return [error, undefined, undefined];
+      }
+    };
+    impl().then(result => {
+      const [err, publicKey, privateKey] = result;
+      callback(err, publicKey, privateKey);
+    });
+    return;
+  }
+  try {
+    let result;
+    if (type === 'rsa' || type === 'rsa-pss') {
+      result = rsa_generateKeyPairNodeSync(type, options, encoding);
+    } else if (type === 'ec') {
+      result = ec_generateKeyPairNodeSync(options, encoding);
+    } else if (type === 'dsa') {
+      result = dsa_generateKeyPairNodeSync(options, encoding);
+    } else if (type === 'dh') {
+      result = dh_generateKeyPairNodeSync(options, encoding);
+    } else {
+      throw new Error(`Unsupported key type: ${type}`);
+    }
+    return [undefined, result.publicKey, result.privateKey];
+  } catch (error) {
+    return [error, undefined, undefined];
+  }
+}
+//# sourceMappingURL=generateKeyPair.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["ed_generateKeyPair","rsa_generateKeyPairNode","rsa_generateKeyPairNodeSync","ec_generateKeyPairNode","ec_generateKeyPairNodeSync","dsa_generateKeyPairNode","dsa_generateKeyPairNodeSync","dh_generateKeyPairNode","dh_generateKeyPairNodeSync","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","impl","result","error","then"],"sources":["generateKeyPair.ts"],"sourcesContent":["import { ed_generateKeyPair } from '../ed';\r\nimport { rsa_generateKeyPairNode, rsa_generateKeyPairNodeSync } from '../rsa';\r\nimport { ec_generateKeyPairNode, ec_generateKeyPairNodeSync } from '../ec';\r\nimport { dsa_generateKeyPairNode, dsa_generateKeyPairNodeSync } from '../dsa';\r\nimport {\r\n  dh_generateKeyPairNode,\r\n  dh_generateKeyPairNodeSync,\r\n} from '../dhKeyPair';\r\nimport {\r\n  kEmptyObject,\r\n  validateFunction,\r\n  type CryptoKeyPair,\r\n  type GenerateKeyPairCallback,\r\n  type GenerateKeyPairOptions,\r\n  type GenerateKeyPairPromiseReturn,\r\n  type GenerateKeyPairReturn,\r\n  type KeyPairGenConfig,\r\n  type KeyPairKey,\r\n  type KeyPairType,\r\n} from '../utils';\r\nimport { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';\r\n\r\nexport const generateKeyPair = (\r\n  type: KeyPairType,\r\n  options: GenerateKeyPairOptions,\r\n  callback: GenerateKeyPairCallback,\r\n): void => {\r\n  validateFunction(callback);\r\n  internalGenerateKeyPair(true, type, options, callback);\r\n};\r\n\r\n// Promisify generateKeyPair\r\n// (attempted to use util.promisify, to no avail)\r\nexport const generateKeyPairPromise = (\r\n  type: KeyPairType,\r\n  options: GenerateKeyPairOptions,\r\n): Promise<GenerateKeyPairPromiseReturn> => {\r\n  return new Promise((resolve, reject) => {\r\n    generateKeyPair(type, options, (err, publicKey, privateKey) => {\r\n      if (err) {\r\n        reject([err, undefined]);\r\n      } else {\r\n        resolve([undefined, { publicKey, privateKey }]);\r\n      }\r\n    });\r\n  });\r\n};\r\n\r\n// generateKeyPairSync\r\nexport function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;\r\nexport function generateKeyPairSync(\r\n  type: KeyPairType,\r\n  options: GenerateKeyPairOptions,\r\n): CryptoKeyPair;\r\nexport function generateKeyPairSync(\r\n  type: KeyPairType,\r\n  options?: GenerateKeyPairOptions,\r\n): CryptoKeyPair {\r\n  const [err, publicKey, privateKey] = internalGenerateKeyPair(\r\n    false,\r\n    type,\r\n    options,\r\n    undefined,\r\n  )!;\r\n\r\n  if (err) {\r\n    throw err;\r\n  }\r\n\r\n  return {\r\n    publicKey,\r\n    privateKey,\r\n  };\r\n}\r\n\r\nfunction parseKeyPairEncoding(\r\n  keyType: string,\r\n  options: GenerateKeyPairOptions = kEmptyObject,\r\n): KeyPairGenConfig {\r\n  const { publicKeyEncoding, privateKeyEncoding } = options;\r\n\r\n  let publicFormat, publicType;\r\n  if (publicKeyEncoding == null) {\r\n    publicFormat = publicType = -1;\r\n  } else if (typeof publicKeyEncoding === 'object') {\r\n    ({ format: publicFormat, type: publicType } = parsePublicKeyEncoding(\r\n      publicKeyEncoding,\r\n      keyType,\r\n      'publicKeyEncoding',\r\n    ));\r\n  } else {\r\n    throw new Error(\r\n      'Invalid argument options.publicKeyEncoding',\r\n      publicKeyEncoding,\r\n    );\r\n  }\r\n\r\n  let privateFormat, privateType, cipher, passphrase;\r\n  if (privateKeyEncoding == null) {\r\n    privateFormat = privateType = -1;\r\n  } else if (typeof privateKeyEncoding === 'object') {\r\n    ({\r\n      format: privateFormat,\r\n      type: privateType,\r\n      cipher,\r\n      passphrase,\r\n    } = parsePrivateKeyEncoding(\r\n      privateKeyEncoding,\r\n      keyType,\r\n      'privateKeyEncoding',\r\n    ));\r\n  } else {\r\n    throw new Error(\r\n      'Invalid argument options.privateKeyEncoding',\r\n      publicKeyEncoding as ErrorOptions,\r\n    );\r\n  }\r\n\r\n  return {\r\n    publicFormat,\r\n    publicType,\r\n    privateFormat,\r\n    privateType,\r\n    cipher,\r\n    passphrase,\r\n  };\r\n}\r\n\r\nfunction internalGenerateKeyPair(\r\n  isAsync: boolean,\r\n  type: KeyPairType,\r\n  options: GenerateKeyPairOptions | undefined,\r\n  callback: GenerateKeyPairCallback | undefined,\r\n): GenerateKeyPairReturn | void {\r\n  const encoding = parseKeyPairEncoding(type, options);\r\n\r\n  switch (type) {\r\n    case 'ed25519':\r\n    case 'ed448':\r\n    case 'x25519':\r\n    case 'x448':\r\n      return ed_generateKeyPair(isAsync, type, encoding, callback);\r\n    case 'rsa':\r\n    case 'rsa-pss':\r\n    case 'dsa':\r\n    case 'ec':\r\n    case 'dh':\r\n      break;\r\n    default: {\r\n      const err = new Error(`\r\n        Invalid Argument options: '${type}' scheme not supported for\r\n        generateKeyPair(). Currently not all encryption methods are supported in\r\n        this library.  Check docs/implementation_coverage.md for status.\r\n      `);\r\n      return [err, undefined, undefined];\r\n    }\r\n  }\r\n\r\n  if (isAsync) {\r\n    const impl = async (): Promise<GenerateKeyPairReturn> => {\r\n      try {\r\n        let result;\r\n        if (type === 'rsa' || type === 'rsa-pss') {\r\n          result = await rsa_generateKeyPairNode(type, options, encoding);\r\n        } else if (type === 'ec') {\r\n          result = await ec_generateKeyPairNode(options, encoding);\r\n        } else if (type === 'dsa') {\r\n          result = await dsa_generateKeyPairNode(options, encoding);\r\n        } else if (type === 'dh') {\r\n          result = await dh_generateKeyPairNode(options, encoding);\r\n        } else {\r\n          throw new Error(`Unsupported key type: ${type}`);\r\n        }\r\n        return [\r\n          undefined,\r\n          result.publicKey as KeyPairKey,\r\n          result.privateKey as KeyPairKey,\r\n        ];\r\n      } catch (error) {\r\n        return [error as Error, undefined, undefined];\r\n      }\r\n    };\r\n\r\n    impl().then(result => {\r\n      const [err, publicKey, privateKey] = result;\r\n      callback!(err, publicKey, privateKey);\r\n    });\r\n    return;\r\n  }\r\n\r\n  try {\r\n    let result;\r\n    if (type === 'rsa' || type === 'rsa-pss') {\r\n      result = rsa_generateKeyPairNodeSync(type, options, encoding);\r\n    } else if (type === 'ec') {\r\n      result = ec_generateKeyPairNodeSync(options, encoding);\r\n    } else if (type === 'dsa') {\r\n      result = dsa_generateKeyPairNodeSync(options, encoding);\r\n    } else if (type === 'dh') {\r\n      result = dh_generateKeyPairNodeSync(options, encoding);\r\n    } else {\r\n      throw new Error(`Unsupported key type: ${type}`);\r\n    }\r\n    return [\r\n      undefined,\r\n      result.publicKey as KeyPairKey,\r\n      result.privateKey as KeyPairKey,\r\n    ];\r\n  } catch (error) {\r\n    return [error as Error, undefined, undefined];\r\n  }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/module/keys/index.js

@@ -0,0 +1,190 @@
+import { AsymmetricKeyObject, CryptoKey, KeyObject, SecretKeyObject, PublicKeyObject, PrivateKeyObject } from './classes';
+import { generateKeyPair, generateKeyPairSync } from './generateKeyPair';
+import { createSign, createVerify, sign, verify, Sign, Verify } from './signVerify';
+import { publicEncrypt, publicDecrypt, privateEncrypt, privateDecrypt } from './publicCipher';
+import { isCryptoKey, parseKeyEncoding, parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+import { NitroModules } from 'react-native-nitro-modules';
+import { binaryLikeToArrayBuffer as toAB, isStringOrBuffer, KFormatType, KeyEncoding, KeyType } from '../utils';
+import { randomBytes } from '../random';
+function createSecretKey(key) {
+  const keyBuffer = toAB(key);
+  return KeyObject.createKeyObject('secret', keyBuffer);
+}
+function prepareAsymmetricKey(key, isPublic) {
+  if (key instanceof KeyObject) {
+    if (isPublic) {
+      // createPublicKey can accept either a public key or extract public from private
+      if (key.type === 'secret') {
+        throw new Error('Cannot create public key from secret key');
+      }
+      // Export as SPKI (public key format) - works for both public and private keys
+      const exported = key.handle.exportKey(KFormatType.DER, KeyEncoding.SPKI);
+      return {
+        data: exported,
+        format: 'der',
+        type: 'spki'
+      };
+    } else {
+      // createPrivateKey requires a private key
+      if (key.type !== 'private') {
+        throw new Error('Key must be a private key');
+      }
+      const exported = key.handle.exportKey(KFormatType.DER, KeyEncoding.PKCS8);
+      return {
+        data: exported,
+        format: 'der',
+        type: 'pkcs8'
+      };
+    }
+  }
+  if (isCryptoKey(key)) {
+    const cryptoKey = key;
+    return prepareAsymmetricKey(cryptoKey.keyObject, isPublic);
+  }
+  if (isStringOrBuffer(key)) {
+    // Detect PEM format from string content
+    const isPem = typeof key === 'string' && key.includes('-----BEGIN');
+    return {
+      data: toAB(key),
+      format: isPem ? 'pem' : undefined
+    };
+  }
+  if (typeof key === 'object' && 'key' in key) {
+    const keyObj = key;
+    const {
+      key: data,
+      format,
+      type
+    } = keyObj;
+    if (data instanceof KeyObject) {
+      return prepareAsymmetricKey(data, isPublic);
+    }
+    if (isCryptoKey(data)) {
+      return prepareAsymmetricKey(data.keyObject, isPublic);
+    }
+    if (!isStringOrBuffer(data)) {
+      throw new Error('Invalid key data type');
+    }
+
+    // For PEM format with string data, convert to ArrayBuffer
+    if ((format === 'pem' || typeof data === 'string' && data.includes('-----BEGIN')) && typeof data === 'string') {
+      return {
+        data: toAB(data),
+        format: 'pem',
+        type
+      };
+    }
+
+    // Filter out 'jwk' format - only 'pem' and 'der' are supported here
+    const filteredFormat = format === 'jwk' ? undefined : format;
+    return {
+      data: toAB(data),
+      format: filteredFormat,
+      type
+    };
+  }
+  throw new Error('Invalid key input');
+}
+function createPublicKey(key) {
+  if (typeof key === 'object' && 'key' in key && key.format === 'jwk') {
+    const handle = NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(key.key);
+    if (keyType === undefined) {
+      throw new Error('Failed to import JWK');
+    }
+    if (keyType === KeyType.PRIVATE) {
+      // Extract public from private
+      const exported = handle.exportKey(KFormatType.DER, KeyEncoding.SPKI);
+      const pubHandle = NitroModules.createHybridObject('KeyObjectHandle');
+      pubHandle.init(KeyType.PUBLIC, exported, KFormatType.DER, KeyEncoding.SPKI);
+      return new PublicKeyObject(pubHandle);
+    }
+    return new PublicKeyObject(handle);
+  }
+  const {
+    data,
+    format,
+    type
+  } = prepareAsymmetricKey(key, true);
+
+  // Map format string to KFormatType enum
+  let kFormat;
+  if (format === 'pem') kFormat = KFormatType.PEM;else if (format === 'der') kFormat = KFormatType.DER;
+
+  // Map type string to KeyEncoding enum
+  let kType;
+  if (type === 'spki') kType = KeyEncoding.SPKI;else if (type === 'pkcs1') kType = KeyEncoding.PKCS1;
+  return KeyObject.createKeyObject('public', data, kFormat, kType);
+}
+function createPrivateKey(key) {
+  if (typeof key === 'object' && 'key' in key && key.format === 'jwk') {
+    const handle = NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(key.key);
+    if (keyType === undefined || keyType !== KeyType.PRIVATE) {
+      throw new Error('Failed to import private key from JWK');
+    }
+    return new PrivateKeyObject(handle);
+  }
+  const {
+    data,
+    format,
+    type
+  } = prepareAsymmetricKey(key, false);
+
+  // Map format string to KFormatType enum
+  let kFormat;
+  if (format === 'pem') kFormat = KFormatType.PEM;else if (format === 'der') kFormat = KFormatType.DER;
+
+  // Map type string to KeyEncoding enum
+  let kType;
+  if (type === 'pkcs8') kType = KeyEncoding.PKCS8;else if (type === 'pkcs1') kType = KeyEncoding.PKCS1;else if (type === 'sec1') kType = KeyEncoding.SEC1;
+  return KeyObject.createKeyObject('private', data, kFormat, kType);
+}
+function generateKeySync(type, options) {
+  if (typeof type !== 'string') {
+    throw new TypeError('The "type" argument must be a string');
+  }
+  if (typeof options !== 'object' || options === null) {
+    throw new TypeError('The "options" argument must be an object');
+  }
+  const {
+    length
+  } = options;
+  if (typeof length !== 'number' || !Number.isInteger(length)) {
+    throw new TypeError('The "options.length" property must be an integer');
+  }
+  switch (type) {
+    case 'hmac':
+      if (length < 8 || length > 2 ** 31 - 1) {
+        throw new RangeError('The "options.length" property must be >= 8 and <= 2147483647');
+      }
+      break;
+    case 'aes':
+      if (length !== 128 && length !== 192 && length !== 256) {
+        throw new RangeError('The "options.length" property must be 128, 192, or 256');
+      }
+      break;
+    default:
+      throw new TypeError(`The "type" argument must be 'aes' or 'hmac'. Received '${type}'`);
+  }
+  const keyBytes = length / 8;
+  const keyMaterial = randomBytes(keyBytes);
+  return createSecretKey(keyMaterial);
+}
+function generateKey(type, options, callback) {
+  if (typeof callback !== 'function') {
+    throw new TypeError('The "callback" argument must be a function');
+  }
+  try {
+    const key = generateKeySync(type, options);
+    process.nextTick(callback, null, key);
+  } catch (err) {
+    process.nextTick(callback, err);
+  }
+}
+export {
+// Node Public API
+createSecretKey, createPublicKey, createPrivateKey, CryptoKey, generateKey, generateKeySync, generateKeyPair, generateKeyPairSync, AsymmetricKeyObject, KeyObject, createSign, createVerify, sign, verify, Sign, Verify, publicEncrypt, publicDecrypt, privateEncrypt, privateDecrypt,
+// Node Internal API
+parsePublicKeyEncoding, parsePrivateKeyEncoding, parseKeyEncoding, SecretKeyObject, PublicKeyObject, PrivateKeyObject, isCryptoKey };
+//# sourceMappingURL=index.js.map