feat: add more KeyObjectHandle implementation

Author: boorad

bun.lock

@@ -39,6 +39,7 @@ target 'QuickCryptoExample' do
     installer.pods_project.targets.each do |target|
       target.build_configurations.each do |config|
         config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '16.0'
+        config.build_settings['CLANG_CXX_LANGUAGE_STANDARD'] = 'c++20'
       end
     end
   end

example/ios/Podfile

@@ -1752,7 +1752,7 @@ DEPENDENCIES:
   - fmt (from `../../node_modules/react-native/third-party-podspecs/fmt.podspec`)
   - glog (from `../../node_modules/react-native/third-party-podspecs/glog.podspec`)
   - hermes-engine (from `../../node_modules/react-native/sdks/hermes-engine/hermes-engine.podspec`)
-  - NitroModules (from `../../node_modules/react-native-nitro-modules`)
+  - NitroModules (from `../node_modules/react-native-nitro-modules`)
   - QuickCrypto (from `../../node_modules/react-native-quick-crypto`)
   - RCT-Folly (from `../../node_modules/react-native/third-party-podspecs/RCT-Folly.podspec`)
   - RCT-Folly/Fabric (from `../../node_modules/react-native/third-party-podspecs/RCT-Folly.podspec`)
@@ -1840,7 +1840,7 @@ EXTERNAL SOURCES:
     :podspec: "../../node_modules/react-native/sdks/hermes-engine/hermes-engine.podspec"
     :tag: hermes-2024-11-12-RNv0.76.2-5b4aa20c719830dcf5684832b89a6edb95ac3d64
   NitroModules:
-    :path: "../../node_modules/react-native-nitro-modules"
+    :path: "../node_modules/react-native-nitro-modules"
   QuickCrypto:
     :path: "../../node_modules/react-native-quick-crypto"
   RCT-Folly:
@@ -2040,6 +2040,6 @@ SPEC CHECKSUMS:
   SocketRocket: d4aabe649be1e368d1318fdf28a022d714d65748
   Yoga: feb4910aba9742cfedc059e2b2902e22ffe9954a
 
-PODFILE CHECKSUM: 63c4c1ca9d3ee6394f468b17e19efd3e548b5357
+PODFILE CHECKSUM: 7f292eb16e0483a44b89e782c3639f979b8ad29c
 
 COCOAPODS: 1.15.2

example/ios/Podfile.lock

@@ -0,0 +1,50 @@
+CompileFlags:
+  Add: 
+    - -std=c++20
+    - -Wall
+    - -Wextra
+    # Project includes
+    - -I${COMPILE_COMMANDS_DIR}/cpp
+    - -I${COMPILE_COMMANDS_DIR}/cpp/cipher
+    - -I${COMPILE_COMMANDS_DIR}/cpp/ed25519
+    - -I${COMPILE_COMMANDS_DIR}/cpp/hash
+    - -I${COMPILE_COMMANDS_DIR}/cpp/hmac
+    - -I${COMPILE_COMMANDS_DIR}/cpp/keys
+    - -I${COMPILE_COMMANDS_DIR}/cpp/pbkdf2
+    - -I${COMPILE_COMMANDS_DIR}/cpp/random
+    - -I${COMPILE_COMMANDS_DIR}/cpp/utils
+    - -I${COMPILE_COMMANDS_DIR}/deps/fastpbkdf2
+    - -I${COMPILE_COMMANDS_DIR}/deps/ncrypto/include
+    # Nitrogen generated includes
+    - -I${COMPILE_COMMANDS_DIR}/nitrogen/generated/shared/c++
+    - -I${COMPILE_COMMANDS_DIR}/nitrogen/generated/android/c++
+    - -I${COMPILE_COMMANDS_DIR}/nitrogen/generated/android
+    # React Native includes
+    - -I${COMPILE_COMMANDS_DIR}/node_modules/react-native/ReactAndroid/src/main/jni/first-party/fbjni/headers
+    - -I${COMPILE_COMMANDS_DIR}/node_modules/react-native/ReactCommon
+    - -I${COMPILE_COMMANDS_DIR}/node_modules/react-native/ReactCommon/jsi
+    - -I${COMPILE_COMMANDS_DIR}/node_modules/react-native/ReactCommon/callinvoker
+    - -I${COMPILE_COMMANDS_DIR}/node_modules/react-native/ReactCommon/react/nativemodule/core
+    - -I${COMPILE_COMMANDS_DIR}/node_modules/react-native/ReactAndroid/src/main/jni/react/turbomodule
+    # Nitro modules
+    - -I${COMPILE_COMMANDS_DIR}/node_modules/react-native-nitro-modules/cpp
+    # OpenSSL
+    - -I/opt/homebrew/include
+  Remove: [-W*, -std=*]
+
+Diagnostics:
+  UnusedIncludes: Strict
+  Suppress: 
+    - unused-includes
+    - unknown-warning-option
+
+Index:
+  Background: Build
+
+InlayHints:
+  Enabled: Yes
+  ParameterNames: Yes
+  DeducedTypes: Yes
+
+Hover:
+  ShowAKA: Yes

