@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/cpp/ec/HybridEcKeyPair.hpp

@@ -0,0 +1,45 @@
+#include <memory>
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/obj_mac.h>
+#include <string>
+
+#include "HybridEcKeyPairSpec.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridEcKeyPair : public HybridEcKeyPairSpec {
+ public:
+  HybridEcKeyPair() : HybridObject(TAG) {}
+  ~HybridEcKeyPair() override = default;
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<void>> generateKeyPair() override;
+  void generateKeyPairSync() 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;
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+
+  void setCurve(const std::string& curve) override;
+  std::shared_ptr<ArrayBuffer> sign(const std::shared_ptr<ArrayBuffer>& data, const std::string& hashAlgorithm) override;
+  bool verify(const std::shared_ptr<ArrayBuffer>& data, const std::shared_ptr<ArrayBuffer>& signature,
+              const std::string& hashAlgorithm) override;
+  std::vector<std::string> getSupportedCurves() override;
+
+ protected:
+  void checkKeyPair();
+
+ private:
+  std::string curve;
+  using EVP_PKEY_ptr = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>;
+  EVP_PKEY_ptr pkey_{nullptr, EVP_PKEY_free};
+
+  static int GetCurveFromName(const char* name);
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/ecdh/HybridECDH.cpp

@@ -0,0 +1,251 @@
+#include "HybridECDH.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <openssl/bn.h>
+#include <openssl/core_names.h>
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/obj_mac.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+// Smart pointer type aliases for RAII
+using EVP_PKEY_CTX_ptr = std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)>;
+using EC_POINT_ptr = std::unique_ptr<EC_POINT, decltype(&EC_POINT_free)>;
+using BN_ptr = std::unique_ptr<BIGNUM, decltype(&BN_free)>;
+
+void HybridECDH::init(const std::string& curveName) {
+  int nid = getCurveNid(curveName);
+  if (nid == NID_undef) {
+    throw std::runtime_error("ECDH: unknown curve name: " + curveName);
+  }
+
+  EC_GROUP_ptr group(EC_GROUP_new_by_curve_name(nid), EC_GROUP_free);
+  if (!group) {
+    throw std::runtime_error("ECDH: failed to create EC group for curve: " + curveName);
+  }
+
+  _curveName = curveName;
+  _curveNid = nid;
+  _group = std::move(group);
+  _pkey.reset();
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::generateKeys() {
+  ensureInitialized();
+
+  EVP_PKEY_CTX_ptr ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_EC, nullptr), EVP_PKEY_CTX_free);
+  if (!ctx) {
+    throw std::runtime_error("ECDH: failed to create keygen context");
+  }
+
+  if (EVP_PKEY_keygen_init(ctx.get()) <= 0) {
+    throw std::runtime_error("ECDH: failed to initialize key generation");
+  }
+
+  if (EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx.get(), _curveNid) <= 0) {
+    throw std::runtime_error("ECDH: failed to set curve");
+  }
+
+  EVP_PKEY* pkey = nullptr;
+  if (EVP_PKEY_keygen(ctx.get(), &pkey) <= 0) {
+    throw std::runtime_error("ECDH: failed to generate key pair");
+  }
+
+  _pkey.reset(pkey);
+
+  return getPublicKey();
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::computeSecret(const std::shared_ptr<ArrayBuffer>& otherPublicKey) {
+  ensureInitialized();
+  if (!_pkey) {
+    throw std::runtime_error("ECDH: private key not set");
+  }
+
+  // Validate the peer's public key BEFORE building an EVP_PKEY from it.
+  // EVP_PKEY_fromdata() does NOT verify that the supplied public-key octets
+  // decode to a point on the configured curve, so an attacker can mount an
+  // invalid-curve attack: send a point on a related, weaker curve (or a
+  // small-order point) and recover bits of our private key from the
+  // resulting "shared secret". Reject malformed encodings, the identity
+  // point, and any point that is not on _group up front.
+  {
+    EC_POINT_ptr peerPoint(EC_POINT_new(_group.get()), EC_POINT_free);
+    if (!peerPoint) {
+      throw std::runtime_error("ECDH: failed to allocate EC_POINT for peer key validation");
+    }
+    if (EC_POINT_oct2point(_group.get(), peerPoint.get(), otherPublicKey->data(), otherPublicKey->size(), nullptr) != 1) {
+      throw std::runtime_error("ECDH: peer public key is malformed");
+    }
+    if (EC_POINT_is_at_infinity(_group.get(), peerPoint.get())) {
+      throw std::runtime_error("ECDH: peer public key is the identity point");
+    }
+    if (EC_POINT_is_on_curve(_group.get(), peerPoint.get(), nullptr) != 1) {
+      throw std::runtime_error("ECDH: peer public key is not on the configured curve");
+    }
+  }
+
+  // Build peer EVP_PKEY from raw public key octets
+  EVP_PKEY_ptr peerPkey(createEcEvpPkey(_curveName.c_str(), otherPublicKey->data(), otherPublicKey->size()), EVP_PKEY_free);
+
+  // Derive shared secret using EVP API
+  EVP_PKEY_CTX_ptr ctx(EVP_PKEY_CTX_new(_pkey.get(), nullptr), EVP_PKEY_CTX_free);
+  if (!ctx) {
+    throw std::runtime_error("ECDH: failed to create derive context");
+  }
+
+  if (EVP_PKEY_derive_init(ctx.get()) <= 0) {
+    throw std::runtime_error("ECDH: failed to initialize key derivation");
+  }
+
+  if (EVP_PKEY_derive_set_peer(ctx.get(), peerPkey.get()) <= 0) {
+    throw std::runtime_error("ECDH: failed to set peer key for derivation");
+  }
+
+  // Get required buffer size
+  size_t secretLen = 0;
+  if (EVP_PKEY_derive(ctx.get(), nullptr, &secretLen) <= 0) {
+    throw std::runtime_error("ECDH: failed to get shared secret length");
+  }
+
+  // Derive the shared secret
+  std::vector<uint8_t> secret(secretLen);
+  if (EVP_PKEY_derive(ctx.get(), secret.data(), &secretLen) <= 0) {
+    throw std::runtime_error("ECDH: failed to derive shared secret");
+  }
+
+  secret.resize(secretLen);
+
+  return ToNativeArrayBuffer(secret);
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::getPrivateKey() {
+  if (!_pkey) {
+    throw std::runtime_error("ECDH: no key set");
+  }
+
+  BIGNUM* priv = nullptr;
+  if (EVP_PKEY_get_bn_param(_pkey.get(), OSSL_PKEY_PARAM_PRIV_KEY, &priv) != 1 || !priv) {
+    throw std::runtime_error("ECDH: no private key available");
+  }
+
+  int len = BN_num_bytes(priv);
+  std::vector<uint8_t> buf(len);
+  BN_bn2bin(priv, buf.data());
+  BN_free(priv);
+
+  return ToNativeArrayBuffer(buf);
+}
+
+void HybridECDH::setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) {
+  ensureInitialized();
+
+  // Convert private key bytes to BIGNUM
+  BN_ptr privBn(BN_bin2bn(privateKey->data(), static_cast<int>(privateKey->size()), nullptr), BN_free);
+  if (!privBn) {
+    throw std::runtime_error("ECDH: failed to convert private key");
+  }
+
+  EC_POINT_ptr pubPoint(EC_POINT_new(_group.get()), EC_POINT_free);
+  if (!pubPoint) {
+    throw std::runtime_error("ECDH: failed to create EC point");
+  }
+
+  if (EC_POINT_mul(_group.get(), pubPoint.get(), privBn.get(), nullptr, nullptr, nullptr) != 1) {
+    throw std::runtime_error("ECDH: failed to compute public key from private key");
+  }
+
+  size_t pubLen = EC_POINT_point2oct(_group.get(), pubPoint.get(), POINT_CONVERSION_UNCOMPRESSED, nullptr, 0, nullptr);
+  if (pubLen == 0) {
+    throw std::runtime_error("ECDH: failed to get public key length");
+  }
+  std::vector<uint8_t> pubOct(pubLen);
+  if (EC_POINT_point2oct(_group.get(), pubPoint.get(), POINT_CONVERSION_UNCOMPRESSED, pubOct.data(), pubLen, nullptr) == 0) {
+    throw std::runtime_error("ECDH: failed to serialize public key");
+  }
+
+  // Build EVP_PKEY via OSSL_PARAM_BLD
+  _pkey.reset(createEcEvpPkey(_curveName.c_str(), pubOct.data(), pubOct.size(), privBn.get()));
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::getPublicKey() {
+  if (!_pkey) {
+    throw std::runtime_error("ECDH: no key set");
+  }
+
+  size_t len = 0;
+  if (EVP_PKEY_get_octet_string_param(_pkey.get(), OSSL_PKEY_PARAM_PUB_KEY, nullptr, 0, &len) != 1 || len == 0) {
+    throw std::runtime_error("ECDH: failed to get public key length");
+  }
+
+  std::vector<uint8_t> buf(len);
+  if (EVP_PKEY_get_octet_string_param(_pkey.get(), OSSL_PKEY_PARAM_PUB_KEY, buf.data(), buf.size(), &len) != 1) {
+    throw std::runtime_error("ECDH: failed to get public key");
+  }
+
+  return ToNativeArrayBuffer(buf);
+}
+
+void HybridECDH::setPublicKey(const std::shared_ptr<ArrayBuffer>& publicKey) {
+  ensureInitialized();
+
+  // Build EVP_PKEY directly from public key octets
+  _pkey.reset(createEcEvpPkey(_curveName.c_str(), publicKey->data(), publicKey->size()));
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::convertKey(const std::shared_ptr<ArrayBuffer>& key, const std::string& curve, double format) {
+  int nid = getCurveNid(curve);
+  if (nid == NID_undef) {
+    throw std::runtime_error("ECDH: unknown curve: " + curve);
+  }
+
+  EC_GROUP_ptr group(EC_GROUP_new_by_curve_name(nid), EC_GROUP_free);
+  if (!group) {
+    throw std::runtime_error("ECDH: failed to create EC group for curve: " + curve);
+  }
+
+  EC_POINT_ptr point(EC_POINT_new(group.get()), EC_POINT_free);
+  if (!point) {
+    throw std::runtime_error("ECDH: failed to create EC point");
+  }
+
+  if (EC_POINT_oct2point(group.get(), point.get(), key->data(), key->size(), nullptr) != 1) {
+    throw std::runtime_error("ECDH: failed to decode public key");
+  }
+
+  auto form = static_cast<point_conversion_form_t>(static_cast<int>(format));
+
+  size_t len = EC_POINT_point2oct(group.get(), point.get(), form, nullptr, 0, nullptr);
+  if (len == 0) {
+    throw std::runtime_error("ECDH: failed to get converted key length");
+  }
+
+  std::vector<uint8_t> buf(len);
+  if (EC_POINT_point2oct(group.get(), point.get(), form, buf.data(), len, nullptr) == 0) {
+    throw std::runtime_error("ECDH: failed to convert key");
+  }
+
+  return ToNativeArrayBuffer(buf);
+}
+
+void HybridECDH::ensureInitialized() const {
+  if (_curveNid == 0 || !_group) {
+    throw std::runtime_error("ECDH: not initialized");
+  }
+}
+
+int HybridECDH::getCurveNid(const std::string& name) {
+  int nid = OBJ_txt2nid(name.c_str());
+  if (nid == NID_undef) {
+    nid = OBJ_sn2nid(name.c_str());
+  }
+  if (nid == NID_undef) {
+    nid = OBJ_ln2nid(name.c_str());
+  }
+  return nid;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/ecdh/HybridECDH.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <memory>
+#include <openssl/ec.h>
+#include <openssl/evp.h>
+#include <string>
+#include <vector>
+
+#include "HybridECDHSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+using margelo::nitro::ArrayBuffer;
+
+using EVP_PKEY_ptr = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>;
+using EC_GROUP_ptr = std::unique_ptr<EC_GROUP, decltype(&EC_GROUP_free)>;
+
+class HybridECDH : public HybridECDHSpec {
+ public:
+  HybridECDH() : HybridObject("ECDH"), _pkey(nullptr, EVP_PKEY_free), _group(nullptr, EC_GROUP_free) {}
+  virtual ~HybridECDH() = default;
+
+  void init(const std::string& curveName) override;
+  std::shared_ptr<ArrayBuffer> generateKeys() override;
+  std::shared_ptr<ArrayBuffer> computeSecret(const std::shared_ptr<ArrayBuffer>& otherPublicKey) override;
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+  void setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) override;
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+  void setPublicKey(const std::shared_ptr<ArrayBuffer>& publicKey) override;
+  std::shared_ptr<ArrayBuffer> convertKey(const std::shared_ptr<ArrayBuffer>& key, const std::string& curve, double format) override;
+
+ private:
+  EVP_PKEY_ptr _pkey;
+  EC_GROUP_ptr _group;
+  std::string _curveName;
+  int _curveNid = 0;
+
+  void ensureInitialized() const;
+  static int getCurveNid(const std::string& name);
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/ed25519/HybridEdKeyPair.cpp

@@ -0,0 +1,360 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/bio.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <string>
+
+#include "HybridEdKeyPair.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<ArrayBuffer> HybridEdKeyPair::diffieHellman(const std::shared_ptr<ArrayBuffer>& privateKey,
+                                                            const std::shared_ptr<ArrayBuffer>& publicKey) {
+  using EVP_PKEY_CTX_ptr = std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)>;
+
+  // Determine key type from curve name
+  int keyType = EVP_PKEY_X25519;
+  if (this->curve == "x448" || this->curve == "X448") {
+    keyType = EVP_PKEY_X448;
+  }
+
+  // 1. Create EVP_PKEY for private key (our key)
+  EVP_PKEY_ptr pkey_priv(EVP_PKEY_new_raw_private_key(keyType, NULL, privateKey->data(), privateKey->size()), EVP_PKEY_free);
+  if (!pkey_priv) {
+    throw std::runtime_error("Failed to create private key: " + getOpenSSLError());
+  }
+
+  // 2. Create EVP_PKEY for public key (peer's key)
+  EVP_PKEY_ptr pkey_pub(EVP_PKEY_new_raw_public_key(keyType, NULL, publicKey->data(), publicKey->size()), EVP_PKEY_free);
+  if (!pkey_pub) {
+    throw std::runtime_error("Failed to create public key: " + getOpenSSLError());
+  }
+
+  // 3. Create the context for the key exchange
+  EVP_PKEY_CTX_ptr ctx(EVP_PKEY_CTX_new_from_pkey(NULL, pkey_priv.get(), NULL), EVP_PKEY_CTX_free);
+  if (!ctx) {
+    throw std::runtime_error("Failed to create key exchange context: " + getOpenSSLError());
+  }
+
+  // 4. Initialize the context
+  if (EVP_PKEY_derive_init(ctx.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize key exchange: " + getOpenSSLError());
+  }
+
+  // 5. Provide the peer's public key
+  if (EVP_PKEY_derive_set_peer(ctx.get(), pkey_pub.get()) <= 0) {
+    throw std::runtime_error("Failed to set peer key: " + getOpenSSLError());
+  }
+
+  // 6. Determine the size of the shared secret
+  size_t shared_secret_len;
+  if (EVP_PKEY_derive(ctx.get(), NULL, &shared_secret_len) <= 0) {
+    throw std::runtime_error("Failed to determine shared secret length: " + getOpenSSLError());
+  }
+
+  // 7. Allocate memory for the shared secret
+  auto shared_secret = std::make_unique<uint8_t[]>(shared_secret_len);
+
+  // 8. Derive the shared secret
+  if (EVP_PKEY_derive(ctx.get(), shared_secret.get(), &shared_secret_len) <= 0) {
+    throw std::runtime_error("Failed to derive shared secret: " + getOpenSSLError());
+  }
+
+  // 9. Return a newly-created ArrayBuffer from the raw buffer w/ cleanup
+  uint8_t* raw_ptr = shared_secret.get();
+  return std::make_shared<NativeArrayBuffer>(shared_secret.release(), shared_secret_len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<Promise<void>> HybridEdKeyPair::generateKeyPair(double publicFormat, double publicType, double privateFormat,
+                                                                double privateType, const std::optional<std::string>& cipher,
+                                                                const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
+  // get owned NativeArrayBuffers before passing to sync function
+  std::optional<std::shared_ptr<ArrayBuffer>> nativePassphrase = std::nullopt;
+  if (passphrase.has_value()) {
+    nativePassphrase = ToNativeArrayBuffer(passphrase.value());
+  }
+
+  return Promise<void>::async([this, publicFormat, publicType, privateFormat, privateType, cipher, nativePassphrase]() {
+    this->generateKeyPairSync(publicFormat, publicType, privateFormat, privateType, cipher, nativePassphrase);
+  });
+}
+
+void HybridEdKeyPair::generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType,
+                                          const std::optional<std::string>& cipher,
+                                          const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
+  // Clear any previous OpenSSL errors to prevent pollution
+  clearOpenSSLErrors();
+
+  if (this->curve.empty()) {
+    throw std::runtime_error("EC curve not set. Call setCurve() first.");
+  }
+
+  // Store encoding configuration for later use in getPublicKey/getPrivateKey
+  this->publicFormat_ = static_cast<int>(publicFormat);
+  this->publicType_ = static_cast<int>(publicType);
+  this->privateFormat_ = static_cast<int>(privateFormat);
+  this->privateType_ = static_cast<int>(privateType);
+
+  // Clean up existing key if any
+  this->pkey_.reset();
+
+  std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)> pctx(EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr),
+                                                                   EVP_PKEY_CTX_free);
+  if (!pctx) {
+    throw std::runtime_error("Invalid curve name: " + this->curve);
+  }
+
+  // keygen init
+  if (EVP_PKEY_keygen_init(pctx.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize keygen");
+  }
+
+  // generate key
+  EVP_PKEY* raw_pkey = nullptr;
+  EVP_PKEY_keygen(pctx.get(), &raw_pkey);
+  if (raw_pkey == nullptr) {
+    throw std::runtime_error("Failed to generate key");
+  }
+  this->pkey_.reset(raw_pkey);
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridEdKeyPair::sign(const std::shared_ptr<ArrayBuffer>& message,
+                                                                             const std::optional<std::shared_ptr<ArrayBuffer>>& key) {
+  // get owned NativeArrayBuffer before passing to sync function
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeKey = std::nullopt;
+  if (key.has_value()) {
+    nativeKey = ToNativeArrayBuffer(key.value());
+  }
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+      [this, nativeMessage, nativeKey]() { return this->signSync(nativeMessage, nativeKey); });
+}
+
+std::shared_ptr<ArrayBuffer> HybridEdKeyPair::signSync(const std::shared_ptr<ArrayBuffer>& message,
+                                                       const std::optional<std::shared_ptr<ArrayBuffer>>& key) {
+  // Clear any previous OpenSSL errors to prevent pollution
+  clearOpenSSLErrors();
+
+  // get key to use for signing
+  EVP_PKEY_ptr pkey = this->importPrivateKey(key);
+
+  // key context
+  std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)> md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
+  if (!md_ctx) {
+    throw std::runtime_error("Error creating signing context");
+  }
+
+  if (EVP_DigestSignInit(md_ctx.get(), nullptr, NULL, NULL, pkey.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize signing: " + getOpenSSLError());
+  }
+
+  // Calculate the required size for the signature by passing a NULL buffer.
+  size_t sig_len = 0;
+  if (EVP_DigestSign(md_ctx.get(), NULL, &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    throw std::runtime_error("Failed to calculate signature size");
+  }
+  auto sig = std::make_unique<uint8_t[]>(sig_len);
+
+  // Actually calculate the signature
+  if (EVP_DigestSign(md_ctx.get(), sig.get(), &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    throw std::runtime_error("Failed to calculate signature");
+  }
+
+  // return value for JS
+  uint8_t* raw_ptr = sig.get();
+  return std::make_shared<NativeArrayBuffer>(sig.release(), sig_len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<Promise<bool>> HybridEdKeyPair::verify(const std::shared_ptr<ArrayBuffer>& signature,
+                                                       const std::shared_ptr<ArrayBuffer>& message,
+                                                       const std::optional<std::shared_ptr<ArrayBuffer>>& key) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativeSignature = ToNativeArrayBuffer(signature);
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeKey = std::nullopt;
+  if (key.has_value()) {
+    nativeKey = ToNativeArrayBuffer(key.value());
+  }
+
+  return Promise<bool>::async(
+      [this, nativeSignature, nativeMessage, nativeKey]() { return this->verifySync(nativeSignature, nativeMessage, nativeKey); });
+}
+
+bool HybridEdKeyPair::verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message,
+                                 const std::optional<std::shared_ptr<ArrayBuffer>>& key) {
+  // Clear any previous OpenSSL errors to prevent pollution
+  clearOpenSSLErrors();
+
+  // get key to use for verifying
+  EVP_PKEY_ptr pkey = this->importPublicKey(key);
+
+  // key context
+  std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)> md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
+  if (!md_ctx) {
+    throw std::runtime_error("Error creating verify context");
+  }
+
+  if (EVP_DigestVerifyInit(md_ctx.get(), nullptr, NULL, NULL, pkey.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize verify: " + getOpenSSLError());
+  }
+
+  // verify
+  auto res = EVP_DigestVerify(md_ctx.get(), signature.get()->data(), signature.get()->size(), message.get()->data(), message.get()->size());
+
+  // return value for JS
+  if (res < 0) {
+    throw std::runtime_error("Failed to verify");
+  }
+  return res == 1; // true if 1, false if 0
+}
+
+std::shared_ptr<ArrayBuffer> HybridEdKeyPair::getPublicKey() {
+  this->checkKeyPair();
+
+  // If format is DER (0) or PEM (1), export in SPKI format
+  if (publicFormat_ == 0 || publicFormat_ == 1) {
+    std::unique_ptr<BIO, decltype(&BIO_free)> bio(BIO_new(BIO_s_mem()), BIO_free);
+    if (!bio) {
+      throw std::runtime_error("Failed to create BIO for public key export");
+    }
+
+    int result;
+    if (publicFormat_ == 1) {
+      // PEM format
+      result = PEM_write_bio_PUBKEY(bio.get(), this->pkey_.get());
+    } else {
+      // DER format
+      result = i2d_PUBKEY_bio(bio.get(), this->pkey_.get());
+    }
+
+    if (result != 1) {
+      throw std::runtime_error("Failed to export public key");
+    }
+
+    BUF_MEM* bptr;
+    BIO_get_mem_ptr(bio.get(), &bptr);
+
+    auto data = std::make_unique<uint8_t[]>(bptr->length);
+    memcpy(data.get(), bptr->data, bptr->length);
+    size_t len = bptr->length;
+
+    uint8_t* raw_ptr = data.get();
+    return std::make_shared<NativeArrayBuffer>(data.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+  }
+
+  // Default: raw format
+  size_t len = 0;
+  EVP_PKEY_get_raw_public_key(this->pkey_.get(), nullptr, &len);
+  auto publ = std::make_unique<uint8_t[]>(len);
+  EVP_PKEY_get_raw_public_key(this->pkey_.get(), publ.get(), &len);
+
+  uint8_t* raw_ptr = publ.get();
+  return std::make_shared<NativeArrayBuffer>(publ.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<ArrayBuffer> HybridEdKeyPair::getPrivateKey() {
+  this->checkKeyPair();
+
+  // If format is DER (0) or PEM (1), export in PKCS8 format
+  if (privateFormat_ == 0 || privateFormat_ == 1) {
+    std::unique_ptr<BIO, decltype(&BIO_free)> bio(BIO_new(BIO_s_mem()), BIO_free);
+    if (!bio) {
+      throw std::runtime_error("Failed to create BIO for private key export");
+    }
+
+    int result;
+    if (privateFormat_ == 1) {
+      // PEM format (PKCS8)
+      result = PEM_write_bio_PrivateKey(bio.get(), this->pkey_.get(), nullptr, nullptr, 0, nullptr, nullptr);
+    } else {
+      // DER format (PKCS8)
+      result = i2d_PrivateKey_bio(bio.get(), this->pkey_.get());
+    }
+
+    if (result != 1) {
+      throw std::runtime_error("Failed to export private key");
+    }
+
+    BUF_MEM* bptr;
+    BIO_get_mem_ptr(bio.get(), &bptr);
+
+    auto data = std::make_unique<uint8_t[]>(bptr->length);
+    memcpy(data.get(), bptr->data, bptr->length);
+    size_t len = bptr->length;
+
+    // Zero the BIO's internal buffer — it held private key bytes (PEM/DER PKCS8)
+    secureZero(bptr->data, bptr->length);
+
+    uint8_t* raw_ptr = data.get();
+    return std::make_shared<NativeArrayBuffer>(data.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+  }
+
+  // Default: raw format
+  size_t len = 0;
+  EVP_PKEY_get_raw_private_key(this->pkey_.get(), nullptr, &len);
+  auto priv = std::make_unique<uint8_t[]>(len);
+  EVP_PKEY_get_raw_private_key(this->pkey_.get(), priv.get(), &len);
+
+  uint8_t* raw_ptr = priv.get();
+  return std::make_shared<NativeArrayBuffer>(priv.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+void HybridEdKeyPair::checkKeyPair() {
+  if (!this->pkey_) {
+    throw std::runtime_error("Keypair not initialized");
+  }
+}
+
+void HybridEdKeyPair::setCurve(const std::string& curve) {
+  this->curve = curve;
+}
+
+auto HybridEdKeyPair::importPublicKey(const std::optional<std::shared_ptr<ArrayBuffer>>& key) -> EVP_PKEY_ptr {
+  if (key.has_value()) {
+    // Determine key type from curve name
+    int keyType = EVP_PKEY_ED25519;
+    if (this->curve == "ed448" || this->curve == "Ed448") {
+      keyType = EVP_PKEY_ED448;
+    } else if (this->curve == "x25519" || this->curve == "X25519") {
+      keyType = EVP_PKEY_X25519;
+    } else if (this->curve == "x448" || this->curve == "X448") {
+      keyType = EVP_PKEY_X448;
+    }
+
+    EVP_PKEY_ptr pkey(EVP_PKEY_new_raw_public_key(keyType, NULL, key.value()->data(), key.value()->size()), EVP_PKEY_free);
+    if (!pkey) {
+      throw std::runtime_error("Failed to read public key");
+    }
+    return pkey;
+  }
+  this->checkKeyPair();
+  EVP_PKEY_up_ref(this->pkey_.get());
+  return EVP_PKEY_ptr(this->pkey_.get(), EVP_PKEY_free);
+}
+
+auto HybridEdKeyPair::importPrivateKey(const std::optional<std::shared_ptr<ArrayBuffer>>& key) -> EVP_PKEY_ptr {
+  if (key.has_value()) {
+    // Determine key type from curve name
+    int keyType = EVP_PKEY_ED25519;
+    if (this->curve == "ed448" || this->curve == "Ed448") {
+      keyType = EVP_PKEY_ED448;
+    } else if (this->curve == "x25519" || this->curve == "X25519") {
+      keyType = EVP_PKEY_X25519;
+    } else if (this->curve == "x448" || this->curve == "X448") {
+      keyType = EVP_PKEY_X448;
+    }
+
+    EVP_PKEY_ptr pkey(EVP_PKEY_new_raw_private_key(keyType, NULL, key.value()->data(), key.value()->size()), EVP_PKEY_free);
+    if (!pkey) {
+      throw std::runtime_error("Failed to read private key");
+    }
+    return pkey;
+  }
+  this->checkKeyPair();
+  EVP_PKEY_up_ref(this->pkey_.get());
+  return EVP_PKEY_ptr(this->pkey_.get(), EVP_PKEY_free);
+}
+
+} // namespace margelo::nitro::crypto