react-native-quick-crypto 0.2.0 → 0.3.0

package/cpp/Utils/MGLUtils.cpp

@@ -0,0 +1,156 @@
+//
+//  MGLUtils.cpp
+//  react-native-quick-crypto
+//
+//  Created by Oscar on 21.06.22.
+//
+
+#include "MGLUtils.h"
+
+#include <jsi/jsi.h>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+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(Environment* env,
+//                                          Local<String> key,
+//                                          enum encoding enc) {
+//   size_t length = 0;
+//   ByteSource out;
+//
+//   if (StringBytes::Size(env->isolate(), key, enc).To(&length) && length >
+//   0)
+//   {
+//     ByteSource::Builder buf(length);
+//     size_t actual =
+//     StringBytes::Write(env->isolate(), buf.data<char>(), length, key, enc);
+//     out = std::move(buf).release(actual);
+//   }
+//
+//   return out;
+// }
+//
+// ByteSource ByteSource::FromStringOrBuffer(Environment* env,
+//                                           Local<Value> value) {
+//   return IsAnyByteSource(value) ? FromBuffer(value)
+//   : FromString(env, value.As<String>());
+// }
+//
+// ByteSource ByteSource::FromString(Environment* env, Local<String> str,
+//                                   bool ntc) {
+//   CHECK(str->IsString());
+//   size_t size = str->Utf8Length(env->isolate());
+//   size_t alloc_size = ntc ? size + 1 : size;
+//   ByteSource::Builder out(alloc_size);
+//   int opts = String::NO_OPTIONS;
+//   if (!ntc) opts |= String::NO_NULL_TERMINATION;
+//   str->WriteUtf8(env->isolate(), out.data<char>(), alloc_size, nullptr,
+//   opts); return std::move(out).release();
+// }
+//
+// ByteSource ByteSource::FromBuffer(Local<Value> buffer, bool ntc) {
+//   ArrayBufferOrViewContents<char> buf(buffer);
+//   return ntc ? buf.ToNullTerminatedCopy() : buf.ToByteSource();
+// }
+//
+// 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);
+}
+
+}  // namespace margelo

package/cpp/Utils/MGLUtils.h

