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

package/nitrogen/generated/ios/QuickCryptoAutolinking.mm

@@ -2,7 +2,7 @@
 /// QuickCryptoAutolinking.mm
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #import <Foundation/Foundation.h>
@@ -10,9 +10,20 @@
 
 #import <type_traits>
 
+#include "HybridBlake3.hpp"
+#include "HybridCipher.hpp"
+#include "HybridCipherFactory.hpp"
+#include "HybridEcKeyPair.hpp"
 #include "HybridEdKeyPair.hpp"
+#include "HybridHash.hpp"
+#include "HybridHmac.hpp"
+#include "HybridKeyObjectHandle.hpp"
 #include "HybridPbkdf2.hpp"
 #include "HybridRandom.hpp"
+#include "HybridRsaCipher.hpp"
+#include "HybridRsaKeyPair.hpp"
+#include "HybridSignHandle.hpp"
+#include "HybridVerifyHandle.hpp"
 
 @interface QuickCryptoAutolinking : NSObject
 @end
@@ -23,6 +34,42 @@
   using namespace margelo::nitro;
   using namespace margelo::nitro::crypto;
 
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Blake3",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridBlake3>,
+                    "The HybridObject \"HybridBlake3\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridBlake3>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Cipher",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCipher>,
+                    "The HybridObject \"HybridCipher\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCipher>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CipherFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCipherFactory>,
+                    "The HybridObject \"HybridCipherFactory\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCipherFactory>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EcKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEcKeyPair>,
+                    "The HybridObject \"HybridEcKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEcKeyPair>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "EdKeyPair",
     []() -> std::shared_ptr<HybridObject> {
@@ -32,6 +79,33 @@
       return std::make_shared<HybridEdKeyPair>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hash",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHash>,
+                    "The HybridObject \"HybridHash\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHash>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hmac",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHmac>,
+                    "The HybridObject \"HybridHmac\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHmac>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "KeyObjectHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridKeyObjectHandle>,
+                    "The HybridObject \"HybridKeyObjectHandle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridKeyObjectHandle>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Pbkdf2",
     []() -> std::shared_ptr<HybridObject> {
@@ -50,6 +124,42 @@
       return std::make_shared<HybridRandom>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RsaCipher",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridRsaCipher>,
+                    "The HybridObject \"HybridRsaCipher\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridRsaCipher>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridRsaKeyPair>,
+                    "The HybridObject \"HybridRsaKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridRsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SignHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSignHandle>,
+                    "The HybridObject \"HybridSignHandle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSignHandle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "VerifyHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridVerifyHandle>,
+                    "The HybridObject \"HybridVerifyHandle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridVerifyHandle>();
+    }
+  );
 }
 
 @end

package/nitrogen/generated/ios/QuickCryptoAutolinking.swift

@@ -2,7 +2,7 @@
 /// QuickCryptoAutolinking.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 public final class QuickCryptoAutolinking {

package/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp

@@ -0,0 +1,104 @@
+///
+/// AsymmetricKeyType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * An enum which can be represented as a JavaScript union (AsymmetricKeyType).
+   */
+  enum class AsymmetricKeyType {
+    RSA      SWIFT_NAME(rsa) = 0,
+    RSA_PSS      SWIFT_NAME(rsaPss) = 1,
+    DSA      SWIFT_NAME(dsa) = 2,
+    EC      SWIFT_NAME(ec) = 3,
+    DH      SWIFT_NAME(dh) = 4,
+    ED25519      SWIFT_NAME(ed25519) = 5,
+    ED448      SWIFT_NAME(ed448) = 6,
+    X25519      SWIFT_NAME(x25519) = 7,
+    X448      SWIFT_NAME(x448) = 8,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ AsymmetricKeyType <> JS AsymmetricKeyType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::AsymmetricKeyType> final {
+    static inline margelo::nitro::crypto::AsymmetricKeyType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("rsa"): return margelo::nitro::crypto::AsymmetricKeyType::RSA;
+        case hashString("rsa-pss"): return margelo::nitro::crypto::AsymmetricKeyType::RSA_PSS;
+        case hashString("dsa"): return margelo::nitro::crypto::AsymmetricKeyType::DSA;
+        case hashString("ec"): return margelo::nitro::crypto::AsymmetricKeyType::EC;
+        case hashString("dh"): return margelo::nitro::crypto::AsymmetricKeyType::DH;
+        case hashString("ed25519"): return margelo::nitro::crypto::AsymmetricKeyType::ED25519;
+        case hashString("ed448"): return margelo::nitro::crypto::AsymmetricKeyType::ED448;
+        case hashString("x25519"): return margelo::nitro::crypto::AsymmetricKeyType::X25519;
+        case hashString("x448"): return margelo::nitro::crypto::AsymmetricKeyType::X448;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum AsymmetricKeyType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::AsymmetricKeyType arg) {
+      switch (arg) {
+        case margelo::nitro::crypto::AsymmetricKeyType::RSA: return JSIConverter<std::string>::toJSI(runtime, "rsa");
+        case margelo::nitro::crypto::AsymmetricKeyType::RSA_PSS: return JSIConverter<std::string>::toJSI(runtime, "rsa-pss");
+        case margelo::nitro::crypto::AsymmetricKeyType::DSA: return JSIConverter<std::string>::toJSI(runtime, "dsa");
+        case margelo::nitro::crypto::AsymmetricKeyType::EC: return JSIConverter<std::string>::toJSI(runtime, "ec");
+        case margelo::nitro::crypto::AsymmetricKeyType::DH: return JSIConverter<std::string>::toJSI(runtime, "dh");
+        case margelo::nitro::crypto::AsymmetricKeyType::ED25519: return JSIConverter<std::string>::toJSI(runtime, "ed25519");
+        case margelo::nitro::crypto::AsymmetricKeyType::ED448: return JSIConverter<std::string>::toJSI(runtime, "ed448");
+        case margelo::nitro::crypto::AsymmetricKeyType::X25519: return JSIConverter<std::string>::toJSI(runtime, "x25519");
+        case margelo::nitro::crypto::AsymmetricKeyType::X448: return JSIConverter<std::string>::toJSI(runtime, "x448");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert AsymmetricKeyType to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("rsa"):
+        case hashString("rsa-pss"):
+        case hashString("dsa"):
+        case hashString("ec"):
+        case hashString("dh"):
+        case hashString("ed25519"):
+        case hashString("ed448"):
+        case hashString("x25519"):
+        case hashString("x448"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/CipherArgs.hpp

@@ -0,0 +1,86 @@
+///
+/// CipherArgs.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * A struct which can be represented as a JavaScript object (CipherArgs).
+   */
+  struct CipherArgs {
+  public:
+    bool isCipher     SWIFT_PRIVATE;
+    std::string cipherType     SWIFT_PRIVATE;
+    std::shared_ptr<ArrayBuffer> cipherKey     SWIFT_PRIVATE;
+    std::shared_ptr<ArrayBuffer> iv     SWIFT_PRIVATE;
+    std::optional<double> authTagLen     SWIFT_PRIVATE;
+
+  public:
+    CipherArgs() = default;
+    explicit CipherArgs(bool isCipher, std::string cipherType, std::shared_ptr<ArrayBuffer> cipherKey, std::shared_ptr<ArrayBuffer> iv, std::optional<double> authTagLen): isCipher(isCipher), cipherType(cipherType), cipherKey(cipherKey), iv(iv), authTagLen(authTagLen) {}
+  };
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ CipherArgs <> JS CipherArgs (object)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::CipherArgs> final {
+    static inline margelo::nitro::crypto::CipherArgs fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::crypto::CipherArgs(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "isCipher")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "cipherType")),
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, "cipherKey")),
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, "iv")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "authTagLen"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::CipherArgs& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "isCipher", JSIConverter<bool>::toJSI(runtime, arg.isCipher));
+      obj.setProperty(runtime, "cipherType", JSIConverter<std::string>::toJSI(runtime, arg.cipherType));
+      obj.setProperty(runtime, "cipherKey", JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.cipherKey));
+      obj.setProperty(runtime, "iv", JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.iv));
+      obj.setProperty(runtime, "authTagLen", JSIConverter<std::optional<double>>::toJSI(runtime, arg.authTagLen));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "isCipher"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "cipherType"))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, "cipherKey"))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, "iv"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "authTagLen"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridBlake3Spec.cpp

