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

package/cpp/hash/HybridHash.cpp

@@ -0,0 +1,151 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHash.hpp"
+
+namespace margelo::nitro::crypto {
+
+HybridHash::~HybridHash() {
+  if (ctx) {
+    EVP_MD_CTX_free(ctx);
+    ctx = nullptr;
+  }
+}
+
+void HybridHash::createHash(const std::string& hashAlgorithmArg, const std::optional<double> outputLengthArg) {
+  algorithm = hashAlgorithmArg;
+  outputLength = outputLengthArg;
+
+  // Create hash context
+  ctx = EVP_MD_CTX_new();
+  if (!ctx) {
+    throw std::runtime_error("Failed to create hash context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Get the message digest by name
+  md = EVP_get_digestbyname(algorithm.c_str());
+  if (!md) {
+    EVP_MD_CTX_free(ctx);
+    ctx = nullptr;
+    throw std::runtime_error("Unknown hash algorithm: " + algorithm);
+  }
+
+  // Initialize the digest
+  if (EVP_DigestInit_ex(ctx, md, nullptr) != 1) {
+    EVP_MD_CTX_free(ctx);
+    ctx = nullptr;
+    throw std::runtime_error("Failed to initialize hash digest: " + std::to_string(ERR_get_error()));
+  }
+}
+
+void HybridHash::update(const std::shared_ptr<ArrayBuffer>& data) {
+  if (!ctx) {
+    throw std::runtime_error("Hash context not initialized");
+  }
+
+  // Update the digest with the data
+  if (EVP_DigestUpdate(ctx, reinterpret_cast<const uint8_t*>(data->data()), data->size()) != 1) {
+    throw std::runtime_error("Failed to update hash digest: " + std::to_string(ERR_get_error()));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> HybridHash::digest(const std::optional<std::string>& encoding) {
+  if (!ctx) {
+    throw std::runtime_error("Hash context not initialized");
+  }
+
+  setParams();
+
+  // Get the default digest size
+  const size_t defaultLen = EVP_MD_CTX_size(ctx);
+  const size_t digestSize = (outputLength.has_value()) ? static_cast<int>(*outputLength) : defaultLen;
+
+  if (digestSize < 0) {
+    throw std::runtime_error("Invalid digest size: " + std::to_string(digestSize));
+  }
+
+  // Create a buffer for the hash output
+  uint8_t* hashBuffer = new uint8_t[digestSize];
+  size_t hashLength = digestSize;
+
+  // Finalize the digest
+  int ret;
+  if (digestSize == defaultLen) {
+    ret = EVP_DigestFinal_ex(ctx, hashBuffer, reinterpret_cast<unsigned int*>(&hashLength));
+  } else {
+    ret = EVP_DigestFinalXOF(ctx, hashBuffer, hashLength);
+  }
+
+  if (ret != 1) {
+    delete[] hashBuffer;
+    throw std::runtime_error("Failed to finalize hash digest: " + std::to_string(ERR_get_error()));
+  }
+
+  return std::make_shared<NativeArrayBuffer>(hashBuffer, hashLength, [=]() { delete[] hashBuffer; });
+}
+
+std::shared_ptr<margelo::nitro::crypto::HybridHashSpec> HybridHash::copy(const std::optional<double> outputLengthArg) {
+  if (!ctx) {
+    throw std::runtime_error("Hash context not initialized");
+  }
+
+  // Create a new context
+  EVP_MD_CTX* newCtx = EVP_MD_CTX_new();
+  if (!newCtx) {
+    throw std::runtime_error("Failed to create new hash context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Copy the existing context to the new one
+  if (EVP_MD_CTX_copy(newCtx, ctx) != 1) {
+    EVP_MD_CTX_free(newCtx);
+    throw std::runtime_error("Failed to copy hash context: " + std::to_string(ERR_get_error()));
+  }
+
+  return std::make_shared<HybridHash>(newCtx, md, algorithm, outputLengthArg);
+}
+
+std::vector<std::string> HybridHash::getSupportedHashAlgorithms() {
+  std::vector<std::string> hashAlgorithms;
+
+  EVP_MD_do_all_provided(
+      nullptr,
+      [](EVP_MD* md, void* arg) {
+        auto* algorithms = static_cast<std::vector<std::string>*>(arg);
+        const char* name = EVP_MD_get0_name(md);
+        if (name) {
+          algorithms->push_back(name);
+        }
+      },
+      &hashAlgorithms);
+
+  return hashAlgorithms;
+}
+
+void HybridHash::setParams() {
+  // Handle algorithm parameters (like XOF length for SHAKE)
+  if (outputLength.has_value()) {
+    uint32_t xoflen = outputLength.value();
+
+    // Add a reasonable maximum output length
+    const int MAX_OUTPUT_LENGTH = 16 * 1024 * 1024; // 16MB
+    if (xoflen > MAX_OUTPUT_LENGTH) {
+      throw std::runtime_error("Output length " + std::to_string(xoflen) + " exceeds maximum allowed size of " +
+                               std::to_string(MAX_OUTPUT_LENGTH));
+    }
+
+    OSSL_PARAM params[] = {OSSL_PARAM_construct_uint("xoflen", &xoflen), OSSL_PARAM_END};
+
+    if (EVP_MD_CTX_set_params(ctx, params) != 1) {
+      EVP_MD_CTX_free(ctx);
+      ctx = nullptr;
+      throw std::runtime_error("Failed to set XOF length (outputLength) parameter: " + std::to_string(ERR_get_error()));
+    }
+  }
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/hash/HybridHash.hpp

@@ -0,0 +1,41 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHashSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridHash : public HybridHashSpec {
+ public:
+  HybridHash() : HybridObject(TAG) {}
+  HybridHash(EVP_MD_CTX* ctx, const EVP_MD* md, const std::string& algorithm, const std::optional<double> outputLength)
+      : HybridObject(TAG), ctx(ctx), md(md), algorithm(algorithm), outputLength(outputLength) {}
+  ~HybridHash();
+
+ public:
+  // Methods
+  void createHash(const std::string& algorithm, const std::optional<double> outputLength) override;
+  void update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> digest(const std::optional<std::string>& encoding = std::nullopt) override;
+  std::shared_ptr<margelo::nitro::crypto::HybridHashSpec> copy(const std::optional<double> outputLength) override;
+  std::vector<std::string> getSupportedHashAlgorithms() override;
+
+ private:
+  // Methods
+  void setParams();
+
+ private:
+  // Properties
+  EVP_MD_CTX* ctx = nullptr;
+  const EVP_MD* md = nullptr;
+  std::string algorithm = "";
+  std::optional<double> outputLength = std::nullopt;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/hmac/HybridHmac.cpp

@@ -0,0 +1,95 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHmac.hpp"
+
+namespace margelo::nitro::crypto {
+
+HybridHmac::~HybridHmac() {
+  if (ctx) {
+    EVP_MAC_CTX_free(ctx);
+    ctx = nullptr;
+  }
+}
+
+void HybridHmac::createHmac(const std::string& hmacAlgorithm, const std::shared_ptr<ArrayBuffer>& secretKey) {
+  algorithm = hmacAlgorithm;
+
+  // Create and use EVP_MAC locally
+  EVP_MAC* mac = EVP_MAC_fetch(nullptr, "HMAC", nullptr);
+  if (!mac) {
+    throw std::runtime_error("Failed to fetch HMAC implementation: " + std::to_string(ERR_get_error()));
+  }
+
+  // Create HMAC context
+  ctx = EVP_MAC_CTX_new(mac);
+  EVP_MAC_free(mac); // Free immediately after creating the context
+  if (!ctx) {
+    throw std::runtime_error("Failed to create HMAC context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Validate algorithm
+  const EVP_MD* md = EVP_get_digestbyname(algorithm.c_str());
+  if (!md) {
+    throw std::runtime_error("Unknown HMAC algorithm: " + algorithm);
+  }
+
+  // Set up parameters for HMAC
+  OSSL_PARAM params[2];
+  params[0] = OSSL_PARAM_construct_utf8_string("digest", const_cast<char*>(algorithm.c_str()), 0);
+  params[1] = OSSL_PARAM_construct_end();
+
+  const uint8_t* keyData = reinterpret_cast<const uint8_t*>(secretKey->data());
+  size_t keySize = secretKey->size();
+
+  // Handle empty key case by providing a dummy key
+  static const uint8_t dummyKey = 0;
+  if (keySize == 0) {
+    keyData = &dummyKey;
+    keySize = 1;
+  }
+
+  // Initialize HMAC
+  if (EVP_MAC_init(ctx, keyData, keySize, params) != 1) {
+    throw std::runtime_error("Failed to initialize HMAC: " + std::to_string(ERR_get_error()));
+  }
+}
+
+void HybridHmac::update(const std::shared_ptr<ArrayBuffer>& data) {
+  if (!ctx) {
+    throw std::runtime_error("HMAC context not initialized");
+  }
+
+  // Update HMAC with new data
+  if (EVP_MAC_update(ctx, reinterpret_cast<const uint8_t*>(data->data()), data->size()) != 1) {
+    throw std::runtime_error("Failed to update HMAC: " + std::to_string(ERR_get_error()));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> HybridHmac::digest() {
+  if (!ctx) {
+    throw std::runtime_error("HMAC context not initialized");
+  }
+
+  // Determine the maximum possible size of the HMAC output
+  const EVP_MD* md = EVP_get_digestbyname(algorithm.c_str());
+  const size_t hmacLength = EVP_MD_get_size(md);
+
+  // Allocate buffer with the exact required size
+  uint8_t* hmacBuffer = new uint8_t[hmacLength];
+
+  // Finalize the HMAC computation directly into the final buffer
+  if (EVP_MAC_final(ctx, hmacBuffer, nullptr, hmacLength) != 1) {
+    delete[] hmacBuffer;
+    throw std::runtime_error("Failed to finalize HMAC digest: " + std::to_string(ERR_get_error()));
+  }
+
+  return std::make_shared<NativeArrayBuffer>(hmacBuffer, hmacLength, [=]() { delete[] hmacBuffer; });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/hmac/HybridHmac.hpp

@@ -0,0 +1,31 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHmacSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridHmac : public HybridHmacSpec {
+ public:
+  HybridHmac() : HybridObject(TAG) {}
+  ~HybridHmac();
+
+ public:
+  // Methods
+  void createHmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key) override;
+  void update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> digest() override;
+
+ private:
+  // Properties
+  EVP_MAC_CTX* ctx = nullptr;
+  std::string algorithm = "";
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -0,0 +1,51 @@
+#include "HybridPbkdf2.hpp"
+#include "Utils.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/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/cpp/random/HybridRandom.cpp

@@ -1,34 +1,48 @@
-#include "HybridRandom.hpp"
-
 #include <openssl/err.h>
 #include <openssl/rand.h>
 
-namespace margelo::crypto {
+#include "HybridRandom.hpp"
+#include "Utils.hpp"
 
-using namespace margelo::nitro;
-using namespace margelo::nitro::crypto;
+namespace margelo::nitro::crypto {
 
-std::future<std::shared_ptr<ArrayBuffer>> HybridRandom::randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset,
-                                                                   double dSize) {
-  size_t size = checkSize(dSize);
-  // copy the JSArrayBuffer that we do not own into a NativeArrayBuffer that we do own, before passing to sync function
-  uint8_t* data = new uint8_t[size];
-  memcpy(data, buffer.get()->data(), size);
-  std::shared_ptr<ArrayBuffer> nativeBuffer = std::make_shared<NativeArrayBuffer>(data, size, false);
+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);
+}
 
-  return std::async(std::launch::async,
-                    [this, nativeBuffer, dOffset, dSize]() { return this->randomFillSync(nativeBuffer, dOffset, dSize); });
+size_t checkOffset(double size, double offset) {
+  if (!CheckIsUint32(offset)) {
+    throw std::runtime_error("offset must be uint32");
+  }
+  if (offset > size) {
+    throw std::runtime_error("offset must be less than size");
+  }
+  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(dSize, dOffset);
   uint8_t* data = buffer.get()->data();
-
   if (RAND_bytes(data + offset, (int)size) != 1) {
-    throw std::runtime_error("error calling RAND_bytes" + std::to_string(ERR_get_error()));
+    throw std::runtime_error("error calling RAND_bytes: " + std::to_string(ERR_get_error()));
   }
-  return std::make_shared<NativeArrayBuffer>(data, size, false);
+  return buffer;
 };
 
-} // namespace margelo::crypto
+} // namespace margelo::nitro::crypto

package/cpp/random/HybridRandom.hpp

@@ -1,44 +1,32 @@
-#include <NitroModules/ArrayBuffer.hpp>
 #include <cmath>
 #include <future>
+#include <iostream>
+#include <memory>
 
 #include "HybridRandomSpec.hpp"
 
-#ifdef ANDROID
-#include "utils/Utils.hpp"
-#else
-#include "Utils.hpp"
-#endif
+namespace margelo::nitro::crypto {
 
-namespace margelo::crypto {
-
-using namespace margelo::nitro;
-using namespace margelo::nitro::crypto;
+using namespace facebook;
 
 class HybridRandom : public HybridRandomSpec {
-public:
-  std::future<std::shared_ptr<ArrayBuffer>> randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+ 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 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);
-}
-
-inline size_t checkOffset(double size, double offset) {
-  if (!CheckIsUint32(offset)) {
-    throw std::runtime_error("offset must be uint32");
-  }
-  if (offset > size) {
-    throw std::runtime_error("offset must be less than size");
+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]);
   }
-  return static_cast<size_t>(offset);
+  printf("\n");
 }
 
-} // namespace margelo::crypto
+} // namespace margelo::nitro::crypto

package/cpp/utils/Utils.hpp

@@ -1,4 +1,21 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
 #include <limits>
+#include <string>
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+// copy a JSArrayBuffer that we do not own into a NativeArrayBuffer that we do own
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(const std::shared_ptr<margelo::nitro::ArrayBuffer>& buffer) {
+  size_t bufferSize = buffer.get()->size();
+  uint8_t* data = new uint8_t[bufferSize];
+  memcpy(data, buffer.get()->data(), bufferSize);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, bufferSize, [=]() { delete[] data; });
+}
 
 inline bool CheckIsUint32(double value) {
   return (value >= std::numeric_limits<uint32_t>::lowest() && value <= std::numeric_limits<uint32_t>::max());
@@ -6,4 +23,12 @@ inline bool CheckIsUint32(double value) {
 
 inline bool CheckIsInt32(double value) {
   return (value >= std::numeric_limits<int32_t>::lowest() && value <= std::numeric_limits<int32_t>::max());
-}
+}
+
+// Function to convert a string to lowercase
+inline std::string toLower(std::string s) {
+  std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+  return s;
+}
+
+} // namespace margelo::nitro::crypto