react-native-quick-crypto 0.2.0

package/cpp/Cipher/MGLCipherHostObject.h

@@ -0,0 +1,90 @@
+//
+// Created by Oscar on 07.06.22.
+//
+
+#ifndef MGLCipherHostObject_h
+#define MGLCipherHostObject_h
+
+#include <jsi/jsi.h>
+#include <openssl/evp.h>
+
+#include <memory>
+#include <string>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+class MGLCipherHostObject : public MGLSmartHostObject {
+ protected:
+  enum CipherKind { kCipher, kDecipher };
+  enum UpdateResult { kSuccess, kErrorMessageSize, kErrorState };
+  enum AuthTagState { kAuthTagUnknown, kAuthTagKnown, kAuthTagPassedToOpenSSL };
+
+ public:
+  // TODO(osp)  Why does an empty constructor need to be here and not on
+  // HashHostObject?
+  explicit MGLCipherHostObject(
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+
+  explicit MGLCipherHostObject(
+      MGLCipherHostObject *other,
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+
+  // Without iv
+  explicit MGLCipherHostObject(
+      const std::string &cipher_type, jsi::ArrayBuffer *cipher_key,
+      bool isCipher, unsigned int auth_tag_len, jsi::Runtime &runtime,
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+
+  // With iv
+  explicit MGLCipherHostObject(
+      const std::string &cipher_type, jsi::ArrayBuffer *cipher_key,
+      bool isCipher, unsigned int auth_tag_len, jsi::ArrayBuffer *iv,
+      jsi::Runtime &runtime, std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+
+  void commonInit(jsi::Runtime &runtime, const char *cipher_type,
+                  const EVP_CIPHER *cipher, const unsigned char *key,
+                  int key_len, const unsigned char *iv, int iv_len,
+                  unsigned int auth_tag_len);
+
+  void installMethods();
+
+  bool InitAuthenticated(const char *cipher_type, int iv_len,
+                         unsigned int auth_tag_len);
+
+  bool CheckCCMMessageLength(int message_len);
+
+  bool IsAuthenticatedMode() const;
+
+  bool MaybePassAuthTagToOpenSSL();
+
+  virtual ~MGLCipherHostObject();
+
+ private:
+  // TODO(osp) this is the node version, DeleteFnPtr seems to be some custom
+  // wrapper, I guess useful for memory deallocation
+  // DeleteFnPtr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free> ctx_;
+  // For now I'm manually calling EVP_CIPHER_CTX_free in the implementation
+  EVP_CIPHER_CTX *ctx_ = nullptr;
+  bool isCipher_;
+  bool pending_auth_failed_;
+  char auth_tag_[EVP_GCM_TLS_TAG_LEN];
+  AuthTagState auth_tag_state_;
+  unsigned int auth_tag_len_;
+  int max_message_size_;
+};
+
+}  // namespace margelo
+
+#endif  // MGLCipherHostObject_h

package/cpp/Cipher/MGLCreateCipherInstaller.cpp

@@ -0,0 +1,74 @@
+
+#include "MGLCreateCipherInstaller.h"
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#else
+#include "MGLJSIMacros.h"
+#endif
+#include "MGLCipherHostObject.h"
+
+using namespace facebook;
+
+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);
+    }
+  });
+}
+}  // namespace margelo

package/cpp/Cipher/MGLCreateCipherInstaller.h

@@ -0,0 +1,17 @@
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+namespace jsi = facebook::jsi;
+
+FieldDefinition getCreateCipherFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo

package/cpp/Cipher/MGLCreateDecipherInstaller.cpp

@@ -0,0 +1,74 @@
+#include "MGLCreateDecipherInstaller.h"
+
+#include <memory>
+
+#include "MGLCipherHostObject.h"
+
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#else
+#include "MGLJSIMacros.h"
+#endif
+
+using namespace facebook;
+
+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);
+    }
+  });
+}
+}  // namespace margelo

package/cpp/Cipher/MGLCreateDecipherInstaller.h

@@ -0,0 +1,17 @@
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+namespace jsi = facebook::jsi;
+
+FieldDefinition getCreateDecipherFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo

