react-native-quick-crypto 1.1.0 → 1.1.2

package/nitrogen/generated/android/QuickCrypto+autolinking.cmake

@@ -59,6 +59,8 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridScryptSpec.cpp
   ../nitrogen/generated/shared/c++/HybridSignHandleSpec.cpp
   ../nitrogen/generated/shared/c++/HybridVerifyHandleSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSlhDsaKeyPairSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridTurboShakeSpec.cpp
   ../nitrogen/generated/shared/c++/HybridUtilsSpec.cpp
   ../nitrogen/generated/shared/c++/HybridX509CertificateHandleSpec.cpp
   # Android-specific Nitrogen C++ sources

package/nitrogen/generated/android/QuickCryptoOnLoad.cpp

@@ -33,6 +33,7 @@
 #include "HybridKeyObjectHandle.hpp"
 #include "HybridMlDsaKeyPair.hpp"
 #include "HybridMlKemKeyPair.hpp"
+#include "HybridSlhDsaKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
 #include "HybridPrime.hpp"
 #include "HybridRandom.hpp"
@@ -40,6 +41,7 @@
 #include "HybridRsaKeyPair.hpp"
 #include "HybridScrypt.hpp"
 #include "HybridSignHandle.hpp"
+#include "HybridTurboShake.hpp"
 #include "HybridUtils.hpp"
 #include "HybridVerifyHandle.hpp"
 #include "HybridX509Certificate.hpp"
