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.
This commit is contained in:
ldm0
2026-11-19 00:30:44 +08:00
parent 67f2149eff
commit f81f514b1a
6 changed files with 202 additions and 12 deletions
@@ -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);
}
@@ -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,
@@ -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;
@@ -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<v8::Context> = &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();
}
}
}
@@ -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
+26 -4
View File
@@ -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::<std::result::Result<_, _>>()?,
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(),