Files
moli/moli-core/tests/scripts/fetch_client_referrer.rs
T
ldm0 4d39ac9502 fix(fetch): resolve client referrers before dispatch
Select the live Document URL, following srcdoc containers and rejecting opaque
client origins, before applying the effective referrer policy. Resolve these
values before both service-worker interception and native network dispatch,
without changing the public Request or the origin and cookie initiator.

Use HTML's about:srcdoc URL match so javascript replacements remain srcdoc
Documents. Preserve the replaced Document's current delivered policies,
including removed meta elements, instead of reverting to response-only state.

Cover network headers across two origins, author base URLs, history changes,
about:blank boundaries, javascript replacements, opaque srcdoc Documents, and
service-worker request metadata.

Keep Fetch resource classification when attaching policy metadata, and isolate
memory-cache entries by their resolved Referer so policy changes cannot reuse
a response selected for a different referrer.
2026-11-21 20:03:27 +08:00

77 lines
2.8 KiB
Rust

use super::*;
async fn check_fetch_client_referrer(opaque: bool) -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!(
"{}/document-referrer.html?response=unsafe-url",
servers.origin,
))
.await?;
let script = format!(
"globalThis.__clientReferrerOrigins = {}; globalThis.__opaqueReferrerProbe = {opaque}; {}",
serde_json::to_string(&[&servers.origin, &servers.cross_origin])?,
include_str!("fetch_client_referrer.js"),
);
let result = tokio::time::timeout(
Duration::from_secs(15),
page.evaluate_runtime_expression_with_await_async(&script, true),
)
.await??;
assert_eq!(result["value"], true, "opaque={opaque}: {result}");
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_client_referrer_uses_live_document_urls_and_srcdoc_ancestors() -> Result<()> {
check_fetch_client_referrer(false).await
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_client_referrer_does_not_reveal_opaque_srcdoc_ancestors() -> Result<()> {
check_fetch_client_referrer(true).await
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_memory_cache_separates_resolved_referrer_values() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/page.html", servers.origin))
.await?;
let result = page
.evaluate_runtime_expression_with_await_async(
r#"(async () => {
const selected = location.origin + '/selected';
for (const [init, expected] of [
[{}, location.href],
[{referrerPolicy:'origin'}, location.origin + '/'],
[{referrerPolicy:'no-referrer'}, null],
[{referrer:selected,referrerPolicy:'unsafe-url'}, selected],
]) {
for (let repeat = 0; repeat < 2; repeat++) {
const actual = await (await fetch('/cached-client-referrer', init)).json();
if (actual !== expected)
throw new Error(JSON.stringify(init) + ': ' + actual + ' != ' + expected);
}
}
return true;
})()"#,
true,
)
.await?;
assert_eq!(result["value"], true, "{result}");
assert_eq!(
servers
.requests
.lock()
.iter()
.filter(|request| request.path == "/cached-client-referrer")
.count(),
4,
"identical resolved referrers should reuse their cached response"
);
Ok(())
}