From 1affe8fff5d2cabb4e1effe609634eef2cbd7578 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Mon, 28 Sep 2026 10:52:45 +0800 Subject: [PATCH] fix(worker): inherit local script referrer policies Resolve local worker policy from the Blob URL creator environment, including meta updates delivered before startup. Keep existing worker snapshots and SharedWorker reuse stable, and carry the policy through worker-created URLs. Preserve parent request and child response policy for nested HTTP workers. Validate with the complete fmt, clippy, and nextest gates (20,458 passed), 73 original WPT files (665 -> 667 passed, zero regressions), and 226 network comparisons covering worker types, ownership, policy timing, and overrides. --- Cargo.lock | 1 + moli-core/tests/scripts/integrity.rs | 5 + .../tests/scripts/local_worker_referrer.js | 135 ++++++++++++++++++ .../tests/scripts/local_worker_referrer.rs | 57 ++++++++ .../scripts/local_worker_referrer_worker.js | 45 ++++++ moli-dom/Cargo.toml | 1 + moli-dom/src/native/document.rs | 18 ++- .../src/native/document/referrer_policy.rs | 80 ++++++++++- moli-dom/src/native/mod.rs | 4 +- moli-renderer-v8/src/blob.rs | 56 ++++++-- .../context_bootstrap/shared_worker_host.rs | 2 +- .../worker_host/constructor.rs | 90 ++++++++---- .../context_host/security_policy.rs | 19 +++ .../src/shared_worker_runtime/loading.rs | 11 +- .../src/worker/global_scope/mod.rs | 5 +- .../src/worker/global_scope/nested_workers.rs | 2 + .../src/worker/global_scope/state.rs | 4 + moli-renderer-v8/src/worker/mod.rs | 10 +- 18 files changed, 474 insertions(+), 71 deletions(-) create mode 100644 moli-core/tests/scripts/local_worker_referrer.js create mode 100644 moli-core/tests/scripts/local_worker_referrer.rs create mode 100644 moli-core/tests/scripts/local_worker_referrer_worker.js diff --git a/Cargo.lock b/Cargo.lock index a274452b717..785108e93fd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2894,6 +2894,7 @@ dependencies = [ "moli-html-input-temporal", "moli-html-input-type", "moli-html2md", + "parking_lot", "percent-encoding", "selectors", "serde", diff --git a/moli-core/tests/scripts/integrity.rs b/moli-core/tests/scripts/integrity.rs index 26026fcf8b2..a552d55722e 100644 --- a/moli-core/tests/scripts/integrity.rs +++ b/moli-core/tests/scripts/integrity.rs @@ -54,6 +54,8 @@ mod fetch_client_referrer; #[path = "css_import_referrer.rs"] mod css_import_referrer; +#[path = "local_worker_referrer.rs"] +mod local_worker_referrer; #[path = "service_worker_referrer.rs"] mod service_worker_referrer; @@ -230,6 +232,9 @@ fn fixture_response( | "/child-sri-accepted.css" | "/child-sri-forbidden.css" => child_stylesheet_integrity::fixture_response(path, query), "/import-referrer.js" => dynamic_import_referrer::fixture_response(query), + "/local-referrer-worker.js" | "/local-referrer-page.html" => { + local_worker_referrer::fixture_response(path, query, request.referer.as_deref()) + } "/import-credentials.js" => ( "200 OK", format!("{javascript}Cache-Control: no-store\r\n"), diff --git a/moli-core/tests/scripts/local_worker_referrer.js b/moli-core/tests/scripts/local_worker_referrer.js new file mode 100644 index 00000000000..6c5d226a8b9 --- /dev/null +++ b/moli-core/tests/scripts/local_worker_referrer.js @@ -0,0 +1,135 @@ +(async () => { + const script = await (await fetch('/local-referrer-worker.js')).text(); + const source = location.origin + '/private-worker-referrer?probe=1'; + const cross = globalThis.localWorkerCrossOrigin; + const checks = globalThis.localWorkerReferrerChecks = []; + const failures = globalThis.localWorkerReferrerFailures = []; + let sequence = 0; + function policy(owner, value) { + const meta = owner.document.createElement('meta'); + meta.name = 'referrer'; + meta.content = value; + owner.document.head.append(meta); + meta.remove(); + } + function blob(owner) { + return owner.URL.createObjectURL(new owner.Blob([script], {type: 'text/javascript'})); + } + function start(owner, url, type, shared, name = 'referrer-' + ++sequence) { + const worker = shared ? new owner.SharedWorker(url, {type, name}) : new owner.Worker(url, {type}); + const channel = shared ? worker.port : worker; + const pending = new Map(); + channel.onmessage = ({data}) => { + const operation = pending.get(data.id); + if (!operation) return; + pending.delete(data.id); + clearTimeout(operation.timer); + if (data.error) operation.reject(new Error(data.error)); + else operation.resolve(data.value); + }; + if (shared) channel.start(); + return { + name, + send(data) { + return new Promise((resolve, reject) => { + const id = ++sequence; + const timer = setTimeout(() => reject(new Error('Worker reply timeout: ' + globalThis.localWorkerReferrerProgress)), 8000); + pending.set(id, {resolve, reject, timer}); + channel.postMessage({...data, id}); + }); + }, + close() { + if (shared) {channel.postMessage({kind: 'close'}); channel.close();} + else worker.terminate(); + } + }; + } + async function check(worker, expectedPolicy, label) { + for (const target of [location.origin, cross]) { + for (const explicit of [false, true]) { + const command = {kind: 'fetch', url: target + '/meta-policy-fetch?worker=' + ++sequence, referrer: source}; + if (explicit) command.policy = 'unsafe-url'; + const expected = explicit || expectedPolicy === 'unsafe-url' ? source : + expectedPolicy === 'no-referrer' ? null : + expectedPolicy === 'default' && target === location.origin ? source : location.origin + '/'; + globalThis.localWorkerReferrerProgress = label; + const actual = await worker.send(command); + checks.push({label, target, explicit, actual, expected}); + if (actual !== expected) failures.push(label + ': ' + JSON.stringify(actual) + ' != ' + JSON.stringify(expected)); + } + } + } + for (const shared of [false, true]) { + for (const type of ['classic', 'module']) { + const label = (shared ? 'shared ' : 'dedicated ') + type; + const active = []; + const urls = []; + const frame = document.createElement('iframe'); + frame.src = '/local-referrer-page.html?policy=no-referrer'; + await new Promise(resolve => {frame.onload = resolve; document.body.append(frame);}); + const child = frame.contentWindow; + const launch = (owner, url) => { + const worker = start(owner, url, type, shared); + active.push(worker); + return worker; + }; + try { + policy(window, 'unsafe-url'); + const responseUrl = blob(child); urls.push(responseUrl); + const responseWorker = launch(window, responseUrl); + await check(responseWorker, 'no-referrer', label + ' Blob creator response policy'); + policy(window, 'origin'); + const url = blob(window); urls.push(url); + policy(window, 'no-referrer'); + const first = launch(window, url); + await check(first, 'no-referrer', label + ' Blob creator policy at launch'); + policy(window, 'origin'); + await check(launch(window, url), 'origin', label + ' later worker'); + await check(first, 'no-referrer', label + ' existing worker snapshot'); + if (shared) { + const reused = start(window, url, type, true, first.name); active.push(reused); + await check(reused, 'no-referrer', label + ' reused worker snapshot'); + } + + policy(child, 'origin'); + await check(responseWorker, 'no-referrer', label + ' response policy snapshot after meta delivery'); + policy(window, 'no-referrer'); + const foreignUrl = blob(child); urls.push(foreignUrl); + const foreign = launch(window, foreignUrl); + await check(foreign, 'origin', label + ' Blob URL creator differs from constructor'); + policy(child, 'no-referrer'); + await check(launch(window, foreignUrl), 'no-referrer', label + ' creator meta update'); + await check(foreign, 'origin', label + ' prior foreign worker snapshot'); + + policy(window, 'unsafe-url'); + const parentUrl = blob(window); urls.push(parentUrl); + await check(launch(child, parentUrl), 'unsafe-url', label + ' child constructor uses Blob creator'); + const workerUrl = await first.send({kind: 'blob', source: script}); urls.push(workerUrl); + await check(launch(window, workerUrl), 'no-referrer', label + ' worker-created Blob'); + + for (const nestedType of shared ? [] : ['classic', 'module']) { + const nested = {send: command => first.send({kind: 'nested', source: script, type: nestedType, command})}; + await check(nested, 'no-referrer', label + ' nested Blob ' + nestedType); + } + policy(window, 'no-referrer'); + await check(launch(window, '/local-referrer-worker.js?policy=origin&id=' + ++sequence), 'origin', label + ' network response policy'); + await check(launch(window, '/local-referrer-worker.js?id=' + ++sequence), 'default', label + ' network default policy'); + if (!shared) { + const networkParent = launch(window, '/local-referrer-worker.js?policy=origin&id=' + ++sequence); + const nestedUrl = location.origin + '/local-referrer-worker.js?policy=no-referrer&id=' + ++sequence; + const nested = {send: command => networkParent.send({kind: 'nested', url: nestedUrl, type, command})}; + const entryReferrer = await nested.send({kind: 'entry-referrer'}); + checks.push({label: label + ' nested script request', actual: entryReferrer, expected: location.origin + '/'}); + if (entryReferrer !== location.origin + '/') failures.push(label + ': nested entry referrer ' + entryReferrer); + await check(nested, 'no-referrer', label + ' nested network response policy'); + } + } finally { + for (const worker of active) worker.close(); + for (const url of urls) URL.revokeObjectURL(url); + frame.remove(); + } + } + } + if (failures.length) throw new Error(failures.join('\n')); + return true; +})(); diff --git a/moli-core/tests/scripts/local_worker_referrer.rs b/moli-core/tests/scripts/local_worker_referrer.rs new file mode 100644 index 00000000000..1848b07202f --- /dev/null +++ b/moli-core/tests/scripts/local_worker_referrer.rs @@ -0,0 +1,57 @@ +use super::*; + +pub(super) fn fixture_response( + path: &str, + query: &str, + referer: Option<&str>, +) -> (&'static str, String, String) { + let policy = url::form_urlencoded::parse(query.as_bytes()) + .find(|(name, _)| name == "policy") + .map(|(_, value)| value.into_owned()); + let content_type = if path == "/local-referrer-page.html" { + "text/html" + } else { + "text/javascript" + }; + let mut headers = format!("Content-Type: {content_type}\r\nCache-Control: no-store\r\n"); + if let Some(policy) = policy { + headers.push_str(&format!("Referrer-Policy: {policy}\r\n")); + } + if path == "/local-referrer-page.html" { + return ( + "200 OK", + headers, + "Worker creator".to_owned(), + ); + } + ( + "200 OK", + headers, + format!( + "globalThis.workerEntryReferrer = {};\n{}", + serde_json::to_string(&referer).unwrap(), + include_str!("local_worker_referrer_worker.js"), + ), + ) +} + +#[tokio::test(flavor = "multi_thread")] +async fn local_workers_inherit_the_correct_environment_referrer_policy() -> Result<()> { + let servers = IntegrityServers::spawn().await?; + let browser = Browser::new(AppConfig::default())?; + let mut page = browser + .fetch(&format!("{}/page.html", servers.origin)) + .await?; + let expression = format!( + "globalThis.localWorkerCrossOrigin = {}; {}", + serde_json::to_string(&servers.cross_origin)?, + include_str!("local_worker_referrer.js"), + ); + let result = tokio::time::timeout( + Duration::from_secs(40), + page.evaluate_runtime_expression_with_await_async(&expression, true), + ) + .await??; + assert_eq!(result["value"], true, "{result}"); + Ok(()) +} diff --git a/moli-core/tests/scripts/local_worker_referrer_worker.js b/moli-core/tests/scripts/local_worker_referrer_worker.js new file mode 100644 index 00000000000..6bdbbf77c65 --- /dev/null +++ b/moli-core/tests/scripts/local_worker_referrer_worker.js @@ -0,0 +1,45 @@ +function connect(channel) { + channel.onmessage = async ({data}) => { + if (data.kind === 'close') { + self.close(); + return; + } + try { + let value; + if (data.kind === 'fetch') { + const options = {referrer: data.referrer}; + if (data.policy !== undefined) options.referrerPolicy = data.policy; + value = await (await fetch(data.url, options)).json(); + } else if (data.kind === 'blob') { + value = URL.createObjectURL(new Blob([data.source], {type: 'text/javascript'})); + } else if (data.kind === 'entry-referrer') { + value = globalThis.workerEntryReferrer ?? null; + } else if (data.kind === 'nested') { + const url = data.url || URL.createObjectURL(new Blob([data.source], {type: 'text/javascript'})); + const worker = new Worker(url, {type: data.type}); + try { + value = await new Promise((resolve, reject) => { + worker.onmessage = event => event.data.error ? reject(new Error(event.data.error)) : resolve(event.data.value); + worker.onerror = event => reject(new Error(event.message)); + worker.postMessage({...data.command, id: 1}); + }); + } finally { + worker.terminate(); + if (!data.url) URL.revokeObjectURL(url); + } + } else { + throw new Error('Unknown command: ' + data.kind); + } + channel.postMessage({id: data.id, value}); + } catch (error) { + channel.postMessage({id: data.id, error: error.name + ': ' + error.message}); + } + }; + if (channel !== self) channel.start(); +} + +if ('onconnect' in self) { + self.onconnect = event => connect(event.ports[0]); +} else { + connect(self); +} diff --git a/moli-dom/Cargo.toml b/moli-dom/Cargo.toml index 9bf51431392..9546b8f4669 100644 --- a/moli-dom/Cargo.toml +++ b/moli-dom/Cargo.toml @@ -15,6 +15,7 @@ moli-css-parse = { path = "../moli-css-parse" } moli-html-input-type = { path = "../moli-html-input-type" } moli-html2md = { path = "../moli-html2md" } moli-html-input-temporal = { path = "../moli-html-input-temporal" } +parking_lot = "0.12" percent-encoding = "2.3" selectors = "0.41" serde = { version = "1.0.228", features = ["derive"] } diff --git a/moli-dom/src/native/document.rs b/moli-dom/src/native/document.rs index e5735a59584..14dc16bb181 100644 --- a/moli-dom/src/native/document.rs +++ b/moli-dom/src/native/document.rs @@ -12,6 +12,8 @@ mod tests; pub use base_url::DocumentBaseUrlPolicyCheck; use base_url::DocumentBaseUrlState; +pub use referrer_policy::DocumentMetaReferrerPolicySource; +use referrer_policy::MetaReferrerPolicy; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum DocumentTitleSetterTarget { @@ -81,8 +83,6 @@ struct DocumentMetadata { default_language: Option>, source_last_modified_ms: Option, base_url_state: DocumentBaseUrlState, - // Delivered meta policy survives element removal but belongs to this Document. - meta_referrer_policy: Option<&'static str>, } // Node relationships and the associated template-owner role belong to one @@ -92,7 +92,7 @@ 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>, + meta_referrer_policy: MetaReferrerPolicy, // Sticky for this Document; aborting a parser disables document.open/write. active_parser_was_aborted: bool, is_inert_template_document: bool, @@ -140,7 +140,6 @@ impl Document { scripting_enabled, default_language: None, source_last_modified_ms: None, - meta_referrer_policy: None, }, arena_state: DocumentArenaState::default(), } @@ -165,7 +164,6 @@ impl Document { .metadata .base_url_state .clone_without_tree_caches(self.url()), - meta_referrer_policy: None, ..self.metadata.clone() }, arena_state: DocumentArenaState::default(), @@ -228,10 +226,6 @@ impl Document { self.metadata.ready_state } - pub fn meta_referrer_policy(&self) -> Option<&str> { - self.metadata.meta_referrer_policy - } - pub fn active_parser_was_aborted(&self) -> bool { self.arena_state.active_parser_was_aborted } @@ -241,7 +235,11 @@ impl Document { } pub fn meta_referrer_policy(&self) -> Option<&str> { - self.arena_state.meta_referrer_policy + self.arena_state.meta_referrer_policy.get() + } + + pub fn meta_referrer_policy_source(&self) -> DocumentMetaReferrerPolicySource { + self.arena_state.meta_referrer_policy.source() } pub fn visibility_hidden(&self) -> bool { diff --git a/moli-dom/src/native/document/referrer_policy.rs b/moli-dom/src/native/document/referrer_policy.rs index ab6ef400df4..0cf98cc3a2e 100644 --- a/moli-dom/src/native/document/referrer_policy.rs +++ b/moli-dom/src/native/document/referrer_policy.rs @@ -1,4 +1,52 @@ use crate::native::{NativeDom, NativeNodeId, Node}; +use parking_lot::RwLock; +use std::sync::{Arc, OnceLock}; + +/// A read-only view of a Document's delivered meta policy, retained by local +/// resources that refer to its environment after the Document is removed. +#[derive(Clone, Debug)] +pub struct DocumentMetaReferrerPolicySource(Arc>>); + +impl DocumentMetaReferrerPolicySource { + pub fn get(&self) -> Option<&'static str> { + *self.0.read() + } +} + +#[derive(Debug, Default)] +pub(super) struct MetaReferrerPolicy { + value: Option<&'static str>, + source: OnceLock, +} + +impl Clone for MetaReferrerPolicy { + fn clone(&self) -> Self { + Self { + value: self.value, + source: OnceLock::new(), + } + } +} + +impl MetaReferrerPolicy { + pub(super) fn get(&self) -> Option<&'static str> { + self.value + } + + fn set(&mut self, policy: &'static str) { + self.value = Some(policy); + if let Some(source) = self.source.get() { + *source.0.write() = self.value; + } + } + + pub(super) fn source(&self) -> DocumentMetaReferrerPolicySource { + // Ordinary Documents need no allocation or lock for policy reads. + self.source + .get_or_init(|| DocumentMetaReferrerPolicySource(Arc::new(RwLock::new(self.value)))) + .clone() + } +} impl NativeDom { pub(crate) fn process_meta_referrer(&mut self, handle: NativeNodeId) { @@ -25,7 +73,7 @@ impl NativeDom { .node_mut(document) .and_then(|node| node.data_mut().as_document_mut()) { - document.metadata.meta_referrer_policy = Some(policy); + document.arena_state.meta_referrer_policy.set(policy); } } @@ -123,6 +171,36 @@ mod tests { assert_eq!(policy(&host, document), Some("origin")); } + #[test] + fn retained_meta_referrer_policy_tracks_its_document_and_not_clones() { + let mut host = host(); + let document = host.document_handle(); + let head = host.document_head_handle().unwrap(); + let source = host + .node(document) + .unwrap() + .as_document() + .unwrap() + .meta_referrer_policy_source(); + let element = meta(&mut host, "origin"); + assert_eq!(source.get(), None); + host.append_child(head, element); + let cloned = host.node(document).unwrap().as_document().unwrap().clone(); + let cloned_source = cloned.meta_referrer_policy_source(); + assert_eq!(source.get(), Some("origin")); + assert_eq!(cloned_source.get(), Some("origin")); + host.set_attribute(element, "content", "no-referrer"); + host.remove_child(head, element); + assert_eq!(source.get(), Some("no-referrer")); + assert_eq!(cloned_source.get(), Some("origin")); + assert_eq!( + cloned.clone_for_node().meta_referrer_policy_source().get(), + None + ); + drop(host); + assert_eq!(source.get(), Some("no-referrer")); + } + #[test] fn meta_referrer_accepts_html_aliases_but_not_header_lists_or_whitespace() { let mut host = host(); diff --git a/moli-dom/src/native/mod.rs b/moli-dom/src/native/mod.rs index c1e961f88f1..70b8baf0172 100644 --- a/moli-dom/src/native/mod.rs +++ b/moli-dom/src/native/mod.rs @@ -18,8 +18,8 @@ use std::sync::Arc; use document::DocumentKind; pub use document::{ - Document, DocumentBaseUrlPolicyCheck, DocumentFragment, DocumentReadyState, - DocumentTitleSetterTarget, DocumentType, + Document, DocumentBaseUrlPolicyCheck, DocumentFragment, DocumentMetaReferrerPolicySource, + DocumentReadyState, DocumentTitleSetterTarget, DocumentType, }; pub use element::{ Attribute, CustomElementState, Element, SelectedFile, html_element_interface_name, diff --git a/moli-renderer-v8/src/blob.rs b/moli-renderer-v8/src/blob.rs index ba442e563b3..49b8e5fd26d 100644 --- a/moli-renderer-v8/src/blob.rs +++ b/moli-renderer-v8/src/blob.rs @@ -32,10 +32,25 @@ type RendererBlobStore = BlobStore< ResourceOwnerId, RendererStoragePartitionIdentity, ObjectUrlAccessKey, - crate::content_security_policy::ContentSecurityPolicySource, + ObjectUrlPolicySource, Arc, >; +#[derive(Clone, Debug)] +pub(crate) struct ObjectUrlPolicySource { + pub(crate) content_security_policy: crate::content_security_policy::ContentSecurityPolicySource, + pub(crate) referrer_policy: Option, + pub(crate) document_meta_referrer_policy: + Option, +} + +#[derive(Default)] +pub(crate) struct ObjectUrlPolicySnapshot { + pub(crate) content_security_policy: + crate::content_security_policy::InheritedContentSecurityPolicy, + pub(crate) referrer_policy: Option, +} + static BLOB_STORE: OnceLock = OnceLock::new(); fn blob_store() -> &'static RendererBlobStore { @@ -109,16 +124,20 @@ pub(super) fn create_object_url_for_object<'s>( let origin = storage_key.origin().to_owned(); let lifetime_id = native_bridge::current_runtime_observable_context_token(scope) .map(native_bridge::RuntimeObservableContextToken::as_u64); - let policy_source = if let Some(host_ptr) = - crate::util::context_host_ptr_from_global_bridge(scope) - { - let global = scope.get_current_context().global(scope); - // SAFETY: the Window callback keeps its host alive for this call. - unsafe { &*host_ptr }.local_worker_content_security_policy_source_for_global(scope, global) - } else { - crate::worker::worker_content_security_policy_snapshot(scope) - .map(|policy| Arc::new(parking_lot::RwLock::new(policy))) - }; + let policy_source = + if let Some(host_ptr) = crate::util::context_host_ptr_from_global_bridge(scope) { + let global = scope.get_current_context().global(scope); + // SAFETY: the Window callback keeps its host alive for this call. + unsafe { &*host_ptr }.object_url_policy_source_for_global(scope, global) + } else { + crate::worker::worker_content_security_policy_snapshot(scope).map(|policy| { + ObjectUrlPolicySource { + content_security_policy: Arc::new(parking_lot::RwLock::new(policy)), + referrer_policy: crate::worker::worker_referrer_policy(scope), + document_meta_referrer_policy: None, + } + }) + }; blob_store().create_object_url_with_target( owner_id, lifetime_id, @@ -138,10 +157,17 @@ pub(crate) fn object_url_data(url: &str) -> Option { blob_store().object_url_data(url) } -pub(crate) fn object_url_content_security_policy( - url: &str, -) -> Option { - Some(blob_store().object_url_metadata(url)?.read().clone()) +pub(crate) fn object_url_policy(url: &str) -> Option { + let source = blob_store().object_url_metadata(url)?; + Some(ObjectUrlPolicySnapshot { + content_security_policy: source.content_security_policy.read().clone(), + referrer_policy: source + .document_meta_referrer_policy + .as_ref() + .and_then(moli_dom::native::DocumentMetaReferrerPolicySource::get) + .map(str::to_owned) + .or(source.referrer_policy), + }) } pub(super) fn revoke_object_url( diff --git a/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs b/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs index 0aa8ca194ca..c55bd286d0a 100644 --- a/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs +++ b/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs @@ -256,7 +256,7 @@ fn shared_worker_constructor_callback_inner<'s>( .local_worker_content_security_policy_source_for_global(scope, global) .map(|source| source.read().clone()) .unwrap_or_default(); - script_load.with_ready_content_security_policy(policy) + script_load.with_ready_inherited_policies(policy, context.document_referrer_policy.clone()) } else { script_load }; diff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs index 7358257f54e..4bc47768c6c 100644 --- a/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs +++ b/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs @@ -256,7 +256,7 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( // Capture the creator policy before loading the body so concurrent URL // revocation cannot leave a loaded script without its policy. let blob_policy = (resolved_url.scheme() == "blob") - .then(|| crate::blob::object_url_content_security_policy(resolved_url.as_str())); + .then(|| crate::blob::object_url_policy(resolved_url.as_str())); let materialized = match materialize_worker_script_source(&resolved_url) { Ok(source) => source, Err(message) => { @@ -266,12 +266,16 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( }; let creator_secure_context = worker_creator_secure_context(scope, host, child_handle); let worker_id = if let Some(script_source) = materialized { - let inherited_policy = if let Some(policy) = blob_policy { - policy.unwrap_or_default() + let (inherited_policy, inherited_referrer_policy) = if let Some(policy) = blob_policy { + let policy = policy.unwrap_or_default(); + (policy.content_security_policy, policy.referrer_policy) } else { - host.local_worker_content_security_policy_source_for_owner(dispatch_scope) - .map(|source| source.read().clone()) - .unwrap_or_default() + ( + host.local_worker_content_security_policy_source_for_owner(dispatch_scope) + .map(|source| source.read().clone()) + .unwrap_or_default(), + document_referrer_policy, + ) }; let request_url = worker_script_resource_url(&resolved_url); let network_response = @@ -307,6 +311,7 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( ) .with_script_kind(worker_options.worker_type) .with_content_security_policy_snapshot(inherited_policy) + .with_referrer_policy(inherited_referrer_policy) .with_module_credentials_mode(worker_options.credentials_mode.0) .with_module_static_import_initiator_url(base_url.clone()) .with_module_static_import_content_security_policies(document_content_security_policies) @@ -471,7 +476,7 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( ); return; } - let (script_url, script_source, content_security_policy) = match materialize_nested_worker_script_source( + let loaded = match materialize_nested_worker_script_source( &resolved_url, &nested_context, worker_options.worker_type, @@ -498,12 +503,14 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( } }; let mut network_policy = nested_context.network_policy.clone(); - let secure_context = Url::parse(&script_url).ok().is_some_and(|script_url| { - nested_context - .network_policy - .secure_context - .resolve(&script_url) - }); + let secure_context = Url::parse(&loaded.script_url) + .ok() + .is_some_and(|script_url| { + nested_context + .network_policy + .secure_context + .resolve(&script_url) + }); network_policy.secure_context = WorkerSecureContextPolicy::Inherited(secure_context); let reserved_service_worker_client_id = reserve_nested_inherited_service_worker_worker_client_for_local_script( @@ -516,12 +523,13 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( worker_policy_context.cross_origin_isolated = false; } let options = WorkerSpawnOptions::new_with_request_client( - script_source, - script_url, + loaded.source, + loaded.script_url, nested_context.loader.request_client().clone(), ) .with_interception_context(nested_context.interception_context.clone()) - .with_content_security_policy_snapshot(content_security_policy) + .with_content_security_policy_snapshot(loaded.content_security_policy) + .with_referrer_policy(loaded.referrer_policy) .with_script_kind(worker_options.worker_type) .with_module_credentials_mode(worker_options.credentials_mode.0) .with_module_static_import_initiator_url(nested_context.base_url.clone()) @@ -854,28 +862,37 @@ fn child_context_handle_from_global<'s>( .map(|value| DomHandle::new(value as usize)) } +struct LoadedNestedWorkerScript { + script_url: String, + source: String, + content_security_policy: crate::content_security_policy::InheritedContentSecurityPolicy, + referrer_policy: Option, +} + fn materialize_nested_worker_script_source( script_url: &Url, context: &NestedWorkerContext, script_kind: WorkerScriptKind, module_credentials_mode: moli_fetch::RequestCredentialsMode, -) -> Result< - ( - String, - String, - crate::content_security_policy::InheritedContentSecurityPolicy, - ), - String, -> { +) -> Result { let blob_policy = (script_url.scheme() == "blob") - .then(|| crate::blob::object_url_content_security_policy(script_url.as_str())); + .then(|| crate::blob::object_url_policy(script_url.as_str())); if let Some(source) = materialize_worker_script_source(script_url)? { - let policy = if let Some(policy) = blob_policy { - policy.unwrap_or_default() + let (content_security_policy, referrer_policy) = if let Some(policy) = blob_policy { + let policy = policy.unwrap_or_default(); + (policy.content_security_policy, policy.referrer_policy) } else { - context.content_security_policy_snapshot.clone() + ( + context.content_security_policy_snapshot.clone(), + context.referrer_policy.clone(), + ) }; - return Ok((script_url.to_string(), source, policy)); + return Ok(LoadedNestedWorkerScript { + script_url: script_url.to_string(), + source, + content_security_policy, + referrer_policy, + }); } let loader = context.loader.clone(); let resource_url = worker_script_resource_url(script_url); @@ -895,7 +912,11 @@ fn materialize_nested_worker_script_source( .creator_message_security .serialized_origin() .unwrap_or("null"), - )); + )) + .with_script_fetch_metadata(moli_fetch::ScriptFetchRequestMetadata { + document_referrer_policy: context.referrer_policy.clone(), + ..Default::default() + }); let response = loader .request_client() .fetch_text_for_worker_blocking_boundary(request) @@ -916,6 +937,8 @@ fn materialize_nested_worker_script_source( response.body_bytes(), )?; let (head, body) = response.into_text_parts(); + let referrer_policy = + crate::referrer_policy::response_referrer_policy_from_headers(&head.headers); let policy = crate::content_security_policy::InheritedContentSecurityPolicy { self_url: Some(head.final_url.clone()), header_policies: crate::content_security_policy::content_security_policy_headers( @@ -934,7 +957,12 @@ fn materialize_nested_worker_script_source( }; let mut final_url = head.final_url; final_url.set_fragment(script_url.fragment()); - Ok((final_url.to_string(), body, policy)) + Ok(LoadedNestedWorkerScript { + script_url: final_url.to_string(), + source: body, + content_security_policy: policy, + referrer_policy, + }) } fn worker_script_inherits_parent_service_worker_controller(script_url: &Url) -> bool { diff --git a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs index f7765e49a4d..f193ac668c5 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs @@ -428,6 +428,25 @@ impl PageScriptHost { ) } + pub(crate) fn object_url_policy_source_for_global<'s>( + &self, + scope: &mut v8::PinScope<'s, '_>, + global: v8::Local<'s, v8::Object>, + ) -> Option { + let owner = policy_owner_dispatch_scope_for_global(scope, global); + let snapshot = self.owner_document_policy_snapshot(owner)?; + Some(crate::blob::ObjectUrlPolicySource { + content_security_policy: self + .local_worker_content_security_policy_source_for_owner(owner)?, + referrer_policy: snapshot.policy_container.referrer_policy, + document_meta_referrer_policy: snapshot + .document_handle + .and_then(|document| self.dom_host().node(document)) + .and_then(moli_dom::native::Node::as_document) + .map(moli_dom::native::Document::meta_referrer_policy_source), + }) + } + pub(crate) fn document_permissions_policy_for_owner( &self, owner: OwnerDispatchScope, diff --git a/moli-renderer-v8/src/shared_worker_runtime/loading.rs b/moli-renderer-v8/src/shared_worker_runtime/loading.rs index ad9f47514a1..2ae8cfe0c49 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/loading.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/loading.rs @@ -362,12 +362,14 @@ impl SharedWorkerLoadedScript { } impl SharedWorkerScriptLoad { - pub(crate) fn with_ready_content_security_policy( + pub(crate) fn with_ready_inherited_policies( mut self, policy: crate::content_security_policy::InheritedContentSecurityPolicy, + referrer_policy: Option, ) -> Self { if let SharedWorkerScriptLoadKind::Ready(script) = &mut self.kind { script.content_security_policy_snapshot = Some(Box::new(policy)); + script.response_referrer_policy = referrer_policy; } self } @@ -611,12 +613,13 @@ pub(super) fn load_shared_worker_blob_script_source( ) -> Result { let mut resource_url = script_url.clone(); resource_url.set_fragment(None); - let policy = - crate::blob::object_url_content_security_policy(resource_url.as_str()).unwrap_or_default(); + let policy = crate::blob::object_url_policy(resource_url.as_str()).unwrap_or_default(); crate::blob::object_url_body_and_type(resource_url.as_str()) .map(|(body, _)| { let mut script = SharedWorkerLoadedScript::new(script_url.to_string(), body); - script.content_security_policy_snapshot = Some(Box::new(policy)); + script.content_security_policy_snapshot = + Some(Box::new(policy.content_security_policy)); + script.response_referrer_policy = policy.referrer_policy; script }) .ok_or_else(|| { diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index da0215ece7e..7b0a4a1ec3e 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -222,7 +222,8 @@ use state::worker_close_callback; pub(crate) use state::{ WorkerGlobalState, get_worker_state, worker_content_security_policy_snapshot, worker_current_script_url, worker_exception_report_target, worker_global_is_closed, - worker_realm_secure_context_available, worker_service_worker_control_state, worker_storage_key, - worker_storage_partition_identity, worker_termination_requested, + worker_realm_secure_context_available, worker_referrer_policy, + worker_service_worker_control_state, worker_storage_key, worker_storage_partition_identity, + worker_termination_requested, }; pub(super) use timers::{TimerInfo, WorkerIsolateTimerQueues, worker_isolate_timer_queues}; diff --git a/moli-renderer-v8/src/worker/global_scope/nested_workers.rs b/moli-renderer-v8/src/worker/global_scope/nested_workers.rs index 11572dd093c..e22a677fa9b 100644 --- a/moli-renderer-v8/src/worker/global_scope/nested_workers.rs +++ b/moli-renderer-v8/src/worker/global_scope/nested_workers.rs @@ -27,6 +27,7 @@ pub(crate) struct NestedWorkerContext { pub(crate) module_static_import_content_security_policies: Vec, pub(crate) content_security_policy_snapshot: crate::content_security_policy::InheritedContentSecurityPolicy, + pub(crate) referrer_policy: Option, pub(crate) require_trusted_types_for_script: bool, pub(crate) network_policy: crate::worker::handle::WorkerNetworkPolicy, pub(crate) policy_context: crate::types::SubresourcePolicyContext, @@ -64,6 +65,7 @@ pub(crate) fn reserve_nested_worker_context( storage_bucket_store: state.storage_bucket_store.clone(), module_static_import_content_security_policies: state.content_security_policies.clone(), content_security_policy_snapshot: content_security_policy::worker_policy_snapshot(&state), + referrer_policy: state.referrer_policy.clone(), require_trusted_types_for_script: crate::content_security_policy::content_security_policy_requires_trusted_types_for_script( &state.content_security_policies, diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rs index 0e0a02fded6..9b9e6843fa1 100644 --- a/moli-renderer-v8/src/worker/global_scope/state.rs +++ b/moli-renderer-v8/src/worker/global_scope/state.rs @@ -344,6 +344,10 @@ pub(crate) fn worker_storage_partition_identity( ) } +pub(crate) fn worker_referrer_policy(scope: &mut v8::PinScope<'_, '_>) -> Option { + get_worker_state(scope)?.borrow().referrer_policy.clone() +} + pub(crate) fn worker_current_script_url(scope: &mut v8::PinScope<'_, '_>) -> Option { get_worker_state(scope)?.borrow().current_script_url.clone() } diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index 6aaf784a4c4..02de6aa8256 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -56,11 +56,11 @@ pub(crate) use global_scope::{ worker_allows_wasm_code_generation_by_csp, worker_broadcast_channel_registry, worker_broadcast_channel_storage_key, worker_broadcast_channel_wake_sender, worker_broadcast_channel_wrapper, - worker_content_security_policy_snapshot, - worker_current_script_url, worker_global_is_closed, worker_global_origin, - worker_message_port_registry, worker_message_port_wake_sender, worker_message_port_wrapper, - worker_notification_permission_state, worker_opfs_directory_iterator_registry, - worker_opfs_handle_registry, worker_realm_secure_context_available, + worker_content_security_policy_snapshot, worker_current_script_url, worker_global_is_closed, + worker_global_origin, worker_message_port_registry, worker_message_port_wake_sender, + worker_message_port_wrapper, worker_notification_permission_state, + worker_opfs_directory_iterator_registry, worker_opfs_handle_registry, + worker_realm_secure_context_available, worker_referrer_policy, worker_service_worker_control_state, worker_storage_key, worker_storage_partition_identity, worker_termination_requested, worker_trusted_types_for_script_requirements, };