fix(scripts): enforce client-origin CORS before script execution

Bind script loads and cache entries to the document client origin, authorize redirects before following them, and preserve redirect origin taint across Window and Worker Fetch/XHR validation and response filtering.

Check dynamic script CSP before transport, cover real HTTP and lifecycle regressions, and refresh the one newly passing WPT case after fixed-binary CLI/CDP comparisons.
This commit is contained in:
ldm0
2026-11-22 02:01:48 +08:00
parent 5aa30f7b40
commit d124fbf6ee
20 changed files with 1124 additions and 97 deletions
+9 -1
View File
@@ -5339,7 +5339,9 @@ async fn module_wasm_csp_blocks_cross_origin_script_element_fetch() -> Result<()
.await?;
assert_eq!(
diagnostic_global(&page, "moduleWasmCspViolationCount"),
Some(&JsValueSnapshot::Number(1.0))
Some(&JsValueSnapshot::Number(1.0)),
"script report: {:#?}",
page.script_execution()
);
assert_eq!(
diagnostic_global(&page, "moduleWasmCspViolationText"),
@@ -5351,6 +5353,12 @@ async fn module_wasm_csp_blocks_cross_origin_script_element_fetch() -> Result<()
diagnostic_global(&page, "moduleWasmCspExecuted"),
Some(&JsValueSnapshot::String(String::new()))
);
assert!(
page.subresource_network_records()
.iter()
.all(|record| record.url().path() != "/assets/execute-start.wasm"),
"CSP must block the dynamic module before source transport starts"
);
server.shutdown().await;
Ok(())
+29 -3
View File
@@ -410,12 +410,38 @@ fn append_browser_subresource_headers(
request: &Request,
request_url: &Url,
) {
let Some(metadata) = request.browser_request_metadata() else {
return;
};
if !matches!(request_url.scheme(), "http" | "https") {
return;
}
let Some(metadata) = request.browser_request_metadata() else {
if matches!(
request.resource_type,
crate::RequestResourceType::Script
| crate::RequestResourceType::ParserBlockingScript
| crate::RequestResourceType::ClassicAsyncOrDeferScript
| crate::RequestResourceType::LatePreloadScript
) {
append_header_if_missing(outgoing, "Accept", "*/*".to_owned());
append_header_if_missing(
outgoing,
"Accept-Language",
config.browser_identity().accept_language().to_owned(),
);
append_header_if_missing(
outgoing,
"Sec-Fetch-Site",
request_sec_fetch_site(request, request_url),
);
append_header_if_missing(
outgoing,
"Sec-Fetch-Mode",
request.request_mode.as_ref().to_owned(),
);
append_header_if_missing(outgoing, "Sec-Fetch-Dest", "script".to_owned());
append_browser_client_hints(outgoing, config);
}
return;
};
append_encoded_header_if_missing(
outgoing,
@@ -144,6 +144,11 @@ impl DocumentResourceLoader {
request_client = request_client.with_browser_site_context(browser_site_context);
}
let loads = ResourceLoadRegistry::new(task_runner);
// The Fetch client origin is independent of a script's referrer/base
// URL, including cross-origin dependencies and inherited/sandboxed Documents.
let request_client = request_client.with_script_request_origin(
moli_url::WebOrigin::from_ascii_serialization(context.origin()),
);
Self {
request_client,
authority: Arc::new(DocumentResourceLoaderAuthority {
@@ -217,6 +222,11 @@ impl DocumentResourceLoader {
if let Some(browser_site_context) = self.request_client.shared_browser_site_context() {
request_client = request_client.with_shared_browser_site_context(browser_site_context);
}
request_client = request_client.with_script_request_origin(
moli_url::WebOrigin::from_ascii_serialization(
self.authority.lifecycle.lock().context.origin(),
),
);
Self {
request_client,
authority: Arc::clone(&self.authority),
+71 -6
View File
@@ -35,6 +35,7 @@ pub struct ResourceRequestClient {
resource_runtime: BrowserResourceRuntime,
page_network_policy: PageNetworkPolicy,
browser_site_context: Option<Arc<BrowserCookieFacadeContext>>,
script_request_origin: Option<Arc<moli_url::WebOrigin>>,
}
/// Thread-affine lifetime root for a standalone resource request client.
@@ -123,6 +124,22 @@ impl ResourceRequestClient {
resource_runtime,
page_network_policy,
browser_site_context: None,
script_request_origin: None,
}
}
pub(crate) fn with_script_request_origin(mut self, origin: moli_url::WebOrigin) -> Self {
self.script_request_origin = Some(Arc::new(origin));
self
}
fn script_request_with_client_origin(&self, request: Request) -> Request {
if request.request_origin().is_none()
&& let Some(origin) = &self.script_request_origin
{
request.with_request_origin(origin.as_ref().clone())
} else {
request
}
}
@@ -162,6 +179,7 @@ impl ResourceRequestClient {
self.page_network_policy.frozen_request_view(),
);
client.browser_site_context = self.browser_site_context.clone();
client.script_request_origin = self.script_request_origin.clone();
client
}
@@ -320,7 +338,7 @@ impl ResourceRequestClient {
request
.browser_request_metadata
.get_or_insert(moli_fetch::BrowserRequestMetadata::Script);
let request = self.apply_network_policy(request)?;
let request = self.apply_network_policy(self.script_request_with_client_origin(request))?;
if let Some(result) = local_text_response(&request) {
return result;
}
@@ -338,7 +356,10 @@ impl ResourceRequestClient {
);
}
let result = self
.fetch_text_stream_with_cancel_after_policy(request, FetchCancelHandle::new())
.fetch_script_text_stream_with_cancel_after_policy(
request,
FetchCancelHandle::new(),
)
.await;
if let (Some(started), Some(url)) = (started, timing_url.as_deref()) {
let status = result.as_ref().ok().map(|response| response.status);
@@ -419,7 +440,7 @@ impl ResourceRequestClient {
}
let cache_request = request.clone();
let result = self
.fetch_text_stream_with_cancel_after_policy(request, FetchCancelHandle::new())
.fetch_script_text_stream_with_cancel_after_policy(request, FetchCancelHandle::new())
.await
.map_err(|error| format!("{error:#}"));
if let (Some(started), Some(url)) = (started, timing_url.as_deref()) {
@@ -469,7 +490,7 @@ impl ResourceRequestClient {
request
.browser_request_metadata
.get_or_insert(moli_fetch::BrowserRequestMetadata::Script);
let request = self.apply_network_policy(request)?;
let request = self.apply_network_policy(self.script_request_with_client_origin(request))?;
if let Some(result) = local_text_response(&request) {
let task_runner = resource_load.task_runner();
task_runner.spawn(async move {
@@ -494,9 +515,10 @@ impl ResourceRequestClient {
let cancel_handle = FetchCancelHandle::new();
resource_load.attach_cancel_handle(cancel_handle.clone());
let callback_resource_load = resource_load.clone();
let started_fetch = self.fetch_text_callback_with_cancel_after_policy(
let started_fetch = self.fetch_script_text_callback_with_cancel_after_policy(
request,
cancel_handle,
resource_load.task_runner(),
move |result| {
callback_resource_load.finish();
if let (Some(started), Some(url)) = (started, timing_url.as_deref()) {
@@ -607,9 +629,10 @@ impl ResourceRequestClient {
let callback_key = key.clone();
let cancel_handle = FetchCancelHandle::new();
load.attach_transport_cancel(cancel_handle.clone());
if let Err(error) = self.fetch_text_callback_with_cancel_after_policy(
if let Err(error) = self.fetch_script_text_callback_with_cancel_after_policy(
request,
cancel_handle,
resource_load.task_runner(),
move |result| {
let result = result.map_err(|error| format!("{error:#}"));
request_client.complete_cached_script_text_load(
@@ -668,6 +691,48 @@ impl ResourceRequestClient {
load.finish(result);
}
async fn fetch_script_text_stream_with_cancel_after_policy(
&self,
request: Request,
cancel_handle: FetchCancelHandle,
) -> Result<Response> {
if request.request_mode == moli_fetch::RequestMode::Cors
&& request.request_origin().is_some()
{
return crate::network_host::fetch_cors_script_text(self, request, cancel_handle)
.await
.map_err(anyhow::Error::msg);
}
self.fetch_text_stream_with_cancel_after_policy(request, cancel_handle)
.await
}
fn fetch_script_text_callback_with_cancel_after_policy<F>(
&self,
request: Request,
cancel_handle: FetchCancelHandle,
task_runner: super::RendererResourceTaskRunner,
callback: F,
) -> Result<()>
where
F: FnOnce(Result<Response>) + Send + 'static,
{
if request.request_mode == moli_fetch::RequestMode::Cors
&& request.request_origin().is_some()
{
let client = self.clone();
task_runner.spawn(async move {
callback(
client
.fetch_script_text_stream_with_cancel_after_policy(request, cancel_handle)
.await,
);
});
return Ok(());
}
self.fetch_text_callback_with_cancel_after_policy(request, cancel_handle, callback)
}
async fn fetch_text_stream_with_cancel_after_policy(
&self,
request: Request,
@@ -99,6 +99,7 @@ fn browser_client_rejects_http_requests_even_with_an_initiator() -> Result<()> {
owner.handle().apply_network_policy(browser)?;
Ok(())
}
mod script_cors;
#[test]
fn loader_clones_share_one_browser_resource_runtime() {
@@ -0,0 +1,486 @@
use super::*;
use crate::{
frame_owner_model::{DocumentId, FrameDocumentTaskOwner, FrameSchedulerLaneId, LocalWindowId},
native_bridge::WindowDocumentOwner,
network::{
RendererResourceTaskRunner,
context::{DocumentFetchContext, DocumentResourceLoader},
loads::{ResourceLoadDisposition, ResourceLoadKind},
},
};
use moli_fetch::{RequestMode, Response};
use parking_lot::Mutex;
struct ScriptServer {
url: Url,
requests: Arc<Mutex<Vec<String>>>,
task: tokio::task::JoinHandle<()>,
}
impl ScriptServer {
async fn new(status: u16, headers: &[(&str, &str)]) -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = Url::parse(&format!(
"http://{}/script.mjs",
listener.local_addr().unwrap()
))
.unwrap();
let body = "export const value = 1;";
let extra_headers = headers
.iter()
.map(|(name, value)| format!("{name}: {value}\r\n"))
.collect::<String>();
let response = format!(
"HTTP/1.1 {status} Test\r\nContent-Type: application/javascript\r\nCache-Control: max-age=3600\r\nContent-Length: {}\r\nConnection: close\r\n{extra_headers}\r\n{body}",
body.len()
);
let requests = Arc::new(Mutex::new(Vec::new()));
let captured = Arc::clone(&requests);
let task = tokio::spawn(async move {
while let Ok((mut stream, _)) = listener.accept().await {
let request = read_http_request_text(&mut stream).await.unwrap();
captured.lock().push(request);
stream.write_all(response.as_bytes()).await.unwrap();
}
});
Self {
url,
requests,
task,
}
}
fn request_count(&self) -> usize {
self.requests.lock().len()
}
fn last_origin(&self) -> Option<String> {
self.last_header("origin")
}
fn last_header(&self, header: &str) -> Option<String> {
self.requests.lock().last().and_then(|request| {
request.lines().find_map(|line| {
let (name, value) = line.split_once(':')?;
name.eq_ignore_ascii_case(header)
.then(|| value.trim().to_owned())
})
})
}
}
impl Drop for ScriptServer {
fn drop(&mut self) {
self.task.abort();
}
}
fn document(loader: &ResourceRequestClient, url: &str, origin: &str) -> DocumentResourceLoader {
let url = Url::parse(url).unwrap();
DocumentResourceLoader::new(
loader.clone(),
RendererResourceTaskRunner::from_current_tokio().unwrap(),
DocumentFetchContext::new(
WindowDocumentOwner::Frame(FrameDocumentTaskOwner::new(
FrameSchedulerLaneId(7),
LocalWindowId(11),
DocumentId(1),
)),
url.clone(),
url,
origin,
),
)
}
fn script_request(url: &Url, mode: RequestMode, credentials: RequestCredentialsMode) -> Request {
Request::new("GET", url.as_str(), None, Vec::new())
.unwrap()
// A dependency's referrer can be same-origin with the script server.
// It must never replace the Document's origin for CORS or cookies.
.with_initiator_url(url)
.with_request_mode(mode)
.with_credentials_mode(credentials)
.with_script_fetch_metadata(ScriptFetchRequestMetadata::default())
}
async fn fetch_script(
document: &DocumentResourceLoader,
request: Request,
callback: bool,
) -> Result<Response> {
let load = document
.register_load(
ResourceLoadKind::Script,
ResourceLoadDisposition::Ordinary,
None,
)
.unwrap();
let client = load.request_client();
if callback {
let (tx, rx) = oneshot::channel();
client.fetch_cacheable_script_text_callback_with_load(request, load, move |result| {
let _ = tx.send(result);
})?;
timeout(Duration::from_secs(5), rx).await??
} else {
let result = timeout(
Duration::from_secs(5),
client.fetch_cacheable_script_text_stream(request),
)
.await?;
load.finish();
result
}
}
#[tokio::test]
async fn script_cors_checks_the_document_origin_and_credentials_in_both_fetch_paths() {
for callback in [false, true] {
for (headers, credentials, allowed) in [
(vec![], RequestCredentialsMode::SameOrigin, false),
(
vec![("Access-Control-Allow-Origin", "https://wrong.test")],
RequestCredentialsMode::SameOrigin,
false,
),
(
vec![("Access-Control-Allow-Origin", "https://page.test")],
RequestCredentialsMode::SameOrigin,
true,
),
(
vec![("Access-Control-Allow-Origin", "*")],
RequestCredentialsMode::SameOrigin,
true,
),
(
vec![("Access-Control-Allow-Origin", "*")],
RequestCredentialsMode::Include,
false,
),
(
vec![("Access-Control-Allow-Origin", "https://page.test")],
RequestCredentialsMode::Include,
false,
),
(
vec![
("Access-Control-Allow-Origin", "https://page.test"),
("Access-Control-Allow-Credentials", "true"),
],
RequestCredentialsMode::Include,
true,
),
] {
let server = ScriptServer::new(200, &headers).await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let document = document(&transport, "https://page.test/page", "https://page.test");
let result = fetch_script(
&document,
script_request(&server.url, RequestMode::Cors, credentials),
callback,
)
.await;
assert_eq!(
result.is_ok(),
allowed,
"callback={callback}, headers={headers:?}, credentials={credentials:?}: {result:?}"
);
assert_eq!(server.last_origin().as_deref(), Some("https://page.test"));
if let Err(error) = result {
assert!(error.to_string().contains("CORS check failed"), "{error}");
}
}
}
}
#[tokio::test]
async fn script_cors_preserves_same_origin_and_no_cors_loading() {
for callback in [false, true] {
for mode in [RequestMode::Cors, RequestMode::NoCors] {
let server = ScriptServer::new(200, &[]).await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let origin = if mode == RequestMode::Cors {
moli_url::origin_ascii_serialization(&server.url)
} else {
"https://page.test".to_owned()
};
let document = document(&transport, server.url.as_str(), &origin);
fetch_script(
&document,
script_request(&server.url, mode, RequestCredentialsMode::Include),
callback,
)
.await
.unwrap();
}
}
}
#[tokio::test]
async fn script_cors_cache_cannot_reuse_no_cors_or_another_documents_authorization() {
for callback in [false, true] {
let server = ScriptServer::new(
200,
&[
("Access-Control-Allow-Origin", "https://first.test"),
("Access-Control-Allow-Credentials", "true"),
],
)
.await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let first = document(&transport, "https://first.test/page", "https://first.test");
let second = first.fork_for_document(DocumentFetchContext::new(
WindowDocumentOwner::Frame(FrameDocumentTaskOwner::new(
FrameSchedulerLaneId(7),
LocalWindowId(11),
DocumentId(2),
)),
Url::parse("https://second.test/page").unwrap(),
Url::parse("https://second.test/base").unwrap(),
"https://second.test",
));
for _ in 0..2 {
fetch_script(
&first,
script_request(
&server.url,
RequestMode::Cors,
RequestCredentialsMode::Include,
),
callback,
)
.await
.unwrap();
}
assert_eq!(
server.request_count(),
1,
"same Document should reuse its authorized response"
);
let result = fetch_script(
&second,
script_request(
&server.url,
RequestMode::Cors,
RequestCredentialsMode::Include,
),
callback,
)
.await;
assert!(
result.is_err(),
"another Document must perform its own CORS check"
);
let server = ScriptServer::new(200, &[]).await;
fetch_script(
&first,
script_request(
&server.url,
RequestMode::NoCors,
RequestCredentialsMode::Include,
),
callback,
)
.await
.unwrap();
let result = fetch_script(
&first,
script_request(
&server.url,
RequestMode::Cors,
RequestCredentialsMode::Include,
),
callback,
)
.await;
assert!(
result.is_err(),
"a classic no-cors cache entry must not authorize a module"
);
}
}
#[tokio::test]
async fn script_cors_rejects_a_redirect_before_requesting_its_target() {
for callback in [false, true] {
let final_server = ScriptServer::new(200, &[("Access-Control-Allow-Origin", "*")]).await;
let redirect = ScriptServer::new(302, &[("Location", final_server.url.as_str())]).await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let document = document(&transport, "https://page.test/page", "https://page.test");
let result = fetch_script(
&document,
script_request(
&redirect.url,
RequestMode::Cors,
RequestCredentialsMode::SameOrigin,
),
callback,
)
.await;
assert!(
result.is_err(),
"missing CORS headers on an intermediate redirect must reject"
);
assert_eq!(
final_server.request_count(),
0,
"blocked redirect target must not be fetched"
);
}
}
#[tokio::test]
async fn script_cors_cross_origin_redirects_taint_the_origin() {
for callback in [false, true] {
for (allow_origin, allowed) in [("null", true), ("https://page.test", false)] {
let final_server =
ScriptServer::new(200, &[("Access-Control-Allow-Origin", allow_origin)]).await;
let redirect = ScriptServer::new(
302,
&[
("Location", final_server.url.as_str()),
("Access-Control-Allow-Origin", "https://page.test"),
],
)
.await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let document = document(&transport, "https://page.test/page", "https://page.test");
let result = fetch_script(
&document,
script_request(
&redirect.url,
RequestMode::Cors,
RequestCredentialsMode::SameOrigin,
),
callback,
)
.await;
assert_eq!(result.is_ok(), allowed, "{result:?}");
assert_eq!(redirect.last_origin().as_deref(), Some("https://page.test"));
assert_eq!(final_server.last_origin().as_deref(), Some("null"));
}
}
}
#[tokio::test]
async fn script_cors_redirects_drop_authorization_apply_referrer_policy_and_preserve_fragments() {
for callback in [false, true] {
let final_server = ScriptServer::new(200, &[("Access-Control-Allow-Origin", "*")]).await;
let redirect = ScriptServer::new(
302,
&[
("Location", final_server.url.as_str()),
("Referrer-Policy", "no-referrer"),
],
)
.await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let origin = moli_url::origin_ascii_serialization(&redirect.url);
let document = document(&transport, redirect.url.as_str(), &origin);
let mut request = script_request(
&redirect.url,
RequestMode::Cors,
RequestCredentialsMode::SameOrigin,
);
request.url.set_fragment(Some("module-fragment"));
request.request_headers = vec![
("Authorization".to_owned(), "Bearer test-only".to_owned()),
("X-Embedder".to_owned(), "preserved".to_owned()),
];
let response = fetch_script(&document, request, callback).await.unwrap();
assert_eq!(response.final_url.fragment(), Some("module-fragment"));
assert_eq!(redirect.request_count(), 1);
assert_eq!(
final_server.request_count(),
1,
"browser-added script headers must not trigger preflight"
);
assert_eq!(
redirect.last_header("authorization").as_deref(),
Some("Bearer test-only")
);
assert_eq!(final_server.last_header("authorization"), None);
assert_eq!(final_server.last_header("referer"), None);
assert_eq!(
final_server.last_header("x-embedder").as_deref(),
Some("preserved")
);
}
}
#[tokio::test]
async fn script_cors_redirects_reject_non_http_schemes_and_cross_origin_url_credentials() {
for callback in [false, true] {
for target in [
"data:text/javascript,export default 1",
"http://user:pass@other.test/module.js",
] {
let redirect = ScriptServer::new(302, &[("Location", target)]).await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let origin = moli_url::origin_ascii_serialization(&redirect.url);
let document = document(&transport, redirect.url.as_str(), &origin);
let result = fetch_script(
&document,
script_request(
&redirect.url,
RequestMode::Cors,
RequestCredentialsMode::SameOrigin,
),
callback,
)
.await;
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("CORS redirect"));
}
}
}
#[tokio::test]
async fn script_cors_uses_inherited_and_opaque_document_origins_after_transport_replacement() {
for callback in [false, true] {
for origin in ["https://creator.test", "null"] {
let server = ScriptServer::new(200, &[("Access-Control-Allow-Origin", origin)]).await;
let transport = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let replacement = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let document = document(&transport, "about:srcdoc", origin)
.with_replacement_transport(replacement.handle());
fetch_script(
&document,
script_request(
&server.url,
RequestMode::Cors,
RequestCredentialsMode::SameOrigin,
),
callback,
)
.await
.unwrap();
assert_eq!(server.last_origin().as_deref(), Some(origin));
}
}
}
#[test]
fn script_cors_memory_cache_key_separates_origins_and_request_modes() {
let url = Url::parse("https://script.test/module.js").unwrap();
let first = script_request(&url, RequestMode::Cors, RequestCredentialsMode::Include)
.with_request_origin(moli_url::WebOrigin::from_ascii_serialization(
"https://first.test",
));
let second = first
.clone()
.with_request_origin(moli_url::WebOrigin::from_ascii_serialization(
"https://second.test",
));
assert_ne!(
super::super::script_text_cache_key(&first),
super::super::script_text_cache_key(&second)
);
assert_ne!(
super::super::script_text_cache_key(&first),
super::super::script_text_cache_key(&first.clone().with_request_mode(RequestMode::NoCors))
);
}
+14 -6
View File
@@ -38,7 +38,7 @@ use crate::network::ResourceRequestClient;
pub(crate) use self::async_fetch::{
collect_image_response_into_parkable, fetch_browser_subresource_with_preflight_headers,
spawn_async_subresource_fetch,
fetch_cors_script_text, spawn_async_subresource_fetch,
};
#[cfg(any(test, feature = "devtools"))]
pub(crate) use self::async_fetch::{
@@ -129,15 +129,13 @@ pub(crate) use self::media::{
start_media_element_resource_fetch,
};
pub(in crate::network_host) use self::preflight_events::CorsPreflightNetworkObserver;
pub(crate) use self::request::build_cached_request_object;
pub(in crate::network_host) use self::request::normalize_request_method;
pub(crate) use self::request::request_constructor_callback;
pub(crate) use self::request::{
FetchArgs, parse_fetch_init, parse_request_redirect_mode_label, request_object_credentials_mode,
};
pub(crate) use self::request::{FetchArgumentError, convert_fetch_arguments};
pub(crate) use self::request::{
RequestInputUrl, build_cached_request_object, build_service_worker_request_object,
};
pub(crate) use self::request::{
mark_request_input_body_used_for_fetch, request_body_already_used_error,
try_resolve_request_constructor_url, try_resolve_request_constructor_url_for_base,
@@ -162,7 +160,7 @@ pub(crate) use self::response::{
cors_preflight_request_headers, 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, materialize_response_object_head,
materialize_response_object_body_with_chunk_callback,
materialize_response_object_head_for_service_worker_respond_with,
materialized_body_bytes_from_value, network_response_filter, response_constructor_callback,
validate_cors_preflight_response, validate_cors_response_chain,
@@ -255,9 +253,19 @@ fn cross_origin_request_modes(
}
}
pub(crate) use response::{fetch_response_metadata, set_response_metadata};
pub(crate) use response::fetch_response_metadata;
#[cfg(test)]
pub(crate) use response::build_fetch_response_object_from_stream_for_request_mode;
pub(crate) mod controlled_resource;
#[cfg(test)]
pub(crate) use response::build_fetch_response_object_for_request_mode;
#[cfg(test)]
pub(crate) use response::materialize_response_object_head;
pub(crate) use request::build_service_worker_request_object;
pub(crate) use response::set_cached_response_head;
@@ -11,6 +11,28 @@ use moli_fetch::{
const MAX_MANUAL_CORS_REDIRECTS: usize = 20;
/// Script fetches need CORS authorization before following every redirect,
/// even though their browser-generated GET requests do not require preflight.
pub(crate) async fn fetch_cors_script_text(
loader: &ResourceRequestClient,
request: Request,
cancel_handle: FetchCancelHandle,
) -> Result<Response, String> {
let observed = fetch_browser_subresource_raw_stream_with_manual_preflight_redirects(
loader,
request,
Some(cancel_handle),
Vec::new(),
None,
)
.await?;
observed
.into_response()
.into_lossy_materialized_text_response()
.await
.map_err(format_network_error)
}
#[cfg(test)]
pub(crate) async fn fetch_browser_subresource_with_preflight(
loader: ResourceRequestClient,
@@ -190,28 +212,6 @@ pub(super) async fn fetch_subresource_hop(
}))
}
pub(crate) fn browser_request_needs_manual_preflight_redirects(
request: &Request,
preflight_request_headers: &[(String, String)],
) -> bool {
matches!(
request.browser_request_metadata(),
Some(
BrowserRequestMetadata::Fetch
| BrowserRequestMetadata::EventSource
| BrowserRequestMetadata::JsonModule
| BrowserRequestMetadata::TextModule
| BrowserRequestMetadata::Manifest
| BrowserRequestMetadata::StyleModule
| BrowserRequestMetadata::Xhr,
)
) && request.request_mode == RequestMode::Cors
&& request.cookie_context.initiator_url.is_some()
&& (request.use_cors_preflight()
|| !is_cors_safelisted_method(&request.method)
|| !moli_fetch::cors_unsafe_request_header_names(preflight_request_headers).is_empty())
}
struct ManualCorsRedirectState {
request: Request,
preflight_request_headers: Vec<(String, String)>,
@@ -265,10 +265,16 @@ impl ManualCorsRedirectState {
&mut self.request,
head,
network_response_extra_info,
moli_fetch::RedirectSource::Network,
web_security_disabled,
)?;
if transition == SubresourceResponseTransition::FollowedRedirect {
self.preflight_request_headers = self.request.request_headers.to_byte_strings();
self.preflight_request_headers.retain(|(name, _)| {
self.request
.request_headers
.iter()
.any(|(remaining, _)| name.eq_ignore_ascii_case(remaining))
});
}
Ok(transition)
}
@@ -424,7 +430,12 @@ pub(crate) fn next_redirect_url(
final_url
.join(&location)
.or_else(|_| url::Url::parse(&location))
.map(Some)
.map(|mut url| {
if !location.contains('#') {
url.set_fragment(final_url.fragment());
}
Some(url)
})
.map_err(|error| {
format!("failed to resolve redirect location `{location}` from {final_url}: {error}")
})
@@ -1104,6 +1115,7 @@ mod tests {
from_cache: false,
cache_state: Default::default(),
negotiated_http_version: None,
preload_state: Default::default(),
},
None,
false,
@@ -1118,16 +1130,26 @@ mod tests {
#[test]
fn follow_rejects_an_invalid_final_redirect_location_without_parsing_manual_redirects() {
let url = Url::parse("https://origin.test/source").unwrap();
let headers = vec![("Location".to_owned(), b"http://[".to_vec())];
let mut head = ResponseHead {
final_url: url.clone(),
status: 302,
status_text: None,
headers: vec![("Location".to_owned(), b"http://[".to_vec())],
request_cookie_report: None,
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,
};
for mode in [RequestRedirectMode::Follow, RequestRedirectMode::Error] {
assert!(validate_redirect_mode_parts(&url, 302, &headers, mode).is_err());
assert!(validate_redirect_mode_response_head(&head, mode).is_err());
}
assert!(
validate_redirect_mode_parts(&url, 302, &headers, RequestRedirectMode::Manual).is_ok()
);
assert!(
validate_redirect_mode_parts(&url, 200, &headers, RequestRedirectMode::Follow).is_ok()
);
assert!(validate_redirect_mode_response_head(&head, RequestRedirectMode::Manual).is_ok());
head.status = 200;
assert!(validate_redirect_mode_response_head(&head, RequestRedirectMode::Follow).is_ok());
}
#[test]
@@ -388,6 +388,7 @@ impl ControlledResourceLoad {
from_cache: false,
cache_state: Default::default(),
negotiated_http_version: None,
preload_state: Default::default(),
})
}
@@ -669,6 +670,7 @@ impl ControlledResourceLoad {
&mut self.request,
response.head.clone(),
network_response_extra_info,
moli_fetch::RedirectSource::Network,
self.load.request_client().web_security_disabled(),
)?
} else {
@@ -676,6 +678,7 @@ impl ControlledResourceLoad {
&mut self.request,
response.head.clone(),
network_response_extra_info,
moli_fetch::RedirectSource::Network,
self.load.request_client().web_security_disabled(),
)?
};
@@ -89,7 +89,7 @@ pub(crate) fn validate_fetch_response_security_policy(
let request_origin = request_origin.into();
if !web_security_disabled {
head.url_list()
.validate_request_mode(request_mode, &request_origin)
.validate_request_mode(request_mode, request_origin.clone())
.map_err(|error| error.to_string())?;
}
if request_mode == RequestMode::SameOrigin {
@@ -683,6 +683,64 @@ mod tests {
);
}
#[test]
fn cors_response_validation_uses_the_redirect_tainted_origin() {
let home = url("https://page.test/a");
let away = url("https://script.test/b");
let elsewhere = url("https://other.test/c");
let origin = WebOrigin::from_url(&home);
for (redirects, serialized_origin) in [
(vec![(&home, &away)], origin.ascii_serialization()),
(vec![(&away, &elsewhere)], "null"),
(vec![(&home, &away), (&away, &home)], "null"),
] {
let final_url = redirects.last().expect("redirect target").1.clone();
let mut head = header_response(
final_url,
vec![(
"Access-Control-Allow-Origin".to_owned(),
serialized_origin.as_bytes().to_vec(),
)],
);
head.redirected = true;
head.redirect_chain = redirects
.into_iter()
.map(|(from, to)| moli_fetch::RedirectInfo {
source: RedirectSource::Network,
from_url: from.clone(),
to_url: to.clone(),
status: 302,
headers: vec![(
"Access-Control-Allow-Origin".to_owned(),
origin.ascii_serialization().as_bytes().to_vec(),
)],
network_extra_info_available: false,
request_extra_info: None,
response_extra_info: None,
redirect_has_extra_info: false,
request_cookie_report: None,
cookie_set_reports: Vec::new(),
from_cache: false,
negotiated_http_version: None,
dispatched_request: None,
})
.collect();
assert_eq!(
head.url_list().serialized_origin(&origin),
serialized_origin
);
validate_cors_response_chain(&origin, &head, RequestCredentialsMode::SameOrigin)
.expect("each response must be authorized against its own request hop origin");
head.headers.clear();
assert!(
validate_cors_response_chain(&origin, &head, RequestCredentialsMode::SameOrigin)
.is_err(),
"returning to the initial origin must not bypass CORS"
);
}
}
#[test]
fn cors_preflight_request_headers_detect_unsafe_method_and_headers() {
let headers = vec![
@@ -7,9 +7,10 @@ use moli_fetch::{
};
use super::next_redirect_url;
use moli_fetch::RequestMode;
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) enum SubresourceResponseTransition {
pub(crate) enum SubresourceResponseTransition {
FinalResponse,
ManualResponse { response_url: url::Url },
FollowedRedirect,
@@ -38,17 +39,21 @@ pub(super) fn advance_subresource_response(
request: &mut Request,
head: ResponseHead,
network_response_extra_info: Option<NetworkResponseExtraInfo>,
source: RedirectSource,
web_security_disabled: bool,
) -> Result<SubresourceResponseTransition, String> {
// Preserve transport-refined snapshots, including cached/internal hops.
request.observe_redirect_requests(&head.redirect_chain);
if !web_security_disabled {
if source == moli_fetch::RedirectSource::Network {
request.observe_redirect_requests(&head.redirect_chain);
}
if source == moli_fetch::RedirectSource::Network && !web_security_disabled {
request.validate_cors_response_for_url(&head.final_url, &head.headers)?;
}
advance_validated_subresource_response(
request,
head,
network_response_extra_info,
source,
web_security_disabled,
)
}
@@ -57,6 +62,7 @@ pub(super) fn advance_validated_subresource_response(
request: &mut Request,
head: ResponseHead,
network_response_extra_info: Option<NetworkResponseExtraInfo>,
source: RedirectSource,
web_security_disabled: bool,
) -> Result<SubresourceResponseTransition, String> {
// Error mode rejects redirect statuses without consulting Location.
@@ -87,15 +93,35 @@ pub(super) fn advance_validated_subresource_response(
else {
return Ok(SubresourceResponseTransition::FinalResponse);
};
let mut redirect = head.into_redirect(
next_url,
RedirectSource::Network,
network_response_extra_info.is_some(),
);
if !matches!(next_url.scheme(), "http" | "https") {
return Err(format!("CORS redirect requires an HTTP(S) URL: {next_url}"));
}
if request.request_mode == RequestMode::Cors
&& (!next_url.username().is_empty() || next_url.password().is_some())
&& request.request_origin().is_some_and(|origin| {
!origin.same_origin_url(&head.final_url) || !origin.same_origin_url(&next_url)
})
{
return Err("CORS redirect URL must not include credentials".to_owned());
}
if !moli_url::same_origin(&head.final_url, &next_url) {
request
.request_headers
.retain(|(name, _)| !name.eq_ignore_ascii_case("authorization"));
if request
.auth()
.is_some_and(|auth| auth.target == moli_fetch::RequestAuthTarget::Server)
{
request.set_auth(None);
}
}
let mut redirect = head.into_redirect(next_url, source, network_response_extra_info.is_some());
redirect.response_extra_info = network_response_extra_info;
request
.follow_redirect_with_web_security(redirect, web_security_disabled)
.map_err(|error| error.to_string())?;
Ok(SubresourceResponseTransition::FollowedRedirect)
}
+18
View File
@@ -1330,6 +1330,24 @@ mod tests {
);
}
#[test]
fn classic_cors_script_uses_the_crossorigin_credentials_mode() {
for (cross_origin, expected) in [
("anonymous", RequestCredentialsMode::SameOrigin),
("", RequestCredentialsMode::SameOrigin),
("use-credentials", RequestCredentialsMode::Include),
] {
let metadata = ScriptFetchMetadata {
cross_origin: Some(cross_origin.to_owned()),
..ScriptFetchMetadata::default()
};
assert_eq!(
external_script_credentials_mode(ScriptKind::Classic, &metadata),
expected
);
}
}
#[test]
fn external_script_request_sets_browser_fetch_mode() {
let classic =
@@ -3,22 +3,9 @@ use super::*;
#[tokio::test]
async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module() {
run_page_vm_async_test(async move {
let (base_url, server) = spawn_path_response_http_server(vec![
(
"/moved-child-defer.js",
"HTTP/1.1 200 OK",
"parent.__movedChildDeferEvents.push('classic-ran');".to_owned(),
Duration::from_millis(80),
),
(
"/later-moved-module.js",
"HTTP/1.1 200 OK",
"parent.__movedChildDeferEvents.push('module-ran');".to_owned(),
Duration::ZERO,
),
])
.await;
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
let (base_url, release_classic, server) = spawn_moved_child_defer_http_server().await;
let loader =
crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");
let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);
let local_executor = page_vm.local_executor.clone();
@@ -63,7 +50,10 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module()
))?;
for _ in 0..12 {
let Some(_) = page_vm.run_next_child_frame_task_source_for_semantic_test().await else {
let Some(_) = page_vm
.run_next_child_frame_task_source_for_semantic_test()
.await
else {
break;
};
}
@@ -74,8 +64,13 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module()
);
let mut classic_completion = None;
let mut module_completion = false;
let mut release_classic = Some(release_classic);
for _ in 0..4 {
if !page_vm.page_resource_completion_queue().has_ready_completion() {
if !page_vm
.page_resource_completion_queue()
.has_ready_completion()
{
tokio::time::timeout(
Duration::from_secs(2),
wait_for_typed_page_resource_completion(&mut page_vm),
@@ -83,30 +78,44 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module()
.await
.expect("moved child defer completion should arrive");
}
let completion =
run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
let completion = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;
if matches!(
completion.action.source(),
RendererOwnerResourceActivitySource::ChildClassicScript
) {
classic_completion = Some(completion);
} else {
assert!(
matches!(
completion.action.source(),
RendererOwnerResourceActivitySource::ModuleGraphFetch
),
"the only other completion is the later module root"
);
run_expected_child_module_script_terminal_turn(
&mut page_vm,
"module terminal retained behind the moved classic defer",
)
.await;
module_completion = true;
// Make the later module ready while the classic source
// is still pending, without relying on transport timing.
release_classic
.take()
.expect("one module completion")
.send(())
.expect("classic response should still be gated");
}
if classic_completion.is_some() && module_completion {
break;
}
assert!(
matches!(
completion.action.source(),
RendererOwnerResourceActivitySource::ModuleGraphFetch
),
"the only completion allowed ahead of the moved classic defer is its later module root"
);
run_expected_child_module_script_terminal_turn(
&mut page_vm,
"module terminal retained behind the moved classic defer",
)
.await;
}
classic_completion
.expect("classic source completion must arrive after retained module terminals");
.expect("classic source completion must arrive before the script is moved");
assert!(
module_completion,
"later module must be ready before testing defer-slot release"
);
page_vm.vm_mut().eval(
r#"
(() => {
@@ -154,15 +163,27 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module()
ChildFrameSemanticTurnKind::DocumentLifecycle,
"moved defer complete transition",
),
(ChildFrameSemanticTurnKind::HostLoad, "moved defer iframe load"),
(
ChildFrameSemanticTurnKind::HostLoad,
"moved defer iframe load",
),
] {
sources.push(
run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(&mut page_vm, source, label)
.await,
run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(
&mut page_vm,
source,
label,
)
.await,
);
}
let final_events = page_vm.vm_mut().eval("__movedChildDeferEvents.join('|')")?;
assert_eq!(page_vm.run_next_child_frame_task_source_for_semantic_test().await, None);
assert_eq!(
page_vm
.run_next_child_frame_task_source_for_semantic_test()
.await,
None
);
Ok::<_, anyhow::Error>((events_after_dispose, sources, final_events))
})
.await
@@ -183,7 +204,9 @@ async fn page_vm_moved_child_defer_disposes_in_flight_slot_before_later_module()
final_events,
"before|after|ready:interactive|moved|module-ran|module-load|dcl|ready:complete|load"
);
server.await.expect("moved child defer server should finish");
server
.await
.expect("moved child defer server should finish");
})
.await;
}
@@ -78,6 +78,7 @@ use moli_websocket::test_support::{
use serde_json::json;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio::sync::oneshot;
use tokio::task::JoinHandle;
use tokio::time::sleep;
use url::Url;
@@ -1583,6 +1584,53 @@ async fn spawn_path_response_http_server(
(format!("http://{addr}"), server)
}
async fn spawn_moved_child_defer_http_server() -> (String, oneshot::Sender<()>, JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind defer fixture");
let base_url = format!("http://{}", listener.local_addr().unwrap());
let (release_classic, classic_released) = oneshot::channel();
let task = tokio::spawn(async move {
let mut classic_released = Some(classic_released);
let mut responses = Vec::new();
for _ in 0..2 {
let (mut stream, _) = listener.accept().await.expect("accept script request");
let request = read_http_request_head(&mut stream).await.unwrap();
let path = request
.lines()
.next()
.unwrap()
.split_whitespace()
.nth(1)
.unwrap();
let (body, gate) = match path {
"/moved-child-defer.js" => (
"parent.__movedChildDeferEvents.push('classic-ran');",
Some(classic_released.take().expect("one classic request")),
),
"/later-moved-module.js" => {
("parent.__movedChildDeferEvents.push('module-ran');", None)
}
_ => panic!("unexpected script path: {path}"),
};
responses.push(tokio::spawn(async move {
if let Some(gate) = gate {
gate.await.expect("test should release classic response");
}
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
stream.write_all(response.as_bytes()).await.unwrap();
}));
}
for response in responses {
response.await.expect("script response task");
}
});
(base_url, release_classic, task)
}
async fn spawn_concurrent_path_response_http_server(
response_specs: Vec<(&'static str, &'static str, String, Duration)>,
) -> (String, JoinHandle<()>) {
+1 -1
View File
@@ -1954,7 +1954,7 @@ async fn spawn_child_external_parser_module_ready_lane_server() -> (
let body = r#"parent.__childExternalParserModuleEvents.push("module:" + (globalThis === self));
globalThis.__childExternalParserModuleValue = 188;"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nAccess-Control-Allow-Origin: http://child-parser-module-driver.test\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
@@ -548,7 +548,14 @@ fn send_synchronous_worker_xhr(
}
}
match result.map(|completion| completion.result) {
Ok(Ok(response)) => apply_xhr_response(scope, xhr, response),
Ok(Ok(mut response)) => {
response.headers = filter_cors_exposed_response_headers(
&worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque),
&response.head(),
prepared.credentials_mode,
);
apply_xhr_response(scope, xhr, response);
}
Ok(Err(_)) | Err(_) => {
throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError")
}
@@ -0,0 +1,125 @@
use super::*;
use parking_lot::Mutex;
struct CorsServer {
url: String,
requests: Arc<Mutex<Vec<String>>>,
task: JoinHandle<()>,
}
impl CorsServer {
async fn new(redirect_to: Option<String>) -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!("http://{}/data", listener.local_addr().unwrap());
let requests = Arc::new(Mutex::new(Vec::new()));
let captured = Arc::clone(&requests);
let task = tokio::spawn(async move {
while let Ok((mut stream, _)) = listener.accept().await {
let request = read_http_request_head(&mut stream).await.unwrap();
let preflight = request.starts_with("OPTIONS ");
captured.lock().push(request);
let origin = if redirect_to.is_some() {
"http://worker.test"
} else {
"null"
};
let (status, location, body) = if preflight {
("204 No Content", String::new(), "")
} else if let Some(target) = &redirect_to {
(
"307 Temporary Redirect",
format!("Location: {target}\r\n"),
"",
)
} else {
("200 OK", String::new(), "allowed")
};
let response = format!(
"HTTP/1.1 {status}\r\nAccess-Control-Allow-Origin: {origin}\r\nAccess-Control-Allow-Methods: PUT\r\nAccess-Control-Allow-Headers: x-test\r\nContent-Type: text/plain\r\nX-Hidden: secret\r\nContent-Length: {}\r\nConnection: close\r\n{location}\r\n{body}",
body.len()
);
stream.write_all(response.as_bytes()).await.unwrap();
}
});
Self {
url,
requests,
task,
}
}
}
impl Drop for CorsServer {
fn drop(&mut self) {
self.task.abort();
}
}
#[tokio::test]
async fn worker_cors_redirects_validate_null_origin_in_fetch_and_xhr() {
ensure_v8();
for api in ["fetch", "xhr", "sync-xhr"] {
let target = CorsServer::new(None).await;
let source = CorsServer::new(Some(target.url.clone())).await;
let loader = ResourceRequestClient::new(&FetchConfig::default()).unwrap();
let mut worker = spawn_worker_with_request_client(
format!(
r#"
(async () => {{
try {{
const url = {url:?};
const api = {api:?};
if (api === "fetch") {{
const response = await fetch(url, {{ method: "PUT", headers: {{ "X-Test": "1" }} }});
postMessage([response.status, await response.text(), response.headers.get("X-Hidden")]);
}} else {{
const xhr = new XMLHttpRequest();
const done = new Promise(resolve => xhr.onloadend = resolve);
xhr.open(api === "sync-xhr" ? "GET" : "PUT", url, api !== "sync-xhr");
if (api !== "sync-xhr") xhr.setRequestHeader("X-Test", "1");
xhr.send();
if (api !== "sync-xhr") await done;
postMessage([xhr.status, xhr.responseText, xhr.getResponseHeader("X-Hidden")]);
}}
}} catch (error) {{
postMessage(String(error));
}} finally {{ close(); }}
}})();
"#,
url = source.url,
),
"http://worker.test/main.js".to_owned(),
loader,
);
let posted = timeout(TIMEOUT, async {
loop {
match worker.recv().await.expect("worker channel") {
WorkerToParentMessage::Post(payload) => break stringify_payload(&payload),
WorkerToParentMessage::SubresourceNetwork(_) => {}
message => panic!("unexpected worker message: {message:?}"),
}
}
})
.await
.expect("worker CORS redirect result");
assert_eq!(posted, r#"[200,"allowed",null]"#, "{api}");
let requests = target.requests.lock();
let expected_requests = if api == "sync-xhr" { 1 } else { 2 };
assert_eq!(requests.len(), expected_requests, "{api}");
assert!(
requests
.last()
.unwrap()
.starts_with(if api == "sync-xhr" { "GET " } else { "PUT " }),
"{api}: actual request must reach the target"
);
for request in requests.iter() {
assert!(
request
.lines()
.any(|line| line.eq_ignore_ascii_case("origin: null")),
"{api}: {request}"
);
}
}
}
@@ -1562,6 +1562,7 @@ fn service_worker_storage_apis_use_explicit_registration_storage_key() {
// ─── Basic tests ────────────────────────────────────────────────────
mod abort_signal_statics;
mod cors_redirects;
mod indexed_db;
mod lazy_storage;
mod lifecycle;
+62
View File
@@ -145,6 +145,9 @@ impl std::str::FromStr for FetchResponseType {
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FetchResponseMetadata {
/// Frozen CORS exposed-name list, retained through filtering, cloning and cache storage.
#[serde(default)]
pub cors_exposed_header_names: Option<Vec<String>>,
pub response_type: FetchResponseType,
/// Internal URLs, including those hidden by an opaque response's public URL.
pub url_list: Vec<Url>,
@@ -157,6 +160,7 @@ pub struct FetchResponseMetadata {
impl Default for FetchResponseMetadata {
fn default() -> Self {
Self {
cors_exposed_header_names: None,
response_type: FetchResponseType::Default,
url_list: Vec::new(),
timing_allow_passed: true,
@@ -214,3 +218,61 @@ mod tests {
}
pub mod header_policy;
impl FetchResponseMetadata {
pub fn capture_cors_exposed_headers(&mut self, headers: &[(String, Vec<u8>)]) {
if self.response_type == FetchResponseType::Cors && self.cors_exposed_header_names.is_none()
{
let names = headers
.iter()
.filter(|(name, _)| self.exposes_header(headers, name))
.map(|(name, _)| name.to_ascii_lowercase())
.collect::<std::collections::BTreeSet<_>>();
self.cors_exposed_header_names = Some(names.into_iter().collect());
}
}
}
impl FetchResponseMetadata {
// This earlier phase has no captured request credentials fact. A raw wildcard
// cannot prove credentialless exposure; explicit frozen names remain authoritative.
pub fn exposes_header(&self, headers: &[(String, Vec<u8>)], name: &str) -> bool {
if !self.response_type.is_readable() {
return false;
}
if self.response_type == FetchResponseType::Default {
return true;
}
if name.eq_ignore_ascii_case("set-cookie") || name.eq_ignore_ascii_case("set-cookie2") {
return false;
}
if self.response_type == FetchResponseType::Basic {
return true;
}
if [
"cache-control",
"content-language",
"content-length",
"content-type",
"expires",
"last-modified",
"pragma",
]
.iter()
.any(|safe| name.eq_ignore_ascii_case(safe))
{
return true;
}
if let Some(names) = &self.cors_exposed_header_names {
return names
.iter()
.any(|exposed| exposed.eq_ignore_ascii_case(name));
}
headers
.iter()
.filter(|(field, _)| field.eq_ignore_ascii_case("access-control-expose-headers"))
.flat_map(|(_, value)| value.split(|byte| *byte == b','))
.map(|token| token.trim_ascii())
.any(|token| token.eq_ignore_ascii_case(name.as_bytes()))
}
}
@@ -4,6 +4,7 @@ use moli_v8_util::{get_private_object, get_private_value, set_private_value, v8_
use moli_webapi_declare::WebApiObject;
pub(super) const RESPONSE_METADATA_SLOT: &str = "__moliResponseMetadata";
const CORS_HEADERS_SLOT: &str = "__moliResponseMetadataCorsHeaders";
const TYPE_SLOT: &str = "__moliResponseMetadataType";
const URL_LIST_SLOT: &str = "__moliResponseMetadataUrls";
const TIMING_SLOT: &str = "__moliResponseMetadataTiming";
@@ -12,6 +13,8 @@ const REDIRECTED_SLOT: &str = "__moliResponseMetadataRedirected";
#[derive(WebApiObject)]
#[webapi(plain)]
struct ResponseMetadataDeclaration<'scope> {
#[webapi(slot = CORS_HEADERS_SLOT)]
cors_exposed_header_names: v8::Local<'scope, v8::Value>,
#[webapi(slot = TYPE_SLOT)]
response_type: &'static str,
#[webapi(slot = URL_LIST_SLOT)]
@@ -41,7 +44,22 @@ pub fn set_response_metadata<'s>(
})
.collect();
let urls = v8::Array::new_with_elements(scope, &values);
let cors_headers: v8::Local<'s, v8::Value> =
if let Some(names) = &metadata.cors_exposed_header_names {
let names = names
.iter()
.map(|name| {
v8_string(scope, name)
.expect("native header name fits V8")
.into()
})
.collect::<Vec<_>>();
v8::Array::new_with_elements(scope, &names).into()
} else {
v8::null(scope).into()
};
let value = ResponseMetadataDeclaration::new(
cors_headers,
metadata.response_type.as_str(),
urls,
metadata.timing_allow_passed,
@@ -71,7 +89,19 @@ pub fn response_metadata<'s>(
.ok()
})
.collect::<Option<Vec<_>>>()?;
let cors_headers = get_private_value(scope, metadata, CORS_HEADERS_SLOT)?;
let cors_exposed_header_names = if cors_headers.is_null_or_undefined() {
None
} else {
let names = v8::Local::<v8::Array>::try_from(cors_headers).ok()?;
Some(
(0..names.length())
.map(|index| Some(names.get_index(scope, index)?.to_rust_string_lossy(scope)))
.collect::<Option<Vec<_>>>()?,
)
};
Some(FetchResponseMetadata {
cors_exposed_header_names,
response_type,
url_list,
timing_allow_passed: get_private_value(scope, metadata, TIMING_SLOT)?.boolean_value(scope),