fix(fetch): omit credentialless worker network credentials

This commit is contained in:
ldm0
2026-11-22 02:02:07 +08:00
parent 3d2c90ebc6
commit 278b4eb3dc
9 changed files with 347 additions and 4 deletions
@@ -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<super::RedirectOwner>) -> 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),
@@ -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(),
) {
@@ -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,
@@ -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();
+22
View File
@@ -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)]
@@ -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>(
@@ -1,5 +1,7 @@
use super::*;
mod credentialless;
#[tokio::test]
async fn worker_fetch_referrer_inputs_reach_the_network() {
ensure_v8();
@@ -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<String> {
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::<BTreeSet<_>>();
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;
}
@@ -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};
}