diff --git a/moli-renderer-v8/src/content_security_policy/module_fetch.rs b/moli-renderer-v8/src/content_security_policy/module_fetch.rs index 95af99e4e01..488f1616ce6 100644 --- a/moli-renderer-v8/src/content_security_policy/module_fetch.rs +++ b/moli-renderer-v8/src/content_security_policy/module_fetch.rs @@ -25,6 +25,7 @@ struct Inner { original_url: Url, owner_scope: Option, state: Mutex, + violation_reporter: Option>, } #[derive(Default)] @@ -72,9 +73,21 @@ impl ModuleFetchCspContext { original_url, owner_scope, state: Mutex::new(State::default()), + violation_reporter: None, })) } + /// Install the networking report route before sharing this fetch context. + pub(crate) fn with_violation_reporter( + mut self, + reporter: impl Fn(ContentSecurityPolicyUrlViolation) + Send + Sync + 'static, + ) -> Self { + Arc::get_mut(&mut self.0) + .expect("module reporting route is bound before fetch context sharing") + .violation_reporter = Some(Arc::new(reporter)); + self + } + pub(crate) fn owner_scope(&self) -> Option { self.0.owner_scope } @@ -119,8 +132,15 @@ impl ModuleFetchCspContext { .any(|(n, checked)| *n == ordinal && checked == url) { state.checked_hops.push((ordinal, url.clone())); - state.violations.extend(report); - state.violations.extend(enforce); + if let Some(reporter) = &self.0.violation_reporter { + drop(state); + for violation in report.into_iter().chain(enforce) { + reporter(violation); + } + } else { + state.violations.extend(report); + state.violations.extend(enforce); + } } match message { Some(message) => anyhow::bail!(message), diff --git a/moli-renderer-v8/src/worker/module_runtime.rs b/moli-renderer-v8/src/worker/module_runtime.rs index bcf72bbb5a2..a40100f63ef 100644 --- a/moli-renderer-v8/src/worker/module_runtime.rs +++ b/moli-renderer-v8/src/worker/module_runtime.rs @@ -94,7 +94,24 @@ pub(super) struct WorkerModuleGraphFetchCompletion { key: WorkerModuleKey, fetch_id: WorkerModuleGraphFetchId, result: Result, - csp_violations: Vec, +} + +/// Module CSP reports are independent networking tasks and can arrive before a response. +pub(super) enum WorkerModuleGraphFetchEvent { + CspViolation(Box), + Complete(Box), +} + +impl WorkerModuleGraphFetchEvent { + pub(super) fn completed( + fetch_id: WorkerModuleGraphFetchId, + key: WorkerModuleKey, + result: Result, + ) -> Self { + Self::Complete(Box::new(WorkerModuleGraphFetchCompletion::new( + fetch_id, key, result, + ))) + } } pub(super) struct WorkerModuleFetchedSource { @@ -235,7 +252,6 @@ impl WorkerModuleGraphFetchCompletion { key, fetch_id, result, - csp_violations: Vec::new(), } } @@ -243,20 +259,6 @@ impl WorkerModuleGraphFetchCompletion { self.fetch_id } - pub(super) fn with_csp_violations( - mut self, - violations: Vec, - ) -> Self { - self.csp_violations = violations; - self - } - - pub(super) fn csp_violations( - &self, - ) -> impl Iterator { - self.csp_violations.iter() - } - pub(super) fn result( &self, ) -> Result<&WorkerModuleFetchedSource, &module_tree::ModuleLoadError> { diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index ae6ed9cdd68..94869919e56 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -107,8 +107,8 @@ use super::inspector_task_runner::WorkerInspectorTaskRunner; use super::inspector_task_runner::{WorkerInspectorTask, WorkerInspectorTaskMode}; use super::module_runtime::{ WorkerBootstrapError, WorkerModuleBootstrapResume, WorkerModuleBootstrapStart, - WorkerModuleEvaluationCompletion, WorkerModuleFetchedSource, WorkerModuleGraphFetchCompletion, - WorkerModuleGraphFetchCspSource, WorkerModuleGraphFetchRequest, WorkerModulePendingBootstrap, + WorkerModuleEvaluationCompletion, WorkerModuleFetchedSource, WorkerModuleGraphFetchCspSource, + WorkerModuleGraphFetchEvent, WorkerModuleGraphFetchRequest, WorkerModulePendingBootstrap, WorkerModuleSource, complete_worker_module_graph_fetch, evaluate_module_worker_bootstrap_source, install_classic_worker_dynamic_module_runtime, resume_worker_dynamic_module_evaluation, resume_worker_module_trees, @@ -692,7 +692,7 @@ fn start_worker_module_graph_fetch( network_partition_key: Option, module_static_import_content_security_policies: Vec, worker_global_policy: crate::content_security_policy::InheritedContentSecurityPolicy, - completion_tx: mpsc::UnboundedSender, + completion_tx: mpsc::UnboundedSender, ) { // Bootstrap module graphs use outside settings, including data: workers. // Later dynamic imports belong to the Worker's own execution origin. @@ -721,6 +721,7 @@ fn start_worker_module_graph_fetch( let resource_kind = request.module_type().csp_resource_kind(resource_kind); let initiator = request.initiator_url().clone(); let source_location = request.source_location().cloned(); + let csp_events = completion_tx.clone(); let csp_context = crate::content_security_policy::ModuleFetchCspContext::new( request.url().clone(), None, @@ -743,16 +744,15 @@ fn start_worker_module_graph_fetch( check(ContentSecurityPolicyDisposition::Enforce), ) }, - ); + ).with_violation_reporter(move |violation| { + let _ = csp_events.send(WorkerModuleGraphFetchEvent::CspViolation(Box::new(violation))); + }); if let Err(error) = csp_context.check_initial_request(request.url()) { - let _ = completion_tx.send( - WorkerModuleGraphFetchCompletion::new( - fetch_id, - request.module_key(), - Err(error.to_string()), - ) - .with_csp_violations(csp_context.take_violations()), - ); + let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed( + fetch_id, + request.module_key(), + Err(error.to_string()), + )); return; } let browser_request_metadata = match request.browser_request_metadata() { @@ -766,14 +766,11 @@ fn start_worker_module_graph_fetch( .with_network_partition_key(network_partition_key) .with_browser_request_metadata(browser_request_metadata), Err(error) => { - let _ = completion_tx.send( - WorkerModuleGraphFetchCompletion::new( - fetch_id, - request.module_key(), - Err(error.to_string()), - ) - .with_csp_violations(csp_context.take_violations()), - ); + let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed( + fetch_id, + request.module_key(), + Err(error.to_string()), + )); return; } }; @@ -844,8 +841,7 @@ fn start_worker_module_graph_fetch( .with_resource(resource) .with_response_referrer_policy(response_referrer_policy)) }); - let completion = WorkerModuleGraphFetchCompletion::new(fetch_id, completion_key, result) - .with_csp_violations(response_csp_context.take_violations()); + let completion = WorkerModuleGraphFetchEvent::completed(fetch_id, completion_key, result); let _ = completion_tx_for_callback.send(completion); }; let Some(load) = loader.register_load( @@ -853,30 +849,46 @@ fn start_worker_module_graph_fetch( ResourceLoadDisposition::Ordinary, None, ) else { - let _ = completion_tx.send( - WorkerModuleGraphFetchCompletion::new( - fetch_id, - request.module_key(), - Err("worker module dependency fetch rejected during shutdown".to_owned()), - ) - .with_csp_violations(csp_context.take_violations()), - ); + let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed( + fetch_id, + request.module_key(), + Err("worker module dependency fetch rejected during shutdown".to_owned()), + )); return; }; if let Err(error) = loader .request_client() .fetch_cacheable_script_text_callback_with_load(fetch_request, load, send_completion) { - let _ = completion_tx.send( - WorkerModuleGraphFetchCompletion::new( - fetch_id, - request.module_key(), - Err(format!( - "failed to start module worker dependency fetch `{}`: {error}", - request.url() - )), - ) - .with_csp_violations(csp_context.take_violations()), + let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed( + fetch_id, + request.module_key(), + Err(format!( + "failed to start module worker dependency fetch `{}`: {error}", + request.url() + )), + )); + } +} + +fn start_worker_module_graph_fetch_batch( + requests: WorkerModuleGraphFetchBatch, + state: &Rc>, + module_graph_fetch_tx: &mpsc::UnboundedSender, +) { + for request in requests.iter().cloned() { + start_worker_module_graph_fetch( + request, + state.borrow().loader.clone(), + state.borrow().network_partition_key.clone(), + state + .borrow() + .module_static_import_content_security_policies + .clone(), + state + .borrow() + .content_security_policy_snapshot_for_inheritance(), + module_graph_fetch_tx.clone(), ); } } @@ -934,7 +946,7 @@ fn worker_has_pending_indexed_db_tasks( fn flush_one_worker_indexed_db_task( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, - module_graph_fetch_tx: &mpsc::UnboundedSender, + module_graph_fetch_tx: &mpsc::UnboundedSender, ) { let flushed = crate::context_bootstrap::flush_next_indexed_db_task(scope); if !flushed { @@ -947,7 +959,7 @@ fn flush_one_worker_indexed_db_task( fn flush_worker_module_fetches( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, - module_graph_fetch_tx: &mpsc::UnboundedSender, + module_graph_fetch_tx: &mpsc::UnboundedSender, ) { for request in take_worker_module_graph_fetches(scope) { start_worker_module_graph_fetch( @@ -980,7 +992,7 @@ use crate::worker::script_loading::report_service_worker_script_resource as repo fn drain_worker_dynamic_module_imports( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, - module_graph_fetch_tx: &mpsc::UnboundedSender, + module_graph_fetch_tx: &mpsc::UnboundedSender, ) { const MAX_DYNAMIC_IMPORT_DRAIN_STEPS: usize = 1_000; for _ in 0..MAX_DYNAMIC_IMPORT_DRAIN_STEPS { @@ -995,7 +1007,7 @@ fn drain_worker_dynamic_module_imports_for_context( isolate: &mut v8::OwnedIsolate, context: &v8::Global, state: &Rc>, - module_graph_fetch_tx: &mpsc::UnboundedSender, + module_graph_fetch_tx: &mpsc::UnboundedSender, ) { let scope = pin!(v8::HandleScope::new(isolate)); let scope = &mut scope.init(); @@ -1010,7 +1022,7 @@ fn dispatch_worker_inspector_task( context: &v8::Global, task: WorkerInspectorTask, state: &Rc>, - module_graph_fetch_tx: &mpsc::UnboundedSender, + module_graph_fetch_tx: &mpsc::UnboundedSender, ) { let (isolate, inspector) = worker_isolate.worker_isolate_and_runtime_inspector(); inspector.execute_task(isolate, task); @@ -1026,9 +1038,7 @@ async fn run_worker_pre_bootstrap_debugger_pause( worker_isolate: &mut WorkerIsolateState, #[cfg(feature = "devtools")] context: &v8::Global, state: &Rc>, - #[cfg(feature = "devtools")] module_graph_fetch_tx: &mpsc::UnboundedSender< - WorkerModuleGraphFetchCompletion, - >, + #[cfg(feature = "devtools")] module_graph_fetch_tx: &mpsc::UnboundedSender, script_url: &str, rx: &mut mpsc::UnboundedReceiver, pending_bootstrap_messages: &mut VecDeque, @@ -1754,7 +1764,7 @@ async fn worker_main( mpsc::unbounded_channel::(); let (xhr_completion_tx, mut xhr_completion_rx) = mpsc::unbounded_channel::(); let (module_graph_fetch_tx, mut module_graph_fetch_rx) = - mpsc::unbounded_channel::(); + mpsc::unbounded_channel::(); let (module_evaluation_tx, mut module_evaluation_rx) = mpsc::unbounded_channel::(); let (websocket_event_tx, mut websocket_events) = WorkerWebSocketEvents::new(); @@ -2156,7 +2166,7 @@ async fn worker_main( Message(Option), Fetch(Option), Xhr(Option), - ModuleGraphFetch(Option>), + ModuleGraphFetch(Option), ModuleEvaluation(Option), ModuleRuntime, IndexedDb, @@ -2179,7 +2189,7 @@ async fn worker_main( msg = rx.recv() => WorkerLoopWake::Message(msg), completion = fetch_completion_rx.recv() => WorkerLoopWake::Fetch(completion), completion = xhr_completion_rx.recv() => WorkerLoopWake::Xhr(completion), - completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion.map(Box::new)), + completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion), completion = module_evaluation_rx.recv() => WorkerLoopWake::ModuleEvaluation(completion), wake = worker_runtime_wake_rx.recv() => WorkerLoopWake::RuntimeWake(wake), event = websocket_events.recv() => WorkerLoopWake::WebSocket(event), @@ -2194,7 +2204,7 @@ async fn worker_main( msg = rx.recv() => WorkerLoopWake::Message(msg), completion = fetch_completion_rx.recv() => WorkerLoopWake::Fetch(completion), completion = xhr_completion_rx.recv() => WorkerLoopWake::Xhr(completion), - completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion.map(Box::new)), + completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion), completion = module_evaluation_rx.recv() => WorkerLoopWake::ModuleEvaluation(completion), wake = worker_runtime_wake_rx.recv() => WorkerLoopWake::RuntimeWake(wake), event = websocket_events.recv() => WorkerLoopWake::WebSocket(event), @@ -3262,7 +3272,21 @@ async fn worker_main( WorkerLoopWake::Opfs(None) => { // OPFS sender dropped, but other work may still be pending. } - WorkerLoopWake::ModuleGraphFetch(Some(completion)) => { + WorkerLoopWake::ModuleGraphFetch(Some(WorkerModuleGraphFetchEvent::CspViolation( + violation, + ))) => { + let scope = pin!(v8::HandleScope::new(worker_isolate.worker_isolate_mut())); + let scope = &mut scope.init(); + let ctx = v8::Local::new(scope, &context); + let scope = &mut v8::ContextScope::new(scope, ctx); + let loader = state.borrow().loader.clone(); + dispatch_worker_csp_violation_event(scope, &loader, &violation); + perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope); + drain_worker_dynamic_module_imports(scope, &state, &module_graph_fetch_tx); + } + WorkerLoopWake::ModuleGraphFetch(Some(WorkerModuleGraphFetchEvent::Complete( + completion, + ))) => { let (isolate, runtime_inspector) = worker_isolate.worker_isolate_and_runtime_inspector(); let scope = pin!(v8::HandleScope::new(isolate)); @@ -3271,10 +3295,6 @@ async fn worker_main( let scope = &mut v8::ContextScope::new(scope, ctx); let global = ctx.global(scope); if let Some(outcome) = complete_worker_module_graph_fetch(scope, &completion) { - for violation in completion.csp_violations() { - let loader = state.borrow().loader.clone(); - dispatch_worker_csp_violation_event(scope, &loader, violation); - } let resume = resume_worker_module_trees(scope, pending_module_bootstrap.as_deref_mut()); flush_worker_module_fetches(scope, &state, &module_graph_fetch_tx); diff --git a/moli-renderer-v8/src/worker/thread/tests/module_csp_typed.rs b/moli-renderer-v8/src/worker/thread/tests/module_csp_typed.rs index cbcd2c75e7d..c1476082e81 100644 --- a/moli-renderer-v8/src/worker/thread/tests/module_csp_typed.rs +++ b/moli-renderer-v8/src/worker/thread/tests/module_csp_typed.rs @@ -101,7 +101,7 @@ addEventListener('securitypolicyviolation', event => events.push({ .replace("REQUESTS", &requests.to_string()) } -async fn result(mut worker: WorkerTestHandle) -> Value { +async fn console_result(worker: &mut WorkerTestHandle) -> Value { let text = timeout(TIMEOUT, async { loop { match worker @@ -119,10 +119,228 @@ async fn result(mut worker: WorkerTestHandle) -> Value { }) .await .expect("module imports must settle"); - worker.terminate_and_join(); serde_json::from_str(text.strip_prefix("log: ").expect(&text)).unwrap() } +async fn result(mut worker: WorkerTestHandle) -> Value { + let result = console_result(&mut worker).await; + worker.terminate_and_join(); + result +} + +struct ParkedModuleResponse { + url: String, + request_rx: oneshot::Receiver, + release_tx: oneshot::Sender<()>, + server: JoinHandle<()>, +} + +async fn parked_module_response(kind: &str) -> ParkedModuleResponse { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("http://{}", listener.local_addr().unwrap()); + let (request_tx, request_rx) = oneshot::channel(); + let (release_tx, release_rx) = oneshot::channel(); + let (mime, body) = match kind { + "json" => ("application/json", r#"{"answer":42}"#), + "text" => ("text/plain", "module-text"), + "javascript" => ("text/javascript", "export default 42;"), + _ => unreachable!(), + }; + let server = tokio::spawn(async move { + let (mut stream, _) = listener.accept().await.unwrap(); + let request = read_http_request_head(&mut stream).await.unwrap(); + request_tx.send(request).unwrap(); + release_rx.await.unwrap(); + let response = format!( + "HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", + body.len(), + ); + stream.write_all(response.as_bytes()).await.unwrap(); + }); + ParkedModuleResponse { + url, + request_rx, + release_tx, + server, + } +} + +fn pending_response_probe(url: &str, kind: &str, expected_violations: usize) -> String { + r#" +let returned = false; +let callerMicrotask = false; +let settled = false; +const events = []; +queueMicrotask(() => callerMicrotask = true); +addEventListener('securitypolicyviolation', event => { + events.push({directive: event.effectiveDirective, disposition: event.disposition, + native: event instanceof SecurityPolicyViolationEvent, trusted: event.isTrusted, + sourceFile: event.sourceFile, line: event.lineNumber, column: event.columnNumber}); + if (events.length === COUNT) { + console.log(JSON.stringify({stage: 'violations', returned, callerMicrotask, settled, events})); + } +}); +const pending = KIND === 'javascript' ? import(URL) : import(URL, {with: {type: KIND}}); +returned = true; +pending.then(module => { + settled = true; + console.log(JSON.stringify({stage: 'settled', value: KIND === 'json' ? module.default.answer : module.default, events: events.length})); +}, error => console.error(String(error.stack || error))); +"# + .replace("COUNT", &expected_violations.to_string()) + .replace("KIND", &serde_json::to_string(kind).unwrap()) + .replace("URL", &serde_json::to_string(url).unwrap()) +} + +#[tokio::test] +async fn worker_module_csp_initial_reports_do_not_wait_for_response() { + ensure_v8(); + for script_kind in [WorkerScriptKind::Classic, WorkerScriptKind::Module] { + for global in global_kinds() { + for kind in ["json", "text", "javascript"] { + let parked = parked_module_response(kind).await; + let import_url = format!("{}/module", parked.url); + let worker_url = format!("{}/worker.js", parked.url); + let mut worker = spawn_test_worker_with_options( + WorkerSpawnOptions::new( + pending_response_probe(&import_url, kind, 2), + worker_url.clone(), + ) + .with_global_kind(global.clone()) + .with_script_kind(script_kind) + .with_content_security_report_only_policies(vec![ + "default-src 'none'".into(), + if kind == "javascript" { + "script-src 'none'" + } else { + "connect-src 'none'" + } + .into(), + ]), + ); + timeout(TIMEOUT, parked.request_rx).await.unwrap().unwrap(); + let report = console_result(&mut worker).await; + assert_eq!(report["stage"], "violations", "{report}"); + assert_eq!(report["returned"], true); + assert_eq!(report["callerMicrotask"], true); + assert_eq!(report["settled"], false); + for event in report["events"].as_array().unwrap() { + assert_eq!(event["disposition"], "report"); + assert_eq!( + event["directive"], + if kind == "javascript" { + "script-src-elem" + } else { + "connect-src" + } + ); + assert_eq!(event["native"], true); + assert_eq!(event["trusted"], true); + assert_eq!(event["sourceFile"], worker_url); + assert!(event["line"].as_i64().unwrap() > 0); + assert!(event["column"].as_i64().unwrap() > 0); + } + parked.release_tx.send(()).unwrap(); + assert_eq!( + result(worker).await, + json!({ + "stage": "settled", "value": if kind == "text" { json!("module-text") } else { json!(42) }, "events": 2 + }) + ); + timeout(TIMEOUT, parked.server).await.unwrap().unwrap(); + } + } + } +} + +#[tokio::test] +async fn worker_module_csp_redirect_reports_do_not_wait_for_response() { + ensure_v8(); + for script_kind in [WorkerScriptKind::Classic, WorkerScriptKind::Module] { + for global in global_kinds() { + for kind in ["json", "text", "javascript"] { + let parked = parked_module_response(kind).await; + let target_url = format!("{}/module", parked.url); + let source = ModuleServer::spawn(move |_| format!( + "HTTP/1.1 302 Found\r\nLocation: {target_url}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n" + )).await; + let mut worker = spawn_test_worker_with_options( + WorkerSpawnOptions::new( + pending_response_probe(&format!("{}/redirect", source.url), kind, 1), + format!("{}/worker.js", source.url), + ) + .with_global_kind(global.clone()) + .with_script_kind(script_kind) + .with_content_security_report_only_policies(vec![ + if kind == "javascript" { + "script-src 'self'" + } else { + "connect-src 'self'" + } + .into(), + ]), + ); + timeout(TIMEOUT, parked.request_rx).await.unwrap().unwrap(); + let report = console_result(&mut worker).await; + assert_eq!(report["stage"], "violations", "{report}"); + assert_eq!(report["returned"], true); + assert_eq!(report["settled"], false); + assert_eq!(report["events"][0]["sourceFile"], ""); + assert_eq!(report["events"][0]["line"], 0); + assert_eq!(report["events"][0]["column"], 0); + parked.release_tx.send(()).unwrap(); + assert_eq!( + result(worker).await, + json!({ + "stage": "settled", "value": if kind == "text" { json!("module-text") } else { json!(42) }, "events": 1 + }) + ); + timeout(TIMEOUT, parked.server).await.unwrap().unwrap(); + assert_eq!(source.requests.lock().len(), 1); + } + } + } +} + +#[tokio::test] +async fn worker_module_csp_tasks_checkpoint_microtasks_before_import_rejection() { + ensure_v8(); + let server = ModuleServer::modules().await; + for script_kind in [WorkerScriptKind::Classic, WorkerScriptKind::Module] { + for global in global_kinds() { + let source = r#" +const order = []; +addEventListener('securitypolicyviolation', event => { + order.push(event.disposition); + queueMicrotask(() => order.push(event.disposition + '-microtask')); +}); +queueMicrotask(() => order.push('caller-microtask')); +const pending = import('./data.json', {with: {type: 'json'}}); +order.push('returned'); +pending.catch(error => { + order.push('rejected'); + console.log(JSON.stringify({order, name: error.name, native: error instanceof TypeError})); +}); +"#; + let worker = spawn_test_worker_with_options( + WorkerSpawnOptions::new(source.into(), format!("{}/worker.js", server.url)) + .with_global_kind(global) + .with_script_kind(script_kind) + .with_content_security_policies(vec!["connect-src 'none'".into()]) + .with_content_security_report_only_policies(vec!["connect-src 'none'".into()]), + ); + assert_eq!( + result(worker).await, + json!({ + "order": ["returned", "caller-microtask", "report", "report-microtask", "enforce", "enforce-microtask", "rejected"], + "name": "TypeError", "native": true, + }) + ); + } + } + assert!(server.requests.lock().is_empty()); +} + #[tokio::test] async fn worker_typed_module_csp_blocks_before_contact_and_reports_every_policy() { ensure_v8();