@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -0,0 +1,51 @@
+#include "HybridPbkdf2.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridPbkdf2::pbkdf2(const std::shared_ptr<ArrayBuffer>& password,
+                                                                            const std::shared_ptr<ArrayBuffer>& salt, double iterations,
+                                                                            double keylen, const std::string& digest) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativePassword = ToNativeArrayBuffer(password);
+  auto nativeSalt = ToNativeArrayBuffer(salt);
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, nativePassword, nativeSalt, iterations, keylen, digest]() {
+    return this->pbkdf2Sync(nativePassword, nativeSalt, iterations, keylen, digest);
+  });
+}
+
+std::shared_ptr<ArrayBuffer> HybridPbkdf2::pbkdf2Sync(const std::shared_ptr<ArrayBuffer>& password,
+                                                      const std::shared_ptr<ArrayBuffer>& salt, double iterations, double keylen,
+                                                      const std::string& digest) {
+  size_t bufferSize = static_cast<size_t>(keylen);
+  uint8_t* data = new uint8_t[bufferSize];
+  auto result = std::make_shared<NativeArrayBuffer>(data, bufferSize, [=]() { delete[] data; });
+
+  // use fastpbkdf2 when possible
+  if (digest == "sha1") {
+    fastpbkdf2_hmac_sha1(password.get()->data(), password.get()->size(), salt.get()->data(), salt.get()->size(),
+                         static_cast<uint32_t>(iterations), result.get()->data(), result.get()->size());
+  } else if (digest == "sha256") {
+    fastpbkdf2_hmac_sha256(password.get()->data(), password.get()->size(), salt.get()->data(), salt.get()->size(),
+                           static_cast<uint32_t>(iterations), result.get()->data(), result.get()->size());
+  } else if (digest == "sha512") {
+    fastpbkdf2_hmac_sha512(password.get()->data(), password.get()->size(), salt.get()->data(), salt.get()->size(),
+                           static_cast<uint32_t>(iterations), result.get()->data(), result.get()->size());
+  } else {
+    // fallback to OpenSSL
+    auto* digestByName = EVP_get_digestbyname(digest.c_str());
+    if (digestByName == nullptr) {
+      throw std::runtime_error("Invalid hash-algorithm: " + digest);
+    }
+    char* passAsCharA = reinterpret_cast<char*>(password.get()->data());
+    const unsigned char* saltAsCharA = reinterpret_cast<const unsigned char*>(salt.get()->data());
+    unsigned char* resultAsCharA = reinterpret_cast<unsigned char*>(result.get()->data());
+    PKCS5_PBKDF2_HMAC(passAsCharA, password.get()->size(), saltAsCharA, salt.get()->size(), static_cast<uint32_t>(iterations), digestByName,
+                      result.get()->size(), resultAsCharA);
+  }
+
+  return result;
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/pbkdf2/HybridPbkdf2.hpp

@@ -0,0 +1,24 @@
+#include <openssl/evp.h>
+
+#include "HybridPbkdf2Spec.hpp"
+#include "fastpbkdf2.h"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridPbkdf2 : public HybridPbkdf2Spec {
+ public:
+  HybridPbkdf2() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> pbkdf2(const std::shared_ptr<ArrayBuffer>& password,
+                                                                const std::shared_ptr<ArrayBuffer>& salt, double iterations, double keylen,
+                                                                const std::string& digest) override;
+
+  std::shared_ptr<ArrayBuffer> pbkdf2Sync(const std::shared_ptr<ArrayBuffer>& password, const std::shared_ptr<ArrayBuffer>& salt,
+                                          double iterations, double keylen, const std::string& digest) override;
+};
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/prime/HybridPrime.cpp

