react-native-quick-crypto 1.1.0 → 1.1.1

package/cpp/sign/HybridSignHandle.cpp

@@ -86,35 +86,13 @@ static bool isOneShotVariant(EVP_PKEY* pkey) {
 #endif
 }
 
-// Get the algorithm name for creating PKEY_CTX (for ML-DSA variants)
-static const char* getAlgorithmName(EVP_PKEY* pkey) {
-  int type = EVP_PKEY_id(pkey);
-#if RNQC_HAS_ML_DSA
-  switch (type) {
-    case EVP_PKEY_ML_DSA_44:
-      return "ML-DSA-44";
-    case EVP_PKEY_ML_DSA_65:
-      return "ML-DSA-65";
-    case EVP_PKEY_ML_DSA_87:
-      return "ML-DSA-87";
-    case EVP_PKEY_ED25519:
-      return "ED25519";
-    case EVP_PKEY_ED448:
-      return "ED448";
-    default:
-      return nullptr;
-  }
-#else
-  switch (type) {
-    case EVP_PKEY_ED25519:
-      return "ED25519";
-    case EVP_PKEY_ED448:
-      return "ED448";
-    default:
-      return nullptr;
-  }
-#endif
-}
+// RAII owners for short-lived OpenSSL handles used in this method. EVP_MD_CTX
+// transitively owns its EVP_PKEY_CTX after a successful EVP_DigestSignInit, so
+// we deliberately rely on EVP_MD_CTX_free to clean both up; the standalone
+// EvpPkeyCtxPtr alias is kept only for the RSA/ECDSA branch, where we
+// allocate the PKEY_CTX directly via EVP_PKEY_CTX_new.
+using EvpMdCtxPtr = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>;
+using EvpPkeyCtxPtr = std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)>;
 
 std::shared_ptr<ArrayBuffer> HybridSignHandle::sign(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
                                                     std::optional<double> padding, std::optional<double> saltLength,
@@ -139,28 +117,19 @@ std::shared_ptr<ArrayBuffer> HybridSignHandle::sign(const std::shared_ptr<Hybrid
   // Ed25519/Ed448/ML-DSA require one-shot signing with EVP_DigestSign
   // Also use one-shot path if no digest was specified (md == nullptr)
   if (is_one_shot || md == nullptr) {
-    // Create a new context for one-shot signing
-    EVP_MD_CTX* sign_ctx = EVP_MD_CTX_new();
+    EvpMdCtxPtr sign_ctx{EVP_MD_CTX_new(), EVP_MD_CTX_free};
     if (!sign_ctx) {
       throw std::runtime_error("Failed to create signing context");
     }
 
-    // Get algorithm name and create PKEY_CTX for ML-DSA
-    const char* alg_name = getAlgorithmName(pkey);
-    EVP_PKEY_CTX* pkey_ctx = nullptr;
-    if (alg_name != nullptr) {
-      pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, alg_name, nullptr);
-      if (!pkey_ctx) {
-        EVP_MD_CTX_free(sign_ctx);
-        throw std::runtime_error(std::string("Failed to create signing context for ") + alg_name);
-      }
-    }
-
-    // Initialize for one-shot signing (pass nullptr for md - these algorithms have built-in hash)
-    if (EVP_DigestSignInit(sign_ctx, pkey_ctx ? &pkey_ctx : nullptr, nullptr, nullptr, pkey) <= 0) {
-      EVP_MD_CTX_free(sign_ctx);
-      if (pkey_ctx)
-        EVP_PKEY_CTX_free(pkey_ctx);
+    // Let OpenSSL allocate the PKEY_CTX from the key's keymgmt. On success the
+    // EVP_MD_CTX assumes ownership and EVP_MD_CTX_free will dispose it; on
+    // failure pkey_ctx_raw stays nullptr, so there is nothing to leak. This
+    // mirrors ncrypto's EVPMDCtxPointer::signInit (Node.js deps/ncrypto/ncrypto.cc
+    // and ~/dev/ncrypto/src/ncrypto.cpp), which works for RSA, ECDSA, Ed25519,
+    // Ed448 and ML-DSA without any algorithm-name pre-creation.
+    EVP_PKEY_CTX* pkey_ctx_raw = nullptr;
+    if (EVP_DigestSignInit(sign_ctx.get(), &pkey_ctx_raw, nullptr, nullptr, pkey) <= 0) {
       throw std::runtime_error("Failed to initialize one-shot signing");
     }
 
@@ -171,21 +140,17 @@ std::shared_ptr<ArrayBuffer> HybridSignHandle::sign(const std::shared_ptr<Hybrid
     // We need to use EVP_DigestSign with the accumulated data
 
     // For one-shot variants, determine signature length first
-    if (EVP_DigestSign(sign_ctx, nullptr, &sig_len, data_buffer.data(), data_buffer.size()) <= 0) {
-      EVP_MD_CTX_free(sign_ctx);
+    if (EVP_DigestSign(sign_ctx.get(), nullptr, &sig_len, data_buffer.data(), data_buffer.size()) <= 0) {
       throw std::runtime_error("Failed to determine Ed signature length");
     }
 
     sig_buf = std::make_unique<uint8_t[]>(sig_len);
-    if (EVP_DigestSign(sign_ctx, sig_buf.get(), &sig_len, data_buffer.data(), data_buffer.size()) <= 0) {
-      EVP_MD_CTX_free(sign_ctx);
+    if (EVP_DigestSign(sign_ctx.get(), sig_buf.get(), &sig_len, data_buffer.data(), data_buffer.size()) <= 0) {
       unsigned long err = ERR_get_error();
       char err_buf[256];
       ERR_error_string_n(err, err_buf, sizeof(err_buf));
       throw std::runtime_error("Failed to sign with Ed key: " + std::string(err_buf));
     }
-
-    EVP_MD_CTX_free(sign_ctx);
   } else {
     // Standard signing flow for RSA/ECDSA
     unsigned char digest[EVP_MAX_MD_SIZE];
@@ -195,13 +160,12 @@ std::shared_ptr<ArrayBuffer> HybridSignHandle::sign(const std::shared_ptr<Hybrid
       throw std::runtime_error("Failed to finalize digest");
     }
 
-    EVP_PKEY_CTX* pkey_ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+    EvpPkeyCtxPtr pkey_ctx{EVP_PKEY_CTX_new(pkey, nullptr), EVP_PKEY_CTX_free};
     if (!pkey_ctx) {
       throw std::runtime_error("Failed to create signing context");
     }
 
-    if (EVP_PKEY_sign_init(pkey_ctx) <= 0) {
-      EVP_PKEY_CTX_free(pkey_ctx);
+    if (EVP_PKEY_sign_init(pkey_ctx.get()) <= 0) {
       char err_buf[512];
       snprintf(err_buf, sizeof(err_buf), "Failed to initialize signing for key type %d (expected one-shot: %s, RNQC_HAS_ML_DSA=%d)",
                pkey_type, is_one_shot ? "true" : "false", RNQC_HAS_ML_DSA);
@@ -210,40 +174,33 @@ std::shared_ptr<ArrayBuffer> HybridSignHandle::sign(const std::shared_ptr<Hybrid
 
     if (padding.has_value()) {
       int pad = static_cast<int>(padding.value());
-      if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, pad) <= 0) {
-        EVP_PKEY_CTX_free(pkey_ctx);
+      if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx.get(), pad) <= 0) {
         throw std::runtime_error("Failed to set RSA padding");
       }
     }
 
     if (saltLength.has_value() && padding.has_value() && static_cast<int>(padding.value()) == RSA_PKCS1_PSS_PADDING) {
       int salt_len = static_cast<int>(saltLength.value());
-      if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, salt_len) <= 0) {
-        EVP_PKEY_CTX_free(pkey_ctx);
+      if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx.get(), salt_len) <= 0) {
         throw std::runtime_error("Failed to set PSS salt length");
       }
     }
 
-    if (EVP_PKEY_CTX_set_signature_md(pkey_ctx, md) <= 0) {
-      EVP_PKEY_CTX_free(pkey_ctx);
+    if (EVP_PKEY_CTX_set_signature_md(pkey_ctx.get(), md) <= 0) {
       throw std::runtime_error("Failed to set signature digest");
     }
 
-    if (EVP_PKEY_sign(pkey_ctx, nullptr, &sig_len, digest, digest_len) <= 0) {
-      EVP_PKEY_CTX_free(pkey_ctx);
+    if (EVP_PKEY_sign(pkey_ctx.get(), nullptr, &sig_len, digest, digest_len) <= 0) {
       throw std::runtime_error("Failed to determine signature length");
     }
 
     sig_buf = std::make_unique<uint8_t[]>(sig_len);
-    if (EVP_PKEY_sign(pkey_ctx, sig_buf.get(), &sig_len, digest, digest_len) <= 0) {
-      EVP_PKEY_CTX_free(pkey_ctx);
+    if (EVP_PKEY_sign(pkey_ctx.get(), sig_buf.get(), &sig_len, digest, digest_len) <= 0) {
       unsigned long err = ERR_get_error();
       char err_buf[256];
       ERR_error_string_n(err, err_buf, sizeof(err_buf));
       throw std::runtime_error("Failed to sign: " + std::string(err_buf));
     }
-
-    EVP_PKEY_CTX_free(pkey_ctx);
   }
 
   int dsa_enc = dsaEncoding.has_value() ? static_cast<int>(dsaEncoding.value()) : kSigEncDER;

package/cpp/sign/HybridVerifyHandle.cpp

@@ -86,35 +86,13 @@ static bool isOneShotVariant(EVP_PKEY* pkey) {
 #endif
 }
 
-// Get the algorithm name for creating PKEY_CTX (for ML-DSA variants)
-static const char* getAlgorithmName(EVP_PKEY* pkey) {
-  int type = EVP_PKEY_id(pkey);
-#if RNQC_HAS_ML_DSA
-  switch (type) {
-    case EVP_PKEY_ML_DSA_44:
-      return "ML-DSA-44";
-    case EVP_PKEY_ML_DSA_65:
-      return "ML-DSA-65";
-    case EVP_PKEY_ML_DSA_87:
-      return "ML-DSA-87";
-    case EVP_PKEY_ED25519:
-      return "ED25519";
-    case EVP_PKEY_ED448:
-      return "ED448";
-    default:
-      return nullptr;
-  }
-#else
-  switch (type) {
-    case EVP_PKEY_ED25519:
-      return "ED25519";
-    case EVP_PKEY_ED448:
-      return "ED448";
-    default:
-      return nullptr;
-  }
-#endif
-}
+// RAII owners for short-lived OpenSSL handles used in this method. EVP_MD_CTX
+// transitively owns its EVP_PKEY_CTX after a successful EVP_DigestVerifyInit,
+// so we deliberately rely on EVP_MD_CTX_free to clean both up; the standalone
+// EvpPkeyCtxPtr alias is kept only for the RSA/ECDSA branch, where we
+// allocate the PKEY_CTX directly via EVP_PKEY_CTX_new.
+using EvpMdCtxPtr = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>;
+using EvpPkeyCtxPtr = std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)>;
 
 bool HybridVerifyHandle::verify(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& signature,
                                 std::optional<double> padding, std::optional<double> saltLength, std::optional<double> dsaEncoding) {
@@ -136,32 +114,23 @@ bool HybridVerifyHandle::verify(const std::shared_ptr<HybridKeyObjectHandleSpec>
   // Ed25519/Ed448/ML-DSA require one-shot verification with EVP_DigestVerify
   // Also use one-shot path if no digest was specified (md == nullptr)
   if (isOneShotVariant(pkey) || md == nullptr) {
-    EVP_MD_CTX* verify_ctx = EVP_MD_CTX_new();
+    EvpMdCtxPtr verify_ctx{EVP_MD_CTX_new(), EVP_MD_CTX_free};
     if (!verify_ctx) {
       throw std::runtime_error("Failed to create verification context");
     }
 
-    // Get algorithm name and create PKEY_CTX for ML-DSA
-    const char* alg_name = getAlgorithmName(pkey);
-    EVP_PKEY_CTX* pkey_ctx = nullptr;
-    if (alg_name != nullptr) {
-      pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, alg_name, nullptr);
-      if (!pkey_ctx) {
-        EVP_MD_CTX_free(verify_ctx);
-        throw std::runtime_error(std::string("Failed to create verification context for ") + alg_name);
-      }
-    }
-
-    // Initialize for one-shot verification (pass nullptr for md - these algorithms have built-in hash)
-    if (EVP_DigestVerifyInit(verify_ctx, pkey_ctx ? &pkey_ctx : nullptr, nullptr, nullptr, pkey) <= 0) {
-      EVP_MD_CTX_free(verify_ctx);
-      if (pkey_ctx)
-        EVP_PKEY_CTX_free(pkey_ctx);
+    // Let OpenSSL allocate the PKEY_CTX from the key's keymgmt. On success the
+    // EVP_MD_CTX assumes ownership and EVP_MD_CTX_free will dispose it; on
+    // failure pkey_ctx_raw stays nullptr, so there is nothing to leak. This
+    // mirrors ncrypto's EVPMDCtxPointer::verifyInit (Node.js deps/ncrypto/ncrypto.cc
+    // and ~/dev/ncrypto/src/ncrypto.cpp), which works for RSA, ECDSA, Ed25519,
+    // Ed448 and ML-DSA without any algorithm-name pre-creation.
+    EVP_PKEY_CTX* pkey_ctx_raw = nullptr;
+    if (EVP_DigestVerifyInit(verify_ctx.get(), &pkey_ctx_raw, nullptr, nullptr, pkey) <= 0) {
       throw std::runtime_error("Failed to initialize one-shot verification");
     }
 
-    int result = EVP_DigestVerify(verify_ctx, sig_data, sig_len, data_buffer.data(), data_buffer.size());
-    EVP_MD_CTX_free(verify_ctx);
+    int result = EVP_DigestVerify(verify_ctx.get(), sig_data, sig_len, data_buffer.data(), data_buffer.size());
     return result == 1;
   }
 
@@ -187,40 +156,34 @@ bool HybridVerifyHandle::verify(const std::shared_ptr<HybridKeyObjectHandleSpec>
     }
   }
 
-  EVP_PKEY_CTX* pkey_ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+  EvpPkeyCtxPtr pkey_ctx{EVP_PKEY_CTX_new(pkey, nullptr), EVP_PKEY_CTX_free};
   if (!pkey_ctx) {
     throw std::runtime_error("Failed to create verification context");
   }
 
-  if (EVP_PKEY_verify_init(pkey_ctx) <= 0) {
-    EVP_PKEY_CTX_free(pkey_ctx);
+  if (EVP_PKEY_verify_init(pkey_ctx.get()) <= 0) {
     throw std::runtime_error("Failed to initialize verification");
   }
 
   if (padding.has_value()) {
     int pad = static_cast<int>(padding.value());
-    if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, pad) <= 0) {
-      EVP_PKEY_CTX_free(pkey_ctx);
+    if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx.get(), pad) <= 0) {
       throw std::runtime_error("Failed to set RSA padding");
     }
   }
 
   if (saltLength.has_value() && padding.has_value() && static_cast<int>(padding.value()) == RSA_PKCS1_PSS_PADDING) {
     int salt_len = static_cast<int>(saltLength.value());
-    if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, salt_len) <= 0) {
-      EVP_PKEY_CTX_free(pkey_ctx);
+    if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx.get(), salt_len) <= 0) {
       throw std::runtime_error("Failed to set PSS salt length");
     }
   }
 
