react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.21

package/src/keys/generateKeyPair.ts

@@ -1,146 +1,145 @@
-// import { ed25519 } from '../ed25519';
-// import {
-//   kEmptyObject,
-//   validateFunction,
-//   type CryptoKeyPair,
-//   type GenerateKeyPairCallback,
-//   type GenerateKeyPairOptions,
-//   type GenerateKeyPairPromiseReturn,
-//   type GenerateKeyPairReturn,
-//   type KeyPairGenConfig,
-//   type KeyPairType,
-// } from '../utils';
-// import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+import { ed_generateKeyPair } from '../ed';
+import {
+  kEmptyObject,
+  validateFunction,
+  type CryptoKeyPair,
+  type GenerateKeyPairCallback,
+  type GenerateKeyPairOptions,
+  type GenerateKeyPairPromiseReturn,
+  type GenerateKeyPairReturn,
+  type KeyPairGenConfig,
+  type KeyPairType,
+} from '../utils';
+import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
 
-// export const generateKeyPair = (
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions,
-//   callback: GenerateKeyPairCallback,
-// ): void => {
-//   validateFunction(callback);
-//   internalGenerateKeyPair(true, type, options, callback);
-// };
+export const generateKeyPair = (
+  type: KeyPairType,
+  options: GenerateKeyPairOptions,
+  callback: GenerateKeyPairCallback,
+): void => {
+  validateFunction(callback);
+  internalGenerateKeyPair(true, type, options, callback);
+};
 
-// // Promisify generateKeyPair
-// // (attempted to use util.promisify, to no avail)
-// export const generateKeyPairPromise = (
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions,
-// ): Promise<GenerateKeyPairPromiseReturn> => {
-//   return new Promise((resolve, reject) => {
-//     generateKeyPair(type, options, (err, publicKey, privateKey) => {
-//       if (err) {
-//         reject([err, undefined]);
-//       } else {
-//         resolve([undefined, { publicKey, privateKey }]);
-//       }
-//     });
-//   });
-// };
+// Promisify generateKeyPair
+// (attempted to use util.promisify, to no avail)
+export const generateKeyPairPromise = (
+  type: KeyPairType,
+  options: GenerateKeyPairOptions,
+): Promise<GenerateKeyPairPromiseReturn> => {
+  return new Promise((resolve, reject) => {
+    generateKeyPair(type, options, (err, publicKey, privateKey) => {
+      if (err) {
+        reject([err, undefined]);
+      } else {
+        resolve([undefined, { publicKey, privateKey }]);
+      }
+    });
+  });
+};
 
-// // generateKeyPairSync
-// export function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;
-// export function generateKeyPairSync(
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions,
-// ): CryptoKeyPair;
-// export function generateKeyPairSync(
-//   type: KeyPairType,
-//   options?: GenerateKeyPairOptions,
-// ): CryptoKeyPair {
-//   const [err, publicKey, privateKey] = internalGenerateKeyPair(
-//     false,
-//     type,
-//     options,
-//     undefined,
-//   )!;
+// generateKeyPairSync
+export function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;
+export function generateKeyPairSync(
+  type: KeyPairType,
+  options: GenerateKeyPairOptions,
+): CryptoKeyPair;
+export function generateKeyPairSync(
+  type: KeyPairType,
+  options?: GenerateKeyPairOptions,
+): CryptoKeyPair {
+  const [err, publicKey, privateKey] = internalGenerateKeyPair(
+    false,
+    type,
+    options,
+    undefined,
+  )!;
 
-//   if (err) {
-//     throw err;
-//   }
+  if (err) {
+    throw err;
+  }
 
-//   return {
-//     publicKey,
-//     privateKey,
-//   };
-// }
+  return {
+    publicKey,
+    privateKey,
+  };
+}
 
