react-native-quick-crypto 0.6.1 → 0.7.0-rc.1

package/cpp/MGLKeys.cpp

@@ -9,22 +9,28 @@
 
 #include <jsi/jsi.h>
 #include <openssl/bio.h>
+#include <openssl/ec.h>
 
 #include <algorithm>
+#include <iostream>
 #include <optional>
 #include <utility>
 #include <vector>
 
 #ifdef ANDROID
+#include "Cipher/MGLRsa.h"
 #include "JSIUtils/MGLJSIMacros.h"
 #include "JSIUtils/MGLJSIUtils.h"
 #include "JSIUtils/MGLTypedArray.h"
 #include "Utils/MGLUtils.h"
+#include "webcrypto/crypto_ec.h"
 #else
+#include "MGLRsa.h"
 #include "MGLJSIMacros.h"
 #include "MGLJSIUtils.h"
 #include "MGLTypedArray.h"
 #include "MGLUtils.h"
+#include "crypto_ec.h"
 #endif
 
 namespace margelo {
@@ -245,28 +251,20 @@ ParseKeyResult ParsePrivateKey(EVPKeyPointer* pkey,
   return ParseKeyResult::kParseKeyFailed;
 }
 
-std::optional<StringOrBuffer> BIOToStringOrBuffer(BIO* bio,
-                                                  PKFormatType format) {
+OptionJSVariant BIOToStringOrBuffer(jsi::Runtime& rt, BIO* bio, PKFormatType format) {
   BUF_MEM* bptr;
   BIO_get_mem_ptr(bio, &bptr);
   if (format == kKeyFormatPEM) {
     // PEM is an ASCII format, so we will return it as a string.
-    return StringOrBuffer{
-        .isString = true,
-        .stringValue = std::string(bptr->data, bptr->length),
-    };
+    return JSVariant(std::string(bptr->data, bptr->length));
   } else {
     // CHECK_EQ(format, kKeyFormatDER);
     // DER is binary, return it as a buffer.
-    std::vector<unsigned char> vec(bptr->data, bptr->data + bptr->length);
-    return StringOrBuffer{
-        .isString = false,
-        .vectorValue = vec,
-    };
+    return JSVariant(ByteSource::Allocated(bptr->data, bptr->length));
   }
 }
 
-std::optional<StringOrBuffer> WritePrivateKey(
+OptionJSVariant WritePrivateKey(
     jsi::Runtime& runtime, EVP_PKEY* pkey,
     const PrivateKeyEncodingConfig& config) {
   BIOPointer bio(BIO_new(BIO_s_mem()));
@@ -294,14 +292,14 @@ std::optional<StringOrBuffer> WritePrivateKey(
     }
   }
 
-  bool err;
+  bool err = false;
 
   PKEncodingType encoding_type = config.type_.value();
   if (encoding_type == kKeyEncodingPKCS1) {
     // PKCS#1 is only permitted for RSA keys.
     //    CHECK_EQ(EVP_PKEY_id(pkey), EVP_PKEY_RSA);
 
-    RSAPointer rsa(EVP_PKEY_get1_RSA(pkey));
+    RsaPointer rsa(EVP_PKEY_get1_RSA(pkey));
     if (config.format_ == kKeyFormatPEM) {
       // Encode PKCS#1 as PEM.
       err = PEM_write_bio_RSAPrivateKey(bio.get(), rsa.get(), config.cipher_,
@@ -351,7 +349,7 @@ std::optional<StringOrBuffer> WritePrivateKey(
     throw jsi::JSError(runtime, "Failed to encode private key");
   }
 
-  return BIOToStringOrBuffer(bio.get(), config.format_);
+  return BIOToStringOrBuffer(runtime, bio.get(), config.format_);
 }
 
 bool WritePublicKeyInner(EVP_PKEY* pkey, const BIOPointer& bio,
@@ -359,7 +357,7 @@ bool WritePublicKeyInner(EVP_PKEY* pkey, const BIOPointer& bio,
   if (config.type_.value() == kKeyEncodingPKCS1) {
     // PKCS#1 is only valid for RSA keys.
     //    CHECK_EQ(EVP_PKEY_id(pkey), EVP_PKEY_RSA);
-    RSAPointer rsa(EVP_PKEY_get1_RSA(pkey));
+    RsaPointer rsa(EVP_PKEY_get1_RSA(pkey));
     if (config.format_ == kKeyFormatPEM) {
       // Encode PKCS#1 as PEM.
       return PEM_write_bio_RSAPublicKey(bio.get(), rsa.get()) == 1;
@@ -381,7 +379,7 @@ bool WritePublicKeyInner(EVP_PKEY* pkey, const BIOPointer& bio,
   }
 }
 
-std::optional<StringOrBuffer> WritePublicKey(
+OptionJSVariant WritePublicKey(
     jsi::Runtime& runtime, EVP_PKEY* pkey,
     const PublicKeyEncodingConfig& config) {
   BIOPointer bio(BIO_new(BIO_s_mem()));
@@ -391,138 +389,104 @@ std::optional<StringOrBuffer> WritePublicKey(
     throw jsi::JSError(runtime, "Failed to encode public key");
   }
 
-  return BIOToStringOrBuffer(bio.get(), config.format_);
+  return BIOToStringOrBuffer(runtime, bio.get(), config.format_);
 }
 
-// Maybe<bool> ExportJWKSecretKey(
-//                               Environment* env,
-//                               std::shared_ptr<KeyObjectData> key,
-//                               Local<Object> target) {
-//  CHECK_EQ(key->GetKeyType(), kKeyTypeSecret);
-//
-//  Local<Value> error;
-//  Local<Value> raw;
-//  MaybeLocal<Value> key_data =
-//  StringBytes::Encode(
-//                      env->isolate(),
-//                      key->GetSymmetricKey(),
-//                      key->GetSymmetricKeySize(),
-//                      BASE64URL,
-//                      &error);
-//  if (key_data.IsEmpty()) {
-//    CHECK(!error.IsEmpty());
-//    env->isolate()->ThrowException(error);
-//    return Nothing<bool>();
-//  }
-//  if (!key_data.ToLocal(&raw))
-//    return Nothing<bool>();
-//
-//  if (target->Set(
-//                  env->context(),
-//                  env->jwk_kty_string(),
-//                  env->jwk_oct_string()).IsNothing() ||
-//      target->Set(
-//                  env->context(),
-//                  env->jwk_k_string(),
-//                  raw).IsNothing()) {
-//                    return Nothing<bool>();
-//                  }
-//
-//  return Just(true);
-//}
-//
-// std::shared_ptr<KeyObjectData> ImportJWKSecretKey(
-//                                                  Environment* env,
-//                                                  Local<Object> jwk) {
-//  Local<Value> key;
-//  if (!jwk->Get(env->context(), env->jwk_k_string()).ToLocal(&key) ||
-//      !key->IsString()) {
-//    THROW_ERR_CRYPTO_INVALID_JWK(env, "Invalid JWK secret key format");
-//    return std::shared_ptr<KeyObjectData>();
-//  }
-//
-//  ByteSource key_data = ByteSource::FromEncodedString(env,
-//  key.As<String>()); if (key_data.size() > INT_MAX) {
-//    THROW_ERR_CRYPTO_INVALID_KEYLEN(env);
-//    return std::shared_ptr<KeyObjectData>();
-//  }
-//
-//  return KeyObjectData::CreateSecret(std::move(key_data));
-//}
-//
-// Maybe<bool> ExportJWKAsymmetricKey(
-//                                   Environment* env,
-//                                   std::shared_ptr<KeyObjectData> key,
-//                                   Local<Object> target,
-//                                   bool handleRsaPss) {
-//  switch (EVP_PKEY_id(key->GetAsymmetricKey().get())) {
-//    case EVP_PKEY_RSA_PSS: {
-//      if (handleRsaPss) return ExportJWKRsaKey(env, key, target);
-//      break;
-//    }
-//    case EVP_PKEY_RSA: return ExportJWKRsaKey(env, key, target);
-//    case EVP_PKEY_EC: return ExportJWKEcKey(env, key, target).IsJust() ?
-//      Just(true) : Nothing<bool>();
-//    case EVP_PKEY_ED25519:
-//      // Fall through
-//    case EVP_PKEY_ED448:
-//      // Fall through
-//    case EVP_PKEY_X25519:
-//      // Fall through
-//    case EVP_PKEY_X448: return ExportJWKEdKey(env, key, target);
-//  }
-//  THROW_ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE(env);
-//  return Just(false);
-//}
-//
-// std::shared_ptr<KeyObjectData> ImportJWKAsymmetricKey(
-//                                                      Environment* env,
-//                                                      Local<Object> jwk,
-//                                                      const char* kty,
-//                                                      const
-//                                                      FunctionCallbackInfo<Value>&
-//                                                      args, unsigned int
-//                                                      offset) {
-//  if (strcmp(kty, "RSA") == 0) {
-//    return ImportJWKRsaKey(env, jwk, args, offset);
-//  } else if (strcmp(kty, "EC") == 0) {
-//    return ImportJWKEcKey(env, jwk, args, offset);
-//  }
-//
-//  THROW_ERR_CRYPTO_INVALID_JWK(env, "%s is not a supported JWK key type",
-//  kty); return std::shared_ptr<KeyObjectData>();
-//}
-//
-// Maybe<bool> GetSecretKeyDetail(
-//                               Environment* env,
-//                               std::shared_ptr<KeyObjectData> key,
-//                               Local<Object> target) {
-//  // For the secret key detail, all we care about is the length,
-//  // converted to bits.
-//
-//  size_t length = key->GetSymmetricKeySize() * CHAR_BIT;
-//  return target->Set(env->context(),
-//                     env->length_string(),
-//                     Number::New(env->isolate(),
-//                     static_cast<double>(length)));
-//}
-//
-// Maybe<bool> GetAsymmetricKeyDetail(
-//                                   Environment* env,
-//                                   std::shared_ptr<KeyObjectData> key,
-//                                   Local<Object> target) {
-//  switch (EVP_PKEY_id(key->GetAsymmetricKey().get())) {
-//    case EVP_PKEY_RSA:
-//      // Fall through
-//    case EVP_PKEY_RSA_PSS: return GetRsaKeyDetail(env, key, target);
-//    case EVP_PKEY_DSA: return GetDsaKeyDetail(env, key, target);
-//    case EVP_PKEY_EC: return GetEcKeyDetail(env, key, target);
-//    case EVP_PKEY_DH: return GetDhKeyDetail(env, key, target);
-//  }
-//  THROW_ERR_CRYPTO_INVALID_KEYTYPE(env);
-//  return Nothing<bool>();
-//}
-//}  // namespace
+jsi::Value ExportJWKSecretKey(jsi::Runtime &rt,
+                              std::shared_ptr<KeyObjectData> key,
+                              jsi::Object &result) {
+  CHECK_EQ(key->GetKeyType(), kKeyTypeSecret);
+
+  std::string key_data = EncodeBase64(key->GetSymmetricKey(), true);
+
+  result.setProperty(rt, "kty", "oct");
+  result.setProperty(rt, "k", key_data);
+  return std::move(result);
+}
+
+std::shared_ptr<KeyObjectData> ImportJWKSecretKey(jsi::Runtime &rt,
+                                                  jsi::Object &jwk) {
+  std::string key = jwk
+    .getProperty(rt, "k")
+    .asString(rt)
+    .utf8(rt);
+
+  // TODO: when adding tests, trap errors like below (i.e. no `k` property, undefined)
+  //  Local<Value> key;
+  //  if (!jwk->Get(env->context(), env->jwk_k_string()).ToLocal(&key) ||
+  //      !key->IsString()) {
+  //    THROW_ERR_CRYPTO_INVALID_JWK(env, "Invalid JWK secret key format");
+  //    return std::shared_ptr<KeyObjectData>();
+  //  }
+
+  ByteSource key_data = ByteSource::FromEncodedString(rt, key, encoding::BASE64URL);
+  if (key_data.size() > INT_MAX) {
+    throw jsi::JSError(rt, "Invalid crypto key length");
+    return std::shared_ptr<KeyObjectData>();
+  }
+
+  return KeyObjectData::CreateSecret(std::move(key_data));
+}
+
+jsi::Value ExportJWKAsymmetricKey(jsi::Runtime &rt,
+                                  std::shared_ptr<KeyObjectData> key,
+                                  jsi::Object &target,
+                                  bool handleRsaPss) {
+  switch (EVP_PKEY_id(key->GetAsymmetricKey().get())) {
+    case EVP_PKEY_RSA_PSS: {
+      if (handleRsaPss) return ExportJWKRsaKey(rt, key, target);
+      break;
+    }
+    case EVP_PKEY_RSA: return ExportJWKRsaKey(rt, key, target);
+    case EVP_PKEY_EC: return ExportJWKEcKey(rt, key, target);
+    // case EVP_PKEY_ED25519:
+    //   // Fall through
+    // case EVP_PKEY_ED448:
+    //   // Fall through
+    // case EVP_PKEY_X25519:
+    //   // Fall through
+    // case EVP_PKEY_X448: return ExportJWKEdKey(rt, key, target);
+  }
+  throw jsi::JSError(rt, "Unsupported JWK asymmetric key type");
+}
+
+std::shared_ptr<KeyObjectData> ImportJWKAsymmetricKey(jsi::Runtime &rt,
+                                                      jsi::Object &jwk,
+                                                      std::string kty,
+                                                      jsi::Value &namedCurve) {
+  if (kty.compare("RSA") == 0) {
+    return ImportJWKRsaKey(rt, jwk);
+  } else if (kty.compare("EC") == 0) {
+    return ImportJWKEcKey(rt, jwk, namedCurve);
+  }
+
+  throw jsi::JSError(rt, "%s is not a supported JWK key type", kty);
+  return std::shared_ptr<KeyObjectData>();
+}
+
+jsi::Value GetSecretKeyDetail(jsi::Runtime &rt,
+                              std::shared_ptr<KeyObjectData> key) {
+  jsi::Object target = jsi::Object(rt);
+  // For the secret key detail, all we care about is the length,
+  // converted to bits.
+  size_t length = key->GetSymmetricKeySize() * CHAR_BIT;
+  target.setProperty(rt, "length", static_cast<double>(length));
+  return std::move(target);
+}
+
+jsi::Value GetAsymmetricKeyDetail(jsi::Runtime &rt,
+                                  std::shared_ptr<KeyObjectData> key) {
+  switch (EVP_PKEY_id(key->GetAsymmetricKey().get())) {
+    case EVP_PKEY_RSA:
+      // Fall through
+    case EVP_PKEY_RSA_PSS: return GetRsaKeyDetail(rt, key);
+    // case EVP_PKEY_DSA: return GetDsaKeyDetail(env, key);
+    case EVP_PKEY_EC: return GetEcKeyDetail(rt, key);
+    // case EVP_PKEY_DH: return GetDhKeyDetail(env, key);
+  }
+  throw jsi::JSError(rt, "Invalid Key Type");
+  return false;
+}
 
 ManagedEVPPKey::ManagedEVPPKey(EVPKeyPointer&& pkey) : pkey_(std::move(pkey)) {}
 
@@ -568,27 +532,24 @@ EVP_PKEY* ManagedEVPPKey::get() const { return pkey_.get(); }
 //                                               pkey_.get(), nullptr, &len)
 //                                               == 1) ? len : 0;
 //}
-//
-// Maybe<bool> ExportJWKInner(Environment* env,
-//                            std::shared_ptr<KeyObjectData> key,
-//                            Local<Value> result,
-//                            bool handleRsaPss) {
-//   switch (key->GetKeyType()) {
-//     case kKeyTypeSecret:
-//       return ExportJWKSecretKey(env, key, result.As<Object>());
-//     case kKeyTypePublic:
-//       // Fall through
-//     case kKeyTypePrivate:
-//       return ExportJWKAsymmetricKey(
-//                                     env, key, result.As<Object>(),
-//                                     handleRsaPss);
-//     default:
-//       UNREACHABLE();
-//   }
-// }
-//
 
-std::optional<StringOrBuffer> ManagedEVPPKey::ToEncodedPublicKey(
+jsi::Value ExportJWKInner(jsi::Runtime &rt,
+                          std::shared_ptr<KeyObjectData> key,
+                          jsi::Object &result,
+                          bool handleRsaPss) {
+  switch (key->GetKeyType()) {
+    case kKeyTypeSecret:
+      return ExportJWKSecretKey(rt, key, result);
+    case kKeyTypePublic:
+      // Fall through
+    case kKeyTypePrivate:
+      return ExportJWKAsymmetricKey(rt, key, result, handleRsaPss);
+    default:
+      throw jsi::JSError(rt, "unreachable code in ExportJWKInner");
+  }
+}
+
+OptionJSVariant ManagedEVPPKey::ToEncodedPublicKey(
     jsi::Runtime& runtime, ManagedEVPPKey key,
     const PublicKeyEncodingConfig& config) {
   if (!key) return {};
@@ -610,7 +571,7 @@ std::optional<StringOrBuffer> ManagedEVPPKey::ToEncodedPublicKey(
   return WritePublicKey(runtime, key.get(), config);
 }
 
-std::optional<StringOrBuffer> ManagedEVPPKey::ToEncodedPrivateKey(
+OptionJSVariant ManagedEVPPKey::ToEncodedPrivateKey(
     jsi::Runtime& runtime, ManagedEVPPKey key,
     const PrivateKeyEncodingConfig& config) {
   if (!key) return {};
@@ -672,7 +633,7 @@ ManagedEVPPKey::GetPrivateKeyEncodingFromJs(jsi::Runtime& runtime,
       if (needs_passphrase &&
           (arguments[*offset].isNull() || arguments[*offset].isUndefined())) {
         throw jsi::JSError(
-            runtime, "passphrase is null or unfedined but it is required");
+            runtime, "passphrase is null or undefined but it is required");
       }
     }
   }
@@ -763,7 +724,7 @@ ManagedEVPPKey ManagedEVPPKey::GetPublicOrPrivateKeyFromJs(
           is_public = false;
           break;
         default:
-          throw new jsi::JSError(runtime, "Invalid key encoding type");
+          throw jsi::JSError(runtime, "Invalid key encoding type");
       }
 
       if (is_public) {
@@ -780,7 +741,7 @@ ManagedEVPPKey ManagedEVPPKey::GetPublicOrPrivateKeyFromJs(
     return ManagedEVPPKey::GetParsedKey(runtime, std::move(pkey), ret,
                                         "Failed to read asymmetric key");
   } else {
-    throw new jsi::JSError(
+    throw jsi::JSError(
         runtime, "public encrypt only supports ArrayBuffer at the moment");
     //    CHECK(args[*offset]->IsObject());
     //    KeyObjectHandle* key =
@@ -801,81 +762,87 @@ ManagedEVPPKey ManagedEVPPKey::GetParsedKey(jsi::Runtime& runtime,
       //       CHECK(pkey);
       break;
     case ParseKeyResult::kParseKeyNeedPassphrase:
-      throw jsi::JSError(runtime,
-                                "Passphrase required for encrypted key");
+      throw jsi::JSError(runtime, "Passphrase required for encrypted key");
       break;
     default:
-      throw new jsi::JSError(runtime, default_msg);
+      throw jsi::JSError(runtime, default_msg);
   }
 
   return ManagedEVPPKey(std::move(pkey));
 }
-//
-// KeyObjectData::KeyObjectData(
-//                              ByteSource symmetric_key)
-//: key_type_(KeyType::kKeyTypeSecret),
-// symmetric_key_(std::move(symmetric_key)),
-// symmetric_key_len_(symmetric_key_.size()),
-// asymmetric_key_() {}
-//
-// KeyObjectData::KeyObjectData(
-//                              KeyType type,
-//                              const ManagedEVPPKey& pkey)
-//: key_type_(type),
-// symmetric_key_(),
-// symmetric_key_len_(0),
-// asymmetric_key_{pkey} {}
-//
-// void KeyObjectData::MemoryInfo(MemoryTracker* tracker) const {
-//   switch (GetKeyType()) {
-//     case kKeyTypeSecret:
-//       tracker->TrackFieldWithSize("symmetric_key", symmetric_key_.size());
-//       break;
-//     case kKeyTypePrivate:
-//       // Fall through
-//     case kKeyTypePublic:
-//       tracker->TrackFieldWithSize("key", asymmetric_key_);
-//       break;
-//     default:
-//       UNREACHABLE();
-//   }
-// }
-//
-// std::shared_ptr<KeyObjectData> KeyObjectData::CreateSecret(ByteSource key)
-// {
-//   CHECK(key);
-//   return std::shared_ptr<KeyObjectData>(new KeyObjectData(std::move(key)));
-// }
-//
-// std::shared_ptr<KeyObjectData> KeyObjectData::CreateAsymmetric(
-//                                                                KeyType
-//                                                                key_type,
-//                                                                const
-//                                                                ManagedEVPPKey&
-//                                                                pkey) {
-//   CHECK(pkey);
-//   return std::shared_ptr<KeyObjectData>(new KeyObjectData(key_type, pkey));
-// }
-//
-// KeyType KeyObjectData::GetKeyType() const {
-//   return key_type_;
-// }
-//
-// ManagedEVPPKey KeyObjectData::GetAsymmetricKey() const {
-//   CHECK_NE(key_type_, kKeyTypeSecret);
-//   return asymmetric_key_;
-// }
-//
-// const char* KeyObjectData::GetSymmetricKey() const {
-//   CHECK_EQ(key_type_, kKeyTypeSecret);
-//   return symmetric_key_.data<char>();
-// }
-//
-// size_t KeyObjectData::GetSymmetricKeySize() const {
-//   CHECK_EQ(key_type_, kKeyTypeSecret);
-//   return symmetric_key_len_;
-// }
-//
+
+KeyObjectData::KeyObjectData(ByteSource symmetric_key)
+: key_type_(KeyType::kKeyTypeSecret),
+  symmetric_key_(std::move(symmetric_key)),
+  symmetric_key_len_(symmetric_key_.size()),
+  asymmetric_key_() {}
+
+KeyObjectData::KeyObjectData(KeyType type,
+                             const ManagedEVPPKey& pkey)
+: key_type_(type),
+  symmetric_key_(),
+  symmetric_key_len_(0),
+  asymmetric_key_{pkey} {}
+
+std::shared_ptr<KeyObjectData> KeyObjectData::CreateSecret(ByteSource key)
+{
+  CHECK(key);
+  return std::shared_ptr<KeyObjectData>(new KeyObjectData(std::move(key)));
+}
+
+std::shared_ptr<KeyObjectData> KeyObjectData::CreateAsymmetric(
+  KeyType key_type,
+  const ManagedEVPPKey& pkey
+) {
+  CHECK(pkey);
+  return std::shared_ptr<KeyObjectData>(new KeyObjectData(key_type, pkey));
+}
+
+KeyType KeyObjectData::GetKeyType() const {
+  return key_type_;
+}
+
+ManagedEVPPKey KeyObjectData::GetAsymmetricKey() const {
+  CHECK_NE(key_type_, kKeyTypeSecret);
+  return asymmetric_key_;
+}
+
+/** Gets the symmetric key value
+ * binary data stored in string, tolerates \0 characters
+ */
+std::string KeyObjectData::GetSymmetricKey() const {
+  CHECK_EQ(key_type_, kKeyTypeSecret);
+  return symmetric_key_.ToString();
+}
+
+size_t KeyObjectData::GetSymmetricKeySize() const {
+  CHECK_EQ(key_type_, kKeyTypeSecret);
+  return symmetric_key_len_;
+}
+
+
+jsi::Value KeyObjectHandle::get(
+  jsi::Runtime &rt,
+  const jsi::PropNameID &propNameID) {
+    auto name = propNameID.utf8(rt);
+
+    if (name == "export") {
+      return this->Export(rt);
+    } else if (name == "exportJwk") {
+      return this->ExportJWK(rt);
+    } else if (name == "initECRaw") {
+      return this-> InitECRaw(rt);
+    } else if (name == "init") {
+      return this->Init(rt);
+    } else if (name == "initJwk") {
+      return this->InitJWK(rt);
+    } else if (name == "keyDetail") {
+      return this->GetKeyDetail(rt);
+    }
+
+    return {};
+}
+
 // v8::Local<v8::Function> KeyObjectHandle::Initialize(Environment* env) {
 //   Local<Function> templ = env->crypto_key_object_handle_constructor();
 //   if (!templ.IsEmpty()) {
@@ -936,9 +903,9 @@ ManagedEVPPKey ManagedEVPPKey::GetParsedKey(jsi::Runtime& runtime,
 //   return obj;
 // }
 //
-// const std::shared_ptr<KeyObjectData>& KeyObjectHandle::Data() {
-//   return data_;
-// }
+const std::shared_ptr<KeyObjectData>& KeyObjectHandle::Data() {
+  return this->data_;
+}
 //
 // void KeyObjectHandle::New(const FunctionCallbackInfo<Value>& args) {
 //   CHECK(args.IsConstructCall());
@@ -952,126 +919,129 @@ ManagedEVPPKey ManagedEVPPKey::GetParsedKey(jsi::Runtime& runtime,
 //  MakeWeak();
 //}
 //
-// void KeyObjectHandle::Init(const FunctionCallbackInfo<Value>& args) {
-//  KeyObjectHandle* key;
-//  ASSIGN_OR_RETURN_UNWRAP(&key, args.Holder());
-//  MarkPopErrorOnReturn mark_pop_error_on_return;
-//
-//  CHECK(args[0]->IsInt32());
-//  KeyType type = static_cast<KeyType>(args[0].As<Uint32>()->Value());
-//
-//  unsigned int offset;
-//  ManagedEVPPKey pkey;
-//
-//  switch (type) {
-//    case kKeyTypeSecret: {
-//      CHECK_EQ(args.Length(), 2);
-//      ArrayBufferOrViewContents<char> buf(args[1]);
-//      key->data_ = KeyObjectData::CreateSecret(buf.ToCopy());
-//      break;
-//    }
-//    case kKeyTypePublic: {
-//      CHECK_EQ(args.Length(), 5);
-//
-//      offset = 1;
-//      pkey = ManagedEVPPKey::GetPublicOrPrivateKeyFromJs(args, &offset);
-//      if (!pkey)
-//        return;
-//      key->data_ = KeyObjectData::CreateAsymmetric(type, pkey);
-//      break;
-//    }
-//    case kKeyTypePrivate: {
-//      CHECK_EQ(args.Length(), 5);
-//
-//      offset = 1;
-//      pkey = ManagedEVPPKey::GetPrivateKeyFromJs(args, &offset, false);
-//      if (!pkey)
-//        return;
-//      key->data_ = KeyObjectData::CreateAsymmetric(type, pkey);
-//      break;
-//    }
-//    default:
-//      UNREACHABLE();
-//  }
-//}
-//
-// void KeyObjectHandle::InitJWK(const FunctionCallbackInfo<Value>& args) {
-//  Environment* env = Environment::GetCurrent(args);
-//  KeyObjectHandle* key;
-//  ASSIGN_OR_RETURN_UNWRAP(&key, args.Holder());
-//  MarkPopErrorOnReturn mark_pop_error_on_return;
-//
-//  // The argument must be a JavaScript object that we will inspect
-//  // to get the JWK properties from.
-//  CHECK(args[0]->IsObject());
-//
-//  // Step one, Secret key or not?
-//  Local<Object> input = args[0].As<Object>();
-//
-//  Local<Value> kty;
-//  if (!input->Get(env->context(), env->jwk_kty_string()).ToLocal(&kty) ||
-//      !kty->IsString()) {
-//    return THROW_ERR_CRYPTO_INVALID_JWK(env);
-//  }
-//
-//  Utf8Value kty_string(env->isolate(), kty);
-//
-//  if (strcmp(*kty_string, "oct") == 0) {
-//    // Secret key
-//    key->data_ = ImportJWKSecretKey(env, input);
-//    if (!key->data_) {
-//      // ImportJWKSecretKey is responsible for throwing an appropriate error
-//      return;
-//    }
-//  } else {
-//    key->data_ = ImportJWKAsymmetricKey(env, input, *kty_string, args, 1);
-//    if (!key->data_) {
-//      // ImportJWKAsymmetricKey is responsible for throwing an appropriate
-//      error return;
-//    }
-//  }
-//
-//  args.GetReturnValue().Set(key->data_->GetKeyType());
-//}
-//
-// void KeyObjectHandle::InitECRaw(const FunctionCallbackInfo<Value>& args) {
-//  Environment* env = Environment::GetCurrent(args);
-//  KeyObjectHandle* key;
-//  ASSIGN_OR_RETURN_UNWRAP(&key, args.Holder());
-//
-//  CHECK(args[0]->IsString());
-//  Utf8Value name(env->isolate(), args[0]);
-//
-//  MarkPopErrorOnReturn mark_pop_error_on_return;
-//
-//  int id = OBJ_txt2nid(*name);
-//  ECKeyPointer eckey(EC_KEY_new_by_curve_name(id));
-//  if (!eckey)
-//    return args.GetReturnValue().Set(false);
-//
-//  const EC_GROUP* group = EC_KEY_get0_group(eckey.get());
-//  ECPointPointer pub(ECDH::BufferToPoint(env, group, args[1]));
-//
-//  if (!pub ||
-//      !eckey ||
-//      !EC_KEY_set_public_key(eckey.get(), pub.get())) {
-//    return args.GetReturnValue().Set(false);
-//  }
-//
-//  EVPKeyPointer pkey(EVP_PKEY_new());
-//  if (!EVP_PKEY_assign_EC_KEY(pkey.get(), eckey.get()))
-//    args.GetReturnValue().Set(false);
-//
-//  eckey.release();  // Release ownership of the key
-//
-//  key->data_ =
-//  KeyObjectData::CreateAsymmetric(
-//                                  kKeyTypePublic,
-//                                  ManagedEVPPKey(std::move(pkey)));
-//
-//  args.GetReturnValue().Set(true);
-//}
-//
+
+jsi::Value KeyObjectHandle::Init(jsi::Runtime &rt) {
+  return HOSTFN("init", 2) {
+    CHECK(args[0].isNumber());
+    KeyType type = static_cast<KeyType>((int32_t)args[0].asNumber());
+
+    unsigned int offset;
+    ManagedEVPPKey pkey;
+
+    switch (type) {
+      case kKeyTypeSecret: {
+        // CHECK_EQ(args.Length(), 2);
+
+        ByteSource key = ByteSource::FromStringOrBuffer(rt, args[1]);
+        this->data_ = KeyObjectData::CreateSecret(std::move(key));
+        break;
+      }
+      case kKeyTypePublic: {
+        // CHECK_EQ(args.Length(), 5);
+
+        offset = 1;
+        pkey = ManagedEVPPKey::GetPublicOrPrivateKeyFromJs(rt, args, &offset);
+        if (!pkey)
+          return false;
+        this->data_ = KeyObjectData::CreateAsymmetric(type, pkey);
+        break;
+      }
+      case kKeyTypePrivate: {
+        // CHECK_EQ(args.Length(), 5);
+
+        offset = 1;
+        pkey = ManagedEVPPKey::GetPrivateKeyFromJs(rt, args, &offset, false);
+        if (!pkey)
+          return false;
+        this->data_ = KeyObjectData::CreateAsymmetric(type, pkey);
+        break;
+      }
+      default:
+        throw jsi::JSError(rt, "invalid keytype for init(): " + std::to_string(type));
+    }
+
+    return true;
+  });
+}
+
+jsi::Value KeyObjectHandle::InitJWK(jsi::Runtime &rt) {
+  return HOSTFN("initJwk", 2) {
+    // The argument must be a JavaScript object that we will inspect
+    // to get the JWK properties from.
+    jsi::Object jwk = jsi::Object(jsi::Value(rt, args[0]).asObject(rt));
+    jsi::Value namedCurve;
+    if (count == 2)
+      namedCurve = jsi::Value(rt, args[1]);
+
+    // Step one, Secret key or not?
+    std::string kty = jwk
+      .getProperty(rt, "kty")
+      .asString(rt)
+      .utf8(rt);
+
+    if (kty.compare("oct") == 0) {
+      // Secret key
+      this->data_ = ImportJWKSecretKey(rt, jwk);
+      if (!this->data_) {
+        // ImportJWKSecretKey is responsible for throwing an appropriate error
+        return jsi::Value::undefined();
+      }
+    } else {
+      this->data_ = ImportJWKAsymmetricKey(rt, jwk, kty, namedCurve);
+      if (!this->data_) {
+        // ImportJWKAsymmetricKey is responsible for throwing an appropriate
+        // error
+       return jsi::Value::undefined();
+      }
+    }
+
+    return static_cast<int>(this->data_->GetKeyType());
+  });
+}
+
+jsi::Value KeyObjectHandle::InitECRaw(jsi::Runtime &rt) {
+  return HOSTFN("initECRaw", 2) {
+      CHECK(args[0].isString());
+      std::string curveName = args[0].asString(rt).utf8(rt);
+      int id = OBJ_txt2nid(curveName.c_str());
+      ECKeyPointer eckey(EC_KEY_new_by_curve_name(id));
+      if (!eckey) {
+          return false;
+      }
+
+      CHECK(args[1].isObject());
+      if (!args[1].getObject(rt).isArrayBuffer(rt)) {
+        throw jsi::JSError(rt,
+                          "KeyObjectHandle::InitECRaw: second argument "
+                          "has to be of type ArrayBuffer!");
+      }
+      auto buf = args[1].asObject(rt).getArrayBuffer(rt);
+
+      const EC_GROUP* group = EC_KEY_get0_group(eckey.get());
+      ECPointPointer pub(ECDH::BufferToPoint(rt, group, buf));
+
+      if (!pub ||
+          !eckey ||
+          !EC_KEY_set_public_key(eckey.get(), pub.get())) {
+          return false;
+      }
+
+      EVPKeyPointer pkey(EVP_PKEY_new());
+      if (!EVP_PKEY_assign_EC_KEY(pkey.get(), eckey.get())) {
+          return false;
+      }
+
+      eckey.release();  // Release ownership of the key
+
+      this->data_ =
+      KeyObjectData::CreateAsymmetric(
+                                      kKeyTypePublic,
+                                      ManagedEVPPKey(std::move(pkey)));
+
+      return true;
+  });
+}
+
 // void KeyObjectHandle::InitEDRaw(const FunctionCallbackInfo<Value>& args) {
 //  Environment* env = Environment::GetCurrent(args);
 //  KeyObjectHandle* key;
@@ -1107,7 +1077,7 @@ ManagedEVPPKey ManagedEVPPKey::GetParsedKey(jsi::Runtime& runtime,
 //      break;
 //    }
 //    default:
-//      UNREACHABLE();
+//      throw jsi::JSError(rt, "unreachable code in InitEDRaw");
 //  }
 //
 //  args.GetReturnValue().Set(true);
@@ -1155,41 +1125,31 @@ ManagedEVPPKey ManagedEVPPKey::GetParsedKey(jsi::Runtime& runtime,
 //      break;
 //    }
 //    default:
-//      UNREACHABLE("unsupported key type");
+//        throw jsi::JSError(rt, "unreachable code in Equals");
 //  }
 //
 //  args.GetReturnValue().Set(ret);
 //}
-//
-// void KeyObjectHandle::GetKeyDetail(const FunctionCallbackInfo<Value>& args)
-// {
-//  Environment* env = Environment::GetCurrent(args);
-//  KeyObjectHandle* key;
-//  ASSIGN_OR_RETURN_UNWRAP(&key, args.Holder());
-//
-//  CHECK(args[0]->IsObject());
-//
-//  std::shared_ptr<KeyObjectData> data = key->Data();
-//
-//  switch (data->GetKeyType()) {
-//    case kKeyTypeSecret:
-//      if (GetSecretKeyDetail(env, data, args[0].As<Object>()).IsNothing())
-//        return;
-//      break;
-//    case kKeyTypePublic:
-//      // Fall through
-//    case kKeyTypePrivate:
-//      if (GetAsymmetricKeyDetail(env, data,
-//      args[0].As<Object>()).IsNothing())
-//        return;
-//      break;
-//    default:
-//      UNREACHABLE();
-//  }
-//
-//  args.GetReturnValue().Set(args[0]);
-//}
-//
+
+jsi::Value KeyObjectHandle::GetKeyDetail(jsi::Runtime &rt) {
+  return HOSTFN("keyDetail", 0) {
+    std::shared_ptr<KeyObjectData> data = this->Data();
+
+    switch (data->GetKeyType()) {
+      case kKeyTypeSecret:
+        return GetSecretKeyDetail(rt, data);
+        break;
+      case kKeyTypePublic:
+        // Fall through
+      case kKeyTypePrivate:
+        return GetAsymmetricKeyDetail(rt, data);
+        break;
+      default:
+        throw jsi::JSError(rt, "unreachable code in GetKeyDetail");
+    }
+  });
+}
+
 // Local<Value> KeyObjectHandle::GetAsymmetricKeyType() const {
 //  const ManagedEVPPKey& key = data_->GetAsymmetricKey();
 //  switch (EVP_PKEY_id(key.get())) {
@@ -1234,82 +1194,65 @@ ManagedEVPPKey ManagedEVPPKey::GetParsedKey(jsi::Runtime& runtime,
 //  args.GetReturnValue().Set(
 //                            static_cast<uint32_t>(key->Data()->GetSymmetricKeySize()));
 //}
-//
-// void KeyObjectHandle::Export(const FunctionCallbackInfo<Value>& args) {
-//  KeyObjectHandle* key;
-//  ASSIGN_OR_RETURN_UNWRAP(&key, args.Holder());
-//
-//  KeyType type = key->Data()->GetKeyType();
-//
-//  MaybeLocal<Value> result;
-//  if (type == kKeyTypeSecret) {
-//    result = key->ExportSecretKey();
-//  } else if (type == kKeyTypePublic) {
-//    unsigned int offset = 0;
-//    PublicKeyEncodingConfig config =
-//    ManagedEVPPKey::GetPublicKeyEncodingFromJs(
-//                                               args, &offset,
-//                                               kKeyContextExport);
-//    CHECK_EQ(offset, static_cast<unsigned int>(args.Length()));
-//    result = key->ExportPublicKey(config);
-//  } else {
-//    CHECK_EQ(type, kKeyTypePrivate);
-//    unsigned int offset = 0;
-//    NonCopyableMaybe<PrivateKeyEncodingConfig> config =
-//    ManagedEVPPKey::GetPrivateKeyEncodingFromJs(
-//                                                args, &offset,
-//                                                kKeyContextExport);
-//    if (config.IsEmpty())
-//      return;
-//    CHECK_EQ(offset, static_cast<unsigned int>(args.Length()));
-//    result = key->ExportPrivateKey(config.Release());
-//  }
-//
-//  if (!result.IsEmpty())
-//    args.GetReturnValue().Set(result.FromMaybe(Local<Value>()));
-//}
-//
-// MaybeLocal<Value> KeyObjectHandle::ExportSecretKey() const {
-//  const char* buf = data_->GetSymmetricKey();
-//  unsigned int len = data_->GetSymmetricKeySize();
-//  return Buffer::Copy(env(), buf, len).FromMaybe(Local<Value>());
-//}
-//
-// MaybeLocal<Value> KeyObjectHandle::ExportPublicKey(
-//                                                   const
-//                                                   PublicKeyEncodingConfig&
-//                                                   config) const {
-//                                                     return
-//                                                     WritePublicKey(env(),
-//                                                     data_->GetAsymmetricKey().get(),
-//                                                     config);
-//                                                   }
-//
-// MaybeLocal<Value> KeyObjectHandle::ExportPrivateKey(
-//                                                    const
-//                                                    PrivateKeyEncodingConfig&
-//                                                    config) const {
-//                                                      return
-//                                                      WritePrivateKey(env(),
-//                                                      data_->GetAsymmetricKey().get(),
-//                                                      config);
-//                                                    }
-//
-// void KeyObjectHandle::ExportJWK(
-//                                const v8::FunctionCallbackInfo<v8::Value>&
-//                                args) {
-//  Environment* env = Environment::GetCurrent(args);
-//  KeyObjectHandle* key;
-//  ASSIGN_OR_RETURN_UNWRAP(&key, args.Holder());
-//
-//  CHECK(args[0]->IsObject());
-//  CHECK(args[1]->IsBoolean());
-//
-//  ExportJWKInner(env, key->Data(), args[0], args[1]->IsTrue());
-//
-//  args.GetReturnValue().Set(args[0]);
-//}
-//
+
+jsi::Value KeyObjectHandle::Export(jsi::Runtime &rt) {
+  return HOSTFN("export", 2) {
+    KeyType type = this->data_->GetKeyType();
+    OptionJSVariant result;
+    if (type == kKeyTypeSecret) {
+      result = this->ExportSecretKey(rt);
+    }
+    else if (type == kKeyTypePublic) {
+      unsigned int offset = 0;
+      PublicKeyEncodingConfig config =
+          ManagedEVPPKey::GetPublicKeyEncodingFromJs(
+              rt, args, &offset, kKeyContextExport);
+      result = this->ExportPublicKey(rt, config);
+    }
+    else if (type == kKeyTypePrivate) {
+      unsigned int offset = 0;
+      NonCopyableMaybe<PrivateKeyEncodingConfig> config =
+          ManagedEVPPKey::GetPrivateKeyEncodingFromJs(
+              rt, args, &offset, kKeyContextExport);
+      if (!config.IsEmpty()) {
+        result = this->ExportPrivateKey(rt, config.Release());
+      }
+    }
+    return toJSI(rt, result);
+  });
+}
+
+OptionJSVariant KeyObjectHandle::ExportSecretKey(jsi::Runtime &rt) const {
+  std::string ret = data_->GetSymmetricKey();
+  return JSVariant(ByteSource::FromString(ret));
+}
+
+OptionJSVariant KeyObjectHandle::ExportPublicKey(
+    jsi::Runtime& rt,
+    const PublicKeyEncodingConfig& config) const {
+  return WritePublicKey(rt,
+    data_->GetAsymmetricKey().get(),
+    config);
+}
+
+OptionJSVariant KeyObjectHandle::ExportPrivateKey(
+    jsi::Runtime &rt,
+    const PrivateKeyEncodingConfig& config) const {
+  return WritePrivateKey(rt,
+    data_->GetAsymmetricKey().get(),
+    config);
+}
+
+jsi::Value KeyObjectHandle::ExportJWK(jsi::Runtime &rt) {
+  return HOSTFN("exportJwk", 2) {
+    CHECK(args[0].isObject());
+    CHECK(args[1].isBool());
+    std::shared_ptr<KeyObjectData> data = this->Data();
+    jsi::Object result = args[0].asObject(rt);
+    return ExportJWKInner(rt, data, result, args[1].asBool());
+  });
+}
+
 // void NativeKeyObject::Initialize(Environment* env, Local<Object> target) {
 //  env->SetMethod(target, "createNativeKeyObjectClass",
 //                 NativeKeyObject::CreateNativeKeyObjectClass);
@@ -1456,4 +1399,5 @@ ManagedEVPPKey ManagedEVPPKey::GetParsedKey(jsi::Runtime& runtime,
 //  void RegisterExternalReferences(ExternalReferenceRegistry * registry) {
 //    KeyObjectHandle::RegisterExternalReferences(registry);
 //  }
+
 }  // namespace margelo