@@ -0,0 +1,81 @@
+#include "HybridPrime.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <ncrypto.h>
+
+namespace margelo::nitro::crypto {
+
+using namespace ncrypto;
+
+static BignumPointer toBignum(const std::optional<std::shared_ptr<ArrayBuffer>>& buf) {
+  if (!buf.has_value() || buf.value()->size() == 0) {
+    return BignumPointer();
+  }
+  return BignumPointer(buf.value()->data(), buf.value()->size());
+}
+
+static std::shared_ptr<ArrayBuffer> generatePrimeImpl(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                      const std::optional<std::shared_ptr<ArrayBuffer>>& rem) {
+  int bits = static_cast<int>(size);
+
+  auto addBn = toBignum(add);
+  auto remBn = toBignum(rem);
+
+  BignumPointer::PrimeConfig config{bits, safe, addBn, remBn};
+  auto prime = BignumPointer::NewPrime(config);
+  if (!prime) {
+    throw std::runtime_error("Failed to generate prime");
+  }
+
+  auto encoded = prime.encode();
+  if (!encoded) {
+    throw std::runtime_error("Failed to encode prime");
+  }
+
+  return ToNativeArrayBuffer(encoded.get<uint8_t>(), encoded.size());
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridPrime::generatePrime(double size, bool safe,
+                                                                                  const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                                                  const std::optional<std::shared_ptr<ArrayBuffer>>& rem) {
+  auto addCopy = add.has_value() ? std::make_optional(ToNativeArrayBuffer(add.value())) : std::nullopt;
+  auto remCopy = rem.has_value() ? std::make_optional(ToNativeArrayBuffer(rem.value())) : std::nullopt;
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([size, safe, addCopy = std::move(addCopy), remCopy = std::move(remCopy)]() {
+    return generatePrimeImpl(size, safe, addCopy, remCopy);
+  });
+}
+
+std::shared_ptr<ArrayBuffer> HybridPrime::generatePrimeSync(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                            const std::optional<std::shared_ptr<ArrayBuffer>>& rem) {
+  return generatePrimeImpl(size, safe, add, rem);
+}
+
+bool HybridPrime::checkPrimeSync(const std::shared_ptr<ArrayBuffer>& candidate, double checks) {
+  BignumPointer bn(candidate->data(), candidate->size());
+  if (!bn) {
+    throw std::runtime_error("Invalid candidate");
+  }
+
+  int result = bn.isPrime(static_cast<int>(checks));
+  if (result == -1) {
+    throw std::runtime_error("Prime check failed");
+  }
+  return result == 1;
+}
+
+std::shared_ptr<Promise<bool>> HybridPrime::checkPrime(const std::shared_ptr<ArrayBuffer>& candidate, double checks) {
+  auto candidateCopy = ToNativeArrayBuffer(candidate);
+  return Promise<bool>::async([candidateCopy, checks]() {
+    BignumPointer bn(candidateCopy->data(), candidateCopy->size());
+    if (!bn) {
+      throw std::runtime_error("Invalid candidate");
+    }
+    int result = bn.isPrime(static_cast<int>(checks));
+    if (result == -1) {
+      throw std::runtime_error("Prime check failed");
+    }
+    return result == 1;
+  });
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/prime/HybridPrime.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "HybridPrimeSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridPrime : public HybridPrimeSpec {
+ public:
+  HybridPrime() : HybridObject(TAG) {}
+
+  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) override;
+  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) override;
+  std::shared_ptr<Promise<bool>> checkPrime(const std::shared_ptr<ArrayBuffer>& candidate, double checks) override;
+  bool checkPrimeSync(const std::shared_ptr<ArrayBuffer>& candidate, double checks) override;
+};
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/random/HybridRandom.cpp

