react-native-quick-crypto 1.0.0-beta.4 → 1.0.0-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "type": "module",
   "main": "lib/commonjs/index",
@@ -8,6 +8,19 @@
   "types": "lib/typescript/index.d.ts",
   "react-native": "src/index",
   "source": "src/index",
+  "scripts": {
+    "clean": "del-cli android/build lib",
+    "tsc": "tsc --noEmit",
+    "typescript": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "lint:fix": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "format": "prettier --check \"**/*.{js,ts,tsx}\"",
+    "format:fix": "prettier --write \"**/*.{js,ts,tsx}\"",
+    "prepare": "bun clean && bun tsc && bob build",
+    "release": "release-it",
+    "specs": "nitro-codegen",
+    "test": "jest"
+  },
   "files": [
     "src",
     "lib",
@@ -27,19 +40,6 @@
     "!**/__fixtures__",
     "!**/__mocks__"
   ],
-  "scripts": {
-    "clean": "del-cli android/build lib",
-    "tsc": "tsc --noEmit",
-    "typescript": "tsc --noEmit",
-    "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "lint:fix": "eslint \"**/*.{js,ts,tsx}\" --fix",
-    "format": "prettier --check \"**/*.{js,ts,tsx}\"",
-    "format:fix": "prettier --write \"**/*.{js,ts,tsx}\"",
-    "prepare": "bun clean && bob build",
-    "release-it": "bun prepare && release-it",
-    "specs": "nitro-codegen",
-    "test": "jest"
-  },
   "keywords": [
     "react-native",
     "ios",
@@ -56,7 +56,8 @@
   },
   "authors": [
     "Szymon Kapała <szymon20000@gmail.com>",
-    "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)"
+    "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+    "Brad Anderson <brad@sankatygroup.com> (https://github.com/boorad)"
   ],
   "license": "MIT",
   "bugs": {
@@ -69,7 +70,7 @@
   "dependencies": {
     "@craftzdog/react-native-buffer": "6.0.5",
     "events": "3.3.0",
-    "react-native-nitro-modules": "0.14.0",
+    "react-native-nitro-modules": "0.18.1",
     "react-native-quick-base64": "2.1.2",
     "readable-stream": "4.5.2",
     "string_decoder": "1.3.0",
@@ -77,19 +78,19 @@
   },
   "devDependencies": {
     "@eslint/compat": "^1.1.1",
-    "@eslint/js": "10.0.0",
+    "@eslint/js": "9.16.0",
     "@release-it/bumper": "6.0.1",
     "@types/jest": "29.5.11",
     "@types/node": "22.0.0",
     "@types/react": "18.3.3",
     "@types/readable-stream": "4.0.11",
-    "del-cli": "5.1.0",
+    "del-cli": "6.0.0",
     "eslint": "9.9.0",
     "eslint-plugin-react-native": "^4.1.0",
     "jest": "29.7.0",
-    "nitro-codegen": "0.14.0",
+    "nitro-codegen": "0.18.1",
     "prettier": "3.3.3",
-    "react-native-builder-bob": "0.30.0",
+    "react-native-builder-bob": "0.33.3",
     "release-it": "17.6.0",
     "typescript": "5.1.6",
     "typescript-eslint": "^8.1.0"
@@ -106,7 +107,10 @@
     "github": {
       "release": false
     },
-    "plugins": {}
+    "hooks": {
+      "before:init": "bun tsc && bun lint && bun format",
+      "after:bump": "bun prepare"
+    }
   },
   "react-native-builder-bob": {
     "source": "src",

package/src/ed.ts

@@ -0,0 +1,58 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { EdKeyPair } from './specs/edKeyPair.nitro';
+import type { CFRGKeyPairType, KeyPairGenConfig } from './utils';
+
+export class Ed {
+  type: CFRGKeyPairType;
+  config: KeyPairGenConfig;
+  native: EdKeyPair;
+
+  constructor(type: CFRGKeyPairType, config: KeyPairGenConfig) {
+    this.type = type;
+    this.config = config;
+    this.native = NitroModules.createHybridObject<EdKeyPair>('EdKeyPair');
+    this.native.setCurve(type);
+  }
+
+  async generateKeyPair(): Promise<void> {
+    this.native.generateKeyPair(
+      this.config.publicFormat || (-1 as number),
+      this.config.publicType || (-1 as number),
+      this.config.privateFormat || (-1 as number),
+      this.config.privateType || (-1 as number),
+      this.config.cipher as string,
+      this.config.passphrase as ArrayBuffer,
+    );
+  }
+
+  generateKeyPairSync(): void {
+    this.native.generateKeyPairSync(
+      this.config.publicFormat || (-1 as number),
+      this.config.publicType || (-1 as number),
+      this.config.privateFormat || (-1 as number),
+      this.config.privateType || (-1 as number),
+      this.config.cipher as string,
+      this.config.passphrase as ArrayBuffer,
+    );
+  }
+
+  getPublicKey(): ArrayBuffer {
+    return this.native.getPublicKey();
+  }
+
+  async sign(message: ArrayBuffer): Promise<ArrayBuffer> {
+    return this.native.sign(message);
+  }
+
+  signSync(message: ArrayBuffer): ArrayBuffer {
+    return this.native.signSync(message);
+  }
+
+  async verify(signature: ArrayBuffer, message: ArrayBuffer): Promise<boolean> {
+    return this.native.verify(signature, message);
+  }
+
+  verifySync(signature: ArrayBuffer, message: ArrayBuffer): boolean {
+    return this.native.verifySync(signature, message);
+  }
+}

package/src/index.ts

@@ -2,6 +2,8 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 
 // API imports
+import * as keys from './keys';
+import * as ed from './ed';
 import * as pbkdf2 from './pbkdf2';
 import * as random from './random';
 
@@ -21,20 +23,17 @@ const QuickCrypto = {
   // createCipheriv,
   // createDecipher,
   // createDecipheriv,
-  // createPublicKey,
-  // createPrivateKey,
-  // createSecretKey,
   // publicEncrypt,
   // publicDecrypt,
   // privateDecrypt,
   // generateKey,
-  // generateKeyPair,
-  // generateKeyPairSync,
   // generateKeySync,
   // createSign,
   // createVerify,
   // subtle,
   // constants,
+  ...keys,
+  ...ed,
   ...pbkdf2,
   ...random,
   // getCiphers,
@@ -60,6 +59,7 @@ global.process.nextTick = setImmediate;
 
 // exports
 export default QuickCrypto;
+export * from './ed';
 export * from './utils';
 
 // Additional exports for CommonJS compatibility

package/src/keys/classes.ts

@@ -0,0 +1,211 @@
+import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
+import type {
+  AsymmetricKeyType,
+  EncodingOptions,
+  KeyUsage,
+  SubtleAlgorithm,
+} from '../utils';
+import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+
+export class CryptoKey {
+  keyObject: KeyObject;
+  keyAlgorithm: SubtleAlgorithm;
+  keyUsages: KeyUsage[];
+  keyExtractable: boolean;
+
+  constructor(
+    keyObject: KeyObject,
+    keyAlgorithm: SubtleAlgorithm,
+    keyUsages: KeyUsage[],
+    keyExtractable: boolean,
+  ) {
+    this.keyObject = keyObject;
+    this.keyAlgorithm = keyAlgorithm;
+    this.keyUsages = keyUsages;
+    this.keyExtractable = keyExtractable;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  inspect(_depth: number, _options: unknown): unknown {
+    throw new Error('CryptoKey.inspect is not implemented');
+    // if (depth < 0) return this;
+
+    // const opts = {
+    //   ...options,
+    //   depth: options.depth == null ? null : options.depth - 1,
+    // };
+
+    // return `CryptoKey ${inspect(
+    //   {
+    //     type: this.type,
+    //     extractable: this.extractable,
+    //     algorithm: this.algorithm,
+    //     usages: this.usages,
+    //   },
+    //   opts
+    // )}`;
+  }
+
+  get type() {
+    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');
+    return this.keyObject.type;
+  }
+
+  get extractable() {
+    return this.keyExtractable;
+  }
+
+  get algorithm() {
+    return this.keyAlgorithm;
+  }
+
+  get usages() {
+    return this.keyUsages;
+  }
+}
+
+export class KeyObject {
+  handle: KeyObjectHandle;
+  type: 'public' | 'secret' | 'private' | 'unknown' = 'unknown';
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export(_options?: EncodingOptions): ArrayBuffer {
+    return new ArrayBuffer(0);
+  }
+
+  constructor(type: string, handle: KeyObjectHandle) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private')
+      throw new Error(`invalid KeyObject type: ${type}`);
+    this.handle = handle;
+    this.type = type;
+  }
+
+  // get type(): string {
+  //   return this.type;
+  // }
+
+  // static from(key) {
+  //   if (!isCryptoKey(key))
+  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
+  //   return key[kKeyObject];
+  // }
+
+  // equals(otherKeyObject) {
+  //   if (!isKeyObject(otherKeyObject)) {
+  //     throw new ERR_INVALID_ARG_TYPE(
+  //       'otherKeyObject',
+  //       'KeyObject',
+  //       otherKeyObject
+  //     );
+  //   }
+
+  //   return (
+  //     otherKeyObject.type === this.type &&
+  //     this[kHandle].equals(otherKeyObject[kHandle])
+  //   );
+  // }
+}
+
+export class SecretKeyObject extends KeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('secret', handle);
+  }
+
+  // get symmetricKeySize() {
+  //   return this[kHandle].getSymmetricKeySize();
+  // }
+
+  export(options?: EncodingOptions) {
+    if (options !== undefined) {
+      if (options.format === 'jwk') {
+        throw new Error('SecretKey export for jwk is not implemented');
+        // return this.handle.exportJwk({}, false);
+      }
+    }
+    return this.handle.exportKey();
+  }
+}
+
+// const kAsymmetricKeyType = Symbol('kAsymmetricKeyType');
+// const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails');
+
+// function normalizeKeyDetails(details = {}) {
+//   if (details.publicExponent !== undefined) {
+//     return {
+//       ...details,
+//       publicExponent: bigIntArrayToUnsignedBigInt(
+//         new Uint8Array(details.publicExponent)
+//       ),
+//     };
+//   }
+//   return details;
+// }
+
+export class AsymmetricKeyObject extends KeyObject {
+  constructor(type: string, handle: KeyObjectHandle) {
+    super(type, handle);
+  }
+
+  private _asymmetricKeyType?: AsymmetricKeyType;
+
+  get asymmetricKeyType(): AsymmetricKeyType {
+    if (!this._asymmetricKeyType) {
+      this._asymmetricKeyType = this.handle.getAsymmetricKeyType();
+    }
+    return this._asymmetricKeyType;
+  }
+
+  // get asymmetricKeyDetails() {
+  //   switch (this._asymmetricKeyType) {
+  //     case 'rsa':
+  //     case 'rsa-pss':
+  //     case 'dsa':
+  //     case 'ec':
+  //       return (
+  //         this[kAsymmetricKeyDetails] ||
+  //         (this[kAsymmetricKeyDetails] = normalizeKeyDetails(
+  //           this[kHandle].keyDetail({})
+  //         ))
+  //       );
+  //     default:
+  //       return {};
+  //   }
+  // }
+}
+
+export class PublicKeyObject extends AsymmetricKeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('public', handle);
+  }
+
+  export(options: EncodingOptions) {
+    if (options?.format === 'jwk') {
+      throw new Error('PublicKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const { format, type } = parsePublicKeyEncoding(
+      options,
+      this.asymmetricKeyType,
+    );
+    return this.handle.exportKey(format, type);
+  }
+}
+
+export class PrivateKeyObject extends AsymmetricKeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('private', handle);
+  }
+
+  export(options: EncodingOptions) {
+    if (options?.format === 'jwk') {
+      if (options.passphrase !== undefined) {
+        throw new Error('jwk does not support encryption');
+      }
+      throw new Error('PrivateKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const { format, type, cipher, passphrase } = parsePrivateKeyEncoding(
+      options,
+      this.asymmetricKeyType,
+    );
+    return this.handle.exportKey(format, type, cipher, passphrase);
+  }
+}

