react-native-quick-crypto 1.0.19 → 1.1.1

package/src/subtle.ts

@@ -83,16 +83,78 @@ function hasAnyNotIn(usages: KeyUsage[], allowed: KeyUsage[]): boolean {
   return usages.some(usage => !allowed.includes(usage));
 }
 
+// WebCrypto §18.4.4: algorithm name lookup is case-insensitive, but the
+// canonical mixed-case form is preserved in the resulting `name` field
+// (e.g. "aes-gcm" → "AES-GCM"). This map is built lazily on first call so
+// the registry of canonical names below can stay declared after the
+// function. Without this, callers who pass lowercase strings bypass the
+// downstream `SUPPORTED_ALGORITHMS` set comparisons silently.
+//
+// The map's value type is `AnyAlgorithm` so callers can use the lookup
+// result directly without re-asserting. The `as AnyAlgorithm` at insertion
+// is the single contract boundary: every name in `SUPPORTED_ALGORITHMS` is
+// already a member of `AnyAlgorithm` by construction.
+let _canonicalAlgorithmNames: Map<string, AnyAlgorithm> | null = null;
+function getCanonicalAlgorithmNames(): Map<string, AnyAlgorithm> {
+  if (_canonicalAlgorithmNames === null) {
+    const map = new Map<string, AnyAlgorithm>();
+    for (const set of Object.values(SUPPORTED_ALGORITHMS)) {
+      if (!set) continue;
+      for (const name of set) {
+        map.set(name.toLowerCase(), name as AnyAlgorithm);
+      }
+    }
+    _canonicalAlgorithmNames = map;
+  }
+  return _canonicalAlgorithmNames;
+}
+
 function normalizeAlgorithm(
   algorithm: SubtleAlgorithm | AnyAlgorithm,
   _operation: Operation,
 ): SubtleAlgorithm {
+  const map = getCanonicalAlgorithmNames();
   if (typeof algorithm === 'string') {
-    return { name: algorithm };
+    return { name: map.get(algorithm.toLowerCase()) ?? algorithm };
+  }
+  if (typeof algorithm.name === 'string') {
+    const canonical = map.get(algorithm.name.toLowerCase()) ?? algorithm.name;
+    return { ...algorithm, name: canonical };
   }
   return algorithm as SubtleAlgorithm;
 }
 
