From d124fbf6eefdd41fb8be19155cb752ab06c717b5 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Tue, 8 Sep 2026 16:57:16 +0800 Subject: [PATCH] fix(scripts): enforce client-origin CORS before script execution Bind script loads and cache entries to the document client origin, authorize redirects before following them, and preserve redirect origin taint across Window and Worker Fetch/XHR validation and response filtering. Check dynamic script CSP before transport, cover real HTTP and lifecycle regressions, and refresh the one newly passing WPT case after fixed-binary CLI/CDP comparisons. --- moli-core/tests/scripts.rs | 10 +- moli-fetch/src/blocking/mod.rs | 32 +- .../src/network/context/document.rs | 10 + .../src/network/request_client.rs | 77 ++- .../src/network/request_client/tests.rs | 1 + .../request_client/tests/script_cors.rs | 486 ++++++++++++++++++ moli-renderer-v8/src/network_host.rs | 20 +- .../src/network_host/async_fetch.rs | 86 ++-- .../src/network_host/controlled_resource.rs | 3 + .../src/network_host/response/cors.rs | 60 ++- .../src/network_host/response_hop.rs | 42 +- moli-renderer-v8/src/planning.rs | 18 + .../tests/extracted/parser_module_tasks.rs | 99 ++-- .../src/runtime/page_vm/tests/mod.rs | 48 ++ moli-renderer-v8/src/script_vm/tests/mod.rs | 2 +- .../src/worker/global_scope/xhr.rs | 9 +- .../src/worker/thread/tests/cors_redirects.rs | 125 +++++ .../src/worker/thread/tests/mod.rs | 1 + moli-types/moli-fetch-types/src/lib.rs | 62 +++ moli-webapi/src/fetch_response/metadata.rs | 30 ++ 20 files changed, 1124 insertions(+), 97 deletions(-) create mode 100644 moli-renderer-v8/src/network/request_client/tests/script_cors.rs create mode 100644 moli-renderer-v8/src/worker/thread/tests/cors_redirects.rs diff --git a/moli-core/tests/scripts.rs b/moli-core/tests/scripts.rs index 4abc00a56d1..4c80d15421a 100644 --- a/moli-core/tests/scripts.rs +++ b/moli-core/tests/scripts.rs @@ -5339,7 +5339,9 @@ async fn module_wasm_csp_blocks_cross_origin_script_element_fetch() -> Result<() .await?; assert_eq!( diagnostic_global(&page, "moduleWasmCspViolationCount"), - Some(&JsValueSnapshot::Number(1.0)) + Some(&JsValueSnapshot::Number(1.0)), + "script report: {:#?}", + page.script_execution() ); assert_eq!( diagnostic_global(&page, "moduleWasmCspViolationText"), @@ -5351,6 +5353,12 @@ async fn module_wasm_csp_blocks_cross_origin_script_element_fetch() -> Result<() diagnostic_global(&page, "moduleWasmCspExecuted"), Some(&JsValueSnapshot::String(String::new())) ); + assert!( + page.subresource_network_records() + .iter() + .all(|record| record.url().path() != "/assets/execute-start.wasm"), + "CSP must block the dynamic module before source transport starts" + ); server.shutdown().await; Ok(()) diff --git a/moli-fetch/src/blocking/mod.rs b/moli-fetch/src/blocking/mod.rs index 85349f861fb..566fd618053 100644 --- a/moli-fetch/src/blocking/mod.rs +++ b/moli-fetch/src/blocking/mod.rs @@ -410,12 +410,38 @@ fn append_browser_subresource_headers( request: &Request, request_url: &Url, ) { - let Some(metadata) = request.browser_request_metadata() else { - return; - }; if !matches!(request_url.scheme(), "http" | "https") { return; } + let Some(metadata) = request.browser_request_metadata() else { + if matches!( + request.resource_type, + crate::RequestResourceType::Script + | crate::RequestResourceType::ParserBlockingScript + | crate::RequestResourceType::ClassicAsyncOrDeferScript + | crate::RequestResourceType::LatePreloadScript + ) { + append_header_if_missing(outgoing, "Accept", "*/*".to_owned()); + append_header_if_missing( + outgoing, + "Accept-Language", + config.browser_identity().accept_language().to_owned(), + ); + append_header_if_missing( + outgoing, + "Sec-Fetch-Site", + request_sec_fetch_site(request, request_url), + ); + append_header_if_missing( + outgoing, + "Sec-Fetch-Mode", + request.request_mode.as_ref().to_owned(), + ); + append_header_if_missing(outgoing, "Sec-Fetch-Dest", "script".to_owned()); + append_browser_client_hints(outgoing, config); + } + return; + }; append_encoded_header_if_missing( outgoing, diff --git a/moli-renderer-v8/src/network/context/document.rs b/moli-renderer-v8/src/network/context/document.rs index 3b47f35f209..8b8e037360b 100644 --- a/moli-renderer-v8/src/network/context/document.rs +++ b/moli-renderer-v8/src/network/context/document.rs @@ -144,6 +144,11 @@ impl DocumentResourceLoader { request_client = request_client.with_browser_site_context(browser_site_context); } let loads = ResourceLoadRegistry::new(task_runner); + // The Fetch client origin is independent of a script's referrer/base + // URL, including cross-origin dependencies and inherited/sandboxed Documents. + let request_client = request_client.with_script_request_origin( + moli_url::WebOrigin::from_ascii_serialization(context.origin()), + ); Self { request_client, authority: Arc::new(DocumentResourceLoaderAuthority { @@ -217,6 +222,11 @@ impl DocumentResourceLoader { if let Some(browser_site_context) = self.request_client.shared_browser_site_context() { request_client = request_client.with_shared_browser_site_context(browser_site_context); } + request_client = request_client.with_script_request_origin( + moli_url::WebOrigin::from_ascii_serialization( + self.authority.lifecycle.lock().context.origin(), + ), + ); Self { request_client, authority: Arc::clone(&self.authority), diff --git a/moli-renderer-v8/src/network/request_client.rs b/moli-renderer-v8/src/network/request_client.rs index a11577789be..311674d82cf 100644 --- a/moli-renderer-v8/src/network/request_client.rs +++ b/moli-renderer-v8/src/network/request_client.rs @@ -35,6 +35,7 @@ pub struct ResourceRequestClient { resource_runtime: BrowserResourceRuntime, page_network_policy: PageNetworkPolicy, browser_site_context: Option>, + script_request_origin: Option>, } /// Thread-affine lifetime root for a standalone resource request client. @@ -123,6 +124,22 @@ impl ResourceRequestClient { resource_runtime, page_network_policy, browser_site_context: None, + script_request_origin: None, + } + } + + pub(crate) fn with_script_request_origin(mut self, origin: moli_url::WebOrigin) -> Self { + self.script_request_origin = Some(Arc::new(origin)); + self + } + + fn script_request_with_client_origin(&self, request: Request) -> Request { + if request.request_origin().is_none() + && let Some(origin) = &self.script_request_origin + { + request.with_request_origin(origin.as_ref().clone()) + } else { + request } } @@ -162,6 +179,7 @@ impl ResourceRequestClient { self.page_network_policy.frozen_request_view(), ); client.browser_site_context = self.browser_site_context.clone(); + client.script_request_origin = self.script_request_origin.clone(); client } @@ -320,7 +338,7 @@ impl ResourceRequestClient { request .browser_request_metadata .get_or_insert(moli_fetch::BrowserRequestMetadata::Script); - let request = self.apply_network_policy(request)?; + let request = self.apply_network_policy(self.script_request_with_client_origin(request))?; if let Some(result) = local_text_response(&request) { return result; } @@ -338,7 +356,10 @@ impl ResourceRequestClient { ); } let result = self - .fetch_text_stream_with_cancel_after_policy(request, FetchCancelHandle::new()) + .fetch_script_text_stream_with_cancel_after_policy( + request, + FetchCancelHandle::new(), + ) .await; if let (Some(started), Some(url)) = (started, timing_url.as_deref()) { let status = result.as_ref().ok().map(|response| response.status); @@ -419,7 +440,7 @@ impl ResourceRequestClient { } let cache_request = request.clone(); let result = self - .fetch_text_stream_with_cancel_after_policy(request, FetchCancelHandle::new()) + .fetch_script_text_stream_with_cancel_after_policy(request, FetchCancelHandle::new()) .await .map_err(|error| format!("{error:#}")); if let (Some(started), Some(url)) = (started, timing_url.as_deref()) { @@ -469,7 +490,7 @@ impl ResourceRequestClient { request .browser_request_metadata .get_or_insert(moli_fetch::BrowserRequestMetadata::Script); - let request = self.apply_network_policy(request)?; + let request = self.apply_network_policy(self.script_request_with_client_origin(request))?; if let Some(result) = local_text_response(&request) { let task_runner = resource_load.task_runner(); task_runner.spawn(async move { @@ -494,9 +515,10 @@ impl ResourceRequestClient { let cancel_handle = FetchCancelHandle::new(); resource_load.attach_cancel_handle(cancel_handle.clone()); let callback_resource_load = resource_load.clone(); - let started_fetch = self.fetch_text_callback_with_cancel_after_policy( + let started_fetch = self.fetch_script_text_callback_with_cancel_after_policy( request, cancel_handle, + resource_load.task_runner(), move |result| { callback_resource_load.finish(); if let (Some(started), Some(url)) = (started, timing_url.as_deref()) { @@ -607,9 +629,10 @@ impl ResourceRequestClient { let callback_key = key.clone(); let cancel_handle = FetchCancelHandle::new(); load.attach_transport_cancel(cancel_handle.clone()); - if let Err(error) = self.fetch_text_callback_with_cancel_after_policy( + if let Err(error) = self.fetch_script_text_callback_with_cancel_after_policy( request, cancel_handle, + resource_load.task_runner(), move |result| { let result = result.map_err(|error| format!("{error:#}")); request_client.complete_cached_script_text_load( @@ -668,6 +691,48 @@ impl ResourceRequestClient { load.finish(result); } + async fn fetch_script_text_stream_with_cancel_after_policy( + &self, + request: Request, + cancel_handle: FetchCancelHandle, + ) -> Result { + if request.request_mode == moli_fetch::RequestMode::Cors + && request.request_origin().is_some() + { + return crate::network_host::fetch_cors_script_text(self, request, cancel_handle) + .await + .map_err(anyhow::Error::msg); + } + self.fetch_text_stream_with_cancel_after_policy(request, cancel_handle) + .await + } + + fn fetch_script_text_callback_with_cancel_after_policy( + &self, + request: Request, + cancel_handle: FetchCancelHandle, + task_runner: super::RendererResourceTaskRunner, + callback: F, + ) -> Result<()> + where + F: FnOnce(Result) + Send + 'static, + { + if request.request_mode == moli_fetch::RequestMode::Cors + && request.request_origin().is_some() + { + let client = self.clone(); + task_runner.spawn(async move { + callback( + client + .fetch_script_text_stream_with_cancel_after_policy(request, cancel_handle) + .await, + ); + }); + return Ok(()); + } + self.fetch_text_callback_with_cancel_after_policy(request, cancel_handle, callback) + } + async fn fetch_text_stream_with_cancel_after_policy( &self, request: Request, diff --git a/moli-renderer-v8/src/network/request_client/tests.rs b/moli-renderer-v8/src/network/request_client/tests.rs index e01dff8f74d..df67d2c65f5 100644 --- a/moli-renderer-v8/src/network/request_client/tests.rs +++ b/moli-renderer-v8/src/network/request_client/tests.rs @@ -99,6 +99,7 @@ fn browser_client_rejects_http_requests_even_with_an_initiator() -> Result<()> { owner.handle().apply_network_policy(browser)?; Ok(()) } +mod script_cors; #[test] fn loader_clones_share_one_browser_resource_runtime() { diff --git a/moli-renderer-v8/src/network/request_client/tests/script_cors.rs b/moli-renderer-v8/src/network/request_client/tests/script_cors.rs new file mode 100644 index 00000000000..2e8348a2065 --- /dev/null +++ b/moli-renderer-v8/src/network/request_client/tests/script_cors.rs @@ -0,0 +1,486 @@ +use super::*; +use crate::{ + frame_owner_model::{DocumentId, FrameDocumentTaskOwner, FrameSchedulerLaneId, LocalWindowId}, + native_bridge::WindowDocumentOwner, + network::{ + RendererResourceTaskRunner, + context::{DocumentFetchContext, DocumentResourceLoader}, + loads::{ResourceLoadDisposition, ResourceLoadKind}, + }, +}; +use moli_fetch::{RequestMode, Response}; +use parking_lot::Mutex; + +struct ScriptServer { + url: Url, + requests: Arc>>, + task: tokio::task::JoinHandle<()>, +} + +impl ScriptServer { + async fn new(status: u16, headers: &[(&str, &str)]) -> Self { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = Url::parse(&format!( + "http://{}/script.mjs", + listener.local_addr().unwrap() + )) + .unwrap(); + let body = "export const value = 1;"; + let extra_headers = headers + .iter() + .map(|(name, value)| format!("{name}: {value}\r\n")) + .collect::(); + let response = format!( + "HTTP/1.1 {status} Test\r\nContent-Type: application/javascript\r\nCache-Control: max-age=3600\r\nContent-Length: {}\r\nConnection: close\r\n{extra_headers}\r\n{body}", + body.len() + ); + let requests = Arc::new(Mutex::new(Vec::new())); + let captured = Arc::clone(&requests); + let task = tokio::spawn(async move { + while let Ok((mut stream, _)) = listener.accept().await { + let request = read_http_request_text(&mut stream).await.unwrap(); + captured.lock().push(request); + stream.write_all(response.as_bytes()).await.unwrap(); + } + }); + Self { + url, + requests, + task, + } + } + + fn request_count(&self) -> usize { + self.requests.lock().len() + } + + fn last_origin(&self) -> Option { + self.last_header("origin") + } + + fn last_header(&self, header: &str) -> Option { + self.requests.lock().last().and_then(|request| { + request.lines().find_map(|line| { + let (name, value) = line.split_once(':')?; + name.eq_ignore_ascii_case(header) + .then(|| value.trim().to_owned()) + }) + }) + } +} + +impl Drop for ScriptServer { + fn drop(&mut self) { + self.task.abort(); + } +} + +fn document(loader: &ResourceRequestClient, url: &str, origin: &str) -> DocumentResourceLoader { + let url = Url::parse(url).unwrap(); + DocumentResourceLoader::new( + loader.clone(), + RendererResourceTaskRunner::from_current_tokio().unwrap(), + DocumentFetchContext::new( + WindowDocumentOwner::Frame(FrameDocumentTaskOwner::new( + FrameSchedulerLaneId(7), + LocalWindowId(11), + DocumentId(1), + )), + url.clone(), + url, + origin, + ), + ) +} + +fn script_request(url: &Url, mode: RequestMode, credentials: RequestCredentialsMode) -> Request { + Request::new("GET", url.as_str(), None, Vec::new()) + .unwrap() + // A dependency's referrer can be same-origin with the script server. + // It must never replace the Document's origin for CORS or cookies. + .with_initiator_url(url) + .with_request_mode(mode) + .with_credentials_mode(credentials) + .with_script_fetch_metadata(ScriptFetchRequestMetadata::default()) +} + +async fn fetch_script( + document: &DocumentResourceLoader, + request: Request, + callback: bool, +) -> Result { + let load = document + .register_load( + ResourceLoadKind::Script, + ResourceLoadDisposition::Ordinary, + None, + ) + .unwrap(); + let client = load.request_client(); + if callback { + let (tx, rx) = oneshot::channel(); + client.fetch_cacheable_script_text_callback_with_load(request, load, move |result| { + let _ = tx.send(result); + })?; + timeout(Duration::from_secs(5), rx).await?? + } else { + let result = timeout( + Duration::from_secs(5), + client.fetch_cacheable_script_text_stream(request), + ) + .await?; + load.finish(); + result + } +} + +#[tokio::test] +async fn script_cors_checks_the_document_origin_and_credentials_in_both_fetch_paths() { + for callback in [false, true] { + for (headers, credentials, allowed) in [ + (vec![], RequestCredentialsMode::SameOrigin, false), + ( + vec![("Access-Control-Allow-Origin", "https://wrong.test")], + RequestCredentialsMode::SameOrigin, + false, + ), + ( + vec![("Access-Control-Allow-Origin", "https://page.test")], + RequestCredentialsMode::SameOrigin, + true, + ), + ( + vec![("Access-Control-Allow-Origin", "*")], + RequestCredentialsMode::SameOrigin, + true, + ), + ( + vec![("Access-Control-Allow-Origin", "*")], + RequestCredentialsMode::Include, + false, + ), + ( + vec![("Access-Control-Allow-Origin", "https://page.test")], + RequestCredentialsMode::Include, + false, + ), + ( + vec![ + ("Access-Control-Allow-Origin", "https://page.test"), + ("Access-Control-Allow-Credentials", "true"), + ], + RequestCredentialsMode::Include, + true, + ), + ] { + let server = ScriptServer::new(200, &headers).await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let document = document(&transport, "https://page.test/page", "https://page.test"); + let result = fetch_script( + &document, + script_request(&server.url, RequestMode::Cors, credentials), + callback, + ) + .await; + assert_eq!( + result.is_ok(), + allowed, + "callback={callback}, headers={headers:?}, credentials={credentials:?}: {result:?}" + ); + assert_eq!(server.last_origin().as_deref(), Some("https://page.test")); + if let Err(error) = result { + assert!(error.to_string().contains("CORS check failed"), "{error}"); + } + } + } +} + +#[tokio::test] +async fn script_cors_preserves_same_origin_and_no_cors_loading() { + for callback in [false, true] { + for mode in [RequestMode::Cors, RequestMode::NoCors] { + let server = ScriptServer::new(200, &[]).await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let origin = if mode == RequestMode::Cors { + moli_url::origin_ascii_serialization(&server.url) + } else { + "https://page.test".to_owned() + }; + let document = document(&transport, server.url.as_str(), &origin); + fetch_script( + &document, + script_request(&server.url, mode, RequestCredentialsMode::Include), + callback, + ) + .await + .unwrap(); + } + } +} + +#[tokio::test] +async fn script_cors_cache_cannot_reuse_no_cors_or_another_documents_authorization() { + for callback in [false, true] { + let server = ScriptServer::new( + 200, + &[ + ("Access-Control-Allow-Origin", "https://first.test"), + ("Access-Control-Allow-Credentials", "true"), + ], + ) + .await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let first = document(&transport, "https://first.test/page", "https://first.test"); + let second = first.fork_for_document(DocumentFetchContext::new( + WindowDocumentOwner::Frame(FrameDocumentTaskOwner::new( + FrameSchedulerLaneId(7), + LocalWindowId(11), + DocumentId(2), + )), + Url::parse("https://second.test/page").unwrap(), + Url::parse("https://second.test/base").unwrap(), + "https://second.test", + )); + for _ in 0..2 { + fetch_script( + &first, + script_request( + &server.url, + RequestMode::Cors, + RequestCredentialsMode::Include, + ), + callback, + ) + .await + .unwrap(); + } + assert_eq!( + server.request_count(), + 1, + "same Document should reuse its authorized response" + ); + let result = fetch_script( + &second, + script_request( + &server.url, + RequestMode::Cors, + RequestCredentialsMode::Include, + ), + callback, + ) + .await; + assert!( + result.is_err(), + "another Document must perform its own CORS check" + ); + + let server = ScriptServer::new(200, &[]).await; + fetch_script( + &first, + script_request( + &server.url, + RequestMode::NoCors, + RequestCredentialsMode::Include, + ), + callback, + ) + .await + .unwrap(); + let result = fetch_script( + &first, + script_request( + &server.url, + RequestMode::Cors, + RequestCredentialsMode::Include, + ), + callback, + ) + .await; + assert!( + result.is_err(), + "a classic no-cors cache entry must not authorize a module" + ); + } +} + +#[tokio::test] +async fn script_cors_rejects_a_redirect_before_requesting_its_target() { + for callback in [false, true] { + let final_server = ScriptServer::new(200, &[("Access-Control-Allow-Origin", "*")]).await; + let redirect = ScriptServer::new(302, &[("Location", final_server.url.as_str())]).await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let document = document(&transport, "https://page.test/page", "https://page.test"); + let result = fetch_script( + &document, + script_request( + &redirect.url, + RequestMode::Cors, + RequestCredentialsMode::SameOrigin, + ), + callback, + ) + .await; + assert!( + result.is_err(), + "missing CORS headers on an intermediate redirect must reject" + ); + assert_eq!( + final_server.request_count(), + 0, + "blocked redirect target must not be fetched" + ); + } +} + +#[tokio::test] +async fn script_cors_cross_origin_redirects_taint_the_origin() { + for callback in [false, true] { + for (allow_origin, allowed) in [("null", true), ("https://page.test", false)] { + let final_server = + ScriptServer::new(200, &[("Access-Control-Allow-Origin", allow_origin)]).await; + let redirect = ScriptServer::new( + 302, + &[ + ("Location", final_server.url.as_str()), + ("Access-Control-Allow-Origin", "https://page.test"), + ], + ) + .await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let document = document(&transport, "https://page.test/page", "https://page.test"); + let result = fetch_script( + &document, + script_request( + &redirect.url, + RequestMode::Cors, + RequestCredentialsMode::SameOrigin, + ), + callback, + ) + .await; + assert_eq!(result.is_ok(), allowed, "{result:?}"); + assert_eq!(redirect.last_origin().as_deref(), Some("https://page.test")); + assert_eq!(final_server.last_origin().as_deref(), Some("null")); + } + } +} + +#[tokio::test] +async fn script_cors_redirects_drop_authorization_apply_referrer_policy_and_preserve_fragments() { + for callback in [false, true] { + let final_server = ScriptServer::new(200, &[("Access-Control-Allow-Origin", "*")]).await; + let redirect = ScriptServer::new( + 302, + &[ + ("Location", final_server.url.as_str()), + ("Referrer-Policy", "no-referrer"), + ], + ) + .await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let origin = moli_url::origin_ascii_serialization(&redirect.url); + let document = document(&transport, redirect.url.as_str(), &origin); + let mut request = script_request( + &redirect.url, + RequestMode::Cors, + RequestCredentialsMode::SameOrigin, + ); + request.url.set_fragment(Some("module-fragment")); + request.request_headers = vec![ + ("Authorization".to_owned(), "Bearer test-only".to_owned()), + ("X-Embedder".to_owned(), "preserved".to_owned()), + ]; + let response = fetch_script(&document, request, callback).await.unwrap(); + assert_eq!(response.final_url.fragment(), Some("module-fragment")); + assert_eq!(redirect.request_count(), 1); + assert_eq!( + final_server.request_count(), + 1, + "browser-added script headers must not trigger preflight" + ); + assert_eq!( + redirect.last_header("authorization").as_deref(), + Some("Bearer test-only") + ); + assert_eq!(final_server.last_header("authorization"), None); + assert_eq!(final_server.last_header("referer"), None); + assert_eq!( + final_server.last_header("x-embedder").as_deref(), + Some("preserved") + ); + } +} + +#[tokio::test] +async fn script_cors_redirects_reject_non_http_schemes_and_cross_origin_url_credentials() { + for callback in [false, true] { + for target in [ + "data:text/javascript,export default 1", + "http://user:pass@other.test/module.js", + ] { + let redirect = ScriptServer::new(302, &[("Location", target)]).await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let origin = moli_url::origin_ascii_serialization(&redirect.url); + let document = document(&transport, redirect.url.as_str(), &origin); + let result = fetch_script( + &document, + script_request( + &redirect.url, + RequestMode::Cors, + RequestCredentialsMode::SameOrigin, + ), + callback, + ) + .await; + assert!(result.is_err()); + assert!(result.unwrap_err().to_string().contains("CORS redirect")); + } + } +} + +#[tokio::test] +async fn script_cors_uses_inherited_and_opaque_document_origins_after_transport_replacement() { + for callback in [false, true] { + for origin in ["https://creator.test", "null"] { + let server = ScriptServer::new(200, &[("Access-Control-Allow-Origin", origin)]).await; + let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let replacement = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let document = document(&transport, "about:srcdoc", origin) + .with_replacement_transport(replacement.handle()); + fetch_script( + &document, + script_request( + &server.url, + RequestMode::Cors, + RequestCredentialsMode::SameOrigin, + ), + callback, + ) + .await + .unwrap(); + assert_eq!(server.last_origin().as_deref(), Some(origin)); + } + } +} + +#[test] +fn script_cors_memory_cache_key_separates_origins_and_request_modes() { + let url = Url::parse("https://script.test/module.js").unwrap(); + let first = script_request(&url, RequestMode::Cors, RequestCredentialsMode::Include) + .with_request_origin(moli_url::WebOrigin::from_ascii_serialization( + "https://first.test", + )); + let second = first + .clone() + .with_request_origin(moli_url::WebOrigin::from_ascii_serialization( + "https://second.test", + )); + assert_ne!( + super::super::script_text_cache_key(&first), + super::super::script_text_cache_key(&second) + ); + assert_ne!( + super::super::script_text_cache_key(&first), + super::super::script_text_cache_key(&first.clone().with_request_mode(RequestMode::NoCors)) + ); +} diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs index b6ef5298587..29e98c81a9c 100644 --- a/moli-renderer-v8/src/network_host.rs +++ b/moli-renderer-v8/src/network_host.rs @@ -38,7 +38,7 @@ use crate::network::ResourceRequestClient; pub(crate) use self::async_fetch::{ collect_image_response_into_parkable, fetch_browser_subresource_with_preflight_headers, - spawn_async_subresource_fetch, + fetch_cors_script_text, spawn_async_subresource_fetch, }; #[cfg(any(test, feature = "devtools"))] pub(crate) use self::async_fetch::{ @@ -129,15 +129,13 @@ pub(crate) use self::media::{ start_media_element_resource_fetch, }; pub(in crate::network_host) use self::preflight_events::CorsPreflightNetworkObserver; +pub(crate) use self::request::build_cached_request_object; pub(in crate::network_host) use self::request::normalize_request_method; pub(crate) use self::request::request_constructor_callback; pub(crate) use self::request::{ FetchArgs, parse_fetch_init, parse_request_redirect_mode_label, request_object_credentials_mode, }; pub(crate) use self::request::{FetchArgumentError, convert_fetch_arguments}; -pub(crate) use self::request::{ - RequestInputUrl, build_cached_request_object, build_service_worker_request_object, -}; pub(crate) use self::request::{ mark_request_input_body_used_for_fetch, request_body_already_used_error, try_resolve_request_constructor_url, try_resolve_request_constructor_url_for_base, @@ -162,7 +160,7 @@ pub(crate) use self::response::{ cors_preflight_request_headers, filter_cors_exposed_response_headers, is_cors_policy_failure_message, materialize_response_object_body, materialize_response_object_body_preserving_error, - materialize_response_object_body_with_chunk_callback, materialize_response_object_head, + materialize_response_object_body_with_chunk_callback, materialize_response_object_head_for_service_worker_respond_with, materialized_body_bytes_from_value, network_response_filter, response_constructor_callback, validate_cors_preflight_response, validate_cors_response_chain, @@ -255,9 +253,19 @@ fn cross_origin_request_modes( } } -pub(crate) use response::{fetch_response_metadata, set_response_metadata}; +pub(crate) use response::fetch_response_metadata; #[cfg(test)] pub(crate) use response::build_fetch_response_object_from_stream_for_request_mode; pub(crate) mod controlled_resource; + +#[cfg(test)] +pub(crate) use response::build_fetch_response_object_for_request_mode; + +#[cfg(test)] +pub(crate) use response::materialize_response_object_head; + +pub(crate) use request::build_service_worker_request_object; + +pub(crate) use response::set_cached_response_head; diff --git a/moli-renderer-v8/src/network_host/async_fetch.rs b/moli-renderer-v8/src/network_host/async_fetch.rs index 704719620af..6c4d75399ce 100644 --- a/moli-renderer-v8/src/network_host/async_fetch.rs +++ b/moli-renderer-v8/src/network_host/async_fetch.rs @@ -11,6 +11,28 @@ use moli_fetch::{ const MAX_MANUAL_CORS_REDIRECTS: usize = 20; +/// Script fetches need CORS authorization before following every redirect, +/// even though their browser-generated GET requests do not require preflight. +pub(crate) async fn fetch_cors_script_text( + loader: &ResourceRequestClient, + request: Request, + cancel_handle: FetchCancelHandle, +) -> Result { + let observed = fetch_browser_subresource_raw_stream_with_manual_preflight_redirects( + loader, + request, + Some(cancel_handle), + Vec::new(), + None, + ) + .await?; + observed + .into_response() + .into_lossy_materialized_text_response() + .await + .map_err(format_network_error) +} + #[cfg(test)] pub(crate) async fn fetch_browser_subresource_with_preflight( loader: ResourceRequestClient, @@ -190,28 +212,6 @@ pub(super) async fn fetch_subresource_hop( })) } -pub(crate) fn browser_request_needs_manual_preflight_redirects( - request: &Request, - preflight_request_headers: &[(String, String)], -) -> bool { - matches!( - request.browser_request_metadata(), - Some( - BrowserRequestMetadata::Fetch - | BrowserRequestMetadata::EventSource - | BrowserRequestMetadata::JsonModule - | BrowserRequestMetadata::TextModule - | BrowserRequestMetadata::Manifest - | BrowserRequestMetadata::StyleModule - | BrowserRequestMetadata::Xhr, - ) - ) && request.request_mode == RequestMode::Cors - && request.cookie_context.initiator_url.is_some() - && (request.use_cors_preflight() - || !is_cors_safelisted_method(&request.method) - || !moli_fetch::cors_unsafe_request_header_names(preflight_request_headers).is_empty()) -} - struct ManualCorsRedirectState { request: Request, preflight_request_headers: Vec<(String, String)>, @@ -265,10 +265,16 @@ impl ManualCorsRedirectState { &mut self.request, head, network_response_extra_info, + moli_fetch::RedirectSource::Network, web_security_disabled, )?; if transition == SubresourceResponseTransition::FollowedRedirect { - self.preflight_request_headers = self.request.request_headers.to_byte_strings(); + self.preflight_request_headers.retain(|(name, _)| { + self.request + .request_headers + .iter() + .any(|(remaining, _)| name.eq_ignore_ascii_case(remaining)) + }); } Ok(transition) } @@ -424,7 +430,12 @@ pub(crate) fn next_redirect_url( final_url .join(&location) .or_else(|_| url::Url::parse(&location)) - .map(Some) + .map(|mut url| { + if !location.contains('#') { + url.set_fragment(final_url.fragment()); + } + Some(url) + }) .map_err(|error| { format!("failed to resolve redirect location `{location}` from {final_url}: {error}") }) @@ -1104,6 +1115,7 @@ mod tests { from_cache: false, cache_state: Default::default(), negotiated_http_version: None, + preload_state: Default::default(), }, None, false, @@ -1118,16 +1130,26 @@ mod tests { #[test] fn follow_rejects_an_invalid_final_redirect_location_without_parsing_manual_redirects() { let url = Url::parse("https://origin.test/source").unwrap(); - let headers = vec![("Location".to_owned(), b"http://[".to_vec())]; + let mut head = ResponseHead { + final_url: url.clone(), + status: 302, + status_text: None, + headers: vec![("Location".to_owned(), b"http://[".to_vec())], + request_cookie_report: None, + cookie_set_reports: Vec::new(), + redirected: false, + redirect_chain: Vec::new(), + from_cache: false, + cache_state: Default::default(), + preload_state: Default::default(), + negotiated_http_version: None, + }; for mode in [RequestRedirectMode::Follow, RequestRedirectMode::Error] { - assert!(validate_redirect_mode_parts(&url, 302, &headers, mode).is_err()); + assert!(validate_redirect_mode_response_head(&head, mode).is_err()); } - assert!( - validate_redirect_mode_parts(&url, 302, &headers, RequestRedirectMode::Manual).is_ok() - ); - assert!( - validate_redirect_mode_parts(&url, 200, &headers, RequestRedirectMode::Follow).is_ok() - ); + assert!(validate_redirect_mode_response_head(&head, RequestRedirectMode::Manual).is_ok()); + head.status = 200; + assert!(validate_redirect_mode_response_head(&head, RequestRedirectMode::Follow).is_ok()); } #[test] diff --git a/moli-renderer-v8/src/network_host/controlled_resource.rs b/moli-renderer-v8/src/network_host/controlled_resource.rs index 2673144b99d..998fa505051 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource.rs @@ -388,6 +388,7 @@ impl ControlledResourceLoad { from_cache: false, cache_state: Default::default(), negotiated_http_version: None, + preload_state: Default::default(), }) } @@ -669,6 +670,7 @@ impl ControlledResourceLoad { &mut self.request, response.head.clone(), network_response_extra_info, + moli_fetch::RedirectSource::Network, self.load.request_client().web_security_disabled(), )? } else { @@ -676,6 +678,7 @@ impl ControlledResourceLoad { &mut self.request, response.head.clone(), network_response_extra_info, + moli_fetch::RedirectSource::Network, self.load.request_client().web_security_disabled(), )? }; diff --git a/moli-renderer-v8/src/network_host/response/cors.rs b/moli-renderer-v8/src/network_host/response/cors.rs index 9ba66224629..9be67d85f2e 100644 --- a/moli-renderer-v8/src/network_host/response/cors.rs +++ b/moli-renderer-v8/src/network_host/response/cors.rs @@ -89,7 +89,7 @@ pub(crate) fn validate_fetch_response_security_policy( let request_origin = request_origin.into(); if !web_security_disabled { head.url_list() - .validate_request_mode(request_mode, &request_origin) + .validate_request_mode(request_mode, request_origin.clone()) .map_err(|error| error.to_string())?; } if request_mode == RequestMode::SameOrigin { @@ -683,6 +683,64 @@ mod tests { ); } + #[test] + fn cors_response_validation_uses_the_redirect_tainted_origin() { + let home = url("https://page.test/a"); + let away = url("https://script.test/b"); + let elsewhere = url("https://other.test/c"); + let origin = WebOrigin::from_url(&home); + for (redirects, serialized_origin) in [ + (vec![(&home, &away)], origin.ascii_serialization()), + (vec![(&away, &elsewhere)], "null"), + (vec![(&home, &away), (&away, &home)], "null"), + ] { + let final_url = redirects.last().expect("redirect target").1.clone(); + let mut head = header_response( + final_url, + vec![( + "Access-Control-Allow-Origin".to_owned(), + serialized_origin.as_bytes().to_vec(), + )], + ); + head.redirected = true; + head.redirect_chain = redirects + .into_iter() + .map(|(from, to)| moli_fetch::RedirectInfo { + source: RedirectSource::Network, + from_url: from.clone(), + to_url: to.clone(), + status: 302, + headers: vec![( + "Access-Control-Allow-Origin".to_owned(), + origin.ascii_serialization().as_bytes().to_vec(), + )], + network_extra_info_available: false, + request_extra_info: None, + response_extra_info: None, + redirect_has_extra_info: false, + request_cookie_report: None, + cookie_set_reports: Vec::new(), + from_cache: false, + negotiated_http_version: None, + + dispatched_request: None, + }) + .collect(); + assert_eq!( + head.url_list().serialized_origin(&origin), + serialized_origin + ); + validate_cors_response_chain(&origin, &head, RequestCredentialsMode::SameOrigin) + .expect("each response must be authorized against its own request hop origin"); + head.headers.clear(); + assert!( + validate_cors_response_chain(&origin, &head, RequestCredentialsMode::SameOrigin) + .is_err(), + "returning to the initial origin must not bypass CORS" + ); + } + } + #[test] fn cors_preflight_request_headers_detect_unsafe_method_and_headers() { let headers = vec![ diff --git a/moli-renderer-v8/src/network_host/response_hop.rs b/moli-renderer-v8/src/network_host/response_hop.rs index 79b05b302cf..ad80c8c2bf5 100644 --- a/moli-renderer-v8/src/network_host/response_hop.rs +++ b/moli-renderer-v8/src/network_host/response_hop.rs @@ -7,9 +7,10 @@ use moli_fetch::{ }; use super::next_redirect_url; +use moli_fetch::RequestMode; #[derive(Clone, Debug, Eq, PartialEq)] -pub(super) enum SubresourceResponseTransition { +pub(crate) enum SubresourceResponseTransition { FinalResponse, ManualResponse { response_url: url::Url }, FollowedRedirect, @@ -38,17 +39,21 @@ pub(super) fn advance_subresource_response( request: &mut Request, head: ResponseHead, network_response_extra_info: Option, + source: RedirectSource, web_security_disabled: bool, ) -> Result { // Preserve transport-refined snapshots, including cached/internal hops. - request.observe_redirect_requests(&head.redirect_chain); - if !web_security_disabled { + if source == moli_fetch::RedirectSource::Network { + request.observe_redirect_requests(&head.redirect_chain); + } + if source == moli_fetch::RedirectSource::Network && !web_security_disabled { request.validate_cors_response_for_url(&head.final_url, &head.headers)?; } advance_validated_subresource_response( request, head, network_response_extra_info, + source, web_security_disabled, ) } @@ -57,6 +62,7 @@ pub(super) fn advance_validated_subresource_response( request: &mut Request, head: ResponseHead, network_response_extra_info: Option, + source: RedirectSource, web_security_disabled: bool, ) -> Result { // Error mode rejects redirect statuses without consulting Location. @@ -87,15 +93,35 @@ pub(super) fn advance_validated_subresource_response( else { return Ok(SubresourceResponseTransition::FinalResponse); }; - let mut redirect = head.into_redirect( - next_url, - RedirectSource::Network, - network_response_extra_info.is_some(), - ); + if !matches!(next_url.scheme(), "http" | "https") { + return Err(format!("CORS redirect requires an HTTP(S) URL: {next_url}")); + } + if request.request_mode == RequestMode::Cors + && (!next_url.username().is_empty() || next_url.password().is_some()) + && request.request_origin().is_some_and(|origin| { + !origin.same_origin_url(&head.final_url) || !origin.same_origin_url(&next_url) + }) + { + return Err("CORS redirect URL must not include credentials".to_owned()); + } + if !moli_url::same_origin(&head.final_url, &next_url) { + request + .request_headers + .retain(|(name, _)| !name.eq_ignore_ascii_case("authorization")); + if request + .auth() + .is_some_and(|auth| auth.target == moli_fetch::RequestAuthTarget::Server) + { + request.set_auth(None); + } + } + + let mut redirect = head.into_redirect(next_url, source, network_response_extra_info.is_some()); redirect.response_extra_info = network_response_extra_info; request .follow_redirect_with_web_security(redirect, web_security_disabled) .map_err(|error| error.to_string())?; + Ok(SubresourceResponseTransition::FollowedRedirect) } diff --git a/moli-renderer-v8/src/planning.rs b/moli-renderer-v8/src/planning.rs index a41cc5d4bcf..64271f37de2 100644 --- a/moli-renderer-v8/src/planning.rs +++ b/moli-renderer-v8/src/planning.rs @@ -1330,6 +1330,24 @@ mod tests { ); } + #[test] + fn classic_cors_script_uses_the_crossorigin_credentials_mode() { + for (cross_origin, expected) in [ + ("anonymous", RequestCredentialsMode::SameOrigin), + ("", RequestCredentialsMode::SameOrigin), + ("use-credentials", RequestCredentialsMode::Include), + ] { + let metadata = ScriptFetchMetadata { + cross_origin: Some(cross_origin.to_owned()), + ..ScriptFetchMetadata::default() + }; + assert_eq!( + external_script_credentials_mode(ScriptKind::Classic, &metadata), + expected + ); + } + } + #[test] fn external_script_request_sets_browser_fetch_mode() { let classic = diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/parser_module_tasks.rs b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/parser_module_tasks.rs index 2dbb8a4e025..8ea33b7cafd 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/extracted/parser_module_tasks.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/extracted/parser_module_tasks.rs @@ -3,22 +3,9 @@ use super::*; #[tokio::test] async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() { run_page_vm_async_test(async move { - let (base_url, server) = spawn_path_response_http_server(vec![ - ( - "/moved-child-defer.js", - "HTTP/1.1 200 OK", - "parent.__movedChildDeferEvents.push('classic-ran');".to_owned(), - Duration::from_millis(80), - ), - ( - "/later-moved-module.js", - "HTTP/1.1 200 OK", - "parent.__movedChildDeferEvents.push('module-ran');".to_owned(), - Duration::ZERO, - ), - ]) - .await; - let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader"); + let (base_url, release_classic, server) = spawn_moved_child_defer_http_server().await; + let loader = + crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader"); let document_url = Url::parse(&format!("{base_url}/page")).expect("page url"); let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url); let local_executor = page_vm.local_executor.clone(); @@ -63,7 +50,10 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() ))?; for _ in 0..12 { - let Some(_) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else { + let Some(_) = page_vm + .run_next_child_frame_task_source_for_semantic_test() + .await + else { break; }; } @@ -74,8 +64,13 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() ); let mut classic_completion = None; + let mut module_completion = false; + let mut release_classic = Some(release_classic); for _ in 0..4 { - if !page_vm.page_resource_completion_queue().has_ready_completion() { + if !page_vm + .page_resource_completion_queue() + .has_ready_completion() + { tokio::time::timeout( Duration::from_secs(2), wait_for_typed_page_resource_completion(&mut page_vm), @@ -83,30 +78,44 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() .await .expect("moved child defer completion should arrive"); } - let completion = - run_next_resource_completion_as_typed_page_turn(&mut page_vm)?; + let completion = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?; if matches!( completion.action.source(), RendererOwnerResourceActivitySource::ChildClassicScript ) { classic_completion = Some(completion); + } else { + assert!( + matches!( + completion.action.source(), + RendererOwnerResourceActivitySource::ModuleGraphFetch + ), + "the only other completion is the later module root" + ); + run_expected_child_module_script_terminal_turn( + &mut page_vm, + "module terminal retained behind the moved classic defer", + ) + .await; + module_completion = true; + // Make the later module ready while the classic source + // is still pending, without relying on transport timing. + release_classic + .take() + .expect("one module completion") + .send(()) + .expect("classic response should still be gated"); + } + if classic_completion.is_some() && module_completion { break; } - assert!( - matches!( - completion.action.source(), - RendererOwnerResourceActivitySource::ModuleGraphFetch - ), - "the only completion allowed ahead of the moved classic defer is its later module root" - ); - run_expected_child_module_script_terminal_turn( - &mut page_vm, - "module terminal retained behind the moved classic defer", - ) - .await; } classic_completion - .expect("classic source completion must arrive after retained module terminals"); + .expect("classic source completion must arrive before the script is moved"); + assert!( + module_completion, + "later module must be ready before testing defer-slot release" + ); page_vm.vm_mut().eval( r#" (() => { @@ -154,15 +163,27 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() ChildFrameSemanticTurnKind::DocumentLifecycle, "moved defer complete transition", ), - (ChildFrameSemanticTurnKind::HostLoad, "moved defer iframe load"), + ( + ChildFrameSemanticTurnKind::HostLoad, + "moved defer iframe load", + ), ] { sources.push( - run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(&mut page_vm, source, label) - .await, + run_expected_child_frame_task_source_after_realm_prerequisite_for_wait( + &mut page_vm, + source, + label, + ) + .await, ); } let final_events = page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?; - assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None); + assert_eq!( + page_vm + .run_next_child_frame_task_source_for_semantic_test() + .await, + None + ); Ok::<_, anyhow::Error>((events_after_dispose, sources, final_events)) }) .await @@ -183,7 +204,9 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() final_events, "before|after|ready:interactive|moved|module-ran|module-load|dcl|ready:complete|load" ); - server.await.expect("moved child defer server should finish"); + server + .await + .expect("moved child defer server should finish"); }) .await; } diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs index 70ec53f99fb..eaed7896141 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs @@ -78,6 +78,7 @@ use moli_websocket::test_support::{ use serde_json::json; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::TcpListener; +use tokio::sync::oneshot; use tokio::task::JoinHandle; use tokio::time::sleep; use url::Url; @@ -1583,6 +1584,53 @@ async fn spawn_path_response_http_server( (format!("http://{addr}"), server) } +async fn spawn_moved_child_defer_http_server() -> (String, oneshot::Sender<()>, JoinHandle<()>) { + let listener = TcpListener::bind("127.0.0.1:0") + .await + .expect("bind defer fixture"); + let base_url = format!("http://{}", listener.local_addr().unwrap()); + let (release_classic, classic_released) = oneshot::channel(); + let task = tokio::spawn(async move { + let mut classic_released = Some(classic_released); + let mut responses = Vec::new(); + for _ in 0..2 { + let (mut stream, _) = listener.accept().await.expect("accept script request"); + let request = read_http_request_head(&mut stream).await.unwrap(); + let path = request + .lines() + .next() + .unwrap() + .split_whitespace() + .nth(1) + .unwrap(); + let (body, gate) = match path { + "/moved-child-defer.js" => ( + "parent.__movedChildDeferEvents.push('classic-ran');", + Some(classic_released.take().expect("one classic request")), + ), + "/later-moved-module.js" => { + ("parent.__movedChildDeferEvents.push('module-ran');", None) + } + _ => panic!("unexpected script path: {path}"), + }; + responses.push(tokio::spawn(async move { + if let Some(gate) = gate { + gate.await.expect("test should release classic response"); + } + let response = format!( + "HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", + body.len() + ); + stream.write_all(response.as_bytes()).await.unwrap(); + })); + } + for response in responses { + response.await.expect("script response task"); + } + }); + (base_url, release_classic, task) +} + async fn spawn_concurrent_path_response_http_server( response_specs: Vec<(&'static str, &'static str, String, Duration)>, ) -> (String, JoinHandle<()>) { diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index a490d0a97c9..0edc78d7dde 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -1954,7 +1954,7 @@ async fn spawn_child_external_parser_module_ready_lane_server() -> ( let body = r#"parent.__childExternalParserModuleEvents.push("module:" + (globalThis === self)); globalThis.__childExternalParserModuleValue = 188;"#; let response = format!( - "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", + "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: http://child-parser-module-driver.test\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", body.len(), body ); diff --git a/moli-renderer-v8/src/worker/global_scope/xhr.rs b/moli-renderer-v8/src/worker/global_scope/xhr.rs index 3a5a798d1de..2ac1d24bbbb 100644 --- a/moli-renderer-v8/src/worker/global_scope/xhr.rs +++ b/moli-renderer-v8/src/worker/global_scope/xhr.rs @@ -548,7 +548,14 @@ fn send_synchronous_worker_xhr( } } match result.map(|completion| completion.result) { - Ok(Ok(response)) => apply_xhr_response(scope, xhr, response), + Ok(Ok(mut response)) => { + response.headers = filter_cors_exposed_response_headers( + &worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque), + &response.head(), + prepared.credentials_mode, + ); + apply_xhr_response(scope, xhr, response); + } Ok(Err(_)) | Err(_) => { throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError") } diff --git a/moli-renderer-v8/src/worker/thread/tests/cors_redirects.rs b/moli-renderer-v8/src/worker/thread/tests/cors_redirects.rs new file mode 100644 index 00000000000..7d1d82d86b9 --- /dev/null +++ b/moli-renderer-v8/src/worker/thread/tests/cors_redirects.rs @@ -0,0 +1,125 @@ +use super::*; +use parking_lot::Mutex; + +struct CorsServer { + url: String, + requests: Arc>>, + task: JoinHandle<()>, +} + +impl CorsServer { + async fn new(redirect_to: Option) -> Self { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("http://{}/data", listener.local_addr().unwrap()); + let requests = Arc::new(Mutex::new(Vec::new())); + let captured = Arc::clone(&requests); + let task = tokio::spawn(async move { + while let Ok((mut stream, _)) = listener.accept().await { + let request = read_http_request_head(&mut stream).await.unwrap(); + let preflight = request.starts_with("OPTIONS "); + captured.lock().push(request); + let origin = if redirect_to.is_some() { + "http://worker.test" + } else { + "null" + }; + let (status, location, body) = if preflight { + ("204 No Content", String::new(), "") + } else if let Some(target) = &redirect_to { + ( + "307 Temporary Redirect", + format!("Location: {target}\r\n"), + "", + ) + } else { + ("200 OK", String::new(), "allowed") + }; + let response = format!( + "HTTP/1.1 {status}\r\nAccess-Control-Allow-Origin: {origin}\r\nAccess-Control-Allow-Methods: PUT\r\nAccess-Control-Allow-Headers: x-test\r\nContent-Type: text/plain\r\nX-Hidden: secret\r\nContent-Length: {}\r\nConnection: close\r\n{location}\r\n{body}", + body.len() + ); + stream.write_all(response.as_bytes()).await.unwrap(); + } + }); + Self { + url, + requests, + task, + } + } +} + +impl Drop for CorsServer { + fn drop(&mut self) { + self.task.abort(); + } +} + +#[tokio::test] +async fn worker_cors_redirects_validate_null_origin_in_fetch_and_xhr() { + ensure_v8(); + for api in ["fetch", "xhr", "sync-xhr"] { + let target = CorsServer::new(None).await; + let source = CorsServer::new(Some(target.url.clone())).await; + let loader = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let mut worker = spawn_worker_with_request_client( + format!( + r#" + (async () => {{ + try {{ + const url = {url:?}; + const api = {api:?}; + if (api === "fetch") {{ + const response = await fetch(url, {{ method: "PUT", headers: {{ "X-Test": "1" }} }}); + postMessage([response.status, await response.text(), response.headers.get("X-Hidden")]); + }} else {{ + const xhr = new XMLHttpRequest(); + const done = new Promise(resolve => xhr.onloadend = resolve); + xhr.open(api === "sync-xhr" ? "GET" : "PUT", url, api !== "sync-xhr"); + if (api !== "sync-xhr") xhr.setRequestHeader("X-Test", "1"); + xhr.send(); + if (api !== "sync-xhr") await done; + postMessage([xhr.status, xhr.responseText, xhr.getResponseHeader("X-Hidden")]); + }} + }} catch (error) {{ + postMessage(String(error)); + }} finally {{ close(); }} + }})(); + "#, + url = source.url, + ), + "http://worker.test/main.js".to_owned(), + loader, + ); + let posted = timeout(TIMEOUT, async { + loop { + match worker.recv().await.expect("worker channel") { + WorkerToParentMessage::Post(payload) => break stringify_payload(&payload), + WorkerToParentMessage::SubresourceNetwork(_) => {} + message => panic!("unexpected worker message: {message:?}"), + } + } + }) + .await + .expect("worker CORS redirect result"); + assert_eq!(posted, r#"[200,"allowed",null]"#, "{api}"); + let requests = target.requests.lock(); + let expected_requests = if api == "sync-xhr" { 1 } else { 2 }; + assert_eq!(requests.len(), expected_requests, "{api}"); + assert!( + requests + .last() + .unwrap() + .starts_with(if api == "sync-xhr" { "GET " } else { "PUT " }), + "{api}: actual request must reach the target" + ); + for request in requests.iter() { + assert!( + request + .lines() + .any(|line| line.eq_ignore_ascii_case("origin: null")), + "{api}: {request}" + ); + } + } +} diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs index 8044df3fdcd..ec5efbb4c4e 100644 --- a/moli-renderer-v8/src/worker/thread/tests/mod.rs +++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs @@ -1562,6 +1562,7 @@ fn service_worker_storage_apis_use_explicit_registration_storage_key() { // ─── Basic tests ──────────────────────────────────────────────────── mod abort_signal_statics; +mod cors_redirects; mod indexed_db; mod lazy_storage; mod lifecycle; diff --git a/moli-types/moli-fetch-types/src/lib.rs b/moli-types/moli-fetch-types/src/lib.rs index 21885dc2f16..35500fd1c87 100644 --- a/moli-types/moli-fetch-types/src/lib.rs +++ b/moli-types/moli-fetch-types/src/lib.rs @@ -145,6 +145,9 @@ impl std::str::FromStr for FetchResponseType { #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct FetchResponseMetadata { + /// Frozen CORS exposed-name list, retained through filtering, cloning and cache storage. + #[serde(default)] + pub cors_exposed_header_names: Option>, pub response_type: FetchResponseType, /// Internal URLs, including those hidden by an opaque response's public URL. pub url_list: Vec, @@ -157,6 +160,7 @@ pub struct FetchResponseMetadata { impl Default for FetchResponseMetadata { fn default() -> Self { Self { + cors_exposed_header_names: None, response_type: FetchResponseType::Default, url_list: Vec::new(), timing_allow_passed: true, @@ -214,3 +218,61 @@ mod tests { } pub mod header_policy; + +impl FetchResponseMetadata { + pub fn capture_cors_exposed_headers(&mut self, headers: &[(String, Vec)]) { + if self.response_type == FetchResponseType::Cors && self.cors_exposed_header_names.is_none() + { + let names = headers + .iter() + .filter(|(name, _)| self.exposes_header(headers, name)) + .map(|(name, _)| name.to_ascii_lowercase()) + .collect::>(); + self.cors_exposed_header_names = Some(names.into_iter().collect()); + } + } +} + +impl FetchResponseMetadata { + // This earlier phase has no captured request credentials fact. A raw wildcard + // cannot prove credentialless exposure; explicit frozen names remain authoritative. + pub fn exposes_header(&self, headers: &[(String, Vec)], name: &str) -> bool { + if !self.response_type.is_readable() { + return false; + } + if self.response_type == FetchResponseType::Default { + return true; + } + if name.eq_ignore_ascii_case("set-cookie") || name.eq_ignore_ascii_case("set-cookie2") { + return false; + } + if self.response_type == FetchResponseType::Basic { + return true; + } + if [ + "cache-control", + "content-language", + "content-length", + "content-type", + "expires", + "last-modified", + "pragma", + ] + .iter() + .any(|safe| name.eq_ignore_ascii_case(safe)) + { + return true; + } + if let Some(names) = &self.cors_exposed_header_names { + return names + .iter() + .any(|exposed| exposed.eq_ignore_ascii_case(name)); + } + headers + .iter() + .filter(|(field, _)| field.eq_ignore_ascii_case("access-control-expose-headers")) + .flat_map(|(_, value)| value.split(|byte| *byte == b',')) + .map(|token| token.trim_ascii()) + .any(|token| token.eq_ignore_ascii_case(name.as_bytes())) + } +} diff --git a/moli-webapi/src/fetch_response/metadata.rs b/moli-webapi/src/fetch_response/metadata.rs index 1424f61289c..ec84b695a9c 100644 --- a/moli-webapi/src/fetch_response/metadata.rs +++ b/moli-webapi/src/fetch_response/metadata.rs @@ -4,6 +4,7 @@ use moli_v8_util::{get_private_object, get_private_value, set_private_value, v8_ use moli_webapi_declare::WebApiObject; pub(super) const RESPONSE_METADATA_SLOT: &str = "__moliResponseMetadata"; +const CORS_HEADERS_SLOT: &str = "__moliResponseMetadataCorsHeaders"; const TYPE_SLOT: &str = "__moliResponseMetadataType"; const URL_LIST_SLOT: &str = "__moliResponseMetadataUrls"; const TIMING_SLOT: &str = "__moliResponseMetadataTiming"; @@ -12,6 +13,8 @@ const REDIRECTED_SLOT: &str = "__moliResponseMetadataRedirected"; #[derive(WebApiObject)] #[webapi(plain)] struct ResponseMetadataDeclaration<'scope> { + #[webapi(slot = CORS_HEADERS_SLOT)] + cors_exposed_header_names: v8::Local<'scope, v8::Value>, #[webapi(slot = TYPE_SLOT)] response_type: &'static str, #[webapi(slot = URL_LIST_SLOT)] @@ -41,7 +44,22 @@ pub fn set_response_metadata<'s>( }) .collect(); let urls = v8::Array::new_with_elements(scope, &values); + let cors_headers: v8::Local<'s, v8::Value> = + if let Some(names) = &metadata.cors_exposed_header_names { + let names = names + .iter() + .map(|name| { + v8_string(scope, name) + .expect("native header name fits V8") + .into() + }) + .collect::>(); + v8::Array::new_with_elements(scope, &names).into() + } else { + v8::null(scope).into() + }; let value = ResponseMetadataDeclaration::new( + cors_headers, metadata.response_type.as_str(), urls, metadata.timing_allow_passed, @@ -71,7 +89,19 @@ pub fn response_metadata<'s>( .ok() }) .collect::>>()?; + let cors_headers = get_private_value(scope, metadata, CORS_HEADERS_SLOT)?; + let cors_exposed_header_names = if cors_headers.is_null_or_undefined() { + None + } else { + let names = v8::Local::::try_from(cors_headers).ok()?; + Some( + (0..names.length()) + .map(|index| Some(names.get_index(scope, index)?.to_rust_string_lossy(scope))) + .collect::>>()?, + ) + }; Some(FetchResponseMetadata { + cors_exposed_header_names, response_type, url_list, timing_allow_passed: get_private_value(scope, metadata, TIMING_SLOT)?.boolean_value(scope),