-// function parseKeyPairEncoding(
-//   keyType: string,
-//   options: GenerateKeyPairOptions = kEmptyObject,
-// ): KeyPairGenConfig {
-//   const { publicKeyEncoding, privateKeyEncoding } = options;
+function parseKeyPairEncoding(
+  keyType: string,
+  options: GenerateKeyPairOptions = kEmptyObject,
+): KeyPairGenConfig {
+  const { publicKeyEncoding, privateKeyEncoding } = options;
 
-//   let publicFormat, publicType;
-//   if (publicKeyEncoding == null) {
-//     publicFormat = publicType = -1;
-//   } else if (typeof publicKeyEncoding === 'object') {
-//     ({ format: publicFormat, type: publicType } = parsePublicKeyEncoding(
-//       publicKeyEncoding,
-//       keyType,
-//       'publicKeyEncoding',
-//     ));
-//   } else {
-//     throw new Error(
-//       'Invalid argument options.publicKeyEncoding',
-//       publicKeyEncoding,
-//     );
-//   }
+  let publicFormat, publicType;
+  if (publicKeyEncoding == null) {
+    publicFormat = publicType = -1;
+  } else if (typeof publicKeyEncoding === 'object') {
+    ({ format: publicFormat, type: publicType } = parsePublicKeyEncoding(
+      publicKeyEncoding,
+      keyType,
+      'publicKeyEncoding',
+    ));
+  } else {
+    throw new Error(
+      'Invalid argument options.publicKeyEncoding',
+      publicKeyEncoding,
+    );
+  }
 
-//   let privateFormat, privateType, cipher, passphrase;
-//   if (privateKeyEncoding == null) {
-//     privateFormat = privateType = -1;
-//   } else if (typeof privateKeyEncoding === 'object') {
-//     ({
-//       format: privateFormat,
-//       type: privateType,
-//       cipher,
-//       passphrase,
-//     } = parsePrivateKeyEncoding(
-//       privateKeyEncoding,
-//       keyType,
-//       'privateKeyEncoding',
-//     ));
-//   } else {
-//     throw new Error(
-//       'Invalid argument options.privateKeyEncoding',
-//       publicKeyEncoding as ErrorOptions,
-//     );
-//   }
+  let privateFormat, privateType, cipher, passphrase;
+  if (privateKeyEncoding == null) {
+    privateFormat = privateType = -1;
+  } else if (typeof privateKeyEncoding === 'object') {
+    ({
+      format: privateFormat,
+      type: privateType,
+      cipher,
+      passphrase,
+    } = parsePrivateKeyEncoding(
+      privateKeyEncoding,
+      keyType,
+      'privateKeyEncoding',
+    ));
+  } else {
+    throw new Error(
+      'Invalid argument options.privateKeyEncoding',
+      publicKeyEncoding as ErrorOptions,
+    );
+  }
 
-//   return {
-//     publicFormat,
-//     publicType,
-//     privateFormat,
-//     privateType,
-//     cipher,
-//     passphrase,
-//   };
-// }
+  return {
+    publicFormat,
+    publicType,
+    privateFormat,
+    privateType,
+    cipher,
+    passphrase,
+  };
+}
 
-// function internalGenerateKeyPair(
-//   isAsync: boolean,
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions | undefined,
-//   callback: GenerateKeyPairCallback | undefined,
-// ): GenerateKeyPairReturn | void {
-//   const encoding = parseKeyPairEncoding(type, options);
+function internalGenerateKeyPair(
+  isAsync: boolean,
+  type: KeyPairType,
+  options: GenerateKeyPairOptions | undefined,
+  callback: GenerateKeyPairCallback | undefined,
+): GenerateKeyPairReturn | void {
+  const encoding = parseKeyPairEncoding(type, options);
 
-//   switch (type) {
-//     case 'ed25519':
-//     case 'ed448':
-//     case 'x25519':
-//     case 'x448': {
-//       return ed25519.utils.generateKeyPair(isAsync, type, encoding, callback);
-//     }
-//     default:
-//     // Fall through
-//   }
+  switch (type) {
+    case 'ed25519':
+    case 'ed448':
+    case 'x25519':
+    case 'x448':
+      return ed_generateKeyPair(isAsync, type, encoding, callback);
+    default:
+    // fall through
+  }
 
-//   const err = new Error(`
-//     Invalid Argument options: '${type}' scheme not supported for
-//     generateKeyPair(). Currently not all encryption methods are supported in
-//     this library.  Check docs/implementation_coverage.md for status.
-//   `);
-//   return [err, undefined, undefined];
-// }
+  const err = new Error(`
+    Invalid Argument options: '${type}' scheme not supported for
+    generateKeyPair(). Currently not all encryption methods are supported in
+    this library.  Check docs/implementation_coverage.md for status.
+  `);
+  return [err, undefined, undefined];
+}

package/src/keys/index.ts

@@ -1,11 +1,12 @@
 import {
+  AsymmetricKeyObject,
   CryptoKey,
   KeyObject,
   SecretKeyObject,
   PublicKeyObject,
   PrivateKeyObject,
 } from './classes';
