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

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/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 "Utils.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/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/cpp/utils/Macros.hpp

@@ -0,0 +1,68 @@
+#include <utility>
+
+// Windows 8+ does not like abort() in Release mode
+#ifdef _WIN32
+#define ABORT_NO_BACKTRACE() _exit(134)
+#else
+#define ABORT_NO_BACKTRACE() abort()
+#endif
+
+struct AssertionInfo {
+  const char* file_line; // filename:line
+  const char* message;
+  const char* function;
+};
+
+inline void Abort() {
+  //  DumpBacktrace(stderr);
+  fflush(stderr);
+  ABORT_NO_BACKTRACE();
+}
+
+inline void Assert(const AssertionInfo& info) {
+  //  std::string name = GetHumanReadableProcessName();
+
+  fprintf(stderr, "%s:%s%s Assertion `%s' failed.\n", info.file_line, info.function, *info.function ? ":" : "", info.message);
+  fflush(stderr);
+
+  Abort();
+}
+
+// Macros stolen from Node
+#define ERROR_AND_ABORT(expr)                                                                                                              \
+  do {                                                                                                                                     \
+    /* Make sure that this struct does not end up in inline code, but      */                                                              \
+    /* rather in a read-only data section when modifying this code.        */                                                              \
+    static const AssertionInfo args = {__FILE__ ":" STRINGIFY(__LINE__), #expr, PRETTY_FUNCTION_NAME};                                     \
+    Assert(args);                                                                                                                          \
+  } while (0)
+
+#ifdef __GNUC__
+#define LIKELY(expr) __builtin_expect(!!(expr), 1)
+#define UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#define PRETTY_FUNCTION_NAME __PRETTY_FUNCTION__
+#else
+#define LIKELY(expr) expr
+#define UNLIKELY(expr) expr
+#define PRETTY_FUNCTION_NAME ""
+#endif
+
+#define STRINGIFY_(x) #x
+#define STRINGIFY(x) STRINGIFY_(x)
+
+#define CHECK(expr)                                                                                                                        \
+  do {                                                                                                                                     \
+    if (UNLIKELY(!(expr))) {                                                                                                               \
+      ERROR_AND_ABORT(expr);                                                                                                               \
+    }                                                                                                                                      \
+  } while (0)
+
+#define CHECK_EQ(a, b) CHECK((a) == (b))
+#define CHECK_GE(a, b) CHECK((a) >= (b))
+#define CHECK_GT(a, b) CHECK((a) > (b))
+#define CHECK_LE(a, b) CHECK((a) <= (b))
+#define CHECK_LT(a, b) CHECK((a) < (b))
+#define CHECK_NE(a, b) CHECK((a) != (b))
+#define CHECK_NULL(val) CHECK((val) == nullptr)
+#define CHECK_NOT_NULL(val) CHECK((val) != nullptr)
+#define CHECK_IMPLIES(a, b) CHECK(!(a) || (b))

package/cpp/utils/Utils.hpp

@@ -1,4 +1,48 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
 #include <limits>
+#include <openssl/err.h>
+#include <string>
+
+#include "Macros.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+// Function to get the last OpenSSL error message and clear the error stack
+inline std::string getOpenSSLError() {
+  unsigned long errCode = ERR_get_error();
+  if (errCode == 0) {
+    return "";
+  }
+  char errStr[256];
+  ERR_error_string_n(errCode, errStr, sizeof(errStr));
+  // Clear any remaining errors from the error stack to prevent pollution
+  ERR_clear_error();
+  return std::string(errStr);
+}
+
+// Function to clear OpenSSL error stack without getting error message
+inline void clearOpenSSLErrors() {
+  ERR_clear_error();
+}
+
+// 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 std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(std::string str) {
+  size_t size = str.size();
+  uint8_t* data = new uint8_t[size];
+  memcpy(data, str.data(), size);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, size, [=]() { delete[] data; });
+}
 
 inline bool CheckIsUint32(double value) {
   return (value >= std::numeric_limits<uint32_t>::lowest() && value <= std::numeric_limits<uint32_t>::max());
@@ -6,4 +50,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

package/deps/blake3/.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.wasm32-wasip1]
+runner = "wasmtime"

package/deps/blake3/.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# CMakeLists.txt whitespace fixups
+3e14f865d30271c74fc68d417af488ea91b66d48

package/deps/blake3/.github/workflows/build_b3sum.py

@@ -0,0 +1,38 @@
+#! /usr/bin/env python3
+
+from pathlib import Path
+import platform
+import shutil
+import subprocess
+import sys
+
+ROOT = Path(__file__).parent.parent.parent
+RUST_TARGET = sys.argv[1]
+
+subprocess.run(
+    ["cargo", "build", "--target", sys.argv[1], "--release"], cwd=ROOT / "b3sum"
+)
+
+if platform.system() == "Windows":
+    original_exe_name = "b3sum.exe"
+else:
+    original_exe_name = "b3sum"
+
+if platform.system() == "Windows":
+    new_exe_name = "b3sum_windows_x64_bin.exe"
+elif platform.system() == "Darwin":
+    new_exe_name = "b3sum_macos_x64_bin"
+elif platform.system() == "Linux":
+    new_exe_name = "b3sum_linux_x64_bin"
+else:
+    raise RuntimeError("Unexpected platform: " + platform.system())
+
+# Copy the built binary so that it has the upload name we want.
+out_dir = ROOT / "b3sum/target" / RUST_TARGET / "release"
+original_exe_path = str(out_dir / original_exe_name)
+new_exe_path = str(out_dir / new_exe_name)
+print("copying", repr(original_exe_path), "to", repr(new_exe_path))
+shutil.copyfile(original_exe_path, new_exe_path)
+
+# This lets the subsequent upload step get the filepath.
+print("::set-output name=bin_path::" + new_exe_path)