diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs index eecfbf645bd..d8e1837e6ae 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs @@ -601,6 +601,187 @@ async fn csp_report_fetch_pause_continue_preserves_service_worker_dispatch() { .await .expect("service worker paused CSP report server should finish"); } +#[tokio::test] +async fn worker_csp_report_fetch_pause_continue_preserves_service_worker_dispatch() { + let (base_url, server) = spawn_service_worker_response_server_with_headers(vec![ + ( + "/app/worker.js", + "text/javascript; charset=utf-8", + Vec::new(), + r#" + self.addEventListener("install", event => { + event.waitUntil(Promise.resolve()); + }); + self.addEventListener("activate", event => { + event.waitUntil(clients.claim()); + }); + self.addEventListener("fetch", event => { + const url = new URL(event.request.url); + if (url.pathname === "/app/client-worker.js") { + return; + } + if (url.pathname === "/app/csp-report") { + event.respondWith(new Response([ + "destination=" + event.request.destination, + "mode=" + event.request.mode, + "credentials=" + event.request.credentials, + "method=" + event.request.method, + "from=service-worker", + "client=" + (event.clientId.length > 0) + ].join("|"))); + } + }); + "#, + ), + ( + "/app/client-worker.js", + "text/javascript; charset=utf-8", + vec![( + "Content-Security-Policy", + "connect-src 'none'; report-uri /app/csp-report", + )], + r#" + let violationSeen = false; + let observed; + const violation = new Promise(resolve => observed = resolve); + self.addEventListener("securitypolicyviolation", event => { + violationSeen = event.type === "securitypolicyviolation" && + event.effectiveDirective === "connect-src" && + event.violatedDirective === "connect-src" && + event.blockedURI.endsWith("/app/blocked-data") && + event.disposition === "enforce" && + event instanceof SecurityPolicyViolationEvent; + observed(); + }); + self.onmessage = async () => { + await fetch("blocked-data").catch(() => {}); + await violation; + postMessage("blocked:" + violationSeen); + }; + "#, + ), + ]) + .await; + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + let (mut vm, browser_context_runtime) = + new_service_worker_page_test_vm_with_loader_and_browser_context_runtime( + &format!("{base_url}/app/page.html"), + &loader, + ); + + vm.eval( + r#" + (() => { + globalThis.__pausedWorkerCspReportProbe = "pending"; + (async () => { + await navigator.serviceWorker.register("worker.js", { scope: "./" }); + await navigator.serviceWorker.ready; + globalThis.__pausedWorkerCspReportProbe = "ready"; + })().catch((error) => { + globalThis.__pausedWorkerCspReportProbe = + "error:" + String(error && error.message); + }); + })() + "#, + ) + .expect("paused worker CSP report setup should evaluate"); + + drain_service_worker_test_until_eval_equals( + &mut vm, + &browser_context_runtime, + &loader, + "String(globalThis.__pausedWorkerCspReportProbe)", + "ready", + ) + .await; + + vm.set_fetch_subresource_interception( + crate::types::SubresourceInterceptionClasses::for_resource_type( + crate::types::SubresourceResourceType::CspReport, + ), + ); + vm.eval( + r#" + (() => { + const worker = new Worker("client-worker.js"); + worker.onmessage = event => { + globalThis.__pausedWorkerCspReportProbe = String(event.data); + }; + worker.onerror = event => { + globalThis.__pausedWorkerCspReportProbe = "error:" + event.message; + }; + worker.postMessage("start"); + })() + "#, + ) + .expect("paused worker CSP report trigger should evaluate"); + + drain_service_worker_test_until_eval_equals( + &mut vm, + &browser_context_runtime, + &loader, + "String(globalThis.__pausedWorkerCspReportProbe)", + "blocked:true", + ) + .await; + + let report_url = format!("{base_url}/app/csp-report"); + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); + let paused_report = loop { + let mut infos = vm.take_pending_subresource_fetch_infos(); + if let Some(index) = infos.iter().position(|info| { + info.resource_type == crate::types::SubresourceResourceType::CspReport + && info.url.as_str() == report_url + }) { + break infos.remove(index); + } + assert!( + std::time::Instant::now() < deadline, + "timed out waiting for paused worker CSP report" + ); + drain_service_worker_test_turn(&mut vm, &browser_context_runtime, &loader).await; + }; + assert_eq!(paused_report.method, "POST"); + + let outcome = vm + .continue_pending_subresource_fetch( + paused_report.internal_id, + None, + None, + None, + None, + false, + false, + ) + .expect("paused worker CSP report continue should start"); + assert_eq!( + outcome, + crate::types::PendingSubresourceContinueOutcome::Started + ); + + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); + let mut items = Vec::new(); + loop { + items.extend(vm.take_network_output().into_items()); + if service_worker_csp_report_seen( + &items, + &report_url, + "destination=report|mode=no-cors|credentials=same-origin|method=POST|from=service-worker|client=true", + ) { + break; + } + assert!( + std::time::Instant::now() < deadline, + "continued paused worker CSP report did not settle through Service Worker: {items:?}" + ); + drain_service_worker_test_turn(&mut vm, &browser_context_runtime, &loader).await; + } + + server + .await + .expect("paused worker CSP report destination server should finish"); +} + #[tokio::test] async fn service_worker_fetch_receives_resolved_client_referrer_and_policy() { diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs index 125e0c78650..2460fec5dfa 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs @@ -128,6 +128,8 @@ async fn navigator_service_worker_intercepts_worker_csp_report_destination() { )], r#" let violationSeen = false; + let observed; + const violation = new Promise(resolve => observed = resolve); self.addEventListener("securitypolicyviolation", event => { violationSeen = event.type === "securitypolicyviolation" && event.effectiveDirective === "connect-src" && @@ -135,9 +137,11 @@ async fn navigator_service_worker_intercepts_worker_csp_report_destination() { event.blockedURI.endsWith("/app/blocked-data") && event.disposition === "enforce" && event instanceof SecurityPolicyViolationEvent; + observed(); }); self.onmessage = async () => { await fetch("blocked-data").catch(() => {}); + await violation; postMessage("blocked:" + violationSeen); }; "#, diff --git a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs index 7f465943871..7013ce361b9 100644 --- a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs +++ b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs @@ -56,13 +56,34 @@ pub(crate) fn check_worker_webtransport_csp( request_url: &Url, ) -> Option { let state = get_worker_state(scope)?; + let document_url = state.borrow().current_script_url.clone()?; + check_worker_request_csp( + scope, + &state, + &document_url, + request_url, + ContentSecurityPolicyResourceKind::WorkerConnect, + "WebTransport", + ) +} + +pub(super) fn check_worker_request_csp( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + document_url: &Url, + request_url: &Url, + kind: ContentSecurityPolicyResourceKind, + operation: &'static str, +) -> Option { let (check, wake_tx) = { let state = state.borrow(); - let document_url = state.current_script_url.as_ref()?; - let policy = worker_request_policy_snapshot( - &state, - ContentSecurityPolicyResourceKind::WorkerConnect, - ); + worker_policies(&state, ContentSecurityPolicyDisposition::Enforce) + .chain(worker_policies( + &state, + ContentSecurityPolicyDisposition::Report, + )) + .next()?; + let policy = worker_request_policy_snapshot(&state, kind); ( policy.check_url( document_url, @@ -78,11 +99,17 @@ pub(crate) fn check_worker_webtransport_csp( let (report_only, enforced) = check.into_violations(); let message = enforced .first() - .map(|violation| worker_content_security_policy_error_message(violation, "WebTransport")); + .map(|violation| worker_content_security_policy_error_message(violation, operation)); let location = crate::content_security_policy::ContentSecurityPolicySourceLocation::capture(scope); + // Preserve the initiating call site, but report in a later worker task so + // listeners cannot reenter the request API before its promise is returned. for mut violation in enforced.into_iter().chain(report_only) { location.apply_to(&mut violation); + // Admit the native keepalive report before a rejection handler can + // close this worker. Event delivery remains a separate task; the + // per-worker report history suppresses another transport submission. + send_worker_content_security_policy_reports_for_state(state, &violation); let _ = wake_tx.send(WorkerMessage::DispatchContentSecurityPolicyViolation( Box::new(violation), )); diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index a9df7fd56d6..9659cfa77b4 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -1034,41 +1034,14 @@ pub(super) fn start_worker_resource_fetch<'s>( }, ); - let report_only_violation = { - let state_ref = state.borrow(); - worker_content_security_policy_report_only_violation( - &state_ref, - &document_url, - &resolved_url, - kind.csp_resource_kind(), - ) - }; - let csp_violation = { - let state_ref = state.borrow(); - worker_content_security_policy_violation( - &state_ref, - &document_url, - &resolved_url, - kind.csp_resource_kind(), - ) - }; - let csp_source_location = if report_only_violation.is_none() && csp_violation.is_none() { - crate::content_security_policy::ContentSecurityPolicySourceLocation::default() - } else { - crate::content_security_policy::ContentSecurityPolicySourceLocation::capture(scope) - }; - if let Some(mut violation) = report_only_violation { - csp_source_location.apply_to(&mut violation); - dispatch_worker_content_security_policy_violation_event_for_state( - scope, &state, &violation, - ); - } - if let Some(mut violation) = csp_violation { - csp_source_location.apply_to(&mut violation); - dispatch_worker_content_security_policy_violation_event_for_state( - scope, &state, &violation, - ); - let message = worker_content_security_policy_error_message(&violation, "fetch"); + if let Some(message) = check_worker_request_csp( + scope, + &state, + &document_url, + &resolved_url, + kind.csp_resource_kind(), + "fetch", + ) { record_worker_subresource_failure( &state.borrow(), document_url, diff --git a/moli-renderer-v8/src/worker/module_runtime.rs b/moli-renderer-v8/src/worker/module_runtime.rs index f2055a4ffe3..4218690db7d 100644 --- a/moli-renderer-v8/src/worker/module_runtime.rs +++ b/moli-renderer-v8/src/worker/module_runtime.rs @@ -495,6 +495,13 @@ enum WorkerModulePendingBootstrapState { } impl WorkerModulePendingBootstrap { + pub(super) fn is_waiting_for_evaluation(&self) -> bool { + matches!( + &self.state, + WorkerModulePendingBootstrapState::Evaluation { .. } + ) + } + fn resume_tree( &mut self, scope: &mut v8::PinScope<'_, '_>, diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index ab04984269b..29d4c05fc27 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -2226,8 +2226,26 @@ async fn worker_main( Timer, } + // CSP tasks can settle promises awaited by a module's evaluation. + // Release them once evaluation has started, while other bootstrap + // messages keep their existing admission and relative order. + let ready_csp_message = pending_module_bootstrap + .as_ref() + .filter(|bootstrap| bootstrap.is_waiting_for_evaluation()) + .and_then(|_| { + pending_bootstrap_messages.iter().position(|message| { + matches!( + message, + WorkerMessage::DispatchContentSecurityPolicyViolation(_) + ) + }) + }) + .and_then(|index| pending_bootstrap_messages.remove(index)); + // Wait for either a message, a fetch completion, or a timer. - let wake = if pending_module_bootstrap.is_none() + let wake = if let Some(message) = ready_csp_message { + WorkerLoopWake::Message(Some(message)) + } else if pending_module_bootstrap.is_none() && let Some(message) = pending_bootstrap_messages.pop_front() { WorkerLoopWake::Message(Some(message)) @@ -3052,7 +3070,10 @@ async fn worker_main( WorkerLoopWake::Message(Some( WorkerMessage::DispatchContentSecurityPolicyViolation(violation), )) => { - if pending_module_bootstrap.is_some() { + if pending_module_bootstrap + .as_ref() + .is_some_and(|bootstrap| !bootstrap.is_waiting_for_evaluation()) + { pending_bootstrap_messages.push_back( WorkerMessage::DispatchContentSecurityPolicyViolation(violation), ); diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs index bcc4a13f05d..37a1caba87d 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs @@ -529,6 +529,8 @@ async fn worker_fetch_csp_block_dispatches_securitypolicyviolation_event() { WorkerSpawnOptions::new( r#" const events = []; + let observed; + const violation = new Promise(resolve => observed = resolve); addEventListener("securitypolicyviolation", event => { events.push({ type: event.type, @@ -540,8 +542,10 @@ async fn worker_fetch_csp_block_dispatches_securitypolicyviolation_event() { disposition: event.disposition, instance: event instanceof SecurityPolicyViolationEvent }); + observed(); }); - fetch("https://api.example/data").catch(error => { + fetch("https://api.example/data").catch(async error => { + await violation; postMessage({ events, error: error && error.message diff --git a/moli-renderer-v8/src/worker/thread/tests/network.rs b/moli-renderer-v8/src/worker/thread/tests/network.rs index 50b916f4df4..40e67cd76ce 100644 --- a/moli-renderer-v8/src/worker/thread/tests/network.rs +++ b/moli-renderer-v8/src/worker/thread/tests/network.rs @@ -178,6 +178,7 @@ fn assert_initial_worker_auth_network_headers(headers: Option<&[(String, String) ); } +mod csp_tasks; mod fetch_network; mod fetch_redirect_modes; mod file_and_xhr; diff --git a/moli-renderer-v8/src/worker/thread/tests/network/csp_tasks.rs b/moli-renderer-v8/src/worker/thread/tests/network/csp_tasks.rs new file mode 100644 index 00000000000..9d17b543f62 --- /dev/null +++ b/moli-renderer-v8/src/worker/thread/tests/network/csp_tasks.rs @@ -0,0 +1,155 @@ +use super::*; +use crate::worker::WorkerGlobalKind; + +#[tokio::test] +async fn worker_fetch_csp_tasks_follow_microtasks_without_reentering_listeners() { + ensure_v8(); + for shared in [false, true] { + for kind in [WorkerScriptKind::Classic, WorkerScriptKind::Module] { + for report_only in [false, true] { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let base = format!("http://{}", listener.local_addr().unwrap()); + let script_url = url::Url::parse(&format!("{base}/worker.js")).unwrap(); + let expected = if report_only { 4 } else { 2 }; + let source = r#" +const base = BASE; +const events = []; +const outcomes = {}; +const microtasks = {}; +let inFetch = false; +let inListener = false; +let nestedStarted = false; +let published = false; +let finishEvaluation; +const finished = new Promise(resolve => finishEvaluation = resolve); +const finish = () => { + if (!published && events.length === EXPECTED && outcomes.outer && outcomes.nested) { + published = true; + console.log(JSON.stringify({events, outcomes})); + finishEvaluation(); + } +}; +const load = label => { + inFetch = true; + const promise = fetch(base + '/' + label); + inFetch = false; + queueMicrotask(() => { microtasks[label] = true; }); + promise.then(() => { + outcomes[label] = {unexpectedFulfillment:true}; + finish(); + }, error => { + outcomes[label] = {name:error.name, native:error instanceof TypeError}; + finish(); + }); +}; +addEventListener('securitypolicyviolation', event => { + const label = new URL(event.blockedURI).pathname.slice(1); + events.push({label, inFetch, inListener, + afterMicrotask:microtasks[label] === true, afterRejection:!!outcomes[label], + disposition:event.disposition, directive:event.effectiveDirective, + native:event instanceof SecurityPolicyViolationEvent, trusted:event.isTrusted, + target:event.target === self, sourceFile:event.sourceFile, + line:event.lineNumber, column:event.columnNumber}); + const previous = inListener; + inListener = true; + if (label === 'outer' && !nestedStarted) { + nestedStarted = true; + load('nested'); + } + inListener = previous; + finish(); +}); +load('outer'); +"# + .replace("BASE", &serde_json::to_string(&base).unwrap()) + .replace("EXPECTED", &expected.to_string()); + let source = match kind { + WorkerScriptKind::Classic => source, + WorkerScriptKind::Module => format!("{source}\nawait finished;"), + }; + let global = if shared { + WorkerGlobalKind::Shared { + name: "csp-tasks".into(), + storage_key: moli_storage_key::MoliStorageKey::first_party_from_url( + &script_url, + None, + ), + } + } else { + WorkerGlobalKind::Dedicated { + name: "csp-tasks".into(), + } + }; + let mut options = WorkerSpawnOptions::new(source, script_url.to_string()) + .with_global_kind(global) + .with_script_kind(kind) + .with_content_security_policies(vec!["connect-src 'none'".into()]); + if report_only { + options = options.with_content_security_report_only_policies(vec![ + "connect-src 'none'".into(), + ]); + } + let mut worker = spawn_test_worker_with_options(options); + let result = timeout(TIMEOUT, async { + loop { + match worker.recv().await.expect("worker must report its result") { + WorkerToParentMessage::Console(console) => { + break console.message; + } + WorkerToParentMessage::SubresourceNetwork(_) => {} + other => panic!("unexpected worker message: {other:?}"), + } + } + }) + .await + .expect("CSP tasks and their promise microtasks must settle"); + worker.terminate_and_join(); + let result: serde_json::Value = + serde_json::from_str(result.strip_prefix("log: ").unwrap()).unwrap(); + assert_eq!( + result["outcomes"], + serde_json::json!({ + "outer":{"name":"TypeError", "native":true}, + "nested":{"name":"TypeError", "native":true}, + }), + "shared={shared}, kind={kind:?}, report_only={report_only}" + ); + let events = result["events"].as_array().unwrap(); + assert_eq!(events.len(), expected); + assert_eq!(events[0]["disposition"], "enforce"); + for label in ["outer", "nested"] { + assert_eq!( + events + .iter() + .filter(|event| event["label"] == label) + .count(), + if report_only { 2 } else { 1 } + ); + } + for event in events { + assert_eq!(event["inFetch"], false, "{result}"); + assert_eq!(event["inListener"], false, "{result}"); + for flag in [ + "afterMicrotask", + "afterRejection", + "native", + "trusted", + "target", + ] { + assert_eq!(event[flag], true, "{flag}: {result}"); + } + assert_eq!(event["directive"], "connect-src"); + assert_eq!(event["sourceFile"], script_url.as_str()); + assert!(event["line"].as_u64().unwrap() > 0); + assert!(event["column"].as_u64().unwrap() > 0); + } + assert!( + timeout(Duration::from_millis(50), listener.accept()) + .await + .is_err(), + "CSP must still block before connecting" + ); + } + } + } +}