react-native-quick-crypto 1.0.19 → 1.1.1

package/cpp/utils/HybridUtils.cpp

@@ -1,18 +1,40 @@
 #include "HybridUtils.hpp"
 
-#include <limits>
+#include <NitroModules/JSIConverter+ArrayBuffer.hpp>
+#include <bit>
+#include <cstring>
 #include <openssl/crypto.h>
-#include <openssl/evp.h>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #include "QuickCryptoUtils.hpp"
+#include "simdutf.h"
 
 namespace margelo::nitro::crypto {
 
 namespace {
 
   constexpr char kHexChars[] = "0123456789abcdef";
+  constexpr bool kCanDirectCopyUtf16 = std::endian::native == std::endian::little && sizeof(char16_t) == 2;
+
+  // Probe if jsi::String::createFromUtf16() is available
+  // jsi::String::createFromUtf16(Runtime& runtime, const char16_t* utf16, size_t length)
+  // and
+  // jsi::String::createFromUtf16(Runtime& runtime, const std::u16string& utf16) are available in RN v0.79.0 and later:
+  // https://github.com/facebook/react-native/commit/d9d824055e9f24614abd5657f9fc89a6ab3f2da2
+  template <typename JSIString = facebook::jsi::String>
+  concept HasStringCreateFromUtf16 = requires(facebook::jsi::Runtime& runtime, const char16_t* utf16, size_t length) {
+    JSIString::createFromUtf16(runtime, utf16, length);
+  };
+
+  // Probe if jsi::String::getStringData() is available
+  // jsi::String::getStringData() is available in RN v0.78.0 and later:
+  // https://github.com/facebook/react-native/commit/c6f12254d16d87978383c08065a626d437e60450
+  template <typename JSIString = facebook::jsi::String>
+  concept HasStringGetStringData = requires(const JSIString& str, facebook::jsi::Runtime& runtime, void (*cb)(bool, const void*, size_t)) {
+    str.getStringData(runtime, cb);
+  };
 
   int hexCharToVal(char c) {
     if (c >= '0' && c <= '9')
@@ -35,16 +57,13 @@ namespace {
   }
 
   std::vector<uint8_t> decodeHex(const std::string& hex) {
-    if (hex.length() % 2 != 0) {
-      throw std::runtime_error("Invalid hex string length");
-    }
     std::vector<uint8_t> result;
     result.reserve(hex.length() / 2);
-    for (size_t i = 0; i < hex.length(); i += 2) {
+    for (size_t i = 0; i + 1 < hex.length(); i += 2) {
       int hi = hexCharToVal(hex[i]);
       int lo = hexCharToVal(hex[i + 1]);
       if (hi < 0 || lo < 0) {
-        throw std::runtime_error("Invalid hex character");
+        break;
       }
       result.push_back(static_cast<uint8_t>((hi << 4) | lo));
     }
@@ -52,67 +71,108 @@ namespace {
   }
 
   std::string encodeBase64(const uint8_t* data, size_t len) {
-    if (len > static_cast<size_t>(std::numeric_limits<int>::max())) {
-      throw std::runtime_error("Input too large for base64 encoding");
-    }
-    size_t encodedLen = ((len + 2) / 3) * 4;
-    std::string result(encodedLen + 1, '\0');
-    int written = EVP_EncodeBlock(reinterpret_cast<unsigned char*>(result.data()), data, static_cast<int>(len));
-    if (written < 0) {
-      throw std::runtime_error("Base64 encoding failed");
+    if (len == 0) {
+      return {};
     }
-    result.resize(static_cast<size_t>(written));
+
+    size_t encodedLen = simdutf::base64_length_from_binary(len, simdutf::base64_default);
+    std::string result(encodedLen, '\0');
+    simdutf::binary_to_base64(reinterpret_cast<const char*>(data), len, result.data(), simdutf::base64_default);
     return result;
   }
 
   std::vector<uint8_t> decodeBase64(const std::string& b64) {
-    if (b64.length() > static_cast<size_t>(std::numeric_limits<int>::max())) {
-      throw std::runtime_error("Input too large for base64 decoding");
+    if (b64.empty()) {
+      return {};
     }
-    size_t maxLen = ((b64.length() + 3) / 4) * 3;
+
+    size_t maxLen = simdutf::maximal_binary_length_from_base64(b64.data(), b64.length());
     std::vector<uint8_t> result(maxLen);
-    int written = EVP_DecodeBlock(result.data(), reinterpret_cast<const unsigned char*>(b64.data()), static_cast<int>(b64.length()));
-    if (written < 0) {
+    auto decodeResult = simdutf::base64_to_binary(b64.data(), b64.size(), reinterpret_cast<char*>(result.data()),
+                                                  simdutf::base64_default_or_url_accept_garbage);
+    if (decodeResult.error != simdutf::error_code::SUCCESS) {
       throw std::runtime_error("Base64 decoding failed");
     }
-    // EVP_DecodeBlock doesn't account for padding — trim trailing zeros from padding
-    size_t padding = 0;
-    if (b64.length() >= 1 && b64[b64.length() - 1] == '=')
-      padding++;
-    if (b64.length() >= 2 && b64[b64.length() - 2] == '=')
-      padding++;
-    result.resize(static_cast<size_t>(written) - padding);
+    result.resize(decodeResult.count);
     return result;
   }
 
   std::string encodeBase64Url(const uint8_t* data, size_t len) {
-    std::string b64 = encodeBase64(data, len);
-    for (auto& c : b64) {
-      if (c == '+')
-        c = '-';
-      else if (c == '/')
-        c = '_';
-    }
-    // Remove trailing '=' padding
-    while (!b64.empty() && b64.back() == '=') {
-      b64.pop_back();
-    }
-    return b64;
+    if (len == 0) {
+      return {};
+    }
+
+    size_t encodedLen = simdutf::base64_length_from_binary(len, simdutf::base64_url);
+    std::string result(encodedLen, '\0');
+    simdutf::binary_to_base64(reinterpret_cast<const char*>(data), len, result.data(), simdutf::base64_url);
+    return result;
   }
 
-  std::vector<uint8_t> decodeBase64Url(const std::string& b64url) {
-    std::string b64 = b64url;
-    for (auto& c : b64) {
-      if (c == '-')
-        c = '+';
-      else if (c == '_')
-        c = '/';
+  template <typename JSIString = facebook::jsi::String>
+  JSIString createUtf16LeString(facebook::jsi::Runtime& runtime, const uint8_t* data, size_t len) {
+    if constexpr (HasStringCreateFromUtf16<JSIString>) {
+      if constexpr (kCanDirectCopyUtf16) {
+        // Fast&direct copy path
+        return JSIString::createFromUtf16(runtime, reinterpret_cast<const char16_t*>(data), len / 2);
+      }
+      // Slow path for unexpected endianness/char16_t size
+      const size_t codeUnitCount = len / 2;
+      std::u16string result(codeUnitCount, u'\0');
+      if (codeUnitCount == 0) {
+        return JSIString::createFromUtf16(runtime, result);
+      }
+
+      for (size_t i = 0; i < codeUnitCount; i++) {
+        result[i] = static_cast<char16_t>(static_cast<uint16_t>(data[i * 2]) | (static_cast<uint16_t>(data[i * 2 + 1]) << 8));
+      }
+      return JSIString::createFromUtf16(runtime, result);
     }
-    // Add back padding
-    while (b64.length() % 4 != 0) {
-      b64.push_back('=');
+    throw std::runtime_error("Unsupported encoding: utf16le");
+  }
+
+  template <typename JSIString = facebook::jsi::String>
+  std::vector<uint8_t> decodeUtf16Le(facebook::jsi::Runtime& runtime, const JSIString& str) {
+    if constexpr (HasStringGetStringData<JSIString>) {
+      std::vector<uint8_t> result;
+      // str.utf8() cannot preserve raw UTF-16 code units such as unpaired surrogates.
+      // Use jsi::String::getStringData() instead.
+      auto chunkCallback = [&result](bool isAscii, const void* data, size_t num) {
+        if (num == 0) {
+          return;
+        }
+
+        size_t offset = result.size();
+        result.resize(offset + (num * 2)); // This fills the buffer with '\0'
+
+        auto* dst = result.data() + offset;
+        if (isAscii) {
+          // Widen ASCII characters from char into char16_t
+          const auto* asciiSrc = reinterpret_cast<const char*>(data);
+          for (size_t i = 0; i < num; i++, dst += 2) {
+            *dst = asciiSrc[i];
+            // *(dst + 1) = '\0' is unnecessary because the buffer is zero filled in resize()
+          }
+          return;
+        }
+
+        const auto* utf16Src = reinterpret_cast<const char16_t*>(data);
+        if constexpr (kCanDirectCopyUtf16) {
+          // Fast&direct copy path
+          std::memcpy(dst, utf16Src, num * 2);
+          return;
+        }
+        // Slow path for unexpected endianness/char16_t size
+        for (size_t i = 0; i < num; i++) {
+          const uint16_t codeUnit = static_cast<uint16_t>(utf16Src[i]);
+          dst[i * 2 + 0] = static_cast<uint8_t>(codeUnit & 0xFFu);
+          dst[i * 2 + 1] = static_cast<uint8_t>(codeUnit >> 8);
+        }
+      };
+
+      str.getStringData(runtime, chunkCallback);
+      return result;
     }
-    return decodeBase64(b64);
+    throw std::runtime_error("Unsupported encoding: utf16le");
   }
 
   std::vector<uint8_t> decodeLatin1(const std::string& str) {
@@ -145,17 +205,15 @@ namespace {
   }
 
   std::string encodeLatin1(const uint8_t* data, size_t len) {
-    std::string result;
-    result.reserve(len * 2);
-    for (size_t i = 0; i < len; i++) {
-      uint8_t byte = data[i];
-      if (byte < 0x80) {
-        result.push_back(static_cast<char>(byte));
-      } else {
-        // Latin1 byte 0x80-0xFF → UTF-8 two-byte sequence
-        result.push_back(static_cast<char>(0xC0 | (byte >> 6)));
-        result.push_back(static_cast<char>(0x80 | (byte & 0x3F)));
-      }
+    if (len == 0) {
+      return {};
+    }
+
+    size_t utf8Len = simdutf::utf8_length_from_latin1(reinterpret_cast<const char*>(data), len);
+    std::string result(utf8Len, '\0');
+    size_t written = simdutf::convert_latin1_to_utf8(reinterpret_cast<const char*>(data), len, result.data());
+    if (written == 0) {
+      throw std::runtime_error("Latin1 encoding failed");
     }
     return result;
   }
@@ -173,63 +231,107 @@ bool HybridUtils::timingSafeEqual(const std::shared_ptr<ArrayBuffer>& a, const s
   return CRYPTO_memcmp(a->data(), b->data(), aLen) == 0;
 }
 
-std::string HybridUtils::bufferToString(const std::shared_ptr<ArrayBuffer>& buffer, const std::string& encoding) {
-  const auto* data = reinterpret_cast<const uint8_t*>(buffer->data());
-  size_t len = buffer->size();
-
-  if (encoding == "hex") {
-    return encodeHex(data, len);
+facebook::jsi::Value HybridUtils::bufferToJsiString(facebook::jsi::Runtime& runtime, const facebook::jsi::Value&,
+                                                    const facebook::jsi::Value* args, size_t argCount) {
+  // Runtime argument check from react-native-nitro-modules/cpp/core/HybridFunction.hpp
+  if (argCount != 2) [[unlikely]] {
+    throw facebook::jsi::JSError(runtime,
+                                 "`Utils.bufferToString(...)` expected 2 arguments, but received " + std::to_string(argCount) + "!");
   }
-  if (encoding == "base64") {
-    return encodeBase64(data, len);
-  }
-  if (encoding == "base64url") {
-    return encodeBase64Url(data, len);
-  }
-  if (encoding == "utf8" || encoding == "utf-8") {
-    return std::string(reinterpret_cast<const char*>(data), len);
-  }
-  if (encoding == "latin1" || encoding == "binary") {
-    return encodeLatin1(data, len);
-  }
-  if (encoding == "ascii") {
-    std::string result(reinterpret_cast<const char*>(data), len);
-    for (auto& c : result) {
-      c &= 0x7F;
+
+  // Exception wrapper from react-native-nitro-modules/cpp/core/HybridFunction.hpp
+  try {
+    // bufferToString(buffer: ArrayBuffer, encoding: string): string; Defined in utils/conversion.ts
+    auto buffer = JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, args[0]);
+    std::string encoding = JSIConverter<std::string>::fromJSI(runtime, args[1]);
+
+    const auto* data = reinterpret_cast<const uint8_t*>(buffer->data());
+    size_t len = buffer->size();
+
+    if (encoding == "hex") {
+      return facebook::jsi::String::createFromUtf8(runtime, encodeHex(data, len));
     }
-    return result;
+    if (encoding == "base64") {
+      return facebook::jsi::String::createFromUtf8(runtime, encodeBase64(data, len));
+    }
+    if (encoding == "base64url") {
+      return facebook::jsi::String::createFromUtf8(runtime, encodeBase64Url(data, len));
+    }
+    if (encoding == "utf8" || encoding == "utf-8") {
+      return facebook::jsi::String::createFromUtf8(runtime, data, len);
+    }
+    if (encoding == "latin1" || encoding == "binary") {
+      return facebook::jsi::String::createFromUtf8(runtime, encodeLatin1(data, len));
+    }
+    if (encoding == "ascii") {
+      std::string result(reinterpret_cast<const char*>(data), len);
+      for (auto& c : result) {
+        c &= 0x7F;
+      }
+      return facebook::jsi::String::createFromUtf8(runtime, result);
+    }
+    if (encoding == "utf16le") {
+      return createUtf16LeString(runtime, data, len);
+    }
+    throw std::runtime_error("Unsupported encoding: " + encoding);
+  } catch (const std::exception& exception) {
+    throw facebook::jsi::JSError(runtime, "Utils.bufferToString(...): " + std::string(exception.what()));
+  } catch (...) {
+    throw facebook::jsi::JSError(runtime,
+                                 "`Utils.bufferToString(...)` threw an unknown " + TypeInfo::getCurrentExceptionName() + " error.");
   }
-  throw std::runtime_error("Unsupported encoding: " + encoding);
 }
 
-std::shared_ptr<ArrayBuffer> HybridUtils::stringToBuffer(const std::string& str, const std::string& encoding) {
-  if (encoding == "hex") {
-    auto decoded = decodeHex(str);
-    return ToNativeArrayBuffer(decoded);
-  }
-  if (encoding == "base64") {
-    auto decoded = decodeBase64(str);
-    return ToNativeArrayBuffer(decoded);
-  }
-  if (encoding == "base64url") {
-    auto decoded = decodeBase64Url(str);
-    return ToNativeArrayBuffer(decoded);
-  }
-  if (encoding == "utf8" || encoding == "utf-8") {
-    return ToNativeArrayBuffer(str);
+facebook::jsi::Value HybridUtils::jsiStringToBuffer(facebook::jsi::Runtime& runtime, const facebook::jsi::Value&,
+                                                    const facebook::jsi::Value* args, size_t argCount) {
+  // Runtime argument check from react-native-nitro-modules/cpp/core/HybridFunction.hpp
+  if (argCount != 2) [[unlikely]] {
+    throw facebook::jsi::JSError(runtime,
+                                 "`Utils.stringToBuffer(...)` expected 2 arguments, but received " + std::to_string(argCount) + "!");
   }
-  if (encoding == "latin1" || encoding == "binary") {
-    auto decoded = decodeLatin1(str);
-    return ToNativeArrayBuffer(decoded);
-  }
-  if (encoding == "ascii") {
-    auto decoded = decodeLatin1(str);
-    for (auto& b : decoded) {
-      b &= 0x7F;
+
+  // Exception wrapper from react-native-nitro-modules/cpp/core/HybridFunction.hpp
+  try {
+    // stringToBuffer(str: string, encoding: string): ArrayBuffer; Defined in utils/conversion.ts
+    auto str = args[0].asString(runtime);
+    std::string encoding = JSIConverter<std::string>::fromJSI(runtime, args[1]);
+
+    if (encoding == "hex") {
+      auto decoded = decodeHex(str.utf8(runtime));
+      return JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, ArrayBuffer::move(std::move(decoded)));
     }
-    return ToNativeArrayBuffer(decoded);
+    if (encoding == "base64" || encoding == "base64url") {
+      auto decoded = decodeBase64(str.utf8(runtime));
+      return JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, ArrayBuffer::move(std::move(decoded)));
+    }
+    if (encoding == "utf8" || encoding == "utf-8") {
+      auto utf8Str = str.utf8(runtime);
+      return JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(
+          runtime, ArrayBuffer::copy(reinterpret_cast<const uint8_t*>(utf8Str.data()), utf8Str.size()));
+    }
+    if (encoding == "latin1" || encoding == "binary" || encoding == "ascii") {
+      auto decoded = decodeLatin1(str.utf8(runtime));
+      return JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, ArrayBuffer::move(std::move(decoded)));
+    }
+    if (encoding == "utf16le") {
+      auto decoded = decodeUtf16Le(runtime, str);
+      return JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, ArrayBuffer::move(std::move(decoded)));
+    }
+    throw std::runtime_error("Unsupported encoding: " + encoding);
+  } catch (const std::exception& exception) {
+    throw facebook::jsi::JSError(runtime, "Utils.stringToBuffer(...): " + std::string(exception.what()));
+  } catch (...) {
+    throw facebook::jsi::JSError(runtime,
+                                 "`Utils.stringToBuffer(...)` threw an unknown " + TypeInfo::getCurrentExceptionName() + " error.");
   }
-  throw std::runtime_error("Unsupported encoding: " + encoding);
+}
+
+void HybridUtils::loadHybridMethods() {
+  HybridUtilsSpec::loadHybridMethods();
+  registerHybrids(this, [](Prototype& prototype) {
+    prototype.registerRawHybridMethod("bufferToString", 2, &HybridUtils::bufferToJsiString);
+    prototype.registerRawHybridMethod("stringToBuffer", 2, &HybridUtils::jsiStringToBuffer);
+  });
 }
 
 } // namespace margelo::nitro::crypto

package/cpp/utils/HybridUtils.hpp

@@ -10,8 +10,15 @@ class HybridUtils : public HybridUtilsSpec {
 
  public:
   bool timingSafeEqual(const std::shared_ptr<ArrayBuffer>& a, const std::shared_ptr<ArrayBuffer>& b) override;
-  std::string bufferToString(const std::shared_ptr<ArrayBuffer>& buffer, const std::string& encoding) override;
-  std::shared_ptr<ArrayBuffer> stringToBuffer(const std::string& str, const std::string& encoding) override;
+
+ protected:
+  void loadHybridMethods() override;
+
+ private:
+  facebook::jsi::Value bufferToJsiString(facebook::jsi::Runtime& runtime, const facebook::jsi::Value& thisArg,
+                                         const facebook::jsi::Value* args, size_t argCount);
+  facebook::jsi::Value jsiStringToBuffer(facebook::jsi::Runtime& runtime, const facebook::jsi::Value& thisArg,
+                                         const facebook::jsi::Value* args, size_t argCount);
 };
 
 } // namespace margelo::nitro::crypto

package/cpp/utils/QuickCryptoUtils.hpp

@@ -2,11 +2,16 @@
 
 #include <algorithm>
 #include <cctype>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
 #include <limits>
 #include <openssl/bn.h>
+#include <openssl/crypto.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 #include "Macros.hpp"
@@ -68,6 +73,73 @@ inline bool CheckIsInt32(double value) {
   return (value >= std::numeric_limits<int32_t>::lowest() && value <= std::numeric_limits<int32_t>::max());
 }
 
+// Validate a JS-side `double` intended to be an unsigned integer in
+// [minValue, maxValue], then cast it to T. Rejects NaN, +/-Infinity, negative
+// values, and fractional values BEFORE the cast — `static_cast<uint32_t>(NaN)`
+// and friends are undefined behavior in C++, and the audit found ~20 sites
+// that did the cast naked. Throws `std::runtime_error` carrying `paramName`
+// on any failure so JS callers see a descriptive, actionable message.
+//
+// The helper is templated so callers pick the destination type
+// (uint32_t, uint64_t, size_t, ...). T must be an unsigned integer type.
+template <typename T>
+T validateUInt(double value, const char* paramName, T minValue = 0, T maxValue = std::numeric_limits<T>::max()) {
+  static_assert(std::is_integral_v<T> && std::is_unsigned_v<T>, "validateUInt: T must be an unsigned integer type");
+
+  if (std::isnan(value)) {
+    throw std::runtime_error(std::string(paramName) + " must be a finite number, got NaN");
+  }
+  if (std::isinf(value)) {
+    throw std::runtime_error(std::string(paramName) + std::string(" must be a finite number, got ") +
+                             (value > 0 ? "+Infinity" : "-Infinity"));
+  }
+  if (value < 0) {
+    throw std::runtime_error(std::string(paramName) + " must be non-negative, got " + std::to_string(value));
+  }
+  if (value != std::floor(value)) {
+    throw std::runtime_error(std::string(paramName) + " must be an integer, got " + std::to_string(value));
+  }
+  if (value < static_cast<double>(minValue) || value > static_cast<double>(maxValue)) {
+    throw std::runtime_error(std::string(paramName) + " out of range [" + std::to_string(minValue) + ", " + std::to_string(maxValue) +
+                             "], got " + std::to_string(value));
+  }
+  return static_cast<T>(value);
+}
+
+// Securely zero a memory range using OPENSSL_cleanse, which the compiler is
+// guaranteed not to optimize away even when the buffer is about to leave
+// scope. Use this for any memory that held secrets — keys, derived bits,
+// shared secrets, plaintext, PEM/DER private-key strings, IV/nonce material.
+//
+// Plain std::memset is unsafe for this purpose: under -O2 the compiler will
+// see that the memset writes are dead (the memory is freed or going out of
+// scope right after) and elide them, leaving the secret on the heap.
+//
+// Overloads cover the common shapes: raw pointer + size, vector, string,
+// fixed-size array. The audit found ~30 sites that need this — XSalsa20,
+// XChaCha20-Poly1305, all KDFs, DH/ECDH shared secrets, RSA/EC/Ed/DSA DER
+// private-key strings — and they get swept in Phase 2.
+inline void secureZero(void* ptr, std::size_t size) {
+  if (ptr != nullptr && size > 0) {
+    OPENSSL_cleanse(ptr, size);
+  }
+}
+
+inline void secureZero(std::vector<uint8_t>& vec) {
+  secureZero(vec.data(), vec.size());
+}
+
+inline void secureZero(std::string& s) {
+  if (!s.empty()) {
+    secureZero(s.data(), s.size());
+  }
+}
+
+template <std::size_t N>
+inline void secureZero(uint8_t (&arr)[N]) {
+  secureZero(static_cast<void*>(arr), N);
+}
+
 // Function to convert a string to lowercase
 inline std::string toLower(std::string s) {
   std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });