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

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

@@ -0,0 +1,55 @@
+#include "OCBCipher.hpp"
+#include <cstring>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+
+#include "QuickCryptoUtils.hpp"
+#include <cstdio>
+#include <iomanip>
+
+namespace margelo::nitro::crypto {
+
+void OCBCipher::init(const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv, size_t tag_len) {
+  HybridCipher::init(key, iv);
+  auth_tag_len = tag_len;
+
+  // Set tag length for OCB (must be 8-16 bytes)
+  if (auth_tag_len < 8 || auth_tag_len > 16) {
+    throw std::runtime_error("OCB tag length must be between 8 and 16 bytes");
+  }
+  if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, auth_tag_len, nullptr) != 1) {
+    throw std::runtime_error("Failed to set OCB tag length");
+  }
+}
+
+std::shared_ptr<ArrayBuffer> OCBCipher::getAuthTag() {
+  checkCtx();
+  if (!is_cipher) {
+    throw std::runtime_error("getAuthTag can only be called during encryption.");
+  }
+  auto tag_buf = std::make_unique<uint8_t[]>(auth_tag_len);
+  if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, auth_tag_len, tag_buf.get()) != 1) {
+    throw std::runtime_error("Failed to get OCB auth tag");
+  }
+  uint8_t* raw_ptr = tag_buf.get();
+  return std::make_shared<NativeArrayBuffer>(tag_buf.release(), auth_tag_len, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+bool OCBCipher::setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) {
+  checkCtx();
+  if (is_cipher) {
+    throw std::runtime_error("setAuthTag can only be called during decryption.");
+  }
+  auto native_tag = ToNativeArrayBuffer(tag);
+  size_t tag_len = native_tag->size();
+  if (tag_len < 8 || tag_len > 16) {
+    throw std::runtime_error("Invalid OCB tag length");
+  }
+  if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len, native_tag->data()) != 1) {
+    throw std::runtime_error("Failed to set OCB auth tag");
+  }
+  auth_tag_len = tag_len;
+  return true;
+}
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class OCBCipher : public HybridCipher {
+ public:
+  OCBCipher() : HybridObject(TAG) {}
+  void init(const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv, size_t tag_len = 16);
+
+  std::shared_ptr<ArrayBuffer> getAuthTag() override;
+  bool setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) override;
+
+ protected:
+  size_t auth_tag_len = 16;
+};
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,163 @@
+#include "XChaCha20Poly1305Cipher.hpp"
+
+#include <cstring>
+#include <stdexcept>
+
+#include "NitroModules/ArrayBuffer.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+XChaCha20Poly1305Cipher::~XChaCha20Poly1305Cipher() {
+#ifdef BLSALLOC_SODIUM
+  sodium_memzero(key_, kKeySize);
+  sodium_memzero(nonce_, kNonceSize);
+  sodium_memzero(auth_tag_, kTagSize);
+  if (!data_buffer_.empty()) {
+    sodium_memzero(data_buffer_.data(), data_buffer_.size());
+  }
+  if (!aad_.empty()) {
+    sodium_memzero(aad_.data(), aad_.size());
+  }
+#else
+  std::memset(key_, 0, kKeySize);
+  std::memset(nonce_, 0, kNonceSize);
+  std::memset(auth_tag_, 0, kTagSize);
+#endif
+  data_buffer_.clear();
+  aad_.clear();
+}
+
+void XChaCha20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  auto native_key = ToNativeArrayBuffer(cipher_key);
+  auto native_iv = ToNativeArrayBuffer(iv);
+
+  if (native_key->size() != kKeySize) {
+    throw std::runtime_error("XChaCha20-Poly1305 key must be 32 bytes, got " + std::to_string(native_key->size()) + " bytes");
+  }
+
+  if (native_iv->size() != kNonceSize) {
+    throw std::runtime_error("XChaCha20-Poly1305 nonce must be 24 bytes, got " + std::to_string(native_iv->size()) + " bytes");
+  }
+
+  std::memcpy(key_, native_key->data(), kKeySize);
+  std::memcpy(nonce_, native_iv->data(), kNonceSize);
+
+  data_buffer_.clear();
+  aad_.clear();
+  is_finalized = false;
+}
+
+std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkNotFinalized();
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  auto native_data = ToNativeArrayBuffer(data);
+  size_t data_len = native_data->size();
+
+  size_t old_size = data_buffer_.size();
+  data_buffer_.resize(old_size + data_len);
+  std::memcpy(data_buffer_.data() + old_size, native_data->data(), data_len);
+
+  return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::final() {
+  checkNotFinalized();
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  if (is_cipher) {
+    uint8_t* ciphertext = new uint8_t[data_buffer_.size()];
+
+    int result =
+        crypto_aead_xchacha20poly1305_ietf_encrypt_detached(ciphertext, auth_tag_, nullptr, data_buffer_.data(), data_buffer_.size(),
+                                                            aad_.empty() ? nullptr : aad_.data(), aad_.size(), nullptr, nonce_, key_);
+
+    if (result != 0) {
+      sodium_memzero(ciphertext, data_buffer_.size());
+      delete[] ciphertext;
+      throw std::runtime_error("XChaCha20Poly1305Cipher: encryption failed");
+    }
+
+    is_finalized = true;
+    size_t ct_len = data_buffer_.size();
+    return std::make_shared<NativeArrayBuffer>(ciphertext, ct_len, [=]() { delete[] ciphertext; });
+  } else {
+    if (data_buffer_.empty()) {
+      is_finalized = true;
+      return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+    }
+
+    uint8_t* plaintext = new uint8_t[data_buffer_.size()];
+
+    int result =
+        crypto_aead_xchacha20poly1305_ietf_decrypt_detached(plaintext, nullptr, data_buffer_.data(), data_buffer_.size(), auth_tag_,
+                                                            aad_.empty() ? nullptr : aad_.data(), aad_.size(), nonce_, key_);
+
+    if (result != 0) {
+      sodium_memzero(plaintext, data_buffer_.size());
+      delete[] plaintext;
+      throw std::runtime_error("XChaCha20Poly1305Cipher: decryption failed - authentication tag mismatch");
+    }
+
+    is_finalized = true;
+    size_t pt_len = data_buffer_.size();
+    return std::make_shared<NativeArrayBuffer>(plaintext, pt_len, [=]() { delete[] plaintext; });
+  }
+#endif
+}
+
+bool XChaCha20Poly1305Cipher::setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) {
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  auto native_aad = ToNativeArrayBuffer(data);
+  aad_.resize(native_aad->size());
+  std::memcpy(aad_.data(), native_aad->data(), native_aad->size());
+  return true;
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::getAuthTag() {
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  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()");
+  }
+
+  uint8_t* tag_copy = new uint8_t[kTagSize];
+  std::memcpy(tag_copy, auth_tag_, kTagSize);
+  return std::make_shared<NativeArrayBuffer>(tag_copy, kTagSize, [=]() { delete[] tag_copy; });
+#endif
+}
+
+bool XChaCha20Poly1305Cipher::setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) {
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  if (is_cipher) {
+    throw std::runtime_error("setAuthTag can only be called during decryption");
+  }
+
+  auto native_tag = ToNativeArrayBuffer(tag);
+  if (native_tag->size() != kTagSize) {
+    throw std::runtime_error("XChaCha20-Poly1305 tag must be 16 bytes, got " + std::to_string(native_tag->size()) + " bytes");
+  }
+
+  std::memcpy(auth_tag_, native_tag->data(), kTagSize);
+  return true;
+#endif
+}
+
+bool XChaCha20Poly1305Cipher::setAutoPadding(bool autoPad) {
+  throw std::runtime_error("setAutoPadding is not supported for xchacha20-poly1305");
+}
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,42 @@
+#pragma once
+
+#ifdef BLSALLOC_SODIUM
+#include "sodium.h"
+#else
+#define crypto_aead_xchacha20poly1305_ietf_KEYBYTES 32U
+#define crypto_aead_xchacha20poly1305_ietf_NPUBBYTES 24U
+#define crypto_aead_xchacha20poly1305_ietf_ABYTES 16U
+#endif
+
+#include <vector>
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class XChaCha20Poly1305Cipher : public HybridCipher {
+ public:
+  XChaCha20Poly1305Cipher() : HybridObject(TAG) {}
+  ~XChaCha20Poly1305Cipher();
+
+  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;
+  bool setAutoPadding(bool autoPad) override;
+
+ private:
+  static constexpr size_t kKeySize = crypto_aead_xchacha20poly1305_ietf_KEYBYTES;
+  static constexpr size_t kNonceSize = crypto_aead_xchacha20poly1305_ietf_NPUBBYTES;
+  static constexpr size_t kTagSize = crypto_aead_xchacha20poly1305_ietf_ABYTES;
+
+  uint8_t key_[kKeySize];
+  uint8_t nonce_[kNonceSize];
+  std::vector<uint8_t> aad_;
+  std::vector<uint8_t> data_buffer_;
+  uint8_t auth_tag_[kTagSize];
+};
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,65 @@
+#include <cstring>   // For std::memcpy
+#include <stdexcept> // For std::runtime_error
+
+#include "NitroModules/ArrayBuffer.hpp"
+#include "QuickCryptoUtils.hpp"
+#include "XSalsa20Cipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+/**
+ * Initialize the cipher with a key and a nonce (using iv argument as nonce)
+ */
+void XSalsa20Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  auto native_key = ToNativeArrayBuffer(cipher_key);
+  auto native_iv = ToNativeArrayBuffer(iv);
+
+  // Validate key size
+  if (native_key->size() < crypto_stream_KEYBYTES) {
+    throw std::runtime_error("XSalsa20 key too short: expected " + std::to_string(crypto_stream_KEYBYTES) + " bytes, got " +
+                             std::to_string(native_key->size()) + " bytes.");
+  }
+  // Validate nonce size
+  if (native_iv->size() < crypto_stream_NONCEBYTES) {
+    throw std::runtime_error("XSalsa20 nonce too short: expected " + std::to_string(crypto_stream_NONCEBYTES) + " bytes, got " +
+                             std::to_string(native_iv->size()) + " bytes.");
+  }
+
+  // Copy key and nonce data
+  std::memcpy(key, native_key->data(), crypto_stream_KEYBYTES);
+  std::memcpy(nonce, native_iv->data(), crypto_stream_NONCEBYTES);
+  is_finalized = false;
+}
+
+/**
+ * xsalsa20 call to sodium implementation
+ */
+std::shared_ptr<ArrayBuffer> XSalsa20Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkNotFinalized();
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XSalsa20Cipher: libsodium must be enabled to use this cipher (BLSALLOC_SODIUM is not defined).");
+#else
+  auto native_data = ToNativeArrayBuffer(data);
+  auto output = new uint8_t[native_data->size()];
+  int result = crypto_stream_xor(output, native_data->data(), native_data->size(), nonce, key);
+  if (result != 0) {
+    throw std::runtime_error("XSalsa20Cipher: Failed to update");
+  }
+  return std::make_shared<NativeArrayBuffer>(output, native_data->size(), [=]() { delete[] output; });
+#endif
+}
+
+/**
+ * xsalsa20 does not have a final step, returns empty buffer
+ */
+std::shared_ptr<ArrayBuffer> XSalsa20Cipher::final() {
+  checkNotFinalized();
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XSalsa20Cipher: libsodium must be enabled to use this cipher (BLSALLOC_SODIUM is not defined).");
+#else
+  is_finalized = true;
+  return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+#endif
+}
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#if BLSALLOC_SODIUM
+#include "sodium.h"
+#else
+// Define XSalsa20 constants when sodium is disabled (for compilation purposes)
+#define crypto_stream_KEYBYTES 32   // XSalsa20 key size (32 bytes)
+#define crypto_stream_NONCEBYTES 24 // XSalsa20 nonce size (24 bytes)
+#endif
+
+#include "HybridCipher.hpp"
+#include "NitroModules/ArrayBuffer.hpp"
+
+namespace margelo::nitro::crypto {
+
+class XSalsa20Cipher : public HybridCipher {
+ public:
+  XSalsa20Cipher() : HybridObject(TAG) {}
+  ~XSalsa20Cipher() {
+    // Let parent destructor free the context
+    ctx = nullptr;
+  }
+
+  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:
+  uint8_t key[crypto_stream_KEYBYTES];
+  uint8_t nonce[crypto_stream_NONCEBYTES];
+};
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,147 @@
+#include "XSalsa20Poly1305Cipher.hpp"
+
+#include <cstring>
+#include <stdexcept>
+
+#include "NitroModules/ArrayBuffer.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+XSalsa20Poly1305Cipher::~XSalsa20Poly1305Cipher() {
+#ifdef BLSALLOC_SODIUM
+  sodium_memzero(key_, kKeySize);
+  sodium_memzero(nonce_, kNonceSize);
+  sodium_memzero(auth_tag_, kTagSize);
+  if (!data_buffer_.empty()) {
+    sodium_memzero(data_buffer_.data(), data_buffer_.size());
+  }
+#else
+  std::memset(key_, 0, kKeySize);
+  std::memset(nonce_, 0, kNonceSize);
+  std::memset(auth_tag_, 0, kTagSize);
+#endif
+  data_buffer_.clear();
+}
+
+void XSalsa20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  auto native_key = ToNativeArrayBuffer(cipher_key);
+  auto native_iv = ToNativeArrayBuffer(iv);
+
+  if (native_key->size() != kKeySize) {
+    throw std::runtime_error("XSalsa20-Poly1305 key must be 32 bytes, got " + std::to_string(native_key->size()) + " bytes");
+  }
+
+  if (native_iv->size() != kNonceSize) {
+    throw std::runtime_error("XSalsa20-Poly1305 nonce must be 24 bytes, got " + std::to_string(native_iv->size()) + " bytes");
+  }
+
+  std::memcpy(key_, native_key->data(), kKeySize);
+  std::memcpy(nonce_, native_iv->data(), kNonceSize);
+
+  data_buffer_.clear();
+  is_finalized = false;
+}
+
+std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkNotFinalized();
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XSalsa20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  auto native_data = ToNativeArrayBuffer(data);
+  size_t data_len = native_data->size();
+
+  size_t old_size = data_buffer_.size();
+  data_buffer_.resize(old_size + data_len);
+  std::memcpy(data_buffer_.data() + old_size, native_data->data(), data_len);
+
+  return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::final() {
+  checkNotFinalized();
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XSalsa20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  if (is_cipher) {
+    uint8_t* ciphertext = new uint8_t[data_buffer_.size()];
+
+    int result = crypto_secretbox_detached(ciphertext, auth_tag_, data_buffer_.data(), data_buffer_.size(), nonce_, key_);
+
+    if (result != 0) {
+      sodium_memzero(ciphertext, data_buffer_.size());
+      delete[] ciphertext;
+      throw std::runtime_error("XSalsa20Poly1305Cipher: encryption failed");
+    }
+
+    is_finalized = true;
+    size_t ct_len = data_buffer_.size();
+    return std::make_shared<NativeArrayBuffer>(ciphertext, ct_len, [=]() { delete[] ciphertext; });
+  } else {
+    if (data_buffer_.empty()) {
+      is_finalized = true;
+      return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+    }
+
+    uint8_t* plaintext = new uint8_t[data_buffer_.size()];
+
+    int result = crypto_secretbox_open_detached(plaintext, data_buffer_.data(), auth_tag_, data_buffer_.size(), nonce_, key_);
+
+    if (result != 0) {
+      sodium_memzero(plaintext, data_buffer_.size());
+      delete[] plaintext;
+      throw std::runtime_error("XSalsa20Poly1305Cipher: decryption failed - authentication tag mismatch");
+    }
+
+    is_finalized = true;
+    size_t pt_len = data_buffer_.size();
+    return std::make_shared<NativeArrayBuffer>(plaintext, pt_len, [=]() { delete[] plaintext; });
+  }
+#endif
+}
+
+bool XSalsa20Poly1305Cipher::setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) {
+  throw std::runtime_error("AAD is not supported for xsalsa20-poly1305 (use xchacha20-poly1305 instead)");
+}
+
+std::shared_ptr<ArrayBuffer> XSalsa20Poly1305Cipher::getAuthTag() {
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XSalsa20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  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()");
+  }
+
+  uint8_t* tag_copy = new uint8_t[kTagSize];
+  std::memcpy(tag_copy, auth_tag_, kTagSize);
+  return std::make_shared<NativeArrayBuffer>(tag_copy, kTagSize, [=]() { delete[] tag_copy; });
+#endif
+}
+
+bool XSalsa20Poly1305Cipher::setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) {
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XSalsa20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
+#else
+  if (is_cipher) {
+    throw std::runtime_error("setAuthTag can only be called during decryption");
+  }
+
+  auto native_tag = ToNativeArrayBuffer(tag);
+  if (native_tag->size() != kTagSize) {
+    throw std::runtime_error("XSalsa20-Poly1305 tag must be 16 bytes, got " + std::to_string(native_tag->size()) + " bytes");
+  }
+
+  std::memcpy(auth_tag_, native_tag->data(), kTagSize);
+  return true;
+#endif
+}
+
+bool XSalsa20Poly1305Cipher::setAutoPadding(bool autoPad) {
+  throw std::runtime_error("setAutoPadding is not supported for xsalsa20-poly1305");
+}
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#ifdef BLSALLOC_SODIUM
+#include "sodium.h"
+#else
+#define crypto_secretbox_xsalsa20poly1305_KEYBYTES 32U
+#define crypto_secretbox_xsalsa20poly1305_NONCEBYTES 24U
+#define crypto_secretbox_xsalsa20poly1305_MACBYTES 16U
+#endif
+
+#include <vector>
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class XSalsa20Poly1305Cipher : public HybridCipher {
+ public:
+  XSalsa20Poly1305Cipher() : HybridObject(TAG) {}
+  ~XSalsa20Poly1305Cipher();
+
+  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;
+  bool setAutoPadding(bool autoPad) override;
+
+ private:
+  static constexpr size_t kKeySize = crypto_secretbox_xsalsa20poly1305_KEYBYTES;
+  static constexpr size_t kNonceSize = crypto_secretbox_xsalsa20poly1305_NONCEBYTES;
+  static constexpr size_t kTagSize = crypto_secretbox_xsalsa20poly1305_MACBYTES;
+
+  uint8_t key_[kKeySize];
+  uint8_t nonce_[kNonceSize];
+  std::vector<uint8_t> data_buffer_;
+  uint8_t auth_tag_[kTagSize];
+};
+
+} // namespace margelo::nitro::crypto