-  if (EVP_PKEY_CTX_set_signature_md(pkey_ctx, md) <= 0) {
-    EVP_PKEY_CTX_free(pkey_ctx);
+  if (EVP_PKEY_CTX_set_signature_md(pkey_ctx.get(), md) <= 0) {
     throw std::runtime_error("Failed to set signature digest");
   }
 
-  int result = EVP_PKEY_verify(pkey_ctx, sig_data, sig_len, digest, digest_len);
-  EVP_PKEY_CTX_free(pkey_ctx);
-
+  int result = EVP_PKEY_verify(pkey_ctx.get(), sig_data, sig_len, digest, digest_len);
   return result == 1;
 }
 

package/cpp/utils/HybridUtils.cpp

@@ -1,5 +1,8 @@
 #include "HybridUtils.hpp"
 
+#include <NitroModules/JSIConverter+ArrayBuffer.hpp>
+#include <bit>
+#include <cstring>
 #include <openssl/crypto.h>
 #include <stdexcept>
 #include <string>
@@ -13,6 +16,25 @@ 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')
@@ -86,6 +108,73 @@ namespace {
     return result;
   }
 
+  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);
+    }
+    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;
+    }
+    throw std::runtime_error("Unsupported encoding: utf16le");
+  }
+
   std::vector<uint8_t> decodeLatin1(const std::string& str) {
     std::vector<uint8_t> result;
     result.reserve(str.size());
@@ -142,56 +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 ArrayBuffer::move(std::move(decoded));
-  }
-  if (encoding == "base64" || encoding == "base64url") {
-    auto decoded = decodeBase64(str);
-    return ArrayBuffer::move(std::move(decoded));
+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 == "utf8" || encoding == "utf-8") {
-    return ArrayBuffer::copy(reinterpret_cast<const uint8_t*>(str.data()), str.size());
-  }
-  if (encoding == "latin1" || encoding == "binary") {
-    auto decoded = decodeLatin1(str);
-    return ArrayBuffer::move(std::move(decoded));
-  }
-  if (encoding == "ascii") {
-    auto decoded = decodeLatin1(str);
-    return ArrayBuffer::move(std::move(decoded));
+
+  // 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)));
+    }
+    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