react-native-quick-crypto 0.2.0 → 0.3.0

package/cpp/Cipher/MGLCipherKeys.h

@@ -0,0 +1,124 @@
+//
+//  MGLCipherKeys.hpp
+//  react-native-fast-crypto
+//
+//  Created by Oscar on 20.06.22.
+//
+
+#ifndef MGLCipherKeys_hpp
+#define MGLCipherKeys_hpp
+
+#include <jsi/jsi.h>
+#include <openssl/evp.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLUtils.h"
+#else
+#include "MGLUtils.h"
+#endif
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+enum PKEncodingType {
+  // RSAPublicKey / RSAPrivateKey according to PKCS#1.
+  kKeyEncodingPKCS1,
+  // PrivateKeyInfo or EncryptedPrivateKeyInfo according to PKCS#8.
+  kKeyEncodingPKCS8,
+  // SubjectPublicKeyInfo according to X.509.
+  kKeyEncodingSPKI,
+  // ECPrivateKey according to SEC1.
+  kKeyEncodingSEC1
+};
+
+enum PKFormatType { kKeyFormatDER, kKeyFormatPEM, kKeyFormatJWK };
+
+enum KeyType { kKeyTypeSecret, kKeyTypePublic, kKeyTypePrivate };
+
+enum KeyEncodingContext {
+  kKeyContextInput,
+  kKeyContextExport,
+  kKeyContextGenerate
+};
+
+enum class ParseKeyResult {
+  kParseKeyOk,
+  kParseKeyNotRecognized,
+  kParseKeyNeedPassphrase,
+  kParseKeyFailed
+};
+
+struct AsymmetricKeyEncodingConfig {
+  bool output_key_object_ = false;
+  PKFormatType format_ = kKeyFormatDER;
+  std::optional<PKEncodingType> type_ = std::nullopt;
+};
+
+using PublicKeyEncodingConfig = AsymmetricKeyEncodingConfig;
+
+struct PrivateKeyEncodingConfig : public AsymmetricKeyEncodingConfig {
+  const EVP_CIPHER* cipher_;
+  // The ByteSource alone is not enough to distinguish between "no passphrase"
+  // and a zero-length passphrase (which can be a null pointer), therefore, we
+  // use a NonCopyableMaybe.
+  NonCopyableMaybe<ByteSource> passphrase_;
+};
+
+// Here node uses extends MemoryRetainer no clue what that is, something with
+// Snapshots stripped it for our implementation but if something doesn't work,
+// you know why
+class ManagedEVPPKey {
+ public:
+  ManagedEVPPKey() {}
+  explicit ManagedEVPPKey(EVPKeyPointer&& pkey);
+  ManagedEVPPKey(const ManagedEVPPKey& that);
+  ManagedEVPPKey& operator=(const ManagedEVPPKey& that);
+
+  operator bool() const;
+  EVP_PKEY* get() const;
+
+  static PublicKeyEncodingConfig GetPublicKeyEncodingFromJs(
+      jsi::Runtime& runtime, const jsi::Value* arguments, unsigned int* offset,
+      KeyEncodingContext context);
+
+  static NonCopyableMaybe<PrivateKeyEncodingConfig> GetPrivateKeyEncodingFromJs(
+      jsi::Runtime& runtime, const jsi::Value* arguments, unsigned int* offset,
+      KeyEncodingContext context);
+  //
+  static ManagedEVPPKey GetParsedKey(jsi::Runtime& runtime,
+                                     EVPKeyPointer&& pkey, ParseKeyResult ret,
+                                     const char* default_msg);
+
+  static ManagedEVPPKey GetPublicOrPrivateKeyFromJs(jsi::Runtime& runtime,
+                                                    const jsi::Value* args,
+                                                    unsigned int* offset);
+
+  //  static ManagedEVPPKey GetPrivateKeyFromJs(
+  //                                            const
+  //                                            v8::FunctionCallbackInfo<v8::Value>&
+  //                                            args, unsigned int* offset, bool
+  //                                            allow_key_object);
+
+  static std::optional<StringOrBuffer> ToEncodedPublicKey(
+      jsi::Runtime& runtime, ManagedEVPPKey key,
+      const PublicKeyEncodingConfig& config);
+
+  static std::optional<StringOrBuffer> ToEncodedPrivateKey(
+      jsi::Runtime& runtime, ManagedEVPPKey key,
+      const PrivateKeyEncodingConfig& config);
+
+ private:
+  size_t size_of_private_key() const;
+  size_t size_of_public_key() const;
+
+  EVPKeyPointer pkey_;
+};
+
+}  // namespace margelo
+
+#endif /* MGLCipherKeys_hpp */

