From 79fac494decfbcc0b46fd6576a9fb65b1a183fe8 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sun, 1 Nov 2026 15:26:47 +0800 Subject: [PATCH] fix(cache): enforce opaque response policies on cache reads --- .../window_runtime/navigator.rs | 13 + .../navigator/cache_response_policy.rs | 125 +++++++ .../src/cross_origin_isolation.rs | 54 ++- moli-renderer-v8/src/document_runtime.rs | 2 + .../src/document_runtime/security_policy.rs | 2 + .../context_host/child_frames.rs | 7 + .../context_host/child_frames/registry.rs | 3 + .../context_host/workers/registration.rs | 4 + moli-renderer-v8/src/network_host.rs | 2 +- .../src/network_host/request_scope.rs | 7 + moli-renderer-v8/src/network_host/response.rs | 2 +- .../src/network_host/response/cors.rs | 243 +++++++++++-- .../script_vm/tests/cache_response_policy.rs | 339 ++++++++++++++++++ moli-renderer-v8/src/script_vm/tests/mod.rs | 1 + .../src/service_worker_runtime/host.rs | 4 + .../src/shared_worker_runtime/loading.rs | 4 + moli-renderer-v8/src/types.rs | 4 + .../src/worker/global_scope/mod.rs | 3 +- .../src/worker/global_scope/state.rs | 6 + moli-renderer-v8/src/worker/mod.rs | 5 +- .../thread/tests/network/credentialless.rs | 1 + 21 files changed, 786 insertions(+), 45 deletions(-) create mode 100644 moli-renderer-v8/src/context_bootstrap/window_runtime/navigator/cache_response_policy.rs create mode 100644 moli-renderer-v8/src/script_vm/tests/cache_response_policy.rs diff --git a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs index 1ed3c92ebd1..85f8d909478 100644 --- a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs +++ b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs @@ -32,6 +32,7 @@ use crate::webidl; mod bucket_maintenance; mod cache_add; mod cache_query; +mod cache_response_policy; mod cache_results; use moli_storage_service::StorageBucketCacheName; mod legacy_storage_quota; @@ -1305,6 +1306,10 @@ fn storage_bucket_cache_storage_match_callback<'s>( }); match matched { Some(Some(Some(response))) => { + if let Err(message) = cache_response_policy::validate(scope, &response) { + reject_type_error(scope, resolver, message); + return; + } let Some(response) = build_storage_bucket_cached_response_object(scope, response) else { reject_type_error( @@ -1769,6 +1774,10 @@ fn storage_bucket_cache_match_callback<'s>( }); match matched { Some(Some(Some(response))) => { + if let Err(message) = cache_response_policy::validate(scope, &response) { + reject_type_error(scope, resolver, message); + return; + } let Some(response) = build_storage_bucket_cached_response_object(scope, response) else { reject_type_error(scope, resolver, "Cache.match failed to build a Response."); @@ -1830,6 +1839,10 @@ fn storage_bucket_cache_match_all_callback<'s>( Some(Some(matches)) => { let mut values = Vec::with_capacity(matches.len()); for matched in matches { + if let Err(message) = cache_response_policy::validate(scope, &matched.response) { + reject_type_error(scope, resolver, message); + return; + } let Some(response) = build_storage_bucket_cached_response_object(scope, matched.response) else { diff --git a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator/cache_response_policy.rs b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator/cache_response_policy.rs new file mode 100644 index 00000000000..e48fae3df1c --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator/cache_response_policy.rs @@ -0,0 +1,125 @@ +//! Cache reads apply the policies of the receiver's relevant settings object. +use super::*; +use crate::cross_origin_isolation::DocumentIsolationPolicy; +use crate::network_host::check_opaque_response_policy; +use crate::types::SubresourcePolicyContext; +use moli_url::WebOrigin; +use url::Url; + +struct Environment { + origin: WebOrigin, + url: Url, + policy: SubresourcePolicyContext, +} + +fn environment(scope: &mut v8::PinScope<'_, '_>) -> Option { + if let Some(policy) = crate::worker::worker_subresource_policy_context(scope) { + return Some(Environment { + origin: crate::worker::worker_global_origin(scope)?, + url: crate::worker::worker_current_script_url(scope)?, + policy, + }); + } + let context = scope.get_current_context(); + let host_ptr = crate::util::context_host_ptr_from_context_slot(context)?; + // The current callback owns this native host. Policy lookup does not + // execute JS or grant the receiver a replacement Window's task authority. + let host = unsafe { &*host_ptr }; + if let Some(identity) = host.window_execution_context_identity_for_v8_context(scope, context) + && host.window_execution_context_identity_is_current(identity) + { + let owner = identity.dispatch_scope(); + let (document, policy) = match owner { + crate::native_bridge::OwnerDispatchScope::Top => ( + host.document_handle(), + SubresourcePolicyContext::from_document_policy(host.document_policy_container()), + ), + crate::native_bridge::OwnerDispatchScope::Child(handle) => ( + host.child_browsing_context_document_handle(handle)?, + host.frame_owner_current_child_snapshot(handle)? + .settings + .subresource_policy_context, + ), + crate::native_bridge::OwnerDispatchScope::LightweightPopup(id) => ( + host.lightweight_popup_document_handle(id)?, + SubresourcePolicyContext::from_document_policy( + host.lightweight_popup_policy_container(id)?, + ), + ), + }; + return Some(Environment { + origin: WebOrigin::from_serialized(&host.window_document_origin(owner)?), + url: host.dom_host().document_url_for_handle(document)?.clone(), + policy, + }); + } + // Cache's existing lifecycle guard rejects retired Window receivers before + // policy evaluation; never borrow a replacement document's settings. + None +} + +fn report( + scope: &mut v8::PinScope<'_, '_>, + report_type: &str, + owner: &Environment, + blocked_url: &Url, + disposition: &str, +) { + let mut blocked_url = blocked_url.clone(); + let _ = blocked_url.set_username(""); + let _ = blocked_url.set_password(None); + blocked_url.set_fragment(None); + crate::context_bootstrap::notify_reporting_observers( + scope, + report_type, + owner.url.as_str(), + serde_json::json!({"blockedURL":blocked_url.as_str(),"type":"corp","disposition":disposition,"destination":""}), + ); +} + +pub(super) fn validate( + scope: &mut v8::PinScope<'_, '_>, + response: &StorageBucketCachedResponse, +) -> Result<(), &'static str> { + // Opaque-redirect and other filtered response types are not subjected to + // the Cache match algorithm's opaque-response CORP check. + if response.head.metadata.response_type != moli_fetch_types::FetchResponseType::Opaque { + return Ok(()); + } + let owner = environment(scope).ok_or("Cache response settings are unavailable.")?; + let url = response + .head + .metadata + .final_url() + .ok_or("Cache entry has no internal response URL.")?; + let report_only = check_opaque_response_policy( + &owner.origin, + url, + &response.head.headers, + response.head.metadata.request_include_credentials, + owner.policy.cross_origin_embedder_policy_report_only, + DocumentIsolationPolicy::None, + ); + if report_only.is_err_and(|violation| violation.is_due_to_coep()) { + report(scope, "coep", &owner, url, "reporting"); + } + match check_opaque_response_policy( + &owner.origin, + url, + &response.head.headers, + response.head.metadata.request_include_credentials, + owner.policy.cross_origin_embedder_policy, + owner.policy.document_isolation_policy, + ) { + Ok(()) => Ok(()), + Err(violation) => { + if violation.is_due_to_coep() { + report(scope, "coep", &owner, url, "enforce"); + } + if violation.is_due_to_dip() { + report(scope, "dip", &owner, url, "enforce"); + } + Err("Cache response was blocked by Cross-Origin-Resource-Policy.") + } + } +} diff --git a/moli-renderer-v8/src/cross_origin_isolation.rs b/moli-renderer-v8/src/cross_origin_isolation.rs index 5386d5ec540..14c8f581f4f 100644 --- a/moli-renderer-v8/src/cross_origin_isolation.rs +++ b/moli-renderer-v8/src/cross_origin_isolation.rs @@ -44,7 +44,20 @@ pub(crate) fn response_headers_enable_coop_coep_isolation( pub(crate) fn cross_origin_embedder_policy_from_headers( headers: &[(String, Vec)], ) -> CrossOriginEmbedderPolicy { - match response_header_policy_value(headers, "cross-origin-embedder-policy").as_deref() { + cross_origin_embedder_policy_from_header(headers, "cross-origin-embedder-policy") +} + +pub(crate) fn cross_origin_embedder_policy_report_only_from_headers( + headers: &[(String, Vec)], +) -> CrossOriginEmbedderPolicy { + cross_origin_embedder_policy_from_header(headers, "cross-origin-embedder-policy-report-only") +} + +fn cross_origin_embedder_policy_from_header( + headers: &[(String, Vec)], + name: &str, +) -> CrossOriginEmbedderPolicy { + match response_header_policy_value(headers, name).as_deref() { Some("require-corp") => CrossOriginEmbedderPolicy::RequireCorp, Some("credentialless") => CrossOriginEmbedderPolicy::Credentialless, _ => CrossOriginEmbedderPolicy::None, @@ -214,4 +227,43 @@ mod tests { DocumentIsolationPolicy::None ); } + + #[test] + fn report_only_embedder_policy_does_not_grant_isolation_or_omit_credentials() { + let headers = vec![ + ( + "Cross-Origin-Opener-Policy".to_owned(), + b"same-origin".to_vec(), + ), + ( + "Cross-Origin-Embedder-Policy-Report-Only".to_owned(), + b"credentialless; report-to=\"coep\"".to_vec(), + ), + ]; + let url = Url::parse("https://example.test/").unwrap(); + let container = + crate::document_runtime::DocumentPolicyContainer::from_navigation_response_headers( + &headers, &url, + ); + let policy = crate::types::SubresourcePolicyContext::from_document_policy(&container); + assert_eq!( + policy.cross_origin_embedder_policy_report_only, + CrossOriginEmbedderPolicy::Credentialless + ); + assert_eq!( + policy.cross_origin_embedder_policy, + CrossOriginEmbedderPolicy::None + ); + assert!(!policy.cross_origin_isolated); + assert!(!response_headers_enable_cross_origin_isolation( + &url, &headers + )); + assert_eq!( + policy.network_credentials_mode( + moli_fetch::RequestMode::NoCors, + moli_fetch::RequestCredentialsMode::Include + ), + moli_fetch::RequestCredentialsMode::Include + ); + } } diff --git a/moli-renderer-v8/src/document_runtime.rs b/moli-renderer-v8/src/document_runtime.rs index 4be499a4181..2166e2b3587 100644 --- a/moli-renderer-v8/src/document_runtime.rs +++ b/moli-renderer-v8/src/document_runtime.rs @@ -659,6 +659,8 @@ pub(crate) struct DocumentPolicyContainer { pub(crate) referrer_policy: Option, pub(crate) cross_origin_embedder_policy: crate::cross_origin_isolation::CrossOriginEmbedderPolicy, + pub(crate) cross_origin_embedder_policy_report_only: + crate::cross_origin_isolation::CrossOriginEmbedderPolicy, pub(crate) document_isolation_policy: crate::cross_origin_isolation::DocumentIsolationPolicy, pub(crate) cross_origin_isolated: bool, /// The response requested a COOP+COEP isolated group. Keep this separate diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rs index 90e0e0682d3..97cb61d2743 100644 --- a/moli-renderer-v8/src/document_runtime/security_policy.rs +++ b/moli-renderer-v8/src/document_runtime/security_policy.rs @@ -429,6 +429,8 @@ impl DocumentPolicyContainer { referrer_policy: crate::referrer_policy::response_referrer_policy_from_headers(headers), cross_origin_embedder_policy: crate::cross_origin_isolation::cross_origin_embedder_policy_from_headers(headers), + cross_origin_embedder_policy_report_only: + crate::cross_origin_isolation::cross_origin_embedder_policy_report_only_from_headers(headers), document_isolation_policy: crate::cross_origin_isolation::document_isolation_policy_from_headers(headers), cross_origin_isolated: diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frames.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frames.rs index cb75213dd0a..b4f1a874e5d 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/child_frames.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/child_frames.rs @@ -445,6 +445,9 @@ impl ChildBrowsingContextEntry { self.document_policy_container.referrer_policy = policy_container.referrer_policy.clone(); self.document_policy_container.cross_origin_embedder_policy = policy_container.cross_origin_embedder_policy; + self.document_policy_container + .cross_origin_embedder_policy_report_only = + policy_container.cross_origin_embedder_policy_report_only; self.document_policy_container.document_isolation_policy = policy_container.document_isolation_policy; self.document_policy_container.cross_origin_isolated = @@ -497,6 +500,10 @@ impl ChildBrowsingContextEntry { snapshot.policy_container.referrer_policy.clone(); self.document_policy_container.cross_origin_embedder_policy = snapshot.policy_container.cross_origin_embedder_policy; + self.document_policy_container + .cross_origin_embedder_policy_report_only = snapshot + .policy_container + .cross_origin_embedder_policy_report_only; self.document_policy_container.document_isolation_policy = snapshot.policy_container.document_isolation_policy; self.document_policy_container.cross_origin_isolated = diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rs index 7f9d8a52d9b..984fdcb4aeb 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rs @@ -536,6 +536,9 @@ impl PageScriptHost { cross_origin_embedder_policy: refresh_policy_source .map(|policy| policy.cross_origin_embedder_policy) .unwrap_or_default(), + cross_origin_embedder_policy_report_only: refresh_policy_source + .map(|policy| policy.cross_origin_embedder_policy_report_only) + .unwrap_or_default(), document_isolation_policy: refresh_policy_source .map(|policy| policy.document_isolation_policy) .unwrap_or_default(), diff --git a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs index 16b68cc98ce..e48ff4989ce 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs @@ -1352,6 +1352,10 @@ fn dedicated_worker_policy_context_from_headers( SubresourcePolicyContext { cross_origin_embedder_policy: crate::cross_origin_isolation::cross_origin_embedder_policy_from_headers(headers), + cross_origin_embedder_policy_report_only: + crate::cross_origin_isolation::cross_origin_embedder_policy_report_only_from_headers( + headers, + ), // Chromium's DedicatedWorkerHost currently keeps Document-Isolation-Policy // aligned with the creator while deriving the worker COEP from the script response. document_isolation_policy: creator_policy_context.document_isolation_policy, diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs index 61e533a43f9..36a27e97e2d 100644 --- a/moli-renderer-v8/src/network_host.rs +++ b/moli-renderer-v8/src/network_host.rs @@ -188,7 +188,7 @@ pub(crate) use self::response::{ build_fetch_response_object_from_body_source_with_metadata, build_fetch_response_object_from_stream_with_metadata, build_filtered_cached_response_object, build_navigation_preload_response_object_from_stream_with_metadata, - cors_preflight_request_headers, fetch_response_needs_orb_body_validation, filter_cors_exposed_response_headers, + check_opaque_response_policy, cors_preflight_request_headers, fetch_response_needs_orb_body_validation, filter_cors_exposed_response_headers, is_cors_policy_failure_message, materialize_response_object_body, materialize_response_object_body_preserving_error, materialize_response_object_body_with_chunk_callback, diff --git a/moli-renderer-v8/src/network_host/request_scope.rs b/moli-renderer-v8/src/network_host/request_scope.rs index c23c9d41ee5..9f148fcb68a 100644 --- a/moli-renderer-v8/src/network_host/request_scope.rs +++ b/moli-renderer-v8/src/network_host/request_scope.rs @@ -51,6 +51,9 @@ pub(crate) fn effective_subresource_policy_context( let policy = match owner { crate::native_bridge::OwnerDispatchScope::Top => crate::types::SubresourcePolicyContext { cross_origin_embedder_policy: host.cross_origin_embedder_policy(), + cross_origin_embedder_policy_report_only: host + .document_policy_container() + .cross_origin_embedder_policy_report_only, document_isolation_policy: host.document_isolation_policy(), cross_origin_isolated: host.cross_origin_isolated(), }, @@ -63,6 +66,10 @@ pub(crate) fn effective_subresource_policy_context( crate::types::SubresourcePolicyContext { cross_origin_embedder_policy: host .lightweight_popup_cross_origin_embedder_policy(popup_id), + cross_origin_embedder_policy_report_only: host + .lightweight_popup_policy_container(popup_id) + .map(|policy| policy.cross_origin_embedder_policy_report_only) + .unwrap_or_default(), document_isolation_policy: host .lightweight_popup_document_isolation_policy(popup_id), cross_origin_isolated: host.lightweight_popup_cross_origin_isolated(popup_id), diff --git a/moli-renderer-v8/src/network_host/response.rs b/moli-renderer-v8/src/network_host/response.rs index daf3fc87f2d..54de2d0cce3 100644 --- a/moli-renderer-v8/src/network_host/response.rs +++ b/moli-renderer-v8/src/network_host/response.rs @@ -19,7 +19,7 @@ pub(super) use self::bindings::new_response_with_init; pub(crate) use self::bindings::{build_error_response_object, response_constructor_callback}; pub(super) use self::body_methods::install_response_body_methods; pub(crate) use self::cors::{ - FetchResponseSecurityViolation, cors_preflight_request_headers, + FetchResponseSecurityViolation, check_opaque_response_policy, cors_preflight_request_headers, fetch_response_needs_orb_body_validation, filter_cors_exposed_response_headers, is_cors_policy_failure_message, validate_cors_preflight_response, validate_cors_response_chain, validate_cross_origin_embedder_and_document_isolation_policy, diff --git a/moli-renderer-v8/src/network_host/response/cors.rs b/moli-renderer-v8/src/network_host/response/cors.rs index c611d2bafcb..8a5ac106a39 100644 --- a/moli-renderer-v8/src/network_host/response/cors.rs +++ b/moli-renderer-v8/src/network_host/response/cors.rs @@ -1,3 +1,72 @@ +#[derive(Debug)] +pub(crate) enum OpaqueResponsePolicyViolation { + Explicit(String), + Defaulted { due_to_coep: bool, due_to_dip: bool }, +} + +impl OpaqueResponsePolicyViolation { + pub(crate) fn is_due_to_coep(&self) -> bool { + matches!( + self, + Self::Defaulted { + due_to_coep: true, + .. + } + ) + } + + pub(crate) fn is_due_to_dip(&self) -> bool { + matches!( + self, + Self::Defaulted { + due_to_dip: true, + .. + } + ) + } +} + +pub(crate) fn check_opaque_response_policy( + request_origin: &WebOrigin, + response_url: &url::Url, + response_headers: &[(String, Vec)], + request_include_credentials: bool, + embedder_policy: CrossOriginEmbedderPolicy, + document_isolation_policy: DocumentIsolationPolicy, +) -> Result<(), OpaqueResponsePolicyViolation> { + if !matches!(response_url.scheme(), "http" | "https") + || request_origin.same_origin_url(response_url) + { + return Ok(()); + } + let policy = moli_fetch::CrossOriginResourcePolicy::from_headers(response_headers); + if let Some(policy) = policy { + policy + .check(request_origin, response_url) + .map_err(OpaqueResponsePolicyViolation::Explicit)?; + } + if policy.is_some() { + return Ok(()); + } + let due_to_coep = match embedder_policy { + CrossOriginEmbedderPolicy::None => false, + CrossOriginEmbedderPolicy::RequireCorp => true, + CrossOriginEmbedderPolicy::Credentialless => request_include_credentials, + }; + let due_to_dip = match document_isolation_policy { + DocumentIsolationPolicy::None => false, + DocumentIsolationPolicy::IsolateAndRequireCorp => true, + DocumentIsolationPolicy::IsolateAndCredentialless => request_include_credentials, + }; + if due_to_coep || due_to_dip { + Err(OpaqueResponsePolicyViolation::Defaulted { + due_to_coep, + due_to_dip, + }) + } else { + Ok(()) + } +} use moli_fetch::validate_cors_response_for_origin; use moli_fetch::{RedirectSource, RequestCredentialsMode, RequestMode}; @@ -309,48 +378,24 @@ pub(crate) fn validate_cross_origin_embedder_and_document_isolation_policy( embedder_policy: CrossOriginEmbedderPolicy, document_isolation_policy: DocumentIsolationPolicy, ) -> Result<(), String> { + if request_mode != RequestMode::NoCors { + return Ok(()); + } let request_origin = request_origin.into(); - if request_mode != RequestMode::NoCors - || !matches!(response_url.scheme(), "http" | "https") - || request_origin.same_origin(&response_url.into()) - { - return Ok(()); - } - - let request_includes_credentials = - request_includes_credentials(&request_origin, response_url, credentials_mode); - let requires_corp_due_to_coep = match embedder_policy { - CrossOriginEmbedderPolicy::None => false, - CrossOriginEmbedderPolicy::RequireCorp => true, - CrossOriginEmbedderPolicy::Credentialless => { - request_mode == RequestMode::Navigate || request_includes_credentials - } - }; - let requires_corp_due_to_dip = match document_isolation_policy { - DocumentIsolationPolicy::None => false, - DocumentIsolationPolicy::IsolateAndRequireCorp => true, - DocumentIsolationPolicy::IsolateAndCredentialless => { - request_mode == RequestMode::Navigate || request_includes_credentials - } - }; - let requires_corp = requires_corp_due_to_coep || requires_corp_due_to_dip; - if !requires_corp { - return Ok(()); - } - - let policy_label = defaulted_corp_policy_label( - requires_corp_due_to_coep, + check_opaque_response_policy( + &request_origin, + response_url, + response_headers, + request_includes_credentials(&request_origin, response_url, credentials_mode), embedder_policy, - requires_corp_due_to_dip, document_isolation_policy, - ); - if let Some(policy) = moli_fetch::CrossOriginResourcePolicy::from_headers(response_headers) { - return policy.check(&request_origin, response_url); - } - Err(format!( - "{policy_label} check failed: requires a valid Cross-Origin-Resource-Policy for {} to load {response_url}", - request_origin.ascii_serialization() - )) + ).map_err(|violation| match violation { + OpaqueResponsePolicyViolation::Explicit(message) => message, + OpaqueResponsePolicyViolation::Defaulted { due_to_coep, due_to_dip } => { + let label = defaulted_corp_policy_label(due_to_coep, embedder_policy, due_to_dip, document_isolation_policy); + format!("{label} check failed: requires a valid Cross-Origin-Resource-Policy for {} to load {response_url}", request_origin.ascii_serialization()) + } + }) } fn defaulted_corp_policy_label( @@ -1684,4 +1729,124 @@ mod tests { .is_ok() ); } + + #[test] + fn opaque_response_policy_distinguishes_explicit_corp_and_policy_defaulting() { + let origin = WebOrigin::from_url(&url("https://example.test/")); + let target = url("https://cdn.test/body"); + let explicit = [( + "Cross-Origin-Resource-Policy".to_owned(), + b"same-origin".to_vec(), + )]; + let violation = check_opaque_response_policy( + &origin, + &target, + &explicit, + true, + CrossOriginEmbedderPolicy::RequireCorp, + DocumentIsolationPolicy::None, + ) + .unwrap_err(); + assert!(!violation.is_due_to_coep()); + for headers in [ + Vec::new(), + vec![( + "Cross-Origin-Resource-Policy".to_owned(), + b"Cross-Origin".to_vec(), + )], + vec![( + "Cross-Origin-Resource-Policy".to_owned(), + b"cross-origin, cross-origin".to_vec(), + )], + vec![ + ( + "Cross-Origin-Resource-Policy".to_owned(), + b"cross-origin".to_vec(), + ), + ( + "Cross-Origin-Resource-Policy".to_owned(), + b"cross-origin".to_vec(), + ), + ], + vec![( + "Cross-Origin-Resource-Policy".to_owned(), + b"\xa0cross-origin\xa0".to_vec(), + )], + ] { + let violation = check_opaque_response_policy( + &origin, + &target, + &headers, + true, + CrossOriginEmbedderPolicy::RequireCorp, + DocumentIsolationPolicy::None, + ) + .unwrap_err(); + assert!(violation.is_due_to_coep()); + assert!( + check_opaque_response_policy( + &origin, + &target, + &headers, + false, + CrossOriginEmbedderPolicy::Credentialless, + DocumentIsolationPolicy::None + ) + .is_ok() + ); + assert!( + check_opaque_response_policy( + &origin, + &target, + &headers, + true, + CrossOriginEmbedderPolicy::None, + DocumentIsolationPolicy::None + ) + .is_ok() + ); + } + assert!( + check_opaque_response_policy( + &origin, + &target, + &[( + "Cross-Origin-Resource-Policy".to_owned(), + b"\tcross-origin \t".to_vec() + )], + true, + CrossOriginEmbedderPolicy::RequireCorp, + DocumentIsolationPolicy::IsolateAndRequireCorp + ) + .is_ok() + ); + assert!( + check_opaque_response_policy( + &origin, + &url("https://example.test/body"), + &[], + true, + CrossOriginEmbedderPolicy::RequireCorp, + DocumentIsolationPolicy::IsolateAndRequireCorp + ) + .is_ok() + ); + let violation = check_opaque_response_policy( + &origin, + &target, + &[], + true, + CrossOriginEmbedderPolicy::None, + DocumentIsolationPolicy::IsolateAndRequireCorp, + ) + .unwrap_err(); + assert!(matches!( + violation, + OpaqueResponsePolicyViolation::Defaulted { + due_to_coep: false, + due_to_dip: true + } + )); + assert!(!violation.is_due_to_coep()); + } } diff --git a/moli-renderer-v8/src/script_vm/tests/cache_response_policy.rs b/moli-renderer-v8/src/script_vm/tests/cache_response_policy.rs new file mode 100644 index 00000000000..2c6ccaee312 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/cache_response_policy.rs @@ -0,0 +1,339 @@ +use super::*; +use crate::cross_origin_isolation::{ + CrossOriginEmbedderPolicy as Coep, DocumentIsolationPolicy as Dip, +}; + +fn install_responses(vm: &mut ScriptVm, origin: &str) { + let context = &vm.current_main_world().unwrap().context as *const _; + vm.with_context_scope_by_ptr_and_checkpoint_for_test(context, |scope, _| { + let mut values = Vec::new(); + for (name, credentials, redirect, corp) in [ + ("included", true, false, false), + ("omitted", false, false, false), + ("corp", true, false, true), + ("redirect", true, true, false), + ] { + let mut headers = Vec::new(); + if corp { + headers.push(( + "Cross-Origin-Resource-Policy".to_owned(), + b"cross-origin".to_vec(), + )); + } + if redirect { + headers.push(( + "Location".to_owned(), + b"https://opaque.test/target".to_vec(), + )); + } + let head = moli_fetch::ResponseHead { + final_url: url::Url::parse(&format!("https://opaque.test/{name}")).unwrap(), + status: if redirect { 302 } else { 200 }, + status_text: None, + headers, + request_cookie_report: None, + request_include_credentials: credentials, + cookie_set_reports: Vec::new(), + redirected: false, + redirect_chain: Vec::new(), + from_cache: false, + cache_state: Default::default(), + preload_state: Default::default(), + negotiated_http_version: None, + }; + let response = crate::network_host::build_fetch_response_object_for_request_mode( + scope, + moli_url::WebOrigin::from_url(&url::Url::parse(origin).unwrap()), + crate::network_host::FetchResponseRequest { + method: "GET", + mode: moli_fetch::RequestMode::NoCors, + redirect_mode: if redirect { + moli_fetch::RequestRedirectMode::Manual + } else { + moli_fetch::RequestRedirectMode::Follow + }, + }, + moli_fetch::Response::from_head_and_text_body(head, "body".to_owned()), + ); + values.push(response.into()); + } + let values = v8::Array::new_with_elements(scope, &values); + let global = scope.get_current_context().global(scope); + let key = crate::util::v8str(scope, "inputs"); + global.create_data_property(scope, key.into(), values.into()); + Ok(()) + }) + .unwrap(); +} + +#[tokio::test(flavor = "current_thread")] +async fn cache_read_policy_preserves_credentials_and_reports_only_coep_blocks() { + for (name, coep, dip, report_only, blocked, enforce_reports, reporting_reports) in [ + ( + "none", + Coep::None, + Dip::None, + Coep::None, + [false, false], + 0, + 0, + ), + ( + "require", + Coep::RequireCorp, + Dip::None, + Coep::None, + [true, true], + 6, + 0, + ), + ( + "credentialless", + Coep::Credentialless, + Dip::None, + Coep::None, + [true, false], + 3, + 0, + ), + ( + "dip-require", + Coep::None, + Dip::IsolateAndRequireCorp, + Coep::None, + [true, true], + 0, + 0, + ), + ( + "dip-credentialless", + Coep::None, + Dip::IsolateAndCredentialless, + Coep::None, + [true, false], + 0, + 0, + ), + ( + "report-only", + Coep::None, + Dip::None, + Coep::RequireCorp, + [false, false], + 0, + 6, + ), + ( + "both", + Coep::RequireCorp, + Dip::None, + Coep::RequireCorp, + [true, true], + 6, + 6, + ), + ] { + let loader = static_http_loader(std::iter::empty::()); + let url = format!("https://cache-policy.test/{name}"); + let mut vm = new_storage_page_task_executor_test_vm_with_loader(&url, &loader); + vm.set_main_navigation_policy_container(crate::document_runtime::DocumentPolicyContainer { + cross_origin_embedder_policy: coep, + cross_origin_embedder_policy_report_only: report_only, + document_isolation_policy: dip, + ..Default::default() + }); + install_responses(&mut vm, &url); + vm.exec(&format!(r#" + globalThis.reports=[];globalThis.done=false;globalThis.results=[]; + globalThis.observer=new ReportingObserver(list=>reports.push(...list.map(report=>report.toJSON())),{{types:['coep']}}); + observer.observe(); + (async()=>{{ + const cache=await caches.open('policy'); + const blocked={blocked}; + const entries=[...inputs,new Response('basic')]; + const types=['opaque','opaque','opaque','opaqueredirect','default']; + for(let index=0;indexcache.match(key)], + ['matchAll',async()=>(await cache.matchAll(key))[0]], + ['storage',()=>caches.match(key,{{cacheName:'policy'}})], + ]){{ + const shouldBlock=index<2&&blocked[index]; + try{{ + const response=await read(); + if(shouldBlock||response.type!==types[index])throw new Error('unexpected response '+index+' '+api); + }}catch(error){{ + if(!shouldBlock||!(error instanceof TypeError))throw error; + }} + results.push([index,api]); + }} + }} + done=true; + }})().catch(error=>done='error:'+error); + "#, blocked=serde_json::to_string(&blocked).unwrap()),None).unwrap(); + advance_page_task_executor_until_eval_equals( + &mut vm, + &loader, + "String(done)", + "true", + name, + ) + .await; + let count = enforce_reports + reporting_reports; + if count != 0 { + advance_page_task_executor_until_eval_equals( + &mut vm, + &loader, + "String(reports.length)", + &count.to_string(), + name, + ) + .await; + } + let reports: Vec = + serde_json::from_str(&vm.eval("JSON.stringify(reports)").unwrap()).unwrap(); + assert_eq!(vm.eval("results.length").unwrap(), "15", "{name}"); + assert_eq!(reports.len(), count, "{name}: {reports:?}"); + assert_eq!( + reports + .iter() + .filter(|report| report["body"]["disposition"] == "enforce") + .count(), + enforce_reports, + "{name}" + ); + assert_eq!( + reports + .iter() + .filter(|report| report["body"]["disposition"] == "reporting") + .count(), + reporting_reports, + "{name}" + ); + for report in reports { + assert_eq!(report["type"], "coep", "{name}"); + assert_eq!(report["url"], url, "{name}"); + assert_eq!(report["body"]["type"], "corp", "{name}"); + assert_eq!(report["body"]["destination"], "", "{name}"); + assert!( + matches!( + report["body"]["blockedURL"].as_str(), + Some("https://opaque.test/included" | "https://opaque.test/omitted") + ), + "{name}: {report}" + ); + } + } +} + +#[tokio::test(flavor = "current_thread")] +async fn borrowed_cache_reads_use_owner_policy_reports_and_error_realm_after_removal() { + let server = StaticHttpServer::spawn_with_raw_responder(1, |_, _| { + let body=""; + format!("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nCross-Origin-Embedder-Policy: require-corp\r\nCross-Origin-Embedder-Policy-Report-Only: require-corp\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",body.len()) + }).await; + let loader = static_http_loader([server.resolve_entry("localhost")]); + let root_url = server.url_for_host("localhost", "/root"); + let child_url = server.url_for_host("localhost", "/child"); + let mut vm = new_storage_page_task_executor_test_vm_with_loader(root_url.as_str(), &loader); + install_responses(&mut vm, root_url.as_str()); + vm.exec(&format!(r#" + globalThis.frameReady=false;globalThis.parentReports=[];globalThis.childReports=[]; + addEventListener('message',event=>{{if(event.data==='cache-child-ready')frameReady=true;}}); + const frame=document.createElement('iframe');frame.id='target';frame.src={child};document.body.append(frame); + "#,child=serde_json::to_string(child_url.as_str()).unwrap()),None).unwrap(); + advance_page_task_executor_until_eval_equals( + &mut vm, + &loader, + "String(frameReady)", + "true", + "cache child response policy", + ) + .await; + vm.exec(r#" + globalThis.done=false; + (async()=>{ + const child=document.getElementById('target').contentWindow; + globalThis.parentObserver=new ReportingObserver(list=>parentReports.push(...list.map(report=>report.toJSON())),{types:['coep']}); + globalThis.childObserver=new child.ReportingObserver(list=>childReports.push(...list.map(report=>report.toJSON())),{types:['coep']}); + parentObserver.observe();childObserver.observe(); + const ownCache=await caches.open('policy');const otherCache=await child.caches.open('policy'); + const key=new URL('/entry',location.href).href;await ownCache.put(key,inputs[0]); + child.origin='https://opaque.test'; + const base=child.document.createElement('base');base.href='https://opaque.test/';child.document.head.append(base); + globalThis.completed=0; + for(const [owner,cache] of [[window,ownCache],[child,otherCache]]){ + for(const callee of [window,child]){ + for(const [api,read] of [ + ['match',()=>callee.Cache.prototype.match.call(cache,key)], + ['all',()=>callee.Cache.prototype.matchAll.call(cache,key)], + ['storage',()=>callee.CacheStorage.prototype.match.call(owner.caches,key,{cacheName:'policy'})], + ]){ + const promise=read(); + if(!(promise instanceof owner.Promise))throw new Error('wrong Promise realm'); + try{ + const value=await promise; + if(owner===child)throw new Error('owner COEP was ignored'); + const response=api==='all'?value[0]:value; + if(Object.getPrototypeOf(response)!==owner.Response.prototype)throw new Error('wrong Response realm'); + if(api==='all'&&(!Object.isFrozen(value)||Object.getPrototypeOf(value)!==owner.Array.prototype))throw new Error('wrong result array'); + }catch(error){ + if(owner!==child||!(error instanceof child.TypeError)||error instanceof TypeError)throw error; + if(!error.message.includes('blocked by Cross-Origin-Resource-Policy'))throw error; + } + completed++; + } + } + } + globalThis.savedCache=otherCache; + done=true; + })().catch(error=>done='error:'+error); + "#,None).unwrap(); + advance_page_task_executor_until_eval_equals( + &mut vm, + &loader, + "String(done)", + "true", + "borrowed Cache read policies", + ) + .await; + advance_page_task_executor_until_eval_equals( + &mut vm, + &loader, + "String(childReports.length)", + "12", + "owner Cache COEP reports", + ) + .await; + assert_eq!(vm.eval("completed").unwrap(), "12"); + assert_eq!(vm.eval("parentReports.length").unwrap(), "0"); + let reports: Vec = + serde_json::from_str(&vm.eval("JSON.stringify(childReports)").unwrap()).unwrap(); + for report in reports { + assert_eq!(report["url"], child_url.as_str()); + assert_eq!(report["body"]["blockedURL"], "https://opaque.test/included"); + } + vm.exec(r#" + globalThis.done=false;document.getElementById('target').remove(); + const key=new URL('/entry',location.href).href; + const promise=Cache.prototype.match.call(savedCache,key); + // Retirement is rejected by the pre-existing lifecycle guard before + // result-realm selection or CORP evaluation. + if(!(promise instanceof Promise))throw new Error('retired rejection Promise realm changed'); + promise.then(()=>done='unexpected response',error=>{ + done=error instanceof DOMException&&error.name==='InvalidStateError'&&error.message.includes('execution context has been destroyed'); + }); + "#,None).unwrap(); + advance_page_task_executor_until_eval_equals( + &mut vm, + &loader, + "String(done)", + "true", + "retained Cache response policy", + ) + .await; + assert_eq!(vm.eval("parentReports.length").unwrap(), "0"); + assert_eq!(server.finish_targets().await, ["/child"]); +} diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index dc971ec2f77..1c2624d1faf 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -2327,6 +2327,7 @@ mod browser_api; mod cache_dictionary_inheritance; mod cache_interfaces; mod cache_response_credentials; +mod cache_response_policy; mod dom_token_list_native_receivers; diff --git a/moli-renderer-v8/src/service_worker_runtime/host.rs b/moli-renderer-v8/src/service_worker_runtime/host.rs index c71a2387913..a278116d756 100644 --- a/moli-renderer-v8/src/service_worker_runtime/host.rs +++ b/moli-renderer-v8/src/service_worker_runtime/host.rs @@ -1066,6 +1066,10 @@ fn service_worker_script_policy_context( crate::cross_origin_isolation::cross_origin_embedder_policy_from_headers(headers); SubresourcePolicyContext { cross_origin_embedder_policy, + cross_origin_embedder_policy_report_only: + crate::cross_origin_isolation::cross_origin_embedder_policy_report_only_from_headers( + headers, + ), document_isolation_policy: crate::cross_origin_isolation::document_isolation_policy_from_headers(headers), // A ServiceWorker's own COEP establishes its independent agent's mode; diff --git a/moli-renderer-v8/src/shared_worker_runtime/loading.rs b/moli-renderer-v8/src/shared_worker_runtime/loading.rs index d1c3497df25..345c43d5724 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/loading.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/loading.rs @@ -639,6 +639,10 @@ fn worker_policy_context_from_response(headers: &[(String, Vec)]) -> Subreso SubresourcePolicyContext { cross_origin_embedder_policy: crate::cross_origin_isolation::cross_origin_embedder_policy_from_headers(headers), + cross_origin_embedder_policy_report_only: + crate::cross_origin_isolation::cross_origin_embedder_policy_report_only_from_headers( + headers, + ), document_isolation_policy: crate::cross_origin_isolation::document_isolation_policy_from_headers(headers), cross_origin_isolated: false, diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs index a6065a8be62..0599adf5852 100644 --- a/moli-renderer-v8/src/types.rs +++ b/moli-renderer-v8/src/types.rs @@ -1041,6 +1041,8 @@ impl From for AsyncSubresourceFetchResponseFi pub(crate) struct SubresourcePolicyContext { pub(super) cross_origin_embedder_policy: crate::cross_origin_isolation::CrossOriginEmbedderPolicy, + pub(super) cross_origin_embedder_policy_report_only: + crate::cross_origin_isolation::CrossOriginEmbedderPolicy, pub(super) document_isolation_policy: crate::cross_origin_isolation::DocumentIsolationPolicy, pub(super) cross_origin_isolated: bool, } @@ -1049,6 +1051,8 @@ impl SubresourcePolicyContext { pub(super) fn from_document_policy(policy: &DocumentPolicyContainer) -> Self { Self { cross_origin_embedder_policy: policy.cross_origin_embedder_policy, + cross_origin_embedder_policy_report_only: policy + .cross_origin_embedder_policy_report_only, document_isolation_policy: policy.document_isolation_policy, cross_origin_isolated: policy.cross_origin_isolated && policy.allows_cross_origin_isolation(), diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index 3589c186b05..9f3bbc14351 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -235,6 +235,7 @@ pub(crate) use state::{ worker_current_script_url, worker_exception_report_target, worker_global_is_closed, worker_realm_secure_context_available, worker_referrer_policy, worker_service_worker_control_state, worker_shared_memory_agent_cluster, worker_storage_key, - worker_storage_partition_identity, worker_termination_requested, + worker_storage_partition_identity, worker_subresource_policy_context, + worker_termination_requested, }; pub(super) use timers::{TimerInfo, WorkerIsolateTimerQueues, worker_isolate_timer_queues}; diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rs index ab1ddc7b482..ed6570d9d9a 100644 --- a/moli-renderer-v8/src/worker/global_scope/state.rs +++ b/moli-renderer-v8/src/worker/global_scope/state.rs @@ -373,6 +373,12 @@ pub(crate) fn worker_current_script_url(scope: &mut v8::PinScope<'_, '_>) -> Opt get_worker_state(scope)?.borrow().current_script_url.clone() } +pub(crate) fn worker_subresource_policy_context( + scope: &mut v8::PinScope<'_, '_>, +) -> Option { + Some(get_worker_state(scope)?.borrow().policy_context) +} + pub(crate) fn worker_exception_report_target( scope: &mut v8::PinScope<'_, '_>, ) -> Option<(mpsc::UnboundedSender, String)> { diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index 719dec11e8b..03d31c994c7 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -79,8 +79,9 @@ pub(crate) use global_scope::{ worker_notification_permission_state, worker_opfs_directory_iterator_registry, worker_opfs_handle_registry, worker_realm_secure_context_available, worker_referrer_policy, worker_service_worker_control_state, worker_shared_memory_agent_cluster, worker_storage_key, - worker_storage_partition_identity, worker_termination_requested, - worker_trusted_types_for_script_requirements, worker_websocket_wrapper, + worker_storage_partition_identity, worker_subresource_policy_context, + worker_termination_requested, worker_trusted_types_for_script_requirements, + worker_websocket_wrapper, }; pub(crate) use handle::WorkerMessage; pub(crate) use handle::{ diff --git a/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs b/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs index 8c826af6b37..73367eb2003 100644 --- a/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs +++ b/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs @@ -112,6 +112,7 @@ async fn check_worker_credentialless_fetch(intercept: bool) { document_isolation_policy: dip, // Network policy applies even without an isolated agent cluster. cross_origin_isolated: false, + ..Default::default() }), ); if intercept {