-// import { generateKeyPair } from './generateKeyPair';
+import { generateKeyPair, generateKeyPairSync } from './generateKeyPair';
 // import { sign, verify } from './signVerify';
 import {
   isCryptoKey,
@@ -13,14 +14,23 @@ import {
   parsePrivateKeyEncoding,
   parsePublicKeyEncoding,
 } from './utils';
+import type { BinaryLike } from '../utils';
+import { binaryLikeToArrayBuffer as toAB } from '../utils';
+
+function createSecretKey(key: BinaryLike): SecretKeyObject {
+  const keyBuffer = toAB(key);
+  return KeyObject.createKeyObject('secret', keyBuffer) as SecretKeyObject;
+}
 
 export {
   // Node Public API
-  // createSecretKey,
+  createSecretKey,
   // createPublicKey,
   // createPrivateKey,
   CryptoKey,
-  // generateKeyPair,
+  generateKeyPair,
+  generateKeyPairSync,
+  AsymmetricKeyObject,
   KeyObject,
   // InternalCryptoKey,
   // sign,

package/src/keys/utils.ts

@@ -4,13 +4,21 @@ import {
   KeyEncoding,
   KFormatType,
 } from '../utils';
-import type { EncodingOptions } from '../utils';
+import type { CryptoKeyPair, EncodingOptions } from '../utils';
+import type { CryptoKey } from './classes';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const isCryptoKey = (obj: any): boolean => {
   return obj !== null && obj?.keyObject !== undefined;
 };
 
+export function getCryptoKeyPair(
+  key: CryptoKey | CryptoKeyPair,
+): CryptoKeyPair {
+  if ('publicKey' in key && 'privateKey' in key) return key;
+  throw new Error('Invalid CryptoKeyPair');
+}
+
 /**
  * Parses the public key encoding based on an object. keyType must be undefined
  * when this is used to parse an input encoding and must be a valid key type if
@@ -65,9 +73,8 @@ export function parseKeyEncoding(
             `Invalid argument ${option('cipher', objName)}: ${cipher}`,
           );
         if (
-          format === KFormatType.kKeyFormatDER &&
-          (type === KeyEncoding.kKeyEncodingPKCS1 ||
-            type === KeyEncoding.kKeyEncodingSEC1)
+          format === KFormatType.DER &&
+          (type === KeyEncoding.PKCS1 || type === KeyEncoding.SEC1)
         ) {
           throw new Error(
             `Incompatible key options ${encodingNames[type]} does not support encryption`,
@@ -97,10 +104,10 @@ export function parseKeyEncoding(
 }
 
 const encodingNames = {
-  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',
-  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',
-  [KeyEncoding.kKeyEncodingSPKI]: 'spki',
-  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',
+  [KeyEncoding.PKCS1]: 'pkcs1',
+  [KeyEncoding.PKCS8]: 'pkcs8',
+  [KeyEncoding.SPKI]: 'spki',
+  [KeyEncoding.SEC1]: 'sec1',
 };
 
 function option(name: string, objName?: string) {
@@ -116,9 +123,9 @@ function parseKeyFormat(
 ) {
   if (formatStr === undefined && defaultFormat !== undefined)
     return defaultFormat;
-  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;
-  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;
-  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;
+  else if (formatStr === 'pem') return KFormatType.PEM;
+  else if (formatStr === 'der') return KFormatType.DER;
+  else if (formatStr === 'jwk') return KFormatType.JWK;
   throw new Error(`Invalid key format str: ${optionName}`);
 }
 
@@ -137,18 +144,18 @@ function parseKeyType(
         `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`,
       );
     }
-    return KeyEncoding.kKeyEncodingPKCS1;
+    return KeyEncoding.PKCS1;
   } else if (typeStr === 'spki' && isPublic !== false) {
-    return KeyEncoding.kKeyEncodingSPKI;
+    return KeyEncoding.SPKI;
   } else if (typeStr === 'pkcs8' && isPublic !== true) {
-    return KeyEncoding.kKeyEncodingPKCS8;
+    return KeyEncoding.PKCS8;
   } else if (typeStr === 'sec1' && isPublic !== true) {
     if (keyType !== undefined && keyType !== 'ec') {
       throw new Error(
         `Incompatible key options ${typeStr} can only be used for EC keys`,
       );
     }
-    return KeyEncoding.kKeyEncodingSEC1;
+    return KeyEncoding.SEC1;
   }
 
   throw new Error(`Invalid option ${optionName} - ${typeStr}`);
@@ -165,13 +172,12 @@ function parseKeyFormatAndType(
   const isInput = keyType === undefined;
   const format = parseKeyFormat(
     formatStr,
-    isInput ? KFormatType.kKeyFormatPEM : undefined,
+    isInput ? KFormatType.PEM : undefined,
     option('format', objName),
   );
 
   const isRequired =
-    (!isInput || format === KFormatType.kKeyFormatDER) &&
-    format !== KFormatType.kKeyFormatJWK;
+    (!isInput || format === KFormatType.DER) && format !== KFormatType.JWK;
 
   const type = parseKeyType(
     typeStr,

package/src/rsa.ts

@@ -0,0 +1,176 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import {
+  CryptoKey,
+  KeyObject,
+  PrivateKeyObject,
+  PublicKeyObject,
+} from './keys';
+import {
+  getUsagesUnion,
+  hasAnyNotIn,
+  lazyDOMException,
+  normalizeHashName,
+} from './utils';
+import type {
+  CryptoKeyPair,
+  KeyUsage,
+  RsaHashedKeyGenParams,
+  SubtleAlgorithm,
+} from './utils';
+import type { RsaKeyPair } from './specs/rsaKeyPair.nitro';
+
+export class Rsa {
+  native: RsaKeyPair;
+
+  constructor(
+    modulusLength: number,
+    publicExponent: Uint8Array,
+    hashAlgorithm: string,
+  ) {
+    this.native = NitroModules.createHybridObject<RsaKeyPair>('RsaKeyPair');
+    this.native.setModulusLength(modulusLength);
+    this.native.setPublicExponent(
+      publicExponent.buffer.slice(
+        publicExponent.byteOffset,
+        publicExponent.byteOffset + publicExponent.byteLength,
+      ) as ArrayBuffer,
+    );
+    this.native.setHashAlgorithm(hashAlgorithm);
+  }
+
+  async generateKeyPair(): Promise<CryptoKeyPair> {
+    await this.native.generateKeyPair();
+    return {
+      publicKey: this.native.getPublicKey(),
+      privateKey: this.native.getPrivateKey(),
+    };
+  }
+
+  generateKeyPairSync(): CryptoKeyPair {
+    this.native.generateKeyPairSync();
+    return {
+      publicKey: this.native.getPublicKey(),
+      privateKey: this.native.getPrivateKey(),
+    };
+  }
+}
+
+// Node API
+export async function rsa_generateKeyPair(
+  algorithm: SubtleAlgorithm,
+  extractable: boolean,
+  keyUsages: KeyUsage[],
+): Promise<CryptoKeyPair> {
+  const { name, modulusLength, publicExponent, hash } =
+    algorithm as RsaHashedKeyGenParams;
+
+  // Validate parameters first
+  if (!modulusLength || modulusLength < 256) {
+    throw lazyDOMException('Invalid key length', 'OperationError');
+  }
+
+  if (!publicExponent || publicExponent.length === 0) {
+    throw lazyDOMException('Invalid public exponent', 'OperationError');
+  }
+
+  // Validate hash algorithm using existing validation function
+  let hashName: string;
+  try {
+    const normalizedHash = normalizeHashName(hash);
+    hashName = typeof hash === 'string' ? hash : hash?.name || normalizedHash;
+  } catch {
+    throw lazyDOMException('Invalid Hash Algorithm', 'NotSupportedError');
+  }
+
+  // Validate usages are not empty
+  if (keyUsages.length === 0) {
+    throw lazyDOMException('Usages cannot be empty', 'SyntaxError');
+  }
+
+  // Usage validation based on algorithm type
+  switch (name) {
+    case 'RSASSA-PKCS1-v1_5':
+      if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+        throw lazyDOMException(
+          `Unsupported key usage for a ${name} key`,
+          'SyntaxError',
+        );
+      }
+      break;
+    case 'RSA-PSS':
+      if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+        throw lazyDOMException(
+          `Unsupported key usage for a ${name} key`,
+          'SyntaxError',
+        );
+      }
+      break;
+    case 'RSA-OAEP':
+      if (
+        hasAnyNotIn(keyUsages, ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'])
+      ) {
+        throw lazyDOMException(
+          `Unsupported key usage for a ${name} key`,
+          'SyntaxError',
+        );
+      }
+      break;
+    default:
+      throw lazyDOMException(
+        'The algorithm is not supported',
+        'NotSupportedError',
+      );
+  }
+
+  // Split usages between public and private keys
+  let publicUsages: KeyUsage[] = [];
+  let privateUsages: KeyUsage[] = [];
+  switch (name) {
+    case 'RSASSA-PKCS1-v1_5':
+    case 'RSA-PSS':
+      publicUsages = getUsagesUnion(keyUsages, 'verify');
+      privateUsages = getUsagesUnion(keyUsages, 'sign');
+      break;
+    case 'RSA-OAEP':
+      publicUsages = getUsagesUnion(keyUsages, 'encrypt', 'wrapKey');
+      privateUsages = getUsagesUnion(keyUsages, 'decrypt', 'unwrapKey');
+      break;
+  }
+
+  // Validate that private key has usages for CryptoKeyPair
+  if (privateUsages.length === 0) {
+    throw lazyDOMException('Usages cannot be empty', 'SyntaxError');
+  }
+
+  const rsa = new Rsa(modulusLength, publicExponent, hashName);
+  await rsa.generateKeyPair();
+
+  const keyAlgorithm = {
+    name,
+    modulusLength,
+    publicExponent,
+    hash: { name: hashName },
+  };
+
+  // Create KeyObject instances using the standard createKeyObject method
+  const publicKeyData = rsa.native.getPublicKey();
+  const pub = KeyObject.createKeyObject(
+    'public',
+    publicKeyData,
+  ) as PublicKeyObject;
+  const publicKey = new CryptoKey(pub, keyAlgorithm, publicUsages, true);
+
+  const privateKeyData = rsa.native.getPrivateKey();
+  const priv = KeyObject.createKeyObject(
+    'private',
+    privateKeyData,
+  ) as PrivateKeyObject;
+  const privateKey = new CryptoKey(
+    priv,
+    keyAlgorithm,
+    privateUsages,
+    extractable,
+  );
+
+  return { publicKey, privateKey };
+}

package/src/specs/blake3.nitro.ts

@@ -0,0 +1,12 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Blake3 extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  initHash(): void;
+  initKeyed(key: ArrayBuffer): void;
+  initDeriveKey(context: string): void;
+  update(data: ArrayBuffer): void;
+  digest(length?: number): ArrayBuffer;
+  reset(): void;
+  copy(): Blake3;
+  getVersion(): string;
+}

package/src/specs/ecKeyPair.nitro.ts

@@ -0,0 +1,38 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+//  Nitro-compatible interfaces defined locally
+interface KeyObject {
+  extractable: boolean;
+}
+
+export interface EcKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  // generateKeyPair functions
+  generateKeyPair(): Promise<void>;
+  generateKeyPairSync(): void;
+
+  // importKey
+  importKey(
+    format: string,
+    keyData: ArrayBuffer,
+    algorithm: string,
+    extractable: boolean,
+    keyUsages: string[],
+  ): KeyObject;
+
+  // exportKey
+  exportKey(key: KeyObject, format: string): ArrayBuffer;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+
+  setCurve(curve: string): void;
+
+  // ECDSA sign/verify operations
+  sign(data: ArrayBuffer, hashAlgorithm: string): ArrayBuffer;
+  verify(
+    data: ArrayBuffer,
+    signature: ArrayBuffer,
+    hashAlgorithm: string,
+  ): boolean;
+}

package/src/specs/edKeyPair.nitro.ts

@@ -2,6 +2,8 @@ import type { HybridObject } from 'react-native-nitro-modules';
 
 export interface EdKeyPair
   extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  diffieHellman(privateKey: ArrayBuffer, publicKey: ArrayBuffer): ArrayBuffer;
+
   generateKeyPair(
     publicFormat: number,
     publicType: number,

package/src/specs/hash.nitro.ts

@@ -6,4 +6,5 @@ export interface Hash extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   digest(encoding?: string): ArrayBuffer;
   copy(outputLength?: number): Hash;
   getSupportedHashAlgorithms(): string[];
+  getOpenSSLVersion(): string;
 }

package/src/specs/keyObjectHandle.nitro.ts

@@ -26,7 +26,6 @@ export interface KeyObjectHandle
     type?: KeyEncoding,
     passphrase?: ArrayBuffer,
   ): boolean;
-  initECRaw(curveName: string, keyData: ArrayBuffer): boolean;
   initJwk(keyData: JWK, namedCurve?: NamedCurve): KeyType | undefined;
   keyDetail(): KeyDetail;
 }