diff --git a/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs b/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs index fee921b3f8c..74cac5356dd 100644 --- a/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs +++ b/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs @@ -27,7 +27,7 @@ use moli_web_mime::{ use std::collections::{HashMap, HashSet}; use super::super::super::node::{ - node_runtime_and_handle_from_args, node_runtime_and_handle_from_object, + node_backing_object, node_runtime_and_handle_from_args, node_runtime_and_handle_from_object, node_runtime_and_handle_from_object_or_detached, }; use super::super::property_string_value; @@ -199,6 +199,10 @@ fn get_shadow_root_adopted_style_sheets_for_receiver<'s>( receiver: v8::Local<'s, v8::Object>, rv: &mut v8::ReturnValue<'_, v8::Value>, ) { + let Some(receiver) = node_backing_object(scope, receiver) else { + throw_shadow_root_style_sheets_illegal_invocation(scope, "adoptedStyleSheets"); + return; + }; let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object_or_detached(scope, receiver) else { @@ -233,6 +237,9 @@ pub(crate) fn ensure_shadow_root_adopted_style_sheets_initialized<'s>( handle: crate::document_runtime::DomHandle, holder: v8::Local<'s, v8::Object>, ) { + let Some(holder) = node_backing_object(scope, holder) else { + return; + }; let array = v8::Array::new(scope, 0); if let Some(existing) = get_private_value(scope, holder, SHADOW_ROOT_ADOPTED_STYLE_SHEETS_SLOT) && !existing.is_undefined() @@ -283,7 +290,9 @@ pub(crate) fn clear_shadow_root_adopted_style_sheets( handle: crate::document_runtime::DomHandle, ) { runtime.set_shadow_root_adopted_style_sheet_installations(handle, Vec::new()); - let Some(holder) = node_wrapper_from_handle(scope, handle) else { + let Some(holder) = node_wrapper_from_handle(scope, handle) + .and_then(|holder| node_backing_object(scope, holder)) + else { return; }; if let Some(existing) = get_private_value(scope, holder, SHADOW_ROOT_ADOPTED_STYLE_SHEETS_SLOT) @@ -638,6 +647,10 @@ fn set_shadow_root_adopted_style_sheets_for_receiver<'s>( receiver: v8::Local<'s, v8::Object>, value: v8::Local<'s, v8::Value>, ) { + let Some(receiver) = node_backing_object(scope, receiver) else { + throw_shadow_root_style_sheets_illegal_invocation(scope, "adoptedStyleSheets"); + return; + }; let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object_or_detached(scope, receiver) else { @@ -766,6 +779,10 @@ fn get_shadow_root_style_sheets_for_receiver<'s>( receiver: v8::Local<'s, v8::Object>, rv: &mut v8::ReturnValue<'_, v8::Value>, ) { + let Some(receiver) = node_backing_object(scope, receiver) else { + throw_shadow_root_style_sheets_illegal_invocation(scope, "styleSheets"); + return; + }; let is_live_receiver = node_runtime_and_handle_from_object(scope, receiver).is_ok(); let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object_or_detached(scope, receiver) @@ -780,10 +797,7 @@ fn get_shadow_root_style_sheets_for_receiver<'s>( return; } let holder = receiver; - let slot = v8str(scope, SHADOW_ROOT_STYLE_SHEETS_SLOT); - if let Some(existing) = holder.get(scope, slot.into()) - && !existing.is_undefined() - { + if let Some(existing) = get_private_value(scope, holder, SHADOW_ROOT_STYLE_SHEETS_SLOT) { if let Ok(list) = v8::Local::::try_from(existing) { if is_live_receiver { sync_shadow_root_style_sheets(scope, list, unsafe { &*runtime_ptr }, handle); @@ -803,7 +817,7 @@ fn get_shadow_root_style_sheets_for_receiver<'s>( return; } let list = new_style_sheet_list_object(scope); - let _ = holder.set(scope, slot.into(), list.into()); + set_private_value(scope, holder, SHADOW_ROOT_STYLE_SHEETS_SLOT, list.into()); if is_live_receiver { sync_shadow_root_style_sheets(scope, list, unsafe { &*runtime_ptr }, handle); } else { diff --git a/moli-renderer-v8/src/native_bridge/element/shadow_template.rs b/moli-renderer-v8/src/native_bridge/element/shadow_template.rs index 4394aa4400e..446760ef261 100644 --- a/moli-renderer-v8/src/native_bridge/element/shadow_template.rs +++ b/moli-renderer-v8/src/native_bridge/element/shadow_template.rs @@ -1,12 +1,11 @@ use super::*; #[derive(WebApiFunctionTemplate)] -#[webapi(interface = web_api_interfaces::ShadowRoot)] +#[webapi(interface = web_api_interfaces::ShadowRoot, enumerable)] pub(super) struct ShadowRootPrototypeReflectionDeclaration { #[webapi( accessor_property = "onslotchange", enumerable, - receiver = web_api_interfaces::ShadowRoot::is_instance, getter = event_handlers::shadow_root_event_handler_getter_function, setter = event_handlers::shadow_root_event_handler_setter_function, data = v8str(scope, "onslotchange") @@ -99,7 +98,7 @@ pub(super) struct TextPrototypeReflectionDeclaration { } #[derive(WebApiFunctionTemplate)] -#[webapi(interface = web_api_interfaces::HTMLSlotElement)] +#[webapi(interface = web_api_interfaces::HTMLSlotElement, enumerable)] pub(super) struct HtmlSlotElementPrototypeDeclaration { #[webapi( accessor_property, diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs index 3bc3bbe56cb..a1cd7935c83 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs @@ -133,6 +133,7 @@ mod security_policy_event_init; mod service_worker_drain; mod session_description; mod shadow_root_init; +mod shadow_root_receivers; mod simple_event_dispatch; mod simple_event_dispatch; mod simple_event_target_handlers; diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/shadow_root_receivers.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/shadow_root_receivers.rs new file mode 100644 index 00000000000..62020a62d46 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/shadow_root_receivers.rs @@ -0,0 +1,143 @@ +use super::*; + +#[test] +fn shadow_root_members_validate_receivers_before_argument_conversion() { + let mut vm = new_parsed_test_vm( + "https://shadow-root-receivers.test/", + "", + ); + let result = vm + .eval(include_str!( + "../../../../tests/fixtures/shadow-root-native-receivers.js" + )) + .expect("ShadowRoot receiver matrix should complete"); + assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "3892"); + assert_eq!( + result, + "true", + "{}", + vm.eval("JSON.stringify(__uiEventResults.rows.filter(row => !row.passed))") + .unwrap(), + ); +} + +#[test] +fn shadow_root_members_accept_registered_native_proxies_without_author_traps() { + let mut vm = new_parsed_test_vm( + "https://shadow-root-native-proxies.test/", + "", + ); + vm.eval( + r#" + globalThis.shadowProxyRecords = []; + globalThis.shadowProxyTraps = 0; + const other = document.querySelector('#child').contentWindow; + for (const owner of [globalThis, other]) for (const flavor of ['live', 'html', 'xml']) { + const doc = flavor === 'live' ? owner.document : flavor === 'html' ? + owner.document.implementation.createHTMLDocument('shadow') : + owner.document.implementation.createDocument(null, 'r'); + for (const mode of ['open', 'closed']) { + const host = doc.createElementNS('http://www.w3.org/1999/xhtml', 'div'); + const root = host.attachShadow({mode, delegatesFocus: true, clonable: true, serializable: true}); + const text = host.appendChild(doc.createTextNode('text')); + const slot = root.appendChild(doc.createElementNS('http://www.w3.org/1999/xhtml', 'slot')); + (doc.body || doc.documentElement).appendChild(host); + for (const kind of ['ShadowRoot', 'Text']) shadowProxyRecords.push({ + owner, doc, host, root, text, slot, mode, kind, target: kind === 'Text' ? text : root, + callee: owner === globalThis ? other : globalThis, + handler: { + get() {shadowProxyTraps++; throw Error('get trap');}, + getPrototypeOf() {shadowProxyTraps++; throw Error('prototype trap');} + } + }); + } + } + true; + "#, + ) + .unwrap(); + vm.with_default_context_scope_and_checkpoint_for_test(|scope, _host_ptr| { + let global = scope.get_current_context().global(scope); + let key = v8::String::new(scope, "shadowProxyRecords").unwrap(); + let value = global.get(scope, key.into()).unwrap(); + let records = v8::Local::::try_from(value).unwrap(); + assert_eq!(records.length(), 24); + for index in 0..records.length() { + let value = records.get_index(scope, index).unwrap(); + let record = v8::Local::::try_from(value).unwrap(); + let key = v8::String::new(scope, "target").unwrap(); + let value = record.get(scope, key.into()).unwrap(); + let target = v8::Local::::try_from(value).unwrap(); + let target = moli_webapi_declare::web_api_object_target(scope, target).unwrap(); + let context = target.get_creation_context(scope).unwrap(); + let key = v8::String::new(scope, "handler").unwrap(); + let value = record.get(scope, key.into()).unwrap(); + let handler = v8::Local::::try_from(value).unwrap(); + let proxy = { + let scope = &mut v8::ContextScope::new(scope, context); + let proxy = v8::Proxy::new(scope, target, handler).unwrap(); + moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap(); + proxy + }; + assert_eq!( + crate::web_api_interfaces::ShadowRoot::is_instance(scope, proxy.into()), + index % 2 == 0, + ); + assert_eq!( + crate::web_api_interfaces::Text::is_instance(scope, proxy.into()), + index % 2 != 0, + ); + let key = v8::String::new(scope, "proxy").unwrap(); + assert!(record.set(scope, key.into(), proxy.into()).unwrap()); + } + Ok(()) + }) + .unwrap(); + assert_eq!(vm.eval(r#"(() => { + for (const [index, record] of shadowProxyRecords.entries()) { + const {callee, target, proxy, kind, root, host, mode, slot} = record; + const check = (passed, name) => {if (!passed) throw Error(`${index}/${kind}: ${name}`);}; + const proto = callee[kind].prototype; + const descriptor = name => Object.getOwnPropertyDescriptor(proto, name); + const typeError = body => { + try {body(); return false;} + catch (error) {return Object.getPrototypeOf(error) === callee.TypeError.prototype;} + }; + const author = new Proxy(proxy, {}); + if (kind === 'Text') { + check(descriptor('assignedSlot').get.call(proxy) === (mode === 'open' ? slot : null), 'native slot'); + check(typeError(() => descriptor('assignedSlot').get.call(author)), 'author Text proxy'); + } else { + for (const name of ['host', 'mode', 'delegatesFocus', 'slotAssignment', 'clonable', + 'serializable', 'activeElement', 'innerHTML', 'styleSheets', 'adoptedStyleSheets', 'onslotchange']) { + const get = descriptor(name).get; + check(get.call(proxy) === get.call(target), 'native getter ' + name); + check(typeError(() => get.call(author)), 'author root proxy ' + name); + } + check(descriptor('host').get.call(proxy) === host && descriptor('mode').get.call(proxy) === mode, + 'native shadow state'); + let conversions = 0; + const poison = {toString() {conversions++; return '';}, + get [Symbol.iterator]() {conversions++; throw 1;}, + get serializableShadowRoots() {conversions++; throw 1;}}; + check(typeError(() => descriptor('innerHTML').set.call(author, poison)) && + typeError(() => descriptor('adoptedStyleSheets').set.call(author, poison)) && + typeError(() => proto.getHTML.call(author, poison)) && + typeError(() => proto.setHTMLUnsafe.call(author, poison)) && conversions === 0, + 'author proxy before conversion'); + let calls = 0; + const handler = () => calls++; + descriptor('onslotchange').set.call(proxy, handler); + callee.EventTarget.prototype.dispatchEvent.call(proxy, new callee.Event('slotchange')); + check(calls === 1 && descriptor('onslotchange').get.call(target) === handler, 'native event handler'); + descriptor('onslotchange').set.call(proxy, null); + descriptor('adoptedStyleSheets').set.call(proxy, []); + check(descriptor('adoptedStyleSheets').get.call(root).length === 0, 'native stylesheet setter'); + check(proto.getHTML.call(proxy) === proto.getHTML.call(target), 'native serialization'); + check(proto.getSelection.call(proxy) === proto.getSelection.call(target), 'native selection'); + } + check(shadowProxyTraps === 0, 'no author traps'); + } + return true; + })()"#).unwrap(), "true"); +} diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs index 63f0d6c678f..bf43c044849 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs @@ -718,7 +718,7 @@ fn html_slot_element_assigned_node_methods_surface_current_assignments() { assert_eq!( result, - "function|function|true|true|true|false|false|false|false|false|false|0|0|0|assignedNodes|assignedElements|assign|1|attachShadow|1|true|1|true|true" + "function|function|true|true|true|false|false|false|true|true|true|0|0|0|assignedNodes|assignedElements|assign|1|attachShadow|1|true|1|true|true" ); } #[test] diff --git a/moli-renderer-v8/src/window_host.rs b/moli-renderer-v8/src/window_host.rs index cc6fe94b9d1..66271b709db 100644 --- a/moli-renderer-v8/src/window_host.rs +++ b/moli-renderer-v8/src/window_host.rs @@ -2135,7 +2135,8 @@ fn event_target_handle_from_receiver<'s>( { return Some(EventTargetHandle::Node(handle)); } - if let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object(scope, this) + if let Ok((runtime_ptr, handle)) = + crate::native_bridge::node_runtime_and_handle_from_object_or_detached(scope, this) && runtime_ptr == host_ptr && host.dom_host().node(handle).is_some() { diff --git a/moli-renderer-v8/tests/fixtures/shadow-root-native-receivers.js b/moli-renderer-v8/tests/fixtures/shadow-root-native-receivers.js new file mode 100644 index 00000000000..19d7a64738f --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/shadow-root-native-receivers.js @@ -0,0 +1,114 @@ +(() => { + const rows = []; + function check(name, body) { + try { rows.push({name, passed: body() === true}); } + catch (error) { rows.push({name, passed: false, error: String(error)}); } + } + function typeError(realm, body) { + try { body(); return false; } + catch (error) { return Object.getPrototypeOf(error) === realm.TypeError.prototype; } + } + const realms = [['top', globalThis], ['child', document.querySelector('#child').contentWindow]]; + const getters = ['host', 'mode', 'delegatesFocus', 'slotAssignment', 'clonable', + 'serializable', 'activeElement', 'innerHTML', 'styleSheets', 'adoptedStyleSheets', 'onslotchange']; + function sample(owner, flavor, mode = 'open') { + const doc = flavor === 'html' ? owner.document.implementation.createHTMLDocument('shadow') : + flavor === 'xml' ? owner.document.implementation.createDocument(null, 'r') : owner.document; + const host = doc.createElementNS('http://www.w3.org/1999/xhtml', 'div'); + const root = host.attachShadow({mode, delegatesFocus: true, clonable: true, serializable: true}); + const text = doc.createTextNode('text'); + host.appendChild(text); + (doc.body || doc.documentElement).appendChild(host); + return {doc, host, root, text}; + } + function withSample(owner, flavor, mode, body) { + const value = sample(owner, flavor, mode); + try { return body(value); } + finally { value.host.remove(); } + } + function invalidValues(owner, value, seen) { + const revoked = owner.Proxy.revocable(value.root, {}); revoked.revoke(); + return [ + ['undefined', undefined], ['null', null], ['number', 1], ['string', 'root'], + ['symbol', Symbol('root')], ['object', {}], ['function', function() {}], + ['prototype', Object.create(owner.ShadowRoot.prototype)], + ['inherited', Object.create(value.root)], ['fragment', value.doc.createDocumentFragment()], + ['document', value.doc], ['element', value.host], ['text', value.text], + ['author proxy', new owner.Proxy(value.root, { + get() {seen.push('get'); throw Error('author get');}, + getPrototypeOf() {seen.push('getPrototypeOf'); throw Error('author prototype');} + })], ['revoked', revoked.proxy] + ]; + } + for (const [calleeName, callee] of realms) { + for (const [proto, names] of [ + [callee.ShadowRoot.prototype, ['getHTML', 'setHTMLUnsafe', 'elementFromPoint', 'elementsFromPoint', 'getSelection']], + [callee.HTMLSlotElement.prototype, ['assignedNodes', 'assignedElements', 'assign']] + ]) for (const name of names) check(`${calleeName} ${name} method descriptor`, () => { + const d = Object.getOwnPropertyDescriptor(proto, name); + return d?.enumerable === true && d.configurable === true && d.writable === true && typeof d.value === 'function'; + }); + for (const [ownerName, owner] of realms) for (const flavor of ['live', 'html', 'xml']) { + const label = `${calleeName} binding ${ownerName} ${flavor}`; + withSample(owner, flavor, 'open', value => { + const seen = []; + for (const [badName, receiver] of invalidValues(owner, value, seen)) { + for (const name of getters) check(`${label} ${name} rejects ${badName} without traps`, () => { + seen.length = 0; + const get = Object.getOwnPropertyDescriptor(callee.ShadowRoot.prototype, name).get; + return typeError(callee, () => Reflect.apply(get, receiver, [])) && seen.length === 0; + }); + for (const name of ['innerHTML', 'adoptedStyleSheets', 'onslotchange']) + check(`${label} ${name} setter rejects ${badName} before conversion`, () => { + seen.length = 0; let conversions = 0; + const arg = {toString() {conversions++; return '';}, + get [Symbol.iterator]() {conversions++; throw Error('sequence conversion');}}; + const set = Object.getOwnPropertyDescriptor(callee.ShadowRoot.prototype, name).set; + return typeError(callee, () => Reflect.apply(set, receiver, [arg])) && conversions === 0 && seen.length === 0; + }); + for (const name of ['getHTML', 'setHTMLUnsafe', 'elementFromPoint', 'elementsFromPoint', 'getSelection']) + check(`${label} ${name} rejects ${badName} before conversion`, () => { + seen.length = 0; let conversions = 0; + const arg = {valueOf() {conversions++; return 0;}, toString() {conversions++; return '';}, + get serializableShadowRoots() {conversions++; return false;}}; + return typeError(callee, () => Reflect.apply(callee.ShadowRoot.prototype[name], receiver, [arg, arg])) && + conversions === 0 && seen.length === 0; + }); + } + }); + for (const mode of ['open', 'closed']) for (const name of getters) + check(`${label} ${name} accepts genuine ${mode} root with poisoned public state`, () => + withSample(owner, flavor, mode, ({host, root}) => { + const get = Object.getOwnPropertyDescriptor(callee.ShadowRoot.prototype, name).get; + let reads = 0; + for (const prop of ['nodeType', 'ownerDocument', 'parentNode', 'host', 'mode']) + Object.defineProperty(root, prop, {configurable: true, get() {reads++; throw Error(prop);}}); + const value = Reflect.apply(get, root, []); + return reads === 0 && (name === 'host' ? value === host : name === 'mode' ? value === mode : + ['delegatesFocus', 'clonable', 'serializable'].includes(name) ? value === true : + name === 'slotAssignment' ? value === 'named' : name === 'innerHTML' ? value === '' : + ['styleSheets', 'adoptedStyleSheets'].includes(name) ? value.length === 0 : value === null); + })); + check(`${label} innerHTML setter preserves conversion exception identity`, () => + withSample(owner, flavor, 'open', ({root}) => { + const sentinel = {}; let conversions = 0; + try { Object.getOwnPropertyDescriptor(callee.ShadowRoot.prototype, 'innerHTML').set.call(root, + {toString() {conversions++; throw sentinel;}}); return false; } + catch (error) {return error === sentinel && conversions === 1;} + })); + withSample(owner, flavor, 'open', value => { + const get = Object.getOwnPropertyDescriptor(callee.Text.prototype, 'assignedSlot').get; + const seen = []; + for (const [badName, receiver] of invalidValues(owner, value, seen).filter(([name]) => name !== 'text')) + check(`${label} Text.assignedSlot rejects ${badName}`, () => { + seen.length = 0; + return typeError(callee, () => Reflect.apply(get, receiver, [])) && seen.length === 0; + }); + check(`${label} Text.assignedSlot accepts genuine Text`, () => Reflect.apply(get, value.text, []) === null); + }); + } + } + globalThis.__uiEventResults = {complete: true, total: rows.length, + passed: rows.filter(row => row.passed).length, rows}; + return rows.every(row => row.passed); +})()