react-native-quick-crypto 0.7.2 → 1.0.0-beta.1

package/src/Hash.ts

@@ -1,132 +0,0 @@
-import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
-import type { InternalHash } from './NativeQuickCrypto/hash';
-import {
-  type Encoding,
-  toArrayBuffer,
-  validateMaxBufferLength,
-  normalizeHashName,
-  type BufferLike,
-  bufferLikeToArrayBuffer,
-} from './Utils';
-import Stream from 'readable-stream';
-import { Buffer } from '@craftzdog/react-native-buffer';
-import { lazyDOMException } from './Utils';
-import type { SubtleAlgorithm } from './keys';
-
-interface HashOptionsBase extends Stream.TransformOptions {
-  outputLength?: number | undefined;
-}
-
-type HashOptions = null | undefined | HashOptionsBase;
-
-global.process.nextTick = setImmediate;
-
-const createInternalHash = NativeQuickCrypto.createHash;
-
-export function createHash(algorithm: string, options?: HashOptions) {
-  return new Hash(algorithm, options);
-}
-
-class Hash extends Stream.Transform {
-  private internalHash: InternalHash;
-
-  constructor(other: Hash, options?: HashOptions);
-  constructor(algorithm: string, options?: HashOptions);
-  constructor(arg: string | Hash, options?: HashOptions) {
-    super(options ?? undefined);
-    if (arg instanceof Hash) {
-      this.internalHash = arg.internalHash.copy(options?.outputLength);
-    } else {
-      this.internalHash = createInternalHash(arg, options?.outputLength);
-    }
-  }
-
-  copy(options?: HashOptionsBase): Hash {
-    const copy = new Hash(this, options);
-    return copy;
-  }
-  /**
-   * 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 | ArrayBuffer, inputEncoding?: Encoding): Hash {
-    if (data instanceof ArrayBuffer) {
-      this.internalHash.update(data);
-      return this;
-    }
-    const buffer = Buffer.from(data, inputEncoding);
-    this.internalHash.update(toArrayBuffer(buffer));
-    return this;
-  }
-
-  _transform(
-    chunk: string | ArrayBuffer,
-    encoding: Encoding,
-    callback: () => void
-  ) {
-    this.update(chunk, encoding);
-    callback();
-  }
-
-  _flush(callback: () => void) {
-    this.push(this.digest());
-    callback();
-  }
-
-  /**
-   * 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;
-  digest(encoding?: Encoding | 'buffer'): string | Buffer {
-    const result: ArrayBuffer = this.internalHash.digest();
-
-    if (encoding && encoding !== 'buffer') {
-      return Buffer.from(result).toString(encoding);
-    }
-
-    return Buffer.from(result);
-  }
-}
-
-// Implementation for WebCrypto subtle.digest()
-
-export const asyncDigest = async (
-  algorithm: SubtleAlgorithm,
-  data: BufferLike
-): Promise<ArrayBuffer> => {
-  validateMaxBufferLength(data, 'data');
-
-  switch (algorithm.name) {
-    case 'SHA-1':
-    // Fall through
-    case 'SHA-256':
-    // Fall through
-    case 'SHA-384':
-    // Fall through
-    case 'SHA-512':
-      const normalizedHashName = normalizeHashName(algorithm.name);
-      const hash = new Hash(normalizedHashName);
-      hash.update(bufferLikeToArrayBuffer(data));
-      return hash.digest();
-  }
-
-  throw lazyDOMException(
-    `Unrecognized algorithm name: ${algorithm.name}`,
-    'NotSupportedError'
-  );
-};

package/src/Hashnames.ts

@@ -1,93 +0,0 @@
-import type { HashAlgorithm } from './keys';
-
-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 | undefined,
-  context: HashContext = HashContext.Node
-): HashAlgorithm {
-  if (typeof algo !== 'undefined') {
-    const normAlgo = algo.toString().toLowerCase();
-    try {
-      const alias = kHashNames[normAlgo]![context] as HashAlgorithm;
-      if (alias) return alias;
-    } catch (_e) {}
-  }
-  throw new Error(`Invalid Hash Algorithm: ${algo}`);
-}

package/src/Hmac.ts

@@ -1,106 +0,0 @@
-import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
-import type { InternalHmac } from './NativeQuickCrypto/hmac';
-import {
-  type Encoding,
-  toArrayBuffer,
-  type BinaryLike,
-  binaryLikeToArrayBuffer,
-} from './Utils';
-import Stream from 'readable-stream';
-import { Buffer } from '@craftzdog/react-native-buffer';
-
-const createInternalHmac = NativeQuickCrypto.createHmac;
-
-export function createHmac(
-  algorithm: string,
-  key: BinaryLike,
-  options?: Stream.TransformOptions
-) {
-  return new Hmac(algorithm, key, options);
-}
-
-class Hmac extends Stream.Transform {
-  private internalHmac: InternalHmac;
-  private isFinalized: boolean = false;
-
-  constructor(
-    algorithm: string,
-    key: BinaryLike,
-    _options?: Stream.TransformOptions
-  ) {
-    super();
-    let keyAsString = binaryLikeToArrayBuffer(key);
-
-    if (keyAsString === undefined) {
-      throw 'Wrong key type';
-    }
-
-    this.internalHmac = createInternalHmac(
-      algorithm,
-      keyAsString as ArrayBuffer
-    );
-  }
-
-  /**
-   * 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 {
-    if (data instanceof ArrayBuffer) {
-      this.internalHmac.update(data);
-      return this;
-    }
-    if (typeof data === 'string') {
-      const buffer = Buffer.from(data, inputEncoding);
-      this.internalHmac.update(toArrayBuffer(buffer));
-      return this;
-    }
-
-    this.internalHmac.update(binaryLikeToArrayBuffer(data));
-    return this;
-  }
-
-  _transform(
-    chunk: string | BinaryLike,
-    encoding: Encoding,
-    callback: () => void
-  ) {
-    this.update(chunk, encoding);
-    callback();
-  }
-
-  _flush(callback: () => void) {
-    this.push(this.digest());
-    callback();
-  }
-
-  /**
-   * 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;
-  digest(encoding?: Encoding | 'buffer'): string | Buffer {
-    const result: ArrayBuffer = this.isFinalized
-      ? new ArrayBuffer(0)
-      : this.internalHmac.digest();
-    this.isFinalized = true;
-    if (encoding && encoding !== 'buffer') {
-      return Buffer.from(result).toString(encoding);
-    }
-    return Buffer.from(result);
-  }
-}

package/src/NativeQuickCrypto/Cipher.ts

@@ -1,102 +0,0 @@
-import type { GenerateKeyPairReturn } from '../Cipher';
-import type { BinaryLike } from '../Utils';
-import type { Buffer } from '@craftzdog/react-native-buffer';
-import type {
-  EncodingOptions,
-  PrivateKeyObject,
-  PublicKeyObject,
-  SecretKeyObject,
-} from '../keys';
-
-// TODO: until shared, keep in sync with C++ side (cpp/Utils/MGLUtils.h)
-export enum KeyVariant {
-  RSA_SSA_PKCS1_v1_5,
-  RSA_PSS,
-  RSA_OAEP,
-  DSA,
-  EC,
-  NID,
-  DH,
-}
-
-export const KeyVariantLookup: Record<string, KeyVariant> = {
-  'RSASSA-PKCS1-v1_5': KeyVariant.RSA_SSA_PKCS1_v1_5,
-  'RSA-PSS': KeyVariant.RSA_PSS,
-  'RSA-OAEP': KeyVariant.RSA_OAEP,
-  'ECDSA': KeyVariant.DSA,
-  'ECDH': KeyVariant.EC,
-  'Ed25519': KeyVariant.NID,
-  'Ed448': KeyVariant.NID,
-  'X25519': KeyVariant.NID,
-  'X448': KeyVariant.NID,
-  'DH': KeyVariant.DH,
-};
-
-export 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;
-  getAuthTag: () => ArrayBuffer;
-};
-
-export type CreateCipherMethod = (params: {
-  cipher_type: string;
-  cipher_key: ArrayBuffer;
-  auth_tag_len: number;
-}) => InternalCipher;
-
-export type CreateDecipherMethod = (params: {
-  cipher_type: string;
-  cipher_key: ArrayBuffer;
-  auth_tag_len: number;
-}) => InternalCipher;
-
-export type PublicEncryptMethod = (
-  data: ArrayBuffer,
-  format: number,
-  type: any,
-  passphrase: any,
-  buffer: ArrayBuffer,
-  padding: number,
-  oaepHash: any,
-  oaepLabel: any
-) => Buffer;
-export type PrivateDecryptMethod = (
-  data: ArrayBuffer,
-  format: number,
-  type: any,
-  passphrase: any,
-  buffer: ArrayBuffer,
-  padding: number,
-  oaepHash: any,
-  oaepLabel: any
-) => Buffer;
-
-export type GenerateKeyPairMethod = (
-  keyVariant: KeyVariant,
-  ...rest: any[]
-) => Promise<GenerateKeyPairReturn>;
-
-export type GenerateKeyPairSyncMethod = (
-  keyVariant: KeyVariant,
-  ...rest: any[]
-) => GenerateKeyPairReturn;
-
-export type CreatePublicKeyMethod = (
-  key: BinaryLike | EncodingOptions
-) => PublicKeyObject;
-
-export type CreatePrivateKeyMethod = (
-  key: BinaryLike | EncodingOptions
-) => PrivateKeyObject;
-
-export type CreateSecretKeyMethod = (
-  key: BinaryLike | EncodingOptions,
-  encoding?: string
-) => SecretKeyObject;

package/src/NativeQuickCrypto/NativeQuickCrypto.ts

@@ -1,102 +0,0 @@
-import { NativeModules, Platform } from 'react-native';
-import type { CreateHmacMethod } from './hmac';
-import type { CreateHashMethod } from './hash';
-import type { Pbkdf2Object } from './pbkdf2';
-import type { RandomObject } from './random';
-import type {
-  CreateCipherMethod,
-  CreateDecipherMethod,
-  PublicEncryptMethod,
-  PrivateDecryptMethod,
-  GenerateKeyPairMethod,
-  GenerateKeyPairSyncMethod,
-  CreatePublicKeyMethod,
-  CreatePrivateKeyMethod,
-  CreateSecretKeyMethod,
-} from './Cipher';
-import type { CreateSignMethod, CreateVerifyMethod } from './sig';
-import type { webcrypto } from './webcrypto';
-
-interface NativeQuickCryptoSpec {
-  createHmac: CreateHmacMethod;
-  pbkdf2: Pbkdf2Object;
-  random: RandomObject;
-  createHash: CreateHashMethod;
-  createCipher: CreateCipherMethod;
-  createDecipher: CreateDecipherMethod;
-  createPublicKey: CreatePublicKeyMethod;
-  createPrivateKey: CreatePrivateKeyMethod;
-  createSecretKey: CreateSecretKeyMethod;
-  publicEncrypt: PublicEncryptMethod;
-  publicDecrypt: PublicEncryptMethod;
-  privateDecrypt: PrivateDecryptMethod;
-  generateKeyPair: GenerateKeyPairMethod;
-  generateKeyPairSync: GenerateKeyPairSyncMethod;
-  createSign: CreateSignMethod;
-  createVerify: CreateVerifyMethod;
-  webcrypto: webcrypto;
-}
-
-// global func declaration for JSI functions
-declare global {
-  function nativeCallSyncHook(): unknown;
-  var __QuickCryptoProxy: object | undefined;
-}
-
-// Check if the constructor exists. If not, try installing the JSI bindings.
-if (global.__QuickCryptoProxy == null) {
-  // Get the native QuickCrypto ReactModule
-  const QuickCryptoModule = NativeModules.QuickCrypto;
-  if (QuickCryptoModule == null) {
-    let message =
-      'Failed to install react-native-quick-crypto: The native `QuickCrypto` Module could not be found.';
-    message +=
-      '\n* Make sure react-native-quick-crypto is correctly autolinked (run `npx react-native config` to verify)';
-    if (Platform.OS === 'ios' || Platform.OS === 'macos') {
-      message += '\n* Make sure you ran `pod install` in the ios/ directory.';
-    }
-    if (Platform.OS === 'android') {
-      message += '\n* Make sure gradle is synced.';
-    }
-    // check if Expo
-    const ExpoConstants =
-      NativeModules.NativeUnimoduleProxy?.modulesConstants?.ExponentConstants;
-    if (ExpoConstants != null) {
-      if (ExpoConstants.appOwnership === 'expo') {
-        // We're running Expo Go
-        throw new Error(
-          'react-native-quick-crypto is not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.'
-        );
-      } else {
-        // We're running Expo bare / standalone
-        message += '\n* Make sure you ran `expo prebuild`.';
-      }
-    }
-
-    message += '\n* Make sure you rebuilt the app.';
-    throw new Error(message);
-  }
-
-  // Check if we are running on-device (JSI)
-  if (global.nativeCallSyncHook == null || QuickCryptoModule.install == null) {
-    throw new Error(
-      'Failed to install react-native-quick-crypto: React Native is not running on-device. QuickCrypto can only be used when synchronous method invocations (JSI) are possible. If you are using a remote debugger (e.g. Chrome), switch to an on-device debugger (e.g. Flipper) instead.'
-    );
-  }
-
-  // Call the synchronous blocking install() function
-  const result = QuickCryptoModule.install();
-  if (result !== true)
-    throw new Error(
-      `Failed to install react-native-quick-crypto: The native QuickCrypto Module could not be installed! Looks like something went wrong when installing JSI bindings: ${result}`
-    );
-
-  // Check again if the constructor now exists. If not, throw an error.
-  if (global.__QuickCryptoProxy == null)
-    throw new Error(
-      'Failed to install react-native-quick-crypto, the native initializer function does not exist. Are you trying to use QuickCrypto from different JS Runtimes?'
-    );
-}
-
-const proxy = global.__QuickCryptoProxy;
-export const NativeQuickCrypto = proxy as any as NativeQuickCryptoSpec;

package/src/NativeQuickCrypto/aes.ts

@@ -1,14 +0,0 @@
-import type { AESKeyVariant } from '../aes';
-import type { CipherOrWrapMode } from '../keys';
-import type { KeyObjectHandle } from './webcrypto';
-
-export type AESCipher = (
-  mode: CipherOrWrapMode,
-  handle: KeyObjectHandle,
-  data: ArrayBuffer,
-  variant: AESKeyVariant,
-  iv_or_counter?: ArrayBuffer,
-  length?: number,
-  authTag?: ArrayBuffer,
-  additionalData?: ArrayBuffer
-) => Promise<ArrayBuffer>;

package/src/NativeQuickCrypto/hash.ts

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

package/src/NativeQuickCrypto/hmac.ts

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

package/src/NativeQuickCrypto/keygen.ts

@@ -1,7 +0,0 @@
-import type { KeyObjectHandle } from './webcrypto';
-
-export type GenerateSecretKeyMethod = (
-  length: number
-) => Promise<KeyObjectHandle>;
-
-export type GenerateSecretKeySyncMethod = (length: number) => KeyObjectHandle;

package/src/NativeQuickCrypto/pbkdf2.ts

@@ -1,16 +0,0 @@
-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

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

package/src/NativeQuickCrypto/rsa.ts

@@ -1,12 +0,0 @@
-import type { CipherOrWrapMode, DigestAlgorithm } from '../keys';
-import type { RSAKeyVariant } from '../rsa';
-import type { KeyObjectHandle } from './webcrypto';
-
-export type RSACipher = (
-  mode: CipherOrWrapMode,
-  handle: KeyObjectHandle,
-  data: ArrayBuffer,
-  variant: RSAKeyVariant,
-  hash: DigestAlgorithm,
-  label?: ArrayBuffer
-) => Promise<ArrayBuffer>;

package/src/NativeQuickCrypto/sig.ts

@@ -1,44 +0,0 @@
-// TODO Add real types to sign/verify, the problem is that because of encryption schemes
-
-import type { KeyObjectHandle } from './webcrypto';
-
-// they will have variable amount of parameters
-export type InternalSign = {
-  init: (algorithm: string) => void;
-  update: (data: ArrayBuffer) => void;
-  sign: (...args: any) => Uint8Array; // returns raw bytes
-};
-
-export type InternalVerify = {
-  init: (algorithm: string) => void;
-  update: (data: ArrayBuffer) => void;
-  verify: (...args: any) => boolean;
-};
-
-export type CreateSignMethod = () => InternalSign;
-
-export type CreateVerifyMethod = () => InternalVerify;
-
-export enum DSASigEnc {
-  kSigEncDER,
-  kSigEncP1363,
-}
-
-export enum SignMode {
-  kSignJobModeSign,
-  kSignJobModeVerify,
-}
-
-export type SignVerify = (
-  mode: SignMode,
-  handle: KeyObjectHandle,
-  unused1: undefined,
-  unused2: undefined,
-  unused3: undefined,
-  data: ArrayBuffer,
-  digest: string | undefined,
-  salt_length: number | undefined,
-  padding: number | undefined,
-  dsa_encoding: DSASigEnc | undefined,
-  signature: ArrayBuffer | undefined
-) => ArrayBuffer | boolean;