diff --git a/moli-core/tests/scripts/dynamic_import_referrer.rs b/moli-core/tests/scripts/dynamic_import_referrer.rs new file mode 100644 index 00000000000..cc83408f796 --- /dev/null +++ b/moli-core/tests/scripts/dynamic_import_referrer.rs @@ -0,0 +1,166 @@ +use super::*; + +pub(super) fn fixture_response(query: &str) -> (&'static str, String, String) { + let params: std::collections::HashMap<_, _> = + url::form_urlencoded::parse(query.as_bytes()).collect(); + let mut headers = "Content-Type: text/javascript\r\nCache-Control: no-store\r\n".to_owned(); + if let Some(policy) = params.get("response") { + headers.push_str(&format!("Referrer-Policy: {policy}\r\n")); + } + ( + "200 OK", + headers, + dynamic_import_credentials::importer_source(params["name"].as_ref()), + ) +} + +async fn check_dynamic_import_referrer_policy(child: bool) -> Result<()> { + let servers = IntegrityServers::spawn().await?; + let browser = Browser::new(AppConfig::default())?; + let mut page = browser + .fetch(&format!("{}/page.html?top", servers.origin)) + .await?; + let mut cases = Vec::new(); + for kind in ["classic", "module"] { + for external in [false, true] { + let mut policies = vec![ + ("default", None, "strict-origin-when-cross-origin"), + ("invalid", None, "strict-origin-when-cross-origin"), + ("no-referrer", None, "no-referrer"), + ("origin", None, "origin"), + ("same-origin", None, "same-origin"), + ("unsafe-url", None, "unsafe-url"), + ]; + if external { + for (header, effective) in [ + ("no-referrer", "no-referrer"), + ("origin", "origin"), + ("invalid", "unsafe-url"), + ("no-referrer, origin", "origin"), + ] { + policies.push(( + "unsafe-url", + Some(header), + if kind == "module" { + effective + } else { + "unsafe-url" + }, + )); + } + } + for (attribute, response, effective) in policies { + let name = format!("referrer-{}", cases.len()); + let mut src = url::Url::parse(&format!("{}/import-referrer.js", servers.origin))?; + src.query_pairs_mut().append_pair("name", &name); + if let Some(response) = response { + src.query_pairs_mut().append_pair("response", response); + } + cases.push(serde_json::json!({ + "name":name, "kind":kind, "external":external, "attribute":attribute, + "effective":effective, "src":src.as_str(), "response":response, + "source":dynamic_import_credentials::importer_source(&name), + })); + } + } + } + let probe = format!( + r#"(async () => {{ + globalThis.importers = {{}}; + globalThis.importerReady = {{}}; + globalThis.timerImports = {{}}; + for (const test of {cases}) {{ + const script = document.createElement('script'); + if (test.kind === 'module') script.type = 'module'; + if (test.attribute !== 'default') script.referrerPolicy = test.attribute; + if (test.external) script.src = test.src; + else script.textContent = test.source; + await new Promise((resolve, reject) => {{ + const timer = setTimeout(() => reject(new Error('source did not run: ' + test.name)), 3000); + importerReady[test.name] = () => {{ clearTimeout(timer); resolve(); }}; + script.onerror = () => reject(new Error('failed to load ' + test.name)); + document.head.append(script); + }}); + script.referrerPolicy = test.attribute === 'no-referrer' ? 'unsafe-url' : 'no-referrer'; + script.remove(); + for (const invocation of ['direct', 'timer']) + for (const [label, origin] of [['same', location.origin], ['cross', {cross}]]) + await importers[test.name](origin + '/echo-origin.js?' + test.name + '-' + invocation + '-' + label, invocation === 'timer'); + }} + return true; + }})()"#, + cases = serde_json::to_string(&cases)?, + cross = serde_json::to_string(&servers.cross_origin)?, + ); + let expression = if child { + format!( + r#"(async () => {{ + const frame = document.createElement('iframe'); + frame.src = '/page.html?child'; + await new Promise(resolve => {{ frame.onload = resolve; document.body.append(frame); }}); + return frame.contentWindow.eval({}); + }})()"#, + serde_json::to_string(&probe)? + ) + } else { + probe + }; + let result = tokio::time::timeout( + Duration::from_secs(15), + page.evaluate_runtime_expression_with_await_async(&expression, true), + ) + .await??; + assert_eq!(result["value"], true, "child={child}: {result}"); + + let requests = servers.requests.lock(); + let mut mismatches = Vec::new(); + for test in &cases { + let source_url = if test["external"] == true { + test["src"].as_str().unwrap().to_owned() + } else { + format!( + "{}/page.html?{}", + servers.origin, + if child { "child" } else { "top" } + ) + }; + for invocation in ["direct", "timer"] { + for origin in ["same", "cross"] { + let path = format!( + "/echo-origin.js?{}-{invocation}-{origin}", + test["name"].as_str().unwrap() + ); + let matching: Vec<_> = requests + .iter() + .filter(|request| request.path == path) + .collect(); + assert_eq!(matching.len(), 1, "child={child}, {path}: {requests:?}"); + let expected = match (test["effective"].as_str().unwrap(), origin) { + ("no-referrer", _) | ("same-origin", "cross") => None, + ("origin", _) | ("strict-origin-when-cross-origin", "cross") => { + Some(format!("{}/", servers.origin)) + } + _ => Some(source_url.clone()), + }; + if matching[0].referer != expected { + mismatches.push(format!( + "{test}: {invocation}/{origin}: {:?}, expected {expected:?}", + matching[0].referer + )); + } + } + } + } + assert!(mismatches.is_empty(), "child={child}: {mismatches:#?}"); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn main_dynamic_imports_preserve_script_referrer_policy() -> Result<()> { + check_dynamic_import_referrer_policy(false).await +} + +#[tokio::test(flavor = "multi_thread")] +async fn child_dynamic_imports_preserve_script_referrer_policy() -> Result<()> { + check_dynamic_import_referrer_policy(true).await +} diff --git a/moli-core/tests/scripts/integrity.rs b/moli-core/tests/scripts/integrity.rs index 8198a5e96bd..474740417f1 100644 --- a/moli-core/tests/scripts/integrity.rs +++ b/moli-core/tests/scripts/integrity.rs @@ -34,6 +34,9 @@ mod child_module_records; #[path = "dynamic_import_credentials.rs"] mod dynamic_import_credentials; +#[path = "dynamic_import_referrer.rs"] +mod dynamic_import_referrer; + struct IntegrityServers { origin: String, cross_origin: String, @@ -197,6 +200,7 @@ fn fixture_response( | "/child-sri-rejected.css" | "/child-sri-accepted.css" | "/child-sri-forbidden.css" => child_stylesheet_integrity::fixture_response(path, query), + "/import-referrer.js" => dynamic_import_referrer::fixture_response(query), "/import-credentials.js" => ( "200 OK", format!("{javascript}Cache-Control: no-store\r\n"), diff --git a/moli-renderer-v8/src/module_runtime/dynamic_resolver.rs b/moli-renderer-v8/src/module_runtime/dynamic_resolver.rs index 15bda030d57..c3b14a210c8 100644 --- a/moli-renderer-v8/src/module_runtime/dynamic_resolver.rs +++ b/moli-renderer-v8/src/module_runtime/dynamic_resolver.rs @@ -29,6 +29,7 @@ pub(crate) struct PendingDynamicModuleImport { owner: DynamicModuleImportOwner, specifier: String, base_url: Url, + referrer_url: Option, resolved_url: Option, attributes: ModuleAttributesKey, phase: ModuleImportPhase, @@ -191,6 +192,7 @@ impl PendingDynamicModuleImport { owner, specifier: specifier.into(), base_url, + referrer_url: None, resolved_url: None, attributes, phase, @@ -198,14 +200,23 @@ impl PendingDynamicModuleImport { } } - pub(crate) fn with_referrer_fetch_metadata( + pub(crate) fn with_referrer_script( mut self, + base_url: Url, metadata: super::ModuleFetchMetadata, ) -> Self { + self.referrer_url = Some(base_url); self.fetch_metadata = metadata; self } + pub(crate) fn referrer(&self) -> module_tree::ModuleReferrer { + self.referrer_url.clone().map_or_else( + module_tree::ModuleReferrer::client, + module_tree::ModuleReferrer::from_url, + ) + } + pub(crate) fn with_resolved_url(mut self, resolved_url: Url) -> Self { self.resolved_url = Some(resolved_url); self diff --git a/moli-renderer-v8/src/module_runtime/graph.rs b/moli-renderer-v8/src/module_runtime/graph.rs index 81007207863..4e9cc9ea708 100644 --- a/moli-renderer-v8/src/module_runtime/graph.rs +++ b/moli-renderer-v8/src/module_runtime/graph.rs @@ -91,6 +91,7 @@ pub(crate) enum ModuleScriptGraphAdvance { pub(crate) struct NativeModuleGraphFetchRequest { source_url: Url, initiator_url: Url, + referrer: module_tree::ModuleReferrer, fetch_metadata: ModuleFetchMetadata, kind: ModuleKind, tree_client: Option, @@ -220,6 +221,7 @@ impl NativeModuleGraphFetchRequest { Self { source_url, initiator_url, + referrer: module_tree::ModuleReferrer::client(), fetch_metadata, kind, tree_client: None, @@ -230,6 +232,11 @@ impl NativeModuleGraphFetchRequest { } } + fn with_referrer(mut self, referrer: module_tree::ModuleReferrer) -> Self { + self.referrer = referrer; + self + } + pub(crate) fn source_url(&self) -> &Url { &self.source_url } @@ -371,6 +378,13 @@ impl NativeModuleGraphFetchRequest { .with_request_origin(request_origin.clone()) .with_credentials_mode(self.fetch_metadata.credentials_mode) .with_script_fetch_metadata(self.fetch_metadata.request_metadata.clone()); + // A module's Referer identifies its importing script, while the request + // origin and cookie context still belong to the fetch client Document. + let request = if let Some(referrer) = &self.referrer.url { + request.with_fetch_referrer(referrer.as_str())? + } else { + request + }; let request = match self.kind { ModuleKind::Css => request .with_resource_type(RequestResourceType::CssStyleSheet) @@ -578,7 +592,7 @@ impl NativeModuleGraphJob { let (label, chromium_tree, kind) = match owner { ModuleScriptCompletionOwner::Parser => ( "parser_owned_external", - external_chromium_tree_root_input(&root) + external_chromium_tree_root_input(&root, module_tree::ModuleReferrer::client()) .expect("parser-owned module graph root should be valid") .map(tree_adapter::parser_owned_tree_job) .expect("parser-owned module graph jobs require an external tree root"), @@ -586,7 +600,7 @@ impl NativeModuleGraphJob { ), ModuleScriptCompletionOwner::Runtime => ( "runtime_module_script_external", - external_chromium_tree_root_input(&root) + external_chromium_tree_root_input(&root, module_tree::ModuleReferrer::client()) .expect("runtime module graph root should be valid") .map(tree_adapter::runtime_module_script_tree_job) .expect("runtime module graph jobs require an external tree root"), @@ -807,7 +821,7 @@ impl NativeModuleGraphJob { }; let root = dynamic_import_root_input(owner, request)?; trace_module_graph_job_created("dynamic_import_external", &root); - self.tree_job = external_chromium_tree_root_input(&root)? + self.tree_job = external_chromium_tree_root_input(&root, request.referrer())? .map(tree_adapter::dynamic_import_tree_job) .map(NativeModuleTreeJob::new); Ok(()) @@ -1734,7 +1748,8 @@ fn native_fetch_request_from_tree_fetch( raw.initiator_url.clone(), local_fetch_metadata(&raw.fetch_metadata), local_module_kind(raw.kind), - )) + ) + .with_referrer(raw.referrer.clone())) } fn native_dependency_request_from_chromium( @@ -2252,6 +2267,7 @@ fn external_module_script_root_input( fn external_chromium_tree_root_input( root: &ModuleRootInput, + referrer: module_tree::ModuleReferrer, ) -> std::result::Result, ModuleLoadError> { if root.source_override.is_some() { return Ok(None); @@ -2266,7 +2282,7 @@ fn external_chromium_tree_root_input( phase: chromium_import_phase(root.phase), kind_hint: Some(chromium_module_kind(key.kind())), fetch_metadata: chromium_fetch_metadata(&root.fetch_metadata), - referrer: moli_module_script_tree::ModuleReferrer::client(), + referrer, position: moli_module_script_tree::TextPosition::default(), }, ))) @@ -3337,6 +3353,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://cdn.example.test/dep.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -3362,6 +3379,39 @@ import "./c.mjs"; ); } + #[test] + fn module_referrer_preserves_the_script_url_without_changing_the_fetch_client() { + let document = url("https://app.example.test/page.html"); + let script = url("https://cdn.example.test/importer.js"); + let dependency = url("https://third.example.test/dependency.js"); + let origin = moli_url::WebOrigin::from_url(&document); + let metadata = ModuleFetchMetadata { + request_metadata: moli_fetch::ScriptFetchRequestMetadata { + referrer_policy: Some("unsafe-url".to_owned()), + ..Default::default() + }, + ..Default::default() + }; + let request = NativeModuleGraphFetchRequest::new( + dependency.clone(), + document.clone(), + metadata, + ModuleKind::JavaScript, + ) + .with_referrer(module_tree::ModuleReferrer::from_url(script.clone())) + .request(&origin) + .unwrap(); + assert_eq!( + request.referrer_header_value(&dependency).as_deref(), + Some(script.as_str()) + ); + assert_eq!(request.request_origin(), Some(&origin)); + assert_eq!( + request.cookie_context.initiator_url.as_ref(), + Some(&document) + ); + } + #[test] fn module_fetch_metadata_maps_use_credentials_to_include() { let script_metadata = ScriptFetchMetadata { @@ -3379,6 +3429,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://app.example.test/dep.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -3429,6 +3480,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://app.example.test/entry.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -3466,6 +3518,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://app.example.test/preload.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -3522,6 +3575,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://app.example.test/dep.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: dependency_metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -3570,6 +3624,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://app.example.test/dynamic.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -3607,6 +3662,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://app.example.test/inline.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -3637,6 +3693,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://app.example.test/entry.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: metadata, kind: ModuleKind::JavaScript, tree_client: None, @@ -4420,6 +4477,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url, initiator_url, + referrer: module_tree::ModuleReferrer::client(), fetch_metadata, kind, tree_client: None, @@ -4491,6 +4549,7 @@ import "./c.mjs"; let request = NativeModuleGraphFetchRequest { source_url: url("https://cdn.example.test/dep.mjs"), initiator_url: url("https://app.example.test/page"), + referrer: module_tree::ModuleReferrer::client(), fetch_metadata: root_metadata.for_descendant_fetches(), kind: ModuleKind::JavaScript, tree_client: None, diff --git a/moli-renderer-v8/src/module_runtime/host_callbacks.rs b/moli-renderer-v8/src/module_runtime/host_callbacks.rs index a7f07abfa1a..22bae025a0f 100644 --- a/moli-renderer-v8/src/module_runtime/host_callbacks.rs +++ b/moli-renderer-v8/src/module_runtime/host_callbacks.rs @@ -115,7 +115,7 @@ fn queue_native_dynamic_import<'s>( }; let host = unsafe { &mut *host_ptr }; let base_url = dynamic_import_base_url(scope, host_defined_options, resource_name, host); - let fetch_metadata = dynamic_import_referrer_fetch_metadata(scope, host_defined_options); + let referrer_script = dynamic_import_referrer_script(scope, host_defined_options); let attributes = dynamic_import_attributes(scope, import_attributes); if let Some(invalid_key) = attributes.invalid_import_attribute_key() { reject_dynamic_import( @@ -153,8 +153,10 @@ fn queue_native_dynamic_import<'s>( base_url, attributes, phase, - ) - .with_referrer_fetch_metadata(fetch_metadata); + ); + if let Some((base_url, fetch_metadata)) = referrer_script { + request = request.with_referrer_script(base_url, fetch_metadata); + } if let Some(resolved_url) = resolved_url { request = request.with_resolved_url(resolved_url); } @@ -214,17 +216,23 @@ fn dynamic_import_base_url<'s>( .unwrap_or_else(|| host.document_url().clone()) } -fn dynamic_import_referrer_fetch_metadata( +fn dynamic_import_referrer_script( scope: &mut v8::PinScope<'_, '_>, host_defined_options: v8::Local<'_, v8::Data>, -) -> super::ModuleFetchMetadata { - script_fetch_metadata_from_host_defined_options(scope, host_defined_options) - .or_else(|| { - scope - .get_current_host_defined_options() - .and_then(|options| script_fetch_metadata_from_host_defined_options(scope, options)) - }) - .unwrap_or_default() +) -> Option<(Url, super::ModuleFetchMetadata)> { + fn from_options( + scope: &mut v8::PinScope<'_, '_>, + options: v8::Local<'_, v8::Data>, + ) -> Option<(Url, super::ModuleFetchMetadata)> { + Some(( + script_base_url_from_host_defined_options(scope, options)?, + script_fetch_metadata_from_host_defined_options(scope, options)?, + )) + } + from_options(scope, host_defined_options).or_else(|| { + let options = scope.get_current_host_defined_options()?; + from_options(scope, options) + }) } fn dynamic_import_base_url_from_compiled_string_resource( diff --git a/moli-renderer-v8/src/script_vm/tests/string_timers.rs b/moli-renderer-v8/src/script_vm/tests/string_timers.rs index 44b43423fa2..858fd493024 100644 --- a/moli-renderer-v8/src/script_vm/tests/string_timers.rs +++ b/moli-renderer-v8/src/script_vm/tests/string_timers.rs @@ -9,6 +9,7 @@ fn execute_nonce_script(vm: &mut ScriptVm, source: &str, url: &Url, nonce: Optio Some(&crate::planning::ScriptFetchMetadata { nonce: nonce.map(str::to_owned), cross_origin: Some("use-credentials".to_owned()), + referrer_policy: Some("no-referrer".to_owned()), parser_inserted: true, integrity: Some("sha256-AAAA".to_owned()), ..Default::default() @@ -36,6 +37,14 @@ fn assert_import_nonce(vm: &mut ScriptVm, base_url: &Url, nonce: Option<&str>) { assert_eq!(request.specifier(), "./dependency.mjs"); assert_eq!(request.base_url(), base_url); assert_eq!(request.fetch_metadata().nonce(), nonce); + assert_eq!( + request + .fetch_metadata() + .request_metadata + .referrer_policy + .as_deref(), + Some("no-referrer") + ); assert_eq!( request.fetch_metadata().credentials_mode, moli_fetch::RequestCredentialsMode::Include diff --git a/moli-renderer-v8/src/util.rs b/moli-renderer-v8/src/util.rs index 141e80e064c..8044b3a341b 100644 --- a/moli-renderer-v8/src/util.rs +++ b/moli-renderer-v8/src/util.rs @@ -547,7 +547,15 @@ pub(crate) fn script_host_defined_options_with_fetch_metadata<'s>( moli_fetch::RequestCredentialsMode::Include => "include", }, )?; - let options = v8::PrimitiveArray::new(scope, 8); + let referrer_policy = v8_string( + scope, + metadata + .request_metadata + .referrer_policy + .as_deref() + .unwrap_or_default(), + )?; + let options = v8::PrimitiveArray::new(scope, 9); options.set(scope, 0, marker.into()); options.set(scope, 1, value.into()); options.set(scope, 2, nonce.into()); @@ -556,6 +564,7 @@ pub(crate) fn script_host_defined_options_with_fetch_metadata<'s>( options.set(scope, 5, v8::Boolean::new(scope, muted_errors).into()); options.set(scope, 6, request_url.into()); options.set(scope, 7, credentials.into()); + options.set(scope, 8, referrer_policy.into()); Some(options.into()) } @@ -576,10 +585,18 @@ pub(crate) fn script_fetch_metadata_from_host_defined_options( _ => return None, } }; + let referrer_policy = if options.length() < 9 { + None + } else { + let value = v8::Local::::try_from(options.get(scope, 8)?).ok()?; + let policy = value.to_rust_string_lossy(scope); + (!policy.is_empty()).then_some(policy) + }; Some(crate::module_runtime::ModuleFetchMetadata { credentials_mode, request_metadata: moli_fetch::ScriptFetchRequestMetadata { nonce: script_nonce_from_host_defined_options(scope, host_defined_options), + referrer_policy, ..Default::default() }, parser_inserted: script_parser_inserted_from_host_defined_options( @@ -1358,6 +1375,7 @@ mod tests { parser_inserted: true, request_metadata: moli_fetch::ScriptFetchRequestMetadata { nonce: Some("initiator-nonce".to_owned()), + referrer_policy: Some("no-referrer".to_owned()), // The importing script's SRI hash must not apply to its imports. integrity: Some("sha256-AAAA".to_owned()), ..Default::default() @@ -1370,6 +1388,10 @@ mod tests { let decoded = script_fetch_metadata_from_host_defined_options(scope, options).unwrap(); assert_eq!(decoded.credentials_mode, credentials_mode); assert_eq!(decoded.nonce(), Some("initiator-nonce")); + assert_eq!( + decoded.request_metadata.referrer_policy.as_deref(), + Some("no-referrer") + ); assert!(decoded.parser_inserted); assert!(decoded.integrity().is_none()); }