From ea83e6fa76b1c150df148c4e4370c3cc47679a96 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Mon, 26 Oct 2026 07:14:35 +0800 Subject: [PATCH] fix(workers): queue Fetch CSP violations on worker tasks Share native request CSP admission with WebTransport. Capture all policy violations and caller locations at the initiating call, then deliver events through the existing worker task channel in enforce/report order. Admit keepalive network reports before rejection handlers can close the Worker; the existing per-worker report history suppresses duplicate submissions. Allow queued CSP tasks during pending module evaluation, including those buffered while the module graph was loading, so top-level await can wait for a violation without blocking initialization. Keep other startup message admission and order intact. Cover classic/module Dedicated and Shared Workers, listener reentrancy, Promise microtasks, error identity, captured locations and pre-wire blocking. Wait for real CSP events in existing service-worker reporting tests. Validation: cargo fmt --all; strict workspace/all-targets/all-features clippy; cargo nextest run --no-fail-fast (23,615 passed, 18 skipped, 32 threads, no retries). --- .../misc/extracted/service_worker_events.rs | 181 ++++++++++++++++++ .../misc/extracted/service_worker_surface.rs | 4 + .../global_scope/content_security_policy.rs | 39 +++- .../src/worker/global_scope/fetch.rs | 43 +---- moli-renderer-v8/src/worker/module_runtime.rs | 7 + moli-renderer-v8/src/worker/thread/mod.rs | 25 ++- .../lifecycle/worker_errors_and_teardown.rs | 6 +- .../src/worker/thread/tests/network.rs | 1 + .../worker/thread/tests/network/csp_tasks.rs | 155 +++++++++++++++ 9 files changed, 417 insertions(+), 44 deletions(-) create mode 100644 moli-renderer-v8/src/worker/thread/tests/network/csp_tasks.rs 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" + ); + } + } + } +}