react-native-quick-crypto 0.2.0

package/src/NativeQuickCrypto/pbkdf2.ts

@@ -0,0 +1,16 @@
+export type Pbkdf2Object = {
+  pbkdf2: (
+    password: ArrayBuffer,
+    salt: ArrayBuffer,
+    iterations: number,
+    keylen: number,
+    digest: string
+  ) => Promise<ArrayBuffer>;
+  pbkdf2Sync: (
+    password: ArrayBuffer,
+    salt: ArrayBuffer,
+    iterations: number,
+    keylen: number,
+    digest: string
+  ) => ArrayBuffer;
+};

package/src/NativeQuickCrypto/random.ts

@@ -0,0 +1,12 @@
+export type RandomObject = {
+  randomFill: (
+    buffer: ArrayBuffer,
+    offset: number,
+    size: number
+  ) => Promise<ArrayBuffer>;
+  randomFillSync: (
+    buffer: ArrayBuffer,
+    offset: number,
+    size: number
+  ) => ArrayBuffer;
+};

package/src/QuickCrypto.ts

@@ -0,0 +1,23 @@
+import * as pbkdf2 from './pbkdf2';
+import * as random from './random';
+import {
+  createCipher,
+  createCipheriv,
+  createDecipher,
+  createDecipheriv,
+} from './Cipher';
+import { createHmac } from './Hmac';
+import { createHash } from './Hash';
+
+export const QuickCrypto = {
+  createHmac,
+  Hmac: createHmac,
+  Hash: createHash,
+  createHash,
+  createCipher,
+  createCipheriv,
+  createDecipher,
+  createDecipheriv,
+  ...pbkdf2,
+  ...random,
+};

package/src/Utils.ts

