Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(fetch): enforce request modes and CORS before redirects

ldm077783ece9da2
diff --git a/moli-core/tests/fetch.rs b/moli-core/tests/fetch.rs
index 49a8440a3..5808c4c51 100644
--- a/moli-core/tests/fetch.rs
+++ b/moli-core/tests/fetch.rs
@@ -13,6 +13,9 @@ use tokio::net::TcpListener;
use tokio::task::JoinHandle;
use url::Url;
+#[path = "fetch/security.rs"]
+mod security;
+
async fn spawn_stalled_binary_response_server() -> Result<(String, JoinHandle<()>)> {
let listener = TcpListener::bind("127.0.0.1:0").await?;
let address = listener.local_addr()?;
diff --git a/moli-core/tests/fetch/security.rs b/moli-core/tests/fetch/security.rs
new file mode 100644
index 000000000..47bab262b
--- /dev/null
+++ b/moli-core/tests/fetch/security.rs
@@ -0,0 +1,447 @@
+use anyhow::Result;
+use moli_core::runtime::{Browser, BrowserConfig};
+use parking_lot::Mutex;
+use serde_json::{Value, json};
+use std::sync::Arc;
+use tokio::{
+ io::{AsyncReadExt, AsyncWriteExt},
+ net::TcpListener,
+ task::{JoinHandle, JoinSet},
+};
+use url::Url;
+
+#[derive(Debug)]
+struct IncomingRequest {
+ method: String,
+ path: String,
+ origin: Option<String>,
+}
+
+struct SecurityServers {
+ origin: String,
+ cross: String,
+ requests: Arc<Mutex<Vec<IncomingRequest>>>,
+ tasks: Vec<JoinHandle<()>>,
+}
+
+impl Drop for SecurityServers {
+ fn drop(&mut self) {
+ for task in &self.tasks {
+ task.abort();
+ }
+ }
+}
+
+impl SecurityServers {
+ async fn spawn() -> Result<Self> {
+ let main = TcpListener::bind("127.0.0.1:0").await?;
+ let other = TcpListener::bind("127.0.0.1:0").await?;
+ let origin = format!("http://{}", main.local_addr()?);
+ let cross = format!("http://{}", other.local_addr()?);
+ let requests = Arc::new(Mutex::new(Vec::new()));
+ let tasks = [main, other].into_iter().map(|listener| {
+ let requests = Arc::clone(&requests);
+ tokio::spawn(async move {
+ let mut connections = JoinSet::new();
+ loop {
+ tokio::select! {
+ accepted = listener.accept() => {
+ let Ok((mut stream, _)) = accepted else { break };
+ let requests = Arc::clone(&requests);
+ connections.spawn(async move {
+ let mut bytes = Vec::new();
+ while !bytes.ends_with(b"\r\n\r\n") && bytes.len() < 16384 {
+ let Ok(byte) = stream.read_u8().await else { return };
+ bytes.push(byte);
+ }
+ let text = String::from_utf8_lossy(&bytes);
+ let mut parts = text.split_whitespace();
+ let method = parts.next().unwrap_or("").to_owned();
+ let path = parts.next().unwrap_or("/").to_owned();
+ let origin = text.lines().filter_map(|line| line.split_once(':'))
+ .find(|(key, _)| key.eq_ignore_ascii_case("Origin"))
+ .map(|(_, value)| value.trim().to_owned());
+ let request = IncomingRequest { method, path, origin };
+ let (status, headers, body) = fixture_response(&request);
+ requests.lock().push(request);
+ let response = format!("HTTP/1.1 {status} Fixture\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len());
+ let _ = stream.write_all(response.as_bytes()).await;
+ });
+ }
+ _ = connections.join_next(), if !connections.is_empty() => {}
+ }
+ }
+ })
+ }).collect();
+ Ok(Self {
+ origin,
+ cross,
+ requests,
+ tasks,
+ })
+ }
+}
+
+fn fixture_response(request: &IncomingRequest) -> (u16, String, String) {
+ let url = Url::parse(&format!("http://fixture.test{}", request.path)).unwrap();
+ let cors = format!(
+ "Access-Control-Allow-Origin: {}\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Methods: PUT\r\nAccess-Control-Allow-Headers: x-probe\r\n",
+ request.origin.as_deref().unwrap_or("*")
+ );
+ let cache = if url.path().starts_with("/cached-") {
+ "Cache-Control: max-age=600\r\n"
+ } else {
+ "Cache-Control: no-store\r\n"
+ };
+ if url.path() == "/page" {
+ return (
+ 200,
+ "Content-Type: text/html\r\n".to_owned(),
+ "<!doctype html><body>fetch security</body>".to_owned(),
+ );
+ }
+ if url.path() == "/sw.js" {
+ return (
+ 200,
+ "Content-Type: text/javascript\r\nCache-Control: no-store\r\n".to_owned(),
+ r#"
+ const seen = [];
+ self.addEventListener('install', event => event.waitUntil(self.skipWaiting()));
+ self.addEventListener('activate', event => event.waitUntil(self.clients.claim()));
+ self.addEventListener('fetch', event => {
+ const url = new URL(event.request.url);
+ if (url.pathname === '/sw-log') {
+ event.respondWith(new Response(JSON.stringify(seen)));
+ } else if (url.pathname.startsWith('/sw-')) {
+ seen.push(url.pathname);
+ event.respondWith(url.pathname === '/sw-redirect'
+ ? Response.redirect(url.searchParams.get('to'))
+ : new Response('worker'));
+ }
+ });
+ "#
+ .to_owned(),
+ );
+ }
+ if request.method == "OPTIONS" {
+ if let Some(status) = url.path().strip_prefix("/preflight-redirect/") {
+ return (
+ status.parse().unwrap(),
+ format!("{cors}Location: /preflight-target/{status}\r\n"),
+ String::new(),
+ );
+ }
+ return (204, cors, String::new());
+ }
+ if matches!(
+ url.path(),
+ "/redirect-allowed" | "/redirect-denied" | "/cached-redirect"
+ ) {
+ let target = url.query_pairs().find(|(name, _)| name == "to").unwrap().1;
+ let cors = if url.path() == "/redirect-denied" {
+ String::new()
+ } else {
+ cors
+ };
+ return (
+ 302,
+ format!("{cors}{cache}Location: {target}\r\n"),
+ String::new(),
+ );
+ }
+ if url.path() == "/track.vtt" {
+ return (
+ 200,
+ format!("{cors}{cache}Content-Type: text/vtt\r\n"),
+ "WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nhello\n".to_owned(),
+ );
+ }
+ (
+ 200,
+ format!("{cors}{cache}Content-Type: text/plain\r\n"),
+ "ok".to_owned(),
+ )
+}
+
+fn redirect(origin: &str, path: &str, target: &str) -> String {
+ let mut url = Url::parse(&format!("{origin}/{path}")).unwrap();
+ url.query_pairs_mut().append_pair("to", target);
+ url.into()
+}
+
+fn fetch_cases(cases: &Value) -> String {
+ format!(
+ r#"(async () => {{
+ const results = {{}};
+ for (const test of {cases}) {{
+ try {{
+ const response = await fetch(test.url, test);
+ results[test.name] = response.type === 'opaqueredirect'
+ ? response.type : await response.text();
+ }} catch (error) {{ results[test.name] = error.name; }}
+ }}
+ return JSON.stringify(results);
+ }})()"#
+ )
+}
+
+fn results(value: Value) -> Result<Value> {
+ Ok(serde_json::from_str(
+ value["value"].as_str().expect("JSON result"),
+ )?)
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn same_origin_fetch_rejects_before_network_or_preflight() -> Result<()> {
+ let server = SecurityServers::spawn().await?;
+ let browser = Browser::new(BrowserConfig::default())?;
+ let mut page = browser.fetch(&format!("{}/page", server.origin)).await?;
+ let cross_target = format!("{}/forbidden-target", server.cross);
+ let cross_redirect = redirect(&server.origin, "redirect-allowed", &cross_target);
+ let cases = json!([
+ {"name":"same", "url":"/resource", "mode":"same-origin"},
+ {"name":"same-put", "url":"/resource-put", "mode":"same-origin", "method":"PUT", "headers":{"X-Probe":"yes"}},
+ {"name":"cross", "url":format!("{}/forbidden-get", server.cross), "mode":"same-origin"},
+ {"name":"cross-put", "url":format!("{}/forbidden-put", server.cross), "mode":"same-origin", "method":"PUT", "headers":{"X-Probe":"yes"}},
+ {"name":"cors", "url":format!("{}/cors-control", server.cross), "mode":"cors"},
+ {"name":"data", "url":"data:text/plain,ok", "mode":"same-origin"},
+ {"name":"same-redirect", "url":redirect(&server.origin, "redirect-allowed", &format!("{}/local-final", server.origin)), "mode":"same-origin"},
+ {"name":"cross-redirect", "url":cross_redirect, "mode":"same-origin"},
+ {"name":"manual", "url":cross_redirect, "mode":"same-origin", "redirect":"manual"},
+ {"name":"error", "url":cross_redirect, "mode":"same-origin", "redirect":"error"}
+ ]);
+ let observed = results(
+ page.evaluate_runtime_expression_with_await_async(&fetch_cases(&cases), true)
+ .await?,
+ )?;
+ assert_eq!(
+ observed,
+ json!({"same":"ok", "same-put":"ok", "cross":"TypeError", "cross-put":"TypeError", "cors":"ok", "data":"ok", "same-redirect":"ok", "cross-redirect":"TypeError", "manual":"opaqueredirect", "error":"TypeError"})
+ );
+ let requests = server.requests.lock();
+ assert!(
+ !requests
+ .iter()
+ .any(|request| request.path.starts_with("/forbidden-") || request.method == "OPTIONS"),
+ "{requests:?}"
+ );
+ assert!(
+ requests
+ .iter()
+ .any(|request| request.path == "/resource-put" && request.method == "PUT")
+ );
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn cors_and_preflight_rejection_never_issue_redirect_target_requests() -> Result<()> {
+ let server = SecurityServers::spawn().await?;
+ let browser = Browser::new(BrowserConfig::default())?;
+ let mut page = browser.fetch(&format!("{}/page", server.origin)).await?;
+ let forbidden = format!("{}/forbidden-cors-target", server.origin);
+ let mut cases = json!([
+ {"name":"denied", "url":redirect(&server.cross, "redirect-denied", &forbidden), "mode":"cors"},
+ {"name":"denied-include", "url":redirect(&server.cross, "redirect-denied", &forbidden), "mode":"cors", "credentials":"include"},
+ {"name":"allowed", "url":redirect(&server.cross, "redirect-allowed", &format!("{}/allowed-final", server.origin)), "mode":"cors", "credentials":"include"},
+ {"name":"preflight-ok", "url":format!("{}/preflight-ok", server.cross), "method":"PUT", "headers":{"X-Probe":"yes"}}
+ ]);
+ for status in [301, 302, 303, 307, 308] {
+ cases.as_array_mut().unwrap().push(json!({"name":format!("preflight-{status}"), "url":format!("{}/preflight-redirect/{status}", server.cross), "method":"PUT", "headers":{"X-Probe":"yes"}}));
+ }
+ let observed = results(
+ page.evaluate_runtime_expression_with_await_async(&fetch_cases(&cases), true)
+ .await?,
+ )?;
+ for test in cases.as_array().unwrap() {
+ let name = test["name"].as_str().unwrap();
+ assert_eq!(
+ observed[name],
+ if matches!(name, "allowed" | "preflight-ok") {
+ "ok"
+ } else {
+ "TypeError"
+ },
+ "{name}: {observed}"
+ );
+ }
+ let requests = server.requests.lock();
+ assert!(
+ !requests
+ .iter()
+ .any(|request| request.path.starts_with("/forbidden-")
+ || request.path.starts_with("/preflight-target/")),
+ "{requests:?}"
+ );
+ let preflights: Vec<_> = requests
+ .iter()
+ .filter(|request| request.path.starts_with("/preflight-redirect/"))
+ .collect();
+ assert_eq!(preflights.len(), 5, "{requests:?}");
+ assert!(preflights.iter().all(|request| request.method == "OPTIONS"));
+ assert_eq!(
+ requests
+ .iter()
+ .find(|request| request.path == "/allowed-final")
+ .unwrap()
+ .origin
+ .as_deref(),
+ Some("null")
+ );
+ assert!(
+ requests
+ .iter()
+ .any(|request| request.path == "/preflight-ok" && request.method == "PUT")
+ );
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn same_origin_fetch_cannot_reuse_a_cross_origin_memory_cache_entry() -> Result<()> {
+ let server = SecurityServers::spawn().await?;
+ let browser = Browser::new(BrowserConfig::default())?;
+ let mut page = browser.fetch(&format!("{}/page", server.origin)).await?;
+ let url = format!("{}/cached-resource", server.cross);
+ let cases = json!([
+ {"name":"warm", "url":url, "mode":"cors"},
+ {"name":"cached", "url":url, "mode":"cors"},
+ {"name":"same-origin", "url":url, "mode":"same-origin"}
+ ]);
+ let observed = results(
+ page.evaluate_runtime_expression_with_await_async(&fetch_cases(&cases), true)
+ .await?,
+ )?;
+ assert_eq!(
+ observed,
+ json!({"warm":"ok", "cached":"ok", "same-origin":"TypeError"})
+ );
+ let requests = server.requests.lock();
+ assert_eq!(
+ requests
+ .iter()
+ .filter(|request| request.path.starts_with("/cached-"))
+ .count(),
+ 1,
+ "{requests:?}"
+ );
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn same_origin_mode_rejects_before_service_worker_dispatch_and_redispatch() -> Result<()> {
+ let server = SecurityServers::spawn().await?;
+ let browser = Browser::new(BrowserConfig::default())?;
+ let mut page = browser.fetch(&format!("{}/page", server.origin)).await?;
+ page.evaluate_runtime_expression_with_await_async(r#"(async () => {
+ await navigator.serviceWorker.register('/sw.js');
+ await navigator.serviceWorker.ready;
+ if (!navigator.serviceWorker.controller) {
+ await new Promise(resolve => navigator.serviceWorker.addEventListener('controllerchange', resolve, {once:true}));
+ }
+ return true;
+ })()"#, true).await?;
+ let cases = json!([
+ {"name":"safe", "url":"/sw-safe", "mode":"same-origin"},
+ {"name":"cross", "url":format!("{}/sw-cross", server.cross), "mode":"same-origin"},
+ {"name":"redirect", "url":redirect(&server.origin, "sw-redirect", &format!("{}/sw-forbidden-target", server.cross)), "mode":"same-origin"},
+ {"name":"cors", "url":redirect(&server.cross, "sw-redirect", &format!("{}/sw-cors-target", server.origin)), "mode":"cors"},
+ {"name":"fallback", "url":redirect(&server.origin, "sw-redirect", &format!("{}/resource", server.origin)), "mode":"same-origin"},
+ {"name":"preflight", "url":redirect(&server.origin, "sw-redirect", &format!("{}/preflight-redirect/307", server.cross)), "method":"PUT", "headers":{"X-Probe":"yes"}}
+ ]);
+ let observed = results(
+ page.evaluate_runtime_expression_with_await_async(&fetch_cases(&cases), true)
+ .await?,
+ )?;
+ assert_eq!(
+ observed,
+ json!({"safe":"worker", "cross":"TypeError", "redirect":"TypeError", "cors":"worker", "fallback":"ok", "preflight":"TypeError"})
+ );
+ let seen = results(
+ page.evaluate_runtime_expression_with_await_async(
+ "fetch('/sw-log').then(response => response.text())",
+ true,
+ )
+ .await?,
+ )?;
+ assert_eq!(
+ seen,
+ json!([
+ "/sw-safe",
+ "/sw-redirect",
+ "/sw-redirect",
+ "/sw-cors-target",
+ "/sw-redirect",
+ "/sw-redirect"
+ ])
+ );
+ let requests = server.requests.lock();
+ assert!(
+ !requests
+ .iter()
+ .any(|request| request.path.starts_with("/sw-cross")
+ || request.path.starts_with("/sw-forbidden-target")
+ || request.path.starts_with("/preflight-target/")),
+ "{requests:?}"
+ );
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn text_track_without_crossorigin_blocks_cross_origin_before_network() -> Result<()> {
+ let server = SecurityServers::spawn().await?;
+ let mut config = BrowserConfig::default();
+ config.set_optional_resource_fetch_enabled(
+ moli_page_types::SubresourceResourceType::TextTrack,
+ true,
+ );
+ let browser = Browser::new(config)?;
+ let mut page = browser.fetch(&format!("{}/page", server.origin)).await?;
+ let cases = json!([
+ {"name":"same", "url":"/track.vtt?same"},
+ {"name":"cross", "url":format!("{}/track.vtt?cross", server.cross)},
+ {"name":"cors", "url":format!("{}/track.vtt?cors", server.cross), "crossOrigin":"anonymous"},
+ {"name":"redirect", "url":redirect(&server.origin, "redirect-allowed", &format!("{}/track.vtt?forbidden-redirect", server.cross))}
+ ]);
+ let observed = results(
+ page.evaluate_runtime_expression_with_await_async(
+ &format!(
+ r#"(async () => {{
+ const results = {{}};
+ for (const test of {cases}) {{
+ results[test.name] = await new Promise(resolve => {{
+ const media = document.createElement('video');
+ if ('crossOrigin' in test) media.crossOrigin = test.crossOrigin;
+ const track = document.createElement('track');
+ track.onload = () => resolve('load');
+ track.onerror = () => resolve('error');
+ track.src = test.url;
+ media.append(track);
+ document.body.append(media);
+ track.track.mode = 'hidden';
+ }});
+ }}
+ return JSON.stringify(results);
+ }})()"#
+ ),
+ true,
+ )
+ .await?,
+ )?;
+ assert_eq!(
+ observed,
+ json!({"same":"load", "cross":"error", "cors":"load", "redirect":"error"})
+ );
+ let requests = server.requests.lock();
+ assert!(
+ !requests.iter().any(|request| matches!(
+ request.path.as_str(),
+ "/track.vtt?cross" | "/track.vtt?forbidden-redirect"
+ )),
+ "{requests:?}"
+ );
+ assert!(
+ requests
+ .iter()
+ .any(|request| request.path == "/track.vtt?cors")
+ );
+ Ok(())
+}
diff --git a/moli-fetch/src/blocking/cache.rs b/moli-fetch/src/blocking/cache.rs
index fef50220c..7f231a9d4 100644
--- a/moli-fetch/src/blocking/cache.rs
+++ b/moli-fetch/src/blocking/cache.rs
@@ -141,15 +141,25 @@ pub(crate) fn next_redirect_url_from_parts(
}
pub(crate) fn next_followed_redirect_url_from_parts(
+ request: &Request,
final_url: &Url,
status: u16,
headers: &[(String, String)],
redirect_count: usize,
- follow_redirects: bool,
) -> Result<Option<Url>> {
+ // HTTP fetch checks the network response before HTTP-redirect fetch. This
+ // also applies to cached redirects and manual/error redirect modes.
+ if matches!(status, 301 | 302 | 303 | 307 | 308) {
+ request
+ .validate_cors_response_for_url(final_url, headers)
+ .map_err(anyhow::Error::msg)?;
+ }
let next_url = next_redirect_url_from_parts(final_url, status, headers, redirect_count)?;
- if follow_redirects && let Some(next_url) = next_url.as_ref() {
+ if request.follow_redirects
+ && let Some(next_url) = next_url.as_ref()
+ {
ensure_http_network_transport_url(next_url)?;
+ request.validate_request_mode_for_url(next_url)?;
}
Ok(next_url)
}
@@ -183,14 +193,16 @@ mod tests {
"file:///moli-policy-must-not-open".to_owned(),
)];
- let error = next_followed_redirect_url_from_parts(&current, 302, &headers, 0, true)
+ let request = Request::get_with_url(current.clone());
+ let error = next_followed_redirect_url_from_parts(&request, &current, 302, &headers, 0)
.expect_err("followed file redirect must be rejected");
assert_eq!(
error.to_string(),
"URL scheme \"file\" is not supported by the HTTP network transport."
);
- let manual = next_followed_redirect_url_from_parts(&current, 302, &headers, 0, false)?
+ let request = request.with_redirect_mode(crate::RequestRedirectMode::Manual);
+ let manual = next_followed_redirect_url_from_parts(&request, &current, 302, &headers, 0)?
.expect("manual redirect URL should remain observable");
assert_eq!(manual.as_str(), "file:///moli-policy-must-not-open");
Ok(())
diff --git a/moli-fetch/src/cors.rs b/moli-fetch/src/cors.rs
new file mode 100644
index 000000000..20cd75348
--- /dev/null
+++ b/moli-fetch/src/cors.rs
@@ -0,0 +1,45 @@
+use moli_web_mime::response_header_value;
+
+use crate::RequestCredentialsMode;
+
+pub fn validate_cors_response_for_origin(
+ origin: &str,
+ response_headers: &[(String, String)],
+ credentials_mode: RequestCredentialsMode,
+) -> Result<(), String> {
+ let Some(allow_origin) = response_header_value(response_headers, "access-control-allow-origin")
+ else {
+ return Err(format!(
+ "CORS check failed: no Access-Control-Allow-Origin for {origin}"
+ ));
+ };
+ let allow_origin = allow_origin.trim();
+ if allow_origin == "*" {
+ if credentials_mode == RequestCredentialsMode::Include {
+ return Err(format!(
+ "CORS check failed: wildcard Access-Control-Allow-Origin does not allow credentialed requests from {origin}"
+ ));
+ }
+ return Ok(());
+ }
+ if allow_origin != origin {
+ return Err(format!(
+ "CORS check failed: Access-Control-Allow-Origin `{allow_origin}` does not allow {origin}"
+ ));
+ }
+
+ if credentials_mode == RequestCredentialsMode::Include {
+ let allow_credentials =
+ response_header_value(response_headers, "access-control-allow-credentials");
+ if allow_credentials
+ .as_deref()
+ .is_none_or(|value| value.trim() != "true")
+ {
+ return Err(format!(
+ "CORS check failed: credentialed requests from {origin} require Access-Control-Allow-Credentials: true"
+ ));
+ }
+ }
+
+ Ok(())
+}
diff --git a/moli-fetch/src/fetch_url_list.rs b/moli-fetch/src/fetch_url_list.rs
index c5181f7df..b2f1c2da0 100644
--- a/moli-fetch/src/fetch_url_list.rs
+++ b/moli-fetch/src/fetch_url_list.rs
@@ -2,7 +2,7 @@ use moli_cookie_jar::same_site_urls;
use moli_url::{origin_ascii_serialization, same_origin};
use url::Url;
-use crate::{RedirectInfo, RedirectSource};
+use crate::{RedirectInfo, RedirectSource, RequestMode};
/// A borrowed view of the URLs visited by a fetch. Requests and responses use
/// the same rules for redirect taint, including synthetic redirects.
@@ -32,6 +32,22 @@ impl<'a> FetchUrlList<'a> {
self.urls().any(|url| !same_origin(origin, url))
}
+ /// Enforces same-origin mode before dispatch, including after redirects.
+ /// Main fetch permits data URLs regardless of mode. CORS response checks
+ /// are separate: permission from a server cannot relax same-origin mode.
+ pub fn validate_request_mode(self, mode: RequestMode, origin: &Url) -> Result<(), String> {
+ if mode == RequestMode::SameOrigin
+ && self.current_url.scheme() != "data"
+ && self.has_cross_origin_url(origin)
+ {
+ return Err(format!(
+ "same-origin request mode blocked a cross-origin URL in the fetch of {}",
+ self.current_url
+ ));
+ }
+ Ok(())
+ }
+
pub fn has_cross_site_url(self, origin: &Url) -> bool {
self.urls().any(|url| !same_site_urls(origin, url, true))
}
diff --git a/moli-fetch/src/lib.rs b/moli-fetch/src/lib.rs
index 6f0639f13..1195f3892 100644
--- a/moli-fetch/src/lib.rs
+++ b/moli-fetch/src/lib.rs
@@ -9,6 +9,7 @@ mod cancellation;
mod client;
mod client_hints;
mod config;
+mod cors;
mod dns;
mod error;
mod fetch_url_list;
@@ -37,6 +38,7 @@ pub use blocking::{
pub use cancellation::FetchCancelHandle;
pub use client::{FetchClient, FetchClientHandle};
pub use config::FetchConfig;
+pub use cors::validate_cors_response_for_origin;
pub use error::{NET_ERR_ABORTED_ERROR_TEXT, ensure_http_status_success};
pub use fetch_url_list::FetchUrlList;
pub use headers::{
diff --git a/moli-fetch/src/request.rs b/moli-fetch/src/request.rs
index ed6b64f50..25494cbc6 100644
--- a/moli-fetch/src/request.rs
+++ b/moli-fetch/src/request.rs
@@ -667,6 +667,48 @@ impl Request {
FetchUrlList::new(request_url, &self.redirect_chain)
}
+ /// Checks mode restrictions before using a cache entry or starting a hop.
+ pub fn validate_request_mode_for_url(&self, request_url: &Url) -> Result<()> {
+ if self.request_mode != RequestMode::SameOrigin || request_url.scheme() == "data" {
+ return Ok(());
+ }
+ let origin = self
+ .cookie_context
+ .initiator_url
+ .as_ref()
+ .context("same-origin request mode requires an initiating origin")?;
+ self.url_list(request_url)
+ .validate_request_mode(self.request_mode, origin)
+ .map_err(anyhow::Error::msg)
+ }
+
+ /// Checks one network response against the request's state before that
+ /// response's redirect is recorded. Synthetic responses must not use this.
+ pub fn validate_cors_response_for_url(
+ &self,
+ response_url: &Url,
+ response_headers: &[(String, String)],
+ ) -> Result<(), String> {
+ if self.request_mode != RequestMode::Cors
+ || !matches!(response_url.scheme(), "http" | "https")
+ {
+ return Ok(());
+ }
+ let Some(origin) = self.cookie_context.initiator_url.as_ref() else {
+ // Standalone HTTP clients have no browser request origin.
+ return Ok(());
+ };
+ let urls = self.url_list(response_url);
+ if !urls.has_cross_origin_url(origin) {
+ return Ok(());
+ }
+ crate::validate_cors_response_for_origin(
+ &urls.serialized_origin(origin),
+ response_headers,
+ self.credentials_mode,
+ )
+ }
+
/// Whether the URL list has left the initiating origin. For subresource
/// fetches, returning to that origin cannot restore basic response tainting.
pub fn has_cross_origin_url(&self, request_url: &Url) -> bool {
diff --git a/moli-fetch/src/runtime.rs b/moli-fetch/src/runtime.rs
index 37ee418a9..6eef2e4c4 100644
--- a/moli-fetch/src/runtime.rs
+++ b/moli-fetch/src/runtime.rs
@@ -863,6 +863,9 @@ impl RuntimeOwner {
if job.cancel_handle.is_cancelled() {
return Err((job.response_tx, anyhow!("fetch runtime request cancelled")));
}
+ if let Err(error) = job.request.validate_request_mode_for_url(&job.current_url) {
+ return Err((job.response_tx, error));
+ }
let request_cookie_report = if job.request.allows_credentials_for_url(&job.current_url) {
match cookie_access_report_for_request(
&self.cookie_store,
@@ -991,6 +994,9 @@ impl RuntimeOwner {
anyhow::Error,
),
> {
+ if let Err(error) = job.request.validate_request_mode_for_url(&job.current_url) {
+ return Err((Box::new(job), None, error));
+ }
let credentials_allowed = job.request.allows_credentials_for_url(&job.current_url);
let request_cookie_report = if credentials_allowed {
match cookie_access_report_for_request(
@@ -1182,6 +1188,9 @@ impl RuntimeOwner {
anyhow::Error,
),
> {
+ if let Err(error) = job.request.validate_request_mode_for_url(&job.current_url) {
+ return Err((Box::new(job), None, error));
+ }
let credentials_allowed = job.request.allows_credentials_for_url(&job.current_url);
let request_cookie_report = if credentials_allowed {
match cookie_access_report_for_request(
@@ -1516,11 +1525,11 @@ impl RuntimeOwner {
response = response.with_network_request_extra_info(request_extra_info.clone());
let next_url = match next_followed_redirect_url_from_parts(
+ &job.request,
&response.final_url,
response.status,
&response.headers,
job.redirect_count,
- job.request.follow_redirects,
) {
Ok(next_url) => next_url,
Err(error) => return Err((job.response_tx, error)),
@@ -1782,11 +1791,11 @@ impl RuntimeOwner {
);
let next_url = match next_followed_redirect_url_from_parts(
+ &job.request,
&final_url,
status,
&headers,
job.redirect_count,
- job.request.follow_redirects,
) {
Ok(next_url) => next_url,
Err(error) => {
@@ -2165,11 +2174,11 @@ impl RuntimeOwner {
}
let next_url = match next_followed_redirect_url_from_parts(
+ &job.request,
&final_url,
status,
&headers,
job.redirect_count,
- job.request.follow_redirects,
) {
Ok(next_url) => next_url,
Err(error) => {
@@ -2329,11 +2338,11 @@ impl RuntimeOwner {
}
};
let next_url = match next_followed_redirect_url_from_parts(
+ &job.request,
&final_url,
cached.status,
&cached.headers,
job.redirect_count,
- job.request.follow_redirects,
) {
Ok(next_url) => next_url,
Err(error) => return Err((Box::new(job), error)),
@@ -2391,11 +2400,11 @@ impl RuntimeOwner {
}
};
let next_url = match next_followed_redirect_url_from_parts(
+ &job.request,
&final_url,
cached.status,
&cached.headers,
job.redirect_count,
- job.request.follow_redirects,
) {
Ok(next_url) => next_url,
Err(error) => return Err((Box::new(job), error)),
diff --git a/moli-fetch/src/tests/mod.rs b/moli-fetch/src/tests/mod.rs
index 1c949516e..79a04c5e8 100644
--- a/moli-fetch/src/tests/mod.rs
+++ b/moli-fetch/src/tests/mod.rs
@@ -1,6 +1,7 @@
mod cookie_context;
mod cookie_store;
mod mixed_transport;
+mod request_security;
mod support;
mod tls_credentials;
mod websocket_transport;
diff --git a/moli-fetch/src/tests/request_security.rs b/moli-fetch/src/tests/request_security.rs
new file mode 100644
index 000000000..aebfc8fc3
--- /dev/null
+++ b/moli-fetch/src/tests/request_security.rs
@@ -0,0 +1,325 @@
+use super::*;
+use crate::{RedirectInfo, RedirectSource};
+
+#[derive(Clone, Copy, Debug)]
+enum Transport {
+ Buffered,
+ Html,
+ Raw,
+}
+
+impl Transport {
+ const ALL: [Self; 3] = [Self::Buffered, Self::Html, Self::Raw];
+
+ async fn fetch(self, client: &FetchClientHandle, request: Request) -> Result<()> {
+ match self {
+ Self::Buffered => {
+ let (tx, rx) = oneshot::channel();
+ client.fetch_with_cancel_callback(
+ request,
+ FetchCancelHandle::new(),
+ move |result| {
+ let _ = tx.send(result);
+ },
+ )?;
+ rx.await??;
+ }
+ Self::Html => {
+ let mut response = client.fetch_html_stream(request).await?;
+ while response.next_chunk().await.is_some() {}
+ response.finish().await?;
+ }
+ Self::Raw => {
+ client.fetch(request).await?;
+ }
+ }
+ Ok(())
+ }
+}
+
+fn synthetic_redirect(from: &Url, to: &Url) -> RedirectInfo {
+ RedirectInfo {
+ source: RedirectSource::ServiceWorker,
+ from_url: from.clone(),
+ to_url: to.clone(),
+ status: 302,
+ headers: vec![("Location".to_owned(), to.to_string())],
+ 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,
+ }
+}
+
+#[tokio::test]
+async fn same_origin_mode_blocks_cross_origin_before_every_transport() -> Result<()> {
+ let server = ScriptedHttpServer::spawn(vec![
+ ScriptedResponse::ok("forbidden").with_header("Access-Control-Allow-Origin", "*"),
+ ]);
+ let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
+ for transport in Transport::ALL {
+ for origin in [Some(Url::parse("http://other.test/")?), None] {
+ let mut request =
+ Request::get(&server.url())?.with_request_mode(RequestMode::SameOrigin);
+ if let Some(origin) = origin {
+ request = request.with_initiator_url(&origin);
+ }
+ let error = transport.fetch(&client, request).await.unwrap_err();
+ assert!(
+ error.to_string().contains("same-origin request mode"),
+ "{transport:?}: {error:#}"
+ );
+ }
+ }
+ assert_eq!(
+ server.hits(),
+ 0,
+ "rejected requests must not reach the server"
+ );
+ server.shutdown();
+ Ok(())
+}
+
+#[tokio::test]
+async fn same_origin_mode_checks_redirects_in_every_transport() -> Result<()> {
+ let target = ScriptedHttpServer::spawn(vec![
+ ScriptedResponse::ok("forbidden").with_header("Access-Control-Allow-Origin", "*"),
+ ]);
+ for transport in Transport::ALL {
+ let server = ScriptedHttpServer::spawn(vec![
+ ScriptedResponse::status(302, "Found").with_header("Location", "/final"),
+ ScriptedResponse::ok("ok"),
+ ScriptedResponse::status(302, "Found").with_header("Location", &target.url()),
+ ]);
+ let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
+ let request = Request::get(&server.url())?
+ .with_initiator_url(&Url::parse(&server.origin())?)
+ .with_request_mode(RequestMode::SameOrigin);
+ transport.fetch(&client, request.clone()).await?;
+ let error = transport.fetch(&client, request).await.unwrap_err();
+ assert!(
+ error.to_string().contains("same-origin request mode"),
+ "{transport:?}: {error:#}"
+ );
+ assert_eq!(server.hits(), 3);
+ server.shutdown();
+ }
+ assert_eq!(
+ target.hits(),
+ 0,
+ "cross-origin redirect must not be followed"
+ );
+ target.shutdown();
+ Ok(())
+}
+
+#[tokio::test]
+async fn same_origin_mode_rejects_inherited_cross_origin_history() -> Result<()> {
+ let server = ScriptedHttpServer::spawn(vec![ScriptedResponse::ok("forbidden")]);
+ let url = Url::parse(&server.url())?;
+ let request = Request::get_with_url(url.clone())
+ .with_initiator_url(&url)
+ .with_request_mode(RequestMode::SameOrigin)
+ .with_redirect_chain(vec![synthetic_redirect(
+ &Url::parse("http://other.test/start")?,
+ &url,
+ )]);
+ let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
+ for transport in Transport::ALL {
+ let error = transport.fetch(&client, request.clone()).await.unwrap_err();
+ assert!(
+ error.to_string().contains("same-origin request mode"),
+ "{transport:?}: {error:#}"
+ );
+ }
+ assert_eq!(server.hits(), 0);
+ server.shutdown();
+ Ok(())
+}
+
+#[tokio::test]
+async fn cors_redirect_rejection_never_contacts_next_hop() -> Result<()> {
+ let origin = Url::parse("http://origin.test/")?;
+ let target = ScriptedHttpServer::spawn(vec![ScriptedResponse::ok("forbidden")]);
+ for transport in Transport::ALL {
+ for (allow_origin, allow_credentials, credentials) in [
+ (None, false, RequestCredentialsMode::SameOrigin),
+ (None, false, RequestCredentialsMode::Include),
+ (
+ Some("http://wrong.test"),
+ false,
+ RequestCredentialsMode::SameOrigin,
+ ),
+ (Some("*"), true, RequestCredentialsMode::Include),
+ (
+ Some("http://origin.test"),
+ false,
+ RequestCredentialsMode::Include,
+ ),
+ ] {
+ let mut redirect =
+ ScriptedResponse::status(302, "Found").with_header("Location", &target.url());
+ if let Some(value) = allow_origin {
+ redirect = redirect.with_header("Access-Control-Allow-Origin", value);
+ }
+ if allow_credentials {
+ redirect = redirect.with_header("Access-Control-Allow-Credentials", "true");
+ }
+ let server = ScriptedHttpServer::spawn(vec![redirect]);
+ let client =
+ FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
+ let request = Request::get(&server.url())?
+ .with_initiator_url(&origin)
+ .with_request_mode(RequestMode::Cors)
+ .with_credentials_mode(credentials);
+ let error = transport.fetch(&client, request).await.unwrap_err();
+ assert!(
+ error.to_string().contains("CORS check failed:"),
+ "{transport:?}, {credentials:?}: {error:#}"
+ );
+ assert_eq!(server.hits(), 1);
+ assert_eq!(target.hits(), 0, "CORS must fail before the next request");
+ server.shutdown();
+ }
+ }
+ target.shutdown();
+ Ok(())
+}
+
+#[tokio::test]
+async fn cors_redirect_validates_the_origin_before_recording_the_hop() -> Result<()> {
+ for transport in Transport::ALL {
+ for credentials in [
+ RequestCredentialsMode::SameOrigin,
+ RequestCredentialsMode::Include,
+ ] {
+ let origin = Url::parse("http://origin.test/")?;
+ let target = ScriptedHttpServer::spawn(vec![ScriptedResponse::ok("ok")]);
+ let server = ScriptedHttpServer::spawn(vec![
+ ScriptedResponse::status(302, "Found")
+ .with_header("Location", &target.url())
+ .with_header("Access-Control-Allow-Origin", "http://origin.test")
+ .with_header("Access-Control-Allow-Credentials", "true"),
+ ]);
+ let client =
+ FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
+ let request = Request::get(&server.url())?
+ .with_initiator_url(&origin)
+ .with_request_mode(RequestMode::Cors)
+ .with_credentials_mode(credentials);
+ transport.fetch(&client, request).await?;
+ assert_eq!(server.hits(), 1);
+ assert_eq!(target.hits(), 1);
+ assert!(
+ server.requests()[0]
+ .to_ascii_lowercase()
+ .contains("\r\norigin: http://origin.test\r\n")
+ );
+ assert!(
+ target.requests()[0]
+ .to_ascii_lowercase()
+ .contains("\r\norigin: null\r\n")
+ );
+ server.shutdown();
+ target.shutdown();
+ }
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn cors_redirect_inherits_synthetic_redirect_taint_without_checking_synthetic_headers()
+-> Result<()> {
+ for transport in Transport::ALL {
+ for (allow_origin, allowed) in [("null", true), ("http://old.test", false)] {
+ let target = ScriptedHttpServer::spawn(vec![ScriptedResponse::ok("ok")]);
+ let server = ScriptedHttpServer::spawn(vec![
+ ScriptedResponse::status(302, "Found")
+ .with_header("Location", &target.url())
+ .with_header("Access-Control-Allow-Origin", allow_origin),
+ ]);
+ let url = Url::parse(&server.url())?;
+ let request = Request::get_with_url(url.clone())
+ .with_initiator_url(&url)
+ .with_request_mode(RequestMode::Cors)
+ .with_credentials_mode(RequestCredentialsMode::SameOrigin)
+ .with_redirect_chain(vec![synthetic_redirect(
+ &Url::parse("http://cross.test/sw")?,
+ &url,
+ )]);
+ let client =
+ FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
+ let result = transport.fetch(&client, request).await;
+ if allowed {
+ result?;
+ } else {
+ assert!(
+ result
+ .unwrap_err()
+ .to_string()
+ .contains("CORS check failed:")
+ );
+ }
+ assert_eq!(server.hits(), 1);
+ assert_eq!(target.hits(), usize::from(allowed));
+ server.shutdown();
+ target.shutdown();
+ }
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn cached_redirects_enforce_cors_and_same_origin_before_follow() -> Result<()> {
+ for transport in [Transport::Html, Transport::Raw] {
+ for mode in [RequestMode::Cors, RequestMode::SameOrigin] {
+ let cache_dir = unique_test_cache_dir();
+ let mut config = FetchConfig::default();
+ config.set_http_cache_dir(Some(cache_dir.display().to_string()));
+ let target = ScriptedHttpServer::spawn(vec![ScriptedResponse::ok("ok")]);
+ let server = ScriptedHttpServer::spawn(vec![
+ ScriptedResponse::status(302, "Found")
+ .with_header("Location", &target.url())
+ .with_header("Cache-Control", "max-age=600"),
+ ]);
+ let origin = if mode == RequestMode::SameOrigin {
+ Url::parse(&server.origin())?
+ } else {
+ Url::parse("http://other.test/")?
+ };
+ let request = Request::get(&server.url())?
+ .with_initiator_url(&origin)
+ .with_request_mode(RequestMode::NoCors);
+ let client = FetchClient::new(&config, new_shared_browser_cookie_store());
+ transport.fetch(&client, request.clone()).await?;
+ let error = transport
+ .fetch(&client, request.with_request_mode(mode))
+ .await
+ .unwrap_err();
+ let expected = if mode == RequestMode::SameOrigin {
+ "same-origin request mode"
+ } else {
+ "CORS check failed:"
+ };
+ assert!(
+ error.to_string().contains(expected),
+ "{transport:?}, {mode:?}: {error:#}"
+ );
+ assert_eq!(server.hits(), 1, "the second redirect must come from cache");
+ assert_eq!(
+ target.hits(),
+ 1,
+ "the rejected cached redirect must not contact its target"
+ );
+ server.shutdown();
+ target.shutdown();
+ drop(client);
+ fs::remove_dir_all(cache_dir)?;
+ }
+ }
+ Ok(())
+}
diff --git a/moli-fetch/src/tests/tls_credentials.rs b/moli-fetch/src/tests/tls_credentials.rs
index 87675b5af..7b3173d2f 100644
--- a/moli-fetch/src/tests/tls_credentials.rs
+++ b/moli-fetch/src/tests/tls_credentials.rs
@@ -155,6 +155,10 @@ impl TlsServer {
}
let head = String::from_utf8(head)?;
let path = head.split_whitespace().nth(1).unwrap().to_owned();
+ let cors_headers = head.lines().filter_map(|line| line.split_once(':'))
+ .find(|(name, _)| name.eq_ignore_ascii_case("Origin"))
+ .map(|(_, origin)| format!("Access-Control-Allow-Origin: {}\r\nAccess-Control-Allow-Credentials: true\r\n", origin.trim()))
+ .unwrap_or_default();
observed.lock().push(ObservedRequest {
connection_id,
path: path.clone(),
@@ -162,12 +166,12 @@ impl TlsServer {
});
let response = match path.as_str() {
"/redirect-cross" => format!(
- "HTTP/1.1 302 Found\r\nLocation: https://localhost:{port}/redirect-back\r\nContent-Length: 0\r\n\r\n"
+ "HTTP/1.1 302 Found\r\n{cors_headers}Location: https://localhost:{port}/redirect-back\r\nContent-Length: 0\r\n\r\n"
),
"/redirect-back" => format!(
- "HTTP/1.1 302 Found\r\nLocation: https://127.0.0.1:{port}/whoami\r\nContent-Length: 0\r\n\r\n"
+ "HTTP/1.1 302 Found\r\n{cors_headers}Location: https://127.0.0.1:{port}/whoami\r\nContent-Length: 0\r\n\r\n"
),
- _ => "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 2\r\n\r\nok".to_owned(),
+ _ => format!("HTTP/1.1 200 OK\r\n{cors_headers}Content-Type: text/plain\r\nContent-Length: 2\r\n\r\nok"),
};
// HTTP/1.1 stays open for further requests, including
// any incorrect reuse of an authenticated connection.
diff --git a/moli-renderer-v8/src/network/request_client.rs b/moli-renderer-v8/src/network/request_client.rs
index 6365722d8..fef50311e 100644
--- a/moli-renderer-v8/src/network/request_client.rs
+++ b/moli-renderer-v8/src/network/request_client.rs
@@ -1055,9 +1055,12 @@ impl ResourceRequestClient {
if let Some(browser_site_context) = self.browser_site_context.as_deref() {
request = request.with_browser_site_context(browser_site_context.clone());
}
- self.page_network_policy
+ let request = self
+ .page_network_policy
.snapshot()
- .apply_to_request(request)
+ .apply_to_request(request)?;
+ request.validate_request_mode_for_url(&request.url)?;
+ Ok(request)
}
}
diff --git a/moli-renderer-v8/src/network_host/async_fetch.rs b/moli-renderer-v8/src/network_host/async_fetch.rs
index 24fd2b529..694d2ed14 100644
--- a/moli-renderer-v8/src/network_host/async_fetch.rs
+++ b/moli-renderer-v8/src/network_host/async_fetch.rs
@@ -1,4 +1,3 @@
-use super::response::validate_cors_response_for_origin;
use super::*;
use moli_fetch::{
BrowserRequestMetadata, FetchCancelHandle, NetworkFetchResult, RedirectInfo,
@@ -109,7 +108,7 @@ pub(crate) fn browser_request_needs_manual_preflight_redirects(
| BrowserRequestMetadata::StyleModule
| BrowserRequestMetadata::Xhr,
)
- ) && request.request_mode != RequestMode::NoCors
+ ) && request.request_mode == RequestMode::Cors
&& request.cookie_context.initiator_url.is_some()
&& (!is_cors_safelisted_method(&request.method)
|| !moli_fetch::cors_unsafe_request_header_names(preflight_request_headers).is_empty())
@@ -316,17 +315,7 @@ fn validate_actual_cors_response_head(
request: &Request,
response: &ResponseHead,
) -> Result<(), String> {
- if request.request_mode == RequestMode::NoCors
- || !matches!(response.final_url.scheme(), "http" | "https")
- || !request.has_cross_origin_url(&response.final_url)
- {
- return Ok(());
- }
- validate_cors_response_for_origin(
- &request.serialized_origin(),
- &response.headers,
- request.credentials_mode,
- )
+ request.validate_cors_response_for_url(&response.final_url, &response.headers)
}
fn next_redirect_url(
@@ -412,7 +401,7 @@ async fn run_cors_preflight_if_needed(
preflight_observer: Option<&CorsPreflightNetworkObserver>,
) -> Result<(), String> {
if let Some(initiator_url) = request.cookie_context.initiator_url.clone()
- && request.request_mode != RequestMode::NoCors
+ && request.request_mode == RequestMode::Cors
&& let Some(preflight_headers) = cors_preflight_request_headers(
request.has_cross_origin_url(&request.url),
&request.url,
@@ -424,6 +413,9 @@ async fn run_cors_preflight_if_needed(
let mut preflight_request =
Request::new("OPTIONS", request.url.as_str(), None, preflight_headers)
.map_err(|error| format!("cors preflight: failed to build request: {error}"))?
+ // Preflight performs one HTTP exchange; a redirect is a
+ // non-ok response, never another OPTIONS request.
+ .with_redirect_mode(RequestRedirectMode::Manual)
.with_initiator_url(&initiator_url)
.with_credentials_mode(RequestCredentialsMode::SameOrigin)
.with_redirect_chain(request.redirect_chain().to_vec())
@@ -461,12 +453,6 @@ async fn run_cors_preflight_if_needed(
&preflight_response,
);
}
- if preflight_response.redirect_chain.len() > request.redirect_chain().len() {
- return Err(format!(
- "CORS preflight failed: preflight request redirected to {}",
- preflight_response.final_url
- ));
- }
validate_cors_preflight_response(
&request.serialized_origin(),
request.credentials_mode,
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs b/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs
index b0de5f165..43b2382e6 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs
@@ -233,7 +233,7 @@ pub(super) fn spawn_network_fetch(
policy_context: prepared.policy_context,
};
let cancel_handle = FetchCancelHandle::new();
- let requires_preflight = prepared.request_mode != moli_fetch::RequestMode::NoCors
+ let requires_preflight = prepared.request_mode == moli_fetch::RequestMode::Cors
&& crate::network_host::cors_preflight_request_headers(
!moli_url::same_origin(&prepared.document_url, &prepared.resolved_url),
&prepared.resolved_url,
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs
index b2877026a..9de0ec863 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs
@@ -40,7 +40,7 @@ pub(super) fn dispatch_service_worker_fetch(
resource_type: SubresourceResourceType::Fetch,
policy_context: prepared.policy_context,
};
- let requires_preflight = prepared.request_mode != moli_fetch::RequestMode::NoCors
+ let requires_preflight = prepared.request_mode == moli_fetch::RequestMode::Cors
&& crate::network_host::cors_preflight_request_headers(
!moli_url::same_origin(&prepared.document_url, &prepared.resolved_url),
&prepared.resolved_url,
diff --git a/moli-renderer-v8/src/network_host/response.rs b/moli-renderer-v8/src/network_host/response.rs
index 8f5463ec1..98a74a319 100644
--- a/moli-renderer-v8/src/network_host/response.rs
+++ b/moli-renderer-v8/src/network_host/response.rs
@@ -16,7 +16,6 @@ pub(crate) use self::cors::{
FetchResponseSecurityViolation, cors_preflight_request_headers,
filter_cors_exposed_response_headers, is_cors_policy_failure_message,
validate_cors_preflight_response, validate_cors_response_chain,
- validate_cors_response_for_origin,
validate_cross_origin_embedder_and_document_isolation_policy,
validate_cross_origin_resource_policy, validate_fetch_response_security_policy,
validate_fetch_response_security_policy_with_body,
diff --git a/moli-renderer-v8/src/network_host/response/cors.rs b/moli-renderer-v8/src/network_host/response/cors.rs
index e697ff742..a7793dad9 100644
--- a/moli-renderer-v8/src/network_host/response/cors.rs
+++ b/moli-renderer-v8/src/network_host/response/cors.rs
@@ -1,3 +1,5 @@
+use moli_fetch::validate_cors_response_for_origin;
+
use moli_cookie_jar::same_site_urls;
use moli_fetch::{RedirectSource, RequestCredentialsMode, RequestMode};
use moli_url::{origin_ascii_serialization, same_origin};
@@ -71,48 +73,6 @@ pub(crate) fn validate_cors_response_chain(
Ok(())
}
-pub(crate) fn validate_cors_response_for_origin(
- origin: &str,
- response_headers: &[(String, String)],
- credentials_mode: RequestCredentialsMode,
-) -> Result<(), String> {
- let Some(allow_origin) = response_header_value(response_headers, "access-control-allow-origin")
- else {
- return Err(format!(
- "CORS check failed: no Access-Control-Allow-Origin for {origin}"
- ));
- };
- let allow_origin = allow_origin.trim();
- if allow_origin == "*" {
- if credentials_mode == RequestCredentialsMode::Include {
- return Err(format!(
- "CORS check failed: wildcard Access-Control-Allow-Origin does not allow credentialed requests from {origin}"
- ));
- }
- return Ok(());
- }
- if allow_origin != origin {
- return Err(format!(
- "CORS check failed: Access-Control-Allow-Origin `{allow_origin}` does not allow {origin}"
- ));
- }
-
- if credentials_mode == RequestCredentialsMode::Include {
- let allow_credentials =
- response_header_value(response_headers, "access-control-allow-credentials");
- if allow_credentials
- .as_deref()
- .is_none_or(|value| value.trim() != "true")
- {
- return Err(format!(
- "CORS check failed: credentialed requests from {origin} require Access-Control-Allow-Credentials: true"
- ));
- }
- }
-
- Ok(())
-}
-
pub(crate) fn validate_fetch_response_security_policy(
document_url: &url::Url,
head: &moli_fetch::ResponseHead,
@@ -120,6 +80,11 @@ pub(crate) fn validate_fetch_response_security_policy(
credentials_mode: RequestCredentialsMode,
policy_context: crate::types::SubresourcePolicyContext,
) -> Result<(), String> {
+ head.url_list()
+ .validate_request_mode(request_mode, document_url)?;
+ if request_mode == RequestMode::SameOrigin {
+ return Ok(());
+ }
if request_mode == RequestMode::NoCors {
validate_cross_origin_resource_policy(document_url, &head.final_url, &head.headers)?;
validate_cross_origin_embedder_and_document_isolation_policy(
@@ -164,6 +129,12 @@ pub(crate) fn validate_fetch_response_security_policy_with_body_classified(
credentials_mode: RequestCredentialsMode,
policy_context: crate::types::SubresourcePolicyContext,
) -> Result<(), FetchResponseSecurityViolation> {
+ head.url_list()
+ .validate_request_mode(request_mode, document_url)
+ .map_err(FetchResponseSecurityViolation::Rejected)?;
+ if request_mode == RequestMode::SameOrigin {
+ return Ok(());
+ }
if request_mode == RequestMode::NoCors {
validate_cross_origin_resource_policy(document_url, &head.final_url, &head.headers)
.map_err(FetchResponseSecurityViolation::Rejected)?;
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
index 1f94af339..d3f324dce 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
@@ -14613,6 +14613,7 @@ async fn spawn_connection_drop_http_server(path: &'static str) -> (String, JoinH
}
async fn spawn_redirect_loop_http_server(path: &'static str) -> (String, JoinHandle<()>) {
+ // Keep each hop CORS-eligible so the test reaches the redirect limit.
const REDIRECT_LOOP_REQUESTS: usize = 11;
let listener = TcpListener::bind("127.0.0.1:0")
.await
@@ -14628,7 +14629,7 @@ async fn spawn_redirect_loop_http_server(path: &'static str) -> (String, JoinHan
.await
.expect("read redirect-loop request");
let response = format!(
- "HTTP/1.1 302 Found\r\nLocation: {path}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+ "HTTP/1.1 302 Found\r\nAccess-Control-Allow-Origin: *\r\nLocation: {path}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
);
stream
.write_all(response.as_bytes())
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs
index 444fbbb36..3cb4fc111 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs
@@ -1345,6 +1345,8 @@ async fn spawn_sw_return_redirect_servers() -> (String, JoinHandle<()>, JoinHand
let final_url = format!("{source_base_url}/redirect-target.js");
let cross_url = format!("http://{cross_addr}/redirect-middle.js");
+ // All network responses permit CORS: rejection must still account for
+ // the cross-origin URL in the classic worker script's redirect history.
let cross_server = tokio::spawn(async move {
let (mut stream, _) = cross_listener
.accept()
@@ -1360,7 +1362,7 @@ async fn spawn_sw_return_redirect_servers() -> (String, JoinHandle<()>, JoinHand
.expect("shared worker intermediate redirect request path");
assert_eq!(request_path, "/redirect-middle.js");
let response = format!(
- "HTTP/1.1 302 Found\r\nLocation: {final_url}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+ "HTTP/1.1 302 Found\r\nAccess-Control-Allow-Origin: http://{source_addr}\r\nAccess-Control-Allow-Credentials: true\r\nLocation: {final_url}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
);
stream
.write_all(response.as_bytes())
@@ -1405,7 +1407,7 @@ async fn spawn_sw_return_redirect_servers() -> (String, JoinHandle<()>, JoinHand
assert_eq!(request_path, "/redirect-target.js");
let body = r#"onconnect = (event) => event.ports[0].postMessage("executed-returned-same-origin");"#;
let response = format!(
- "HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+ "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Origin: null\r\nAccess-Control-Allow-Credentials: true\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
diff --git a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs
index df5b88ac2..c952b1c53 100644
--- a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs
+++ b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs
@@ -298,6 +298,16 @@ impl ServiceWorkerRuntimeService {
mut fetch_job: ServiceWorkerFetchJob,
request: ServiceWorkerFetchRequest,
) -> Result<(), Box<ServiceWorkerFetchJob>> {
+ if let Err(error) =
+ moli_fetch::FetchUrlList::new(&fetch_job.request_url, &fetch_job.redirect_chain)
+ .validate_request_mode(
+ fetch_job.request_mode,
+ &fetch_job.network_context.document_url,
+ )
+ {
+ self.complete_fetch_with_failure(fetch_job, error);
+ return Ok(());
+ }
let (dispatch_event, start_launch, fallback_job) = {
let mut state = self.inner.state.lock();
let (document_url, storage_key) = match state.live_clients.get(&request.client_id) {
diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs
index c3fbd9878..205fbce4c 100644
--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs
@@ -1004,6 +1004,7 @@ async fn spawn_connection_drop_http_server(path: &'static str) -> (String, JoinH
}
async fn spawn_redirect_loop_http_server(path: &'static str) -> (String, JoinHandle<()>) {
+ // Keep each hop CORS-eligible so the test reaches the redirect limit.
const REDIRECT_LOOP_REQUESTS: usize = 11;
let listener = TcpListener::bind("127.0.0.1:0")
.await
@@ -1019,7 +1020,7 @@ async fn spawn_redirect_loop_http_server(path: &'static str) -> (String, JoinHan
.await
.expect("read worker redirect-loop request");
let response = format!(
- "HTTP/1.1 302 Found\r\nLocation: {path}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+ "HTTP/1.1 302 Found\r\nAccess-Control-Allow-Origin: *\r\nLocation: {path}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
);
stream
.write_all(response.as_bytes())