react-native-quick-crypto 1.0.10 → 1.0.12

package/android/CMakeLists.txt

@@ -25,7 +25,9 @@ endif()
 add_library(
   ${PACKAGE_NAME} SHARED
   src/main/cpp/cpp-adapter.cpp
+  ../cpp/argon2/HybridArgon2.cpp
   ../cpp/blake3/HybridBlake3.cpp
+  ../cpp/certificate/HybridCertificate.cpp
   ../cpp/cipher/CCMCipher.cpp
   ../cpp/cipher/GCMCipher.cpp
   ../cpp/cipher/HybridCipher.cpp
@@ -37,22 +39,29 @@ add_library(
   ../cpp/cipher/ChaCha20Cipher.cpp
   ../cpp/cipher/ChaCha20Poly1305Cipher.cpp
   ../cpp/dh/HybridDiffieHellman.cpp
+  ../cpp/dh/HybridDhKeyPair.cpp
+  ../cpp/dsa/HybridDsaKeyPair.cpp
   ../cpp/ec/HybridEcKeyPair.cpp
   ../cpp/ecdh/HybridECDH.cpp
   ../cpp/ed25519/HybridEdKeyPair.cpp
   ../cpp/hash/HybridHash.cpp
   ../cpp/hmac/HybridHmac.cpp
   ../cpp/hkdf/HybridHkdf.cpp
+  ../cpp/kmac/HybridKmac.cpp
   ../cpp/keys/HybridKeyObjectHandle.cpp
   ../cpp/keys/KeyObjectData.cpp
   ../cpp/mldsa/HybridMlDsaKeyPair.cpp
+  ../cpp/mlkem/HybridMlKemKeyPair.cpp
   ../cpp/pbkdf2/HybridPbkdf2.cpp
+  ../cpp/prime/HybridPrime.cpp
   ../cpp/random/HybridRandom.cpp
   ../cpp/rsa/HybridRsaKeyPair.cpp
   ../cpp/scrypt/HybridScrypt.cpp
   ../cpp/sign/HybridSignHandle.cpp
   ../cpp/sign/HybridVerifyHandle.cpp
+  ../cpp/x509/HybridX509Certificate.cpp
   ../cpp/utils/HybridUtils.cpp
+  ../cpp/utils/QuickCryptoUtils.cpp
   ${BLAKE3_SOURCES}
   ../deps/fastpbkdf2/fastpbkdf2.c
   ../deps/ncrypto/src/aead.cpp
@@ -66,23 +75,30 @@ include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinkin
 # local includes
 include_directories(
   "src/main/cpp"
+  "../cpp/argon2"
   "../cpp/blake3"
+  "../cpp/certificate"
   "../cpp/cipher"
   "../cpp/dh"
+  "../cpp/dsa"
   "../cpp/ec"
   "../cpp/ecdh"
   "../cpp/ed25519"
   "../cpp/hash"
   "../cpp/hkdf"
   "../cpp/hmac"
+  "../cpp/kmac"
   "../cpp/keys"
   "../cpp/mldsa"
+  "../cpp/mlkem"
   "../cpp/pbkdf2"
+  "../cpp/prime"
   "../cpp/random"
   "../cpp/rsa"
   "../cpp/sign"
   "../cpp/scrypt"
   "../cpp/utils"
+  "../cpp/x509"
   "../deps/blake3/c"
   "../deps/fastpbkdf2"
   "../deps/ncrypto/include"

package/cpp/argon2/HybridArgon2.cpp

@@ -0,0 +1,103 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <ncrypto.h>
+#include <openssl/err.h>
+#include <openssl/opensslv.h>
+#include <string>
+
+#include "HybridArgon2.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+#if OPENSSL_VERSION_NUMBER >= 0x30200000L
+#ifndef OPENSSL_NO_ARGON2
+
+static ncrypto::Argon2Type parseAlgorithm(const std::string& algo) {
+  if (algo == "argon2d")
+    return ncrypto::Argon2Type::ARGON2D;
+  if (algo == "argon2i")
+    return ncrypto::Argon2Type::ARGON2I;
+  if (algo == "argon2id")
+    return ncrypto::Argon2Type::ARGON2ID;
+  throw std::runtime_error("Unknown argon2 algorithm: " + algo);
+}
+
+static std::shared_ptr<ArrayBuffer> hashImpl(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message,
+                                             const std::shared_ptr<ArrayBuffer>& nonce, double parallelism, double tagLength, double memory,
+                                             double passes, double version, const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                                             const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) {
+
+  auto type = parseAlgorithm(algorithm);
+
+  ncrypto::Buffer<const char> passBuf{message->size() > 0 ? reinterpret_cast<const char*>(message->data()) : "", message->size()};
+
+  ncrypto::Buffer<const unsigned char> saltBuf{nonce->size() > 0 ? reinterpret_cast<const unsigned char*>(nonce->data())
+                                                                 : reinterpret_cast<const unsigned char*>(""),
+                                               nonce->size()};
+
+  ncrypto::Buffer<const unsigned char> secretBuf{nullptr, 0};
+  if (secret.has_value() && secret.value()->size() > 0) {
+    secretBuf = {reinterpret_cast<const unsigned char*>(secret.value()->data()), secret.value()->size()};
+  }
+
+  ncrypto::Buffer<const unsigned char> adBuf{nullptr, 0};
+  if (associatedData.has_value() && associatedData.value()->size() > 0) {
+    adBuf = {reinterpret_cast<const unsigned char*>(associatedData.value()->data()), associatedData.value()->size()};
+  }
+
+  auto result =
+      ncrypto::argon2(passBuf, saltBuf, static_cast<uint32_t>(parallelism), static_cast<size_t>(tagLength), static_cast<uint32_t>(memory),
+                      static_cast<uint32_t>(passes), static_cast<uint32_t>(version), secretBuf, adBuf, type);
+
+  if (!result) {
+    unsigned long err = ERR_peek_last_error();
+    const char* reason = err ? ERR_reason_error_string(err) : nullptr;
+    throw std::runtime_error(reason ? std::string("Argon2 operation failed: ") + reason : "Argon2 operation failed");
+  }
+
+  return ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(result.get()), result.size());
+}
+
+#endif // OPENSSL_NO_ARGON2
+#endif // OPENSSL_VERSION_NUMBER
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridArgon2::hash(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message, const std::shared_ptr<ArrayBuffer>& nonce,
+                   double parallelism, double tagLength, double memory, double passes, double version,
+                   const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                   const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) {
+#if OPENSSL_VERSION_NUMBER >= 0x30200000L && !defined(OPENSSL_NO_ARGON2)
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  auto nativeNonce = ToNativeArrayBuffer(nonce);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeSecret;
+  if (secret.has_value()) {
+    nativeSecret = ToNativeArrayBuffer(secret.value());
+  }
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeAd;
+  if (associatedData.has_value()) {
+    nativeAd = ToNativeArrayBuffer(associatedData.value());
+  }
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([algorithm, nativeMessage, nativeNonce, parallelism, tagLength, memory, passes,
+                                                       version, nativeSecret = std::move(nativeSecret), nativeAd = std::move(nativeAd)]() {
+    return hashImpl(algorithm, nativeMessage, nativeNonce, parallelism, tagLength, memory, passes, version, nativeSecret, nativeAd);
+  });
+#else
+  throw std::runtime_error("Argon2 is not supported (requires OpenSSL 3.2+)");
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> HybridArgon2::hashSync(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message,
+                                                    const std::shared_ptr<ArrayBuffer>& nonce, double parallelism, double tagLength,
+                                                    double memory, double passes, double version,
+                                                    const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                                                    const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) {
+#if OPENSSL_VERSION_NUMBER >= 0x30200000L && !defined(OPENSSL_NO_ARGON2)
+  return hashImpl(algorithm, message, nonce, parallelism, tagLength, memory, passes, version, secret, associatedData);
+#else
+  throw std::runtime_error("Argon2 is not supported (requires OpenSSL 3.2+)");
+#endif
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/argon2/HybridArgon2.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "HybridArgon2Spec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridArgon2 : public HybridArgon2Spec {
+ public:
+  HybridArgon2() : HybridObject(TAG) {}
+
+ public:
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> hash(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message,
+                                                              const std::shared_ptr<ArrayBuffer>& nonce, double parallelism,
+                                                              double tagLength, double memory, double passes, double version,
+                                                              const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                                                              const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) override;
+
+  std::shared_ptr<ArrayBuffer> hashSync(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message,
+                                        const std::shared_ptr<ArrayBuffer>& nonce, double parallelism, double tagLength, double memory,
+                                        double passes, double version, const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                                        const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) override;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/certificate/HybridCertificate.cpp

@@ -0,0 +1,42 @@
+#include "HybridCertificate.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <ncrypto.h>
+#include <openssl/crypto.h>
+
+namespace margelo::nitro::crypto {
+
+bool HybridCertificate::verifySpkac(const std::shared_ptr<ArrayBuffer>& spkac) {
+  return ncrypto::VerifySpkac(reinterpret_cast<const char*>(spkac->data()), spkac->size());
+}
+
+std::shared_ptr<ArrayBuffer> HybridCertificate::exportPublicKey(const std::shared_ptr<ArrayBuffer>& spkac) {
+  auto bio = ncrypto::ExportPublicKey(reinterpret_cast<const char*>(spkac->data()), spkac->size());
+
+  if (!bio) {
+    auto empty = new uint8_t[0];
+    return std::make_shared<NativeArrayBuffer>(empty, 0, [empty]() { delete[] empty; });
+  }
+
+  BUF_MEM* mem = bio;
+  if (!mem || mem->length == 0) {
+    auto empty = new uint8_t[0];
+    return std::make_shared<NativeArrayBuffer>(empty, 0, [empty]() { delete[] empty; });
+  }
+
+  return ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(mem->data), mem->length);
+}
+
+std::shared_ptr<ArrayBuffer> HybridCertificate::exportChallenge(const std::shared_ptr<ArrayBuffer>& spkac) {
+  auto buf = ncrypto::ExportChallenge(reinterpret_cast<const char*>(spkac->data()), spkac->size());
+
+  if (buf.data == nullptr) {
+    auto empty = new uint8_t[0];
+    return std::make_shared<NativeArrayBuffer>(empty, 0, [empty]() { delete[] empty; });
+  }
+
+  auto result = ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(buf.data), buf.len);
+  OPENSSL_free(buf.data);
+  return result;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/certificate/HybridCertificate.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "HybridCertificateSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridCertificate : public HybridCertificateSpec {
+ public:
+  HybridCertificate() : HybridObject(TAG) {}
+
+  bool verifySpkac(const std::shared_ptr<ArrayBuffer>& spkac) override;
+  std::shared_ptr<ArrayBuffer> exportPublicKey(const std::shared_ptr<ArrayBuffer>& spkac) override;
+  std::shared_ptr<ArrayBuffer> exportChallenge(const std::shared_ptr<ArrayBuffer>& spkac) override;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/CCMCipher.cpp

@@ -54,6 +54,7 @@ void CCMCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::s
 
 std::shared_ptr<ArrayBuffer> CCMCipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   checkCtx();
+  checkNotFinalized();
   auto native_data = ToNativeArrayBuffer(data);
   size_t in_len = native_data->size();
   if (in_len < 0 || in_len > INT_MAX) {
@@ -104,10 +105,11 @@ std::shared_ptr<ArrayBuffer> CCMCipher::update(const std::shared_ptr<ArrayBuffer
 
 std::shared_ptr<ArrayBuffer> CCMCipher::final() {
   checkCtx();
+  checkNotFinalized();
 
   // CCM decryption does not use final. Verification happens in the last update call.
   if (!is_cipher) {
-    // Return an empty buffer, matching Node.js behavior
+    is_finalized = true;
     unsigned char* empty_output = new unsigned char[0];
     return std::make_shared<NativeArrayBuffer>(empty_output, 0, [=]() { delete[] empty_output; });
   }
@@ -138,6 +140,7 @@ std::shared_ptr<ArrayBuffer> CCMCipher::final() {
     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; });

package/cpp/cipher/ChaCha20Cipher.cpp

@@ -64,6 +64,7 @@ void ChaCha20Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const s
 
 std::shared_ptr<ArrayBuffer> ChaCha20Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   checkCtx();
+  checkNotFinalized();
   auto native_data = ToNativeArrayBuffer(data);
   size_t in_len = native_data->size();
   if (in_len > INT_MAX) {
@@ -89,7 +90,8 @@ std::shared_ptr<ArrayBuffer> ChaCha20Cipher::update(const std::shared_ptr<ArrayB
 
 std::shared_ptr<ArrayBuffer> ChaCha20Cipher::final() {
   checkCtx();
-  // For ChaCha20, final() should return an empty buffer since it's a stream cipher
+  checkNotFinalized();
+  is_finalized = true;
   unsigned char* empty_output = new unsigned char[0];
   return std::make_shared<NativeArrayBuffer>(empty_output, 0, [=]() { delete[] empty_output; });
 }

package/cpp/cipher/ChaCha20Poly1305Cipher.cpp

@@ -60,13 +60,12 @@ void ChaCha20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key,
     ctx = nullptr;
     throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to set key/IV: " + std::string(err_buf));
   }
-
-  // Reset final_called flag
-  final_called = false;
+  is_finalized = false;
 }
 
 std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   checkCtx();
+  checkNotFinalized();
   auto native_data = ToNativeArrayBuffer(data);
   size_t in_len = native_data->size();
   if (in_len > INT_MAX) {
@@ -92,6 +91,7 @@ std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::update(const std::shared_pt
 
 std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::final() {
   checkCtx();
+  checkNotFinalized();
 
   // For ChaCha20-Poly1305, we need to call final to generate the tag
   int out_len = 0;
@@ -105,7 +105,7 @@ std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::final() {
     throw std::runtime_error("ChaCha20Poly1305Cipher: Failed to finalize: " + std::string(err_buf));
   }
 
-  final_called = true;
+  is_finalized = true;
   return std::make_shared<NativeArrayBuffer>(out, out_len, [=]() { delete[] out; });
 }
 
@@ -130,7 +130,7 @@ std::shared_ptr<ArrayBuffer> ChaCha20Poly1305Cipher::getAuthTag() {
   if (!is_cipher) {
     throw std::runtime_error("getAuthTag can only be called during encryption");
   }
-  if (!final_called) {
+  if (!is_finalized) {
     throw std::runtime_error("getAuthTag must be called after final()");
   }
 

package/cpp/cipher/ChaCha20Poly1305Cipher.hpp

@@ -6,7 +6,7 @@ namespace margelo::nitro::crypto {
 
 class ChaCha20Poly1305Cipher : public HybridCipher {
  public:
-  ChaCha20Poly1305Cipher() : HybridObject(TAG), final_called(false) {}
+  ChaCha20Poly1305Cipher() : HybridObject(TAG) {}
   ~ChaCha20Poly1305Cipher() {
     // Let parent destructor free the context
     ctx = nullptr;
@@ -24,7 +24,6 @@ class ChaCha20Poly1305Cipher : public HybridCipher {
   static constexpr int kKeySize = 32;
   static constexpr int kNonceSize = 12;
   static constexpr int kTagSize = 16; // Poly1305 tag is always 16 bytes
-  bool final_called;
 };
 
 } // namespace margelo::nitro::crypto

package/cpp/cipher/HybridCipher.cpp

@@ -8,6 +8,7 @@
 #include "HybridCipher.hpp"
 #include "QuickCryptoUtils.hpp"
 
+#include <ncrypto.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 
@@ -26,6 +27,12 @@ void HybridCipher::checkCtx() const {
   }
 }
 
+void HybridCipher::checkNotFinalized() const {
+  if (is_finalized) {
+    throw std::runtime_error("Unsupported state or unable to authenticate data");
+  }
+}
+
 bool HybridCipher::maybePassAuthTagToOpenSSL() {
   if (auth_tag_state == kAuthTagKnown) {
     OSSL_PARAM params[] = {OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, auth_tag, auth_tag_len),
@@ -47,6 +54,7 @@ void HybridCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std
     EVP_CIPHER_CTX_free(ctx);
     ctx = nullptr;
   }
+  is_finalized = false;
 
   // 1. Get cipher implementation by name
   const EVP_CIPHER* cipher = EVP_get_cipherbyname(cipher_type.c_str());
@@ -99,6 +107,7 @@ void HybridCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std
 std::shared_ptr<ArrayBuffer> HybridCipher::update(const std::shared_ptr<ArrayBuffer>& data) {
   auto native_data = ToNativeArrayBuffer(data);
   checkCtx();
+  checkNotFinalized();
   size_t in_len = native_data->size();
   if (in_len > INT_MAX) {
     throw std::runtime_error("Message too long");
@@ -124,6 +133,7 @@ std::shared_ptr<ArrayBuffer> HybridCipher::update(const std::shared_ptr<ArrayBuf
 
 std::shared_ptr<ArrayBuffer> HybridCipher::final() {
   checkCtx();
+  checkNotFinalized();
   // Block size is max output size for final, unless EVP_CIPH_NO_PADDING is set
   int block_size = EVP_CIPHER_CTX_block_size(ctx);
   if (block_size <= 0)
@@ -148,8 +158,8 @@ std::shared_ptr<ArrayBuffer> HybridCipher::final() {
 
   // Context should NOT be freed here. It might be needed for getAuthTag() for GCM/OCB.
   // The context will be freed by the destructor (~HybridCipher) when the object goes out of scope.
+  is_finalized = true;
 
-  // Return the shared_ptr<NativeArrayBuffer> (implicit upcast to shared_ptr<ArrayBuffer>)
   return native_final_chunk;
 }
 
@@ -336,4 +346,61 @@ std::vector<std::string> HybridCipher::getSupportedCiphers() {
   return cipher_names;
 }
 
+std::optional<CipherInfo> HybridCipher::getCipherInfo(const std::string& name, std::optional<double> keyLength,
+                                                      std::optional<double> ivLength) {
+  auto cipher = ncrypto::Cipher::FromName(name.c_str());
+  if (!cipher)
+    return std::nullopt;
+
+  size_t iv_length = cipher.getIvLength();
+  size_t key_length = cipher.getKeyLength();
+
+  if (keyLength.has_value() || ivLength.has_value()) {
+    auto ctx = ncrypto::CipherCtxPointer::New();
+    if (!ctx.init(cipher, true))
+      return std::nullopt;
+
+    if (keyLength.has_value()) {
+      size_t check_len = static_cast<size_t>(keyLength.value());
+      if (!ctx.setKeyLength(check_len))
+        return std::nullopt;
+      key_length = check_len;
+    }
+
+    if (ivLength.has_value()) {
+      size_t check_len = static_cast<size_t>(ivLength.value());
+      if (cipher.isCcmMode()) {
+        if (check_len < 7 || check_len > 13)
+          return std::nullopt;
+      } else if (cipher.isGcmMode()) {
+        // GCM accepts flexible IV lengths
+      } else if (cipher.isOcbMode()) {
+        if (!ctx.setIvLength(check_len))
+          return std::nullopt;
+      } else {
+        if (check_len != iv_length)
+          return std::nullopt;
+      }
+      iv_length = check_len;
+    }
+  }
+
+  std::string name_str(cipher.getName());
+  std::transform(name_str.begin(), name_str.end(), name_str.begin(), ::tolower);
+
+  std::string mode_str(cipher.getModeLabel());
+
+  std::optional<double> block_size = std::nullopt;
+  if (!cipher.isStreamMode()) {
+    block_size = static_cast<double>(cipher.getBlockSize());
+  }
+
+  std::optional<double> iv_len = std::nullopt;
+  if (iv_length != 0) {
+    iv_len = static_cast<double>(iv_length);
+  }
+
+  return CipherInfo{name_str, static_cast<double>(cipher.getNid()), mode_str, static_cast<double>(key_length), block_size, iv_len};
+}
+
 } // namespace margelo::nitro::crypto

package/cpp/cipher/HybridCipher.hpp

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 
+#include "CipherInfo.hpp"
 #include "HybridCipherSpec.hpp"
 
 namespace margelo::nitro::crypto {
@@ -40,6 +41,9 @@ class HybridCipher : public HybridCipherSpec {
 
   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 };
@@ -49,6 +53,7 @@ class HybridCipher : public HybridCipherSpec {
  protected:
   // Properties
   bool is_cipher = true;
+  bool is_finalized = false;
   std::string cipher_type;
   EVP_CIPHER_CTX* ctx = nullptr;
   bool pending_auth_failed = false;
@@ -62,6 +67,7 @@ class HybridCipher : public HybridCipherSpec {
   // Methods
   int getMode();
   void checkCtx() const;
+  void checkNotFinalized() const;
   bool maybePassAuthTagToOpenSSL();
 };
 

package/cpp/cipher/HybridRsaCipher.cpp

@@ -14,19 +14,6 @@ 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:

package/cpp/cipher/XChaCha20Poly1305Cipher.cpp

@@ -45,10 +45,11 @@ void XChaCha20Poly1305Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key
 
   data_buffer_.clear();
   aad_.clear();
-  final_called_ = false;
+  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
@@ -64,6 +65,7 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::update(const std::shared_p
 }
 
 std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::final() {
+  checkNotFinalized();
 #ifndef BLSALLOC_SODIUM
   throw std::runtime_error("XChaCha20Poly1305Cipher: libsodium must be enabled (BLSALLOC_SODIUM)");
 #else
@@ -80,12 +82,12 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::final() {
       throw std::runtime_error("XChaCha20Poly1305Cipher: encryption failed");
     }
 
-    final_called_ = true;
+    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()) {
-      final_called_ = true;
+      is_finalized = true;
       return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
     }
 
@@ -101,7 +103,7 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::final() {
       throw std::runtime_error("XChaCha20Poly1305Cipher: decryption failed - authentication tag mismatch");
     }
 
-    final_called_ = true;
+    is_finalized = true;
     size_t pt_len = data_buffer_.size();
     return std::make_shared<NativeArrayBuffer>(plaintext, pt_len, [=]() { delete[] plaintext; });
   }
@@ -126,7 +128,7 @@ std::shared_ptr<ArrayBuffer> XChaCha20Poly1305Cipher::getAuthTag() {
   if (!is_cipher) {
     throw std::runtime_error("getAuthTag can only be called during encryption");
   }
-  if (!final_called_) {
+  if (!is_finalized) {
     throw std::runtime_error("getAuthTag must be called after final()");
   }
 

package/cpp/cipher/XChaCha20Poly1305Cipher.hpp

@@ -16,7 +16,7 @@ namespace margelo::nitro::crypto {
 
 class XChaCha20Poly1305Cipher : public HybridCipher {
  public:
-  XChaCha20Poly1305Cipher() : HybridObject(TAG), final_called_(false) {}
+  XChaCha20Poly1305Cipher() : HybridObject(TAG) {}
   ~XChaCha20Poly1305Cipher();
 
   void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
@@ -37,7 +37,6 @@ class XChaCha20Poly1305Cipher : public HybridCipher {
   std::vector<uint8_t> aad_;
   std::vector<uint8_t> data_buffer_;
   uint8_t auth_tag_[kTagSize];
-  bool final_called_;
 };
 
 } // namespace margelo::nitro::crypto

package/cpp/cipher/XSalsa20Cipher.cpp

@@ -28,12 +28,14 @@ void XSalsa20Cipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const s
   // 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
@@ -51,9 +53,11 @@ std::shared_ptr<ArrayBuffer> XSalsa20Cipher::update(const std::shared_ptr<ArrayB
  * 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
 }