react-native-quick-crypto 0.2.0

package/lib/module/random.js

@@ -0,0 +1,190 @@
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { isBuffer } from '../src/Utils';
+const random = NativeQuickCrypto.random;
+export function randomFill(buffer) {
+  var _ref, _ref2;
+
+  if (typeof (_ref = (arguments.length <= 1 ? 0 : arguments.length - 1) - 1 + 1, _ref < 1 || arguments.length <= _ref ? undefined : arguments[_ref]) !== 'function') {
+    throw new Error('No callback provided to randomDill');
+  }
+
+  const callback = (_ref2 = (arguments.length <= 1 ? 0 : arguments.length - 1) - 1 + 1, _ref2 < 1 || arguments.length <= _ref2 ? undefined : arguments[_ref2]);
+  let offset = 0;
+  let size = buffer.byteLength;
+
+  if (typeof (arguments.length <= 3 ? undefined : arguments[3]) === 'function') {
+    offset = arguments.length <= 1 ? undefined : arguments[1];
+    size = arguments.length <= 2 ? undefined : arguments[2];
+  }
+
+  if (typeof (arguments.length <= 2 ? undefined : arguments[2]) === 'function') {
+    offset = arguments.length <= 1 ? undefined : arguments[1];
+  }
+
+  random.randomFill(isBuffer(buffer) ? buffer.buffer : buffer, offset, size).then(() => {
+    callback(null, buffer);
+  }, e => {
+    callback(e);
+  });
+}
+export function randomFillSync(buffer) {
+  let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  let size = arguments.length > 2 ? arguments[2] : undefined;
+  random.randomFillSync(buffer.buffer ? buffer.buffer : buffer, offset, size !== null && size !== void 0 ? size : buffer.byteLength);
+  return buffer;
+}
+export function randomBytes(size, callback) {
+  const buf = new Buffer(size);
+
+  if (callback === undefined) {
+    randomFillSync(buf.buffer, 0, size);
+    return buf;
+  }
+
+  randomFill(buf.buffer, 0, size, error => {
+    if (error) {
+      callback(error);
+    }
+
+    callback(null, buf);
+  });
+}
+export const rng = randomBytes;
+export const pseudoRandomBytes = randomBytes;
+export const prng = randomBytes;
+// 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 = 0xffffffffffff; // 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 = []; // Generates an integer in [min, max) range where min is inclusive and max is
+// exclusive.
+
+export function randomInt(arg1, arg2, callback) {
+  // Detect optional min syntax
+  // randomInt(max)
+  // randomInt(max, callback)
+  let max;
+  let min;
+  const minNotSpecified = typeof arg2 === 'undefined' || typeof arg2 === 'function';
+
+  if (minNotSpecified) {
+    callback = arg2;
+    max = arg1;
+    min = 0;
+  } else {
+    min = arg1;
+    max = arg2;
+  }
+
+  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, 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.
+
+
+export function getRandomValues(data) {
+  if (data.byteLength > 65536) {
+    throw new Error('The requested length exceeds 65,536 bytes');
+  }
+
+  randomFillSync(data, 0);
+  return data;
+}
+//# sourceMappingURL=random.js.map

package/lib/module/random.js.map

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

package/lib/typescript/Cipher.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import Stream from 'stream';
+import { BinaryLike, CipherEncoding, Encoding } from './Utils';
+import type { Buffer } from '@craftzdog/react-native-buffer';
+declare class CipherCommon extends Stream.Transform {
+    private internal;
+    private decoder;
+    constructor(cipherType: string, cipherKey: BinaryLike, isCipher: boolean, options?: Record<string, any>, iv?: BinaryLike | null);
+    update(data: BinaryLike, inputEncoding?: CipherEncoding, outputEncoding?: CipherEncoding): ArrayBuffer | string;
+    final(): ArrayBuffer;
+    final(outputEncoding: BufferEncoding | 'buffer'): string;
+    _transform(chunk: BinaryLike, encoding: Encoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+    setAutoPadding(autoPadding?: boolean): this;
+    setAAD(buffer: Buffer, options?: {
+        plaintextLength: number;
+    }): this;
+    setAuthTag(tag: Buffer): this;
+}
+declare class Cipher extends CipherCommon {
+    constructor(cipherType: string, cipherKey: BinaryLike, options?: Record<string, any>, iv?: BinaryLike | null);
+}
+declare class Decipher extends CipherCommon {
+    constructor(cipherType: string, cipherKey: BinaryLike, options?: Record<string, any>, iv?: BinaryLike | null);
+}
+export declare function createDecipher(algorithm: string, password: BinaryLike, options?: Stream.TransformOptions): Decipher;
+export declare function createDecipheriv(algorithm: string, key: BinaryLike, iv: BinaryLike | null, options?: Stream.TransformOptions): Decipher;
+export declare function createCipher(algorithm: string, password: BinaryLike, options?: Stream.TransformOptions): Cipher;
+export declare function createCipheriv(algorithm: string, key: BinaryLike, iv: BinaryLike | null, options?: Stream.TransformOptions): Cipher;
+export {};

package/lib/typescript/Hash.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import 'react-native';
+import { Encoding } from './Utils';
+import Stream from 'stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+interface HashOptionsBase extends Stream.TransformOptions {
+    outputLength?: number | undefined;
+}
+declare type HashOptions = null | undefined | HashOptionsBase;
+declare type BinaryLike = ArrayBuffer;
+export declare function createHash(algorithm: string, options?: HashOptions): Hash;
+declare class Hash extends Stream.Transform {
+    private internalHash;
+    constructor(other: Hash, options?: HashOptions);
+    constructor(algorithm: string, options?: HashOptions);
+    copy(options?: HashOptionsBase): Hash;
+    /**
+     * Updates the hash content with the given `data`, the encoding of which
+     * is given in `inputEncoding`.
+     * If `encoding` is not provided, and the `data` is a string, an
+     * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+     *
+     * This can be called many times with new data as it is streamed.
+     * @since v0.1.92
+     * @param inputEncoding The `encoding` of the `data` string.
+     */
+    update(data: string | BinaryLike, inputEncoding?: Encoding): Hash;
+    _transform(chunk: string | BinaryLike, encoding: Encoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+    /**
+     * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
+     * If `encoding` is provided a string will be returned; otherwise
+     * a `Buffer` is returned.
+     *
+     * The `Hash` object can not be used again after `hash.digest()` method has been
+     * called. Multiple calls will cause an error to be thrown.
+     * @since v0.1.92
+     * @param encoding The `encoding` of the return value.
+     */
+    digest(): Buffer;
+    digest(encoding: 'buffer'): Buffer;
+    digest(encoding: Encoding): string;
+}
+export {};

package/lib/typescript/Hmac.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { Encoding, BinaryLike } from './Utils';
+import Stream from 'stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+export declare function createHmac(algorithm: string, key: BinaryLike, options?: Stream.TransformOptions): Hmac;
+declare class Hmac extends Stream.Transform {
+    private internalHmac;
+    private isFinalized;
+    constructor(algorithm: string, key: BinaryLike, _options?: Stream.TransformOptions);
+    /**
+     * Updates the `Hmac` content with the given `data`, the encoding of which
+     * is given in `inputEncoding`.
+     * If `encoding` is not provided, and the `data` is a string, an
+     * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+     *
+     * This can be called many times with new data as it is streamed.
+     * @since v0.1.94
+     * @param inputEncoding The `encoding` of the `data` string.
+     */
+    update(data: string | BinaryLike, inputEncoding?: Encoding): Hmac;
+    _transform(chunk: string | BinaryLike, encoding: Encoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+    /**
+     * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
+     * If `encoding` is
+     * provided a string is returned; otherwise a `Buffer` is returned;
+     *
+     * The `Hmac` object can not be used again after `hmac.digest()` has been
+     * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
+     * @since v0.1.94
+     * @param encoding The `encoding` of the return value.
+     */
+    digest(): Buffer;
+    digest(encoding: 'buffer'): Buffer;
+    digest(encoding: Encoding): string;
+}
+export {};

package/lib/typescript/NativeQuickCrypto/Cipher.d.ts

@@ -0,0 +1,22 @@
+import type { BinaryLike } from 'src/Utils';
+export declare type InternalCipher = {
+    update: (data: BinaryLike | ArrayBufferView) => ArrayBuffer;
+    final: () => ArrayBuffer;
+    copy: () => void;
+    setAAD: (args: {
+        data: BinaryLike;
+        plaintextLength?: number;
+    }) => InternalCipher;
+    setAutoPadding: (autoPad: boolean) => boolean;
+    setAuthTag: (tag: ArrayBuffer) => boolean;
+};
+export declare type CreateCipherMethod = (params: {
+    cipher_type: string;
+    cipher_key: ArrayBuffer;
+    auth_tag_len: number;
+}) => InternalCipher;
+export declare type CreateDecipherMethod = (params: {
+    cipher_type: string;
+    cipher_key: ArrayBuffer;
+    auth_tag_len: number;
+}) => InternalCipher;

package/lib/typescript/NativeQuickCrypto/NativeQuickCrypto.d.ts

@@ -0,0 +1,19 @@
+import type { CreateHmacMethod } from './hmac';
+import type { CreateHashMethod } from './hash';
+import type { Pbkdf2Object } from './pbkdf2';
+import type { RandomObject } from './random';
+import type { CreateCipherMethod, CreateDecipherMethod } from './Cipher';
+interface NativeQuickCryptoSpec {
+    createHmac: CreateHmacMethod;
+    pbkdf2: Pbkdf2Object;
+    random: RandomObject;
+    createHash: CreateHashMethod;
+    createCipher: CreateCipherMethod;
+    createDecipher: CreateDecipherMethod;
+}
+declare global {
+    function nativeCallSyncHook(): unknown;
+    var __QuickCryptoProxy: object | undefined;
+}
+export declare const NativeQuickCrypto: NativeQuickCryptoSpec;
+export {};

package/lib/typescript/NativeQuickCrypto/hash.d.ts

@@ -0,0 +1,6 @@
+export declare type InternalHash = {
+    update: (data: ArrayBuffer) => InternalHash;
+    digest: () => ArrayBuffer;
+    copy: (len?: number) => InternalHash;
+};
+export declare type CreateHashMethod = (algorithm: string, outputLength?: number) => InternalHash;

package/lib/typescript/NativeQuickCrypto/hmac.d.ts

@@ -0,0 +1,5 @@
+export declare type InternalHmac = {
+    update: (data: ArrayBuffer) => InternalHmac;
+    digest: () => ArrayBuffer;
+};
+export declare type CreateHmacMethod = (algorithm: string, key?: ArrayBuffer) => InternalHmac;

package/lib/typescript/NativeQuickCrypto/pbkdf2.d.ts

@@ -0,0 +1,4 @@
+export declare 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/lib/typescript/NativeQuickCrypto/random.d.ts

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

package/lib/typescript/QuickCrypto.d.ts

@@ -0,0 +1,31 @@
+import * as random from './random';
+import { createCipher, createCipheriv, createDecipher, createDecipheriv } from './Cipher';
+import { createHmac } from './Hmac';
+import { createHash } from './Hash';
+export declare const QuickCrypto: {
+    randomFill<T extends import("@craftzdog/react-native-buffer").Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
+    randomFill<T_1 extends import("@craftzdog/react-native-buffer").Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T_1, offset: number, callback: (err: Error | null, buf: T_1) => void): void;
+    randomFill<T_2 extends import("@craftzdog/react-native-buffer").Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T_2, offset: number, size: number, callback: (err: Error | null, buf: T_2) => void): void;
+    randomFillSync<T_3 extends import("@craftzdog/react-native-buffer").Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T_3, offset?: number | undefined, size?: number | undefined): T_3;
+    randomBytes(size: number): ArrayBuffer;
+    randomBytes(size: number, callback: (err: Error | null, buf?: ArrayBuffer | undefined) => void): void;
+    randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
+    randomInt(max: number): number;
+    randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
+    randomInt(min: number, max: number): number;
+    getRandomValues(data: Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array): Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array;
+    rng: typeof random.randomBytes;
+    pseudoRandomBytes: typeof random.randomBytes;
+    prng: typeof random.randomBytes;
+    pbkdf2(password: import("./Utils").BinaryLike, salt: import("./Utils").BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: import("@craftzdog/react-native-buffer").Buffer | undefined) => void): void;
+    pbkdf2(password: import("./Utils").BinaryLike, salt: import("./Utils").BinaryLike, iterations: number, keylen: number, callback: (err: Error | null, derivedKey?: import("@craftzdog/react-native-buffer").Buffer | undefined) => void): void;
+    pbkdf2Sync(password: import("./Utils").BinaryLike, salt: import("./Utils").BinaryLike, iterations: number, keylen: number, digest?: string | undefined): import("@craftzdog/react-native-buffer").Buffer;
+    createHmac: typeof createHmac;
+    Hmac: typeof createHmac;
+    Hash: typeof createHash;
+    createHash: typeof createHash;
+    createCipher: typeof createCipher;
+    createCipheriv: typeof createCipheriv;
+    createDecipher: typeof createDecipher;
+    createDecipheriv: typeof createDecipheriv;
+};

