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

package/package.json

@@ -1,33 +1,15 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "0.7.11",
+  "version": "1.0.0-beta.10",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
-  "packageManager": "bun@1.1.26",
+  "type": "module",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
-  "types": "lib/typescript/src/index.d.ts",
-  "react-native": "lib/module/index",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index",
   "source": "src/index",
-  "files": [
-    "src",
-    "lib",
-    "android/src",
-    "android/build.gradle",
-    "android/gradle.properties",
-    "android/CMakeLists.txt",
-    "ios",
-    "cpp",
-    "react-native-quick-crypto.podspec",
-    "!lib/typescript/example",
-    "!android/build",
-    "!ios/build",
-    "!**/__tests__",
-    "!**/__fixtures__",
-    "!**/__mocks__"
-  ],
   "scripts": {
     "clean": "del-cli android/build lib",
-    "deepclean": "del-cli node_modules",
     "tsc": "tsc --noEmit",
     "typescript": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
@@ -36,8 +18,28 @@
     "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",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios",
+    "cpp",
+    "deps",
+    "nitrogen",
+    "react-native.config.js",
+    "app.plugin.js",
+    "*.podspec",
+    "README.md",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
   "keywords": [
     "react-native",
     "ios",
@@ -66,35 +68,37 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@craftzdog/react-native-buffer": "^6.0.5",
-    "events": "^3.3.0",
-    "readable-stream": "^4.5.2",
-    "string_decoder": "^1.3.0",
-    "util": "^0.12.5"
+    "@craftzdog/react-native-buffer": "6.0.5",
+    "events": "3.3.0",
+    "react-native-quick-base64": "2.1.2",
+    "readable-stream": "4.5.2",
+    "string_decoder": "1.3.0",
+    "util": "0.12.5"
   },
   "devDependencies": {
     "@eslint/compat": "^1.1.1",
-    "@eslint/js": "9.17.0",
-    "@react-native/babel-preset": "0.76.5",
-    "@react-native/eslint-config": "0.76.5",
-    "@react-native/eslint-plugin": "0.76.5",
-    "@release-it/conventional-changelog": "^9.0.3",
-    "@types/jest": "^29.5.11",
-    "@types/node": "^22.0.0",
-    "@types/react": "^18.0.33",
-    "@types/readable-stream": "^4.0.11",
-    "del-cli": "^6.0.0",
-    "eslint": "9.15.0",
-    "eslint-plugin-react-native": "^4.1.0",
-    "jest": "^29.7.0",
+    "@eslint/js": "9.18.0",
+    "@release-it/bumper": "7.0.1",
+    "@types/jest": "29.5.11",
+    "@types/node": "22.0.0",
+    "@types/react": "18.3.3",
+    "@types/readable-stream": "4.0.18",
+    "del-cli": "6.0.0",
+    "eslint": "9.9.0",
+    "eslint-plugin-react-native": "5.0.0",
+    "jest": "29.7.0",
+    "nitro-codegen": "0.21.0",
     "prettier": "3.3.3",
-    "react": "18.2.0",
-    "react-native": "0.72.7",
     "react-native-builder-bob": "0.35.2",
-    "release-it": "17.11.0",
-    "sscrypto": "^1.1.1",
-    "typescript": "5.7.2",
-    "typescript-eslint": "8.19.0"
+    "react-native-nitro-modules": "0.21.0",
+    "release-it": "18.1.1",
+    "typescript": "5.1.6",
+    "typescript-eslint": "^8.1.0"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "*"
   },
   "release-it": {
     "npm": {
@@ -111,7 +115,7 @@
       "@release-it/bumper": {
         "out": [
           {
-            "file": "../../packages/example/package.json",
+            "file": "../../example/package.json",
             "path": [
               "version",
               "dependencies.react-native-quick-crypto"
@@ -130,13 +134,15 @@
       [
         "typescript",
         {
-          "project": "tsconfig.json"
+          "project": "tsconfig.json",
+          "tsc": "../../node_modules/.bin/tsc"
         }
       ]
     ]
   },
-  "workspaces": [
-    ".",
-    "example"
+  "trustedDependencies": [
+    "react-native-quick-crypto",
+    "nitro-codegen",
+    "react-native-nitro-modules"
   ]
 }

package/src/ed.ts

@@ -0,0 +1,79 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { binaryLikeToArrayBuffer as toAB } from './utils';
+import type { EdKeyPair } from './specs/edKeyPair.nitro';
+import type { BinaryLike, 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();
+  }
+
+  getPrivateKey(): ArrayBuffer {
+    return this.native.getPrivateKey();
+  }
+
+  async sign(message: BinaryLike, key?: BinaryLike): Promise<ArrayBuffer> {
+    return key
+      ? this.native.sign(toAB(message), toAB(key))
+      : this.native.sign(toAB(message));
+  }
+
+  signSync(message: BinaryLike, key?: BinaryLike): ArrayBuffer {
+    return key
+      ? this.native.signSync(toAB(message), toAB(key))
+      : this.native.signSync(toAB(message));
+  }
+
+  async verify(
+    signature: BinaryLike,
+    message: BinaryLike,
+    key?: BinaryLike,
+  ): Promise<boolean> {
+    return key
+      ? this.native.verify(toAB(signature), toAB(message), toAB(key))
+      : this.native.verify(toAB(signature), toAB(message));
+  }
+
+  verifySync(
+    signature: BinaryLike,
+    message: BinaryLike,
+    key?: BinaryLike,
+  ): boolean {
+    return key
+      ? this.native.verifySync(toAB(signature), toAB(message), toAB(key))
+      : this.native.verifySync(toAB(signature), toAB(message));
+  }
+}

package/src/index.ts

@@ -1,62 +1,50 @@
+// polyfill imports
 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';
-import {
-  createCipher,
-  createCipheriv,
-  createDecipher,
-  createDecipheriv,
-  publicEncrypt,
-  publicDecrypt,
-  privateDecrypt,
-  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';
+
+// utils import
+import * as utils from './utils';
 
 /**
- * Loosely matches Node.js {crypto} with some unimplemented functionality
+ * Loosely matches Node.js {crypto} with some unimplemented functionality.
+ * See `docs/implementation-coverage.md` for status.
  */
 const QuickCrypto = {
-  createHmac,
-  Hmac: createHmac,
-  Hash: createHash,
-  createHash,
-  createCipher,
-  createCipheriv,
-  createDecipher,
-  createDecipheriv,
-  createPublicKey,
-  createPrivateKey,
-  createSecretKey,
-  publicEncrypt,
-  publicDecrypt,
-  privateDecrypt,
-  generateKey,
-  generateKeyPair,
-  generateKeyPairSync,
-  generateKeySync,
-  createSign,
-  createVerify,
-  subtle,
-  constants,
+  // createHmac,
+  // Hmac: createHmac,
+  // Hash: createHash,
+  // createHash,
+  // createCipher,
+  // createCipheriv,
+  // createDecipher,
+  // createDecipheriv,
+  // publicEncrypt,
+  // publicDecrypt,
+  // privateDecrypt,
+  // generateKey,
+  // generateKeySync,
+  // createSign,
+  // createVerify,
+  // subtle,
+  // constants,
+  ...keys,
+  ...ed,
   ...pbkdf2,
   ...random,
-  getCiphers,
-  getHashes,
-  webcrypto,
+  // getCiphers,
+  // getHashes,
+  // webcrypto,
+  ...utils,
 };
 
 /**
- * Optional. Patch global.crypto with quickcrypto and global.Buffer with react-native-buffer.
+ * Optional. Patch global.crypto with react-native-quick-crypto and
+ * global.Buffer with react-native-buffer.
  */
 export const install = () => {
   // @ts-expect-error copyBytesFrom and poolSizets are missing from react-native-buffer
@@ -66,7 +54,15 @@ export const install = () => {
   global.crypto = QuickCrypto;
 };
 
+// random, cipher, hash use nextTick
+global.process.nextTick = setImmediate;
+
+// exports
 export default QuickCrypto;
+export * from './ed';
+export * from './pbkdf2';
+export * from './random';
+export * from './utils';
 
 // Additional exports for CommonJS compatibility
 module.exports = QuickCrypto;

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);
+  }
+}