@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/cpp/cipher/HybridCipher.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <openssl/core_names.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/param_build.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "CipherInfo.hpp"
+#include "HybridCipherSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+// Default tag length for OCB, SIV, CCM, ChaCha20-Poly1305
+constexpr unsigned kDefaultAuthTagLength = 16;
+
+class HybridCipher : public HybridCipherSpec {
+ public:
+  HybridCipher() : HybridObject(TAG) {}
+  ~HybridCipher() override;
+
+ public:
+  // Methods
+  std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) override;
+
+  std::shared_ptr<ArrayBuffer> final() override;
+
+  virtual void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv);
+
+  void setArgs(const CipherArgs& args) override;
+
+  bool setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) override;
+
+  bool setAutoPadding(bool autoPad) override;
+
+  bool setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) override;
+
+  std::shared_ptr<ArrayBuffer> getAuthTag() override;
+
+  std::vector<std::string> getSupportedCiphers() override;
+
+  std::optional<CipherInfo> getCipherInfo(const std::string& name, std::optional<double> keyLength,
+                                          std::optional<double> ivLength) override;
+
+ protected:
+  // Protected enums for state management
+  enum CipherKind { kCipher, kDecipher };
+  enum UpdateResult { kSuccess, kErrorMessageSize, kErrorState };
+  enum AuthTagState { kAuthTagUnknown, kAuthTagKnown, kAuthTagPassedToOpenSSL };
+
+ protected:
+  // Properties
+  bool is_cipher = true;
+  bool is_finalized = false;
+  std::string cipher_type;
+  EVP_CIPHER_CTX* ctx = nullptr;
+  bool pending_auth_failed = false;
+  bool has_aad = false;
+  uint8_t auth_tag[EVP_GCM_TLS_TAG_LEN];
+  AuthTagState auth_tag_state;
+  unsigned int auth_tag_len = 0;
+  int max_message_size;
+
+ protected:
+  // Methods
+  int getMode();
+  void checkCtx() const;
+  void checkNotFinalized() const;
+  bool maybePassAuthTagToOpenSSL();
+};
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/cipher/HybridCipherFactory.hpp

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <memory>
+#include <openssl/evp.h>
+#include <string>
+
+#include "CCMCipher.hpp"
+#include "ChaCha20Cipher.hpp"
+#include "ChaCha20Poly1305Cipher.hpp"
+#include "GCMCipher.hpp"
+#include "HybridCipherFactorySpec.hpp"
+#include "OCBCipher.hpp"
+#include "QuickCryptoUtils.hpp"
+#include "XChaCha20Poly1305Cipher.hpp"
+#include "XSalsa20Cipher.hpp"
+#include "XSalsa20Poly1305Cipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridCipherFactory : public HybridCipherFactorySpec {
+ public:
+  HybridCipherFactory() : HybridObject(TAG) {}
+  ~HybridCipherFactory() = default;
+
+ public:
+  // Factory method exposed to JS
+  inline std::shared_ptr<HybridCipherSpec> createCipher(const CipherArgs& args) {
+    // Create the appropriate cipher instance based on mode
+    std::shared_ptr<HybridCipher> cipherInstance;
+
+    // OpenSSL
+    // temporary cipher context to determine the mode
+    EVP_CIPHER* cipher = EVP_CIPHER_fetch(nullptr, args.cipherType.c_str(), nullptr);
+    if (cipher) {
+      int mode = EVP_CIPHER_get_mode(cipher);
+
+      switch (mode) {
+        case EVP_CIPH_OCB_MODE: {
+          cipherInstance = std::make_shared<OCBCipher>();
+          cipherInstance->setArgs(args);
+          // Pass tag length (default 16 if not present)
+          size_t tag_len = args.authTagLen.has_value() ? static_cast<size_t>(args.authTagLen.value()) : 16;
+          std::static_pointer_cast<OCBCipher>(cipherInstance)->init(args.cipherKey, args.iv, tag_len);
+          EVP_CIPHER_free(cipher);
+          return cipherInstance;
+        }
+        case EVP_CIPH_CCM_MODE: {
+          cipherInstance = std::make_shared<CCMCipher>();
+          cipherInstance->setArgs(args);
+          cipherInstance->init(args.cipherKey, args.iv);
+          EVP_CIPHER_free(cipher);
+          return cipherInstance;
+        }
+        case EVP_CIPH_GCM_MODE: {
+          cipherInstance = std::make_shared<GCMCipher>();
+          cipherInstance->setArgs(args);
+          cipherInstance->init(args.cipherKey, args.iv);
+          EVP_CIPHER_free(cipher);
+          return cipherInstance;
+        }
+        case EVP_CIPH_STREAM_CIPHER: {
+          // Check for ChaCha20 variants specifically
+          std::string cipherName = toLower(args.cipherType);
+          if (cipherName == "chacha20") {
+            cipherInstance = std::make_shared<ChaCha20Cipher>();
+            cipherInstance->setArgs(args);
+            cipherInstance->init(args.cipherKey, args.iv);
+            EVP_CIPHER_free(cipher);
+            return cipherInstance;
+          }
+          if (cipherName == "chacha20-poly1305") {
+            cipherInstance = std::make_shared<ChaCha20Poly1305Cipher>();
+            cipherInstance->setArgs(args);
+            cipherInstance->init(args.cipherKey, args.iv);
+            EVP_CIPHER_free(cipher);
+            return cipherInstance;
+          }
+        }
+        default: {
+          // Default case for other ciphers
+          cipherInstance = std::make_shared<HybridCipher>();
+          cipherInstance->setArgs(args);
+          cipherInstance->init(args.cipherKey, args.iv);
+          EVP_CIPHER_free(cipher);
+          return cipherInstance;
+        }
+      }
+    }
+    EVP_CIPHER_free(cipher);
+
+    // libsodium ciphers
+    std::string cipherName = toLower(args.cipherType);
+    if (cipherName == "xsalsa20") {
+      cipherInstance = std::make_shared<XSalsa20Cipher>();
+      cipherInstance->setArgs(args);
+      cipherInstance->init(args.cipherKey, args.iv);
+      return cipherInstance;
+    }
+    if (cipherName == "xsalsa20-poly1305") {
+      cipherInstance = std::make_shared<XSalsa20Poly1305Cipher>();
+      cipherInstance->setArgs(args);
+      cipherInstance->init(args.cipherKey, args.iv);
+      return cipherInstance;
+    }
+    if (cipherName == "xchacha20-poly1305") {
+      cipherInstance = std::make_shared<XChaCha20Poly1305Cipher>();
+      cipherInstance->setArgs(args);
+      cipherInstance->init(args.cipherKey, args.iv);
+      return cipherInstance;
+    }
+
+    // Unsupported cipher type
+    throw std::runtime_error("Unsupported or unknown cipher type: " + args.cipherType);
+  }
+};
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/cipher/HybridRsaCipher.cpp

