react-native-quick-crypto 1.0.0-beta.2 → 1.0.0-beta.21

package/src/blake3.ts

@@ -0,0 +1,123 @@
+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';
+
+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(opts.key.buffer as ArrayBuffer);
+    } 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/cipher.ts

@@ -0,0 +1,335 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import Stream, { type TransformOptions } from 'readable-stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike, BinaryLikeNode, Encoding } from './utils';
+import type {
+  CipherCCMOptions,
+  CipherCCMTypes,
+  CipherGCMTypes,
+  CipherGCMOptions,
+  CipherOCBOptions,
+  CipherOCBTypes,
+} from 'crypto'; // @types/node
+import type {
+  Cipher as NativeCipher,
+  CipherFactory,
+} from './specs/cipher.nitro';
+import { ab2str, binaryLikeToArrayBuffer } from './utils';
+import {
+  getDefaultEncoding,
+  getUIntOption,
+  normalizeEncoding,
+  validateEncoding,
+} from './utils/cipher';
+
+export type CipherOptions =
+  | CipherCCMOptions
+  | CipherOCBOptions
+  | CipherGCMOptions
+  | TransformOptions;
+
+class CipherUtils {
+  private static native =
+    NitroModules.createHybridObject<NativeCipher>('Cipher');
+  public static getSupportedCiphers(): string[] {
+    return this.native.getSupportedCiphers();
+  }
+}
+
+export function getCiphers(): string[] {
+  return CipherUtils.getSupportedCiphers();
+}
+
+interface CipherArgs {
+  isCipher: boolean;
+  cipherType: string;
+  cipherKey: BinaryLikeNode;
+  iv: BinaryLike;
+  options?: CipherOptions;
+}
+
+class CipherCommon extends Stream.Transform {
+  private native: NativeCipher;
+
+  constructor({ isCipher, cipherType, cipherKey, iv, options }: CipherArgs) {
+    // Explicitly create TransformOptions for super()
+    const streamOptions: TransformOptions = {};
+    if (options) {
+      // List known TransformOptions keys (adjust if needed)
+      const transformKeys: Array<keyof TransformOptions> = [
+        'readableHighWaterMark',
+        'writableHighWaterMark',
+        'decodeStrings',
+        'defaultEncoding',
+        'objectMode',
+        'destroy',
+        'read',
+        'write',
+        'writev',
+        'final',
+        'transform',
+        'flush',
+        // Add any other relevant keys from readable-stream's TransformOptions
+      ];
+      for (const key of transformKeys) {
+        if (key in options) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (streamOptions as any)[key] = (options as any)[key];
+        }
+      }
+    }
+    super(streamOptions); // Pass filtered options
+
+    const authTagLen: number =
+      getUIntOption(options ?? {}, 'authTagLength') !== -1
+        ? getUIntOption(options ?? {}, 'authTagLength')
+        : 16; // defaults to 16 bytes
+
+    const factory =
+      NitroModules.createHybridObject<CipherFactory>('CipherFactory');
+    this.native = factory.createCipher({
+      isCipher,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      authTagLen,
+    });
+  }
+
+  update(data: Buffer): Buffer;
+  update(data: BinaryLike, inputEncoding?: Encoding): Buffer;
+  update(
+    data: BinaryLike,
+    inputEncoding: Encoding,
+    outputEncoding: Encoding,
+  ): string;
+  update(
+    data: BinaryLike,
+    inputEncoding?: Encoding,
+    outputEncoding?: Encoding,
+  ): Buffer | string {
+    const defaultEncoding = getDefaultEncoding();
+    inputEncoding = inputEncoding ?? defaultEncoding;
+    outputEncoding = outputEncoding ?? defaultEncoding;
+
+    if (typeof data === 'string') {
+      validateEncoding(data, inputEncoding);
+    } else if (!ArrayBuffer.isView(data)) {
+      throw new Error('Invalid data argument');
+    }
+
+    const ret = this.native.update(
+      binaryLikeToArrayBuffer(data, inputEncoding),
+    );
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      return ab2str(ret, outputEncoding);
+    }
+
+    return Buffer.from(ret);
+  }
+
+  final(): Buffer;
+  final(outputEncoding: BufferEncoding | 'buffer'): string;
+  final(outputEncoding?: BufferEncoding | 'buffer'): Buffer | string {
+    const ret = this.native.final();
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      return ab2str(ret, outputEncoding);
+    }
+
+    return Buffer.from(ret);
+  }
+
+  _transform(
+    chunk: BinaryLike,
+    encoding: BufferEncoding,
+    callback: () => void,
+  ) {
+    this.push(this.update(chunk, normalizeEncoding(encoding)));
+    callback();
+  }
+
+  _flush(callback: () => void) {
+    this.push(this.final());
+    callback();
+  }
+
+  public setAutoPadding(autoPadding?: boolean): this {
+    const res = this.native.setAutoPadding(!!autoPadding);
+    if (!res) {
+      throw new Error('setAutoPadding failed');
+    }
+    return this;
+  }
+
+  public setAAD(
+    buffer: Buffer,
+    options?: {
+      plaintextLength: number;
+    },
+  ): this {
+    // Check if native parts are initialized
+    if (!this.native || typeof this.native.setAAD !== 'function') {
+      throw new Error('Cipher native object or setAAD method not initialized.');
+    }
+    const res = this.native.setAAD(buffer.buffer, options?.plaintextLength);
+    if (!res) {
+      throw new Error('setAAD failed (native call returned false)');
+    }
+    return this;
+  }
+
+  public getAuthTag(): Buffer {
+    return Buffer.from(this.native.getAuthTag());
+  }
+
+  public setAuthTag(tag: Buffer): this {
+    const res = this.native.setAuthTag(binaryLikeToArrayBuffer(tag));
+    if (!res) {
+      throw new Error('setAuthTag failed');
+    }
+    return this;
+  }
+
+  public getSupportedCiphers(): string[] {
+    return this.native.getSupportedCiphers();
+  }
+}
+
+class Cipheriv extends CipherCommon {
+  constructor(
+    cipherType: string,
+    cipherKey: BinaryLikeNode,
+    iv: BinaryLike,
+    options?: CipherOptions,
+  ) {
+    super({
+      isCipher: true,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      options,
+    });
+  }
+}
+
+export type Cipher = Cipheriv;
+
+class Decipheriv extends CipherCommon {
+  constructor(
+    cipherType: string,
+    cipherKey: BinaryLikeNode,
+    iv: BinaryLike,
+    options?: CipherOptions,
+  ) {
+    super({
+      isCipher: false,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      options,
+    });
+  }
+}
+
+export type Decipher = Decipheriv;
+
+export function createDecipheriv(
+  algorithm: CipherCCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherCCMOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: CipherOCBTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherOCBOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: CipherGCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherGCMOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: TransformOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherOptions,
+): Decipher {
+  return new Decipheriv(algorithm, key, iv, options);
+}
+
+export function createCipheriv(
+  algorithm: CipherCCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherCCMOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: CipherOCBTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherOCBOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: CipherGCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherGCMOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: TransformOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherOptions,
+): Cipher {
+  return new Cipheriv(algorithm, key, iv, options);
+}
+
+/**
+ * xsalsa20 stream encryption with @noble/ciphers compatible API
+ *
+ * @param key - 32 bytes
+ * @param nonce - 24 bytes
+ * @param data - data to encrypt
+ * @param output - unused
+ * @param counter - unused
+ * @returns encrypted data
+ */
+export function xsalsa20(
+  key: Uint8Array,
+  nonce: Uint8Array,
+  data: Uint8Array,
+  // @ts-expect-error haven't implemented this part of @noble/ciphers API
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  output?: Uint8Array | undefined,
+  // @ts-expect-error haven't implemented this part of @noble/ciphers API
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  counter?: number,
+): Uint8Array {
+  const factory =
+    NitroModules.createHybridObject<CipherFactory>('CipherFactory');
+  const native = factory.createCipher({
+    isCipher: true,
+    cipherType: 'xsalsa20',
+    cipherKey: binaryLikeToArrayBuffer(key),
+    iv: binaryLikeToArrayBuffer(nonce),
+  });
+  const result = native.update(binaryLikeToArrayBuffer(data));
+  return new Uint8Array(result);
+}