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

package/src/utils/cipher.ts

@@ -0,0 +1,82 @@
+import type { Encoding } from './types';
+
+// Mimics node behavior for default global encoding
+let defaultEncoding: Encoding = 'buffer';
+
+export function setDefaultEncoding(encoding: Encoding) {
+  defaultEncoding = encoding;
+}
+
+export function getDefaultEncoding(): Encoding {
+  return defaultEncoding;
+}
+
+export function normalizeEncoding(enc: string) {
+  if (!enc) return 'utf8';
+  let retried;
+  while (true) {
+    switch (enc) {
+      case 'utf8':
+      case 'utf-8':
+        return 'utf8';
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return 'utf16le';
+      case 'latin1':
+      case 'binary':
+        return 'latin1';
+      case 'base64':
+      case 'ascii':
+      case 'hex':
+        return enc;
+      default:
+        if (retried) return; // undefined
+        enc = ('' + enc).toLowerCase();
+        retried = true;
+    }
+  }
+}
+
+export function validateEncoding(data: string, encoding: string) {
+  const normalizedEncoding = normalizeEncoding(encoding);
+  const length = data.length;
+
+  if (normalizedEncoding === 'hex' && length % 2 !== 0) {
+    throw new Error(`Encoding ${encoding} not valid for data length ${length}`);
+  }
+}
+
+/**
+ * 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 value;
+}

package/src/utils/conversion.ts

@@ -0,0 +1,285 @@
+import { Buffer as CraftzdogBuffer } from '@craftzdog/react-native-buffer';
+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';
+
+type UtilsWithStringConverter = Utils & {
+  bufferToString(
+    buffer: ArrayBuffer,
+    encoding: string,
+    start?: number,
+    end?: number,
+  ): 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');
+  }
+}
+
+// WebCrypto / Web IDL §BufferSource: SharedArrayBuffer-backed inputs must
+// be rejected. Concurrent writes from another worker during async crypto
+// can corrupt computations or leak intermediate state, so even copying
+// the source isn't safe (the copy itself races). Reject at conversion.
+// See Node's `lib/internal/webidl.js` BufferSource converter (commit
+// bee10872588) — it throws TypeError, matching the WebIDL spec.
+//
+// We apply this guard to *every* conversion helper, not just the ones
+// reached from `subtle.*`. That's deliberately stricter than Node, whose
+// classic APIs (`createHash().update`, `createHmac().update`,
+// `createCipheriv().update`, etc.) accept SAB-backed views. The TOCTOU
+// concern is the same on either side of the WebCrypto / classic line, so
+// we prefer the safer default everywhere.
+export function rejectSharedArrayBuffer(buf: unknown): void {
+  if (typeof SharedArrayBuffer === 'undefined') return;
+  if (buf instanceof SharedArrayBuffer) {
+    throw new TypeError('SharedArrayBuffer is not a supported BufferSource');
+  }
+  if (
+    ArrayBuffer.isView(buf) &&
+    (buf as ArrayBufferView).buffer instanceof SharedArrayBuffer
+  ) {
+    throw new TypeError(
+      'View on a SharedArrayBuffer is not a supported BufferSource',
+    );
+  }
+}
+
+/**
+ * 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 return only the
+ * view's region and won't leak unrelated bytes from the backing buffer.
+ */
+export const abvToArrayBuffer = (buf: ABV) => {
+  rejectSharedArrayBuffer(buf);
+  if (CraftzdogBuffer.isBuffer(buf)) {
+    return buf.buffer as ArrayBuffer;
+  }
+  if (ArrayBuffer.isView(buf)) {
+    return buf.buffer as ArrayBuffer;
+  }
+  return buf as ArrayBuffer;
+};
+
+/**
+ * Converts supplied argument to an ArrayBuffer. Note this copies data
+ * only when the supplied view represents a subrange of the underlying
+ * ArrayBuffer; otherwise the backing buffer is returned directly
+ * (aliased — do not mutate after passing).
+ * @param buf
+ * @returns ArrayBuffer
+ */
+export function toArrayBuffer(
+  buf: CraftzdogBuffer | SafeBuffer | ArrayBufferView,
+): ArrayBuffer {
+  if (CraftzdogBuffer.isBuffer(buf) || ArrayBuffer.isView(buf)) {
+    if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+      return buf.buffer as ArrayBuffer;
+    } else {
+      return buf.buffer.slice(
+        buf.byteOffset,
+        buf.byteOffset + buf.byteLength,
+      ) as ArrayBuffer;
+    }
+  }
+  const ab = new ArrayBuffer(buf.length);
+  const view = new Uint8Array(ab);
+  for (let i = 0; i < buf.length; ++i) {
+    view[i] = SafeBuffer.isBuffer(buf) ? buf.readUInt8(i) : buf[i]!;
+  }
+  return ab;
+}
+
+export function bufferLikeToArrayBuffer(buf: BufferLike): ArrayBuffer {
+  rejectSharedArrayBuffer(buf);
+
+  // Buffer
+  if (CraftzdogBuffer.isBuffer(buf) || SafeBuffer.isBuffer(buf)) {
+    return toArrayBuffer(buf);
+  }
+  // ArrayBufferView
+  if (ArrayBuffer.isView(buf)) {
+    return toArrayBuffer(buf);
+  }
+
+  // If buf is already an ArrayBuffer, return it.
+  if (buf instanceof ArrayBuffer) {
+    return buf;
+  }
+
+  throw new TypeError(
+    'Input must be a Buffer, ArrayBufferView, or ArrayBuffer.',
+  );
+}
+
+export function binaryLikeToArrayBuffer(
+  input: BinaryLikeNode, // CipherKey adds compat with node types
+  encoding: string = 'utf-8',
+): ArrayBuffer {
+  rejectSharedArrayBuffer(input);
+
+  // string
+  if (typeof input === 'string') {
+    if (encoding === 'buffer') {
+      throw new Error(
+        'Cannot create a buffer from a string with a buffer encoding',
+      );
+    }
+
+    if (nativeStringToBufferEncodings.has(encoding)) {
+      return utils.stringToBuffer(input, encoding);
+    }
+    const buffer = CraftzdogBuffer.from(input, encoding);
+    return buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength,
+    );
+  }
+
+  // Buffer
+  if (CraftzdogBuffer.isBuffer(input) || SafeBuffer.isBuffer(input)) {
+    return toArrayBuffer(input);
+  }
+
+  // ArrayBufferView
+  // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property
+  if (ArrayBuffer.isView(input)) {
+    return toArrayBuffer(input);
+  }
+
+  // ArrayBuffer
+  if (input instanceof ArrayBuffer) {
+    return input;
+  }
+
+  // if (!(input instanceof ArrayBuffer)) {
+  //   try {
+  //     // this is a strange fallback case and input is unknown at this point
+  //     const buffer = Buffer.from(input as unknown as string);
+  //     return buffer.buffer.slice(
+  //       buffer.byteOffset,
+  //       buffer.byteOffset + buffer.byteLength
+  //     );
+  //   } catch(e: unknown) {
+  //     console.log('throwing 1');
+  //     const err = e as Error;
+  //     throw new Error(err.message);
+  //   }
+  // }
+
+  // KeyObject — duck-typed via Symbol.toStringTag to avoid circular dependency
+  // with keys/classes. The type assertion must match KeyObjectHandle.exportKey().
+  if (
+    typeof input === 'object' &&
+    input != null &&
+    Object.prototype.toString.call(input) === '[object KeyObject]'
+  ) {
+    return (
+      input as { handle: { exportKey(): ArrayBuffer } }
+    ).handle.exportKey();
+  }
+
+  throw new Error(
+    'Invalid argument type for "key". Need ArrayBuffer, TypedArray, KeyObject, CryptoKey, string',
+  );
+}
+
+export function ab2str(
+  buf: ArrayBuffer,
+  encoding: string = 'hex',
+  start?: number,
+  end?: number,
+): string {
+  if (nativeBufferToStringEncodings.has(encoding)) {
+    return bufferToString(buf, encoding, start, end);
+  }
+
+  return CraftzdogBuffer.from(buf).toString(encoding, start, end);
+}
+
+/** Native C++ buffer-to-string with arguments normalization*/
+export function bufferToString(
+  buf: ArrayBuffer,
+  encoding: string = 'hex',
+  start?: number,
+  end?: number,
+): string {
+  // https://github.com/nodejs/node/blob/v24.15.0/lib/buffer.js#L915-L928
+  if (start === undefined || start < 0) {
+    start = 0;
+  } else if (start >= buf.byteLength) {
+    return '';
+  } else {
+    start = Math.trunc(start) || 0;
+  }
+
+  if (end === undefined || end > buf.byteLength) {
+    end = buf.byteLength;
+  } else {
+    end = Math.trunc(end) || 0;
+  }
+
+  if (end <= start) {
+    return '';
+  }
+
+  return utils.bufferToString(buf, encoding, start, end);
+}
+
+/** Native C++ string-to-buffer — exposed for benchmarking */
+export function stringToBuffer(
+  str: string,
+  encoding: string = 'utf-8',
+): ArrayBuffer {
+  return utils.stringToBuffer(str, encoding);
+}
+
+export const kEmptyObject = Object.freeze(Object.create(null));
+
+export * from './noble';

