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

package/cpp/MGLKeys.cpp

@@ -251,24 +251,26 @@ ParseKeyResult ParsePrivateKey(EVPKeyPointer* pkey,
   return ParseKeyResult::kParseKeyFailed;
 }
 
-OptionJSVariant BIOToStringOrBuffer(jsi::Runtime& rt, BIO* bio, PKFormatType format) {
+jsi::Value 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 JSVariant(std::string(bptr->data, bptr->length));
+    return toJSI(rt, std::string(bptr->data, bptr->length));
   } else {
-    // CHECK_EQ(format, kKeyFormatDER);
+    CHECK_EQ(format, kKeyFormatDER);
     // DER is binary, return it as a buffer.
-    return JSVariant(ByteSource::Allocated(bptr->data, bptr->length));
+    ByteSource::Builder out(bptr->length);
+    memcpy(out.data<void>(), bptr->data, bptr->length);
+    return toJSI(rt, std::move(out).release());
   }
 }
 
-OptionJSVariant WritePrivateKey(
+jsi::Value WritePrivateKey(
     jsi::Runtime& runtime, EVP_PKEY* pkey,
     const PrivateKeyEncodingConfig& config) {
   BIOPointer bio(BIO_new(BIO_s_mem()));
-  //  CHECK(bio);
+  CHECK(bio);
 
   // If an empty string was passed as the passphrase, the ByteSource might
   // contain a null pointer, which OpenSSL will ignore, causing it to invoke its
@@ -293,8 +295,15 @@ OptionJSVariant WritePrivateKey(
   }
 
   bool err = false;
+  PKEncodingType encoding_type;
+
+  if (config.type_.has_value()) {
+    encoding_type = config.type_.value();
+  } else {
+    // default for no value in std::option `config.type_`
+    encoding_type = kKeyEncodingSEC1;
+  }
 
-  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);
@@ -307,8 +316,8 @@ OptionJSVariant WritePrivateKey(
                                         pass_len, nullptr, nullptr) != 1;
     } else {
       // Encode PKCS#1 as DER. This does not permit encryption.
-      //      CHECK_EQ(config.format_, kKeyFormatDER);
-      //      CHECK_NULL(config.cipher_);
+      CHECK_EQ(config.format_, kKeyFormatDER);
+      CHECK_NULL(config.cipher_);
       err = i2d_RSAPrivateKey_bio(bio.get(), rsa.get()) != 1;
     }
   } else if (encoding_type == kKeyEncodingPKCS8) {
@@ -318,31 +327,28 @@ OptionJSVariant WritePrivateKey(
                                           pass_len, nullptr, nullptr) != 1;
     } else {
       // Encode PKCS#8 as DER.
-      //      CHECK_EQ(config.format_, kKeyFormatDER);
+      CHECK_EQ(config.format_, kKeyFormatDER);
       err = i2d_PKCS8PrivateKey_bio(bio.get(), pkey, config.cipher_, pass,
                                     pass_len, nullptr, nullptr) != 1;
     }
   } else {
-    //    CHECK_EQ(encoding_type, kKeyEncodingSEC1);
+    CHECK_EQ(encoding_type, kKeyEncodingSEC1);
 
     // SEC1 is only permitted for EC keys.
-    //    CHECK_EQ(EVP_PKEY_id(pkey), EVP_PKEY_EC);
-
-    //    ECKeyPointer ec_key(EVP_PKEY_get1_EC_KEY(pkey));
-    //    if (config.format_ == kKeyFormatPEM) {
-    //      // Encode SEC1 as PEM.
-    //      err = PEM_write_bio_ECPrivateKey(
-    //                                       bio.get(), ec_key.get(),
-    //                                       config.cipher_,
-    //                                       reinterpret_cast<unsigned
-    //                                       char*>(pass), pass_len, nullptr,
-    //                                       nullptr) != 1;
-    //    } else {
-    //      // Encode SEC1 as DER. This does not permit encryption.
-    //      CHECK_EQ(config.format_, kKeyFormatDER);
-    //      CHECK_NULL(config.cipher_);
-    //      err = i2d_ECPrivateKey_bio(bio.get(), ec_key.get()) != 1;
-    //    }
+    CHECK_EQ(EVP_PKEY_id(pkey), EVP_PKEY_EC);
+
+    ECKeyPointer ec_key(EVP_PKEY_get1_EC_KEY(pkey));
+    if (config.format_ == kKeyFormatPEM) {
+      // Encode SEC1 as PEM.
+      err = PEM_write_bio_ECPrivateKey(bio.get(),ec_key.get(), config.cipher_,
+                                       reinterpret_cast<unsigned char*>(pass),
+                                       pass_len, nullptr, nullptr) != 1;
+    } else {
+      // Encode SEC1 as DER. This does not permit encryption.
+      CHECK_EQ(config.format_, kKeyFormatDER);
+      // CHECK_NULL(config.cipher_);
+      err = i2d_ECPrivateKey_bio(bio.get(), ec_key.get()) != 1;
+    }
   }
 
   if (err) {
@@ -354,36 +360,37 @@ OptionJSVariant WritePrivateKey(
 
 bool WritePublicKeyInner(EVP_PKEY* pkey, const BIOPointer& bio,
                          const PublicKeyEncodingConfig& config) {
+  if (!config.type_.has_value()) return false;
   if (config.type_.value() == kKeyEncodingPKCS1) {
     // PKCS#1 is only valid for RSA keys.
-    //    CHECK_EQ(EVP_PKEY_id(pkey), EVP_PKEY_RSA);
+    CHECK_EQ(EVP_PKEY_id(pkey), EVP_PKEY_RSA);
     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;
     } else {
       // Encode PKCS#1 as DER.
-      //      CHECK_EQ(config.format_, kKeyFormatDER);
+      CHECK_EQ(config.format_, kKeyFormatDER);
       return i2d_RSAPublicKey_bio(bio.get(), rsa.get()) == 1;
     }
   } else {
-    //    CHECK_EQ(config.type_.ToChecked(), kKeyEncodingSPKI);
+    CHECK_EQ(config.type_.value(), kKeyEncodingSPKI);
     if (config.format_ == kKeyFormatPEM) {
       // Encode SPKI as PEM.
       return PEM_write_bio_PUBKEY(bio.get(), pkey) == 1;
     } else {
       // Encode SPKI as DER.
-      //      CHECK_EQ(config.format_, kKeyFormatDER);
+      CHECK_EQ(config.format_, kKeyFormatDER);
       return i2d_PUBKEY_bio(bio.get(), pkey) == 1;
     }
   }
 }
 
-OptionJSVariant WritePublicKey(
+jsi::Value WritePublicKey(
     jsi::Runtime& runtime, EVP_PKEY* pkey,
     const PublicKeyEncodingConfig& config) {
   BIOPointer bio(BIO_new(BIO_s_mem()));
-  //  CHECK(bio);
+  CHECK(bio);
 
   if (!WritePublicKeyInner(pkey, bio, config)) {
     throw jsi::JSError(runtime, "Failed to encode public key");
@@ -518,20 +525,18 @@ EVP_PKEY* ManagedEVPPKey::get() const { return pkey_.get(); }
 //                              size_of_private_key() +
 //                              size_of_public_key());
 //}
-//
-// size_t ManagedEVPPKey::size_of_private_key() const {
-//  size_t len = 0;
-//  return (pkey_ && EVP_PKEY_get_raw_private_key(
-//                                                pkey_.get(), nullptr, &len)
-//                                                == 1) ? len : 0;
-//}
-//
-// size_t ManagedEVPPKey::size_of_public_key() const {
-//  size_t len = 0;
-//  return (pkey_ && EVP_PKEY_get_raw_public_key(
-//                                               pkey_.get(), nullptr, &len)
-//                                               == 1) ? len : 0;
-//}
+
+size_t ManagedEVPPKey::size_of_private_key() const {
+ size_t len = 0;
+ return (pkey_ && EVP_PKEY_get_raw_private_key(pkey_.get(), nullptr, &len) == 1)
+  ? len : 0;
+}
+
+size_t ManagedEVPPKey::size_of_public_key() const {
+ size_t len = 0;
+ return (pkey_ && EVP_PKEY_get_raw_public_key(pkey_.get(), nullptr, &len) == 1)
+  ? len : 0;
+}
 
 jsi::Value ExportJWKInner(jsi::Runtime &rt,
                           std::shared_ptr<KeyObjectData> key,
@@ -549,45 +554,48 @@ jsi::Value ExportJWKInner(jsi::Runtime &rt,
   }
 }
 
-OptionJSVariant ManagedEVPPKey::ToEncodedPublicKey(
-    jsi::Runtime& runtime, ManagedEVPPKey key,
-    const PublicKeyEncodingConfig& config) {
+jsi::Value ManagedEVPPKey::ToEncodedPublicKey(jsi::Runtime& rt,
+                                              ManagedEVPPKey key,
+                                              const PublicKeyEncodingConfig& config) {
   if (!key) return {};
-  // TODO(osp) ignore all this for now
-  //   if (config.output_key_object_) {
-  //     // Note that this has the downside of containing sensitive data of the
-  //     // private key.
-  //     std::shared_ptr<KeyObjectData> data =
-  //     KeyObjectData::CreateAsymmetric(kKeyTypePublic, std::move(key));
-  // TODO(osp) Replaced tristate for std::optional
-  //     return Tristate(KeyObjectHandle::Create(env, data).ToLocal(out));
-  //   } else if (config.format_ == kKeyFormatJWK) {
-  //     std::shared_ptr<KeyObjectData> data =
-  //     KeyObjectData::CreateAsymmetric(kKeyTypePublic, std::move(key));
-  //     *out = Object::New(env->isolate());
-  //     return ExportJWKInner(env, data, *out, false);
-  //   }
-
-  return WritePublicKey(runtime, key.get(), config);
+  if (config.output_key_object_) {
+    // Note that this has the downside of containing sensitive data of the
+    // private key.
+    auto data = KeyObjectData::CreateAsymmetric(kKeyTypePublic, std::move(key));
+    auto handle = KeyObjectHandle::Create(rt, data);
+    auto out = jsi::Object::createFromHostObject(rt, handle);
+    return jsi::Value(std::move(out));
+  } else
+  if (config.format_ == kKeyFormatJWK) {
+    throw std::runtime_error("ToEncodedPublicKey 2 (JWK) not implemented from node");
+    // std::shared_ptr<KeyObjectData> data =
+    // KeyObjectData::CreateAsymmetric(kKeyTypePublic, std::move(key));
+    // *out = Object::New(env->isolate());
+    // return ExportJWKInner(env, data, *out, false);
+  }
+
+  return WritePublicKey(rt, key.get(), config);
 }
 
-OptionJSVariant ManagedEVPPKey::ToEncodedPrivateKey(
-    jsi::Runtime& runtime, ManagedEVPPKey key,
-    const PrivateKeyEncodingConfig& config) {
+jsi::Value ManagedEVPPKey::ToEncodedPrivateKey(jsi::Runtime& rt,
+                                                    ManagedEVPPKey key,
+                                                    const PrivateKeyEncodingConfig& config) {
   if (!key) return {};
-  //   if (config.output_key_object_) {
-  //     std::shared_ptr<KeyObjectData> data =
-  //     KeyObjectData::CreateAsymmetric(kKeyTypePrivate, std::move(key));
-  // TODO(osp) replaced tristate for std::optional
-  //     return Tristate(KeyObjectHandle::Create(env, data).ToLocal(out));
-  //   } else if (config.format_ == kKeyFormatJWK) {
-  //     std::shared_ptr<KeyObjectData> data =
-  //     KeyObjectData::CreateAsymmetric(kKeyTypePrivate, std::move(key));
-  //     *out = Object::New(env->isolate());
-  //     return ExportJWKInner(env, data, *out, false);
-  //   }
-
-  return WritePrivateKey(runtime, key.get(), config);
+  if (config.output_key_object_) {
+    auto data = KeyObjectData::CreateAsymmetric(kKeyTypePrivate, std::move(key));
+    auto handle = KeyObjectHandle::Create(rt, data);
+    auto out = jsi::Object::createFromHostObject(rt, handle);
+    return jsi::Value(std::move(out));
+  } else
+  if (config.format_ == kKeyFormatJWK) {
+    throw std::runtime_error("ToEncodedPrivateKey 2 (JWK) not implemented from node");
+    // std::shared_ptr<KeyObjectData> data =
+    // KeyObjectData::CreateAsymmetric(kKeyTypePrivate, std::move(key));
+    // *out = Object::New(env->isolate());
+    // return ExportJWKInner(env, data, *out, false);
+  }
+
+  return WritePrivateKey(rt, key.get(), config);
 }
 
 NonCopyableMaybe<PrivateKeyEncodingConfig>
@@ -668,19 +676,25 @@ ManagedEVPPKey ManagedEVPPKey::GetPrivateKeyFromJs(jsi::Runtime& runtime,
     return GetParsedKey(runtime, std::move(pkey), ret,
                         "Failed to read private key");
   } else {
-    //    CHECK(args[*offset]->IsObject() && allow_key_object);
-    //    KeyObjectHandle* key;
-    //    ASSIGN_OR_RETURN_UNWRAP(&key, args[*offset].As<Object>(),
-    //    ManagedEVPPKey()); CHECK_EQ(key->Data()->GetKeyType(),
-    //    kKeyTypePrivate);
-    //    (*offset) += 4;
-    //    return key->Data()->GetAsymmetricKey();
-    throw jsi::JSError(runtime, "KeyObject are not currently supported");
+    if( !(args[*offset].isObject() && allow_key_object)) {
+      throw jsi::JSError(runtime,
+                         "ManagedEVPPKey::GetPrivateKeyFromJs: First argument "
+                         "must be object (CryptoKey) and caller must pass "
+                         "allow_key_object as true");
+    }
+    std::shared_ptr<KeyObjectHandle> handle =
+      std::static_pointer_cast<KeyObjectHandle>(
+        args[*offset].asObject(runtime).getHostObject(runtime));
+    CHECK_EQ(handle->Data()->GetKeyType(), kKeyTypePrivate);
+    (*offset) += 4;
+    return handle->Data()->GetAsymmetricKey();
   }
 }
 
 ManagedEVPPKey ManagedEVPPKey::GetPublicOrPrivateKeyFromJs(
-    jsi::Runtime& runtime, const jsi::Value* args, unsigned int* offset) {
+    jsi::Runtime& runtime,
+    const jsi::Value* args,
+    unsigned int* offset) {
   if (args[*offset].asObject(runtime).isArrayBuffer(runtime)) {
     auto dataArrayBuffer =
         args[(*offset)++].asObject(runtime).getArrayBuffer(runtime);
@@ -741,15 +755,19 @@ ManagedEVPPKey ManagedEVPPKey::GetPublicOrPrivateKeyFromJs(
     return ManagedEVPPKey::GetParsedKey(runtime, std::move(pkey), ret,
                                         "Failed to read asymmetric key");
   } else {
-    throw jsi::JSError(
-        runtime, "public encrypt only supports ArrayBuffer at the moment");
-    //    CHECK(args[*offset]->IsObject());
-    //    KeyObjectHandle* key =
-    //    Unwrap<KeyObjectHandle>(args[*offset].As<Object>());
-    //    CHECK_NOT_NULL(key);
-    //    CHECK_NE(key->Data()->GetKeyType(), kKeyTypeSecret);
-    //    (*offset) += 4;
-    //    return key->Data()->GetAsymmetricKey();
+    if( !(args[*offset].isObject()) ) {
+      throw jsi::JSError(runtime,
+                         "ManagedEVPPKey::GetPublicOrPrivateKeyFromJs: First "
+                         "argument not ArrayBuffer or object (CryptoKey)");
+    }
+    std::shared_ptr<KeyObjectHandle> handle =
+      std::static_pointer_cast<KeyObjectHandle>(
+        args[*offset].asObject(runtime).getHostObject(runtime));
+    // note: below check is kKeyTypeSecret in Node.js
+    //       but kKeyTypePublic in RNQC when testing verify() on ECDSA
+    CHECK_EQ(handle->Data()->GetKeyType(), kKeyTypePublic);
+    (*offset) += 4;
+    return handle->Data()->GetAsymmetricKey();
   }
 }
 
@@ -838,6 +856,8 @@ jsi::Value KeyObjectHandle::get(
       return this->InitJWK(rt);
     } else if (name == "keyDetail") {
       return this->GetKeyDetail(rt);
+    } else if (name == "getAsymmetricKeyType") {
+      return this->GetAsymmetricKeyType(rt);
     }
 
     return {};
@@ -886,23 +906,14 @@ jsi::Value KeyObjectHandle::get(
 //   registry->Register(GetKeyDetail);
 //   registry->Register(Equals);
 // }
-//
-// MaybeLocal<Object> KeyObjectHandle::Create(
-//                                            Environment* env,
-//                                            std::shared_ptr<KeyObjectData>
-//                                            data) {
-//   Local<Object> obj;
-//   Local<Function> ctor = KeyObjectHandle::Initialize(env);
-//   CHECK(!env->crypto_key_object_handle_constructor().IsEmpty());
-//   if (!ctor->NewInstance(env->context(), 0, nullptr).ToLocal(&obj))
-//     return MaybeLocal<Object>();
-//
-//   KeyObjectHandle* key = Unwrap<KeyObjectHandle>(obj);
-//   CHECK_NOT_NULL(key);
-//   key->data_ = data;
-//   return obj;
-// }
-//
+
+std::shared_ptr<KeyObjectHandle> KeyObjectHandle::Create(jsi::Runtime &rt,
+                                                         std::shared_ptr<KeyObjectData> data) {
+  auto handle = std::make_shared<KeyObjectHandle>();
+  handle->data_ = data;
+  return handle;
+}
+
 const std::shared_ptr<KeyObjectData>& KeyObjectHandle::Data() {
   return this->data_;
 }
@@ -1150,31 +1161,45 @@ jsi::Value KeyObjectHandle::GetKeyDetail(jsi::Runtime &rt) {
   });
 }
 
-// Local<Value> KeyObjectHandle::GetAsymmetricKeyType() const {
-//  const ManagedEVPPKey& key = data_->GetAsymmetricKey();
-//  switch (EVP_PKEY_id(key.get())) {
-//    case EVP_PKEY_RSA:
-//      return env()->crypto_rsa_string();
-//    case EVP_PKEY_RSA_PSS:
-//      return env()->crypto_rsa_pss_string();
-//    case EVP_PKEY_DSA:
-//      return env()->crypto_dsa_string();
-//    case EVP_PKEY_DH:
-//      return env()->crypto_dh_string();
-//    case EVP_PKEY_EC:
-//      return env()->crypto_ec_string();
-//    case EVP_PKEY_ED25519:
-//      return env()->crypto_ed25519_string();
-//    case EVP_PKEY_ED448:
-//      return env()->crypto_ed448_string();
-//    case EVP_PKEY_X25519:
-//      return env()->crypto_x25519_string();
-//    case EVP_PKEY_X448:
-//      return env()->crypto_x448_string();
-//    default:
-//      return Undefined(env()->isolate());
-//  }
-//}
+jsi::Value KeyObjectHandle::GetAsymmetricKeyType(jsi::Runtime &rt) const {
+  return HOSTFN("getAsymmetricKeyType", 0) {
+    const ManagedEVPPKey& key = this->data_->GetAsymmetricKey();
+    std::string ret;
+    switch (EVP_PKEY_id(key.get())) {
+      case EVP_PKEY_RSA:
+        ret = "rss";
+        break;
+      case EVP_PKEY_RSA_PSS:
+        ret = "rsa_pss";
+        break;
+      case EVP_PKEY_DSA:
+        ret = "dsa";
+        break;
+      case EVP_PKEY_DH:
+        ret = "dh";
+        break;
+      case EVP_PKEY_EC:
+        ret = "ec";
+        break;
+      case EVP_PKEY_ED25519:
+        ret = "ed25519";
+        break;
+      case EVP_PKEY_ED448:
+        ret = "ed448";
+        break;
+      case EVP_PKEY_X25519:
+        ret = "x25519";
+        break;
+      case EVP_PKEY_X448:
+        ret = "x448";
+        break;
+      default:
+        throw jsi::JSError(rt, "unknown KeyType in GetAsymmetricKeyType");
+    }
+    return jsi::String::createFromUtf8(rt, ret);
+  });
+}
+
 //
 // void KeyObjectHandle::GetAsymmetricKeyType(
 //                                           const
@@ -1198,7 +1223,7 @@ jsi::Value KeyObjectHandle::GetKeyDetail(jsi::Runtime &rt) {
 jsi::Value KeyObjectHandle::Export(jsi::Runtime &rt) {
   return HOSTFN("export", 2) {
     KeyType type = this->data_->GetKeyType();
-    OptionJSVariant result;
+    jsi::Value result;
     if (type == kKeyTypeSecret) {
       result = this->ExportSecretKey(rt);
     }
@@ -1218,16 +1243,16 @@ jsi::Value KeyObjectHandle::Export(jsi::Runtime &rt) {
         result = this->ExportPrivateKey(rt, config.Release());
       }
     }
-    return toJSI(rt, result);
+    return result;
   });
 }
 
-OptionJSVariant KeyObjectHandle::ExportSecretKey(jsi::Runtime &rt) const {
+jsi::Value KeyObjectHandle::ExportSecretKey(jsi::Runtime &rt) const {
   std::string ret = data_->GetSymmetricKey();
-  return JSVariant(ByteSource::FromString(ret));
+  return toJSI(rt, ByteSource::FromString(ret));
 }
 
-OptionJSVariant KeyObjectHandle::ExportPublicKey(
+jsi::Value KeyObjectHandle::ExportPublicKey(
     jsi::Runtime& rt,
     const PublicKeyEncodingConfig& config) const {
   return WritePublicKey(rt,
@@ -1235,7 +1260,7 @@ OptionJSVariant KeyObjectHandle::ExportPublicKey(
     config);
 }
 
-OptionJSVariant KeyObjectHandle::ExportPrivateKey(
+jsi::Value KeyObjectHandle::ExportPrivateKey(
     jsi::Runtime &rt,
     const PrivateKeyEncodingConfig& config) const {
   return WritePrivateKey(rt,

package/cpp/MGLKeys.h

@@ -101,7 +101,8 @@ class ManagedEVPPKey {
       KeyEncodingContext context);
   //
   static ManagedEVPPKey GetParsedKey(jsi::Runtime &runtime,
-                                     EVPKeyPointer &&pkey, ParseKeyResult ret,
+                                     EVPKeyPointer &&pkey,
+                                     ParseKeyResult ret,
                                      const char *default_msg);
 
   static ManagedEVPPKey GetPublicOrPrivateKeyFromJs(jsi::Runtime &runtime,
@@ -113,17 +114,17 @@ class ManagedEVPPKey {
                                             unsigned int *offset,
                                             bool allow_key_object);
 
-  static OptionJSVariant ToEncodedPublicKey(
-      jsi::Runtime &runtime, ManagedEVPPKey key,
-      const PublicKeyEncodingConfig &config);
+  static jsi::Value ToEncodedPublicKey(jsi::Runtime &runtime,
+                                       ManagedEVPPKey key,
+                                       const PublicKeyEncodingConfig &config);
 
-  static OptionJSVariant ToEncodedPrivateKey(
-      jsi::Runtime &runtime, ManagedEVPPKey key,
-      const PrivateKeyEncodingConfig &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;
+   size_t size_of_private_key() const;
+   size_t size_of_public_key() const;
 
   EVPKeyPointer pkey_;
 };
@@ -167,20 +168,24 @@ class JSI_EXPORT KeyObjectHandle: public jsi::HostObject {
     jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
     const std::shared_ptr<KeyObjectData>& Data();
 
+    static std::shared_ptr<KeyObjectHandle> Create(jsi::Runtime &rt,
+                                                   std::shared_ptr<KeyObjectData> data);
+
  protected:
     jsi::Value Export(jsi::Runtime &rt);
     jsi::Value ExportJWK(jsi::Runtime &rt);
-    OptionJSVariant ExportPublicKey(
+    jsi::Value ExportPublicKey(
       jsi::Runtime& rt,
       const PublicKeyEncodingConfig& config) const;
-    OptionJSVariant ExportPrivateKey(
+    jsi::Value ExportPrivateKey(
       jsi::Runtime& rt,
       const PrivateKeyEncodingConfig& config) const;
-    OptionJSVariant ExportSecretKey(jsi::Runtime& rt) 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);
-    jsi::Value GetKeyDetail(jsi::Runtime &rt);
 
  private:
     std::shared_ptr<KeyObjectData> data_;