react-native-quick-crypto 1.0.10 → 1.0.11

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/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,12 @@ 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';
 
@@ -26,6 +29,7 @@ import * as subtle from './subtle';
  * See `docs/implementation-coverage.md` for status.
  */
 const QuickCrypto = {
+  ...argon2Module,
   ...keys,
   ...blake3,
   ...cipher,
@@ -34,12 +38,14 @@ const QuickCrypto = {
   ...hmac,
   ...hkdf,
   ...pbkdf2,
+  ...prime,
   ...scrypt,
   ...random,
   ...ecdh,
   ...dh,
   ...utils,
   ...subtle,
+  Certificate,
   getCurves,
   constants,
   Buffer,
@@ -72,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';
@@ -80,6 +88,7 @@ export * from './hash';
 export * from './hmac';
 export * from './hkdf';
 export * from './pbkdf2';
+export * from './prime';
 export * from './scrypt';
 export * from './random';
 export * from './ecdh';

package/src/keys/classes.ts

@@ -126,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,

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/dsaKeyPair.nitro.ts

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface DsaKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(): Promise<void>;
+  generateKeyPairSync(): void;
+
+  setModulusLength(modulusLength: number): void;
+  setDivisorLength(divisorLength: number): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+}

package/src/specs/ecdh.nitro.ts

@@ -8,4 +8,5 @@ export interface ECDH extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   setPrivateKey(privateKey: ArrayBuffer): void;
   getPublicKey(): ArrayBuffer;
   setPublicKey(publicKey: ArrayBuffer): void;
+  convertKey(key: ArrayBuffer, curve: string, format: number): ArrayBuffer;
 }

package/src/specs/prime.nitro.ts

@@ -0,0 +1,18 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+
+export interface Prime extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generatePrime(
+    size: number,
+    safe: boolean,
+    add?: ArrayBuffer,
+    rem?: ArrayBuffer,
+  ): Promise<ArrayBuffer>;
+  generatePrimeSync(
+    size: number,
+    safe: boolean,
+    add?: ArrayBuffer,
+    rem?: ArrayBuffer,
+  ): ArrayBuffer;
+  checkPrime(candidate: ArrayBuffer, checks: number): Promise<boolean>;
+  checkPrimeSync(candidate: ArrayBuffer, checks: number): boolean;
+}