react-native-quick-crypto 1.0.0-beta.2 → 1.0.0-beta.21

package/src/utils/conversion.ts

@@ -1,16 +1,150 @@
-import { Buffer } from '@craftzdog/react-native-buffer';
-import type { ArrayBufferView } from './types';
+import { Buffer as CraftzdogBuffer } from '@craftzdog/react-native-buffer';
+import { Buffer as SafeBuffer } from 'safe-buffer';
+import type { ABV, BinaryLikeNode, BufferLike } from './types';
+import { KeyObject } from '../keys/classes';
 
-export const abvToArrayBuffer = (buffer: ArrayBufferView) => {
-  if (Buffer.isBuffer(buffer)) {
-    return buffer.buffer;
+/**
+ * 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
+ */
+export const abvToArrayBuffer = (buf: ABV) => {
+  if (CraftzdogBuffer.isBuffer(buf)) {
+    return buf.buffer as ArrayBuffer;
   }
-  if (ArrayBuffer.isView(buffer)) {
-    return buffer.buffer;
+  if (ArrayBuffer.isView(buf)) {
+    return buf.buffer as ArrayBuffer;
   }
-  return buffer;
+  return buf as ArrayBuffer;
 };
 
+/**
+ * Converts supplied argument to an ArrayBuffer.  Note this copies data if the
+ * supplied buffer has the .slice() method, so can be a bit slow.
+ * @param buf
+ * @returns ArrayBuffer
+ */
+export function toArrayBuffer(
+  buf: CraftzdogBuffer | SafeBuffer | ArrayBufferView,
+): ArrayBuffer {
+  if (CraftzdogBuffer.isBuffer(buf) || ArrayBuffer.isView(buf)) {
+    if (buf?.buffer?.slice) {
+      return buf.buffer.slice(
+        buf.byteOffset,
+        buf.byteOffset + buf.byteLength,
+      ) as ArrayBuffer;
+    } else {
+      return buf.buffer 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 {
+  // 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;
+  }
+
+  // If buf is a SharedArrayBuffer, convert it to ArrayBuffer.
+  // This typically involves a copy of the data.
+  if (
+    typeof SharedArrayBuffer !== 'undefined' &&
+    buf instanceof SharedArrayBuffer
+  ) {
+    const arrayBuffer = new ArrayBuffer(buf.byteLength);
+    new Uint8Array(arrayBuffer).set(new Uint8Array(buf));
+    return arrayBuffer;
+  }
+
+  // If we reach here, 'buf' is of a type within BufferLike that has not been handled by the above checks.
+  // This indicates either an incomplete BufferLike definition or an unexpected input type.
+  // Throw an error to signal this, ensuring the function's contract (return ArrayBuffer or throw) is met.
+  throw new TypeError(
+    'Input must be a Buffer, ArrayBufferView, ArrayBuffer, or SharedArrayBuffer.',
+  );
+}
+
+export function binaryLikeToArrayBuffer(
+  input: BinaryLikeNode, // CipherKey adds compat with node types
+  encoding: string = 'utf-8',
+): ArrayBuffer {
+  // string
+  if (typeof input === 'string') {
+    if (encoding === 'buffer') {
+      throw new Error(
+        'Cannot create a buffer from a string with a buffer 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
+  if (input instanceof KeyObject) {
+    return input.handle.exportKey();
+  }
+
+  throw new Error('input could not be converted to ArrayBuffer');
+}
+
 export function ab2str(buf: ArrayBuffer, encoding: string = 'hex') {
-  return Buffer.from(buf).toString(encoding);
+  return CraftzdogBuffer.from(buf).toString(encoding);
 }
+
+export const kEmptyObject = Object.freeze(Object.create(null));
+
+export * from './noble';

package/src/utils/errors.ts

@@ -0,0 +1,15 @@
+type DOMName =
+  | string
+  | {
+      name: string;
+      cause: unknown;
+    };
+
+export function lazyDOMException(message: string, domName: DOMName): Error {
+  let cause = '';
+  if (typeof domName !== 'string') {
+    cause = `\nCaused by: ${domName.cause}`;
+  }
+
+  return new Error(`[${domName}]: ${message}${cause}`);
+}

package/src/utils/hashnames.ts

@@ -0,0 +1,98 @@
+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',
+  },
+};
+
+{
+  // 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]!]!;
+    }
+  }
+}
+
+export function normalizeHashName(
+  algo: string | HashAlgorithm | { name: string } | undefined,
+  context: HashContext = HashContext.Node,
+): HashAlgorithm {
+  if (typeof algo !== 'undefined') {
+    const hashName =
+      typeof algo === 'string' ? algo : algo.name || algo.toString();
+    const normAlgo = hashName.toLowerCase();
+    try {
+      const alias = kHashNames[normAlgo]![context] as HashAlgorithm;
+      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

@@ -1,6 +1,6 @@
-import { ab2str, abvToArrayBuffer } from "./conversion";
-
-export const utils = {
-  ab2str,
-  abvToArrayBuffer,
-};
+export * from './conversion';
+export * from './errors';
+export * from './hashnames';
+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;
+}