react-native-quick-crypto 1.0.10 → 1.0.11

package/nitrogen/generated/android/QuickCryptoOnLoad.cpp

@@ -15,10 +15,14 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
+#include "HybridArgon2.hpp"
 #include "HybridBlake3.hpp"
+#include "HybridCertificate.hpp"
 #include "HybridCipher.hpp"
 #include "HybridCipherFactory.hpp"
+#include "HybridDhKeyPair.hpp"
 #include "HybridDiffieHellman.hpp"
+#include "HybridDsaKeyPair.hpp"
 #include "HybridECDH.hpp"
 #include "HybridEcKeyPair.hpp"
 #include "HybridEdKeyPair.hpp"
@@ -28,6 +32,7 @@
 #include "HybridKeyObjectHandle.hpp"
 #include "HybridMlDsaKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
+#include "HybridPrime.hpp"
 #include "HybridRandom.hpp"
 #include "HybridRsaCipher.hpp"
 #include "HybridRsaKeyPair.hpp"
@@ -48,6 +53,15 @@ int initialize(JavaVM* vm) {
     
 
     // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "Argon2",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridArgon2>,
+                      "The HybridObject \"HybridArgon2\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridArgon2>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Blake3",
       []() -> std::shared_ptr<HybridObject> {
@@ -57,6 +71,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridBlake3>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "Certificate",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridCertificate>,
+                      "The HybridObject \"HybridCertificate\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridCertificate>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Cipher",
       []() -> std::shared_ptr<HybridObject> {
@@ -75,6 +98,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridCipherFactory>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "DhKeyPair",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridDhKeyPair>,
+                      "The HybridObject \"HybridDhKeyPair\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridDhKeyPair>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "DiffieHellman",
       []() -> std::shared_ptr<HybridObject> {
@@ -84,6 +116,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridDiffieHellman>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "DsaKeyPair",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridDsaKeyPair>,
+                      "The HybridObject \"HybridDsaKeyPair\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridDsaKeyPair>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "ECDH",
       []() -> std::shared_ptr<HybridObject> {
@@ -165,6 +206,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridPbkdf2>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "Prime",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridPrime>,
+                      "The HybridObject \"HybridPrime\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridPrime>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Random",
       []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/ios/QuickCryptoAutolinking.mm

@@ -10,10 +10,14 @@
 
 #import <type_traits>
 
+#include "HybridArgon2.hpp"
 #include "HybridBlake3.hpp"
+#include "HybridCertificate.hpp"
 #include "HybridCipher.hpp"
 #include "HybridCipherFactory.hpp"
+#include "HybridDhKeyPair.hpp"
 #include "HybridDiffieHellman.hpp"
+#include "HybridDsaKeyPair.hpp"
 #include "HybridECDH.hpp"
 #include "HybridEcKeyPair.hpp"
 #include "HybridEdKeyPair.hpp"
@@ -23,6 +27,7 @@
 #include "HybridKeyObjectHandle.hpp"
 #include "HybridMlDsaKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
+#include "HybridPrime.hpp"
 #include "HybridRandom.hpp"
 #include "HybridRsaCipher.hpp"
 #include "HybridRsaKeyPair.hpp"
@@ -40,6 +45,15 @@
   using namespace margelo::nitro;
   using namespace margelo::nitro::crypto;
 
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Argon2",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridArgon2>,
+                    "The HybridObject \"HybridArgon2\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridArgon2>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Blake3",
     []() -> std::shared_ptr<HybridObject> {
@@ -49,6 +63,15 @@
       return std::make_shared<HybridBlake3>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Certificate",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCertificate>,
+                    "The HybridObject \"HybridCertificate\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCertificate>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Cipher",
     []() -> std::shared_ptr<HybridObject> {
@@ -67,6 +90,15 @@
       return std::make_shared<HybridCipherFactory>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DhKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDhKeyPair>,
+                    "The HybridObject \"HybridDhKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDhKeyPair>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "DiffieHellman",
     []() -> std::shared_ptr<HybridObject> {
@@ -76,6 +108,15 @@
       return std::make_shared<HybridDiffieHellman>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDsaKeyPair>,
+                    "The HybridObject \"HybridDsaKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDsaKeyPair>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "ECDH",
     []() -> std::shared_ptr<HybridObject> {
@@ -157,6 +198,15 @@
       return std::make_shared<HybridPbkdf2>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Prime",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPrime>,
+                    "The HybridObject \"HybridPrime\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPrime>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Random",
     []() -> std::shared_ptr<HybridObject> {

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

@@ -0,0 +1,104 @@
+///
+/// CipherInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * A struct which can be represented as a JavaScript object (CipherInfo).
+   */
+  struct CipherInfo final {
+  public:
+    std::string name     SWIFT_PRIVATE;
+    double nid     SWIFT_PRIVATE;
+    std::string mode     SWIFT_PRIVATE;
+    double keyLength     SWIFT_PRIVATE;
+    std::optional<double> blockSize     SWIFT_PRIVATE;
+    std::optional<double> ivLength     SWIFT_PRIVATE;
+
+  public:
+    CipherInfo() = default;
+    explicit CipherInfo(std::string name, double nid, std::string mode, double keyLength, std::optional<double> blockSize, std::optional<double> ivLength): name(name), nid(nid), mode(mode), keyLength(keyLength), blockSize(blockSize), ivLength(ivLength) {}
+
+  public:
+    friend bool operator==(const CipherInfo& lhs, const CipherInfo& rhs) = default;
+  };
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ CipherInfo <> JS CipherInfo (object)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::CipherInfo> final {
+    static inline margelo::nitro::crypto::CipherInfo fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::crypto::CipherInfo(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "name"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nid"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mode"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "keyLength"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "blockSize"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ivLength")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::CipherInfo& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "name"), JSIConverter<std::string>::toJSI(runtime, arg.name));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "nid"), JSIConverter<double>::toJSI(runtime, arg.nid));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "mode"), JSIConverter<std::string>::toJSI(runtime, arg.mode));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "keyLength"), JSIConverter<double>::toJSI(runtime, arg.keyLength));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "blockSize"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.blockSize));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ivLength"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.ivLength));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "name")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nid")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mode")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "keyLength")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "blockSize")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ivLength")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

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

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

@@ -0,0 +1,66 @@
+///
+/// HybridArgon2Spec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Argon2`
+   * Inherit this class to create instances of `HybridArgon2Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridArgon2: public HybridArgon2Spec {
+   * public:
+   *   HybridArgon2(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridArgon2Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridArgon2Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridArgon2Spec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual 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) = 0;
+      virtual 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) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Argon2";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,64 @@
+///
+/// HybridCertificateSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Certificate`
+   * Inherit this class to create instances of `HybridCertificateSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCertificate: public HybridCertificateSpec {
+   * public:
+   *   HybridCertificate(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCertificateSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCertificateSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCertificateSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual bool verifySpkac(const std::shared_ptr<ArrayBuffer>& spkac) = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportPublicKey(const std::shared_ptr<ArrayBuffer>& spkac) = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportChallenge(const std::shared_ptr<ArrayBuffer>& spkac) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Certificate";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -22,6 +22,7 @@ namespace margelo::nitro::crypto {
       prototype.registerHybridMethod("setAuthTag", &HybridCipherSpec::setAuthTag);
       prototype.registerHybridMethod("getAuthTag", &HybridCipherSpec::getAuthTag);
       prototype.registerHybridMethod("getSupportedCiphers", &HybridCipherSpec::getSupportedCiphers);
+      prototype.registerHybridMethod("getCipherInfo", &HybridCipherSpec::getCipherInfo);
     });
   }
 

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

@@ -15,12 +15,15 @@
 
 // Forward declaration of `CipherArgs` to properly resolve imports.
 namespace margelo::nitro::crypto { struct CipherArgs; }
+// Forward declaration of `CipherInfo` to properly resolve imports.
+namespace margelo::nitro::crypto { struct CipherInfo; }
 
 #include <NitroModules/ArrayBuffer.hpp>
 #include "CipherArgs.hpp"
 #include <optional>
 #include <string>
 #include <vector>
+#include "CipherInfo.hpp"
 
 namespace margelo::nitro::crypto {
 
@@ -61,6 +64,7 @@ namespace margelo::nitro::crypto {
       virtual bool setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) = 0;
       virtual std::shared_ptr<ArrayBuffer> getAuthTag() = 0;
       virtual std::vector<std::string> getSupportedCiphers() = 0;
+      virtual std::optional<CipherInfo> getCipherInfo(const std::string& name, std::optional<double> keyLength, std::optional<double> ivLength) = 0;
 
     protected:
       // Hybrid Setup

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

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

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

@@ -0,0 +1,69 @@
+///
+/// HybridDhKeyPairSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+
+
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `DhKeyPair`
+   * Inherit this class to create instances of `HybridDhKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDhKeyPair: public HybridDhKeyPairSpec {
+   * public:
+   *   HybridDhKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDhKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDhKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDhKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair() = 0;
+      virtual void generateKeyPairSync() = 0;
+      virtual void setPrimeLength(double primeLength) = 0;
+      virtual void setPrime(const std::shared_ptr<ArrayBuffer>& prime) = 0;
+      virtual void setGenerator(double generator) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPrivateKey() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "DhKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

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