package/lib/typescript/Utils.d.ts

@@ -0,0 +1,13 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+export declare type BinaryLike = string | ArrayBuffer | Buffer;
+export declare type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex' | 'binary';
+export declare type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';
+export declare type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';
+export declare type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding;
+export declare type CipherEncoding = Encoding | 'buffer';
+export declare function setDefaultEncoding(encoding: CipherEncoding): void;
+export declare function getDefaultEncoding(): CipherEncoding;
+export declare function isBuffer(buf: any): buf is Buffer;
+export declare function toArrayBuffer(buf: Buffer): ArrayBuffer;
+export declare function binaryLikeToArrayBuffer(input: BinaryLike, encoding?: string): ArrayBuffer;
+export declare function ab2str(buf: ArrayBuffer, encoding?: string): string;

package/lib/typescript/index.d.ts

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

package/lib/typescript/pbkdf2.d.ts

@@ -0,0 +1,9 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { BinaryLike } from './Utils';
+declare type Password = BinaryLike;
+declare type Salt = BinaryLike;
+declare type Pbkdf2Callback = (err: Error | null, derivedKey?: Buffer) => void;
+export declare function pbkdf2(password: Password, salt: Salt, iterations: number, keylen: number, digest: string, callback: Pbkdf2Callback): void;
+export declare function pbkdf2(password: Password, salt: Salt, iterations: number, keylen: number, callback: Pbkdf2Callback): void;
+export declare function pbkdf2Sync(password: Password, salt: Salt, iterations: number, keylen: number, digest?: string): Buffer;
+export {};