@@ -0,0 +1,48 @@
+#include <openssl/err.h>
+#include <openssl/rand.h>
+
+#include "HybridRandom.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+size_t checkSize(double size) {
+  if (!CheckIsUint32(size)) {
+    throw std::runtime_error("size must be uint32");
+  }
+  if (static_cast<uint32_t>(size) > pow(2, 31) - 1) {
+    throw std::runtime_error("size must be less than 2^31 - 1");
+  }
+  return static_cast<size_t>(size);
+}
+
+size_t checkOffset(double offset) {
+  if (!CheckIsUint32(offset)) {
+    throw std::runtime_error("offset must be uint32");
+  }
+  return static_cast<size_t>(offset);
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridRandom::randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset,
+                                                                                double dSize) {
+  // get owned NativeArrayBuffer before passing to sync function
+  auto nativeBuffer = ToNativeArrayBuffer(buffer);
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+      [this, nativeBuffer, dOffset, dSize]() { return this->randomFillSync(nativeBuffer, dOffset, dSize); });
+};
+
+std::shared_ptr<ArrayBuffer> HybridRandom::randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) {
+  size_t size = checkSize(dSize);
+  size_t offset = checkOffset(dOffset);
+  if (offset + size > buffer->size()) {
+    throw std::runtime_error("offset + size must not exceed buffer length");
+  }
+  uint8_t* data = buffer->data();
+  if (RAND_bytes(data + offset, static_cast<int>(size)) != 1) {
+    throw std::runtime_error("error calling RAND_bytes: " + std::to_string(ERR_get_error()));
+  }
+  return buffer;
+};
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/random/HybridRandom.hpp

