react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.22

package/cpp/keys/HybridKeyObjectHandle.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "HybridKeyObjectHandleSpec.hpp"
+#include "JWK.hpp"
+#include "KeyDetail.hpp"
+#include "KeyObjectData.hpp"
+#include "KeyType.hpp"
+#include "NamedCurve.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec {
+ public:
+  HybridKeyObjectHandle() : HybridObject(TAG) {}
+
+ public:
+  std::shared_ptr<ArrayBuffer> exportKey(std::optional<KFormatType> format, std::optional<KeyEncoding> type,
+                                         const std::optional<std::string>& cipher,
+                                         const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
+  JWK exportJwk(const JWK& key, bool handleRsaPss) override;
+
+  AsymmetricKeyType getAsymmetricKeyType() override;
+
+  bool init(KeyType keyType, const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key, std::optional<KFormatType> format,
+            std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
+  bool initECRaw(const std::string& namedCurve, const std::shared_ptr<ArrayBuffer>& keyData) override;
+
+  std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) override;
+
+  KeyDetail keyDetail() override;
+
+  KeyObjectData& getKeyObjectData() {
+    return data_;
+  }
+  const KeyObjectData& getKeyObjectData() const {
+    return data_;
+  }
+
+ private:
+  KeyObjectData data_;
+
+  bool initRawKey(KeyType keyType, std::shared_ptr<ArrayBuffer> keyData);
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/keys/KeyObjectData.cpp

@@ -0,0 +1,226 @@
+#include "KeyObjectData.hpp"
+#include "Utils.hpp"
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+ncrypto::EVPKeyPointer::PrivateKeyEncodingConfig GetPrivateKeyEncodingConfig(KFormatType format, KeyEncoding type) {
+  auto pk_format = static_cast<ncrypto::EVPKeyPointer::PKFormatType>(format);
+  auto pk_type = static_cast<ncrypto::EVPKeyPointer::PKEncodingType>(type);
+
+  auto config = ncrypto::EVPKeyPointer::PrivateKeyEncodingConfig(false, pk_format, pk_type);
+  return config;
+}
+
+ncrypto::EVPKeyPointer::PublicKeyEncodingConfig GetPublicKeyEncodingConfig(KFormatType format, KeyEncoding type) {
+  auto pk_format = static_cast<ncrypto::EVPKeyPointer::PKFormatType>(format);
+  auto pk_type = static_cast<ncrypto::EVPKeyPointer::PKEncodingType>(type);
+
+  auto config = ncrypto::EVPKeyPointer::PublicKeyEncodingConfig(false, pk_format, pk_type);
+  return config;
+}
+
+KeyObjectData TryParsePrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format, std::optional<KeyEncoding> type,
+                                 const std::optional<std::shared_ptr<ArrayBuffer>>& /* passphrase */) {
+  auto config = GetPrivateKeyEncodingConfig(format.value(), type.value());
+  auto buffer = ncrypto::Buffer<const unsigned char>{key->data(), key->size()};
+  auto res = ncrypto::EVPKeyPointer::TryParsePrivateKey(config, buffer);
+  if (res) {
+    return KeyObjectData::CreateAsymmetric(KeyType::PRIVATE, std::move(res.value));
+  }
+
+  if (res.error.value() == ncrypto::EVPKeyPointer::PKParseError::NEED_PASSPHRASE) {
+    throw std::runtime_error("Passphrase required for encrypted key");
+  } else {
+    throw std::runtime_error("Failed to read private key");
+  }
+}
+
+KeyObjectData::KeyObjectData(std::nullptr_t) : key_type_(KeyType::SECRET) {}
+
+KeyObjectData::KeyObjectData(std::shared_ptr<ArrayBuffer> symmetric_key)
+    : key_type_(KeyType::SECRET), data_(std::make_shared<Data>(std::move(symmetric_key))) {}
+
+KeyObjectData::KeyObjectData(KeyType type, ncrypto::EVPKeyPointer&& pkey)
+    : key_type_(type), data_(std::make_shared<Data>(std::move(pkey))) {}
+
+KeyObjectData KeyObjectData::CreateSecret(std::shared_ptr<ArrayBuffer> key) {
+  return KeyObjectData(std::move(key));
+}
+
+KeyObjectData KeyObjectData::CreateAsymmetric(KeyType key_type, ncrypto::EVPKeyPointer&& pkey) {
+  CHECK(pkey);
+  return KeyObjectData(key_type, std::move(pkey));
+}
+
+KeyType KeyObjectData::GetKeyType() const {
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return key_type_;
+}
+
+const ncrypto::EVPKeyPointer& KeyObjectData::GetAsymmetricKey() const {
+  if (key_type_ == KeyType::SECRET) {
+    throw std::runtime_error("Cannot get asymmetric key from secret key object");
+  }
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return data_->asymmetric_key;
+}
+
+std::shared_ptr<ArrayBuffer> KeyObjectData::GetSymmetricKey() const {
+  if (key_type_ != KeyType::SECRET) {
+    throw std::runtime_error("Cannot get symmetric key from asymmetric key object");
+  }
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return data_->symmetric_key;
+}
+
+size_t KeyObjectData::GetSymmetricKeySize() const {
+  if (key_type_ != KeyType::SECRET) {
+    throw std::runtime_error("Cannot get symmetric key size from asymmetric key object");
+  }
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return data_->symmetric_key->size();
+}
+
+KeyObjectData KeyObjectData::GetPublicOrPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                                   std::optional<KeyEncoding> type,
+                                                   const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
+  // Check if key size fits in int32_t without using double conversion
+  if (key->size() > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
+    std::string error_msg = "key is too big (int32): size=" + std::to_string(key->size()) +
+                            ", max_int32=" + std::to_string(std::numeric_limits<int32_t>::max());
+    throw std::runtime_error(error_msg);
+  }
+
+  // If no format is specified, assume DER format for binary data
+  KFormatType actualFormat = format.has_value() ? format.value() : KFormatType::DER;
+
+  if (actualFormat == KFormatType::PEM || actualFormat == KFormatType::DER) {
+    auto buffer = ncrypto::Buffer<const unsigned char>{key->data(), key->size()};
+
+    if (actualFormat == KFormatType::PEM) {
+      // For PEM, we can easily determine whether it is a public or private key
+      // by looking for the respective PEM tags.
+      auto res = ncrypto::EVPKeyPointer::TryParsePublicKeyPEM(buffer);
+      if (res) {
+        return CreateAsymmetric(KeyType::PUBLIC, std::move(res.value));
+      }
+
+      if (res.error.has_value() && res.error.value() == ncrypto::EVPKeyPointer::PKParseError::NOT_RECOGNIZED) {
+        auto config = GetPrivateKeyEncodingConfig(actualFormat, type.value());
+        if (passphrase.has_value()) {
+          auto& passphrase_ptr = passphrase.value();
+          config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+        }
+
+        auto private_res = ncrypto::EVPKeyPointer::TryParsePrivateKey(config, buffer);
+        if (private_res) {
+          return CreateAsymmetric(KeyType::PRIVATE, std::move(private_res.value));
+        }
+      }
+      throw std::runtime_error("Failed to read PEM asymmetric key");
+    } else if (actualFormat == KFormatType::DER) {
+      // For DER, try parsing as public key first
+      if (type.has_value() && type.value() == KeyEncoding::SPKI) {
+        auto public_config = GetPublicKeyEncodingConfig(actualFormat, type.value());
+        auto res = ncrypto::EVPKeyPointer::TryParsePublicKey(public_config, buffer);
+        if (res) {
+          return CreateAsymmetric(KeyType::PUBLIC, std::move(res.value));
+        }
+      } else if (type.has_value() && type.value() == KeyEncoding::PKCS8) {
+        auto private_config = GetPrivateKeyEncodingConfig(actualFormat, type.value());
+        if (passphrase.has_value()) {
+          auto& passphrase_ptr = passphrase.value();
+          private_config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+        }
+        auto res = ncrypto::EVPKeyPointer::TryParsePrivateKey(private_config, buffer);
+        if (res) {
+          return CreateAsymmetric(KeyType::PRIVATE, std::move(res.value));
+        }
+      } else {
+        // If no encoding type specified, try both SPKI and PKCS8
+        auto public_config = GetPublicKeyEncodingConfig(actualFormat, KeyEncoding::SPKI);
+        auto public_res = ncrypto::EVPKeyPointer::TryParsePublicKey(public_config, buffer);
+        if (public_res) {
+          return CreateAsymmetric(KeyType::PUBLIC, std::move(public_res.value));
+        }
+
+        auto private_config = GetPrivateKeyEncodingConfig(actualFormat, KeyEncoding::PKCS8);
+        auto private_res = ncrypto::EVPKeyPointer::TryParsePrivateKey(private_config, buffer);
+        if (private_res) {
+          return CreateAsymmetric(KeyType::PRIVATE, std::move(private_res.value));
+        }
+      }
+      throw std::runtime_error("Failed to read DER asymmetric key");
+    }
+  }
+
+  throw std::runtime_error("Unsupported key format for GetPublicOrPrivateKey. Only PEM and DER are supported.");
+}
+
+KeyObjectData KeyObjectData::GetPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                           std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase,
+                                           bool /* isPublic */) {
+  // Check if key size fits in int32_t without using double conversion
+  if (key->size() > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
+    std::string error_msg = "key is too big (int32): size=" + std::to_string(key->size()) +
+                            ", max_int32=" + std::to_string(std::numeric_limits<int32_t>::max());
+    throw std::runtime_error(error_msg);
+  }
+
+  // If no format is specified, assume DER format for binary data
+  KFormatType actualFormat = format.has_value() ? format.value() : KFormatType::DER;
+
+  if (actualFormat == KFormatType::PEM || actualFormat == KFormatType::DER) {
+    auto buffer = ncrypto::Buffer<const unsigned char>{key->data(), key->size()};
+
+    if (actualFormat == KFormatType::PEM) {
+      return TryParsePrivateKey(key, format, type, passphrase);
+    } else if (actualFormat == KFormatType::DER) {
+      // Try the specified encoding first, or PKCS8 as default
+      KeyEncoding primaryEncoding = type.value_or(KeyEncoding::PKCS8);
+      auto private_config = GetPrivateKeyEncodingConfig(actualFormat, primaryEncoding);
+      if (passphrase.has_value()) {
+        auto& passphrase_ptr = passphrase.value();
+        private_config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+      }
+
+      // Clear any existing OpenSSL errors before parsing
+      ERR_clear_error();
+
+      auto res = ncrypto::EVPKeyPointer::TryParsePrivateKey(private_config, buffer);
+      if (res) {
+        return CreateAsymmetric(KeyType::PRIVATE, std::move(res.value));
+      }
+
+      // If no specific encoding was provided, try other encodings as fallback
+      if (!type.has_value()) {
+        std::vector<KeyEncoding> fallbackEncodings = {KeyEncoding::SEC1, KeyEncoding::PKCS1};
+        for (auto encoding : fallbackEncodings) {
+          auto config = GetPrivateKeyEncodingConfig(actualFormat, encoding);
+          if (passphrase.has_value()) {
+            auto& passphrase_ptr = passphrase.value();
+            config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+          }
+          auto fallback_res = ncrypto::EVPKeyPointer::TryParsePrivateKey(config, buffer);
+          if (fallback_res) {
+            return CreateAsymmetric(KeyType::PRIVATE, std::move(fallback_res.value));
+          }
+        }
+      }
+      throw std::runtime_error("Failed to read DER private key");
+    }
+  }
+
+  throw std::runtime_error("Unsupported key format for GetPrivateKey. Only PEM and DER are supported.");
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/keys/KeyObjectData.hpp

@@ -0,0 +1,71 @@
+#include <memory>
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+#include "../../deps/ncrypto/ncrypto.h"
+#include "KFormatType.hpp"
+#include "KeyEncoding.hpp"
+#include "KeyType.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+class KeyObjectData final {
+ public:
+  static KeyObjectData CreateSecret(std::shared_ptr<ArrayBuffer> key);
+
+  static KeyObjectData CreateAsymmetric(KeyType type, ncrypto::EVPKeyPointer&& pkey);
+
+  KeyObjectData(std::nullptr_t = nullptr);
+
+  inline operator bool() const {
+    return data_ != nullptr;
+  }
+
+  KeyType GetKeyType() const;
+
+  // These functions allow unprotected access to the raw key material and should
+  // only be used to implement cryptographic operations requiring the key.
+  const ncrypto::EVPKeyPointer& GetAsymmetricKey() const;
+  std::shared_ptr<ArrayBuffer> GetSymmetricKey() const;
+  size_t GetSymmetricKeySize() const;
+
+  static KeyObjectData GetPublicOrPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                             std::optional<KeyEncoding> type,
+                                             const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase);
+
+  static KeyObjectData GetPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format, std::optional<KeyEncoding> type,
+                                     const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase, bool isPublic);
+
+  inline KeyObjectData addRef() const {
+    return KeyObjectData(key_type_, data_);
+  }
+
+  inline KeyObjectData addRefWithType(KeyType type) const {
+    return KeyObjectData(type, data_);
+  }
+
+ private:
+  explicit KeyObjectData(std::shared_ptr<ArrayBuffer> symmetric_key);
+  explicit KeyObjectData(KeyType type, ncrypto::EVPKeyPointer&& pkey);
+
+  //   static KeyObjectData GetParsedKey(KeyType type,
+  //     Environment* env,
+  //     ncrypto::EVPKeyPointer&& pkey,
+  //     ParseKeyResult ret,
+  //     const char* default_msg);
+
+  KeyType key_type_;
+
+  struct Data {
+    const std::shared_ptr<ArrayBuffer> symmetric_key;
+    const ncrypto::EVPKeyPointer asymmetric_key;
+    explicit Data(std::shared_ptr<ArrayBuffer> symmetric_key) : symmetric_key(std::move(symmetric_key)) {}
+    explicit Data(ncrypto::EVPKeyPointer asymmetric_key) : asymmetric_key(std::move(asymmetric_key)) {}
+  };
+  std::shared_ptr<Data> data_;
+
+  KeyObjectData(KeyType type, std::shared_ptr<Data> data) : key_type_(type), data_(data) {}
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/keys/node.h