@@ -0,0 +1,254 @@
+//
+//  MGLUtils.h
+//  Pods
+//
+//  Created by Oscar on 20.06.22.
+//
+
+#ifndef MGLUtils_h
+#define MGLUtils_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>
+#ifndef OPENSSL_NO_ENGINE
+#include <openssl/engine.h>
+#endif  // !OPENSSL_NO_ENGINE
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+struct StringOrBuffer {
+  bool isString;
+  std::string stringValue;
+  std::vector<unsigned char> vectorValue;
+};
+
+template <typename T, void (*function)(T*)>
+struct FunctionDeleter {
+  void operator()(T* pointer) const { function(pointer); }
+  typedef std::unique_ptr<T, FunctionDeleter> Pointer;
+};
+
+template <typename T, void (*function)(T*)>
+using DeleteFnPtr = typename FunctionDeleter<T, function>::Pointer;
+using X509Pointer = DeleteFnPtr<X509, X509_free>;
+using BIOPointer = DeleteFnPtr<BIO, BIO_free_all>;
+using PKCS8Pointer = DeleteFnPtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>;
+using EVPKeyCtxPointer = DeleteFnPtr<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;
+using EVPKeyPointer = DeleteFnPtr<EVP_PKEY, EVP_PKEY_free>;
+using BignumPointer = DeleteFnPtr<BIGNUM, BN_free>;
+using RSAPointer = DeleteFnPtr<RSA, RSA_free>;
+
+template <typename T>
+class NonCopyableMaybe {
+ public:
+  NonCopyableMaybe() : empty_(true) {}
+  explicit NonCopyableMaybe(T&& value)
+      : empty_(false), value_(std::move(value)) {}
+
+  bool IsEmpty() const { return empty_; }
+
+  const T* get() const { return empty_ ? nullptr : &value_; }
+
+  const T* operator->() const {
+    //    CHECK(!empty_);
+    return &value_;
+  }
+
+  T&& Release() {
+    //    CHECK_EQ(empty_, false);
+    empty_ = true;
+    return std::move(value_);
+  }
+
+ private:
+  bool empty_;
+  T value_;
+};
+
+template <typename T>
+inline T MultiplyWithOverflowCheck(T a, T b) {
+  auto ret = a * b;
+  //  if (a != 0)
+  //    CHECK_EQ(b, ret / a);
+
+  return ret;
+}
+
+template <typename T>
+T* MallocOpenSSL(size_t count) {
+  void* mem = OPENSSL_malloc(MultiplyWithOverflowCheck(count, sizeof(T)));
+  //  CHECK_IMPLIES(mem == nullptr, count == 0);
+  return static_cast<T*>(mem);
+}
+
+// A helper class representing a read-only byte array. When deallocated, its
+// contents are zeroed.
+class ByteSource {
+ public:
+  class Builder {
+   public:
+    // Allocates memory using OpenSSL's memory allocator.
+    explicit Builder(size_t size)
+        : data_(MallocOpenSSL<char>(size)), size_(size) {}
+
+    Builder(Builder&& other) = delete;
+    Builder& operator=(Builder&& other) = delete;
+    Builder(const Builder&) = delete;
+    Builder& operator=(const Builder&) = delete;
+
+    ~Builder() { OPENSSL_clear_free(data_, size_); }
+
+    // Returns the underlying non-const pointer.
+    template <typename T>
+    T* data() {
+      return reinterpret_cast<T*>(data_);
+    }
+
+    // Returns the (allocated) size in bytes.
+    size_t size() const { return size_; }
+
+    // Finalizes the Builder and returns a read-only view that is optionally
+    // truncated.
+    ByteSource release(std::optional<size_t> resize = std::nullopt) && {
+      if (resize) {
+        //        CHECK_LE(*resize, size_);
+        if (*resize == 0) {
+          OPENSSL_clear_free(data_, size_);
+          data_ = nullptr;
+        }
+        size_ = *resize;
+      }
+      ByteSource out = ByteSource::Allocated(data_, size_);
+      data_ = nullptr;
+      size_ = 0;
+      return out;
+    }
+
+   private:
+    void* data_;
+    size_t size_;
+  };
+
+  ByteSource() = default;
+  ByteSource(ByteSource&& other) noexcept;
+  ~ByteSource();
+
+  ByteSource& operator=(ByteSource&& other) noexcept;
+
+  ByteSource(const ByteSource&) = delete;
+  ByteSource& operator=(const ByteSource&) = delete;
+
+  template <typename T = void>
+  const T* data() const {
+    return reinterpret_cast<const T*>(data_);
+  }
+
+  size_t size() const { return size_; }
+
+  operator bool() const { return data_ != nullptr; }
+
+  //  BignumPointer ToBN() const {
+  //    return BignumPointer(BN_bin2bn(data<unsigned char>(), size(), nullptr));
+  //  }
+
+  // Creates a v8::BackingStore that takes over responsibility for
+  // any allocated data. The ByteSource will be reset with size = 0
+  // after being called.
+  //  std::unique_ptr<v8::BackingStore> ReleaseToBackingStore();
+  //
+  //  v8::Local<v8::ArrayBuffer> ToArrayBuffer(Environment* env);
+  //
+  //  v8::MaybeLocal<v8::Uint8Array> ToBuffer(Environment* env);
+
+  static ByteSource Allocated(void* data, size_t size);
+  static ByteSource Foreign(const void* data, size_t size);
+
+  //  static ByteSource FromEncodedString(Environment* env,
+  //                                      v8::Local<v8::String> value,
+  //                                      enum encoding enc = BASE64);
+  //
+  //  static ByteSource FromStringOrBuffer(Environment* env,
+  //                                       v8::Local<v8::Value> value);
+  //
+  //  static ByteSource FromString(Environment* env,
+  //                               v8::Local<v8::String> str,
+  //                               bool ntc = false);
+
+  //  static ByteSource FromBuffer(v8::Local<v8::Value> buffer,
+  //                               bool ntc = false);
+
+  //  static ByteSource FromBIO(const BIOPointer& bio);
+  //
+  //  static ByteSource NullTerminatedCopy(Environment* env,
+  //                                       v8::Local<v8::Value> value);
+  //
+  //  static ByteSource FromSymmetricKeyObjectHandle(v8::Local<v8::Value>
+  //  handle);
+
+  //  static ByteSource FromSecretKeyBytes(
+  //                                       Environment* env,
+  //                                       v8::Local<v8::Value> value);
+
+ private:
+  const void* data_ = nullptr;
+  void* allocated_data_ = nullptr;
+  size_t size_ = 0;
+
+  ByteSource(const void* data, void* allocated_data, size_t size)
+      : data_(data), allocated_data_(allocated_data), size_(size) {}
+};
+
+// Originally part of the ArrayBufferContentOrView class
+inline ByteSource ToNullTerminatedByteSource(jsi::Runtime& runtime,
+                                             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;
+  memcpy(buf, buffer.data(runtime), buffer.size(runtime));
+  return ByteSource::Allocated(buf, buffer.size(runtime));
+}
+
+int PasswordCallback(char* buf, int size, int rwflag, void* u) {
+  const ByteSource* passphrase = *static_cast<const ByteSource**>(u);
+  if (passphrase != nullptr) {
+    size_t buflen = static_cast<size_t>(size);
+    size_t len = passphrase->size();
+    if (buflen < len) return -1;
+    memcpy(buf, passphrase->data(), len);
+    return len;
+  }
+
+  return -1;
+}
+
+void CheckEntropy() {
+  for (;;) {
+    int status = RAND_status();
+    //    CHECK_GE(status, 0);  // Cannot fail.
+    if (status != 0) break;
+
+    // Give up, RAND_poll() not supported.
+    if (RAND_poll() == 0) break;
+  }
+}
+
+}  // namespace margelo
+
+#endif /* MGLUtils_h */