@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/package.json

@@ -1,6 +1,160 @@
 {
   "name": "@ohos-ports/react-native-quick-crypto",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.8-beta.0",
+  "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
+  "main": "lib/commonjs/index",
+  "module": "lib/module/index",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "scripts": {
+    "clean": "del-cli android/build lib",
+    "clean:deep": "bun run clean && del-cli node_modules",
+    "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}\"",
+    "specs": "nitrogen",
+    "circular": "dpdm --circular --no-tree --no-warning --exit-code circular:1 --transform src/index.ts",
+    "test": "jest"
+  },
+  "files": [
+    "src",
+    "lib",
+    "jest",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios",
+    "cpp",
+    "deps/blake3/c",
+    "deps/blake3/LICENSE_A2",
+    "deps/blake3/LICENSE_A2LLVM",
+    "deps/blake3/LICENSE_CC0",
+    "deps/fastpbkdf2",
+    "deps/ncrypto/include",
+    "deps/ncrypto/src/aead.cpp",
+    "deps/ncrypto/src/engine.cpp",
+    "deps/ncrypto/src/ncrypto.cpp",
+    "deps/ncrypto/LICENSE",
+    "deps/simdutf/include",
+    "deps/simdutf/src",
+    "deps/simdutf/LICENSE-MIT",
+    "deps/simdutf/LICENSE-APACHE",
+    "nitrogen",
+    "*.podspec",
+    "README.md",
+    "app.plugin.js",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/*.tsbuildinfo",
+    "!ios/libsodium-stable",
+    "!deps/simdutf/src/CMakeLists.txt",
+    "!deps/blake3/c/blake3_c_rust_bindings",
+    "!deps/blake3/c/dependencies",
+    "!deps/blake3/c/*_x86-64_*.S",
+    "!deps/blake3/c/*_x86-64_*.asm",
+    "!deps/blake3/c/blake3_avx2.c",
+    "!deps/blake3/c/blake3_avx512.c",
+    "!deps/blake3/c/blake3_sse2.c",
+    "!deps/blake3/c/blake3_sse41.c",
+    "!deps/blake3/c/blake3_tbb.cpp",
+    "!deps/blake3/c/main.c",
+    "!deps/blake3/c/example.c",
+    "!deps/blake3/c/example_tbb.c",
+    "!deps/blake3/c/test.py",
+    "!deps/blake3/c/Makefile.testing",
+    "!deps/blake3/c/CMakeLists.txt",
+    "!deps/blake3/c/CMakePresets.json",
+    "!deps/blake3/c/blake3-config.cmake.in",
+    "!deps/blake3/c/libblake3.pc.in",
+    "ohos/quick_crypto_napi.cpp",
+    "ohos/binding.gyp",
+    "ohos/build/Release/quick_crypto.node"
+  ],
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "jsi",
+    "nitro",
+    "crypto",
+    "cryptography",
+    "cryptocurrency",
+    "c++",
+    "fast",
+    "quick",
+    "web3"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/react-native-quick-crypto/1.1.8"
+  },
+  "authors": [
+    "Szymon Kapała <szymon20000@gmail.com>",
+    "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+    "Brad Anderson <brad@sankatygroup.com> (https://github.com/boorad)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "homepage": "https://github.com/ohos-ports/ohos-ports#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@craftzdog/react-native-buffer": "^6.1.2",
+    "events": "3.3.0",
+    "readable-stream": "4.7.0",
+    "safe-buffer": "^5.2.1",
+    "string_decoder": "^1.3.0",
+    "util": "0.12.5"
+  },
+  "devDependencies": {
+    "@babel/runtime": "7.28.4",
+    "@types/jest": "29.5.11",
+    "@types/node": "24.3.0",
+    "@types/react": "18.3.3",
+    "@types/readable-stream": "4.0.23",
+    "del-cli": "7.0.0",
+    "dpdm": "^4.0.1",
+    "expo": "^54.0.25",
+    "jest": "29.7.0",
+    "nitrogen": "0.33.2",
+    "react-native-builder-bob": "0.40.15",
+    "react-native-nitro-modules": "0.33.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "@ohos-ports/react-native": "^0.87.1-beta.3",
+    "react-native-nitro-modules": ">=0.31.2",
+    "react-native-quick-base64": ">=3.0.0",
+    "expo": ">=48.0.0"
+  },
+  "peerDependenciesMeta": {
+    "expo": {
+      "optional": true
+    }
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.json",
+          "tsc": "../../node_modules/.bin/tsc"
+        }
+      ]
+    ]
+  }
+}

package/src/argon2.ts

@@ -0,0 +1,161 @@
+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
+
+// RFC 9106 § 3.1: Argon2 input/parameter constraints.
+//   p (parallelism)   1   ≤ p ≤ 2^24 - 1
+//   T (tag length)    4   ≤ T ≤ 2^32 - 1
+//   m (memory in KiB) 8*p ≤ m ≤ 2^32 - 1
+//   t (passes)        1   ≤ t ≤ 2^32 - 1
+//   |salt| (nonce)    8   ≤ |s| ≤ 2^32 - 1
+//   v (version)       0x10 (v1.0) or 0x13 (v1.3)
+const ARGON2_MAX_U24 = 0xff_ffff;
+const ARGON2_MAX_U32 = 0xffff_ffff;
+
+function isUInt(value: unknown, max: number): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isFinite(value) &&
+    Number.isInteger(value) &&
+    value >= 0 &&
+    value <= max
+  );
+}
+
+function validateAlgorithm(algorithm: string): void {
+  if (
+    algorithm !== 'argon2d' &&
+    algorithm !== 'argon2i' &&
+    algorithm !== 'argon2id'
+  ) {
+    throw new TypeError(`Unknown argon2 algorithm: ${algorithm}`);
+  }
+}
+
+// Returns the resolved nonce ArrayBuffer so the caller can pass it
+// straight to native without re-resolving `params.nonce`.
+function validateArgon2Params(
+  params: Argon2Params,
+  version: number,
+): ArrayBuffer {
+  if (!isUInt(params.parallelism, ARGON2_MAX_U24) || params.parallelism < 1) {
+    throw new RangeError(
+      `Invalid Argon2 parallelism: ${params.parallelism} ` +
+        `(RFC 9106: 1 ≤ p ≤ 2^24 - 1)`,
+    );
+  }
+  if (!isUInt(params.tagLength, ARGON2_MAX_U32) || params.tagLength < 4) {
+    throw new RangeError(
+      `Invalid Argon2 tagLength: ${params.tagLength} ` +
+        `(RFC 9106: 4 ≤ T ≤ 2^32 - 1)`,
+    );
+  }
+  const minMemory = 8 * params.parallelism;
+  if (!isUInt(params.memory, ARGON2_MAX_U32) || params.memory < minMemory) {
+    throw new RangeError(
+      `Invalid Argon2 memory: ${params.memory} KiB ` +
+        `(RFC 9106: 8 * p (= ${minMemory}) ≤ m ≤ 2^32 - 1)`,
+    );
+  }
+  if (!isUInt(params.passes, ARGON2_MAX_U32) || params.passes < 1) {
+    throw new RangeError(
+      `Invalid Argon2 passes: ${params.passes} ` +
+        `(RFC 9106: 1 ≤ t ≤ 2^32 - 1)`,
+    );
+  }
+  if (version !== 0x10 && version !== 0x13) {
+    throw new RangeError(
+      `Invalid Argon2 version: 0x${version.toString(16)} ` +
+        `(RFC 9106: 0x10 or 0x13)`,
+    );
+  }
+  // Salt (nonce) must be 8..2^32 - 1 bytes — measured against the resolved
+  // ArrayBuffer because BinaryLike accepts strings whose UTF-8 length is
+  // what actually reaches OpenSSL.
+  const nonceAB = binaryLikeToArrayBuffer(params.nonce);
+  if (nonceAB.byteLength < 8 || nonceAB.byteLength > ARGON2_MAX_U32) {
+    throw new RangeError(
+      `Invalid Argon2 nonce length: ${nonceAB.byteLength} bytes ` +
+        `(RFC 9106: 8 ≤ |s| ≤ 2^32 - 1)`,
+    );
+  }
+  return nonceAB;
+}
+
+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 nonceAB = validateArgon2Params(params, version);
+  const result = getNative().hashSync(
+    algorithm,
+    toAB(params.message),
+    nonceAB,
+    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;
+  let nonceAB: ArrayBuffer;
+  try {
+    nonceAB = validateArgon2Params(params, version);
+  } catch (err) {
+    callback(err as Error, Buffer.alloc(0));
+    return;
+  }
+  getNative()
+    .hash(
+      algorithm,
+      toAB(params.message),
+      nonceAB,
+      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/blake3.ts

@@ -0,0 +1,124 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { Blake3 as NativeBlake3 } from './specs/blake3.nitro';
+import type { BinaryLike, Encoding } from './utils';
+import { binaryLikeToArrayBuffer, ab2str } from './utils';
+import { toArrayBuffer } from './utils/conversion';
+
+const BLAKE3_KEY_LEN = 32;
+const BLAKE3_OUT_LEN = 32;
+
+export interface Blake3Options {
+  dkLen?: number;
+  key?: Uint8Array;
+  context?: string;
+}
+
+export class Blake3 {
+  private native: NativeBlake3;
+  private mode: 'hash' | 'keyed' | 'deriveKey';
+  private keyData?: Uint8Array;
+  private contextData?: string;
+
+  constructor(opts?: Blake3Options) {
+    this.native = NitroModules.createHybridObject<NativeBlake3>('Blake3');
+
+    if (opts?.key && opts?.context) {
+      throw new Error(
+        'BLAKE3: cannot use both key and context options together',
+      );
+    }
+
+    if (opts?.key) {
+      if (opts.key.length !== BLAKE3_KEY_LEN) {
+        throw new Error(`BLAKE3: key must be exactly ${BLAKE3_KEY_LEN} bytes`);
+      }
+      this.mode = 'keyed';
+      this.keyData = opts.key;
+      this.native.initKeyed(toArrayBuffer(opts.key));
+    } else if (opts?.context !== undefined) {
+      if (typeof opts.context !== 'string' || opts.context.length === 0) {
+        throw new Error('BLAKE3: context must be a non-empty string');
+      }
+      this.mode = 'deriveKey';
+      this.contextData = opts.context;
+      this.native.initDeriveKey(opts.context);
+    } else {
+      this.mode = 'hash';
+      this.native.initHash();
+    }
+  }
+
+  update(data: BinaryLike, inputEncoding?: Encoding): this {
+    const buffer = binaryLikeToArrayBuffer(data, inputEncoding ?? 'utf8');
+    this.native.update(buffer);
+    return this;
+  }
+
+  digest(): Buffer;
+  digest(encoding: Encoding): string;
+  digest(length: number): Buffer;
+  digest(encodingOrLength?: Encoding | number): Buffer | string {
+    let length: number | undefined;
+    let encoding: Encoding | undefined;
+
+    if (typeof encodingOrLength === 'number') {
+      length = encodingOrLength;
+    } else if (encodingOrLength) {
+      encoding = encodingOrLength;
+    }
+
+    const result = this.native.digest(length);
+
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(result, encoding);
+    }
+
+    return Buffer.from(result);
+  }
+
+  digestLength(length: number): Buffer {
+    return Buffer.from(this.native.digest(length));
+  }
+
+  reset(): this {
+    this.native.reset();
+    return this;
+  }
+
+  copy(): Blake3 {
+    const copied = new Blake3();
+    // Replace the native with a copy
+    copied.native = this.native.copy() as NativeBlake3;
+    copied.mode = this.mode;
+    copied.keyData = this.keyData;
+    copied.contextData = this.contextData;
+    return copied;
+  }
+
+  static getVersion(): string {
+    const native = NitroModules.createHybridObject<NativeBlake3>('Blake3');
+    native.initHash();
+    return native.getVersion();
+  }
+}
+
+export function createBlake3(opts?: Blake3Options): Blake3 {
+  return new Blake3(opts);
+}
+
+export function blake3(data: BinaryLike, opts?: Blake3Options): Uint8Array {
+  const hasher = new Blake3(opts);
+  hasher.update(data);
+  const length = opts?.dkLen ?? BLAKE3_OUT_LEN;
+  const result = hasher.digestLength(length);
+  return new Uint8Array(result);
+}
+
+blake3.create = createBlake3;
+
+export const blake3Exports = {
+  Blake3,
+  createBlake3,
+  blake3,
+};

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