@@ -0,0 +1,440 @@
+#include "HybridRsaCipher.hpp"
+#include "../keys/HybridKeyObjectHandle.hpp"
+#include "QuickCryptoUtils.hpp"
+
+#include <cstring>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+
+namespace margelo::nitro::crypto {
+
+using margelo::nitro::NativeArrayBuffer;
+
+constexpr int kRsaPkcs1Padding = 1;
+constexpr int kRsaOaepPadding = 4;
+
+int toOpenSSLPadding(int padding) {
+  switch (padding) {
+    case kRsaPkcs1Padding:
+      return RSA_PKCS1_PADDING;
+    case kRsaOaepPadding:
+      return RSA_PKCS1_OAEP_PADDING;
+    default:
+      throw std::runtime_error("Unsupported padding mode: " + std::to_string(padding));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaCipher::encrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                                      const std::shared_ptr<ArrayBuffer>& data, double padding,
+                                                      const std::string& hashAlgorithm,
+                                                      const std::optional<std::shared_ptr<ArrayBuffer>>& label) {
+  auto keyHandleImpl = std::static_pointer_cast<HybridKeyObjectHandle>(keyHandle);
+  EVP_PKEY* pkey = keyHandleImpl->getKeyObjectData().GetAsymmetricKey().get();
+
+  if (!pkey) {
+    throw std::runtime_error("Invalid key for RSA encryption");
+  }
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+  if (!ctx) {
+    throw std::runtime_error("Failed to create EVP_PKEY_CTX");
+  }
+
+  if (EVP_PKEY_encrypt_init(ctx) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to initialize encryption: " + std::string(err_buf));
+  }
+
+  int paddingInt = static_cast<int>(padding);
+  int opensslPadding = toOpenSSLPadding(paddingInt);
+
+  if (EVP_PKEY_CTX_set_rsa_padding(ctx, opensslPadding) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to set RSA padding");
+  }
+
+  if (paddingInt == kRsaOaepPadding) {
+    const EVP_MD* md = getDigestByName(hashAlgorithm);
+    if (EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) <= 0) {
+      EVP_PKEY_CTX_free(ctx);
+      throw std::runtime_error("Failed to set OAEP hash algorithm");
+    }
+
+    if (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) <= 0) {
+      EVP_PKEY_CTX_free(ctx);
+      throw std::runtime_error("Failed to set MGF1 hash algorithm");
+    }
+
+    if (label.has_value() && label.value()->size() > 0) {
+      auto native_label = ToNativeArrayBuffer(label.value());
+      unsigned char* label_copy = (unsigned char*)OPENSSL_malloc(native_label->size());
+      if (!label_copy) {
+        EVP_PKEY_CTX_free(ctx);
+        throw std::runtime_error("Failed to allocate memory for label");
+      }
+      std::memcpy(label_copy, native_label->data(), native_label->size());
+
+      if (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, label_copy, native_label->size()) <= 0) {
+        OPENSSL_free(label_copy);
+        EVP_PKEY_CTX_free(ctx);
+        throw std::runtime_error("Failed to set OAEP label");
+      }
+    }
+  }
+
+  auto native_data = ToNativeArrayBuffer(data);
+  const unsigned char* in = native_data->data();
+  size_t inlen = native_data->size();
+
+  size_t outlen;
+  if (EVP_PKEY_encrypt(ctx, nullptr, &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to determine output length: " + std::string(err_buf));
+  }
+
+  auto out_buf = std::make_unique<uint8_t[]>(outlen);
+
+  if (EVP_PKEY_encrypt(ctx, out_buf.get(), &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Encryption failed: " + std::string(err_buf));
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), outlen, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaCipher::decrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                                      const std::shared_ptr<ArrayBuffer>& data, double padding,
+                                                      const std::string& hashAlgorithm,
+                                                      const std::optional<std::shared_ptr<ArrayBuffer>>& label) {
+  auto keyHandleImpl = std::static_pointer_cast<HybridKeyObjectHandle>(keyHandle);
+  EVP_PKEY* pkey = keyHandleImpl->getKeyObjectData().GetAsymmetricKey().get();
+
+  if (!pkey) {
+    throw std::runtime_error("Invalid key for RSA decryption");
+  }
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+  if (!ctx) {
+    throw std::runtime_error("Failed to create EVP_PKEY_CTX");
+  }
+
+  if (EVP_PKEY_decrypt_init(ctx) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to initialize decryption: " + std::string(err_buf));
+  }
+
+  int paddingInt = static_cast<int>(padding);
+  int opensslPadding = toOpenSSLPadding(paddingInt);
+
+  if (EVP_PKEY_CTX_set_rsa_padding(ctx, opensslPadding) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to set RSA padding");
+  }
+
+  if (paddingInt == kRsaOaepPadding) {
+    const EVP_MD* md = getDigestByName(hashAlgorithm);
+    if (EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) <= 0) {
+      EVP_PKEY_CTX_free(ctx);
+      throw std::runtime_error("Failed to set OAEP hash algorithm");
+    }
+
+    if (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) <= 0) {
+      EVP_PKEY_CTX_free(ctx);
+      throw std::runtime_error("Failed to set MGF1 hash algorithm");
+    }
+
+    if (label.has_value() && label.value()->size() > 0) {
+      auto native_label = ToNativeArrayBuffer(label.value());
+      unsigned char* label_copy = (unsigned char*)OPENSSL_malloc(native_label->size());
+      if (!label_copy) {
+        EVP_PKEY_CTX_free(ctx);
+        throw std::runtime_error("Failed to allocate memory for label");
+      }
+      std::memcpy(label_copy, native_label->data(), native_label->size());
+
+      if (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, label_copy, native_label->size()) <= 0) {
+        OPENSSL_free(label_copy);
+        EVP_PKEY_CTX_free(ctx);
+        throw std::runtime_error("Failed to set OAEP label");
+      }
+    }
+  }
+
+  auto native_data = ToNativeArrayBuffer(data);
+  const unsigned char* in = native_data->data();
+  size_t inlen = native_data->size();
+
+  size_t outlen;
+  if (EVP_PKEY_decrypt(ctx, nullptr, &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to determine output length: " + std::string(err_buf));
+  }
+
+  auto out_buf = std::make_unique<uint8_t[]>(outlen);
+
+  if (EVP_PKEY_decrypt(ctx, out_buf.get(), &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Decryption failed: " + std::string(err_buf));
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), outlen, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaCipher::publicDecrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                                            const std::shared_ptr<ArrayBuffer>& data, double padding) {
+  auto keyHandleImpl = std::static_pointer_cast<HybridKeyObjectHandle>(keyHandle);
+  EVP_PKEY* pkey = keyHandleImpl->getKeyObjectData().GetAsymmetricKey().get();
+
+  if (!pkey) {
+    throw std::runtime_error("Invalid key for RSA public decryption");
+  }
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+  if (!ctx) {
+    throw std::runtime_error("Failed to create EVP_PKEY_CTX");
+  }
+
+  if (EVP_PKEY_verify_recover_init(ctx) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to initialize verify recover: " + std::string(err_buf));
+  }
+
+  int paddingInt = static_cast<int>(padding);
+  int opensslPadding = toOpenSSLPadding(paddingInt);
+
+  if (EVP_PKEY_CTX_set_rsa_padding(ctx, opensslPadding) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to set RSA padding");
+  }
+
+  auto native_data = ToNativeArrayBuffer(data);
+  const unsigned char* in = native_data->data();
+  size_t inlen = native_data->size();
+
+  size_t outlen;
+  if (EVP_PKEY_verify_recover(ctx, nullptr, &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to determine output length: " + std::string(err_buf));
+  }
+
+  if (outlen == 0) {
+    EVP_PKEY_CTX_free(ctx);
+    uint8_t* empty_buf = new uint8_t[1];
+    return std::make_shared<NativeArrayBuffer>(empty_buf, 0, [empty_buf]() { delete[] empty_buf; });
+  }
+
+  auto out_buf = std::make_unique<uint8_t[]>(outlen);
+
+  if (EVP_PKEY_verify_recover(ctx, out_buf.get(), &outlen, in, inlen) <= 0) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+
+    if ((err & 0xFFFFFFF) == 0x1C880004 || (err & 0xFF) == 0x04) {
+      ERR_clear_error();
+      EVP_PKEY_CTX_free(ctx);
+      uint8_t* empty_buf = new uint8_t[1];
+      return std::make_shared<NativeArrayBuffer>(empty_buf, 0, [empty_buf]() { delete[] empty_buf; });
+    }
+
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Public decryption failed: " + std::string(err_buf));
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), outlen, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaCipher::privateEncrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                                             const std::shared_ptr<ArrayBuffer>& data, double padding) {
+  auto keyHandleImpl = std::static_pointer_cast<HybridKeyObjectHandle>(keyHandle);
+  EVP_PKEY* pkey = keyHandleImpl->getKeyObjectData().GetAsymmetricKey().get();
+
+  if (!pkey) {
+    throw std::runtime_error("Invalid key for RSA private encryption");
+  }
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+  if (!ctx) {
+    throw std::runtime_error("Failed to create EVP_PKEY_CTX");
+  }
+
+  if (EVP_PKEY_sign_init(ctx) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to initialize signing: " + std::string(err_buf));
+  }
+
+  int paddingInt = static_cast<int>(padding);
+  int opensslPadding = toOpenSSLPadding(paddingInt);
+
+  if (EVP_PKEY_CTX_set_rsa_padding(ctx, opensslPadding) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to set RSA padding");
+  }
+
+  auto native_data = ToNativeArrayBuffer(data);
+  const unsigned char* in = native_data->data();
+  size_t inlen = native_data->size();
+
+  size_t outlen;
+  if (EVP_PKEY_sign(ctx, nullptr, &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to determine output length: " + std::string(err_buf));
+  }
+
+  auto out_buf = std::make_unique<uint8_t[]>(outlen);
+
+  if (EVP_PKEY_sign(ctx, out_buf.get(), &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Private encryption failed: " + std::string(err_buf));
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), outlen, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaCipher::privateDecrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                                             const std::shared_ptr<ArrayBuffer>& data, double padding,
+                                                             const std::string& hashAlgorithm,
+                                                             const std::optional<std::shared_ptr<ArrayBuffer>>& label) {
+  auto keyHandleImpl = std::static_pointer_cast<HybridKeyObjectHandle>(keyHandle);
+  EVP_PKEY* pkey = keyHandleImpl->getKeyObjectData().GetAsymmetricKey().get();
+
+  if (!pkey) {
+    throw std::runtime_error("Invalid key for RSA private decryption");
+  }
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+  if (!ctx) {
+    throw std::runtime_error("Failed to create EVP_PKEY_CTX");
+  }
+
+  if (EVP_PKEY_decrypt_init(ctx) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to initialize decryption: " + std::string(err_buf));
+  }
+
+  int paddingInt = static_cast<int>(padding);
+  int opensslPadding = toOpenSSLPadding(paddingInt);
+
+  if (EVP_PKEY_CTX_set_rsa_padding(ctx, opensslPadding) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    throw std::runtime_error("Failed to set RSA padding");
+  }
+
+  if (paddingInt == kRsaOaepPadding) {
+    const EVP_MD* md = getDigestByName(hashAlgorithm);
+    if (EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) <= 0) {
+      EVP_PKEY_CTX_free(ctx);
+      throw std::runtime_error("Failed to set OAEP hash algorithm");
+    }
+
+    if (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) <= 0) {
+      EVP_PKEY_CTX_free(ctx);
+      throw std::runtime_error("Failed to set MGF1 hash algorithm");
+    }
+
+    if (label.has_value() && label.value()->size() > 0) {
+      auto native_label = ToNativeArrayBuffer(label.value());
+      unsigned char* label_copy = (unsigned char*)OPENSSL_malloc(native_label->size());
+      if (!label_copy) {
+        EVP_PKEY_CTX_free(ctx);
+        throw std::runtime_error("Failed to allocate memory for label");
+      }
+      std::memcpy(label_copy, native_label->data(), native_label->size());
+
+      if (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, label_copy, native_label->size()) <= 0) {
+        OPENSSL_free(label_copy);
+        EVP_PKEY_CTX_free(ctx);
+        throw std::runtime_error("Failed to set OAEP label");
+      }
+    }
+  }
+
+  auto native_data = ToNativeArrayBuffer(data);
+  const unsigned char* in = native_data->data();
+  size_t inlen = native_data->size();
+
+  size_t outlen;
+  if (EVP_PKEY_decrypt(ctx, nullptr, &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to determine output length: " + std::string(err_buf));
+  }
+
+  auto out_buf = std::make_unique<uint8_t[]>(outlen);
+
+  if (EVP_PKEY_decrypt(ctx, out_buf.get(), &outlen, in, inlen) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Private decryption failed: " + std::string(err_buf));
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), outlen, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+void HybridRsaCipher::loadHybridMethods() {
+  registerHybrids(this, [](Prototype& prototype) {
+    prototype.registerHybridMethod("encrypt", &HybridRsaCipher::encrypt);
+    prototype.registerHybridMethod("decrypt", &HybridRsaCipher::decrypt);
+    prototype.registerHybridMethod("publicDecrypt", &HybridRsaCipher::publicDecrypt);
+    prototype.registerHybridMethod("privateEncrypt", &HybridRsaCipher::privateEncrypt);
+    prototype.registerHybridMethod("privateDecrypt", &HybridRsaCipher::privateDecrypt);
+  });
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/cipher/HybridRsaCipher.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "HybridRsaCipherSpec.hpp"
+#include <memory>
+
+namespace margelo::nitro::crypto {
+
+class HybridRsaCipher : public HybridRsaCipherSpec {
+ public:
+  HybridRsaCipher() : HybridObject(TAG) {}
+
+  std::shared_ptr<ArrayBuffer> encrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                       const std::shared_ptr<ArrayBuffer>& data, double padding, const std::string& hashAlgorithm,
+                                       const std::optional<std::shared_ptr<ArrayBuffer>>& label) override;
+
+  std::shared_ptr<ArrayBuffer> decrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                       const std::shared_ptr<ArrayBuffer>& data, double padding, const std::string& hashAlgorithm,
+                                       const std::optional<std::shared_ptr<ArrayBuffer>>& label) override;
+
+  std::shared_ptr<ArrayBuffer> publicDecrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                             const std::shared_ptr<ArrayBuffer>& data, double padding) override;
+
+  std::shared_ptr<ArrayBuffer> privateEncrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                              const std::shared_ptr<ArrayBuffer>& data, double padding) override;
+
+  std::shared_ptr<ArrayBuffer> privateDecrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle,
+                                              const std::shared_ptr<ArrayBuffer>& data, double padding, const std::string& hashAlgorithm,
+                                              const std::optional<std::shared_ptr<ArrayBuffer>>& label) override;
+
+  void loadHybridMethods() override;
+};
+
+} // namespace margelo::nitro::crypto