package/cpp/Cipher/MGLCreateCipherInstaller.cpp

@@ -17,58 +17,61 @@ namespace margelo {
 FieldDefinition getCreateCipherFieldDefinition(
     std::shared_ptr<react::CallInvoker> jsCallInvoker,
     std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
-  return HOST_LAMBDA("createCipher", {
-    if (count < 1) {
-      throw jsi::JSError(runtime, "Params object is required");
-    }
-
-    if (!arguments[0].isObject()) {
-      throw jsi::JSError(runtime, "createCipher: Params needs to be an object");
-    }
-
-    auto params = arguments[0].getObject(runtime);
-
-    if (!params.hasProperty(runtime, "cipher_type")) {
-      throw jsi::JSError(runtime, "createCipher: cipher_type is required");
-    }
-
-    auto cipher_type = params.getProperty(runtime, "cipher_type")
-                           .asString(runtime)
-                           .utf8(runtime);
-
-    if (!params.hasProperty(runtime, "cipher_key")) {
-      throw jsi::JSError(runtime, "createCipher: cipher_key is required");
-    }
-
-    auto cipher_key = params.getProperty(runtime, "cipher_key")
-                          .getObject(runtime)
-                          .getArrayBuffer(runtime);
-
-    if (!params.hasProperty(runtime, "auth_tag_len")) {
-      throw jsi::JSError(runtime, "createCipher: auth_tag_len is required");
-    }
-
-    unsigned auto int auth_tag_len =
-        (int)params.getProperty(runtime, "auth_tag_len").getNumber();
-
-    if (params.hasProperty(runtime, "iv") &&
-        !params.getProperty(runtime, "iv").isNull() &&
-        !params.getProperty(runtime, "iv").isUndefined()) {  // createCipheriv
-      auto iv = params.getProperty(runtime, "iv")
-                    .getObject(runtime)
-                    .getArrayBuffer(runtime);
-      auto hostObject = std::make_shared<MGLCipherHostObject>(
-          cipher_type, &cipher_key, true, auth_tag_len, &iv, runtime,
-          jsCallInvoker, workerQueue);
-
-      return jsi::Object::createFromHostObject(runtime, hostObject);
-    } else {
-      auto hostObject = std::make_shared<MGLCipherHostObject>(
-          cipher_type, &cipher_key, true, auth_tag_len, runtime, jsCallInvoker,
-          workerQueue);
-
-      return jsi::Object::createFromHostObject(runtime, hostObject);
-    }
-  });
+  return buildPair(
+      "createCipher", JSIF([=]) {
+        if (count < 1) {
+          throw jsi::JSError(runtime, "Params object is required");
+        }
+
+        if (!arguments[0].isObject()) {
+          throw jsi::JSError(runtime,
+                             "createCipher: Params needs to be an object");
+        }
+
+        auto params = arguments[0].getObject(runtime);
+
+        if (!params.hasProperty(runtime, "cipher_type")) {
+          throw jsi::JSError(runtime, "createCipher: cipher_type is required");
+        }
+
+        auto cipher_type = params.getProperty(runtime, "cipher_type")
+                               .asString(runtime)
+                               .utf8(runtime);
+
+        if (!params.hasProperty(runtime, "cipher_key")) {
+          throw jsi::JSError(runtime, "createCipher: cipher_key is required");
+        }
+
+        auto cipher_key = params.getProperty(runtime, "cipher_key")
+                              .getObject(runtime)
+                              .getArrayBuffer(runtime);
+
+        if (!params.hasProperty(runtime, "auth_tag_len")) {
+          throw jsi::JSError(runtime, "createCipher: auth_tag_len is required");
+        }
+
+        unsigned int auth_tag_len = static_cast<int>(
+            params.getProperty(runtime, "auth_tag_len").getNumber());
+
+        if (params.hasProperty(runtime, "iv") &&
+            !params.getProperty(runtime, "iv").isNull() &&
+            !params.getProperty(runtime, "iv")
+                 .isUndefined()) {  // createCipheriv
+          auto iv = params.getProperty(runtime, "iv")
+                        .getObject(runtime)
+                        .getArrayBuffer(runtime);
+          auto hostObject = std::make_shared<MGLCipherHostObject>(
+              cipher_type, &cipher_key, true, auth_tag_len, &iv, runtime,
+              jsCallInvoker, workerQueue);
+
+          return jsi::Object::createFromHostObject(runtime, hostObject);
+        } else {
+          auto hostObject = std::make_shared<MGLCipherHostObject>(
+              cipher_type, &cipher_key, true, auth_tag_len, runtime,
+              jsCallInvoker, workerQueue);
+
+          return jsi::Object::createFromHostObject(runtime, hostObject);
+        }
+      });
 }
 }  // namespace margelo

