react-native-quick-crypto 0.7.11 → 1.0.0-beta.10

package/src/aes.ts

@@ -1,402 +0,0 @@
-import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
-import {
-  lazyDOMException,
-  type BufferLike,
-  hasAnyNotIn,
-  validateKeyOps,
-  validateByteLength,
-  validateMaxBufferLength,
-  bufferLikeToArrayBuffer,
-} from './Utils';
-import {
-  type ImportFormat,
-  type SubtleAlgorithm,
-  type KeyUsage,
-  CryptoKey,
-  createSecretKey,
-  SecretKeyObject,
-  type JWK,
-  type AESAlgorithm,
-  CipherOrWrapMode,
-  type EncryptDecryptParams,
-  type AesGcmParams,
-  type AesCbcParams,
-  type AesCtrParams,
-  type TagLength,
-  type AESLength,
-  type AesKeyGenParams,
-} from './keys';
-import { generateKeyPromise } from './keygen';
-
-// needs to match the values in cpp/webcrypto/crypto_aes.{h,cpp}
-export enum AESKeyVariant {
-  AES_CTR_128,
-  AES_CTR_192,
-  AES_CTR_256,
-  AES_CBC_128,
-  AES_CBC_192,
-  AES_CBC_256,
-  AES_GCM_128,
-  AES_GCM_192,
-  AES_GCM_256,
-  AES_KW_128,
-  AES_KW_192,
-  AES_KW_256,
-}
-
-const kMaxCounterLength = 128;
-const kTagLengths: TagLength[] = [32, 64, 96, 104, 112, 120, 128];
-export const kAesKeyLengths = [128, 192, 256];
-
-export const getAlgorithmName = (name: string, length?: number) => {
-  if (length === undefined)
-    throw lazyDOMException(
-      `Invalid algorithm length: ${length}`,
-      'SyntaxError',
-    );
-  switch (name) {
-    case 'AES-CBC':
-      return `A${length}CBC`;
-    case 'AES-CTR':
-      return `A${length}CTR`;
-    case 'AES-GCM':
-      return `A${length}GCM`;
-    case 'AES-KW':
-      return `A${length}KW`;
-    default:
-      throw lazyDOMException(`invalid algorithm name: ${name}`, 'SyntaxError');
-  }
-};
-
-function validateKeyLength(length?: number) {
-  if (length !== 128 && length !== 192 && length !== 256)
-    throw lazyDOMException(`Invalid key length: ${length}`, 'DataError');
-}
-
-function getVariant(name: AESAlgorithm, length: AESLength): AESKeyVariant {
-  switch (name) {
-    case 'AES-CBC':
-      switch (length) {
-        case 128:
-          return AESKeyVariant.AES_CBC_128;
-        case 192:
-          return AESKeyVariant.AES_CBC_192;
-        case 256:
-          return AESKeyVariant.AES_CBC_256;
-      }
-      // @ts-expect-error unreachable code
-      break;
-    case 'AES-CTR':
-      switch (length) {
-        case 128:
-          return AESKeyVariant.AES_CTR_128;
-        case 192:
-          return AESKeyVariant.AES_CTR_192;
-        case 256:
-          return AESKeyVariant.AES_CTR_256;
-      }
-      // @ts-expect-error unreachable code
-      break;
-    case 'AES-GCM':
-      switch (length) {
-        case 128:
-          return AESKeyVariant.AES_GCM_128;
-        case 192:
-          return AESKeyVariant.AES_GCM_192;
-        case 256:
-          return AESKeyVariant.AES_GCM_256;
-      }
-      // @ts-expect-error unreachable code
-      break;
-    case 'AES-KW':
-      switch (length) {
-        case 128:
-          return AESKeyVariant.AES_KW_128;
-        case 192:
-          return AESKeyVariant.AES_KW_192;
-        case 256:
-          return AESKeyVariant.AES_KW_256;
-      }
-      // @ts-expect-error unreachable code
-      break;
-  }
-
-  // @ts-expect-error unreachable code
-  throw lazyDOMException(
-    `Error getting variant ${name} at length: ${length}`,
-    'DataError',
-  );
-}
-
-function asyncAesCtrCipher(
-  mode: CipherOrWrapMode,
-  key: CryptoKey,
-  data: ArrayBuffer,
-  { counter, length }: AesCtrParams,
-): Promise<ArrayBuffer> {
-  validateByteLength(counter, 'algorithm.counter', 16);
-  // The length must specify an integer between 1 and 128. While
-  // there is no default, this should typically be 64.
-  if (length === 0 || length > kMaxCounterLength) {
-    throw lazyDOMException(
-      'AES-CTR algorithm.length must be between 1 and 128',
-      'OperationError',
-    );
-  }
-
-  return NativeQuickCrypto.webcrypto.aesCipher(
-    mode,
-    key.keyObject.handle,
-    data,
-    getVariant('AES-CTR', key.algorithm.length as AESLength),
-    bufferLikeToArrayBuffer(counter),
-    length,
-  );
-}
-
-function asyncAesCbcCipher(
-  mode: CipherOrWrapMode,
-  key: CryptoKey,
-  data: ArrayBuffer,
-  { iv }: AesCbcParams,
-): Promise<ArrayBuffer> {
-  validateByteLength(iv, 'algorithm.iv', 16);
-  return NativeQuickCrypto.webcrypto.aesCipher(
-    mode,
-    key.keyObject.handle,
-    data,
-    getVariant('AES-CBC', key.algorithm.length as AESLength),
-    bufferLikeToArrayBuffer(iv),
-  );
-}
-
-// function asyncAesKwCipher(
-//   mode: CipherOrWrapMode,
-//   key: CryptoKey,
-//   data: BufferLike
-// ): Promise<ArrayBuffer> {
-//   return NativeQuickCrypto.webcrypto.aesCipher(
-//     mode,
-//     key.keyObject.handle,
-//     data,
-//     getVariant('AES-KW', key.algorithm.length)
-//   );
-// }
-
-function asyncAesGcmCipher(
-  mode: CipherOrWrapMode,
-  key: CryptoKey,
-  data: ArrayBuffer,
-  { iv, additionalData, tagLength = 128 }: AesGcmParams,
-) {
-  if (!kTagLengths.includes(tagLength)) {
-    throw lazyDOMException(
-      `${tagLength} is not a valid AES-GCM tag length`,
-      'OperationError',
-    );
-  }
-
-  validateMaxBufferLength(iv, 'algorithm.iv');
-
-  if (additionalData !== undefined) {
-    validateMaxBufferLength(additionalData, 'algorithm.additionalData');
-  }
-
-  const tagByteLength = Math.floor(tagLength / 8);
-  let length: number | undefined;
-  let tag = new ArrayBuffer(0);
-  switch (mode) {
-    case CipherOrWrapMode.kWebCryptoCipherDecrypt: {
-      // const slice = ArrayBuffer.isView(data)
-      //   ? DataView.prototype.buffer.slice
-      //   : ArrayBuffer.prototype.slice;
-      tag = data.slice(-tagByteLength);
-
-      // Refs: https://www.w3.org/TR/WebCryptoAPI/#aes-gcm-operations
-      //
-      // > If *plaintext* has a length less than *tagLength* bits, then `throw`
-      // > an `OperationError`.
-      if (tagByteLength > tag.byteLength) {
-        throw lazyDOMException(
-          'The provided data is too small.',
-          'OperationError',
-        );
-      }
-
-      data = data.slice(0, -tagByteLength);
-      break;
-    }
-    case CipherOrWrapMode.kWebCryptoCipherEncrypt:
-      length = tagByteLength;
-      break;
-  }
-
-  return NativeQuickCrypto.webcrypto.aesCipher(
-    mode,
-    key.keyObject.handle,
-    data,
-    getVariant('AES-GCM', key.algorithm.length as AESLength),
-    bufferLikeToArrayBuffer(iv),
-    length,
-    bufferLikeToArrayBuffer(tag),
-    bufferLikeToArrayBuffer(additionalData || new ArrayBuffer(0)),
-  );
-}
-
-export const aesCipher = (
-  mode: CipherOrWrapMode,
-  key: CryptoKey,
-  data: ArrayBuffer,
-  algorithm: EncryptDecryptParams, // | WrapUnwrapParams
-): Promise<ArrayBuffer> => {
-  switch (algorithm.name) {
-    case 'AES-CTR':
-      return asyncAesCtrCipher(mode, key, data, algorithm);
-    case 'AES-CBC':
-      return asyncAesCbcCipher(mode, key, data, algorithm);
-    case 'AES-GCM':
-      return asyncAesGcmCipher(mode, key, data, algorithm);
-    // case 'AES-KW':
-    //   return asyncAesKwCipher(mode, key, data);
-  }
-  throw new Error(`aesCipher: Unknown algorithm ${algorithm.name}`);
-};
-
-export const aesGenerateKey = async (
-  algorithm: AesKeyGenParams,
-  extractable: boolean,
-  keyUsages: KeyUsage[],
-): Promise<CryptoKey> => {
-  const { name, length } = algorithm;
-  if (!name) {
-    throw lazyDOMException('Algorithm name is undefined', 'SyntaxError');
-  }
-  if (!kAesKeyLengths.includes(length)) {
-    throw lazyDOMException(
-      'AES key length must be 128, 192, or 256 bits',
-      'OperationError',
-    );
-  }
-
-  const checkUsages = ['wrapKey', 'unwrapKey'];
-  if (name !== 'AES-KW') {
-    checkUsages.push('encrypt', 'decrypt');
-  }
-  // const usagesSet = new SafeSet(keyUsages);
-  if (hasAnyNotIn(keyUsages, checkUsages)) {
-    throw lazyDOMException(
-      `Unsupported key usage for an AES key: ${keyUsages}`,
-      'SyntaxError',
-    );
-  }
-
-  const [err, key] = await generateKeyPromise('aes', { length });
-  if (err) {
-    throw lazyDOMException(
-      `aesGenerateKey (generateKeyPromise) failed: [${err.message}]`,
-      {
-        name: 'OperationError',
-        cause: err,
-      },
-    );
-  }
-
-  return new CryptoKey(
-    key as SecretKeyObject,
-    { name, length },
-    Array.from(keyUsages),
-    extractable,
-  );
-};
-
-export const aesImportKey = async (
-  algorithm: SubtleAlgorithm,
-  format: ImportFormat,
-  keyData: BufferLike | JWK,
-  extractable: boolean,
-  keyUsages: KeyUsage[],
-): Promise<CryptoKey> => {
-  const { name } = algorithm;
-  const checkUsages = ['wrapKey', 'unwrapKey'];
-  if (name !== 'AES-KW') {
-    checkUsages.push('encrypt', 'decrypt');
-  }
-
-  // const usagesSet = new SafeSet(keyUsages);
-  if (hasAnyNotIn(keyUsages, checkUsages)) {
-    throw lazyDOMException(
-      'Unsupported key usage for an AES key',
-      'SyntaxError',
-    );
-  }
-
-  let keyObject: SecretKeyObject;
-  let length: number | undefined;
-
-  switch (format) {
-    case 'raw': {
-      const data = bufferLikeToArrayBuffer(keyData as BufferLike);
-      validateKeyLength(data.byteLength * 8);
-      keyObject = createSecretKey(data);
-      break;
-    }
-    case 'jwk': {
-      const data = keyData as JWK;
-
-      if (!data.kty) throw lazyDOMException('Invalid keyData', 'DataError');
-
-      if (data.kty !== 'oct')
-        throw lazyDOMException('Invalid JWK "kty" Parameter', 'DataError');
-
-      if (
-        keyUsages.length > 0 &&
-        data.use !== undefined &&
-        data.use !== 'enc'
-      ) {
-        throw lazyDOMException('Invalid JWK "use" Parameter', 'DataError');
-      }
-
-      validateKeyOps(data.key_ops, keyUsages);
-
-      if (
-        data.ext !== undefined &&
-        data.ext === false &&
-        extractable === true
-      ) {
-        throw lazyDOMException(
-          'JWK "ext" Parameter and extractable mismatch',
-          'DataError',
-        );
-      }
-
-      const handle = NativeQuickCrypto.webcrypto.createKeyObjectHandle();
-      handle.initJwk(data);
-
-      ({ length } = handle.keyDetail());
-      validateKeyLength(length);
-
-      if (data.alg !== undefined) {
-        if (data.alg !== getAlgorithmName(algorithm.name, length))
-          throw lazyDOMException(
-            'JWK "alg" does not match the requested algorithm',
-            'DataError',
-          );
-      }
-
-      keyObject = new SecretKeyObject(handle);
-      break;
-    }
-    default:
-      throw lazyDOMException(
-        `Unable to import AES key with format ${format}`,
-        'NotSupportedError',
-      );
-  }
-
-  if (length === undefined) {
-    ({ length } = keyObject.handle.keyDetail());
-    validateKeyLength(length);
-  }
-
-  return new CryptoKey(keyObject, { name, length }, keyUsages, extractable);
-};

