react-native-quick-crypto 1.0.0-beta.3 → 1.0.0-beta.5

package/QuickCrypto.podspec

@@ -22,6 +22,10 @@ Pod::Spec.new do |s|
     "ios/**/*.{h,m,mm}",
     # implementation (C++)
     "cpp/**/*.{hpp,cpp}",
+    # dependencies (C++)
+    "deps/**/*.{hpp,cpp}",
+    # dependencies (C)
+    "deps/**/*.{h,c}",
   ]
 
   # Add all files generated by Nitrogen

package/README.md

@@ -8,6 +8,8 @@ A fast implementation of Node's `crypto` module.
 
 > Note: This version `1.x` is undergoing a major refactor, porting to New Architecture, Bridgeless, and [`Nitro Modules`](https://github.com/mrousavy/react-native-nitro) and is incomplete compared to the `0.x` version.  Status, as always, will be represented in [implementation-coverage.md](../main/docs/implementation-coverage.md).
 
+> Note: Minimum supported version of React Native is `0.75`.  If you need to use earlier versions, please use `0.x` versions of this library.
+
 ## Features
 
 Unlike any other current JS-based polyfills, react-native-quick-crypto is written in C/C++ JSI and provides much greater performance - especially on mobile devices.

package/android/CMakeLists.txt

@@ -1,8 +1,7 @@
+project(QuickCrypto)
 cmake_minimum_required(VERSION 3.9.0)
 
-project(QuickCrypto)
 set(PACKAGE_NAME QuickCrypto)
-
 set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 20)
 
@@ -10,12 +9,23 @@ set(CMAKE_CXX_STANDARD 20)
 add_library(
   ${PACKAGE_NAME} SHARED
   src/main/cpp/cpp-adapter.cpp
+  ../cpp/pbkdf2/HybridPbkdf2.cpp
   ../cpp/random/HybridRandom.cpp
+  ../deps/fastpbkdf2/fastpbkdf2.c
 )
 
-include_directories(../cpp)
+# add Nitrogen specs
 include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinking.cmake)
 
+# local includes
+include_directories(
+  "src/main/cpp"
+  "../cpp/pbkdf2"
+  "../cpp/random"
+  "../cpp/utils"
+  "../deps/fastpbkdf2"
+)
+
 # Third party libraries (Prefabs)
 find_library(LOG_LIB log)
 
@@ -31,14 +41,17 @@ target_link_libraries(
   fbjni::fbjni                           # <-- Facebook C++ JNI helpers
   openssl::crypto                        # <-- OpenSSL (Crypto)
   ReactAndroid::jsi
-  ReactAndroid::turbomodulejsijni
-  ReactAndroid::react_nativemodule_core
-  ReactAndroid::react_render_core
-  ReactAndroid::runtimeexecutor
-  ReactAndroid::fabricjni
-  ReactAndroid::react_debug
-  ReactAndroid::react_render_core
-  ReactAndroid::react_render_componentregistry
-  ReactAndroid::rrc_view
-  ReactAndroid::folly_runtime
   )
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::reactnative             # <-- RN: Native Modules umbrella prefab
+  )
+else()
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::turbomodulejsijni
+    ReactAndroid::react_nativemodule_core  # <-- RN: React Native native module core
+  )
+endif()

package/android/build.gradle

@@ -104,7 +104,11 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
+  // Add a dependency on NitroModules
   implementation project(":react-native-nitro-modules")
+
+  // Add a dependency on OpenSSL
+  // TODO: update to v3 (see #351)
   implementation "com.android.ndk.thirdparty:openssl:1.1.1q-beta-1"
 }
 

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,15 +1,8 @@
+#include <fbjni/fbjni.h>
 #include <jni.h>
 
-#include "random/HybridRandom.hpp"
-#include <NitroModules/HybridObjectRegistry.hpp>
-
-using namespace margelo::nitro::crypto;
-using namespace margelo::crypto;
+#include "QuickCryptoOnLoad.hpp"
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "Random", []() -> std::shared_ptr<HybridObject> { return std::make_shared<HybridRandom>();
-  });
-
-  return JNI_VERSION_1_2;
+  return facebook::jni::initialize(vm, [=] { margelo::nitro::crypto::initialize(vm); });
 }

package/android/src/main/java/com/margelo/nitro/quickcrypto/QuickCryptoPackage.java

@@ -1,27 +1,21 @@
 package com.margelo.nitro.quickcrypto;
 
 import android.util.Log;
+
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.TurboReactPackage;
+import com.margelo.nitro.core.HybridObject;
+import com.margelo.nitro.core.HybridObjectRegistry;
 
 import java.util.HashMap;
+import java.util.function.Supplier;
 
 public class QuickCryptoPackage extends TurboReactPackage {
   private static final String TAG = "QuickCrypto";
-  static {
-    try {
-      Log.i(TAG, "Loading C++ library...");
-      System.loadLibrary(TAG);
-      Log.i(TAG, "Successfully loaded C++ library!");
-    } catch (Throwable e) {
-      Log.e(TAG, "Failed to load C++ library! Is it properly installed and linked?", e);
-      throw e;
-    }
-  }
 
   @Nullable
   @Override
@@ -35,4 +29,15 @@ public class QuickCryptoPackage extends TurboReactPackage {
       return new HashMap<>();
     };
   }
+
+  static {
+    try {
+      Log.i(TAG, "Loading C++ library...");
+      System.loadLibrary(TAG);
+      Log.i(TAG, "Successfully loaded C++ library!");
+    } catch (Throwable e) {
+      Log.e(TAG, "Failed to load C++ library! Is it properly installed and linked?", e);
+      throw e;
+    }
+  }
 }

package/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -0,0 +1,71 @@
+#include "HybridPbkdf2.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::future<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 std::async(std::launch::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,35 @@
+#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
+  virtual std::future<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;
+
+  virtual 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,58 @@
-#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;
 
-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);
+}
+
+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);
+}
+
+
+namespace margelo::nitro::crypto {
+
+std::future<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 std::async(std::launch::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 std::make_shared<NativeArrayBuffer>(data, size, false);
+  return buffer;
 };
 
-} // namespace margelo::crypto
+} // namespace margelo::nitro::crypto

package/cpp/random/HybridRandom.hpp

@@ -1,44 +1,29 @@
-#include <NitroModules/ArrayBuffer.hpp>
 #include <cmath>
 #include <future>
+#include <iostream>
 
 #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:
+  HybridRandom() : HybridObject(TAG) {}
+
+public:
+  // Methods
   std::future<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,9 +1,20 @@
 #include <limits>
 
+#include <NitroModules/ArrayBuffer.hpp>
+
+// 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());
 }
 
 inline bool CheckIsInt32(double value) {
   return (value >= std::numeric_limits<int32_t>::lowest() && value <= std::numeric_limits<int32_t>::max());
-}
+}