@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/lib/commonjs/diffie-hellman.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DiffieHellman = void 0;
+exports.createDiffieHellman = createDiffieHellman;
+exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman;
+var _reactNativeNitroModules = require("./nitro-node-shim");
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _dhGroups = require("./dh-groups");
+var _conversion = require("./utils/conversion");
+class DiffieHellman {
+  constructor(sizeOrPrime, generator, encoding) {
+    this._hybrid = _reactNativeNitroModules.NitroModules.createHybridObject('DiffieHellman');
+    if (typeof sizeOrPrime === 'number') {
+      const gen = typeof generator === 'number' ? generator : 2;
+      this._hybrid.initWithSize(sizeOrPrime, gen);
+    } else {
+      let primeBuf;
+      if (_reactNativeBuffer.Buffer.isBuffer(sizeOrPrime)) {
+        primeBuf = sizeOrPrime;
+      } else {
+        primeBuf = _reactNativeBuffer.Buffer.from(sizeOrPrime, encoding);
+      }
+      let genBuf;
+      if (generator === undefined) {
+        genBuf = _reactNativeBuffer.Buffer.from([2]);
+      } else if (typeof generator === 'number') {
+        genBuf = _reactNativeBuffer.Buffer.from([generator]);
+      } else if (_reactNativeBuffer.Buffer.isBuffer(generator)) {
+        genBuf = generator;
+      } else {
+        genBuf = _reactNativeBuffer.Buffer.from(generator, encoding);
+      }
+      this._hybrid.init((0, _conversion.toArrayBuffer)(primeBuf), (0, _conversion.toArrayBuffer)(genBuf));
+    }
+  }
+  generateKeys(encoding) {
+    const keys = _reactNativeBuffer.Buffer.from(this._hybrid.generateKeys());
+    if (encoding) return keys.toString(encoding);
+    return keys;
+  }
+  computeSecret(otherPublicKey, inputEncoding, outputEncoding) {
+    let keyBuf;
+    if (_reactNativeBuffer.Buffer.isBuffer(otherPublicKey)) {
+      keyBuf = otherPublicKey;
+    } else {
+      keyBuf = _reactNativeBuffer.Buffer.from(otherPublicKey, inputEncoding);
+    }
+    const secret = _reactNativeBuffer.Buffer.from(this._hybrid.computeSecret((0, _conversion.toArrayBuffer)(keyBuf)));
+    if (outputEncoding) return secret.toString(outputEncoding);
+    return secret;
+  }
+  getPrime(encoding) {
+    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPrime());
+    if (encoding) return p.toString(encoding);
+    return p;
+  }
+  getGenerator(encoding) {
+    const g = _reactNativeBuffer.Buffer.from(this._hybrid.getGenerator());
+    if (encoding) return g.toString(encoding);
+    return g;
+  }
+  getPublicKey(encoding) {
+    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPublicKey());
+    if (encoding) return p.toString(encoding);
+    return p;
+  }
+  getPrivateKey(encoding) {
+    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPrivateKey());
+    if (encoding) return p.toString(encoding);
+    return p;
+  }
+  setPublicKey(publicKey, encoding) {
+    let keyBuf;
+    if (_reactNativeBuffer.Buffer.isBuffer(publicKey)) {
+      keyBuf = publicKey;
+    } else {
+      keyBuf = _reactNativeBuffer.Buffer.from(publicKey, encoding);
+    }
+    this._hybrid.setPublicKey((0, _conversion.toArrayBuffer)(keyBuf));
+  }
+  setPrivateKey(privateKey, encoding) {
+    let keyBuf;
+    if (_reactNativeBuffer.Buffer.isBuffer(privateKey)) {
+      keyBuf = privateKey;
+    } else {
+      keyBuf = _reactNativeBuffer.Buffer.from(privateKey, encoding);
+    }
+    this._hybrid.setPrivateKey((0, _conversion.toArrayBuffer)(keyBuf));
+  }
+  get verifyError() {
+    return this._hybrid.getVerifyError();
+  }
+}
+exports.DiffieHellman = DiffieHellman;
+function createDiffieHellman(primeOrSize, primeEncodingOrGenerator, generator, _generatorEncoding) {
+  if (typeof primeOrSize === 'number') {
+    const gen = typeof primeEncodingOrGenerator === 'number' ? primeEncodingOrGenerator : 2;
+    return new DiffieHellman(primeOrSize, gen);
+  }
+
+  // Standardize arguments for String/Buffer prime
+  // createDiffieHellman(prime, [encoding], [generator], [encoding])
+
+  let prime;
+  let generatorVal;
+  if (_reactNativeBuffer.Buffer.isBuffer(primeOrSize)) {
+    prime = primeOrSize;
+    // 2nd arg is generator if not string (encoding)
+    if (primeEncodingOrGenerator !== undefined && typeof primeEncodingOrGenerator !== 'string') {
+      generatorVal = primeEncodingOrGenerator;
+    } else if (generator !== undefined) {
+      generatorVal = generator;
+    } else {
+      generatorVal = 2;
+    }
+  } else {
+    // String prime
+    const encoding = typeof primeEncodingOrGenerator === 'string' ? primeEncodingOrGenerator : 'utf8'; // Defaulting to utf8 or hex? Node default is 'binary' usually but utf8 safer for TS. Node docs say: "If no encoding is specified, 'binary' is used."
+    // We'll trust user passed encoding if it's a string, otherwise handle it.
+    prime = _reactNativeBuffer.Buffer.from(primeOrSize, encoding);
+
+    // Generator handling in this case
+    if (generator !== undefined) {
+      generatorVal = generator;
+      if (typeof generator === 'string' && _generatorEncoding) {
+        generatorVal = _reactNativeBuffer.Buffer.from(generator, _generatorEncoding);
+      } else if (typeof generator === 'string') {
+        // string with no encoding, assume same as prime? or utf8?
+        generatorVal = _reactNativeBuffer.Buffer.from(generator, encoding);
+      }
+    } else if (typeof primeEncodingOrGenerator !== 'string' && primeEncodingOrGenerator !== undefined) {
+      // 2nd arg was generator
+      generatorVal = primeEncodingOrGenerator;
+    } else {
+      generatorVal = 2;
+    }
+  }
+  return new DiffieHellman(prime, generatorVal);
+}
+function getDiffieHellman(groupName) {
+  const group = _dhGroups.DH_GROUPS[groupName];
+  if (!group) {
+    throw new Error(`Unknown group: ${groupName}`);
+  }
+  // group.prime and group.generator are hex strings
+  return new DiffieHellman(group.prime, group.generator, 'hex');
+}
+//# sourceMappingURL=diffie-hellman.js.map

