react-native-quick-crypto 1.0.0-beta.9 → 1.0.1

package/cpp/mldsa/HybridMlDsaKeyPair.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <memory>
+#include <openssl/evp.h>
+#include <string>
+
+#include "HybridMlDsaKeyPairSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridMlDsaKeyPair : public HybridMlDsaKeyPairSpec {
+ public:
+  HybridMlDsaKeyPair() : HybridObject(TAG) {}
+  ~HybridMlDsaKeyPair();
+
+  std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType) override;
+
+  void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType) override;
+
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> sign(const std::shared_ptr<ArrayBuffer>& message) override;
+
+  std::shared_ptr<ArrayBuffer> signSync(const std::shared_ptr<ArrayBuffer>& message) override;
+
+  std::shared_ptr<Promise<bool>> verify(const std::shared_ptr<ArrayBuffer>& signature,
+                                        const std::shared_ptr<ArrayBuffer>& message) override;
+
+  bool verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) override;
+
+  void setVariant(const std::string& variant) override;
+
+ private:
+  std::string variant_;
+  EVP_PKEY* pkey_ = nullptr;
+
+  int publicFormat_ = -1;
+  int publicType_ = -1;
+  int privateFormat_ = -1;
+  int privateType_ = -1;
+
+  void checkKeyPair();
+  int getEvpPkeyType() const;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -3,70 +3,49 @@
 
 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
-) {
+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);
-    }
-  );
+  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; });
+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);
+  // 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;
+  return result;
 }
 
 } // namespace margelo::nitro::crypto

package/cpp/pbkdf2/HybridPbkdf2.hpp

@@ -13,23 +13,12 @@ class HybridPbkdf2 : public HybridPbkdf2Spec {
 
  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<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;
+  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

@@ -4,6 +4,7 @@
 #include "HybridRandom.hpp"
 #include "Utils.hpp"
 
+namespace margelo::nitro::crypto {
 
 size_t checkSize(double size) {
   if (!CheckIsUint32(size)) {
@@ -25,33 +26,21 @@ size_t checkOffset(double size, double offset) {
   return static_cast<size_t>(offset);
 }
 
-
-namespace margelo::nitro::crypto {
-
-std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
-HybridRandom::randomFill(const std::shared_ptr<ArrayBuffer>& buffer,
-                         double dOffset,
-                         double dSize) {
+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);
-    }
-  );
+      [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) {
+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 buffer;
 };

package/cpp/random/HybridRandom.hpp

@@ -1,7 +1,7 @@
 #include <cmath>
 #include <future>
-#include <memory>
 #include <iostream>
+#include <memory>
 
 #include "HybridRandomSpec.hpp"
 
@@ -15,17 +15,16 @@ class HybridRandom : public HybridRandomSpec {
 
  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<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;
+  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("%u ", data[i]);
   }
   printf("\n");
 }

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