From cf2d92804042e4a87c04458da998ef751ce77510 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Mon, 28 Sep 2026 06:56:19 +0800 Subject: [PATCH] fix(referrer): persist meta policy on each document Apply meta referrer delivery on insertion and attribute changes, preserve it across removal and document.open(), and share the state with Fetch, XHR, and existing script consumers. Cover temporal ordering, namespaces, windowless documents, cloning, and main/child/popup network owners. --- moli-core/tests/scripts/integrity.rs | 6 + .../tests/scripts/meta_referrer_policy.rs | 213 ++++++++++++++++++ moli-dom/src/native/attributes.rs | 4 + moli-dom/src/native/document.rs | 7 + moli-renderer-v8/src/context_bootstrap.rs | 4 +- .../src/document_runtime/security_policy.rs | 11 +- 6 files changed, 238 insertions(+), 7 deletions(-) create mode 100644 moli-core/tests/scripts/meta_referrer_policy.rs diff --git a/moli-core/tests/scripts/integrity.rs b/moli-core/tests/scripts/integrity.rs index 5039ecf52e1..52445158fb2 100644 --- a/moli-core/tests/scripts/integrity.rs +++ b/moli-core/tests/scripts/integrity.rs @@ -46,6 +46,9 @@ mod modulepreload_document_referrer; #[path = "classic_document_referrer.rs"] mod classic_document_referrer; +#[path = "meta_referrer_policy.rs"] +mod meta_referrer_policy; + struct IntegrityServers { origin: String, cross_origin: String, @@ -202,6 +205,9 @@ fn fixture_response( let (path, query) = request.path.split_once('?').unwrap_or((&request.path, "")); let javascript = "Content-Type: text/javascript\r\n"; match path { + "/meta-policy.html" | "/meta-policy.js" | "/meta-policy-fetch" => { + meta_referrer_policy::fixture_response(path, request.referer.as_deref()) + } "/classic-policy.html" | "/classic-policy.js" => { classic_document_referrer::fixture_response(path, query, origin, cross) } diff --git a/moli-core/tests/scripts/meta_referrer_policy.rs b/moli-core/tests/scripts/meta_referrer_policy.rs new file mode 100644 index 00000000000..ea4eebc4eea --- /dev/null +++ b/moli-core/tests/scripts/meta_referrer_policy.rs @@ -0,0 +1,213 @@ +use super::*; + +pub(super) fn fixture_response( + path: &str, + referrer: Option<&str>, +) -> (&'static str, String, String) { + let (content_type, body) = match path { + "/meta-policy.html" => ( + "text/html", + r#"Policy document + "#.to_owned(), + ), + "/meta-policy.js" => ("text/javascript", "/* policy probe */".to_owned()), + _ => ("application/json", serde_json::to_string(&referrer).unwrap()), + }; + ( + "200 OK", + format!( + "Content-Type: {content_type}\r\nCache-Control: no-store\r\nReferrer-Policy: unsafe-url\r\nAccess-Control-Allow-Origin: *\r\n" + ), + body, + ) +} + +async fn check_meta_policy(owner: &str) -> Result<()> { + let servers = IntegrityServers::spawn().await?; + let browser = Browser::new(AppConfig::default())?; + let document_url = format!("{}/meta-policy.html?owner={owner}", servers.origin); + let parent_url = format!( + "{}/document-referrer.html?response=no-referrer", + servers.origin + ); + let mut page = browser + .fetch(if owner == "main" { + &document_url + } else { + &parent_url + }) + .await?; + let probe = format!( + r#"(async () => {{ + const observations = []; + let index = 0; + async function check(label, expected) {{ + for (const origin of {origins}) {{ + const id = ++index; + const resource = origin + '/meta-policy-fetch?' + id; + const actual = await (await fetch(resource)).json(); + if (actual !== expected) throw new Error(label + ': fetch ' + actual + ' != ' + expected); + const explicit = await (await fetch(resource + '-explicit', {{referrerPolicy:'unsafe-url'}})).json(); + if (explicit !== location.href) throw new Error(label + ': explicit policy ' + explicit); + const xhr = new XMLHttpRequest(); + const value = await new Promise((resolve,reject) => {{ + xhr.open('GET', resource + '-xhr'); + xhr.onload = () => resolve(JSON.parse(xhr.responseText)); xhr.onerror = reject; xhr.send(); + }}); + if (value !== expected) throw new Error(label + ': XHR ' + value + ' != ' + expected); + const sync = new XMLHttpRequest(); + sync.open('GET', resource + '-sync-xhr', false); sync.send(); + const syncValue = JSON.parse(sync.responseText); + if (syncValue !== expected) throw new Error(label + ': sync XHR ' + syncValue + ' != ' + expected); + const observation = {{expected}}; + if ({check_scripts}) {{ + const url = origin + '/meta-policy.js?' + id; + await new Promise((resolve,reject) => {{ + const script = document.createElement('script'); script.src=url; + script.onload=resolve; script.onerror=reject; document.body.append(script); + }}); + observation.url = url; + }} + observations.push(observation); + }} + }} + const origin = location.origin + '/'; + const first = document.getElementById('first'); + await check('parser meta overrides response', null); + const second = document.createElement('meta'); second.name='referrer'; second.content='origin'; + document.head.insertBefore(second,first); + await check('most recent insertion before older meta', origin); + first.content='no-referrer'; + await check('same-value assignment delivers again', null); + first.remove(); + await check('removal does not undo delivery', null); + first.content='unsafe-url'; + await check('detached mutation has no effect', null); + document.body.append(first); + await check('body insertion delivers policy', location.href); + first.content='never'; + await check('legacy never', null); + first.content='always'; + await check('legacy always', location.href); + first.content='origin'; + for (const value of ['', ' origin', 'origin, no-referrer', 'future-policy']) first.content=value; + await check('invalid values retain current policy', origin); + first.name='other'; first.content='no-referrer'; + await check('other metadata ignored', origin); + first.name='REFERRER'; + await check('name change delivers content', null); + const host=document.createElement('div');document.body.append(host); + const shadow=host.attachShadow({{mode:'open'}}); + const hidden=document.createElement('meta'); hidden.name='referrer'; hidden.content='unsafe-url'; + shadow.append(hidden); hidden.content='origin'; + await check('shadow metadata ignored', null); + first.setAttributeNS('urn:other','content','unsafe-url'); + await check('namespaced content ignored', null); + first.setAttributeNS(null,'content','origin'); + await check('null namespace content applies', origin); + first.remove(); second.remove(); + await check('all metadata removed', origin); + return JSON.stringify(observations); + }})()"#, + origins = serde_json::to_string(&[&servers.origin, &servers.cross_origin])?, + // Lightweight popups do not yet schedule dynamically inserted scripts. + // Keep their Fetch and synchronous/asynchronous XHR coverage independent. + check_scripts = owner != "popup", + ); + let expression = match owner { + "child" => format!( + r#"(async () => {{ + const frame=document.createElement('iframe');frame.src={url}; + await new Promise(resolve => {{frame.onload=resolve;document.body.append(frame);}}); + return frame.contentWindow.eval({probe}); + }})()"#, + url = serde_json::to_string(&document_url)?, + probe = serde_json::to_string(&probe)?, + ), + "popup" => format!( + r#"(async () => {{ + const popup=window.open({url}); + while (!popup.document || popup.document.readyState !== 'complete' || !popup.document.getElementById('first')) + await new Promise(resolve => setTimeout(resolve,1)); + try {{ + return await new Promise((resolve,reject) => {{ + function onResult(event) {{ + if ('metaPolicyResult' in event.data) {{ + removeEventListener('message',onResult); resolve(event.data.metaPolicyResult); + }} else if ('metaPolicyError' in event.data) {{ + removeEventListener('message',onResult); reject(new Error(event.data.metaPolicyError)); + }} + }} + addEventListener('message',onResult); + popup.postMessage({{metaPolicyProbe:{probe}}}, '*'); + }}); + }} finally {{ popup.close(); }} + }})()"#, + url = serde_json::to_string(&document_url)?, + probe = serde_json::to_string(&probe)?, + ), + _ => probe, + }; + let result = tokio::time::timeout( + Duration::from_secs(15), + page.evaluate_runtime_expression_with_await_async(&expression, true), + ) + .await??; + let observations: Vec = serde_json::from_str( + result["value"] + .as_str() + .unwrap_or_else(|| panic!("{owner}: {result}")), + )?; + assert_eq!(observations.len(), 30, "{owner}: {result}"); + assert_eq!( + observations + .iter() + .filter(|entry| entry["url"].is_string()) + .count(), + if owner == "popup" { 0 } else { 30 }, + "{owner}: script observations" + ); + let requests = servers.requests.lock(); + for observation in &observations { + let Some(script_url) = observation["url"].as_str() else { + continue; + }; + let url = url::Url::parse(script_url)?; + let path = format!("{}?{}", url.path(), url.query().unwrap()); + let found = requests + .iter() + .filter(|request| request.path == path) + .collect::>(); + assert_eq!(found.len(), 1, "{owner}, {path}: {requests:?}"); + assert_eq!( + found[0].referer.as_deref(), + observation["expected"].as_str(), + "{owner}, {path}" + ); + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn main_document_meta_referrer_policy_tracks_deliveries() -> Result<()> { + check_meta_policy("main").await +} + +#[tokio::test(flavor = "multi_thread")] +async fn child_document_meta_referrer_policy_tracks_deliveries() -> Result<()> { + check_meta_policy("child").await +} + +#[tokio::test(flavor = "multi_thread")] +async fn popup_document_meta_referrer_policy_tracks_deliveries() -> Result<()> { + check_meta_policy("popup").await +} diff --git a/moli-dom/src/native/attributes.rs b/moli-dom/src/native/attributes.rs index e8f3e65ebe3..21a56d0b95f 100644 --- a/moli-dom/src/native/attributes.rs +++ b/moli-dom/src/native/attributes.rs @@ -91,6 +91,7 @@ impl NativeDom { }; let base_document = self.base_element_attribute_owner_document(node_id, None, &normalized_name); + let referrer_attribute = self.is_meta_referrer_attribute(node_id, None, &normalized_name); let changed = self .node_mut(node_id) .and_then(|node| node.data_mut().as_element_mut()) @@ -106,6 +107,9 @@ impl NativeDom { if changed && let Some(document) = base_document { self.process_base_element(document, false); } + if referrer_attribute { + self.process_meta_referrer(node_id); + } changed } diff --git a/moli-dom/src/native/document.rs b/moli-dom/src/native/document.rs index 1dc219f0604..e5735a59584 100644 --- a/moli-dom/src/native/document.rs +++ b/moli-dom/src/native/document.rs @@ -90,6 +90,9 @@ struct DocumentMetadata { #[derive(Debug, Clone, Default)] struct DocumentArenaState { source_response_status: Option, + // Meta delivery updates policy in time order; removing the element does + // not undo the policy it delivered to this Document. + meta_referrer_policy: Option<&'static str>, // Sticky for this Document; aborting a parser disables document.open/write. active_parser_was_aborted: bool, is_inert_template_document: bool, @@ -237,6 +240,10 @@ impl Document { self.arena_state.active_parser_was_aborted = true; } + pub fn meta_referrer_policy(&self) -> Option<&str> { + self.arena_state.meta_referrer_policy + } + pub fn visibility_hidden(&self) -> bool { self.metadata.visibility_hidden } diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 3d0b0e24997..de9916bac36 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -110,8 +110,8 @@ mod navigation_serialize; pub(crate) use navigation_entry::navigation_entry_public_token; pub(crate) use navigation_serialize::current_document_referrer_policy; pub(crate) use navigation_serialize::{ - document_referrer_policy_for_native_document, document_referrer_policy_in_subtree, - history_document_id_for_holder, publish_top_level_navigation_history, + document_referrer_policy_for_native_document, history_document_id_for_holder, + publish_top_level_navigation_history, }; mod navigation_surface; mod navigation_transition_worlds; diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rs index 2fd86aa7b58..702becef5dc 100644 --- a/moli-renderer-v8/src/document_runtime/security_policy.rs +++ b/moli-renderer-v8/src/document_runtime/security_policy.rs @@ -1010,11 +1010,12 @@ impl DocumentRuntime { } pub(crate) fn current_document_referrer_policy(&self) -> Option { - crate::context_bootstrap::document_referrer_policy_in_subtree( - &self.dom_host, - self.dom_host.document_handle(), - ) - .or_else(|| self.response_referrer_policy().map(ToOwned::to_owned)) + self.dom_host + .node(self.dom_host.document_handle()) + .and_then(Node::as_document) + .and_then(|document| document.meta_referrer_policy()) + .map(ToOwned::to_owned) + .or_else(|| self.response_referrer_policy().map(ToOwned::to_owned)) } pub(crate) fn cross_origin_embedder_policy(