Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(fetch): enforce request modes and CORS before redirects
ldm077783ece9da2
diff --git a/moli-core/tests/fetch.rs b/moli-core/tests/fetch.rsindex 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.rsnew file mode 100644index 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.rsindex 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(¤t, 302, &headers, 0, true)+ let request = Request::get_with_url(current.clone());+ let error = next_followed_redirect_url_from_parts(&request, ¤t, 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(¤t, 302, &headers, 0, false)?+ let request = request.with_redirect_mode(crate::RequestRedirectMode::Manual);+ let manual = next_followed_redirect_url_from_parts(&request, ¤t, 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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<()>, JoinHandlet 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<()>, JoinHandassert_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.rsindex 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.rsindex 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())