react-native-quick-crypto 0.7.3 → 1.0.0-beta.1

package/cpp/MGLKeys.h

@@ -1,203 +0,0 @@
-//
-//  MGLCipherKeys.h
-//  react-native-quick-crypto
-//
-//  Created by Oscar on 20.06.22.
-//
-
-#ifndef MGLCipherKeys_h
-#define MGLCipherKeys_h
-
-#include <jsi/jsi.h>
-#include <openssl/evp.h>
-
-#include <memory>
-#include <optional>
-#include <string>
-
-#ifdef ANDROID
-#include "Utils/MGLUtils.h"
-#include "JSIUtils/MGLSmartHostObject.h"
-#else
-#include "MGLUtils.h"
-#include "MGLSmartHostObject.h"
-#endif
-
-// This file should roughly match https://github.com/nodejs/node/blob/main/src/crypto/crypto_keys.cc
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-enum PKEncodingType {
-  // RSAPublicKey / RSAPrivateKey according to PKCS#1.
-  kKeyEncodingPKCS1,
-  // PrivateKeyInfo or EncryptedPrivateKeyInfo according to PKCS#8.
-  kKeyEncodingPKCS8,
-  // SubjectPublicKeyInfo according to X.509.
-  kKeyEncodingSPKI,
-  // ECPrivateKey according to SEC1.
-  kKeyEncodingSEC1
-};
-
-enum PKFormatType { kKeyFormatDER, kKeyFormatPEM, kKeyFormatJWK };
-
-enum KeyType { kKeyTypeSecret, kKeyTypePublic, kKeyTypePrivate };
-
-enum KeyEncodingContext {
-  kKeyContextInput,
-  kKeyContextExport,
-  kKeyContextGenerate
-};
-
-enum class ParseKeyResult {
-  kParseKeyOk,
-  kParseKeyNotRecognized,
-  kParseKeyNeedPassphrase,
-  kParseKeyFailed
-};
-
-enum class WebCryptoKeyExportStatus {
-  OK,
-  INVALID_KEY_TYPE,
-  FAILED
-};
-
-struct AsymmetricKeyEncodingConfig {
-  bool output_key_object_ = false;
-  PKFormatType format_ = kKeyFormatDER;
-  std::optional<PKEncodingType> type_ = std::nullopt;
-};
-
-using PublicKeyEncodingConfig = AsymmetricKeyEncodingConfig;
-
-struct PrivateKeyEncodingConfig : public AsymmetricKeyEncodingConfig {
-  const EVP_CIPHER *cipher_;
-  // The ByteSource alone is not enough to distinguish between "no passphrase"
-  // and a zero-length passphrase (which can be a null pointer), therefore, we
-  // use a NonCopyableMaybe.
-  NonCopyableMaybe<ByteSource> passphrase_;
-};
-
-// Here node uses extends MemoryRetainer no clue what that is, something with
-// Snapshots stripped it for our implementation but if something doesn't work,
-// you know why
-class ManagedEVPPKey {
- public:
-  ManagedEVPPKey() {}
-  explicit ManagedEVPPKey(EVPKeyPointer &&pkey);
-  ManagedEVPPKey(const ManagedEVPPKey &that);
-  ManagedEVPPKey &operator=(const ManagedEVPPKey &that);
-
-  operator bool() const;
-  EVP_PKEY *get() const;
-
-  static PublicKeyEncodingConfig GetPublicKeyEncodingFromJs(
-      jsi::Runtime &runtime, const jsi::Value *arguments, unsigned int *offset,
-      KeyEncodingContext context);
-
-  static NonCopyableMaybe<PrivateKeyEncodingConfig> GetPrivateKeyEncodingFromJs(
-      jsi::Runtime &runtime, const jsi::Value *arguments, unsigned int *offset,
-      KeyEncodingContext context);
-  //
-  static ManagedEVPPKey GetParsedKey(jsi::Runtime &runtime,
-                                     EVPKeyPointer &&pkey,
-                                     ParseKeyResult ret,
-                                     const char *default_msg);
-
-  static ManagedEVPPKey GetPublicOrPrivateKeyFromJs(jsi::Runtime &runtime,
-                                                    const jsi::Value *args,
-                                                    unsigned int *offset);
-
-  static ManagedEVPPKey GetPrivateKeyFromJs(jsi::Runtime &runtime,
-                                            const jsi::Value *args,
-                                            unsigned int *offset,
-                                            bool allow_key_object);
-
-  static jsi::Value ToEncodedPublicKey(jsi::Runtime &runtime,
-                                       ManagedEVPPKey key,
-                                       const PublicKeyEncodingConfig &config);
-
-  static jsi::Value ToEncodedPrivateKey(jsi::Runtime &runtime,
-                                        ManagedEVPPKey key,
-                                        const PrivateKeyEncodingConfig &config);
-
- private:
-   size_t size_of_private_key() const;
-   size_t size_of_public_key() const;
-
-  EVPKeyPointer pkey_;
-};
-
-// Analogous to the KeyObjectData class on node
-// https://github.com/nodejs/node/blob/main/src/crypto/crypto_keys.h#L132
-class KeyObjectData {
- public:
-  static std::shared_ptr<KeyObjectData> CreateSecret(ByteSource key);
-
-  static std::shared_ptr<KeyObjectData> CreateAsymmetric(
-      KeyType type,
-      const ManagedEVPPKey& pkey);
-
-  KeyType GetKeyType() const;
-
-  // These functions allow unprotected access to the raw key material and should
-  // only be used to implement cryptographic operations requiring the key.
-  ManagedEVPPKey GetAsymmetricKey() const;
-  std::string GetSymmetricKey() const;
-  size_t GetSymmetricKeySize() const;
-
- private:
- explicit KeyObjectData(ByteSource symmetric_key);
-
-  KeyObjectData(
-      KeyType type,
-      const ManagedEVPPKey& pkey);
-
-  const KeyType key_type_;
-  const ByteSource symmetric_key_;
-  const size_t symmetric_key_len_;
-  const ManagedEVPPKey asymmetric_key_;
-};
-
-// Analogous to the KeyObjectHandle class in node
-// https://github.com/nodejs/node/blob/main/src/crypto/crypto_keys.h#L164
-class JSI_EXPORT KeyObjectHandle: public jsi::HostObject {
- public:
-    KeyObjectHandle() {}
-    jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
-    const std::shared_ptr<KeyObjectData>& Data();
-
-    static std::shared_ptr<KeyObjectHandle> Create(std::shared_ptr<KeyObjectData> data);
-
- protected:
-    jsi::Value Export(jsi::Runtime &rt);
-    jsi::Value ExportJWK(jsi::Runtime &rt);
-    jsi::Value ExportPublicKey(
-      jsi::Runtime& rt,
-      const PublicKeyEncodingConfig& config) const;
-    jsi::Value ExportPrivateKey(
-      jsi::Runtime& rt,
-      const PrivateKeyEncodingConfig& config) const;
-    jsi::Value ExportSecretKey(jsi::Runtime& rt) const;
-    jsi::Value GetKeyDetail(jsi::Runtime &rt);
-    jsi::Value GetAsymmetricKeyType(jsi::Runtime &rt) const;
-    jsi::Value Init(jsi::Runtime &rt);
-    jsi::Value InitECRaw(jsi::Runtime &rt);
-    jsi::Value InitJWK(jsi::Runtime &rt);
-
- private:
-    std::shared_ptr<KeyObjectData> data_;
-};
-
-WebCryptoKeyExportStatus PKEY_SPKI_Export(
-    KeyObjectData* key_data,
-    ByteSource* out);
-
-WebCryptoKeyExportStatus PKEY_PKCS8_Export(
-    KeyObjectData* key_data,
-    ByteSource* out);
-
-}  // namespace margelo
-
-#endif /* MGLCipherKeys_h */

