fix: hash string passing

Author: boorad

docs/implementation-coverage.md

@@ -253,7 +253,7 @@ These algorithms provide quantum-resistant cryptography.
   * ❌ `subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)`
   * ✅ `subtle.decrypt(algorithm, key, data)`
   * 🚧 `subtle.deriveBits(algorithm, baseKey, length)`
-  * ❌ `subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)`
+  * 🚧 `subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)`
   * 🚧 `subtle.digest(algorithm, data)`
   * ❌ `subtle.encapsulateBits(encapsulationAlgorithm, encapsulationKey)`
   * ❌ `subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)`

example/src/benchmarks/hash/hash.ts

@@ -0,0 +1,100 @@
+import rnqc from 'react-native-quick-crypto';
+import { sha256 } from '@noble/hashes/sha2';
+// @ts-expect-error - crypto-browserify is not typed
+import browserify from 'crypto-browserify';
+import type { BenchFn } from '../../types/benchmarks';
+import { Bench } from 'tinybench';
+
+// Generate test data of different sizes using repeating pattern
+const generateString = (sizeInMB: number): string => {
+  const chunk =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  const bytesPerMB = 1024 * 1024;
+  const totalBytes = Math.floor(sizeInMB * bytesPerMB);
+  const repeatCount = Math.ceil(totalBytes / chunk.length);
+  return chunk.repeat(repeatCount).substring(0, totalBytes);
+};
+
+// Pre-generate test data (8MB as reported in issue)
+const text100KB = generateString(0.1);
+const text1MB = generateString(1);
+const text8MB = generateString(8);
+
+const hash_sha256_8mb: BenchFn = () => {
+  const bench = new Bench({
+    name: 'hash sha256 8MB string',
+    time: 10,
+    iterations: 1,
+    warmupIterations: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      const hash = rnqc.createHash('sha256');
+      hash.update(text8MB);
+      hash.digest('hex');
+    })
+    .add('@noble/hashes/sha256', () => {
+      sha256(text8MB);
+    })
+    .add('browserify', () => {
+      const hash = browserify.createHash('sha256');
+      hash.update(text8MB);
+      hash.digest('hex');
+    });
+
+  return bench;
+};
+
+const hash_sha256_1mb: BenchFn = () => {
+  const bench = new Bench({
+    name: 'hash sha256 1MB string',
+    time: 50,
+    iterations: 2,
+    warmupIterations: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      const hash = rnqc.createHash('sha256');
+      hash.update(text1MB);
+      hash.digest('hex');
+    })
+    .add('@noble/hashes/sha256', () => {
+      sha256(text1MB);
+    })
+    .add('browserify', () => {
+      const hash = browserify.createHash('sha256');
+      hash.update(text1MB);
+      hash.digest('hex');
+    });
+
+  return bench;
+};
+
+const hash_sha256_100kb: BenchFn = () => {
+  const bench = new Bench({
+    name: 'hash sha256 100KB string',
+    iterations: 5,
+  });
+
+  bench
+    .add('rnqc', () => {
+      const hash = rnqc.createHash('sha256');
+      hash.update(text100KB);
+      hash.digest('hex');
+    })
+    .add('@noble/hashes/sha256', () => {
+      sha256(text100KB);
+    })
+    .add('browserify', () => {
+      const hash = browserify.createHash('sha256');
+      hash.update(text100KB);
+      hash.digest('hex');
+    });
+
+  bench.warmupTime = 100;
+  return bench;
+};
+
+export default [hash_sha256_100kb, hash_sha256_1mb, hash_sha256_8mb];

example/src/hooks/useBenchmarks.ts

@@ -2,10 +2,11 @@ import { useEffect, useState } from 'react';
 import { BenchmarkSuite } from '../benchmarks/benchmarks';
 import blake3 from '../benchmarks/blake3/blake3';
 import ed from '../benchmarks/ed/ed25519';
+import hkdf from '../benchmarks/hkdf/hkdf';
+import hash from '../benchmarks/hash/hash';
 import pbkdf2 from '../benchmarks/pbkdf2/pbkdf2';
 import random from '../benchmarks/random/randomBytes';
 import xsalsa20 from '../benchmarks/cipher/xsalsa20';
