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

package/dist/module/dsa.js

@@ -0,0 +1,87 @@
+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 { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { KeyObject } from './keys/classes';
+import { KFormatType, KeyEncoding } from './utils';
+export class Dsa {
+  constructor(modulusLength, divisorLength) {
+    _defineProperty(this, "native", void 0);
+    this.native = NitroModules.createHybridObject('DsaKeyPair');
+    this.native.setModulusLength(modulusLength);
+    if (divisorLength !== undefined && divisorLength >= 0) {
+      this.native.setDivisorLength(divisorLength);
+    }
+  }
+  async generateKeyPair() {
+    await this.native.generateKeyPair();
+  }
+  generateKeyPairSync() {
+    this.native.generateKeyPairSync();
+  }
+}
+function dsa_prepareKeyGenParams(options) {
+  if (!options) {
+    throw new Error('Options are required for DSA key generation');
+  }
+  const {
+    modulusLength,
+    divisorLength
+  } = options;
+  if (!modulusLength || modulusLength <= 0) {
+    throw new Error('Invalid or missing modulusLength for DSA key generation');
+  }
+  return new Dsa(modulusLength, divisorLength);
+}
+function dsa_formatKeyPairOutput(dsa, encoding) {
+  const {
+    publicFormat,
+    privateFormat,
+    cipher,
+    passphrase
+  } = encoding;
+  const publicKeyData = dsa.native.getPublicKey();
+  const privateKeyData = dsa.native.getPrivateKey();
+  const pub = KeyObject.createKeyObject('public', publicKeyData, KFormatType.DER, KeyEncoding.SPKI);
+  const priv = KeyObject.createKeyObject('private', privateKeyData, KFormatType.DER, KeyEncoding.PKCS8);
+  let publicKey;
+  let privateKey;
+  if (publicFormat === -1) {
+    publicKey = pub;
+  } else {
+    const format = publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
+    const exported = pub.handle.exportKey(format, KeyEncoding.SPKI);
+    if (format === KFormatType.PEM) {
+      publicKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      publicKey = exported;
+    }
+  }
+  if (privateFormat === -1) {
+    privateKey = priv;
+  } else {
+    const format = privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
+    const exported = priv.handle.exportKey(format, KeyEncoding.PKCS8, cipher, passphrase);
+    if (format === KFormatType.PEM) {
+      privateKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      privateKey = exported;
+    }
+  }
+  return {
+    publicKey,
+    privateKey
+  };
+}
+export async function dsa_generateKeyPairNode(options, encoding) {
+  const dsa = dsa_prepareKeyGenParams(options);
+  await dsa.generateKeyPair();
+  return dsa_formatKeyPairOutput(dsa, encoding);
+}
+export function dsa_generateKeyPairNodeSync(options, encoding) {
+  const dsa = dsa_prepareKeyGenParams(options);
+  dsa.generateKeyPairSync();
+  return dsa_formatKeyPairOutput(dsa, encoding);
+}
+//# sourceMappingURL=dsa.js.map

package/dist/module/dsa.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","Buffer","KeyObject","KFormatType","KeyEncoding","Dsa","constructor","modulusLength","divisorLength","_defineProperty","native","createHybridObject","setModulusLength","undefined","setDivisorLength","generateKeyPair","generateKeyPairSync","dsa_prepareKeyGenParams","options","Error","dsa_formatKeyPairOutput","dsa","encoding","publicFormat","privateFormat","cipher","passphrase","publicKeyData","getPublicKey","privateKeyData","getPrivateKey","pub","createKeyObject","DER","SPKI","priv","PKCS8","publicKey","privateKey","format","PEM","exported","handle","exportKey","from","Uint8Array","toString","dsa_generateKeyPairNode","dsa_generateKeyPairNodeSync"],"sources":["dsa.ts"],"sourcesContent":["import { NitroModules } from 'react-native-nitro-modules';\r\nimport { Buffer } from '@craftzdog/react-native-buffer';\r\nimport { KeyObject, PublicKeyObject, PrivateKeyObject } from './keys/classes';\r\nimport type { DsaKeyPair } from './specs/v1/dsaKeyPair.nitro';\r\nimport type { GenerateKeyPairOptions, KeyPairGenConfig } from './utils/types';\r\nimport { KFormatType, KeyEncoding } from './utils';\r\n\r\nexport class Dsa {\r\n  native: DsaKeyPair;\r\n\r\n  constructor(modulusLength: number, divisorLength?: number) {\r\n    this.native = NitroModules.createHybridObject<DsaKeyPair>('DsaKeyPair');\r\n    this.native.setModulusLength(modulusLength);\r\n    if (divisorLength !== undefined && divisorLength >= 0) {\r\n      this.native.setDivisorLength(divisorLength);\r\n    }\r\n  }\r\n\r\n  async generateKeyPair(): Promise<void> {\r\n    await this.native.generateKeyPair();\r\n  }\r\n\r\n  generateKeyPairSync(): void {\r\n    this.native.generateKeyPairSync();\r\n  }\r\n}\r\n\r\nfunction dsa_prepareKeyGenParams(\r\n  options: GenerateKeyPairOptions | undefined,\r\n): Dsa {\r\n  if (!options) {\r\n    throw new Error('Options are required for DSA key generation');\r\n  }\r\n\r\n  const { modulusLength, divisorLength } = options;\r\n\r\n  if (!modulusLength || modulusLength <= 0) {\r\n    throw new Error('Invalid or missing modulusLength for DSA key generation');\r\n  }\r\n\r\n  return new Dsa(modulusLength, divisorLength);\r\n}\r\n\r\nfunction dsa_formatKeyPairOutput(\r\n  dsa: Dsa,\r\n  encoding: KeyPairGenConfig,\r\n): {\r\n  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n} {\r\n  const { publicFormat, privateFormat, cipher, passphrase } = encoding;\r\n\r\n  const publicKeyData = dsa.native.getPublicKey();\r\n  const privateKeyData = dsa.native.getPrivateKey();\r\n\r\n  const pub = KeyObject.createKeyObject(\r\n    'public',\r\n    publicKeyData,\r\n    KFormatType.DER,\r\n    KeyEncoding.SPKI,\r\n  ) as PublicKeyObject;\r\n\r\n  const priv = KeyObject.createKeyObject(\r\n    'private',\r\n    privateKeyData,\r\n    KFormatType.DER,\r\n    KeyEncoding.PKCS8,\r\n  ) as PrivateKeyObject;\r\n\r\n  let publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  let privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n\r\n  if (publicFormat === -1) {\r\n    publicKey = pub;\r\n  } else {\r\n    const format =\r\n      publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;\r\n    const exported = pub.handle.exportKey(format, KeyEncoding.SPKI);\r\n    if (format === KFormatType.PEM) {\r\n      publicKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');\r\n    } else {\r\n      publicKey = exported;\r\n    }\r\n  }\r\n\r\n  if (privateFormat === -1) {\r\n    privateKey = priv;\r\n  } else {\r\n    const format =\r\n      privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;\r\n    const exported = priv.handle.exportKey(\r\n      format,\r\n      KeyEncoding.PKCS8,\r\n      cipher,\r\n      passphrase,\r\n    );\r\n    if (format === KFormatType.PEM) {\r\n      privateKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');\r\n    } else {\r\n      privateKey = exported;\r\n    }\r\n  }\r\n\r\n  return { publicKey, privateKey };\r\n}\r\n\r\nexport async function dsa_generateKeyPairNode(\r\n  options: GenerateKeyPairOptions | undefined,\r\n  encoding: KeyPairGenConfig,\r\n): Promise<{\r\n  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n}> {\r\n  const dsa = dsa_prepareKeyGenParams(options);\r\n  await dsa.generateKeyPair();\r\n  return dsa_formatKeyPairOutput(dsa, encoding);\r\n}\r\n\r\nexport function dsa_generateKeyPairNodeSync(\r\n  options: GenerateKeyPairOptions | undefined,\r\n  encoding: KeyPairGenConfig,\r\n): {\r\n  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n} {\r\n  const dsa = dsa_prepareKeyGenParams(options);\r\n  dsa.generateKeyPairSync();\r\n  return dsa_formatKeyPairOutput(dsa, encoding);\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/module/ec.js

@@ -0,0 +1,354 @@
+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 { NitroModules } from 'react-native-nitro-modules';
+import { CryptoKey, KeyObject, PublicKeyObject, PrivateKeyObject } from './keys/classes';
+import { bufferLikeToArrayBuffer, getUsagesUnion, hasAnyNotIn, kNamedCurveAliases, lazyDOMException, normalizeHashName, HashContext, KeyEncoding, KFormatType } from './utils';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { ECDH } from './ecdh';
+class EcUtils {
+  static get native() {
+    if (!this._native) {
+      this._native = NitroModules.createHybridObject('EcKeyPair');
+    }
+    return this._native;
+  }
+  static getSupportedCurves() {
+    return this.native.getSupportedCurves();
+  }
+}
+_defineProperty(EcUtils, "_native", void 0);
+export function getCurves() {
+  return EcUtils.getSupportedCurves();
+}
+export class Ec {
+  constructor(curve) {
+    _defineProperty(this, "native", void 0);
+    this.native = NitroModules.createHybridObject('EcKeyPair');
+    this.native.setCurve(curve);
+  }
+  async generateKeyPair() {
+    await this.native.generateKeyPair();
+    return {
+      publicKey: this.native.getPublicKey(),
+      privateKey: this.native.getPrivateKey()
+    };
+  }
+  generateKeyPairSync() {
+    this.native.generateKeyPairSync();
+    return {
+      publicKey: this.native.getPublicKey(),
+      privateKey: this.native.getPrivateKey()
+    };
+  }
+}
+
+// WebCrypto API - only P-256, P-384, P-521 allowed per spec
+export function ecImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  const {
+    name,
+    namedCurve
+  } = algorithm;
+  if (!namedCurve || !kNamedCurveAliases[namedCurve]) {
+    throw lazyDOMException('Unrecognized namedCurve', 'NotSupportedError');
+  }
+
+  // Handle JWK format
+  if (format === 'jwk') {
+    const jwk = keyData;
+
+    // Validate JWK
+    if (jwk.kty !== 'EC') {
+      throw lazyDOMException('Invalid JWK "kty" Parameter', 'DataError');
+    }
+    if (jwk.crv !== namedCurve) {
+      throw lazyDOMException('JWK "crv" does not match the requested algorithm', 'DataError');
+    }
+
+    // Check use parameter if present
+    if (jwk.use !== undefined) {
+      const expectedUse = name === 'ECDH' ? 'enc' : 'sig';
+      if (jwk.use !== expectedUse) {
+        throw lazyDOMException('Invalid JWK "use" Parameter', 'DataError');
+      }
+    }
+
+    // Check alg parameter if present
+    if (jwk.alg !== undefined) {
+      let expectedAlg;
+      if (name === 'ECDSA') {
+        // Map namedCurve to expected ECDSA algorithm
+        expectedAlg = namedCurve === 'P-256' ? 'ES256' : namedCurve === 'P-384' ? 'ES384' : namedCurve === 'P-521' ? 'ES512' : undefined;
+      } else if (name === 'ECDH') {
+        // ECDH uses ECDH-ES algorithm
+        expectedAlg = 'ECDH-ES';
+      }
+      if (expectedAlg && jwk.alg !== undefined && jwk.alg !== expectedAlg) {
+        throw lazyDOMException('JWK "alg" does not match the requested algorithm', 'DataError');
+      }
+    }
+
+    // Import using C++ layer
+    const handle = NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(jwk, namedCurve);
+    if (keyType === undefined) {
+      throw lazyDOMException('Invalid JWK', 'DataError');
+    }
+
+    // Create the appropriate KeyObject based on type
+    let keyObject;
+    if (keyType === 1) {
+      keyObject = new PublicKeyObject(handle);
+    } else if (keyType === 2) {
+      keyObject = new PrivateKeyObject(handle);
+    } else {
+      throw lazyDOMException('Unexpected key type from JWK import', 'DataError');
+    }
+    return new CryptoKey(keyObject, algorithm, keyUsages, extractable);
+  }
+
+  // Handle binary formats (spki, pkcs8, raw)
+  if (format !== 'spki' && format !== 'pkcs8' && format !== 'raw') {
+    throw lazyDOMException(`Unsupported format: ${format}`, 'NotSupportedError');
+  }
+
+  // Determine expected key type based on format
+  const expectedKeyType = format === 'spki' || format === 'raw' ? 'public' : 'private';
+
+  // Validate usages for the key type
+  const isPublicKey = expectedKeyType === 'public';
+  let validUsages;
+  if (name === 'ECDSA') {
+    validUsages = isPublicKey ? ['verify'] : ['sign'];
+  } else if (name === 'ECDH') {
+    validUsages = isPublicKey ? [] : ['deriveKey', 'deriveBits'];
+  } else {
+    throw lazyDOMException('Unsupported algorithm', 'NotSupportedError');
+  }
+  if (hasAnyNotIn(keyUsages, validUsages)) {
+    throw lazyDOMException(`Unsupported key usage for a ${name} key`, 'SyntaxError');
+  }
+
+  // Convert keyData to ArrayBuffer
+  const keyBuffer = bufferLikeToArrayBuffer(keyData);
+
+  // Create KeyObject directly using the appropriate format
+  let keyObject;
+  if (format === 'raw') {
+    // Raw format is only for public keys - use specialized EC raw import
+    const handle = NitroModules.createHybridObject('KeyObjectHandle');
+    const curveAlias = kNamedCurveAliases[namedCurve];
+    // Only throw if initialization explicitly fails
+    if (!handle.initECRaw(curveAlias, keyBuffer)) {
+      throw lazyDOMException('Failed to import EC raw key', 'DataError');
+    }
+    keyObject = new PublicKeyObject(handle);
+  } else {
+    // Use standard DER import for spki/pkcs8
+    keyObject = KeyObject.createKeyObject(expectedKeyType, keyBuffer, KFormatType.DER, format === 'spki' ? KeyEncoding.SPKI : KeyEncoding.PKCS8);
+  }
+  return new CryptoKey(keyObject, algorithm, keyUsages, extractable);
+}
+
+// Node API
+export const ecdsaSignVerify = (key, data, {
+  hash
+}, signature) => {
+  const isSign = signature === undefined;
+  const expectedKeyType = isSign ? 'private' : 'public';
+  if (key.type !== expectedKeyType) {
+    throw lazyDOMException(`Key must be a ${expectedKeyType} key`, 'InvalidAccessError');
+  }
+  const hashName = typeof hash === 'string' ? hash : hash === null || hash === void 0 ? void 0 : hash.name;
+  if (!hashName) {
+    throw lazyDOMException('Hash algorithm is required for ECDSA', 'InvalidAccessError');
+  }
+
+  // Normalize hash algorithm name to WebCrypto format for C++ layer
+  const normalizedHashName = normalizeHashName(hashName, HashContext.WebCrypto);
+
+  // Create EC instance with the curve from the key
+  const namedCurve = key.algorithm.namedCurve;
+  const ec = new Ec(namedCurve);
+
+  // Extract and import the actual key data from the CryptoKey
+  // Export in DER format with appropriate encoding
+  const encoding = key.type === 'private' ? KeyEncoding.PKCS8 : KeyEncoding.SPKI;
+  const keyData = key.keyObject.handle.exportKey(KFormatType.DER, encoding);
+  const keyBuffer = bufferLikeToArrayBuffer(keyData);
+  ec.native.importKey('der', keyBuffer, key.algorithm.name, key.extractable, key.usages);
+  const dataBuffer = bufferLikeToArrayBuffer(data);
+  if (isSign) {
+    // Sign operation
+    return ec.native.sign(dataBuffer, normalizedHashName);
+  } else {
+    // Verify operation
+    const signatureBuffer = bufferLikeToArrayBuffer(signature);
+    return ec.native.verify(dataBuffer, signatureBuffer, normalizedHashName);
+  }
+};
+
+// WebCrypto API - only P-256, P-384, P-521 allowed per spec
+
+export async function ec_generateKeyPair(name, namedCurve, extractable, keyUsages,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_options // TODO: Implement format options support
+) {
+  // validation checks
+  if (!Object.keys(kNamedCurveAliases).includes(namedCurve || '')) {
+    throw lazyDOMException(`Unrecognized namedCurve '${namedCurve}'`, 'NotSupportedError');
+  }
+  switch (name) {
+    case 'ECDSA':
+      if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+        throw lazyDOMException('Unsupported key usage for an ECDSA key', 'SyntaxError');
+      }
+      break;
+    case 'ECDH':
+      if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {
+        throw lazyDOMException('Unsupported key usage for an ECDH key', 'SyntaxError');
+      }
+    // Fall through
+  }
+  const ec = new Ec(namedCurve);
+  await ec.generateKeyPair();
+  let publicUsages = [];
+  let privateUsages = [];
+  switch (name) {
+    case 'ECDSA':
+      publicUsages = getUsagesUnion(keyUsages, 'verify');
+      privateUsages = getUsagesUnion(keyUsages, 'sign');
+      break;
+    case 'ECDH':
+      publicUsages = [];
+      privateUsages = getUsagesUnion(keyUsages, 'deriveKey', 'deriveBits');
+      break;
+  }
+  const keyAlgorithm = {
+    name,
+    namedCurve: namedCurve
+  };
+
+  // Export keys directly from the EC key pair using the internal EVP_PKEY
+  // These methods export in DER format (SPKI for public, PKCS8 for private)
+  const publicKeyData = ec.native.getPublicKey();
+  const privateKeyData = ec.native.getPrivateKey();
+  const pub = KeyObject.createKeyObject('public', publicKeyData, KFormatType.DER, KeyEncoding.SPKI);
+  const publicKey = new CryptoKey(pub, keyAlgorithm, publicUsages, true);
+
+  // All keys are now exported in PKCS8 format for consistency
+  const priv = KeyObject.createKeyObject('private', privateKeyData, KFormatType.DER, KeyEncoding.PKCS8);
+  const privateKey = new CryptoKey(priv, keyAlgorithm, privateUsages, extractable);
+  return {
+    publicKey,
+    privateKey
+  };
+}
+function ec_prepareKeyGenParams(options) {
+  if (!options) {
+    throw new Error('Options are required for EC key generation');
+  }
+  const {
+    namedCurve
+  } = options;
+  if (!namedCurve) {
+    throw new Error('namedCurve is required for EC key generation');
+  }
+  return new Ec(namedCurve);
+}
+function ec_formatKeyPairOutput(ec, encoding) {
+  const {
+    publicFormat,
+    publicType,
+    privateFormat,
+    privateType,
+    cipher,
+    passphrase
+  } = encoding;
+  const publicKeyData = ec.native.getPublicKey();
+  const privateKeyData = ec.native.getPrivateKey();
+  const pub = KeyObject.createKeyObject('public', publicKeyData, KFormatType.DER, KeyEncoding.SPKI);
+  const priv = KeyObject.createKeyObject('private', privateKeyData, KFormatType.DER, KeyEncoding.PKCS8);
+  let publicKey;
+  let privateKey;
+  if (publicFormat === -1) {
+    publicKey = pub;
+  } else {
+    const format = publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
+    const keyEncoding = publicType === KeyEncoding.SPKI ? KeyEncoding.SPKI : KeyEncoding.SPKI;
+    const exported = pub.handle.exportKey(format, keyEncoding);
+    if (format === KFormatType.PEM) {
+      publicKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      publicKey = exported;
+    }
+  }
+  if (privateFormat === -1) {
+    privateKey = priv;
+  } else {
+    const format = privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
+    const keyEncoding = privateType === KeyEncoding.PKCS8 ? KeyEncoding.PKCS8 : privateType === KeyEncoding.SEC1 ? KeyEncoding.SEC1 : KeyEncoding.PKCS8;
+    const exported = priv.handle.exportKey(format, keyEncoding, cipher, passphrase);
+    if (format === KFormatType.PEM) {
+      privateKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      privateKey = exported;
+    }
+  }
+  return {
+    publicKey,
+    privateKey
+  };
+}
+export async function ec_generateKeyPairNode(options, encoding) {
+  const ec = ec_prepareKeyGenParams(options);
+  await ec.generateKeyPair();
+  return ec_formatKeyPairOutput(ec, encoding);
+}
+export function ec_generateKeyPairNodeSync(options, encoding) {
+  const ec = ec_prepareKeyGenParams(options);
+  ec.generateKeyPairSync();
+  return ec_formatKeyPairOutput(ec, encoding);
+}
+export function ecDeriveBits(algorithm, baseKey, length) {
+  const publicKey = algorithm.public;
+  if (!publicKey) {
+    throw new Error('Public key is required for ECDH derivation');
+  }
+  if (baseKey.algorithm.name !== publicKey.algorithm.name) {
+    throw new Error('Keys must be of the same algorithm');
+  }
+  if (baseKey.algorithm.namedCurve !== publicKey.algorithm.namedCurve) {
+    throw new Error('Keys must use the same curve');
+  }
+  const namedCurve = baseKey.algorithm.namedCurve;
+  if (!namedCurve) {
+    throw new Error('Curve name is missing');
+  }
+  const opensslCurve = kNamedCurveAliases[namedCurve];
+  const ecdh = new ECDH(opensslCurve);
+  const jwkPrivate = baseKey.keyObject.handle.exportJwk({}, false);
+  if (!jwkPrivate.d) throw new Error('Invalid private key');
+  const privateBytes = Buffer.from(jwkPrivate.d, 'base64url');
+  ecdh.setPrivateKey(privateBytes);
+  const jwkPublic = publicKey.keyObject.handle.exportJwk({}, false);
+  if (!jwkPublic.x || !jwkPublic.y) throw new Error('Invalid public key');
+  const x = Buffer.from(jwkPublic.x, 'base64url');
+  const y = Buffer.from(jwkPublic.y, 'base64url');
+  const publicBytes = Buffer.concat([Buffer.from([0x04]), x, y]);
+  const secret = ecdh.computeSecret(publicBytes);
+  const secretBuf = Buffer.from(secret);
+
+  // If length is null, return full secret
+  if (length === null) {
+    return secretBuf.buffer;
+  }
+
+  // If length is specified, truncate
+  const byteLength = Math.ceil(length / 8);
+  if (secretBuf.byteLength >= byteLength) {
+    return secretBuf.buffer.slice(secretBuf.byteOffset, secretBuf.byteOffset + byteLength);
+  }
+  throw new Error('Derived key is shorter than requested length');
+}
+//# sourceMappingURL=ec.js.map

