webcrypto: ML-DSA + ML-KEM, ChaCha20-Poly1305, raw-secret/raw-public, toCryptoKey, v26 SubtleCrypto surface (+10 tests, webcrypto 58%→76%)

src/jsc/bindings/AsymmetricKeyValue.cpp

@@ -30,6 +30,7 @@
 #include "ZigGlobalObject.h"
 #include "webcrypto/JSCryptoKey.h"
 #include "webcrypto/JSSubtleCrypto.h"
+#include "webcrypto/CryptoKeyAKP.h"
 #include "webcrypto/CryptoKeyOKP.h"
 #include "webcrypto/CryptoKeyEC.h"
 #include "webcrypto/CryptoKeyRSA.h"
@@ -101,6 +102,13 @@ AsymmetricKeyValue::AsymmetricKeyValue(WebCore::CryptoKey& cryptoKey)
     case CryptoAlgorithmIdentifier::ECDH:
         key = downcast<WebCore::CryptoKeyEC>(cryptoKey).platformKey();
         break;
+    case CryptoAlgorithmIdentifier::ML_DSA_44:
+    case CryptoAlgorithmIdentifier::ML_DSA_65:
+    case CryptoAlgorithmIdentifier::ML_DSA_87:
+    case CryptoAlgorithmIdentifier::ML_KEM_768:
+    case CryptoAlgorithmIdentifier::ML_KEM_1024:
+        key = downcast<WebCore::CryptoKeyAKP>(cryptoKey).platformKey();
+        break;
     case CryptoAlgorithmIdentifier::X25519:
     case CryptoAlgorithmIdentifier::Ed25519: {
         const auto& okpKey = downcast<WebCore::CryptoKeyOKP>(cryptoKey);
@@ -132,6 +140,7 @@ AsymmetricKeyValue::AsymmetricKeyValue(WebCore::CryptoKey& cryptoKey)
     case CryptoAlgorithmIdentifier::SHA3_512:
     case CryptoAlgorithmIdentifier::HKDF:
     case CryptoAlgorithmIdentifier::PBKDF2:
+    case CryptoAlgorithmIdentifier::ChaCha20_Poly1305:
     case CryptoAlgorithmIdentifier::None:
         key = nullptr;
         break;

src/jsc/bindings/ZigGlobalObject.cpp

@@ -1659,7 +1659,16 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionDispatchEvent, (JSGlobalObject * lexicalGloba
 
 JSC_DEFINE_CUSTOM_GETTER(getterSubtleCrypto, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
-    return JSValue::encode(static_cast<Zig::GlobalObject*>(lexicalGlobalObject)->subtleCrypto());
+    // Node brand-checks the receiver: Crypto.prototype.subtle on anything but
+    // the crypto global throws ERR_INVALID_THIS. Resolve through
+    // defaultGlobalObject so vm-context lexical globals still find the singleton.
+    auto* global = defaultGlobalObject(lexicalGlobalObject);
+    if (JSValue::decode(thisValue) != global->cryptoObject()) [[unlikely]] {
+        auto& vm = JSC::getVM(lexicalGlobalObject);
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        return Bun::throwError(lexicalGlobalObject, scope, Bun::ErrorCode::ERR_INVALID_THIS, "Value of \"this\" must be of type Crypto"_s);
+    }
+    return JSValue::encode(global->subtleCrypto());
 }
 
 extern "C" JSC::EncodedJSValue ExpectMatcherUtils_createSigleton(JSC::JSGlobalObject* lexicalGlobalObject);
@@ -2099,11 +2108,14 @@ void GlobalObject::finishCreation(VM& vm)
         [](const Initializer<JSObject>& init) {
             JSC::JSGlobalObject* globalObject = init.owner;
             JSObject* crypto = JSValue::decode(CryptoObject__create(globalObject)).getObject();
-            crypto->putDirectCustomAccessor(
+            // Node defines `subtle` on Crypto.prototype with a brand check, not on
+            // the instance; the getter above enforces the brand.
+            JSObject* prototype = crypto->getPrototypeDirect().getObject();
+            prototype->putDirectCustomAccessor(
                 init.vm,
                 Identifier::fromString(init.vm, "subtle"_s),
                 JSC::CustomGetterSetter::create(init.vm, getterSubtleCrypto, setterSubtleCrypto),
-                PropertyAttribute::DontDelete | 0);
+                PropertyAttribute::DontDelete | PropertyAttribute::CustomAccessor);
 
             init.set(crypto);
         });

src/jsc/bindings/node/crypto/JSPrivateKeyObjectPrototype.cpp

@@ -22,7 +22,7 @@ const JSC::ClassInfo JSPrivateKeyObjectPrototype::s_info = { "PrivateKeyObject"_
 // (JSAsymmetricKeyObjectPrototype.cpp), matching Node's prototype chain.
 static const JSC::HashTableValue JSPrivateKeyObjectPrototypeTableValues[] = {
     { "export"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPrivateKeyObjectPrototype_export, 1 } },
-    // { "toCryptoKey"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPrivateKeyObjectPrototype_toCryptoKey, 3 } },
+    { "toCryptoKey"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPrivateKeyObjectPrototype_toCryptoKey, 3 } },
 };
 
 void JSPrivateKeyObjectPrototype::finishCreation(JSC::VM& vm)
