react-native-quick-crypto 0.2.0

package/cpp/JSIUtils/MGLTypedArray.h

@@ -0,0 +1,160 @@
+//
+//  TypedArray.h
+//  react-native-quick-crypto
+//
+//  Created by Marc Rousavy on 31.10.21.
+//  Originally created by Expo (expo-gl)
+//
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <utility>
+#include <vector>
+
+namespace jsi = facebook::jsi;
+
+enum class MGLTypedArrayKind {
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Uint16Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+};
+
+template <MGLTypedArrayKind T>
+class MGLTypedArray;
+
+template <MGLTypedArrayKind T>
+struct typedArrayTypeMap;
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Int8Array> {
+  typedef int8_t type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Int16Array> {
+  typedef int16_t type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Int32Array> {
+  typedef int32_t type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Uint8Array> {
+  typedef uint8_t type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Uint8ClampedArray> {
+  typedef uint8_t type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Uint16Array> {
+  typedef uint16_t type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Uint32Array> {
+  typedef uint32_t type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Float32Array> {
+  typedef float type;
+};
+template <>
+struct typedArrayTypeMap<MGLTypedArrayKind::Float64Array> {
+  typedef double type;
+};
+
+void invalidateJsiPropNameIDCache();
+
+class MGLTypedArrayBase : public jsi::Object {
+ public:
+  template <MGLTypedArrayKind T>
+  using ContentType = typename typedArrayTypeMap<T>::type;
+
+  MGLTypedArrayBase(jsi::Runtime &, size_t, MGLTypedArrayKind);
+  MGLTypedArrayBase(jsi::Runtime &, const jsi::Object &);
+  MGLTypedArrayBase(MGLTypedArrayBase &&) = default;
+  MGLTypedArrayBase &operator=(MGLTypedArrayBase &&) = default;
+
+  MGLTypedArrayKind getKind(jsi::Runtime &runtime) const;
+
+  template <MGLTypedArrayKind T>
+  MGLTypedArray<T> get(jsi::Runtime &runtime) const &;
+  template <MGLTypedArrayKind T>
+  MGLTypedArray<T> get(jsi::Runtime &runtime) &&;
+  template <MGLTypedArrayKind T>
+  MGLTypedArray<T> as(jsi::Runtime &runtime) const &;
+  template <MGLTypedArrayKind T>
+  MGLTypedArray<T> as(jsi::Runtime &runtime) &&;
+
+  size_t size(jsi::Runtime &runtime) const;
+  size_t length(jsi::Runtime &runtime) const;
+  size_t byteLength(jsi::Runtime &runtime) const;
+  size_t byteOffset(jsi::Runtime &runtime) const;
+  bool hasBuffer(jsi::Runtime &runtime) const;
+
+  std::vector<uint8_t> toVector(jsi::Runtime &runtime);
+  jsi::ArrayBuffer getBuffer(jsi::Runtime &runtime) const;
+
+ private:
+  template <MGLTypedArrayKind>
+  friend class MGLTypedArray;
+};
+
+bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj);
+MGLTypedArrayBase getTypedArray(jsi::Runtime &runtime,
+                                const jsi::Object &jsObj);
+
+std::vector<uint8_t> arrayBufferToVector(jsi::Runtime &runtime,
+                                         jsi::Object &jsObj);
+void arrayBufferUpdate(jsi::Runtime &runtime, jsi::ArrayBuffer &buffer,
+                       std::vector<uint8_t> data, size_t offset);
+
+template <MGLTypedArrayKind T>
+class MGLTypedArray : public MGLTypedArrayBase {
+ public:
+  MGLTypedArray(jsi::Runtime &runtime, size_t size);
+  MGLTypedArray(jsi::Runtime &runtime, std::vector<ContentType<T>> data);
+  explicit MGLTypedArray(MGLTypedArrayBase &&base);
+  explicit MGLTypedArray(MGLTypedArray &&) = default;
+  MGLTypedArray &operator=(MGLTypedArray &&) = default;
+
+  std::vector<ContentType<T>> toVector(jsi::Runtime &runtime);
+  void update(jsi::Runtime &runtime, const std::vector<ContentType<T>> &data);
+};
+
+template <MGLTypedArrayKind T>
+MGLTypedArray<T> MGLTypedArrayBase::get(jsi::Runtime &runtime) const & {
+  assert(getKind(runtime) == T);
+  (void)runtime;  // when assert is disabled we need to mark this as used
+  return MGLTypedArray<T>(
+      jsi::Value(runtime, jsi::Value(runtime, *this).asObject(runtime)));
+}
+
+template <MGLTypedArrayKind T>
+MGLTypedArray<T> MGLTypedArrayBase::get(jsi::Runtime &runtime) && {
+  assert(getKind(runtime) == T);
+  (void)runtime;  // when assert is disabled we need to mark this as used
+  return MGLTypedArray<T>(std::move(*this));
+}
+
+template <MGLTypedArrayKind T>
+MGLTypedArray<T> MGLTypedArrayBase::as(jsi::Runtime &runtime) const & {
+  if (getKind(runtime) != T) {
+    throw jsi::JSError(runtime, "Object is not a MGLTypedArray");
+  }
+  return get<T>(runtime);
+}
+
+template <MGLTypedArrayKind T>
+MGLTypedArray<T> MGLTypedArrayBase::as(jsi::Runtime &runtime) && {
+  if (getKind(runtime) != T) {
+    throw jsi::JSError(runtime, "Object is not a MGLTypedArray");
+  }
+  return std::move(*this).get<T>(runtime);
+}

package/cpp/MGLQuickCryptoHostObject.cpp

@@ -0,0 +1,64 @@
+// Copyright 2022 Margelo
+#include "MGLQuickCryptoHostObject.h"
+
+#include <ReactCommon/TurboModuleUtils.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <vector>
+
+#ifdef ANDROID
+#include "Cipher/MGLCreateCipherInstaller.h"
+#include "Cipher/MGLCreateDecipherInstaller.h"
+#include "HMAC/MGLHmacInstaller.h"
+#include "Hash/MGLHashInstaller.h"
+#include "Random/MGLRandomHostObject.h"
+#include "fastpbkdf2/MGLPbkdf2HostObject.h"
+#else
+#include "MGLCreateCipherInstaller.h"
+#include "MGLCreateDecipherInstaller.h"
+#include "MGLHashInstaller.h"
+#include "MGLHmacInstaller.h"
+#include "MGLPbkdf2HostObject.h"
+#include "MGLRandomHostObject.h"
+
+#endif
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+MGLQuickCryptoHostObject::MGLQuickCryptoHostObject(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
+    : MGLSmartHostObject(jsCallInvoker, workerQueue) {
+  // HmacInstaller
+  this->fields.push_back(getHmacFieldDefinition(jsCallInvoker, workerQueue));
+
+  // HashInstaller
+  this->fields.push_back(getHashFieldDefinition(jsCallInvoker, workerQueue));
+
+  // CreateCipherInstaller
+  this->fields.push_back(
+      getCreateCipherFieldDefinition(jsCallInvoker, workerQueue));
+
+  // CreateDecipherInstaller
+  this->fields.push_back(
+      getCreateDecipherFieldDefinition(jsCallInvoker, workerQueue));
+
+  // Pbkdf2HostObject
+  this->fields.push_back(JSI_VALUE("pbkdf2", {
+    auto hostObject =
+        std::make_shared<MGLPbkdf2HostObject>(jsCallInvoker, workerQueue);
+    return jsi::Object::createFromHostObject(runtime, hostObject);
+  }));
+
+  // RandomHostObject
+  this->fields.push_back(JSI_VALUE("random", {
+    auto hostObject =
+        std::make_shared<MGLRandomHostObject>(jsCallInvoker, workerQueue);
+    return jsi::Object::createFromHostObject(runtime, hostObject);
+  }));
+}
+
+}  // namespace margelo

package/cpp/MGLQuickCryptoHostObject.h

@@ -0,0 +1,30 @@
+// Copyright 2022 Margelo
+#ifndef CPP_FASTCRYPTOHOSTOBJECT_H_
+#define CPP_FASTCRYPTOHOSTOBJECT_H_
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#include "JSIUtils/MGLSmartHostObject.h"
+#include "JSIUtils/MGLTypedArray.h"
+#include "Utils/MGLDispatchQueue.h"
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+class JSI_EXPORT MGLQuickCryptoHostObject : public MGLSmartHostObject {
+ public:
+  explicit MGLQuickCryptoHostObject(
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+
+  virtual ~MGLQuickCryptoHostObject() { invalidateJsiPropNameIDCache(); }
+};
+
+}  // namespace margelo
+
+#endif  // CPP_FASTCRYPTOHOSTOBJECT_H_

package/cpp/Random/MGLRandomHostObject.cpp

@@ -0,0 +1,89 @@
+//
+// Created by Szymon on 25/02/2022.
+//
+
+#include "MGLRandomHostObject.h"
+
+#ifdef ANDROID
+#include "JSIUtils/MGLTypedArray.h"
+#else
+#include "MGLTypedArray.h"
+#endif
+#include <openssl/bn.h>
+#include <openssl/dsa.h>
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/kdf.h>
+#include <openssl/rand.h>
+#include <openssl/rsa.h>
+#include <openssl/ssl.h>
+
+#include <memory>
+#include <utility>
+
+namespace margelo {
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+MGLRandomHostObject::MGLRandomHostObject(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
+    : MGLSmartHostObject(jsCallInvoker, workerQueue) {
+  this->fields.push_back(buildPair(
+      "randomFill", JSIF([=]) {
+        if (count != 3) {
+          throw jsi::JSError(runtime,
+                             "randomFill(..) expects exactly 4 arguments!");
+        }
+
+        auto result = arguments[0].asObject(runtime).getArrayBuffer(runtime);
+        auto resultSize = result.size(runtime);
+        auto *resultData = result.data(runtime);
+        auto resultPreventGC =
+            std::make_shared<jsi::ArrayBuffer>(std::move(result));
+
+        auto offset = (int)arguments[1].asNumber();
+        auto size = arguments[2].asNumber();
+
+        return react::createPromiseAsJSIValue(
+            runtime, [=](jsi::Runtime &runtime,
+                         std::shared_ptr<react::Promise> promise) {
+              // TODO(Szymon) implement check prime once we have bignums
+              this->runOnWorkerThread([=]() {
+                if (RAND_bytes(resultData + offset, size) != 1) {
+                  this->runOnJSThread([=]() {
+                    promise->reject("Sth went wrong with RAND_bytes");
+                  });
+                }
+                this->runOnJSThread([=]() {
+                  promise->resolve(
+                      jsi::ArrayBuffer(std::move(*resultPreventGC)));
+                });
+              });
+            });
+      }));
+
+  this->fields.push_back(buildPair(
+      "randomFillSync", JSIF([=]) {
+        if (count != 3) {
+          throw jsi::JSError(runtime,
+                             "randomFillSync(..) expects exactly 4 arguments!");
+        }
+
+        auto result = arguments[0].asObject(runtime).getArrayBuffer(runtime);
+        auto resultSize = result.size(runtime);
+        auto *resultData = result.data(runtime);
+        auto offset = (int)arguments[1].asNumber();
+        auto size = arguments[2].asNumber();
+
+        if (RAND_bytes(resultData + offset, size) != 1) {
+          throw jsi::JSError(runtime, "Sth went wrong with RAND_bytes" +
+                                          std::to_string(ERR_get_error()));
+        }
+
+        return result;
+      }));
+}
+
+}  // namespace margelo

package/cpp/Random/MGLRandomHostObject.h

@@ -0,0 +1,27 @@
+//
+// Created by Szymon on 25/02/2022.
+//
+
+#ifndef MGL_RANDOMHOSTOBJECT_H
+#define MGL_RANDOMHOSTOBJECT_H
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+namespace jsi = facebook::jsi;
+
+class MGLRandomHostObject : public MGLSmartHostObject {
+ public:
+  MGLRandomHostObject(
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+};
+
+}  // namespace margelo
+#endif  // MGL_RANDOMHOSTOBJECT_H

package/cpp/Utils/MGLDispatchQueue.cpp

@@ -0,0 +1,75 @@
+//
+// Created by Szymon on 23/02/2022.
+//
+
+#include "MGLDispatchQueue.h"
+
+#include <utility>
+
+namespace margelo {
+
+namespace DispatchQueue {
+
+dispatch_queue::dispatch_queue(std::string name, size_t thread_cnt)
+    : name_{std::move(name)}, threads_(thread_cnt) {
+  printf("Creating dispatch queue: %s\n", name_.c_str());
+  printf("Dispatch threads: %zu\n", thread_cnt);
+
+  for (size_t i = 0; i < threads_.size(); i++) {
+    threads_[i] = std::thread(&dispatch_queue::dispatch_thread_handler, this);
+  }
+}
+
+dispatch_queue::~dispatch_queue() {
+  printf("Destructor: Destroying dispatch threads...\n");
+
+  // Signal to dispatch threads that it's time to wrap up
+  std::unique_lock<std::mutex> lock(lock_);
+  quit_ = true;
+  cv_.notify_all();
+  lock.unlock();
+
+  // Wait for threads to finish before we exit
+  for (size_t i = 0; i < threads_.size(); i++) {
+    if (threads_[i].joinable()) {
+      printf("Destructor: Joining thread %zu until completion\n", i);
+      threads_[i].join();
+    }
+  }
+}
+
+void dispatch_queue::dispatch(const fp_t &op) {
+  std::unique_lock<std::mutex> lock(lock_);
+  q_.push(op);
+  cv_.notify_one();
+}
+
+void dispatch_queue::dispatch(fp_t &&op) {
+  std::unique_lock<std::mutex> lock(lock_);
+  q_.push(std::move(op));
+  cv_.notify_one();
+}
+
+void dispatch_queue::dispatch_thread_handler(void) {
+  std::unique_lock<std::mutex> lock(lock_);
+
+  do {
+    // Wait until we have data or a quit signal
+    cv_.wait(lock, [this] { return (q_.size() || quit_); });
+
+    // after wait, we own the lock
+    if (!quit_ && q_.size()) {
+      auto op = std::move(q_.front());
+      q_.pop();
+
+      // unlock now that we're done messing with the queue
+      lock.unlock();
+
+      op();
+
+      lock.lock();
+    }
+  } while (!quit_);
+}
+}  // namespace DispatchQueue
+}  // namespace margelo

package/cpp/Utils/MGLDispatchQueue.h

@@ -0,0 +1,55 @@
+//
+// Created by Szymon on 23/02/2022.
+//
+
+#ifndef MGL_DISPATCHQUEUE_H
+#define MGL_DISPATCHQUEUE_H
+
+#include <condition_variable>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace margelo {
+
+// taken from
+// https://github.com/embeddedartistry/embedded-resources/blob/master/examples/cpp/dispatch.cpp
+namespace DispatchQueue {
+class dispatch_queue {
+  typedef std::function<void(void)> fp_t;
+
+ public:
+  explicit dispatch_queue(std::string name, size_t thread_cnt = 1);
+  ~dispatch_queue();
+
+  // dispatch and copy
+  void dispatch(const fp_t &op);
+  // dispatch and move
+  void dispatch(fp_t &&op);
+
+  // Deleted operations
+  dispatch_queue(const dispatch_queue &rhs) = delete;
+  dispatch_queue &operator=(const dispatch_queue &rhs) = delete;
+  dispatch_queue(dispatch_queue &&rhs) = delete;
+  dispatch_queue &operator=(dispatch_queue &&rhs) = delete;
+
+ private:
+  std::string name_;
+  std::mutex lock_;
+  std::vector<std::thread> threads_;
+  std::queue<fp_t> q_;
+  std::condition_variable cv_;
+  bool quit_ = false;
+
+  void dispatch_thread_handler(void);
+};
+}  // namespace DispatchQueue
+
+}  // namespace margelo
+
+#endif  // MGL_DISPATCHQUEUE_H

package/cpp/Utils/logs.h

@@ -0,0 +1,38 @@
+#ifdef ANDROID
+// LOGS ANDROID
+#include <android/log.h>
+#define LOG_TAG "react-native-quick-crypto"
+#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#define LOGSIMPLE(...)
+#else
+// LOGS NO ANDROID
+#include <stdio.h>
+#define LOG_TAG "react-native-quick-crypto"
+#define LOGV(...)      \
+  printf("  ");        \
+  printf(__VA_ARGS__); \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGD(...)      \
+  printf("  ");        \
+  printf(__VA_ARGS__); \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGI(...)      \
+  printf("  ");        \
+  printf(__VA_ARGS__); \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGW(...)          \
+  printf("  * Warning: "); \
+  printf(__VA_ARGS__);     \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGE(...)           \
+  printf("  *** Error:  "); \
+  printf(__VA_ARGS__);      \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGSIMPLE(...) \
+  printf(" ");         \
+  printf(__VA_ARGS__);
+#endif  // ANDROID