mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(csp): dispatch worker module violations as independent tasks
This commit is contained in:
@@ -25,6 +25,7 @@ struct Inner {
|
||||
original_url: Url,
|
||||
owner_scope: Option<crate::native_bridge::OwnerDispatchScope>,
|
||||
state: Mutex<State>,
|
||||
violation_reporter: Option<Arc<dyn Fn(ContentSecurityPolicyUrlViolation) + Send + Sync>>,
|
||||
}
|
||||
|
||||
#[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<crate::native_bridge::OwnerDispatchScope> {
|
||||
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),
|
||||
|
||||
@@ -94,7 +94,24 @@ pub(super) struct WorkerModuleGraphFetchCompletion {
|
||||
key: WorkerModuleKey,
|
||||
fetch_id: WorkerModuleGraphFetchId,
|
||||
result: Result<WorkerModuleFetchedSource, module_tree::ModuleLoadError>,
|
||||
csp_violations: Vec<ContentSecurityPolicyUrlViolation>,
|
||||
}
|
||||
|
||||
/// Module CSP reports are independent networking tasks and can arrive before a response.
|
||||
pub(super) enum WorkerModuleGraphFetchEvent {
|
||||
CspViolation(Box<ContentSecurityPolicyUrlViolation>),
|
||||
Complete(Box<WorkerModuleGraphFetchCompletion>),
|
||||
}
|
||||
|
||||
impl WorkerModuleGraphFetchEvent {
|
||||
pub(super) fn completed(
|
||||
fetch_id: WorkerModuleGraphFetchId,
|
||||
key: WorkerModuleKey,
|
||||
result: Result<WorkerModuleFetchedSource, String>,
|
||||
) -> 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<ContentSecurityPolicyUrlViolation>,
|
||||
) -> Self {
|
||||
self.csp_violations = violations;
|
||||
self
|
||||
}
|
||||
|
||||
pub(super) fn csp_violations(
|
||||
&self,
|
||||
) -> impl Iterator<Item = &ContentSecurityPolicyUrlViolation> {
|
||||
self.csp_violations.iter()
|
||||
}
|
||||
|
||||
pub(super) fn result(
|
||||
&self,
|
||||
) -> Result<&WorkerModuleFetchedSource, &module_tree::ModuleLoadError> {
|
||||
|
||||
@@ -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<String>,
|
||||
module_static_import_content_security_policies: Vec<ContentSecurityPolicy>,
|
||||
worker_global_policy: crate::content_security_policy::InheritedContentSecurityPolicy,
|
||||
completion_tx: mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
|
||||
completion_tx: mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
) {
|
||||
// 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<RefCell<WorkerGlobalState>>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
) {
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
) {
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
) {
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
) {
|
||||
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<v8::Context>,
|
||||
state: &Rc<RefCell<WorkerGlobalState>>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
) {
|
||||
let scope = pin!(v8::HandleScope::new(isolate));
|
||||
let scope = &mut scope.init();
|
||||
@@ -1010,7 +1022,7 @@ fn dispatch_worker_inspector_task(
|
||||
context: &v8::Global<v8::Context>,
|
||||
task: WorkerInspectorTask,
|
||||
state: &Rc<RefCell<WorkerGlobalState>>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
|
||||
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
) {
|
||||
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<v8::Context>,
|
||||
state: &Rc<RefCell<WorkerGlobalState>>,
|
||||
#[cfg(feature = "devtools")] module_graph_fetch_tx: &mpsc::UnboundedSender<
|
||||
WorkerModuleGraphFetchCompletion,
|
||||
>,
|
||||
#[cfg(feature = "devtools")] module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
|
||||
script_url: &str,
|
||||
rx: &mut mpsc::UnboundedReceiver<WorkerMessage>,
|
||||
pending_bootstrap_messages: &mut VecDeque<WorkerMessage>,
|
||||
@@ -1754,7 +1764,7 @@ async fn worker_main(
|
||||
mpsc::unbounded_channel::<WorkerFetchEvent>();
|
||||
let (xhr_completion_tx, mut xhr_completion_rx) = mpsc::unbounded_channel::<WorkerXhrEvent>();
|
||||
let (module_graph_fetch_tx, mut module_graph_fetch_rx) =
|
||||
mpsc::unbounded_channel::<WorkerModuleGraphFetchCompletion>();
|
||||
mpsc::unbounded_channel::<WorkerModuleGraphFetchEvent>();
|
||||
let (module_evaluation_tx, mut module_evaluation_rx) =
|
||||
mpsc::unbounded_channel::<WorkerModuleEvaluationCompletion>();
|
||||
let (websocket_event_tx, mut websocket_events) = WorkerWebSocketEvents::new();
|
||||
@@ -2156,7 +2166,7 @@ async fn worker_main(
|
||||
Message(Option<WorkerMessage>),
|
||||
Fetch(Option<WorkerFetchEvent>),
|
||||
Xhr(Option<WorkerXhrEvent>),
|
||||
ModuleGraphFetch(Option<Box<WorkerModuleGraphFetchCompletion>>),
|
||||
ModuleGraphFetch(Option<WorkerModuleGraphFetchEvent>),
|
||||
ModuleEvaluation(Option<WorkerModuleEvaluationCompletion>),
|
||||
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);
|
||||
|
||||
@@ -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<String>,
|
||||
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();
|
||||
|
||||
Reference in New Issue
Block a user