@@ -218,6 +220,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridMlKemKeyPair>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "SlhDsaKeyPair",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridSlhDsaKeyPair>,
+                      "The HybridObject \"HybridSlhDsaKeyPair\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridSlhDsaKeyPair>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Pbkdf2",
       []() -> std::shared_ptr<HybridObject> {
@@ -281,6 +292,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridSignHandle>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "TurboShake",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridTurboShake>,
+                      "The HybridObject \"HybridTurboShake\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridTurboShake>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Utils",
       []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/ios/QuickCryptoAutolinking.mm

@@ -28,6 +28,7 @@
 #include "HybridKeyObjectHandle.hpp"
 #include "HybridMlDsaKeyPair.hpp"
 #include "HybridMlKemKeyPair.hpp"
+#include "HybridSlhDsaKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
 #include "HybridPrime.hpp"
 #include "HybridRandom.hpp"
@@ -35,6 +36,7 @@
 #include "HybridRsaKeyPair.hpp"
 #include "HybridScrypt.hpp"
 #include "HybridSignHandle.hpp"
+#include "HybridTurboShake.hpp"
 #include "HybridUtils.hpp"
 #include "HybridVerifyHandle.hpp"
 #include "HybridX509Certificate.hpp"
@@ -210,6 +212,15 @@
       return std::make_shared<HybridMlKemKeyPair>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SlhDsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSlhDsaKeyPair>,
+                    "The HybridObject \"HybridSlhDsaKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSlhDsaKeyPair>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Pbkdf2",
     []() -> std::shared_ptr<HybridObject> {
@@ -273,6 +284,15 @@
       return std::make_shared<HybridSignHandle>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "TurboShake",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridTurboShake>,
+                    "The HybridObject \"HybridTurboShake\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridTurboShake>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Utils",
     []() -> std::shared_ptr<HybridObject> {

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

@@ -44,6 +44,18 @@ namespace margelo::nitro::crypto {
     ML_KEM_512      SWIFT_NAME(mlKem512) = 12,
     ML_KEM_768      SWIFT_NAME(mlKem768) = 13,
     ML_KEM_1024      SWIFT_NAME(mlKem1024) = 14,
+    SLH_DSA_SHA2_128S      SWIFT_NAME(slhDsaSha2128s) = 15,
+    SLH_DSA_SHA2_128F      SWIFT_NAME(slhDsaSha2128f) = 16,
+    SLH_DSA_SHA2_192S      SWIFT_NAME(slhDsaSha2192s) = 17,
+    SLH_DSA_SHA2_192F      SWIFT_NAME(slhDsaSha2192f) = 18,
+    SLH_DSA_SHA2_256S      SWIFT_NAME(slhDsaSha2256s) = 19,
+    SLH_DSA_SHA2_256F      SWIFT_NAME(slhDsaSha2256f) = 20,
+    SLH_DSA_SHAKE_128S      SWIFT_NAME(slhDsaShake128s) = 21,
+    SLH_DSA_SHAKE_128F      SWIFT_NAME(slhDsaShake128f) = 22,
+    SLH_DSA_SHAKE_192S      SWIFT_NAME(slhDsaShake192s) = 23,
+    SLH_DSA_SHAKE_192F      SWIFT_NAME(slhDsaShake192f) = 24,
+    SLH_DSA_SHAKE_256S      SWIFT_NAME(slhDsaShake256s) = 25,
+    SLH_DSA_SHAKE_256F      SWIFT_NAME(slhDsaShake256f) = 26,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
@@ -71,6 +83,18 @@ namespace margelo::nitro {
         case hashString("ml-kem-512"): return margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_512;
         case hashString("ml-kem-768"): return margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_768;
         case hashString("ml-kem-1024"): return margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_1024;
+        case hashString("slh-dsa-sha2-128s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128S;
+        case hashString("slh-dsa-sha2-128f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128F;
+        case hashString("slh-dsa-sha2-192s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192S;
+        case hashString("slh-dsa-sha2-192f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192F;
+        case hashString("slh-dsa-sha2-256s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256S;
+        case hashString("slh-dsa-sha2-256f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256F;
+        case hashString("slh-dsa-shake-128s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128S;
+        case hashString("slh-dsa-shake-128f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128F;
+        case hashString("slh-dsa-shake-192s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192S;
+        case hashString("slh-dsa-shake-192f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192F;
+        case hashString("slh-dsa-shake-256s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256S;
+        case hashString("slh-dsa-shake-256f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256F;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum AsymmetricKeyType - invalid value!");
       }
@@ -92,6 +116,18 @@ namespace margelo::nitro {
         case margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_512: return JSIConverter<std::string>::toJSI(runtime, "ml-kem-512");
         case margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_768: return JSIConverter<std::string>::toJSI(runtime, "ml-kem-768");
         case margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_1024: return JSIConverter<std::string>::toJSI(runtime, "ml-kem-1024");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-128s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-128f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-192s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-192f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-256s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-256f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-128s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-128f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-192s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-192f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-256s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-256f");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert AsymmetricKeyType to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -118,6 +154,18 @@ namespace margelo::nitro {
         case hashString("ml-kem-512"):
         case hashString("ml-kem-768"):
         case hashString("ml-kem-1024"):
+        case hashString("slh-dsa-sha2-128s"):
+        case hashString("slh-dsa-sha2-128f"):
+        case hashString("slh-dsa-sha2-192s"):
+        case hashString("slh-dsa-sha2-192f"):
+        case hashString("slh-dsa-sha2-256s"):
+        case hashString("slh-dsa-sha2-256f"):
+        case hashString("slh-dsa-shake-128s"):
+        case hashString("slh-dsa-shake-128f"):
+        case hashString("slh-dsa-shake-192s"):
+        case hashString("slh-dsa-shake-192f"):
+        case hashString("slh-dsa-shake-256s"):
+        case hashString("slh-dsa-shake-256f"):
           return true;
         default:
           return false;

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

@@ -16,14 +16,23 @@ namespace margelo::nitro::crypto {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("exportKey", &HybridKeyObjectHandleSpec::exportKey);
       prototype.registerHybridMethod("exportJwk", &HybridKeyObjectHandleSpec::exportJwk);
+      prototype.registerHybridMethod("exportRawPublic", &HybridKeyObjectHandleSpec::exportRawPublic);
+      prototype.registerHybridMethod("exportRawPrivate", &HybridKeyObjectHandleSpec::exportRawPrivate);
+      prototype.registerHybridMethod("exportRawSeed", &HybridKeyObjectHandleSpec::exportRawSeed);
+      prototype.registerHybridMethod("exportECPublicRaw", &HybridKeyObjectHandleSpec::exportECPublicRaw);
+      prototype.registerHybridMethod("exportECPrivateRaw", &HybridKeyObjectHandleSpec::exportECPrivateRaw);
       prototype.registerHybridMethod("getAsymmetricKeyType", &HybridKeyObjectHandleSpec::getAsymmetricKeyType);
       prototype.registerHybridMethod("init", &HybridKeyObjectHandleSpec::init);
       prototype.registerHybridMethod("initECRaw", &HybridKeyObjectHandleSpec::initECRaw);
       prototype.registerHybridMethod("initPqcRaw", &HybridKeyObjectHandleSpec::initPqcRaw);
+      prototype.registerHybridMethod("initRawPublic", &HybridKeyObjectHandleSpec::initRawPublic);
+      prototype.registerHybridMethod("initRawPrivate", &HybridKeyObjectHandleSpec::initRawPrivate);
+      prototype.registerHybridMethod("initRawSeed", &HybridKeyObjectHandleSpec::initRawSeed);
       prototype.registerHybridMethod("initJwk", &HybridKeyObjectHandleSpec::initJwk);
       prototype.registerHybridMethod("keyDetail", &HybridKeyObjectHandleSpec::keyDetail);
       prototype.registerHybridMethod("keyEquals", &HybridKeyObjectHandleSpec::keyEquals);
       prototype.registerHybridMethod("getSymmetricKeySize", &HybridKeyObjectHandleSpec::getSymmetricKeySize);
+      prototype.registerHybridMethod("checkEcKeyData", &HybridKeyObjectHandleSpec::checkEcKeyData);
     });
   }
 

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

@@ -77,14 +77,23 @@ 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 std::shared_ptr<ArrayBuffer> exportRawPublic() = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportRawPrivate() = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportRawSeed() = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportECPublicRaw(bool compressed) = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportECPrivateRaw() = 0;
       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 bool initRawPublic(const std::string& asymmetricKeyType, const std::shared_ptr<ArrayBuffer>& keyData, const std::optional<std::string>& namedCurve) = 0;
+      virtual bool initRawPrivate(const std::string& asymmetricKeyType, const std::shared_ptr<ArrayBuffer>& keyData, const std::optional<std::string>& namedCurve) = 0;
+      virtual bool initRawSeed(const std::string& asymmetricKeyType, const std::shared_ptr<ArrayBuffer>& keyData) = 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;
       virtual double getSymmetricKeySize() = 0;
+      virtual bool checkEcKeyData() = 0;
 
     protected:
       // Hybrid Setup

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

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

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

@@ -0,0 +1,72 @@
+///
+/// HybridSlhDsaKeyPairSpec.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>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SlhDsaKeyPair`
+   * Inherit this class to create instances of `HybridSlhDsaKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSlhDsaKeyPair: public HybridSlhDsaKeyPairSpec {
+   * public:
+   *   HybridSlhDsaKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSlhDsaKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSlhDsaKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSlhDsaKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      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 std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> sign(const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual std::shared_ptr<ArrayBuffer> signSync(const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual std::shared_ptr<Promise<bool>> verify(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual bool verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual void setVariant(const std::string& variant) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SlhDsaKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,70 @@
+///
+/// HybridTurboShakeSpec.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 `TurboShakeVariant` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class TurboShakeVariant; }
+// Forward declaration of `KangarooTwelveVariant` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class KangarooTwelveVariant; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include "TurboShakeVariant.hpp"
+#include "KangarooTwelveVariant.hpp"
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `TurboShake`
+   * Inherit this class to create instances of `HybridTurboShakeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTurboShake: public HybridTurboShakeSpec {
+   * public:
+   *   HybridTurboShake(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTurboShakeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTurboShakeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTurboShakeSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> turboShake(TurboShakeVariant variant, double domainSeparation, double outputLength, const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> kangarooTwelve(KangarooTwelveVariant variant, double outputLength, const std::shared_ptr<ArrayBuffer>& data, const std::optional<std::shared_ptr<ArrayBuffer>>& customization) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "TurboShake";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -15,8 +15,6 @@ namespace margelo::nitro::crypto {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("timingSafeEqual", &HybridUtilsSpec::timingSafeEqual);
-      prototype.registerHybridMethod("bufferToString", &HybridUtilsSpec::bufferToString);
-      prototype.registerHybridMethod("stringToBuffer", &HybridUtilsSpec::stringToBuffer);
     });
   }
 

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

@@ -16,7 +16,6 @@
 
 
 #include <NitroModules/ArrayBuffer.hpp>
-#include <string>
 
 namespace margelo::nitro::crypto {
 
@@ -50,8 +49,6 @@ namespace margelo::nitro::crypto {
     public:
       // Methods
       virtual bool timingSafeEqual(const std::shared_ptr<ArrayBuffer>& a, const std::shared_ptr<ArrayBuffer>& b) = 0;
-      virtual std::string bufferToString(const std::shared_ptr<ArrayBuffer>& buffer, const std::string& encoding) = 0;
-      virtual std::shared_ptr<ArrayBuffer> stringToBuffer(const std::string& str, const std::string& encoding) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -70,11 +70,13 @@ namespace margelo::nitro::crypto {
     std::optional<std::string> dp     SWIFT_PRIVATE;
     std::optional<std::string> dq     SWIFT_PRIVATE;
     std::optional<std::string> qi     SWIFT_PRIVATE;
+    std::optional<std::string> pub     SWIFT_PRIVATE;
+    std::optional<std::string> priv     SWIFT_PRIVATE;
     std::optional<bool> ext     SWIFT_PRIVATE;
 
   public:
     JWK() = default;
-    explicit JWK(std::optional<JWKkty> kty, std::optional<JWKuse> use, std::optional<std::vector<KeyUsage>> key_ops, std::optional<std::string> alg, std::optional<std::string> crv, std::optional<std::string> kid, std::optional<std::string> x5u, std::optional<std::vector<std::string>> x5c, std::optional<std::string> x5t, std::optional<std::string> x5t_256, std::optional<std::string> n, std::optional<std::string> e, std::optional<std::string> d, std::optional<std::string> p, std::optional<std::string> q, std::optional<std::string> x, std::optional<std::string> y, std::optional<std::string> k, std::optional<std::string> dp, std::optional<std::string> dq, std::optional<std::string> qi, std::optional<bool> ext): kty(kty), use(use), key_ops(key_ops), alg(alg), crv(crv), kid(kid), x5u(x5u), x5c(x5c), x5t(x5t), x5t_256(x5t_256), n(n), e(e), d(d), p(p), q(q), x(x), y(y), k(k), dp(dp), dq(dq), qi(qi), ext(ext) {}
+    explicit JWK(std::optional<JWKkty> kty, std::optional<JWKuse> use, std::optional<std::vector<KeyUsage>> key_ops, std::optional<std::string> alg, std::optional<std::string> crv, std::optional<std::string> kid, std::optional<std::string> x5u, std::optional<std::vector<std::string>> x5c, std::optional<std::string> x5t, std::optional<std::string> x5t_256, std::optional<std::string> n, std::optional<std::string> e, std::optional<std::string> d, std::optional<std::string> p, std::optional<std::string> q, std::optional<std::string> x, std::optional<std::string> y, std::optional<std::string> k, std::optional<std::string> dp, std::optional<std::string> dq, std::optional<std::string> qi, std::optional<std::string> pub, std::optional<std::string> priv, std::optional<bool> ext): kty(kty), use(use), key_ops(key_ops), alg(alg), crv(crv), kid(kid), x5u(x5u), x5c(x5c), x5t(x5t), x5t_256(x5t_256), n(n), e(e), d(d), p(p), q(q), x(x), y(y), k(k), dp(dp), dq(dq), qi(qi), pub(pub), priv(priv), ext(ext) {}
 
   public:
     friend bool operator==(const JWK& lhs, const JWK& rhs) = default;
@@ -111,6 +113,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dp"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dq"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "qi"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pub"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "priv"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ext")))
       );
     }
@@ -137,6 +141,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "dp"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.dp));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "dq"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.dq));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "qi"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.qi));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "pub"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.pub));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "priv"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.priv));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ext"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.ext));
       return obj;
     }
@@ -169,6 +175,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dp")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dq")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "qi")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pub")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "priv")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ext")))) return false;
       return true;
     }

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