package/src/keys/generateKeyPair.ts

@@ -0,0 +1,146 @@
+// 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';
+
+// 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 }]);
+//       }
+//     });
+//   });
+// };
+
+// // 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;
+//   }
+
+//   return {
+//     publicKey,
+//     privateKey,
+//   };
+// }
+
+// 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 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,
+//   };
+// }
+
+// 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
+//   }
+
+//   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,99 +1,42 @@
-import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
-import type { EncodingOptions, KeyUsage, SubtleAlgorithm } from '../utils';
-
-export class CryptoKey {
-  keyObject: KeyObject;
-  keyAlgorithm: SubtleAlgorithm;
-  keyUsages: KeyUsage[];
-  keyExtractable: boolean;
-
-  constructor(
-    keyObject: KeyObject,
-    keyAlgorithm: SubtleAlgorithm,
-    keyUsages: KeyUsage[],
-    keyExtractable: boolean,
-  ) {
-    this.keyObject = keyObject;
-    this.keyAlgorithm = keyAlgorithm;
-    this.keyUsages = keyUsages;
-    this.keyExtractable = keyExtractable;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  inspect(_depth: number, _options: unknown): unknown {
-    throw new Error('CryptoKey.inspect is not implemented');
-    // if (depth < 0) return this;
-
-    // const opts = {
-    //   ...options,
-    //   depth: options.depth == null ? null : options.depth - 1,
-    // };
-
-    // return `CryptoKey ${inspect(
-    //   {
-    //     type: this.type,
-    //     extractable: this.extractable,
-    //     algorithm: this.algorithm,
-    //     usages: this.usages,
-    //   },
-    //   opts
-    // )}`;
-  }
-
-  get type() {
-    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');
-    return this.keyObject.type;
-  }
-
-  get extractable() {
-    return this.keyExtractable;
-  }
-
-  get algorithm() {
-    return this.keyAlgorithm;
-  }
-
-  get usages() {
-    return this.keyUsages;
-  }
-}
-
-class KeyObject {
-  handle: KeyObjectHandle;
-  type: 'public' | 'secret' | 'private' | 'unknown' = 'unknown';
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  export(_options?: EncodingOptions): ArrayBuffer {
-    return new ArrayBuffer(0);
-  }
-
-  constructor(type: string, handle: KeyObjectHandle) {
-    if (type !== 'secret' && type !== 'public' && type !== 'private')
-      throw new Error(`invalid KeyObject type: ${type}`);
-    this.handle = handle;
-    this.type = type;
-  }
-
-  // get type(): string {
-  //   return this.type;
-  // }
-
-  // static from(key) {
-  //   if (!isCryptoKey(key))
-  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
-  //   return key[kKeyObject];
-  // }
-
-  // equals(otherKeyObject) {
-  //   if (!isKeyObject(otherKeyObject)) {
-  //     throw new ERR_INVALID_ARG_TYPE(
-  //       'otherKeyObject',
-  //       'KeyObject',
-  //       otherKeyObject
-  //     );
-  //   }
-
-  //   return (
-  //     otherKeyObject.type === this.type &&
-  //     this[kHandle].equals(otherKeyObject[kHandle])
-  //   );
-  // }
-}
+import {
+  CryptoKey,
+  KeyObject,
+  SecretKeyObject,
+  PublicKeyObject,
+  PrivateKeyObject,
+} from './classes';
+// import { generateKeyPair } from './generateKeyPair';
+// import { sign, verify } from './signVerify';
+import {
+  isCryptoKey,
+  parseKeyEncoding,
+  parsePrivateKeyEncoding,
+  parsePublicKeyEncoding,
+} from './utils';
+
+export {
+  // Node Public API
+  // createSecretKey,
+  // createPublicKey,
+  // createPrivateKey,
+  CryptoKey,
+  // generateKeyPair,
+  KeyObject,
+  // InternalCryptoKey,
+  // sign,
+  // verify,
+
+  // Node Internal API
+  parsePublicKeyEncoding,
+  parsePrivateKeyEncoding,
+  parseKeyEncoding,
+  // preparePrivateKey,
+  // preparePublicOrPrivateKey,
+  // prepareSecretKey,
+  SecretKeyObject,
+  PublicKeyObject,
+  PrivateKeyObject,
+  // isKeyObject,
+  isCryptoKey,
+  // importGenericSecretKey,
+};