diff --git a/moli-renderer-v8/src/context_bootstrap/window_runtime/service_worker.rs b/moli-renderer-v8/src/context_bootstrap/window_runtime/service_worker.rs index 082b2124933..53896767799 100644 --- a/moli-renderer-v8/src/context_bootstrap/window_runtime/service_worker.rs +++ b/moli-renderer-v8/src/context_bootstrap/window_runtime/service_worker.rs @@ -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() diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rs index 6c1d2d713a8..aa6875b8207 100644 --- a/moli-renderer-v8/src/document_runtime/security_policy.rs +++ b/moli-renderer-v8/src/document_runtime/security_policy.rs @@ -1501,51 +1501,6 @@ impl DocumentRuntime { ) } - pub(crate) fn service_worker_registration_csp_check_for_document( - &self, - document_handle: Option, - 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, diff --git a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs index 778b6c92d70..a4612ab7c47 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs @@ -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, '_>, diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted.rs index 27af0ddf27a..2373021aeb0 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted.rs @@ -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; diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_csp.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_csp.rs new file mode 100644 index 00000000000..63d7104aaa8 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_csp.rs @@ -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", + "", + ), + ( + "/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(); +} 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 c9150e1764a..5bd3dc208ab 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 @@ -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![ diff --git a/moli-renderer-v8/src/worker/global_scope/service_worker_container.rs b/moli-renderer-v8/src/worker/global_scope/service_worker_container.rs index 6cbb8aa2b6f..716d091fbf1 100644 --- a/moli-renderer-v8/src/worker/global_scope/service_worker_container.rs +++ b/moli-renderer-v8/src/worker/global_scope/service_worker_container.rs @@ -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.