@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/cpp/utils/HybridUtils.cpp

@@ -0,0 +1,197 @@
+#include "HybridUtils.hpp"
+
+#include <openssl/crypto.h>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "QuickCryptoUtils.hpp"
+#include "simdutf.h"
+
+namespace margelo::nitro::crypto {
+
+namespace {
+
+  constexpr char kHexChars[] = "0123456789abcdef";
+
+  int hexCharToVal(char c) {
+    if (c >= '0' && c <= '9')
+      return c - '0';
+    if (c >= 'a' && c <= 'f')
+      return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F')
+      return c - 'A' + 10;
+    return -1;
+  }
+
+  std::string encodeHex(const uint8_t* data, size_t len) {
+    std::string result;
+    result.reserve(len * 2);
+    for (size_t i = 0; i < len; i++) {
+      result.push_back(kHexChars[data[i] >> 4]);
+      result.push_back(kHexChars[data[i] & 0x0F]);
+    }
+    return result;
+  }
+
+  std::vector<uint8_t> decodeHex(const std::string& hex) {
+    std::vector<uint8_t> result;
+    result.reserve(hex.length() / 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) {
+        break;
+      }
+      result.push_back(static_cast<uint8_t>((hi << 4) | lo));
+    }
+    return result;
+  }
+
+  std::string encodeBase64(const uint8_t* data, size_t len) {
+    if (len == 0) {
+      return {};
+    }
+
+    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.empty()) {
+      return {};
+    }
+
+    size_t maxLen = simdutf::maximal_binary_length_from_base64(b64.data(), b64.length());
+    std::vector<uint8_t> result(maxLen);
+    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");
+    }
+    result.resize(decodeResult.count);
+    return result;
+  }
+
+  std::string encodeBase64Url(const uint8_t* data, size_t len) {
+    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> decodeLatin1(const std::string& str) {
+    std::vector<uint8_t> result;
+    result.reserve(str.size());
+    size_t i = 0;
+    while (i < str.size()) {
+      auto byte = static_cast<uint8_t>(str[i]);
+      uint32_t cp;
+      if (byte < 0x80) {
+        cp = byte;
+        i += 1;
+      } else if ((byte & 0xE0) == 0xC0 && i + 1 < str.size()) {
+        cp = ((byte & 0x1F) << 6) | (static_cast<uint8_t>(str[i + 1]) & 0x3F);
+        i += 2;
+      } else if ((byte & 0xF0) == 0xE0 && i + 2 < str.size()) {
+        cp = ((byte & 0x0F) << 12) | ((static_cast<uint8_t>(str[i + 1]) & 0x3F) << 6) | (static_cast<uint8_t>(str[i + 2]) & 0x3F);
+        i += 3;
+      } else if ((byte & 0xF8) == 0xF0 && i + 3 < str.size()) {
+        cp = ((byte & 0x07) << 18) | ((static_cast<uint8_t>(str[i + 1]) & 0x3F) << 12) | ((static_cast<uint8_t>(str[i + 2]) & 0x3F) << 6) |
+             (static_cast<uint8_t>(str[i + 3]) & 0x3F);
+        i += 4;
+      } else {
+        cp = byte;
+        i += 1;
+      }
+      result.push_back(static_cast<uint8_t>(cp & 0xFF));
+    }
+    return result;
+  }
+
+  std::string encodeLatin1(const uint8_t* data, size_t len) {
+    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;
+  }
+
+} // anonymous namespace
+
+bool HybridUtils::timingSafeEqual(const std::shared_ptr<ArrayBuffer>& a, const std::shared_ptr<ArrayBuffer>& b) {
+  size_t aLen = a->size();
+  size_t bLen = b->size();
+
+  if (aLen != bLen) {
+    throw std::runtime_error("Input buffers must have the same byte length");
+  }
+
+  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);
+  }
+  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;
+    }
+    return result;
+  }
+  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));
+  }
+  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));
+  }
+  throw std::runtime_error("Unsupported encoding: " + encoding);
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/utils/HybridUtils.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "HybridUtilsSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridUtils : public HybridUtilsSpec {
+ public:
+  HybridUtils() : HybridObject(TAG) {}
+
+ 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;
+};
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/utils/Macros.hpp

