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

package/README.md

@@ -0,0 +1,170 @@
+<a href="https://margelo.io">
+  <img src="./docs/img/banner.svg" width="100%" />
+</a>
+
+# ⚡️ react-native-quick-crypto
+
+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](../blob/main/docs/implementation-coverage.md).
+
+## 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.
+QuickCrypto can be used as a drop-in replacement for your Web3/Crypto apps to speed up common cryptography functions.
+
+- 🏎️ Up to 58x faster than all other solutions
+- ⚡️ Lightning fast implementation with pure C++ and JSI, instead of JS
+- 🧪 Well tested in JS and C++ (OpenSSL)
+- 💰 Made for crypto apps and Wallets
+- 🔢 Secure native compiled cryptography
+- 🔁 Easy drop-in replacement for [crypto-browserify](https://github.com/browserify/crypto-browserify) or [react-native-crypto](https://github.com/tradle/react-native-crypto)
+
+## Versions
+
+| Version | RN Architecture | Modules |
+| ------- | ------ | ------- |
+| `1.x`     | new [->](https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md)  | Nitro Modules [->](https://github.com/margelo/react-native-nitro) |
+| `0.x`     | old  | Bridge & JSI |
+
+## Benchmarks
+
+For example, creating a Wallet using ethers.js uses complex algorithms to generate a private-key/mnemonic-phrase pair:
+
+```ts
+const start = performance.now();
+const wallet = ethers.Wallet.createRandom();
+const end = performance.now();
+console.log(`Creating a Wallet took ${end - start} ms.`);
+```
+
+**Without** react-native-quick-crypto 🐢:
+
+```
+Creating a Wallet took 16862 ms
+```
+
+**With** react-native-quick-crypto ⚡️:
+
+```
+Creating a Wallet took 289 ms
+```
+
+---
+
+## Installation
+
+<h3>
+  React Native  <a href="#"><img src="./docs/img/react-native.png" height="15" /></a>
+</h3>
+
+```sh
+yarn add react-native-quick-crypto
+cd ios && pod install
+```
+
+<h3>
+  Expo  <a href="#"><img src="./docs/img/expo.png" height="12" /></a>
+</h3>
+
+```sh
+expo install react-native-quick-crypto
+expo prebuild
+```
+
+Optional: override `global.Buffer` and `global.crypto` in your application as early as possible for example in index.js.
+
+```ts
+import { install } from 'react-native-quick-crypto';
+
+install();
+```
+
+## Replace `crypto-browserify`
+
+If you are using a library that depends on `crypto`, instead of polyfilling it with `crypto-browserify` (or `react-native-crypto`) you can use `react-native-quick-crypto` for a fully native implementation. This way you can get much faster crypto operations with just a single-line change!
+
+### Using metro config
+
+Use the [`resolveRequest`](https://facebook.github.io/metro/docs/resolution#resolverequest-customresolver) configuration option in your `metro.config.js`
+
+```js
+config.resolver.resolveRequest = (context, moduleName, platform) => {
+  if (moduleName === 'crypto') {
+    // when importing crypto, resolve to react-native-quick-crypto
+    return context.resolveRequest(
+      context,
+      'react-native-quick-crypto',
+      platform,
+    )
+  }
+  // otherwise chain to the standard Metro resolver.
+  return context.resolveRequest(context, moduleName, platform)
+}
+```
+
+### Using babel-plugin-module-resolver
+
+You need to install `babel-plugin-module-resolver`, it's a babel plugin that will alias any imports in the code with the values you pass to it. It tricks any module that will try to import certain dependencies with the native versions we require for React Native.
+
+```sh
+yarn add --dev babel-plugin-module-resolver
+```
+
+Then, in your `babel.config.js`, add the plugin to swap the `crypto`, `stream` and `buffer` dependencies:
+
+```diff
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+  plugins: [
++   [
++     'module-resolver',
++     {
++       alias: {
++         'crypto': 'react-native-quick-crypto',
++         'stream': 'readable-stream',
++         'buffer': '@craftzdog/react-native-buffer',
++       },
++     },
++   ],
+    ...
+  ],
+};
+```
+
+Then restart your bundler using `yarn start --reset-cache`.
+
+## Usage
+
+For example, to hash a string with SHA256 you can do the following:
+
+```ts
+import QuickCrypto from 'react-native-quick-crypto';
+
+const hashed = QuickCrypto.createHash('sha256')
+  .update('Damn, Margelo writes hella good software!')
+  .digest('hex');
+```
+
+## Limitations
+
+As the library uses JSI for synchronous native methods access, remote debugging (e.g. with Chrome) is no longer possible. Instead, you should use [Flipper](https://fbflipper.com).
+
+Not all cryptographic algorithms are supported yet. See the [implementation coverage](./docs/implementation-coverage.md) document for more details. If you need a specific algorithm, please open a `feature request` issue and we'll see what we can do.
+
+## Community Discord
+
+[Join the Margelo Community Discord](https://discord.gg/6CSHz2qAvA) to chat about react-native-quick-crypto or other Margelo libraries.
+
+## Adopting at scale
+
+react-native-quick-crypto was built at Margelo, an elite app development agency. For enterprise support or other business inquiries, contact us at <a href="mailto:hello@margelo.io?subject=Adopting react-native-quick-crypto at scale">hello@margelo.io</a>!
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+- react-native-quick-crypto is licensed under MIT.
+- react-native-quick-crypto is heavily inspired by NodeJS Crypto, which is licensed under [nodejs/LICENSE](https://github.com/nodejs/node/blob/main/LICENSE).

package/cpp/random/HybridRandom.cpp

@@ -0,0 +1,34 @@
+#include "HybridRandom.hpp"
+
+#include <openssl/err.h>
+#include <openssl/rand.h>
+
+namespace margelo::crypto {
+
+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);
+
+  return std::async(std::launch::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()));
+  }
+  return std::make_shared<NativeArrayBuffer>(data, size, false);
+};
+
+} // namespace margelo::crypto

package/cpp/random/HybridRandom.hpp

@@ -0,0 +1,44 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <cmath>
+#include <future>
+
+#include "HybridRandomSpec.hpp"
+
+#ifdef ANDROID
+#include "utils/Utils.hpp"
+#else
+#include "Utils.hpp"
+#endif
+
+namespace margelo::crypto {
+
+using namespace margelo::nitro;
+using namespace margelo::nitro::crypto;
+
+class HybridRandom : public HybridRandomSpec {
+public:
+  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");
+  }
+  return static_cast<size_t>(offset);
+}
+
+} // namespace margelo::crypto

package/cpp/utils/Utils.hpp

@@ -0,0 +1,9 @@
+#include <limits>
+
+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());
+}