@@ -0,0 +1,32 @@
+#include <cmath>
+#include <future>
+#include <iostream>
+#include <memory>
+
+#include "HybridRandomSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridRandom : public HybridRandomSpec {
+ public:
+  HybridRandom() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset,
+                                                                    double dSize) override;
+
+  std::shared_ptr<ArrayBuffer> randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+};
+
+inline void printData(std::string name, uint8_t* data, size_t size) {
+  std::cout << "data - " << name << std::endl;
+  for (size_t i = 0; i < size; i++) {
+    printf("%u ", data[i]);
+  }
+  printf("\n");
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/rsa/HybridRsaKeyPair.cpp

@@ -0,0 +1,154 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <openssl/bio.h>
+#include <openssl/buffer.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <stdexcept>
+#include <string>
+
+#include "HybridRsaKeyPair.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<void>> HybridRsaKeyPair::generateKeyPair() {
+  return Promise<void>::async([this]() { this->generateKeyPairSync(); });
+}
+
+void HybridRsaKeyPair::generateKeyPairSync() {
+  // Clean up existing key if any
+  if (this->pkey != nullptr) {
+    EVP_PKEY_free(this->pkey);
+    this->pkey = nullptr;
+  }
+
+  // Create key generation context
+  std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)> ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, nullptr), EVP_PKEY_CTX_free);
+
+  if (!ctx) {
+    throw std::runtime_error("Failed to create RSA key generation context");
+  }
+
+  if (EVP_PKEY_keygen_init(ctx.get()) <= 0) {
+    throw std::runtime_error("Failed to initialize RSA key generation");
+  }
+
+  // Set modulus length
+  if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx.get(), this->modulusLength) <= 0) {
+    throw std::runtime_error("Failed to set RSA modulus length");
+  }
+
+  // Set public exponent
+  std::unique_ptr<BIGNUM, decltype(&BN_free)> exponent(BN_new(), BN_free);
+  if (!exponent) {
+    throw std::runtime_error("Failed to create BIGNUM for public exponent");
+  }
+
+  // Default to 65537 (0x10001) if no public exponent is set
+  if (this->publicExponent.empty()) {
+    if (BN_set_word(exponent.get(), RSA_F4) != 1) {
+      throw std::runtime_error("Failed to set default public exponent");
+    }
+  } else {
+    if (BN_bin2bn(this->publicExponent.data(), this->publicExponent.size(), exponent.get()) == nullptr) {
+      throw std::runtime_error("Failed to convert public exponent to BIGNUM");
+    }
+  }
+
+  if (EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx.get(), exponent.get()) <= 0) {
+    throw std::runtime_error("Failed to set RSA public exponent");
+  }
+
+  // Generate the key pair
+  EVP_PKEY* raw_pkey = nullptr;
+  if (EVP_PKEY_keygen(ctx.get(), &raw_pkey) <= 0) {
+    throw std::runtime_error("Failed to generate RSA key pair");
+  }
+
+  this->pkey = raw_pkey;
+}
+
+void HybridRsaKeyPair::setModulusLength(double modulusLength) {
+  this->modulusLength = static_cast<int>(modulusLength);
+}
+
+void HybridRsaKeyPair::setPublicExponent(const std::shared_ptr<ArrayBuffer>& publicExponent) {
+  if (publicExponent && publicExponent->size() > 0) {
+    const uint8_t* data = publicExponent->data();
+    this->publicExponent.assign(data, data + publicExponent->size());
+  }
+}
+
+void HybridRsaKeyPair::setHashAlgorithm(const std::string& hashAlgorithm) {
+  this->hashAlgorithm = hashAlgorithm;
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaKeyPair::getPublicKey() {
+  this->checkKeyPair();
+
+  // Export as DER format using direct OpenSSL calls
+  BIO* bio = BIO_new(BIO_s_mem());
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for public key export");
+  }
+
+  if (i2d_PUBKEY_bio(bio, this->pkey) != 1) {
+    BIO_free(bio);
+    throw std::runtime_error("Failed to export public key to DER format");
+  }
+
+  BUF_MEM* mem;
+  BIO_get_mem_ptr(bio, &mem);
+
+  // Create a string from the DER data and use ToNativeArrayBuffer utility
+  std::string derData(mem->data, mem->length);
+  BIO_free(bio);
+
+  return ToNativeArrayBuffer(derData);
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaKeyPair::getPrivateKey() {
+  this->checkKeyPair();
+
+  // Export as DER format in PKCS8 format using direct OpenSSL calls
+  BIO* bio = BIO_new(BIO_s_mem());
+  if (!bio) {
+    throw std::runtime_error("Failed to create BIO for private key export");
+  }
+
+  if (i2d_PKCS8PrivateKey_bio(bio, this->pkey, nullptr, nullptr, 0, nullptr, nullptr) != 1) {
+    BIO_free(bio);
+    throw std::runtime_error("Failed to export private key to DER PKCS8 format");
+  }
+
+  BUF_MEM* mem;
+  BIO_get_mem_ptr(bio, &mem);
+
+  // Create a string from the DER data and use ToNativeArrayBuffer utility
+  std::string derData(mem->data, mem->length);
+  BIO_free(bio);
+
+  return ToNativeArrayBuffer(derData);
+}
+
+KeyObject HybridRsaKeyPair::importKey(const std::string& /* format */, const std::shared_ptr<ArrayBuffer>& /* keyData */,
+                                      const std::string& /* algorithm */, bool /* extractable */,
+                                      const std::vector<std::string>& /* keyUsages */) {
+  throw std::runtime_error("HybridRsaKeyPair::importKey() is not yet implemented");
+}
+
+std::shared_ptr<ArrayBuffer> HybridRsaKeyPair::exportKey(const KeyObject& /* key */, const std::string& /* format */) {
+  throw std::runtime_error("HybridRsaKeyPair::exportKey() is not yet implemented");
+}
+
+void HybridRsaKeyPair::checkKeyPair() {
+  if (this->pkey == nullptr) {
+    throw std::runtime_error("RSA KeyPair not initialized");
+  }
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/rsa/HybridRsaKeyPair.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "HybridRsaKeyPairSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+class HybridRsaKeyPair : public HybridRsaKeyPairSpec {
+ public:
+  HybridRsaKeyPair() : HybridObject(TAG), pkey(nullptr), modulusLength(2048), hashAlgorithm("SHA-256") {}
+  ~HybridRsaKeyPair() {
+    if (pkey) {
+      EVP_PKEY_free(pkey);
+    }
+  }
+
+  std::shared_ptr<Promise<void>> generateKeyPair() override;
+  void generateKeyPairSync() override;
+  void setModulusLength(double modulusLength) override;
+  void setPublicExponent(const std::shared_ptr<ArrayBuffer>& publicExponent) override;
+  void setHashAlgorithm(const std::string& hashAlgorithm) override;
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+  KeyObject importKey(const std::string& format, const std::shared_ptr<ArrayBuffer>& keyData, const std::string& algorithm,
+                      bool extractable, const std::vector<std::string>& keyUsages) override;
+  std::shared_ptr<ArrayBuffer> exportKey(const KeyObject& key, const std::string& format) override;
+
+ private:
+  EVP_PKEY* pkey;
+  int modulusLength;
+  std::vector<unsigned char> publicExponent;
+  std::string hashAlgorithm;
+
+  void checkKeyPair();
+};
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/scrypt/HybridScrypt.cpp

@@ -0,0 +1,62 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <string>
+#include <vector>
+
+#include "HybridScrypt.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridScrypt::deriveKey(const std::shared_ptr<ArrayBuffer>& password,
+                                                                               const std::shared_ptr<ArrayBuffer>& salt, double N, double r,
+                                                                               double p, double maxmem, double keylen) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativePassword = ToNativeArrayBuffer(password);
+  auto nativeSalt = ToNativeArrayBuffer(salt);
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, nativePassword, nativeSalt, N, r, p, maxmem, keylen]() {
+    return this->deriveKeySync(nativePassword, nativeSalt, N, r, p, maxmem, keylen);
+  });
+}
+
+std::shared_ptr<ArrayBuffer> HybridScrypt::deriveKeySync(const std::shared_ptr<ArrayBuffer>& password,
+                                                         const std::shared_ptr<ArrayBuffer>& salt, double N, double r, double p,
+                                                         double maxmem, double keylen) {
+  // Use EVP_PBE_scrypt to match Node.js implementation exactly
+  // All parameters are uint64_t for this API (unlike EVP_KDF which uses uint32_t for r/p)
+  uint64_t n_val = static_cast<uint64_t>(N);
+  uint64_t r_val = static_cast<uint64_t>(r);
+  uint64_t p_val = static_cast<uint64_t>(p);
+  uint64_t maxmem_val = static_cast<uint64_t>(maxmem);
+  size_t outLen = static_cast<size_t>(keylen);
+
+  if (outLen == 0) {
+    throw std::runtime_error("SCRYPT length cannot be zero");
+  }
+
+  // Prepare password and salt pointers
+  const char* pass_data = password && password->size() > 0 ? reinterpret_cast<const char*>(password->data()) : "";
+  size_t pass_len = password ? password->size() : 0;
+
+  const unsigned char* salt_data =
+      salt && salt->size() > 0 ? reinterpret_cast<const unsigned char*>(salt->data()) : reinterpret_cast<const unsigned char*>("");
+  size_t salt_len = salt ? salt->size() : 0;
+
+  // Allocate output buffer
+  uint8_t* outBuf = new uint8_t[outLen];
+
+  // Use EVP_PBE_scrypt - the same API Node.js uses
+  int result = EVP_PBE_scrypt(pass_data, pass_len, salt_data, salt_len, n_val, r_val, p_val, maxmem_val, outBuf, outLen);
+
+  if (result != 1) {
+    delete[] outBuf;
+    throw std::runtime_error("SCRYPT derivation failed: " + getOpenSSLError());
+  }
+
+  return std::make_shared<NativeArrayBuffer>(outBuf, outLen, [=]() { delete[] outBuf; });
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/cpp/scrypt/HybridScrypt.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <string>
+
+#include "HybridScryptSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridScrypt : public HybridScryptSpec {
+ public:
+  HybridScrypt() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<ArrayBuffer> deriveKeySync(const std::shared_ptr<ArrayBuffer>& password, const std::shared_ptr<ArrayBuffer>& salt,
+                                             double N, double r, double p, double maxmem, double keylen) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> deriveKey(const std::shared_ptr<ArrayBuffer>& password,
+                                                                   const std::shared_ptr<ArrayBuffer>& salt, double N, double r, double p,
+                                                                   double maxmem, double keylen) override;
+};
+
+} // namespace margelo::nitro::crypto