package/cpp/HMAC/MGLHmacHostObject.cpp

@@ -0,0 +1,95 @@
+// Copyright 2022 Margelo
+
+#ifdef ANDROID
+#include "MGLHmacHostObject.h"
+
+#include "JSIUtils/MGLTypedArray.h"
+#else
+#include "MGLHmacHostObject.h"
+#include "MGLTypedArray.h"
+#endif
+
+#include <jsi/jsi.h>
+#include <openssl/hmac.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#define OUT
+
+namespace margelo {
+
+using namespace facebook;
+
+const EVP_MD *parseHashAlgorithm(const std::string &hashAlgorithm) {
+  if (hashAlgorithm == "sha1") {
+    return EVP_sha1();
+  }
+  if (hashAlgorithm == "sha256") {
+    return EVP_sha256();
+  }
+  if (hashAlgorithm == "sha512") {
+    return EVP_sha512();
+  }
+  const EVP_MD *res = EVP_get_digestbyname(hashAlgorithm.c_str());
+  if (res != nullptr) {
+    return res;
+  }
+  throw std::runtime_error("Invalid Hash Algorithm!");
+}
+
+MGLHmacHostObject::MGLHmacHostObject(
+    const std::string &hashAlgorithm, jsi::Runtime &runtime,
+    jsi::ArrayBuffer &key, std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
+    : MGLSmartHostObject(jsCallInvoker, workerQueue) {
+  this->context = HMAC_CTX_new();
+  if (key.size(runtime) == 0) {
+    HMAC_Init_ex(this->context, "", 0, parseHashAlgorithm(hashAlgorithm),
+                 nullptr);
+  } else {
+    HMAC_Init_ex(this->context, key.data(runtime),
+                 static_cast<int>(key.size(runtime)),
+                 parseHashAlgorithm(hashAlgorithm), nullptr);
+  }
+
+  this->fields.push_back(HOST_LAMBDA("update", {
+    if (!arguments[0].isObject() ||
+        !arguments[0].getObject(runtime).isArrayBuffer(runtime)) {
+      throw jsi::JSError(
+          runtime,
+          "MGLHmacHostObject::update: First argument ('message') "
+          "has to be of type ArrayBuffer!");
+    }
+
+    auto message = arguments[0].getObject(runtime).getArrayBuffer(runtime);
+
+    HMAC_Update(this->context, message.data(runtime), message.size(runtime));
+
+    return jsi::Value::undefined();
+  }));
+
+  this->fields.push_back(HOST_LAMBDA("digest", {
+    auto size = HMAC_size(this->context);
+
+    unsigned char *OUT md = new unsigned char[size];
+    unsigned int OUT length;
+
+    HMAC_Final(this->context, md, &length);
+
+    MGLTypedArray<MGLTypedArrayKind::Uint8Array> MGLtypedArray(runtime, length);
+    std::vector<unsigned char> vec(md, md + length);
+    MGLtypedArray.update(runtime, vec);
+
+    return MGLtypedArray;
+  }));
+}
+
+MGLHmacHostObject::~MGLHmacHostObject() {
+  if (this->context != nullptr) {
+    HMAC_CTX_free(this->context);
+  }
+}
+
+}  // namespace margelo

package/cpp/HMAC/MGLHmacHostObject.h

@@ -0,0 +1,39 @@
+//
+//  HmacHostObject.h
+//
+//  Created by Marc Rousavy on 22.02.22.
+//
+
+#ifndef MGLHmacHostObject_h
+#define MGLHmacHostObject_h
+
+#include <jsi/jsi.h>
+#include <openssl/hmac.h>
+
+#include <memory>
+#include <string>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+
+using namespace facebook;
+
+class MGLHmacHostObject : public MGLSmartHostObject {
+ public:
+  explicit MGLHmacHostObject(
+      const std::string &hashAlgorithm, jsi::Runtime &runtime,
+      jsi::ArrayBuffer &key, std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+  virtual ~MGLHmacHostObject();
+
+ private:
+  HMAC_CTX *context;
+};
+}  // namespace margelo
+
+#endif /* MGLHmacHostObject_h */

package/cpp/HMAC/MGLHmacInstaller.cpp

@@ -0,0 +1,43 @@
+//
+//  HMAC-JSI-Installer.m
+//  PinkPanda
+//
+//  Created by Marc Rousavy on 31.10.21.
+//
+
+#include "MGLHmacInstaller.h"
+
+#include <openssl/hmac.h>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#include "MGLHmacHostObject.h"
+#else
+#include "MGLHmacHostObject.h"
+#include "MGLJSIMacros.h"
+#endif
+
+using namespace facebook;
+
+namespace margelo {
+
+FieldDefinition getHmacFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
+  // createHmac(hashAlgorithm: 'sha1' | 'sha256' | 'sha512',
+  //            key: string)
+  return HOST_LAMBDA("createHmac", {
+    if (count != 2) {
+      throw jsi::JSError(runtime,
+                         "createHmac(..) expects exactly 2 arguments!");
+    }
+
+    auto hashAlgorithm = arguments[0].asString(runtime).utf8(runtime);
+    auto key = arguments[1].getObject(runtime).getArrayBuffer(runtime);
+
+    auto hostObject = std::make_shared<MGLHmacHostObject>(
+        hashAlgorithm, runtime, key, jsCallInvoker, workerQueue);
+    return jsi::Object::createFromHostObject(runtime, hostObject);
+  });
+}
+}  // namespace margelo

