react-native-quick-crypto 1.0.11 → 1.0.12

package/android/CMakeLists.txt

@@ -47,9 +47,11 @@ add_library(
   ../cpp/hash/HybridHash.cpp
   ../cpp/hmac/HybridHmac.cpp
   ../cpp/hkdf/HybridHkdf.cpp
+  ../cpp/kmac/HybridKmac.cpp
   ../cpp/keys/HybridKeyObjectHandle.cpp
   ../cpp/keys/KeyObjectData.cpp
   ../cpp/mldsa/HybridMlDsaKeyPair.cpp
+  ../cpp/mlkem/HybridMlKemKeyPair.cpp
   ../cpp/pbkdf2/HybridPbkdf2.cpp
   ../cpp/prime/HybridPrime.cpp
   ../cpp/random/HybridRandom.cpp
@@ -57,7 +59,9 @@ add_library(
   ../cpp/scrypt/HybridScrypt.cpp
   ../cpp/sign/HybridSignHandle.cpp
   ../cpp/sign/HybridVerifyHandle.cpp
+  ../cpp/x509/HybridX509Certificate.cpp
   ../cpp/utils/HybridUtils.cpp
+  ../cpp/utils/QuickCryptoUtils.cpp
   ${BLAKE3_SOURCES}
   ../deps/fastpbkdf2/fastpbkdf2.c
   ../deps/ncrypto/src/aead.cpp
@@ -83,8 +87,10 @@ include_directories(
   "../cpp/hash"
   "../cpp/hkdf"
   "../cpp/hmac"
+  "../cpp/kmac"
   "../cpp/keys"
   "../cpp/mldsa"
+  "../cpp/mlkem"
   "../cpp/pbkdf2"
   "../cpp/prime"
   "../cpp/random"
@@ -92,6 +98,7 @@ include_directories(
   "../cpp/sign"
   "../cpp/scrypt"
   "../cpp/utils"
+  "../cpp/x509"
   "../deps/blake3/c"
   "../deps/fastpbkdf2"
   "../deps/ncrypto/include"

package/cpp/cipher/CCMCipher.cpp

@@ -54,6 +54,7 @@ void CCMCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::s
 
 std::shared_ptr<ArrayBuffer> CCMCipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   checkCtx();
+  checkNotFinalized();
   auto native_data = ToNativeArrayBuffer(data);
   size_t in_len = native_data->size();
   if (in_len < 0 || in_len > INT_MAX) {
@@ -104,10 +105,11 @@ std::shared_ptr<ArrayBuffer> CCMCipher::update(const std::shared_ptr<ArrayBuffer
 
 std::shared_ptr<ArrayBuffer> CCMCipher::final() {
   checkCtx();
+  checkNotFinalized();
 
   // CCM decryption does not use final. Verification happens in the last update call.
   if (!is_cipher) {
-    // Return an empty buffer, matching Node.js behavior
+    is_finalized = true;
     unsigned char* empty_output = new unsigned char[0];
     return std::make_shared<NativeArrayBuffer>(empty_output, 0, [=]() { delete[] empty_output; });
   }
@@ -138,6 +140,7 @@ std::shared_ptr<ArrayBuffer> CCMCipher::final() {
     throw std::runtime_error("Failed to get auth tag after finalization: " + std::string(err_buf));
   }
   auth_tag_state = kAuthTagKnown;
+  is_finalized = true;
 
   unsigned char* final_output = out_buf.release();
   return std::make_shared<NativeArrayBuffer>(final_output, out_len, [=]() { delete[] final_output; });

package/cpp/cipher/ChaCha20Cipher.cpp

@@ -64,6 +64,7 @@ void ChaCha20Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const s
 
 std::shared_ptr<ArrayBuffer> ChaCha20Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   checkCtx();
+  checkNotFinalized();
   auto native_data = ToNativeArrayBuffer(data);
   size_t in_len = native_data->size();
   if (in_len > INT_MAX) {
@@ -89,7 +90,8 @@ std::shared_ptr<ArrayBuffer> ChaCha20Cipher::update(const std::shared_ptr<ArrayB
 
 std::shared_ptr<ArrayBuffer> ChaCha20Cipher::final() {
   checkCtx();
-  // For ChaCha20, final() should return an empty buffer since it's a stream cipher
+  checkNotFinalized();
+  is_finalized = true;
   unsigned char* empty_output = new unsigned char[0];
   return std::make_shared<NativeArrayBuffer>(empty_output, 0, [=]() { delete[] empty_output; });
 }

package/cpp/cipher/ChaCha20Poly1305Cipher.cpp

@@ -60,13 +60,12 @@ void ChaCha20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key,
     ctx = nullptr;
     throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to set key/IV: " + std::string(err_buf));
   }
-
-  // Reset final_called flag
-  final_called = false;
+  is_finalized = false;
 }
 
 std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   checkCtx();
+  checkNotFinalized();
   auto native_data = ToNativeArrayBuffer(data);
   size_t in_len = native_data->size();
   if (in_len > INT_MAX) {
@@ -92,6 +91,7 @@ std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::update(const std::shared_pt
 
 std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::final() {
   checkCtx();
+  checkNotFinalized();
 
   // For ChaCha20-Poly1305, we need to call final to generate the tag
   int out_len = 0;
@@ -105,7 +105,7 @@ std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::final() {
     throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to finalize: " + std::string(err_buf));
   }
 
-  final_called = true;
+  is_finalized = true;
   return std::make_shared<NativeArrayBuffer>(out, out_len, [=]() { delete[] out; });
 }
 
@@ -130,7 +130,7 @@ std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::getAuthTag() {
   if (!is_cipher) {
     throw std::runtime_error("getAuthTag can only be called during encryption");
   }
-  if (!final_called) {
+  if (!is_finalized) {
     throw std::runtime_error("getAuthTag must be called after final()");
   }
 

package/cpp/cipher/ChaCha20Poly1305Cipher.hpp

@@ -6,7 +6,7 @@ namespace margelo::nitro::crypto {
 
 class ChaCha20Poly1305Cipher : public HybridCipher {
  public:
-  ChaCha20Poly1305Cipher() : HybridObject(TAG), final_called(false) {}
+  ChaCha20Poly1305Cipher() : HybridObject(TAG) {}
   ~ChaCha20Poly1305Cipher() {
     // Let parent destructor free the context
     ctx = nullptr;
@@ -24,7 +24,6 @@ class ChaCha20Poly1305Cipher : public HybridCipher {
   static constexpr int kKeySize = 32;
   static constexpr int kNonceSize = 12;
   static constexpr int kTagSize = 16; // Poly1305 tag is always 16 bytes
-  bool final_called;
 };
 
 } // namespace margelo::nitro::crypto

package/cpp/cipher/HybridCipher.cpp

@@ -27,6 +27,12 @@ void HybridCipher::checkCtx() const {
   }
 }
 
+void HybridCipher::checkNotFinalized() const {
+  if (is_finalized) {
+    throw std::runtime_error("Unsupported state or unable to authenticate data");
+  }
+}
+
 bool HybridCipher::maybePassAuthTagToOpenSSL() {
   if (auth_tag_state == kAuthTagKnown) {
     OSSL_PARAM params[] = {OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, auth_tag, auth_tag_len),
@@ -48,6 +54,7 @@ void HybridCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std
     EVP_CIPHER_CTX_free(ctx);
     ctx = nullptr;
   }
+  is_finalized = false;
 
   // 1. Get cipher implementation by name
   const EVP_CIPHER* cipher = EVP_get_cipherbyname(cipher_type.c_str());
@@ -100,6 +107,7 @@ void HybridCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std
 std::shared_ptr<ArrayBuffer> HybridCipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   auto native_data = ToNativeArrayBuffer(data);
   checkCtx();
+  checkNotFinalized();
   size_t in_len = native_data->size();
   if (in_len > INT_MAX) {
     throw std::runtime_error("Message too long");
@@ -125,6 +133,7 @@ std::shared_ptr<ArrayBuffer> HybridCipher::update(const std::shared_ptr<ArrayBuf
 
 std::shared_ptr<ArrayBuffer> HybridCipher::final() {
   checkCtx();
+  checkNotFinalized();
   // Block size is max output size for final, unless EVP_CIPH_NO_PADDING is set
   int block_size = EVP_CIPHER_CTX_block_size(ctx);
   if (block_size <= 0)
@@ -149,8 +158,8 @@ std::shared_ptr<ArrayBuffer> HybridCipher::final() {
 
   // Context should NOT be freed here. It might be needed for getAuthTag() for GCM/OCB.
   // The context will be freed by the destructor (~HybridCipher) when the object goes out of scope.
+  is_finalized = true;
 
-  // Return the shared_ptr<NativeArrayBuffer> (implicit upcast to shared_ptr<ArrayBuffer>)
   return native_final_chunk;
 }
 

package/cpp/cipher/HybridCipher.hpp

@@ -53,6 +53,7 @@ class HybridCipher : public HybridCipherSpec {
  protected:
   // Properties
   bool is_cipher = true;
+  bool is_finalized = false;
   std::string cipher_type;
   EVP_CIPHER_CTX* ctx = nullptr;
   bool pending_auth_failed = false;
@@ -66,6 +67,7 @@ class HybridCipher : public HybridCipherSpec {
   // Methods
   int getMode();
   void checkCtx() const;
+  void checkNotFinalized() const;
   bool maybePassAuthTagToOpenSSL();
 };
 

package/cpp/cipher/HybridRsaCipher.cpp

@@ -14,19 +14,6 @@ using margelo::nitro::NativeArrayBuffer;
 constexpr int kRsaPkcs1Padding = 1;
 constexpr int kRsaOaepPadding = 4;
 
-const EVP_MD* getDigestByName(const std::string& hashAlgorithm) {
-  if (hashAlgorithm == "SHA-1" || hashAlgorithm == "SHA1" || hashAlgorithm == "sha1" || hashAlgorithm == "sha-1") {
-    return EVP_sha1();
-  } else if (hashAlgorithm == "SHA-256" || hashAlgorithm == "SHA256" || hashAlgorithm == "sha256" || hashAlgorithm == "sha-256") {
-    return EVP_sha256();
-  } else if (hashAlgorithm == "SHA-384" || hashAlgorithm == "SHA384" || hashAlgorithm == "sha384" || hashAlgorithm == "sha-384") {
-    return EVP_sha384();
-  } else if (hashAlgorithm == "SHA-512" || hashAlgorithm == "SHA512" || hashAlgorithm == "sha512" || hashAlgorithm == "sha-512") {
-    return EVP_sha512();
-  }
-  throw std::runtime_error("Unsupported hash algorithm: " + hashAlgorithm);
-}
-
 int toOpenSSLPadding(int padding) {
   switch (padding) {
     case kRsaPkcs1Padding:

package/cpp/cipher/XChaCha20Poly1305Cipher.cpp

@@ -45,10 +45,11 @@ void XChaCha20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key
 
   data_buffer_.clear();
   aad_.clear();
-  final_called_ = false;
+  is_finalized = false;
 }
 
 std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkNotFinalized();
 #ifndef BLSALLOC_SODIUM
   throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
 #else
@@ -64,6 +65,7 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::update(const std::shared_p
 }
 
 std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::final() {
+  checkNotFinalized();
 #ifndef BLSALLOC_SODIUM
   throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
 #else
@@ -80,12 +82,12 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::final() {
       throw std::runtime_error("XChaCha20Poly1305Cipher: encryption failed");
     }
 
-    final_called_ = true;
+    is_finalized = true;
     size_t ct_len = data_buffer_.size();
     return std::make_shared<NativeArrayBuffer>(ciphertext, ct_len, [=]() { delete[] ciphertext; });
   } else {
     if (data_buffer_.empty()) {
-      final_called_ = true;
+      is_finalized = true;
       return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
     }
 
@@ -101,7 +103,7 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::final() {
       throw std::runtime_error("XChaCha20Poly1305Cipher: decryption failed - authentication tag mismatch");
     }
 
-    final_called_ = true;
+    is_finalized = true;
     size_t pt_len = data_buffer_.size();
     return std::make_shared<NativeArrayBuffer>(plaintext, pt_len, [=]() { delete[] plaintext; });
   }
@@ -126,7 +128,7 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::getAuthTag() {
   if (!is_cipher) {
     throw std::runtime_error("getAuthTag can only be called during encryption");
   }
-  if (!final_called_) {
+  if (!is_finalized) {
     throw std::runtime_error("getAuthTag must be called after final()");
   }
 

package/cpp/cipher/XChaCha20Poly1305Cipher.hpp

@@ -16,7 +16,7 @@ namespace margelo::nitro::crypto {
 
 class XChaCha20Poly1305Cipher : public HybridCipher {
  public:
-  XChaCha20Poly1305Cipher() : HybridObject(TAG), final_called_(false) {}
+  XChaCha20Poly1305Cipher() : HybridObject(TAG) {}
   ~XChaCha20Poly1305Cipher();
 
   void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
@@ -37,7 +37,6 @@ class XChaCha20Poly1305Cipher : public HybridCipher {
   std::vector<uint8_t> aad_;
   std::vector<uint8_t> data_buffer_;
   uint8_t auth_tag_[kTagSize];
-  bool final_called_;
 };
 
 } // namespace margelo::nitro::crypto

package/cpp/cipher/XSalsa20Cipher.cpp

@@ -28,12 +28,14 @@ void XSalsa20Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const s
   // Copy key and nonce data
   std::memcpy(key, native_key->data(), crypto_stream_KEYBYTES);
   std::memcpy(nonce, native_iv->data(), crypto_stream_NONCEBYTES);
+  is_finalized = false;
 }
 
 /**
  * xsalsa20 call to sodium implementation
  */
 std::shared_ptr<ArrayBuffer> XSalsa20Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkNotFinalized();
 #ifndef BLSALLOC_SODIUM
   throw std::runtime_error("XSalsa20Cipher: libsodium must be enabled to use this cipher (BLSALLOC_SODIUM is not defined).");
 #else
@@ -51,9 +53,11 @@ std::shared_ptr<ArrayBuffer> XSalsa20Cipher::update(const std::shared_ptr<ArrayB
  * xsalsa20 does not have a final step, returns empty buffer
  */
 std::shared_ptr<ArrayBuffer> XSalsa20Cipher::final() {
+  checkNotFinalized();
 #ifndef BLSALLOC_SODIUM
   throw std::runtime_error("XSalsa20Cipher: libsodium must be enabled to use this cipher (BLSALLOC_SODIUM is not defined).");
 #else
+  is_finalized = true;
   return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
 #endif
 }

package/cpp/cipher/XSalsa20Poly1305Cipher.cpp

@@ -40,10 +40,11 @@ void XSalsa20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key,
   std::memcpy(nonce_, native_iv->data(), kNonceSize);
 
   data_buffer_.clear();
-  final_called_ = false;
+  is_finalized = false;
 }
 
 std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkNotFinalized();
 #ifndef BLSALLOC_SODIUM
   throw std::runtime_error("XSalsa20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
 #else
@@ -59,6 +60,7 @@ std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::update(const std::shared_pt
 }
 
 std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::final() {
+  checkNotFinalized();
 #ifndef BLSALLOC_SODIUM
   throw std::runtime_error("XSalsa20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
 #else
@@ -73,12 +75,12 @@ std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::final() {
       throw std::runtime_error("XSalsa20Poly1305Cipher: encryption failed");
     }
 
-    final_called_ = true;
+    is_finalized = true;
     size_t ct_len = data_buffer_.size();
     return std::make_shared<NativeArrayBuffer>(ciphertext, ct_len, [=]() { delete[] ciphertext; });
   } else {
     if (data_buffer_.empty()) {
-      final_called_ = true;
+      is_finalized = true;
       return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
     }
 
@@ -92,7 +94,7 @@ std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::final() {
       throw std::runtime_error("XSalsa20Poly1305Cipher: decryption failed - authentication tag mismatch");
     }
 
-    final_called_ = true;
+    is_finalized = true;
     size_t pt_len = data_buffer_.size();
     return std::make_shared<NativeArrayBuffer>(plaintext, pt_len, [=]() { delete[] plaintext; });
   }
@@ -110,7 +112,7 @@ std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::getAuthTag() {
   if (!is_cipher) {
     throw std::runtime_error("getAuthTag can only be called during encryption");
   }
-  if (!final_called_) {
+  if (!is_finalized) {
     throw std::runtime_error("getAuthTag must be called after final()");
   }
 

package/cpp/cipher/XSalsa20Poly1305Cipher.hpp

@@ -16,7 +16,7 @@ namespace margelo::nitro::crypto {
 
 class XSalsa20Poly1305Cipher : public HybridCipher {
  public:
-  XSalsa20Poly1305Cipher() : HybridObject(TAG), final_called_(false) {}
+  XSalsa20Poly1305Cipher() : HybridObject(TAG) {}
   ~XSalsa20Poly1305Cipher();
 
   void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
@@ -36,7 +36,6 @@ class XSalsa20Poly1305Cipher : public HybridCipher {
   uint8_t nonce_[kNonceSize];
   std::vector<uint8_t> data_buffer_;
   uint8_t auth_tag_[kTagSize];
-  bool final_called_;
 };
 
 } // namespace margelo::nitro::crypto

package/cpp/ecdh/HybridECDH.cpp

@@ -2,6 +2,7 @@
 #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>
@@ -12,15 +13,9 @@ 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_KEY_ptr = std::unique_ptr<EC_KEY, decltype(&EC_KEY_free)>;
 using EC_POINT_ptr = std::unique_ptr<EC_POINT, decltype(&EC_POINT_free)>;
 using BN_ptr = std::unique_ptr<BIGNUM, decltype(&BN_free)>;
 
-// Suppress deprecation warnings for EC_KEY_* functions
-// These APIs work but are deprecated in OpenSSL 3.x
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-
 void HybridECDH::init(const std::string& curveName) {
   int nid = getCurveNid(curveName);
   if (nid == NID_undef) {
@@ -70,41 +65,8 @@ std::shared_ptr<ArrayBuffer> HybridECDH::computeSecret(const std::shared_ptr<Arr
     throw std::runtime_error("ECDH: private key not set");
   }
 
-  // Create EC_POINT from the peer's public key bytes
-  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(), otherPublicKey->data(), otherPublicKey->size(), nullptr) != 1) {
-    throw std::runtime_error("ECDH: failed to decode peer public key");
-  }
-
-  // Create EC_KEY for the peer
-  EC_KEY_ptr ecKey(EC_KEY_new(), EC_KEY_free);
-  if (!ecKey) {
-    throw std::runtime_error("ECDH: failed to create EC_KEY");
-  }
-
-  if (EC_KEY_set_group(ecKey.get(), _group.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to set EC group");
-  }
-
-  if (EC_KEY_set_public_key(ecKey.get(), point.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to set peer public key");
-  }
-
-  // Create EVP_PKEY for the peer
-  EVP_PKEY_ptr peerPkey(EVP_PKEY_new(), EVP_PKEY_free);
-  if (!peerPkey) {
-    throw std::runtime_error("ECDH: failed to create peer EVP_PKEY");
-  }
-
-  // EVP_PKEY_assign_EC_KEY takes ownership of ecKey on success
-  if (EVP_PKEY_assign_EC_KEY(peerPkey.get(), ecKey.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to assign EC_KEY to EVP_PKEY");
-  }
-  ecKey.release(); // EVP_PKEY now owns the EC_KEY
+  // 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);
@@ -142,19 +104,15 @@ std::shared_ptr<ArrayBuffer> HybridECDH::getPrivateKey() {
     throw std::runtime_error("ECDH: no key set");
   }
 
-  const EC_KEY* ec = EVP_PKEY_get0_EC_KEY(_pkey.get());
-  if (!ec) {
-    throw std::runtime_error("ECDH: key is not an EC key");
-  }
-
-  const BIGNUM* priv = EC_KEY_get0_private_key(ec);
-  if (!priv) {
+  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);
 }
@@ -162,23 +120,12 @@ std::shared_ptr<ArrayBuffer> HybridECDH::getPrivateKey() {
 void HybridECDH::setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) {
   ensureInitialized();
 
-  // Create new EC_KEY
-  EC_KEY_ptr ecKey(EC_KEY_new(), EC_KEY_free);
-  if (!ecKey) {
-    throw std::runtime_error("ECDH: failed to create EC_KEY");
-  }
-
-  if (EC_KEY_set_group(ecKey.get(), _group.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to set EC group");
-  }
-
   // 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");
   }
 
-  // Calculate public key from 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");
@@ -188,28 +135,17 @@ void HybridECDH::setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) {
     throw std::runtime_error("ECDH: failed to compute public key from private key");
   }
 
-  // Set keys on EC_KEY (these functions copy the values, so we still own privBn and pubPoint)
-  if (EC_KEY_set_private_key(ecKey.get(), privBn.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to set private key");
-  }
-
-  if (EC_KEY_set_public_key(ecKey.get(), pubPoint.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to set public key");
-  }
-
-  // Create new EVP_PKEY
-  EVP_PKEY_ptr pkey(EVP_PKEY_new(), EVP_PKEY_free);
-  if (!pkey) {
-    throw std::runtime_error("ECDH: failed to create EVP_PKEY");
+  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");
   }
-
-  // EVP_PKEY_assign_EC_KEY takes ownership of ecKey on success
-  if (EVP_PKEY_assign_EC_KEY(pkey.get(), ecKey.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to assign EC_KEY to EVP_PKEY");
+  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");
   }
-  ecKey.release(); // EVP_PKEY now owns the EC_KEY
 
-  _pkey = std::move(pkey);
+  // 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() {
@@ -217,26 +153,14 @@ std::shared_ptr<ArrayBuffer> HybridECDH::getPublicKey() {
     throw std::runtime_error("ECDH: no key set");
   }
 
-  const EC_KEY* ec = EVP_PKEY_get0_EC_KEY(_pkey.get());
-  if (!ec) {
-    throw std::runtime_error("ECDH: key is not an EC key");
-  }
-
-  const EC_POINT* point = EC_KEY_get0_public_key(ec);
-  const EC_GROUP* group = EC_KEY_get0_group(ec);
-  if (!point || !group) {
-    throw std::runtime_error("ECDH: incomplete key");
-  }
-
-  // Get uncompressed public key size
-  size_t len = EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, nullptr, 0, nullptr);
-  if (len == 0) {
+  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 (EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, buf.data(), len, nullptr) == 0) {
-    throw std::runtime_error("ECDH: failed to encode public key");
+  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);
@@ -245,43 +169,8 @@ std::shared_ptr<ArrayBuffer> HybridECDH::getPublicKey() {
 void HybridECDH::setPublicKey(const std::shared_ptr<ArrayBuffer>& publicKey) {
   ensureInitialized();
 
-  // Create EC_POINT from the public key bytes
-  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(), publicKey->data(), publicKey->size(), nullptr) != 1) {
-    throw std::runtime_error("ECDH: invalid public key");
-  }
-
-  // Create new EC_KEY
-  EC_KEY_ptr ecKey(EC_KEY_new(), EC_KEY_free);
-  if (!ecKey) {
-    throw std::runtime_error("ECDH: failed to create EC_KEY");
-  }
-
-  if (EC_KEY_set_group(ecKey.get(), _group.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to set EC group");
-  }
-
-  if (EC_KEY_set_public_key(ecKey.get(), point.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to set public key");
-  }
-
-  // Create new EVP_PKEY
-  EVP_PKEY_ptr pkey(EVP_PKEY_new(), EVP_PKEY_free);
-  if (!pkey) {
-    throw std::runtime_error("ECDH: failed to create EVP_PKEY");
-  }
-
-  // EVP_PKEY_assign_EC_KEY takes ownership of ecKey on success
-  if (EVP_PKEY_assign_EC_KEY(pkey.get(), ecKey.get()) != 1) {
-    throw std::runtime_error("ECDH: failed to assign EC_KEY to EVP_PKEY");
-  }
-  ecKey.release(); // EVP_PKEY now owns the EC_KEY
-
-  _pkey = std::move(pkey);
+  // 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) {
@@ -336,6 +225,4 @@ int HybridECDH::getCurveNid(const std::string& name) {
   return nid;
 }
 
-#pragma clang diagnostic pop
-
 } // namespace margelo::nitro::crypto