react-native-quick-crypto 1.1.0 → 1.1.2

package/src/ec.ts

@@ -27,6 +27,7 @@ import {
   kNamedCurveAliases,
   lazyDOMException,
   normalizeHashName,
+  validateJwkStructure,
   HashContext,
   KeyEncoding,
   KFormatType,
@@ -93,36 +94,27 @@ export function ecImportKey(
     throw lazyDOMException('Unrecognized namedCurve', 'NotSupportedError');
   }
 
-  // Handle JWK format
   if (format === 'jwk') {
     const jwk = keyData as JWK;
 
-    // Validate JWK
+    if (!jwk || typeof jwk !== 'object') {
+      throw lazyDOMException('Invalid keyData', 'DataError');
+    }
     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',
       );
     }
+    const expectedUse = name === 'ECDH' ? 'enc' : 'sig';
+    validateJwkStructure(jwk, extractable, keyUsages, expectedUse);
 
-    // 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: string | undefined;
-
       if (name === 'ECDSA') {
-        // Map namedCurve to expected ECDSA algorithm
         expectedAlg =
           namedCurve === 'P-256'
             ? 'ES256'
@@ -132,11 +124,9 @@ export function ecImportKey(
                 ? 'ES512'
                 : undefined;
       } else if (name === 'ECDH') {
-        // ECDH uses ECDH-ES algorithm
         expectedAlg = 'ECDH-ES';
       }
-
-      if (expectedAlg && jwk.alg !== undefined && jwk.alg !== expectedAlg) {
+      if (expectedAlg && jwk.alg !== expectedAlg) {
         throw lazyDOMException(
           'JWK "alg" does not match the requested algorithm',
           'DataError',
@@ -144,32 +134,49 @@ export function ecImportKey(
       }
     }
 
-    // Import using C++ layer
+    const isPublicJwk = jwk.d === undefined;
+    const validUsagesJwk: KeyUsage[] =
+      name === 'ECDSA'
+        ? isPublicJwk
+          ? ['verify']
+          : ['sign']
+        : isPublicJwk
+          ? []
+          : ['deriveKey', 'deriveBits'];
+    if (hasAnyNotIn(keyUsages, validUsagesJwk)) {
+      throw lazyDOMException(
+        `Unsupported key usage for a ${name} key`,
+        'SyntaxError',
+      );
+    }
+
     const handle =
       NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
-    const keyType = handle.initJwk(jwk, namedCurve as NamedCurve);
-
+    let keyType: number | undefined;
+    try {
+      keyType = handle.initJwk(jwk, namedCurve as NamedCurve);
+    } catch (err) {
+      throw lazyDOMException('Invalid keyData', {
+        name: 'DataError',
+        cause: err,
+      });
+    }
     if (keyType === undefined) {
-      throw lazyDOMException('Invalid JWK', 'DataError');
+      throw lazyDOMException('Invalid keyData', 'DataError');
     }
 
-    // Create the appropriate KeyObject based on type
     let keyObject: 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',
-      );
+      throw lazyDOMException('Invalid keyData', '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}`,
@@ -177,11 +184,9 @@ export function ecImportKey(
     );
   }
 
-  // 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: KeyUsage[];
 
@@ -225,6 +230,18 @@ export function ecImportKey(
       KFormatType.DER,
       format === 'spki' ? KeyEncoding.SPKI : KeyEncoding.PKCS8,
     );
+
+    // Validate the imported curve matches the requested algorithm.namedCurve.
+    const expectedAlias =
+      kNamedCurveAliases[namedCurve as keyof typeof kNamedCurveAliases];
+    if (keyObject.handle.keyDetail().namedCurve !== expectedAlias) {
+      throw lazyDOMException('Named curve mismatch', 'DataError');
+    }
+  }
+
+  // Verify the public/private point lies on the named curve.
+  if (!keyObject.handle.checkEcKeyData()) {
+    throw lazyDOMException('Invalid keyData', 'DataError');
   }
 
   return new CryptoKey(keyObject, algorithm, keyUsages, extractable);
@@ -433,6 +450,10 @@ function ec_formatKeyPairOutput(
 
   if (publicFormat === -1) {
     publicKey = pub;
+  } else if (publicFormat === 'raw-public') {
+    publicKey = Buffer.from(
+      pub.handle.exportECPublicRaw(publicType === 'compressed'),
+    );
   } else {
     const format =
       publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
@@ -448,6 +469,8 @@ function ec_formatKeyPairOutput(
 
   if (privateFormat === -1) {
     privateKey = priv;
+  } else if (privateFormat === 'raw-private') {
+    privateKey = Buffer.from(priv.handle.exportECPrivateRaw());
   } else {
     const format =
       privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;

package/src/ed.ts

@@ -8,6 +8,7 @@ import {
   PrivateKeyObject as PrivateKeyObjectClass,
 } from './keys/classes';
 import type { EdKeyPair } from './specs/edKeyPair.nitro';
+import type { KeyObjectHandle as KeyObjectHandleSpec } from './specs/keyObjectHandle.nitro';
 import type {
   BinaryLike,
   CFRGKeyPairType,
@@ -31,6 +32,10 @@ import {
 } from './utils';
 import { ECDH } from './ecdh';
 
+function coerceToNumeric(value: unknown): number {
+  return typeof value === 'number' ? value : -1;
+}
+
 export class Ed {
   type: CFRGKeyPairType;
   config: KeyPairGenConfig;
@@ -86,10 +91,10 @@ export class Ed {
 
   async generateKeyPair(): Promise<void> {
     await this.native.generateKeyPair(
-      this.config.publicFormat ?? -1,
-      this.config.publicType ?? -1,
-      this.config.privateFormat ?? -1,
-      this.config.privateType ?? -1,
+      coerceToNumeric(this.config.publicFormat),
+      coerceToNumeric(this.config.publicType),
+      coerceToNumeric(this.config.privateFormat),
+      coerceToNumeric(this.config.privateType),
       this.config.cipher,
       this.config.passphrase as ArrayBuffer,
     );
@@ -97,10 +102,10 @@ export class Ed {
 
   generateKeyPairSync(): void {
     this.native.generateKeyPairSync(
-      this.config.publicFormat ?? -1,
-      this.config.publicType ?? -1,
-      this.config.privateFormat ?? -1,
-      this.config.privateType ?? -1,
+      coerceToNumeric(this.config.publicFormat),
+      coerceToNumeric(this.config.publicType),
+      coerceToNumeric(this.config.privateFormat),
+      coerceToNumeric(this.config.privateType),
       this.config.cipher,
       this.config.passphrase as ArrayBuffer,
     );
@@ -166,18 +171,86 @@ export function diffieHellman(
   options: DiffieHellmanOptions,
   callback?: DiffieHellmanCallback,
 ): Buffer | void {
-  checkDiffieHellmanOptions(options);
+  if (!options || typeof options !== 'object') {
+    throw new TypeError('options must be an object');
+  }
+  if (callback !== undefined && typeof callback !== 'function') {
+    throw new TypeError('callback must be a function');
+  }
 
-  const privateKey = options.privateKey as PrivateKeyObject;
+  const resolvedOptions: DiffieHellmanOptions = {
+    publicKey: resolveDhKeyInput(options.publicKey, 'publicKey'),
+    privateKey: resolveDhKeyInput(options.privateKey, 'privateKey'),
+  };
+  checkDiffieHellmanOptions(resolvedOptions);
+
+  const privateKey = resolvedOptions.privateKey as PrivateKeyObject;
   const keyType = privateKey.asymmetricKeyType;
 
   if (keyType === 'ec') {
-    return ecDiffieHellman(options, callback);
+    return ecDiffieHellman(resolvedOptions, callback);
+  }
+
+  if (keyType === 'dh') {
+    throw new Error(
+      'crypto.diffieHellman with DH KeyObjects is not supported yet — use the DiffieHellman class for now',
+    );
   }
 
   const type = keyType as CFRGKeyPairType;
   const ed = new Ed(type, {});
-  return ed.diffieHellman(options, callback);
+  return ed.diffieHellman(resolvedOptions, callback);
+}
+
+function isRawKeyInput(value: unknown): value is {
+  key: ArrayBuffer | ArrayBufferView | string;
+  format: 'raw-public' | 'raw-private' | 'raw-seed';
+  asymmetricKeyType: string;
+  namedCurve?: string;
+} {
+  if (!value || typeof value !== 'object') return false;
+  const obj = value as { format?: string };
+  return (
+    obj.format === 'raw-public' ||
+    obj.format === 'raw-private' ||
+    obj.format === 'raw-seed'
+  );
+}
+
+function resolveDhKeyInput(
+  input: DiffieHellmanOptions['publicKey'],
+  name: 'publicKey' | 'privateKey',
+): AsymmetricKeyObject {
+  if (isRawKeyInput(input)) {
+    const expectedKeyType = name === 'publicKey' ? 'public' : 'private';
+    if (input.format === 'raw-public' && expectedKeyType !== 'public') {
+      throw new Error(`Invalid format 'raw-public' for ${name}`);
+    }
+    if (
+      (input.format === 'raw-private' || input.format === 'raw-seed') &&
+      expectedKeyType !== 'private'
+    ) {
+      throw new Error(`Invalid format '${input.format}' for ${name}`);
+    }
+    if (input.asymmetricKeyType === 'ec' && !input.namedCurve) {
+      throw new Error(`namedCurve is required for EC raw key in ${name}`);
+    }
+
+    const handle =
+      NitroModules.createHybridObject<KeyObjectHandleSpec>('KeyObjectHandle');
+    const keyData = toAB(input.key as BinaryLike);
+    if (input.format === 'raw-public') {
+      handle.initRawPublic(input.asymmetricKeyType, keyData, input.namedCurve);
+      return new PublicKeyObject(handle);
+    }
+    if (input.format === 'raw-seed') {
+      handle.initRawSeed(input.asymmetricKeyType, keyData);
+      return new PrivateKeyObjectClass(handle);
+    }
+    handle.initRawPrivate(input.asymmetricKeyType, keyData, input.namedCurve);
+    return new PrivateKeyObjectClass(handle);
+  }
+  return input as AsymmetricKeyObject;
 }
 
 function ed_createKeyObjects(ed: Ed): {
@@ -206,17 +279,19 @@ function ed_formatKeyPairOutput(
   ed: Ed,
   encoding: KeyPairGenConfig,
 ): {
-  publicKey: PublicKeyObject | string | ArrayBuffer;
-  privateKey: PrivateKeyObjectClass | string | ArrayBuffer;
+  publicKey: PublicKeyObject | string | ArrayBuffer | Buffer;
+  privateKey: PrivateKeyObjectClass | string | ArrayBuffer | Buffer;
 } {
   const { publicFormat, privateFormat, cipher, passphrase } = encoding;
   const { pub, priv } = ed_createKeyObjects(ed);
 
-  let publicKey: PublicKeyObject | string | ArrayBuffer;
-  let privateKey: PrivateKeyObjectClass | string | ArrayBuffer;
+  let publicKey: PublicKeyObject | string | ArrayBuffer | Buffer;
+  let privateKey: PrivateKeyObjectClass | string | ArrayBuffer | Buffer;
 
   if (publicFormat == null || publicFormat === -1) {
     publicKey = pub;
+  } else if (publicFormat === 'raw-public') {
+    publicKey = Buffer.from(pub.handle.exportRawPublic());
   } else {
     const format =
       publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
@@ -230,6 +305,10 @@ function ed_formatKeyPairOutput(
 
   if (privateFormat == null || privateFormat === -1) {
     privateKey = priv;
+  } else if (privateFormat === 'raw-private') {
+    privateKey = Buffer.from(priv.handle.exportRawPrivate());
+  } else if (privateFormat === 'raw-seed') {
+    privateKey = Buffer.from(priv.handle.exportRawSeed());
   } else {
     const format =
       privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;

package/src/hash.ts

@@ -3,6 +3,7 @@ import { NitroModules } from 'react-native-nitro-modules';
 import type { TransformOptions } from 'readable-stream';
 import { Buffer } from '@craftzdog/react-native-buffer';
 import type { Hash as NativeHash } from './specs/hash.nitro';
+import type { TurboShake as NativeTurboShake } from './specs/turboshake.nitro';
 import type {
   BinaryLike,
   Encoding,
@@ -183,18 +184,28 @@ class Hash extends Stream.Transform {
     return this.native.getOpenSSLVersion();
   }
 
-  // stream interface
+  // Stream interface — surface synchronous errors via the callback so
+  // they emit as stream 'error' events instead of throwing out of the
+  // Transform plumbing (which would crash the host pipeline).
   _transform(
     chunk: BinaryLike,
     encoding: BufferEncoding,
-    callback: () => void,
+    callback: (err?: Error | null) => void,
   ) {
-    this.update(chunk, encoding as Encoding);
-    callback();
+    try {
+      this.update(chunk, encoding as Encoding);
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
   }
-  _flush(callback: () => void) {
-    this.push(this.digest());
-    callback();
+  _flush(callback: (err?: Error | null) => void) {
+    try {
+      this.push(this.digest());
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
   }
 }
 
@@ -257,19 +268,33 @@ export const asyncDigest = async (
   }
 
   if (name === 'cSHAKE128' || name === 'cSHAKE256') {
-    if (typeof algorithm.length !== 'number' || algorithm.length <= 0) {
+    // CShakeParams.outputLength is required (in bits) per the WICG modern-algos
+    // spec, renamed from `length` (commit ab8dc2b84c2). Mirror Node's
+    // hash.js:223-228 / webidl.js:570-595.
+    if (
+      typeof algorithm.outputLength !== 'number' ||
+      algorithm.outputLength <= 0
+    ) {
       throw lazyDOMException(
-        'cSHAKE requires a length parameter',
+        'CShakeParams.outputLength is required',
         'OperationError',
       );
     }
-    if (algorithm.length % 8) {
+    if (algorithm.outputLength % 8) {
       throw lazyDOMException(
-        'Unsupported CShakeParams length',
+        'Unsupported CShakeParams outputLength',
         'NotSupportedError',
       );
     }
-    return internalDigest(algorithm, data, algorithm.length);
+    return internalDigest(algorithm, data, algorithm.outputLength / 8);
+  }
+
+  if (name === 'TurboSHAKE128' || name === 'TurboSHAKE256') {
+    return turboShakeDigest(name, algorithm, data);
+  }
+
+  if (name === 'KT128' || name === 'KT256') {
+    return kangarooTwelveDigest(name, algorithm, data);
   }
 
   throw lazyDOMException(
@@ -278,6 +303,94 @@ export const asyncDigest = async (
   );
 };
 
+// TurboSHAKE / KangarooTwelve are not exposed by OpenSSL EVP, so we route
+// them to a dedicated Nitro module (cpp/turboshake) that ports the Node.js
+// reference implementation. Lazy-load to keep the module out of the hot path
+// for callers that only use SHA-2/SHA-3.
+let nativeTurboShake: NativeTurboShake | undefined;
+const getTurboShake = (): NativeTurboShake => {
+  if (!nativeTurboShake) {
+    nativeTurboShake =
+      NitroModules.createHybridObject<NativeTurboShake>('TurboShake');
+  }
+  return nativeTurboShake;
+};
+
+// RFC 9861 §2.2 default per the WICG Modern Algos draft for TurboSHAKE.
+const kDefaultTurboShakeDomainSeparation = 0x1f;
+
+const turboShakeDigest = async (
+  name: 'TurboSHAKE128' | 'TurboSHAKE256',
+  algorithm: SubtleAlgorithm,
+  data: BufferLike,
+): Promise<ArrayBuffer> => {
+  if (
+    typeof algorithm.outputLength !== 'number' ||
+    algorithm.outputLength <= 0
+  ) {
+    throw lazyDOMException(
+      'TurboShakeParams.outputLength is required',
+      'OperationError',
+    );
+  }
+  if (algorithm.outputLength % 8) {
+    throw lazyDOMException(
+      'Invalid TurboShakeParams outputLength',
+      'OperationError',
+    );
+  }
+  const ds = algorithm.domainSeparation ?? kDefaultTurboShakeDomainSeparation;
+  if (
+    typeof ds !== 'number' ||
+    !Number.isInteger(ds) ||
+    ds < 0x01 ||
+    ds > 0x7f
+  ) {
+    throw lazyDOMException(
+      'TurboShakeParams.domainSeparation must be in range 0x01-0x7f',
+      'OperationError',
+    );
+  }
+  return getTurboShake().turboShake(
+    name,
+    ds,
+    algorithm.outputLength / 8,
+    bufferLikeToArrayBuffer(data),
+  );
+};
+
+const kangarooTwelveDigest = async (
+  name: 'KT128' | 'KT256',
+  algorithm: SubtleAlgorithm,
+  data: BufferLike,
+): Promise<ArrayBuffer> => {
+  if (
+    typeof algorithm.outputLength !== 'number' ||
+    algorithm.outputLength <= 0
+  ) {
+    throw lazyDOMException(
+      'KangarooTwelveParams.outputLength is required',
+      'OperationError',
+    );
+  }
+  if (algorithm.outputLength % 8) {
+    throw lazyDOMException(
+      'Invalid KangarooTwelveParams outputLength',
+      'OperationError',
+    );
+  }
+  const customization =
+    algorithm.customization !== undefined
+      ? bufferLikeToArrayBuffer(algorithm.customization)
+      : undefined;
+  return getTurboShake().kangarooTwelve(
+    name,
+    algorithm.outputLength / 8,
+    bufferLikeToArrayBuffer(data),
+    customization,
+  );
+};
+
 const internalDigest = (
   algorithm: SubtleAlgorithm,
   data: BufferLike,

package/src/hkdf.ts

@@ -45,6 +45,46 @@ function sanitizeInput(input: BinaryLike, name: string): ArrayBuffer {
   }
 }
 
+// Output byte-length of each fixed-length digest. HKDF requires a fixed-
+// output hash (it builds on HMAC), so XOFs like SHAKE128/256 are not
+// included even though `normalizeHashName` will accept them — passing
+// SHAKE here is a caller bug we surface as `Unsupported HKDF digest`
+// instead of letting the native side return an opaque error.
+const HKDF_HASH_BYTES: Readonly<Record<string, number>> = {
+  sha1: 20,
+  sha224: 28,
+  sha256: 32,
+  sha384: 48,
+  sha512: 64,
+  'sha3-256': 32,
+  'sha3-384': 48,
+  'sha3-512': 64,
+  ripemd160: 20,
+};
+
+function validateHkdfKeylen(digest: string, keylen: number): void {
+  if (
+    typeof keylen !== 'number' ||
+    !Number.isFinite(keylen) ||
+    !Number.isInteger(keylen) ||
+    keylen < 0 ||
+    keylen > 0x7fff_ffff
+  ) {
+    throw new TypeError('Bad key length');
+  }
+  const hashLen = HKDF_HASH_BYTES[digest.toLowerCase()];
+  if (hashLen === undefined) {
+    throw new TypeError(`Unsupported HKDF digest: ${digest}`);
+  }
+  // RFC 5869 §2.3: L ≤ 255 * HashLen.
+  if (keylen > 255 * hashLen) {
+    throw new RangeError(
+      `HKDF keylen ${keylen} exceeds RFC 5869 ceiling ` +
+        `255 * HashLen (${255 * hashLen}) for ${digest}`,
+    );
+  }
+}
+
 export function hkdf(
   digest: string,
   key: KeyMaterial,
@@ -61,9 +101,7 @@ export function hkdf(
     const sanitizedSalt = sanitizeInput(salt, 'Salt');
     const sanitizedInfo = sanitizeInput(info, 'Info');
 
-    if (keylen < 0) {
-      throw new TypeError('Bad key length');
-    }
+    validateHkdfKeylen(normalizedDigest, keylen);
 
     const nativeMod = getNative();
     nativeMod
@@ -99,9 +137,7 @@ export function hkdfSync(
   const sanitizedSalt = sanitizeInput(salt, 'Salt');
   const sanitizedInfo = sanitizeInput(info, 'Info');
 
-  if (keylen < 0) {
-    throw new TypeError('Bad key length');
-  }
+  validateHkdfKeylen(normalizedDigest, keylen);
 
   const nativeMod = getNative();
   const result = nativeMod.deriveKeySync(
@@ -134,6 +170,8 @@ export function hkdfDeriveBits(
   const hashName = typeof hash === 'string' ? hash : hash.name;
   const normalizedDigest = normalizeHashName(hashName);
 
+  validateHkdfKeylen(normalizedDigest, keylen);
+
   const nativeMod = getNative();
   const result = nativeMod.deriveKeySync(
     normalizedDigest,

package/src/hmac.ts

@@ -85,18 +85,28 @@ class Hmac extends Stream.Transform {
     return Buffer.from(nativeDigest);
   }
 
-  // stream interface
+  // Stream interface — surface synchronous errors via the callback so
+  // they emit as stream 'error' events instead of throwing out of the
+  // Transform plumbing.
   _transform(
     chunk: BinaryLike,
     encoding: BufferEncoding,
-    callback: () => void,
+    callback: (err?: Error | null) => void,
   ) {
-    this.update(chunk, encoding as Encoding);
-    callback();
+    try {
+      this.update(chunk, encoding as Encoding);
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
   }
-  _flush(callback: () => void) {
-    this.push(this.digest());
-    callback();
+  _flush(callback: (err?: Error | null) => void) {
+    try {
+      this.push(this.digest());
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
   }
 }