package/src/constants.ts

@@ -1,79 +0,0 @@
-// Taken by printing node.crypto.constants
-// Node declares them as enums on v8 directly
-// Whenever the API gets updated (or some dependency like OpenSSL) I guess we will have to revisit these
-export const constants = {
-  OPENSSL_VERSION_NUMBER: 269488367,
-  SSL_OP_ALL: 2147485780,
-  SSL_OP_ALLOW_NO_DHE_KEX: 1024,
-  SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144,
-  SSL_OP_CIPHER_SERVER_PREFERENCE: 4194304,
-  SSL_OP_CISCO_ANYCONNECT: 32768,
-  SSL_OP_COOKIE_EXCHANGE: 8192,
-  SSL_OP_CRYPTOPRO_TLSEXT_BUG: 2147483648,
-  SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: 2048,
-  SSL_OP_EPHEMERAL_RSA: 0,
-  SSL_OP_LEGACY_SERVER_CONNECT: 4,
-  SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: 0,
-  SSL_OP_MICROSOFT_SESS_ID_BUG: 0,
-  SSL_OP_MSIE_SSLV2_RSA_PADDING: 0,
-  SSL_OP_NETSCAPE_CA_DN_BUG: 0,
-  SSL_OP_NETSCAPE_CHALLENGE_BUG: 0,
-  SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: 0,
-  SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: 0,
-  SSL_OP_NO_COMPRESSION: 131072,
-  SSL_OP_NO_ENCRYPT_THEN_MAC: 524288,
-  SSL_OP_NO_QUERY_MTU: 4096,
-  SSL_OP_NO_RENEGOTIATION: 1073741824,
-  SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: 65536,
-  SSL_OP_NO_SSLv2: 0,
-  SSL_OP_NO_SSLv3: 33554432,
-  SSL_OP_NO_TICKET: 16384,
-  SSL_OP_NO_TLSv1: 67108864,
-  SSL_OP_NO_TLSv1_1: 268435456,
-  SSL_OP_NO_TLSv1_2: 134217728,
-  SSL_OP_NO_TLSv1_3: 536870912,
-  SSL_OP_PKCS1_CHECK_1: 0,
-  SSL_OP_PKCS1_CHECK_2: 0,
-  SSL_OP_PRIORITIZE_CHACHA: 2097152,
-  SSL_OP_SINGLE_DH_USE: 0,
-  SSL_OP_SINGLE_ECDH_USE: 0,
-  SSL_OP_SSLEAY_080_CLIENT_DH_BUG: 0,
-  SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: 0,
-  SSL_OP_TLS_BLOCK_PADDING_BUG: 0,
-  SSL_OP_TLS_D5_BUG: 0,
-  SSL_OP_TLS_ROLLBACK_BUG: 8388608,
-  ENGINE_METHOD_RSA: 1,
-  ENGINE_METHOD_DSA: 2,
-  ENGINE_METHOD_DH: 4,
-  ENGINE_METHOD_RAND: 8,
-  ENGINE_METHOD_EC: 2048,
-  ENGINE_METHOD_CIPHERS: 64,
-  ENGINE_METHOD_DIGESTS: 128,
-  ENGINE_METHOD_PKEY_METHS: 512,
-  ENGINE_METHOD_PKEY_ASN1_METHS: 1024,
-  ENGINE_METHOD_ALL: 65535,
-  ENGINE_METHOD_NONE: 0,
-  DH_CHECK_P_NOT_SAFE_PRIME: 2,
-  DH_CHECK_P_NOT_PRIME: 1,
-  DH_UNABLE_TO_CHECK_GENERATOR: 4,
-  DH_NOT_SUITABLE_GENERATOR: 8,
-  ALPN_ENABLED: 1,
-  RSA_PKCS1_PADDING: 1,
-  RSA_SSLV23_PADDING: 2,
-  RSA_NO_PADDING: 3,
-  RSA_PKCS1_OAEP_PADDING: 4,
-  RSA_X931_PADDING: 5,
-  RSA_PKCS1_PSS_PADDING: 6,
-  RSA_PSS_SALTLEN_DIGEST: -1,
-  RSA_PSS_SALTLEN_MAX_SIGN: -2,
-  RSA_PSS_SALTLEN_AUTO: -2,
-  defaultCoreCipherList:
-    'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
-  TLS1_VERSION: 769,
-  TLS1_1_VERSION: 770,
-  TLS1_2_VERSION: 771,
-  TLS1_3_VERSION: 772,
-  POINT_CONVERSION_COMPRESSED: 2,
-  POINT_CONVERSION_UNCOMPRESSED: 4,
-  POINT_CONVERSION_HYBRID: 6,
-};