package/dist/module/ec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","CryptoKey","KeyObject","PublicKeyObject","PrivateKeyObject","bufferLikeToArrayBuffer","getUsagesUnion","hasAnyNotIn","kNamedCurveAliases","lazyDOMException","normalizeHashName","HashContext","KeyEncoding","KFormatType","Buffer","ECDH","EcUtils","native","_native","createHybridObject","getSupportedCurves","_defineProperty","getCurves","Ec","constructor","curve","setCurve","generateKeyPair","publicKey","getPublicKey","privateKey","getPrivateKey","generateKeyPairSync","ecImportKey","format","keyData","algorithm","extractable","keyUsages","name","namedCurve","jwk","kty","crv","use","undefined","expectedUse","alg","expectedAlg","handle","keyType","initJwk","keyObject","expectedKeyType","isPublicKey","validUsages","keyBuffer","curveAlias","initECRaw","createKeyObject","DER","SPKI","PKCS8","ecdsaSignVerify","key","data","hash","signature","isSign","type","hashName","normalizedHashName","WebCrypto","ec","encoding","exportKey","importKey","usages","dataBuffer","sign","signatureBuffer","verify","ec_generateKeyPair","_options","Object","keys","includes","publicUsages","privateUsages","keyAlgorithm","publicKeyData","privateKeyData","pub","priv","ec_prepareKeyGenParams","options","Error","ec_formatKeyPairOutput","publicFormat","publicType","privateFormat","privateType","cipher","passphrase","PEM","keyEncoding","exported","from","Uint8Array","toString","SEC1","ec_generateKeyPairNode","ec_generateKeyPairNodeSync","ecDeriveBits","baseKey","length","public","opensslCurve","ecdh","jwkPrivate","exportJwk","d","privateBytes","setPrivateKey","jwkPublic","x","y","publicBytes","concat","secret","computeSecret","secretBuf","buffer","byteLength","Math","ceil","slice","byteOffset"],"sources":["ec.ts"],"sourcesContent":["import { NitroModules } from 'react-native-nitro-modules';\r\nimport type { EcKeyPair } from './specs/v1/ecKeyPair.nitro';\r\nimport type { KeyObjectHandle } from './specs/v1/keyObjectHandle.nitro';\r\nimport {\r\n  CryptoKey,\r\n  KeyObject,\r\n  PublicKeyObject,\r\n  PrivateKeyObject,\r\n} from './keys/classes';\r\nimport type {\r\n  CryptoKeyPair,\r\n  KeyPairOptions,\r\n  KeyUsage,\r\n  SubtleAlgorithm,\r\n  BufferLike,\r\n  BinaryLike,\r\n  JWK,\r\n  ImportFormat,\r\n  NamedCurve,\r\n  GenerateKeyPairOptions,\r\n  KeyPairGenConfig,\r\n} from './utils/types';\r\nimport {\r\n  bufferLikeToArrayBuffer,\r\n  getUsagesUnion,\r\n  hasAnyNotIn,\r\n  kNamedCurveAliases,\r\n  lazyDOMException,\r\n  normalizeHashName,\r\n  HashContext,\r\n  KeyEncoding,\r\n  KFormatType,\r\n} from './utils';\r\nimport { Buffer } from '@craftzdog/react-native-buffer';\r\nimport { ECDH } from './ecdh';\r\n\r\nclass EcUtils {\r\n  private static _native: EcKeyPair | undefined;\r\n  private static get native(): EcKeyPair {\r\n    if (!this._native) {\r\n      this._native = NitroModules.createHybridObject<EcKeyPair>('EcKeyPair');\r\n    }\r\n    return this._native;\r\n  }\r\n  public static getSupportedCurves(): string[] {\r\n    return this.native.getSupportedCurves();\r\n  }\r\n}\r\n\r\nexport function getCurves(): string[] {\r\n  return EcUtils.getSupportedCurves();\r\n}\r\n\r\nexport class Ec {\r\n  native: EcKeyPair;\r\n\r\n  constructor(curve: string) {\r\n    this.native = NitroModules.createHybridObject<EcKeyPair>('EcKeyPair');\r\n    this.native.setCurve(curve);\r\n  }\r\n\r\n  async generateKeyPair(): Promise<CryptoKeyPair> {\r\n    await this.native.generateKeyPair();\r\n    return {\r\n      publicKey: this.native.getPublicKey(),\r\n      privateKey: this.native.getPrivateKey(),\r\n    };\r\n  }\r\n\r\n  generateKeyPairSync(): CryptoKeyPair {\r\n    this.native.generateKeyPairSync();\r\n    return {\r\n      publicKey: this.native.getPublicKey(),\r\n      privateKey: this.native.getPrivateKey(),\r\n    };\r\n  }\r\n}\r\n\r\n// WebCrypto API - only P-256, P-384, P-521 allowed per spec\r\nexport function ecImportKey(\r\n  format: ImportFormat,\r\n  keyData: BufferLike | BinaryLike | JWK,\r\n  algorithm: SubtleAlgorithm,\r\n  extractable: boolean,\r\n  keyUsages: KeyUsage[],\r\n): CryptoKey {\r\n  const { name, namedCurve } = algorithm;\r\n\r\n  if (\r\n    !namedCurve ||\r\n    !kNamedCurveAliases[namedCurve as keyof typeof kNamedCurveAliases]\r\n  ) {\r\n    throw lazyDOMException('Unrecognized namedCurve', 'NotSupportedError');\r\n  }\r\n\r\n  // Handle JWK format\r\n  if (format === 'jwk') {\r\n    const jwk = keyData as JWK;\r\n\r\n    // Validate JWK\r\n    if (jwk.kty !== 'EC') {\r\n      throw lazyDOMException('Invalid JWK \"kty\" Parameter', 'DataError');\r\n    }\r\n\r\n    if (jwk.crv !== namedCurve) {\r\n      throw lazyDOMException(\r\n        'JWK \"crv\" does not match the requested algorithm',\r\n        'DataError',\r\n      );\r\n    }\r\n\r\n    // Check use parameter if present\r\n    if (jwk.use !== undefined) {\r\n      const expectedUse = name === 'ECDH' ? 'enc' : 'sig';\r\n      if (jwk.use !== expectedUse) {\r\n        throw lazyDOMException('Invalid JWK \"use\" Parameter', 'DataError');\r\n      }\r\n    }\r\n\r\n    // Check alg parameter if present\r\n    if (jwk.alg !== undefined) {\r\n      let expectedAlg: string | undefined;\r\n\r\n      if (name === 'ECDSA') {\r\n        // Map namedCurve to expected ECDSA algorithm\r\n        expectedAlg =\r\n          namedCurve === 'P-256'\r\n            ? 'ES256'\r\n            : namedCurve === 'P-384'\r\n              ? 'ES384'\r\n              : namedCurve === 'P-521'\r\n                ? 'ES512'\r\n                : undefined;\r\n      } else if (name === 'ECDH') {\r\n        // ECDH uses ECDH-ES algorithm\r\n        expectedAlg = 'ECDH-ES';\r\n      }\r\n\r\n      if (expectedAlg && jwk.alg !== undefined && jwk.alg !== expectedAlg) {\r\n        throw lazyDOMException(\r\n          'JWK \"alg\" does not match the requested algorithm',\r\n          'DataError',\r\n        );\r\n      }\r\n    }\r\n\r\n    // Import using C++ layer\r\n    const handle =\r\n      NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');\r\n    const keyType = handle.initJwk(jwk, namedCurve as NamedCurve);\r\n\r\n    if (keyType === undefined) {\r\n      throw lazyDOMException('Invalid JWK', 'DataError');\r\n    }\r\n\r\n    // Create the appropriate KeyObject based on type\r\n    let keyObject: KeyObject;\r\n    if (keyType === 1) {\r\n      keyObject = new PublicKeyObject(handle);\r\n    } else if (keyType === 2) {\r\n      keyObject = new PrivateKeyObject(handle);\r\n    } else {\r\n      throw lazyDOMException(\r\n        'Unexpected key type from JWK import',\r\n        'DataError',\r\n      );\r\n    }\r\n\r\n    return new CryptoKey(keyObject, algorithm, keyUsages, extractable);\r\n  }\r\n\r\n  // Handle binary formats (spki, pkcs8, raw)\r\n  if (format !== 'spki' && format !== 'pkcs8' && format !== 'raw') {\r\n    throw lazyDOMException(\r\n      `Unsupported format: ${format}`,\r\n      'NotSupportedError',\r\n    );\r\n  }\r\n\r\n  // Determine expected key type based on format\r\n  const expectedKeyType =\r\n    format === 'spki' || format === 'raw' ? 'public' : 'private';\r\n\r\n  // Validate usages for the key type\r\n  const isPublicKey = expectedKeyType === 'public';\r\n  let validUsages: KeyUsage[];\r\n\r\n  if (name === 'ECDSA') {\r\n    validUsages = isPublicKey ? ['verify'] : ['sign'];\r\n  } else if (name === 'ECDH') {\r\n    validUsages = isPublicKey ? [] : ['deriveKey', 'deriveBits'];\r\n  } else {\r\n    throw lazyDOMException('Unsupported algorithm', 'NotSupportedError');\r\n  }\r\n\r\n  if (hasAnyNotIn(keyUsages, validUsages)) {\r\n    throw lazyDOMException(\r\n      `Unsupported key usage for a ${name} key`,\r\n      'SyntaxError',\r\n    );\r\n  }\r\n\r\n  // Convert keyData to ArrayBuffer\r\n  const keyBuffer = bufferLikeToArrayBuffer(keyData as BufferLike);\r\n\r\n  // Create KeyObject directly using the appropriate format\r\n  let keyObject: KeyObject;\r\n\r\n  if (format === 'raw') {\r\n    // Raw format is only for public keys - use specialized EC raw import\r\n    const handle =\r\n      NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');\r\n    const curveAlias =\r\n      kNamedCurveAliases[namedCurve as keyof typeof kNamedCurveAliases];\r\n    // Only throw if initialization explicitly fails\r\n    if (!handle.initECRaw(curveAlias, keyBuffer)) {\r\n      throw lazyDOMException('Failed to import EC raw key', 'DataError');\r\n    }\r\n    keyObject = new PublicKeyObject(handle);\r\n  } else {\r\n    // Use standard DER import for spki/pkcs8\r\n    keyObject = KeyObject.createKeyObject(\r\n      expectedKeyType,\r\n      keyBuffer,\r\n      KFormatType.DER,\r\n      format === 'spki' ? KeyEncoding.SPKI : KeyEncoding.PKCS8,\r\n    );\r\n  }\r\n\r\n  return new CryptoKey(keyObject, algorithm, keyUsages, extractable);\r\n}\r\n\r\n// Node API\r\nexport const ecdsaSignVerify = (\r\n  key: CryptoKey,\r\n  data: BufferLike,\r\n  { hash }: SubtleAlgorithm,\r\n  signature?: BufferLike,\r\n): ArrayBuffer | boolean => {\r\n  const isSign = signature === undefined;\r\n  const expectedKeyType = isSign ? 'private' : 'public';\r\n\r\n  if (key.type !== expectedKeyType) {\r\n    throw lazyDOMException(\r\n      `Key must be a ${expectedKeyType} key`,\r\n      'InvalidAccessError',\r\n    );\r\n  }\r\n\r\n  const hashName = typeof hash === 'string' ? hash : hash?.name;\r\n\r\n  if (!hashName) {\r\n    throw lazyDOMException(\r\n      'Hash algorithm is required for ECDSA',\r\n      'InvalidAccessError',\r\n    );\r\n  }\r\n\r\n  // Normalize hash algorithm name to WebCrypto format for C++ layer\r\n  const normalizedHashName = normalizeHashName(hashName, HashContext.WebCrypto);\r\n\r\n  // Create EC instance with the curve from the key\r\n  const namedCurve = key.algorithm.namedCurve!;\r\n  const ec = new Ec(namedCurve);\r\n\r\n  // Extract and import the actual key data from the CryptoKey\r\n  // Export in DER format with appropriate encoding\r\n  const encoding =\r\n    key.type === 'private' ? KeyEncoding.PKCS8 : KeyEncoding.SPKI;\r\n  const keyData = key.keyObject.handle.exportKey(KFormatType.DER, encoding);\r\n  const keyBuffer = bufferLikeToArrayBuffer(keyData);\r\n  ec.native.importKey(\r\n    'der',\r\n    keyBuffer,\r\n    key.algorithm.name!,\r\n    key.extractable,\r\n    key.usages,\r\n  );\r\n\r\n  const dataBuffer = bufferLikeToArrayBuffer(data);\r\n\r\n  if (isSign) {\r\n    // Sign operation\r\n    return ec.native.sign(dataBuffer, normalizedHashName);\r\n  } else {\r\n    // Verify operation\r\n    const signatureBuffer = bufferLikeToArrayBuffer(signature!);\r\n    return ec.native.verify(dataBuffer, signatureBuffer, normalizedHashName);\r\n  }\r\n};\r\n\r\n// WebCrypto API - only P-256, P-384, P-521 allowed per spec\r\n\r\nexport async function ec_generateKeyPair(\r\n  name: string,\r\n  namedCurve: string,\r\n  extractable: boolean,\r\n  keyUsages: KeyUsage[],\r\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n  _options?: KeyPairOptions, // TODO: Implement format options support\r\n): Promise<CryptoKeyPair> {\r\n  // validation checks\r\n  if (!Object.keys(kNamedCurveAliases).includes(namedCurve || '')) {\r\n    throw lazyDOMException(\r\n      `Unrecognized namedCurve '${namedCurve}'`,\r\n      'NotSupportedError',\r\n    );\r\n  }\r\n\r\n  switch (name) {\r\n    case 'ECDSA':\r\n      if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {\r\n        throw lazyDOMException(\r\n          'Unsupported key usage for an ECDSA key',\r\n          'SyntaxError',\r\n        );\r\n      }\r\n      break;\r\n    case 'ECDH':\r\n      if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {\r\n        throw lazyDOMException(\r\n          'Unsupported key usage for an ECDH key',\r\n          'SyntaxError',\r\n        );\r\n      }\r\n    // Fall through\r\n  }\r\n\r\n  const ec = new Ec(namedCurve!);\r\n  await ec.generateKeyPair();\r\n\r\n  let publicUsages: KeyUsage[] = [];\r\n  let privateUsages: KeyUsage[] = [];\r\n  switch (name) {\r\n    case 'ECDSA':\r\n      publicUsages = getUsagesUnion(keyUsages, 'verify');\r\n      privateUsages = getUsagesUnion(keyUsages, 'sign');\r\n      break;\r\n    case 'ECDH':\r\n      publicUsages = [];\r\n      privateUsages = getUsagesUnion(keyUsages, 'deriveKey', 'deriveBits');\r\n      break;\r\n  }\r\n\r\n  const keyAlgorithm = { name, namedCurve: namedCurve! };\r\n\r\n  // Export keys directly from the EC key pair using the internal EVP_PKEY\r\n  // These methods export in DER format (SPKI for public, PKCS8 for private)\r\n  const publicKeyData = ec.native.getPublicKey();\r\n  const privateKeyData = ec.native.getPrivateKey();\r\n\r\n  const pub = KeyObject.createKeyObject(\r\n    'public',\r\n    publicKeyData,\r\n    KFormatType.DER,\r\n    KeyEncoding.SPKI,\r\n  ) as PublicKeyObject;\r\n  const publicKey = new CryptoKey(\r\n    pub,\r\n    keyAlgorithm as SubtleAlgorithm,\r\n    publicUsages,\r\n    true,\r\n  );\r\n\r\n  // All keys are now exported in PKCS8 format for consistency\r\n  const priv = KeyObject.createKeyObject(\r\n    'private',\r\n    privateKeyData,\r\n    KFormatType.DER,\r\n    KeyEncoding.PKCS8,\r\n  ) as PrivateKeyObject;\r\n  const privateKey = new CryptoKey(\r\n    priv,\r\n    keyAlgorithm as SubtleAlgorithm,\r\n    privateUsages,\r\n    extractable,\r\n  );\r\n\r\n  return { publicKey, privateKey };\r\n}\r\n\r\nfunction ec_prepareKeyGenParams(\r\n  options: GenerateKeyPairOptions | undefined,\r\n): Ec {\r\n  if (!options) {\r\n    throw new Error('Options are required for EC key generation');\r\n  }\r\n\r\n  const { namedCurve } = options as { namedCurve?: string };\r\n\r\n  if (!namedCurve) {\r\n    throw new Error('namedCurve is required for EC key generation');\r\n  }\r\n\r\n  return new Ec(namedCurve);\r\n}\r\n\r\nfunction ec_formatKeyPairOutput(\r\n  ec: Ec,\r\n  encoding: KeyPairGenConfig,\r\n): {\r\n  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n} {\r\n  const {\r\n    publicFormat,\r\n    publicType,\r\n    privateFormat,\r\n    privateType,\r\n    cipher,\r\n    passphrase,\r\n  } = encoding;\r\n\r\n  const publicKeyData = ec.native.getPublicKey();\r\n  const privateKeyData = ec.native.getPrivateKey();\r\n\r\n  const pub = KeyObject.createKeyObject(\r\n    'public',\r\n    publicKeyData,\r\n    KFormatType.DER,\r\n    KeyEncoding.SPKI,\r\n  ) as PublicKeyObject;\r\n\r\n  const priv = KeyObject.createKeyObject(\r\n    'private',\r\n    privateKeyData,\r\n    KFormatType.DER,\r\n    KeyEncoding.PKCS8,\r\n  ) as PrivateKeyObject;\r\n\r\n  let publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  let privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n\r\n  if (publicFormat === -1) {\r\n    publicKey = pub;\r\n  } else {\r\n    const format =\r\n      publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;\r\n    const keyEncoding =\r\n      publicType === KeyEncoding.SPKI ? KeyEncoding.SPKI : KeyEncoding.SPKI;\r\n    const exported = pub.handle.exportKey(format, keyEncoding);\r\n    if (format === KFormatType.PEM) {\r\n      publicKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');\r\n    } else {\r\n      publicKey = exported;\r\n    }\r\n  }\r\n\r\n  if (privateFormat === -1) {\r\n    privateKey = priv;\r\n  } else {\r\n    const format =\r\n      privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;\r\n    const keyEncoding =\r\n      privateType === KeyEncoding.PKCS8\r\n        ? KeyEncoding.PKCS8\r\n        : privateType === KeyEncoding.SEC1\r\n          ? KeyEncoding.SEC1\r\n          : KeyEncoding.PKCS8;\r\n    const exported = priv.handle.exportKey(\r\n      format,\r\n      keyEncoding,\r\n      cipher,\r\n      passphrase,\r\n    );\r\n    if (format === KFormatType.PEM) {\r\n      privateKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');\r\n    } else {\r\n      privateKey = exported;\r\n    }\r\n  }\r\n\r\n  return { publicKey, privateKey };\r\n}\r\n\r\nexport async function ec_generateKeyPairNode(\r\n  options: GenerateKeyPairOptions | undefined,\r\n  encoding: KeyPairGenConfig,\r\n): Promise<{\r\n  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n}> {\r\n  const ec = ec_prepareKeyGenParams(options);\r\n  await ec.generateKeyPair();\r\n  return ec_formatKeyPairOutput(ec, encoding);\r\n}\r\n\r\nexport function ec_generateKeyPairNodeSync(\r\n  options: GenerateKeyPairOptions | undefined,\r\n  encoding: KeyPairGenConfig,\r\n): {\r\n  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;\r\n  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;\r\n} {\r\n  const ec = ec_prepareKeyGenParams(options);\r\n  ec.generateKeyPairSync();\r\n  return ec_formatKeyPairOutput(ec, encoding);\r\n}\r\n\r\nexport function ecDeriveBits(\r\n  algorithm: SubtleAlgorithm,\r\n  baseKey: CryptoKey,\r\n  length: number | null,\r\n): ArrayBuffer {\r\n  const publicKey = algorithm.public;\r\n\r\n  if (!publicKey) {\r\n    throw new Error('Public key is required for ECDH derivation');\r\n  }\r\n\r\n  if (baseKey.algorithm.name !== publicKey.algorithm.name) {\r\n    throw new Error('Keys must be of the same algorithm');\r\n  }\r\n\r\n  if (baseKey.algorithm.namedCurve !== publicKey.algorithm.namedCurve) {\r\n    throw new Error('Keys must use the same curve');\r\n  }\r\n\r\n  const namedCurve = baseKey.algorithm.namedCurve;\r\n  if (!namedCurve) {\r\n    throw new Error('Curve name is missing');\r\n  }\r\n\r\n  const opensslCurve =\r\n    kNamedCurveAliases[namedCurve as keyof typeof kNamedCurveAliases];\r\n  const ecdh = new ECDH(opensslCurve);\r\n\r\n  const jwkPrivate = baseKey.keyObject.handle.exportJwk({}, false);\r\n  if (!jwkPrivate.d) throw new Error('Invalid private key');\r\n  const privateBytes = Buffer.from(jwkPrivate.d, 'base64url');\r\n  ecdh.setPrivateKey(privateBytes);\r\n\r\n  const jwkPublic = publicKey.keyObject.handle.exportJwk({}, false);\r\n  if (!jwkPublic.x || !jwkPublic.y) throw new Error('Invalid public key');\r\n  const x = Buffer.from(jwkPublic.x, 'base64url');\r\n  const y = Buffer.from(jwkPublic.y, 'base64url');\r\n  const publicBytes = Buffer.concat([Buffer.from([0x04]), x, y]);\r\n\r\n  const secret = ecdh.computeSecret(publicBytes);\r\n  const secretBuf = Buffer.from(secret);\r\n\r\n  // If length is null, return full secret\r\n  if (length === null) {\r\n    return secretBuf.buffer;\r\n  }\r\n\r\n  // If length is specified, truncate\r\n  const byteLength = Math.ceil(length / 8);\r\n  if (secretBuf.byteLength >= byteLength) {\r\n    return secretBuf.buffer.slice(\r\n      secretBuf.byteOffset,\r\n      secretBuf.byteOffset + byteLength,\r\n    ) as ArrayBuffer;\r\n  }\r\n\r\n  throw new Error('Derived key is shorter than requested length');\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/module/ecdh.js

