react-native-quick-crypto 0.2.0 → 0.3.2

package/README.md

@@ -1,8 +1,21 @@
+<a href="https://margelo.io">
+  <img src="./img/banner.svg" width="100%" />
+</a>
+
 # ⚡️ react-native-quick-crypto
 
-A fast implementation of Node's `crypto` module written in C/C++ JSI.
+A fast implementation of Node's `crypto` module.
+
+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.
 
-QuickCrypto can be used as a drop-in replacement for your Web3/Crypto apps to speed up all cryptography functions.
+* 🏎️ Up to 300x 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
+* 🤌 Up to 5x smaller in JS-bundle size
+* 🔢 Secure native compiled cryptography
+* 🔁 Easy drop-in replacement for [crypto-browserify](https://github.com/crypto-browserify/crypto-browserify) or [react-native-crypto](https://github.com/tradle/react-native-crypto)
 
 For example, creating a Wallet using ethers.js uses complex algorithms to generate a private-key/mnemonic-phrase pair:
 
@@ -16,27 +29,31 @@ console.log(`Creating a Wallet took ${end - start}ms.`)
 **Without** react-native-crypto 🐢:
 
 ```
-Creating a Wallet took 31.3582738422ms
+Creating a Wallet took xxxms
 ```
 
 **With** react-native-crypto ⚡️:
 
 ```
-Creating a Wallet took 2.47425001859ms
+Creating a Wallet took yyyms
 ```
 
 ---
 
 ## Installation
 
-### React Native
+<h3>
+  React Native  <a href="#"><img src="./img/react-native.png" height="15" /></a>
+</h3>
 
 ```sh
 yarn add react-native-quick-crypto
 cd ios && pod install
 ```
 
-### Expo
+<h3>
+  Expo  <a href="#"><img src="./img/expo.png" height="12" /></a>
+</h3>
 
 ```sh
 expo install react-native-quick-crypto
@@ -45,18 +62,25 @@ expo prebuild
 
 ## Usage
 
-In your `metro.config.js`, add a module resolver to replace `crypto` with `react-native-quick-crypto`:
+In your `babel.config.js`, add a module resolver to replace `crypto` with `react-native-quick-crypto`:
 
 ```diff
 +const path = require('path');
 
- module.exports = {
-+  resolver: {
-+    extraNodeModules: {
-+      crypto: path.resolve(__dirname, './node_modules/react-native-quick-crypto'),
-+    },
-+  },
-   ...
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+  plugins: [
++   [
++     'module-resolver',
++     {
++       alias: {
++         'crypto': 'react-native-quick-crypto',
++       },
++     },
++   ],
+    ...
+  ],
+};
 ```
 
 Now, all imports for `crypto` will be resolved as `react-native-quick-crypto` instead.

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.reactnativebignumber">
+          package="com.margelo.quickcrypto">
 
 </manifest>

package/android/src/main/java/com/margelo/quickcrypto/QuickCryptoModule.java

@@ -0,0 +1,70 @@
+package com.margelo.quickcrypto;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.JavaScriptContextHolder;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+
+@ReactModule(name = QuickCryptoModule.NAME)
+public class QuickCryptoModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "QuickCrypto";
+
+  @DoNotStrip
+  private HybridData mHybridData;
+
+  private native HybridData initHybrid();
+
+  public QuickCryptoModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean install() {
+    try {
+      if (mHybridData != null) {
+        return false;
+      }
+      Log.i(NAME, "Loading C++ library...");
+      System.loadLibrary("reactnativequickcrypto");
+
+      JavaScriptContextHolder jsContext = getReactApplicationContext().getJavaScriptContextHolder();
+      CallInvokerHolderImpl jsCallInvokerHolder = (CallInvokerHolderImpl) getReactApplicationContext()
+                                                  .getCatalystInstance()
+                                                  .getJSCallInvokerHolder();
+
+
+      Log.i(NAME, "Installing JSI Bindings for react-native-quick-crypto...");
+      mHybridData = initHybrid();
+      nativeInstall(jsContext.get(), jsCallInvokerHolder);
+      Log.i(NAME, "Successfully installed JSI Bindings for react-native-quick-crypto!");
+
+      return true;
+    } catch (Exception exception) {
+      Log.e(NAME, "Failed to install JSI Bindings for react-native-quick-crypto!", exception);
+      return false;
+    }
+  }
+
+  public void destroy() {
+    if (mHybridData == null) {
+      return;
+    }
+    mHybridData.resetNative();
+  }
+
+  private native void nativeInstall(long jsiPtr, CallInvokerHolderImpl jsCallInvokerHolder);
+}

package/android/src/main/java/com/{reactnativequickcrypto → margelo/quickcrypto}/QuickCryptoPackage.java

@@ -1,4 +1,4 @@
-package com.reactnativequickcrypto;
+package com.margelo.quickcrypto;
 
 import androidx.annotation.NonNull;
 
@@ -10,17 +10,16 @@ import com.facebook.react.uimanager.ViewManager;
 import java.util.Collections;
 import java.util.List;
 
-
 public class QuickCryptoPackage implements ReactPackage {
-@NonNull
-@Override
-public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
-  return Collections.singletonList(new QuickCryptoModule(reactContext));
-}
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    return Collections.singletonList(new QuickCryptoModule(reactContext));
+  }
 
-@NonNull
-@Override
-public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
-  return Collections.emptyList();
-}
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
 }

package/cpp/Cipher/MGLCipherHostObject.cpp

@@ -4,8 +4,10 @@
 #include "MGLCipherHostObject.h"
 
 #ifdef ANDROID
+#include "JSIUtils/MGLJSIUtils.h"
 #include "JSIUtils/MGLTypedArray.h"
 #else
+#include "MGLJSIUtils.h"
 #include "MGLTypedArray.h"
 #endif
 
@@ -106,7 +108,7 @@ MGLCipherHostObject::MGLCipherHostObject(
 
   int key_len =
       EVP_BytesToKey(cipher, EVP_md5(), nullptr, cipher_key->data(runtime),
-                     cipher_key->size(runtime), 1, key, iv);
+                     static_cast<int>(cipher_key->size(runtime)), 1, key, iv);
 
   // TODO(osp) this looks like a macro, check if necessary
   // CHECK_NE(key_len, 0);
@@ -445,62 +447,76 @@ void MGLCipherHostObject::installMethods() {
   }));
 
   // setAuthTag
-  this->fields.push_back(HOST_LAMBDA("setAuthTag", {
-    if (count != 1 || !arguments[0].isObject() ||
-        !arguments[0].asObject(runtime).isArrayBuffer(runtime)) {
-      throw jsi::JSError(
-          runtime, "cipher.setAuthTag requires an ArrayBuffer tag argument");
-    }
+  this->fields.push_back(buildPair(
+      "setAuthTag", JSIF([=]) {
+        if (count != 1 || !arguments[0].isObject() ||
+            !arguments[0].asObject(runtime).isArrayBuffer(runtime)) {
+          jsi::detail::throwJSError(
+              runtime,
+              "cipher.setAuthTag requires an ArrayBuffer tag argument");
+          throw jsi::JSError(
+              runtime,
+              "cipher.setAuthTag requires an ArrayBuffer tag argument");
+        }
 
-    if (!ctx_ || !IsAuthenticatedMode() || isCipher_ ||
-        auth_tag_state_ != kAuthTagUnknown) {
-      return false;
-    }
+        if (!ctx_ || !IsAuthenticatedMode() || isCipher_ ||
+            auth_tag_state_ != kAuthTagUnknown) {
+          return false;
+        }
 
-    auto authTagArrayBuffer =
-        arguments[0].asObject(runtime).getArrayBuffer(runtime);
-    const unsigned char *data = authTagArrayBuffer.data(runtime);
-    auto tag_len = authTagArrayBuffer.length(runtime);
+        auto authTagArrayBuffer =
+            arguments[0].asObject(runtime).getArrayBuffer(runtime);
+        if (!CheckSizeInt32(runtime, authTagArrayBuffer)) {
+          jsi::detail::throwJSError(
+              runtime,
+              "cipher.setAuthTag requires an ArrayBuffer tag argument");
+          throw jsi::JSError(
+              runtime,
+              "cipher.setAuthTag requires an ArrayBuffer tag argument");
+        }
+        //    const unsigned char *data = authTagArrayBuffer.data(runtime);
+        unsigned int tag_len =
+            static_cast<unsigned int>(authTagArrayBuffer.length(runtime));
 
-    //    ArrayBufferOrViewContents<char> auth_tag(args[0]);
-    // TODO(osp) implement this check
-    //    if (UNLIKELY(!auth_tag.CheckSizeInt32()))
-    //      return THROW_ERR_OUT_OF_RANGE(env, "buffer is too big");
+        //    ArrayBufferOrViewContents<char> auth_tag(args[0]);
+        // TODO(osp) implement this check
+        //    if (UNLIKELY(!auth_tag.CheckSizeInt32()))
+        //      return THROW_ERR_OUT_OF_RANGE(env, "buffer is too big");
 
-    //    unsigned int tag_len = auth_tag.size();
+        //        unsigned int tag_len = auth_tag.size();
 
-    const int mode = EVP_CIPHER_CTX_mode(ctx_);
-    bool is_valid;
-    if (mode == EVP_CIPH_GCM_MODE) {
-      // Restrict GCM tag lengths according to NIST 800-38d, page 9.
-      is_valid =
-          (auth_tag_len_ == kNoAuthTagLength || auth_tag_len_ == tag_len) &&
-          IsValidGCMTagLength(tag_len);
-    } else {
-      // At this point, the tag length is already known and must match the
-      // length of the given authentication tag.
-      // TODO(osp) add CHECK here
-      IsSupportedAuthenticatedMode(ctx_);
-      //      CHECK_NE(cipher->auth_tag_len_, kNoAuthTagLength);
-      is_valid = auth_tag_len_ == tag_len;
-    }
+        const int mode = EVP_CIPHER_CTX_mode(ctx_);
+        bool is_valid;
+        if (mode == EVP_CIPH_GCM_MODE) {
+          // Restrict GCM tag lengths according to NIST 800-38d, page 9.
+          is_valid =
+              (auth_tag_len_ == kNoAuthTagLength || auth_tag_len_ == tag_len) &&
+              IsValidGCMTagLength(tag_len);
+        } else {
+          // At this point, the tag length is already known and must match the
+          // length of the given authentication tag.
+          // TODO(osp) add CHECK here
+          IsSupportedAuthenticatedMode(ctx_);
+          //      CHECK_NE(cipher->auth_tag_len_, kNoAuthTagLength);
+          is_valid = auth_tag_len_ == tag_len;
+        }
 
-    if (!is_valid) {
-      throw jsi::JSError(runtime,
-                         "Invalid authentication tag length: " + tag_len);
-      //      return THROW_ERR_CRYPTO_INVALID_AUTH_TAG(
-      //              env, "Invalid authentication tag length: %u", tag_len);
-    }
+        if (!is_valid) {
+          jsi::detail::throwJSError(
+              runtime, "Invalid authentication tag length" + tag_len);
+          throw jsi::JSError(runtime,
+                             "Invalid authentication tag length: " + tag_len);
+        }
 
-    auth_tag_len_ = tag_len;
-    auth_tag_state_ = kAuthTagKnown;
-    //    CHECK_LE(cipher->auth_tag_len_, sizeof(cipher->auth_tag_));
+        auth_tag_len_ = tag_len;
+        auth_tag_state_ = kAuthTagKnown;
+        //    CHECK_LE(cipher->auth_tag_len_, sizeof(cipher->auth_tag_));
 
-    memset(auth_tag_, 0, sizeof(auth_tag_));
-    CopyTo(runtime, &authTagArrayBuffer, auth_tag_, auth_tag_len_);
+        memset(auth_tag_, 0, sizeof(auth_tag_));
+        CopyTo(runtime, &authTagArrayBuffer, auth_tag_, auth_tag_len_);
 
-    return true;
-  }));
+        return true;
+      }));
 }
 
 bool MGLCipherHostObject::MaybePassAuthTagToOpenSSL() {