From e22fac47c4defb95bb8bd8f43d3a28ebd3fbcef2 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Thu, 22 Oct 2026 00:55:32 +0800 Subject: [PATCH] fix(dom): validate ShadowRoot members with native receivers Use generated receiver checks for ShadowRoot members and Text.assignedSlot, and expose enumerable ShadowRoot and slot operations. Share stylesheet caches through the native backing identity and private slots so registered native proxies remain usable without invoking author traps. Cover borrowed bindings, callee-realm TypeErrors, forged/revoked/author proxies, conversion ordering and genuine roots across live, windowless and XML documents. Exercise registered native proxies in both realms. --- .../element/shadow_dom/root_accessors.rs | 28 +++- .../native_bridge/element/shadow_template.rs | 5 +- .../src/script_vm/tests/browser_api/mod.rs | 1 + .../browser_api/shadow_root_receivers.rs | 143 ++++++++++++++++++ .../src/script_vm/tests/dom_xhr/shadow_dom.rs | 2 +- moli-renderer-v8/src/window_host.rs | 3 +- .../fixtures/shadow-root-native-receivers.js | 114 ++++++++++++++ 7 files changed, 284 insertions(+), 12 deletions(-) create mode 100644 moli-renderer-v8/src/script_vm/tests/browser_api/shadow_root_receivers.rs create mode 100644 moli-renderer-v8/tests/fixtures/shadow-root-native-receivers.js 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); +})()