@@ -0,0 +1,106 @@
+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 { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { toArrayBuffer } from './utils/conversion';
+const POINT_CONVERSION_COMPRESSED = 2;
+const POINT_CONVERSION_UNCOMPRESSED = 4;
+const POINT_CONVERSION_HYBRID = 6;
+export class ECDH {
+  static get convertKeyHybrid() {
+    if (!this._convertKeyHybrid) {
+      this._convertKeyHybrid = NitroModules.createHybridObject('ECDH');
+    }
+    return this._convertKeyHybrid;
+  }
+  constructor(curveName) {
+    _defineProperty(this, "_hybrid", void 0);
+    this._hybrid = NitroModules.createHybridObject('ECDH');
+    this._hybrid.init(curveName);
+  }
+  generateKeys() {
+    const key = this._hybrid.generateKeys();
+    return Buffer.from(key);
+  }
+  computeSecret(otherPublicKey, inputEncoding) {
+    let keyBuf;
+    if (Buffer.isBuffer(otherPublicKey)) {
+      keyBuf = otherPublicKey;
+    } else if (typeof otherPublicKey === 'string') {
+      keyBuf = Buffer.from(otherPublicKey, inputEncoding);
+    } else {
+      // Handle array view or other types if necessary, but Node.js typically expects Buffer or string + encoding
+      throw new TypeError('Invalid otherPublicKey type');
+    }
+
+    // ECDH.computeSecret in Node.js returns Buffer
+    const secret = this._hybrid.computeSecret(toArrayBuffer(keyBuf));
+    return Buffer.from(secret);
+  }
+  getPrivateKey() {
+    return Buffer.from(this._hybrid.getPrivateKey());
+  }
+  setPrivateKey(privateKey, encoding) {
+    let keyBuf;
+    if (Buffer.isBuffer(privateKey)) {
+      keyBuf = privateKey;
+    } else {
+      keyBuf = Buffer.from(privateKey, encoding);
+    }
+    this._hybrid.setPrivateKey(toArrayBuffer(keyBuf));
+  }
+  getPublicKey(encoding) {
+    // Node.js getPublicKey([encoding[, format]])
+    // If encoding is provided, returns string. If not, Buffer.
+    // Our C++ returns ArrayBuffer (Buffer).
+    // We ignore format for now as C++ implementation defaults to uncompressed.
+    const pub = Buffer.from(this._hybrid.getPublicKey());
+    if (encoding) {
+      return pub.toString(encoding);
+    }
+    return pub;
+  }
+  setPublicKey(publicKey, encoding) {
+    let keyBuf;
+    if (Buffer.isBuffer(publicKey)) {
+      keyBuf = publicKey;
+    } else {
+      keyBuf = Buffer.from(publicKey, encoding);
+    }
+    this._hybrid.setPublicKey(toArrayBuffer(keyBuf));
+  }
+  static convertKey(key, curve, inputEncoding, outputEncoding, format) {
+    let keyBuf;
+    if (Buffer.isBuffer(key)) {
+      keyBuf = key;
+    } else {
+      keyBuf = Buffer.from(key, inputEncoding);
+    }
+    let formatNum;
+    switch (format) {
+      case 'compressed':
+        formatNum = POINT_CONVERSION_COMPRESSED;
+        break;
+      case 'hybrid':
+        formatNum = POINT_CONVERSION_HYBRID;
+        break;
+      case 'uncompressed':
+      case undefined:
+        formatNum = POINT_CONVERSION_UNCOMPRESSED;
+        break;
+      default:
+        throw new TypeError(`Invalid point conversion format: ${format}`);
+    }
+    const result = Buffer.from(ECDH.convertKeyHybrid.convertKey(toArrayBuffer(keyBuf), curve, formatNum));
+    if (outputEncoding) {
+      return result.toString(outputEncoding);
+    }
+    return result;
+  }
+}
+_defineProperty(ECDH, "_convertKeyHybrid", void 0);
+export function createECDH(curveName) {
+  return new ECDH(curveName);
+}
+//# sourceMappingURL=ecdh.js.map

package/dist/module/ecdh.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","Buffer","toArrayBuffer","POINT_CONVERSION_COMPRESSED","POINT_CONVERSION_UNCOMPRESSED","POINT_CONVERSION_HYBRID","ECDH","convertKeyHybrid","_convertKeyHybrid","createHybridObject","constructor","curveName","_defineProperty","_hybrid","init","generateKeys","key","from","computeSecret","otherPublicKey","inputEncoding","keyBuf","isBuffer","TypeError","secret","getPrivateKey","setPrivateKey","privateKey","encoding","getPublicKey","pub","toString","setPublicKey","publicKey","convertKey","curve","outputEncoding","format","formatNum","undefined","result","createECDH"],"sources":["ecdh.ts"],"sourcesContent":["import { NitroModules } from 'react-native-nitro-modules';\r\nimport type { ECDH as ECDHInterface } from './specs/v1/ecdh.nitro';\r\nimport { Buffer } from '@craftzdog/react-native-buffer';\r\nimport { toArrayBuffer } from './utils/conversion';\r\n\r\nconst POINT_CONVERSION_COMPRESSED = 2;\r\nconst POINT_CONVERSION_UNCOMPRESSED = 4;\r\nconst POINT_CONVERSION_HYBRID = 6;\r\n\r\nexport class ECDH {\r\n  private static _convertKeyHybrid: ECDHInterface | undefined;\r\n  private static get convertKeyHybrid(): ECDHInterface {\r\n    if (!this._convertKeyHybrid) {\r\n      this._convertKeyHybrid =\r\n        NitroModules.createHybridObject<ECDHInterface>('ECDH');\r\n    }\r\n    return this._convertKeyHybrid;\r\n  }\r\n\r\n  private _hybrid: ECDHInterface;\r\n\r\n  constructor(curveName: string) {\r\n    this._hybrid = NitroModules.createHybridObject<ECDHInterface>('ECDH');\r\n    this._hybrid.init(curveName);\r\n  }\r\n\r\n  generateKeys(): Buffer {\r\n    const key = this._hybrid.generateKeys();\r\n    return Buffer.from(key);\r\n  }\r\n\r\n  computeSecret(\r\n    otherPublicKey: Buffer | string | { code: number; byteLength: number },\r\n    inputEncoding?: BufferEncoding,\r\n  ): Buffer {\r\n    let keyBuf: Buffer;\r\n    if (Buffer.isBuffer(otherPublicKey)) {\r\n      keyBuf = otherPublicKey;\r\n    } else if (typeof otherPublicKey === 'string') {\r\n      keyBuf = Buffer.from(otherPublicKey, inputEncoding);\r\n    } else {\r\n      // Handle array view or other types if necessary, but Node.js typically expects Buffer or string + encoding\r\n      throw new TypeError('Invalid otherPublicKey type');\r\n    }\r\n\r\n    // ECDH.computeSecret in Node.js returns Buffer\r\n    const secret = this._hybrid.computeSecret(toArrayBuffer(keyBuf));\r\n    return Buffer.from(secret);\r\n  }\r\n\r\n  getPrivateKey(): Buffer {\r\n    return Buffer.from(this._hybrid.getPrivateKey());\r\n  }\r\n\r\n  setPrivateKey(privateKey: Buffer | string, encoding?: BufferEncoding): void {\r\n    let keyBuf: Buffer;\r\n    if (Buffer.isBuffer(privateKey)) {\r\n      keyBuf = privateKey;\r\n    } else {\r\n      keyBuf = Buffer.from(privateKey, encoding);\r\n    }\r\n    this._hybrid.setPrivateKey(toArrayBuffer(keyBuf));\r\n  }\r\n\r\n  getPublicKey(encoding?: BufferEncoding): Buffer | string {\r\n    // Node.js getPublicKey([encoding[, format]])\r\n    // If encoding is provided, returns string. If not, Buffer.\r\n    // Our C++ returns ArrayBuffer (Buffer).\r\n    // We ignore format for now as C++ implementation defaults to uncompressed.\r\n    const pub = Buffer.from(this._hybrid.getPublicKey());\r\n    if (encoding) {\r\n      return pub.toString(encoding);\r\n    }\r\n    return pub;\r\n  }\r\n\r\n  setPublicKey(publicKey: Buffer | string, encoding?: BufferEncoding): void {\r\n    let keyBuf: Buffer;\r\n    if (Buffer.isBuffer(publicKey)) {\r\n      keyBuf = publicKey;\r\n    } else {\r\n      keyBuf = Buffer.from(publicKey, encoding);\r\n    }\r\n    this._hybrid.setPublicKey(toArrayBuffer(keyBuf));\r\n  }\r\n\r\n  static convertKey(\r\n    key: Buffer | string,\r\n    curve: string,\r\n    inputEncoding?: BufferEncoding,\r\n    outputEncoding?: BufferEncoding,\r\n    format?: 'uncompressed' | 'compressed' | 'hybrid',\r\n  ): Buffer | string {\r\n    let keyBuf: Buffer;\r\n    if (Buffer.isBuffer(key)) {\r\n      keyBuf = key;\r\n    } else {\r\n      keyBuf = Buffer.from(key, inputEncoding);\r\n    }\r\n\r\n    let formatNum: number;\r\n    switch (format) {\r\n      case 'compressed':\r\n        formatNum = POINT_CONVERSION_COMPRESSED;\r\n        break;\r\n      case 'hybrid':\r\n        formatNum = POINT_CONVERSION_HYBRID;\r\n        break;\r\n      case 'uncompressed':\r\n      case undefined:\r\n        formatNum = POINT_CONVERSION_UNCOMPRESSED;\r\n        break;\r\n      default:\r\n        throw new TypeError(\r\n          `Invalid point conversion format: ${format as string}`,\r\n        );\r\n    }\r\n\r\n    const result = Buffer.from(\r\n      ECDH.convertKeyHybrid.convertKey(toArrayBuffer(keyBuf), curve, formatNum),\r\n    );\r\n\r\n    if (outputEncoding) {\r\n      return result.toString(outputEncoding);\r\n    }\r\n    return result;\r\n  }\r\n}\r\n\r\nexport function createECDH(curveName: string): ECDH {\r\n  return new ECDH(curveName);\r\n}\r\n"],"mappings":";;;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,MAAM,QAAQ,gCAAgC;AACvD,SAASC,aAAa,QAAQ,oBAAoB;AAElD,MAAMC,2BAA2B,GAAG,CAAC;AACrC,MAAMC,6BAA6B,GAAG,CAAC;AACvC,MAAMC,uBAAuB,GAAG,CAAC;AAEjC,OAAO,MAAMC,IAAI,CAAC;EAEhB,WAAmBC,gBAAgBA,CAAA,EAAkB;IACnD,IAAI,CAAC,IAAI,CAACC,iBAAiB,EAAE;MAC3B,IAAI,CAACA,iBAAiB,GACpBR,YAAY,CAACS,kBAAkB,CAAgB,MAAM,CAAC;IAC1D;IACA,OAAO,IAAI,CAACD,iBAAiB;EAC/B;EAIAE,WAAWA,CAACC,SAAiB,EAAE;IAAAC,eAAA;IAC7B,IAAI,CAACC,OAAO,GAAGb,YAAY,CAACS,kBAAkB,CAAgB,MAAM,CAAC;IACrE,IAAI,CAACI,OAAO,CAACC,IAAI,CAACH,SAAS,CAAC;EAC9B;EAEAI,YAAYA,CAAA,EAAW;IACrB,MAAMC,GAAG,GAAG,IAAI,CAACH,OAAO,CAACE,YAAY,CAAC,CAAC;IACvC,OAAOd,MAAM,CAACgB,IAAI,CAACD,GAAG,CAAC;EACzB;EAEAE,aAAaA,CACXC,cAAsE,EACtEC,aAA8B,EACtB;IACR,IAAIC,MAAc;IAClB,IAAIpB,MAAM,CAACqB,QAAQ,CAACH,cAAc,CAAC,EAAE;MACnCE,MAAM,GAAGF,cAAc;IACzB,CAAC,MAAM,IAAI,OAAOA,cAAc,KAAK,QAAQ,EAAE;MAC7CE,MAAM,GAAGpB,MAAM,CAACgB,IAAI,CAACE,cAAc,EAAEC,aAAa,CAAC;IACrD,CAAC,MAAM;MACL;MACA,MAAM,IAAIG,SAAS,CAAC,6BAA6B,CAAC;IACpD;;IAEA;IACA,MAAMC,MAAM,GAAG,IAAI,CAACX,OAAO,CAACK,aAAa,CAAChB,aAAa,CAACmB,MAAM,CAAC,CAAC;IAChE,OAAOpB,MAAM,CAACgB,IAAI,CAACO,MAAM,CAAC;EAC5B;EAEAC,aAAaA,CAAA,EAAW;IACtB,OAAOxB,MAAM,CAACgB,IAAI,CAAC,IAAI,CAACJ,OAAO,CAACY,aAAa,CAAC,CAAC,CAAC;EAClD;EAEAC,aAAaA,CAACC,UAA2B,EAAEC,QAAyB,EAAQ;IAC1E,IAAIP,MAAc;IAClB,IAAIpB,MAAM,CAACqB,QAAQ,CAACK,UAAU,CAAC,EAAE;MAC/BN,MAAM,GAAGM,UAAU;IACrB,CAAC,MAAM;MACLN,MAAM,GAAGpB,MAAM,CAACgB,IAAI,CAACU,UAAU,EAAEC,QAAQ,CAAC;IAC5C;IACA,IAAI,CAACf,OAAO,CAACa,aAAa,CAACxB,aAAa,CAACmB,MAAM,CAAC,CAAC;EACnD;EAEAQ,YAAYA,CAACD,QAAyB,EAAmB;IACvD;IACA;IACA;IACA;IACA,MAAME,GAAG,GAAG7B,MAAM,CAACgB,IAAI,CAAC,IAAI,CAACJ,OAAO,CAACgB,YAAY,CAAC,CAAC,CAAC;IACpD,IAAID,QAAQ,EAAE;MACZ,OAAOE,GAAG,CAACC,QAAQ,CAACH,QAAQ,CAAC;IAC/B;IACA,OAAOE,GAAG;EACZ;EAEAE,YAAYA,CAACC,SAA0B,EAAEL,QAAyB,EAAQ;IACxE,IAAIP,MAAc;IAClB,IAAIpB,MAAM,CAACqB,QAAQ,CAACW,SAAS,CAAC,EAAE;MAC9BZ,MAAM,GAAGY,SAAS;IACpB,CAAC,MAAM;MACLZ,MAAM,GAAGpB,MAAM,CAACgB,IAAI,CAACgB,SAAS,EAAEL,QAAQ,CAAC;IAC3C;IACA,IAAI,CAACf,OAAO,CAACmB,YAAY,CAAC9B,aAAa,CAACmB,MAAM,CAAC,CAAC;EAClD;EAEA,OAAOa,UAAUA,CACflB,GAAoB,EACpBmB,KAAa,EACbf,aAA8B,EAC9BgB,cAA+B,EAC/BC,MAAiD,EAChC;IACjB,IAAIhB,MAAc;IAClB,IAAIpB,MAAM,CAACqB,QAAQ,CAACN,GAAG,CAAC,EAAE;MACxBK,MAAM,GAAGL,GAAG;IACd,CAAC,MAAM;MACLK,MAAM,GAAGpB,MAAM,CAACgB,IAAI,CAACD,GAAG,EAAEI,aAAa,CAAC;IAC1C;IAEA,IAAIkB,SAAiB;IACrB,QAAQD,MAAM;MACZ,KAAK,YAAY;QACfC,SAAS,GAAGnC,2BAA2B;QACvC;MACF,KAAK,QAAQ;QACXmC,SAAS,GAAGjC,uBAAuB;QACnC;MACF,KAAK,cAAc;MACnB,KAAKkC,SAAS;QACZD,SAAS,GAAGlC,6BAA6B;QACzC;MACF;QACE,MAAM,IAAImB,SAAS,CACjB,oCAAoCc,MAAM,EAC5C,CAAC;IACL;IAEA,MAAMG,MAAM,GAAGvC,MAAM,CAACgB,IAAI,CACxBX,IAAI,CAACC,gBAAgB,CAAC2B,UAAU,CAAChC,aAAa,CAACmB,MAAM,CAAC,EAAEc,KAAK,EAAEG,SAAS,CAC1E,CAAC;IAED,IAAIF,cAAc,EAAE;MAClB,OAAOI,MAAM,CAACT,QAAQ,CAACK,cAAc,CAAC;IACxC;IACA,OAAOI,MAAM;EACf;AACF;AAAC5B,eAAA,CAtHYN,IAAI;AAwHjB,OAAO,SAASmC,UAAUA,CAAC9B,SAAiB,EAAQ;EAClD,OAAO,IAAIL,IAAI,CAACK,SAAS,CAAC;AAC5B","ignoreList":[]}