mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
fix(fetch): omit credentialless worker network credentials
This commit is contained in:
@@ -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();
|
||||
|
||||
@@ -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};
|
||||
}
|
||||
Reference in New Issue
Block a user