react-native-quick-crypto 1.0.0-beta.8 → 1.0.0

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/sign/HybridSignHandle.cpp

@@ -0,0 +1,191 @@
+#include "HybridSignHandle.hpp"
+
+#include "../keys/HybridKeyObjectHandle.hpp"
+#include "SignUtils.hpp"
+#include "Utils.hpp"
+
+#include <cstring>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+
+namespace margelo::nitro::crypto {
+
+using margelo::nitro::NativeArrayBuffer;
+
+HybridSignHandle::~HybridSignHandle() {
+  if (md_ctx) {
+    EVP_MD_CTX_free(md_ctx);
+    md_ctx = nullptr;
+  }
+}
+
+void HybridSignHandle::init(const std::string& algorithm) {
+  algorithm_name = algorithm;
+  md = getDigestByName(algorithm);
+
+  md_ctx = EVP_MD_CTX_new();
+  if (!md_ctx) {
+    throw std::runtime_error("Failed to create message digest context");
+  }
+
+  if (EVP_DigestInit_ex(md_ctx, md, nullptr) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    md_ctx = nullptr;
+    throw std::runtime_error("Failed to initialize message digest");
+  }
+}
+
+void HybridSignHandle::update(const std::shared_ptr<ArrayBuffer>& data) {
+  if (!md_ctx) {
+    throw std::runtime_error("Sign not initialized");
+  }
+
+  auto native_data = ToNativeArrayBuffer(data);
+
+  // Accumulate raw data for potential one-shot signing (Ed25519/Ed448)
+  const uint8_t* ptr = reinterpret_cast<const uint8_t*>(native_data->data());
+  data_buffer.insert(data_buffer.end(), ptr, ptr + native_data->size());
+
+  if (EVP_DigestUpdate(md_ctx, native_data->data(), native_data->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 update digest: " + std::string(err_buf));
+  }
+}
+
+// Check if key type requires one-shot signing (Ed25519, Ed448)
+static bool isOneShotVariant(EVP_PKEY* pkey) {
+  int type = EVP_PKEY_id(pkey);
+  return type == EVP_PKEY_ED25519 || type == EVP_PKEY_ED448;
+}
+
+std::shared_ptr<ArrayBuffer> HybridSignHandle::sign(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                                    std::optional<double> padding, std::optional<double> saltLength,
+                                                    std::optional<double> dsaEncoding) {
+  if (!md_ctx) {
+    throw std::runtime_error("Sign not initialized");
+  }
+
+  auto keyHandleImpl = std::static_pointer_cast<HybridKeyObjectHandle>(keyHandle);
+  EVP_PKEY* pkey = keyHandleImpl->getKeyObjectData().GetAsymmetricKey().get();
+
+  if (!pkey) {
+    throw std::runtime_error("Invalid private key for signing");
+  }
+
+  size_t sig_len = 0;
+  std::unique_ptr<uint8_t[]> sig_buf;
+
+  // Ed25519/Ed448 require one-shot signing with EVP_DigestSign
+  if (isOneShotVariant(pkey)) {
+    // Create a new context for one-shot signing
+    EVP_MD_CTX* sign_ctx = EVP_MD_CTX_new();
+    if (!sign_ctx) {
+      throw std::runtime_error("Failed to create signing context");
+    }
+
+    // Initialize for one-shot signing (pass nullptr for md - Ed25519/Ed448 have built-in hash)
+    if (EVP_DigestSignInit(sign_ctx, nullptr, nullptr, nullptr, pkey) <= 0) {
+      EVP_MD_CTX_free(sign_ctx);
+      throw std::runtime_error("Failed to initialize Ed signing");
+    }
+
+    // Get the accumulated data from the digest context
+    // For Ed25519/Ed448, we need to pass the original data, not a digest
+    // Since we've been accumulating with DigestUpdate, we need to use the data buffer
+    // Unfortunately, EVP_MD_CTX doesn't expose the accumulated data directly
+    // 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);
+      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);
+      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];
+    unsigned int digest_len = 0;
+
+    if (EVP_DigestFinal_ex(md_ctx, digest, &digest_len) <= 0) {
+      throw std::runtime_error("Failed to finalize digest");
+    }
+
+    EVP_PKEY_CTX* pkey_ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+    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);
+      throw std::runtime_error("Failed to initialize signing");
+    }
+
+    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);
+        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);
+        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);
+      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);
+      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);
+      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;
+  if (dsa_enc == kSigEncP1363) {
+    unsigned int n = getBytesOfRS(pkey);
+    if (n > 0) {
+      auto p1363_buf = std::make_unique<uint8_t[]>(2 * n);
+      std::memset(p1363_buf.get(), 0, 2 * n);
+      if (convertSignatureToP1363(sig_buf.get(), sig_len, p1363_buf.get(), n)) {
+        uint8_t* raw_ptr = p1363_buf.get();
+        return std::make_shared<NativeArrayBuffer>(p1363_buf.release(), 2 * n, [raw_ptr]() { delete[] raw_ptr; });
+      }
+    }
+  }
+
+  uint8_t* raw_ptr = sig_buf.get();
+  return std::make_shared<NativeArrayBuffer>(sig_buf.release(), sig_len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/sign/HybridSignHandle.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridKeyObjectHandleSpec.hpp"
+#include "HybridSignHandleSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridSignHandle : public HybridSignHandleSpec {
+ public:
+  HybridSignHandle() : HybridObject(TAG) {}
+  ~HybridSignHandle();
+
+ public:
+  void init(const std::string& algorithm) override;
+  void update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> sign(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, std::optional<double> padding,
+                                    std::optional<double> saltLength, std::optional<double> dsaEncoding) override;
+
+ private:
+  EVP_MD_CTX* md_ctx = nullptr;
+  const EVP_MD* md = nullptr;
+  std::string algorithm_name;
+  // Buffer for accumulating data for one-shot signing (Ed25519/Ed448)
+  std::vector<uint8_t> data_buffer;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/sign/HybridVerifyHandle.cpp

@@ -0,0 +1,158 @@
+#include "HybridVerifyHandle.hpp"
+
+#include "../keys/HybridKeyObjectHandle.hpp"
+#include "SignUtils.hpp"
+#include "Utils.hpp"
+
+#include <cstring>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+
+namespace margelo::nitro::crypto {
+
+using margelo::nitro::NativeArrayBuffer;
+
+HybridVerifyHandle::~HybridVerifyHandle() {
+  if (md_ctx) {
+    EVP_MD_CTX_free(md_ctx);
+    md_ctx = nullptr;
+  }
+}
+
+void HybridVerifyHandle::init(const std::string& algorithm) {
+  algorithm_name = algorithm;
+  md = getDigestByName(algorithm);
+
+  md_ctx = EVP_MD_CTX_new();
+  if (!md_ctx) {
+    throw std::runtime_error("Failed to create message digest context");
+  }
+
+  if (EVP_DigestInit_ex(md_ctx, md, nullptr) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    md_ctx = nullptr;
+    throw std::runtime_error("Failed to initialize message digest");
+  }
+}
+
+void HybridVerifyHandle::update(const std::shared_ptr<ArrayBuffer>& data) {
+  if (!md_ctx) {
+    throw std::runtime_error("Verify not initialized");
+  }
+
+  auto native_data = ToNativeArrayBuffer(data);
+
+  // Accumulate raw data for potential one-shot verification (Ed25519/Ed448)
+  const uint8_t* ptr = reinterpret_cast<const uint8_t*>(native_data->data());
+  data_buffer.insert(data_buffer.end(), ptr, ptr + native_data->size());
+
+  if (EVP_DigestUpdate(md_ctx, native_data->data(), native_data->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 update digest: " + std::string(err_buf));
+  }
+}
+
+// Check if key type requires one-shot verification (Ed25519, Ed448)
+static bool isOneShotVariant(EVP_PKEY* pkey) {
+  int type = EVP_PKEY_id(pkey);
+  return type == EVP_PKEY_ED25519 || type == EVP_PKEY_ED448;
+}
+
+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) {
+  if (!md_ctx) {
+    throw std::runtime_error("Verify not initialized");
+  }
+
+  auto keyHandleImpl = std::static_pointer_cast<HybridKeyObjectHandle>(keyHandle);
+  EVP_PKEY* pkey = keyHandleImpl->getKeyObjectData().GetAsymmetricKey().get();
+
+  if (!pkey) {
+    throw std::runtime_error("Invalid public key for verification");
+  }
+
+  auto native_sig = ToNativeArrayBuffer(signature);
+  const unsigned char* sig_data = native_sig->data();
+  size_t sig_len = native_sig->size();
+
+  // Ed25519/Ed448 require one-shot verification with EVP_DigestVerify
+  if (isOneShotVariant(pkey)) {
+    EVP_MD_CTX* verify_ctx = EVP_MD_CTX_new();
+    if (!verify_ctx) {
+      throw std::runtime_error("Failed to create verification context");
+    }
+
+    // Initialize for one-shot verification (pass nullptr for md - Ed25519/Ed448 have built-in hash)
+    if (EVP_DigestVerifyInit(verify_ctx, nullptr, nullptr, nullptr, pkey) <= 0) {
+      EVP_MD_CTX_free(verify_ctx);
+      throw std::runtime_error("Failed to initialize Ed verification");
+    }
+
+    int result = EVP_DigestVerify(verify_ctx, sig_data, sig_len, data_buffer.data(), data_buffer.size());
+    EVP_MD_CTX_free(verify_ctx);
+    return result == 1;
+  }
+
+  // Standard verification flow for RSA/ECDSA
+  unsigned char digest[EVP_MAX_MD_SIZE];
+  unsigned int digest_len = 0;
+
+  if (EVP_DigestFinal_ex(md_ctx, digest, &digest_len) <= 0) {
+    throw std::runtime_error("Failed to finalize digest");
+  }
+
+  std::unique_ptr<uint8_t[]> der_sig_buf;
+  int dsa_enc = dsaEncoding.has_value() ? static_cast<int>(dsaEncoding.value()) : kSigEncDER;
+  if (dsa_enc == kSigEncP1363) {
+    unsigned int n = getBytesOfRS(pkey);
+    if (n > 0) {
+      size_t der_len = 0;
+      der_sig_buf = convertSignatureToDER(sig_data, sig_len, n, &der_len);
+      if (der_sig_buf) {
+        sig_data = der_sig_buf.get();
+        sig_len = der_len;
+      }
+    }
+  }
+
+  EVP_PKEY_CTX* pkey_ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+  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);
+    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);
+      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);
+      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);
+    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);
+
+  return result == 1;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/sign/HybridVerifyHandle.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridKeyObjectHandleSpec.hpp"
+#include "HybridVerifyHandleSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridVerifyHandle : public HybridVerifyHandleSpec {
+ public:
+  HybridVerifyHandle() : HybridObject(TAG) {}
+  ~HybridVerifyHandle();
+
+ public:
+  void init(const std::string& algorithm) override;
+  void update(const std::shared_ptr<ArrayBuffer>& data) override;
+  bool 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) override;
+
+ private:
+  EVP_MD_CTX* md_ctx = nullptr;
+  const EVP_MD* md = nullptr;
+  std::string algorithm_name;
+  // Buffer for accumulating data for one-shot verification (Ed25519/Ed448)
+  std::vector<uint8_t> data_buffer;
+};
+
+} // namespace margelo::nitro::crypto