@@ -0,0 +1,68 @@
+#include <utility>
+
+// Windows 8+ does not like abort() in Release mode
+#ifdef _WIN32
+#define ABORT_NO_BACKTRACE() _exit(134)
+#else
+#define ABORT_NO_BACKTRACE() abort()
+#endif
+
+struct AssertionInfo {
+  const char* file_line; // filename:line
+  const char* message;
+  const char* function;
+};
+
+inline void Abort() {
+  //  DumpBacktrace(stderr);
+  fflush(stderr);
+  ABORT_NO_BACKTRACE();
+}
+
+inline void Assert(const AssertionInfo& info) {
+  //  std::string name = GetHumanReadableProcessName();
+
+  fprintf(stderr, "%s:%s%s Assertion `%s' failed.\n", info.file_line, info.function, *info.function ? ":" : "", info.message);
+  fflush(stderr);
+
+  Abort();
+}
+
+// Macros stolen from Node
+#define ERROR_AND_ABORT(expr)                                                                                                              \
+  do {                                                                                                                                     \
+    /* Make sure that this struct does not end up in inline code, but      */                                                              \
+    /* rather in a read-only data section when modifying this code.        */                                                              \
+    static const AssertionInfo args = {__FILE__ ":" STRINGIFY(__LINE__), #expr, PRETTY_FUNCTION_NAME};                                     \
+    Assert(args);                                                                                                                          \
+  } while (0)
+
+#ifdef __GNUC__
+#define LIKELY(expr) __builtin_expect(!!(expr), 1)
+#define UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#define PRETTY_FUNCTION_NAME __PRETTY_FUNCTION__
+#else
+#define LIKELY(expr) expr
+#define UNLIKELY(expr) expr
+#define PRETTY_FUNCTION_NAME ""
+#endif
+
+#define STRINGIFY_(x) #x
+#define STRINGIFY(x) STRINGIFY_(x)
+
+#define CHECK(expr)                                                                                                                        \
+  do {                                                                                                                                     \
+    if (UNLIKELY(!(expr))) {                                                                                                               \
+      ERROR_AND_ABORT(expr);                                                                                                               \
+    }                                                                                                                                      \
+  } while (0)
+
+#define CHECK_EQ(a, b) CHECK((a) == (b))
+#define CHECK_GE(a, b) CHECK((a) >= (b))
+#define CHECK_GT(a, b) CHECK((a) > (b))
+#define CHECK_LE(a, b) CHECK((a) <= (b))
+#define CHECK_LT(a, b) CHECK((a) < (b))
+#define CHECK_NE(a, b) CHECK((a) != (b))
+#define CHECK_NULL(val) CHECK((val) == nullptr)
+#define CHECK_NOT_NULL(val) CHECK((val) != nullptr)
+#define CHECK_IMPLIES(a, b) CHECK(!(a) || (b))

package/harmony/quick_crypto/src/main/cpp/cpp/utils/QuickCryptoUtils.cpp

@@ -0,0 +1,44 @@
+#include "QuickCryptoUtils.hpp"
+#include <openssl/bn.h>
+#include <openssl/core_names.h>
+#include <openssl/evp.h>
+#include <openssl/param_build.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+EVP_PKEY* createEcEvpPkey(const char* group_name, const uint8_t* pub_oct, size_t pub_len, const BIGNUM* priv_bn) {
+  OSSL_PARAM_BLD* bld = OSSL_PARAM_BLD_new();
+  if (!bld)
+    throw std::runtime_error("Failed to create OSSL_PARAM_BLD");
+
+  OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME, group_name, 0);
+  OSSL_PARAM_BLD_push_octet_string(bld, OSSL_PKEY_PARAM_PUB_KEY, pub_oct, pub_len);
+  if (priv_bn)
+    OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv_bn);
+
+  OSSL_PARAM* params = OSSL_PARAM_BLD_to_param(bld);
+  OSSL_PARAM_BLD_free(bld);
+  if (!params)
+    throw std::runtime_error("Failed to build EC parameters");
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_from_name(nullptr, "EC", nullptr);
+  if (!ctx) {
+    OSSL_PARAM_free(params);
+    throw std::runtime_error("Failed to create EVP_PKEY_CTX for EC");
+  }
+
+  int selection = priv_bn ? EVP_PKEY_KEYPAIR : EVP_PKEY_PUBLIC_KEY;
+  EVP_PKEY* pkey = nullptr;
+  if (EVP_PKEY_fromdata_init(ctx) <= 0 || EVP_PKEY_fromdata(ctx, &pkey, selection, params) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    OSSL_PARAM_free(params);
+    throw std::runtime_error("Failed to create EVP_PKEY from EC parameters");
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+  OSSL_PARAM_free(params);
+  return pkey;
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/utils/QuickCryptoUtils.hpp

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <limits>
+#include <openssl/bn.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <string>
+#include <vector>
+
+#include "Macros.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+// Function to get the last OpenSSL error message and clear the error stack
+inline std::string getOpenSSLError() {
+  unsigned long errCode = ERR_get_error();
+  if (errCode == 0) {
+    return "";
+  }
+  char errStr[256];
+  ERR_error_string_n(errCode, errStr, sizeof(errStr));
+  // Clear any remaining errors from the error stack to prevent pollution
+  ERR_clear_error();
+  return std::string(errStr);
+}
+
+// Function to clear OpenSSL error stack without getting error message
+inline void clearOpenSSLErrors() {
+  ERR_clear_error();
+}
+
+// copy a JSArrayBuffer that we do not own into a NativeArrayBuffer that we do own
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(const std::shared_ptr<margelo::nitro::ArrayBuffer>& buffer) {
+  size_t bufferSize = buffer.get()->size();
+  uint8_t* data = new uint8_t[bufferSize];
+  memcpy(data, buffer.get()->data(), bufferSize);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, bufferSize, [=]() { delete[] data; });
+}
+
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(std::string str) {
+  size_t size = str.size();
+  uint8_t* data = new uint8_t[size];
+  memcpy(data, str.data(), size);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, size, [=]() { delete[] data; });
+}
+
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(const std::vector<uint8_t>& vec) {
+  size_t size = vec.size();
+  uint8_t* data = new uint8_t[size];
+  memcpy(data, vec.data(), size);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, size, [=]() { delete[] data; });
+}
+
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(const uint8_t* ptr, size_t size) {
+  uint8_t* data = new uint8_t[size];
+  memcpy(data, ptr, size);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, size, [=]() { delete[] data; });
+}
+
+inline bool CheckIsUint32(double value) {
+  return (value >= std::numeric_limits<uint32_t>::lowest() && value <= std::numeric_limits<uint32_t>::max());
+}
+
+inline bool CheckIsInt32(double value) {
+  return (value >= std::numeric_limits<int32_t>::lowest() && value <= std::numeric_limits<int32_t>::max());
+}
+
+// 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)); });
+  return s;
+}
+
+inline const EVP_MD* getDigestByName(const std::string& algorithm) {
+  std::string algo = toLower(algorithm);
+
+  // Strip legacy RSA- prefix (e.g. rsa-sha256 -> sha256) for Node.js compat
+  if (algo.size() > 4 && algo.compare(0, 4, "rsa-") == 0) {
+    algo = algo.substr(4);
+  }
+
+  if (algo == "sha1" || algo == "sha-1") {
+    return EVP_sha1();
+  } else if (algo == "sha224" || algo == "sha-224") {
+    return EVP_sha224();
+  } else if (algo == "sha256" || algo == "sha-256") {
+    return EVP_sha256();
+  } else if (algo == "sha384" || algo == "sha-384") {
+    return EVP_sha384();
+  } else if (algo == "sha512" || algo == "sha-512") {
+    return EVP_sha512();
+  } else if (algo == "sha3-224") {
+    return EVP_sha3_224();
+  } else if (algo == "sha3-256") {
+    return EVP_sha3_256();
+  } else if (algo == "sha3-384") {
+    return EVP_sha3_384();
+  } else if (algo == "sha3-512") {
+    return EVP_sha3_512();
+  } else if (algo == "ripemd160" || algo == "ripemd-160") {
+    return EVP_ripemd160();
+  }
+  throw std::runtime_error("Unsupported hash algorithm: " + algorithm);
+}
+
+// Build an EVP_PKEY from EC curve name + public key octets + optional private key BIGNUM.
+// Uses OSSL_PARAM_BLD + EVP_PKEY_fromdata (OpenSSL 3.x, no deprecated EC_KEY APIs).
+// Caller owns the returned EVP_PKEY*.
+EVP_PKEY* createEcEvpPkey(const char* group_name, const uint8_t* pub_oct, size_t pub_len, const BIGNUM* priv_bn = nullptr);
+
+} // namespace margelo::nitro::crypto