react-native-quick-crypto 0.7.0-rc.9 → 0.7.1

package/android/CMakeLists.txt

@@ -43,7 +43,9 @@ add_library(
   "../cpp/Sig/MGLVerifyInstaller.cpp"
   "../cpp/Sig/MGLSignHostObjects.cpp"
   "../cpp/webcrypto/MGLWebCrypto.cpp"
+  "../cpp/webcrypto/crypto_aes.cpp"
   "../cpp/webcrypto/crypto_ec.cpp"
+  "../cpp/webcrypto/crypto_keygen.cpp"
 )
 
 target_include_directories(

package/cpp/Cipher/MGLGenerateKeyPairInstaller.cpp

@@ -10,6 +10,7 @@
 #include <iostream>
 #include <memory>
 #include <mutex>
+#include <string>
 #include <thread>
 #include <utility>
 
@@ -18,9 +19,11 @@
 #ifdef ANDROID
 #include "JSIUtils/MGLJSIMacros.h"
 #include "JSIUtils/MGLTypedArray.h"
+#include "webcrypto/crypto_ec.h"
 #else
 #include "MGLJSIMacros.h"
 #include "MGLTypedArray.h"
+#include "crypto_ec.h"
 #endif
 
 using namespace facebook;
@@ -29,24 +32,44 @@ namespace margelo {
 
 std::mutex m;
 
-// Current implementation only supports RSA schemes (check line config.variant =
-// ) As more encryption schemes are added this will require an abstraction that
-// supports more schemes
 FieldDefinition getGenerateKeyPairFieldDefinition(
     std::shared_ptr<react::CallInvoker> jsCallInvoker,
     std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
   return buildPair(
       "generateKeyPair", JSIF([=]) {
-        auto config = std::make_shared<RsaKeyPairGenConfig>(
+
+        KeyVariant variant =
+          static_cast<KeyVariant>((int)arguments[0].asNumber());
+        std::shared_ptr<RsaKeyPairGenConfig> rsaConfig;
+        std::shared_ptr<EcKeyPairGenConfig> ecConfig;
+
+        // switch on variant to get proper config from arguments
+        // outside of lambda 🤮
+        if (variant == kvRSA_SSA_PKCS1_v1_5 ||
+            variant == kvRSA_PSS ||
+            variant == kvRSA_OAEP
+        ) {
+          rsaConfig = std::make_shared<RsaKeyPairGenConfig>(
             prepareRsaKeyGenConfig(runtime, arguments));
+        } else
+        if (variant == kvEC) {
+          ecConfig = std::make_shared<EcKeyPairGenConfig>(
+            prepareEcKeyGenConfig(runtime, arguments));
+        } else {
+          throw std::runtime_error("KeyVariant not implemented"
+            + std::to_string((int)variant));
+        }
+
         auto promiseConstructor =
             runtime.global().getPropertyAsFunction(runtime, "Promise");
 
         auto promise = promiseConstructor.callAsConstructor(
             runtime,
             jsi::Function::createFromHostFunction(
-                runtime, jsi::PropNameID::forAscii(runtime, "executor"), 2,
-                [&jsCallInvoker, config](
+                runtime,
+                jsi::PropNameID::forAscii(runtime, "executor"),
+                4,
+                [&jsCallInvoker, variant, rsaConfig, ecConfig](
                     jsi::Runtime &runtime, const jsi::Value &,
                     const jsi::Value *promiseArgs, size_t) -> jsi::Value {
                   auto resolve =
@@ -54,19 +77,33 @@ FieldDefinition getGenerateKeyPairFieldDefinition(
                   auto reject =
                       std::make_shared<jsi::Value>(runtime, promiseArgs[1]);
 
-                  std::thread t([&runtime, resolve, reject,
-                                 jsCallInvoker, config]() {
+                  std::thread t([&runtime, resolve, reject, jsCallInvoker,
+                      variant, rsaConfig, ecConfig]() {
                     m.lock();
                     try {
-                      jsCallInvoker->invokeAsync([&runtime, config, resolve]() {
-                        auto keys = generateRSAKeyPair(runtime, config);
-                        auto publicKey = toJSI(runtime, keys.first);
-                        auto privateKey = toJSI(runtime, keys.second);
+                      jsCallInvoker->invokeAsync([&runtime, resolve,
+                          variant, rsaConfig, ecConfig]() {
+                        std::pair<jsi::Value, jsi::Value> keys;
+
+                        // switch on variant to get proper generateKeyPair
+                        if (variant == kvRSA_SSA_PKCS1_v1_5 ||
+                            variant == kvRSA_PSS ||
+                            variant == kvRSA_OAEP
+                        ) {
+                          keys = generateRsaKeyPair(runtime, rsaConfig);
+                        } else
+                        if (variant == kvEC) {
+                          keys = generateEcKeyPair(runtime, ecConfig);
+                        } else {
+                          throw std::runtime_error("KeyVariant not implemented"
+                            + std::to_string((int)variant));
+                        }
+
                         auto res = jsi::Array::createWithElements(
                           runtime,
                           jsi::Value::undefined(),
-                          publicKey,
-                          privateKey);
+                          keys.first,
+                          keys.second);
                         resolve->asObject(runtime).asFunction(runtime).call(
                             runtime, std::move(res));
                       });

package/cpp/Cipher/MGLGenerateKeyPairSyncInstaller.cpp

@@ -17,31 +17,47 @@
 #include "JSIUtils/MGLJSIMacros.h"
 #include "JSIUtils/MGLJSIUtils.h"
 #include "JSIUtils/MGLTypedArray.h"
+#include "webcrypto/crypto_ec.h"
 #else
 #include "MGLJSIMacros.h"
 #include "MGLJSIUtils.h"
 #include "MGLTypedArray.h"
+#include "crypto_ec.h"
 #endif
 
 using namespace facebook;
 
 namespace margelo {
 
-// Current implementation only supports RSA schemes (check line config.variant =
-// ) As more encryption schemes are added this will require an abstraction that
-// supports more schemes
 FieldDefinition getGenerateKeyPairSyncFieldDefinition(
     std::shared_ptr<react::CallInvoker> jsCallInvoker,
     std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
   return buildPair(
       "generateKeyPairSync", JSIF([=]) {
-        auto config = std::make_shared<RsaKeyPairGenConfig>(
-            prepareRsaKeyGenConfig(runtime, arguments));
-        auto keys = generateRSAKeyPair(runtime, std::move(config));
-        auto publicKey = toJSI(runtime, keys.first);
-        auto privateKey = toJSI(runtime, keys.second);
+        std::pair<jsi::Value, jsi::Value> keys;
+        KeyVariant variant =
+            static_cast<KeyVariant>((int)arguments[0].asNumber());
+
+        // switch on variant to get proper config/genKeyPair
+        if (variant == kvRSA_SSA_PKCS1_v1_5 ||
+            variant == kvRSA_PSS ||
+            variant == kvRSA_OAEP
+        ) {
+            auto config = std::make_shared<RsaKeyPairGenConfig>(
+                prepareRsaKeyGenConfig(runtime, arguments));
+            keys = generateRsaKeyPair(runtime, config);
+        } else
+        if (variant == kvEC) {
+            auto config = std::make_shared<EcKeyPairGenConfig>(
+            prepareEcKeyGenConfig(runtime, arguments));
+            keys = generateEcKeyPair(runtime, config);
+        } else {
+            throw std::runtime_error("KeyVariant not implemented: " +
+                std::to_string((int)variant));
+        }
+        // keys.first = publicKey   keys.second = privateKey
         return jsi::Array::createWithElements(
-            runtime, jsi::Value::undefined(), publicKey, privateKey);
+            runtime, jsi::Value::undefined(), keys.first, keys.second);
       });
 }
 }  // namespace margelo

package/cpp/Cipher/MGLRsa.cpp

@@ -7,9 +7,15 @@
 
 #include "MGLRsa.h"
 #ifdef ANDROID
+#include "Cipher/MGLPublicCipher.h"
 #include "JSIUtils/MGLJSIMacros.h"
+#include "JSIUtils/MGLJSIUtils.h"
+#include "Utils/MGLUtils.h"
 #else
+#include "MGLPublicCipher.h"
 #include "MGLJSIMacros.h"
+#include "MGLJSIUtils.h"
+#include "MGLUtils.h"
 #endif
 
 #include <string>
@@ -21,7 +27,7 @@ namespace jsi = facebook::jsi;
 
 EVPKeyCtxPointer setup(std::shared_ptr<RsaKeyPairGenConfig> config) {
   EVPKeyCtxPointer ctx(EVP_PKEY_CTX_new_id(
-      config->variant == kKeyVariantRSA_PSS ? EVP_PKEY_RSA_PSS : EVP_PKEY_RSA,
+      config->variant == kvRSA_PSS ? EVP_PKEY_RSA_PSS : EVP_PKEY_RSA,
       nullptr));
 
   if (EVP_PKEY_keygen_init(ctx.get()) <= 0) return EVPKeyCtxPointer();
@@ -43,7 +49,7 @@ EVPKeyCtxPointer setup(std::shared_ptr<RsaKeyPairGenConfig> config) {
     bn.release();
   }
 
-  if (config->variant == kKeyVariantRSA_PSS) {
+  if (config->variant == kvRSA_PSS) {
     if (config->md != nullptr &&
         EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx.get(), config->md) <= 0) {
       return EVPKeyCtxPointer();
@@ -94,12 +100,12 @@ RsaKeyPairGenConfig prepareRsaKeyGenConfig(jsi::Runtime& runtime,
   //    CHECK(args[*offset + 1]->IsUint32());  // Modulus bits
   //    CHECK(args[*offset + 2]->IsUint32());  // Exponent
   config.variant =
-      static_cast<RSAKeyVariant>((int)arguments[offset].asNumber());
+      static_cast<KeyVariant>((int)arguments[offset].asNumber());
 
   // TODO(osp)
-  //    CHECK_IMPLIES(params->params.variant != kKeyVariantRSA_PSS,
+  //    CHECK_IMPLIES(params->params.variant != kvRSA_PSS,
   //                  args.Length() == 10);
-  //    CHECK_IMPLIES(params->params.variant == kKeyVariantRSA_PSS,
+  //    CHECK_IMPLIES(params->params.variant == kvRSA_PSS,
   //                  args.Length() == 13);
   config.modulus_bits =
       static_cast<unsigned int>(arguments[offset + 1].asNumber());
@@ -107,7 +113,7 @@ RsaKeyPairGenConfig prepareRsaKeyGenConfig(jsi::Runtime& runtime,
 
   offset += 3;
 
-  if (config.variant == kKeyVariantRSA_PSS) {
+  if (config.variant == kvRSA_PSS) {
     if (!arguments[offset].isUndefined()) {
       // TODO(osp) CHECK(string)
       config.md = EVP_get_digestbyname(
@@ -153,8 +159,9 @@ RsaKeyPairGenConfig prepareRsaKeyGenConfig(jsi::Runtime& runtime,
   return config;
 }
 
-std::pair<JSVariant, JSVariant> generateRSAKeyPair(
+std::pair<jsi::Value, jsi::Value> generateRsaKeyPair(
     jsi::Runtime& runtime, std::shared_ptr<RsaKeyPairGenConfig> config) {
+  // TODO: this is all copied into crypto_ec.cpp - template it up like Node?
   CheckEntropy();
 
   EVPKeyCtxPointer ctx = setup(config);
@@ -171,18 +178,137 @@ std::pair<JSVariant, JSVariant> generateRSAKeyPair(
 
   config->key = ManagedEVPPKey(EVPKeyPointer(pkey));
 
-  OptionJSVariant publicBuffer =
+  jsi::Value publicBuffer =
       ManagedEVPPKey::ToEncodedPublicKey(runtime, std::move(config->key),
                                          config->public_key_encoding);
-  OptionJSVariant privateBuffer =
+  jsi::Value privateBuffer =
       ManagedEVPPKey::ToEncodedPrivateKey(runtime, std::move(config->key),
                                           config->private_key_encoding);
 
-  if (!publicBuffer.has_value() || !privateBuffer.has_value()) {
-    throw jsi::JSError(runtime, "Failed to encode public and/or private key");
+  if (publicBuffer.isUndefined() || privateBuffer.isUndefined()) {
+    throw jsi::JSError(runtime, "Failed to encode public and/or private key (RSA)");
   }
 
-  return {std::move(publicBuffer.value()), std::move(privateBuffer.value())};
+  return {std::move(publicBuffer), std::move(privateBuffer)};
+}
+
+template <MGLPublicCipher::EVP_PKEY_cipher_init_t init,
+          MGLPublicCipher::EVP_PKEY_cipher_t cipher>
+WebCryptoCipherStatus RSA_Cipher(const RSACipherConfig& params, ByteSource* out) {
+  CHECK_NE(params.key->GetKeyType(), kKeyTypeSecret);
+  ManagedEVPPKey m_pkey = params.key->GetAsymmetricKey();
+  // Mutex::ScopedLock lock(*m_pkey.mutex());
+
+  EVPKeyCtxPointer ctx(EVP_PKEY_CTX_new(m_pkey.get(), nullptr));
+
+  if (!ctx || init(ctx.get()) <= 0)
+    return WebCryptoCipherStatus::FAILED;
+
+  if (EVP_PKEY_CTX_set_rsa_padding(ctx.get(), params.padding) <= 0) {
+    return WebCryptoCipherStatus::FAILED;
+  }
+
+  if (params.digest != nullptr &&
+      (EVP_PKEY_CTX_set_rsa_oaep_md(ctx.get(), params.digest) <= 0 ||
+       EVP_PKEY_CTX_set_rsa_mgf1_md(ctx.get(), params.digest) <= 0)) {
+    return WebCryptoCipherStatus::FAILED;
+  }
+
+  if (!SetRsaOaepLabel(ctx, params.label)) return WebCryptoCipherStatus::FAILED;
+
+  size_t out_len = 0;
+  if (cipher(
+          ctx.get(),
+          nullptr,
+          &out_len,
+          params.data.data<unsigned char>(),
+          params.data.size()) <= 0) {
+    return WebCryptoCipherStatus::FAILED;
+  }
+
+  ByteSource::Builder buf(out_len);
+
+  if (cipher(ctx.get(),
+             buf.data<unsigned char>(),
+             &out_len,
+             params.data.data<unsigned char>(),
+             params.data.size()) <= 0) {
+    return WebCryptoCipherStatus::FAILED;
+  }
+
+  *out = std::move(buf).release(out_len);
+  return WebCryptoCipherStatus::OK;
+}
+
+RSACipherConfig RSACipher::GetParamsFromJS(jsi::Runtime &rt,
+                                          const jsi::Value *args) {
+  RSACipherConfig params;
+  unsigned int offset = 0;
+
+  // padding
+  params.padding = RSA_PKCS1_OAEP_PADDING;
+
+  // mode (encrypt/decrypt)
+  params.mode = static_cast<WebCryptoCipherMode>((int)args[offset].getNumber());
+  offset++;
+
+  // key (handle)
+  if (!args[offset].isObject()) {
+    throw std::runtime_error("arg is not a KeyObjectHandle: key");
+  }
+  std::shared_ptr<KeyObjectHandle> handle =
+    std::static_pointer_cast<KeyObjectHandle>(
+      args[offset].asObject(rt).getHostObject(rt));
+  params.key = handle->Data();
+  offset++;
+
+  // data
+  params.data = GetByteSourceFromJS(rt, args[offset], "data");
+  offset++;
+
+  // variant
+  if (CheckIsInt32(args[offset])) {
+    params.variant = static_cast<RSAKeyVariant>((int)args[offset].getNumber());
+  }
+  // offset++; // The below variant-dependent params advance offset themselves
+
+  std::string digest;
+  switch (params.variant) {
+    case kKeyVariantRSA_OAEP:
+      // hash (digest)
+      CHECK(args[offset + 1].isString());
+      digest = args[offset + 1].asString(rt).utf8(rt);
+      params.digest = EVP_get_digestbyname(digest.c_str());
+      if (params.digest == nullptr) {
+        throw jsi::JSError(rt, "invalid digest: " + digest);
+        return params;
+      }
+
+      // label
+      if (args[offset + 2].isUndefined()) {
+        params.label = ByteSource();
+      } else {
+        params.label = GetByteSourceFromJS(rt, args[offset + 2], "label");
+      }
+
+      break;
+    default:
+      throw jsi::JSError(rt, "Invalid RSA key variant");
+  }
+
+  return params;
+}
+
+WebCryptoCipherStatus RSACipher::DoCipher(const RSACipherConfig &params,
+                                          ByteSource *out) {
+  switch (params.mode) {
+    case kEncrypt:
+      CHECK_EQ(params.key->GetKeyType(), kKeyTypePublic);
+      return RSA_Cipher<EVP_PKEY_encrypt_init, EVP_PKEY_encrypt>(params, out);
+    case kDecrypt:
+      CHECK_EQ(params.key->GetKeyType(), kKeyTypePrivate);
+      return RSA_Cipher<EVP_PKEY_decrypt_init, EVP_PKEY_decrypt>(params, out);
+  }
 }
 
 jsi::Value ExportJWKRsaKey(jsi::Runtime &rt,
@@ -329,12 +455,11 @@ jsi::Value GetRsaKeyDetail(jsi::Runtime &rt,
   RSA_get0_key(rsa, &n, &e, nullptr);
 
   size_t modulus_length = BN_num_bits(n);
-  // TODO: should this be modulusLength or n?
   target.setProperty(rt, "modulusLength", static_cast<double>(modulus_length));
 
   size_t exp_size = BN_num_bytes(e);
-  // TODO: should this be publicExponent or e?
-  target.setProperty(rt, "publicExponent", EncodeBignum(e, exp_size, true));
+  ByteSource public_exponent = ByteSource::FromBN(e, exp_size);
+  target.setProperty(rt, "publicExponent", toJSI(rt, std::move(public_exponent)));
 
   if (type == EVP_PKEY_RSA_PSS) {
     // Due to the way ASN.1 encoding works, default values are omitted when
@@ -393,4 +518,56 @@ jsi::Value GetRsaKeyDetail(jsi::Runtime &rt,
   return target;
 }
 
+bool RsaKeyExport::GetParamsFromJS(jsi::Runtime &rt, const jsi::Value *args) {
+  RsaKeyExportConfig params;
+  unsigned int offset = 0;
+
+  // format
+  params.format = static_cast<WebCryptoKeyFormat>((int)args[offset].getNumber());
+  offset++;
+
+  // key
+  std::shared_ptr<KeyObjectHandle> handle =
+    std::static_pointer_cast<KeyObjectHandle>(
+      args[1].asObject(rt).getHostObject(rt));
+  params.key_ = handle->Data();
+  offset++;
+
+  // variant
+  params.variant = static_cast<KeyVariant>((int)args[offset].getNumber());
+  offset++;
+
+  this->params_ = std::move(params);
+  return true;
+}
+
+WebCryptoKeyExportStatus RsaKeyExport::DoExport(ByteSource* out) {
+  auto key_data = this->params_.key_;
+  CHECK_NE(key_data->GetKeyType(), kKeyTypeSecret);
+
+  switch (this->params_.format) {
+    case kWebCryptoKeyFormatRaw:
+      throw std::runtime_error("Raw format not supported for RSA keys");
+      return WebCryptoKeyExportStatus::FAILED;
+    case kWebCryptoKeyFormatJWK:
+      throw std::runtime_error("JWK format not handled in C++ for RSA keys");
+      return WebCryptoKeyExportStatus::FAILED;
+    case kWebCryptoKeyFormatPKCS8:
+      if (key_data->GetKeyType() != kKeyTypePrivate) {
+        throw std::runtime_error("Invalid key type for PKCS8 export");
+        return WebCryptoKeyExportStatus::INVALID_KEY_TYPE;
+      }
+      return PKEY_PKCS8_Export(key_data.get(), out);
+    case kWebCryptoKeyFormatSPKI:
+      if (key_data->GetKeyType() != kKeyTypePublic) {
+        throw std::runtime_error("Invalid key type for SPKI export");
+        return WebCryptoKeyExportStatus::INVALID_KEY_TYPE;
+      }
+      return PKEY_SPKI_Export(key_data.get(), out);
+    default:
+      throw std::runtime_error("Unrecognized format for RSA key export");
+      return WebCryptoKeyExportStatus::FAILED;
+  }
+}
+
 }  // namespace margelo

package/cpp/Cipher/MGLRsa.h

@@ -25,6 +25,7 @@ namespace margelo {
 
 namespace jsi = facebook::jsi;
 
+// TODO: keep in in sync with JS side (src/rsa.ts)
 enum RSAKeyVariant {
   kKeyVariantRSA_SSA_PKCS1_v1_5,
   kKeyVariantRSA_PSS,
@@ -43,7 +44,7 @@ struct RsaKeyPairGenConfig {
   PrivateKeyEncodingConfig private_key_encoding;
   ManagedEVPPKey key;
 
-  RSAKeyVariant variant;
+  KeyVariant variant;
   unsigned int modulus_bits;
   unsigned int exponent;
 
@@ -57,7 +58,7 @@ struct RsaKeyPairGenConfig {
 RsaKeyPairGenConfig prepareRsaKeyGenConfig(jsi::Runtime& runtime,
                                          const jsi::Value* arguments);
 
-std::pair<JSVariant, JSVariant> generateRSAKeyPair(
+std::pair<jsi::Value, jsi::Value> generateRsaKeyPair(
     jsi::Runtime& runtime, std::shared_ptr<RsaKeyPairGenConfig> config);
 
 jsi::Value ExportJWKRsaKey(jsi::Runtime &rt,
@@ -70,6 +71,39 @@ std::shared_ptr<KeyObjectData> ImportJWKRsaKey(jsi::Runtime &rt,
 jsi::Value GetRsaKeyDetail(jsi::Runtime &rt,
                            std::shared_ptr<KeyObjectData> key);
 
+struct RsaKeyExportConfig final {
+  WebCryptoKeyFormat format;
+  std::shared_ptr<KeyObjectData> key_;
+  KeyVariant variant;
+};
+
+class RsaKeyExport {
+ public:
+  bool GetParamsFromJS(jsi::Runtime &rt, const jsi::Value *args);
+  WebCryptoKeyExportStatus DoExport(ByteSource* out);
+ private:
+  RsaKeyExportConfig params_;
+};
+
+struct RSACipherConfig final {
+  WebCryptoCipherMode mode;
+  std::shared_ptr<KeyObjectData> key;
+  ByteSource data;
+  RSAKeyVariant variant;
+  ByteSource label;
+  int padding = 0;
+  const EVP_MD* digest = nullptr;
+
+  RSACipherConfig() = default;
+};
+
+class RSACipher {
+ public:
+  RSACipher() {}
+  RSACipherConfig GetParamsFromJS(jsi::Runtime &rt, const jsi::Value *args);
+  WebCryptoCipherStatus DoCipher(const RSACipherConfig &params, ByteSource *out);
+};
+
 }  // namespace margelo
 
 #endif /* MGLRsa_hpp */

package/cpp/JSIUtils/MGLJSIUtils.h

@@ -9,6 +9,7 @@
 #define MGLJSIUtils_h
 
 #include <jsi/jsi.h>
+#include <limits>
 
 namespace jsi = facebook::jsi;
 
@@ -21,4 +22,20 @@ inline bool CheckSizeInt32(jsi::Runtime &runtime, jsi::ArrayBuffer &buffer) {
   return buffer.size(runtime) <= INT_MAX;
 }
 
+inline bool CheckIsInt32(const jsi::Value &value) {
+  if (!value.isNumber()) {
+    return false;
+  }
+  double d = value.asNumber();
+  return (d >= std::numeric_limits<int32_t>::lowest() && d <= std::numeric_limits<int32_t>::max());
+}
+
+inline bool CheckIsUint32(const jsi::Value &value) {
+  if (!value.isNumber()) {
+    return false;
+  }
+  double d = value.asNumber();
+  return (d >= std::numeric_limits<uint32_t>::lowest() && d <= std::numeric_limits<uint32_t>::max());
+}
+
 #endif /* MGLJSIUtils_h */