fix(service-worker): enforce registration client CSP before queuing jobs

Check the container owner's current worker-src policy, including fallback
and report-only policies, after argument and Trusted Types conversion.
Reject blocked Window and Worker registrations with SecurityError before
watchers, registration jobs or network requests, including warm reuse.

Queue native CSP violations on the exact owning document or worker; retain
the ServiceWorker response's separate policy for its scripts and imports.
Validate Window script and scope origins against its inherited storage
origin before reporting CSP violations.

Create Window registration promises and errors in the container realm,
including methods borrowed across Windows.
This commit is contained in:
ldm0
2026-11-20 22:48:03 +08:00
parent 64d1af4951
commit 968d025ece
7 changed files with 421 additions and 150 deletions
@@ -314,6 +314,12 @@ pub(in crate::context_bootstrap) fn navigator_service_worker_register_callback<'
) {
return;
}
// The container owns the returned promise and its rejection values even
// when a register method from another Window is borrowed.
let Some(context) = args.this().get_creation_context(scope) else {
return;
};
let scope = &mut v8::ContextScope::new(scope, context);
let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {
let Some(resolver) = v8::PromiseResolver::new(scope) else {
return;
@@ -425,6 +431,8 @@ pub(in crate::context_bootstrap) fn navigator_service_worker_register_callback<'
rv.set(promise.into());
return;
}
// Check the container owner's current policy after author conversions,
// before any job (including reuse of an existing registration) is queued.
if host
.check_service_worker_registration_csp_for_owner(scope, owner, &script_url)
.blocks_request()
@@ -1501,51 +1501,6 @@ impl DocumentRuntime {
)
}
pub(crate) fn service_worker_registration_csp_check_for_document(
&self,
document_handle: Option<DomHandle>,
document_url: &Url,
document_origin: Option<&Url>,
policy_container: &DocumentPolicyContainer,
script_url: &Url,
) -> DocumentContentSecurityPolicyCheck {
if self.bypass_content_security_policy() {
return DocumentContentSecurityPolicyCheck {
report_only_violations: Vec::new(),
enforced_violations: Vec::new(),
};
}
let policies = self.document_content_security_policies_for_optional_document(
document_handle,
&policy_container.response_content_security_policies,
&policy_container.content_security_reporting_endpoints,
);
let kind = ContentSecurityPolicyResourceKind::WorkerConstructor;
let redirect = ContentSecurityPolicyRedirectStatus::NoRedirect;
let enforced_violation = document_url_policy_violation_from_document_policies(
policies,
document_url,
document_origin,
script_url,
kind,
redirect,
ContentSecurityPolicyDisposition::Enforce,
);
let report_only_violation = document_url_policy_violation(
&policy_container.response_content_security_report_only_policies,
&policy_container.content_security_reporting_endpoints,
document_url,
script_url,
kind,
redirect,
ContentSecurityPolicyDisposition::Report,
);
DocumentContentSecurityPolicyCheck {
report_only_violations: report_only_violation.into_iter().collect(),
enforced_violations: enforced_violation.into_iter().collect(),
}
}
pub(crate) fn document_connect_policy_snapshot_for_document(
&self,
document_handle: Option<DomHandle>,
@@ -4,9 +4,9 @@ use crate::types::SubresourceResourceType;
use crate::{
content_security_policy::{
ContentSecurityPolicyDisposition, ContentSecurityPolicyNonUrlKind,
ContentSecurityPolicyRedirectStatus, ContentSecurityPolicyScriptElementRequest,
ContentSecurityPolicyStyleElementRequest, TrustedTypesForScriptRequirements,
current_script_violation_location,
ContentSecurityPolicyRedirectStatus, ContentSecurityPolicyResourceKind,
ContentSecurityPolicyScriptElementRequest, ContentSecurityPolicyStyleElementRequest,
TrustedTypesForScriptRequirements, current_script_violation_location,
},
context_bootstrap::CHILD_BROWSING_CONTEXT_HANDLE_SLOT,
document_runtime::{
@@ -838,43 +838,6 @@ impl PageScriptHost {
unsafe { &*self.document_runtime }.cross_origin_isolated()
}
pub(crate) fn check_service_worker_registration_csp_for_owner(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
owner: OwnerDispatchScope,
script_url: &url::Url,
) -> DocumentCspOutcome {
let Some(document) = self.owner_document_policy_snapshot(owner) else {
return DocumentCspOutcome::Allowed;
};
let origin = self
.window_document_origin(owner)
.and_then(|origin| url::Url::parse(&origin).ok());
// SAFETY: this host and the DocumentRuntime are owned by the same ScriptVm.
let (report_only, enforced) = unsafe { &*self.document_runtime }
.service_worker_registration_csp_check_for_document(
document.document_handle,
&document.document_url,
origin.as_ref(),
&document.policy_container,
script_url,
)
.into_violations();
let host_ptr: *mut Self = self;
if let Some(violation) = report_only.into_iter().next() {
self.dispatch_content_security_policy_violation_event_for_owner_best_effort(
scope, host_ptr, owner, &violation,
);
}
let Some(violation) = enforced.into_iter().next() else {
return DocumentCspOutcome::Allowed;
};
self.dispatch_content_security_policy_violation_event_for_owner_best_effort(
scope, host_ptr, owner, &violation,
);
DocumentCspOutcome::Blocked(violation)
}
pub(crate) fn window_cross_origin_isolated(&self, owner: OwnerDispatchScope) -> bool {
self.window_policy_container(owner).is_some_and(|policy| {
policy.allows_cross_origin_isolation()
@@ -1385,6 +1348,28 @@ impl PageScriptHost {
}
}
pub(crate) fn check_service_worker_registration_csp_for_owner(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
owner: OwnerDispatchScope,
script_url: &Url,
) -> DocumentCspOutcome {
let Some(document) = self.owner_document_policy_snapshot(owner) else {
return DocumentCspOutcome::Allowed;
};
let Some(policy) = self.document_connect_policy_snapshot_for_owner(owner) else {
return DocumentCspOutcome::Allowed;
};
let check = policy
.for_resource_kind(ContentSecurityPolicyResourceKind::WorkerConstructor)
.check_url(
&document.document_url,
script_url,
ContentSecurityPolicyRedirectStatus::NoRedirect,
);
self.queue_document_connect_csp_check_with_script_location(scope, owner, check)
}
pub(crate) fn check_document_connect_csp_for_owner_with_redirect_status<'s>(
&mut self,
scope: &mut v8::PinScope<'s, '_>,
@@ -14,6 +14,7 @@ mod platform_compat;
mod popup_window;
mod script_security;
mod service_worker_clients;
mod service_worker_csp;
mod service_worker_events;
mod service_worker_popup;
mod service_worker_registration;
@@ -0,0 +1,368 @@
use super::*;
#[tokio::test]
async fn service_worker_register_csp_uses_worker_response_policy() {
const PROBE: &str = r#"
let outcome, violation;
const complete = () => {
if (outcome && violation) postMessage(outcome + '|' + violation);
};
addEventListener('securitypolicyviolation', e => {
violation = [e.effectiveDirective, e.disposition, e.isTrusted, e.target === self].join(':');
complete();
});
navigator.serviceWorker.register('sw.js').then(
() => { outcome = 'resolved'; complete(); },
e => { outcome = e.name + ':' + (e instanceof DOMException); complete(); }
);
"#;
let (base, server) = spawn_service_worker_response_server_with_headers(vec![
(
"/app/blocked-worker.js",
"text/javascript",
vec![("Content-Security-Policy", "worker-src 'none'")],
PROBE,
),
(
"/app/report-worker.js",
"text/javascript",
vec![("Content-Security-Policy-Report-Only", "worker-src 'none'")],
PROBE,
),
(
"/app/sw.js",
"text/javascript",
Vec::new(),
"self.oninstall = e => e.waitUntil(skipWaiting());",
),
])
.await;
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
let (mut vm, runtime) = new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
&format!("{base}/app/page.html"),
&loader,
);
vm.set_response_content_security_policies(&["worker-src 'self'".to_owned()]);
vm.eval(r#"
globalThis.__workerCspDone = false;
(async () => {
const results = [];
for (const script of ['blocked-worker.js', 'report-worker.js']) {
const worker = new Worker(script);
results.push(await new Promise(resolve => { worker.onmessage = e => resolve(e.data); }));
worker.terminate();
}
globalThis.__workerCspResult = results.join(',');
})().catch(e => { globalThis.__workerCspResult = 'error:' + e; })
.finally(() => { globalThis.__workerCspDone = true; });
"#).unwrap();
drain_service_worker_test_until_eval_equals(
&mut vm,
&runtime,
&loader,
"String(__workerCspDone)",
"true",
)
.await;
assert_eq!(
vm.eval("__workerCspResult").unwrap(),
"SecurityError:true|worker-src:enforce:true:true,resolved|worker-src:report:true:true"
);
server.await.unwrap();
}
#[tokio::test]
async fn service_worker_register_csp_blocks_before_fetch_or_registration() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
for (policy, kind) in [
("worker-src 'none'", "classic"),
("worker-src 'none'", "module"),
("child-src 'none'; script-src 'self'", "classic"),
("script-src 'none'", "classic"),
("default-src 'none'", "module"),
] {
// Keep a listener open so a mistaken fetch remains observable, rather
// than turning into a network error that resembles a CSP rejection.
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
let (mut vm, runtime) =
new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
&format!("{base}/app/page.html"),
&loader,
);
vm.set_response_content_security_policies(&[policy.to_owned()]);
vm.eval(&format!(
"globalThis.__kind = {}",
serde_json::to_string(kind).unwrap()
))
.unwrap();
vm.eval(r#"
globalThis.__cspEvents = [];
document.addEventListener('securitypolicyviolation', e => {
__cspEvents.push([e.effectiveDirective, e.disposition,
e.isTrusted, e.target === document, e.blockedURI.endsWith('/app/sw.js')].join(':'));
});
globalThis.__cspRegisterDone = false;
navigator.serviceWorker.register('sw.js', {type: __kind}).then(
() => { globalThis.__cspResult = 'resolved'; },
e => { globalThis.__cspResult = [e.name, e instanceof DOMException, __cspEvents.length].join(':'); }
).then(async () => {
globalThis.__cspRegistrations = (await navigator.serviceWorker.getRegistrations()).length;
globalThis.__cspRegisterDone = true;
});
"#).unwrap();
drain_service_worker_test_until_eval_equals(
&mut vm,
&runtime,
&loader,
"String(__cspRegisterDone && __cspEvents.length === 1)",
"true",
)
.await;
assert_eq!(
vm.eval("__cspResult + '|' + __cspEvents + '|' + __cspRegistrations")
.unwrap(),
"SecurityError:true:0|worker-src:enforce:true:true:true|0",
"{policy}, {kind}"
);
assert!(
tokio::time::timeout(std::time::Duration::from_millis(20), listener.accept())
.await
.is_err(),
"blocked registration fetched its script: {policy}, {kind}"
);
}
}
#[tokio::test]
async fn service_worker_register_csp_rechecks_existing_registration_and_type_changes() {
let (base, server) = spawn_service_worker_response_server(vec![(
"/app/sw.js",
"text/javascript",
"self.addEventListener('install', e => e.waitUntil(skipWaiting()));",
)])
.await;
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
let (mut vm, runtime) = new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
&format!("{base}/app/page.html"),
&loader,
);
vm.eval(r#"
globalThis.__warmDone = false;
(async () => {
const registration = await navigator.serviceWorker.register('sw.js');
await __moliTestActivatedServiceWorker();
const meta = document.createElement('meta');
meta.httpEquiv = 'Content-Security-Policy'; meta.content = "worker-src 'none'";
document.head.append(meta);
const results = [];
for (const [script, type] of [['sw.js', 'classic'], ['sw.js', 'module'], ['other.js', 'classic']]) {
results.push(await navigator.serviceWorker.register(script, {type}).then(
() => 'resolved', e => e.name + ':' + (e instanceof DOMException)));
}
const retained = await navigator.serviceWorker.getRegistration();
globalThis.__warmResult = results.join('|') + '|' + (retained === registration) + '|' + registration.active.state;
})().catch(e => { globalThis.__warmResult = 'error:' + e; })
.finally(() => { globalThis.__warmDone = true; });
"#).unwrap();
drain_service_worker_test_until_eval_equals(
&mut vm,
&runtime,
&loader,
"String(__warmDone)",
"true",
)
.await;
assert_eq!(
vm.eval("__warmResult").unwrap(),
"SecurityError:true|SecurityError:true|SecurityError:true|true|activated"
);
server.await.unwrap();
}
#[tokio::test]
async fn service_worker_register_csp_uses_container_owner_and_queues_its_event() {
let (base, server) = spawn_service_worker_response_server(vec![
(
"/app/child.html",
"text/html",
"<!doctype html><head></head><body>",
),
(
"/app/sw.js",
"text/javascript",
"self.addEventListener('install', e => e.waitUntil(skipWaiting()));",
),
])
.await;
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
let (mut vm, runtime) = new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
&format!("{base}/app/page.html"),
&loader,
);
vm.eval(&format!(
"globalThis.__scriptURL = {}",
serde_json::to_string(&format!("{base}/app/sw.js")).unwrap()
))
.unwrap();
vm.eval(r#"
globalThis.__ownerDone = false;
(async () => {
const frame = document.createElement('iframe');
const loaded = new Promise(resolve => { frame.onload = resolve; });
frame.src = '/app/child.html';
document.body.append(frame); await loaded;
const child = frame.contentWindow;
globalThis.__ownerEvents = [];
for (const [label, doc] of [['top', document], ['child', child.document]]) {
doc.addEventListener('securitypolicyviolation', e => {
if (e.target === doc) __ownerEvents.push(label + ':' + e.isTrusted);
});
}
const restrict = doc => {
const meta = doc.createElement('meta');
meta.httpEquiv = 'Content-Security-Policy'; meta.content = "worker-src 'none'";
doc.head.append(meta);
};
const register = navigator.serviceWorker.register;
restrict(document);
const initial = register.call(child.navigator.serviceWorker, __scriptURL);
const realms = [initial instanceof child.Promise && !(initial instanceof Promise)];
const registration = await initial;
await __moliTestActivatedServiceWorker(child.navigator.serviceWorker);
restrict(child.document);
const childPromise = register.call(child.navigator.serviceWorker, __scriptURL);
realms.push(childPromise instanceof child.Promise && !(childPromise instanceof Promise));
const childError = await childPromise
.then(() => 'resolved', e => e.name + ':' + (e instanceof child.DOMException));
const topPromise = child.navigator.serviceWorker.register.call(navigator.serviceWorker, __scriptURL);
realms.push(topPromise instanceof Promise && !(topPromise instanceof child.Promise));
const topError = await topPromise
.then(() => 'resolved', e => e.name + ':' + (e instanceof DOMException));
globalThis.__ownerResult = [registration.scope.endsWith('/app/'), childError, topError, realms.every(Boolean)].join('|');
})().catch(e => { globalThis.__ownerResult = 'error:' + e; })
.finally(() => { globalThis.__ownerDone = true; });
"#).unwrap();
drain_service_worker_test_until_eval_equals(
&mut vm,
&runtime,
&loader,
"String(__ownerDone && __ownerEvents.length === 2)",
"true",
)
.await;
assert_eq!(
vm.eval("__ownerResult + '|' + __ownerEvents.sort()")
.unwrap(),
"true|SecurityError:true|SecurityError:true|true|child:true,top:true"
);
server.await.unwrap();
}
#[tokio::test]
async fn service_worker_register_csp_observes_policy_added_during_author_conversion() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
for trusted_types in [false, true] {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
let (mut vm, runtime) =
new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
&format!("{base}/app/page.html"),
&loader,
);
if trusted_types {
vm.set_response_content_security_policies(&[
"require-trusted-types-for 'script'".to_owned()
]);
}
vm.eval(&format!("globalThis.__useTT = {trusted_types}"))
.unwrap();
vm.eval(r#"
const restrict = () => {
const meta = document.createElement('meta');
meta.httpEquiv = 'Content-Security-Policy'; meta.content = "worker-src 'none'";
document.head.append(meta);
};
if (__useTT) trustedTypes.createPolicy('default', {createScriptURL: value => { restrict(); return value; }});
const options = __useTT ? {} : {get scope() { restrict(); return './'; }};
globalThis.__conversionDone = false;
navigator.serviceWorker.register('sw.js', options).then(
() => { globalThis.__conversionResult = 'resolved'; },
e => { globalThis.__conversionResult = e.name + ':' + (e instanceof DOMException); }
).finally(() => { globalThis.__conversionDone = true; });
"#).unwrap();
drain_service_worker_test_until_eval_equals(
&mut vm,
&runtime,
&loader,
"String(__conversionDone)",
"true",
)
.await;
assert_eq!(
vm.eval("__conversionResult").unwrap(),
"SecurityError:true",
"TT={trusted_types}"
);
assert!(
tokio::time::timeout(std::time::Duration::from_millis(20), listener.accept())
.await
.is_err()
);
}
}
#[tokio::test]
async fn service_worker_register_csp_reports_each_policy_without_inheriting_it_into_imports() {
let (base, server) = spawn_service_worker_response_server(vec![
(
"/app/sw.js",
"text/javascript",
"importScripts('dependency.js'); self.oninstall = e => e.waitUntil(skipWaiting());",
),
(
"/app/dependency.js",
"text/javascript",
"self.imported = true;",
),
])
.await;
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
let (mut vm, runtime) = new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
&format!("{base}/app/page.html"),
&loader,
);
vm.set_response_content_security_policies(&[
"worker-src 'self'; child-src 'none'; script-src 'none'; default-src 'none'".to_owned(),
]);
vm.set_response_content_security_report_only_policies(&[
"worker-src 'none'".to_owned(),
"child-src 'none'".to_owned(),
]);
vm.eval(r#"
globalThis.__reports = [];
document.addEventListener('securitypolicyviolation', e => {
__reports.push([e.effectiveDirective, e.disposition, e.isTrusted, e.target === document].join(':'));
});
globalThis.__reportDone = false;
(async () => {
await navigator.serviceWorker.register('sw.js');
const registration = await __moliTestActivatedServiceWorker();
globalThis.__reportResult = registration.active.state;
})().catch(e => { globalThis.__reportResult = 'error:' + e; })
.finally(() => { globalThis.__reportDone = true; });
"#).unwrap();
drain_service_worker_test_until_eval_equals(
&mut vm,
&runtime,
&loader,
"String(__reportDone && __reports.length === 2)",
"true",
)
.await;
assert_eq!(
vm.eval("__reportResult + '|' + __reports").unwrap(),
"activated|worker-src:report:true:true,worker-src:report:true:true"
);
server.await.unwrap();
}
@@ -2879,69 +2879,6 @@ async fn navigator_service_worker_url_arguments_follow_webidl_and_origin_rules()
.expect("service worker URL argument script server should finish");
}
#[tokio::test]
async fn service_worker_register_csp_blocks_before_fetch_or_registration() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
for (policy, kind) in [
("worker-src 'none'", "classic"),
("worker-src 'none'", "module"),
("child-src 'none'; script-src 'self'", "classic"),
("script-src 'none'", "classic"),
("default-src 'none'", "module"),
] {
// Keep a listener open so a mistaken fetch remains observable, rather
// than turning into a network error that resembles a CSP rejection.
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
let (mut vm, runtime) =
new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
&format!("{base}/app/page.html"),
&loader,
);
vm.set_response_content_security_policies(&[policy.to_owned()]);
vm.eval(&format!(
"globalThis.__kind = {}",
serde_json::to_string(kind).unwrap()
))
.unwrap();
vm.eval(r#"
globalThis.__cspEvents = [];
document.addEventListener('securitypolicyviolation', e => {
__cspEvents.push([e.effectiveDirective, e.disposition,
e.isTrusted, e.target === document, e.blockedURI.endsWith('/app/sw.js')].join(':'));
});
globalThis.__cspRegisterDone = false;
navigator.serviceWorker.register('sw.js', {type: __kind}).then(
() => { globalThis.__cspResult = 'resolved'; },
e => { globalThis.__cspResult = [e.name, e instanceof DOMException, __cspEvents.length].join(':'); }
).then(async () => {
globalThis.__cspRegistrations = (await navigator.serviceWorker.getRegistrations()).length;
globalThis.__cspRegisterDone = true;
});
"#).unwrap();
drain_service_worker_test_until_eval_equals(
&mut vm,
&runtime,
&loader,
"String(__cspRegisterDone && __cspEvents.length === 1)",
"true",
)
.await;
assert_eq!(
vm.eval("__cspResult + '|' + __cspEvents + '|' + __cspRegistrations")
.unwrap(),
"SecurityError:true:0|worker-src:enforce:true:true:true|0",
"{policy}, {kind}"
);
assert!(
tokio::time::timeout(std::time::Duration::from_millis(20), listener.accept())
.await
.is_err(),
"blocked registration fetched its script: {policy}, {kind}"
);
}
}
#[tokio::test]
async fn navigator_service_worker_update_check_preserves_mime_security_error() {
let (base_url, server) = spawn_service_worker_response_server_with_headers(vec![
@@ -1,6 +1,9 @@
//! Worker-owned ServiceWorkerContainer jobs and realm-local registration objects.
use super::*;
use crate::content_security_policy::{
ContentSecurityPolicyDisposition, ContentSecurityPolicyResourceKind,
};
use crate::service_worker_runtime::{
ServiceWorkerClientUrlError, ServiceWorkerRegisterJob, ServiceWorkerRegistrationRequest,
ServiceWorkerRegistrationSnapshot, ServiceWorkerUpdateViaCache,
@@ -92,7 +95,7 @@ pub(crate) fn try_worker_service_worker_register<'s>(
update_via_cache: ServiceWorkerUpdateViaCache,
rv: &mut v8::ReturnValue<'s, v8::Value>,
) -> bool {
let Some(state) = get_worker_state(scope) else {
let Some(worker_state) = get_worker_state(scope) else {
return false;
};
let requirements = worker_trusted_types_for_script_requirements(scope).unwrap_or_default();
@@ -110,7 +113,7 @@ pub(crate) fn try_worker_service_worker_register<'s>(
};
rv.set(resolver.get_promise(scope).into());
let request = {
let mut state = state.borrow_mut();
let state = worker_state.borrow();
let Some(document_url) = state.current_script_url.clone() else {
reject(
scope,
@@ -175,6 +178,20 @@ pub(crate) fn try_worker_service_worker_register<'s>(
);
return true;
};
drop(state);
if let Some(message) = super::content_security_policy::check_worker_request_csp(
scope,
&worker_state,
&document_url,
&script_url,
ContentSecurityPolicyResourceKind::WorkerConstructor,
"ServiceWorkerContainer.register",
ContentSecurityPolicyDisposition::Enforce,
) {
reject(scope, resolver, &message, Some("SecurityError"));
return true;
}
let mut state = worker_state.borrow_mut();
let storage_key = state.storage_key.serialized_storage_key();
// Subscribe before starting the job. The owner queues the installing
// snapshot, promise result, and updatefound as separate worker tasks.