+// WebCrypto §25.7.6 (JWK import): if the JWK's `ext` member is present and
+// false, the requested `extractable` parameter must also be false. If the
+// JWK's `key_ops` member is present, every requested usage must appear in
+// it. We centralize the check here so every importKey path that accepts
+// `format === 'jwk'` can reuse it.
+function validateJwkExtAndKeyOps(
+  jwk: JWK,
+  extractable: boolean,
+  keyUsages: KeyUsage[],
+): void {
+  if (jwk.ext === false && extractable) {
+    throw lazyDOMException(
+      'JWK "ext" is false but extractable was requested',
+      'DataError',
+    );
+  }
+  if (jwk.key_ops !== undefined) {
+    if (!Array.isArray(jwk.key_ops)) {
+      throw lazyDOMException('JWK "key_ops" must be an array', 'DataError');
+    }
+    for (const usage of keyUsages) {
+      if (!jwk.key_ops.includes(usage)) {
+        throw lazyDOMException(
+          `JWK "key_ops" does not include requested usage "${usage}"`,
+          'DataError',
+        );
+      }
+    }
+  }
+}
+
 function getAlgorithmName(name: string, length: number): string {
   switch (name) {
     case 'AES-CBC':
@@ -816,6 +878,8 @@ async function kmacImportKey(
       throw lazyDOMException('Invalid keyData', 'DataError');
     }
 
+    validateJwkExtAndKeyOps(jwk, extractable, keyUsages);
+
     if (jwk.kty !== 'oct') {
       throw lazyDOMException('Invalid JWK format for KMAC key', 'DataError');
     }
@@ -902,6 +966,8 @@ function rsaImportKey(
       throw new Error('Invalid JWK format for RSA key');
     }
 
+    validateJwkExtAndKeyOps(jwk, extractable, keyUsages);
+
     const handle =
       NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
     const keyType = handle.initJwk(jwk, undefined);
@@ -992,6 +1058,8 @@ async function hmacImportKey(
       throw new Error('Invalid keyData');
     }
 
+    validateJwkExtAndKeyOps(jwk, extractable, keyUsages);
+
     if (jwk.kty !== 'oct') {
       throw new Error('Invalid JWK format for HMAC key');
     }
@@ -1069,6 +1137,8 @@ async function aesImportKey(
       throw new Error('Invalid JWK format for AES key');
     }
 
+    validateJwkExtAndKeyOps(jwk, extractable, keyUsages);
+
     const handle =
       NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
     const keyType = handle.initJwk(jwk, undefined);
@@ -1164,6 +1234,7 @@ function edImportKey(
     keyObject = new PublicKeyObject(handle);
   } else if (format === 'jwk') {
     const jwkData = data as JWK;
+    validateJwkExtAndKeyOps(jwkData, extractable, keyUsages);
     const handle =
       NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
     const keyType = handle.initJwk(jwkData);
@@ -1588,6 +1659,13 @@ const hkdfImportKey = async (
   keyUsages: KeyUsage[],
 ): Promise<CryptoKey> => {
   const { name } = algorithm;
+  // WebCrypto §28.7.6: HKDF keys are never extractable. The previous
+  // implementation passed `extractable` through verbatim, allowing callers
+  // to round-trip the input keying material via `exportKey` — defeating
+  // the whole point of the deriveBits-only usage.
+  if (extractable) {
+    throw lazyDOMException(`${name} keys are not extractable`, 'SyntaxError');
+  }
   if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {
     throw new Error(`Unsupported key usage for a ${name} key`);
   }
@@ -1595,7 +1673,7 @@ const hkdfImportKey = async (
   switch (format) {
     case 'raw': {
       const keyObject = createSecretKey(keyData as BinaryLike);
-      return new CryptoKey(keyObject, { name }, keyUsages, extractable);
+      return new CryptoKey(keyObject, { name }, keyUsages, false);
     }
     default:
       throw new Error(`Unable to import ${name} key with format ${format}`);
@@ -2161,12 +2239,16 @@ export class Subtle {
     baseKey: CryptoKey,
     length: number,
   ): Promise<ArrayBuffer> {
-    // Allow either deriveBits OR deriveKey usage (WebCrypto spec allows both)
-    if (
-      !baseKey.keyUsages.includes('deriveBits') &&
-      !baseKey.keyUsages.includes('deriveKey')
-    ) {
-      throw new Error('baseKey does not have deriveBits or deriveKey usage');
+    // WebCrypto §SubtleCrypto.deriveBits step 11: throw InvalidAccessError
+    // unless `baseKey.[[usages]]` contains "deriveBits" specifically. The
+    // previous `deriveBits || deriveKey` accept-either branch silently
+    // promoted deriveKey-only keys into deriveBits use, contradicting the
+    // spec usage gate.
+    if (!baseKey.keyUsages.includes('deriveBits')) {
+      throw lazyDOMException(
+        'baseKey does not have deriveBits usage',
+        'InvalidAccessError',
+      );
     }
     if (baseKey.algorithm.name !== algorithm.name)
       throw new Error('Key algorithm mismatch');

package/src/utils/cipher.ts

@@ -48,13 +48,35 @@ export function validateEncoding(data: string, encoding: string) {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function getUIntOption(options: Record<string, any>, key: string) {
-  let value;
-  if (options && (value = options[key]) != null) {
-    // >>> Turns any type into a positive integer (also sets the sign bit to 0)
-    if (value >>> 0 !== value) throw new Error(`options.${key}: ${value}`);
-    return value;
+/**
+ * Reads an unsigned-integer option from an options-like object.
+ *
+ * Returns `undefined` if the option is missing, `null`, or `undefined`.
+ * Throws `RangeError` if the value is present but not a non-negative
+ * 32-bit integer (NaN, Infinity, fractional, negative, or > 2^32 - 1).
+ *
+ * Replaces the previous `Record<string, any>` + sentinel-`-1` signature,
+ * which defeated the type checker (audit Phase 1.4). Callers that used
+ * `getUIntOption(opts ?? {}, key) !== -1 ? getUIntOption(...) : default`
+ * collapse to `getUIntOption(opts, key) ?? default`.
+ */
+export function getUIntOption(
+  options: Readonly<Record<string, unknown>> | undefined,
+  key: string,
+): number | undefined {
+  if (options == null) return undefined;
+  const value = options[key];
+  if (value == null) return undefined;
+  if (
+    typeof value !== 'number' ||
+    !Number.isFinite(value) ||
+    !Number.isInteger(value) ||
+    value < 0 ||
+    value > 0xffff_ffff
+  ) {
+    throw new RangeError(
+      `options.${key} must be a non-negative 32-bit integer, got ${String(value)}`,
+    );
   }
-  return -1;
+  return value;
 }

package/src/utils/conversion.ts

@@ -3,16 +3,65 @@ import { Buffer as SafeBuffer } from 'safe-buffer';
 import { NitroModules } from 'react-native-nitro-modules';
 import type { Utils } from '../specs/utils.nitro';
 import type { ABV, BinaryLikeNode, BufferLike } from './types';
+import { Platform } from 'react-native';
 
-const utils = NitroModules.createHybridObject<Utils>('Utils');
+type UtilsWithStringConverter = Utils & {
+  bufferToString(buffer: ArrayBuffer, encoding: string): string;
+  stringToBuffer(str: string, encoding: string): ArrayBuffer;
+};
+
+const utils =
+  NitroModules.createHybridObject<UtilsWithStringConverter>('Utils');
+
+const isHermes =
+  (global as { HermesInternal?: unknown }).HermesInternal != null;
+
+// v0.78.0, https://github.com/facebook/react-native/commit/c6f12254d16d87978383c08065a626d437e60450
+// Use jsi::String::getStringData() rather than jsi::String::utf16()
+const canGetU16StringFromJsiString = !(
+  Platform.constants.reactNativeVersion.major == 0 &&
+  Platform.constants.reactNativeVersion.minor < 78
+);
+
+// v0.79.0, https://github.com/facebook/react-native/commit/d9d824055e9f24614abd5657f9fc89a6ab3f2da2
+const canCreateJsiStringFromUtf16 = !(
+  Platform.constants.reactNativeVersion.major == 0 &&
+  Platform.constants.reactNativeVersion.minor < 79
+);
+
+const baseNativeEncodings = [
+  'hex',
+  'base64',
+  'base64url',
+  'utf8',
+  'utf-8',
+  'latin1',
+  'binary',
+  'ascii',
+];
+const nativeStringToBufferEncodings = new Set<string>(baseNativeEncodings);
+const nativeBufferToStringEncodings = new Set<string>(baseNativeEncodings);
+
+// The fast and lossless paths for utf16le are only available on Hermes
+if (isHermes) {
+  if (canGetU16StringFromJsiString) {
+    nativeStringToBufferEncodings.add('utf16le');
+  }
+  if (canCreateJsiStringFromUtf16) {
+    nativeBufferToStringEncodings.add('utf16le');
+  }
+}
 
 /**
- * Converts supplied argument to an ArrayBuffer.  Note this does not copy the
- * data so it is faster than toArrayBuffer.  Not copying is important for
- * functions like randomFill which need to be able to write to the underlying
- * buffer.
- * @param buf
- * @returns ArrayBuffer
+ * Returns the underlying ArrayBuffer of a Buffer / TypedArray view **without
+ * copying**, ignoring `byteOffset`/`byteLength`. The full backing storage is
+ * exposed.
+ *
+ * Only use this when the caller separately tracks `byteOffset`/`byteLength`
+ * and the native receiver needs to write back into the original memory
+ * (e.g. `randomFill`). For data that will be read by native crypto, use
+ * `binaryLikeToArrayBuffer`/`toArrayBuffer` instead — those slice to the
+ * view's region and won't leak unrelated bytes from the backing buffer.
  */
 export const abvToArrayBuffer = (buf: ABV) => {
   if (CraftzdogBuffer.isBuffer(buf)) {
@@ -97,7 +146,7 @@ export function binaryLikeToArrayBuffer(
       );
     }
 
-    if (nativeEncodings.has(encoding)) {
+    if (nativeStringToBufferEncodings.has(encoding)) {
       return utils.stringToBuffer(input, encoding);
     }
     const buffer = CraftzdogBuffer.from(input, encoding);
@@ -155,19 +204,8 @@ export function binaryLikeToArrayBuffer(
   );
 }
 
-const nativeEncodings = new Set([
-  'hex',
-  'base64',
-  'base64url',
-  'utf8',
-  'utf-8',
-  'latin1',
-  'binary',
-  'ascii',
-]);
-
 export function ab2str(buf: ArrayBuffer, encoding: string = 'hex'): string {
-  if (nativeEncodings.has(encoding)) {
+  if (nativeBufferToStringEncodings.has(encoding)) {
     return utils.bufferToString(buf, encoding);
   }
   return CraftzdogBuffer.from(buf).toString(encoding);

package/src/utils/timingSafeEqual.ts

@@ -1,7 +1,7 @@
 import { NitroModules } from 'react-native-nitro-modules';
 import type { Utils } from '../specs/utils.nitro';
 import type { ABV } from './types';
-import { abvToArrayBuffer } from './conversion';
+import { binaryLikeToArrayBuffer } from './conversion';
 
 let utils: Utils;
 function getNative(): Utils {
@@ -12,8 +12,13 @@ function getNative(): Utils {
 }
 
 export function timingSafeEqual(a: ABV, b: ABV): boolean {
-  const bufA = abvToArrayBuffer(a);
-  const bufB = abvToArrayBuffer(b);
+  // Use binaryLikeToArrayBuffer (not abvToArrayBuffer) so that TypedArray /
+  // Buffer views are sliced to their `byteOffset`/`byteLength` window. The
+  // zero-copy `abvToArrayBuffer` returns the entire backing buffer, which
+  // would (a) compare unrelated bytes and (b) silently fail the byte-length
+  // check for any view smaller than its backing.
+  const bufA = binaryLikeToArrayBuffer(a);
+  const bufB = binaryLikeToArrayBuffer(b);
 
   if (bufA.byteLength !== bufB.byteLength) {
     throw new RangeError('Input buffers must have the same byte length');

package/src/x509certificate.ts

@@ -78,12 +78,11 @@ export class X509Certificate {
       'X509CertificateHandle',
     );
 
-    let ab: ArrayBuffer;
-    if (typeof buffer === 'string') {
-      ab = Buffer.from(buffer).buffer as ArrayBuffer;
-    } else {
-      ab = binaryLikeToArrayBuffer(buffer);
-    }
+    // For string input, route through binaryLikeToArrayBuffer so the result
+    // is a tight ArrayBuffer of just the encoded bytes. `Buffer.from(str).buffer`
+    // can return a pool-backed ArrayBuffer with byteOffset > 0, exposing
+    // unrelated bytes (and giving the wrong byteLength) to native.
+    const ab: ArrayBuffer = binaryLikeToArrayBuffer(buffer);
 
     this.handle.init(ab);
   }

package/deps/blake3/.cargo/config.toml

@@ -1,2 +0,0 @@
-[target.wasm32-wasip1]
-runner = "wasmtime"

package/deps/blake3/.git-blame-ignore-revs

@@ -1,2 +0,0 @@
-# CMakeLists.txt whitespace fixups
-3e14f865d30271c74fc68d417af488ea91b66d48

package/deps/blake3/.github/workflows/build_b3sum.py

@@ -1,38 +0,0 @@
-#! /usr/bin/env python3
-
-from pathlib import Path
-import platform
-import shutil
-import subprocess
-import sys
-
-ROOT = Path(__file__).parent.parent.parent
-RUST_TARGET = sys.argv[1]
-
-subprocess.run(
-    ["cargo", "build", "--target", sys.argv[1], "--release"], cwd=ROOT / "b3sum"
-)
-
-if platform.system() == "Windows":
-    original_exe_name = "b3sum.exe"
-else:
-    original_exe_name = "b3sum"
-
-if platform.system() == "Windows":
-    new_exe_name = "b3sum_windows_x64_bin.exe"
-elif platform.system() == "Darwin":
-    new_exe_name = "b3sum_macos_x64_bin"
-elif platform.system() == "Linux":
-    new_exe_name = "b3sum_linux_x64_bin"
-else:
-    raise RuntimeError("Unexpected platform: " + platform.system())
-
-# Copy the built binary so that it has the upload name we want.
-out_dir = ROOT / "b3sum/target" / RUST_TARGET / "release"
-original_exe_path = str(out_dir / original_exe_name)
-new_exe_path = str(out_dir / new_exe_name)
-print("copying", repr(original_exe_path), "to", repr(new_exe_path))
-shutil.copyfile(original_exe_path, new_exe_path)
-
-# This lets the subsequent upload step get the filepath.
-print("::set-output name=bin_path::" + new_exe_path)