react-native-quick-crypto 0.2.0

package/cpp/Hash/MGLHashInstaller.cpp

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

package/cpp/Hash/MGLHashInstaller.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 getHashFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo

package/cpp/JSIUtils/MGLJSIMacros.h

@@ -0,0 +1,37 @@
+//
+// Created by Szymon on 24/02/2022.
+//
+
+#ifndef MGL_JSIMACROS_H
+#define MGL_JSIMACROS_H
+
+#include <utility>
+
+// if you want to create a new marco use (https://godbolt.org) provide flag -E
+// in right panel
+
+#define HOST_LAMBDA(name, body) HOST_LAMBDA_CAP(name, [=], body)
+
+#define HOST_LAMBDA_CAP(name, capture, body)                                 \
+  std::make_pair(                                                            \
+      name, capture(jsi::Runtime &runtime) {                                 \
+        const auto func =                                                    \
+            capture(jsi::Runtime & runtime, const jsi::Value &thisValue,     \
+                    const jsi::Value *arguments, size_t count)               \
+                ->jsi::Value body;                                           \
+        auto propNameID = jsi::PropNameID::forAscii(runtime, name);          \
+        return jsi::Function::createFromHostFunction(runtime, propNameID, 0, \
+                                                     func);                  \
+      })
+
+#define JSI_VALUE(name, body) JSI_VALUE_CAP(name, [=], body)
+
+#define JSI_VALUE_CAP(name, capture, body) \
+  std::make_pair(name, capture(jsi::Runtime &runtime) body)
+
+#define JSIF(capture)                                         \
+  capture(jsi::Runtime &runtime, const jsi::Value &thisValue, \
+          const jsi::Value *arguments, size_t count)          \
+      ->jsi::Value
+
+#endif  // MGL_JSIMACROS_H

package/cpp/JSIUtils/MGLSmartHostObject.cpp

@@ -0,0 +1,43 @@
+//
+// Created by Szymon on 24/02/2022.
+//
+
+#include "MGLSmartHostObject.h"
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+FieldDefinition buildPair(std::string name, jsi::HostFunctionType &&f) {
+  auto valueBuilder = [f, name](jsi::Runtime &runtime) {
+    const auto func = f;
+    auto propNameID = jsi::PropNameID::forAscii(runtime, name);
+    return jsi::Function::createFromHostFunction(runtime, propNameID, 0, func);
+  };
+  return std::make_pair(name, valueBuilder);
+}
+
+std::vector<jsi::PropNameID> MGLSmartHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  for (auto field : fields) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(runtime, field.first));
+  }
+  return propertyNames;
+}
+
+// TODO(Szymon) maybe add memoization here
+jsi::Value MGLSmartHostObject::get(jsi::Runtime &runtime,
+                                   const jsi::PropNameID &propNameId) {
+  auto name = propNameId.utf8(runtime);
+  for (auto field : fields) {
+    auto fieldName = field.first;
+    if (fieldName == name) {
+      return (field.second)(runtime);
+    }
+  }
+  return jsi::Value::undefined();
+}
+
+}  // namespace margelo

package/cpp/JSIUtils/MGLSmartHostObject.h

@@ -0,0 +1,46 @@
+//
+// Created by Szymon on 24/02/2022.
+//
+
+#ifndef MGL_SMARTHOSTOBJECT_H
+#define MGL_SMARTHOSTOBJECT_H
+
+#include <ReactCommon/TurboModuleUtils.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "MGLJSIMacros.h"
+#include "MGLThreadAwareHostObject.h"
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+typedef std::function<jsi::Value(jsi::Runtime &runtime)> JSIValueBuilder;
+
+typedef std::pair<std::string, JSIValueBuilder> FieldDefinition;
+
+FieldDefinition buildPair(std::string name, jsi::HostFunctionType &&f);
+
+class JSI_EXPORT MGLSmartHostObject : public MGLThreadAwareHostObject {
+ public:
+  MGLSmartHostObject(std::shared_ptr<react::CallInvoker> jsCallInvoker,
+                     std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
+      : MGLThreadAwareHostObject(jsCallInvoker, workerQueue) {}
+
+  virtual ~MGLSmartHostObject() {}
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &runtime);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &propNameId);
+
+  std::vector<std::pair<std::string, JSIValueBuilder>> fields;
+};
+
+}  // namespace margelo
+
+#endif  // MGL_SMARTHOSTOBJECT_H

