react-native-quick-crypto 1.0.9 → 1.0.11

package/src/dsa.ts

@@ -0,0 +1,129 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { KeyObject, PublicKeyObject, PrivateKeyObject } from './keys';
+import type { DsaKeyPair } from './specs/dsaKeyPair.nitro';
+import type { GenerateKeyPairOptions, KeyPairGenConfig } from './utils/types';
+import { KFormatType, KeyEncoding } from './utils';
+
+export class Dsa {
+  native: DsaKeyPair;
+
+  constructor(modulusLength: number, divisorLength?: number) {
+    this.native = NitroModules.createHybridObject<DsaKeyPair>('DsaKeyPair');
+    this.native.setModulusLength(modulusLength);
+    if (divisorLength !== undefined && divisorLength >= 0) {
+      this.native.setDivisorLength(divisorLength);
+    }
+  }
+
+  async generateKeyPair(): Promise<void> {
+    await this.native.generateKeyPair();
+  }
+
+  generateKeyPairSync(): void {
+    this.native.generateKeyPairSync();
+  }
+}
+
+function dsa_prepareKeyGenParams(
+  options: GenerateKeyPairOptions | undefined,
+): Dsa {
+  if (!options) {
+    throw new Error('Options are required for DSA key generation');
+  }
+
+  const { modulusLength, divisorLength } = options;
+
+  if (!modulusLength || modulusLength <= 0) {
+    throw new Error('Invalid or missing modulusLength for DSA key generation');
+  }
+
+  return new Dsa(modulusLength, divisorLength);
+}
+
+function dsa_formatKeyPairOutput(
+  dsa: Dsa,
+  encoding: KeyPairGenConfig,
+): {
+  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+} {
+  const { publicFormat, privateFormat, cipher, passphrase } = encoding;
+
+  const publicKeyData = dsa.native.getPublicKey();
+  const privateKeyData = dsa.native.getPrivateKey();
+
+  const pub = KeyObject.createKeyObject(
+    'public',
+    publicKeyData,
+    KFormatType.DER,
+    KeyEncoding.SPKI,
+  ) as PublicKeyObject;
+
+  const priv = KeyObject.createKeyObject(
+    'private',
+    privateKeyData,
+    KFormatType.DER,
+    KeyEncoding.PKCS8,
+  ) as PrivateKeyObject;
+
+  let publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+  let privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+
+  if (publicFormat === -1) {
+    publicKey = pub;
+  } else {
+    const format =
+      publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
+    const exported = pub.handle.exportKey(format, KeyEncoding.SPKI);
+    if (format === KFormatType.PEM) {
+      publicKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      publicKey = exported;
+    }
+  }
+
+  if (privateFormat === -1) {
+    privateKey = priv;
+  } else {
+    const format =
+      privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
+    const exported = priv.handle.exportKey(
+      format,
+      KeyEncoding.PKCS8,
+      cipher,
+      passphrase,
+    );
+    if (format === KFormatType.PEM) {
+      privateKey = Buffer.from(new Uint8Array(exported)).toString('utf-8');
+    } else {
+      privateKey = exported;
+    }
+  }
+
+  return { publicKey, privateKey };
+}
+
+export async function dsa_generateKeyPairNode(
+  options: GenerateKeyPairOptions | undefined,
+  encoding: KeyPairGenConfig,
+): Promise<{
+  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+}> {
+  const dsa = dsa_prepareKeyGenParams(options);
+  await dsa.generateKeyPair();
+  return dsa_formatKeyPairOutput(dsa, encoding);
+}
+
+export function dsa_generateKeyPairNodeSync(
+  options: GenerateKeyPairOptions | undefined,
+  encoding: KeyPairGenConfig,
+): {
+  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+} {
+  const dsa = dsa_prepareKeyGenParams(options);
+  dsa.generateKeyPairSync();
+  return dsa_formatKeyPairOutput(dsa, encoding);
+}

package/src/ec.ts

