diff --git a/moli-renderer-v8/src/network_host/controlled_resource.rs b/moli-renderer-v8/src/network_host/controlled_resource.rs index 7c974df8e04..bb9b7aa7f9f 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource.rs @@ -96,6 +96,12 @@ impl LoadedResponse { } impl ControlledResourceLoad { + fn effective_credentials_mode(&self) -> moli_fetch::RequestCredentialsMode { + match self.response_policy { + ResourceResponsePolicy::Xhr => self.request.credentials_mode, + ResourceResponsePolicy::Fetch(policy) => policy.network_credentials_mode(self.request.request_mode, self.request.credentials_mode), + } + } pub(crate) fn with_redirect_owner(mut self, owner: Option) -> Self { self.redirect_owner = owner; self @@ -552,7 +558,7 @@ impl ControlledResourceLoad { } let observed = super::async_fetch::fetch_subresource_hop( &loader, - self.request.clone(), + self.request.clone().with_credentials_mode(self.effective_credentials_mode()), hop_cancel.clone(), self.preflight_headers.clone(), Some(&preflight_observer), diff --git a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs index 675d332f582..424c40ee9b5 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs @@ -260,7 +260,7 @@ impl super::ControlledResourceLoad { fetch_id, self.interception.clone(), self.request.request_mode, - self.request.credentials_mode, + self.effective_credentials_mode(), policy, request_origin.clone(), Arc::clone(&request_url), @@ -295,7 +295,7 @@ impl super::ControlledResourceLoad { &delivered.response.head(), delivered.response.body_bytes(), self.request.request_mode, - self.request.credentials_mode, + self.effective_credentials_mode(), policy, self.load.request_client().web_security_disabled(), ) { diff --git a/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs b/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs index 1292f3abec2..cf64aed5363 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs @@ -44,6 +44,7 @@ impl ControlledResourceLoad { return Ok(None); }; let dispatch = ServiceWorkerFetchDispatch { + redirect_check: None, internal_id: self.info.internal_id, request: ServiceWorkerFetchRequest { client_id: source.client_id, diff --git a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs index 3f38b86a509..16d60fd04a4 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs @@ -81,6 +81,11 @@ pub(super) fn service_worker_network_fallback_request_for_job( .request .clone() .with_page_network_policy() + .with_credentials_mode( + job.network_context + .policy_context + .network_credentials_mode(job.request.request_mode, job.request.credentials_mode), + ) .with_use_cors_preflight(job.metadata.use_cors_preflight) .with_browser_request_metadata(service_worker_fetch_browser_metadata( job.network_context.resource_type, @@ -1262,6 +1267,57 @@ mod tests { } } + #[test] + fn credentialless_network_fallback_preserves_fetch_event_credentials() { + let service = new_service_worker_runtime_service(); + let event_id = ServiceWorkerEventId(212); + let completion_queue = crate::page_task_queue::RendererResourceCompletionTestHarness::new(); + insert_active_fetch_job( + &service, + event_id, + ServiceWorkerVersionId(1), + &RendererServiceWorkerRunIdentity::fresh(), + 312, + completion_queue.sender(), + ); + let mut job = service + .inner + .state + .lock() + .pending_fetch_jobs + .remove(&event_id) + .unwrap(); + job.request.credentials_mode = moli_fetch::RequestCredentialsMode::Include; + job.network_context + .policy_context + .cross_origin_embedder_policy = + crate::cross_origin_isolation::CrossOriginEmbedderPolicy::Credentialless; + let same_origin_url = job.request.url.clone(); + let cross_origin_url = url("https://other.test/data"); + for mode in [ + moli_fetch::RequestMode::NoCors, + moli_fetch::RequestMode::Cors, + moli_fetch::RequestMode::SameOrigin, + moli_fetch::RequestMode::Navigate, + ] { + job.request.request_mode = mode; + let fallback = service_worker_network_fallback_request_for_job(&job); + assert!(fallback.allows_credentials_for_url(&same_origin_url)); + assert_eq!( + fallback.allows_credentials_for_url(&cross_origin_url), + mode != moli_fetch::RequestMode::NoCors, + ); + assert_eq!( + fetch_request_for_job(&job).credentials_mode, + moli_fetch::RequestCredentialsMode::Include, + ); + assert_eq!( + job.request.credentials_mode, + moli_fetch::RequestCredentialsMode::Include, + ); + } + } + #[test] fn event_source_network_fallback_preserves_long_lived_request_metadata() { let service = new_service_worker_runtime_service(); diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs index 58b32913b3f..6cea5554fec 100644 --- a/moli-renderer-v8/src/types.rs +++ b/moli-renderer-v8/src/types.rs @@ -1049,6 +1049,28 @@ impl SubresourcePolicyContext { && policy.allows_cross_origin_isolation(), } } + + /// Select network credentials without changing the author-visible Request. + /// SameOrigin reuses Fetch's per-hop credential gate, including its sticky + /// omission after a redirect leaves the client origin. Neither policy is + /// conditional on the agent cluster's crossOriginIsolated capability. + pub(super) fn network_credentials_mode( + self, + mode: moli_fetch::RequestMode, + credentials: moli_fetch::RequestCredentialsMode, + ) -> moli_fetch::RequestCredentialsMode { + if mode == moli_fetch::RequestMode::NoCors + && credentials == moli_fetch::RequestCredentialsMode::Include + && (self.cross_origin_embedder_policy + == crate::cross_origin_isolation::CrossOriginEmbedderPolicy::Credentialless + || self.document_isolation_policy + == crate::cross_origin_isolation::DocumentIsolationPolicy::IsolateAndCredentialless) + { + moli_fetch::RequestCredentialsMode::SameOrigin + } else { + credentials + } + } } #[derive(Clone, Debug)] diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index c41920f1321..ea6b90a9086 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -999,6 +999,8 @@ pub(super) fn start_worker_resource_fetch<'s>( let blob_environment = BlobUrlFetchEnvironment::for_worker(scope); let blob_url_entry = blob_url_entry.map(|entry| entry.for_environment(blob_environment.as_ref())); + let network_credentials_mode = + policy_context.network_credentials_mode(request_mode, credentials_mode); // Use the same normalized header list as Request before policy checks and // context overrides can otherwise discard a repeated Range field. let request_headers = combined_headers_entries(&request_headers); @@ -1028,7 +1030,7 @@ pub(super) fn start_worker_resource_fetch<'s>( WorkerTimingRequest::Fetch { method: method.clone(), mode: request_mode, - credentials: credentials_mode, + credentials: network_credentials_mode, redirect: redirect_mode, policy: policy_context, font: kind == WorkerFetchKind::Font, @@ -1185,9 +1187,11 @@ pub(super) fn start_worker_resource_fetch<'s>( request_metadata, policy_context, ) + } + } pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( diff --git a/moli-renderer-v8/src/worker/thread/tests/network.rs b/moli-renderer-v8/src/worker/thread/tests/network.rs index 363ac9d65b9..db3fea5cb84 100644 --- a/moli-renderer-v8/src/worker/thread/tests/network.rs +++ b/moli-renderer-v8/src/worker/thread/tests/network.rs @@ -1,5 +1,7 @@ use super::*; +mod credentialless; + #[tokio::test] async fn worker_fetch_referrer_inputs_reach_the_network() { ensure_v8(); diff --git a/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs b/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs new file mode 100644 index 00000000000..fa9c8fc6b5d --- /dev/null +++ b/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs @@ -0,0 +1,225 @@ +use super::*; +use crate::cross_origin_isolation::{CrossOriginEmbedderPolicy, DocumentIsolationPolicy}; +use crate::types::SubresourcePolicyContext; +use std::collections::BTreeSet; + +async fn credentialless_fetch_server( + listener: TcpListener, + same_origin: String, + cross_origin: String, + requests: usize, +) -> Vec { + let mut observed = Vec::new(); + for _ in 0..requests { + let (mut socket, _) = listener.accept().await.unwrap(); + let request = read_http_request_head(&mut socket).await.unwrap(); + let path = request.split_whitespace().nth(1).unwrap(); + let location = match path { + "/same-to-cross" => Some(format!("{cross_origin}/cross-final")), + "/cross-to-same" => Some(format!("{same_origin}/same-final")), + "/round-trip" => Some(format!("{cross_origin}/return")), + "/return" => Some(format!("{same_origin}/round-final")), + _ => None, + }; + let cookie = path.trim_start_matches('/').replace('-', "_"); + let mut headers = format!( + "HTTP/1.1 {}\r\nContent-Type: image/png\r\nCache-Control: no-store\r\nSet-Cookie: seen_{cookie}=1; Path=/; SameSite=Lax\r\nAccess-Control-Allow-Origin: {same_origin}\r\nAccess-Control-Allow-Credentials: true\r\nConnection: close\r\n", + if location.is_some() { + "302 Found" + } else { + "200 OK" + }, + ); + if path != "/no-corp" { + headers.push_str("Cross-Origin-Resource-Policy: cross-origin\r\n"); + } + if let Some(location) = location { + headers.push_str(&format!("Location: {location}\r\n")); + } + let body = b"\x89PNG\r\n\x1a\n"; + headers.push_str(&format!("Content-Length: {}\r\n\r\n", body.len())); + socket.write_all(headers.as_bytes()).await.unwrap(); + socket.write_all(body).await.unwrap(); + observed.push(request); + } + observed +} + +async fn check_worker_credentialless_fetch(intercept: bool) { + ensure_v8(); + let mut failures = Vec::new(); + for (name, coep, dip, credentialless) in [ + ( + "none", + CrossOriginEmbedderPolicy::None, + DocumentIsolationPolicy::None, + false, + ), + ( + "require-corp", + CrossOriginEmbedderPolicy::RequireCorp, + DocumentIsolationPolicy::None, + false, + ), + ( + "credentialless", + CrossOriginEmbedderPolicy::Credentialless, + DocumentIsolationPolicy::None, + true, + ), + ( + "isolate-and-credentialless", + CrossOriginEmbedderPolicy::None, + DocumentIsolationPolicy::IsolateAndCredentialless, + true, + ), + ] { + let same = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let cross = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let same_origin = format!("http://{}", same.local_addr().unwrap()); + let cross_origin = format!("http://{}", cross.local_addr().unwrap()); + let same_server = tokio::spawn(credentialless_fetch_server( + same, + same_origin.clone(), + cross_origin.clone(), + 6, + )); + let cross_server = tokio::spawn(credentialless_fetch_server( + cross, + same_origin.clone(), + cross_origin.clone(), + 7, + )); + let cookie_store = moli_cookie_jar::new_shared_browser_cookie_store(); + cookie_store.lock().set_document_cookie( + &url::Url::parse(&same_origin).unwrap(), + "seed=1; Path=/; SameSite=Lax", + ); + let mut config = FetchConfig::default(); + config.set_http_no_proxy(Some("*".to_owned())); + let source = format!( + "{}\nonmessage = async () => {{ postMessage(await workerCredentiallessFetchProbe({same_origin:?}, {cross_origin:?})); close(); }};", + include_str!("../../../../../tests/fixtures/worker-credentialless-fetch.js"), + ); + let mut worker = spawn_test_worker_with_options( + WorkerSpawnOptions::new(source, format!("{same_origin}/worker.js")) + .with_request_client( + ResourceRequestClient::new_with_cookie_store(&config, cookie_store.clone()) + .unwrap(), + ) + .with_policy_context(SubresourcePolicyContext { + cross_origin_embedder_policy: coep, + document_isolation_policy: dip, + // Network policy applies even without an isolated agent cluster. + cross_origin_isolated: false, + }), + ); + if intercept { + worker.set_fetch_subresource_interception( + crate::types::SubresourceInterceptionClasses::for_resource_type( + SubresourceResourceType::Fetch, + ), + ); + } + worker.post_message(serialize_test_string("go")); + let payload = loop { + let message = timeout(TIMEOUT, worker.recv()).await.unwrap().unwrap(); + match message { + WorkerToParentMessage::PendingSubresourceFetch(pending) => { + worker.continue_pending_fetch(pending_worker_fetch_continue( + pending.fetch_id, + 1, + &pending.info, + false, + )); + } + WorkerToParentMessage::Post(payload) => break stringify_payload(&payload), + WorkerToParentMessage::SubresourceNetwork(_) => {} + WorkerToParentMessage::SubresourceContinue( + PendingSubresourceContinueEvent::Completed { .. }, + ) => {} + other => panic!("unexpected credentialless worker message: {other:?}"), + } + }; + worker.terminate_and_join(); + let payload: serde_json::Value = serde_json::from_str(&payload).unwrap(); + assert_eq!(payload["isolated"], false, "{name}"); + let results = payload["results"].as_array().unwrap(); + assert_eq!(results.len(), 9, "{name}: {payload}"); + for (index, result) in results.iter().enumerate() { + assert_eq!( + result["credentials"], + if index < 7 { "include" } else { "omit" } + ); + assert_eq!( + result["mode"], + if matches!(index, 2 | 8) { + "cors" + } else { + "no-cors" + } + ); + let expected = if index == 6 && coep == CrossOriginEmbedderPolicy::RequireCorp { + serde_json::json!({"error": "TypeError"}) + } else if matches!(index, 0 | 7) { + serde_json::json!({"type": "basic", "status": 200}) + } else if matches!(index, 2 | 8) { + serde_json::json!({"type": "cors", "status": 200}) + } else { + serde_json::json!({"type": "opaque", "status": 0}) + }; + for (field, expected) in expected.as_object().unwrap() { + if &result[field] != expected { + failures.push(format!("{name}, case {index}, {field}: {result}")); + } + } + } + let mut requests = timeout(TIMEOUT, same_server).await.unwrap().unwrap(); + requests.extend(timeout(TIMEOUT, cross_server).await.unwrap().unwrap()); + let mut expected_cookies = BTreeSet::from(["seed".to_owned()]); + for request in &requests { + let path = request.split_whitespace().nth(1).unwrap(); + let allowed = match path { + "/same-omit" | "/cors-omit" => false, + "/same" | "/cors" | "/same-to-cross" | "/round-trip" => true, + _ => !credentialless, + }; + let has_cookie = request.lines().any(|line| { + line.split_once(':').is_some_and(|(name, value)| { + name.eq_ignore_ascii_case("cookie") + && value.split(';').any(|cookie| cookie.trim() == "seed=1") + }) + }); + if has_cookie != allowed { + failures.push(format!( + "{name}, {path}: expected Cookie={allowed}, got {has_cookie}" + )); + } + if allowed { + expected_cookies.insert(format!("seen_{}", path[1..].replace('-', "_"))); + } + } + let actual_cookies = cookie_store + .lock() + .cookies() + .into_iter() + .map(|cookie| cookie.name) + .collect::>(); + if actual_cookies != expected_cookies { + failures.push(format!( + "{name}: cookies {actual_cookies:?}, expected {expected_cookies:?}" + )); + } + } + assert!(failures.is_empty(), "{}", failures.join("\n")); +} + +#[tokio::test] +async fn worker_fetch_credentialless_credentials_follow_redirect_taint() { + check_worker_credentialless_fetch(false).await; +} + +#[tokio::test] +async fn worker_fetch_credentialless_credentials_survive_interception() { + check_worker_credentialless_fetch(true).await; +} diff --git a/moli-renderer-v8/tests/fixtures/worker-credentialless-fetch.js b/moli-renderer-v8/tests/fixtures/worker-credentialless-fetch.js new file mode 100644 index 00000000000..95d20bafdc8 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/worker-credentialless-fetch.js @@ -0,0 +1,27 @@ +async function workerCredentiallessFetchProbe(sameOrigin, crossOrigin) { + const cases = [ + ['same', sameOrigin, 'same', 'no-cors', 'include'], + ['cross', crossOrigin, 'cross', 'no-cors', 'include'], + ['cors', crossOrigin, 'cors', 'cors', 'include'], + ['same-to-cross', sameOrigin, 'same-to-cross', 'no-cors', 'include'], + ['cross-to-same', crossOrigin, 'cross-to-same', 'no-cors', 'include'], + ['round-trip', sameOrigin, 'round-trip', 'no-cors', 'include'], + ['no-corp', crossOrigin, 'no-corp', 'no-cors', 'include'], + ['same-omit', sameOrigin, 'same-omit', 'no-cors', 'omit'], + ['cors-omit', crossOrigin, 'cors-omit', 'cors', 'omit'], + ]; + const results = []; + for (const [name, origin, path, mode, credentials] of cases) { + const request = new Request(`${origin}/${path}`, {mode, credentials}); + let result; + try { + const response = await fetch(request); + await response.arrayBuffer(); + result = {type: response.type, status: response.status}; + } catch (error) { + result = {error: error.name}; + } + results.push({name, mode: request.mode, credentials: request.credentials, ...result}); + } + return {isolated: self.crossOriginIsolated, results}; +}