package/cpp/HMAC/MGLHmacInstaller.h

@@ -0,0 +1,20 @@
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+namespace jsi = facebook::jsi;
+
+/// It's signature is:
+/// createHmac(hashAlgorithm: 'sha1' | 'sha256' | 'sha512',
+///            key: string): HMAC
+FieldDefinition getHmacFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo

package/cpp/Hash/MGLHashHostObject.cpp

@@ -0,0 +1,147 @@
+// Copyright 2022 Margelo
+
+#include "MGLHashHostObject.h"
+
+#ifdef ANDROID
+#include "JSIUtils/MGLTypedArray.h"
+#else
+#include "MGLTypedArray.h"
+#endif
+
+#include <jsi/jsi.h>
+#include <openssl/err.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#define OUT
+
+namespace margelo {
+
+using namespace facebook;
+namespace jsi = facebook::jsi;
+
+const EVP_MD *parseHashAlgorithmForHashObject(
+    const std::string &hashAlgorithm) {
+  const EVP_MD *res = EVP_get_digestbyname(hashAlgorithm.c_str());
+  if (res != nullptr) {
+    return res;
+  }
+  throw std::runtime_error("Invalid Hash Algorithm!");
+}
+
+MGLHashHostObject::MGLHashHostObject(
+    MGLHashHostObject *other, std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
+    : MGLSmartHostObject(jsCallInvoker, workerQueue) {
+  const EVP_MD *md = EVP_MD_CTX_md(other->mdctx_);
+  this->mdctx_ = EVP_MD_CTX_new();
+  EVP_MD_CTX_copy(this->mdctx_, other->mdctx_);
+  md_len_ = EVP_MD_size(md);
+
+  installMethods();
+}
+
+MGLHashHostObject::MGLHashHostObject(
+    const std::string hashAlgorithm, unsigned int md_len,
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
+    : MGLSmartHostObject(jsCallInvoker, workerQueue) {
+  const EVP_MD *md = parseHashAlgorithmForHashObject(hashAlgorithm);
+  mdctx_ = EVP_MD_CTX_new();
+  if (!mdctx_ || EVP_DigestInit_ex(mdctx_, md, nullptr) <= 0) {
+    EVP_MD_CTX_reset(mdctx_);
+    return;
+  }
+  md_len_ = EVP_MD_size(md);
+  if (md_len != -1) {
+    md_len_ = md_len;
+  }
+
+  installMethods();
+}
+
+void MGLHashHostObject::installMethods() {
+  this->fields.push_back(HOST_LAMBDA("update", {
+    if (!arguments[0].isObject() ||
+        !arguments[0].getObject(runtime).isArrayBuffer(runtime)) {
+      throw jsi::JSError(runtime,
+                         "HmacHostObject::update: First argument ('message') "
+                         "has to be of type ArrayBuffer!");
+    }
+    auto messageBuffer =
+        arguments[0].getObject(runtime).getArrayBuffer(runtime);
+
+    const unsigned char *data =
+        reinterpret_cast<const unsigned char *>(messageBuffer.data(runtime));
+    int size = messageBuffer.size(runtime);
+
+    EVP_DigestUpdate(mdctx_, data, size);
+
+    return jsi::Value::undefined();
+  }));
+
+  this->fields.push_back(buildPair(
+      "copy", JSIF([this]) {
+        int md_len = -1;
+        if (!arguments[0].isUndefined()) {
+          md_len = static_cast<int>(arguments[0].asNumber());
+        }
+        std::shared_ptr<MGLHashHostObject> copy =
+            std::make_shared<MGLHashHostObject>(
+                this, this->weakJsCallInvoker.lock(), this->dispatchQueue);
+        if (md_len != -1) {
+          copy->md_len_ = md_len;
+        }
+        return jsi::Object::createFromHostObject(runtime, copy);
+      }));
+
+  this->fields.push_back(buildPair(
+      "digest", JSIF([this]) {
+        unsigned int len = md_len_;
+
+        if (digest_ == nullptr && len > 0) {
+          // Some hash algorithms such as SHA3 do not support calling
+          // EVP_DigestFinal_ex more than once, however, Hash._flush
+          // and Hash.digest can both be used to retrieve the digest,
+          // so we need to cache it.
+          // See https://github.com/nodejs/node/issues/28245.
+
+          char *md_value = new char[len];
+
+          size_t default_len = EVP_MD_CTX_size(mdctx_);
+          int ret;
+          if (len == default_len) {
+            ret = EVP_DigestFinal_ex(
+                mdctx_, reinterpret_cast<unsigned char *>(md_value), &len);
+          } else {
+            ret = EVP_DigestFinalXOF(
+                mdctx_, reinterpret_cast<unsigned char *>(md_value), len);
+          }
+
+          if (ret != 1) {
+            throw jsi::JSError(
+                runtime, "openSSL error:" + std::to_string(ERR_get_error()));
+          }
+
+          digest_ = md_value;
+        }
+
+        MGLTypedArray<MGLTypedArrayKind::Uint8Array> typedArray(runtime, len);
+        std::vector<unsigned char> vec(digest_, digest_ + len);
+        typedArray.update(runtime, vec);
+        return typedArray;
+      }));
+}
+
+MGLHashHostObject::~MGLHashHostObject() {
+  if (this->mdctx_ != nullptr) {
+    EVP_MD_CTX_free(this->mdctx_);
+  }
+  if (digest_ != nullptr) {
+    delete[] digest_;
+  }
+}
+
+}  // namespace margelo

package/cpp/Hash/MGLHashHostObject.h

@@ -0,0 +1,53 @@
+// Copyright 2022 Margelo
+//  HashHostObject.h
+//
+//
+
+#ifndef HashHostObject_h
+#define HashHostObject_h
+
+#include <jsi/jsi.h>
+#include <openssl/dsa.h>
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/kdf.h>
+#include <openssl/rsa.h>
+#include <openssl/ssl.h>
+
+#include <memory>
+#include <string>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+
+using namespace facebook;
+
+class MGLHashHostObject : public MGLSmartHostObject {
+ public:
+  explicit MGLHashHostObject(
+      std::string hashAlgorithm, unsigned int md_len,
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+
+  explicit MGLHashHostObject(
+      MGLHashHostObject *other,
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+  void installMethods();
+
+  virtual ~MGLHashHostObject();
+
+ private:
+  EVP_MD_CTX *mdctx_ = nullptr;
+  unsigned int md_len_ = 0;
+  char *digest_ = nullptr;
+};
+}  // namespace margelo
+
+#endif /* MGLHashHostObject_h */