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

package/src/expo-plugin/withRNQC.ts

@@ -0,0 +1,23 @@
+import { createRunOncePlugin } from 'expo/config-plugins';
+import type { ConfigPlugin } from 'expo/config-plugins';
+import type { ConfigProps } from './@types';
+import { withSodiumIos } from './withSodiumIos';
+import { withSodiumAndroid } from './withSodiumAndroid';
+import { withXCode } from './withXCode';
+
+const withRNQCInternal: ConfigPlugin<ConfigProps> = (config, props = {}) => {
+  // add XCode workarounds for some 16.x releases that are not RN-friendly
+  config = withXCode(config, props);
+
+  // enable libsodium algorithms
+  if (props.sodiumEnabled) {
+    config = withSodiumIos(config, props);
+    config = withSodiumAndroid(config, props);
+  }
+
+  return config;
+};
+
+export function createRNQCPlugin(name: string, version: string) {
+  return createRunOncePlugin(withRNQCInternal, name, version);
+}

package/src/expo-plugin/withSodiumAndroid.ts

@@ -0,0 +1,24 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import { withGradleProperties } from 'expo/config-plugins';
+import type { ConfigProps } from './@types';
+
+export const withSodiumAndroid: ConfigPlugin<ConfigProps> = config => {
+  return withGradleProperties(config, config => {
+    config.modResults = config.modResults || [];
+
+    // Check if the property already exists
+    const existingProperty = config.modResults.find(
+      item => item.type === 'property' && item.key === 'sodiumEnabled',
+    );
+
+    if (!existingProperty) {
+      config.modResults.push({
+        type: 'property',
+        key: 'sodiumEnabled',
+        value: 'true',
+      });
+    }
+
+    return config;
+  });
+};

package/src/expo-plugin/withSodiumIos.ts

@@ -0,0 +1,30 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import { withDangerousMod } from 'expo/config-plugins';
+import fs from 'fs';
+import path from 'path';
+import type { ConfigProps } from './@types';
+
+export const withSodiumIos: ConfigPlugin<ConfigProps> = config => {
+  return withDangerousMod(config, [
+    'ios',
+    config => {
+      const podfilePath = path.join(
+        config.modRequest.platformProjectRoot,
+        'Podfile',
+      );
+      let contents = fs.readFileSync(podfilePath, 'utf-8');
+
+      // Check if SODIUM_ENABLED is already set
+      if (!contents.includes("ENV['SODIUM_ENABLED']")) {
+        // Add it right after the RCT_NEW_ARCH_ENABLED ENV variable
+        contents = contents.replace(
+          /^(ENV\['RCT_NEW_ARCH_ENABLED'\].*$)/m,
+          `$1\nENV['SODIUM_ENABLED'] = '1'`,
+        );
+        fs.writeFileSync(podfilePath, contents);
+      }
+
+      return config;
+    },
+  ]);
+};

package/src/expo-plugin/withXCode.ts

