react-native-quick-crypto 0.7.0 → 0.7.2

package/src/NativeQuickCrypto/rsa.ts

@@ -0,0 +1,12 @@
+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/webcrypto.ts

@@ -1,3 +1,4 @@
+import type { AESCipher } from './aes';
 import type {
   AsymmetricKeyType,
   JWK,
@@ -8,6 +9,12 @@ import type {
   NamedCurve,
 } from '../keys';
 import type { SignVerify } from './sig';
+import type {
+  GenerateSecretKeyMethod,
+  GenerateSecretKeySyncMethod,
+} from './keygen';
+import type { KeyVariant } from './Cipher';
+import type { RSACipher } from './rsa';
 
 type KeyDetail = {
   length?: number;
@@ -24,6 +31,12 @@ type ECExportKey = (
   handle: KeyObjectHandle
 ) => ArrayBuffer;
 
+type RSAExportKey = (
+  format: KWebCryptoKeyFormat,
+  handle: KeyObjectHandle,
+  variant: KeyVariant
+) => ArrayBuffer;
+
 export type KeyObjectHandle = {
   export(
     format?: KFormatType,
@@ -33,7 +46,13 @@ export type KeyObjectHandle = {
   ): ArrayBuffer;
   exportJwk(key: JWK, handleRsaPss: boolean): JWK;
   getAsymmetricKeyType(): AsymmetricKeyType;
-  init(keyType: KeyType, key: any): boolean;
+  init(
+    keyType: KeyType,
+    key: any,
+    format?: KFormatType,
+    type?: KeyEncoding,
+    passphrase?: string | ArrayBuffer
+  ): boolean;
   initECRaw(curveName: string, keyData: ArrayBuffer): boolean;
   initJwk(keyData: JWK, namedCurve?: NamedCurve): KeyType | undefined;
   keyDetail(): KeyDetail;
@@ -42,7 +61,12 @@ export type KeyObjectHandle = {
 type CreateKeyObjectHandle = () => KeyObjectHandle;
 
 export type webcrypto = {
-  ecExportKey: ECExportKey;
+  aesCipher: AESCipher;
   createKeyObjectHandle: CreateKeyObjectHandle;
+  ecExportKey: ECExportKey;
+  generateSecretKey: GenerateSecretKeyMethod;
+  generateSecretKeySync: GenerateSecretKeySyncMethod;
+  rsaCipher: RSACipher;
+  rsaExportKey: RSAExportKey;
   signVerify: SignVerify;
 };

package/src/Utils.ts

@@ -2,8 +2,9 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 import type {
   AnyAlgorithm,
   DeriveBitsAlgorithm,
+  DigestAlgorithm,
   EncryptDecryptAlgorithm,
-  HashAlgorithm,
+  EncryptDecryptParams,
   KeyPairAlgorithm,
   KeyUsage,
   SecretKeyAlgorithm,
@@ -208,12 +209,16 @@ export function validateString(str: any, name?: string): str is string {
   return isString;
 }
 
-export function validateFunction(f: any): f is Function {
-  return f != null && typeof f === 'function';
+export function validateFunction(f: any): boolean {
+  return f !== null && typeof f === 'function';
 }
 
 export function isStringOrBuffer(val: any): val is string | ArrayBuffer {
-  return typeof val === 'string' || ArrayBuffer.isView(val);
+  return (
+    typeof val === 'string' ||
+    ArrayBuffer.isView(val) ||
+    val instanceof ArrayBuffer
+  );
 }
 
 export function validateObject<T>(
@@ -329,7 +334,7 @@ type SupportedAlgorithm<Type extends string> = {
 };
 
 type SupportedAlgorithms = {
-  'digest': SupportedAlgorithm<HashAlgorithm>;
+  'digest': SupportedAlgorithm<DigestAlgorithm>;
   'generateKey': SupportedAlgorithm<KeyPairAlgorithm | SecretKeyAlgorithm>;
   'sign': SupportedAlgorithm<SignVerifyAlgorithm>;
   'verify': SupportedAlgorithm<SignVerifyAlgorithm>;
@@ -491,11 +496,12 @@ export const validateMaxBufferLength = (
 // adapted for Node.js from Deno's implementation
 // https://github.com/denoland/deno/blob/v1.29.1/ext/crypto/00_crypto.js#L195
 export const normalizeAlgorithm = (
-  algorithm: SubtleAlgorithm | AnyAlgorithm,
+  algorithm: SubtleAlgorithm | EncryptDecryptParams | AnyAlgorithm,
   op: Operation
-): SubtleAlgorithm => {
-  if (typeof algorithm === 'string')
+): SubtleAlgorithm | EncryptDecryptParams => {
+  if (typeof algorithm === 'string') {
     return normalizeAlgorithm({ name: algorithm }, op);
+  }
 
   // 1.
   const registeredAlgorithms = kSupportedAlgorithms[op];
@@ -663,6 +669,29 @@ export const validateKeyOps = (
   }
 };
 
+// In WebCrypto, the publicExponent option in RSA is represented as a
+// WebIDL "BigInteger"... that is, a Uint8Array that allows an arbitrary
+// number of leading zero bits. Our conventional APIs for reading
+// an unsigned int from a Buffer are not adequate. The implementation
+// here is adapted from the chromium implementation here:
+// https://github.com/chromium/chromium/blob/HEAD/third_party/blink/public/platform/web_crypto_algorithm_params.h, but ported to JavaScript
+// Returns undefined if the conversion was unsuccessful.
+export const bigIntArrayToUnsignedInt = (
+  input: Uint8Array
+): number | undefined => {
+  let result = 0;
+
+  for (let n = 0; n < input.length; ++n) {
+    const n_reversed = input.length - n - 1;
+    if (n_reversed >= 4 && input[n]) return; // Too large
+    // @ts-ignore
+    // eslint-disable-next-line no-bitwise
+    result |= input[n] << (8 * n_reversed);
+  }
+
+  return result;
+};
+
 // TODO: these used to be shipped by crypto-browserify in quickcrypto v0.6
 // could instead fetch from OpenSSL if needed and handle breaking changes
 export const getHashes = () => [

package/src/aes.ts

@@ -4,6 +4,9 @@ import {
   type BufferLike,
   hasAnyNotIn,
   validateKeyOps,
+  validateByteLength,
+  validateMaxBufferLength,
+  bufferLikeToArrayBuffer,
 } from './Utils';
 import {
   type ImportFormat,
@@ -13,70 +16,37 @@ import {
   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 {
-//   ArrayBufferIsView,
-//   ArrayBufferPrototypeSlice,
-//   ArrayFrom,
-//   ArrayPrototypeIncludes,
-//   ArrayPrototypePush,
-//   MathFloor,
-//   SafeSet,
-//   TypedArrayPrototypeSlice,
-// } = primordials;
-
-// const {
-//   AESCipherJob,
-//   KeyObjectHandle,
-//   kCryptoJobAsync,
-//   kKeyVariantAES_CTR_128,
-//   kKeyVariantAES_CBC_128,
-//   kKeyVariantAES_GCM_128,
-//   kKeyVariantAES_KW_128,
-//   kKeyVariantAES_CTR_192,
-//   kKeyVariantAES_CBC_192,
-//   kKeyVariantAES_GCM_192,
-//   kKeyVariantAES_KW_192,
-//   kKeyVariantAES_CTR_256,
-//   kKeyVariantAES_CBC_256,
-//   kKeyVariantAES_GCM_256,
-//   kKeyVariantAES_KW_256,
-//   kWebCryptoCipherDecrypt,
-//   kWebCryptoCipherEncrypt,
-// } = internalBinding('crypto');
-
-// const {
-//   hasAnyNotIn,
-//   jobPromise,
-//   validateByteLength,
-//   validateKeyOps,
-//   validateMaxBufferLength,
-//   kAesKeyLengths,
-//   kHandle,
-//   kKeyObject,
-// } = require('internal/crypto/util');
-
-// const {
-//   lazyDOMException,
-//   promisify,
-// } = require('internal/util');
-
-// const { PromiseReject } = primordials;
-
-// const {
-//   InternalCryptoKey,
-//   SecretKeyObject,
-//   createSecretKey,
-// } = require('internal/crypto/keys');
-
-// const {
-//   generateKey: _generateKey,
-// } = require('internal/crypto/keygen');
-
-// const kMaxCounterLength = 128;
-// const kTagLengths = [32, 64, 96, 104, 112, 120, 128];
-// const generateKey = promisify(_generateKey);
+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)
@@ -103,174 +73,241 @@ function validateKeyLength(length?: number) {
     throw lazyDOMException(`Invalid key length: ${length}`, 'DataError');
 }
 
-// function getVariant(name, length) {
-//   switch (name) {
-//     case 'AES-CBC':
-//       switch (length) {
-//         case 128: return kKeyVariantAES_CBC_128;
-//         case 192: return kKeyVariantAES_CBC_192;
-//         case 256: return kKeyVariantAES_CBC_256;
-//       }
-//       break;
-//     case 'AES-CTR':
-//       switch (length) {
-//         case 128: return kKeyVariantAES_CTR_128;
-//         case 192: return kKeyVariantAES_CTR_192;
-//         case 256: return kKeyVariantAES_CTR_256;
-//       }
-//       break;
-//     case 'AES-GCM':
-//       switch (length) {
-//         case 128: return kKeyVariantAES_GCM_128;
-//         case 192: return kKeyVariantAES_GCM_192;
-//         case 256: return kKeyVariantAES_GCM_256;
-//       }
-//       break;
-//     case 'AES-KW':
-//       switch (length) {
-//         case 128: return kKeyVariantAES_KW_128;
-//         case 192: return kKeyVariantAES_KW_192;
-//         case 256: return kKeyVariantAES_KW_256;
-//       }
-//       break;
-//   }
-// }
+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-ignore
+      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-ignore
+      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-ignore
+      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-ignore
+      break;
+  }
 
-// function asyncAesCtrCipher(mode, key, data, { counter, length }) {
-//   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 jobPromise(() => new AESCipherJob(
-//     kCryptoJobAsync,
-//     mode,
-//     key[kKeyObject][kHandle],
-//     data,
-//     getVariant('AES-CTR', key.algorithm.length),
-//     counter,
-//     length));
-// }
+  // @ts-ignore
+  throw lazyDOMException(
+    `Error getting variant ${name} at length: ${length}`,
+    'DataError'
+  );
+}
 
-// function asyncAesCbcCipher(mode, key, data, { iv }) {
-//   validateByteLength(iv, 'algorithm.iv', 16);
-//   return jobPromise(() => new AESCipherJob(
-//     kCryptoJobAsync,
-//     mode,
-//     key[kKeyObject][kHandle],
-//     data,
-//     getVariant('AES-CBC', key.algorithm.length),
-//     iv));
-// }
+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'
+    );
+  }
 
-// function asyncAesKwCipher(mode, key, data) {
-//   return jobPromise(() => new AESCipherJob(
-//     kCryptoJobAsync,
-//     mode,
-//     key[kKeyObject][kHandle],
-//     data,
-//     getVariant('AES-KW', key.algorithm.length)));
-// }
+  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 asyncAesGcmCipher(
-//   mode,
-//   key,
-//   data,
-//   { iv, additionalData, tagLength = 128 }) {
-//   if (!ArrayPrototypeIncludes(kTagLengths, tagLength)) {
-//     return PromiseReject(lazyDOMException(
-//       `${tagLength} is not a valid AES-GCM tag length`,
-//       'OperationError'));
-//   }
-
-//   validateMaxBufferLength(iv, 'algorithm.iv');
-
-//   if (additionalData !== undefined) {
-//     validateMaxBufferLength(additionalData, 'algorithm.additionalData');
-//   }
-
-//   const tagByteLength = MathFloor(tagLength / 8);
-//   let tag;
-//   switch (mode) {
-//     case kWebCryptoCipherDecrypt: {
-//       const slice = ArrayBufferIsView(data) ?
-//         TypedArrayPrototypeSlice : ArrayBufferPrototypeSlice;
-//       tag = slice(data, -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) {
-//         return PromiseReject(lazyDOMException(
-//           'The provided data is too small.',
-//           'OperationError'));
-//       }
-
-//       data = slice(data, 0, -tagByteLength);
-//       break;
-//     }
-//     case kWebCryptoCipherEncrypt:
-//       tag = tagByteLength;
-//       break;
-//   }
-
-//   return jobPromise(() => new AESCipherJob(
-//     kCryptoJobAsync,
+// function asyncAesKwCipher(
+//   mode: CipherOrWrapMode,
+//   key: CryptoKey,
+//   data: BufferLike
+// ): Promise<ArrayBuffer> {
+//   return NativeQuickCrypto.webcrypto.aesCipher(
 //     mode,
-//     key[kKeyObject][kHandle],
+//     key.keyObject.handle,
 //     data,
-//     getVariant('AES-GCM', key.algorithm.length),
-//     iv,
-//     tag,
-//     additionalData));
+//     getVariant('AES-KW', key.algorithm.length)
+//   );
 // }
 
-// export const aesCipher = (mode, key, data, algorithm) => {
-//   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);
-//   }
-// };
-
-// export const aesGenerateKey = async (algorithm, extractable, keyUsages)  => {
-//   const { name, length } = algorithm;
-//   if (!ArrayPrototypeIncludes(kAesKeyLengths, length)) {
-//     throw lazyDOMException(
-//       'AES key length must be 128, 192, or 256 bits',
-//       'OperationError');
-//   }
-
-//   const checkUsages = ['wrapKey', 'unwrapKey'];
-//   if (name !== 'AES-KW')
-//     ArrayPrototypePush(checkUsages, 'encrypt', 'decrypt');
-
-//   const usagesSet = new SafeSet(keyUsages);
-//   if (hasAnyNotIn(usagesSet, checkUsages)) {
-//     throw lazyDOMException(
-//       'Unsupported key usage for an AES key',
-//       'SyntaxError');
-//   }
-
-//   const key = await generateKey('aes', { length }).catch((err) => {
-//     throw lazyDOMException(
-//       'The operation failed for an operation-specific reason' +
-//       `[${err.message}]`,
-//       { name: 'OperationError', cause: err });
-//   });
-
-//   return new InternalCryptoKey(
-//     key,
-//     { name, length },
-//     ArrayFrom(usagesSet),
-//     extractable);
-// };
+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,