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

package/cpp/cipher/CCMCipher.cpp

@@ -0,0 +1,211 @@
+#include "CCMCipher.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+void CCMCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  // 1. Call the base class initializer first
+  try {
+    HybridCipher::init(cipher_key, iv);
+  } catch (const std::exception& e) {
+    throw; // Re-throw after logging
+  }
+
+  // Ensure context is valid after base init
+  checkCtx();
+
+  // 2. Perform CCM-specific initialization
+  size_t iv_len = iv->size();
+
+  // Set the IV length using CCM-specific control
+  if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_CCM_SET_IVLEN, iv_len, nullptr) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to set IV length: " + std::string(err_buf));
+  }
+
+  // Set the expected/output tag length using CCM-specific control.
+  // auth_tag_len should have been defaulted or set via setArgs in the base init.
+  if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_CCM_SET_TAG, auth_tag_len, nullptr) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to set tag length: " + std::string(err_buf));
+  }
+
+  // Finally, initialize the key and IV using the parameters passed to this function.
+  const unsigned char* key_ptr = reinterpret_cast<const unsigned char*>(cipher_key->data());
+  const unsigned char* iv_ptr = reinterpret_cast<const unsigned char*>(iv->data());
+
+  // The last argument (is_cipher) should be consistent with the initial setup call.
+  if (EVP_CipherInit_ex(ctx.get(), nullptr, nullptr, key_ptr, iv_ptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to set key/IV: " + std::string(err_buf));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> CCMCipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkCtx();
+  checkNotFinalized();
+  has_update_called = true;
+  size_t in_len = data->size();
+  if (in_len < 0 || in_len > INT_MAX) {
+    throw std::runtime_error("Invalid message length");
+  }
+  int out_len = 0;
+
+  if (!is_cipher) {
+    maybePassAuthTagToOpenSSL();
+  }
+
+  int block_size = EVP_CIPHER_CTX_block_size(ctx.get());
+  if (block_size <= 0) {
+    throw std::runtime_error("Invalid block size in update");
+  }
+  out_len = in_len + block_size - 1;
+  if (out_len < 0 || out_len < in_len) {
+    throw std::runtime_error("Calculated output buffer size invalid in update");
+  }
+
+  auto out_buf = std::make_unique<unsigned char[]>(out_len);
+  const uint8_t* in = reinterpret_cast<const uint8_t*>(data->data());
+
+  int actual_out_len = 0;
+  int ret = EVP_CipherUpdate(ctx.get(), out_buf.get(), &actual_out_len, in, in_len);
+
+  if (!is_cipher) {
+    // Decryption: tag verification happens during update for CCM. Don't
+    // throw here — defer the failure to final() so callers see the standard
+    // "auth tag mismatch on final" semantics. This also covers the misuse
+    // case where setAuthTag() was never called: ret <= 0 here, we record
+    // it, and final() turns it into a thrown error.
+    if (ret <= 0) {
+      pending_auth_failed = true;
+      actual_out_len = 0;
+    }
+  } else {
+    // Encryption: Check for standard errors
+    if (ret != 1) {
+      pending_auth_failed = true; // Should this be set for encryption failure?
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      throw std::runtime_error("Error in update() performing encryption operation: " + std::string(err_buf));
+    }
+  }
+  // If we reached here, the operation (encryption or decryption) succeeded
+
+  unsigned char* final_output = out_buf.release();
+  return std::make_shared<NativeArrayBuffer>(final_output, actual_out_len, [=]() { delete[] final_output; });
+}
+
+std::shared_ptr<ArrayBuffer> CCMCipher::final() {
+  checkCtx();
+  checkNotFinalized();
+
+  // CCM decryption does not use final for the verification step itself
+  // (that happens in update()), but final() is still where misuse must
+  // surface — both "setAuthTag was never called" and "the tag we did set
+  // didn't match the ciphertext" land here.
+  if (!is_cipher) {
+    is_finalized = true;
+    if (auth_tag_state == kAuthTagUnknown || pending_auth_failed) {
+      throw std::runtime_error("Unsupported state or unable to authenticate data");
+    }
+    auto empty_output = std::make_unique<unsigned char[]>(0);
+    unsigned char* raw_ptr = empty_output.get();
+    return std::make_shared<NativeArrayBuffer>(empty_output.release(), 0, [raw_ptr]() { delete[] raw_ptr; });
+  }
+
+  // Proceed only for encryption
+  int block_size = EVP_CIPHER_CTX_block_size(ctx.get());
+  if (block_size <= 0) {
+    throw std::runtime_error("Invalid block size");
+  }
+  auto out_buf = std::make_unique<unsigned char[]>(block_size);
+  int out_len = 0;
+
+  if (!EVP_CipherFinal_ex(ctx.get(), out_buf.get(), &out_len)) {
+    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 finalization failed: " + std::string(err_buf));
+  }
+
+  if (auth_tag_len == 0) {
+    auth_tag_len = sizeof(auth_tag);
+  }
+
+  if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_CCM_GET_TAG, auth_tag_len, auth_tag) != 1) {
+    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 get auth tag after finalization: " + std::string(err_buf));
+  }
+  auth_tag_state = kAuthTagKnown;
+  is_finalized = true;
+
+  unsigned char* final_output = out_buf.release();
+  return std::make_shared<NativeArrayBuffer>(final_output, out_len, [=]() { delete[] final_output; });
+}
+
+bool CCMCipher::setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) {
+  checkCtx();
+  checkAADBeforeUpdate();
+  if (!plaintextLength.has_value()) {
+    throw std::runtime_error("CCM mode requires plaintextLength to be set");
+  }
+
+  // IMPORTANT: For CCM decryption (!is_cipher), OpenSSL requires this initial update
+  // call to specify the TOTAL LENGTH OF THE CIPHERTEXT, not the plaintext.
+  // The caller (JS) must ensure `plaintextLength` holds the ciphertext length when decrypting.
+  int data_len = static_cast<int>(plaintextLength.value());
+  if (data_len > kMaxMessageSize) {
+    throw std::runtime_error("Provided data length exceeds maximum allowed size");
+  }
+
+  if (!is_cipher) {
+    if (!maybePassAuthTagToOpenSSL()) {
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      throw std::runtime_error("setAAD: Failed to set auth tag parameters: " + std::string(err_buf));
+    }
+  }
+
+  int out_len = 0;
+
+  // Get AAD data and length *before* deciding whether to set total length
+  size_t aad_len = data->size();
+
+  // 1. Set the total *ciphertext* length. This seems necessary based on examples,
+  //    BUT the wiki says "(only needed if AAD is passed)". Let's skip if decrypting and AAD length is 0.
+  bool should_set_total_length = is_cipher || aad_len > 0;
+  if (should_set_total_length) {
+    if (EVP_CipherUpdate(ctx.get(), nullptr, &out_len, nullptr, data_len) != 1) {
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      throw std::runtime_error("CCMCipher: Failed to set expected length: " + std::string(err_buf));
+    }
+  }
+
+  // 2. Process AAD Data
+  // Per OpenSSL CCM decryption examples, this MUST be called even if aad_len is 0.
+  // Pass nullptr as the output buffer, the AAD data pointer, and its length.
+  if (EVP_CipherUpdate(ctx.get(), nullptr, &out_len, data->data(), aad_len) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to update AAD: " + std::string(err_buf));
+  }
+  return true;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/CCMCipher.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class CCMCipher : public HybridCipher {
+ public:
+  CCMCipher() : HybridObject(TAG) {}
+  // Destructor defaulted: HybridCipher's unique_ptr ctx frees itself.
+  ~CCMCipher() override = default;
+
+  void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
+  std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> final() override;
+  bool setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) override;
+
+ private:
+  // CCM mode supports messages up to 2^(8L) - 1 bytes where L is the length of nonce
+  // With a 12-byte nonce (L=3), max size is 2^24 - 1 bytes
+  static constexpr int kMaxMessageSize = (1 << 24) - 1;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/ChaCha20Cipher.cpp

@@ -0,0 +1,91 @@
+#include "ChaCha20Cipher.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+void ChaCha20Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  // Resetting the unique_ptr frees any previous context.
+  ctx.reset();
+
+  // Get ChaCha20 cipher implementation
+  const EVP_CIPHER* cipher = EVP_chacha20();
+  if (!cipher) {
+    throw std::runtime_error("Failed to get ChaCha20 cipher implementation");
+  }
+
+  // Create a new context
+  ctx.reset(EVP_CIPHER_CTX_new());
+  if (!ctx) {
+    throw std::runtime_error("Failed to create cipher context");
+  }
+
+  // Initialize the encryption/decryption operation
+  if (EVP_CipherInit_ex(ctx.get(), cipher, nullptr, nullptr, nullptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    ctx.reset();
+    throw std::runtime_error("ChaCha20Cipher: Failed initial CipherInit setup: " + std::string(err_buf));
+  }
+
+  // Set key and IV
+  // Validate key size
+  if (cipher_key->size() != kKeySize) {
+    throw std::runtime_error("ChaCha20 key must be 32 bytes");
+  }
+
+  // Validate IV size
+  if (iv->size() != kIVSize) {
+    throw std::runtime_error("ChaCha20 IV must be 16 bytes");
+  }
+
+  const unsigned char* key_ptr = reinterpret_cast<const unsigned char*>(cipher_key->data());
+  const unsigned char* iv_ptr = reinterpret_cast<const unsigned char*>(iv->data());
+
+  if (EVP_CipherInit_ex(ctx.get(), nullptr, nullptr, key_ptr, iv_ptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    ctx.reset();
+    throw std::runtime_error("ChaCha20Cipher: Failed to set key/IV: " + std::string(err_buf));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> ChaCha20Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkCtx();
+  checkNotFinalized();
+  size_t in_len = data->size();
+  if (in_len > INT_MAX) {
+    throw std::runtime_error("Message too long");
+  }
+
+  // For ChaCha20, output size equals input size since it's a stream cipher
+  int out_len = in_len;
+  auto out_buf = std::make_unique<uint8_t[]>(out_len);
+
+  // Perform the cipher update operation
+  if (EVP_CipherUpdate(ctx.get(), out_buf.get(), &out_len, data->data(), in_len) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("ChaCha20Cipher: Failed to update: " + std::string(err_buf));
+  }
+
+  // Create and return a new buffer of exact size needed
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), out_len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<ArrayBuffer> ChaCha20Cipher::final() {
+  checkCtx();
+  checkNotFinalized();
+  is_finalized = true;
+  auto empty_buf = std::make_unique<unsigned char[]>(0);
+  unsigned char* raw_ptr = empty_buf.get();
+  return std::make_shared<NativeArrayBuffer>(empty_buf.release(), 0, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/ChaCha20Cipher.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class ChaCha20Cipher : public HybridCipher {
+ public:
+  ChaCha20Cipher() : HybridObject(TAG) {}
+  // Destructor defaulted: HybridCipher's unique_ptr ctx frees itself.
+  ~ChaCha20Cipher() override = default;
+
+  void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
+  std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> final() override;
+
+ private:
+  // ChaCha20 uses a 256-bit key (32 bytes) and a 128-bit IV (16 bytes)
+  static constexpr int kKeySize = 32;
+  static constexpr int kIVSize = 16;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/ChaCha20Poly1305Cipher.cpp

@@ -0,0 +1,175 @@
+#include "ChaCha20Poly1305Cipher.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+void ChaCha20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  // Resetting the unique_ptr frees any previous context.
+  ctx.reset();
+
+  // Get ChaCha20-Poly1305 cipher implementation
+  const EVP_CIPHER* cipher = EVP_chacha20_poly1305();
+  if (!cipher) {
+    throw std::runtime_error("Failed to get ChaCha20-Poly1305 cipher implementation");
+  }
+
+  // Create a new context
+  ctx.reset(EVP_CIPHER_CTX_new());
+  if (!ctx) {
+    throw std::runtime_error("Failed to create cipher context");
+  }
+
+  // Initialize the encryption/decryption operation
+  if (EVP_CipherInit_ex(ctx.get(), cipher, nullptr, nullptr, nullptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    ctx.reset();
+    throw std::runtime_error("ChaCha20Poly1305Cipher: Failed initial CipherInit setup: " + std::string(err_buf));
+  }
+
+  // Set key and IV
+  // Validate key size
+  if (cipher_key->size() != kKeySize) {
+    throw std::runtime_error("ChaCha20-Poly1305 key must be 32 bytes");
+  }
+
+  // Validate nonce size
+  if (iv->size() != kNonceSize) {
+    throw std::runtime_error("ChaCha20-Poly1305 nonce must be 12 bytes");
+  }
+
+  const unsigned char* key_ptr = reinterpret_cast<const unsigned char*>(cipher_key->data());
+  const unsigned char* iv_ptr = reinterpret_cast<const unsigned char*>(iv->data());
+
+  if (EVP_CipherInit_ex(ctx.get(), nullptr, nullptr, key_ptr, iv_ptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    ctx.reset();
+    throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to set key/IV: " + std::string(err_buf));
+  }
+  is_finalized = false;
+  has_update_called = false;
+  has_aad = false;
+  pending_auth_failed = false;
+  auth_tag_state = kAuthTagUnknown;
+}
+
+std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkCtx();
+  checkNotFinalized();
+  has_update_called = true;
+  size_t in_len = data->size();
+  if (in_len > INT_MAX) {
+    throw std::runtime_error("Message too long");
+  }
+
+  // For ChaCha20-Poly1305, output size equals input size since it's a stream cipher
+  int out_len = in_len;
+  auto out_buf = std::make_unique<uint8_t[]>(out_len);
+
+  // Perform the cipher update operation
+  if (EVP_CipherUpdate(ctx.get(), out_buf.get(), &out_len, data->data(), in_len) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to update: " + std::string(err_buf));
+  }
+
+  // Create and return a new buffer of exact size needed
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), out_len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::final() {
+  checkCtx();
+  checkNotFinalized();
+
+  // For decryption, the auth tag must have been provided via setAuthTag
+  // before final(). OpenSSL's ChaCha20-Poly1305 EVP_CipherFinal_ex does
+  // not flag a missing tag as an error (it simply doesn't verify), which
+  // would silently accept unauthenticated ciphertext — defeating the whole
+  // point of an AEAD. Enforce the precondition explicitly.
+  if (!is_cipher && auth_tag_state == kAuthTagUnknown) {
+    throw std::runtime_error("Unsupported state or unable to authenticate data");
+  }
+
+  // For ChaCha20-Poly1305, we need to call final to generate the tag
+  int out_len = 0;
+  auto out_buf = std::make_unique<unsigned char[]>(0);
+
+  if (EVP_CipherFinal_ex(ctx.get(), out_buf.get(), &out_len) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to finalize: " + std::string(err_buf));
+  }
+
+  is_finalized = true;
+  unsigned char* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), out_len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+bool ChaCha20Poly1305Cipher::setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) {
+  checkCtx();
+  checkAADBeforeUpdate();
+  size_t aad_len = data->size();
+
+  // Set AAD data
+  int out_len = 0;
+  if (EVP_CipherUpdate(ctx.get(), nullptr, &out_len, data->data(), aad_len) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to set AAD: " + std::string(err_buf));
+  }
+  return true;
+}
+
+std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::getAuthTag() {
+  checkCtx();
+  if (!is_cipher) {
+    throw std::runtime_error("getAuthTag can only be called during encryption");
+  }
+  if (!is_finalized) {
+    throw std::runtime_error("getAuthTag must be called after final()");
+  }
+
+  // Get the authentication tag
+  auto tag_buf = std::make_unique<uint8_t[]>(kTagSize);
+  if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_AEAD_GET_TAG, kTagSize, tag_buf.get()) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to get auth tag: " + std::string(err_buf));
+  }
+
+  uint8_t* raw_ptr = tag_buf.get();
+  return std::make_shared<NativeArrayBuffer>(tag_buf.release(), kTagSize, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+bool ChaCha20Poly1305Cipher::setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) {
+  checkCtx();
+  if (is_cipher) {
+    throw std::runtime_error("setAuthTag can only be called during decryption");
+  }
+
+  if (tag->size() != kTagSize) {
+    throw std::runtime_error("ChaCha20-Poly1305 tag must be 16 bytes");
+  }
+
+  if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_AEAD_SET_TAG, kTagSize, tag->data()) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to set auth tag: " + std::string(err_buf));
+  }
+  auth_tag_state = kAuthTagPassedToOpenSSL;
+  return true;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/ChaCha20Poly1305Cipher.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class ChaCha20Poly1305Cipher : public HybridCipher {
+ public:
+  ChaCha20Poly1305Cipher() : HybridObject(TAG) {}
+  // Destructor defaulted: HybridCipher's unique_ptr ctx frees itself.
+  ~ChaCha20Poly1305Cipher() override = default;
+
+  void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
+  std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> final() override;
+  bool setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) override;
+  std::shared_ptr<ArrayBuffer> getAuthTag() override;
+  bool setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) override;
+
+ private:
+  // ChaCha20-Poly1305 uses a 256-bit key (32 bytes) and a 96-bit nonce (12 bytes)
+  static constexpr int kKeySize = 32;
+  static constexpr int kNonceSize = 12;
+  static constexpr int kTagSize = 16; // Poly1305 tag is always 16 bytes
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/GCMCipher.cpp

@@ -0,0 +1,65 @@
+#include "GCMCipher.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+void GCMCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  // Resetting the unique_ptr frees any previous context.
+  ctx.reset();
+  is_finalized = false;
+  has_update_called = false;
+  has_aad = false;
+  pending_auth_failed = false;
+  auth_tag_state = kAuthTagUnknown;
+
+  // 1. Get cipher implementation by name
+  const EVP_CIPHER* cipher = EVP_get_cipherbyname(cipher_type.c_str());
+  if (!cipher) {
+    throw std::runtime_error("Unknown cipher " + cipher_type);
+  }
+
+  // 2. Create a new context
+  ctx.reset(EVP_CIPHER_CTX_new());
+  if (!ctx) {
+    throw std::runtime_error("Failed to create cipher context");
+  }
+
+  // 3. Initialize with cipher type only (no key/IV yet)
+  if (EVP_CipherInit_ex(ctx.get(), cipher, nullptr, nullptr, nullptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    ctx.reset();
+    throw std::runtime_error("GCMCipher: Failed initial CipherInit setup: " + std::string(err_buf));
+  }
+
+  // 4. Set IV length for non-standard IV sizes (GCM default is 96 bits/12 bytes)
+  size_t iv_len = iv->size();
+
+  if (iv_len != 12) { // Only set if not the default length
+    if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_IVLEN, static_cast<int>(iv_len), nullptr) != 1) {
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      ctx.reset();
+      throw std::runtime_error("GCMCipher: Failed to set IV length: " + std::string(err_buf));
+    }
+  }
+
+  // 5. Now set the key and IV
+  const unsigned char* key_ptr = reinterpret_cast<const unsigned char*>(cipher_key->data());
+  const unsigned char* iv_ptr = reinterpret_cast<const unsigned char*>(iv->data());
+
+  if (EVP_CipherInit_ex(ctx.get(), nullptr, nullptr, key_ptr, iv_ptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    ctx.reset();
+    throw std::runtime_error("GCMCipher: Failed to set key/IV: " + std::string(err_buf));
+  }
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/GCMCipher.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class GCMCipher : public HybridCipher {
+ public:
+  GCMCipher() : HybridObject(TAG) {}
+
+  void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
+};
+
+} // namespace margelo::nitro::crypto