Lightweight coding agent that runs in your terminal
Rust
Restrict MCP HTTP redirects to the configured origin (#39046)
Eric Trautff770113ca37
diff --git a/codex-rs/rmcp-client/src/http_client_adapter.rs b/codex-rs/rmcp-client/src/http_client_adapter.rsindex 2564aef3a1..c2327735f8 100644--- a/codex-rs/rmcp-client/src/http_client_adapter.rs+++ b/codex-rs/rmcp-client/src/http_client_adapter.rs@@ -56,6 +56,7 @@ use sse_stream::SseStream;use tokio::sync::oneshot;use crate::event_notification_transport::MAX_EVENT_NOTIFICATION_BYTES;+use crate::http_client_redirect::SameOriginRedirectHttpClient;use crate::incoming_jsonrpc::deserialize_incoming_jsonrpc_message;use crate::incoming_jsonrpc::normalize_sse_jsonrpc_message;use crate::local_stdio_transport::MAX_MCP_STDIO_LINE_BYTES;@@ -124,7 +125,7 @@ impl StreamableHttpClientAdapter {initialize_deadline: Arc<Mutex<Option<Instant>>>,) -> Self {Self {- http_client,+ http_client: Arc::new(SameOriginRedirectHttpClient::new(http_client)),default_headers,auth_provider,event_stream_cancellations: Arc::default(),diff --git a/codex-rs/rmcp-client/src/http_client_redirect.rs b/codex-rs/rmcp-client/src/http_client_redirect.rsnew file mode 100644index 0000000000..fa73b66b36--- /dev/null+++ b/codex-rs/rmcp-client/src/http_client_redirect.rs@@ -0,0 +1,221 @@+//! Restricts MCP HTTP redirects to the configured server's origin.+//!+//! MCP requests can carry sensitive headers and tool-call bodies. Following a+//! cross-origin redirect would send them to another server or an internal+//! service, so this transport validates each redirect before following it.++use std::sync::Arc;+use std::time::Duration;+use std::time::Instant;++use codex_exec_server::ExecServerError;+use codex_exec_server::HttpClient;+use codex_exec_server::HttpHeader;+use codex_exec_server::HttpRedirectPolicy;+use codex_exec_server::HttpRequestParams;+use codex_exec_server::HttpRequestResponse;+use codex_exec_server::HttpResponseBodyStream;+use futures::FutureExt;+use futures::future::BoxFuture;+use http::HeaderValue;+use http::StatusCode;+use url::Url;++const MAX_REDIRECTS: usize = 10;++pub(crate) struct SameOriginRedirectHttpClient {+ inner: Arc<dyn HttpClient>,+}++enum RedirectResponse {+ Buffered(HttpRequestResponse),+ Streaming(HttpRequestResponse, HttpResponseBodyStream),+}++impl SameOriginRedirectHttpClient {+ pub(crate) fn new(inner: Arc<dyn HttpClient>) -> Self {+ Self { inner }+ }++ async fn execute(+ &self,+ mut params: HttpRequestParams,+ ) -> Result<RedirectResponse, ExecServerError> {+ // Inspect each Location ourselves before the underlying client can send+ // sensitive request data to the redirect destination.+ params.redirect_policy = HttpRedirectPolicy::Stop;+ let mut current_url = Url::parse(¶ms.url)+ .map_err(|error| ExecServerError::HttpRequest(error.to_string()))?;+ let original_origin = current_url.origin();+ // Redirect hops share the original timeout instead of restarting it.+ let deadline = params+ .timeout_ms+ .map(|timeout_ms| Instant::now() + Duration::from_millis(timeout_ms));+ let mut redirects = 0;++ loop {+ if let Some(deadline) = deadline {+ let Some(remaining) = deadline.checked_duration_since(Instant::now()) else {+ return Err(ExecServerError::HttpRequest(+ "MCP HTTP request timed out".to_string(),+ ));+ };+ params.timeout_ms = Some(+ u64::try_from(remaining.as_millis())+ .unwrap_or(u64::MAX)+ .max(1),+ );+ }++ let result = if params.stream_response {+ let (response, stream) = self.inner.http_request_stream(params.clone()).await?;+ RedirectResponse::Streaming(response, stream)+ } else {+ RedirectResponse::Buffered(self.inner.http_request(params.clone()).await?)+ };+ let response = match &result {+ RedirectResponse::Buffered(response) | RedirectResponse::Streaming(response, _) => {+ response+ }+ };+ let status = StatusCode::from_u16(response.status).ok();+ if !matches!(+ status,+ Some(+ StatusCode::MOVED_PERMANENTLY+ | StatusCode::FOUND+ | StatusCode::SEE_OTHER+ | StatusCode::TEMPORARY_REDIRECT+ | StatusCode::PERMANENT_REDIRECT+ )+ ) {+ return Ok(result);+ }++ let Some(location) = response+ .headers+ .iter()+ .find(|header| header.name.eq_ignore_ascii_case("location"))+ .map(|header| header.value.as_str())+ else {+ return Ok(result);+ };+ let next_url = current_url+ .join(location)+ .map_err(|error| ExecServerError::HttpRequest(error.to_string()))?;+ // Compare every hop with the configured origin so redirect chains+ // cannot escape it through a later cross-origin Location.+ if next_url.origin() != original_origin {+ return Err(ExecServerError::HttpRequest(+ "MCP HTTP redirect to a different origin is not allowed".to_string(),+ ));+ }+ // A hostname can resolve to a different address on the next HTTP+ // connection. HTTPS authenticates the hostname; localhost and IP+ // literals do not depend on attacker-controlled DNS.+ if next_url.scheme() == "http"+ && matches!(next_url.host(), Some(url::Host::Domain(host)) if host != "localhost")+ {+ return Err(ExecServerError::HttpRequest(+ "MCP HTTP redirects for non-loopback hostnames require HTTPS".to_string(),+ ));+ }+ if redirects >= MAX_REDIRECTS {+ return Err(ExecServerError::HttpRequest(+ "MCP HTTP request exceeded the redirect limit".to_string(),+ ));+ }++ // Preserve normal HTTP behavior: 307/308 retain the method and body;+ // 303 and legacy 301/302 POST redirects switch to a bodyless GET.+ let drop_body = matches!(+ status,+ Some(StatusCode::MOVED_PERMANENTLY | StatusCode::FOUND)+ ) && params.method.eq_ignore_ascii_case("POST")+ || status == Some(StatusCode::SEE_OTHER);+ if drop_body {+ if !params.method.eq_ignore_ascii_case("HEAD") {+ params.method = "GET".to_string();+ }+ params.body = None;+ params.headers.retain(|header| {+ ![+ "content-type",+ "content-length",+ "content-encoding",+ "transfer-encoding",+ ]+ .iter()+ .any(|name| header.name.eq_ignore_ascii_case(name))+ });+ }++ // HTTPS keeps application proxy credentials inside the tunnel to+ // the already-validated origin. Plaintext routes can change across+ // requests, so their proxy credentials must never be replayed.+ params.headers.retain(|header| {+ (current_url.scheme() == "https"+ || !header.name.eq_ignore_ascii_case("proxy-authorization"))+ && !header.name.eq_ignore_ascii_case("referer")+ });+ let mut referer = current_url.clone();+ let _ = referer.set_username("");+ let _ = referer.set_password(None);+ referer.set_fragment(None);+ if HeaderValue::from_str(referer.as_str()).is_ok() {+ params.headers.push(HttpHeader {+ name: "referer".to_string(),+ value: referer.to_string(),+ });+ }++ params.url = next_url.to_string();+ current_url = next_url;+ redirects += 1;+ }+ }+}++impl HttpClient for SameOriginRedirectHttpClient {+ fn http_request(+ &self,+ mut params: HttpRequestParams,+ ) -> BoxFuture<'_, Result<HttpRequestResponse, ExecServerError>> {+ async move {+ params.stream_response = false;+ if params.redirect_policy == HttpRedirectPolicy::Stop {+ return self.inner.http_request(params).await;+ }+ match self.execute(params).await? {+ RedirectResponse::Buffered(response) => Ok(response),+ RedirectResponse::Streaming(_, _) => Err(ExecServerError::Protocol(+ "MCP buffered HTTP request returned a streamed response".to_string(),+ )),+ }+ }+ .boxed()+ }++ fn http_request_stream(+ &self,+ mut params: HttpRequestParams,+ ) -> BoxFuture<'_, Result<(HttpRequestResponse, HttpResponseBodyStream), ExecServerError>> {+ async move {+ params.stream_response = true;+ if params.redirect_policy == HttpRedirectPolicy::Stop {+ return self.inner.http_request_stream(params).await;+ }+ match self.execute(params).await? {+ RedirectResponse::Streaming(response, stream) => Ok((response, stream)),+ RedirectResponse::Buffered(_) => Err(ExecServerError::Protocol(+ "MCP streamed HTTP request returned a buffered response".to_string(),+ )),+ }+ }+ .boxed()+ }+}++#[cfg(test)]+#[path = "http_client_redirect_tests.rs"]+mod tests;diff --git a/codex-rs/rmcp-client/src/http_client_redirect_tests.rs b/codex-rs/rmcp-client/src/http_client_redirect_tests.rsnew file mode 100644index 0000000000..f3bb42cfdb--- /dev/null+++ b/codex-rs/rmcp-client/src/http_client_redirect_tests.rs@@ -0,0 +1,390 @@+use std::sync::Arc;+use std::sync::Mutex;++use codex_exec_server::Environment;+use codex_exec_server::HttpHeader;+use pretty_assertions::assert_eq;+use wiremock::Mock;+use wiremock::MockServer;+use wiremock::ResponseTemplate;+use wiremock::matchers::path;++use crate::http_headers::with_http_headers_helper;++use super::*;++const PROXY_HEADERS_HELPER: &str = if cfg!(windows) {+ r#"echo {"Proxy-Authorization":"Bearer proxy-token"}"#+} else {+ r#"printf '{"Proxy-Authorization":"Bearer proxy-token"}'"#+};++fn request(url: impl Into<String>) -> HttpRequestParams {+ HttpRequestParams {+ method: "POST".to_string(),+ url: url.into(),+ headers: Vec::new(),+ body: Some(b"sensitive-body".to_vec().into()),+ timeout_ms: Some(5_000),+ redirect_policy: HttpRedirectPolicy::Follow,+ request_id: "redirect-test".to_string(),+ stream_response: false,+ }+}++fn headers<const N: usize>(headers: [(&str, &str); N]) -> Vec<HttpHeader> {+ headers+ .into_iter()+ .map(|(name, value)| HttpHeader {+ name: name.to_string(),+ value: value.to_string(),+ })+ .collect()+}++#[derive(Default)]+struct RecordingRedirectHttpClient {+ requests: Mutex<Vec<HttpRequestParams>>,+ delay: Duration,+ loop_redirects: bool,+}++impl HttpClient for RecordingRedirectHttpClient {+ fn http_request(+ &self,+ params: HttpRequestParams,+ ) -> BoxFuture<'_, Result<HttpRequestResponse, ExecServerError>> {+ let mut requests = self.requests.lock().expect("request recorder lock");+ let redirect = requests.is_empty() || self.loop_redirects;+ let delay = self.delay;+ requests.push(params);+ async move {+ if !delay.is_zero() {+ tokio::time::sleep(delay).await;+ }+ Ok(HttpRequestResponse {+ status: if redirect { 307 } else { 200 },+ headers: if redirect {+ headers([("location", "/final")])+ } else {+ Vec::new()+ },+ body: Vec::new().into(),+ })+ }+ .boxed()+ }++ fn http_request_stream(+ &self,+ _params: HttpRequestParams,+ ) -> BoxFuture<'_, Result<(HttpRequestResponse, HttpResponseBodyStream), ExecServerError>> {+ async {+ Err(ExecServerError::HttpRequest(+ "unexpected streaming request".to_string(),+ ))+ }+ .boxed()+ }+}++#[tokio::test]+async fn plaintext_hostname_redirects_are_rejected_before_dns_can_rebind() -> anyhow::Result<()> {+ for (url, expected_error) in [+ (+ "http://mcp.example/start",+ Some("non-loopback hostnames require HTTPS"),+ ),+ ("http://localhost/start", None),+ ("http://127.0.0.1/start", None),+ ("http://[::1]/start", None),+ ("https://mcp.example/start", None),+ ] {+ let recorder = Arc::new(RecordingRedirectHttpClient::default());+ let client = SameOriginRedirectHttpClient::new(recorder.clone());+ let response = client+ .http_request(HttpRequestParams {+ headers: headers([("authorization", "Bearer sensitive-token")]),+ ..request(url)+ })+ .await;++ if let Some(expected_error) = expected_error {+ let error = response.expect_err("plaintext hostname redirects must fail");+ assert!(error.to_string().contains(expected_error), "{error}");+ } else {+ assert_eq!(response?.status, 200);+ }+ let requests = recorder.requests.lock().expect("request recorder lock");+ assert_eq!(requests.len(), if expected_error.is_some() { 1 } else { 2 });+ }++ Ok(())+}++#[tokio::test]+async fn same_origin_redirects_enforce_shared_timeout_and_hop_limit() {+ for (delay, timeout_ms, expected_error, expected_requests) in [+ (Duration::from_millis(100), 175, "timed out", 2),+ (Duration::ZERO, 5_000, "redirect limit", MAX_REDIRECTS + 1),+ ] {+ let recorder = Arc::new(RecordingRedirectHttpClient {+ delay,+ loop_redirects: true,+ ..Default::default()+ });+ let client = SameOriginRedirectHttpClient::new(recorder.clone());+ let error = client+ .http_request(HttpRequestParams {+ method: "GET".to_string(),+ body: None,+ timeout_ms: Some(timeout_ms),+ ..request("https://mcp.example/loop")+ })+ .await+ .expect_err("redirect loops must respect both limits");++ assert!(error.to_string().contains(expected_error), "{error}");+ let requests = recorder.requests.lock().expect("request recorder lock");+ assert_eq!(requests.len(), expected_requests);+ }+}++#[tokio::test]+async fn same_origin_redirects_preserve_method_body_and_headers() -> anyhow::Result<()> {+ for (method, redirect_status, redirected_method) in [+ ("POST", 301, "GET"),+ ("POST", 302, "GET"),+ ("POST", 303, "GET"),+ ("HEAD", 303, "HEAD"),+ ("POST", 307, "POST"),+ ("GET", 307, "GET"),+ ("DELETE", 307, "DELETE"),+ ("POST", 308, "POST"),+ ] {+ let server = MockServer::start().await;+ Mock::given(path("/start"))+ .respond_with(+ ResponseTemplate::new(redirect_status).insert_header("location", "/final"),+ )+ .expect(1)+ .mount(&server)+ .await;+ Mock::given(path("/final"))+ .respond_with(ResponseTemplate::new(200))+ .expect(1)+ .mount(&server)+ .await;++ let client =+ SameOriginRedirectHttpClient::new(Environment::default_for_tests().get_http_client());+ let expected_content_length = b"sensitive-body".len().to_string();+ let mut params = HttpRequestParams {+ method: method.to_string(),+ headers: headers([+ ("x-api-key", "sensitive-key"),+ ("proxy-authorization", "sensitive-proxy-credentials"),+ ("referer", "https://stale.example/"),+ ]),+ body: (method == "POST").then(|| b"sensitive-body".to_vec().into()),+ stream_response: method != "DELETE",+ ..request(format!("{}/start", server.uri()))+ };+ if method == "POST" {+ params.headers.extend(headers([+ ("content-type", "application/json"),+ ("content-encoding", "identity"),+ ("content-length", &expected_content_length),+ ]));+ }+ let status = if method == "DELETE" {+ client.http_request(params).await?.status+ } else {+ client.http_request_stream(params).await?.0.status+ };+ assert_eq!(status, 200);++ let requests = server.received_requests().await.expect("recorded requests");+ let redirected = &requests[1];+ let expected_referer = format!("{}/start", server.uri());+ let body_preserved = redirected_method == "POST";+ for (name, expected) in [+ ("x-api-key", Some("sensitive-key")),+ ("proxy-authorization", None),+ ("referer", Some(expected_referer.as_str())),+ ("content-type", body_preserved.then_some("application/json")),+ ("content-encoding", body_preserved.then_some("identity")),+ (+ "content-length",+ body_preserved.then_some(expected_content_length.as_str()),+ ),+ ] {+ assert_eq!(+ redirected+ .headers+ .get(name)+ .and_then(|value| value.to_str().ok()),+ expected,+ "unexpected redirected {name} header"+ );+ }+ assert_eq!(+ (redirected.method.as_str(), redirected.body.as_slice()),+ (+ redirected_method,+ if body_preserved {+ b"sensitive-body".as_slice()+ } else {+ b"".as_slice()+ }+ )+ );+ }++ Ok(())+}++#[tokio::test]+async fn https_redirects_preserve_configured_and_helper_proxy_authorization() -> anyhow::Result<()>+{+ for helper_enabled in [false, true] {+ let recorder = Arc::new(RecordingRedirectHttpClient::default());+ let inner: Arc<dyn HttpClient> = recorder.clone();+ let directory = tempfile::tempdir()?;+ let url = "https://mcp.example/start";+ let inner = if helper_enabled {+ with_http_headers_helper(+ inner,+ url,+ PROXY_HEADERS_HELPER,+ directory.path().to_path_buf(),+ )?+ } else {+ inner+ };+ let client = SameOriginRedirectHttpClient::new(inner);+ let response = client+ .http_request(HttpRequestParams {+ headers: if helper_enabled {+ Vec::new()+ } else {+ headers([("Proxy-Authorization", "Bearer proxy-token")])+ },+ ..request(url)+ })+ .await?;++ let requests = recorder.requests.lock().expect("request recorder lock");+ assert_eq!(+ (+ response.status,+ requests.len(),+ requests[1].url.as_str(),+ requests[1]+ .headers+ .iter()+ .find(|header| header.name.eq_ignore_ascii_case("proxy-authorization"))+ .map(|header| header.value.as_str()),+ ),+ (+ 200,+ 2,+ "https://mcp.example/final",+ Some("Bearer proxy-token"),+ ),+ );+ }++ Ok(())+}++#[tokio::test]+async fn plaintext_helper_redirects_block_mcp_but_preserve_oauth_stop() -> anyhow::Result<()> {+ for (request_id, redirect_policy) in [+ ("mcp-request-1", HttpRedirectPolicy::Follow),+ ("oauth-request-1", HttpRedirectPolicy::Stop),+ ] {+ let server = MockServer::start().await;+ Mock::given(path("/start"))+ .respond_with(ResponseTemplate::new(307).insert_header("location", "/final"))+ .expect(1)+ .mount(&server)+ .await;++ let directory = tempfile::tempdir()?;+ let url = format!("{}/start", server.uri());+ let helper = with_http_headers_helper(+ Environment::default_for_tests().get_http_client(),+ &url,+ PROXY_HEADERS_HELPER,+ directory.path().to_path_buf(),+ )?;+ let client = SameOriginRedirectHttpClient::new(helper);+ let response = client+ .http_request_stream(HttpRequestParams {+ request_id: request_id.to_string(),+ redirect_policy,+ stream_response: true,+ ..request(url)+ })+ .await;++ match (redirect_policy, response) {+ (HttpRedirectPolicy::Stop, Ok((response, _))) => assert_eq!(response.status, 307),+ (HttpRedirectPolicy::Follow, Err(error)) => {+ assert!(error.to_string().contains("Proxy-Authorization"));+ }+ _ => panic!("unexpected plaintext proxy-credential redirect behavior"),+ }+ assert_eq!(server.received_requests().await.unwrap().len(), 1);+ }+ Ok(())+}++#[tokio::test]+async fn cross_origin_redirects_never_reach_their_destination() -> anyhow::Result<()> {+ for status in [307, 308] {+ for method in ["POST", "GET", "DELETE"] {+ let destination = MockServer::start().await;+ let server = MockServer::start().await;+ Mock::given(path("/start"))+ .respond_with(+ ResponseTemplate::new(status)+ .insert_header("location", format!("{}/private", destination.uri())),+ )+ .expect(1)+ .mount(&server)+ .await;++ let client = SameOriginRedirectHttpClient::new(+ Environment::default_for_tests().get_http_client(),+ );+ let params = HttpRequestParams {+ method: method.to_string(),+ headers: headers([("x-api-key", "sensitive-key")]),+ body: (method == "POST").then(|| b"sensitive-body".to_vec().into()),+ stream_response: method != "DELETE",+ ..request(format!("{}/start", server.uri()))+ };+ let error = if method == "DELETE" {+ client+ .http_request(params)+ .await+ .expect_err("cross-origin DELETE redirect must fail")+ } else {+ match client.http_request_stream(params).await {+ Ok(_) => panic!("cross-origin {method} redirect must fail"),+ Err(error) => error,+ }+ };++ assert!(+ error.to_string().contains("different origin"),+ "cross-origin {method} redirect must explain its rejection: {error}"+ );+ assert!(destination.received_requests().await.unwrap().is_empty());+ }+ }++ Ok(())+}diff --git a/codex-rs/rmcp-client/src/http_headers.rs b/codex-rs/rmcp-client/src/http_headers.rsindex 66ae1bd8bf..230443cd1d 100644--- a/codex-rs/rmcp-client/src/http_headers.rs+++ b/codex-rs/rmcp-client/src/http_headers.rs@@ -197,6 +197,23 @@ impl HttpHeadersClient {}Ok(params)}++ fn reject_proxy_authorization_redirect(+ response: &HttpRequestResponse,+ ) -> Result<(), ExecServerError> {+ if (300..400).contains(&response.status)+ && response+ .headers+ .iter()+ .any(|header| header.name.eq_ignore_ascii_case("location"))+ {+ return Err(ExecServerError::HttpRequest(+ "MCP HTTP redirect cannot safely replay Proxy-Authorization credentials"+ .to_string(),+ ));+ }+ Ok(())+ }}impl HttpClient for HttpHeadersClient {@@ -205,8 +222,21 @@ impl HttpClient for HttpHeadersClient {params: HttpRequestParams,) -> BoxFuture<'_, Result<HttpRequestResponse, ExecServerError>> {async move {+ // OAuth validates redirect responses itself; only intercept MCP replay.+ let mcp_redirect_was_stopped = params.redirect_policy == HttpRedirectPolicy::Stop+ && !params.request_id.starts_with("oauth-request-");let params = self.prepare_request(params).await?;- self.inner.http_request(params).await+ let prevent_proxy_authorization_redirect = mcp_redirect_was_stopped+ && Url::parse(¶ms.url).is_ok_and(|url| url.scheme() == "http")+ && params+ .headers+ .iter()+ .any(|header| header.name.eq_ignore_ascii_case("proxy-authorization"));+ let response = self.inner.http_request(params).await?;+ if prevent_proxy_authorization_redirect {+ Self::reject_proxy_authorization_redirect(&response)?;+ }+ Ok(response)}.boxed()}@@ -216,8 +246,20 @@ impl HttpClient for HttpHeadersClient {params: HttpRequestParams,) -> BoxFuture<'_, Result<(HttpRequestResponse, HttpResponseBodyStream), ExecServerError>> {async move {+ let mcp_redirect_was_stopped = params.redirect_policy == HttpRedirectPolicy::Stop+ && !params.request_id.starts_with("oauth-request-");let params = self.prepare_request(params).await?;- self.inner.http_request_stream(params).await+ let prevent_proxy_authorization_redirect = mcp_redirect_was_stopped+ && Url::parse(¶ms.url).is_ok_and(|url| url.scheme() == "http")+ && params+ .headers+ .iter()+ .any(|header| header.name.eq_ignore_ascii_case("proxy-authorization"));+ let (response, stream) = self.inner.http_request_stream(params).await?;+ if prevent_proxy_authorization_redirect {+ Self::reject_proxy_authorization_redirect(&response)?;+ }+ Ok((response, stream))}.boxed()}diff --git a/codex-rs/rmcp-client/src/lib.rs b/codex-rs/rmcp-client/src/lib.rsindex 379fa8d5b7..4203788638 100644--- a/codex-rs/rmcp-client/src/lib.rs+++ b/codex-rs/rmcp-client/src/lib.rs@@ -3,6 +3,7 @@ mod elicitation_client_service;mod event_notification_transport;mod executor_process_transport;mod http_client_adapter;+mod http_client_redirect;mod http_headers;mod in_process_transport;mod incoming_jsonrpc;diff --git a/codex-rs/rmcp-client/tests/mcp_2026_discovery.rs b/codex-rs/rmcp-client/tests/mcp_2026_discovery.rsindex 72968a75d3..9e660d1f1c 100644--- a/codex-rs/rmcp-client/tests/mcp_2026_discovery.rs+++ b/codex-rs/rmcp-client/tests/mcp_2026_discovery.rs@@ -230,8 +230,9 @@ async fn modern_discovery_does_not_follow_redirects_with_sensitive_headers() ->}#[tokio::test]-async fn legacy_mcp_requests_follow_redirects_with_configured_headers() -> anyhow::Result<()> {- let redirect_target = MockServer::start().await;+async fn legacy_mcp_requests_follow_same_origin_redirects_with_configured_headers()+-> anyhow::Result<()> {+ let server = MockServer::start().await;Mock::given(method("POST")).and(path("/forwarded")).and(header("x-api-key", "sensitive-key"))@@ -244,23 +245,19 @@ async fn legacy_mcp_requests_follow_redirects_with_configured_headers() -> anyho}}).expect(2)- .mount(&redirect_target)+ .mount(&server).await;- let resource_server = MockServer::start().await;Mock::given(method("POST")).and(path("/mcp"))- .respond_with(- ResponseTemplate::new(307)- .insert_header("location", format!("{}/forwarded", redirect_target.uri())),- )+ .respond_with(ResponseTemplate::new(307).insert_header("location", "/forwarded")).expect(2)- .mount(&resource_server)+ .mount(&server).await;let client = RmcpClient::new_streamable_http_client_with_protocol_mode("legacy-redirect-test",- &format!("{}/mcp", resource_server.uri()),+ &format!("{}/mcp", server.uri()),/*bearer_token*/ None,Some(HashMap::from([("x-api-key".to_string(),@@ -275,12 +272,66 @@ async fn legacy_mcp_requests_follow_redirects_with_configured_headers() -> anyho).await?;initialize_client(&client).await?;- redirect_target.verify().await;- resource_server.verify().await;+ server.verify().await;client.shutdown().await;Ok(())}+#[tokio::test]+async fn legacy_fallback_does_not_follow_cross_origin_tool_redirects() -> anyhow::Result<()> {+ for mode in [McpProtocolMode::Legacy, McpProtocolMode::V20260728] {+ let destination = MockServer::start().await;+ let server = MockServer::start().await;+ let destination_url = format!("{}/private", destination.uri());+ Mock::given(method("POST"))+ .and(path("/redirected"))+ .respond_with(ResponseTemplate::new(307).insert_header("location", destination_url))+ .expect(1)+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path("/mcp"))+ .respond_with(move |request: &Request| {+ let body: Value = request.body_json().expect("valid JSON-RPC request");+ match body["method"].as_str() {+ Some("server/discover") => ResponseTemplate::new(200).set_body_json(json!({+ "jsonrpc": "2.0",+ "id": body["id"],+ "error": {"code": -32601, "message": "method not found"},+ })),+ Some("initialize") => legacy_initialize_response(&body),+ Some("notifications/initialized") => ResponseTemplate::new(202),+ Some("tools/call") => {+ ResponseTemplate::new(307).insert_header("location", "/redirected")+ }+ other => panic!("unexpected legacy MCP method: {other:?}"),+ }+ })+ .mount(&server)+ .await;++ let client = create_client(&server, mode).await?;+ initialize_client(&client).await?;+ let error = client+ .call_tool(+ "query_logs_sql".to_string(),+ Some(json!({"query": "sensitive-query"})),+ /*meta*/ None,+ Some(Duration::from_secs(5)),+ )+ .await+ .expect_err("cross-origin tools/call redirect must fail");+ assert!(+ format!("{error:#}").contains("different origin"),+ "cross-origin tools/call redirect must explain its rejection: {error:#}"+ );+ assert!(destination.received_requests().await.unwrap().is_empty());+ client.shutdown().await;+ }++ Ok(())+}+#[tokio::test]async fn modern_discovery_accepts_metadata_namespaced_server_identity() -> anyhow::Result<()> {let server = MockServer::start().await;