packages/react-native-quick-crypto/.clangd

@@ -2,3 +2,6 @@
 README.md
 
 ios/**
+
+.cache/**
+build-clangd/**

packages/react-native-quick-crypto/.gitignore

@@ -39,6 +39,7 @@ include_directories(
   "../cpp/random"
   "../cpp/utils"
   "../deps/fastpbkdf2"
+  "../deps/ncrypto"
 )
 
 # Third party libraries (Prefabs)

packages/react-native-quick-crypto/android/CMakeLists.txt

@@ -1,7 +1,8 @@
-#include "HybridKeyObjectHandle.hpp"
-
 #include <stdexcept>
 
+#include "HybridKeyObjectHandle.hpp"
+#include "Utils.hpp"
+
 namespace margelo::nitro::crypto {
 
 std::shared_ptr<ArrayBuffer> HybridKeyObjectHandle::exportKey(std::optional<KFormatType> format, std::optional<KeyEncoding> type,
@@ -21,7 +22,33 @@ CFRGKeyPairType HybridKeyObjectHandle::getAsymmetricKeyType() {
 bool HybridKeyObjectHandle::init(KeyType keyType, const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key,
                                  std::optional<KFormatType> format, std::optional<KeyEncoding> type,
                                  const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
-  throw std::runtime_error("Not yet implemented");
+  // get ArrayBuffer from key
+  std::shared_ptr<ArrayBuffer> ab;
+  if (std::holds_alternative<std::string>(key)) {
+    ab = ToNativeArrayBuffer(std::get<std::string>(key));
+  } else {
+    ab = std::get<std::shared_ptr<ArrayBuffer>>(key);
+  }
+
+  switch (keyType) {
+    case KeyType::SECRET: {
+      this->data_ = KeyObjectData::CreateSecret(ab);
+      break;
+    }
+    case KeyType::PUBLIC: {
+      auto data = KeyObjectData::GetPublicOrPrivateKey(ab, format, type, passphrase);
+      if (!data) return false;
+      this->data_ = data.addRefWithType(KeyType::PUBLIC);
+      break;
+    }
+    case KeyType::PRIVATE: {
+      if (auto data = KeyObjectData::GetPrivateKey(ab, format, type, passphrase, false)) {
+        this->data_ = std::move(data);
+      }
+      break;
+    }
+  }
+  return true;
 }
 
 bool HybridKeyObjectHandle::initECRaw(const std::string& curveName, const std::shared_ptr<ArrayBuffer>& keyData) {

packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.cpp

@@ -7,12 +7,12 @@
 #include "HybridKeyObjectHandleSpec.hpp"
 #include "JWK.hpp"
 #include "KeyDetail.hpp"
+#include "KeyObjectData.hpp"
+#include "KeyType.hpp"
 #include "NamedCurve.hpp"
 
 namespace margelo::nitro::crypto {
 
-using namespace facebook;
-
 class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec {
  public:
   HybridKeyObjectHandle() : HybridObject(TAG) {}
@@ -21,13 +21,22 @@ class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec {
   std::shared_ptr<ArrayBuffer> exportKey(std::optional<KFormatType> format, std::optional<KeyEncoding> type,
                                          const std::optional<std::string>& cipher,
                                          const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
   JWK exportJwk(const JWK& key, bool handleRsaPss) override;
+
   CFRGKeyPairType getAsymmetricKeyType() override;
+
   bool init(KeyType keyType, const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key, std::optional<KFormatType> format,
             std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
   bool initECRaw(const std::string& curveName, const std::shared_ptr<ArrayBuffer>& keyData) override;
+
   std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) override;
+
   KeyDetail keyDetail() override;
+
+ private:
+  KeyObjectData data_;
 };
 
 } // namespace margelo::nitro::crypto

packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.hpp

@@ -0,0 +1,95 @@
+#include "KeyObjectData.hpp"
+
+namespace margelo {
+
+KeyObjectData::KeyObjectData(std::nullptr_t)
+    : key_type_(KeyType::SECRET) {}
+
+KeyObjectData::KeyObjectData(std::shared_ptr<ArrayBuffer> symmetric_key)
+    : key_type_(KeyType::SECRET),
+      data_(std::make_shared<Data>(std::move(symmetric_key))) {}
+
+KeyObjectData::KeyObjectData(KeyType type, ncrypto::EVPKeyPointer&& pkey)
+    : key_type_(type), data_(std::make_shared<Data>(std::move(pkey))) {}
+
+KeyObjectData KeyObjectData::CreateSecret(std::shared_ptr<ArrayBuffer> key) {
+  return KeyObjectData(std::move(key));
+}
+
+KeyObjectData KeyObjectData::CreateAsymmetric(KeyType key_type,
+                                              ncrypto::EVPKeyPointer&& pkey) {
+  CHECK(pkey);
+  return KeyObjectData(key_type, std::move(pkey));
+}
+
+KeyType KeyObjectData::GetKeyType() const {
+  CHECK(data_);
+  return key_type_;
+}
+
+const ncrypto::EVPKeyPointer& KeyObjectData::GetAsymmetricKey() const {
+  CHECK_NE(key_type_, KeyType::SECRET);
+  CHECK(data_);
+  return data_->asymmetric_key;
+}
+
+std::shared_ptr<ArrayBuffer> KeyObjectData::GetSymmetricKey() const {
+  CHECK_EQ(key_type_, KeyType::SECRET);
+  CHECK(data_);
+  return data_->symmetric_key;
+}
+
+size_t KeyObjectData::GetSymmetricKeySize() const {
+  CHECK_EQ(key_type_, KeyType::SECRET);
+  CHECK(data_);
+  return data_->symmetric_key->size();
+}
+
+KeyObjectData KeyObjectData::GetPublicOrPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                                   std::optional<KeyEncoding> type,
+                                                   const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
+  if (!CheckIsInt32(key->size())) {
+    throw std::runtime_error("key is too big (int32)");
+  }
+
+  if (format.has_value() && format.value() == KFormatType::PEM) {
+    // For PEM, we can easily determine whether it is a public or private key
+    // by looking for the respective PEM tags.
+    auto res = EVPKeyPointer::TryParsePublicKeyPEM(key);
+    if (res) {
+      return CreateAsymmetric(KeyType::PUBLIC, std::move(res.value));
+    }
+
+    if (res.error.value() == EVPKeyPointer::PKParseError::NOT_RECOGNIZED) {
+      return TryParsePrivateKey(key, format, type, passphrase);
+    }
+    throw std::runtime_error("Failed to read asymmetric key");
+  }
+}
+
+KeyObjectData KeyObjectData::GetPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                           std::optional<KeyEncoding> type,
+                                           const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase,
+                                           bool isPublic) {
+  throw std::runtime_error("Not yet implemented");
+}
+
+KeyObjectData TryParsePrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                 std::optional<KeyEncoding> type,
+                                 const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
+  auto res = EVPKeyPointer::TryParsePrivateKey(config, buffer);
+  if (res) {
+    return KeyObjectData::CreateAsymmetric(KeyType::kKeyTypePrivate,
+                                           std::move(res.value));
+  }
+
+  if (res.error.value() == EVPKeyPointer::PKParseError::NEED_PASSPHRASE) {
+    THROW_ERR_MISSING_PASSPHRASE(env, "Passphrase required for encrypted key");
+  } else {
+    ThrowCryptoError(
+        env, res.openssl_error.value_or(0), "Failed to read private key");
+  }
+  return {};
+}
+
+} // namespace margelo