react-native-quick-crypto 0.7.0-rc.9 → 0.7.1

package/src/ec.ts

@@ -1,4 +1,6 @@
+import { generateKeyPairPromise, type GenerateKeyPairOptions } from './Cipher';
 import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { DSASigEnc, SignMode } from './NativeQuickCrypto/sig';
 import {
   bufferLikeToArrayBuffer,
   type BufferLike,
@@ -8,6 +10,8 @@ import {
   validateKeyOps,
   hasAnyNotIn,
   ab2str,
+  getUsagesUnion,
+  normalizeHashName,
 } from './Utils';
 import {
   type ImportFormat,
@@ -22,7 +26,9 @@ import {
   type AnyAlgorithm,
   PrivateKeyObject,
   KeyType,
+  type CryptoKeyPair,
 } from './keys';
+import type { KeyObjectHandle } from './NativeQuickCrypto/webcrypto';
 
 // const {
 //   ArrayPrototypeIncludes,
@@ -114,71 +120,6 @@ function createECPublicKeyRaw(
   return new PublicKeyObject(handle);
 }
 
-// async function ecGenerateKey(algorithm, extractable, keyUsages) {
-//   const { name, namedCurve } = algorithm;
-
-//   if (!ArrayPrototypeIncludes(ObjectKeys(kNamedCurveAliases), namedCurve)) {
-//     throw lazyDOMException(
-//       'Unrecognized namedCurve',
-//       'NotSupportedError');
-//   }
-
-//   const usageSet = new SafeSet(keyUsages);
-//   switch (name) {
-//     case 'ECDSA':
-//       if (hasAnyNotIn(usageSet, ['sign', 'verify'])) {
-//         throw lazyDOMException(
-//           'Unsupported key usage for an ECDSA key',
-//           'SyntaxError');
-//       }
-//       break;
-//     case 'ECDH':
-//       if (hasAnyNotIn(usageSet, ['deriveKey', 'deriveBits'])) {
-//         throw lazyDOMException(
-//           'Unsupported key usage for an ECDH key',
-//           'SyntaxError');
-//       }
-//       // Fall through
-//   }
-
-//   const keypair = await generateKeyPair('ec', { namedCurve }).catch((err) => {
-//     throw lazyDOMException(
-//       'The operation failed for an operation-specific reason',
-//       { name: 'OperationError', cause: err });
-//   });
-
-//   let publicUsages;
-//   let privateUsages;
-//   switch (name) {
-//     case 'ECDSA':
-//       publicUsages = getUsagesUnion(usageSet, 'verify');
-//       privateUsages = getUsagesUnion(usageSet, 'sign');
-//       break;
-//     case 'ECDH':
-//       publicUsages = [];
-//       privateUsages = getUsagesUnion(usageSet, 'deriveKey', 'deriveBits');
-//       break;
-//   }
-
-//   const keyAlgorithm = { name, namedCurve };
-
-//   const publicKey =
-//     new InternalCryptoKey(
-//       keypair.publicKey,
-//       keyAlgorithm,
-//       publicUsages,
-//       true);
-
-//   const privateKey =
-//     new InternalCryptoKey(
-//       keypair.privateKey,
-//       keyAlgorithm,
-//       privateUsages,
-//       extractable);
-
-//   return { __proto__: null, publicKey, privateKey };
-// }
-
 export function ecExportKey(
   key: CryptoKey,
   format: KWebCryptoKeyFormat
@@ -310,8 +251,8 @@ export function ecImportKey(
     case 'ECDSA':
     // Fall through
     case 'ECDH':
-      // if (keyObject.asymmetricKeyType !== 'ec')
-      //   throw new Error('Invalid key type');
+      if (keyObject.asymmetricKeyType !== 'ec')
+        throw new Error('Invalid key type');
       break;
   }
 
@@ -326,26 +267,109 @@ export function ecImportKey(
   return new CryptoKey(keyObject, { name, namedCurve }, keyUsages, extractable);
 }
 
-// function ecdsaSignVerify(key, data, { name, hash }, signature) {
-//   const mode = signature === undefined ? kSignJobModeSign : kSignJobModeVerify;
-//   const type = mode === kSignJobModeSign ? 'private' : 'public';
-
-//   if (key.type !== type)
-//     throw lazyDOMException(`Key must be a ${type} key`, 'InvalidAccessError');
-
-//   const hashname = normalizeHashName(hash.name);
-
-//   return jobPromise(() => new SignJob(
-//     kCryptoJobAsync,
-//     mode,
-//     key[kKeyObject][kHandle],
-//     undefined,
-//     undefined,
-//     undefined,
-//     data,
-//     hashname,
-//     undefined,  // Salt length, not used with ECDSA
-//     undefined,  // PSS Padding, not used with ECDSA
-//     kSigEncP1363,
-//     signature));
-// }
+export const ecdsaSignVerify = (
+  key: CryptoKey,
+  data: BufferLike,
+  { hash }: SubtleAlgorithm,
+  signature?: BufferLike
+) => {
+  const mode: SignMode =
+    signature === undefined
+      ? SignMode.kSignJobModeSign
+      : SignMode.kSignJobModeVerify;
+  const type = mode === SignMode.kSignJobModeSign ? 'private' : 'public';
+
+  if (key.type !== type)
+    throw lazyDOMException(`Key must be a ${type} key`, 'InvalidAccessError');
+
+  const hashname = normalizeHashName(hash);
+
+  return NativeQuickCrypto.webcrypto.signVerify(
+    mode,
+    key.keyObject.handle,
+    // three undefined args because C++ uses `GetPublicOrPrivateKeyFromJs` & friends
+    undefined,
+    undefined,
+    undefined,
+    bufferLikeToArrayBuffer(data),
+    hashname,
+    undefined, // salt length, not used with ECDSA
+    undefined, // pss padding, not used with ECDSA
+    DSASigEnc.kSigEncP1363,
+    bufferLikeToArrayBuffer(signature || new ArrayBuffer(0))
+  );
+};
+
+export const ecGenerateKey = async (
+  algorithm: SubtleAlgorithm,
+  extractable: boolean,
+  keyUsages: KeyUsage[]
+): Promise<CryptoKeyPair> => {
+  const { name, namedCurve } = algorithm;
+
+  if (!Object.keys(kNamedCurveAliases).includes(namedCurve || '')) {
+    throw lazyDOMException(
+      `Unrecognized namedCurve '${namedCurve}'`,
+      'NotSupportedError'
+    );
+  }
+
+  // const usageSet = new SafeSet(keyUsages);
+  switch (name) {
+    case 'ECDSA':
+      const checkUsages = ['sign', 'verify'];
+      if (hasAnyNotIn(keyUsages, checkUsages)) {
+        throw lazyDOMException(
+          'Unsupported key usage for an ECDSA key',
+          'SyntaxError'
+        );
+      }
+      break;
+    case 'ECDH':
+      if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {
+        throw lazyDOMException(
+          'Unsupported key usage for an ECDH key',
+          'SyntaxError'
+        );
+      }
+    // Fall through
+  }
+
+  const options: GenerateKeyPairOptions = { namedCurve };
+  const [err, keypair] = await generateKeyPairPromise('ec', options);
+
+  if (err) {
+    throw lazyDOMException('ecGenerateKey (generateKeyPairPromise) failed', {
+      name: 'OperationError',
+      cause: err,
+    });
+  }
+
+  let publicUsages: KeyUsage[] = [];
+  let privateUsages: KeyUsage[] = [];
+  switch (name) {
+    case 'ECDSA':
+      publicUsages = getUsagesUnion(keyUsages, 'verify');
+      privateUsages = getUsagesUnion(keyUsages, 'sign');
+      break;
+    case 'ECDH':
+      publicUsages = [];
+      privateUsages = getUsagesUnion(keyUsages, 'deriveKey', 'deriveBits');
+      break;
+  }
+
+  const keyAlgorithm = { name, namedCurve };
+
+  const pub = new PublicKeyObject(keypair?.publicKey as KeyObjectHandle);
+  const publicKey = new CryptoKey(pub, keyAlgorithm, publicUsages, true);
+
+  const priv = new PrivateKeyObject(keypair?.privateKey as KeyObjectHandle);
+  const privateKey = new CryptoKey(
+    priv,
+    keyAlgorithm,
+    privateUsages,
+    extractable
+  );
+
+  return { publicKey, privateKey };
+};

package/src/index.ts

@@ -12,15 +12,18 @@ import {
   generateKeyPair,
   generateKeyPairSync,
 } from './Cipher';
+import { generateKey, generateKeySync } from './keygen';
 import { createSign, createVerify } from './sig';
 import { createHmac } from './Hmac';
 import { createHash } from './Hash';
 import { constants } from './constants';
 import { subtle } from './subtle';
 import { getCiphers, getHashes } from './Utils';
+import webcrypto from './webcrypto';
+import { createPrivateKey, createPublicKey, createSecretKey } from './keys';
 
 /**
- * Loosesly matches Node.js {crypto} with some unimplemented functionality
+ * Loosely matches Node.js {crypto} with some unimplemented functionality
  */
 const QuickCrypto = {
   createHmac,
@@ -31,11 +34,16 @@ const QuickCrypto = {
   createCipheriv,
   createDecipher,
   createDecipheriv,
+  createPublicKey,
+  createPrivateKey,
+  createSecretKey,
   publicEncrypt,
   publicDecrypt,
   privateDecrypt,
+  generateKey,
   generateKeyPair,
   generateKeyPairSync,
+  generateKeySync,
   createSign,
   createVerify,
   subtle,
@@ -44,6 +52,7 @@ const QuickCrypto = {
   ...random,
   getCiphers,
   getHashes,
+  webcrypto,
 };
 
 /**

package/src/keygen.ts

@@ -0,0 +1,80 @@
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { lazyDOMException, validateFunction } from './Utils';
+import { kAesKeyLengths } from './aes';
+import {
+  SecretKeyObject,
+  type SecretKeyType,
+  type AesKeyGenParams,
+} from './keys';
+
+export type KeyGenCallback = (
+  err: Error | undefined,
+  key?: SecretKeyObject
+) => void;
+
+export const generateKeyPromise = (
+  type: SecretKeyType,
+  options: AesKeyGenParams // | HmacKeyGenParams
+): Promise<[Error | undefined, SecretKeyObject | undefined]> => {
+  return new Promise((resolve, reject) => {
+    generateKey(type, options, (err, key) => {
+      if (err) {
+        reject([err, undefined]);
+      }
+      resolve([undefined, key]);
+    });
+  });
+};
+
+export const generateKey = (
+  type: SecretKeyType,
+  options: AesKeyGenParams, // | HmacKeyGenParams,
+  callback: KeyGenCallback
+): void => {
+  validateLength(type, options.length);
+  if (!validateFunction(callback)) {
+    throw lazyDOMException('Callback is not a function', 'SyntaxError');
+  }
+  NativeQuickCrypto.webcrypto
+    .generateSecretKey(options.length)
+    .then((handle) => {
+      callback(undefined, new SecretKeyObject(handle));
+    })
+    .catch((err) => {
+      callback(err, undefined);
+    });
+};
+
+export const generateKeySync = (
+  type: SecretKeyType,
+  options: AesKeyGenParams // | HmacKeyGenParams,
+): SecretKeyObject => {
+  validateLength(type, options.length);
+  const handle = NativeQuickCrypto.webcrypto.generateSecretKeySync(
+    options.length
+  );
+  return new SecretKeyObject(handle);
+};
+
+const validateLength = (type: SecretKeyType, length: number) => {
+  switch (type) {
+    case 'aes':
+      if (!kAesKeyLengths.includes(length)) {
+        throw lazyDOMException(
+          'AES key length must be 128, 192, or 256 bits',
+          'OperationError'
+        );
+      }
+      break;
+    case 'hmac':
+      if (length < 8 || length > 2 ** 31 - 1) {
+        throw lazyDOMException(
+          'HMAC key length must be between 8 and 2^31 - 1',
+          'OperationError'
+        );
+      }
+      break;
+    default:
+      throw new Error(`Unsupported key type '${type}' for generateKey()`);
+  }
+};