react-native-quick-crypto 1.1.0 → 1.1.2

package/src/random.ts

@@ -1,6 +1,11 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 import type { ABV, RandomCallback } from './utils';
-import { abvToArrayBuffer } from './utils';
+import {
+  abvToArrayBuffer,
+  lazyDOMException,
+  QuotaExceededError,
+  rejectSharedArrayBuffer,
+} from './utils';
 import { NitroModules } from 'react-native-nitro-modules';
 import type { Random } from './specs/random.nitro';
 
@@ -59,8 +64,17 @@ export function randomFill(buffer: ABV, ...rest: unknown[]): void {
   }
 
   getNative();
-  random.randomFill(abvToArrayBuffer(buffer), viewOffset + offset, size).then(
+  const ab = abvToArrayBuffer(buffer);
+  const start = viewOffset + offset;
+  random.randomFill(ab, start, size).then(
     (res: ArrayBuffer) => {
+      // The native async path operates on a copy of the underlying buffer to
+      // avoid races with JS-owned memory on the worker thread, so the
+      // randomized bytes live in `res`, not in the caller's buffer. Copy them
+      // back to preserve Node's in-place randomFill semantics.
+      if (res !== ab) {
+        new Uint8Array(ab, start, size).set(new Uint8Array(res, start, size));
+      }
       callback(null, res);
     },
     (e: Error) => {
@@ -224,7 +238,7 @@ export function randomInt(
     if (x < randLimit) {
       const n = (x % range) + min;
       if (isSync) return n;
-      process.nextTick(callback as RandomIntCallback, undefined, n);
+      process.nextTick(callback as RandomIntCallback, null, n);
       return;
     }
   }
@@ -279,6 +293,27 @@ export type RandomTypedArrays =
   | Uint16Array
   | Uint32Array;
 
+// WebCrypto §getRandomValues only accepts integer-typed views. Float and
+// non-TypedArray ABVs (DataView) must be rejected with a TypeMismatchError
+// DOMException — see https://w3c.github.io/webcrypto/#Crypto-method-getRandomValues
+const INTEGER_TYPED_ARRAY_TAGS = new Set([
+  'Int8Array',
+  'Int16Array',
+  'Int32Array',
+  'Uint8Array',
+  'Uint8ClampedArray',
+  'Uint16Array',
+  'Uint32Array',
+  'BigInt64Array',
+  'BigUint64Array',
+]);
+
+function isIntegerTypedArray(value: unknown): boolean {
+  if (!ArrayBuffer.isView(value)) return false;
+  const tag = (value as { [Symbol.toStringTag]?: string })[Symbol.toStringTag];
+  return tag !== undefined && INTEGER_TYPED_ARRAY_TAGS.has(tag);
+}
+
 /**
  * Fills the provided typed array with cryptographically strong random values.
  *
@@ -286,8 +321,24 @@ export type RandomTypedArrays =
  * @returns The filled data
  */
 export function getRandomValues(data: RandomTypedArrays) {
+  // WebIDL BufferSource conversion (TypeError) must run before the
+  // WebCrypto-specific integer-type / size checks (TypeMismatchError /
+  // QuotaExceededError). `randomFillSync` below also rejects SAB via
+  // `abvToArrayBuffer`, but by then we'd already have thrown the wrong
+  // error type for a non-integer SAB-view, so the explicit early call is
+  // load-bearing for spec compliance — not redundant.
+  rejectSharedArrayBuffer(data);
+  if (!isIntegerTypedArray(data)) {
+    throw lazyDOMException(
+      'The data argument must be an integer-type TypedArray',
+      'TypeMismatchError',
+    );
+  }
   if (data.byteLength > 65536) {
-    throw new Error('The requested length exceeds 65,536 bytes');
+    throw new QuotaExceededError('The requested length exceeds 65,536 bytes', {
+      quota: 65536,
+      requested: data.byteLength,
+    });
   }
   randomFillSync(data, 0);
   return data;
@@ -299,14 +350,28 @@ for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 0x100).toString(16).slice(1));
 }
 
-// Based on https://github.com/uuidjs/uuid/blob/main/src/v4.js
-export function randomUUID() {
-  const size = 16;
-  const buffer = new Buffer(size);
-  randomFillSync(buffer, 0, size);
+export interface RandomUUIDOptions {
+  // Accepted for Node.js parity. RNQC does not buffer entropy, so this is a
+  // no-op: every UUID already pulls fresh bytes from the OS CSPRNG.
+  disableEntropyCache?: boolean;
+}
 
-  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-  buffer[6] = (buffer[6]! & 0x0f) | 0x40;
+function validateRandomUUIDOptions(options?: RandomUUIDOptions): void {
+  if (options === undefined) return;
+  if (typeof options !== 'object' || options === null) {
+    throw new TypeError('options must be an object');
+  }
+  if (
+    options.disableEntropyCache !== undefined &&
+    typeof options.disableEntropyCache !== 'boolean'
+  ) {
+    throw new TypeError('options.disableEntropyCache must be a boolean');
+  }
+}
+
+// RFC 9562 variant 10xx is shared by v4 and v7.
+function serializeUUID(buffer: Buffer, version: number): string {
+  buffer[6] = (buffer[6]! & 0x0f) | (version << 4);
   buffer[8] = (buffer[8]! & 0x3f) | 0x80;
 
   return (
@@ -332,3 +397,31 @@ export function randomUUID() {
     byteToHex[buffer[15]!]
   ).toLowerCase();
 }
+
+// RFC 9562 §5.4 — random UUID (v4).
+export function randomUUID(options?: RandomUUIDOptions): string {
+  validateRandomUUIDOptions(options);
+  const buffer = new Buffer(16);
+  randomFillSync(buffer, 0, 16);
+  return serializeUUID(buffer, 4);
+}
+
+// RFC 9562 §5.7 — Unix-ms timestamped UUID (v7).
+// Layout: 48-bit big-endian Unix-ms timestamp | 4-bit version (7) |
+// 12 bits random | 2-bit variant (10) | 62 bits random.
+export function randomUUIDv7(options?: RandomUUIDOptions): string {
+  validateRandomUUIDOptions(options);
+  const buffer = new Buffer(16);
+  randomFillSync(buffer, 6, 10);
+
+  const now = Date.now();
+  const msb = Math.floor(now / 0x100000000);
+  buffer[0] = (msb >>> 8) & 0xff;
+  buffer[1] = msb & 0xff;
+  buffer[2] = (now >>> 24) & 0xff;
+  buffer[3] = (now >>> 16) & 0xff;
+  buffer[4] = (now >>> 8) & 0xff;
+  buffer[5] = now & 0xff;
+
+  return serializeUUID(buffer, 7);
+}

package/src/rsa.ts

@@ -60,6 +60,13 @@ export class Rsa {
   }
 }
 
+// Modern best practice (NIST SP 800-131A Rev. 2, IETF RFC 8017): RSA keys
+// shorter than 2048 bits are deprecated for both signing and encryption.
+// 1024-bit moduli have been factored in academic settings; 768-bit keys
+// have been factored on commodity hardware. Reject anything below 2048
+// at the JS boundary so callers can't accidentally generate weak keys.
+const RSA_MIN_MODULUS_LENGTH = 2048;
+
 // Node API
 export async function rsa_generateKeyPair(
   algorithm: SubtleAlgorithm,
@@ -70,8 +77,12 @@ export async function rsa_generateKeyPair(
     algorithm as RsaHashedKeyGenParams;
 
   // Validate parameters first
-  if (!modulusLength || modulusLength < 256) {
-    throw lazyDOMException('Invalid key length', 'OperationError');
+  if (!modulusLength || modulusLength < RSA_MIN_MODULUS_LENGTH) {
+    throw lazyDOMException(
+      `RSA modulusLength must be at least ${RSA_MIN_MODULUS_LENGTH} bits ` +
+        `(got ${modulusLength ?? 0})`,
+      'OperationError',
+    );
   }
 
   if (!publicExponent || publicExponent.length === 0) {
@@ -198,8 +209,11 @@ function rsa_prepareKeyGenParams(
     hash?: string;
   };
 
-  if (!modulusLength || modulusLength < 256) {
-    throw new Error('Invalid modulus length');
+  if (!modulusLength || modulusLength < RSA_MIN_MODULUS_LENGTH) {
+    throw new RangeError(
+      `RSA modulusLength must be at least ${RSA_MIN_MODULUS_LENGTH} bits ` +
+        `(got ${modulusLength ?? 0})`,
+    );
   }
 
   const pubExp = publicExponent || 65537;
@@ -246,6 +260,14 @@ function rsa_formatKeyPairOutput(
   let publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
   let privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
 
+  if (
+    publicFormat === 'raw-public' ||
+    privateFormat === 'raw-private' ||
+    privateFormat === 'raw-seed'
+  ) {
+    throw new Error('Raw key formats are not supported for RSA keys');
+  }
+
   if (publicFormat === -1) {
     publicKey = pub;
   } else {

package/src/scrypt.ts

@@ -35,12 +35,83 @@ const defaults = {
   maxmem: 32 * 1024 * 1024,
 };
 
+// RFC 7914 § 2: scrypt parameters
+//   N — CPU/memory cost; must be a power of 2 > 1.
+//   r — block size; positive integer.
+//   p — parallelization factor; positive integer.
+//   r * p must be < 2^30 (otherwise the spec output is undefined).
+//   The work buffer is 128 * r * N bytes, which must fit in maxmem.
+const SCRYPT_MAX_RP = 1 << 30; // 2^30 per RFC 7914
+
+function isPositiveInteger(value: unknown): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isFinite(value) &&
+    Number.isInteger(value) &&
+    value > 0
+  );
+}
+
+function validateScryptParams(
+  N: number,
+  r: number,
+  p: number,
+  maxmem: number,
+): void {
+  if (!isPositiveInteger(N)) {
+    throw new RangeError(`Invalid scrypt cost (N): ${N}`);
+  }
+  // Power-of-two & > 1 check (RFC 7914 §6 step 1).
+  if (N <= 1 || (N & (N - 1)) !== 0) {
+    throw new RangeError(
+      `Invalid scrypt cost (N): ${N} — must be a power of 2 greater than 1`,
+    );
+  }
+  if (!isPositiveInteger(r)) {
+    throw new RangeError(`Invalid scrypt blockSize (r): ${r}`);
+  }
+  if (!isPositiveInteger(p)) {
+    throw new RangeError(`Invalid scrypt parallelization (p): ${p}`);
+  }
+  if (r * p >= SCRYPT_MAX_RP) {
+    throw new RangeError(
+      `Invalid scrypt parameters: r * p (${r * p}) must be < 2^30`,
+    );
+  }
+  if (!isPositiveInteger(maxmem)) {
+    throw new RangeError(`Invalid scrypt maxmem: ${maxmem}`);
+  }
+  // 128 * r * N is the minimum working memory. Reject early so we don't
+  // hand a doomed parameter set to native and OOM the device.
+  const required = 128 * r * N;
+  if (required > maxmem) {
+    throw new RangeError(
+      `Invalid scrypt parameters: working memory ${required} bytes ` +
+        `exceeds maxmem ${maxmem}`,
+    );
+  }
+}
+
+function validateScryptKeylen(keylen: number): void {
+  if (
+    typeof keylen !== 'number' ||
+    !Number.isFinite(keylen) ||
+    !Number.isInteger(keylen) ||
+    keylen < 0 ||
+    keylen > 0x7fff_ffff
+  ) {
+    throw new TypeError('Bad key length');
+  }
+}
+
 function getScryptParams(options?: ScryptOptions) {
   const N = options?.N ?? options?.cost ?? defaults.N;
   const r = options?.r ?? options?.blockSize ?? defaults.r;
   const p = options?.p ?? options?.parallelization ?? defaults.p;
   const maxmem = options?.maxmem ?? defaults.maxmem;
 
+  validateScryptParams(N, r, p, maxmem);
+
   return { N, r, p, maxmem };
 }
 
@@ -85,9 +156,7 @@ export function scrypt(
     const sanitizedPassword = sanitizeInput(password, 'Password');
     const sanitizedSalt = sanitizeInput(salt, 'Salt');
 
-    if (keylen < 0) {
-      throw new TypeError('Bad key length');
-    }
+    validateScryptKeylen(keylen);
 
     const nativeMod = getNative();
     nativeMod
@@ -115,9 +184,7 @@ export function scryptSync(
   const sanitizedPassword = sanitizeInput(password, 'Password');
   const sanitizedSalt = sanitizeInput(salt, 'Salt');
 
-  if (keylen < 0) {
-    throw new TypeError('Bad key length');
-  }
+  validateScryptKeylen(keylen);
 
   const nativeMod = getNative();
   const result = nativeMod.deriveKeySync(

package/src/slhdsa.ts

@@ -0,0 +1,146 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { SlhDsaKeyPair } from './specs/slhDsaKeyPair.nitro';
+import {
+  CryptoKey,
+  KeyObject,
+  PublicKeyObject,
+  PrivateKeyObject as PrivateKeyObjectClass,
+} from './keys/classes';
+import type {
+  CryptoKeyPair,
+  KeyUsage,
+  SubtleAlgorithm,
+  SlhDsaAlgorithm,
+} from './utils';
+import {
+  hasAnyNotIn,
+  lazyDOMException,
+  getUsagesUnion,
+  KFormatType,
+  KeyEncoding,
+} from './utils';
+
+export type SlhDsaVariant = SlhDsaAlgorithm;
+
+export const SLH_DSA_VARIANTS: readonly SlhDsaVariant[] = [
+  'SLH-DSA-SHA2-128s',
+  'SLH-DSA-SHA2-128f',
+  'SLH-DSA-SHA2-192s',
+  'SLH-DSA-SHA2-192f',
+  'SLH-DSA-SHA2-256s',
+  'SLH-DSA-SHA2-256f',
+  'SLH-DSA-SHAKE-128s',
+  'SLH-DSA-SHAKE-128f',
+  'SLH-DSA-SHAKE-192s',
+  'SLH-DSA-SHAKE-192f',
+  'SLH-DSA-SHAKE-256s',
+  'SLH-DSA-SHAKE-256f',
+] as const;
+
+export class SlhDsa {
+  variant: SlhDsaVariant;
+  native: SlhDsaKeyPair;
+
+  constructor(variant: SlhDsaVariant) {
+    this.variant = variant;
+    this.native =
+      NitroModules.createHybridObject<SlhDsaKeyPair>('SlhDsaKeyPair');
+    this.native.setVariant(variant);
+  }
+
+  async generateKeyPair(): Promise<void> {
+    await this.native.generateKeyPair(
+      KFormatType.DER,
+      KeyEncoding.SPKI,
+      KFormatType.DER,
+      KeyEncoding.PKCS8,
+    );
+  }
+
+  generateKeyPairSync(): void {
+    this.native.generateKeyPairSync(
+      KFormatType.DER,
+      KeyEncoding.SPKI,
+      KFormatType.DER,
+      KeyEncoding.PKCS8,
+    );
+  }
+
+  getPublicKey(): ArrayBuffer {
+    return this.native.getPublicKey();
+  }
+
+  getPrivateKey(): ArrayBuffer {
+    return this.native.getPrivateKey();
+  }
+
+  async sign(message: ArrayBuffer): Promise<ArrayBuffer> {
+    return this.native.sign(message);
+  }
+
+  signSync(message: ArrayBuffer): ArrayBuffer {
+    return this.native.signSync(message);
+  }
+
+  async verify(signature: ArrayBuffer, message: ArrayBuffer): Promise<boolean> {
+    return this.native.verify(signature, message);
+  }
+
+  verifySync(signature: ArrayBuffer, message: ArrayBuffer): boolean {
+    return this.native.verifySync(signature, message);
+  }
+}
+
+export async function slhdsa_generateKeyPairWebCrypto(
+  variant: SlhDsaVariant,
+  extractable: boolean,
+  keyUsages: KeyUsage[],
+): Promise<CryptoKeyPair> {
+  if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+    throw lazyDOMException(
+      `Unsupported key usage for ${variant}`,
+      'SyntaxError',
+    );
+  }
+
+  const publicUsages = getUsagesUnion(keyUsages, 'verify');
+  const privateUsages = getUsagesUnion(keyUsages, 'sign');
+
+  if (privateUsages.length === 0) {
+    throw lazyDOMException('Usages cannot be empty', 'SyntaxError');
+  }
+
+  const slhdsa = new SlhDsa(variant);
+  await slhdsa.generateKeyPair();
+
+  const publicKeyData = slhdsa.getPublicKey();
+  const privateKeyData = slhdsa.getPrivateKey();
+
+  const pub = KeyObject.createKeyObject(
+    'public',
+    publicKeyData,
+    KFormatType.DER,
+    KeyEncoding.SPKI,
+  ) as PublicKeyObject;
+  const publicKey = new CryptoKey(
+    pub,
+    { name: variant } as SubtleAlgorithm,
+    publicUsages,
+    true,
+  );
+
+  const priv = KeyObject.createKeyObject(
+    'private',
+    privateKeyData,
+    KFormatType.DER,
+    KeyEncoding.PKCS8,
+  ) as PrivateKeyObjectClass;
+  const privateKey = new CryptoKey(
+    priv,
+    { name: variant } as SubtleAlgorithm,
+    privateUsages,
+    extractable,
+  );
+
+  return { publicKey, privateKey };
+}

package/src/specs/keyObjectHandle.nitro.ts

@@ -18,6 +18,11 @@ export interface KeyObjectHandle
     passphrase?: ArrayBuffer,
   ): ArrayBuffer;
   exportJwk(key: JWK, handleRsaPss: boolean): JWK;
+  exportRawPublic(): ArrayBuffer;
+  exportRawPrivate(): ArrayBuffer;
+  exportRawSeed(): ArrayBuffer;
+  exportECPublicRaw(compressed: boolean): ArrayBuffer;
+  exportECPrivateRaw(): ArrayBuffer;
   getAsymmetricKeyType(): AsymmetricKeyType;
   init(
     keyType: KeyType,
@@ -32,8 +37,20 @@ export interface KeyObjectHandle
     keyData: ArrayBuffer,
     isPublic: boolean,
   ): boolean;
+  initRawPublic(
+    asymmetricKeyType: string,
+    keyData: ArrayBuffer,
+    namedCurve?: string,
+  ): boolean;
+  initRawPrivate(
+    asymmetricKeyType: string,
+    keyData: ArrayBuffer,
+    namedCurve?: string,
+  ): boolean;
+  initRawSeed(asymmetricKeyType: string, keyData: ArrayBuffer): boolean;
   initJwk(keyData: JWK, namedCurve?: NamedCurve): KeyType | undefined;
   keyDetail(): KeyDetail;
   keyEquals(other: KeyObjectHandle): boolean;
   getSymmetricKeySize(): number;
+  checkEcKeyData(): boolean;
 }

package/src/specs/slhDsaKeyPair.nitro.ts

@@ -0,0 +1,29 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface SlhDsaKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): Promise<void>;
+
+  generateKeyPairSync(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+
+  sign(message: ArrayBuffer): Promise<ArrayBuffer>;
+  signSync(message: ArrayBuffer): ArrayBuffer;
+
+  verify(signature: ArrayBuffer, message: ArrayBuffer): Promise<boolean>;
+  verifySync(signature: ArrayBuffer, message: ArrayBuffer): boolean;
+
+  setVariant(variant: string): void;
+}

package/src/specs/turboshake.nitro.ts

@@ -0,0 +1,21 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export type TurboShakeVariant = 'TurboSHAKE128' | 'TurboSHAKE256';
+export type KangarooTwelveVariant = 'KT128' | 'KT256';
+
+export interface TurboShake
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  turboShake(
+    variant: TurboShakeVariant,
+    domainSeparation: number,
+    outputLength: number,
+    data: ArrayBuffer,
+  ): Promise<ArrayBuffer>;
+
+  kangarooTwelve(
+    variant: KangarooTwelveVariant,
+    outputLength: number,
+    data: ArrayBuffer,
+    customization?: ArrayBuffer,
+  ): Promise<ArrayBuffer>;
+}

package/src/specs/utils.nitro.ts

@@ -2,6 +2,4 @@ import { type HybridObject } from 'react-native-nitro-modules';
 
 export interface Utils extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   timingSafeEqual(a: ArrayBuffer, b: ArrayBuffer): boolean;
-  bufferToString(buffer: ArrayBuffer, encoding: string): string;
-  stringToBuffer(str: string, encoding: string): ArrayBuffer;
 }