@@ -0,0 +1,151 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+
+export type BinaryLike = string | ArrayBuffer | Buffer;
+
+export type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex' | 'binary';
+export type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';
+export type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';
+export type Encoding =
+  | BinaryToTextEncoding
+  | CharacterEncoding
+  | LegacyCharacterEncoding;
+
+// TODO(osp) should buffer be part of the Encoding type?
+export type CipherEncoding = Encoding | 'buffer';
+
+// Mimics node behavior for default global encoding
+let defaultEncoding: CipherEncoding = 'buffer';
+
+export function setDefaultEncoding(encoding: CipherEncoding) {
+  defaultEncoding = encoding;
+}
+
+export function getDefaultEncoding(): CipherEncoding {
+  return defaultEncoding;
+}
+
+// function slowCases(enc: string) {
+//   switch (enc.length) {
+//     case 4:
+//       if (enc === 'UTF8') return 'utf8';
+//       if (enc === 'ucs2' || enc === 'UCS2') return 'utf16le';
+//       enc = `${enc}`.toLowerCase();
+//       if (enc === 'utf8') return 'utf8';
+//       if (enc === 'ucs2') return 'utf16le';
+//       break;
+//     case 3:
+//       if (enc === 'hex' || enc === 'HEX' || `${enc}`.toLowerCase() === 'hex')
+//         return 'hex';
+//       break;
+//     case 5:
+//       if (enc === 'ascii') return 'ascii';
+//       if (enc === 'ucs-2') return 'utf16le';
+//       if (enc === 'UTF-8') return 'utf8';
+//       if (enc === 'ASCII') return 'ascii';
+//       if (enc === 'UCS-2') return 'utf16le';
+//       enc = `${enc}`.toLowerCase();
+//       if (enc === 'utf-8') return 'utf8';
+//       if (enc === 'ascii') return 'ascii';
+//       if (enc === 'ucs-2') return 'utf16le';
+//       break;
+//     case 6:
+//       if (enc === 'base64') return 'base64';
+//       if (enc === 'latin1' || enc === 'binary') return 'latin1';
+//       if (enc === 'BASE64') return 'base64';
+//       if (enc === 'LATIN1' || enc === 'BINARY') return 'latin1';
+//       enc = `${enc}`.toLowerCase();
+//       if (enc === 'base64') return 'base64';
+//       if (enc === 'latin1' || enc === 'binary') return 'latin1';
+//       break;
+//     case 7:
+//       if (
+//         enc === 'utf16le' ||
+//         enc === 'UTF16LE' ||
+//         `${enc}`.toLowerCase() === 'utf16le'
+//       )
+//         return 'utf16le';
+//       break;
+//     case 8:
+//       if (
+//         enc === 'utf-16le' ||
+//         enc === 'UTF-16LE' ||
+//         `${enc}`.toLowerCase() === 'utf-16le'
+//       )
+//         return 'utf16le';
+//       break;
+//     case 9:
+//       if (
+//         enc === 'base64url' ||
+//         enc === 'BASE64URL' ||
+//         `${enc}`.toLowerCase() === 'base64url'
+//       )
+//         return 'base64url';
+//       break;
+//     default:
+//       if (enc === '') return 'utf8';
+//   }
+// }
+
+// // Return undefined if there is no match.
+// // Move the "slow cases" to a separate function to make sure this function gets
+// // inlined properly. That prioritizes the common case.
+// export function normalizeEncoding(enc?: string) {
+//   if (enc == null || enc === 'utf8' || enc === 'utf-8') return 'utf8';
+//   return slowCases(enc);
+// }
+
+export function isBuffer(buf: any): buf is Buffer {
+  return buf instanceof Buffer || buf?.constructor?.name === 'Buffer';
+}
+
+export function toArrayBuffer(buf: Buffer): ArrayBuffer {
+  if (buf?.buffer?.slice) {
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  const ab = new ArrayBuffer(buf.length);
+  const view = new Uint8Array(ab);
+  for (let i = 0; i < buf.length; ++i) {
+    view[i] = buf[i];
+  }
+  return ab;
+}
+
+export function binaryLikeToArrayBuffer(
+  input: BinaryLike,
+  encoding: string = 'utf-8'
+): ArrayBuffer {
+  if (typeof input === 'string') {
+    const buffer = Buffer.from(input, encoding);
+
+    return buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength
+    );
+  }
+
+  if (isBuffer(input)) {
+    return toArrayBuffer(input);
+  }
+
+  // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property
+  if ((input as any).buffer) {
+    return (input as any).buffer;
+  }
+
+  if (!(input instanceof ArrayBuffer)) {
+    try {
+      const buffer = Buffer.from(input);
+      return buffer.buffer.slice(
+        buffer.byteOffset,
+        buffer.byteOffset + buffer.byteLength
+      );
+    } catch {
+      throw 'error';
+    }
+  }
+  return input;
+}
+
+export function ab2str(buf: ArrayBuffer, encoding: string = 'hex') {
+  return Buffer.from(buf).toString(encoding);
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './QuickCrypto';

package/src/pbkdf2.ts

@@ -0,0 +1,96 @@
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { BinaryLike, binaryLikeToArrayBuffer } from './Utils';
+
+const WRONG_PASS =
+  'Password must be a string, a Buffer, a typed array or a DataView';
+const WRON_SALT = `Salt must be a string, a Buffer, a typed array or a DataView`;
+
+type Password = BinaryLike;
+type Salt = BinaryLike;
+type Pbkdf2Callback = (err: Error | null, derivedKey?: Buffer) => void;
+
+function sanitizeInput(input: BinaryLike, errorMsg: string): ArrayBuffer {
+  try {
+    return binaryLikeToArrayBuffer(input);
+  } catch (e: any) {
+    throw errorMsg;
+  }
+}
+
+const nativePbkdf2 = NativeQuickCrypto.pbkdf2;
+
+export function pbkdf2(
+  password: Password,
+  salt: Salt,
+  iterations: number,
+  keylen: number,
+  digest: string,
+  callback: Pbkdf2Callback
+): void;
+export function pbkdf2(
+  password: Password,
+  salt: Salt,
+  iterations: number,
+  keylen: number,
+  callback: Pbkdf2Callback
+): void;
+export function pbkdf2(
+  password: Password,
+  salt: Salt,
+  iterations: number,
+  keylen: number,
+  arg0?: unknown,
+  arg1?: unknown
+): void {
+  let digest = 'sha1';
+  let callback: undefined | Pbkdf2Callback;
+  if (typeof arg0 === 'string') {
+    digest = arg0;
+    if (typeof arg1 === 'function') {
+      callback = arg1 as Pbkdf2Callback;
+    }
+  } else {
+    if (typeof arg0 === 'function') {
+      callback = arg0 as Pbkdf2Callback;
+    }
+  }
+  if (callback === undefined) {
+    throw new Error('No callback provided to pbkdf2');
+  }
+
+  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
+  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);
+
+  nativePbkdf2
+    .pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, digest)
+    .then(
+      (res: ArrayBuffer) => {
+        callback!(null, Buffer.from(res));
+      },
+      (e: Error) => {
+        callback!(e);
+      }
+    );
+}
+export function pbkdf2Sync(
+  password: Password,
+  salt: Salt,
+  iterations: number,
+  keylen: number,
+  digest?: string
+): Buffer {
+  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
+  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);
+
+  const algo = digest ? digest : 'sha1';
+  let result: ArrayBuffer = nativePbkdf2.pbkdf2Sync(
+    sanitizedPassword,
+    sanitizedSalt,
+    iterations,
+    keylen,
+    algo
+  );
+
+  return Buffer.from(result);
+}