package/lib/typescript/random.d.ts

@@ -0,0 +1,20 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+declare type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array;
+declare type ArrayBufferView = TypedArray | DataView | ArrayBufferLike | Buffer;
+export declare function randomFill<T extends ArrayBufferView>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
+export declare function randomFill<T extends ArrayBufferView>(buffer: T, offset: number, callback: (err: Error | null, buf: T) => void): void;
+export declare function randomFill<T extends ArrayBufferView>(buffer: T, offset: number, size: number, callback: (err: Error | null, buf: T) => void): void;
+export declare function randomFillSync<T extends ArrayBufferView>(buffer: T, offset?: number, size?: number): T;
+export declare function randomBytes(size: number): ArrayBuffer;
+export declare function randomBytes(size: number, callback: (err: Error | null, buf?: ArrayBuffer) => void): void;
+export declare const rng: typeof randomBytes;
+export declare const pseudoRandomBytes: typeof randomBytes;
+export declare const prng: typeof randomBytes;
+declare type RandomIntCallback = (err: Error | null, value: number) => void;
+export declare function randomInt(max: number, callback: RandomIntCallback): void;
+export declare function randomInt(max: number): number;
+export declare function randomInt(min: number, max: number, callback: RandomIntCallback): void;
+export declare function randomInt(min: number, max: number): number;
+declare type DataType = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;
+export declare function getRandomValues(data: DataType): DataType;
+export {};