package/cpp/JSIUtils/MGLThreadAwareHostObject.cpp

@@ -0,0 +1,24 @@
+//
+// Created by Szymon on 24/02/2022.
+//
+
+#include "MGLThreadAwareHostObject.h"
+
+#include <utility>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+void MGLThreadAwareHostObject::runOnWorkerThread(std::function<void()> &&job) {
+  this->dispatchQueue->dispatch(job);
+}
+
+void MGLThreadAwareHostObject::runOnJSThread(std::function<void()> &&job) {
+  auto callInvoker = this->weakJsCallInvoker.lock();
+  if (callInvoker != nullptr) {
+    callInvoker->invokeAsync(std::move(job));
+  }
+}
+
+}  // namespace margelo

package/cpp/JSIUtils/MGLThreadAwareHostObject.h

@@ -0,0 +1,43 @@
+//
+// Created by Szymon on 24/02/2022.
+//
+
+#ifndef MGL_THREADAWAREHOSTOBJECT_H
+#define MGL_THREADAWAREHOSTOBJECT_H
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ONANDROID
+#include "Utils/MGLDispatchQueue.h"
+#else
+#include "../Utils/MGLDispatchQueue.h"
+#endif
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+class JSI_EXPORT MGLThreadAwareHostObject : public jsi::HostObject {
+ public:
+  explicit MGLThreadAwareHostObject(
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
+      : weakJsCallInvoker(jsCallInvoker), dispatchQueue(workerQueue) {}
+
+  virtual ~MGLThreadAwareHostObject() {}
+
+  void runOnWorkerThread(std::function<void(void)> &&job);
+  void runOnJSThread(std::function<void(void)> &&job);
+
+ protected:
+  std::weak_ptr<react::CallInvoker> weakJsCallInvoker;
+  std::shared_ptr<DispatchQueue::dispatch_queue> dispatchQueue;
+};
+
+}  // namespace margelo
+
+#endif  // MGL_THREADAWAREHOSTOBJECT_H

package/cpp/JSIUtils/MGLTypedArray.cpp