package/lib/commonjs/diffie-hellman.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeBuffer","_dhGroups","_conversion","DiffieHellman","constructor","sizeOrPrime","generator","encoding","_hybrid","NitroModules","createHybridObject","gen","initWithSize","primeBuf","Buffer","isBuffer","from","genBuf","undefined","init","toArrayBuffer","generateKeys","keys","toString","computeSecret","otherPublicKey","inputEncoding","outputEncoding","keyBuf","secret","getPrime","p","getGenerator","g","getPublicKey","getPrivateKey","setPublicKey","publicKey","setPrivateKey","privateKey","verifyError","getVerifyError","exports","createDiffieHellman","primeOrSize","primeEncodingOrGenerator","_generatorEncoding","prime","generatorVal","getDiffieHellman","groupName","group","DH_GROUPS","Error"],"sourceRoot":"../../src","sources":["diffie-hellman.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/dsa.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Dsa = void 0;
+exports.dsa_generateKeyPairNode = dsa_generateKeyPairNode;
+exports.dsa_generateKeyPairNodeSync = dsa_generateKeyPairNodeSync;
+var _reactNativeNitroModules = require("./nitro-node-shim");
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _classes = require("./keys/classes");
+var _utils = require("./utils");
+class Dsa {
+  constructor(modulusLength, divisorLength) {
+    this.native = _reactNativeNitroModules.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();
+  }
+}
+
+// FIPS 186-4 §4.2: only L = 1024, 2048, 3072 are sanctioned. NIST has
+// deprecated DSA-1024 for new applications, but we retain it for
+// interop with legacy systems and match Node's permissive default. We
+// reject anything below 1024 outright.
+exports.Dsa = Dsa;
+const DSA_MIN_MODULUS_LENGTH = 1024;
+function dsa_prepareKeyGenParams(options) {
+  if (!options) {
+    throw new Error('Options are required for DSA key generation');
+  }
+  const {
+    modulusLength,
+    divisorLength
+  } = options;
+  if (!modulusLength || modulusLength < DSA_MIN_MODULUS_LENGTH) {
+    throw new RangeError(`DSA modulusLength must be at least ${DSA_MIN_MODULUS_LENGTH} bits ` + `(got ${modulusLength ?? 0})`);
+  }
+  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 = _classes.KeyObject.createKeyObject('public', publicKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+  const priv = _classes.KeyObject.createKeyObject('private', privateKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  let publicKey;
+  let privateKey;
+  if (publicFormat === 'raw-public' || privateFormat === 'raw-private' || privateFormat === 'raw-seed') {
+    throw new Error('Raw key formats are not supported for DSA keys');
+  }
+  if (publicFormat === -1) {
+    publicKey = pub;
+  } else {
+    const format = publicFormat === _utils.KFormatType.PEM ? _utils.KFormatType.PEM : _utils.KFormatType.DER;
+    const exported = pub.handle.exportKey(format, _utils.KeyEncoding.SPKI);
+    if (format === _utils.KFormatType.PEM) {
+      publicKey = _reactNativeBuffer.Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      publicKey = exported;
+    }
+  }
+  if (privateFormat === -1) {
+    privateKey = priv;
+  } else {
+    const format = privateFormat === _utils.KFormatType.PEM ? _utils.KFormatType.PEM : _utils.KFormatType.DER;
+    const exported = priv.handle.exportKey(format, _utils.KeyEncoding.PKCS8, cipher, passphrase);
+    if (format === _utils.KFormatType.PEM) {
+      privateKey = _reactNativeBuffer.Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      privateKey = exported;
+    }
+  }
+  return {
+    publicKey,
+    privateKey
+  };
+}
+async function dsa_generateKeyPairNode(options, encoding) {
+  const dsa = dsa_prepareKeyGenParams(options);
+  await dsa.generateKeyPair();
+  return dsa_formatKeyPairOutput(dsa, encoding);
+}
+function dsa_generateKeyPairNodeSync(options, encoding) {
+  const dsa = dsa_prepareKeyGenParams(options);
+  dsa.generateKeyPairSync();
+  return dsa_formatKeyPairOutput(dsa, encoding);
+}
+//# sourceMappingURL=dsa.js.map

package/lib/commonjs/dsa.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeBuffer","_classes","_utils","Dsa","constructor","modulusLength","divisorLength","native","NitroModules","createHybridObject","setModulusLength","undefined","setDivisorLength","generateKeyPair","generateKeyPairSync","exports","DSA_MIN_MODULUS_LENGTH","dsa_prepareKeyGenParams","options","Error","RangeError","dsa_formatKeyPairOutput","dsa","encoding","publicFormat","privateFormat","cipher","passphrase","publicKeyData","getPublicKey","privateKeyData","getPrivateKey","pub","KeyObject","createKeyObject","KFormatType","DER","KeyEncoding","SPKI","priv","PKCS8","publicKey","privateKey","format","PEM","exported","handle","exportKey","Buffer","from","Uint8Array","toString","dsa_generateKeyPairNode","dsa_generateKeyPairNodeSync"],"sourceRoot":"../../src","sources":["dsa.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/ec.js

@@ -0,0 +1,370 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Ec = void 0;
+exports.ecDeriveBits = ecDeriveBits;
+exports.ecImportKey = ecImportKey;
+exports.ec_generateKeyPair = ec_generateKeyPair;
+exports.ec_generateKeyPairNode = ec_generateKeyPairNode;
+exports.ec_generateKeyPairNodeSync = ec_generateKeyPairNodeSync;
+exports.ecdsaSignVerify = void 0;
+exports.getCurves = getCurves;
+var _reactNativeNitroModules = require("./nitro-node-shim");
+var _classes = require("./keys/classes");
+var _utils = require("./utils");
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _ecdh = require("./ecdh");
+class EcUtils {
+  static get native() {
+    if (!this._native) {
+      this._native = _reactNativeNitroModules.NitroModules.createHybridObject('EcKeyPair');
+    }
+    return this._native;
+  }
+  static getSupportedCurves() {
+    return this.native.getSupportedCurves();
+  }
+}
+function getCurves() {
+  return EcUtils.getSupportedCurves();
+}
+class Ec {
+  constructor(curve) {
+    this.native = _reactNativeNitroModules.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
+exports.Ec = Ec;
+function ecImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  const {
+    name,
+    namedCurve
+  } = algorithm;
+  if (!namedCurve || !_utils.kNamedCurveAliases[namedCurve]) {
+    throw (0, _utils.lazyDOMException)('Unrecognized namedCurve', 'NotSupportedError');
+  }
+  if (format === 'jwk') {
+    const jwk = keyData;
+    if (!jwk || typeof jwk !== 'object') {
+      throw (0, _utils.lazyDOMException)('Invalid keyData', 'DataError');
+    }
+    if (jwk.kty !== 'EC') {
+      throw (0, _utils.lazyDOMException)('Invalid JWK "kty" Parameter', 'DataError');
+    }
+    if (jwk.crv !== namedCurve) {
+      throw (0, _utils.lazyDOMException)('JWK "crv" does not match the requested algorithm', 'DataError');
+    }
+    const expectedUse = name === 'ECDH' ? 'enc' : 'sig';
+    (0, _utils.validateJwkStructure)(jwk, extractable, keyUsages, expectedUse);
+    if (jwk.alg !== undefined) {
+      let expectedAlg;
+      if (name === 'ECDSA') {
+        expectedAlg = namedCurve === 'P-256' ? 'ES256' : namedCurve === 'P-384' ? 'ES384' : namedCurve === 'P-521' ? 'ES512' : undefined;
+      } else if (name === 'ECDH') {
+        expectedAlg = 'ECDH-ES';
+      }
+      if (expectedAlg && jwk.alg !== expectedAlg) {
+        throw (0, _utils.lazyDOMException)('JWK "alg" does not match the requested algorithm', 'DataError');
+      }
+    }
+    const isPublicJwk = jwk.d === undefined;
+    const validUsagesJwk = name === 'ECDSA' ? isPublicJwk ? ['verify'] : ['sign'] : isPublicJwk ? [] : ['deriveKey', 'deriveBits'];
+    if ((0, _utils.hasAnyNotIn)(keyUsages, validUsagesJwk)) {
+      throw (0, _utils.lazyDOMException)(`Unsupported key usage for a ${name} key`, 'SyntaxError');
+    }
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    let keyType;
+    try {
+      keyType = handle.initJwk(jwk, namedCurve);
+    } catch (err) {
+      throw (0, _utils.lazyDOMException)('Invalid keyData', {
+        name: 'DataError',
+        cause: err
+      });
+    }
+    if (keyType === undefined) {
+      throw (0, _utils.lazyDOMException)('Invalid keyData', 'DataError');
+    }
+    let keyObject;
+    if (keyType === 1) {
+      keyObject = new _classes.PublicKeyObject(handle);
+    } else if (keyType === 2) {
+      keyObject = new _classes.PrivateKeyObject(handle);
+    } else {
+      throw (0, _utils.lazyDOMException)('Invalid keyData', 'DataError');
+    }
+    return new _classes.CryptoKey(keyObject, algorithm, keyUsages, extractable);
+  }
+  if (format !== 'spki' && format !== 'pkcs8' && format !== 'raw') {
+    throw (0, _utils.lazyDOMException)(`Unsupported format: ${format}`, 'NotSupportedError');
+  }
+  const expectedKeyType = format === 'spki' || format === 'raw' ? 'public' : 'private';
+  const isPublicKey = expectedKeyType === 'public';
+  let validUsages;
+  if (name === 'ECDSA') {
+    validUsages = isPublicKey ? ['verify'] : ['sign'];
+  } else if (name === 'ECDH') {
+    validUsages = isPublicKey ? [] : ['deriveKey', 'deriveBits'];
+  } else {
+    throw (0, _utils.lazyDOMException)('Unsupported algorithm', 'NotSupportedError');
+  }
+  if ((0, _utils.hasAnyNotIn)(keyUsages, validUsages)) {
+    throw (0, _utils.lazyDOMException)(`Unsupported key usage for a ${name} key`, 'SyntaxError');
+  }
+
+  // Convert keyData to ArrayBuffer
+  const keyBuffer = (0, _utils.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 = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    const curveAlias = _utils.kNamedCurveAliases[namedCurve];
+    // Only throw if initialization explicitly fails
+    if (!handle.initECRaw(curveAlias, keyBuffer)) {
+      throw (0, _utils.lazyDOMException)('Failed to import EC raw key', 'DataError');
+    }
+    keyObject = new _classes.PublicKeyObject(handle);
+  } else {
+    // Use standard DER import for spki/pkcs8
+    keyObject = _classes.KeyObject.createKeyObject(expectedKeyType, keyBuffer, _utils.KFormatType.DER, format === 'spki' ? _utils.KeyEncoding.SPKI : _utils.KeyEncoding.PKCS8);
+
+    // Validate the imported curve matches the requested algorithm.namedCurve.
+    const expectedAlias = _utils.kNamedCurveAliases[namedCurve];
+    if (keyObject.handle.keyDetail().namedCurve !== expectedAlias) {
+      throw (0, _utils.lazyDOMException)('Named curve mismatch', 'DataError');
+    }
+  }
+
+  // Verify the public/private point lies on the named curve.
+  if (!keyObject.handle.checkEcKeyData()) {
+    throw (0, _utils.lazyDOMException)('Invalid keyData', 'DataError');
+  }
+  return new _classes.CryptoKey(keyObject, algorithm, keyUsages, extractable);
+}
+
+// Node API
+const ecdsaSignVerify = (key, data, {
+  hash
+}, signature) => {
+  const isSign = signature === undefined;
+  const expectedKeyType = isSign ? 'private' : 'public';
+  if (key.type !== expectedKeyType) {
+    throw (0, _utils.lazyDOMException)(`Key must be a ${expectedKeyType} key`, 'InvalidAccessError');
+  }
+  const hashName = typeof hash === 'string' ? hash : hash?.name;
+  if (!hashName) {
+    throw (0, _utils.lazyDOMException)('Hash algorithm is required for ECDSA', 'InvalidAccessError');
+  }
+
+  // Normalize hash algorithm name to WebCrypto format for C++ layer
+  const normalizedHashName = (0, _utils.normalizeHashName)(hashName, _utils.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' ? _utils.KeyEncoding.PKCS8 : _utils.KeyEncoding.SPKI;
+  const keyData = key.keyObject.handle.exportKey(_utils.KFormatType.DER, encoding);
+  const keyBuffer = (0, _utils.bufferLikeToArrayBuffer)(keyData);
+  ec.native.importKey('der', keyBuffer, key.algorithm.name, key.extractable, key.usages);
+  const dataBuffer = (0, _utils.bufferLikeToArrayBuffer)(data);
+  if (isSign) {
+    // Sign operation
+    return ec.native.sign(dataBuffer, normalizedHashName);
+  } else {
+    // Verify operation
+    const signatureBuffer = (0, _utils.bufferLikeToArrayBuffer)(signature);
+    return ec.native.verify(dataBuffer, signatureBuffer, normalizedHashName);
+  }
+};
+
+// WebCrypto API - only P-256, P-384, P-521 allowed per spec
+exports.ecdsaSignVerify = ecdsaSignVerify;
+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(_utils.kNamedCurveAliases).includes(namedCurve || '')) {
+    throw (0, _utils.lazyDOMException)(`Unrecognized namedCurve '${namedCurve}'`, 'NotSupportedError');
+  }
+  switch (name) {
+    case 'ECDSA':
+      if ((0, _utils.hasAnyNotIn)(keyUsages, ['sign', 'verify'])) {
+        throw (0, _utils.lazyDOMException)('Unsupported key usage for an ECDSA key', 'SyntaxError');
+      }
+      break;
+    case 'ECDH':
+      if ((0, _utils.hasAnyNotIn)(keyUsages, ['deriveKey', 'deriveBits'])) {
+        throw (0, _utils.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 = (0, _utils.getUsagesUnion)(keyUsages, 'verify');
+      privateUsages = (0, _utils.getUsagesUnion)(keyUsages, 'sign');
+      break;
+    case 'ECDH':
+      publicUsages = [];
+      privateUsages = (0, _utils.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 = _classes.KeyObject.createKeyObject('public', publicKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+  const publicKey = new _classes.CryptoKey(pub, keyAlgorithm, publicUsages, true);
+
+  // All keys are now exported in PKCS8 format for consistency
+  const priv = _classes.KeyObject.createKeyObject('private', privateKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  const privateKey = new _classes.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 = _classes.KeyObject.createKeyObject('public', publicKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+  const priv = _classes.KeyObject.createKeyObject('private', privateKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  let publicKey;
+  let privateKey;
+  if (publicFormat === -1) {
+    publicKey = pub;
+  } else if (publicFormat === 'raw-public') {
+    publicKey = _reactNativeBuffer.Buffer.from(pub.handle.exportECPublicRaw(publicType === 'compressed'));
+  } else {
+    const format = publicFormat === _utils.KFormatType.PEM ? _utils.KFormatType.PEM : _utils.KFormatType.DER;
+    const keyEncoding = publicType === _utils.KeyEncoding.SPKI ? _utils.KeyEncoding.SPKI : _utils.KeyEncoding.SPKI;
+    const exported = pub.handle.exportKey(format, keyEncoding);
+    if (format === _utils.KFormatType.PEM) {
+      publicKey = _reactNativeBuffer.Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      publicKey = exported;
+    }
+  }
+  if (privateFormat === -1) {
+    privateKey = priv;
+  } else if (privateFormat === 'raw-private') {
+    privateKey = _reactNativeBuffer.Buffer.from(priv.handle.exportECPrivateRaw());
+  } else {
+    const format = privateFormat === _utils.KFormatType.PEM ? _utils.KFormatType.PEM : _utils.KFormatType.DER;
+    const keyEncoding = privateType === _utils.KeyEncoding.PKCS8 ? _utils.KeyEncoding.PKCS8 : privateType === _utils.KeyEncoding.SEC1 ? _utils.KeyEncoding.SEC1 : _utils.KeyEncoding.PKCS8;
+    const exported = priv.handle.exportKey(format, keyEncoding, cipher, passphrase);
+    if (format === _utils.KFormatType.PEM) {
+      privateKey = _reactNativeBuffer.Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      privateKey = exported;
+    }
+  }
+  return {
+    publicKey,
+    privateKey
+  };
+}
+async function ec_generateKeyPairNode(options, encoding) {
+  const ec = ec_prepareKeyGenParams(options);
+  await ec.generateKeyPair();
+  return ec_formatKeyPairOutput(ec, encoding);
+}
+function ec_generateKeyPairNodeSync(options, encoding) {
+  const ec = ec_prepareKeyGenParams(options);
+  ec.generateKeyPairSync();
+  return ec_formatKeyPairOutput(ec, encoding);
+}
+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 = _utils.kNamedCurveAliases[namedCurve];
+  const ecdh = new _ecdh.ECDH(opensslCurve);
+  const jwkPrivate = baseKey.keyObject.handle.exportJwk({}, false);
+  if (!jwkPrivate.d) throw new Error('Invalid private key');
+  const privateBytes = _reactNativeBuffer.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 = _reactNativeBuffer.Buffer.from(jwkPublic.x, 'base64url');
+  const y = _reactNativeBuffer.Buffer.from(jwkPublic.y, 'base64url');
+  const publicBytes = _reactNativeBuffer.Buffer.concat([_reactNativeBuffer.Buffer.from([0x04]), x, y]);
+  const secret = ecdh.computeSecret(publicBytes);
+  const secretBuf = _reactNativeBuffer.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