-import hkdf from '../benchmarks/hkdf/hkdf';
 
 export const useBenchmarks = (): [
   BenchmarkSuite[],
@@ -22,16 +23,17 @@ export const useBenchmarks = (): [
   useEffect(() => {
     const newSuites: BenchmarkSuite[] = [];
     newSuites.push(new BenchmarkSuite('blake3', blake3));
+    newSuites.push(new BenchmarkSuite('cipher', xsalsa20));
     newSuites.push(new BenchmarkSuite('ed', ed));
     newSuites.push(new BenchmarkSuite('pbkdf2', pbkdf2));
+    newSuites.push(new BenchmarkSuite('hash', hash));
     newSuites.push(new BenchmarkSuite('hkdf', hkdf));
     newSuites.push(
       new BenchmarkSuite('random', random, {
         'browserify/randombytes':
           'polyfilled with RNQC, so a somewhat senseless benchmark',
       }),
     );
-    newSuites.push(new BenchmarkSuite('cipher', xsalsa20));
     setSuites(newSuites);
   }, []);
 

packages/react-native-quick-crypto/cpp/hash/HybridHash.cpp

@@ -68,14 +68,21 @@ void HybridHash::createHash(const std::string& hashAlgorithmArg, const std::opti
   }
 }
 
-void HybridHash::update(const std::shared_ptr<ArrayBuffer>& data) {
+void HybridHash::update(const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& data) {
   if (!ctx) {
     throw std::runtime_error("Hash context not initialized");
   }
 
-  // Update the digest with the data
-  if (EVP_DigestUpdate(ctx, reinterpret_cast<const uint8_t*>(data->data()), data->size()) != 1) {
-    throw std::runtime_error("Failed to update hash digest: " + std::to_string(ERR_get_error()));
+  if (std::holds_alternative<std::string>(data)) {
+    const std::string& str = std::get<std::string>(data);
+    if (EVP_DigestUpdate(ctx, reinterpret_cast<const uint8_t*>(str.data()), str.length()) != 1) {
+      throw std::runtime_error("Failed to update hash digest: " + std::to_string(ERR_get_error()));
+    }
+  } else {
+    const std::shared_ptr<ArrayBuffer>& buffer = std::get<std::shared_ptr<ArrayBuffer>>(data);
+    if (EVP_DigestUpdate(ctx, reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size()) != 1) {
+      throw std::runtime_error("Failed to update hash digest: " + std::to_string(ERR_get_error()));
+    }
   }
 }
 

packages/react-native-quick-crypto/cpp/hash/HybridHash.hpp

@@ -21,7 +21,7 @@ class HybridHash : public HybridHashSpec {
  public:
   // Methods
   void createHash(const std::string& algorithm, const std::optional<double> outputLength) override;
-  void update(const std::shared_ptr<ArrayBuffer>& data) override;
+  void update(const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& data) override;
   std::shared_ptr<ArrayBuffer> digest(const std::optional<std::string>& encoding = std::nullopt) override;
   std::shared_ptr<margelo::nitro::crypto::HybridHashSpec> copy(const std::optional<double> outputLength) override;
   std::vector<std::string> getSupportedHashAlgorithms() override;

packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.hpp

@@ -98,7 +98,12 @@ class Hash extends Stream.Transform {
     const defaultEncoding: Encoding = 'utf8';
     inputEncoding = inputEncoding ?? defaultEncoding;
 
-    this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));
+    // OPTIMIZED PATH: Pass UTF-8 strings directly to native without conversion
+    if (typeof data === 'string' && inputEncoding === 'utf8') {
+      this.native.update(data);
+    } else {
+      this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));
+    }
 
     return this; // to support chaining syntax createHash().update().digest()
   }

packages/react-native-quick-crypto/src/hash.ts

@@ -2,7 +2,7 @@ import type { HybridObject } from 'react-native-nitro-modules';
 
 export interface Hash extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   createHash(algorithm: string, outputLength?: number): void;
-  update(data: ArrayBuffer): void;
+  update(data: ArrayBuffer | string): void;
   digest(encoding?: string): ArrayBuffer;
   copy(outputLength?: number): Hash;
   getSupportedHashAlgorithms(): string[];