package/src/utils/errors.ts

@@ -0,0 +1,83 @@
+type DOMName =
+  | string
+  | {
+      name: string;
+      cause: unknown;
+    };
+
+// Hermes (React Native) does not implement DOMException natively. Use it when
+// the host provides one; otherwise fall back to an Error subclass that exposes
+// the WebCrypto-relevant surface (.name, .message, .code) so consumers that
+// branch on `err.name === 'InvalidAccessError'` see the spec-correct value.
+const DOM_EXCEPTION_CODES: Record<string, number> = {
+  IndexSizeError: 1,
+  HierarchyRequestError: 3,
+  WrongDocumentError: 4,
+  InvalidCharacterError: 5,
+  NoModificationAllowedError: 7,
+  NotFoundError: 8,
+  NotSupportedError: 9,
+  InUseAttributeError: 10,
+  InvalidStateError: 11,
+  SyntaxError: 12,
+  InvalidModificationError: 13,
+  NamespaceError: 14,
+  InvalidAccessError: 15,
+  TypeMismatchError: 17,
+  SecurityError: 18,
+  NetworkError: 19,
+  AbortError: 20,
+  URLMismatchError: 21,
+  QuotaExceededError: 22,
+  TimeoutError: 23,
+  InvalidNodeTypeError: 24,
+  DataCloneError: 25,
+};
+
+const HostDOMException: typeof globalThis.DOMException | undefined = (
+  globalThis as { DOMException?: typeof globalThis.DOMException }
+).DOMException;
+
+class FallbackDOMException extends Error {
+  readonly code: number;
+  constructor(message: string, name: string) {
+    super(message);
+    this.name = name;
+    this.code = DOM_EXCEPTION_CODES[name] ?? 0;
+  }
+}
+
+export function lazyDOMException(message: string, domName: DOMName): Error {
+  const name = typeof domName === 'string' ? domName : domName.name;
+  const cause = typeof domName === 'string' ? undefined : domName.cause;
+
+  let err: Error;
+  if (HostDOMException) {
+    err =
+      cause !== undefined
+        ? new HostDOMException(message, { name, cause } as never)
+        : new HostDOMException(message, name);
+  } else {
+    err = new FallbackDOMException(message, name);
+    if (cause !== undefined) {
+      (err as Error & { cause?: unknown }).cause = cause;
+    }
+  }
+  return err;
+}
+
+// QuotaExceededError carries `quota` and `requested` numeric fields per the
+// WebIDL spec (https://webidl.spec.whatwg.org/#quotaexceedederror). DOMException
+// in legacy hosts does not expose these, so always use our subclass.
+export class QuotaExceededError extends FallbackDOMException {
+  readonly quota: number | null;
+  readonly requested: number | null;
+  constructor(
+    message: string,
+    options: { quota?: number; requested?: number } = {},
+  ) {
+    super(message, 'QuotaExceededError');
+    this.quota = options.quota ?? null;
+    this.requested = options.requested ?? null;
+  }
+}