@@ -0,0 +1,28 @@
+///
+/// HybridBlake3Spec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridBlake3Spec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridBlake3Spec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("initHash", &HybridBlake3Spec::initHash);
+      prototype.registerHybridMethod("initKeyed", &HybridBlake3Spec::initKeyed);
+      prototype.registerHybridMethod("initDeriveKey", &HybridBlake3Spec::initDeriveKey);
+      prototype.registerHybridMethod("update", &HybridBlake3Spec::update);
+      prototype.registerHybridMethod("digest", &HybridBlake3Spec::digest);
+      prototype.registerHybridMethod("reset", &HybridBlake3Spec::reset);
+      prototype.registerHybridMethod("copy", &HybridBlake3Spec::copy);
+      prototype.registerHybridMethod("getVersion", &HybridBlake3Spec::getVersion);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridBlake3Spec.hpp

@@ -0,0 +1,76 @@
+///
+/// HybridBlake3Spec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `HybridBlake3Spec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridBlake3Spec; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include <optional>
+#include <memory>
+#include "HybridBlake3Spec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Blake3`
+   * Inherit this class to create instances of `HybridBlake3Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridBlake3: public HybridBlake3Spec {
+   * public:
+   *   HybridBlake3(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridBlake3Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridBlake3Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridBlake3Spec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void initHash() = 0;
+      virtual void initKeyed(const std::shared_ptr<ArrayBuffer>& key) = 0;
+      virtual void initDeriveKey(const std::string& context) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest(std::optional<double> length) = 0;
+      virtual void reset() = 0;
+      virtual std::shared_ptr<HybridBlake3Spec> copy() = 0;
+      virtual std::string getVersion() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Blake3";
+  };
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridCipherFactorySpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridCipherFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCipherFactorySpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridCipherFactorySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("createCipher", &HybridCipherFactorySpec::createCipher);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridCipherFactorySpec.hpp

@@ -0,0 +1,67 @@
+///
+/// HybridCipherFactorySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridCipherSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridCipherSpec; }
+// Forward declaration of `CipherArgs` to properly resolve imports.
+namespace margelo::nitro::crypto { struct CipherArgs; }
+
+#include <memory>
+#include "HybridCipherSpec.hpp"
+#include "CipherArgs.hpp"
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CipherFactory`
+   * Inherit this class to create instances of `HybridCipherFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCipherFactory: public HybridCipherFactorySpec {
+   * public:
+   *   HybridCipherFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCipherFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCipherFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCipherFactorySpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridCipherSpec> createCipher(const CipherArgs& args) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CipherFactory";
+  };
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridCipherSpec.cpp

@@ -0,0 +1,28 @@
+///
+/// HybridCipherSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCipherSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridCipherSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("update", &HybridCipherSpec::update);
+      prototype.registerHybridMethod("final", &HybridCipherSpec::final);
+      prototype.registerHybridMethod("setArgs", &HybridCipherSpec::setArgs);
+      prototype.registerHybridMethod("setAAD", &HybridCipherSpec::setAAD);
+      prototype.registerHybridMethod("setAutoPadding", &HybridCipherSpec::setAutoPadding);
+      prototype.registerHybridMethod("setAuthTag", &HybridCipherSpec::setAuthTag);
+      prototype.registerHybridMethod("getAuthTag", &HybridCipherSpec::getAuthTag);
+      prototype.registerHybridMethod("getSupportedCiphers", &HybridCipherSpec::getSupportedCiphers);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridCipherSpec.hpp

@@ -0,0 +1,76 @@
+///
+/// HybridCipherSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `CipherArgs` to properly resolve imports.
+namespace margelo::nitro::crypto { struct CipherArgs; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include "CipherArgs.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Cipher`
+   * Inherit this class to create instances of `HybridCipherSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCipher: public HybridCipherSpec {
+   * public:
+   *   HybridCipher(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCipherSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCipherSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCipherSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> final() = 0;
+      virtual void setArgs(const CipherArgs& args) = 0;
+      virtual bool setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) = 0;
+      virtual bool setAutoPadding(bool autoPad) = 0;
+      virtual bool setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getAuthTag() = 0;
+      virtual std::vector<std::string> getSupportedCiphers() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Cipher";
+  };
+
+} // namespace margelo::nitro::crypto