package/package.json

@@ -0,0 +1,168 @@
+{
+  "name": "react-native-quick-crypto",
+  "version": "0.2.0",
+  "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
+  "main": "lib/commonjs/index",
+  "module": "lib/module/index",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "react-native-quick-crypto.podspec",
+    "!lib/typescript/example",
+    "!android/build",
+    "!ios/build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "scripts": {
+    "typescript": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "prepare": "bob build",
+    "release": "release-it",
+    "pods": "cd example && pod-install --quiet"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "jsi",
+    "crypto",
+    "c++",
+    "fast",
+    "web3"
+  ],
+  "repository": "https://github.com/margelo/react-native-quick-crypto",
+  "authors": "Szymon Kapała (szymon20000@gmail.com) & Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/margelo/react-native-quick-crypto/issues"
+  },
+  "homepage": "https://github.com/margelo/react-native-quick-crypto#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@jamesacarr/eslint-formatter-github-actions": "^0.1.0",
+    "@react-native-community/eslint-config": "^3.0.1",
+    "@react-native-community/eslint-plugin": "^1.1.0",
+    "@release-it/conventional-changelog": "^3.3.0",
+    "@types/react": "^17.0.21",
+    "@types/react-native": "^0.65.5",
+    "@typescript-eslint/eslint-plugin": "^5.14.0",
+    "eslint": "^7.32.0",
+    "prettier": "^2.4.0",
+    "react": "^17.0.2",
+    "react-native": "^0.66.0",
+    "react-native-builder-bob": "^0.18.1",
+    "release-it": "^14.11.5",
+    "typescript": "^4.4.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "conventionalcommits",
+          "types": [
+            {
+              "type": "feat",
+              "section": "✨ Features"
+            },
+            {
+              "type": "fix",
+              "section": "🐛 Bug Fixes"
+            },
+            {
+              "type": "perf",
+              "section": "💨 Performance Improvements"
+            },
+            {
+              "type": "chore(deps)",
+              "section": "🛠️ Dependency Upgrades"
+            },
+            {
+              "type": "docs",
+              "section": "📚 Documentation"
+            }
+          ]
+        }
+      }
+    }
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@react-native-community",
+      "prettier"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "error",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    },
+    "globals": {
+      "BufferEncoding": true
+    }
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "dependencies": {
+    "@craftzdog/react-native-buffer": "^6.0.4",
+    "@types/node": "^17.0.31",
+    "events": "^3.3.0",
+    "react-native-quick-base64": "^2.0.2",
+    "stream": "^0.0.2",
+    "stream-browserify": "^3.0.0",
+    "string_decoder": "^1.3.0"
+  }
+}