diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs index eb46fe32404..a2513904fd3 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs @@ -762,10 +762,7 @@ impl ScriptVm { crate::context_bootstrap::record_resource_performance_entry(scope, entry); } let mut observable_response = response; - if matches!( - pending.info.resource_type, - SubresourceResourceType::Fetch | SubresourceResourceType::Xhr - ) && !response_filter.as_ref().is_some_and(|filter| filter.is_readable()) { + if pending.info.resource_type == SubresourceResourceType::Xhr && !response_filter.as_ref().is_some_and(|filter| filter.is_readable()) { observable_response.headers = crate::network_host::filter_cors_exposed_response_headers( &pending.request_origin, @@ -784,6 +781,15 @@ impl ScriptVm { .expect("detached keepalive completion is handled before V8 entry"); let resolver = v8::Local::new(scope, &resolver); let (mut head, body) = observable_response.into_body(); + let response_request = crate::network_host::FetchResponseRequest { + method: &response_request_method, + mode: pending.request_mode, + redirect_mode, + }; + response_request.capture_cors_exposure( + &pending.request_origin, &head, pending.credentials_mode, + &mut metadata, + ); if let Some(status_text) = response_status_text { head.status_text = Some(status_text); } diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs index e4f62067c28..94e7a18ed4b 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs @@ -1033,10 +1033,7 @@ impl ScriptVm { } let mut observable_head = started.head.clone(); - if matches!( - pending.info.resource_type, - SubresourceResourceType::Fetch | SubresourceResourceType::Xhr - ) && !started.response_filter.as_ref().is_some_and(|filter| filter.is_readable()) { + if pending.info.resource_type == SubresourceResourceType::Xhr && !started.response_filter.as_ref().is_some_and(|filter| filter.is_readable()) { observable_head.headers = crate::network_host::filter_cors_exposed_response_headers( &pending.request_origin, &observable_head, diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs index 87458356d06..0d4c22a0606 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs @@ -18,6 +18,7 @@ mod misc; mod native_events; mod no_cors_redirect; mod null_body; +mod opaque_response; mod open_validation; mod query_realms; mod receivers; diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/opaque_response.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/opaque_response.rs new file mode 100644 index 00000000000..50e4ef2e581 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/opaque_response.rs @@ -0,0 +1,156 @@ +use super::*; +use crate::util::v8str; + +#[test] +fn window_filtered_fetch_preserves_internal_head_through_clone_and_cache() { + for streaming in [false, true] { + for (mode, redirect, status, response_type) in [ + ("no-cors", "follow", 200, "opaque"), + ("cors", "manual", 302, "opaqueredirect"), + ] { + let mut vm = new_storage_test_vm("https://opaque-response.test/"); + vm.set_fetch_subresource_interception( + crate::types::SubresourceInterceptionClasses::for_resource_type( + crate::types::SubresourceResourceType::Fetch, + ), + ); + vm.eval(&format!(r#" + globalThis.opaqueResult = 'pending'; + fetch('https://remote-opaque-response.test/response', {{mode: '{mode}', redirect: '{redirect}'}}) + .then(async response => {{ + globalThis.original = response; + globalThis.cloned = response.clone(); + const bucket = await navigator.storageBuckets.open('opaque-response'); + const cache = await bucket.caches.open('responses'); + await cache.put('/key', cloned.clone()); + globalThis.cached = await cache.match('/key'); + await navigator.storageBuckets.delete('opaque-response'); + for (const entry of [original, cloned, cached]) {{ + if (!(entry instanceof Response) || entry.type !== '{response_type}' || + entry.status !== 0 || entry.statusText !== '' || entry.body !== null || + entry.bodyUsed || [...entry.headers].length !== 0) throw new Error('public response surface'); + let error; + try {{ entry.headers.set('x-author', 'changed'); }} catch (value) {{ error = value; }} + if (!(error instanceof TypeError)) throw new Error('immutable public headers'); + }} + opaqueResult = 'ok'; + }}).catch(error => opaqueResult = String(error.stack || error)); + "#)).unwrap(); + let requests = vm.take_pending_subresource_fetch_infos(); + assert_eq!(requests.len(), 1); + let request = &requests[0]; + let headers = vec![ + ( + "Content-Type".to_owned(), + "application/octet-stream".to_owned(), + ), + ("Content-Length".to_owned(), "0".to_owned()), + ("Access-Control-Allow-Origin".to_owned(), "*".to_owned()), + ( + "Cross-Origin-Resource-Policy".to_owned(), + "cross-origin".to_owned(), + ), + ("Vary".to_owned(), "*".to_owned()), + ("Set-Cookie".to_owned(), "hidden=secret".to_owned()), + ]; + let head = moli_fetch::ResponseHead { + final_url: request.url.clone(), + status, + status_text: Some("Internal Status".to_owned()), + headers: headers.clone(), + request_cookie_report: None, + cookie_set_reports: Vec::new(), + redirected: false, + redirect_chain: Vec::new(), + from_cache: false, + negotiated_http_version: None, + }; + if streaming { + let body_source_id = crate::network_host::new_network_body_source_id(); + vm.start_streaming_async_subresource_fetch( + crate::types::AsyncSubresourceStreamingStarted { + response_filter: None, + skip_fetch_security_validation: false, + internal_id: request.internal_id, + request_url: request.url.clone(), + request_method: "GET".to_owned(), + request_headers: Vec::new(), + request_body: None, + body_source_id, + head, + network_request_headers: None, + }, + ) + .unwrap(); + vm.finish_streaming_async_subresource_fetch( + request.internal_id, + body_source_id, + Ok(()), + ) + .unwrap(); + } else { + vm.complete_async_subresource_fetch( + crate::types::AsyncSubresourceFetchCompletion { + internal_id: request.internal_id, + request_url: request.url.clone(), + request_method: "GET".to_owned(), + request_headers: Vec::new(), + request_body: None, + response_status_text: None, + skip_fetch_security_validation: false, + response_filter: None, + network_error_text: None, + result: Ok( + crate::protocol_types::NavigationResponse::from_head_and_body( + head, + String::new(), + Vec::new(), + ), + ), + }, + ) + .unwrap(); + } + vm.exec("0", None).unwrap(); + assert_eq!( + vm.eval("opaqueResult").unwrap(), + "ok", + "{response_type}/streaming={streaming}" + ); + let context_ptr: *const v8::Global = &vm.page_default_context; + vm.renderer_document_isolate + .with_entered_renderer_document_isolate(move |isolate| { + let scope = std::pin::pin!(v8::HandleScope::new(isolate)); + let scope = &mut scope.init(); + let context = unsafe { v8::Local::new(scope, &*context_ptr) }; + let scope = &mut v8::ContextScope::new(scope, context); + for name in ["original", "cloned", "cached"] { + let value = context + .global(scope) + .get(scope, v8str(scope, name).into()) + .unwrap(); + let (head, _) = + crate::network_host::materialize_response_object_head_for_service_worker_respond_with( + scope, value, "test", + ) + .unwrap(); + assert_eq!(head.metadata.response_type.as_str(), response_type, "{name}"); + assert_eq!(head.status, status, "{name}"); + assert_eq!(head.status_text, "Internal Status", "{name}"); + for (name, value) in &headers { + assert!( + head.headers + .iter() + .any(|(key, entry)| key.eq_ignore_ascii_case(name) + && entry == value), + "missing internal {name}: {:?}", + head.headers + ); + } + } + Ok(()) + }) + .unwrap(); + } + } +} diff --git a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs index 97e12dbe1c0..abcac517241 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs @@ -539,6 +539,14 @@ impl ServiceWorkerRuntimeService { response: ServiceWorkerFetchResponse, ) { job.cancel_pending_navigation_preload(); + if let Some(message) = service_worker_fetch_response_rejection(&job, &response) { + self.complete_fetch_with_network_failure( + job, + message, + crate::network_host::FAILED_ERROR_TEXT.to_owned(), + ); + return; + } if is_redirect_status(response.head.status) && response.head.metadata.response_type == crate::types::FetchResponseType::OpaqueRedirect diff --git a/moli-storage-service/src/buckets.rs b/moli-storage-service/src/buckets.rs index ee72b6e47a6..a04ebd46bd0 100644 --- a/moli-storage-service/src/buckets.rs +++ b/moli-storage-service/src/buckets.rs @@ -1824,6 +1824,8 @@ fn cache_entry_matches_query( return false; } query.ignore_vary + // Opaque public headers are empty even though Cache retains the internal head. + || matches!(entry.response.head.metadata.response_type.as_str(), "opaque" | "opaqueredirect") || cached_response_vary_matches_request( &entry.response.head.headers, &entry.request.headers, @@ -2177,6 +2179,7 @@ fn load_storage_bucket_cache_file( .map(|url| url.parse()) .collect::>()?, redirected: entry.redirected, + cors_exposed_header_names: None, }; let body = BASE64_STANDARD .decode(entry.body_base64.as_bytes()) @@ -2965,7 +2968,8 @@ mod tests { .parse() .expect("valid response URL") ], - redirected: false + redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -3051,7 +3055,8 @@ mod tests { .parse() .expect("valid response URL") ], - redirected: false + redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -3292,6 +3297,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 201, status_text: "Created".to_owned(), @@ -3342,6 +3348,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -3403,6 +3410,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 201, status_text: "Created".to_owned(), @@ -3462,6 +3470,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -3559,6 +3568,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -3628,6 +3638,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -3642,6 +3653,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -3732,6 +3744,7 @@ mod tests { response: StorageBucketCachedResponse { head: moli_fetch_types::FetchResponseHead { metadata: moli_fetch_types::FetchResponseMetadata { + cors_exposed_header_names: None, response_type: (response_type.to_owned()) .parse() .expect("valid response type"), @@ -3850,7 +3863,8 @@ mod tests { .parse() .expect("valid response URL") ], - redirected: false + redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -4093,7 +4107,8 @@ mod tests { response_type: moli_fetch_types::FetchResponseType::Default, timing_allow_passed: true, url_list: Vec::new(), - redirected: false + redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -4191,6 +4206,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 202, status_text: "Accepted".to_owned(), @@ -4273,6 +4289,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -4287,6 +4304,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 201, status_text: "Created".to_owned(), @@ -4376,6 +4394,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 206, status_text: "Partial Content".to_owned(), @@ -4433,6 +4452,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -4493,6 +4513,7 @@ mod tests { timing_allow_passed: true, url_list: Vec::new(), redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(), @@ -4861,6 +4882,7 @@ mod tests { .expect("valid response URL"), ], redirected: false, + cors_exposed_header_names: None, }, status: 200, status_text: "OK".to_owned(),