From f81f514b1a019d62ea2e3faba40060ce1830bc30 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sun, 13 Sep 2026 02:46:44 +0800 Subject: [PATCH] fix(fetch): preserve opaque response metadata through service workers Keep internal response status, status text and headers through Window and Worker fetch, Response.clone(), Cache storage and FetchEvent.respondWith(). This preserves CORP checks when a require-corp client receives an opaque response from a service worker. Keep public opaque headers empty and immutable, and use the public header view when matching Vary in Cache. Cover streamed and materialized responses, opaque redirects, filtered HTTP 206 responses and Vary:* cache roundtrips. Reject invalid filtered respondWith responses before following their restored internal Location headers. --- .../subresource_fetch/fetch_dispatch.rs | 14 +- .../script_vm/subresource_fetch/streaming.rs | 5 +- .../src/script_vm/tests/dom_xhr/mod.rs | 1 + .../tests/dom_xhr/opaque_response.rs | 156 ++++++++++++++++++ .../service/fetch_settlement.rs | 8 + moli-storage-service/src/buckets.rs | 30 +++- 6 files changed, 202 insertions(+), 12 deletions(-) create mode 100644 moli-renderer-v8/src/script_vm/tests/dom_xhr/opaque_response.rs 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(),