fix(network): preserve window referrers in XHR and EventSource

This commit is contained in:
ldm0
2026-11-11 21:08:28 +08:00
parent e2e4e09c30
commit da4cc29333
8 changed files with 288 additions and 67 deletions
@@ -2,11 +2,13 @@ use super::*;
use crate::native_bridge::{JsContextHost, throw_dom_exception};
use crate::network_host::{
BLOCKED_BY_CLIENT_ERROR_TEXT, active_subresource_network_partition_key,
effective_subresource_policy_context, local_url_response, merge_subresource_request_headers,
effective_subresource_policy_context, effective_subresource_referrer_policy,
local_url_response, merge_subresource_request_headers,
observe_subresource_request_cookie_report, resolve_context_url, spawn_async_subresource_fetch,
};
use crate::service_worker_runtime::{
ServiceWorkerFetchDispatch, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination,
ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination,
service_worker_fetch_request_metadata,
};
use crate::types::{
PendingSubresourceFetchInfo, SubresourceNetworkRecord, SubresourceResourceType,
@@ -44,6 +46,8 @@ struct PreparedEventSourceRequest {
owner: crate::native_bridge::OwnerDispatchScope,
resource_loader: crate::network::context::DocumentResourceLoader,
document_url: url::Url,
referrer_source: Option<url::Url>,
document_referrer_policy: Option<String>,
request_origin: moli_url::WebOrigin,
resolved_url: url::Url,
request_headers: moli_fetch::RequestHeaders,
@@ -399,6 +403,8 @@ fn prepare_event_source_request<'s>(
owner,
resource_loader,
document_url,
referrer_source: host.document_client_referrer_source(owner),
document_referrer_policy: effective_subresource_referrer_policy(host, owner),
request_origin,
resolved_url,
request_headers,
@@ -425,6 +431,7 @@ fn dispatch_service_worker_event_source<'s>(
&prepared.document_url,
&prepared.resolved_url,
)?;
let native_request = build_event_source_request(prepared).ok()?;
let cancel_handle = FetchCancelHandle::new();
let registered = register_event_source_request(
@@ -446,11 +453,7 @@ fn dispatch_service_worker_event_source<'s>(
prepared.credentials_mode,
RequestRedirectMode::Follow,
None,
ServiceWorkerFetchRequestMetadata {
mixed_content_policy: Default::default(),
cache: "no-store".to_owned(),
..ServiceWorkerFetchRequestMetadata::default()
},
service_worker_fetch_request_metadata(&native_request),
);
let dispatch = ServiceWorkerFetchDispatch {
request_body_owner: None,
@@ -492,26 +495,35 @@ fn dispatch_service_worker_event_source<'s>(
}
fn build_event_source_request(prepared: &PreparedEventSourceRequest) -> Result<Request, String> {
Request::new(
let request = Request::new(
"GET",
prepared.resolved_url.as_str(),
None,
prepared.request_headers.clone(),
)
.map_err(|error| error.to_string())
.map(|request| {
request
.with_initiator_url(&prepared.document_url)
.with_request_origin(prepared.request_origin.clone())
.with_request_mode(RequestMode::Cors)
.with_credentials_mode(prepared.credentials_mode)
.with_network_partition_key(prepared.network_partition_key.clone())
.with_redirect_mode(RequestRedirectMode::Follow)
.with_cache_mode(RequestCacheMode::NoStore)
.with_browser_request_metadata(BrowserRequestMetadata::EventSource)
.with_subframe_context(prepared.frame_id.is_some())
.without_request_timeout()
})
.map_err(|error| error.to_string())?
.with_fetch_referrer(
prepared
.referrer_source
.as_ref()
.map_or("", url::Url::as_str),
)
.map_err(|error| error.to_string())?;
Ok(request
.with_initiator_url(&prepared.document_url)
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
document_referrer_policy: prepared.document_referrer_policy.clone(),
..Default::default()
})
.with_request_origin(prepared.request_origin.clone())
.with_request_mode(RequestMode::Cors)
.with_credentials_mode(prepared.credentials_mode)
.with_network_partition_key(prepared.network_partition_key.clone())
.with_redirect_mode(RequestRedirectMode::Follow)
.with_cache_mode(RequestCacheMode::NoStore)
.with_browser_request_metadata(BrowserRequestMetadata::EventSource)
.with_subframe_context(prepared.frame_id.is_some())
.without_request_timeout())
}
struct RegisteredEventSourceRequest {
+2 -19
View File
@@ -26,7 +26,7 @@ use super::events::{
use super::*;
use crate::runtime::RendererPageContextCancelReason;
use crossbeam_channel::{after, bounded, never};
use moli_fetch::{BrowserRequestMetadata, FetchCancelHandle, RequestMode};
use moli_fetch::{FetchCancelHandle, RequestMode};
use std::{thread, time::Duration};
pub(super) fn xhr_send_callback<'s>(
@@ -298,24 +298,7 @@ fn send_synchronous_network_xhr(
timing.capture_window_initiator(scope, host);
let csp = crate::network_host::WindowCspRequestContext::capture(scope, host, prepared.owner)
.expect("synchronous XHR prepared a live Document request authority");
let mut request = Request::new_bytes(
&prepared.method,
prepared.resolved_url.as_str(),
prepared.send_body.clone(),
prepared.request_headers.clone(),
)
.expect("xhr request url was already resolved")
.with_page_network_policy()
.with_initiator_url(&prepared.document_url)
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
document_referrer_policy: prepared.document_referrer_policy.clone(),
..Default::default()
})
.with_request_origin(prepared.request_origin.clone())
.with_credentials_mode(prepared.credentials_mode)
.with_network_partition_key(prepared.network_partition_key.clone())
.with_browser_request_metadata(BrowserRequestMetadata::Xhr)
.with_use_cors_preflight(prepared.use_cors_preflight);
let mut request = prepared.request().with_page_network_policy();
if let Some(check) = csp.redirect_check(
scope,
&prepared.document_url,
@@ -2,11 +2,11 @@ use super::super::delivery::{queue_xhr_failure_delivery, queue_xhr_response_deli
use super::super::*;
use super::request::PreparedXhrSendRequest;
use crate::service_worker_runtime::{
ServiceWorkerFetchDispatch, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination,
ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination,
service_worker_fetch_request_metadata,
};
use moli_fetch::{
BrowserRequestMetadata, FetchCancelHandle, RequestRedirectMode,
should_request_be_blocked_due_to_bad_port,
FetchCancelHandle, RequestRedirectMode, should_request_be_blocked_due_to_bad_port,
};
pub(super) fn record_intercepted_xhr(
@@ -122,11 +122,7 @@ pub(super) fn dispatch_service_worker_xhr(
prepared.credentials_mode,
RequestRedirectMode::Follow,
None,
ServiceWorkerFetchRequestMetadata {
mixed_content_policy: Default::default(),
use_cors_preflight: prepared.use_cors_preflight,
..ServiceWorkerFetchRequestMetadata::default()
},
service_worker_fetch_request_metadata(&prepared.request()),
);
let dispatch = ServiceWorkerFetchDispatch {
request_body_owner: None,
@@ -313,24 +309,9 @@ pub(super) fn spawn_network_xhr_fetch(
prepared: PreparedXhrSendRequest,
request_client: ResourceRequestClient,
) -> u64 {
let mut request = Request::new_bytes(
&prepared.method,
prepared.resolved_url.as_str(),
prepared.send_body.clone(),
prepared.request_headers.clone(),
)
.expect("xhr request url was already resolved")
.with_initiator_url(&prepared.document_url)
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
document_referrer_policy: prepared.document_referrer_policy.clone(),
..Default::default()
})
.with_request_origin(prepared.request_origin.clone())
.with_credentials_mode(prepared.credentials_mode)
.with_network_partition_key(prepared.network_partition_key.clone())
.with_browser_request_metadata(BrowserRequestMetadata::Xhr)
.with_use_cors_preflight(prepared.use_cors_preflight)
.with_subframe_context(prepared.frame_id.is_some());
let mut request = prepared
.request()
.with_subframe_context(prepared.frame_id.is_some());
let request_cookie_report = observe_subresource_request_cookie_report(
prepared.resource_loader.request_client(),
@@ -19,6 +19,7 @@ pub(super) struct PreparedXhrSendRequest {
pub(super) resource_loader: crate::network::context::DocumentResourceLoader,
pub(super) document_url: url::Url,
pub(super) document_referrer_policy: Option<String>,
referrer_source: Option<url::Url>,
pub(super) request_origin: moli_url::WebOrigin,
pub(super) network_partition_key: Option<String>,
pub(super) policy_context: crate::types::SubresourcePolicyContext,
@@ -32,6 +33,32 @@ pub(super) struct PreparedXhrSendRequest {
pub(super) use_cors_preflight: bool,
}
impl PreparedXhrSendRequest {
pub(super) fn request(&self) -> moli_fetch::Request {
// Network dispatch and Service Worker metadata share the captured
// client's referrer without rebinding its cookie or request origin.
moli_fetch::Request::new_bytes(
&self.method,
self.resolved_url.as_str(),
self.send_body.clone(),
self.request_headers.clone(),
)
.expect("xhr request url was already resolved")
.with_fetch_referrer(self.referrer_source.as_ref().map_or("", url::Url::as_str))
.expect("XHR referrer source is a captured Document URL")
.with_initiator_url(&self.document_url)
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
document_referrer_policy: self.document_referrer_policy.clone(),
..Default::default()
})
.with_request_origin(self.request_origin.clone())
.with_credentials_mode(self.credentials_mode)
.with_network_partition_key(self.network_partition_key.clone())
.with_browser_request_metadata(moli_fetch::BrowserRequestMetadata::Xhr)
.with_use_cors_preflight(self.use_cors_preflight)
}
}
pub(super) enum XhrSendPrepareError {
ExecutionContext,
Url(ResolveContextUrlError),
@@ -105,6 +132,7 @@ pub(super) fn prepare_xhr_send_request<'s>(
request_origin,
network_partition_key,
document_referrer_policy,
referrer_source: host.document_client_referrer_source(owner),
policy_context,
resolved_url,
blob_url_entry: blob_url_entry(scope, xhr)
@@ -2534,6 +2534,7 @@ mod audio_worklet_and_message_ports;
mod blob_storage_key;
mod message_port_transfer_semantics;
mod service_and_shared_worker_lifecycle;
mod window_request_referrer;
mod window_service_worker_response_policy;
mod worker_messages_and_service_workers;
mod worker_security_and_audio_worklets;
@@ -0,0 +1,150 @@
use super::*;
const CLIENT: &str =
include_str!("../../../../../tests/fixtures/window-request-referrer-client.js");
const SERVICE_WORKER: &str =
include_str!("../../../../../tests/fixtures/window-request-referrer-sw.js");
async fn check_window_request_referrer(policy: &'static str) {
for controlled in [false, true] {
run_page_vm_async_test(async move {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let address = listener.local_addr().unwrap();
let origin = format!("http://{address}");
let cross = format!("http://localhost:{}", address.port());
let server_origin = origin.clone();
let server_cross = cross.clone();
let (requests, mut received) = tokio::sync::mpsc::unbounded_channel();
let (stop, mut stopped) = tokio::sync::oneshot::channel::<()>();
let server = std::thread::spawn(move || {
tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async move {
let listener = TcpListener::from_std(listener).unwrap();
loop {
let accepted = tokio::select! {
result = listener.accept() => result.ok(),
_ = &mut stopped => None,
_ = tokio::time::sleep(Duration::from_secs(30)) => None,
};
let Some((mut stream, _)) = accepted else { break };
let head = read_http_request_head(&mut stream).await.unwrap();
let path = head.lines().next().unwrap().split_whitespace().nth(1).unwrap();
let url = Url::parse(&format!("{server_origin}{path}")).unwrap();
let referrer = head.lines().find_map(|line| {
let (name, value) = line.split_once(':')?;
name.eq_ignore_ascii_case("referer").then(|| value.trim().to_owned())
});
requests.send((path.to_owned(), referrer.clone())).unwrap();
let api = url.query_pairs().find(|(key, _)| key == "api").map(|(_, value)| value.into_owned());
let mut status = "200 OK";
let mut extra = String::new();
let (body, content_type) = if head.starts_with("OPTIONS ") {
(String::new(), "text/plain")
} else if url.path() == "/app/sw.js" {
(format!("const CROSS = {};\n{SERVICE_WORKER}", serde_json::to_string(&server_cross).unwrap()), "text/javascript")
} else if url.path() == "/app/network-redirect" {
status = "307 Temporary Redirect";
extra = format!("Location: {server_cross}/network?api={}\r\nReferrer-Policy: no-referrer\r\n", api.as_deref().unwrap());
(String::new(), "text/plain")
} else {
let value = serde_json::json!({"source":"network","referrer":referrer}).to_string();
if api.as_deref() == Some("eventsource") {
(format!("data: {value}\n\n"), "text/event-stream")
} else { (value, "application/json") }
};
let response = format!("HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\nAccess-Control-Allow-Origin: {server_origin}\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Methods: GET, OPTIONS\r\nAccess-Control-Allow-Headers: cache-control, last-event-id\r\n{extra}\r\n{body}", body.len());
stream.write_all(response.as_bytes()).await.unwrap();
}
});
});
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let mut hooks = PageVmRuntimeHooks::standalone_without_owner_reservation_for_test();
hooks.resource_task_runner = Some(loader.browser_resource_runtime().resource_task_runner());
let document_url = Url::parse(&format!("{origin}/app/page.html?policy={policy}&marker=private#fragment")).unwrap();
let mut page = test_page_vm_with_loader_document_url_and_hooks(&loader, Vec::new(), document_url.clone(), hooks);
page.retain_standalone_request_client_owner_for_test(loader);
let headers = if policy == "default" { Vec::new() } else {
vec![("Referrer-Policy".to_owned(), if policy == "meta-no-referrer" { b"unsafe-url".to_vec() } else { policy.as_bytes().to_vec() })]
};
page.vm_mut().set_main_navigation_policy_container(
crate::document_runtime::DocumentPolicyContainer::from_navigation_response_headers(&headers, &document_url),
);
let mut full_referrer = document_url.clone();
full_referrer.set_fragment(None);
let local = page.local_executor.clone();
local.run(async move {
let meta = if policy == "meta-no-referrer" { "document.head.appendChild(Object.assign(document.createElement('meta'), {name: 'referrer', content: 'no-referrer'}));" } else { "" };
let source = format!("const ORIGIN = {}, CROSS = {}, CONTROLLED = {controlled};\ndocument.head.appendChild(Object.assign(document.createElement('base'), {{href: ORIGIN + '/unrelated-base/'}}));\n{meta}\n{CLIENT}", serde_json::to_string(&origin).unwrap(), serde_json::to_string(&cross).unwrap());
page.vm_mut().eval(&source)?;
drive_service_worker_page_vm_until_done(&mut page, "String(referrerResult !== null || referrerError !== null)", "Window XHR and EventSource must preserve the requesting Document referrer across SW dispatch and fallback").await?;
assert_eq!(page.vm_mut().eval("String(referrerError)")?, "null");
let result: serde_json::Value = serde_json::from_str(&page.vm_mut().eval("JSON.stringify(referrerResult)")?)?;
let rows = result["rows"].as_array().unwrap();
assert_eq!(rows.len(), 27);
let effective_policy = match policy { "default" => "strict-origin-when-cross-origin", "meta-no-referrer" => "no-referrer", other => other };
for row in rows {
assert!(row.get("error").is_none(), "{policy}/{controlled}: {row}");
let route = row["route"].as_str().unwrap();
let synthetic = controlled && matches!(route, "synthetic-same" | "synthetic-cross");
let is_cross = route.ends_with("-cross") || (controlled && route == "synthetic-redirect");
let expected = if route == "network-policy-redirect" || effective_policy == "no-referrer" || (effective_policy == "same-origin" && is_cross) {
None
} else if effective_policy == "origin" || (effective_policy == "strict-origin-when-cross-origin" && is_cross) {
Some(format!("{origin}/"))
} else { Some(full_referrer.to_string()) };
let data = &row["data"];
if synthetic {
assert_eq!(data["source"], "serviceworker");
assert_eq!(data["referrer"], expected.as_deref().unwrap_or(""), "{policy}/{controlled}: {row}");
assert_eq!(data["referrerPolicy"], effective_policy);
assert_eq!(data["cache"], if row["kind"] == "eventsource" { "no-store" } else { "default" });
} else {
assert_eq!(data["source"], "network");
assert_eq!(data["referrer"], serde_json::to_value(expected)?, "{policy}/{controlled}: {row}");
}
}
anyhow::Ok(())
}).await.unwrap();
let _ = stop.send(());
server.join().unwrap();
let mut observed = Vec::new();
while let Ok(request) = received.try_recv() { observed.push(request); }
assert_eq!(observed.iter().filter(|(path, _)| path == "/app/sw.js").count(), usize::from(controlled));
assert!(observed.iter().any(|(path, _)| path.starts_with("/app/network?api=xhr")));
assert!(observed.iter().any(|(path, _)| path.starts_with("/app/network?api=eventsource")));
if matches!(policy, "no-referrer" | "meta-no-referrer") {
assert!(observed.iter().filter(|(path, _)| path != "/app/sw.js").all(|(_, referrer)| referrer.is_none()));
}
}).await;
}
}
#[tokio::test]
async fn window_request_referrer_default_policy() {
check_window_request_referrer("default").await;
}
#[tokio::test]
async fn window_request_referrer_no_referrer_policy() {
check_window_request_referrer("no-referrer").await;
}
#[tokio::test]
async fn window_request_referrer_origin_policy() {
check_window_request_referrer("origin").await;
}
#[tokio::test]
async fn window_request_referrer_same_origin_policy() {
check_window_request_referrer("same-origin").await;
}
#[tokio::test]
async fn window_request_referrer_unsafe_url_policy() {
check_window_request_referrer("unsafe-url").await;
}
#[tokio::test]
async fn window_request_referrer_meta_no_referrer_policy() {
check_window_request_referrer("meta-no-referrer").await;
}
@@ -0,0 +1,45 @@
globalThis.referrerResult = null;
globalThis.referrerError = null;
(async () => {
if (CONTROLLED) {
await navigator.serviceWorker.register('/app/sw.js', {scope: '/app/'});
await navigator.serviceWorker.ready;
if (!navigator.serviceWorker.controller) await new Promise(resolve =>
navigator.serviceWorker.addEventListener('controllerchange', resolve, {once: true}));
}
function take(kind, url) {
if (kind === 'fetch') return fetch(url).then(response => response.json());
if (kind === 'eventsource') return new Promise((resolve, reject) => {
const source = new EventSource(url);
source.onmessage = event => {source.close(); resolve(JSON.parse(event.data));};
source.onerror = () => {source.close(); reject(new Error('EventSource failed: ' + url));};
});
if (kind === 'syncxhr') {
const xhr = new XMLHttpRequest(); xhr.open('GET', url, false); xhr.send();
if (xhr.status !== 200) throw new Error('sync XHR status ' + xhr.status);
return Promise.resolve(JSON.parse(xhr.responseText));
}
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest(); xhr.open('GET', url, true);
xhr.onload = () => xhr.status === 200 ? resolve(JSON.parse(xhr.responseText)) : reject(new Error('XHR status ' + xhr.status));
xhr.onerror = () => reject(new Error('XHR failed: ' + url)); xhr.send();
});
}
const routes = [
['synthetic-same', ORIGIN + '/app/echo'], ['synthetic-cross', CROSS + '/echo'],
['forward-same', ORIGIN + '/app/forward'], ['forward-cross', CROSS + '/forward'],
['fallback-same', ORIGIN + '/app/network'], ['fallback-cross', CROSS + '/network'],
['synthetic-redirect', ORIGIN + '/app/sw-redirect'],
['network-policy-redirect', ORIGIN + '/app/network-redirect']
];
const rows = [];
for (const kind of ['xhr', 'syncxhr', 'eventsource', 'fetch']) {
for (const [route, url] of routes) {
if (kind === 'syncxhr' && !route.startsWith('synthetic-')) continue;
try { rows.push({kind, route, data: await take(kind, url + '?api=' + kind)}); }
catch (error) { rows.push({kind, route, error: String(error)}); }
}
}
referrerResult = {url: location.href, documentReferrerPolicy: document.referrerPolicy, rows};
})().catch(error => referrerError = String(error)); void 0;
@@ -0,0 +1,21 @@
self.oninstall = event => event.waitUntil(self.skipWaiting());
self.onactivate = event => event.waitUntil(self.clients.claim());
self.onfetch = event => {
const url = new URL(event.request.url), path = url.pathname;
const kind = url.searchParams.get('api');
if (path.endsWith('/echo')) {
const result = {source: 'serviceworker', referrer: event.request.referrer,
referrerPolicy: event.request.referrerPolicy, cache: event.request.cache,
method: event.request.method, mode: event.request.mode,
credentials: event.request.credentials, destination: event.request.destination,
bodyIsNull: event.request.body === null, clientId: event.clientId,
resultingClientId: event.resultingClientId};
event.respondWith(new Response(kind === 'eventsource' ? 'data: ' + JSON.stringify(result) + '\n\n' : JSON.stringify(result),
{headers: {'Content-Type': kind === 'eventsource' ? 'text/event-stream' : 'application/json'}}));
} else if (path.endsWith('/forward')) {
event.respondWith(fetch(event.request));
} else if (path.endsWith('/sw-redirect')) {
event.respondWith(Response.redirect(CROSS + '/network?api=' + kind, 307));
}
};