@@ -50,21 +50,21 @@ JSC_DEFINE_HOST_FUNCTION(jsPrivateKeyObjectPrototype_export, (JSGlobalObject * g
     return JSValue::encode(handle.exportAsymmetric(globalObject, scope, optionsValue, CryptoKeyType::Private));
 }
 
-// JSC_DEFINE_HOST_FUNCTION(jsPrivateKeyObjectPrototype_toCryptoKey, (JSGlobalObject * globalObject, CallFrame* callFrame))
-// {
-//     VM& vm = globalObject->vm();
-//     ThrowScope scope = DECLARE_THROW_SCOPE(vm);
+JSC_DEFINE_HOST_FUNCTION(jsPrivateKeyObjectPrototype_toCryptoKey, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    ThrowScope scope = DECLARE_THROW_SCOPE(vm);
 
-//     JSPrivateKeyObject* privateKeyObject = dynamicDowncast<JSPrivateKeyObject>(callFrame->thisValue());
-//     if (!privateKeyObject) {
-//         throwThisTypeError(*globalObject, scope, "PrivateKeyObject"_s, "toCryptoKey"_s);
-//         return {};
-//     }
+    JSPrivateKeyObject* privateKeyObject = dynamicDowncast<JSPrivateKeyObject>(callFrame->thisValue());
+    if (!privateKeyObject) {
+        throwThisTypeError(*globalObject, scope, "PrivateKeyObject"_s, "toCryptoKey"_s);
+        return {};
+    }
 
-//     KeyObject& handle = privateKeyObject->handle();
-//     JSValue algorithmValue = callFrame->argument(0);
-//     JSValue extractableValue = callFrame->argument(1);
-//     JSValue keyUsagesValue = callFrame->argument(2);
+    KeyObject& handle = privateKeyObject->handle();
+    JSValue algorithmValue = callFrame->argument(0);
+    JSValue extractableValue = callFrame->argument(1);
+    JSValue keyUsagesValue = callFrame->argument(2);
 
-//     return JSValue::encode(handle.toCryptoKey(globalObject, scope, algorithmValue, extractableValue, keyUsagesValue));
-// }
+    return JSValue::encode(handle.toCryptoKey(globalObject, scope, algorithmValue, extractableValue, keyUsagesValue));
+}

src/jsc/bindings/node/crypto/JSPublicKeyObjectPrototype.cpp

@@ -22,7 +22,7 @@ const JSC::ClassInfo JSPublicKeyObjectPrototype::s_info = { "PublicKeyObject"_s,
 // (JSAsymmetricKeyObjectPrototype.cpp), matching Node's prototype chain.
 static const JSC::HashTableValue JSPublicKeyObjectPrototypeTableValues[] = {
     { "export"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPublicKeyObjectPrototype_export, 1 } },
-    // { "toCryptoKey"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPublicKeyObjectPrototype_toCryptoKey, 3 } },
+    { "toCryptoKey"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPublicKeyObjectPrototype_toCryptoKey, 3 } },
 };
 
 void JSPublicKeyObjectPrototype::finishCreation(JSC::VM& vm)