package/cpp/MGLQuickCryptoHostObject.cpp

@@ -1,127 +0,0 @@
-// Copyright 2022 Margelo
-#include "MGLQuickCryptoHostObject.h"
-
-#include <ReactCommon/TurboModuleUtils.h>
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#ifdef ANDROID
-#include "Cipher/MGLCreateCipherInstaller.h"
-#include "Cipher/MGLCreateDecipherInstaller.h"
-#include "Cipher/MGLGenerateKeyPairInstaller.h"
-#include "Cipher/MGLGenerateKeyPairSyncInstaller.h"
-#include "Cipher/MGLPublicCipher.h"
-#include "Cipher/MGLPublicCipherInstaller.h"
-#include "HMAC/MGLHmacInstaller.h"
-#include "Hash/MGLHashInstaller.h"
-#include "Random/MGLRandomHostObject.h"
-#include "Sig/MGLSignInstaller.h"
-#include "Sig/MGLVerifyInstaller.h"
-#include "fastpbkdf2/MGLPbkdf2HostObject.h"
-#include "webcrypto/MGLWebCrypto.h"
-#else
-#include "MGLCreateCipherInstaller.h"
-#include "MGLCreateDecipherInstaller.h"
-#include "MGLGenerateKeyPairInstaller.h"
-#include "MGLGenerateKeyPairSyncInstaller.h"
-#include "MGLHashInstaller.h"
-#include "MGLHmacInstaller.h"
-#include "MGLPbkdf2HostObject.h"
-#include "MGLPublicCipher.h"
-#include "MGLPublicCipherInstaller.h"
-#include "MGLRandomHostObject.h"
-#include "MGLSignInstaller.h"
-#include "MGLVerifyInstaller.h"
-#include "MGLWebCrypto.h"
-#endif
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-MGLQuickCryptoHostObject::MGLQuickCryptoHostObject(
-    std::shared_ptr<react::CallInvoker> jsCallInvoker,
-    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
-    : MGLSmartHostObject(jsCallInvoker, workerQueue) {
-  // HmacInstaller
-  this->fields.push_back(getHmacFieldDefinition(jsCallInvoker, workerQueue));
-
-  // HashInstaller
-  this->fields.push_back(getHashFieldDefinition(jsCallInvoker, workerQueue));
-
-  // createCipher
-  this->fields.push_back(
-      getCreateCipherFieldDefinition(jsCallInvoker, workerQueue));
-
-  // createDecipher
-  this->fields.push_back(
-      getCreateDecipherFieldDefinition(jsCallInvoker, workerQueue));
-
-  // publicEncrypt
-  this->fields.push_back(
-      getPublicCipherFieldDefinition<MGLPublicCipher::kPublic,
-                                    EVP_PKEY_encrypt_init,
-                                    EVP_PKEY_encrypt>(
-          "publicEncrypt", jsCallInvoker, workerQueue));
-
-  // privateDecrypt
-  this->fields.push_back(
-      getPublicCipherFieldDefinition<MGLPublicCipher::kPrivate,
-                                    EVP_PKEY_decrypt_init,
-                                    EVP_PKEY_decrypt>(
-          "privateDecrypt", jsCallInvoker, workerQueue));
-
-  // privateEncrypt
-  this->fields.push_back(
-      getPublicCipherFieldDefinition<MGLPublicCipher::kPrivate,
-                                    EVP_PKEY_sign_init,
-                                    EVP_PKEY_sign>(
-          "privateEncrypt", jsCallInvoker, workerQueue));
-
-  // publicDecrypt
-  this->fields.push_back(
-      getPublicCipherFieldDefinition<MGLPublicCipher::kPublic,
-                                    EVP_PKEY_verify_recover_init,
-                                    EVP_PKEY_verify_recover>(
-          "publicDecrypt", jsCallInvoker, workerQueue));
-
-  // generateKeyPair
-  this->fields.push_back(
-      getGenerateKeyPairFieldDefinition(jsCallInvoker, workerQueue));
-
-  // generateKeyPairSync
-  this->fields.push_back(
-      getGenerateKeyPairSyncFieldDefinition(jsCallInvoker, workerQueue));
-
-  // Pbkdf2HostObject
-  this->fields.push_back(JSI_VALUE("pbkdf2", {
-    auto hostObject =
-        std::make_shared<MGLPbkdf2HostObject>(jsCallInvoker, workerQueue);
-    return jsi::Object::createFromHostObject(runtime, hostObject);
-  }));
-
-  // RandomHostObject
-  this->fields.push_back(JSI_VALUE("random", {
-    auto hostObject =
-        std::make_shared<MGLRandomHostObject>(jsCallInvoker, workerQueue);
-    return jsi::Object::createFromHostObject(runtime, hostObject);
-  }));
-
-  // createSign
-  this->fields.push_back(getSignFieldDefinition(jsCallInvoker, workerQueue));
-
-  // createVerify
-  this->fields.push_back(getVerifyFieldDefinition(jsCallInvoker, workerQueue));
-
-  // subtle API
-  this->fields.push_back(JSI_VALUE("webcrypto", {
-    auto hostObject = std::make_shared<MGLWebCryptoHostObject>(
-        jsCallInvoker, workerQueue);
-    return jsi::Object::createFromHostObject(runtime, hostObject);
-  }));
-}
-
-}  // namespace margelo