@@ -34,6 +34,23 @@ import {
 import { Buffer } from '@craftzdog/react-native-buffer';
 import { ECDH } from './ecdh';
 
+class EcUtils {
+  private static _native: EcKeyPair | undefined;
+  private static get native(): EcKeyPair {
+    if (!this._native) {
+      this._native = NitroModules.createHybridObject<EcKeyPair>('EcKeyPair');
+    }
+    return this._native;
+  }
+  public static getSupportedCurves(): string[] {
+    return this.native.getSupportedCurves();
+  }
+}
+
+export function getCurves(): string[] {
+  return EcUtils.getSupportedCurves();
+}
+
 export class Ec {
   native: EcKeyPair;
 
@@ -488,8 +505,7 @@ export function ecDeriveBits(
   baseKey: CryptoKey,
   length: number | null,
 ): ArrayBuffer {
-  const publicParams = algorithm as SubtleAlgorithm & { public?: CryptoKey };
-  const publicKey = publicParams.public;
+  const publicKey = algorithm.public;
 
   if (!publicKey) {
     throw new Error('Public key is required for ECDH derivation');
@@ -508,31 +524,19 @@ export function ecDeriveBits(
     throw new Error('Curve name is missing');
   }
 
-  // Create new ECDH instance (Node.js style wrapper)
-  const ecdh = new ECDH(namedCurve);
+  const opensslCurve =
+    kNamedCurveAliases[namedCurve as keyof typeof kNamedCurveAliases];
+  const ecdh = new ECDH(opensslCurve);
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const jwkPrivate = baseKey.keyObject.export({ format: 'jwk' }) as any;
+  const jwkPrivate = baseKey.keyObject.handle.exportJwk({}, false);
   if (!jwkPrivate.d) throw new Error('Invalid private key');
   const privateBytes = Buffer.from(jwkPrivate.d, 'base64');
-
   ecdh.setPrivateKey(privateBytes);
 
-  // Public key
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const jwkPublic = publicKey.keyObject.export({ format: 'jwk' }) as any;
-
-  // HybridECDH `computeSecret` takes public key.
-  // My implementation `HybridECDH.cpp` `computeSecret` expects what?
-  // `derive_secret` -> `EVP_PKEY_derive_set_peer`
-  // `computeSecret` calls `EC_POINT_oct2point`. So it expects an uncompressed/compressed point (04... or 02/03...).
-  // JWK gives `x` and `y`. We can construct the uncompressed point 04 + x + y.
-
+  const jwkPublic = publicKey.keyObject.handle.exportJwk({}, false);
   if (!jwkPublic.x || !jwkPublic.y) throw new Error('Invalid public key');
   const x = Buffer.from(jwkPublic.x, 'base64');
   const y = Buffer.from(jwkPublic.y, 'base64');
-
-  // Uncompressed point: 0x04 || x || y
   const publicBytes = Buffer.concat([Buffer.from([0x04]), x, y]);
 
   const secret = ecdh.computeSecret(publicBytes);

package/src/ecdh.ts

@@ -2,7 +2,20 @@ import { NitroModules } from 'react-native-nitro-modules';
 import type { ECDH as ECDHInterface } from './specs/ecdh.nitro';
 import { Buffer } from '@craftzdog/react-native-buffer';
 
+const POINT_CONVERSION_COMPRESSED = 2;
+const POINT_CONVERSION_UNCOMPRESSED = 4;
+const POINT_CONVERSION_HYBRID = 6;
+
 export class ECDH {
+  private static _convertKeyHybrid: ECDHInterface | undefined;
+  private static get convertKeyHybrid(): ECDHInterface {
+    if (!this._convertKeyHybrid) {
+      this._convertKeyHybrid =
+        NitroModules.createHybridObject<ECDHInterface>('ECDH');
+    }
+    return this._convertKeyHybrid;
+  }
+
   private _hybrid: ECDHInterface;
 
   constructor(curveName: string) {
@@ -69,6 +82,52 @@ export class ECDH {
     }
     this._hybrid.setPublicKey(keyBuf.buffer as ArrayBuffer);
   }
+
+  static convertKey(
+    key: Buffer | string,
+    curve: string,
+    inputEncoding?: BufferEncoding,
+    outputEncoding?: BufferEncoding,
+    format?: 'uncompressed' | 'compressed' | 'hybrid',
+  ): Buffer | string {
+    let keyBuf: Buffer;
+    if (Buffer.isBuffer(key)) {
+      keyBuf = key;
+    } else {
+      keyBuf = Buffer.from(key, inputEncoding);
+    }
+
+    let formatNum: number;
+    switch (format) {
+      case 'compressed':
+        formatNum = POINT_CONVERSION_COMPRESSED;
+        break;
+      case 'hybrid':
+        formatNum = POINT_CONVERSION_HYBRID;
+        break;
+      case 'uncompressed':
+      case undefined:
+        formatNum = POINT_CONVERSION_UNCOMPRESSED;
+        break;
+      default:
+        throw new TypeError(
+          `Invalid point conversion format: ${format as string}`,
+        );
+    }
+
+    const result = Buffer.from(
+      ECDH.convertKeyHybrid.convertKey(
+        keyBuf.buffer as ArrayBuffer,
+        curve,
+        formatNum,
+      ),
+    );
+
+    if (outputEncoding) {
+      return result.toString(outputEncoding);
+    }
+    return result;
+  }
 }
 
 export function createECDH(curveName: string): ECDH {

package/src/ed.ts

@@ -427,8 +427,7 @@ export function xDeriveBits(
   baseKey: CryptoKey,
   length: number | null,
 ): ArrayBuffer {
-  const publicParams = algorithm as SubtleAlgorithm & { public?: CryptoKey };
-  const publicKey = publicParams.public;
+  const publicKey = algorithm.public;
 
   if (!publicKey) {
     throw new Error('Public key is required for X25519/X448 derivation');

package/src/hash.ts

@@ -272,8 +272,19 @@ const internalDigest = (
   return arrayBuffer;
 };
 
+export function hash(
+  algorithm: string,
+  data: BinaryLike,
+  outputEncoding?: Encoding,
+): string | Buffer {
+  const h = createHash(algorithm);
+  h.update(data);
+  return outputEncoding ? h.digest(outputEncoding) : h.digest();
+}
+
 export const hashExports = {
   createHash,
   getHashes,
+  hash,
   asyncDigest,
 };

package/src/index.ts

@@ -2,6 +2,7 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 
 // API imports
+import * as argon2Module from './argon2';
 import * as keys from './keys';
 import * as blake3 from './blake3';
 import * as cipher from './cipher';
@@ -10,10 +11,13 @@ import { hashExports as hash } from './hash';
 import { hmacExports as hmac } from './hmac';
 import * as hkdf from './hkdf';
 import * as pbkdf2 from './pbkdf2';
+import * as prime from './prime';
 import * as scrypt from './scrypt';
 import * as random from './random';
 import * as ecdh from './ecdh';
 import * as dh from './diffie-hellman';
+import { Certificate } from './certificate';
+import { getCurves } from './ec';
 import { constants } from './constants';
 
 // utils import
@@ -25,6 +29,7 @@ import * as subtle from './subtle';
  * See `docs/implementation-coverage.md` for status.
  */
 const QuickCrypto = {
+  ...argon2Module,
   ...keys,
   ...blake3,
   ...cipher,
@@ -33,12 +38,15 @@ const QuickCrypto = {
   ...hmac,
   ...hkdf,
   ...pbkdf2,
+  ...prime,
   ...scrypt,
   ...random,
   ...ecdh,
   ...dh,
   ...utils,
   ...subtle,
+  Certificate,
+  getCurves,
   constants,
   Buffer,
 };
@@ -70,7 +78,9 @@ if (global.process.nextTick == null) {
 
 // exports
 export default QuickCrypto;
+export * from './argon2';
 export * from './blake3';
+export { Certificate } from './certificate';
 export * from './cipher';
 export * from './ed';
 export * from './keys';
@@ -78,9 +88,11 @@ export * from './hash';
 export * from './hmac';
 export * from './hkdf';
 export * from './pbkdf2';
+export * from './prime';
 export * from './scrypt';
 export * from './random';
 export * from './ecdh';
+export { getCurves } from './ec';
 export * from './diffie-hellman';
 export * from './utils';
 export * from './subtle';

package/src/keys/classes.ts

@@ -89,6 +89,13 @@ export class KeyObject {
     throw new Error('export() must be implemented by subclasses');
   }
 
+  equals(otherKeyObject: KeyObject): boolean {
+    if (!(otherKeyObject instanceof KeyObject)) {
+      throw new TypeError('otherKeyObject must be a KeyObject');
+    }
+    return this.handle.keyEquals(otherKeyObject.handle);
+  }
+
   constructor(type: string, handle: KeyObjectHandle);
   constructor(type: string, key: ArrayBuffer);
   constructor(type: string, handleOrKey: KeyObjectHandle | ArrayBuffer) {
@@ -119,11 +126,22 @@ export class KeyObject {
     this.type = type as 'public' | 'secret' | 'private';
   }
 
-  // static from(key) {
-  //   if (!isCryptoKey(key))
-  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
-  //   return key[kKeyObject];
-  // }
+  static from(key: CryptoKey): KeyObject {
+    if (!(key instanceof CryptoKey)) {
+      throw new TypeError(
+        `The "key" argument must be an instance of CryptoKey. Received ${typeof key}`,
+      );
+    }
+    return key.keyObject;
+  }
+
+  toCryptoKey(
+    algorithm: SubtleAlgorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[],
+  ): CryptoKey {
+    return new CryptoKey(this, algorithm, keyUsages, extractable);
+  }
 
   static createKeyObject(
     type: string,
@@ -197,9 +215,9 @@ export class SecretKeyObject extends KeyObject {
     super('secret', handle);
   }
 
-  // get symmetricKeySize() {
-  //   return this.handle.getSymmetricKeySize();
-  // }
+  get symmetricKeySize(): number {
+    return this.handle.getSymmetricKeySize();
+  }
 
   export(options: { format: 'pem' } & EncodingOptions): never;
   export(options: { format: 'der' } & EncodingOptions): Buffer;

package/src/keys/generateKeyPair.ts

@@ -1,6 +1,11 @@
 import { ed_generateKeyPair } from '../ed';
 import { rsa_generateKeyPairNode, rsa_generateKeyPairNodeSync } from '../rsa';
 import { ec_generateKeyPairNode, ec_generateKeyPairNodeSync } from '../ec';
+import { dsa_generateKeyPairNode, dsa_generateKeyPairNodeSync } from '../dsa';
+import {
+  dh_generateKeyPairNode,
+  dh_generateKeyPairNodeSync,
+} from '../dhKeyPair';
 import {
   kEmptyObject,
   validateFunction,
@@ -139,6 +144,7 @@ function internalGenerateKeyPair(
     case 'rsa-pss':
     case 'dsa':
     case 'ec':
+    case 'dh':
       break;
     default: {
       const err = new Error(`
@@ -158,6 +164,10 @@ function internalGenerateKeyPair(
           result = await rsa_generateKeyPairNode(type, options, encoding);
         } else if (type === 'ec') {
           result = await ec_generateKeyPairNode(options, encoding);
+        } else if (type === 'dsa') {
+          result = await dsa_generateKeyPairNode(options, encoding);
+        } else if (type === 'dh') {
+          result = await dh_generateKeyPairNode(options, encoding);
         } else {
           throw new Error(`Unsupported key type: ${type}`);
         }
@@ -184,6 +194,10 @@ function internalGenerateKeyPair(
       result = rsa_generateKeyPairNodeSync(type, options, encoding);
     } else if (type === 'ec') {
       result = ec_generateKeyPairNodeSync(options, encoding);
+    } else if (type === 'dsa') {
+      result = dsa_generateKeyPairNodeSync(options, encoding);
+    } else if (type === 'dh') {
+      result = dh_generateKeyPairNodeSync(options, encoding);
     } else {
       throw new Error(`Unsupported key type: ${type}`);
     }

package/src/prime.ts

@@ -0,0 +1,134 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { Prime as NativePrime } from './specs/prime.nitro';
+import type { BinaryLike } from './utils';
+import { binaryLikeToArrayBuffer } from './utils';
+
+let native: NativePrime;
+function getNative(): NativePrime {
+  if (native == null) {
+    native = NitroModules.createHybridObject<NativePrime>('Prime');
+  }
+  return native;
+}
+
+export interface GeneratePrimeOptions {
+  safe?: boolean;
+  bigint?: boolean;
+  add?: ArrayBuffer | Buffer | Uint8Array;
+  rem?: ArrayBuffer | Buffer | Uint8Array;
+}
+
+export interface CheckPrimeOptions {
+  checks?: number;
+}
+
+function toOptionalArrayBuffer(
+  value?: ArrayBuffer | Buffer | Uint8Array,
+): ArrayBuffer | undefined {
+  if (value == null) return undefined;
+  if (value instanceof ArrayBuffer) return value;
+  return binaryLikeToArrayBuffer(value);
+}
+
+function bufferToBigInt(buf: Buffer): bigint {
+  let result = 0n;
+  for (let i = 0; i < buf.length; i++) {
+    result = (result << 8n) | BigInt(buf[i]!);
+  }
+  return result;
+}
+
+function bigIntToBuffer(value: bigint): ArrayBuffer {
+  if (value === 0n) return new Uint8Array([0]).buffer;
+  const hex = value.toString(16);
+  const paddedHex = hex.length % 2 ? '0' + hex : hex;
+  const bytes = new Uint8Array(paddedHex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(paddedHex.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes.buffer;
+}
+
+export function generatePrimeSync(
+  size: number,
+  options?: GeneratePrimeOptions,
+): Buffer | bigint {
+  const safe = options?.safe ?? false;
+  const add = toOptionalArrayBuffer(options?.add);
+  const rem = toOptionalArrayBuffer(options?.rem);
+  const result = Buffer.from(
+    getNative().generatePrimeSync(size, safe, add, rem),
+  );
+  if (options?.bigint) {
+    return bufferToBigInt(result);
+  }
+  return result;
+}
+
+type GeneratePrimeCallback = (
+  err: Error | null,
+  prime: Buffer | bigint,
+) => void;
+
+export function generatePrime(
+  size: number,
+  options: GeneratePrimeOptions | GeneratePrimeCallback,
+  callback?: GeneratePrimeCallback,
+): void {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  const safe = options?.safe ?? false;
+  const add = toOptionalArrayBuffer(options?.add);
+  const rem = toOptionalArrayBuffer(options?.rem);
+  const wantBigint = options?.bigint ?? false;
+
+  getNative()
+    .generatePrime(size, safe, add, rem)
+    .then(ab => {
+      const result = Buffer.from(ab);
+      if (wantBigint) {
+        callback?.(null, bufferToBigInt(result));
+      } else {
+        callback?.(null, result);
+      }
+    })
+    .catch((err: Error) => callback?.(err, Buffer.alloc(0)));
+}
+
+export function checkPrimeSync(
+  candidate: BinaryLike | bigint,
+  options?: CheckPrimeOptions,
+): boolean {
+  const checks = options?.checks ?? 0;
+  const buf =
+    typeof candidate === 'bigint'
+      ? bigIntToBuffer(candidate)
+      : binaryLikeToArrayBuffer(candidate);
+  return getNative().checkPrimeSync(buf, checks);
+}
+
+type CheckPrimeCallback = (err: Error | null, result: boolean) => void;
+
+export function checkPrime(
+  candidate: BinaryLike | bigint,
+  options: CheckPrimeOptions | CheckPrimeCallback,
+  callback?: CheckPrimeCallback,
+): void {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  const checks = options.checks ?? 0;
+  const buf =
+    typeof candidate === 'bigint'
+      ? bigIntToBuffer(candidate)
+      : binaryLikeToArrayBuffer(candidate);
+
+  getNative()
+    .checkPrime(buf, checks)
+    .then(result => callback?.(null, result))
+    .catch((err: Error) => callback?.(err, false));
+}

package/src/specs/argon2.nitro.ts

@@ -0,0 +1,29 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Argon2 extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  hash(
+    algorithm: string,
+    message: ArrayBuffer,
+    nonce: ArrayBuffer,
+    parallelism: number,
+    tagLength: number,
+    memory: number,
+    passes: number,
+    version: number,
+    secret?: ArrayBuffer,
+    associatedData?: ArrayBuffer,
+  ): Promise<ArrayBuffer>;
+
+  hashSync(
+    algorithm: string,
+    message: ArrayBuffer,
+    nonce: ArrayBuffer,
+    parallelism: number,
+    tagLength: number,
+    memory: number,
+    passes: number,
+    version: number,
+    secret?: ArrayBuffer,
+    associatedData?: ArrayBuffer,
+  ): ArrayBuffer;
+}

package/src/specs/certificate.nitro.ts

@@ -0,0 +1,8 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Certificate
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  verifySpkac(spkac: ArrayBuffer): boolean;
+  exportPublicKey(spkac: ArrayBuffer): ArrayBuffer;
+  exportChallenge(spkac: ArrayBuffer): ArrayBuffer;
+}

package/src/specs/cipher.nitro.ts

@@ -8,6 +8,15 @@ type CipherArgs = {
   authTagLen?: number;
 };
 
+interface CipherInfo {
+  name: string;
+  nid: number;
+  mode: string;
+  keyLength: number;
+  blockSize?: number;
+  ivLength?: number;
+}
+
 export interface Cipher extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   update(data: ArrayBuffer): ArrayBuffer;
   final(): ArrayBuffer;
@@ -17,6 +26,11 @@ export interface Cipher extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   setAuthTag(tag: ArrayBuffer): boolean;
   getAuthTag(): ArrayBuffer;
   getSupportedCiphers(): string[];
+  getCipherInfo(
+    name: string,
+    keyLength?: number,
+    ivLength?: number,
+  ): CipherInfo | undefined;
 }
 
 export interface CipherFactory

package/src/specs/dhKeyPair.nitro.ts

@@ -0,0 +1,14 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface DhKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(): Promise<void>;
+  generateKeyPairSync(): void;
+
+  setPrimeLength(primeLength: number): void;
+  setPrime(prime: ArrayBuffer): void;
+  setGenerator(generator: number): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+}

package/src/specs/diffie-hellman.nitro.ts

@@ -12,4 +12,5 @@ export interface DiffieHellman
   getPrivateKey(): ArrayBuffer;
   setPublicKey(publicKey: ArrayBuffer): void;
   setPrivateKey(privateKey: ArrayBuffer): void;
+  getVerifyError(): number;
 }