@@ -50,21 +50,21 @@ JSC_DEFINE_HOST_FUNCTION(jsPublicKeyObjectPrototype_export, (JSGlobalObject * gl
     return JSValue::encode(handle.exportAsymmetric(globalObject, scope, optionsValue, CryptoKeyType::Public));
 }
 
-// JSC_DEFINE_HOST_FUNCTION(jsPublicKeyObjectPrototype_toCryptoKey, (JSGlobalObject * globalObject, CallFrame* callFrame))
-// {
-//     VM& vm = globalObject->vm();
-//     ThrowScope scope = DECLARE_THROW_SCOPE(vm);
+JSC_DEFINE_HOST_FUNCTION(jsPublicKeyObjectPrototype_toCryptoKey, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    ThrowScope scope = DECLARE_THROW_SCOPE(vm);
 
-//     JSPublicKeyObject* publicKeyObject = dynamicDowncast<JSPublicKeyObject>(callFrame->thisValue());
-//     if (!publicKeyObject) {
-//         throwThisTypeError(*globalObject, scope, "PublicKeyObject"_s, "toCryptoKey"_s);
-//         return {};
-//     }
+    JSPublicKeyObject* publicKeyObject = dynamicDowncast<JSPublicKeyObject>(callFrame->thisValue());
+    if (!publicKeyObject) {
+        throwThisTypeError(*globalObject, scope, "PublicKeyObject"_s, "toCryptoKey"_s);
+        return {};
+    }
 
-//     KeyObject& handle = publicKeyObject->handle();
-//     JSValue algorithmValue = callFrame->argument(0);
-//     JSValue extractableValue = callFrame->argument(1);
-//     JSValue keyUsagesValue = callFrame->argument(2);
+    KeyObject& handle = publicKeyObject->handle();
+    JSValue algorithmValue = callFrame->argument(0);
+    JSValue extractableValue = callFrame->argument(1);
+    JSValue keyUsagesValue = callFrame->argument(2);
 
-//     return JSValue::encode(handle.toCryptoKey(globalObject, scope, algorithmValue, extractableValue, keyUsagesValue));
-// }
+    return JSValue::encode(handle.toCryptoKey(globalObject, scope, algorithmValue, extractableValue, keyUsagesValue));
+}

src/jsc/bindings/node/crypto/JSSecretKeyObjectPrototype.cpp

@@ -23,7 +23,7 @@ const JSC::ClassInfo JSSecretKeyObjectPrototype::s_info = { "SecretKeyObject"_s,
 static const JSC::HashTableValue JSSecretKeyObjectPrototypeTableValues[] = {
     { "export"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSecretKeyObjectExport, 1 } },
     { "symmetricKeySize"_s, static_cast<unsigned>(PropertyAttribute::CustomAccessor | PropertyAttribute::ReadOnly), NoIntrinsic, { HashTableValue::GetterSetterType, jsSecretKeyObjectSymmetricKeySize, 0 } },
-    // { "toCryptoKey"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSecretKeyObjectToCryptoKey, 3 } },
+    { "toCryptoKey"_s, static_cast<unsigned>(PropertyAttribute::Function | PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSecretKeyObjectToCryptoKey, 3 } },
 };
 
 void JSSecretKeyObjectPrototype::finishCreation(JSC::VM& vm)
@@ -69,21 +69,21 @@ JSC_DEFINE_CUSTOM_GETTER(jsSecretKeyObjectSymmetricKeySize, (JSGlobalObject * gl
     return JSValue::encode(jsNumber(symmetricKeySize));
 }
 
-// JSC_DEFINE_HOST_FUNCTION(jsSecretKeyObjectToCryptoKey, (JSGlobalObject * globalObject, CallFrame* callFrame))
-// {
-//     VM& vm = globalObject->vm();
-//     ThrowScope scope = DECLARE_THROW_SCOPE(vm);
+JSC_DEFINE_HOST_FUNCTION(jsSecretKeyObjectToCryptoKey, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    ThrowScope scope = DECLARE_THROW_SCOPE(vm);
 
-//     JSSecretKeyObject* secretKeyObject = dynamicDowncast<JSSecretKeyObject>(callFrame->thisValue());
-//     if (!secretKeyObject) {
-//         throwThisTypeError(*globalObject, scope, "SecretKeyObject"_s, "toCryptoKey"_s);
-//         return {};
-//     }
+    JSSecretKeyObject* secretKeyObject = dynamicDowncast<JSSecretKeyObject>(callFrame->thisValue());
+    if (!secretKeyObject) {
+        throwThisTypeError(*globalObject, scope, "SecretKeyObject"_s, "toCryptoKey"_s);
+        return {};
+    }
 
-//     KeyObject& handle = secretKeyObject->handle();
-//     JSValue algorithmValue = callFrame->argument(0);
-//     JSValue extractableValue = callFrame->argument(1);
-//     JSValue keyUsagesValue = callFrame->argument(2);
+    KeyObject& handle = secretKeyObject->handle();
+    JSValue algorithmValue = callFrame->argument(0);
+    JSValue extractableValue = callFrame->argument(1);
+    JSValue keyUsagesValue = callFrame->argument(2);
 
-//     return JSValue::encode(handle.toCryptoKey(globalObject, scope, algorithmValue, extractableValue, keyUsagesValue));
-// }
+    return JSValue::encode(handle.toCryptoKey(globalObject, scope, algorithmValue, extractableValue, keyUsagesValue));
+}

src/jsc/bindings/node/crypto/KeyObject.cpp

@@ -7,12 +7,26 @@
 #include "ErrorCode.h"
 #include "NodeValidator.h"
 #include "AsymmetricKeyValue.h"
+#include "CryptoAlgorithm.h"
+#include "CryptoAlgorithmParameters.h"
+#include "CryptoAlgorithmRegistry.h"
 #include "CryptoKeyAES.h"
+#include "CryptoKeyAKP.h"
 #include "CryptoKeyHMAC.h"
 #include "CryptoKeyRaw.h"
 #include "CryptoKey.h"
 #include "CryptoKeyType.h"
 #include "JSCryptoKey.h"
+#include "JSCryptoKeyUsage.h"
+#include "SubtleCrypto.h"
+#include "JSDOMConvertInterface.h"
+#include "JSDOMConvertObject.h"
+#include "JSDOMConvertSequences.h"
+#include "JSDOMConvertStrings.h"
+#include "JSDOMConvertUnion.h"
+#include "JSDOMConvertEnumeration.h"
+#include "JSDOMExceptionHandling.h"
+#include "OpenSSLUtilities.h"
 #include "CryptoGenKeyPair.h"
 #include "JSBuffer.h"
 #include "BunString.h"
@@ -897,9 +911,134 @@ std::optional<bool> KeyObject::equals(const KeyObject& other) const
     }
 }
 