package/src/random.ts

@@ -0,0 +1,277 @@
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { isBuffer } from '../src/Utils';
+
+const random = NativeQuickCrypto.random;
+
+type TypedArray =
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Float32Array
+  | Float64Array;
+type ArrayBufferView = TypedArray | DataView | ArrayBufferLike | Buffer;
+
+export function randomFill<T extends ArrayBufferView>(
+  buffer: T,
+  callback: (err: Error | null, buf: T) => void
+): void;
+
+export function randomFill<T extends ArrayBufferView>(
+  buffer: T,
+  offset: number,
+  callback: (err: Error | null, buf: T) => void
+): void;
+
+export function randomFill<T extends ArrayBufferView>(
+  buffer: T,
+  offset: number,
+  size: number,
+  callback: (err: Error | null, buf: T) => void
+): void;
+
+export function randomFill(buffer: any, ...rest: any[]): void {
+  if (typeof rest[rest.length - 1] !== 'function') {
+    throw new Error('No callback provided to randomDill');
+  }
+
+  const callback = rest[rest.length - 1] as any as (
+    err: Error | null,
+    buf?: ArrayBuffer
+  ) => void;
+
+  let offset: number = 0;
+  let size: number = buffer.byteLength;
+
+  if (typeof rest[2] === 'function') {
+    offset = rest[0];
+    size = rest[1];
+  }
+
+  if (typeof rest[1] === 'function') {
+    offset = rest[0];
+  }
+
+  random
+    .randomFill(isBuffer(buffer) ? buffer.buffer : buffer, offset, size)
+    .then(
+      () => {
+        callback(null, buffer);
+      },
+      (e: Error) => {
+        callback(e);
+      }
+    );
+}
+
+export function randomFillSync<T extends ArrayBufferView>(
+  buffer: T,
+  offset?: number,
+  size?: number
+): T;
+
+export function randomFillSync(buffer: any, offset: number = 0, size?: number) {
+  random.randomFillSync(
+    buffer.buffer ? buffer.buffer : buffer,
+    offset,
+    size ?? buffer.byteLength
+  );
+  return buffer;
+}
+
+export function randomBytes(size: number): ArrayBuffer;
+
+export function randomBytes(
+  size: number,
+  callback: (err: Error | null, buf?: ArrayBuffer) => void
+): void;
+
+export function randomBytes(
+  size: number,
+  callback?: (err: Error | null, buf?: ArrayBuffer) => void
+): void | ArrayBuffer {
+  const buf = new Buffer(size);
+
+  if (callback === undefined) {
+    randomFillSync(buf.buffer, 0, size);
+    return buf;
+  }
+
+  randomFill(buf.buffer, 0, size, (error: Error | null) => {
+    if (error) {
+      callback(error);
+    }
+    callback(null, buf);
+  });
+}
+
+export const rng = randomBytes;
+export const pseudoRandomBytes = randomBytes;
+export const prng = randomBytes;
+
+type RandomIntCallback = (err: Error | null, value: number) => void;
+type Task = {
+  min: number;
+  max: number;
+  callback: RandomIntCallback;
+};
+
+// The rest of the file is taken from https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js
+
+// Largest integer we can read from a buffer.
+// e.g.: Buffer.from("ff".repeat(6), "hex").readUIntBE(0, 6);
+const RAND_MAX = 0xffff_ffff_ffff;
+
+// Cache random data to use in randomInt. The cache size must be evenly
+// divisible by 6 because each attempt to obtain a random int uses 6 bytes.
+const randomCache = new Buffer(6 * 1024);
+let randomCacheOffset = randomCache.length;
+let asyncCacheFillInProgress = false;
+const asyncCachePendingTasks: Task[] = [];
+
+// Generates an integer in [min, max) range where min is inclusive and max is
+// exclusive.
+
+export function randomInt(max: number, callback: RandomIntCallback): void;
+export function randomInt(max: number): number;
+export function randomInt(
+  min: number,
+  max: number,
+  callback: RandomIntCallback
+): void;
+export function randomInt(min: number, max: number): number;
+export function randomInt(
+  arg1: number,
+  arg2?: number | RandomIntCallback,
+  callback?: RandomIntCallback
+): void | number {
+  // Detect optional min syntax
+  // randomInt(max)
+  // randomInt(max, callback)
+  let max: number;
+  let min: number;
+  const minNotSpecified =
+    typeof arg2 === 'undefined' || typeof arg2 === 'function';
+
+  if (minNotSpecified) {
+    callback = arg2 as any as undefined | RandomIntCallback;
+    max = arg1;
+    min = 0;
+  } else {
+    min = arg1;
+    max = arg2 as any as number;
+  }
+
+  const isSync = typeof callback === 'undefined';
+  if (!Number.isSafeInteger(min)) {
+    // todo throw new ERR_INVALID_ARG_TYPE('min', 'a safe integer', min);
+    throw 'ERR_INVALID_ARG_TYPE';
+  }
+  if (!Number.isSafeInteger(max)) {
+    // todo throw new ERR_INVALID_ARG_TYPE('max', 'a safe integer', max);
+    throw 'ERR_INVALID_ARG_TYPE';
+  }
+  if (max <= min) {
+    /* todo throw new ERR_OUT_OF_RANGE(
+      'max',
+      `greater than the value of "min" (${min})`,
+      max
+    );*/
+    throw 'ERR_OUT_OF_RANGE';
+  }
+
+  // First we generate a random int between [0..range)
+  const range = max - min;
+
+  if (!(range <= RAND_MAX)) {
+    /* todo throw new ERR_OUT_OF_RANGE(
+      `max${minNotSpecified ? '' : ' - min'}`,
+      `<= ${RAND_MAX}`,
+      range
+    );*/
+    throw 'ERR_OUT_OF_RANGE';
+  }
+
+  // For (x % range) to produce an unbiased value greater than or equal to 0 and
+  // less than range, x must be drawn randomly from the set of integers greater
+  // than or equal to 0 and less than randLimit.
+  const randLimit = RAND_MAX - (RAND_MAX % range);
+
+  // If we don't have a callback, or if there is still data in the cache, we can
+  // do this synchronously, which is super fast.
+  while (isSync || randomCacheOffset < randomCache.length) {
+    if (randomCacheOffset === randomCache.length) {
+      // This might block the thread for a bit, but we are in sync mode.
+      randomFillSync(randomCache);
+      randomCacheOffset = 0;
+    }
+
+    const x = randomCache.readUIntBE(randomCacheOffset, 6);
+    randomCacheOffset += 6;
+
+    if (x < randLimit) {
+      const n = (x % range) + min;
+      if (isSync) return n;
+      process.nextTick(callback as Function, undefined, n);
+      return;
+    }
+  }
+
+  // At this point, we are in async mode with no data in the cache. We cannot
+  // simply refill the cache, because another async call to randomInt might
+  // already be doing that. Instead, queue this call for when the cache has
+  // been refilled.
+  if (callback !== undefined) {
+    // it is (typescript doesn't know it)
+    asyncCachePendingTasks.push({ min, max, callback });
+    asyncRefillRandomIntCache();
+  }
+}
+
+function asyncRefillRandomIntCache() {
+  if (asyncCacheFillInProgress) return;
+
+  asyncCacheFillInProgress = true;
+  randomFill(randomCache, (err) => {
+    asyncCacheFillInProgress = false;
+
+    const tasks = asyncCachePendingTasks;
+    const errorReceiver = err && tasks.shift();
+    if (!err) randomCacheOffset = 0;
+
+    // Restart all pending tasks. If an error occurred, we only notify a single
+    // callback (errorReceiver) about it. This way, every async call to
+    // randomInt has a chance of being successful, and it avoids complex
+    // exception handling here.
+    tasks.splice(0).forEach((task) => {
+      randomInt(task.min, task.max, task.callback);
+    });
+
+    // This is the only call that might throw, and is therefore done at the end.
+    if (errorReceiver) errorReceiver.callback(err, 0);
+  });
+}
+
+// Really just the Web Crypto API alternative
+// to require('crypto').randomFillSync() with an
+// additional limitation that the input buffer is
+// not allowed to exceed 65536 bytes, and can only
+// be an integer-type TypedArray.
+type DataType =
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Uint8Array
+  | Uint16Array
+  | Uint32Array;
+export function getRandomValues(data: DataType) {
+  if (data.byteLength > 65536) {
+    throw new Error('The requested length exceeds 65,536 bytes');
+  }
+  randomFillSync(data, 0);
+  return data;
+}