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

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

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

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

@@ -0,0 +1,77 @@
+///
+/// HybridEcKeyPairSpec.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 `KeyObject` to properly resolve imports.
+namespace margelo::nitro::crypto { struct KeyObject; }
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#include <NitroModules/Promise.hpp>
+#include "KeyObject.hpp"
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `EcKeyPair`
+   * Inherit this class to create instances of `HybridEcKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEcKeyPair: public HybridEcKeyPairSpec {
+   * public:
+   *   HybridEcKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEcKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEcKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridEcKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair() = 0;
+      virtual void generateKeyPairSync() = 0;
+      virtual KeyObject importKey(const std::string& format, const std::shared_ptr<ArrayBuffer>& keyData, const std::string& algorithm, bool extractable, const std::vector<std::string>& keyUsages) = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportKey(const KeyObject& key, const std::string& format) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPrivateKey() = 0;
+      virtual void setCurve(const std::string& curve) = 0;
+      virtual std::shared_ptr<ArrayBuffer> sign(const std::shared_ptr<ArrayBuffer>& data, const std::string& hashAlgorithm) = 0;
+      virtual bool verify(const std::shared_ptr<ArrayBuffer>& data, const std::shared_ptr<ArrayBuffer>& signature, const std::string& hashAlgorithm) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "EcKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -2,7 +2,7 @@
 /// HybridEdKeyPairSpec.cpp
 /// 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
 ///
 
 #include "HybridEdKeyPairSpec.hpp"
@@ -14,6 +14,7 @@ namespace margelo::nitro::crypto {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("diffieHellman", &HybridEdKeyPairSpec::diffieHellman);
       prototype.registerHybridMethod("generateKeyPair", &HybridEdKeyPairSpec::generateKeyPair);
       prototype.registerHybridMethod("generateKeyPairSync", &HybridEdKeyPairSpec::generateKeyPairSync);
       prototype.registerHybridMethod("getPublicKey", &HybridEdKeyPairSpec::getPublicKey);

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

@@ -2,7 +2,7 @@
 /// HybridEdKeyPairSpec.hpp
 /// 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
 ///
 
 #pragma once
@@ -16,10 +16,10 @@
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 
+#include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
-#include <optional>
 #include <string>
-#include <NitroModules/ArrayBuffer.hpp>
+#include <optional>
 
 namespace margelo::nitro::crypto {
 
@@ -44,7 +44,7 @@ namespace margelo::nitro::crypto {
       explicit HybridEdKeyPairSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridEdKeyPairSpec() { }
+      ~HybridEdKeyPairSpec() override = default;
 
     public:
       // Properties
@@ -52,6 +52,7 @@ namespace margelo::nitro::crypto {
 
     public:
       // Methods
+      virtual std::shared_ptr<ArrayBuffer> diffieHellman(const std::shared_ptr<ArrayBuffer>& privateKey, const std::shared_ptr<ArrayBuffer>& publicKey) = 0;
       virtual std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;

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

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

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

@@ -0,0 +1,75 @@
+///
+/// HybridHashSpec.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 `HybridHashSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridHashSpec; }
+
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include "HybridHashSpec.hpp"
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Hash`
+   * Inherit this class to create instances of `HybridHashSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHash: public HybridHashSpec {
+   * public:
+   *   HybridHash(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHashSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHashSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHashSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void createHash(const std::string& algorithm, std::optional<double> outputLength) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest(const std::optional<std::string>& encoding) = 0;
+      virtual std::shared_ptr<HybridHashSpec> copy(std::optional<double> outputLength) = 0;
+      virtual std::vector<std::string> getSupportedHashAlgorithms() = 0;
+      virtual std::string getOpenSSLVersion() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Hash";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,66 @@
+///
+/// HybridHmacSpec.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; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Hmac`
+   * Inherit this class to create instances of `HybridHmacSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHmac: public HybridHmacSpec {
+   * public:
+   *   HybridHmac(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHmacSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHmacSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHmacSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void createHmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Hmac";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -2,7 +2,7 @@
 /// HybridKeyObjectHandleSpec.cpp
 /// 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
 ///
 
 #include "HybridKeyObjectHandleSpec.hpp"

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

@@ -2,7 +2,7 @@
 /// HybridKeyObjectHandleSpec.hpp
 /// 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
 ///
 
 #pragma once
@@ -21,8 +21,8 @@ namespace margelo::nitro::crypto { enum class KFormatType; }
 namespace margelo::nitro::crypto { enum class KeyEncoding; }
 // Forward declaration of `JWK` to properly resolve imports.
 namespace margelo::nitro::crypto { struct JWK; }
-// Forward declaration of `CFRGKeyPairType` to properly resolve imports.
-namespace margelo::nitro::crypto { enum class CFRGKeyPairType; }
+// Forward declaration of `AsymmetricKeyType` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class AsymmetricKeyType; }
 // Forward declaration of `KeyType` to properly resolve imports.
 namespace margelo::nitro::crypto { enum class KeyType; }
 // Forward declaration of `NamedCurve` to properly resolve imports.
@@ -31,12 +31,12 @@ namespace margelo::nitro::crypto { enum class NamedCurve; }
 namespace margelo::nitro::crypto { struct KeyDetail; }
 
 #include <NitroModules/ArrayBuffer.hpp>
-#include <optional>
 #include "KFormatType.hpp"
+#include <optional>
 #include "KeyEncoding.hpp"
 #include <string>
 #include "JWK.hpp"
-#include "CFRGKeyPairType.hpp"
+#include "AsymmetricKeyType.hpp"
 #include "KeyType.hpp"
 #include <variant>
 #include "NamedCurve.hpp"
@@ -65,7 +65,7 @@ namespace margelo::nitro::crypto {
       explicit HybridKeyObjectHandleSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridKeyObjectHandleSpec() { }
+      ~HybridKeyObjectHandleSpec() override = default;
 
     public:
       // Properties
@@ -75,9 +75,9 @@ namespace margelo::nitro::crypto {
       // Methods
       virtual std::shared_ptr<ArrayBuffer> exportKey(std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual JWK exportJwk(const JWK& key, bool handleRsaPss) = 0;
-      virtual CFRGKeyPairType getAsymmetricKeyType() = 0;
+      virtual AsymmetricKeyType getAsymmetricKeyType() = 0;
       virtual bool init(KeyType keyType, const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key, std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
-      virtual bool initECRaw(const std::string& curveName, const std::shared_ptr<ArrayBuffer>& keyData) = 0;
+      virtual bool initECRaw(const std::string& namedCurve, const std::shared_ptr<ArrayBuffer>& keyData) = 0;
       virtual std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) = 0;
       virtual KeyDetail keyDetail() = 0;
 

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

@@ -2,7 +2,7 @@
 /// HybridPbkdf2Spec.cpp
 /// 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
 ///
 
 #include "HybridPbkdf2Spec.hpp"

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

@@ -2,7 +2,7 @@
 /// HybridPbkdf2Spec.hpp
 /// 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
 ///
 
 #pragma once
@@ -16,8 +16,8 @@
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 
-#include <NitroModules/Promise.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
 #include <string>
 
 namespace margelo::nitro::crypto {
@@ -43,7 +43,7 @@ namespace margelo::nitro::crypto {
       explicit HybridPbkdf2Spec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridPbkdf2Spec() { }
+      ~HybridPbkdf2Spec() override = default;
 
     public:
       // Properties

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

@@ -2,7 +2,7 @@
 /// HybridRandomSpec.cpp
 /// 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
 ///
 
 #include "HybridRandomSpec.hpp"

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

@@ -2,7 +2,7 @@
 /// HybridRandomSpec.hpp
 /// 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
 ///
 
 #pragma once
@@ -16,8 +16,8 @@
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 
-#include <NitroModules/Promise.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
 
 namespace margelo::nitro::crypto {
 
@@ -42,7 +42,7 @@ namespace margelo::nitro::crypto {
       explicit HybridRandomSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridRandomSpec() { }
+      ~HybridRandomSpec() override = default;
 
     public:
       // Properties

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

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

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

@@ -0,0 +1,72 @@
+///
+/// HybridRsaCipherSpec.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 `HybridKeyObjectHandleSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include "HybridKeyObjectHandleSpec.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `RsaCipher`
+   * Inherit this class to create instances of `HybridRsaCipherSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRsaCipher: public HybridRsaCipherSpec {
+   * public:
+   *   HybridRsaCipher(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRsaCipherSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRsaCipherSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRsaCipherSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual 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) = 0;
+      virtual 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) = 0;
+      virtual std::shared_ptr<ArrayBuffer> privateEncrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& data, double padding) = 0;
+      virtual std::shared_ptr<ArrayBuffer> privateDecrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& data, double padding) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "RsaCipher";
+  };
+
+} // namespace margelo::nitro::crypto

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

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