package/src/utils/hashnames.ts

@@ -0,0 +1,129 @@
+import type { HashAlgorithm } from '.';
+
+export enum HashContext {
+  Node,
+  WebCrypto,
+  JwkRsa,
+  JwkRsaPss,
+  JwkRsaOaep,
+  JwkHmac,
+}
+
+// WebCrypto and JWK use a bunch of different names for the
+// standard set of SHA-* digest algorithms... which is ... fun.
+// Here we provide a utility for mapping between them in order
+// make it easier in the code.
+
+type HashNames = {
+  [key: string]: { [key in HashContext as string]: string };
+};
+
+const kHashNames: HashNames = {
+  sha1: {
+    [HashContext.Node]: 'sha1',
+    [HashContext.WebCrypto]: 'SHA-1',
+    [HashContext.JwkRsa]: 'RS1',
+    [HashContext.JwkRsaPss]: 'PS1',
+    [HashContext.JwkRsaOaep]: 'RSA-OAEP',
+    [HashContext.JwkHmac]: 'HS1',
+  },
+  sha224: {
+    [HashContext.Node]: 'sha224',
+    [HashContext.WebCrypto]: 'SHA-224',
+    [HashContext.JwkRsa]: 'RS224',
+    [HashContext.JwkRsaPss]: 'PS224',
+    [HashContext.JwkRsaOaep]: 'RSA-OAEP-224',
+    [HashContext.JwkHmac]: 'HS224',
+  },
+  sha256: {
+    [HashContext.Node]: 'sha256',
+    [HashContext.WebCrypto]: 'SHA-256',
+    [HashContext.JwkRsa]: 'RS256',
+    [HashContext.JwkRsaPss]: 'PS256',
+    [HashContext.JwkRsaOaep]: 'RSA-OAEP-256',
+    [HashContext.JwkHmac]: 'HS256',
+  },
+  sha384: {
+    [HashContext.Node]: 'sha384',
+    [HashContext.WebCrypto]: 'SHA-384',
+    [HashContext.JwkRsa]: 'RS384',
+    [HashContext.JwkRsaPss]: 'PS384',
+    [HashContext.JwkRsaOaep]: 'RSA-OAEP-384',
+    [HashContext.JwkHmac]: 'HS384',
+  },
+  sha512: {
+    [HashContext.Node]: 'sha512',
+    [HashContext.WebCrypto]: 'SHA-512',
+    [HashContext.JwkRsa]: 'RS512',
+    [HashContext.JwkRsaPss]: 'PS512',
+    [HashContext.JwkRsaOaep]: 'RSA-OAEP-512',
+    [HashContext.JwkHmac]: 'HS512',
+  },
+  ripemd160: {
+    [HashContext.Node]: 'ripemd160',
+    [HashContext.WebCrypto]: 'RIPEMD-160',
+  },
+  'sha3-256': {
+    [HashContext.Node]: 'sha3-256',
+    [HashContext.WebCrypto]: 'SHA3-256',
+  },
+  'sha3-384': {
+    [HashContext.Node]: 'sha3-384',
+    [HashContext.WebCrypto]: 'SHA3-384',
+  },
+  'sha3-512': {
+    [HashContext.Node]: 'sha3-512',
+    [HashContext.WebCrypto]: 'SHA3-512',
+  },
+  shake128: {
+    [HashContext.Node]: 'shake128',
+    [HashContext.WebCrypto]: 'cSHAKE128',
+  },
+  shake256: {
+    [HashContext.Node]: 'shake256',
+    [HashContext.WebCrypto]: 'cSHAKE256',
+  },
+};
+
+{
+  // Index the aliases
+  const keys: string[] = Object.keys(kHashNames);
+  for (let n: number = 0; n < keys.length; n++) {
+    const contexts: string[] = Object.keys(kHashNames[keys[n]!]!);
+    for (let i: number = 0; i < contexts.length; i++) {
+      const alias: string = kHashNames[keys[n]!]![contexts[i]!]!.toLowerCase();
+      if (kHashNames[alias] === undefined)
+        kHashNames[alias] = kHashNames[keys[n]!]!;
+    }
+  }
+
+  // Add OpenSSL legacy RSA-* aliases (e.g. RSA-SHA256 -> sha256)
+  for (let n: number = 0; n < keys.length; n++) {
+    const key = keys[n]!;
+    if (key.startsWith('sha') || key === 'ripemd160') {
+      const rsaAlias = 'rsa-' + key;
+      if (kHashNames[rsaAlias] === undefined) {
+        kHashNames[rsaAlias] = kHashNames[key]!;
+      }
+    }
+  }
+}
+
+export function normalizeHashName(
+  algo: string | HashAlgorithm | { name: string } | undefined,
+  context: HashContext = HashContext.Node,
+): string {
+  if (typeof algo !== 'undefined') {
+    const hashName =
+      typeof algo === 'string' ? algo : algo.name || algo.toString();
+    const normAlgo = hashName.toLowerCase();
+    try {
+      const alias = kHashNames[normAlgo]![context];
+      if (alias) return alias;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (_e) {
+      // ignore
+    }
+  }
+  throw new Error(`Invalid Hash Algorithm: ${algo}`);
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './conversion';
+export * from './errors';
+export * from './hashnames';
+export * from './timingSafeEqual';
+export * from './types';
+export * from './validation';
+export * from './cipher';

package/src/utils/noble.ts

@@ -0,0 +1,85 @@
+import type { Hex } from './types';
+
+/**
+ * Takes hex string or Uint8Array, converts to Uint8Array.
+ * Validates output length.
+ * Will throw error for other types.
+ * @param title descriptive title for an error e.g. 'private key'
+ * @param hex hex string or Uint8Array
+ * @param expectedLength optional, will compare to result array's length
+ * @returns
+ */
+export function ensureBytes(
+  title: string,
+  hex: Hex,
+  expectedLength?: number,
+): Uint8Array {
+  let res: Uint8Array;
+  if (typeof hex === 'string') {
+    try {
+      res = hexToBytes(hex);
+    } catch (e) {
+      throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);
+    }
+  } else if (isBytes(hex)) {
+    // Uint8Array.from() instead of hash.slice() because node.js Buffer
+    // is instance of Uint8Array, and its slice() creates **mutable** copy
+    res = Uint8Array.from(hex);
+  } else {
+    throw new Error(title + ' must be hex string or Uint8Array');
+  }
+  const len = res.length;
+  if (typeof expectedLength === 'number' && len !== expectedLength)
+    throw new Error(
+      title + ' of length ' + expectedLength + ' expected, got ' + len,
+    );
+  return res;
+}
+
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+export function isBytes(a: unknown): a is Uint8Array {
+  return (
+    a instanceof Uint8Array ||
+    (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array')
+  );
+}
+
+// We use optimized technique to convert hex string to byte array
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;
+function asciiToBase16(ch: number): number | undefined {
+  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48
+  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+  return;
+}
+
+/**
+ * Convert hex string to byte array. Uses built-in function, when available.
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+export function hexToBytes(hex: string): Uint8Array {
+  if (typeof hex !== 'string')
+    throw new Error('hex string expected, got ' + typeof hex);
+  // @ts-expect-error Uint8Array.fromHex
+  if (hasHexBuiltin) return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error('hex string expected, got unpadded hex of length ' + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === undefined || n2 === undefined) {
+      const char = hex.substring(hi, hi + 2);
+      throw new Error(
+        'hex string expected, got non-hex character "' +
+          char +
+          '" at index ' +
+          hi,
+      );
+    }
+    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+  }
+  return array;
+}

package/src/utils/timingSafeEqual.ts

@@ -0,0 +1,28 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { Utils } from '../specs/utils.nitro';
+import type { ABV } from './types';
+import { binaryLikeToArrayBuffer } from './conversion';
+
+let utils: Utils;
+function getNative(): Utils {
+  if (utils == null) {
+    utils = NitroModules.createHybridObject<Utils>('Utils');
+  }
+  return utils;
+}
+
+export function timingSafeEqual(a: ABV, b: ABV): boolean {
+  // 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');
+  }
+
+  return getNative().timingSafeEqual(bufA, bufB);
+}