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

package/cpp/ed25519/HybridEdKeyPair.cpp

@@ -0,0 +1,268 @@
+#include "HybridEdKeyPair.hpp"
+
+#include <memory>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<void>>
+HybridEdKeyPair::generateKeyPair(
+  double publicFormat,
+  double publicType,
+  double privateFormat,
+  double privateType,
+  const std::optional<std::string>& cipher,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+) {
+  // get owned NativeArrayBuffers before passing to sync function
+  std::optional<std::shared_ptr<ArrayBuffer>> nativePassphrase = std::nullopt;
+  if (passphrase.has_value()) {
+    nativePassphrase = ToNativeArrayBuffer(passphrase.value());
+  }
+
+  return Promise<void>::async(
+    [this, publicFormat, publicType, privateFormat, privateType, cipher,
+     nativePassphrase]() {
+      this->generateKeyPairSync(
+        publicFormat,
+        publicType,
+        privateFormat,
+        privateType,
+        cipher,
+        nativePassphrase
+      );
+    }
+  );
+}
+
+void
+HybridEdKeyPair::generateKeyPairSync(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+) {
+  EVP_PKEY_CTX* pctx;
+
+  // key context
+  pctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pctx == nullptr) {
+    throw std::runtime_error("Invalid curve name: " + this->curve);
+  }
+
+  // keygen init
+  if (EVP_PKEY_keygen_init(pctx) <= 0) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to initialize keygen");
+  }
+
+  // generate key
+  EVP_PKEY_keygen(pctx, &this->pkey);
+  if (this->pkey == nullptr) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to generate key");
+  }
+
+  // cleanup
+  EVP_PKEY_CTX_free(pctx);
+}
+
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridEdKeyPair::sign(
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+  // get owned NativeArrayBuffer before passing to sync function
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeKey = std::nullopt;
+  if (key.has_value()) {
+    nativeKey = ToNativeArrayBuffer(key.value());
+  }
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, nativeMessage, nativeKey]() {
+      return this->signSync(nativeMessage, nativeKey);
+    }
+  );
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::signSync(
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+
+  size_t sig_len = 0;
+  uint8_t* sig = NULL;
+  EVP_MD_CTX* md_ctx = nullptr;
+  EVP_PKEY_CTX* pkey_ctx = nullptr;
+
+  // get key to use for signing
+  EVP_PKEY* pkey = this->importPrivateKey(key);
+
+  // key context
+  md_ctx = EVP_MD_CTX_new();
+  if (md_ctx == nullptr) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Error creating signing context");
+  }
+
+  pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pkey_ctx == nullptr) {
+    EVP_PKEY_CTX_free(pkey_ctx);
+    throw std::runtime_error("Error creating signing context: " + this->curve);
+  }
+
+  if (EVP_DigestSignInit(md_ctx, &pkey_ctx, NULL, NULL, pkey) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    char* err = ERR_error_string(ERR_get_error(), NULL);
+    throw std::runtime_error("Failed to initialize signing: " + std::string(err));
+  }
+
+  // Calculate the required size for the signature by passing a NULL buffer.
+  if (EVP_DigestSign(md_ctx, NULL, &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to calculate signature size");
+  }
+  sig = new uint8_t[sig_len];
+
+  // Actually calculate the signature
+  if (EVP_DigestSign(md_ctx, sig, &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to calculate signature");
+  }
+
+  // return value for JS
+  std::shared_ptr<ArrayBuffer> signature = std::make_shared<NativeArrayBuffer>(
+    sig,
+    sig_len,
+    [=]() { delete[] sig; }
+  );
+
+  // Clean up
+  EVP_MD_CTX_free(md_ctx);
+
+  return signature;
+}
+
+std::shared_ptr<Promise<bool>>
+HybridEdKeyPair::verify(
+  const std::shared_ptr<ArrayBuffer>& signature,
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativeSignature = ToNativeArrayBuffer(signature);
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeKey = std::nullopt;
+  if (key.has_value()) {
+    nativeKey = ToNativeArrayBuffer(key.value());
+  }
+
+  return Promise<bool>::async([this, nativeSignature, nativeMessage, nativeKey]() {
+      return this->verifySync(nativeSignature, nativeMessage, nativeKey);
+    }
+  );
+}
+
+bool
+HybridEdKeyPair::verifySync(
+  const std::shared_ptr<ArrayBuffer>& signature,
+  const std::shared_ptr<ArrayBuffer>& message,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& key
+) {
+  // get key to use for verifying
+  EVP_PKEY* pkey = this->importPrivateKey(key);
+
+  EVP_MD_CTX* md_ctx = nullptr;
+  EVP_PKEY_CTX* pkey_ctx = nullptr;
+
+  // key context
+  md_ctx = EVP_MD_CTX_new();
+  if (md_ctx == nullptr) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Error creating verify context");
+  }
+
+  pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pkey_ctx == nullptr) {
+    EVP_PKEY_CTX_free(pkey_ctx);
+    throw std::runtime_error("Error creating verify context: " + this->curve);
+  }
+
+  if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, NULL, NULL, pkey) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    char* err = ERR_error_string(ERR_get_error(), NULL);
+    throw std::runtime_error("Failed to initialize verify: " + std::string(err));
+  }
+
+  // verify
+  auto res = EVP_DigestVerify(
+    md_ctx,
+    signature.get()->data(), signature.get()->size(),
+    message.get()->data(), message.get()->size()
+  );
+
+  //return value for JS
+  if (res < 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to verify");
+  }
+  return res == 1; // true if 1, false if 0
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::getPublicKey() {
+  this->checkKeyPair();
+  size_t len = 32;
+  uint8_t* publ = new uint8_t[len];
+  EVP_PKEY_get_raw_public_key(this->pkey, publ, &len);
+
+  return std::make_shared<NativeArrayBuffer>(publ, len, [=]() { delete[] publ; });
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::getPrivateKey() {
+  this->checkKeyPair();
+  size_t len = 32;
+  uint8_t* priv = new uint8_t[len];
+  EVP_PKEY_get_raw_private_key(this->pkey, priv, &len);
+
+  return std::make_shared<NativeArrayBuffer>(priv, len, [=]() { delete[] priv; });
+}
+
+void
+HybridEdKeyPair::checkKeyPair() {
+  if (this->pkey == nullptr) {
+    throw std::runtime_error("Keypair not initialized");
+  }
+}
+
+void
+HybridEdKeyPair::setCurve(const std::string& curve) {
+  this->curve = curve;
+}
+
+EVP_PKEY*
+HybridEdKeyPair::importPrivateKey(const std::optional<std::shared_ptr<ArrayBuffer>>& key) {
+  EVP_PKEY* pkey = nullptr;
+  if (key.has_value()) {
+    pkey = EVP_PKEY_new_raw_private_key(
+      EVP_PKEY_ED25519, // TODO: use this->curve somehow
+      NULL,
+      key.value()->data(),
+      32
+    );
+    if (pkey == nullptr) {
+      throw std::runtime_error("Failed to read private key");
+    }
+  } else {
+    this->checkKeyPair();
+    pkey = this->pkey;
+  }
+  return pkey;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/ed25519/HybridEdKeyPair.hpp

@@ -0,0 +1,85 @@
+#include <openssl/evp.h>
+#include <openssl/err.h>
+#include <memory>
+#include <string>
+
+#include "HybridEdKeyPairSpec.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridEdKeyPair : public HybridEdKeyPairSpec {
+ public:
+  HybridEdKeyPair() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<void>>
+  generateKeyPair(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+  ) override;
+
+  void
+  generateKeyPairSync(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+  ) override;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  sign(
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+  std::shared_ptr<ArrayBuffer>
+  signSync(
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+  std::shared_ptr<Promise<bool>>
+  verify(
+    const std::shared_ptr<ArrayBuffer>& signature,
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+  bool
+  verifySync(
+    const std::shared_ptr<ArrayBuffer>& signature,
+    const std::shared_ptr<ArrayBuffer>& message,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  ) override;
+
+ protected:
+  std::shared_ptr<ArrayBuffer>
+  getPublicKey() override;
+
+  std::shared_ptr<ArrayBuffer>
+  getPrivateKey() override;
+
+  void checkKeyPair();
+
+  void setCurve(const std::string& curve) override;
+
+ private:
+  std::string curve;
+  EVP_PKEY* pkey = nullptr;
+
+  EVP_PKEY* importPrivateKey(
+    const std::optional<std::shared_ptr<ArrayBuffer>>& key
+  );
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -0,0 +1,72 @@
+#include "HybridPbkdf2.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridPbkdf2::pbkdf2(
+  const std::shared_ptr<ArrayBuffer>& password,
+  const std::shared_ptr<ArrayBuffer>& salt,
+  double iterations,
+  double keylen,
+  const std::string& digest
+) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativePassword = ToNativeArrayBuffer(password);
+  auto nativeSalt = ToNativeArrayBuffer(salt);
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+    [this, nativePassword, nativeSalt, iterations, keylen, digest]() {
+      return this->pbkdf2Sync(nativePassword, nativeSalt, iterations, keylen, digest);
+    }
+  );
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridPbkdf2::pbkdf2Sync(
+  const std::shared_ptr<ArrayBuffer>& password,
+  const std::shared_ptr<ArrayBuffer>& salt,
+  double iterations,
+  double keylen,
+  const std::string& digest
+) {
+    size_t bufferSize = static_cast<size_t>(keylen);
+    uint8_t* data = new uint8_t[bufferSize];
+    auto result = std::make_shared<NativeArrayBuffer>(data, bufferSize, [=]() { delete[] data; });
+
+    // use fastpbkdf2 when possible
+    if (digest == "sha1") {
+      fastpbkdf2_hmac_sha1(password.get()->data(), password.get()->size(),
+                           salt.get()->data(), salt.get()->size(),
+                           static_cast<uint32_t>(iterations),
+                           result.get()->data(), result.get()->size());
+    } else if (digest == "sha256") {
+      fastpbkdf2_hmac_sha256(password.get()->data(), password.get()->size(),
+                             salt.get()->data(), salt.get()->size(),
+                             static_cast<uint32_t>(iterations),
+                             result.get()->data(), result.get()->size());
+    } else if (digest == "sha512") {
+      fastpbkdf2_hmac_sha512(password.get()->data(), password.get()->size(),
+                             salt.get()->data(), salt.get()->size(),
+                             static_cast<uint32_t>(iterations),
+                             result.get()->data(), result.get()->size());
+    } else {
+      // fallback to OpenSSL
+      auto *digestByName = EVP_get_digestbyname(digest.c_str());
+      if (digestByName == nullptr) {
+        throw std::runtime_error("Invalid hash-algorithm: " + digest);
+      }
+      char *passAsCharA = reinterpret_cast<char *>(password.get()->data());
+      const unsigned char *saltAsCharA =
+          reinterpret_cast<const unsigned char *>(salt.get()->data());
+      unsigned char *resultAsCharA =
+          reinterpret_cast<unsigned char *>(result.get()->data());
+      PKCS5_PBKDF2_HMAC(passAsCharA, password.get()->size(), saltAsCharA,
+                        salt.get()->size(), static_cast<uint32_t>(iterations),
+                        digestByName, result.get()->size(), resultAsCharA);
+    }
+
+    return result;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/pbkdf2/HybridPbkdf2.hpp

@@ -0,0 +1,35 @@
+#include <openssl/evp.h>
+
+#include "HybridPbkdf2Spec.hpp"
+#include "fastpbkdf2.h"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridPbkdf2 : public HybridPbkdf2Spec {
+ public:
+  HybridPbkdf2() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  pbkdf2(
+    const std::shared_ptr<ArrayBuffer>& password,
+    const std::shared_ptr<ArrayBuffer>& salt,
+    double iterations,
+    double keylen,
+    const std::string& digest
+  ) override;
+
+  std::shared_ptr<ArrayBuffer>
+  pbkdf2Sync(
+    const std::shared_ptr<ArrayBuffer>& password,
+    const std::shared_ptr<ArrayBuffer>& salt,
+    double iterations,
+    double keylen,
+    const std::string& digest
+  ) override;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/random/HybridRandom.cpp

@@ -0,0 +1,59 @@
+#include <openssl/err.h>
+#include <openssl/rand.h>
+
+#include "HybridRandom.hpp"
+#include "Utils.hpp"
+
+
+size_t checkSize(double size) {
+  if (!CheckIsUint32(size)) {
+    throw std::runtime_error("size must be uint32");
+  }
+  if (static_cast<uint32_t>(size) > pow(2, 31) - 1) {
+    throw std::runtime_error("size must be less than 2^31 - 1");
+  }
+  return static_cast<size_t>(size);
+}
+
+size_t checkOffset(double size, double offset) {
+  if (!CheckIsUint32(offset)) {
+    throw std::runtime_error("offset must be uint32");
+  }
+  if (offset > size) {
+    throw std::runtime_error("offset must be less than size");
+  }
+  return static_cast<size_t>(offset);
+}
+
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridRandom::randomFill(const std::shared_ptr<ArrayBuffer>& buffer,
+                         double dOffset,
+                         double dSize) {
+  // get owned NativeArrayBuffer before passing to sync function
+  auto nativeBuffer = ToNativeArrayBuffer(buffer);
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+    [this, nativeBuffer, dOffset, dSize]() {
+      return this->randomFillSync(nativeBuffer, dOffset, dSize);
+    }
+  );
+};
+
+std::shared_ptr<ArrayBuffer>
+HybridRandom::randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer,
+                             double dOffset,
+                             double dSize) {
+  size_t size = checkSize(dSize);
+  size_t offset = checkOffset(dSize, dOffset);
+  uint8_t* data = buffer.get()->data();
+  if (RAND_bytes(data + offset, (int)size) != 1) {
+    throw std::runtime_error("error calling RAND_bytes" +
+      std::to_string(ERR_get_error()));
+  }
+  return buffer;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/random/HybridRandom.hpp

@@ -0,0 +1,33 @@
+#include <cmath>
+#include <future>
+#include <memory>
+#include <iostream>
+
+#include "HybridRandomSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridRandom : public HybridRandomSpec {
+ public:
+  HybridRandom() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+
+  std::shared_ptr<ArrayBuffer>
+  randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+};
+
+inline void printData(std::string name, uint8_t* data, size_t size) {
+  std::cout << "data - " << name << std::endl;
+  for (size_t i = 0; i < size; i++) {
+      printf("%u ", data[i]);
+  }
+  printf("\n");
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/utils/Utils.hpp

@@ -0,0 +1,20 @@
+#include <limits>
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+// copy a JSArrayBuffer that we do not own into a NativeArrayBuffer that we do own
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer>
+ToNativeArrayBuffer(const std::shared_ptr<margelo::nitro::ArrayBuffer>& buffer) {
+  size_t bufferSize = buffer.get()->size();
+  uint8_t* data = new uint8_t[bufferSize];
+  memcpy(data, buffer.get()->data(), bufferSize);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, bufferSize, [=]() { delete[] data; });
+}
+
+inline bool CheckIsUint32(double value) {
+  return (value >= std::numeric_limits<uint32_t>::lowest() && value <= std::numeric_limits<uint32_t>::max());
+}
+
+inline bool CheckIsInt32(double value) {
+  return (value >= std::numeric_limits<int32_t>::lowest() && value <= std::numeric_limits<int32_t>::max());
+}

package/lib/commonjs/ed.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Ed = void 0;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _utils = require("./utils");
+class Ed {
+  constructor(type, config) {
+    this.type = type;
+    this.config = config;
+    this.native = _reactNativeNitroModules.NitroModules.createHybridObject('EdKeyPair');
+    this.native.setCurve(type);
+  }
+  async generateKeyPair() {
+    this.native.generateKeyPair(this.config.publicFormat || -1, this.config.publicType || -1, this.config.privateFormat || -1, this.config.privateType || -1, this.config.cipher, this.config.passphrase);
+  }
+  generateKeyPairSync() {
+    this.native.generateKeyPairSync(this.config.publicFormat || -1, this.config.publicType || -1, this.config.privateFormat || -1, this.config.privateType || -1, this.config.cipher, this.config.passphrase);
+  }
+  getPublicKey() {
+    return this.native.getPublicKey();
+  }
+  getPrivateKey() {
+    return this.native.getPrivateKey();
+  }
+  async sign(message, key) {
+    return key ? this.native.sign((0, _utils.binaryLikeToArrayBuffer)(message), (0, _utils.binaryLikeToArrayBuffer)(key)) : this.native.sign((0, _utils.binaryLikeToArrayBuffer)(message));
+  }
+  signSync(message, key) {
+    return key ? this.native.signSync((0, _utils.binaryLikeToArrayBuffer)(message), (0, _utils.binaryLikeToArrayBuffer)(key)) : this.native.signSync((0, _utils.binaryLikeToArrayBuffer)(message));
+  }
+  async verify(signature, message, key) {
+    return key ? this.native.verify((0, _utils.binaryLikeToArrayBuffer)(signature), (0, _utils.binaryLikeToArrayBuffer)(message), (0, _utils.binaryLikeToArrayBuffer)(key)) : this.native.verify((0, _utils.binaryLikeToArrayBuffer)(signature), (0, _utils.binaryLikeToArrayBuffer)(message));
+  }
+  verifySync(signature, message, key) {
+    return key ? this.native.verifySync((0, _utils.binaryLikeToArrayBuffer)(signature), (0, _utils.binaryLikeToArrayBuffer)(message), (0, _utils.binaryLikeToArrayBuffer)(key)) : this.native.verifySync((0, _utils.binaryLikeToArrayBuffer)(signature), (0, _utils.binaryLikeToArrayBuffer)(message));
+  }
+}
+exports.Ed = Ed;
+//# sourceMappingURL=ed.js.map

package/lib/commonjs/ed.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_utils","Ed","constructor","type","config","native","NitroModules","createHybridObject","setCurve","generateKeyPair","publicFormat","publicType","privateFormat","privateType","cipher","passphrase","generateKeyPairSync","getPublicKey","getPrivateKey","sign","message","key","toAB","signSync","verify","signature","verifySync","exports"],"sourceRoot":"../../src","sources":["ed.ts"],"mappings":"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","ignoreList":[]}