package/nitrogen/generated/android/QuickCrypto+autolinking.cmake

@@ -0,0 +1,45 @@
+#
+# QuickCrypto+autolinking.cmake
+# Tue Aug 13 2024
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/react-native-nitro
+# Copyright © 2024 Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinking.cmake)
+# ```
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  QuickCrypto PRIVATE
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridRandomSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        QuickCrypto
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)

package/nitrogen/generated/android/QuickCrypto+autolinking.gradle

@@ -0,0 +1,26 @@
+///
+/// QuickCrypto+autolinking.gradle
+/// Tue Aug 13 2024
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/react-native-nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/QuickCrypto+autolinking.gradle'
+/// ```
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/ios/QuickCrypto+autolinking.rb

@@ -0,0 +1,57 @@
+#
+# QuickCrypto+autolinking.rb
+# Tue Aug 13 2024
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/react-native-nitro
+# Copyright © 2024 Marc Rousavy @ Margelo
+#
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# ```ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/QuickCrypto+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] Adding QuickCrypto specs..."
+
+  spec.dependency "NitroModules"
+
+  current_source_files = spec.attributes_hash['source_files'] || []
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,swift}",
+  ]
+
+  current_public_header_files = spec.attributes_hash['public_header_files'] || []
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = spec.attributes_hash['private_header_files'] || []
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only C)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+  })
+end

package/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,9 @@
+///
+/// QuickCrypto-Swift-Cxx-Bridge.cpp
+/// Tue Aug 13 2024
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/react-native-nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#include "QuickCrypto-Swift-Cxx-Bridge.hpp"

package/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.hpp

@@ -0,0 +1,25 @@
+///
+/// QuickCrypto-Swift-Cxx-Bridge.hpp
+/// Tue Aug 13 2024
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/react-native-nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+
+
+// Include C++ defined types
+
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::crypto::bridge::swift {
+
+  
+
+} // namespace margelo::nitro::crypto::bridge::swift

package/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,29 @@
+///
+/// QuickCrypto-Swift-Cxx-Umbrella.hpp
+/// Tue Aug 13 2024
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/react-native-nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+// Include C++ defined types
+#include <NitroModules/ArrayBuffer.hpp>
+
+// C++ helpers for Swift
+#include "QuickCrypto-Swift-Cxx-Bridge.hpp"
+
+// Forward declarations of Swift defined types
+
+
+// Include Swift defined types
+#if __has_include("QuickCrypto-Swift.h")
+#include "QuickCrypto-Swift.h"
+#else
+#error QuickCrypto's autogenerated Swift header cannot be found! Make sure the Swift module's name is actually "QuickCrypto", and try building the app first.
+#endif

package/nitrogen/generated/shared/c++/HybridRandomSpec.cpp

@@ -0,0 +1,23 @@
+///
+/// HybridRandomSpec.cpp
+/// Tue Aug 13 2024
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/react-native-nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#include "HybridRandomSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridRandomSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("randomFill", &HybridRandomSpec::randomFill);
+      prototype.registerHybridMethod("randomFillSync", &HybridRandomSpec::randomFillSync);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridRandomSpec.hpp

@@ -0,0 +1,62 @@
+///
+/// HybridRandomSpec.hpp
+/// Tue Aug 13 2024
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/react-native-nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Random`
+   * Inherit this class to create instances of `HybridRandomSpec` in C++.
+   * @example
+   * ```cpp
+   * class HybridRandom: public HybridRandomSpec {
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRandomSpec: public HybridObject {
+    public:
+      // Constructor
+      explicit HybridRandomSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRandomSpec() { }
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::future<std::shared_ptr<ArrayBuffer>> randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double size) = 0;
+      virtual std::shared_ptr<ArrayBuffer> randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double size) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Random";
+  };
+
+} // namespace margelo::nitro::crypto

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "type": "module",
   "main": "lib/commonjs/index",
@@ -10,17 +10,15 @@
   "source": "src/index",
   "files": [
     "src",
-    "react-native.config.js",
     "lib",
     "android/build.gradle",
     "android/gradle.properties",
     "android/CMakeLists.txt",
     "android/src",
-    "ios/**/*.h",
-    "ios/**/*.m",
-    "ios/**/*.mm",
-    "ios/**/*.cpp",
-    "ios/**/*.swift",
+    "ios",
+    "cpp",
+    "nitrogen",
+    "react-native.config.js",
     "app.plugin.js",
     "*.podspec",
     "README.md",