package/cpp/Cipher/MGLCreateCipherInstaller.h

@@ -1,3 +1,6 @@
+#ifndef MGLCreateCipherInstaller_h
+#define MGLCreateCipherInstaller_h
+
 #include <jsi/jsi.h>
 
 #include <memory>
@@ -15,3 +18,5 @@ FieldDefinition getCreateCipherFieldDefinition(
     std::shared_ptr<react::CallInvoker> jsCallInvoker,
     std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
 }  // namespace margelo
+
+#endif

package/cpp/Cipher/MGLCreateDecipherInstaller.cpp

@@ -17,58 +17,61 @@ namespace margelo {
 FieldDefinition getCreateDecipherFieldDefinition(
     std::shared_ptr<react::CallInvoker> jsCallInvoker,
     std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
-  return HOST_LAMBDA("createDecipher", {
-    if (count < 1) {
-      throw jsi::JSError(runtime, "Params object is required");
-    }
-
-    if (!arguments[0].isObject()) {
-      throw jsi::JSError(runtime, "createCipher: Params needs to be an object");
-    }
-
-    auto params = arguments[0].getObject(runtime);
-
-    if (!params.hasProperty(runtime, "cipher_type")) {
-      throw jsi::JSError(runtime, "createCipher: cipher_type is required");
-    }
-
-    auto cipher_type = params.getProperty(runtime, "cipher_type")
-                           .asString(runtime)
-                           .utf8(runtime);
-
-    if (!params.hasProperty(runtime, "cipher_key")) {
-      throw jsi::JSError(runtime, "createCipher: cipher_key is required");
-    }
-
-    auto cipher_key = params.getProperty(runtime, "cipher_key")
-                          .getObject(runtime)
-                          .getArrayBuffer(runtime);
-
-    if (!params.hasProperty(runtime, "auth_tag_len")) {
-      throw jsi::JSError(runtime, "createCipher: auth_tag_len is required");
-    }
-
-    unsigned auto int auth_tag_len =
-        (int)params.getProperty(runtime, "auth_tag_len").getNumber();
-
-    if (params.hasProperty(runtime, "iv") &&
-        !params.getProperty(runtime, "iv").isNull() &&
-        !params.getProperty(runtime, "iv").isUndefined()) {  // createDecipheriv
-      auto iv = params.getProperty(runtime, "iv")
-                    .getObject(runtime)
-                    .getArrayBuffer(runtime);
-      auto hostObject = std::make_shared<MGLCipherHostObject>(
-          cipher_type, &cipher_key, false, auth_tag_len, &iv, runtime,
-          jsCallInvoker, workerQueue);
-
-      return jsi::Object::createFromHostObject(runtime, hostObject);
-    } else {
-      auto hostObject = std::make_shared<MGLCipherHostObject>(
-          cipher_type, &cipher_key, false, auth_tag_len, runtime, jsCallInvoker,
-          workerQueue);
-
-      return jsi::Object::createFromHostObject(runtime, hostObject);
-    }
-  });
+  return buildPair(
+      "createDecipher", JSIF([=]) {
+        if (count < 1) {
+          throw jsi::JSError(runtime, "Params object is required");
+        }
+
+        if (!arguments[0].isObject()) {
+          throw jsi::JSError(runtime,
+                             "createCipher: Params needs to be an object");
+        }
+
+        auto params = arguments[0].getObject(runtime);
+
+        if (!params.hasProperty(runtime, "cipher_type")) {
+          throw jsi::JSError(runtime, "createCipher: cipher_type is required");
+        }
+
+        auto cipher_type = params.getProperty(runtime, "cipher_type")
+                               .asString(runtime)
+                               .utf8(runtime);
+
+        if (!params.hasProperty(runtime, "cipher_key")) {
+          throw jsi::JSError(runtime, "createCipher: cipher_key is required");
+        }
+
+        auto cipher_key = params.getProperty(runtime, "cipher_key")
+                              .getObject(runtime)
+                              .getArrayBuffer(runtime);
+
+        if (!params.hasProperty(runtime, "auth_tag_len")) {
+          throw jsi::JSError(runtime, "createCipher: auth_tag_len is required");
+        }
+
+        unsigned int auth_tag_len =
+            (int)params.getProperty(runtime, "auth_tag_len").getNumber();
+
+        if (params.hasProperty(runtime, "iv") &&
+            !params.getProperty(runtime, "iv").isNull() &&
+            !params.getProperty(runtime, "iv")
+                 .isUndefined()) {  // createDecipheriv
+          auto iv = params.getProperty(runtime, "iv")
+                        .getObject(runtime)
+                        .getArrayBuffer(runtime);
+          auto hostObject = std::make_shared<MGLCipherHostObject>(
+              cipher_type, &cipher_key, false, auth_tag_len, &iv, runtime,
+              jsCallInvoker, workerQueue);
+
+          return jsi::Object::createFromHostObject(runtime, hostObject);
+        } else {
+          auto hostObject = std::make_shared<MGLCipherHostObject>(
+              cipher_type, &cipher_key, false, auth_tag_len, runtime,
+              jsCallInvoker, workerQueue);
+
+          return jsi::Object::createFromHostObject(runtime, hostObject);
+        }
+      });
 }
 }  // namespace margelo

