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

package/README.md

@@ -61,7 +61,7 @@ Creating a Wallet took 289 ms
 </h3>
 
 ```sh
-yarn add react-native-quick-crypto
+bun add react-native-quick-crypto react-native-nitro-modules
 cd ios && pod install
 ```
 

package/android/CMakeLists.txt

@@ -9,6 +9,7 @@ set(CMAKE_CXX_STANDARD 20)
 add_library(
   ${PACKAGE_NAME} SHARED
   src/main/cpp/cpp-adapter.cpp
+  ../cpp/ed25519/HybridEdKeyPair.cpp
   ../cpp/pbkdf2/HybridPbkdf2.cpp
   ../cpp/random/HybridRandom.cpp
   ../deps/fastpbkdf2/fastpbkdf2.c
@@ -20,6 +21,7 @@ include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinkin
 # local includes
 include_directories(
   "src/main/cpp"
+  "../cpp/ed25519"
   "../cpp/pbkdf2"
   "../cpp/random"
   "../cpp/utils"
@@ -29,8 +31,6 @@ include_directories(
 # Third party libraries (Prefabs)
 find_library(LOG_LIB log)
 
-find_package(ReactAndroid REQUIRED CONFIG)
-find_package(fbjni REQUIRED CONFIG)
 find_package(openssl REQUIRED CONFIG)
 
 # Link all libraries together
@@ -38,9 +38,7 @@ target_link_libraries(
   ${PACKAGE_NAME}
   ${LOG_LIB}                             # <-- Logcat logger
   android                                # <-- Android core
-  fbjni::fbjni                           # <-- Facebook C++ JNI helpers
   openssl::crypto                        # <-- OpenSSL (Crypto)
-  ReactAndroid::jsi
   )
 
 if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.2.2"
+    classpath "com.android.tools.build:gradle:8.7.3"
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
   }
 }
@@ -49,9 +49,18 @@ android {
 
     externalNativeBuild {
       cmake {
-        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
         arguments "-DANDROID_STL=c++_shared"
         abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
       }
     }
   }
@@ -67,6 +76,27 @@ android {
     prefab true
   }
 
+packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -108,8 +138,7 @@ dependencies {
   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"
+  implementation 'io.github.ronickg:openssl:3.3.2'
 }
 
 if (isNewArchitectureEnabled()) {

package/cpp/ed25519/HybridEdKeyPair.cpp

@@ -0,0 +1,268 @@
+#include "HybridEdKeyPair.hpp"
+
+#include <memory>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<void>>
+HybridEdKeyPair::generateKeyPair(
+  double publicFormat,
+  double publicType,
+  double privateFormat,
+  double privateType,
+  const std::optional<std::string>& cipher,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+) {
+  // get owned NativeArrayBuffers before passing to sync function
+  std::optional<std::shared_ptr<ArrayBuffer>> nativePassphrase = std::nullopt;
+  if (passphrase.has_value()) {
+    nativePassphrase = ToNativeArrayBuffer(passphrase.value());
+  }
+
+  return Promise<void>::async(
+    [this, publicFormat, publicType, privateFormat, privateType, cipher,
+     nativePassphrase]() {
+      this->generateKeyPairSync(
+        publicFormat,
+        publicType,
+        privateFormat,
+        privateType,
+        cipher,
+        nativePassphrase
+      );
+    }
+  );
+}
+
+void
+HybridEdKeyPair::generateKeyPairSync(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+) {
+  EVP_PKEY_CTX* pctx;
+
+  // key context
+  pctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pctx == nullptr) {
+    throw std::runtime_error("Invalid curve name: " + this->curve);
+  }
+
+  // keygen init
+  if (EVP_PKEY_keygen_init(pctx) <= 0) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to initialize keygen");
+  }
+
+  // generate key
+  EVP_PKEY_keygen(pctx, &this->pkey);
+  if (this->pkey == nullptr) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to generate key");
+  }
+
+  // cleanup
+  EVP_PKEY_CTX_free(pctx);
+}
+
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridEdKeyPair::sign(
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+  // get owned NativeArrayBuffer before passing to sync function
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeKey = std::nullopt;
+  if (key.has_value()) {
+    nativeKey = ToNativeArrayBuffer(key.value());
+  }
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, nativeMessage, nativeKey]() {
+      return this->signSync(nativeMessage, nativeKey);
+    }
+  );
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::signSync(
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+
+  size_t sig_len = 0;
+  uint8_t* sig = NULL;
+  EVP_MD_CTX* md_ctx = nullptr;
+  EVP_PKEY_CTX* pkey_ctx = nullptr;
+
+  // get key to use for signing
+  EVP_PKEY* pkey = this->importPrivateKey(key);
+
+  // key context
+  md_ctx = EVP_MD_CTX_new();
+  if (md_ctx == nullptr) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Error creating signing context");
+  }
+
+  pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pkey_ctx == nullptr) {
+    EVP_PKEY_CTX_free(pkey_ctx);
+    throw std::runtime_error("Error creating signing context: " + this->curve);
+  }
+
+  if (EVP_DigestSignInit(md_ctx, &pkey_ctx, NULL, NULL, pkey) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    char* err = ERR_error_string(ERR_get_error(), NULL);
+    throw std::runtime_error("Failed to initialize signing: " + std::string(err));
+  }
+
+  // Calculate the required size for the signature by passing a NULL buffer.
+  if (EVP_DigestSign(md_ctx, NULL, &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to calculate signature size");
+  }
+  sig = new uint8_t[sig_len];
+
+  // Actually calculate the signature
+  if (EVP_DigestSign(md_ctx, sig, &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to calculate signature");
+  }
+
+  // return value for JS
+  std::shared_ptr<ArrayBuffer> signature = std::make_shared<NativeArrayBuffer>(
+    sig,
+    sig_len,
+    [=]() { delete[] sig; }
+  );
+
+  // Clean up
+  EVP_MD_CTX_free(md_ctx);
+
+  return signature;
+}
+
+std::shared_ptr<Promise<bool>>
+HybridEdKeyPair::verify(
+  const std::shared_ptr<ArrayBuffer>& signature,
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativeSignature = ToNativeArrayBuffer(signature);
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeKey = std::nullopt;
+  if (key.has_value()) {
+    nativeKey = ToNativeArrayBuffer(key.value());
+  }
+
+  return Promise<bool>::async([this, nativeSignature, nativeMessage, nativeKey]() {
+      return this->verifySync(nativeSignature, nativeMessage, nativeKey);
+    }
+  );
+}
+
+bool
+HybridEdKeyPair::verifySync(
+  const std::shared_ptr<ArrayBuffer>& signature,
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+  // get key to use for verifying
+  EVP_PKEY* pkey = this->importPrivateKey(key);
+
+  EVP_MD_CTX* md_ctx = nullptr;
+  EVP_PKEY_CTX* pkey_ctx = nullptr;
+
+  // key context
+  md_ctx = EVP_MD_CTX_new();
+  if (md_ctx == nullptr) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Error creating verify context");
+  }
+
+  pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pkey_ctx == nullptr) {
+    EVP_PKEY_CTX_free(pkey_ctx);
+    throw std::runtime_error("Error creating verify context: " + this->curve);
+  }
+
+  if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, NULL, NULL, pkey) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    char* err = ERR_error_string(ERR_get_error(), NULL);
+    throw std::runtime_error("Failed to initialize verify: " + std::string(err));
+  }
+
+  // verify
+  auto res = EVP_DigestVerify(
+    md_ctx,
+    signature.get()->data(), signature.get()->size(),
+    message.get()->data(), message.get()->size()
+  );
+
+  //return value for JS
+  if (res < 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to verify");
+  }
+  return res == 1; // true if 1, false if 0
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::getPublicKey() {
+  this->checkKeyPair();
+  size_t len = 32;
+  uint8_t* publ = new uint8_t[len];
+  EVP_PKEY_get_raw_public_key(this->pkey, publ, &len);
+
+  return std::make_shared<NativeArrayBuffer>(publ, len, [=]() { delete[] publ; });
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::getPrivateKey() {
+  this->checkKeyPair();
+  size_t len = 32;
+  uint8_t* priv = new uint8_t[len];
+  EVP_PKEY_get_raw_private_key(this->pkey, priv, &len);
+
+  return std::make_shared<NativeArrayBuffer>(priv, len, [=]() { delete[] priv; });
+}
+
+void
+HybridEdKeyPair::checkKeyPair() {
+  if (this->pkey == nullptr) {
+    throw std::runtime_error("Keypair not initialized");
+  }
+}
+
+void
+HybridEdKeyPair::setCurve(const std::string& curve) {
+  this->curve = curve;
+}
+
+EVP_PKEY*
+HybridEdKeyPair::importPrivateKey(const std::optional<std::shared_ptr<ArrayBuffer>>& key) {
+  EVP_PKEY* pkey = nullptr;
+  if (key.has_value()) {
+    pkey = EVP_PKEY_new_raw_private_key(
+      EVP_PKEY_ED25519, // TODO: use this->curve somehow
+      NULL,
+      key.value()->data(),
+      32
+    );
+    if (pkey == nullptr) {
+      throw std::runtime_error("Failed to read private key");
+    }
+  } else {
+    this->checkKeyPair();
+    pkey = this->pkey;
+  }
+  return pkey;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/ed25519/HybridEdKeyPair.hpp

@@ -0,0 +1,85 @@
+#include <openssl/evp.h>
+#include <openssl/err.h>
+#include <memory>
+#include <string>
+
+#include "HybridEdKeyPairSpec.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridEdKeyPair : public HybridEdKeyPairSpec {
+ public:
+  HybridEdKeyPair() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<void>>
+  generateKeyPair(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+  ) override;
+
+  void
+  generateKeyPairSync(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+  ) override;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  sign(
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+  std::shared_ptr<ArrayBuffer>
+  signSync(
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+  std::shared_ptr<Promise<bool>>
+  verify(
+    const std::shared_ptr<ArrayBuffer>& signature,
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+  bool
+  verifySync(
+    const std::shared_ptr<ArrayBuffer>& signature,
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+ protected:
+  std::shared_ptr<ArrayBuffer>
+  getPublicKey() override;
+
+  std::shared_ptr<ArrayBuffer>
+  getPrivateKey() override;
+
+  void checkKeyPair();
+
+  void setCurve(const std::string& curve) override;
+
+ private:
+  std::string curve;
+  EVP_PKEY* pkey = nullptr;
+
+  EVP_PKEY* importPrivateKey(
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  );
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -3,7 +3,7 @@
 
 namespace margelo::nitro::crypto {
 
-std::future<std::shared_ptr<ArrayBuffer>>
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
 HybridPbkdf2::pbkdf2(
   const std::shared_ptr<ArrayBuffer>& password,
   const std::shared_ptr<ArrayBuffer>& salt,
@@ -15,10 +15,11 @@ HybridPbkdf2::pbkdf2(
   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);
-                    });
+  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>

package/cpp/pbkdf2/HybridPbkdf2.hpp

@@ -8,12 +8,12 @@ namespace margelo::nitro::crypto {
 using namespace facebook;
 
 class HybridPbkdf2 : public HybridPbkdf2Spec {
-public:
+ public:
   HybridPbkdf2() : HybridObject(TAG) {}
 
-public:
+ public:
   // Methods
-  virtual std::future<std::shared_ptr<ArrayBuffer>>
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
   pbkdf2(
     const std::shared_ptr<ArrayBuffer>& password,
     const std::shared_ptr<ArrayBuffer>& salt,
@@ -22,7 +22,7 @@ public:
     const std::string& digest
   ) override;
 
-  virtual std::shared_ptr<ArrayBuffer>
+  std::shared_ptr<ArrayBuffer>
   pbkdf2Sync(
     const std::shared_ptr<ArrayBuffer>& password,
     const std::shared_ptr<ArrayBuffer>& salt,

package/cpp/random/HybridRandom.cpp

@@ -28,17 +28,18 @@ size_t checkOffset(double size, double offset) {
 
 namespace margelo::nitro::crypto {
 
-std::future<std::shared_ptr<ArrayBuffer>>
+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 std::async(std::launch::async,
-                    [this, nativeBuffer, dOffset, dSize]() {
-                      return this->randomFillSync(nativeBuffer, dOffset, dSize);
-                    });
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+    [this, nativeBuffer, dOffset, dSize]() {
+      return this->randomFillSync(nativeBuffer, dOffset, dSize);
+    }
+  );
 };
 
 std::shared_ptr<ArrayBuffer>

package/cpp/random/HybridRandom.hpp

@@ -1,5 +1,6 @@
 #include <cmath>
 #include <future>
+#include <memory>
 #include <iostream>
 
 #include "HybridRandomSpec.hpp"
@@ -9,13 +10,16 @@ namespace margelo::nitro::crypto {
 using namespace facebook;
 
 class HybridRandom : public HybridRandomSpec {
-public:
+ public:
   HybridRandom() : HybridObject(TAG) {}
 
-public:
+ 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;
+  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 void printData(std::string name, uint8_t* data, size_t size) {

package/lib/commonjs/ed.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Ed = void 0;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+class Ed {
+  constructor(type, config) {
+    this.type = type;
+    this.config = config;
+    this.native = _reactNativeNitroModules.NitroModules.createHybridObject('EdKeyPair');
+    this.native.setCurve(type);
+  }
+  async generateKeyPair() {
+    this.native.generateKeyPair(this.config.publicFormat || -1, this.config.publicType || -1, this.config.privateFormat || -1, this.config.privateType || -1, this.config.cipher, this.config.passphrase);
+  }
+  generateKeyPairSync() {
+    this.native.generateKeyPairSync(this.config.publicFormat || -1, this.config.publicType || -1, this.config.privateFormat || -1, this.config.privateType || -1, this.config.cipher, this.config.passphrase);
+  }
+  getPublicKey() {
+    return this.native.getPublicKey();
+  }
+  getPrivateKey() {
+    return this.native.getPrivateKey();
+  }
+  async sign(message, key) {
+    return key ? this.native.sign(message, key) : this.native.sign(message);
+  }
+  signSync(message, key) {
+    return key ? this.native.signSync(message, key) : this.native.signSync(message);
+  }
+  async verify(message, signature, key) {
+    return key ? this.native.verify(message, signature, key) : this.native.verify(message, signature);
+  }
+  verifySync(message, signature, key) {
+    return key ? this.native.verifySync(message, signature, key) : this.native.verifySync(message, signature);
+  }
+}
+exports.Ed = Ed;
+//# sourceMappingURL=ed.js.map

package/lib/commonjs/ed.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","Ed","constructor","type","config","native","NitroModules","createHybridObject","setCurve","generateKeyPair","publicFormat","publicType","privateFormat","privateType","cipher","passphrase","generateKeyPairSync","getPublicKey","getPrivateKey","sign","message","key","signSync","verify","signature","verifySync","exports"],"sourceRoot":"../../src","sources":["ed.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAIO,MAAMC,EAAE,CAAC;EAKdC,WAAWA,CAACC,IAAqB,EAAEC,MAAwB,EAAE;IAC3D,IAAI,CAACD,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACC,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,MAAM,GAAGC,qCAAY,CAACC,kBAAkB,CAAY,WAAW,CAAC;IACrE,IAAI,CAACF,MAAM,CAACG,QAAQ,CAACL,IAAI,CAAC;EAC5B;EAEA,MAAMM,eAAeA,CAAA,EAAkB;IACrC,IAAI,CAACJ,MAAM,CAACI,eAAe,CACzB,IAAI,CAACL,MAAM,CAACM,YAAY,IAAK,CAAC,CAAY,EAC1C,IAAI,CAACN,MAAM,CAACO,UAAU,IAAK,CAAC,CAAY,EACxC,IAAI,CAACP,MAAM,CAACQ,aAAa,IAAK,CAAC,CAAY,EAC3C,IAAI,CAACR,MAAM,CAACS,WAAW,IAAK,CAAC,CAAY,EACzC,IAAI,CAACT,MAAM,CAACU,MAAM,EAClB,IAAI,CAACV,MAAM,CAACW,UACd,CAAC;EACH;EAEAC,mBAAmBA,CAAA,EAAS;IAC1B,IAAI,CAACX,MAAM,CAACW,mBAAmB,CAC7B,IAAI,CAACZ,MAAM,CAACM,YAAY,IAAK,CAAC,CAAY,EAC1C,IAAI,CAACN,MAAM,CAACO,UAAU,IAAK,CAAC,CAAY,EACxC,IAAI,CAACP,MAAM,CAACQ,aAAa,IAAK,CAAC,CAAY,EAC3C,IAAI,CAACR,MAAM,CAACS,WAAW,IAAK,CAAC,CAAY,EACzC,IAAI,CAACT,MAAM,CAACU,MAAM,EAClB,IAAI,CAACV,MAAM,CAACW,UACd,CAAC;EACH;EAEAE,YAAYA,CAAA,EAAgB;IAC1B,OAAO,IAAI,CAACZ,MAAM,CAACY,YAAY,CAAC,CAAC;EACnC;EAEAC,aAAaA,CAAA,EAAgB;IAC3B,OAAO,IAAI,CAACb,MAAM,CAACa,aAAa,CAAC,CAAC;EACpC;EAEA,MAAMC,IAAIA,CAACC,OAAoB,EAAEC,GAAiB,EAAwB;IACxE,OAAOA,GAAG,GAAG,IAAI,CAAChB,MAAM,CAACc,IAAI,CAACC,OAAO,EAAEC,GAAG,CAAC,GAAG,IAAI,CAAChB,MAAM,CAACc,IAAI,CAACC,OAAO,CAAC;EACzE;EAEAE,QAAQA,CAACF,OAAoB,EAAEC,GAAiB,EAAe;IAC7D,OAAOA,GAAG,GACN,IAAI,CAAChB,MAAM,CAACiB,QAAQ,CAACF,OAAO,EAAEC,GAAG,CAAC,GAClC,IAAI,CAAChB,MAAM,CAACiB,QAAQ,CAACF,OAAO,CAAC;EACnC;EAEA,MAAMG,MAAMA,CACVH,OAAoB,EACpBI,SAAsB,EACtBH,GAAiB,EACC;IAClB,OAAOA,GAAG,GACN,IAAI,CAAChB,MAAM,CAACkB,MAAM,CAACH,OAAO,EAAEI,SAAS,EAAEH,GAAG,CAAC,GAC3C,IAAI,CAAChB,MAAM,CAACkB,MAAM,CAACH,OAAO,EAAEI,SAAS,CAAC;EAC5C;EAEAC,UAAUA,CACRL,OAAoB,EACpBI,SAAsB,EACtBH,GAAiB,EACR;IACT,OAAOA,GAAG,GACN,IAAI,CAAChB,MAAM,CAACoB,UAAU,CAACL,OAAO,EAAEI,SAAS,EAAEH,GAAG,CAAC,GAC/C,IAAI,CAAChB,MAAM,CAACoB,UAAU,CAACL,OAAO,EAAEI,SAAS,CAAC;EAChD;AACF;AAACE,OAAA,CAAAzB,EAAA,GAAAA,EAAA","ignoreList":[]}

package/lib/commonjs/index.js

@@ -8,8 +8,43 @@ var _exportNames = {
 };
 exports.install = exports.default = void 0;
 var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var keys = _interopRequireWildcard(require("./keys"));
+var ed = _interopRequireWildcard(require("./ed"));
+Object.keys(ed).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === ed[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return ed[key];
+    }
+  });
+});
 var pbkdf2 = _interopRequireWildcard(require("./pbkdf2"));
+Object.keys(pbkdf2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === pbkdf2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return pbkdf2[key];
+    }
+  });
+});
 var random = _interopRequireWildcard(require("./random"));
+Object.keys(random).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === random[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return random[key];
+    }
+  });
+});
 var utils = _interopRequireWildcard(require("./utils"));
 Object.keys(utils).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -43,20 +78,17 @@ const QuickCrypto = {
   // createCipheriv,
   // createDecipher,
   // createDecipheriv,
-  // createPublicKey,
-  // createPrivateKey,
-  // createSecretKey,
   // publicEncrypt,
   // publicDecrypt,
   // privateDecrypt,
   // generateKey,
-  // generateKeyPair,
-  // generateKeyPairSync,
   // generateKeySync,
   // createSign,
   // createVerify,
   // subtle,
   // constants,
+  ...keys,
+  ...ed,
   ...pbkdf2,
   ...random,
   // getCiphers,