react-native-quick-crypto 1.0.0-beta.8 → 1.0.0

package/cpp/cipher/HybridRsaCipher.cpp

@@ -0,0 +1,348 @@
+#include "HybridRsaCipher.hpp"
+#include "../keys/HybridKeyObjectHandle.hpp"
+#include "Utils.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;
+
+const EVP_MD* getDigestByName(const std::string& hashAlgorithm) {
+  if (hashAlgorithm == "SHA-1" || hashAlgorithm == "SHA1" || hashAlgorithm == "sha1" || hashAlgorithm == "sha-1") {
+    return EVP_sha1();
+  } else if (hashAlgorithm == "SHA-256" || hashAlgorithm == "SHA256" || hashAlgorithm == "sha256" || hashAlgorithm == "sha-256") {
+    return EVP_sha256();
+  } else if (hashAlgorithm == "SHA-384" || hashAlgorithm == "SHA384" || hashAlgorithm == "sha384" || hashAlgorithm == "sha-384") {
+    return EVP_sha384();
+  } else if (hashAlgorithm == "SHA-512" || hashAlgorithm == "SHA512" || hashAlgorithm == "sha512" || hashAlgorithm == "sha-512") {
+    return EVP_sha512();
+  }
+  throw std::runtime_error("Unsupported hash algorithm: " + hashAlgorithm);
+}
+
+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::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) {
+  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_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));
+  }
+
+  auto out_buf = std::make_unique<uint8_t[]>(outlen);
+
+  if (EVP_PKEY_verify_recover(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("privateEncrypt", &HybridRsaCipher::privateEncrypt);
+    prototype.registerHybridMethod("privateDecrypt", &HybridRsaCipher::privateDecrypt);
+  });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/HybridRsaCipher.hpp

@@ -0,0 +1,29 @@
+#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> 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) override;
+
+  void loadHybridMethods() override;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/OCBCipher.cpp

@@ -0,0 +1,55 @@
+#include "OCBCipher.hpp"
+#include <cstring>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+
+#include "Utils.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 12-16 bytes)
+  if (auth_tag_len < 12 || auth_tag_len > 16) {
+    throw std::runtime_error("OCB tag length must be between 12 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 < 12 || 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/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/cpp/cipher/XSalsa20Cipher.cpp

@@ -0,0 +1,61 @@
+#include <cstring>   // For std::memcpy
+#include <stdexcept> // For std::runtime_error
+
+#include "NitroModules/ArrayBuffer.hpp"
+#include "Utils.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);
+}
+
+/**
+ * xsalsa20 call to sodium implementation
+ */
+std::shared_ptr<ArrayBuffer> XSalsa20Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+#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() {
+#ifndef BLSALLOC_SODIUM
+  throw std::runtime_error("XSalsa20Cipher: libsodium must be enabled to use this cipher (BLSALLOC_SODIUM is not defined).");
+#else
+  return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+#endif
+}
+
+} // namespace margelo::nitro::crypto

package/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