package/cpp/Cipher/MGLGenerateKeyPairInstaller.cpp

@@ -0,0 +1,107 @@
+//
+//  MGLGenerateKeyPairInstaller.cpp
+//  react-native-quick-crypto
+//
+//  Created by Oscar on 24.06.22.
+//
+
+#include "MGLGenerateKeyPairInstaller.h"
+
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <utility>
+
+#include "MGLRsa.h"
+
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#include "JSIUtils/MGLTypedArray.h"
+#else
+#include "MGLJSIMacros.h"
+#include "MGLTypedArray.h"
+#endif
+
+using namespace facebook;
+
+namespace margelo {
+
+std::mutex m;
+
+// Current implementation only supports RSA schemes (check line config.variant =
+// ) As more encryption schemes are added this will require an abstraction that
+// supports more schemes
+FieldDefinition getGenerateKeyPairFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
+  return buildPair(
+      "generateKeyPair", JSIF([=]) {
+        auto config = std::make_shared<RsaKeyPairGenConfig>(
+            prepareRsaKeyGenConfig(runtime, arguments));
+        auto promiseConstructor =
+            runtime.global().getPropertyAsFunction(runtime, "Promise");
+
+        auto promise = promiseConstructor.callAsConstructor(
+            runtime,
+            jsi::Function::createFromHostFunction(
+                runtime, jsi::PropNameID::forAscii(runtime, "executor"), 2,
+                [arguments, &jsCallInvoker, config](
+                    jsi::Runtime &runtime, const jsi::Value &,
+                    const jsi::Value *promiseArgs, size_t) -> jsi::Value {
+                  auto resolve =
+                      std::make_shared<jsi::Value>(runtime, promiseArgs[0]);
+                  auto reject =
+                      std::make_shared<jsi::Value>(runtime, promiseArgs[1]);
+
+                  std::thread t([&runtime, arguments, resolve, reject,
+                                 jsCallInvoker, config]() {
+                    m.lock();
+                    try {
+                      const auto keys = generateRSAKeyPair(runtime, config);
+                      jsCallInvoker->invokeAsync([&runtime, keys, jsCallInvoker,
+                                                  resolve]() {
+                        if (keys.first.isString && keys.second.isString) {
+                          auto publicKey = jsi::String::createFromUtf8(
+                              runtime, keys.first.stringValue);
+                          auto privateKey = jsi::String::createFromUtf8(
+                              runtime, keys.second.stringValue);
+                          auto res = jsi::Array::createWithElements(
+                              runtime, jsi::Value::undefined(), publicKey,
+                              privateKey);
+                          resolve->asObject(runtime).asFunction(runtime).call(
+                              runtime, std::move(res));
+                        } else {
+                          MGLTypedArray<MGLTypedArrayKind::Uint8Array>
+                              publicKeyBuffer(runtime, keys.first.vectorValue);
+                          MGLTypedArray<MGLTypedArrayKind::Uint8Array>
+                              privateKeyBuffer(runtime,
+                                               keys.second.vectorValue);
+
+                          auto res = jsi::Array::createWithElements(
+                              runtime, jsi::Value::undefined(), publicKeyBuffer,
+                              privateKeyBuffer);
+                          resolve->asObject(runtime).asFunction(runtime).call(
+                              runtime, std::move(res));
+                        }
+                      });
+                    } catch (std::exception e) {
+                      jsCallInvoker->invokeAsync(
+                          [&runtime, &jsCallInvoker, reject]() {
+                            reject->asObject(runtime).asFunction(runtime).call(
+                                runtime, jsi::String::createFromUtf8(
+                                             runtime, "Error generating key"));
+                          });
+                    }
+                    m.unlock();
+                  });
+
+                  t.detach();
+
+                  return {};
+                }));
+
+        return promise;
+      });
+}
+}  // namespace margelo

