react-native-quick-crypto 1.0.11 → 1.0.12

package/cpp/keys/HybridKeyObjectHandle.cpp

@@ -5,6 +5,7 @@
 #include "HybridKeyObjectHandle.hpp"
 #include "QuickCryptoUtils.hpp"
 #include <openssl/bn.h>
+#include <openssl/core_names.h>
 #include <openssl/crypto.h>
 #include <openssl/ec.h>
 #include <openssl/evp.h>
@@ -91,9 +92,9 @@ std::shared_ptr<ArrayBuffer> HybridKeyObjectHandle::exportKey(std::optional<KFor
                                                               const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
   auto keyType = data_.GetKeyType();
 
-  // Handle secret keys
+  // Copy to avoid JSI ArrayBuffer GC issues. See #645.
   if (keyType == KeyType::SECRET) {
-    return data_.GetSymmetricKey();
+    return ToNativeArrayBuffer(data_.GetSymmetricKey());
   }
 
   // Handle asymmetric keys (public/private)
@@ -127,22 +128,39 @@ std::shared_ptr<ArrayBuffer> HybridKeyObjectHandle::exportKey(std::optional<KFor
 
     // For EC keys, handle raw format (uncompressed point)
     if (!format.has_value() && !type.has_value() && keyId == EVP_PKEY_EC && keyType == KeyType::PUBLIC) {
-      const EC_KEY* ec_key = EVP_PKEY_get0_EC_KEY(pkey.get());
-      if (!ec_key)
-        throw std::runtime_error("Failed to get EC key");
-      const EC_GROUP* group = EC_KEY_get0_group(ec_key);
-      const EC_POINT* point = EC_KEY_get0_public_key(ec_key);
-      if (!group || !point)
-        throw std::runtime_error("Failed to get EC public key");
-      size_t len = EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, nullptr, 0, nullptr);
-      if (len == 0)
-        throw std::runtime_error("Failed to get EC point size");
+      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("Failed to get EC public key size");
       std::vector<uint8_t> buf(len);
-      if (EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, buf.data(), len, nullptr) == 0) {
-        throw std::runtime_error("Failed to encode EC 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("Failed to get EC public key");
+      return ToNativeArrayBuffer(std::string(reinterpret_cast<const char*>(buf.data()), len));
+    }
+
+#if OPENSSL_VERSION_NUMBER >= 0x30500000L
+    if (!format.has_value() && !type.has_value()) {
+      const char* typeName = EVP_PKEY_get0_type_name(pkey.get());
+      if (typeName != nullptr) {
+        std::string name(typeName);
+        bool isPqcKey = (name.starts_with("ML-KEM-") || name.starts_with("ML-DSA-"));
+        if (isPqcKey) {
+          if (keyType == KeyType::PUBLIC) {
+            auto rawData = pkey.rawPublicKey();
+            if (!rawData) {
+              throw std::runtime_error("Failed to get raw PQC public key");
+            }
+            return ToNativeArrayBuffer(std::string(reinterpret_cast<const char*>(rawData.get()), rawData.size()));
+          } else {
+            auto rawData = pkey.rawSeed();
+            if (!rawData) {
+              throw std::runtime_error("Failed to get raw PQC seed");
+            }
+            return ToNativeArrayBuffer(std::string(reinterpret_cast<const char*>(rawData.get()), rawData.size()));
+          }
+        }
       }
-      return ToNativeArrayBuffer(std::string(reinterpret_cast<const char*>(buf.data()), buf.size()));
     }
+#endif
 
     // Set default format and type if not provided
     auto exportFormat = format.value_or(KFormatType::DER);
@@ -258,54 +276,50 @@ JWK HybridKeyObjectHandle::exportJwk(const JWK& key, bool handleRsaPss) {
 
   // Export EC keys
   if (keyId == EVP_PKEY_EC) {
-    const EC_KEY* ec = EVP_PKEY_get0_EC_KEY(pkey.get());
-    if (!ec)
-      throw std::runtime_error("Failed to get EC key");
+    char curve_name_buf[64];
+    size_t name_len = 0;
+    if (EVP_PKEY_get_utf8_string_param(pkey.get(), OSSL_PKEY_PARAM_GROUP_NAME, curve_name_buf, sizeof(curve_name_buf), &name_len) != 1)
+      throw std::runtime_error("Failed to get EC group name");
 
-    const EC_GROUP* group = EC_KEY_get0_group(ec);
-    if (!group)
-      throw std::runtime_error("Failed to get EC group");
+    std::string curve_name(curve_name_buf, name_len);
 
-    int nid = EC_GROUP_get_curve_name(group);
-    const char* curve_name = OBJ_nid2sn(nid);
-    if (!curve_name)
-      throw std::runtime_error("Unknown curve");
-
-    // Get the field size in bytes for proper padding
-    size_t field_size = (EC_GROUP_get_degree(group) + 7) / 8;
+    int bits = EVP_PKEY_bits(pkey.get());
+    if (bits <= 0)
+      throw std::runtime_error("Failed to get EC key size");
+    size_t field_size = (static_cast<size_t>(bits) + 7) / 8;
 
     result.kty = JWKkty::EC;
 
     // Map OpenSSL curve names to JWK curve names
-    if (strcmp(curve_name, "prime256v1") == 0) {
+    if (curve_name == "prime256v1") {
       result.crv = "P-256";
-    } else if (strcmp(curve_name, "secp384r1") == 0) {
+    } else if (curve_name == "secp384r1") {
       result.crv = "P-384";
-    } else if (strcmp(curve_name, "secp521r1") == 0) {
+    } else if (curve_name == "secp521r1") {
       result.crv = "P-521";
     } else {
       result.crv = curve_name;
     }
 
-    const EC_POINT* pub_key = EC_KEY_get0_public_key(ec);
-    if (pub_key) {
-      BIGNUM* x_bn = BN_new();
-      BIGNUM* y_bn = BN_new();
-
-      if (EC_POINT_get_affine_coordinates(group, pub_key, x_bn, y_bn, nullptr) == 1) {
-        result.x = bn_to_base64url(x_bn, field_size);
-        result.y = bn_to_base64url(y_bn, field_size);
-      }
-
+    BIGNUM* x_bn = nullptr;
+    BIGNUM* y_bn = nullptr;
+    if (EVP_PKEY_get_bn_param(pkey.get(), OSSL_PKEY_PARAM_EC_PUB_X, &x_bn) != 1 ||
+        EVP_PKEY_get_bn_param(pkey.get(), OSSL_PKEY_PARAM_EC_PUB_Y, &y_bn) != 1) {
       BN_free(x_bn);
       BN_free(y_bn);
+      throw std::runtime_error("Failed to get EC public key coordinates");
     }
+    result.x = bn_to_base64url(x_bn, field_size);
+    result.y = bn_to_base64url(y_bn, field_size);
+    BN_free(x_bn);
+    BN_free(y_bn);
 
     // Export private key if this is a private key
     if (keyType == KeyType::PRIVATE) {
-      const BIGNUM* priv_key = EC_KEY_get0_private_key(ec);
-      if (priv_key) {
-        result.d = bn_to_base64url(priv_key, field_size);
+      BIGNUM* priv_bn = nullptr;
+      if (EVP_PKEY_get_bn_param(pkey.get(), OSSL_PKEY_PARAM_PRIV_KEY, &priv_bn) == 1 && priv_bn) {
+        result.d = bn_to_base64url(priv_bn, field_size);
+        BN_free(priv_bn);
       }
     }
 
@@ -389,8 +403,25 @@ AsymmetricKeyType HybridKeyObjectHandle::getAsymmetricKeyType() {
       return AsymmetricKeyType::ML_DSA_87;
 #endif
     default:
-      throw std::runtime_error("Unsupported asymmetric key type");
+      break;
   }
+
+#if OPENSSL_VERSION_NUMBER >= 0x30500000L
+  // EVP_PKEY_id returns -1 for provider-only key types (e.g. ML-KEM)
+  // Fall back to string-based type name comparison
+  const char* typeName = EVP_PKEY_get0_type_name(pkey.get());
+  if (typeName != nullptr) {
+    std::string name(typeName);
+    if (name == "ML-KEM-512")
+      return AsymmetricKeyType::ML_KEM_512;
+    if (name == "ML-KEM-768")
+      return AsymmetricKeyType::ML_KEM_768;
+    if (name == "ML-KEM-1024")
+      return AsymmetricKeyType::ML_KEM_1024;
+  }
+#endif
+
+  throw std::runtime_error("Unsupported asymmetric key type");
 }
 
 bool HybridKeyObjectHandle::init(KeyType keyType, const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& key,
@@ -574,81 +605,54 @@ std::optional<KeyType> HybridKeyObjectHandle::initJwk(const JWK& keyData, std::o
 
     std::string crv = keyData.crv.value();
 
-    // Map JWK curve names to OpenSSL NIDs
-    int nid;
+    // Map JWK curve names to OpenSSL group names and field sizes
+    const char* group_name;
+    size_t field_size;
     if (crv == "P-256") {
-      nid = NID_X9_62_prime256v1;
+      group_name = "prime256v1";
+      field_size = 32;
     } else if (crv == "P-384") {
-      nid = NID_secp384r1;
+      group_name = "secp384r1";
+      field_size = 48;
     } else if (crv == "P-521") {
-      nid = NID_secp521r1;
+      group_name = "secp521r1";
+      field_size = 66;
     } else {
       throw std::runtime_error("Unsupported EC curve: " + crv);
     }
 
-    // Create EC_KEY
-    EC_KEY* ec = EC_KEY_new_by_curve_name(nid);
-    if (!ec)
-      throw std::runtime_error("Failed to create EC key");
-
-    const EC_GROUP* group = EC_KEY_get0_group(ec);
-
     // Decode public key coordinates
     BIGNUM* x_bn = base64url_to_bn(keyData.x.value());
     BIGNUM* y_bn = base64url_to_bn(keyData.y.value());
-
     if (!x_bn || !y_bn) {
-      EC_KEY_free(ec);
-      throw std::runtime_error("Failed to decode EC public key coordinates");
-    }
-
-    // Set public key
-    EC_POINT* pub_key = EC_POINT_new(group);
-    if (!pub_key || EC_POINT_set_affine_coordinates(group, pub_key, x_bn, y_bn, nullptr) != 1) {
       BN_free(x_bn);
       BN_free(y_bn);
-      if (pub_key)
-        EC_POINT_free(pub_key);
-      EC_KEY_free(ec);
-      throw std::runtime_error("Failed to set EC public key");
+      throw std::runtime_error("Failed to decode EC public key coordinates");
     }
 
+    // Build uncompressed point: 0x04 || x_padded || y_padded
+    std::vector<uint8_t> pub_oct(1 + 2 * field_size, 0);
+    pub_oct[0] = 0x04;
+    BN_bn2binpad(x_bn, pub_oct.data() + 1, static_cast<int>(field_size));
+    BN_bn2binpad(y_bn, pub_oct.data() + 1 + field_size, static_cast<int>(field_size));
     BN_free(x_bn);
     BN_free(y_bn);
 
-    if (EC_KEY_set_public_key(ec, pub_key) != 1) {
-      EC_POINT_free(pub_key);
-      EC_KEY_free(ec);
-      throw std::runtime_error("Failed to set EC public key on EC_KEY");
-    }
-
-    EC_POINT_free(pub_key);
-
-    // Set private key if present
+    BIGNUM* d_bn = nullptr;
     if (isPrivate) {
-      BIGNUM* d_bn = base64url_to_bn(keyData.d.value());
-      if (!d_bn) {
-        EC_KEY_free(ec);
+      d_bn = base64url_to_bn(keyData.d.value());
+      if (!d_bn)
         throw std::runtime_error("Failed to decode EC private key");
-      }
-
-      if (EC_KEY_set_private_key(ec, d_bn) != 1) {
-        BN_free(d_bn);
-        EC_KEY_free(ec);
-        throw std::runtime_error("Failed to set EC private key");
-      }
-
-      BN_free(d_bn);
     }
 
-    // Create EVP_PKEY from EC_KEY
-    EVP_PKEY* pkey = EVP_PKEY_new();
-    if (!pkey || EVP_PKEY_assign_EC_KEY(pkey, ec) != 1) {
-      EC_KEY_free(ec);
-      if (pkey)
-        EVP_PKEY_free(pkey);
-      throw std::runtime_error("Failed to create EVP_PKEY from EC_KEY");
+    EVP_PKEY* pkey = nullptr;
+    try {
+      pkey = createEcEvpPkey(group_name, pub_oct.data(), pub_oct.size(), d_bn);
+    } catch (...) {
+      BN_free(d_bn);
+      throw;
     }
+    BN_free(d_bn);
 
     KeyType type = isPrivate ? KeyType::PRIVATE : KeyType::PUBLIC;
     data_ = KeyObjectData::CreateAsymmetric(type, ncrypto::EVPKeyPointer(pkey));
@@ -733,20 +737,11 @@ KeyDetail HybridKeyObjectHandle::keyDetail() {
   }
 
   if (keyType == EVP_PKEY_EC) {
-    // Extract EC curve name
-    EC_KEY* ec_key = EVP_PKEY_get1_EC_KEY(pkey);
-    if (ec_key) {
-      const EC_GROUP* group = EC_KEY_get0_group(ec_key);
-      if (group) {
-        int nid = EC_GROUP_get_curve_name(group);
-        const char* curve_name = OBJ_nid2sn(nid);
-        if (curve_name) {
-          std::string namedCurve(curve_name);
-          EC_KEY_free(ec_key);
-          return KeyDetail(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, namedCurve);
-        }
-      }
-      EC_KEY_free(ec_key);
+    char curve_name[64];
+    size_t name_len = 0;
+    if (EVP_PKEY_get_utf8_string_param(pkey, OSSL_PKEY_PARAM_GROUP_NAME, curve_name, sizeof(curve_name), &name_len) == 1) {
+      return KeyDetail(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt,
+                       std::string(curve_name, name_len));
     }
   }
 
@@ -812,48 +807,56 @@ bool HybridKeyObjectHandle::initECRaw(const std::string& namedCurve, const std::
     throw std::runtime_error("Unknown curve: " + namedCurve);
   }
 
-  // Create EC_GROUP for the curve
-  ncrypto::ECGroupPointer group = ncrypto::ECGroupPointer::NewByCurveName(nid);
-  if (!group) {
-    throw std::runtime_error("Failed to create EC_GROUP for curve");
+  // Get the OpenSSL group name for this curve
+  const char* group_name = OBJ_nid2sn(nid);
+  if (!group_name) {
+    throw std::runtime_error("Failed to get curve name for NID");
   }
 
-  // Create EC_POINT from raw bytes
-  ncrypto::ECPointPointer point = ncrypto::ECPointPointer::New(group.get());
-  if (!point) {
-    throw std::runtime_error("Failed to create EC_POINT");
-  }
+  EVP_PKEY* pkey = createEcEvpPkey(group_name, keyData->data(), keyData->size());
+  this->data_ = KeyObjectData::CreateAsymmetric(KeyType::PUBLIC, ncrypto::EVPKeyPointer(pkey));
+  return true;
+}
 
-  // Convert raw bytes to EC_POINT
-  ncrypto::Buffer<const unsigned char> buffer{.data = reinterpret_cast<const unsigned char*>(keyData->data()), .len = keyData->size()};
+bool HybridKeyObjectHandle::initPqcRaw(const std::string& algorithmName, const std::shared_ptr<ArrayBuffer>& keyData, bool isPublic) {
+#if OPENSSL_VERSION_NUMBER >= 0x30500000L
+  data_ = KeyObjectData();
 
-  if (!point.setFromBuffer(buffer, group.get())) {
-    throw std::runtime_error("Failed to read DER asymmetric key");
-  }
+  int nid = 0;
+  if (algorithmName == "ML-KEM-512")
+    nid = EVP_PKEY_ML_KEM_512;
+  else if (algorithmName == "ML-KEM-768")
+    nid = EVP_PKEY_ML_KEM_768;
+  else if (algorithmName == "ML-KEM-1024")
+    nid = EVP_PKEY_ML_KEM_1024;
+  else if (algorithmName == "ML-DSA-44")
+    nid = EVP_PKEY_ML_DSA_44;
+  else if (algorithmName == "ML-DSA-65")
+    nid = EVP_PKEY_ML_DSA_65;
+  else if (algorithmName == "ML-DSA-87")
+    nid = EVP_PKEY_ML_DSA_87;
+  else
+    throw std::runtime_error("Unknown PQC algorithm: " + algorithmName);
 
-  // Create EC_KEY and set the public key
-  ncrypto::ECKeyPointer ec = ncrypto::ECKeyPointer::New(group.get());
-  if (!ec) {
-    throw std::runtime_error("Failed to create EC_KEY");
-  }
+  ncrypto::Buffer<const unsigned char> buffer{.data = reinterpret_cast<const unsigned char*>(keyData->data()), .len = keyData->size()};
 
-  if (!ec.setPublicKey(point)) {
-    throw std::runtime_error("Failed to set public key on EC_KEY");
+  ncrypto::EVPKeyPointer pkey;
+  if (isPublic) {
+    pkey = ncrypto::EVPKeyPointer::NewRawPublic(nid, buffer);
+  } else {
+    pkey = ncrypto::EVPKeyPointer::NewRawSeed(nid, buffer);
   }
 
-  // Create EVP_PKEY from EC_KEY
-  ncrypto::EVPKeyPointer pkey = ncrypto::EVPKeyPointer::New();
   if (!pkey) {
-    throw std::runtime_error("Failed to create EVP_PKEY");
-  }
-
-  if (!pkey.set(ec)) {
-    throw std::runtime_error("Failed to assign EC_KEY to EVP_PKEY");
+    return false;
   }
 
-  // Store as public key
-  this->data_ = KeyObjectData::CreateAsymmetric(KeyType::PUBLIC, std::move(pkey));
+  auto keyType = isPublic ? KeyType::PUBLIC : KeyType::PRIVATE;
+  this->data_ = KeyObjectData::CreateAsymmetric(keyType, std::move(pkey));
   return true;
+#else
+  throw std::runtime_error("PQC raw key import requires OpenSSL 3.5+");
+#endif
 }
 
 bool HybridKeyObjectHandle::keyEquals(const std::shared_ptr<HybridKeyObjectHandleSpec>& other) {

package/cpp/keys/HybridKeyObjectHandle.hpp

@@ -31,6 +31,8 @@ class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec {
 
   bool initECRaw(const std::string& namedCurve, const std::shared_ptr<ArrayBuffer>& keyData) override;
 
+  bool initPqcRaw(const std::string& algorithmName, const std::shared_ptr<ArrayBuffer>& keyData, bool isPublic) override;
+
   std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) override;
 
   KeyDetail keyDetail() override;
@@ -39,13 +41,14 @@ class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec {
 
   double getSymmetricKeySize() override;
 
-  KeyObjectData& getKeyObjectData() {
-    return data_;
-  }
   const KeyObjectData& getKeyObjectData() const {
     return data_;
   }
 
+  void setKeyObjectData(KeyObjectData data) {
+    data_ = std::move(data);
+  }
+
  private:
   KeyObjectData data_;
 

package/cpp/keys/KeyObjectData.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <memory>
 
 #include <NitroModules/ArrayBuffer.hpp>

package/cpp/kmac/HybridKmac.cpp

@@ -0,0 +1,83 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/core_names.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <string>
+#include <vector>
+
+#include "HybridKmac.hpp"
+
+namespace margelo::nitro::crypto {
+
+void HybridKmac::createKmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key, double outputLength,
+                            const std::optional<std::shared_ptr<ArrayBuffer>>& customization) {
+  outputLen = static_cast<size_t>(outputLength);
+  if (outputLen == 0) {
+    throw std::runtime_error("KMAC output length must be greater than 0");
+  }
+
+  std::unique_ptr<EVP_MAC, decltype(&EVP_MAC_free)> mac(EVP_MAC_fetch(nullptr, algorithm.c_str(), nullptr), EVP_MAC_free);
+  if (!mac) {
+    throw std::runtime_error("Failed to fetch " + algorithm + " implementation: " + std::to_string(ERR_get_error()));
+  }
+
+  ctx.reset(EVP_MAC_CTX_new(mac.get()));
+  if (!ctx) {
+    throw std::runtime_error("Failed to create KMAC context: " + std::to_string(ERR_get_error()));
+  }
+
+  OSSL_PARAM params[3];
+  size_t paramCount = 0;
+
+  params[paramCount++] = OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_SIZE, &outputLen);
+
+  std::vector<uint8_t> custData;
+  if (customization.has_value() && customization.value()->size() > 0) {
+    const auto& custBuf = customization.value();
+    custData.assign(reinterpret_cast<const uint8_t*>(custBuf->data()), reinterpret_cast<const uint8_t*>(custBuf->data()) + custBuf->size());
+    params[paramCount++] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_CUSTOM, custData.data(), custData.size());
+  }
+
+  params[paramCount] = OSSL_PARAM_construct_end();
+
+  const uint8_t* keyData = reinterpret_cast<const uint8_t*>(key->data());
+  size_t keySize = key->size();
+
+  if (keySize == 0) {
+    throw std::runtime_error("KMAC key must not be empty");
+  }
+
+  if (EVP_MAC_init(ctx.get(), keyData, keySize, params) != 1) {
+    throw std::runtime_error("Failed to initialize KMAC: " + std::to_string(ERR_get_error()));
+  }
+}
+
+void HybridKmac::update(const std::shared_ptr<ArrayBuffer>& data) {
+  if (!ctx) {
+    throw std::runtime_error("KMAC context not initialized");
+  }
+
+  if (EVP_MAC_update(ctx.get(), reinterpret_cast<const uint8_t*>(data->data()), data->size()) != 1) {
+    throw std::runtime_error("Failed to update KMAC: " + std::to_string(ERR_get_error()));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> HybridKmac::digest() {
+  if (!ctx) {
+    throw std::runtime_error("KMAC context not initialized");
+  }
+
+  uint8_t* buffer = new uint8_t[outputLen];
+
+  if (EVP_MAC_final(ctx.get(), buffer, nullptr, outputLen) != 1) {
+    delete[] buffer;
+    throw std::runtime_error("Failed to finalize KMAC digest: " + std::to_string(ERR_get_error()));
+  }
+
+  ctx.reset();
+
+  return std::make_shared<NativeArrayBuffer>(buffer, outputLen, [=]() { delete[] buffer; });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/kmac/HybridKmac.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <string>
+
+#include "HybridKmacSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+using EVP_MAC_CTX_ptr = std::unique_ptr<EVP_MAC_CTX, decltype(&EVP_MAC_CTX_free)>;
+
+class HybridKmac : public HybridKmacSpec {
+ public:
+  HybridKmac() : HybridObject(TAG) {}
+
+ public:
+  void createKmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key, double outputLength,
+                  const std::optional<std::shared_ptr<ArrayBuffer>>& customization) override;
+  void update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> digest() override;
+
+ private:
+  EVP_MAC_CTX_ptr ctx{nullptr, EVP_MAC_CTX_free};
+  size_t outputLen = 0;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/mldsa/HybridMlDsaKeyPair.cpp

@@ -15,13 +15,6 @@
 
 namespace margelo::nitro::crypto {
 
-HybridMlDsaKeyPair::~HybridMlDsaKeyPair() {
-  if (pkey_ != nullptr) {
-    EVP_PKEY_free(pkey_);
-    pkey_ = nullptr;
-  }
-}
-
 int HybridMlDsaKeyPair::getEvpPkeyType() const {
 #if RNQC_HAS_ML_DSA
   if (variant_ == "ML-DSA-44")
@@ -66,10 +59,7 @@ void HybridMlDsaKeyPair::generateKeyPairSync(double publicFormat, double publicT
   privateFormat_ = static_cast<int>(privateFormat);
   privateType_ = static_cast<int>(privateType);
 
-  if (pkey_ != nullptr) {
-    EVP_PKEY_free(pkey_);
-    pkey_ = nullptr;
-  }
+  pkey_.reset();
 
   EVP_PKEY_CTX* pctx = EVP_PKEY_CTX_new_from_name(nullptr, variant_.c_str(), nullptr);
   if (pctx == nullptr) {
@@ -81,10 +71,12 @@ void HybridMlDsaKeyPair::generateKeyPairSync(double publicFormat, double publicT
     throw std::runtime_error("Failed to initialize keygen: " + getOpenSSLError());
   }
 
-  if (EVP_PKEY_keygen(pctx, &pkey_) <= 0) {
+  EVP_PKEY* raw = nullptr;
+  if (EVP_PKEY_keygen(pctx, &raw) <= 0) {
     EVP_PKEY_CTX_free(pctx);
     throw std::runtime_error("Failed to generate ML-DSA key pair: " + getOpenSSLError());
   }
+  pkey_.reset(raw);
 
   EVP_PKEY_CTX_free(pctx);
 #endif
@@ -103,9 +95,9 @@ std::shared_ptr<ArrayBuffer> HybridMlDsaKeyPair::getPublicKey() {
 
   int result;
   if (publicFormat_ == 1) {
-    result = PEM_write_bio_PUBKEY(bio, pkey_);
+    result = PEM_write_bio_PUBKEY(bio, pkey_.get());
   } else {
-    result = i2d_PUBKEY_bio(bio, pkey_);
+    result = i2d_PUBKEY_bio(bio, pkey_.get());
   }
 
   if (result != 1) {
@@ -139,10 +131,9 @@ std::shared_ptr<ArrayBuffer> HybridMlDsaKeyPair::getPrivateKey() {
 
   int result;
   if (privateFormat_ == 1) {
-    result = PEM_write_bio_PrivateKey(bio, pkey_, nullptr, nullptr, 0, nullptr, nullptr);
+    result = PEM_write_bio_PrivateKey(bio, pkey_.get(), nullptr, nullptr, 0, nullptr, nullptr);
   } else {
-    // Use PKCS8 format for DER export (not raw private key format)
-    result = i2d_PKCS8PrivateKey_bio(bio, pkey_, nullptr, nullptr, 0, nullptr, nullptr);
+    result = i2d_PKCS8PrivateKey_bio(bio, pkey_.get(), nullptr, nullptr, 0, nullptr, nullptr);
   }
 
   if (result != 1) {
@@ -186,7 +177,7 @@ std::shared_ptr<ArrayBuffer> HybridMlDsaKeyPair::signSync(const std::shared_ptr<
     throw std::runtime_error("Failed to create signing context for " + variant_);
   }
 
-  if (EVP_DigestSignInit(md_ctx, &pkey_ctx, nullptr, nullptr, pkey_) <= 0) {
+  if (EVP_DigestSignInit(md_ctx, &pkey_ctx, nullptr, nullptr, pkey_.get()) <= 0) {
     EVP_MD_CTX_free(md_ctx);
     EVP_PKEY_CTX_free(pkey_ctx);
     throw std::runtime_error("Failed to initialize signing: " + getOpenSSLError());
@@ -237,7 +228,7 @@ bool HybridMlDsaKeyPair::verifySync(const std::shared_ptr<ArrayBuffer>& signatur
     throw std::runtime_error("Failed to create verify context for " + variant_);
   }
 
-  if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, nullptr, nullptr, pkey_) <= 0) {
+  if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, nullptr, nullptr, pkey_.get()) <= 0) {
     EVP_MD_CTX_free(md_ctx);
     EVP_PKEY_CTX_free(pkey_ctx);
     throw std::runtime_error("Failed to initialize verification: " + getOpenSSLError());
@@ -256,7 +247,7 @@ bool HybridMlDsaKeyPair::verifySync(const std::shared_ptr<ArrayBuffer>& signatur
 }
 
 void HybridMlDsaKeyPair::checkKeyPair() {
-  if (pkey_ == nullptr) {
+  if (!pkey_) {
     throw std::runtime_error("Key pair not initialized");
   }
 }

package/cpp/mldsa/HybridMlDsaKeyPair.hpp

@@ -11,7 +11,7 @@ namespace margelo::nitro::crypto {
 class HybridMlDsaKeyPair : public HybridMlDsaKeyPairSpec {
  public:
   HybridMlDsaKeyPair() : HybridObject(TAG) {}
-  ~HybridMlDsaKeyPair();
+  ~HybridMlDsaKeyPair() override = default;
 
   std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType) override;
 
@@ -32,8 +32,10 @@ class HybridMlDsaKeyPair : public HybridMlDsaKeyPairSpec {
   void setVariant(const std::string& variant) override;
 
  private:
+  using EVP_PKEY_ptr = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>;
+
   std::string variant_;
-  EVP_PKEY* pkey_ = nullptr;
+  EVP_PKEY_ptr pkey_{nullptr, EVP_PKEY_free};
 
   int publicFormat_ = -1;
   int publicType_ = -1;