@@ -0,0 +1,55 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import type { ConfigProps } from './@types';
+import { withBuildProperties } from 'expo-build-properties';
+import { withDangerousMod } from 'expo/config-plugins';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ *  Workaround for some jank XCode releases that break React Native native modules
+ *
+ *  see: https://github.com/mrousavy/nitro/issues/422#issuecomment-2545988256
+ */
+export const withXCode: ConfigPlugin<ConfigProps> = config => {
+  // Use expo-build-properties to bump iOS deployment target
+  config = withBuildProperties(config, { ios: { deploymentTarget: '16.1' } });
+  // Patch the generated Podfile fallback to ensure platform is always 16.1
+  config = withDangerousMod(config, [
+    'ios',
+    modConfig => {
+      const podfilePath = path.join(
+        modConfig.modRequest.platformProjectRoot,
+        'Podfile',
+      );
+      let contents = fs.readFileSync(podfilePath, 'utf-8');
+
+      // Check if the IPHONEOS_DEPLOYMENT_TARGET setting is already present
+      // We search for the key being assigned, e.g., config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] =
+      const deploymentTargetSettingExists =
+        /\.build_settings\s*\[\s*['"]IPHONEOS_DEPLOYMENT_TARGET['"]\s*\]\s*=/.test(
+          contents,
+        );
+
+      if (!deploymentTargetSettingExists) {
+        // IPHONEOS_DEPLOYMENT_TARGET setting not found, proceed to add it.
+        contents = contents.replace(
+          /(post_install\s+do\s+\|installer\|[\s\S]*?)(\r?\n\s\send\s*)$/m,
+          `$1
+
+    # Expo Build Properties: force deployment target
+    # https://github.com/mrousavy/nitro/issues/422#issuecomment-2545988256
+    installer.pods_project.targets.each do |target|
+      target.build_configurations.each do |config|
+        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '16.1'
+      end
+    end
+$2`,
+        );
+      }
+
+      fs.writeFileSync(podfilePath, contents);
+      return modConfig;
+    },
+  ]);
+  return config;
+};

package/src/hash.ts

@@ -0,0 +1,274 @@
+import { Stream } from 'readable-stream';
+import { NitroModules } from 'react-native-nitro-modules';
+import type { TransformOptions } from 'readable-stream';
+import type { Hash as NativeHash } from './specs/hash.nitro';
+import type {
+  BinaryLike,
+  Encoding,
+  BufferLike,
+  SubtleAlgorithm,
+} from './utils';
+import {
+  ab2str,
+  binaryLikeToArrayBuffer,
+  bufferLikeToArrayBuffer,
+} from './utils';
+import { validateMaxBufferLength } from './utils/validation';
+import { lazyDOMException } from './utils/errors';
+import { normalizeHashName } from './utils/hashnames';
+
+class HashUtils {
+  private static native = NitroModules.createHybridObject<NativeHash>('Hash');
+  public static getSupportedHashAlgorithms(): string[] {
+    return this.native.getSupportedHashAlgorithms();
+  }
+}
+
+export function getHashes() {
+  return HashUtils.getSupportedHashAlgorithms();
+}
+
+interface HashOptions extends TransformOptions {
+  /**
+   * For XOF hash functions such as `shake256`, the
+   * outputLength option can be used to specify the desired output length in bytes.
+   */
+  outputLength?: number | undefined;
+}
+
+interface HashArgs {
+  algorithm: string;
+  options?: HashOptions;
+  native?: NativeHash;
+}
+
+class Hash extends Stream.Transform {
+  private algorithm: string;
+  private options: HashOptions;
+  private native: NativeHash;
+
+  private validate(args: HashArgs) {
+    if (typeof args.algorithm !== 'string' || args.algorithm.length === 0)
+      throw new Error('Algorithm must be a non-empty string');
+    if (
+      args.options?.outputLength !== undefined &&
+      args.options.outputLength < 0
+    )
+      throw new Error('Output length must be a non-negative number');
+    if (
+      args.options?.outputLength !== undefined &&
+      typeof args.options.outputLength !== 'number'
+    )
+      throw new Error('Output length must be a number');
+  }
+
+  /**
+   * @internal use `createHash()` instead
+   */
+  private constructor(args: HashArgs) {
+    super(args.options);
+
+    this.validate(args);
+
+    this.algorithm = args.algorithm;
+    this.options = args.options ?? {};
+
+    if (args.native) {
+      this.native = args.native;
+      return;
+    }
+
+    this.native = NitroModules.createHybridObject<NativeHash>('Hash');
+    this.native.createHash(this.algorithm, this.options.outputLength);
+  }
+
+  /**
+   * Updates the hash content with the given `data`, the encoding of which
+   * is given in `inputEncoding`.
+   * If `encoding` is not provided, and the `data` is a string, an
+   * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+   *
+   * This can be called many times with new data as it is streamed.
+   * @since v1.0.0
+   * @param inputEncoding The `encoding` of the `data` string.
+   */
+  update(data: BinaryLike): Hash;
+  update(data: BinaryLike, inputEncoding: Encoding): Buffer;
+  update(data: BinaryLike, inputEncoding?: Encoding): Hash | Buffer {
+    const defaultEncoding: Encoding = 'utf8';
+    inputEncoding = inputEncoding ?? defaultEncoding;
+
+    this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));
+
+    return this; // to support chaining syntax createHash().update().digest()
+  }
+
+  /**
+   * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
+   * If `encoding` is provided a string will be returned; otherwise
+   * a `Buffer` is returned.
+   *
+   * The `Hash` object can not be used again after `hash.digest()` method has been
+   * called. Multiple calls will cause an error to be thrown.
+   * @since v1.0.0
+   * @param encoding The `encoding` of the return value.
+   */
+  digest(): Buffer;
+  digest(encoding: Encoding): Buffer;
+  digest(encoding?: Encoding): Buffer | string {
+    const nativeDigest = this.native.digest(encoding);
+
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(nativeDigest, encoding);
+    }
+
+    return Buffer.from(nativeDigest);
+  }
+
+  /**
+   * Creates a new `Hash` object that contains a deep copy of the internal state
+   * of the current `Hash` object.
+   *
+   * The optional `options` argument controls stream behavior. For XOF hash
+   * functions such as `'shake256'`, the `outputLength` option can be used to
+   * specify the desired output length in bytes.
+   *
+   * An error is thrown when an attempt is made to copy the `Hash` object after
+   * its `hash.digest()` method has been called.
+   *
+   * ```js
+   * // Calculate a rolling hash.
+   * import { createHash } from 'react-native-quick-crypto';
+   *
+   * const hash = createHash('sha256');
+   *
+   * hash.update('one');
+   * console.log(hash.copy().digest('hex'));
+   *
+   * hash.update('two');
+   * console.log(hash.copy().digest('hex'));
+   *
+   * hash.update('three');
+   * console.log(hash.copy().digest('hex'));
+   *
+   * // Etc.
+   * ```
+   * @since v1.0.0
+   * @param options `stream.transform` options
+   */
+  copy(): Hash;
+  copy(options: HashOptions): Hash;
+  copy(options?: HashOptions): Hash {
+    const newOptions = options ?? this.options;
+    const newNativeHash = this.native.copy(newOptions.outputLength);
+    const hash = new Hash({
+      algorithm: this.algorithm,
+      options: newOptions,
+      native: newNativeHash,
+    });
+    return hash;
+  }
+
+  /**
+   * Returns the OpenSSL version string
+   * @since v1.0.0
+   */
+  getOpenSSLVersion(): string {
+    return this.native.getOpenSSLVersion();
+  }
+
+  // stream interface
+  _transform(
+    chunk: BinaryLike,
+    encoding: BufferEncoding,
+    callback: () => void,
+  ) {
+    this.update(chunk, encoding as Encoding);
+    callback();
+  }
+  _flush(callback: () => void) {
+    this.push(this.digest());
+    callback();
+  }
+}
+
+/**
+ * Creates and returns a `Hash` object that can be used to generate hash digests
+ * using the given `algorithm`. Optional `options` argument controls stream
+ * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option
+ * can be used to specify the desired output length in bytes.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 sum of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hash = crypto.createHash('sha256').update('Test123').digest('hex');
+ * console.log('SHA-256 of "Test123":', hash);
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export function createHash(algorithm: string, options?: HashOptions): Hash {
+  // @ts-expect-error private constructor
+  return new Hash({
+    algorithm,
+    options,
+  });
+}
+
+// Implementation for WebCrypto subtle.digest()
+
+/**
+ * Asynchronous digest function for WebCrypto SubtleCrypto API
+ * @param algorithm The hash algorithm to use
+ * @param data The data to hash
+ * @returns Promise resolving to the hash digest as ArrayBuffer
+ */
+export const asyncDigest = async (
+  algorithm: SubtleAlgorithm,
+  data: BufferLike,
+): Promise<ArrayBuffer> => {
+  validateMaxBufferLength(data, 'data');
+
+  switch (algorithm.name) {
+    case 'SHA-1':
+    // Fall through
+    case 'SHA-256':
+    // Fall through
+    case 'SHA-384':
+    // Fall through
+    case 'SHA-512':
+      return internalDigest(algorithm, data);
+  }
+
+  throw lazyDOMException(
+    `Unrecognized algorithm name: ${algorithm.name}`,
+    'NotSupportedError',
+  );
+};
+
+const internalDigest = (
+  algorithm: SubtleAlgorithm,
+  data: BufferLike,
+): ArrayBuffer => {
+  const normalizedHashName = normalizeHashName(algorithm.name);
+  const hash = createHash(normalizedHashName);
+  hash.update(bufferLikeToArrayBuffer(data));
+  const result = hash.digest();
+  const arrayBuffer = new ArrayBuffer(result.length);
+  const view = new Uint8Array(arrayBuffer);
+  view.set(result);
+  return arrayBuffer;
+};
+
+export const hashExports = {
+  createHash,
+  getHashes,
+  asyncDigest,
+};