@@ -0,0 +1,5 @@
+#pragma once
+
+// BINARY is a deprecated alias of LATIN1.
+// BASE64URL is not currently exposed to the JavaScript side.
+enum encoding { ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER, BASE64URL, LATIN1 = BINARY };

package/cpp/rsa/HybridRsaKeyPair.cpp

@@ -0,0 +1,154 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <openssl/bio.h>
+#include <openssl/buffer.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <stdexcept>
+#include <string>
+
+#include "HybridRsaKeyPair.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<void>> HybridRsaKeyPair::generateKeyPair() {
+  return Promise<void>::async([this]() { this->generateKeyPairSync(); });
+}
+
+void HybridRsaKeyPair::generateKeyPairSync() {
+  // Clean up existing key if any
+  if (this->pkey != nullptr) {
+    EVP_PKEY_free(this->pkey);
+    this->pkey = nullptr;
+  }
+
+  // Create key generation context
+  std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)> ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, nullptr), EVP_PKEY_CTX_free);
+
+  if (!ctx) {
+    throw std::runtime_error("Failed to create RSA key generation context");
+  }
+
+  if (EVP_PKEY_keygen_init(ctx.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize RSA key generation");
+  }
+
+  // Set modulus length
+  if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx.get(), this->modulusLength) <= 0) {
+    throw std::runtime_error("Failed to set RSA modulus length");
+  }
+
+  // Set public exponent
+  std::unique_ptr<BIGNUM, decltype(&BN_free)> exponent(BN_new(), BN_free);
+  if (!exponent) {
+    throw std::runtime_error("Failed to create BIGNUM for public exponent");
+  }
+
+  // Default to 65537 (0x10001) if no public exponent is set
+  if (this->publicExponent.empty()) {
+    if (BN_set_word(exponent.get(), RSA_F4) != 1) {
+      throw std::runtime_error("Failed to set default public exponent");
+    }
+  } else {
+    if (BN_bin2bn(this->publicExponent.data(), this->publicExponent.size(), exponent.get()) == nullptr) {
+      throw std::runtime_error("Failed to convert public exponent to BIGNUM");
+    }
+  }
+
+  if (EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx.get(), exponent.get()) <= 0) {
+    throw std::runtime_error("Failed to set RSA public exponent");
+  }
+
+  // Generate the key pair
+  EVP_PKEY* raw_pkey = nullptr;
+  if (EVP_PKEY_keygen(ctx.get(), &raw_pkey) <= 0) {
+    throw std::runtime_error("Failed to generate RSA key pair");
+  }
+
+  this->pkey = raw_pkey;
+}
+
+void HybridRsaKeyPair::setModulusLength(double modulusLength) {
+  this->modulusLength = static_cast<int>(modulusLength);
+}
+
+void HybridRsaKeyPair::setPublicExponent(const std::shared_ptr<ArrayBuffer>& publicExponent) {
+  if (publicExponent && publicExponent->size() > 0) {
+    const uint8_t* data = publicExponent->data();
+    this->publicExponent.assign(data, data + publicExponent->size());
+  }
+}
+
+void HybridRsaKeyPair::setHashAlgorithm(const std::string& hashAlgorithm) {
+  this->hashAlgorithm = hashAlgorithm;
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaKeyPair::getPublicKey() {
+  this->checkKeyPair();
+
+  // Export as DER format using direct OpenSSL calls
+  BIO* bio = BIO_new(BIO_s_mem());
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for public key export");
+  }
+
+  if (i2d_PUBKEY_bio(bio, this->pkey) != 1) {
+    BIO_free(bio);
+    throw std::runtime_error("Failed to export public key to DER format");
+  }
+
+  BUF_MEM* mem;
+  BIO_get_mem_ptr(bio, &mem);
+
+  // Create a string from the DER data and use ToNativeArrayBuffer utility
+  std::string derData(mem->data, mem->length);
+  BIO_free(bio);
+
+  return ToNativeArrayBuffer(derData);
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaKeyPair::getPrivateKey() {
+  this->checkKeyPair();
+
+  // Export as DER format in PKCS8 format using direct OpenSSL calls
+  BIO* bio = BIO_new(BIO_s_mem());
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for private key export");
+  }
+
+  if (i2d_PKCS8PrivateKey_bio(bio, this->pkey, nullptr, nullptr, 0, nullptr, nullptr) != 1) {
+    BIO_free(bio);
+    throw std::runtime_error("Failed to export private key to DER PKCS8 format");
+  }
+
+  BUF_MEM* mem;
+  BIO_get_mem_ptr(bio, &mem);
+
+  // Create a string from the DER data and use ToNativeArrayBuffer utility
+  std::string derData(mem->data, mem->length);
+  BIO_free(bio);
+
+  return ToNativeArrayBuffer(derData);
+}
+
+KeyObject HybridRsaKeyPair::importKey(const std::string& /* format */, const std::shared_ptr<ArrayBuffer>& /* keyData */,
+                                      const std::string& /* algorithm */, bool /* extractable */,
+                                      const std::vector<std::string>& /* keyUsages */) {
+  throw std::runtime_error("HybridRsaKeyPair::importKey() is not yet implemented");
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaKeyPair::exportKey(const KeyObject& /* key */, const std::string& /* format */) {
+  throw std::runtime_error("HybridRsaKeyPair::exportKey() is not yet implemented");
+}
+
+void HybridRsaKeyPair::checkKeyPair() {
+  if (this->pkey == nullptr) {
+    throw std::runtime_error("RSA KeyPair not initialized");
+  }
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/rsa/HybridRsaKeyPair.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "HybridRsaKeyPairSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+class HybridRsaKeyPair : public HybridRsaKeyPairSpec {
+ public:
+  HybridRsaKeyPair() : HybridObject(TAG), pkey(nullptr), modulusLength(2048), hashAlgorithm("SHA-256") {}
+  ~HybridRsaKeyPair() {
+    if (pkey) {
+      EVP_PKEY_free(pkey);
+    }
+  }
+
+  std::shared_ptr<Promise<void>> generateKeyPair() override;
+  void generateKeyPairSync() override;
+  void setModulusLength(double modulusLength) override;
+  void setPublicExponent(const std::shared_ptr<ArrayBuffer>& publicExponent) override;
+  void setHashAlgorithm(const std::string& hashAlgorithm) override;
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+  KeyObject importKey(const std::string& format, const std::shared_ptr<ArrayBuffer>& keyData, const std::string& algorithm,
+                      bool extractable, const std::vector<std::string>& keyUsages) override;
+  std::shared_ptr<ArrayBuffer> exportKey(const KeyObject& key, const std::string& format) override;
+
+ private:
+  EVP_PKEY* pkey;
+  int modulusLength;
+  std::vector<unsigned char> publicExponent;
+  std::string hashAlgorithm;
+
+  void checkKeyPair();
+};
+
+} // namespace margelo::nitro::crypto

package/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/cpp/utils/Utils.hpp

@@ -3,12 +3,32 @@
 #include <algorithm>
 #include <cctype>
 #include <limits>
+#include <openssl/err.h>
 #include <string>
 
+#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();
@@ -17,6 +37,13 @@ inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(co
   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 bool CheckIsUint32(double value) {
   return (value >= std::numeric_limits<uint32_t>::lowest() && value <= std::numeric_limits<uint32_t>::max());
 }