mirror of
https://github.com/oven-sh/bun
synced 2026-02-19 07:12:24 +00:00
6b149bc9aa
- Update QueuedTask constructor calls to use new payload parameter - BunPerformMicrotaskJob now handles async context directly (saves one argument slot) - Replace SortedArrayMap usage with if-else chains (API changed in WTF) - Fix typos: DOMEGCOutputConstraint -> DOMGCOutputConstraint - Fix WTF_MAKE_TZONE_ALLOCATED macro argument in CryptoSignJob.h - Update code generators (bindgen.ts, enumeration.ts) to not use SortedArrayMap Claude-Generated-By: Claude Code (cli/claude-opus-4-5=100%) Claude-Steers: 13
687 lines
42 KiB
C++
687 lines
42 KiB
C++
/*
|
|
This file is part of the WebKit open source project.
|
|
This file has been generated by generate-bindings.pl. DO NOT MODIFY!
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wtf/Forward.h"
|
|
|
|
#if ENABLE(WEB_CRYPTO)
|
|
|
|
#include "JSSubtleCrypto.h"
|
|
|
|
#include "ActiveDOMObject.h"
|
|
#include "DOMPromiseProxy.h"
|
|
#include "ExtendedDOMClientIsoSubspaces.h"
|
|
#include "ExtendedDOMIsoSubspaces.h"
|
|
#include "JSCryptoKey.h"
|
|
#include "JSCryptoKeyUsage.h"
|
|
#include "JSDOMBinding.h"
|
|
#include "JSDOMConstructorNotConstructable.h"
|
|
#include "JSDOMConvertAny.h"
|
|
#include "JSDOMConvertBoolean.h"
|
|
#include "JSDOMConvertBufferSource.h"
|
|
#include "JSDOMConvertDictionary.h"
|
|
#include "JSDOMConvertInterface.h"
|
|
#include "JSDOMConvertNumbers.h"
|
|
#include "JSDOMConvertObject.h"
|
|
#include "JSDOMConvertPromise.h"
|
|
#include "JSDOMConvertSequences.h"
|
|
#include "JSDOMConvertStrings.h"
|
|
#include "JSDOMConvertUnion.h"
|
|
#include "JSDOMExceptionHandling.h"
|
|
#include "JSDOMGlobalObject.h"
|
|
#include "JSDOMGlobalObjectInlines.h"
|
|
#include "JSDOMOperation.h"
|
|
#include "JSDOMOperationReturningPromise.h"
|
|
#include "JSDOMWrapperCache.h"
|
|
#include "JSJsonWebKey.h"
|
|
#include "ScriptExecutionContext.h"
|
|
#include "WebCoreJSClientData.h"
|
|
#include "WebCoreOpaqueRoot.h"
|
|
#include <JavaScriptCore/FunctionPrototype.h>
|
|
#include <JavaScriptCore/HeapAnalyzer.h>
|
|
#include <JavaScriptCore/JSArray.h>
|
|
#include <JavaScriptCore/JSCInlines.h>
|
|
#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
|
|
#include <JavaScriptCore/JSString.h>
|
|
#include <JavaScriptCore/SlotVisitorMacros.h>
|
|
#include <JavaScriptCore/SubspaceInlines.h>
|
|
#include <variant>
|
|
#include <wtf/GetPtr.h>
|
|
#include <wtf/PointerPreparations.h>
|
|
#include <wtf/URL.h>
|
|
#include "ErrorCode.h"
|
|
|
|
namespace WebCore {
|
|
using namespace JSC;
|
|
|
|
String convertEnumerationToString(SubtleCrypto::KeyFormat enumerationValue)
|
|
{
|
|
static const NeverDestroyed<String> values[] = {
|
|
MAKE_STATIC_STRING_IMPL("raw"),
|
|
MAKE_STATIC_STRING_IMPL("spki"),
|
|
MAKE_STATIC_STRING_IMPL("pkcs8"),
|
|
MAKE_STATIC_STRING_IMPL("jwk"),
|
|
};
|
|
static_assert(static_cast<size_t>(SubtleCrypto::KeyFormat::Raw) == 0, "SubtleCrypto::KeyFormat::Raw is not 0 as expected");
|
|
static_assert(static_cast<size_t>(SubtleCrypto::KeyFormat::Spki) == 1, "SubtleCrypto::KeyFormat::Spki is not 1 as expected");
|
|
static_assert(static_cast<size_t>(SubtleCrypto::KeyFormat::Pkcs8) == 2, "SubtleCrypto::KeyFormat::Pkcs8 is not 2 as expected");
|
|
static_assert(static_cast<size_t>(SubtleCrypto::KeyFormat::Jwk) == 3, "SubtleCrypto::KeyFormat::Jwk is not 3 as expected");
|
|
ASSERT(static_cast<size_t>(enumerationValue) < std::size(values));
|
|
return values[static_cast<size_t>(enumerationValue)];
|
|
}
|
|
|
|
template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, SubtleCrypto::KeyFormat enumerationValue)
|
|
{
|
|
return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue));
|
|
}
|
|
|
|
template<> std::optional<SubtleCrypto::KeyFormat> parseEnumeration<SubtleCrypto::KeyFormat>(JSGlobalObject& lexicalGlobalObject, JSValue value)
|
|
{
|
|
auto stringValue = value.toWTFString(&lexicalGlobalObject);
|
|
if (stringValue == "jwk"_s)
|
|
return SubtleCrypto::KeyFormat::Jwk;
|
|
if (stringValue == "pkcs8"_s)
|
|
return SubtleCrypto::KeyFormat::Pkcs8;
|
|
if (stringValue == "raw"_s)
|
|
return SubtleCrypto::KeyFormat::Raw;
|
|
if (stringValue == "spki"_s)
|
|
return SubtleCrypto::KeyFormat::Spki;
|
|
return std::nullopt;
|
|
}
|
|
|
|
template<> ASCIILiteral expectedEnumerationValues<SubtleCrypto::KeyFormat>()
|
|
{
|
|
return "\"raw\", \"spki\", \"pkcs8\", \"jwk\""_s;
|
|
}
|
|
|
|
// Functions
|
|
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_encrypt);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_decrypt);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_sign);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_verify);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_digest);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_generateKey);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_deriveKey);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_deriveBits);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_importKey);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_exportKey);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_wrapKey);
|
|
static JSC_DECLARE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_unwrapKey);
|
|
|
|
// Attributes
|
|
|
|
static JSC_DECLARE_CUSTOM_GETTER(jsSubtleCryptoConstructor);
|
|
|
|
class JSSubtleCryptoPrototype final : public JSC::JSNonFinalObject {
|
|
public:
|
|
using Base = JSC::JSNonFinalObject;
|
|
static JSSubtleCryptoPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
|
|
{
|
|
JSSubtleCryptoPrototype* ptr = new (NotNull, JSC::allocateCell<JSSubtleCryptoPrototype>(vm)) JSSubtleCryptoPrototype(vm, globalObject, structure);
|
|
ptr->finishCreation(vm);
|
|
return ptr;
|
|
}
|
|
|
|
DECLARE_INFO;
|
|
template<typename CellType, JSC::SubspaceAccess>
|
|
static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
|
|
{
|
|
STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSubtleCryptoPrototype, Base);
|
|
return &vm.plainObjectSpace();
|
|
}
|
|
static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
|
|
{
|
|
return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
|
|
}
|
|
|
|
private:
|
|
JSSubtleCryptoPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
|
|
: JSC::JSNonFinalObject(vm, structure)
|
|
{
|
|
}
|
|
|
|
void finishCreation(JSC::VM&);
|
|
};
|
|
STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSubtleCryptoPrototype, JSSubtleCryptoPrototype::Base);
|
|
|
|
using JSSubtleCryptoDOMConstructor = JSDOMConstructorNotConstructable<JSSubtleCrypto>;
|
|
|
|
template<> const ClassInfo JSSubtleCryptoDOMConstructor::s_info = { "SubtleCrypto"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSubtleCryptoDOMConstructor) };
|
|
|
|
template<> JSValue JSSubtleCryptoDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
|
|
{
|
|
UNUSED_PARAM(vm);
|
|
return globalObject.functionPrototype();
|
|
}
|
|
|
|
template<> void JSSubtleCryptoDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
|
|
{
|
|
putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
|
|
JSString* nameString = jsNontrivialString(vm, "SubtleCrypto"_s);
|
|
m_originalName.set(vm, this, nameString);
|
|
putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
|
|
putDirect(vm, vm.propertyNames->prototype, JSSubtleCrypto::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
|
|
}
|
|
|
|
/* Hash table for prototype */
|
|
|
|
static const HashTableValue JSSubtleCryptoPrototypeTableValues[] = {
|
|
{ "constructor"_s, static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::GetterSetterType, jsSubtleCryptoConstructor, 0 } },
|
|
{ "encrypt"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_encrypt, 3 } },
|
|
{ "decrypt"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_decrypt, 3 } },
|
|
{ "sign"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_sign, 3 } },
|
|
{ "verify"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_verify, 4 } },
|
|
{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_digest, 2 } },
|
|
{ "generateKey"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_generateKey, 3 } },
|
|
{ "deriveKey"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_deriveKey, 5 } },
|
|
{ "deriveBits"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_deriveBits, 3 } },
|
|
{ "importKey"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_importKey, 5 } },
|
|
{ "exportKey"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_exportKey, 2 } },
|
|
{ "wrapKey"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_wrapKey, 4 } },
|
|
{ "unwrapKey"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSubtleCryptoPrototypeFunction_unwrapKey, 7 } },
|
|
};
|
|
|
|
const ClassInfo JSSubtleCryptoPrototype::s_info = { "SubtleCrypto"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSubtleCryptoPrototype) };
|
|
|
|
void JSSubtleCryptoPrototype::finishCreation(VM& vm)
|
|
{
|
|
Base::finishCreation(vm);
|
|
reifyStaticProperties(vm, JSSubtleCrypto::info(), JSSubtleCryptoPrototypeTableValues, *this);
|
|
JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
|
|
}
|
|
|
|
const ClassInfo JSSubtleCrypto::s_info = { "SubtleCrypto"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSubtleCrypto) };
|
|
|
|
JSSubtleCrypto::JSSubtleCrypto(Structure* structure, JSDOMGlobalObject& globalObject, Ref<SubtleCrypto>&& impl)
|
|
: JSDOMWrapper<SubtleCrypto>(structure, globalObject, WTF::move(impl))
|
|
{
|
|
}
|
|
|
|
void JSSubtleCrypto::finishCreation(VM& vm)
|
|
{
|
|
Base::finishCreation(vm);
|
|
ASSERT(inherits(info()));
|
|
|
|
// static_assert(!std::is_base_of<ActiveDOMObject, SubtleCrypto>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
|
|
}
|
|
|
|
JSObject* JSSubtleCrypto::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
|
|
{
|
|
auto* structure = JSSubtleCryptoPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype());
|
|
structure->setMayBePrototype(true);
|
|
return JSSubtleCryptoPrototype::create(vm, &globalObject, structure);
|
|
}
|
|
|
|
JSObject* JSSubtleCrypto::prototype(VM& vm, JSDOMGlobalObject& globalObject)
|
|
{
|
|
return getDOMPrototype<JSSubtleCrypto>(vm, globalObject);
|
|
}
|
|
|
|
JSValue JSSubtleCrypto::getConstructor(VM& vm, const JSGlobalObject* globalObject)
|
|
{
|
|
return getDOMConstructor<JSSubtleCryptoDOMConstructor, DOMConstructorID::SubtleCrypto>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
|
|
}
|
|
|
|
void JSSubtleCrypto::destroy(JSC::JSCell* cell)
|
|
{
|
|
JSSubtleCrypto* thisObject = static_cast<JSSubtleCrypto*>(cell);
|
|
thisObject->JSSubtleCrypto::~JSSubtleCrypto();
|
|
}
|
|
|
|
JSC_DEFINE_CUSTOM_GETTER(jsSubtleCryptoConstructor, (JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, PropertyName))
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
auto* prototype = jsDynamicCast<JSSubtleCryptoPrototype*>(JSValue::decode(thisValue));
|
|
if (!prototype) [[unlikely]]
|
|
return throwVMTypeError(lexicalGlobalObject, throwScope);
|
|
return JSValue::encode(JSSubtleCrypto::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject()));
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_encryptBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 3) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto key = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "key"_s, "SubtleCrypto"_s, "encrypt"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto data = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer>>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.encrypt(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), *key, WTF::move(data), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_encrypt, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_encryptBody>(*lexicalGlobalObject, *callFrame, "encrypt");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_decryptBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 3) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto key = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "key"_s, "SubtleCrypto"_s, "decrypt"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto data = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer>>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.decrypt(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), *key, WTF::move(data), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_decrypt, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_decryptBody>(*lexicalGlobalObject, *callFrame, "decrypt");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_signBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 3) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto key = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "key"_s, "SubtleCrypto"_s, "sign"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto data = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer>>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.sign(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), *key, WTF::move(data), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_sign, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_signBody>(*lexicalGlobalObject, *callFrame, "sign");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_verifyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 4) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto key = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "key"_s, "SubtleCrypto"_s, "verify"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto signature = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer>>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
|
|
auto data = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer>>(*lexicalGlobalObject, argument3.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.verify(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), *key, WTF::move(signature), WTF::move(data), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_verify, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_verifyBody>(*lexicalGlobalObject, *callFrame, "verify");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_digestBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 2) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto data = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer>>(*lexicalGlobalObject, argument1.value());
|
|
if (throwScope.exception()) [[unlikely]] {
|
|
throwScope.clearException();
|
|
return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "data"_s, "ArrayBuffer, Buffer, TypedArray, or DataView"_s, argument1.value());
|
|
}
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.digest(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), WTF::move(data), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_digest, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_digestBody>(*lexicalGlobalObject, *callFrame, "digest");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_generateKeyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 3) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto extractable = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto keyUsages = convert<IDLSequence<IDLEnumeration<CryptoKeyUsage>>>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.generateKey(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), WTF::move(extractable), WTF::move(keyUsages), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_generateKey, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_generateKeyBody>(*lexicalGlobalObject, *callFrame, "generateKey");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_deriveKeyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 5) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto baseKey = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "baseKey"_s, "SubtleCrypto"_s, "deriveKey"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto derivedKeyType = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
|
|
auto extractable = convert<IDLBoolean>(*lexicalGlobalObject, argument3.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
|
|
auto keyUsages = convert<IDLSequence<IDLEnumeration<CryptoKeyUsage>>>(*lexicalGlobalObject, argument4.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.deriveKey(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), *baseKey, WTF::move(derivedKeyType), WTF::move(extractable), WTF::move(keyUsages), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_deriveKey, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_deriveKeyBody>(*lexicalGlobalObject, *callFrame, "deriveKey");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_deriveBitsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 3) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument0.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto baseKey = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "baseKey"_s, "SubtleCrypto"_s, "deriveBits"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto length = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLArrayBuffer>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.deriveBits(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(algorithm), *baseKey, WTF::move(length), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_deriveBits, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_deriveBitsBody>(*lexicalGlobalObject, *callFrame, "deriveBits");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_importKeyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 5) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto format = convert<IDLEnumeration<SubtleCrypto::KeyFormat>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "format"_s, "SubtleCrypto"_s, "importKey"_s, expectedEnumerationValues<SubtleCrypto::KeyFormat>()); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto keyData = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer, IDLDictionary<JsonWebKey>>>(*lexicalGlobalObject, argument1.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto algorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument2.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
|
|
auto extractable = convert<IDLBoolean>(*lexicalGlobalObject, argument3.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
|
|
auto keyUsages = convert<IDLSequence<IDLEnumeration<CryptoKeyUsage>>>(*lexicalGlobalObject, argument4.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLInterface<CryptoKey>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.importKey(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(format), WTF::move(keyData), WTF::move(algorithm), WTF::move(extractable), WTF::move(keyUsages), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_importKey, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_importKeyBody>(*lexicalGlobalObject, *callFrame, "importKey");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_exportKeyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 2) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto format = convert<IDLEnumeration<SubtleCrypto::KeyFormat>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "format"_s, "SubtleCrypto"_s, "exportKey"_s, expectedEnumerationValues<SubtleCrypto::KeyFormat>()); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto key = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "key"_s, "SubtleCrypto"_s, "exportKey"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) {
|
|
return impl.exportKey(WTF::move(format), *key, WTF::move(promise));
|
|
})));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_exportKey, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_exportKeyBody>(*lexicalGlobalObject, *callFrame, "exportKey");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_wrapKeyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 4) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto format = convert<IDLEnumeration<SubtleCrypto::KeyFormat>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "format"_s, "SubtleCrypto"_s, "wrapKey"_s, expectedEnumerationValues<SubtleCrypto::KeyFormat>()); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto key = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "key"_s, "SubtleCrypto"_s, "wrapKey"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto wrappingKey = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 2, "wrappingKey"_s, "SubtleCrypto"_s, "wrapKey"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
|
|
auto wrapAlgorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument3.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLAny>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.wrapKey(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(format), *key, *wrappingKey, WTF::move(wrapAlgorithm), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_wrapKey, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_wrapKeyBody>(*lexicalGlobalObject, *callFrame, "wrapKey");
|
|
}
|
|
|
|
static inline JSC::EncodedJSValue jsSubtleCryptoPrototypeFunction_unwrapKeyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSSubtleCrypto>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
|
|
{
|
|
auto& vm = JSC::getVM(lexicalGlobalObject);
|
|
auto throwScope = DECLARE_THROW_SCOPE(vm);
|
|
UNUSED_PARAM(throwScope);
|
|
UNUSED_PARAM(callFrame);
|
|
auto& impl = castedThis->wrapped();
|
|
if (callFrame->argumentCount() < 7) [[unlikely]]
|
|
return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
|
|
EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
|
|
auto format = convert<IDLEnumeration<SubtleCrypto::KeyFormat>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "format"_s, "SubtleCrypto"_s, "unwrapKey"_s, expectedEnumerationValues<SubtleCrypto::KeyFormat>()); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
|
|
auto wrappedKey = convert<IDLUnion<IDLArrayBufferView, IDLArrayBuffer>>(*lexicalGlobalObject, argument1.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
|
|
auto unwrappingKey = convert<IDLInterface<CryptoKey>>(*lexicalGlobalObject, argument2.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 2, "unwrappingKey"_s, "SubtleCrypto"_s, "unwrapKey"_s, "CryptoKey"_s); });
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
|
|
auto unwrapAlgorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument3.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
|
|
auto unwrappedKeyAlgorithm = convert<IDLUnion<IDLObject, IDLDOMString>>(*lexicalGlobalObject, argument4.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
|
|
auto extractable = convert<IDLBoolean>(*lexicalGlobalObject, argument5.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
EnsureStillAliveScope argument6 = callFrame->uncheckedArgument(6);
|
|
auto keyUsages = convert<IDLSequence<IDLEnumeration<CryptoKeyUsage>>>(*lexicalGlobalObject, argument6.value());
|
|
RETURN_IF_EXCEPTION(throwScope, {});
|
|
RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLInterface<CryptoKey>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.unwrapKey(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTF::move(format), WTF::move(wrappedKey), *unwrappingKey, WTF::move(unwrapAlgorithm), WTF::move(unwrappedKeyAlgorithm), WTF::move(extractable), WTF::move(keyUsages), WTF::move(promise)); })));
|
|
}
|
|
|
|
JSC_DEFINE_HOST_FUNCTION(jsSubtleCryptoPrototypeFunction_unwrapKey, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
|
|
{
|
|
return IDLOperationReturningPromise<JSSubtleCrypto>::call<jsSubtleCryptoPrototypeFunction_unwrapKeyBody>(*lexicalGlobalObject, *callFrame, "unwrapKey");
|
|
}
|
|
|
|
JSC::GCClient::IsoSubspace* JSSubtleCrypto::subspaceForImpl(JSC::VM& vm)
|
|
{
|
|
return WebCore::subspaceForImpl<JSSubtleCrypto, UseCustomHeapCellType::No>(
|
|
vm,
|
|
[](auto& spaces) { return spaces.m_clientSubspaceForSubtleCrypto.get(); },
|
|
[](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSubtleCrypto = std::forward<decltype(space)>(space); },
|
|
[](auto& spaces) { return spaces.m_subspaceForSubtleCrypto.get(); },
|
|
[](auto& spaces, auto&& space) { spaces.m_subspaceForSubtleCrypto = std::forward<decltype(space)>(space); });
|
|
}
|
|
|
|
void JSSubtleCrypto::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
|
|
{
|
|
auto* thisObject = jsCast<JSSubtleCrypto*>(cell);
|
|
analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
|
|
if (thisObject->scriptExecutionContext())
|
|
analyzer.setLabelForCell(cell, makeString("url "_s, thisObject->scriptExecutionContext()->url().string()));
|
|
Base::analyzeHeap(cell, analyzer);
|
|
}
|
|
|
|
bool JSSubtleCryptoOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, AbstractSlotVisitor& visitor, ASCIILiteral* reason)
|
|
{
|
|
auto* jsSubtleCrypto = jsCast<JSSubtleCrypto*>(handle.slot()->asCell());
|
|
ScriptExecutionContext* owner = WTF::getPtr(jsSubtleCrypto->wrapped().scriptExecutionContext());
|
|
if (!owner)
|
|
return false;
|
|
if (reason) [[unlikely]]
|
|
*reason = "Reachable from ScriptExecutionContext"_s;
|
|
return visitor.containsOpaqueRoot(context);
|
|
}
|
|
|
|
void JSSubtleCryptoOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
|
|
{
|
|
auto* jsSubtleCrypto = static_cast<JSSubtleCrypto*>(handle.slot()->asCell());
|
|
auto& world = *static_cast<DOMWrapperWorld*>(context);
|
|
uncacheWrapper(world, &jsSubtleCrypto->wrapped(), jsSubtleCrypto);
|
|
}
|
|
|
|
#if ENABLE(BINDING_INTEGRITY)
|
|
#if PLATFORM(WIN)
|
|
#pragma warning(disable : 4483)
|
|
extern "C" {
|
|
extern void (*const __identifier("??_7SubtleCrypto@WebCore@@6B@")[])();
|
|
}
|
|
#else
|
|
extern "C" {
|
|
extern void* _ZTVN7WebCore12SubtleCryptoE[];
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<SubtleCrypto>&& impl)
|
|
{
|
|
|
|
if constexpr (std::is_polymorphic_v<SubtleCrypto>) {
|
|
#if ENABLE(BINDING_INTEGRITY)
|
|
// const void* actualVTablePointer = getVTablePointer(impl.ptr());
|
|
#if PLATFORM(WIN)
|
|
void* expectedVTablePointer = __identifier("??_7SubtleCrypto@WebCore@@6B@");
|
|
#else
|
|
// void* expectedVTablePointer = &_ZTVN7WebCore12SubtleCryptoE[2];
|
|
#endif
|
|
|
|
// If you hit this assertion you either have a use after free bug, or
|
|
// SubtleCrypto has subclasses. If SubtleCrypto has subclasses that get passed
|
|
// to toJS() we currently require SubtleCrypto you to opt out of binding hardening
|
|
// by adding the SkipVTableValidation attribute to the interface IDL definition
|
|
// RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
|
|
#endif
|
|
}
|
|
return createWrapper<SubtleCrypto>(globalObject, WTF::move(impl));
|
|
}
|
|
|
|
JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, SubtleCrypto& impl)
|
|
{
|
|
return wrap(lexicalGlobalObject, globalObject, impl);
|
|
}
|
|
|
|
SubtleCrypto* JSSubtleCrypto::toWrapped(JSC::VM&, JSC::JSValue value)
|
|
{
|
|
if (auto* wrapper = jsDynamicCast<JSSubtleCrypto*>(value))
|
|
return &wrapper->wrapped();
|
|
return nullptr;
|
|
}
|
|
|
|
}
|
|
|
|
#endif // ENABLE(WEB_CRYPTO)
|