package/src/hmac.ts

@@ -0,0 +1,135 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { Stream } from 'readable-stream';
+import { NitroModules } from 'react-native-nitro-modules';
+import type { TransformOptions } from 'readable-stream';
+import type { Hmac as NativeHmac } from './specs/hmac.nitro';
+import type { BinaryLike, Encoding } from './utils/types';
+import { ab2str, binaryLikeToArrayBuffer } from './utils/conversion';
+
+interface HmacArgs {
+  algorithm: string;
+  key: BinaryLike;
+  options?: TransformOptions;
+}
+
+class Hmac extends Stream.Transform {
+  private algorithm: string;
+  private key: BinaryLike;
+  private native: NativeHmac;
+
+  private validate(args: HmacArgs) {
+    if (typeof args.algorithm !== 'string' || args.algorithm.length === 0)
+      throw new Error('Algorithm must be a non-empty string');
+    if (args.key === null || args.key === undefined)
+      throw new Error('Key must not be null or undefined');
+  }
+
+  /**
+   * @internal use `createHmac()` instead
+   */
+  private constructor(args: HmacArgs) {
+    super(args.options);
+
+    this.validate(args);
+
+    this.algorithm = args.algorithm;
+    this.key = args.key;
+
+    this.native = NitroModules.createHybridObject<NativeHmac>('Hmac');
+    this.native.createHmac(this.algorithm, binaryLikeToArrayBuffer(this.key));
+  }
+
+  /**
+   * Updates the `Hmac` content with the given `data`, the encoding of which is given in `inputEncoding`.
+   * If `encoding` is not provided, and the `data` is a string, an encoding of `'utf8'` is enforced.
+   * If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+   *
+   * This can be called many times with new data as it is streamed.
+   * @since v1.0.0
+   * @param inputEncoding The `encoding` of the `data` string.
+   */
+  update(data: BinaryLike): Hmac;
+  update(data: BinaryLike, inputEncoding: Encoding): Hmac;
+  update(data: BinaryLike, inputEncoding?: Encoding): Hmac {
+    const defaultEncoding: Encoding = 'utf8';
+    inputEncoding = inputEncoding ?? defaultEncoding;
+
+    this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));
+
+    return this; // to support chaining syntax createHmac().update().digest()
+  }
+
+  /**
+   * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
+   * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned;
+   *
+   * The `Hmac` object can not be used again after `hmac.digest()` has been
+   * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
+   * @since v1.0.0
+   * @param encoding The `encoding` of the return value.
+   */
+  digest(): Buffer;
+  digest(encoding: Encoding): string;
+  digest(encoding?: Encoding): Buffer | string {
+    const nativeDigest = this.native.digest();
+
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(nativeDigest, encoding);
+    }
+
+    return Buffer.from(nativeDigest);
+  }
+
+  // stream interface
+  _transform(
+    chunk: BinaryLike,
+    encoding: BufferEncoding,
+    callback: () => void,
+  ) {
+    this.update(chunk, encoding as Encoding);
+    callback();
+  }
+  _flush(callback: () => void) {
+    this.push(this.digest());
+    callback();
+  }
+}
+
+/**
+ * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
+ * Optional `options` argument controls stream behavior.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 HMAC of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hmac = crypto.createHmac('sha256', 'secret-key');
+ * hmac.update('message to hash');
+ * const digest = hmac.digest('hex');
+ * console.log(digest); // prints HMAC digest in hexadecimal format
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export function createHmac(
+  algorithm: string,
+  key: BinaryLike,
+  options?: TransformOptions,
+): Hmac {
+  // @ts-expect-error private constructor
+  return new Hmac({
+    algorithm,
+    key,
+    options,
+  });
+}
+
+export const hmacExports = {
+  createHmac,
+};

package/src/index.ts

@@ -2,48 +2,39 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 
 // API imports
+import * as keys from './keys';
+import * as blake3 from './blake3';
+import * as cipher from './cipher';
+import * as ed from './ed';
+import { hashExports as hash } from './hash';
+import { hmacExports as hmac } from './hmac';
+import * as pbkdf2 from './pbkdf2';
 import * as random from './random';
 
 // utils import
-import { utils } from './utils';
+import * as utils from './utils';
+import * as subtle from './subtle';
 
 /**
  * Loosely matches Node.js {crypto} with some unimplemented functionality.
  * See `docs/implementation-coverage.md` for status.
  */
 const QuickCrypto = {
-  // createHmac,
-  // Hmac: createHmac,
-  // Hash: createHash,
-  // createHash,
-  // createCipher,
-  // createCipheriv,
-  // createDecipher,
-  // createDecipheriv,
-  // createPublicKey,
-  // createPrivateKey,
-  // createSecretKey,
-  // publicEncrypt,
-  // publicDecrypt,
-  // privateDecrypt,
-  // generateKey,
-  // generateKeyPair,
-  // generateKeyPairSync,
-  // generateKeySync,
-  // createSign,
-  // createVerify,
-  // subtle,
-  // constants,
-  // ...pbkdf2,
+  ...keys,
+  ...blake3,
+  ...cipher,
+  ...ed,
+  ...hash,
+  ...hmac,
+  ...pbkdf2,
   ...random,
-  // getCiphers,
-  // getHashes,
-  // webcrypto,
-  utils,
+  ...utils,
+  ...subtle,
 };
 
 /**
- * Optional. Patch global.crypto with quickcrypto and global.Buffer with react-native-buffer.
+ * Optional. Patch global.crypto with react-native-quick-crypto and
+ * global.Buffer with react-native-buffer.
  */
 export const install = () => {
   // @ts-expect-error copyBytesFrom and poolSizets are missing from react-native-buffer
@@ -56,7 +47,19 @@ export const install = () => {
 // random, cipher, hash use nextTick
 global.process.nextTick = setImmediate;
 
+// exports
 export default QuickCrypto;
+export * from './blake3';
+export * from './cipher';
+export * from './ed';
+export * from './keys';
+export * from './hash';
+export * from './hmac';
+export * from './pbkdf2';
+export * from './random';
+export * from './utils';
+export * from './subtle';
+export { subtle, isCryptoKeyPair } from './subtle';
 
 // Additional exports for CommonJS compatibility
 module.exports = QuickCrypto;