package/cpp/MGLQuickCryptoHostObject.h

@@ -1,30 +0,0 @@
-// Copyright 2022 Margelo
-#ifndef CPP_FASTCRYPTOHOSTOBJECT_H_
-#define CPP_FASTCRYPTOHOSTOBJECT_H_
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-
-#include <memory>
-
-#include "JSIUtils/MGLSmartHostObject.h"
-#include "JSIUtils/MGLTypedArray.h"
-#include "Utils/MGLDispatchQueue.h"
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-namespace react = facebook::react;
-
-class JSI_EXPORT MGLQuickCryptoHostObject : public MGLSmartHostObject {
- public:
-  explicit MGLQuickCryptoHostObject(
-      std::shared_ptr<react::CallInvoker> jsCallInvoker,
-      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
-
-  virtual ~MGLQuickCryptoHostObject() { invalidateJsiPropNameIDCache(); }
-};
-
-}  // namespace margelo
-
-#endif  // CPP_FASTCRYPTOHOSTOBJECT_H_

package/cpp/Random/MGLRandomHostObject.cpp

@@ -1,96 +0,0 @@
-//
-// Created by Szymon on 25/02/2022.
-//
-
-#include "MGLRandomHostObject.h"
-
-#ifdef ANDROID
-#include "JSIUtils/MGLTypedArray.h"
-#else
-#include "MGLTypedArray.h"
-#endif
-#include <openssl/bn.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>
-
-#include <memory>
-#include <utility>
-
-namespace margelo {
-namespace jsi = facebook::jsi;
-namespace react = facebook::react;
-
-MGLRandomHostObject::MGLRandomHostObject(
-    std::shared_ptr<react::CallInvoker> jsCallInvoker,
-    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
-    : MGLSmartHostObject(jsCallInvoker, workerQueue) {
-  this->fields.push_back(buildPair(
-      "randomFill", JSIF([=]) {
-        if (count != 3) {
-          throw jsi::JSError(runtime,
-                             "randomFill(..) expects exactly 4 arguments!");
-        }
-          
-      if(!arguments[0].isObject() || !arguments[0].asObject(runtime).isArrayBuffer(runtime)) {
-          throw std::runtime_error("First argument it not an array buffer");
-      }
-
-      if (!arguments[0].isObject()
-        || !arguments[0].asObject(runtime).isArrayBuffer(runtime)) {
-          throw std::runtime_error("First argument it not an array buffer");
-      }
-
-        auto result = arguments[0].asObject(runtime).getArrayBuffer(runtime);
-        auto *resultData = result.data(runtime);
-        auto resultPreventGC =
-            std::make_shared<jsi::ArrayBuffer>(std::move(result));
-
-        auto offset = (int)arguments[1].asNumber();
-        auto size = arguments[2].asNumber();
-
-        return react::createPromiseAsJSIValue(
-            runtime, [=](jsi::Runtime &runtime,
-                         std::shared_ptr<react::Promise> promise) {
-              // TODO(Szymon) implement check prime once we have bignums
-              this->runOnWorkerThread([=]() {
-                if (RAND_bytes(resultData + offset, size) != 1) {
-                  this->runOnJSThread([=]() {
-                    promise->reject("Sth went wrong with RAND_bytes");
-                  });
-                }
-                this->runOnJSThread([=]() {
-                  promise->resolve(
-                      jsi::ArrayBuffer(std::move(*resultPreventGC)));
-                });
-              });
-            });
-      }));
-
-  this->fields.push_back(buildPair(
-      "randomFillSync", JSIF([=]) {
-        if (count != 3) {
-          throw jsi::JSError(runtime,
-                             "randomFillSync(..) expects exactly 4 arguments!");
-        }
-
-        auto result = arguments[0].asObject(runtime).getArrayBuffer(runtime);
-        auto *resultData = result.data(runtime);
-        auto offset = (int)arguments[1].asNumber();
-        auto size = arguments[2].asNumber();
-
-        if (RAND_bytes(resultData + offset, size) != 1) {
-          throw jsi::JSError(runtime, "Sth went wrong with RAND_bytes" +
-                                          std::to_string(ERR_get_error()));
-        }
-
-        return result;
-      }));
-}
-
-}  // namespace margelo

package/cpp/Random/MGLRandomHostObject.h

@@ -1,27 +0,0 @@
-//
-// Created by Szymon on 25/02/2022.
-//
-
-#ifndef MGL_RANDOMHOSTOBJECT_H
-#define MGL_RANDOMHOSTOBJECT_H
-
-#include <memory>
-
-#ifdef ANDROID
-#include "JSIUtils/MGLSmartHostObject.h"
-#else
-#include "MGLSmartHostObject.h"
-#endif
-
-namespace margelo {
-namespace jsi = facebook::jsi;
-
-class MGLRandomHostObject : public MGLSmartHostObject {
- public:
-  MGLRandomHostObject(
-      std::shared_ptr<react::CallInvoker> jsCallInvoker,
-      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
-};
-
-}  // namespace margelo
-#endif  // MGL_RANDOMHOSTOBJECT_H