react-native-quick-crypto 0.7.11 → 1.0.0-beta.10

package/cpp/Sig/MGLSignHostObjects.h

@@ -1,128 +0,0 @@
-#ifndef MGLSignHostObjects_h
-#define MGLSignHostObjects_h
-
-#include <jsi/jsi.h>
-#include <openssl/evp.h>
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <utility>
-
-#include "MGLKeys.h"
-#ifdef ANDROID
-#include "JSIUtils/MGLSmartHostObject.h"
-#include "Utils/MGLUtils.h"
-#else
-#include "MGLSmartHostObject.h"
-#include "MGLUtils.h"
-#endif
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-static const unsigned int kNoDsaSignature = static_cast<unsigned int>(-1);
-
-enum mode { kModeSign, kModeVerify };
-
-enum DSASigEnc {
-  kSigEncDER,
-  kSigEncP1363,
-};
-
-class SignBase : public MGLSmartHostObject {
- public:
-  SignBase(std::shared_ptr<react::CallInvoker> jsCallInvoker,
-           std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
-
-  typedef enum {
-    kSignOk,
-    kSignUnknownDigest,
-    kSignInit,
-    kSignNotInitialised,
-    kSignUpdate,
-    kSignPrivateKey,
-    kSignPublicKey,
-    kSignMalformedSignature
-  } Error;
-
-  struct SignResult {
-    Error error;
-    std::optional<jsi::Value> signature;
-
-    explicit SignResult(Error err, std::optional<jsi::Value> sig = std::nullopt)
-        : error(err), signature(std::move(sig)) {}
-  };
-
-  void InstallMethods(mode);
-
-  SignResult SignFinal(jsi::Runtime& runtime, const ManagedEVPPKey& pkey,
-                       int padding, std::optional<int>& salt_len,
-                       DSASigEnc dsa_sig_enc);
-
-  Error VerifyFinal(const ManagedEVPPKey& pkey, const ByteSource& sig,
-                    int padding, std::optional<int>& saltlen,
-                    bool* verify_result);
-
- protected:
-  EVPMDPointer mdctx_;
-};
-
-struct SignConfiguration final {  //  : public MemoryRetainer
-  enum Mode {
-    kSign,
-    kVerify
-  };
-  enum Flags {
-    kHasNone = 0,
-    kHasSaltLength = 1,
-    kHasPadding = 2
-  };
-
-  // CryptoJobMode job_mode;  // all async for now
-  Mode mode;
-  ManagedEVPPKey key;
-  ByteSource data;
-  ByteSource signature;
-  const EVP_MD* digest = nullptr;
-  int flags = SignConfiguration::kHasNone;
-  int padding = 0;
-  int salt_length = 0;
-  DSASigEnc dsa_encoding = kSigEncDER;
-
-  SignConfiguration() = default;
-
-  // explicit SignConfiguration(SignConfiguration&& other) noexcept;
-
-  // SignConfiguration& operator=(SignConfiguration&& other) noexcept;
-
-  // void MemoryInfo(MemoryTracker* tracker) const override;
-  // SET_MEMORY_INFO_NAME(SignConfiguration)
-  // SET_SELF_SIZE(SignConfiguration)
-};
-
-class SubtleSignVerify {
-  public:
-    SignConfiguration GetParamsFromJS(jsi::Runtime &rt, const jsi::Value *args);
-    void DoSignVerify(jsi::Runtime &rt, const SignConfiguration &params, ByteSource &out);
-    jsi::Value EncodeOutput(jsi::Runtime &rt,const SignConfiguration &params, ByteSource &out);
-};
-
-class MGLSignHostObject : public SignBase {
- public:
-  explicit MGLSignHostObject(
-      std::shared_ptr<react::CallInvoker> jsCallInvoker,
-      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
-};
-
-class MGLVerifyHostObject : public SignBase {
- public:
-  explicit MGLVerifyHostObject(
-      std::shared_ptr<react::CallInvoker> jsCallInvoker,
-      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
-};
-
-}  // namespace margelo
-
-#endif /* MGLSignHostObjects_h */

package/cpp/Sig/MGLSignInstaller.cpp

@@ -1,24 +0,0 @@
-#include "MGLSignInstaller.h"
-
-#include "MGLSignHostObjects.h"
-#ifdef ANDROID
-#include "JSIUtils/MGLJSIMacros.h"
-#else
-#include "MGLJSIMacros.h"
-#include "logs.h"
-#endif
-
-namespace margelo {
-
-FieldDefinition getSignFieldDefinition(
-    std::shared_ptr<react::CallInvoker> jsCallInvoker,
-    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
-  return buildPair(
-      "createSign", JSIF([=]) {
-        auto hostObject =
-            std::make_shared<MGLSignHostObject>(jsCallInvoker, workerQueue);
-        return jsi::Object::createFromHostObject(runtime, hostObject);
-      });
-}
-
-}  // namespace margelo

package/cpp/Sig/MGLSignInstaller.h

@@ -1,29 +0,0 @@
-//
-//  MGLSignInstaller.hpp
-//  DoubleConversion
-//
-//  Created by Oscar on 30.06.22.
-//
-
-#ifndef MGLSignInstaller_h
-#define MGLSignInstaller_h
-
-#include <jsi/jsi.h>
-
-#include <memory>
-
-#ifdef ANDROID
-#include "JSIUtils/MGLSmartHostObject.h"
-#else
-#include "MGLSmartHostObject.h"
-#endif
-
-namespace margelo {
-namespace jsi = facebook::jsi;
-
-FieldDefinition getSignFieldDefinition(
-    std::shared_ptr<react::CallInvoker> jsCallInvoker,
-    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
-}  // namespace margelo
-
-#endif /* MGLSignInstaller_h */

package/cpp/Sig/MGLVerifyInstaller.cpp

@@ -1,24 +0,0 @@
-#include "MGLVerifyInstaller.h"
-
-#include "MGLSignHostObjects.h"
-#ifdef ANDROID
-#include "JSIUtils/MGLJSIMacros.h"
-#else
-#include "MGLJSIMacros.h"
-#include "logs.h"
-#endif
-
-namespace margelo {
-
-FieldDefinition getVerifyFieldDefinition(
-    std::shared_ptr<react::CallInvoker> jsCallInvoker,
-    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
-  return buildPair(
-      "createVerify", JSIF([=]) {
-        auto hostObject =
-            std::make_shared<MGLVerifyHostObject>(jsCallInvoker, workerQueue);
-        return jsi::Object::createFromHostObject(runtime, hostObject);
-      });
-}
-
-}  // namespace margelo

package/cpp/Sig/MGLVerifyInstaller.h

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

package/cpp/Utils/MGLDispatchQueue.cpp

@@ -1,75 +0,0 @@
-//
-// 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

@@ -1,55 +0,0 @@
-//
-// 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/MGLUtils.cpp

@@ -1,295 +0,0 @@
-#include "MGLUtils.h"
-
-#include <jsi/jsi.h>
-
-#include <iostream>
-#include <optional>
-#include <string>
-
-#include "base64.h"
-
-#ifdef ANDROID
-#include "JSIUtils/MGLJSIMacros.h"
-#else
-#include "MGLJSIMacros.h"
-#endif
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-ByteSource ArrayBufferToByteSource(jsi::Runtime& runtime,
-                                   const jsi::ArrayBuffer& buffer) {
-  if (buffer.size(runtime) == 0) return ByteSource();
-  char* buf = MallocOpenSSL<char>(buffer.size(runtime));
-  CHECK_NOT_NULL(buf);
-  // const cast artificially removes the const qualifier, but you cannot still
-  // modify the data in this case, this is safe because we are just memcopying
-  // to the buffer
-  memcpy(buf, const_cast<jsi::ArrayBuffer&>(buffer).data(runtime),
-         buffer.size(runtime));
-  return ByteSource::Allocated(buf, buffer.size(runtime));
-}
-
-ByteSource ArrayBufferToNTCByteSource(jsi::Runtime& runtime,
-                                      const jsi::ArrayBuffer& buffer) {
-  if (buffer.size(runtime) == 0) return ByteSource();
-  char* buf = MallocOpenSSL<char>(buffer.size(runtime) + 1);
-  CHECK_NOT_NULL(buf);
-  buf[buffer.size(runtime)] = 0;
-  // const cast artificially removes the const qualifier, but you cannot still
-  // modify the data in this case, this is safe because we are just memcopying
-  // to the buffer
-  memcpy(buf, const_cast<jsi::ArrayBuffer&>(buffer).data(runtime),
-         buffer.size(runtime));
-  return ByteSource::Allocated(buf, buffer.size(runtime));
-}
-
-ByteSource::ByteSource(ByteSource&& other) noexcept
-    : data_(other.data_),
-      allocated_data_(other.allocated_data_),
-      size_(other.size_) {
-  other.allocated_data_ = nullptr;
-}
-
-ByteSource::~ByteSource() { OPENSSL_clear_free(allocated_data_, size_); }
-
-ByteSource& ByteSource::operator=(ByteSource&& other) noexcept {
-  if (&other != this) {
-    OPENSSL_clear_free(allocated_data_, size_);
-    data_ = other.data_;
-    allocated_data_ = other.allocated_data_;
-    other.allocated_data_ = nullptr;
-    size_ = other.size_;
-  }
-  return *this;
-}
-
-// std::unique_ptr<BackingStore> ByteSource::ReleaseToBackingStore() {
-//   // It's ok for allocated_data_ to be nullptr but
-//   // only if size_ is zero.
-//   CHECK_IMPLIES(size_ > 0, allocated_data_ != nullptr);
-//   std::unique_ptr<BackingStore> ptr = ArrayBuffer::NewBackingStore(
-//                                                                    allocated_data_,
-//                                                                    size(),
-//                                                                    [](void*
-//                                                                    data,
-//                                                                    size_t
-//                                                                    length,
-//                                                                    void*
-//                                                                    deleter_data)
-//                                                                    {
-//                                                                      OPENSSL_clear_free(deleter_data,
-//                                                                      length);
-//                                                                    },
-//                                                                    allocated_data_);
-//   CHECK(ptr);
-//   allocated_data_ = nullptr;
-//   data_ = nullptr;
-//   size_ = 0;
-//   return ptr;
-// }
-//
-// Local<ArrayBuffer> ByteSource::ToArrayBuffer(Environment* env) {
-//   std::unique_ptr<BackingStore> store = ReleaseToBackingStore();
-//   return ArrayBuffer::New(env->isolate(), std::move(store));
-// }
-//
-// MaybeLocal<Uint8Array> ByteSource::ToBuffer(Environment* env) {
-//   Local<ArrayBuffer> ab = ToArrayBuffer(env);
-//   return Buffer::New(env, ab, 0, ab->ByteLength());
-// }
-
-ByteSource ByteSource::FromBIO(const BIOPointer& bio) {
-//  CHECK(bio);
-  BUF_MEM* bptr;
-  BIO_get_mem_ptr(bio.get(), &bptr);
-  ByteSource::Builder out(bptr->length);
-  memcpy(out.data<void>(), bptr->data, bptr->length);
-  return std::move(out).release();
-}
-
-ByteSource ByteSource::FromEncodedString(jsi::Runtime &rt,
-                                         const std::string key,
-                                         enum encoding enc) {
-  // memcpy & size together properly handle strings containing \0 characters
-  std::string result = StringBytesWrite(rt, key, enc);
-  size_t size = result.size();
-  ByteSource::Builder out(size);
-  memcpy(out.data<void>(), result.data(), size);
-  return std::move(out).release(size);
-}
-
-ByteSource ByteSource::FromStringOrBuffer(jsi::Runtime& runtime,
-                                          const jsi::Value& value) {
-  return value.isString()
-             ? FromString(value.asString(runtime).utf8(runtime))
-             : FromBuffer(runtime,
-                          value.asObject(runtime).getArrayBuffer(runtime));
-}
-
-// ntc = null terminated copy
-ByteSource ByteSource::FromString(std::string str, bool ntc) {
-  //   CHECK(str->IsString());
-  size_t size = str.size();
-  size_t alloc_size = ntc ? size + 1 : size;
-  ByteSource::Builder out(alloc_size);
-  if (ntc) {
-    strcpy(out.data<char>(), str.data());
-  } else {
-    strncpy(out.data<char>(), str.data(), alloc_size);
-  }
-
-  return std::move(out).release(alloc_size);
-}
-
-ByteSource ByteSource::FromBuffer(jsi::Runtime& runtime,
-                                  const jsi::ArrayBuffer& buffer, bool ntc) {
-  return ntc ? ArrayBufferToNTCByteSource(runtime, buffer)
-             : ArrayBufferToByteSource(runtime, buffer);
-}
-//
-// ByteSource ByteSource::FromSecretKeyBytes(
-//                                           Environment* env,
-//                                           Local<Value> value) {
-//   // A key can be passed as a string, buffer or KeyObject with type
-//   'secret'.
-//   // If it is a string, we need to convert it to a buffer. We are not doing
-//   that
-//   // in JS to avoid creating an unprotected copy on the heap.
-//   return value->IsString() || IsAnyByteSource(value) ?
-//   ByteSource::FromStringOrBuffer(env, value) :
-//   ByteSource::FromSymmetricKeyObjectHandle(value);
-// }
-
-// ByteSource ByteSource::NullTerminatedCopy(Environment* env,
-//                                           Local<Value> value) {
-//   return Buffer::HasInstance(value) ? FromBuffer(value, true)
-//   : FromString(env, value.As<String>(), true);
-// }
-
-// ByteSource ByteSource::FromSymmetricKeyObjectHandle(Local<Value> handle) {
-//   CHECK(handle->IsObject());
-//   KeyObjectHandle* key = Unwrap<KeyObjectHandle>(handle.As<Object>());
-//   CHECK_NOT_NULL(key);
-//   return Foreign(key->Data()->GetSymmetricKey(),
-//                  key->Data()->GetSymmetricKeySize());
-// }
-
-ByteSource ByteSource::Allocated(void* data, size_t size) {
-  return ByteSource(data, data, size);
-}
-
-ByteSource ByteSource::Foreign(const void* data, size_t size) {
-  return ByteSource(data, nullptr, size);
-}
-
-ByteSource ByteSource::FromBN(const BIGNUM* bn, size_t size) {
-  std::vector<uint8_t> buf(size);
-  CHECK_EQ(BN_bn2binpad(bn, buf.data(), size), size);
-  ByteSource::Builder out(size);
-  memcpy(out.data<void>(), buf.data(), size);
-  return std::move(out).release();
-}
-
-ByteSource GetByteSourceFromJS(jsi::Runtime &rt,
-                               const jsi::Value &value,
-                               std::string name) {
-    if (!value.isObject() || !value.asObject(rt).isArrayBuffer(rt)) {
-    throw jsi::JSError(rt, "arg is not an array buffer: " + name);
-  }
-  ByteSource data = ByteSource::FromStringOrBuffer(rt, value);
-  if (data.size() > INT_MAX) {
-    throw jsi::JSError(rt, "arg is too big (> int32): " + name);
-  }
-  return data;
-}
-
-std::string EncodeBignum(const BIGNUM* bn,
-                         size_t size,
-                         bool url) {
-  if (size == 0)
-    size = BN_num_bytes(bn);
-  std::vector<uint8_t> buf(size);
-  CHECK_EQ(BN_bn2binpad(bn, buf.data(), size), size);
-  std::string data(buf.begin(), buf.end());
-  return EncodeBase64(data, url);
-}
-
-// loosely based on Node src/string_bytes.cc - StringBytes::Write()
-std::string StringBytesWrite(jsi::Runtime &rt,
-                             const std::string val,
-                             enum encoding encoding) {
-  std::string result;
-
-  switch (encoding) {
-    case BASE64:
-      // fallthrough
-    case BASE64URL:
-      result = DecodeBase64(val);
-      break;
-    default:
-      throw jsi::JSError(rt, "Encoding not supported");
-  }
-
-  return result;
-}
-
-std::string EncodeBase64(const std::string data, bool url) {
-  return base64_encode(data, url);
-}
-
-std::string DecodeBase64(const std::string &in, bool remove_linebreaks) {
-  return base64_decode(in, remove_linebreaks);
-}
-
-MUST_USE_RESULT CSPRNGResult CSPRNG(void* buffer, size_t length) {
-  unsigned char* buf = static_cast<unsigned char*>(buffer);
-  do {
-    if (1 == RAND_status()) {
-#if OPENSSL_VERSION_MAJOR >= 3
-      if (1 == RAND_bytes_ex(nullptr, buf, length, 0)) return {true};
-#else
-      while (length > INT_MAX && 1 == RAND_bytes(buf, INT_MAX)) {
-        buf += INT_MAX;
-        length -= INT_MAX;
-      }
-      if (length <= INT_MAX && 1 == RAND_bytes(buf, static_cast<int>(length)))
-        return {true};
-#endif
-    }
-#if OPENSSL_VERSION_MAJOR >= 3
-    const auto code = ERR_peek_last_error();
-    // A misconfigured OpenSSL 3 installation may report 1 from RAND_poll()
-    // and RAND_status() but fail in RAND_bytes() if it cannot look up
-    // a matching algorithm for the CSPRNG.
-    if (ERR_GET_LIB(code) == ERR_LIB_RAND) {
-      const auto reason = ERR_GET_REASON(code);
-      if (reason == RAND_R_ERROR_INSTANTIATING_DRBG ||
-          reason == RAND_R_UNABLE_TO_FETCH_DRBG ||
-          reason == RAND_R_UNABLE_TO_CREATE_DRBG) {
-        return {false};
-      }
-    }
-#endif
-  } while (1 == RAND_poll());
-
-  return {false};
-}
-
-bool SetRsaOaepLabel(const EVPKeyCtxPointer& ctx, const ByteSource& label) {
-  if (label.size() != 0) {
-    // OpenSSL takes ownership of the label, so we need to create a copy.
-    void* label_copy = OPENSSL_memdup(label.data(), label.size());
-    CHECK_NOT_NULL(label_copy);
-    int ret = EVP_PKEY_CTX_set0_rsa_oaep_label(
-        ctx.get(), static_cast<unsigned char*>(label_copy), label.size());
-    if (ret <= 0) {
-      OPENSSL_free(label_copy);
-      return false;
-    }
-  }
-  return true;
-}
-
-}  // namespace margelo