react-native-quick-crypto 1.0.10 → 1.0.11

package/nitrogen/generated/shared/c++/HybridDsaKeyPairSpec.hpp

@@ -0,0 +1,68 @@
+///
+/// HybridDsaKeyPairSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `DsaKeyPair`
+   * Inherit this class to create instances of `HybridDsaKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDsaKeyPair: public HybridDsaKeyPairSpec {
+   * public:
+   *   HybridDsaKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDsaKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDsaKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDsaKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair() = 0;
+      virtual void generateKeyPairSync() = 0;
+      virtual void setModulusLength(double modulusLength) = 0;
+      virtual void setDivisorLength(double divisorLength) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPrivateKey() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "DsaKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridECDHSpec.cpp

@@ -21,6 +21,7 @@ namespace margelo::nitro::crypto {
       prototype.registerHybridMethod("setPrivateKey", &HybridECDHSpec::setPrivateKey);
       prototype.registerHybridMethod("getPublicKey", &HybridECDHSpec::getPublicKey);
       prototype.registerHybridMethod("setPublicKey", &HybridECDHSpec::setPublicKey);
+      prototype.registerHybridMethod("convertKey", &HybridECDHSpec::convertKey);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridECDHSpec.hpp

@@ -56,6 +56,7 @@ namespace margelo::nitro::crypto {
       virtual void setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) = 0;
       virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
       virtual void setPublicKey(const std::shared_ptr<ArrayBuffer>& publicKey) = 0;
+      virtual std::shared_ptr<ArrayBuffer> convertKey(const std::shared_ptr<ArrayBuffer>& key, const std::string& curve, double format) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridPrimeSpec.cpp

@@ -0,0 +1,24 @@
+///
+/// HybridPrimeSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPrimeSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridPrimeSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("generatePrime", &HybridPrimeSpec::generatePrime);
+      prototype.registerHybridMethod("generatePrimeSync", &HybridPrimeSpec::generatePrimeSync);
+      prototype.registerHybridMethod("checkPrime", &HybridPrimeSpec::checkPrime);
+      prototype.registerHybridMethod("checkPrimeSync", &HybridPrimeSpec::checkPrimeSync);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridPrimeSpec.hpp

@@ -0,0 +1,67 @@
+///
+/// HybridPrimeSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Prime`
+   * Inherit this class to create instances of `HybridPrimeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPrime: public HybridPrimeSpec {
+   * public:
+   *   HybridPrime(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPrimeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPrimeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPrimeSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> generatePrime(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add, const std::optional<std::shared_ptr<ArrayBuffer>>& rem) = 0;
+      virtual std::shared_ptr<ArrayBuffer> generatePrimeSync(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add, const std::optional<std::shared_ptr<ArrayBuffer>>& rem) = 0;
+      virtual std::shared_ptr<Promise<bool>> checkPrime(const std::shared_ptr<ArrayBuffer>& candidate, double checks) = 0;
+      virtual bool checkPrimeSync(const std::shared_ptr<ArrayBuffer>& candidate, double checks) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Prime";
+  };
+
+} // namespace margelo::nitro::crypto

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/argon2.ts

@@ -0,0 +1,83 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { NitroModules } from 'react-native-nitro-modules';
+import type { Argon2 as NativeArgon2 } from './specs/argon2.nitro';
+import { binaryLikeToArrayBuffer } from './utils';
+import type { BinaryLike } from './utils';
+
+let native: NativeArgon2;
+function getNative(): NativeArgon2 {
+  if (native == null) {
+    native = NitroModules.createHybridObject<NativeArgon2>('Argon2');
+  }
+  return native;
+}
+
+export interface Argon2Params {
+  message: BinaryLike;
+  nonce: BinaryLike;
+  parallelism: number;
+  tagLength: number;
+  memory: number;
+  passes: number;
+  secret?: BinaryLike;
+  associatedData?: BinaryLike;
+  version?: number;
+}
+
+const ARGON2_VERSION = 0x13; // v1.3
+
+function validateAlgorithm(algorithm: string): void {
+  if (
+    algorithm !== 'argon2d' &&
+    algorithm !== 'argon2i' &&
+    algorithm !== 'argon2id'
+  ) {
+    throw new TypeError(`Unknown argon2 algorithm: ${algorithm}`);
+  }
+}
+
+function toAB(value: BinaryLike): ArrayBuffer {
+  return binaryLikeToArrayBuffer(value);
+}
+
+export function argon2Sync(algorithm: string, params: Argon2Params): Buffer {
+  validateAlgorithm(algorithm);
+  const version = params.version ?? ARGON2_VERSION;
+  const result = getNative().hashSync(
+    algorithm,
+    toAB(params.message),
+    toAB(params.nonce),
+    params.parallelism,
+    params.tagLength,
+    params.memory,
+    params.passes,
+    version,
+    params.secret ? toAB(params.secret) : undefined,
+    params.associatedData ? toAB(params.associatedData) : undefined,
+  );
+  return Buffer.from(result);
+}
+
+export function argon2(
+  algorithm: string,
+  params: Argon2Params,
+  callback: (err: Error | null, result: Buffer) => void,
+): void {
+  validateAlgorithm(algorithm);
+  const version = params.version ?? ARGON2_VERSION;
+  getNative()
+    .hash(
+      algorithm,
+      toAB(params.message),
+      toAB(params.nonce),
+      params.parallelism,
+      params.tagLength,
+      params.memory,
+      params.passes,
+      version,
+      params.secret ? toAB(params.secret) : undefined,
+      params.associatedData ? toAB(params.associatedData) : undefined,
+    )
+    .then(ab => callback(null, Buffer.from(ab)))
+    .catch((err: Error) => callback(err, Buffer.alloc(0)));
+}

package/src/certificate.ts

@@ -0,0 +1,41 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { Certificate as NativeCertificate } from './specs/certificate.nitro';
+import type { BinaryLike } from './utils';
+import { binaryLikeToArrayBuffer } from './utils';
+
+let native: NativeCertificate;
+function getNative(): NativeCertificate {
+  if (native == null) {
+    native = NitroModules.createHybridObject<NativeCertificate>('Certificate');
+  }
+  return native;
+}
+
+function toArrayBuffer(
+  spkac: BinaryLike,
+  encoding?: BufferEncoding,
+): ArrayBuffer {
+  if (typeof spkac === 'string') {
+    return binaryLikeToArrayBuffer(spkac, encoding || 'utf8');
+  }
+  return binaryLikeToArrayBuffer(spkac);
+}
+
+export class Certificate {
+  static exportChallenge(spkac: BinaryLike, encoding?: BufferEncoding): Buffer {
+    return Buffer.from(
+      getNative().exportChallenge(toArrayBuffer(spkac, encoding)),
+    );
+  }
+
+  static exportPublicKey(spkac: BinaryLike, encoding?: BufferEncoding): Buffer {
+    return Buffer.from(
+      getNative().exportPublicKey(toArrayBuffer(spkac, encoding)),
+    );
+  }
+
+  static verifySpkac(spkac: BinaryLike, encoding?: BufferEncoding): boolean {
+    return getNative().verifySpkac(toArrayBuffer(spkac, encoding));
+  }
+}

package/src/cipher.ts

@@ -28,18 +28,42 @@ export type CipherOptions =
   | CipherGCMOptions
   | TransformOptions;
 
+export interface CipherInfoResult {
+  name: string;
+  nid: number;
+  mode: string;
+  keyLength: number;
+  blockSize?: number;
+  ivLength?: number;
+}
+
 class CipherUtils {
   private static native =
     NitroModules.createHybridObject<NativeCipher>('Cipher');
   public static getSupportedCiphers(): string[] {
     return this.native.getSupportedCiphers();
   }
+  public static getCipherInfo(
+    name: string,
+    keyLength?: number,
+    ivLength?: number,
+  ): CipherInfoResult | undefined {
+    return this.native.getCipherInfo(name, keyLength, ivLength);
+  }
 }
 
 export function getCiphers(): string[] {
   return CipherUtils.getSupportedCiphers();
 }
 
+export function getCipherInfo(
+  name: string,
+  options?: { keyLength?: number; ivLength?: number },
+): CipherInfoResult | undefined {
+  if (typeof name !== 'string' || name.length === 0) return undefined;
+  return CipherUtils.getCipherInfo(name, options?.keyLength, options?.ivLength);
+}
+
 interface CipherArgs {
   isCipher: boolean;
   cipherType: string;

package/src/dhKeyPair.ts

@@ -0,0 +1,156 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { KeyObject, PublicKeyObject, PrivateKeyObject } from './keys';
+import type { DhKeyPair } from './specs/dhKeyPair.nitro';
+import type { GenerateKeyPairOptions, KeyPairGenConfig } from './utils/types';
+import { KFormatType, KeyEncoding } from './utils';
+import { DH_GROUPS } from './dh-groups';
+
+export class DhKeyPairGen {
+  native: DhKeyPair;
+
+  constructor(options: GenerateKeyPairOptions) {
+    this.native = NitroModules.createHybridObject<DhKeyPair>('DhKeyPair');
+
+    const { groupName, prime, primeLength, generator } = options;
+
+    if (groupName) {
+      // Resolve named group to prime + generator
+      const group = DH_GROUPS[groupName];
+      if (!group) {
+        throw new Error(`Unknown DH group: ${groupName}`);
+      }
+      const primeBuf = Buffer.from(group.prime, 'hex');
+      this.native.setPrime(
+        primeBuf.buffer.slice(
+          primeBuf.byteOffset,
+          primeBuf.byteOffset + primeBuf.byteLength,
+        ) as ArrayBuffer,
+      );
+      const gen = parseInt(group.generator, 16);
+      this.native.setGenerator(gen);
+    } else if (prime) {
+      // Custom prime as Buffer
+      const primeBuf = Buffer.from(prime);
+      this.native.setPrime(
+        primeBuf.buffer.slice(
+          primeBuf.byteOffset,
+          primeBuf.byteOffset + primeBuf.byteLength,
+        ) as ArrayBuffer,
+      );
+      this.native.setGenerator(generator ?? 2);
+    } else if (primeLength) {
+      this.native.setPrimeLength(primeLength);
+      this.native.setGenerator(generator ?? 2);
+    } else {
+      throw new Error(
+        'DH key generation requires one of: groupName, prime, or primeLength',
+      );
+    }
+  }
+
+  async generateKeyPair(): Promise<void> {
+    await this.native.generateKeyPair();
+  }
+
+  generateKeyPairSync(): void {
+    this.native.generateKeyPairSync();
+  }
+}
+
+function dh_prepareKeyGenParams(
+  options: GenerateKeyPairOptions | undefined,
+): DhKeyPairGen {
+  if (!options) {
+    throw new Error('Options are required for DH key generation');
+  }
+
+  return new DhKeyPairGen(options);
+}
+
+function dh_formatKeyPairOutput(
+  dh: DhKeyPairGen,
+  encoding: KeyPairGenConfig,
+): {
+  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+} {
+  const { publicFormat, privateFormat, cipher, passphrase } = encoding;
+
+  const publicKeyData = dh.native.getPublicKey();
+  const privateKeyData = dh.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 dh_generateKeyPairNode(
+  options: GenerateKeyPairOptions | undefined,
+  encoding: KeyPairGenConfig,
+): Promise<{
+  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+}> {
+  const dh = dh_prepareKeyGenParams(options);
+  await dh.generateKeyPair();
+  return dh_formatKeyPairOutput(dh, encoding);
+}
+
+export function dh_generateKeyPairNodeSync(
+  options: GenerateKeyPairOptions | undefined,
+  encoding: KeyPairGenConfig,
+): {
+  publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+  privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+} {
+  const dh = dh_prepareKeyGenParams(options);
+  dh.generateKeyPairSync();
+  return dh_formatKeyPairOutput(dh, encoding);
+}

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