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

package/cpp/mldsa/HybridMlDsaKeyPair.cpp

@@ -0,0 +1,243 @@
+#include "HybridMlDsaKeyPair.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_DSA 1
+#else
+#define RNQC_HAS_ML_DSA 0
+#endif
+
+namespace margelo::nitro::crypto {
+
+using EVP_MD_CTX_ptr = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>;
+using EVP_PKEY_CTX_ptr = std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)>;
+
+int HybridMlDsaKeyPair::getEvpPkeyType() const {
+#if RNQC_HAS_ML_DSA
+  if (variant_ == "ML-DSA-44")
+    return EVP_PKEY_ML_DSA_44;
+  if (variant_ == "ML-DSA-65")
+    return EVP_PKEY_ML_DSA_65;
+  if (variant_ == "ML-DSA-87")
+    return EVP_PKEY_ML_DSA_87;
+#endif
+  return 0;
+}
+
+void HybridMlDsaKeyPair::setVariant(const std::string& variant) {
+#if !RNQC_HAS_ML_DSA
+  throw std::runtime_error("ML-DSA requires OpenSSL 3.5+");
+#endif
+  if (variant != "ML-DSA-44" && variant != "ML-DSA-65" && variant != "ML-DSA-87") {
+    throw std::runtime_error("Invalid ML-DSA variant: " + variant + ". Must be ML-DSA-44, ML-DSA-65, or ML-DSA-87");
+  }
+  variant_ = variant;
+}
+
+std::shared_ptr<Promise<void>> HybridMlDsaKeyPair::generateKeyPair(double publicFormat, double publicType, double privateFormat,
+                                                                   double privateType) {
+  auto self = this->shared_cast<HybridMlDsaKeyPair>();
+  return Promise<void>::async([self, publicFormat, publicType, privateFormat, privateType]() {
+    self->generateKeyPairSync(publicFormat, publicType, privateFormat, privateType);
+  });
+}
+
+void HybridMlDsaKeyPair::generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType) {
+#if !RNQC_HAS_ML_DSA
+  throw std::runtime_error("ML-DSA requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+
+  if (variant_.empty()) {
+    throw std::runtime_error("ML-DSA 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_ptr pctx(EVP_PKEY_CTX_new_from_name(nullptr, variant_.c_str(), nullptr), EVP_PKEY_CTX_free);
+  if (pctx == nullptr) {
+    throw std::runtime_error("Failed to create key context for " + variant_ + ": " + getOpenSSLError());
+  }
+
+  if (EVP_PKEY_keygen_init(pctx.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize keygen: " + getOpenSSLError());
+  }
+
+  EVP_PKEY* raw = nullptr;
+  if (EVP_PKEY_keygen(pctx.get(), &raw) <= 0) {
+    throw std::runtime_error("Failed to generate ML-DSA key pair: " + getOpenSSLError());
+  }
+  pkey_.reset(raw);
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> HybridMlDsaKeyPair::getPublicKey() {
+#if !RNQC_HAS_ML_DSA
+  throw std::runtime_error("ML-DSA 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);
+
+  size_t len = bptr->length;
+  auto buf = std::make_unique<uint8_t[]>(len);
+  memcpy(buf.get(), bptr->data, len);
+
+  BIO_free(bio);
+
+  uint8_t* raw_ptr = buf.get();
+  return std::make_shared<NativeArrayBuffer>(buf.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> HybridMlDsaKeyPair::getPrivateKey() {
+#if !RNQC_HAS_ML_DSA
+  throw std::runtime_error("ML-DSA 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);
+
+  size_t len = bptr->length;
+  auto buf = std::make_unique<uint8_t[]>(len);
+  memcpy(buf.get(), bptr->data, len);
+
+  // Wipe the private key bytes from the BIO before freeing.
+  secureZero(bptr->data, bptr->length);
+  BIO_free(bio);
+
+  uint8_t* raw_ptr = buf.get();
+  return std::make_shared<NativeArrayBuffer>(buf.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+#endif
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridMlDsaKeyPair::sign(const std::shared_ptr<ArrayBuffer>& message) {
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  auto self = this->shared_cast<HybridMlDsaKeyPair>();
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([self, nativeMessage]() { return self->signSync(nativeMessage); });
+}
+
+std::shared_ptr<ArrayBuffer> HybridMlDsaKeyPair::signSync(const std::shared_ptr<ArrayBuffer>& message) {
+#if !RNQC_HAS_ML_DSA
+  throw std::runtime_error("ML-DSA requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+  checkKeyPair();
+
+  EVP_MD_CTX_ptr md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
+  if (md_ctx == nullptr) {
+    throw std::runtime_error("Failed to create signing context");
+  }
+
+  // Pass nullptr — EVP_DigestSignInit allocates the matching PKEY_CTX from
+  // pkey_ and the EVP_MD_CTX takes ownership of it.
+  if (EVP_DigestSignInit(md_ctx.get(), nullptr, nullptr, nullptr, pkey_.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize signing: " + getOpenSSLError());
+  }
+
+  size_t sig_len = 0;
+  if (EVP_DigestSign(md_ctx.get(), nullptr, &sig_len, message->data(), message->size()) <= 0) {
+    throw std::runtime_error("Failed to calculate signature size: " + getOpenSSLError());
+  }
+
+  auto sig = std::make_unique<uint8_t[]>(sig_len);
+
+  if (EVP_DigestSign(md_ctx.get(), sig.get(), &sig_len, message->data(), message->size()) <= 0) {
+    throw std::runtime_error("Failed to sign message: " + getOpenSSLError());
+  }
+
+  uint8_t* raw_ptr = sig.get();
+  return std::make_shared<NativeArrayBuffer>(sig.release(), sig_len, [raw_ptr]() { delete[] raw_ptr; });
+#endif
+}
+
+std::shared_ptr<Promise<bool>> HybridMlDsaKeyPair::verify(const std::shared_ptr<ArrayBuffer>& signature,
+                                                          const std::shared_ptr<ArrayBuffer>& message) {
+  auto nativeSignature = ToNativeArrayBuffer(signature);
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  auto self = this->shared_cast<HybridMlDsaKeyPair>();
+  return Promise<bool>::async([self, nativeSignature, nativeMessage]() { return self->verifySync(nativeSignature, nativeMessage); });
+}
+
+bool HybridMlDsaKeyPair::verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) {
+#if !RNQC_HAS_ML_DSA
+  throw std::runtime_error("ML-DSA requires OpenSSL 3.5+");
+#else
+  clearOpenSSLErrors();
+  checkKeyPair();
+
+  EVP_MD_CTX_ptr md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
+  if (md_ctx == nullptr) {
+    throw std::runtime_error("Failed to create verify context");
+  }
+
+  // Pass nullptr — EVP_DigestVerifyInit allocates the matching PKEY_CTX from
+  // pkey_ and the EVP_MD_CTX takes ownership of it.
+  if (EVP_DigestVerifyInit(md_ctx.get(), nullptr, nullptr, nullptr, pkey_.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize verification: " + getOpenSSLError());
+  }
+
+  int result = EVP_DigestVerify(md_ctx.get(), signature->data(), signature->size(), message->data(), message->size());
+
+  if (result < 0) {
+    throw std::runtime_error("Verification error: " + getOpenSSLError());
+  }
+
+  return result == 1;
+#endif
+}
+
+void HybridMlDsaKeyPair::checkKeyPair() {
+  if (!pkey_) {
+    throw std::runtime_error("Key pair not initialized");
+  }
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/mldsa/HybridMlDsaKeyPair.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <memory>
+#include <openssl/evp.h>
+#include <string>
+
+#include "HybridMlDsaKeyPairSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridMlDsaKeyPair : public HybridMlDsaKeyPairSpec {
+ public:
+  HybridMlDsaKeyPair() : HybridObject(TAG) {}
+  ~HybridMlDsaKeyPair() override = default;
+
+  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;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> sign(const std::shared_ptr<ArrayBuffer>& message) override;
+
+  std::shared_ptr<ArrayBuffer> signSync(const std::shared_ptr<ArrayBuffer>& message) override;
+
+  std::shared_ptr<Promise<bool>> verify(const std::shared_ptr<ArrayBuffer>& signature,
+                                        const std::shared_ptr<ArrayBuffer>& message) override;
+
+  bool verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) override;
+
+  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_ptr pkey_{nullptr, EVP_PKEY_free};
+
+  int publicFormat_ = -1;
+  int publicType_ = -1;
+  int privateFormat_ = -1;
+  int privateType_ = -1;
+
+  void checkKeyPair();
+  int getEvpPkeyType() const;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/mlkem/HybridMlKemKeyPair.cpp

@@ -0,0 +1,315 @@
+#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 {
+
+using EVP_PKEY_CTX_ptr = std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)>;
+
+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) {
+  auto self = this->shared_cast<HybridMlKemKeyPair>();
+  return Promise<void>::async([self, publicFormat, publicType, privateFormat, privateType]() {
+    self->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_ptr pctx(EVP_PKEY_CTX_new_from_name(nullptr, variant_.c_str(), nullptr), EVP_PKEY_CTX_free);
+  if (pctx == nullptr) {
+    throw std::runtime_error("Failed to create key context for " + variant_ + ": " + getOpenSSLError());
+  }
+
+  if (EVP_PKEY_keygen_init(pctx.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize keygen: " + getOpenSSLError());
+  }
+
+  EVP_PKEY* raw = nullptr;
+  if (EVP_PKEY_keygen(pctx.get(), &raw) <= 0) {
+    throw std::runtime_error("Failed to generate ML-KEM key pair: " + getOpenSSLError());
+  }
+
+  pkey_.reset(raw);
+#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);
+
+  size_t len = bptr->length;
+  auto buf = std::make_unique<uint8_t[]>(len);
+  memcpy(buf.get(), bptr->data, len);
+
+  BIO_free(bio);
+
+  uint8_t* raw_ptr = buf.get();
+  return std::make_shared<NativeArrayBuffer>(buf.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+#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);
+
+  size_t len = bptr->length;
+  auto buf = std::make_unique<uint8_t[]>(len);
+  memcpy(buf.get(), bptr->data, len);
+
+  // Wipe the private key bytes from the BIO before freeing.
+  secureZero(bptr->data, bptr->length);
+  BIO_free(bio);
+
+  uint8_t* raw_ptr = buf.get();
+  return std::make_shared<NativeArrayBuffer>(buf.release(), len, [raw_ptr]() { delete[] raw_ptr; });
+#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() {
+  auto self = this->shared_cast<HybridMlKemKeyPair>();
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([self]() { return self->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_ptr ctx(EVP_PKEY_CTX_new(pkey_.get(), nullptr), EVP_PKEY_CTX_free);
+  if (ctx == nullptr) {
+    throw std::runtime_error("Failed to create encapsulation context: " + getOpenSSLError());
+  }
+
+  if (EVP_PKEY_encapsulate_init(ctx.get(), nullptr) <= 0) {
+    throw std::runtime_error("Failed to initialize encapsulation: " + getOpenSSLError());
+  }
+
+  size_t ct_len = 0;
+  size_t sk_len = 0;
+  if (EVP_PKEY_encapsulate(ctx.get(), nullptr, &ct_len, nullptr, &sk_len) <= 0) {
+    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;
+  auto out = std::make_unique<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.get(), &ct_len_u32, sizeof(uint32_t));
+  memcpy(out.get() + sizeof(uint32_t), &sk_len_u32, sizeof(uint32_t));
+
+  uint8_t* ct_data = out.get() + header_size;
+  uint8_t* sk_data = ct_data + ct_len;
+
+  if (EVP_PKEY_encapsulate(ctx.get(), ct_data, &ct_len, sk_data, &sk_len) <= 0) {
+    throw std::runtime_error("Failed to encapsulate: " + getOpenSSLError());
+  }
+
+  uint8_t* raw_ptr = out.get();
+  return std::make_shared<NativeArrayBuffer>(out.release(), total_size, [raw_ptr]() { delete[] raw_ptr; });
+#endif
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridMlKemKeyPair::decapsulate(const std::shared_ptr<ArrayBuffer>& ciphertext) {
+  auto nativeCiphertext = ToNativeArrayBuffer(ciphertext);
+  auto self = this->shared_cast<HybridMlKemKeyPair>();
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([self, nativeCiphertext]() { return self->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_ptr ctx(EVP_PKEY_CTX_new(pkey_.get(), nullptr), EVP_PKEY_CTX_free);
+  if (ctx == nullptr) {
+    throw std::runtime_error("Failed to create decapsulation context: " + getOpenSSLError());
+  }
+
+  if (EVP_PKEY_decapsulate_init(ctx.get(), nullptr) <= 0) {
+    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.get(), nullptr, &sk_len, ct_data, ct_size) <= 0) {
+    throw std::runtime_error("Failed to determine shared key size: " + getOpenSSLError());
+  }
+
+  auto sk_buf = std::make_unique<uint8_t[]>(sk_len);
+
+  if (EVP_PKEY_decapsulate(ctx.get(), sk_buf.get(), &sk_len, ct_data, ct_size) <= 0) {
+    throw std::runtime_error("Failed to decapsulate: " + getOpenSSLError());
+  }
+
+  uint8_t* raw_ptr = sk_buf.get();
+  return std::make_shared<NativeArrayBuffer>(sk_buf.release(), sk_len, [raw_ptr]() { delete[] raw_ptr; });
+#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