package/cpp/Cipher/MGLGenerateKeyPairInstaller.h

@@ -0,0 +1,32 @@
+
+//
+//  MGLGenerateKeyPairInstaller.hpp
+//  react-native-quick-crypto
+//
+//  Created by Oscar on 22.06.22.
+//
+
+#ifndef MGLGenerateKeyPairInstaller_hpp
+#define MGLGenerateKeyPairInstaller_hpp
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+#include "MGLCipherKeys.h"
+#include "MGLRsa.h"
+#include "MGLUtils.h"
+
+namespace margelo {
+
+FieldDefinition getGenerateKeyPairFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo
+
+#endif /* MGLGenerateKeyPairInstaller_hpp */

package/cpp/Cipher/MGLGenerateKeyPairSyncInstaller.cpp

@@ -0,0 +1,60 @@
+//
+//  MGLGenerateKeyPairInstaller.cpp
+//  react-native-quick-crypto
+//
+//  Created by Oscar on 22.06.22.
+//
+
+#include "MGLGenerateKeyPairSyncInstaller.h"
+
+#include <iostream>
+#include <memory>
+#include <utility>
+
+#include "MGLRsa.h"
+
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#include "JSIUtils/MGLJSIUtils.h"
+#include "JSIUtils/MGLTypedArray.h"
+#else
+#include "MGLJSIMacros.h"
+#include "MGLJSIUtils.h"
+#include "MGLTypedArray.h"
+#endif
+
+using namespace facebook;
+
+namespace margelo {
+
+// Current implementation only supports RSA schemes (check line config.variant =
+// ) As more encryption schemes are added this will require an abstraction that
+// supports more schemes
+FieldDefinition getGenerateKeyPairSyncFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
+  return buildPair(
+      "generateKeyPairSync", JSIF([=]) {
+        auto config = std::make_shared<RsaKeyPairGenConfig>(
+            prepareRsaKeyGenConfig(runtime, arguments));
+        auto keys = generateRSAKeyPair(runtime, std::move(config));
+        if (keys.first.isString && keys.second.isString) {
+          auto publicKey =
+              jsi::String::createFromUtf8(runtime, keys.first.stringValue);
+          auto privateKey =
+              jsi::String::createFromUtf8(runtime, keys.second.stringValue);
+          return jsi::Array::createWithElements(
+              runtime, jsi::Value::undefined(), publicKey, privateKey);
+        } else {
+          MGLTypedArray<MGLTypedArrayKind::Uint8Array> publicKeyBuffer(
+              runtime, keys.first.vectorValue);
+          MGLTypedArray<MGLTypedArrayKind::Uint8Array> privateKeyBuffer(
+              runtime, keys.second.vectorValue);
+
+          return jsi::Array::createWithElements(
+              runtime, jsi::Value::undefined(), publicKeyBuffer,
+              privateKeyBuffer);
+        }
+      });
+}
+}  // namespace margelo

package/cpp/Cipher/MGLGenerateKeyPairSyncInstaller.h

@@ -0,0 +1,35 @@
+//
+//  MGLGenerateKeyPairInstaller.hpp
+//  react-native-quick-crypto
+//
+//  Created by Oscar on 22.06.22.
+//
+
+#ifndef MGLGenerateKeyPairSyncInstaller_hpp
+#define MGLGenerateKeyPairSyncInstaller_hpp
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+#include "MGLCipherKeys.h"
+#include "MGLRsa.h"
+#include "MGLUtils.h"
+
+namespace margelo {
+
+// https://nodejs.org/api/crypto.html go to generateKeyPair
+/// It's signature is:
+/// generateKeyPair(type: string, options: record, callback: (error, publicKey,
+/// privateKey))
+FieldDefinition getGenerateKeyPairSyncFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo
+
+#endif /* MGLGenerateKeyPairInstaller_hpp */