Files
moli/moli-core/tests/scripts/integrity.rs
T
ldm0 fc35034823 fix(preload): verify ordinary preload integrity
Check ordinary preload responses with the shared SRI implementation, including CORS eligibility and Service Worker response filters. Dispatch error on verification failure while retaining the actual response bytes for Resource Timing.

Cover top-level and child parser links, dynamic links, binary bodies, redirect taint, hash selection, and Service Worker responses with integration regressions.
2026-11-20 22:47:41 +08:00

1224 lines
57 KiB
Rust

#[path = "referrer_policy_inheritance.rs"]
mod referrer_policy_inheritance;
use super::*;
use parking_lot::Mutex;
use std::sync::Arc;
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
task::{JoinHandle, JoinSet},
};
#[path = "document_referrer_dispatch.rs"]
mod document_referrer_dispatch;
#[path = "child_stylesheet_integrity.rs"]
mod child_stylesheet_integrity;
#[path = "module_csp.rs"]
mod module_csp;
const SCRIPT: &str = "globalThis.sriExecutions = (globalThis.sriExecutions || 0) + 1;";
const INTEGRITY: &str = "sha384-T7tuz8k7Hz0eBaWUPKiAEECRmaKHLJ1eRz7NF4VdK1fN++IaKD3hEk0SETOP+8aJ";
#[path = "preload_integrity.rs"]
mod preload;
struct IntegrityServers {
origin: String,
cross_origin: String,
requests: Arc<Mutex<Vec<IntegrityRequest>>>,
requests_changed: Arc<tokio::sync::Notify>,
tasks: Vec<JoinHandle<()>>,
}
#[derive(Debug)]
struct IntegrityRequest {
body: String,
method: String,
path: String,
origin: Option<String>,
cookie: Option<String>,
referer: Option<String>,
sec_fetch_dest: Option<String>,
sec_fetch_mode: Option<String>,
sec_fetch_site: Option<String>,
}
impl Drop for IntegrityServers {
fn drop(&mut self) {
for task in &self.tasks {
task.abort();
}
}
}
impl IntegrityServers {
async fn spawn() -> Result<Self> {
let main = TcpListener::bind("127.0.0.1:0").await?;
let cross = TcpListener::bind("127.0.0.1:0").await?;
let origin = format!("http://{}", main.local_addr()?);
let cross_origin = format!("http://{}", cross.local_addr()?);
let requests = Arc::new(Mutex::new(Vec::new()));
let requests_changed = Arc::new(tokio::sync::Notify::new());
let tasks = [main, cross]
.into_iter()
.map(|listener| {
let origin = origin.clone();
let cross_origin = cross_origin.clone();
let requests = Arc::clone(&requests);
let requests_changed = Arc::clone(&requests_changed);
tokio::spawn(async move {
let mut connections = JoinSet::new();
loop {
tokio::select! {
accepted = listener.accept() => {
let Ok((mut stream, _)) = accepted else { break };
let origin = origin.clone();
let cross_origin = cross_origin.clone();
let requests = Arc::clone(&requests);
let requests_changed = Arc::clone(&requests_changed);
connections.spawn(async move {
let mut request = Vec::new();
while !request.ends_with(b"\r\n\r\n") && request.len() < 16384 {
let Ok(byte) = stream.read_u8().await else { return };
request.push(byte);
}
let request = String::from_utf8_lossy(&request);
let path = request.split_whitespace().nth(1).unwrap_or("/");
let header = |name: &str| request.lines().filter_map(|line| line.split_once(':'))
.find(|(key, _)| key.eq_ignore_ascii_case(name))
.map(|(_, value)| value.trim().to_owned());
let body_len = header("Content-Length").and_then(|value| value.parse().ok()).unwrap_or(0);
let mut body = vec![0; body_len];
if stream.read_exact(&mut body).await.is_err() { return; }
let incoming = IntegrityRequest {
body: String::from_utf8_lossy(&body).into_owned(),
method: request.split_whitespace().next().unwrap_or("GET").to_owned(),
path: path.to_owned(), origin: header("Origin"), cookie: header("Cookie"),
referer: header("Referer"),
sec_fetch_dest: header("Sec-Fetch-Dest"),
sec_fetch_mode: header("Sec-Fetch-Mode"),
sec_fetch_site: header("Sec-Fetch-Site"),
};
let (status, headers, body) = fixture_response(&incoming, &origin, &cross_origin);
requests.lock().push(incoming);
requests_changed.notify_one();
let response = format!(
"HTTP/1.1 {status}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len(),
);
let _ = stream.write_all(response.as_bytes()).await;
});
}
_ = connections.join_next(), if !connections.is_empty() => {}
}
}
})
})
.collect();
Ok(Self {
origin,
cross_origin,
requests,
requests_changed,
tasks,
})
}
}
fn network_cases(origin: &str, cross: &str) -> serde_json::Value {
serde_json::json!([
{"name": "same-origin", "src": format!("{origin}/script.js"), "integrity": INTEGRITY, "expected": "load"},
{"name": "excess-padding-mismatch", "src": format!("{origin}/script.js"), "integrity": "sha384-AAAA===", "expected": "error"},
{"name": "interior-padding-mismatch", "src": format!("{origin}/script.js"), "integrity": "sha384-A=AAA", "expected": "error"},
{"name": "padding-only-mismatch", "src": format!("{origin}/script.js"), "integrity": "sha384-====", "expected": "error"},
{"name": "malformed-stronger-hash", "src": format!("{origin}/script.js"), "integrity": format!("{INTEGRITY} sha512-AAAA==="), "expected": "error"},
{"name": "noncanonical-padding", "src": format!("{origin}/script.js"), "integrity": format!("{INTEGRITY}="), "expected": "load"},
{"name": "excess-padding-match", "src": format!("{origin}/script.js"), "integrity": format!("{INTEGRITY}===="), "expected": "load"},
{"name": "non-base64-ignored", "src": format!("{origin}/script.js"), "integrity": "sha384-***", "expected": "load"},
{"name": "malformed-and-matching", "src": format!("{origin}/script.js"), "integrity": format!("sha384-A=AAA {INTEGRITY}"), "expected": "load"},
{"name": "cross-no-cors", "src": format!("{cross}/script.js"), "integrity": INTEGRITY, "expected": "error"},
{"name": "cross-anonymous", "src": format!("{cross}/cors.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "load"},
{"name": "cross-no-acao", "src": format!("{cross}/script.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "error"},
{"name": "cors-without-integrity", "src": format!("{cross}/script.js"), "crossOrigin": "anonymous", "expected": "error"},
{"name": "cors-empty-integrity", "src": format!("{cross}/script.js"), "integrity": "", "crossOrigin": "anonymous", "expected": "error"},
{"name": "cors-unsupported-integrity", "src": format!("{cross}/script.js"), "integrity": "sha1-ignored", "crossOrigin": "anonymous", "expected": "error"},
{"name": "redirect-cross", "src": format!("{origin}/redirect.js"), "integrity": INTEGRITY, "expected": "error"},
{"name": "redirect-home", "src": format!("{origin}/roundtrip.js"), "integrity": INTEGRITY, "expected": "error"},
{"name": "cors-redirect", "src": format!("{origin}/cors-redirect.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "load"},
{"name": "cors-unapproved-hop", "src": format!("{cross}/unapproved-redirect.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "error"},
{"name": "cors-null-origin", "src": format!("{cross}/cors-redirect-null.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "load"},
{"name": "cors-old-origin", "src": format!("{cross}/cors-redirect-origin.js"), "integrity": INTEGRITY, "crossOrigin": "anonymous", "expected": "error"},
{"name": "absent-integrity", "src": format!("{cross}/script.js"), "expected": "load"},
{"name": "empty-integrity", "src": format!("{cross}/script.js"), "integrity": "", "expected": "load"},
{"name": "unsupported-integrity", "src": format!("{cross}/script.js"), "integrity": "sha1-ignored", "expected": "load"},
{"name": "mismatch", "src": format!("{origin}/script.js"), "integrity": "sha384-foobar", "expected": "error"}
])
}
fn fixture_response(
request: &IntegrityRequest,
origin: &str,
cross: &str,
) -> (&'static str, String, String) {
let (path, query) = request.path.split_once('?').unwrap_or((&request.path, ""));
let javascript = "Content-Type: text/javascript\r\n";
match path {
"/module-csp.html" | "/module-csp-privacy.html" | "/module-csp-report-uri" | "/module-csp-report-to" | "/module-csp-hash-preload.html" | "/module-csp-hash-tampered.js" | "/module-csp.text" | "/module-csp.json" | "/module-csp.css" | "/module-csp.js" | "/module-csp.wasm" => {
module_csp::fixture_response(path, query, origin, cross)
}
"/child-sri-frame.html"
| "/child-sri-rejected.css"
| "/child-sri-accepted.css"
| "/child-sri-forbidden.css" => child_stylesheet_integrity::fixture_response(path, query),
"/text-module.txt" => (
"200 OK",
"Content-Type: application/octet-stream\r\nCache-Control: no-store\r\n".to_owned(),
SCRIPT.to_owned(),
),
"/text-module-preload.html" => (
"200 OK",
"Content-Type: text/html\r\n".to_owned(),
text_modules::preload_markup(),
),
"/document-referrer.html" | "/meta-policy.html" | "/meta-policy-fetch" => {
document_referrer_dispatch::fixture_response(path, query, request.referer.as_deref())
}
"/preload-parser.html" => (
"200 OK",
"Content-Type: text/html\r\n".to_owned(),
preload::parser_markup(origin, cross),
),
"/echo-origin.js"
| "/echo-origin-redirect.js"
| "/echo-origin-home.js"
| "/echo-origin-roundtrip.js"
| "/module-graph.js" => {
// Echo the actual request Origin: a missing header must not silently
// receive ACAO: null and hide a broken redirect handoff.
let mut headers = format!(
"{javascript}Cache-Control: no-store\r\nVary: Origin\r\nX-Sri-Private: yes\r\n"
);
if let Some(origin) = &request.origin {
headers.push_str(&format!("Access-Control-Allow-Origin: {origin}\r\nAccess-Control-Allow-Credentials: true\r\n"));
}
if request.method == "OPTIONS" {
headers.push_str("Access-Control-Allow-Methods: GET, PUT\r\nAccess-Control-Allow-Headers: x-sri-test\r\n");
return ("204 No Content", headers, String::new());
}
let target = match path {
"/echo-origin-redirect.js" => Some(format!("{cross}/echo-origin.js?{query}")),
"/echo-origin-home.js" => Some(format!("{origin}/echo-origin.js?{query}")),
"/echo-origin-roundtrip.js" => Some(format!("{cross}/echo-origin-home.js?{query}")),
_ => None,
};
if let Some(target) = target {
headers.push_str(&format!("Location: {target}\r\n"));
("302 Found", headers, String::new())
} else if path == "/module-graph.js" {
(
"200 OK",
headers,
format!(
"import '{cross}/{}';",
if query == "graph-blocked" {
"script.js?blocked-static"
} else {
"echo-origin.js?static-dependency"
}
),
)
} else {
("200 OK", headers, SCRIPT.to_owned())
}
}
"/style.css"
| "/style-roundtrip.css"
| "/style-home.css"
| "/app.webmanifest"
| "/manifest-roundtrip.webmanifest"
| "/manifest-home.webmanifest" => {
let mut headers = "Cache-Control: no-store\r\nVary: Origin\r\n".to_owned();
if let Some(incoming_origin) = &request.origin
&& !(query == "bad-hop" && path.contains("-home."))
{
let allowed_origin = if query == "bad-final" && !path.contains('-') {
origin
} else {
incoming_origin
};
headers.push_str(&format!(
"Access-Control-Allow-Origin: {allowed_origin}\r\n"
));
}
let target = match path {
"/style-roundtrip.css" => Some(format!("{cross}/style-home.css?{query}")),
"/style-home.css" => Some(format!("{origin}/style.css?{query}")),
"/manifest-roundtrip.webmanifest" => {
Some(format!("{cross}/manifest-home.webmanifest?{query}"))
}
"/manifest-home.webmanifest" => Some(format!("{origin}/app.webmanifest?{query}")),
_ => None,
};
if let Some(target) = target {
headers.push_str(&format!("Location: {target}\r\n"));
("302 Found", headers, String::new())
} else if path.ends_with(".css") {
headers.push_str("Content-Type: text/css\r\n");
("200 OK", headers, "body { color: green; }".to_owned())
} else {
headers.push_str("Content-Type: application/manifest+json\r\n");
(
"200 OK",
headers,
r#"{"name":"Redirected manifest"}"#.to_owned(),
)
}
}
"/manifest-page.html" => (
"200 OK",
"Content-Type: text/html\r\n".to_owned(),
format!(
"<!doctype html><link rel=manifest href='/{}?{query}'>",
if query == "same-origin" {
"app.webmanifest"
} else {
"manifest-roundtrip.webmanifest"
}
),
),
"/script.js" => ("200 OK", javascript.to_owned(), SCRIPT.to_owned()),
"/cacheable.js" => (
"200 OK",
format!("{javascript}Cache-Control: max-age=60\r\n"),
SCRIPT.to_owned(),
),
"/cors.js" | "/cors-null.js" | "/cors-origin.js" => (
"200 OK",
format!(
"{javascript}Access-Control-Allow-Origin: {}\r\n",
match path {
"/cors-null.js" => "null",
"/cors-origin.js" => origin,
_ => "*",
}
),
SCRIPT.to_owned(),
),
"/redirect.js"
| "/roundtrip.js"
| "/redirect-home.js"
| "/cors-redirect.js"
| "/unapproved-redirect.js"
| "/cors-redirect-null.js"
| "/cors-redirect-origin.js" => {
let target = match path {
"/redirect.js" => format!("{cross}/script.js"),
"/roundtrip.js" => format!("{cross}/redirect-home.js"),
"/cors-redirect.js" => format!("{cross}/cors.js"),
"/unapproved-redirect.js" => format!("{origin}/cors.js"),
"/cors-redirect-null.js" => format!("{origin}/cors-null.js"),
"/cors-redirect-origin.js" => format!("{origin}/cors-origin.js"),
_ => format!("{origin}/script.js"),
};
let acao = if path.starts_with("/cors-redirect") {
"Access-Control-Allow-Origin: *\r\n"
} else {
""
};
(
"302 Found",
format!("Location: {target}\r\n{acao}"),
String::new(),
)
}
"/worker.js" => {
let body = format!(
r#"
self.addEventListener('install', event => event.waitUntil(self.skipWaiting()));
self.addEventListener('activate', event => event.waitUntil(clients.claim()));
self.addEventListener('fetch', event => {{
const path = new URL(event.request.url).pathname;
if (path === '/sw-opaque.js')
event.respondWith(fetch('{cross}/script.js', {{mode: 'no-cors'}}));
else if (path === '/sw-basic.js')
event.respondWith(fetch('{origin}/script.js'));
else if (path === '/sw-cors.js')
event.respondWith(fetch('{cross}/cors.js'));
else if (path === '/sw-default.js')
event.respondWith(new Response({script}, {{headers: {{'Content-Type': 'text/javascript'}}}}));
else if (path === '/sw-redirect.js')
event.respondWith(Response.redirect('{cross}/script.js'));
else if (path === '/sw-roundtrip.js')
event.respondWith(Response.redirect('{cross}/redirect-home.js'));
else if (path === '/sw-cors-redirect.js')
event.respondWith(Response.redirect('{origin}/cors.js'));
else if (path === '/sw-cors-redirect-null.js')
event.respondWith(Response.redirect('{origin}/cors-null.js'));
else if (path === '/sw-cors-redirect-origin.js')
event.respondWith(Response.redirect('{origin}/cors-origin.js'));
else if (path === '/sw-cors-redirect-no-acao.js')
event.respondWith(Response.redirect('{origin}/script.js'));
else if (path === '/sw-cors-redirect-unapproved-hop.js')
event.respondWith(Response.redirect('{cross}/unapproved-redirect.js'));
else if (path === '/sw-request-state.js')
event.respondWith(Response.redirect('{origin}/echo-origin.js' + new URL(event.request.url).search));
else if (path === '/sw-request-state-redirect.js')
event.respondWith(Response.redirect('{origin}/echo-origin-redirect.js' + new URL(event.request.url).search));
else if (path === '/sw-cacheable.js')
event.respondWith(Response.redirect('{origin}/cacheable.js'));
else if (path.startsWith('/sw-return-'))
event.respondWith(Response.redirect('{origin}' + path.replace('/sw-return-', '/sw-final-')));
else if (path === '/sw-final-basic.js')
event.respondWith(fetch('{origin}/echo-origin.js?worker-basic'));
else if (path === '/sw-final-basic-buffered.js')
event.respondWith(fetch('{origin}/echo-origin.js?worker-basic-buffered').then(async response => {{
await response.clone().text();
return response;
}}));
else if (path === '/sw-final-cors.js')
event.respondWith(fetch('{cross}/echo-origin.js?worker-cors'));
else if (path === '/sw-final-default.js')
event.respondWith(new Response({script}, {{headers: {{'Content-Type': 'text/javascript', 'X-Sri-Private': 'yes'}}}}));
}});
"#,
script = serde_json::to_string(SCRIPT).unwrap()
);
("200 OK", javascript.to_owned(), body)
}
"/child-classic.html" => (
"200 OK",
"Content-Type: text/html\r\n".to_owned(),
"<!doctype html><body><script>globalThis.sriExecutions=0</script><script src='/sw-default.js?parser'></script>".to_owned(),
),
"/module-destination" => {
let (mime, body) = if request.sec_fetch_dest.as_deref() == Some("script") {
("application/javascript", "globalThis.destinationExecutions = (globalThis.destinationExecutions || 0) + 1; export default 'script value';")
} else {
("text/plain", "text module body")
};
("200 OK", format!("Content-Type: {mime}\r\nCache-Control: max-age=600\r\nVary: Sec-Fetch-Dest\r\n"), body.to_owned())
}
"/page.html" | "/parser.html" | "/cookie-page.html" | "/csp-page.html" => {
let mut html = "<!doctype html><body><script>globalThis.sriEvents = {}; globalThis.sriExecutions = 0;</script>".to_owned();
if path == "/csp-page.html" {
html.insert_str(15, "<meta http-equiv='Content-Security-Policy' content=\"script-src 'self' 'unsafe-inline'\">");
}
if path == "/parser.html" {
for case in network_cases(origin, cross).as_array().unwrap() {
let name = case["name"].as_str().unwrap();
html.push_str(&format!("<script src=\"{}\" onload=\"sriEvents['{name}']='load'\" onerror=\"sriEvents['{name}']='error'\"", case["src"].as_str().unwrap()));
for attribute in ["integrity", "crossOrigin"] {
if let Some(value) = case[attribute].as_str() {
html.push_str(&format!(" {attribute}=\"{value}\""));
}
}
html.push_str("></script>");
}
}
let mut headers = "Content-Type: text/html\r\n".to_owned();
if path == "/cookie-page.html" {
headers.push_str("Set-Cookie: sriSession=present; Path=/; SameSite=Lax\r\n");
}
("200 OK", headers, html)
}
_ => (
"404 Not Found",
"Content-Type: text/plain\r\n".to_owned(),
"not found".to_owned(),
),
}
}
fn assert_integrity_results(result: serde_json::Value, cases: &serde_json::Value) {
let result: serde_json::Value =
serde_json::from_str(result["value"].as_str().expect("integrity result JSON")).unwrap();
let mut executions = 0;
for case in cases.as_array().unwrap() {
let name = case["name"].as_str().unwrap();
assert_eq!(result["events"][name], case["expected"], "{name}: {result}");
executions += usize::from(case["expected"] == "load");
}
assert_eq!(
result["executions"], executions,
"rejected scripts must not execute"
);
}
fn dynamic_probe(cases: &serde_json::Value, service_worker: bool) -> String {
format!(
r#"(async () => {{
if ({service_worker}) {{
const controlled = navigator.serviceWorker.controller ? Promise.resolve() :
new Promise(resolve => navigator.serviceWorker.addEventListener('controllerchange', resolve, {{once: true}}));
await navigator.serviceWorker.register('/worker.js', {{scope: '/'}});
await navigator.serviceWorker.ready;
await controlled;
}}
for (const test of {cases}) {{
sriEvents[test.name] = await new Promise(resolve => {{
const script = document.createElement('script');
script.src = test.src;
if ('type' in test) script.type = test.type;
if ('integrity' in test) script.integrity = test.integrity;
if ('crossOrigin' in test) script.crossOrigin = test.crossOrigin;
script.onload = () => resolve('load');
script.onerror = () => resolve('error');
document.body.append(script);
}});
}}
return JSON.stringify({{events: sriEvents, executions: sriExecutions}});
}})()"#
)
}
#[tokio::test(flavor = "multi_thread")]
async fn parser_script_integrity_requires_readable_response() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/parser.html", servers.origin))
.await?;
let result = page
.evaluate_runtime_expression_async(
"JSON.stringify({events: sriEvents, executions: sriExecutions})",
)
.await?;
assert_integrity_results(
result,
&network_cases(&servers.origin, &servers.cross_origin),
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn dynamic_script_integrity_requires_readable_response() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/page.html", servers.origin))
.await?;
let cases = network_cases(&servers.origin, &servers.cross_origin);
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, false), true)
.await?;
assert_integrity_results(result, &cases);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn module_script_integrity_requires_readable_response() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/page.html", servers.origin))
.await?;
let cases = serde_json::json!([
{"name": "same-origin", "src": "/script.js", "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "cors", "src": format!("{}/cors.js", servers.cross_origin), "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "no-acao", "src": format!("{}/script.js", servers.cross_origin), "type": "module", "integrity": INTEGRITY, "expected": "error"},
{"name": "without-integrity", "src": format!("{}/script.js?absent", servers.cross_origin), "type": "module", "expected": "error"},
{"name": "empty-integrity", "src": format!("{}/script.js?empty", servers.cross_origin), "type": "module", "integrity": "", "expected": "error"},
{"name": "unsupported-integrity", "src": format!("{}/script.js?unsupported", servers.cross_origin), "type": "module", "integrity": "sha1-ignored", "expected": "error"}
]);
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, false), true)
.await?;
assert_integrity_results(result, &cases);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn direct_scripts_send_origin_and_fetch_metadata() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/cookie-page.html", servers.origin))
.await?;
let origin = &servers.origin;
let cross = &servers.cross_origin;
let cases = serde_json::json!([
{"name": "control", "src": "/echo-origin.js?control", "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "classic", "src": format!("{cross}/echo-origin.js?classic"), "crossOrigin": "anonymous", "integrity": INTEGRITY, "expected": "load"},
{"name": "module", "src": format!("{cross}/echo-origin.js?module"), "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "include", "src": format!("{cross}/echo-origin.js?include"), "type": "module", "crossOrigin": "use-credentials", "integrity": INTEGRITY, "expected": "load"},
{"name": "home", "src": format!("{cross}/echo-origin-home.js?home"), "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "roundtrip", "src": "/echo-origin-roundtrip.js?roundtrip", "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "no-cors", "src": format!("{cross}/echo-origin.js?no-cors"), "expected": "load"},
{"name": "graph", "src": "/module-graph.js?graph", "type": "module", "expected": "load"},
{"name": "graph-blocked", "src": "/module-graph.js?graph-blocked", "type": "module", "expected": "error"}
]);
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, false), true)
.await?;
assert_integrity_results(result, &cases);
let imported = page
.evaluate_runtime_expression_with_await_async(
&format!("import('{cross}/echo-origin.js?dynamic-import').then(() => 'loaded')"),
true,
)
.await?;
assert_eq!(imported["value"], "loaded");
let rejected = page
.evaluate_runtime_expression_with_await_async(
&format!(
"import('{cross}/script.js?blocked-dynamic').then(() => 'loaded', () => 'rejected')"
),
true,
)
.await?;
assert_eq!(rejected["value"], "rejected");
let executions = page
.evaluate_runtime_expression_async("sriExecutions")
.await?;
assert_eq!(
executions["value"], 9,
"CORS-rejected dependencies must not execute"
);
let requests = servers.requests.lock();
for name in [
"control",
"classic",
"module",
"include",
"home",
"roundtrip",
"no-cors",
"graph",
"graph-blocked",
"static-dependency",
"dynamic-import",
"blocked-static",
"blocked-dynamic",
] {
let actual: Vec<_> = requests
.iter()
.filter(|request| request.path.ends_with(&format!("?{name}")))
.collect();
let expected_origins = match name {
"home" => vec![Some(origin.as_str()), Some("null")],
"roundtrip" => vec![Some(origin.as_str()), Some(origin.as_str()), Some("null")],
"no-cors" => vec![None],
_ => vec![Some(origin.as_str())],
};
assert_eq!(actual.len(), expected_origins.len(), "{name}: {actual:?}");
for (index, (request, expected_origin)) in actual.iter().zip(expected_origins).enumerate() {
assert_eq!(
request.origin.as_deref(),
expected_origin,
"{name}: {request:?}"
);
assert_eq!(
request.sec_fetch_dest.as_deref(),
Some("script"),
"{name}: {request:?}"
);
assert_eq!(
request.sec_fetch_mode.as_deref(),
Some(if name == "no-cors" { "no-cors" } else { "cors" }),
"{name}: {request:?}"
);
let same_origin = matches!(name, "control" | "graph" | "graph-blocked")
|| (name == "roundtrip" && index == 0);
assert_eq!(
request.sec_fetch_site.as_deref(),
Some(if same_origin {
"same-origin"
} else {
"same-site"
}),
"{name}: {request:?}"
);
assert_eq!(
request.cookie.as_deref(),
if same_origin || matches!(name, "include" | "no-cors") {
Some("sriSession=present")
} else {
None
},
"{name}: {request:?}"
);
}
}
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn srcdoc_module_requests_use_window_origin_instead_of_base_url() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/cookie-page.html", servers.origin))
.await?;
let result = page.evaluate_runtime_expression_with_await_async(&format!(r#"(async () => {{
const results = [];
for (const kind of ['module', 'classic', 'preload', 'dynamic']) {{
for (const originKind of ['same-origin', 'inherited', 'sandboxed']) {{
const name = originKind + '-' + kind;
const frame = document.createElement('iframe');
if (originKind === 'sandboxed') frame.setAttribute('sandbox', 'allow-scripts');
const terminal = new Promise(resolve => {{
const handler = event => {{
if (event.source !== frame.contentWindow || !String(event.data).startsWith(name + ':')) return;
removeEventListener('message', handler);
resolve(event.data);
}};
addEventListener('message', handler);
}});
const terminalAttributes = `onload="parent.postMessage('${{name}}:load', '*')" onerror="parent.postMessage('${{name}}:error', '*')"`;
const source = './echo-origin.js?' + name;
const resource = kind === 'preload'
? `<link rel='modulepreload' href='${{source}}' integrity='{INTEGRITY}' ${{terminalAttributes}}>`
: kind === 'dynamic'
? `<script>import('${{source}}').then(() => parent.postMessage('${{name}}:load', '*'), () => parent.postMessage('${{name}}:error', '*'));<\/script>`
: `<script type='${{kind === 'module' ? 'module' : 'text/javascript'}}' crossorigin='anonymous' src='${{source}}' integrity='{INTEGRITY}' ${{terminalAttributes}}><\/script>`;
frame.srcdoc = `<base href='${{originKind === 'same-origin' ? location.origin : '{cross}'}}/'>` + resource;
document.body.append(frame);
results.push(await terminal);
frame.remove();
}}
}}
return JSON.stringify(results);
}})()"#, cross = servers.cross_origin), true).await?;
let result: serde_json::Value = serde_json::from_str(result["value"].as_str().unwrap())?;
let mut expected = Vec::new();
let requests = servers.requests.lock();
for kind in ["module", "classic", "preload", "dynamic"] {
for (origin_kind, origin) in [
("same-origin", Some(servers.origin.as_str())),
("inherited", Some(servers.origin.as_str())),
("sandboxed", Some("null")),
] {
let name = format!("{origin_kind}-{kind}");
expected.push(format!("{name}:load"));
let request = requests
.iter()
.find(|request| request.path == format!("/echo-origin.js?{name}"))
.expect("child script request");
assert_eq!(request.origin.as_deref(), origin, "{request:?}");
assert_eq!(request.sec_fetch_dest.as_deref(), Some("script"));
assert_eq!(request.sec_fetch_mode.as_deref(), Some("cors"));
assert_eq!(
request.cookie.as_deref(),
if origin_kind == "same-origin" {
Some("sriSession=present")
} else {
None
},
"{request:?}"
);
}
}
assert_eq!(result, serde_json::json!(expected));
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn csp_blocks_dynamic_scripts_before_cors_fetch_and_reports_violation() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/csp-page.html", servers.origin))
.await?;
let result = page.evaluate_runtime_expression_with_await_async(&format!(r#"(async () => {{
const results = [];
for (const type of ['', 'module']) {{
const script = document.createElement('script');
script.type = type;
script.crossOrigin = 'anonymous';
script.src = '{cross}/script.js?csp-blocked-' + type;
const violation = new Promise(resolve => {{
document.addEventListener('securitypolicyviolation', event => resolve(event.effectiveDirective), {{once: true}});
}});
const terminal = new Promise(resolve => {{
script.onload = () => resolve('load');
script.onerror = () => resolve('error');
}});
document.body.append(script);
results.push(await Promise.all([terminal, violation]));
}}
return JSON.stringify(results);
}})()"#, cross = servers.cross_origin), true).await?;
let result: serde_json::Value = serde_json::from_str(result["value"].as_str().unwrap())?;
assert_eq!(
result,
serde_json::json!([["error", "script-src-elem"], ["error", "script-src-elem"]])
);
assert!(
!servers
.requests
.lock()
.iter()
.any(|request| request.path.contains("csp-blocked")),
"CSP must reject before sending a request"
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn stylesheet_roundtrip_preserves_cors_validation_and_cssom_origin_clean() -> 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 results = {};
for (const name of ['same-origin', 'no-cors', 'allow', 'bad-hop', 'bad-final']) {
const link = document.createElement('link');
link.rel = 'stylesheet';
link.href = (name === 'same-origin' ? '/style.css?' : '/style-roundtrip.css?') + name;
if (!['same-origin', 'no-cors'].includes(name)) link.crossOrigin = 'anonymous';
const event = await new Promise(resolve => {
link.onload = () => resolve('load');
link.onerror = () => resolve('error');
document.head.append(link);
});
let rules;
try { rules = link.sheet ? link.sheet.cssRules.length : null; }
catch (error) { rules = error.name; }
results[name] = {event, rules};
link.remove();
}
return JSON.stringify(results);
})()"#,
true,
)
.await?;
let result: serde_json::Value = serde_json::from_str(result["value"].as_str().unwrap())?;
assert_eq!(
result,
serde_json::json!({
"same-origin": {"event": "load", "rules": 1},
"no-cors": {"event": "load", "rules": "SecurityError"},
"allow": {"event": "load", "rules": 1},
// Chromium keeps an unreadable empty sheet after a failed load.
"bad-hop": {"event": "error", "rules": "SecurityError"},
"bad-final": {"event": "error", "rules": "SecurityError"}
})
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn manifest_roundtrip_checks_intermediate_and_final_cors_responses() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
for name in ["same-origin", "allow", "bad-hop", "bad-final"] {
let mut page = browser
.fetch(&format!("{}/manifest-page.html?{name}", servers.origin))
.await?;
let completion = page.start_prepare_app_manifest_load()?.wait().await?;
let moli_renderer_v8::RendererAppManifestLoadPreparation::Ready(load) =
page.finish_prepare_app_manifest_load(completion)?
else {
anyhow::bail!("{name}: expected a network manifest load");
};
let (result, publication) = load.execute().await.into_parts();
let completion = page
.start_publish_app_manifest_load(publication)?
.wait()
.await?;
page.finish_publish_app_manifest_load(completion)?;
let allowed = matches!(name, "same-origin" | "allow");
assert_eq!(
result.data.as_deref(),
Some(if allowed {
r#"{"name":"Redirected manifest"}"#
} else {
""
}),
"{name}: {result:?}",
);
assert_eq!(
result.manifest.name.as_deref(),
allowed.then_some("Redirected manifest"),
"{name}: {result:?}"
);
}
let requests = servers.requests.lock();
let roundtrip: Vec<_> = requests
.iter()
.filter(|request| request.path.ends_with(".webmanifest?allow"))
.collect();
assert_eq!(roundtrip.len(), 3, "{roundtrip:?}");
for (request, expected_origin) in
roundtrip
.iter()
.zip([None, Some(servers.origin.as_str()), Some("null")])
{
assert_eq!(request.origin.as_deref(), expected_origin, "{request:?}");
assert_eq!(request.sec_fetch_dest.as_deref(), Some("manifest"));
}
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn child_classic_scripts_use_the_controlling_service_worker() -> 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 = tokio::time::timeout(
Duration::from_secs(15),
page.evaluate_runtime_expression_with_await_async(
r#"(async () => {
const controlled = navigator.serviceWorker.controller ? Promise.resolve() :
new Promise(resolve => navigator.serviceWorker.addEventListener('controllerchange', resolve, {once:true}));
await navigator.serviceWorker.register('/worker.js', {scope:'/'});
await navigator.serviceWorker.ready;
await controlled;
const child = document.createElement('iframe');
child.src='/child-classic.html';
await new Promise(resolve => {child.onload=resolve;document.body.append(child);});
const other = child.contentWindow;
if (other.sriExecutions !== 1) throw new Error('parser script did not execute');
const script = other.document.createElement('script');
script.src='/sw-default.js?dynamic';
await new Promise((resolve,reject) => {
script.onload=resolve;
script.onerror=() => reject(new Error('dynamic script failed'));
other.document.body.append(script);
});
const executions = other.sriExecutions;
child.remove();
return executions;
})()"#,
true,
),
).await??;
assert_eq!(result["value"], 2, "{result}");
assert!(
!servers
.requests
.lock()
.iter()
.any(|request| request.path.starts_with("/sw-default.js")),
"both child script paths must be served by the controlling service worker"
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn service_worker_script_integrity_preserves_response_filter() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/page.html", servers.origin))
.await?;
let cases = serde_json::json!([
{"name": "opaque", "src": "/sw-opaque.js", "integrity": INTEGRITY, "expected": "error"},
{"name": "basic", "src": "/sw-basic.js", "integrity": INTEGRITY, "expected": "load"},
{"name": "cors", "src": "/sw-cors.js", "integrity": INTEGRITY, "expected": "load"},
{"name": "default", "src": "/sw-default.js", "integrity": INTEGRITY, "expected": "load"},
{"name": "redirect-cross", "src": "/sw-redirect.js", "integrity": INTEGRITY, "expected": "error"},
{"name": "redirect-home", "src": "/sw-roundtrip.js", "integrity": INTEGRITY, "expected": "error"},
{"name": "opaque-without-integrity", "src": "/sw-opaque.js", "expected": "load"},
{"name": "opaque-empty-integrity", "src": "/sw-opaque.js", "integrity": "", "expected": "load"}
]);
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, true), true)
.await?;
assert_integrity_results(result, &cases);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn service_worker_cross_origin_redirect_integrity_checks_network_responses() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/page.html", servers.origin))
.await?;
let cross = &servers.cross_origin;
// These requests start cross-origin, so the worker's synthetic response
// must be distinguished from a cross-origin HTTP redirect without ACAO.
let cases = serde_json::json!([
{"name": "classic-cors", "src": format!("{cross}/sw-cors-redirect.js"), "crossOrigin": "anonymous", "integrity": INTEGRITY, "expected": "load"},
{"name": "module-cors", "src": format!("{cross}/sw-cors-redirect.js"), "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "module-null-origin", "src": format!("{cross}/sw-cors-redirect-null.js"), "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "module-old-origin", "src": format!("{cross}/sw-cors-redirect-origin.js"), "type": "module", "integrity": INTEGRITY, "expected": "error"},
{"name": "module-no-acao", "src": format!("{cross}/sw-cors-redirect-no-acao.js"), "type": "module", "integrity": INTEGRITY, "expected": "error"},
{"name": "module-unapproved-hop", "src": format!("{cross}/sw-cors-redirect-unapproved-hop.js"), "type": "module", "integrity": INTEGRITY, "expected": "error"},
{"name": "classic-opaque", "src": format!("{cross}/sw-cors-redirect.js"), "integrity": INTEGRITY, "expected": "error"}
]);
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, true), true)
.await?;
assert_integrity_results(result, &cases);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn service_worker_script_redirect_preserves_origin_and_credentials() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/cookie-page.html", servers.origin))
.await?;
let cross = &servers.cross_origin;
let cases = serde_json::json!([
{"name": "control", "src": "/echo-origin.js?control", "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "module", "src": format!("{cross}/sw-request-state.js?module"), "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "classic", "src": format!("{cross}/sw-request-state.js?classic"), "crossOrigin": "anonymous", "integrity": INTEGRITY, "expected": "load"},
{"name": "module-include", "src": format!("{cross}/sw-request-state.js?module-include"), "type": "module", "crossOrigin": "use-credentials", "integrity": INTEGRITY, "expected": "load"},
{"name": "classic-include", "src": format!("{cross}/sw-request-state.js?classic-include"), "crossOrigin": "use-credentials", "integrity": INTEGRITY, "expected": "load"},
{"name": "module-chain", "src": format!("{cross}/sw-request-state-redirect.js?module-chain"), "type": "module", "integrity": INTEGRITY, "expected": "load"},
{"name": "classic-chain", "src": format!("{cross}/sw-request-state-redirect.js?classic-chain"), "crossOrigin": "anonymous", "integrity": INTEGRITY, "expected": "load"}
]);
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, true), true)
.await?;
{
let requests = servers.requests.lock();
for case in cases.as_array().unwrap() {
let name = case["name"].as_str().unwrap();
let requests: Vec<_> = requests
.iter()
.filter(|request| request.path.ends_with(&format!("?{name}")))
.collect();
assert_eq!(
requests.len(),
if name.ends_with("-chain") { 2 } else { 1 },
"{name}: {requests:?}"
);
for request in requests {
assert_eq!(
request.sec_fetch_dest.as_deref(),
Some("script"),
"{name}: {request:?}"
);
assert_eq!(
request.sec_fetch_mode.as_deref(),
Some("cors"),
"{name}: {request:?}"
);
assert_eq!(
request.origin.as_deref(),
if name == "control" {
Some(servers.origin.as_str())
} else {
Some("null")
},
"{name}: {request:?}"
);
assert_eq!(
request.cookie.as_deref(),
if name == "control" || name.ends_with("-include") {
Some("sriSession=present")
} else {
None
},
"{name}: {request:?}"
);
}
}
}
assert_integrity_results(result, &cases);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn service_worker_fetch_redirect_preserves_origin_and_credentials() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/cookie-page.html", servers.origin))
.await?;
page.evaluate_runtime_expression_with_await_async(
&dynamic_probe(&serde_json::json!([]), true),
true,
)
.await?;
let cross = &servers.cross_origin;
let cases = serde_json::json!([
{"name": "control", "src": "/echo-origin.js?control", "credentials": "same-origin"},
{"name": "same-origin", "src": format!("{cross}/sw-request-state.js?same-origin"), "credentials": "same-origin"},
{"name": "include", "src": format!("{cross}/sw-request-state.js?include"), "credentials": "include"},
{"name": "omit", "src": format!("{cross}/sw-request-state.js?omit"), "credentials": "omit"},
{"name": "preflight", "src": format!("{cross}/sw-request-state.js?preflight"), "credentials": "same-origin", "method": "PUT", "headers": {"X-Sri-Test": "yes"}},
{"name": "chain", "src": format!("{cross}/sw-request-state-redirect.js?chain"), "credentials": "same-origin"},
{"name": "preflight-chain", "src": format!("{cross}/sw-request-state-redirect.js?preflight-chain"), "credentials": "same-origin", "method": "PUT", "headers": {"X-Sri-Test": "yes"}}
]);
let result = page
.evaluate_runtime_expression_with_await_async(
&format!(
r#"(async () => {{
const results = {{}};
for (const test of {cases}) {{
try {{
const response = await fetch(test.src, test);
results[test.name] = {{body: await response.text(), type: response.type,
privateHeader: response.headers.get('X-Sri-Private')}};
}}
catch (error) {{ results[test.name] = String(error); }}
}}
return JSON.stringify(results);
}})()"#
),
true,
)
.await?;
let results: serde_json::Value = serde_json::from_str(result["value"].as_str().unwrap())?;
let requests = servers.requests.lock();
for case in cases.as_array().unwrap() {
let name = case["name"].as_str().unwrap();
let requests: Vec<_> = requests
.iter()
.filter(|request| request.path.ends_with(&format!("?{name}")))
.collect();
assert_eq!(
requests.len(),
match name {
"preflight-chain" => 4,
"preflight" | "chain" => 2,
_ => 1,
},
"{name}: {requests:?}"
);
for request in requests {
assert_eq!(
request.origin.as_deref(),
if name == "control" {
None
} else {
Some("null")
},
"{name}: {request:?}"
);
assert_eq!(
request.cookie.as_deref(),
if name == "control" || name == "include" {
Some("sriSession=present")
} else {
None
},
"{name}: {request:?}"
);
}
assert_eq!(results[name]["body"], SCRIPT, "{name}: {results}");
assert_eq!(
results[name]["type"],
if name == "control" { "basic" } else { "cors" },
"{name}: {results}"
);
assert_eq!(
results[name]["privateHeader"],
if name == "control" {
serde_json::json!("yes")
} else {
serde_json::Value::Null
},
"{name}: {results}"
);
}
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn service_worker_script_redirect_does_not_reuse_another_response_url_list() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/page.html", servers.origin))
.await?;
// Prime the ordinary Fetch memory cache, and prove the entry is reusable
// before introducing a different URL list through the worker.
let result = page.evaluate_runtime_expression_with_await_async(
"(async () => { await (await fetch('/cacheable.js')).text(); return await (await fetch('/cacheable.js')).text(); })()",
true,
).await?;
assert_eq!(result["value"], SCRIPT);
assert_eq!(
servers
.requests
.lock()
.iter()
.filter(|request| request.path == "/cacheable.js")
.count(),
1
);
let cases = serde_json::json!([
{"name": "same-origin", "src": "/sw-cacheable.js", "crossOrigin": "anonymous", "integrity": INTEGRITY, "expected": "load"},
{"name": "cross-origin", "src": format!("{}/sw-cacheable.js", servers.cross_origin), "crossOrigin": "anonymous", "integrity": INTEGRITY, "expected": "error"}
]);
// Both fetches end at the same cacheable URL. Its body can be reused, but
// the first response's same-origin URL list must not authorize the second.
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, true), true)
.await?;
assert_integrity_results(result, &cases);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn service_worker_redirect_preserves_worker_response_filter() -> Result<()> {
let servers = IntegrityServers::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&format!("{}/page.html", servers.origin))
.await?;
page.evaluate_runtime_expression_with_await_async(
&dynamic_probe(&serde_json::json!([]), true),
true,
)
.await?;
let result = page.evaluate_runtime_expression_with_await_async(
&format!(r#"(async () => {{
const results = {{}};
for (const kind of ['basic', 'basic-buffered', 'cors', 'default']) {{
try {{
const response = await fetch('{cross}/sw-return-' + kind + '.js');
results[kind] = {{type: response.type, privateHeader: response.headers.get('X-Sri-Private'), body: await response.text()}};
}} catch (error) {{ results[kind] = String(error); }}
}}
return JSON.stringify(results);
}})()"#, cross = servers.cross_origin), true,
).await?;
let results: serde_json::Value = serde_json::from_str(result["value"].as_str().unwrap())?;
// A worker-created Default response becomes Basic even after a cross-origin
// redirect. Forwarding a fetched CORS response retains that response's filter.
for (kind, response_type, private_header) in [
("basic", "basic", Some("yes")),
("basic-buffered", "basic", Some("yes")),
("cors", "cors", None),
("default", "basic", Some("yes")),
] {
assert_eq!(results[kind]["body"], SCRIPT, "{kind}: {results}");
assert_eq!(results[kind]["type"], response_type, "{kind}: {results}");
assert_eq!(
results[kind]["privateHeader"],
serde_json::json!(private_header),
"{kind}: {results}"
);
}
let cases = serde_json::Value::Array(
["basic", "basic-buffered", "cors", "default"]
.into_iter()
.map(|kind| {
serde_json::json!({
"name": kind, "src": format!("{}/sw-return-{kind}.js", servers.cross_origin),
"type": "module", "integrity": INTEGRITY, "expected": "load"
})
})
.collect(),
);
let result = page
.evaluate_runtime_expression_with_await_async(&dynamic_probe(&cases, false), true)
.await?;
assert_integrity_results(result, &cases);
Ok(())
}
#[path = "text_network.rs"]
mod text_modules;
#[path = "module_cache.rs"]
mod module_cache;