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.
This commit is contained in:
ldm0
2026-11-20 22:47:55 +08:00
parent 187130dec4
commit e22fac47c4
7 changed files with 284 additions and 12 deletions
@@ -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::<v8::Object>::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 {
@@ -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,
@@ -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;
@@ -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/",
"<!doctype html><iframe id=child></iframe>",
);
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/",
"<!doctype html><iframe id=child></iframe>",
);
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::<v8::Array>::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::<v8::Object>::try_from(value).unwrap();
let key = v8::String::new(scope, "target").unwrap();
let value = record.get(scope, key.into()).unwrap();
let target = v8::Local::<v8::Object>::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::<v8::Object>::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");
}
@@ -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]
+2 -1
View File
@@ -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()
{
@@ -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);
})()