@@ -0,0 +1,325 @@
+//
+//  TypedArray.cpp
+//  react-native-quick-crypto
+//
+//  Created by Marc Rousavy on 31.10.21.
+//  Originally created by Expo (expo-gl)
+//
+
+#include "MGLTypedArray.h"
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+template <MGLTypedArrayKind T>
+using ContentType = typename typedArrayTypeMap<T>::type;
+
+enum class Prop {
+  Buffer,             // "buffer"
+  Constructor,        // "constructor"
+  Name,               // "name"
+  Proto,              // "__proto__"
+  Length,             // "length"
+  ByteLength,         // "byteLength"
+  ByteOffset,         // "offset"
+  IsView,             // "isView"
+  ArrayBuffer,        // "ArrayBuffer"
+  Int8Array,          // "Int8Array"
+  Int16Array,         // "Int16Array"
+  Int32Array,         // "Int32Array"
+  Uint8Array,         // "Uint8Array"
+  Uint8ClampedArray,  // "Uint8ClampedArray"
+  Uint16Array,        // "Uint16Array"
+  Uint32Array,        // "Uint32Array"
+  Float32Array,       // "Float32Array"
+  Float64Array,       // "Float64Array"
+};
+
+class PropNameIDCache {
+ public:
+  const jsi::PropNameID &get(jsi::Runtime &runtime, Prop prop) {
+    if (!this->props[prop]) {
+      this->props[prop] =
+          std::make_unique<jsi::PropNameID>(createProp(runtime, prop));
+    }
+    return *(this->props[prop]);
+  }
+
+  const jsi::PropNameID &getConstructorNameProp(jsi::Runtime &runtime,
+                                                MGLTypedArrayKind kind);
+
+  void invalidate() { props.erase(props.begin(), props.end()); }
+
+ private:
+  std::unordered_map<Prop, std::unique_ptr<jsi::PropNameID>> props;
+
+  jsi::PropNameID createProp(jsi::Runtime &runtime, Prop prop);
+};
+
+PropNameIDCache propNameIDCache;
+
+void invalidateJsiPropNameIDCache() { propNameIDCache.invalidate(); }
+
+MGLTypedArrayKind getTypedArrayKindForName(const std::string &name);
+
+MGLTypedArrayBase::MGLTypedArrayBase(jsi::Runtime &runtime, size_t size,
+                                     MGLTypedArrayKind kind)
+    : MGLTypedArrayBase(
+          runtime,
+          runtime.global()
+              .getProperty(runtime, propNameIDCache.getConstructorNameProp(
+                                        runtime, kind))
+              .asObject(runtime)
+              .asFunction(runtime)
+              .callAsConstructor(runtime, {static_cast<double>(size)})
+              .asObject(runtime)) {}
+
+MGLTypedArrayBase::MGLTypedArrayBase(jsi::Runtime &runtime,
+                                     const jsi::Object &obj)
+    : jsi::Object(jsi::Value(runtime, obj).asObject(runtime)) {}
+
+MGLTypedArrayKind MGLTypedArrayBase::getKind(jsi::Runtime &runtime) const {
+  auto constructorName =
+      this->getProperty(runtime,
+                        propNameIDCache.get(runtime, Prop::Constructor))
+          .asObject(runtime)
+          .getProperty(runtime, propNameIDCache.get(runtime, Prop::Name))
+          .asString(runtime)
+          .utf8(runtime);
+  return getTypedArrayKindForName(constructorName);
+}
+
+size_t MGLTypedArrayBase::size(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length))
+      .asNumber();
+}
+
+size_t MGLTypedArrayBase::length(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length))
+      .asNumber();
+}
+
+size_t MGLTypedArrayBase::byteLength(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteLength))
+      .asNumber();
+}
+
+size_t MGLTypedArrayBase::byteOffset(jsi::Runtime &runtime) const {
+  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteOffset))
+      .asNumber();
+}
+
+bool MGLTypedArrayBase::hasBuffer(jsi::Runtime &runtime) const {
+  auto buffer =
+      getProperty(runtime, propNameIDCache.get(runtime, Prop::Buffer));
+  return buffer.isObject() && buffer.asObject(runtime).isArrayBuffer(runtime);
+}
+
+std::vector<uint8_t> MGLTypedArrayBase::toVector(jsi::Runtime &runtime) {
+  auto start = reinterpret_cast<uint8_t *>(getBuffer(runtime).data(runtime) +
+                                           byteOffset(runtime));
+  auto end = start + byteLength(runtime);
+  return std::vector<uint8_t>(start, end);
+}
+
+jsi::ArrayBuffer MGLTypedArrayBase::getBuffer(jsi::Runtime &runtime) const {
+  auto buffer =
+      getProperty(runtime, propNameIDCache.get(runtime, Prop::Buffer));
+  if (buffer.isObject() && buffer.asObject(runtime).isArrayBuffer(runtime)) {
+    return buffer.asObject(runtime).getArrayBuffer(runtime);
+  } else {
+    throw std::runtime_error("no ArrayBuffer attached");
+  }
+}
+
+bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
+  auto jsVal =
+      runtime.global()
+          .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
+          .asObject(runtime)
+          .getProperty(runtime, propNameIDCache.get(runtime, Prop::IsView))
+          .asObject(runtime)
+          .asFunction(runtime)
+          .callWithThis(runtime, runtime.global(),
+                        {jsi::Value(runtime, jsObj)});
+  if (jsVal.isBool()) {
+    return jsVal.getBool();
+  } else {
+    throw std::runtime_error("value is not a boolean");
+  }
+}
+
+MGLTypedArrayBase getTypedArray(jsi::Runtime &runtime,
+                                const jsi::Object &jsObj) {
+  auto jsVal =
+      runtime.global()
+          .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
+          .asObject(runtime)
+          .getProperty(runtime, propNameIDCache.get(runtime, Prop::IsView))
+          .asObject(runtime)
+          .asFunction(runtime)
+          .callWithThis(runtime, runtime.global(),
+                        {jsi::Value(runtime, jsObj)});
+  if (jsVal.isBool()) {
+    return MGLTypedArrayBase(runtime, jsObj);
+  } else {
+    throw std::runtime_error("value is not a boolean");
+  }
+}
+
+std::vector<uint8_t> arrayBufferToVector(jsi::Runtime &runtime,
+                                         jsi::Object &jsObj) {
+  if (!jsObj.isArrayBuffer(runtime)) {
+    throw std::runtime_error("Object is not an ArrayBuffer");
+  }
+  auto jsArrayBuffer = jsObj.getArrayBuffer(runtime);
+
+  uint8_t *dataBlock = jsArrayBuffer.data(runtime);
+  size_t blockSize =
+      jsArrayBuffer
+          .getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteLength))
+          .asNumber();
+  return std::vector<uint8_t>(dataBlock, dataBlock + blockSize);
+}
+
+void arrayBufferUpdate(jsi::Runtime &runtime, jsi::ArrayBuffer &buffer,
+                       std::vector<uint8_t> data, size_t offset) {
+  uint8_t *dataBlock = buffer.data(runtime);
+  size_t blockSize = buffer.size(runtime);
+  if (data.size() > blockSize) {
+    throw jsi::JSError(runtime, "ArrayBuffer is to small to fit data");
+  }
+  std::copy(data.begin(), data.end(), dataBlock + offset);
+}
+
+template <MGLTypedArrayKind T>
+MGLTypedArray<T>::MGLTypedArray(jsi::Runtime &runtime, size_t size)
+    : MGLTypedArrayBase(runtime, size, T) {}
+
+template <MGLTypedArrayKind T>
+MGLTypedArray<T>::MGLTypedArray(jsi::Runtime &runtime,
+                                std::vector<ContentType<T>> data)
+    : MGLTypedArrayBase(runtime, data.size(), T) {
+  update(runtime, data);
+}
+
+template <MGLTypedArrayKind T>
+MGLTypedArray<T>::MGLTypedArray(MGLTypedArrayBase &&base)
+    : MGLTypedArrayBase(std::move(base)) {}
+
+template <MGLTypedArrayKind T>
+std::vector<ContentType<T>> MGLTypedArray<T>::toVector(jsi::Runtime &runtime) {
+  auto start = reinterpret_cast<ContentType<T> *>(
+      getBuffer(runtime).data(runtime) + byteOffset(runtime));
+  auto end = start + size(runtime);
+  return std::vector<ContentType<T>>(start, end);
+}
+
+template <MGLTypedArrayKind T>
+void MGLTypedArray<T>::update(jsi::Runtime &runtime,
+                              const std::vector<ContentType<T>> &data) {
+  if (data.size() != size(runtime)) {
+    throw jsi::JSError(
+        runtime,
+        "TypedArray can only be updated with a vector of the same size");
+  }
+  uint8_t *rawData = getBuffer(runtime).data(runtime) + byteOffset(runtime);
+  std::copy(data.begin(), data.end(),
+            reinterpret_cast<ContentType<T> *>(rawData));
+}
+
+const jsi::PropNameID &PropNameIDCache::getConstructorNameProp(
+    jsi::Runtime &runtime, MGLTypedArrayKind kind) {
+  switch (kind) {
+    case MGLTypedArrayKind::Int8Array:
+      return get(runtime, Prop::Int8Array);
+    case MGLTypedArrayKind::Int16Array:
+      return get(runtime, Prop::Int16Array);
+    case MGLTypedArrayKind::Int32Array:
+      return get(runtime, Prop::Int32Array);
+    case MGLTypedArrayKind::Uint8Array:
+      return get(runtime, Prop::Uint8Array);
+    case MGLTypedArrayKind::Uint8ClampedArray:
+      return get(runtime, Prop::Uint8ClampedArray);
+    case MGLTypedArrayKind::Uint16Array:
+      return get(runtime, Prop::Uint16Array);
+    case MGLTypedArrayKind::Uint32Array:
+      return get(runtime, Prop::Uint32Array);
+    case MGLTypedArrayKind::Float32Array:
+      return get(runtime, Prop::Float32Array);
+    case MGLTypedArrayKind::Float64Array:
+      return get(runtime, Prop::Float64Array);
+  }
+}
+
+jsi::PropNameID PropNameIDCache::createProp(jsi::Runtime &runtime, Prop prop) {
+  auto create = [&](const std::string &propName) {
+    return jsi::PropNameID::forUtf8(runtime, propName);
+  };
+  switch (prop) {
+    case Prop::Buffer:
+      return create("buffer");
+    case Prop::Constructor:
+      return create("constructor");
+    case Prop::Name:
+      return create("name");
+    case Prop::Proto:
+      return create("__proto__");
+    case Prop::Length:
+      return create("length");
+    case Prop::ByteLength:
+      return create("byteLength");
+    case Prop::ByteOffset:
+      return create("byteOffset");
+    case Prop::IsView:
+      return create("isView");
+    case Prop::ArrayBuffer:
+      return create("ArrayBuffer");
+    case Prop::Int8Array:
+      return create("Int8Array");
+    case Prop::Int16Array:
+      return create("Int16Array");
+    case Prop::Int32Array:
+      return create("Int32Array");
+    case Prop::Uint8Array:
+      return create("Uint8Array");
+    case Prop::Uint8ClampedArray:
+      return create("Uint8ClampedArray");
+    case Prop::Uint16Array:
+      return create("Uint16Array");
+    case Prop::Uint32Array:
+      return create("Uint32Array");
+    case Prop::Float32Array:
+      return create("Float32Array");
+    case Prop::Float64Array:
+      return create("Float64Array");
+  }
+}
+
+std::unordered_map<std::string, MGLTypedArrayKind> nameToKindMap = {
+    {"Int8Array", MGLTypedArrayKind::Int8Array},
+    {"Int16Array", MGLTypedArrayKind::Int16Array},
+    {"Int32Array", MGLTypedArrayKind::Int32Array},
+    {"Uint8Array", MGLTypedArrayKind::Uint8Array},
+    {"Uint8ClampedArray", MGLTypedArrayKind::Uint8ClampedArray},
+    {"Uint16Array", MGLTypedArrayKind::Uint16Array},
+    {"Uint32Array", MGLTypedArrayKind::Uint32Array},
+    {"Float32Array", MGLTypedArrayKind::Float32Array},
+    {"Float64Array", MGLTypedArrayKind::Float64Array},
+};
+
+MGLTypedArrayKind getTypedArrayKindForName(const std::string &name) {
+  return nameToKindMap.at(name);
+}
+
+template class MGLTypedArray<MGLTypedArrayKind::Int8Array>;
+template class MGLTypedArray<MGLTypedArrayKind::Int16Array>;
+template class MGLTypedArray<MGLTypedArrayKind::Int32Array>;
+template class MGLTypedArray<MGLTypedArrayKind::Uint8Array>;
+template class MGLTypedArray<MGLTypedArrayKind::Uint8ClampedArray>;
+template class MGLTypedArray<MGLTypedArrayKind::Uint16Array>;
+template class MGLTypedArray<MGLTypedArrayKind::Uint32Array>;
+template class MGLTypedArray<MGLTypedArrayKind::Float32Array>;
+template class MGLTypedArray<MGLTypedArrayKind::Float64Array>;