fix: use handle.exportJwk() for ECDH deriveBits key export

ecDeriveBits was calling keyObject.export({ format: 'jwk' }) which throws
at the TypeScript layer since JWK export isn't wired through the export()
method. The C++ exportJwk() on the native handle works fine — use it
directly, matching the pattern already used in subtle.ts exportKeyJWK.

Also adds 'public' property to SubtleAlgorithm type to remove casting,
applies the same cleanup in ed.ts xDeriveBits, and adds ECDH deriveBits
and import/export test cases.

Author: boorad

.claude/plans/quick-wins.md

@@ -33,6 +33,11 @@ straightforward to implement.
 - Return the size of a symmetric key in bytes
 - Simple property accessor
 
+## createDiffieHellmanGroup alias
+- Node.js exports `createDiffieHellmanGroup` as an alias for `getDiffieHellman`
+- `getDiffieHellman` already exists and works
+- Just add a re-export: `export { getDiffieHellman as createDiffieHellmanGroup }`
+
 ## diffieHellman.verifyError
 - DiffieHellman class is fully implemented except this property
 - Returns verification errors from DH parameter checking

docs/data/coverage.ts

@@ -136,7 +136,7 @@ export const COVERAGE_DATA: CoverageCategory[] = [
       { name: 'createCipheriv', status: 'implemented' },
       { name: 'createDecipheriv', status: 'implemented' },
       { name: 'createDiffieHellman', status: 'implemented' },
-      { name: 'createDiffieHellmanGroup', status: 'implemented' },
+      { name: 'createDiffieHellmanGroup', status: 'missing' },
       { name: 'createECDH', status: 'implemented' },
       { name: 'createHash', status: 'implemented' },
       { name: 'createHmac', status: 'implemented' },
@@ -151,8 +151,8 @@ export const COVERAGE_DATA: CoverageCategory[] = [
       {
         name: 'diffieHellman',
         subItems: [
-          { name: 'dh', status: 'implemented' },
-          { name: 'ec', status: 'implemented' },
+          { name: 'dh', status: 'missing' },
+          { name: 'ec', status: 'missing' },
           { name: 'x448', status: 'implemented' },
           { name: 'x25519', status: 'implemented' },
         ],

example/ios/Podfile.lock

@@ -2811,7 +2811,7 @@ SPEC CHECKSUMS:
   MMKVCore: f2dd4c9befea04277a55e84e7812f930537993df
   NitroMmkv: afbc5b2fbf963be567c6c545aa1efcf6a9cec68e
   NitroModules: 11bba9d065af151eae51e38a6425e04c3b223ff3
-  QuickCrypto: 9e46baaa4fea5a22fdf23c3aae184b983c948b23
+  QuickCrypto: ac4d2eead1de738bcf06f565c4ab31db817f88c1
   RCT-Folly: 846fda9475e61ec7bcbf8a3fe81edfcaeb090669
   RCTDeprecation: c4b9e2fd0ab200e3af72b013ed6113187c607077
   RCTRequired: e97dd5dafc1db8094e63bc5031e0371f092ae92a

example/src/tests/subtle/deriveBits.ts

@@ -1,4 +1,5 @@
 import { expect } from 'chai';
+import type { WebCryptoKeyPair } from 'react-native-quick-crypto';
 import crypto, {
   Buffer,
   subtle,
@@ -215,4 +216,193 @@ test(SUITE, 'x25519 - error handling', () => {
   }).to.throw();
 });
 
-// ecdh deriveBits
+// --- ECDH subtle.deriveBits Tests ---
+
+import type { NamedCurve } from 'react-native-quick-crypto';
+
+const ecdhCurves: Array<{ curve: NamedCurve; bitLen: number }> = [
+  { curve: 'P-256', bitLen: 256 },
+  { curve: 'P-384', bitLen: 384 },
+  { curve: 'P-521', bitLen: 528 },
+];
+
+for (const { curve, bitLen } of ecdhCurves) {
+  test(SUITE, `ECDH deriveBits - ${curve}`, async () => {
+    const alice = (await subtle.generateKey(
+      { name: 'ECDH', namedCurve: curve },
+      true,
+      ['deriveBits'],
+    )) as WebCryptoKeyPair;
+    const bob = (await subtle.generateKey(
+      { name: 'ECDH', namedCurve: curve },
+      true,
+      ['deriveBits'],
+    )) as WebCryptoKeyPair;
+
+    const bits = await subtle.deriveBits(
+      { name: 'ECDH', public: bob.publicKey },
+      alice.privateKey,
+      bitLen,
+    );
+    expect(bits).to.be.an.instanceOf(ArrayBuffer);
+    expect(bits.byteLength).to.equal(bitLen / 8);
+  });
+
+  test(SUITE, `ECDH deriveBits symmetry - ${curve}`, async () => {
+    const alice = (await subtle.generateKey(
+      { name: 'ECDH', namedCurve: curve },
+      true,
+      ['deriveBits'],
+    )) as WebCryptoKeyPair;
+    const bob = (await subtle.generateKey(
+      { name: 'ECDH', namedCurve: curve },
+      true,
+      ['deriveBits'],
+    )) as WebCryptoKeyPair;
+
+    const aliceBits = await subtle.deriveBits(
+      { name: 'ECDH', public: bob.publicKey },
+      alice.privateKey,
+      bitLen,
+    );
+    const bobBits = await subtle.deriveBits(
+      { name: 'ECDH', public: alice.publicKey },
+      bob.privateKey,
+      bitLen,
+    );
+
+    expect(Buffer.from(aliceBits).equals(Buffer.from(bobBits))).to.equal(true);
+  });
+}
+
+// --- X448 diffieHellman Tests ---
+
+test(SUITE, 'x448 - shared secret', () => {
+  const alice = crypto.generateKeyPairSync('x448', {});
+  const bob = crypto.generateKeyPairSync('x448', {});
+
+  const privateKey = KeyObject.createKeyObject(
+    'private',
+    alice.privateKey as ArrayBuffer,
+  );
+  const publicKey = KeyObject.createKeyObject(
+    'public',
+    bob.publicKey as ArrayBuffer,
+  );
+
+  const sharedSecret = crypto.diffieHellman({ privateKey, publicKey });
+  expect(Buffer.isBuffer(sharedSecret)).to.equal(true);
+});
+
+test(SUITE, 'x448 - shared secret symmetry', () => {
+  const alice = crypto.generateKeyPairSync('x448', {});
+  const bob = crypto.generateKeyPairSync('x448', {});
+
+  const alicePrivate = KeyObject.createKeyObject(
+    'private',
+    alice.privateKey as ArrayBuffer,
+  );
+  const alicePublic = KeyObject.createKeyObject(
+    'public',
+    alice.publicKey as ArrayBuffer,
+  );
+  const bobPrivate = KeyObject.createKeyObject(
+    'private',
+    bob.privateKey as ArrayBuffer,
+  );
+  const bobPublic = KeyObject.createKeyObject(
+    'public',
+    bob.publicKey as ArrayBuffer,
+  );
+
+  const sharedSecretAlice = crypto.diffieHellman({
+    privateKey: alicePrivate,
+    publicKey: bobPublic,
+  }) as Buffer;
+
+  const sharedSecretBob = crypto.diffieHellman({
+    privateKey: bobPrivate,
+    publicKey: alicePublic,
+  }) as Buffer;
+
+  expect(Buffer.isBuffer(sharedSecretAlice)).to.equal(true);
+  expect(Buffer.isBuffer(sharedSecretBob)).to.equal(true);
+  expect(sharedSecretAlice.equals(sharedSecretBob)).to.equal(true);
+});
+
+test(SUITE, 'x448 - shared secret properties', () => {
+  const alice = crypto.generateKeyPairSync('x448', {});
+  const bob = crypto.generateKeyPairSync('x448', {});
+
+  const alicePrivate = KeyObject.createKeyObject(
+    'private',
+    alice.privateKey as ArrayBuffer,
+  );
+  const bobPublic = KeyObject.createKeyObject(
+    'public',
+    bob.publicKey as ArrayBuffer,
+  );
+
+  const sharedSecret = crypto.diffieHellman({
+    privateKey: alicePrivate,
+    publicKey: bobPublic,
+  }) as Buffer;
+
+  expect(sharedSecret.length).to.equal(56);
+
+  const allZeros = Buffer.alloc(56, 0);
+  expect(sharedSecret.equals(allZeros)).to.equal(false);
+
+  const sharedSecret2 = crypto.diffieHellman({
+    privateKey: alicePrivate,
+    publicKey: bobPublic,
+  }) as Buffer;
+  expect(sharedSecret.equals(sharedSecret2)).to.equal(true);
+});
+
+test(SUITE, 'x448 - different key pairs produce different secrets', () => {
+  const alice = crypto.generateKeyPairSync('x448', {});
+  const bob = crypto.generateKeyPairSync('x448', {});
+  const charlie = crypto.generateKeyPairSync('x448', {});
+
+  const alicePrivate = KeyObject.createKeyObject(
+    'private',
+    alice.privateKey as ArrayBuffer,
+  );
+  const bobPublic = KeyObject.createKeyObject(
+    'public',
+    bob.publicKey as ArrayBuffer,
+  );
+  const charliePublic = KeyObject.createKeyObject(
+    'public',
+    charlie.publicKey as ArrayBuffer,
+  );
+
+  const secretAliceBob = crypto.diffieHellman({
+    privateKey: alicePrivate,
+    publicKey: bobPublic,
+  }) as Buffer;
+
+  const secretAliceCharlie = crypto.diffieHellman({
+    privateKey: alicePrivate,
+    publicKey: charliePublic,
+  }) as Buffer;
+
+  expect(secretAliceBob.equals(secretAliceCharlie)).to.equal(false);
+});
+
+test(SUITE, 'x448 - error handling', () => {
+  const alice = crypto.generateKeyPairSync('x448', {});
+
+  const alicePrivate = KeyObject.createKeyObject(
+    'private',
+    alice.privateKey as ArrayBuffer,
+  );
+
+  expect(() => {
+    crypto.diffieHellman({
+      privateKey: alicePrivate,
+      publicKey: {} as KeyObject,
+    });
+  }).to.throw();
+});

example/src/tests/subtle/import_export.ts

@@ -2193,3 +2193,91 @@ test(SUITE, 'ML-DSA-44 importKey rejects invalid format', async () => {
     'NotSupportedError',
   );
 });
+
+// --- Ed25519/Ed448 raw import/export Tests ---
+
+const edCurves = [
+  { name: 'Ed25519' as const, rawSize: 32 },
+  { name: 'Ed448' as const, rawSize: 57 },
+];
+
+for (const { name: curveName, rawSize } of edCurves) {
+  test(SUITE, `${curveName} raw export public key`, async () => {
+    const keyPair = (await subtle.generateKey({ name: curveName }, true, [
+      'sign',
+      'verify',
+    ])) as CryptoKeyPair;
+
+    const raw = (await subtle.exportKey(
+      'raw',
+      keyPair.publicKey as CryptoKey,
+    )) as ArrayBuffer;
+
+    expect(raw).to.be.instanceOf(ArrayBuffer);
+    expect(raw.byteLength).to.equal(rawSize);
+  });
+
+  test(SUITE, `${curveName} raw export/import round-trip`, async () => {
+    const keyPair = (await subtle.generateKey({ name: curveName }, true, [
+      'sign',
+      'verify',
+    ])) as CryptoKeyPair;
+
+    const raw = (await subtle.exportKey(
+      'raw',
+      keyPair.publicKey as CryptoKey,
+    )) as ArrayBuffer;
+
+    const imported = await subtle.importKey(
+      'raw',
+      raw,
+      { name: curveName },
+      true,
+      ['verify'],
+    );
+
+    expect(imported.type).to.equal('public');
+    expect(imported.algorithm.name).to.equal(curveName);
+    expect(imported.extractable).to.equal(true);
+    expect(imported.usages).to.deep.equal(['verify']);
+
+    const reExported = (await subtle.exportKey('raw', imported)) as ArrayBuffer;
+    expect(Buffer.from(raw).equals(Buffer.from(reExported))).to.equal(true);
+  });
+
+  test(SUITE, `${curveName} raw import then verify signature`, async () => {
+    const testData = new TextEncoder().encode(`${curveName} raw import test`);
+
+    const keyPair = (await subtle.generateKey({ name: curveName }, true, [
+      'sign',
+      'verify',
+    ])) as CryptoKeyPair;
+
+    const signature = await subtle.sign(
+      { name: curveName },
+      keyPair.privateKey as CryptoKey,
+      testData,
+    );
+
+    const raw = (await subtle.exportKey(
+      'raw',
+      keyPair.publicKey as CryptoKey,
+    )) as ArrayBuffer;
+
+    const importedPublic = await subtle.importKey(
+      'raw',
+      raw,
+      { name: curveName },
+      true,
+      ['verify'],
+    );
+
+    const isValid = await subtle.verify(
+      { name: curveName },
+      importedPublic,
+      signature,
+      testData,
+    );
+    expect(isValid).to.equal(true);
+  });
+}

packages/react-native-quick-crypto/src/ec.ts

@@ -488,8 +488,7 @@ export function ecDeriveBits(
   baseKey: CryptoKey,
   length: number | null,
 ): ArrayBuffer {
-  const publicParams = algorithm as SubtleAlgorithm & { public?: CryptoKey };
-  const publicKey = publicParams.public;
+  const publicKey = algorithm.public;
 
   if (!publicKey) {
     throw new Error('Public key is required for ECDH derivation');
@@ -508,31 +507,19 @@ export function ecDeriveBits(
     throw new Error('Curve name is missing');
   }
 
-  // Create new ECDH instance (Node.js style wrapper)
-  const ecdh = new ECDH(namedCurve);
+  const opensslCurve =
+    kNamedCurveAliases[namedCurve as keyof typeof kNamedCurveAliases];
+  const ecdh = new ECDH(opensslCurve);
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const jwkPrivate = baseKey.keyObject.export({ format: 'jwk' }) as any;
+  const jwkPrivate = baseKey.keyObject.handle.exportJwk({}, false);
   if (!jwkPrivate.d) throw new Error('Invalid private key');
   const privateBytes = Buffer.from(jwkPrivate.d, 'base64');
-
   ecdh.setPrivateKey(privateBytes);
 
-  // Public key
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const jwkPublic = publicKey.keyObject.export({ format: 'jwk' }) as any;
-
-  // HybridECDH `computeSecret` takes public key.
-  // My implementation `HybridECDH.cpp` `computeSecret` expects what?
-  // `derive_secret` -> `EVP_PKEY_derive_set_peer`
-  // `computeSecret` calls `EC_POINT_oct2point`. So it expects an uncompressed/compressed point (04... or 02/03...).
-  // JWK gives `x` and `y`. We can construct the uncompressed point 04 + x + y.
-
+  const jwkPublic = publicKey.keyObject.handle.exportJwk({}, false);
   if (!jwkPublic.x || !jwkPublic.y) throw new Error('Invalid public key');
   const x = Buffer.from(jwkPublic.x, 'base64');
   const y = Buffer.from(jwkPublic.y, 'base64');
-
-  // Uncompressed point: 0x04 || x || y
   const publicBytes = Buffer.concat([Buffer.from([0x04]), x, y]);
 
   const secret = ecdh.computeSecret(publicBytes);

packages/react-native-quick-crypto/src/ed.ts

@@ -427,8 +427,7 @@ export function xDeriveBits(
   baseKey: CryptoKey,
   length: number | null,
 ): ArrayBuffer {
-  const publicParams = algorithm as SubtleAlgorithm & { public?: CryptoKey };
-  const publicKey = publicParams.public;
+  const publicKey = algorithm.public;
 
   if (!publicKey) {
     throw new Error('Public key is required for X25519/X448 derivation');

packages/react-native-quick-crypto/src/utils/types.ts

@@ -187,6 +187,7 @@ export type SubtleAlgorithm = {
   modulusLength?: number;
   publicExponent?: number | Uint8Array;
   saltLength?: number;
+  public?: CryptoKey;
 };
 
 export type KeyPairType =