react-native-quick-crypto 1.0.10 → 1.0.12

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;

package/cpp/mlkem/HybridMlKemKeyPair.cpp

@@ -0,0 +1,319 @@
+#include "HybridMlKemKeyPair.hpp"
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <openssl/bio.h>
+#include <openssl/err.h>
+#include <openssl/pem.h>
+
+#include "QuickCryptoUtils.hpp"
+
+#if OPENSSL_VERSION_NUMBER >= 0x30500000L
+#define RNQC_HAS_ML_KEM 1
+#else
+#define RNQC_HAS_ML_KEM 0
+#endif
+
+namespace margelo::nitro::crypto {
+
+void HybridMlKemKeyPair::setVariant(const std::string& variant) {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#endif
+  if (variant != "ML-KEM-512" && variant != "ML-KEM-768" && variant != "ML-KEM-1024") {
+    throw std::runtime_error("Invalid ML-KEM variant: " + variant + ". Must be ML-KEM-512, ML-KEM-768, or ML-KEM-1024");
+  }
+  variant_ = variant;
+}
+
+std::shared_ptr<Promise<void>> HybridMlKemKeyPair::generateKeyPair(double publicFormat, double publicType, double privateFormat,
+                                                                   double privateType) {
+  return Promise<void>::async([this, publicFormat, publicType, privateFormat, privateType]() {
+    this->generateKeyPairSync(publicFormat, publicType, privateFormat, privateType);
+  });
+}
+
+void HybridMlKemKeyPair::generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType) {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+
+  if (variant_.empty()) {
+    throw std::runtime_error("ML-KEM variant not set. Call setVariant() first.");
+  }
+
+  publicFormat_ = static_cast<int>(publicFormat);
+  publicType_ = static_cast<int>(publicType);
+  privateFormat_ = static_cast<int>(privateFormat);
+  privateType_ = static_cast<int>(privateType);
+
+  pkey_.reset();
+
+  EVP_PKEY_CTX* pctx = EVP_PKEY_CTX_new_from_name(nullptr, variant_.c_str(), nullptr);
+  if (pctx == nullptr) {
+    throw std::runtime_error("Failed to create key context for " + variant_ + ": " + getOpenSSLError());
+  }
+
+  if (EVP_PKEY_keygen_init(pctx) <= 0) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to initialize keygen: " + getOpenSSLError());
+  }
+
+  EVP_PKEY* raw = nullptr;
+  if (EVP_PKEY_keygen(pctx, &raw) <= 0) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to generate ML-KEM key pair: " + getOpenSSLError());
+  }
+
+  pkey_.reset(raw);
+  EVP_PKEY_CTX_free(pctx);
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> HybridMlKemKeyPair::getPublicKey() {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#else
+  checkKeyPair();
+
+  BIO* bio = BIO_new(BIO_s_mem());
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for public key export");
+  }
+
+  int result;
+  if (publicFormat_ == 1) {
+    result = PEM_write_bio_PUBKEY(bio, pkey_.get());
+  } else {
+    result = i2d_PUBKEY_bio(bio, pkey_.get());
+  }
+
+  if (result != 1) {
+    BIO_free(bio);
+    throw std::runtime_error("Failed to export public key: " + getOpenSSLError());
+  }
+
+  BUF_MEM* bptr;
+  BIO_get_mem_ptr(bio, &bptr);
+
+  uint8_t* data = new uint8_t[bptr->length];
+  memcpy(data, bptr->data, bptr->length);
+  size_t len = bptr->length;
+
+  BIO_free(bio);
+
+  return std::make_shared<NativeArrayBuffer>(data, len, [=]() { delete[] data; });
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> HybridMlKemKeyPair::getPrivateKey() {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#else
+  checkKeyPair();
+
+  BIO* bio = BIO_new(BIO_s_mem());
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for private key export");
+  }
+
+  int result;
+  if (privateFormat_ == 1) {
+    result = PEM_write_bio_PrivateKey(bio, pkey_.get(), nullptr, nullptr, 0, nullptr, nullptr);
+  } else {
+    result = i2d_PKCS8PrivateKey_bio(bio, pkey_.get(), nullptr, nullptr, 0, nullptr, nullptr);
+  }
+
+  if (result != 1) {
+    BIO_free(bio);
+    throw std::runtime_error("Failed to export private key: " + getOpenSSLError());
+  }
+
+  BUF_MEM* bptr;
+  BIO_get_mem_ptr(bio, &bptr);
+
+  uint8_t* data = new uint8_t[bptr->length];
+  memcpy(data, bptr->data, bptr->length);
+  size_t len = bptr->length;
+
+  BIO_free(bio);
+
+  return std::make_shared<NativeArrayBuffer>(data, len, [=]() { delete[] data; });
+#endif
+}
+
+void HybridMlKemKeyPair::setPublicKey(const std::shared_ptr<ArrayBuffer>& keyData, double format, double type) {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+
+  if (variant_.empty()) {
+    throw std::runtime_error("ML-KEM variant not set. Call setVariant() first.");
+  }
+
+  publicFormat_ = static_cast<int>(format);
+  publicType_ = static_cast<int>(type);
+
+  BIO* bio = BIO_new_mem_buf(keyData->data(), static_cast<int>(keyData->size()));
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for public key import");
+  }
+
+  EVP_PKEY* importedKey = nullptr;
+  if (publicFormat_ == 1) {
+    importedKey = PEM_read_bio_PUBKEY(bio, nullptr, nullptr, nullptr);
+  } else {
+    importedKey = d2i_PUBKEY_bio(bio, nullptr);
+  }
+
+  BIO_free(bio);
+
+  if (importedKey == nullptr) {
+    throw std::runtime_error("Failed to import public key: " + getOpenSSLError());
+  }
+
+  pkey_.reset(importedKey);
+#endif
+}
+
+void HybridMlKemKeyPair::setPrivateKey(const std::shared_ptr<ArrayBuffer>& keyData, double format, double type) {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+
+  if (variant_.empty()) {
+    throw std::runtime_error("ML-KEM variant not set. Call setVariant() first.");
+  }
+
+  privateFormat_ = static_cast<int>(format);
+  privateType_ = static_cast<int>(type);
+
+  BIO* bio = BIO_new_mem_buf(keyData->data(), static_cast<int>(keyData->size()));
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for private key import");
+  }
+
+  EVP_PKEY* importedKey = nullptr;
+  if (privateFormat_ == 1) {
+    importedKey = PEM_read_bio_PrivateKey(bio, nullptr, nullptr, nullptr);
+  } else {
+    importedKey = d2i_PrivateKey_bio(bio, nullptr);
+  }
+
+  BIO_free(bio);
+
+  if (importedKey == nullptr) {
+    throw std::runtime_error("Failed to import private key: " + getOpenSSLError());
+  }
+
+  pkey_.reset(importedKey);
+#endif
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridMlKemKeyPair::encapsulate() {
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this]() { return this->encapsulateSync(); });
+}
+
+std::shared_ptr<ArrayBuffer> HybridMlKemKeyPair::encapsulateSync() {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+  checkKeyPair();
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey_.get(), nullptr);
+  if (ctx == nullptr) {
+    throw std::runtime_error("Failed to create encapsulation context: " + getOpenSSLError());
+  }
+
+  if (EVP_PKEY_encapsulate_init(ctx, nullptr) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to initialize encapsulation: " + getOpenSSLError());
+  }
+
+  size_t ct_len = 0;
+  size_t sk_len = 0;
+  if (EVP_PKEY_encapsulate(ctx, nullptr, &ct_len, nullptr, &sk_len) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to determine encapsulation output sizes: " + getOpenSSLError());
+  }
+
+  // Pack result as: [uint32 ct_len][uint32 sk_len][ciphertext][shared_key]
+  size_t header_size = sizeof(uint32_t) * 2;
+  size_t total_size = header_size + ct_len + sk_len;
+  uint8_t* out = new uint8_t[total_size];
+
+  uint32_t ct_len_u32 = static_cast<uint32_t>(ct_len);
+  uint32_t sk_len_u32 = static_cast<uint32_t>(sk_len);
+  memcpy(out, &ct_len_u32, sizeof(uint32_t));
+  memcpy(out + sizeof(uint32_t), &sk_len_u32, sizeof(uint32_t));
+
+  uint8_t* ct_data = out + header_size;
+  uint8_t* sk_data = ct_data + ct_len;
+
+  if (EVP_PKEY_encapsulate(ctx, ct_data, &ct_len, sk_data, &sk_len) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    delete[] out;
+    throw std::runtime_error("Failed to encapsulate: " + getOpenSSLError());
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+
+  return std::make_shared<NativeArrayBuffer>(out, total_size, [=]() { delete[] out; });
+#endif
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridMlKemKeyPair::decapsulate(const std::shared_ptr<ArrayBuffer>& ciphertext) {
+  auto nativeCiphertext = ToNativeArrayBuffer(ciphertext);
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, nativeCiphertext]() { return this->decapsulateSync(nativeCiphertext); });
+}
+
+std::shared_ptr<ArrayBuffer> HybridMlKemKeyPair::decapsulateSync(const std::shared_ptr<ArrayBuffer>& ciphertext) {
+#if !RNQC_HAS_ML_KEM
+  throw std::runtime_error("ML-KEM requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+  checkKeyPair();
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey_.get(), nullptr);
+  if (ctx == nullptr) {
+    throw std::runtime_error("Failed to create decapsulation context: " + getOpenSSLError());
+  }
+
+  if (EVP_PKEY_decapsulate_init(ctx, nullptr) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to initialize decapsulation: " + getOpenSSLError());
+  }
+
+  const uint8_t* ct_data = ciphertext->data();
+  size_t ct_size = ciphertext->size();
+
+  size_t sk_len = 0;
+  if (EVP_PKEY_decapsulate(ctx, nullptr, &sk_len, ct_data, ct_size) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to determine shared key size: " + getOpenSSLError());
+  }
+
+  uint8_t* sk_data = new uint8_t[sk_len];
+
+  if (EVP_PKEY_decapsulate(ctx, sk_data, &sk_len, ct_data, ct_size) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    delete[] sk_data;
+    throw std::runtime_error("Failed to decapsulate: " + getOpenSSLError());
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+
+  return std::make_shared<NativeArrayBuffer>(sk_data, sk_len, [=]() { delete[] sk_data; });
+#endif
+}
+
+void HybridMlKemKeyPair::checkKeyPair() {
+  if (!pkey_) {
+    throw std::runtime_error("Key pair not initialized");
+  }
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/mlkem/HybridMlKemKeyPair.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <openssl/evp.h>
+#include <string>
+
+#include "HybridMlKemKeyPairSpec.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridMlKemKeyPair : public HybridMlKemKeyPairSpec {
+ public:
+  HybridMlKemKeyPair() : HybridObject(TAG) {}
+  ~HybridMlKemKeyPair() override = default;
+
+  void setVariant(const std::string& variant) override;
+
+  std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType) override;
+  void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType) override;
+
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+
+  void setPublicKey(const std::shared_ptr<ArrayBuffer>& keyData, double format, double type) override;
+  void setPrivateKey(const std::shared_ptr<ArrayBuffer>& keyData, double format, double type) override;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> encapsulate() override;
+  std::shared_ptr<ArrayBuffer> encapsulateSync() override;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> decapsulate(const std::shared_ptr<ArrayBuffer>& ciphertext) override;
+  std::shared_ptr<ArrayBuffer> decapsulateSync(const std::shared_ptr<ArrayBuffer>& ciphertext) override;
+
+ private:
+  std::string variant_;
+
+  using EVP_PKEY_ptr = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>;
+  EVP_PKEY_ptr pkey_{nullptr, EVP_PKEY_free};
+
+  int publicFormat_ = -1;
+  int publicType_ = -1;
+  int privateFormat_ = -1;
+  int privateType_ = -1;
+
+  void checkKeyPair();
+};
+
+} // namespace margelo::nitro::crypto