react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.22

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

@@ -47,14 +47,12 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ CipherArgs <> JS CipherArgs (object)
   template <>
-  struct JSIConverter<CipherArgs> final {
-    static inline CipherArgs fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  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 CipherArgs(
+      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")),
@@ -62,7 +60,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "authTagLen"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const CipherArgs& arg) {
+    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));

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.hpp

@@ -53,7 +53,7 @@ namespace margelo::nitro::crypto {
 
     public:
       // Methods
-      virtual std::shared_ptr<margelo::nitro::crypto::HybridCipherSpec> createCipher(const CipherArgs& args) = 0;
+      virtual std::shared_ptr<HybridCipherSpec> createCipher(const CipherArgs& args) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -21,8 +21,8 @@ namespace margelo::nitro::crypto { struct CipherArgs; }
 #include <NitroModules/ArrayBuffer.hpp>
 #include "CipherArgs.hpp"
 #include <optional>
-#include <vector>
 #include <string>
+#include <vector>
 
 namespace margelo::nitro::crypto {
 

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

@@ -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

@@ -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 {
 
@@ -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

@@ -19,6 +19,7 @@ namespace margelo::nitro::crypto {
       prototype.registerHybridMethod("digest", &HybridHashSpec::digest);
       prototype.registerHybridMethod("copy", &HybridHashSpec::copy);
       prototype.registerHybridMethod("getSupportedHashAlgorithms", &HybridHashSpec::getSupportedHashAlgorithms);
+      prototype.registerHybridMethod("getOpenSSLVersion", &HybridHashSpec::getOpenSSLVersion);
     });
   }
 

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

@@ -59,8 +59,9 @@ namespace margelo::nitro::crypto {
       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<margelo::nitro::crypto::HybridHashSpec> copy(std::optional<double> outputLength) = 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

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

@@ -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"
@@ -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.hpp

@@ -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 {

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

@@ -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 {
 

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

@@ -0,0 +1,22 @@
+///
+/// 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);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,70 @@
+///
+/// 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, 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, const std::string& hashAlgorithm, const std::optional<std::shared_ptr<ArrayBuffer>>& label) = 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

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

@@ -0,0 +1,77 @@
+///
+/// HybridRsaKeyPairSpec.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 `KeyObject` to properly resolve imports.
+namespace margelo::nitro::crypto { struct KeyObject; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include "KeyObject.hpp"
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `RsaKeyPair`
+   * Inherit this class to create instances of `HybridRsaKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRsaKeyPair: public HybridRsaKeyPairSpec {
+   * public:
+   *   HybridRsaKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRsaKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRsaKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRsaKeyPairSpec() 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 setPublicExponent(const std::shared_ptr<ArrayBuffer>& publicExponent) = 0;
+      virtual void setHashAlgorithm(const std::string& hashAlgorithm) = 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;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "RsaKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -25,11 +25,11 @@ namespace margelo::nitro::crypto { enum class JWKuse; }
 // Forward declaration of `KeyUsage` to properly resolve imports.
 namespace margelo::nitro::crypto { enum class KeyUsage; }
 
-#include <optional>
 #include "JWKkty.hpp"
+#include <optional>
 #include "JWKuse.hpp"
-#include <vector>
 #include "KeyUsage.hpp"
+#include <vector>
 #include <string>
 
 namespace margelo::nitro::crypto {
@@ -71,17 +71,15 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ JWK <> JS JWK (object)
   template <>
-  struct JSIConverter<JWK> final {
-    static inline JWK fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::JWK> final {
+    static inline margelo::nitro::crypto::JWK fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return JWK(
-        JSIConverter<std::optional<JWKkty>>::fromJSI(runtime, obj.getProperty(runtime, "kty")),
-        JSIConverter<std::optional<JWKuse>>::fromJSI(runtime, obj.getProperty(runtime, "use")),
-        JSIConverter<std::optional<std::vector<KeyUsage>>>::fromJSI(runtime, obj.getProperty(runtime, "key_ops")),
+      return margelo::nitro::crypto::JWK(
+        JSIConverter<std::optional<margelo::nitro::crypto::JWKkty>>::fromJSI(runtime, obj.getProperty(runtime, "kty")),
+        JSIConverter<std::optional<margelo::nitro::crypto::JWKuse>>::fromJSI(runtime, obj.getProperty(runtime, "use")),
+        JSIConverter<std::optional<std::vector<margelo::nitro::crypto::KeyUsage>>>::fromJSI(runtime, obj.getProperty(runtime, "key_ops")),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "alg")),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "crv")),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "kid")),
@@ -103,11 +101,11 @@ namespace margelo::nitro {
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "ext"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const JWK& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::JWK& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, "kty", JSIConverter<std::optional<JWKkty>>::toJSI(runtime, arg.kty));
-      obj.setProperty(runtime, "use", JSIConverter<std::optional<JWKuse>>::toJSI(runtime, arg.use));
-      obj.setProperty(runtime, "key_ops", JSIConverter<std::optional<std::vector<KeyUsage>>>::toJSI(runtime, arg.key_ops));
+      obj.setProperty(runtime, "kty", JSIConverter<std::optional<margelo::nitro::crypto::JWKkty>>::toJSI(runtime, arg.kty));
+      obj.setProperty(runtime, "use", JSIConverter<std::optional<margelo::nitro::crypto::JWKuse>>::toJSI(runtime, arg.use));
+      obj.setProperty(runtime, "key_ops", JSIConverter<std::optional<std::vector<margelo::nitro::crypto::KeyUsage>>>::toJSI(runtime, arg.key_ops));
       obj.setProperty(runtime, "alg", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.alg));
       obj.setProperty(runtime, "crv", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.crv));
       obj.setProperty(runtime, "kid", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.kid));
@@ -134,9 +132,9 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
-      if (!JSIConverter<std::optional<JWKkty>>::canConvert(runtime, obj.getProperty(runtime, "kty"))) return false;
-      if (!JSIConverter<std::optional<JWKuse>>::canConvert(runtime, obj.getProperty(runtime, "use"))) return false;
-      if (!JSIConverter<std::optional<std::vector<KeyUsage>>>::canConvert(runtime, obj.getProperty(runtime, "key_ops"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::crypto::JWKkty>>::canConvert(runtime, obj.getProperty(runtime, "kty"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::crypto::JWKuse>>::canConvert(runtime, obj.getProperty(runtime, "use"))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::crypto::KeyUsage>>>::canConvert(runtime, obj.getProperty(runtime, "key_ops"))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "alg"))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "crv"))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "kid"))) return false;