react-native-quick-crypto 1.0.10 → 1.0.12

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

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

@@ -0,0 +1,68 @@
+///
+/// HybridDsaKeyPairSpec.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 `DsaKeyPair`
+   * Inherit this class to create instances of `HybridDsaKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDsaKeyPair: public HybridDsaKeyPairSpec {
+   * public:
+   *   HybridDsaKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDsaKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDsaKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDsaKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair() = 0;
+      virtual void generateKeyPairSync() = 0;
+      virtual void setModulusLength(double modulusLength) = 0;
+      virtual void setDivisorLength(double divisorLength) = 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 = "DsaKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -21,6 +21,7 @@ namespace margelo::nitro::crypto {
       prototype.registerHybridMethod("setPrivateKey", &HybridECDHSpec::setPrivateKey);
       prototype.registerHybridMethod("getPublicKey", &HybridECDHSpec::getPublicKey);
       prototype.registerHybridMethod("setPublicKey", &HybridECDHSpec::setPublicKey);
+      prototype.registerHybridMethod("convertKey", &HybridECDHSpec::convertKey);
     });
   }
 

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

@@ -56,6 +56,7 @@ namespace margelo::nitro::crypto {
       virtual void setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) = 0;
       virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
       virtual void setPublicKey(const std::shared_ptr<ArrayBuffer>& publicKey) = 0;
+      virtual std::shared_ptr<ArrayBuffer> convertKey(const std::shared_ptr<ArrayBuffer>& key, const std::string& curve, double format) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -19,6 +19,7 @@ namespace margelo::nitro::crypto {
       prototype.registerHybridMethod("getAsymmetricKeyType", &HybridKeyObjectHandleSpec::getAsymmetricKeyType);
       prototype.registerHybridMethod("init", &HybridKeyObjectHandleSpec::init);
       prototype.registerHybridMethod("initECRaw", &HybridKeyObjectHandleSpec::initECRaw);
+      prototype.registerHybridMethod("initPqcRaw", &HybridKeyObjectHandleSpec::initPqcRaw);
       prototype.registerHybridMethod("initJwk", &HybridKeyObjectHandleSpec::initJwk);
       prototype.registerHybridMethod("keyDetail", &HybridKeyObjectHandleSpec::keyDetail);
       prototype.registerHybridMethod("keyEquals", &HybridKeyObjectHandleSpec::keyEquals);

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

@@ -80,6 +80,7 @@ namespace margelo::nitro::crypto {
       virtual AsymmetricKeyType getAsymmetricKeyType() = 0;
       virtual bool init(KeyType keyType, const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& key, std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual bool initECRaw(const std::string& namedCurve, const std::shared_ptr<ArrayBuffer>& keyData) = 0;
+      virtual bool initPqcRaw(const std::string& algorithmName, const std::shared_ptr<ArrayBuffer>& keyData, bool isPublic) = 0;
       virtual std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) = 0;
       virtual KeyDetail keyDetail() = 0;
       virtual bool keyEquals(const std::shared_ptr<HybridKeyObjectHandleSpec>& other) = 0;

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

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

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

@@ -0,0 +1,66 @@
+///
+/// HybridKmacSpec.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 <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Kmac`
+   * Inherit this class to create instances of `HybridKmacSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridKmac: public HybridKmacSpec {
+   * public:
+   *   HybridKmac(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridKmacSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridKmacSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridKmacSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void createKmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key, double outputLength, const std::optional<std::shared_ptr<ArrayBuffer>>& customization) = 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 = "Kmac";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,74 @@
+///
+/// HybridMlKemKeyPairSpec.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 <string>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MlKemKeyPair`
+   * Inherit this class to create instances of `HybridMlKemKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMlKemKeyPair: public HybridMlKemKeyPairSpec {
+   * public:
+   *   HybridMlKemKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMlKemKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMlKemKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMlKemKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void setVariant(const std::string& variant) = 0;
+      virtual std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType) = 0;
+      virtual void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPrivateKey() = 0;
+      virtual void setPublicKey(const std::shared_ptr<ArrayBuffer>& keyData, double format, double type) = 0;
+      virtual void setPrivateKey(const std::shared_ptr<ArrayBuffer>& keyData, double format, double type) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> encapsulate() = 0;
+      virtual std::shared_ptr<ArrayBuffer> encapsulateSync() = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> decapsulate(const std::shared_ptr<ArrayBuffer>& ciphertext) = 0;
+      virtual std::shared_ptr<ArrayBuffer> decapsulateSync(const std::shared_ptr<ArrayBuffer>& ciphertext) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MlKemKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,67 @@
+///
+/// HybridPrimeSpec.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 <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Prime`
+   * Inherit this class to create instances of `HybridPrimeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPrime: public HybridPrimeSpec {
+   * public:
+   *   HybridPrime(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPrimeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPrimeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPrimeSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> generatePrime(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add, const std::optional<std::shared_ptr<ArrayBuffer>>& rem) = 0;
+      virtual std::shared_ptr<ArrayBuffer> generatePrimeSync(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add, const std::optional<std::shared_ptr<ArrayBuffer>>& rem) = 0;
+      virtual std::shared_ptr<Promise<bool>> checkPrime(const std::shared_ptr<ArrayBuffer>& candidate, double checks) = 0;
+      virtual bool checkPrimeSync(const std::shared_ptr<ArrayBuffer>& candidate, double checks) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Prime";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,46 @@
+///
+/// HybridX509CertificateHandleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridX509CertificateHandleSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridX509CertificateHandleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("init", &HybridX509CertificateHandleSpec::init);
+      prototype.registerHybridMethod("subject", &HybridX509CertificateHandleSpec::subject);
+      prototype.registerHybridMethod("subjectAltName", &HybridX509CertificateHandleSpec::subjectAltName);
+      prototype.registerHybridMethod("issuer", &HybridX509CertificateHandleSpec::issuer);
+      prototype.registerHybridMethod("infoAccess", &HybridX509CertificateHandleSpec::infoAccess);
+      prototype.registerHybridMethod("validFrom", &HybridX509CertificateHandleSpec::validFrom);
+      prototype.registerHybridMethod("validTo", &HybridX509CertificateHandleSpec::validTo);
+      prototype.registerHybridMethod("validFromDate", &HybridX509CertificateHandleSpec::validFromDate);
+      prototype.registerHybridMethod("validToDate", &HybridX509CertificateHandleSpec::validToDate);
+      prototype.registerHybridMethod("signatureAlgorithm", &HybridX509CertificateHandleSpec::signatureAlgorithm);
+      prototype.registerHybridMethod("signatureAlgorithmOid", &HybridX509CertificateHandleSpec::signatureAlgorithmOid);
+      prototype.registerHybridMethod("serialNumber", &HybridX509CertificateHandleSpec::serialNumber);
+      prototype.registerHybridMethod("fingerprint", &HybridX509CertificateHandleSpec::fingerprint);
+      prototype.registerHybridMethod("fingerprint256", &HybridX509CertificateHandleSpec::fingerprint256);
+      prototype.registerHybridMethod("fingerprint512", &HybridX509CertificateHandleSpec::fingerprint512);
+      prototype.registerHybridMethod("raw", &HybridX509CertificateHandleSpec::raw);
+      prototype.registerHybridMethod("pem", &HybridX509CertificateHandleSpec::pem);
+      prototype.registerHybridMethod("publicKey", &HybridX509CertificateHandleSpec::publicKey);
+      prototype.registerHybridMethod("keyUsage", &HybridX509CertificateHandleSpec::keyUsage);
+      prototype.registerHybridMethod("ca", &HybridX509CertificateHandleSpec::ca);
+      prototype.registerHybridMethod("checkIssued", &HybridX509CertificateHandleSpec::checkIssued);
+      prototype.registerHybridMethod("checkPrivateKey", &HybridX509CertificateHandleSpec::checkPrivateKey);
+      prototype.registerHybridMethod("verify", &HybridX509CertificateHandleSpec::verify);
+      prototype.registerHybridMethod("checkHost", &HybridX509CertificateHandleSpec::checkHost);
+      prototype.registerHybridMethod("checkEmail", &HybridX509CertificateHandleSpec::checkEmail);
+      prototype.registerHybridMethod("checkIP", &HybridX509CertificateHandleSpec::checkIP);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,96 @@
+///
+/// HybridX509CertificateHandleSpec.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
+
+// Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; }
+// Forward declaration of `HybridX509CertificateHandleSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridX509CertificateHandleSpec; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include <memory>
+#include "HybridKeyObjectHandleSpec.hpp"
+#include <vector>
+#include "HybridX509CertificateHandleSpec.hpp"
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `X509CertificateHandle`
+   * Inherit this class to create instances of `HybridX509CertificateHandleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridX509CertificateHandle: public HybridX509CertificateHandleSpec {
+   * public:
+   *   HybridX509CertificateHandle(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridX509CertificateHandleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridX509CertificateHandleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridX509CertificateHandleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void init(const std::shared_ptr<ArrayBuffer>& buffer) = 0;
+      virtual std::string subject() = 0;
+      virtual std::string subjectAltName() = 0;
+      virtual std::string issuer() = 0;
+      virtual std::string infoAccess() = 0;
+      virtual std::string validFrom() = 0;
+      virtual std::string validTo() = 0;
+      virtual double validFromDate() = 0;
+      virtual double validToDate() = 0;
+      virtual std::string signatureAlgorithm() = 0;
+      virtual std::string signatureAlgorithmOid() = 0;
+      virtual std::string serialNumber() = 0;
+      virtual std::string fingerprint() = 0;
+      virtual std::string fingerprint256() = 0;
+      virtual std::string fingerprint512() = 0;
+      virtual std::shared_ptr<ArrayBuffer> raw() = 0;
+      virtual std::string pem() = 0;
+      virtual std::shared_ptr<HybridKeyObjectHandleSpec> publicKey() = 0;
+      virtual std::vector<std::string> keyUsage() = 0;
+      virtual bool ca() = 0;
+      virtual bool checkIssued(const std::shared_ptr<HybridX509CertificateHandleSpec>& other) = 0;
+      virtual bool checkPrivateKey(const std::shared_ptr<HybridKeyObjectHandleSpec>& key) = 0;
+      virtual bool verify(const std::shared_ptr<HybridKeyObjectHandleSpec>& key) = 0;
+      virtual std::optional<std::string> checkHost(const std::string& name, double flags) = 0;
+      virtual std::optional<std::string> checkEmail(const std::string& email, double flags) = 0;
+      virtual std::optional<std::string> checkIP(const std::string& ip) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "X509CertificateHandle";
+  };
+
+} // namespace margelo::nitro::crypto