-JSValue KeyObject::toCryptoKey(JSGlobalObject* globalObject, ThrowScope& scope, JSValue algorithmValue, JSValue extractableValue, JSValue keyUsagesValue)
+static std::optional<Vector<uint8_t>> marshalAsymmetricKey(const ncrypto::EVPKeyPointer& pkey, bool isPublic)
 {
-    return jsUndefined();
+    return WebCore::marshalEVPKey(pkey.get(), isPublic);
+}
+
+// KeyObject.prototype.toCryptoKey, following Node's per-algorithm dispatch in
+// lib/internal/crypto/keys.js.
+JSValue KeyObject::toCryptoKey(JSGlobalObject* lexicalGlobalObject, ThrowScope& scope, JSValue algorithmValue, JSValue extractableValue, JSValue keyUsagesValue)
+{
+    auto* globalObject = defaultGlobalObject(lexicalGlobalObject);
+
+    auto algorithm = WebCore::convert<WebCore::IDLUnion<WebCore::IDLObject, WebCore::IDLDOMString>>(*lexicalGlobalObject, algorithmValue);
+    RETURN_IF_EXCEPTION(scope, {});
+    bool extractable = extractableValue.toBoolean(lexicalGlobalObject);
+    auto keyUsages = WebCore::convert<WebCore::IDLSequence<WebCore::IDLEnumeration<WebCore::CryptoKeyUsage>>>(*lexicalGlobalObject, keyUsagesValue);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto usagesBitmap = WebCore::SubtleCrypto::toCryptoKeyUsageBitmap(keyUsages);
+
+    auto throwDOMException = [&](WebCore::ExceptionCode code, const String& message) -> JSValue {
+        WebCore::propagateException(*lexicalGlobalObject, scope, WebCore::Exception { code, message });
+        return {};
+    };
+
+    auto paramsOrException = WebCore::SubtleCrypto::normalizeImportParameters(*lexicalGlobalObject, WTF::move(algorithm));
+    RETURN_IF_EXCEPTION(scope, {});
+    if (paramsOrException.hasException()) {
+        WebCore::propagateException(*lexicalGlobalObject, scope, paramsOrException.releaseException());
+        return {};
+    }
+    auto params = paramsOrException.releaseReturnValue();
+    auto identifier = params->identifier;
+
+    RefPtr<WebCore::CryptoKey> result;
+    std::optional<WebCore::ExceptionCode> failureCode;
+    String failureMessage;
+    auto keyCallback = [&](WebCore::CryptoKey& key) { result = &key; };
+    auto exceptionCallback = [&](WebCore::ExceptionCode code, const String& message) {
+        failureCode = code;
+        failureMessage = message;
+    };
+
+    if (type() == CryptoKeyType::Secret) {
+        WebCore::CryptoKeyFormat format = WebCore::CryptoKeyFormat::Raw;
+        switch (identifier) {
+        case CryptoAlgorithmIdentifier::HMAC:
+        case CryptoAlgorithmIdentifier::AES_CTR:
+        case CryptoAlgorithmIdentifier::AES_CBC:
+        case CryptoAlgorithmIdentifier::AES_GCM:
+        case CryptoAlgorithmIdentifier::AES_KW:
+        case CryptoAlgorithmIdentifier::HKDF:
+        case CryptoAlgorithmIdentifier::PBKDF2:
+            break;
+        case CryptoAlgorithmIdentifier::ChaCha20_Poly1305:
+            format = WebCore::CryptoKeyFormat::RawSecret;
+            break;
+        default:
+            // AES-CFB lands here on purpose: node v26.3.0 has no AES-CFB in
+            // webcrypto, so toCryptoKey rejects it even though Bun's
+            // subtle.importKey accepts it as an extension.
+            return throwDOMException(WebCore::NotSupportedError, "Unrecognized algorithm name"_s);
+        }
+
+        Vector<uint8_t> keyData;
+        keyData.appendVector(symmetricKey());
+        auto importAlgorithm = WebCore::CryptoAlgorithmRegistry::singleton().create(identifier);
+        importAlgorithm->importKey(format, WebCore::KeyData { WTF::move(keyData) }, *params, extractable, usagesBitmap, WTF::move(keyCallback), WTF::move(exceptionCallback));
+    } else {
+        bool isPublic = type() == CryptoKeyType::Public;
+        switch (identifier) {
+        case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
+        case CryptoAlgorithmIdentifier::RSA_PSS:
+        case CryptoAlgorithmIdentifier::RSA_OAEP:
+        case CryptoAlgorithmIdentifier::ECDSA:
+        case CryptoAlgorithmIdentifier::ECDH:
+        case CryptoAlgorithmIdentifier::Ed25519:
+        case CryptoAlgorithmIdentifier::X25519: {
+            // Round-trip through DER so the WebCrypto import performs the same
+            // validation as importKey.
+            auto der = marshalAsymmetricKey(asymmetricKey(), isPublic);
+            if (!der)
+                return throwDOMException(WebCore::OperationError, ""_s);
+            auto importAlgorithm = WebCore::CryptoAlgorithmRegistry::singleton().create(identifier);
+            importAlgorithm->importKey(isPublic ? WebCore::CryptoKeyFormat::Spki : WebCore::CryptoKeyFormat::Pkcs8, WebCore::KeyData { WTF::move(*der) }, *params, extractable, usagesBitmap, WTF::move(keyCallback), WTF::move(exceptionCallback));
+            break;
+        }
+        case CryptoAlgorithmIdentifier::ML_DSA_44:
+        case CryptoAlgorithmIdentifier::ML_DSA_65:
+        case CryptoAlgorithmIdentifier::ML_DSA_87:
+        case CryptoAlgorithmIdentifier::ML_KEM_768:
+        case CryptoAlgorithmIdentifier::ML_KEM_1024: {
+            // Node's 'KeyObject' import path wraps the handle directly.
+            WebCore::CryptoKeyUsageBitmap allowedUsages;
+            if (WebCore::CryptoKeyAKP::isMlDsa(identifier))
+                allowedUsages = isPublic ? WebCore::CryptoKeyUsageVerify : WebCore::CryptoKeyUsageSign;
+            else
+                allowedUsages = isPublic
+                    ? WebCore::CryptoKeyUsageEncapsulateKey | WebCore::CryptoKeyUsageEncapsulateBits
+                    : WebCore::CryptoKeyUsageDecapsulateKey | WebCore::CryptoKeyUsageDecapsulateBits;
+            if (usagesBitmap & ~allowedUsages)
+                // Node v26.3.0 says "for a ML-..." here (toCryptoKey) but "for an ML-..." in generateKey.
+                return throwDOMException(WebCore::SyntaxError, makeString("Unsupported key usage for a "_s, WebCore::CryptoAlgorithmRegistry::singleton().name(identifier), " key"_s));
+            if (EVP_PKEY_id(asymmetricKey().get()) != WebCore::CryptoKeyAKP::nidForIdentifier(identifier))
+                return throwDOMException(WebCore::DataError, "Invalid key type"_s);
+            EVP_PKEY_up_ref(asymmetricKey().get());
+            WebCore::EvpPKeyPtr platformKey(asymmetricKey().get());
+            result = WebCore::CryptoKeyAKP::create(identifier, type(), WTF::move(platformKey), extractable, usagesBitmap);
+            if (!result)
+                return throwDOMException(WebCore::OperationError, ""_s);
+            break;
+        }
+        default:
+            return throwDOMException(WebCore::NotSupportedError, "Unrecognized algorithm name"_s);
+        }
+    }
+
+    if (failureCode)
+        return throwDOMException(*failureCode, failureMessage);
+    if (!result)
+        return throwDOMException(WebCore::OperationError, ""_s);
+
+    if ((result->type() == WebCore::CryptoKeyType::Private || result->type() == WebCore::CryptoKeyType::Secret) && !result->usagesBitmap()) {
+        return throwDOMException(WebCore::SyntaxError,
+            result->type() == WebCore::CryptoKeyType::Private
+                ? "Usages cannot be empty when importing a private key."_s
+                : "Usages cannot be empty when importing a secret key."_s);
+    }
+
+    return WebCore::toJS(lexicalGlobalObject, globalObject, *result);
 }
 
 static std::optional<const Vector<uint8_t>*> getSymmetricKey(const WebCore::CryptoKey& key)