@@ -34,6 +34,7 @@ namespace margelo::nitro::crypto {
     EC      SWIFT_NAME(ec) = 2,
     OCT      SWIFT_NAME(oct) = 3,
     OKP      SWIFT_NAME(okp) = 4,
+    AKP      SWIFT_NAME(akp) = 5,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
@@ -51,6 +52,7 @@ namespace margelo::nitro {
         case hashString("EC"): return margelo::nitro::crypto::JWKkty::EC;
         case hashString("oct"): return margelo::nitro::crypto::JWKkty::OCT;
         case hashString("OKP"): return margelo::nitro::crypto::JWKkty::OKP;
+        case hashString("AKP"): return margelo::nitro::crypto::JWKkty::AKP;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum JWKkty - invalid value!");
       }
@@ -62,6 +64,7 @@ namespace margelo::nitro {
         case margelo::nitro::crypto::JWKkty::EC: return JSIConverter<std::string>::toJSI(runtime, "EC");
         case margelo::nitro::crypto::JWKkty::OCT: return JSIConverter<std::string>::toJSI(runtime, "oct");
         case margelo::nitro::crypto::JWKkty::OKP: return JSIConverter<std::string>::toJSI(runtime, "OKP");
+        case margelo::nitro::crypto::JWKkty::AKP: return JSIConverter<std::string>::toJSI(runtime, "AKP");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert JWKkty to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -78,6 +81,7 @@ namespace margelo::nitro {
         case hashString("EC"):
         case hashString("oct"):
         case hashString("OKP"):
+        case hashString("AKP"):
           return true;
         default:
           return false;

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

@@ -0,0 +1,76 @@
+///
+/// KangarooTwelveVariant.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/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * An enum which can be represented as a JavaScript union (KangarooTwelveVariant).
+   */
+  enum class KangarooTwelveVariant {
+    KT128      SWIFT_NAME(kt128) = 0,
+    KT256      SWIFT_NAME(kt256) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ KangarooTwelveVariant <> JS KangarooTwelveVariant (union)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::KangarooTwelveVariant> final {
+    static inline margelo::nitro::crypto::KangarooTwelveVariant fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("KT128"): return margelo::nitro::crypto::KangarooTwelveVariant::KT128;
+        case hashString("KT256"): return margelo::nitro::crypto::KangarooTwelveVariant::KT256;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum KangarooTwelveVariant - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KangarooTwelveVariant arg) {
+      switch (arg) {
+        case margelo::nitro::crypto::KangarooTwelveVariant::KT128: return JSIConverter<std::string>::toJSI(runtime, "KT128");
+        case margelo::nitro::crypto::KangarooTwelveVariant::KT256: return JSIConverter<std::string>::toJSI(runtime, "KT256");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert KangarooTwelveVariant to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("KT128"):
+        case hashString("KT256"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro