From 76652ac3cad64dbc2fd54e976ce4bad0a37caa03 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Sun, 23 Oct 2022 20:25:18 -0700 Subject: Add Web Crypto API (#1384) * Add Web Crypto API * Duplicate symbols * Update c_cpp_properties.json Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com> --- src/bun.js/bindings/webcrypto/JSCryptoKey.cpp | 361 ++++++++++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100644 src/bun.js/bindings/webcrypto/JSCryptoKey.cpp (limited to 'src/bun.js/bindings/webcrypto/JSCryptoKey.cpp') diff --git a/src/bun.js/bindings/webcrypto/JSCryptoKey.cpp b/src/bun.js/bindings/webcrypto/JSCryptoKey.cpp new file mode 100644 index 000000000..dea8e3ff7 --- /dev/null +++ b/src/bun.js/bindings/webcrypto/JSCryptoKey.cpp @@ -0,0 +1,361 @@ +/* + 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" + +#if ENABLE(WEB_CRYPTO) + +#include "JSCryptoKey.h" + +#include "ActiveDOMObject.h" +#include "ExtendedDOMClientIsoSubspaces.h" +#include "ExtendedDOMIsoSubspaces.h" +#include "JSCryptoAesKeyAlgorithm.h" +#include "JSCryptoEcKeyAlgorithm.h" +#include "JSCryptoHmacKeyAlgorithm.h" +#include "JSCryptoKeyAlgorithm.h" +#include "JSCryptoKeyUsage.h" +#include "JSCryptoRsaHashedKeyAlgorithm.h" +#include "JSCryptoRsaKeyAlgorithm.h" +#include "JSDOMAttribute.h" +#include "JSDOMBinding.h" +#include "JSDOMConstructorNotConstructable.h" +#include "JSDOMConvertBoolean.h" +#include "JSDOMConvertDictionary.h" +#include "JSDOMConvertSequences.h" +#include "JSDOMConvertUnion.h" +#include "JSDOMExceptionHandling.h" +#include "JSDOMGlobalObject.h" +#include "JSDOMGlobalObjectInlines.h" +#include "JSDOMWrapperCache.h" +#include "ScriptExecutionContext.h" +#include "WebCoreJSClientData.h" +#include "WebCoreOpaqueRoot.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace WebCore { +using namespace JSC; + +String convertEnumerationToString(CryptoKey::Type enumerationValue) +{ + static const NeverDestroyed values[] = { + MAKE_STATIC_STRING_IMPL("public"), + MAKE_STATIC_STRING_IMPL("private"), + MAKE_STATIC_STRING_IMPL("secret"), + }; + static_assert(static_cast(CryptoKey::Type::Public) == 0, "CryptoKey::Type::Public is not 0 as expected"); + static_assert(static_cast(CryptoKey::Type::Private) == 1, "CryptoKey::Type::Private is not 1 as expected"); + static_assert(static_cast(CryptoKey::Type::Secret) == 2, "CryptoKey::Type::Secret is not 2 as expected"); + ASSERT(static_cast(enumerationValue) < WTF_ARRAY_LENGTH(values)); + return values[static_cast(enumerationValue)]; +} + +template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject, CryptoKey::Type enumerationValue) +{ + return jsStringWithCache(lexicalGlobalObject.vm(), convertEnumerationToString(enumerationValue)); +} + +template<> std::optional parseEnumeration(JSGlobalObject& lexicalGlobalObject, JSValue value) +{ + auto stringValue = value.toWTFString(&lexicalGlobalObject); + static constexpr std::pair mappings[] = { + { "private", CryptoKey::Type::Private }, + { "public", CryptoKey::Type::Public }, + { "secret", CryptoKey::Type::Secret }, + }; + static constexpr SortedArrayMap enumerationMapping { mappings }; + if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue)) + return *enumerationValue; + return std::nullopt; +} + +template<> const char* expectedEnumerationValues() +{ + return "\"public\", \"private\", \"secret\""; +} + +// Attributes + +static JSC_DECLARE_CUSTOM_GETTER(jsCryptoKeyConstructor); +static JSC_DECLARE_CUSTOM_GETTER(jsCryptoKey_type); +static JSC_DECLARE_CUSTOM_GETTER(jsCryptoKey_extractable); +static JSC_DECLARE_CUSTOM_GETTER(jsCryptoKey_algorithm); +static JSC_DECLARE_CUSTOM_GETTER(jsCryptoKey_usages); + +class JSCryptoKeyPrototype final : public JSC::JSNonFinalObject { +public: + using Base = JSC::JSNonFinalObject; + static JSCryptoKeyPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure) + { + JSCryptoKeyPrototype* ptr = new (NotNull, JSC::allocateCell(vm)) JSCryptoKeyPrototype(vm, globalObject, structure); + ptr->finishCreation(vm); + return ptr; + } + + DECLARE_INFO; + template + static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm) + { + STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoKeyPrototype, 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: + JSCryptoKeyPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure) + : JSC::JSNonFinalObject(vm, structure) + { + } + + void finishCreation(JSC::VM&); +}; +STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoKeyPrototype, JSCryptoKeyPrototype::Base); + +using JSCryptoKeyDOMConstructor = JSDOMConstructorNotConstructable; + +template<> const ClassInfo JSCryptoKeyDOMConstructor::s_info = { "CryptoKey"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoKeyDOMConstructor) }; + +template<> JSValue JSCryptoKeyDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject) +{ + UNUSED_PARAM(vm); + return globalObject.functionPrototype(); +} + +template<> void JSCryptoKeyDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject) +{ + putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum); + JSString* nameString = jsNontrivialString(vm, "CryptoKey"_s); + m_originalName.set(vm, this, nameString); + putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum); + putDirect(vm, vm.propertyNames->prototype, JSCryptoKey::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete); +} + +/* Hash table for prototype */ + +static const HashTableValue JSCryptoKeyPrototypeTableValues[] = +{ + { "constructor"_s, static_cast(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::GetterSetterType, jsCryptoKeyConstructor, 0 } }, + { "type"_s, static_cast(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, jsCryptoKey_type, 0 } }, + { "extractable"_s, static_cast(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, jsCryptoKey_extractable, 0 } }, + { "algorithm"_s, static_cast(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, jsCryptoKey_algorithm, 0 } }, + { "usages"_s, static_cast(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, jsCryptoKey_usages, 0 } }, +}; + +const ClassInfo JSCryptoKeyPrototype::s_info = { "CryptoKey"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoKeyPrototype) }; + +void JSCryptoKeyPrototype::finishCreation(VM& vm) +{ + Base::finishCreation(vm); + reifyStaticProperties(vm, JSCryptoKey::info(), JSCryptoKeyPrototypeTableValues, *this); + JSC_TO_STRING_TAG_WITHOUT_TRANSITION(); +} + +const ClassInfo JSCryptoKey::s_info = { "CryptoKey"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoKey) }; + +JSCryptoKey::JSCryptoKey(Structure* structure, JSDOMGlobalObject& globalObject, Ref&& impl) + : JSDOMWrapper(structure, globalObject, WTFMove(impl)) +{ +} + +void JSCryptoKey::finishCreation(VM& vm) +{ + Base::finishCreation(vm); + ASSERT(inherits(info())); + + // static_assert(!std::is_base_of::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject."); + +} + +JSObject* JSCryptoKey::createPrototype(VM& vm, JSDOMGlobalObject& globalObject) +{ + return JSCryptoKeyPrototype::create(vm, &globalObject, JSCryptoKeyPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype())); +} + +JSObject* JSCryptoKey::prototype(VM& vm, JSDOMGlobalObject& globalObject) +{ + return getDOMPrototype(vm, globalObject); +} + +JSValue JSCryptoKey::getConstructor(VM& vm, const JSGlobalObject* globalObject) +{ + return getDOMConstructor(vm, *jsCast(globalObject)); +} + +void JSCryptoKey::destroy(JSC::JSCell* cell) +{ + JSCryptoKey* thisObject = static_cast(cell); + thisObject->JSCryptoKey::~JSCryptoKey(); +} + +JSC_DEFINE_CUSTOM_GETTER(jsCryptoKeyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)) +{ + VM& vm = JSC::getVM(lexicalGlobalObject); + auto throwScope = DECLARE_THROW_SCOPE(vm); + auto* prototype = jsDynamicCast(JSValue::decode(thisValue)); + if (UNLIKELY(!prototype)) + return throwVMTypeError(lexicalGlobalObject, throwScope); + return JSValue::encode(JSCryptoKey::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject())); +} + +static inline JSValue jsCryptoKey_typeGetter(JSGlobalObject& lexicalGlobalObject, JSCryptoKey& thisObject) +{ + auto& vm = JSC::getVM(&lexicalGlobalObject); + auto throwScope = DECLARE_THROW_SCOPE(vm); + auto& impl = thisObject.wrapped(); + RELEASE_AND_RETURN(throwScope, (toJS>(lexicalGlobalObject, throwScope, impl.type()))); +} + +JSC_DEFINE_CUSTOM_GETTER(jsCryptoKey_type, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) +{ + return IDLAttribute::get(*lexicalGlobalObject, thisValue, attributeName); +} + +static inline JSValue jsCryptoKey_extractableGetter(JSGlobalObject& lexicalGlobalObject, JSCryptoKey& thisObject) +{ + auto& vm = JSC::getVM(&lexicalGlobalObject); + auto throwScope = DECLARE_THROW_SCOPE(vm); + auto& impl = thisObject.wrapped(); + RELEASE_AND_RETURN(throwScope, (toJS(lexicalGlobalObject, throwScope, impl.extractable()))); +} + +JSC_DEFINE_CUSTOM_GETTER(jsCryptoKey_extractable, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) +{ + return IDLAttribute::get(*lexicalGlobalObject, thisValue, attributeName); +} + +static inline JSValue jsCryptoKey_algorithmGetter(JSGlobalObject& lexicalGlobalObject, JSCryptoKey& thisObject) +{ + auto& vm = JSC::getVM(&lexicalGlobalObject); + auto throwScope = DECLARE_THROW_SCOPE(vm); + if (JSValue cachedValue = thisObject.m_algorithm.get()) + return cachedValue; + auto& impl = thisObject.wrapped(); + JSValue result = toJS, IDLDictionary, IDLDictionary, IDLDictionary, IDLDictionary, IDLDictionary>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.algorithm()); + RETURN_IF_EXCEPTION(throwScope, { }); + thisObject.m_algorithm.set(JSC::getVM(&lexicalGlobalObject), &thisObject, result); + return result; +} + +JSC_DEFINE_CUSTOM_GETTER(jsCryptoKey_algorithm, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) +{ + return IDLAttribute::get(*lexicalGlobalObject, thisValue, attributeName); +} + +static inline JSValue jsCryptoKey_usagesGetter(JSGlobalObject& lexicalGlobalObject, JSCryptoKey& thisObject) +{ + auto& vm = JSC::getVM(&lexicalGlobalObject); + auto throwScope = DECLARE_THROW_SCOPE(vm); + if (JSValue cachedValue = thisObject.m_usages.get()) + return cachedValue; + auto& impl = thisObject.wrapped(); + JSValue result = toJS>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.usages()); + RETURN_IF_EXCEPTION(throwScope, { }); + thisObject.m_usages.set(JSC::getVM(&lexicalGlobalObject), &thisObject, result); + return result; +} + +JSC_DEFINE_CUSTOM_GETTER(jsCryptoKey_usages, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) +{ + return IDLAttribute::get(*lexicalGlobalObject, thisValue, attributeName); +} + +JSC::GCClient::IsoSubspace* JSCryptoKey::subspaceForImpl(JSC::VM& vm) +{ + return WebCore::subspaceForImpl(vm, + [] (auto& spaces) { return spaces.m_clientSubspaceForCryptoKey.get(); }, + [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoKey = WTFMove(space); }, + [] (auto& spaces) { return spaces.m_subspaceForCryptoKey.get(); }, + [] (auto& spaces, auto&& space) { spaces.m_subspaceForCryptoKey = WTFMove(space); } + ); +} + +template +void JSCryptoKey::visitChildrenImpl(JSCell* cell, Visitor& visitor) +{ + auto* thisObject = jsCast(cell); + ASSERT_GC_OBJECT_INHERITS(thisObject, info()); + Base::visitChildren(thisObject, visitor); + visitor.append(thisObject->m_algorithm); + visitor.append(thisObject->m_usages); +} + +DEFINE_VISIT_CHILDREN(JSCryptoKey); + +void JSCryptoKey::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer) +{ + auto* thisObject = jsCast(cell); + analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped()); + if (thisObject->scriptExecutionContext()) + analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string()); + Base::analyzeHeap(cell, analyzer); +} + +bool JSCryptoKeyOwner::isReachableFromOpaqueRoots(JSC::Handle handle, void* context, AbstractSlotVisitor& visitor, const char** reason) +{ + auto* jsCryptoKey = jsCast(handle.slot()->asCell()); + CryptoKey* owner = &jsCryptoKey->wrapped(); + if (UNLIKELY(reason)) + *reason = "Reachable from CryptoKey"; + return visitor.containsOpaqueRoot(context); +} + +void JSCryptoKeyOwner::finalize(JSC::Handle handle, void* context) +{ + auto* jsCryptoKey = static_cast(handle.slot()->asCell()); + auto& world = *static_cast(context); + uncacheWrapper(world, &jsCryptoKey->wrapped(), jsCryptoKey); +} + +JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref&& impl) +{ + return createWrapper(globalObject, WTFMove(impl)); +} + +JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, CryptoKey& impl) +{ + return wrap(lexicalGlobalObject, globalObject, impl); +} + +CryptoKey* JSCryptoKey::toWrapped(JSC::VM&, JSC::JSValue value) +{ + if (auto* wrapper = jsDynamicCast(value)) + return &wrapper->wrapped(); + return nullptr; +} + +} + +#endif // ENABLE(WEB_CRYPTO) -- cgit v1.2.3