Lightweight coding agent that runs in your terminal
Rust
Enforce issuer binding for MCP OAuth endpoints (#39935)
jif7f9832d0d08c
diff --git a/codex-rs/app-server/tests/suite/v2/executor_mcp.rs b/codex-rs/app-server/tests/suite/v2/executor_mcp.rsindex b0a32df15c..8e426fe7bf 100644--- a/codex-rs/app-server/tests/suite/v2/executor_mcp.rs+++ b/codex-rs/app-server/tests/suite/v2/executor_mcp.rs@@ -130,9 +130,11 @@ async fn selected_executor_plugin_exposes_its_mcps_only_to_that_thread() -> Resulet (registration_request_tx, mut registration_request_rx) = mpsc::unbounded_channel();let (token_request_tx, mut token_request_rx) = mpsc::unbounded_channel();let oauth_metadata = json!({+ "issuer": EXECUTOR_OAUTH_MCP_URL,"authorization_endpoint": "https://oauth-only.invalid/authorize","token_endpoint": "http://oauth-only.invalid/token","registration_endpoint": "http://oauth-only.invalid/register",+ "authorization_response_iss_parameter_supported": true,"scopes_supported": ["read", "write"],"response_types_supported": ["code"],"code_challenge_methods_supported": ["S256"],@@ -345,7 +347,8 @@ startup_timeout_sec = 10callback_url.query_pairs_mut().append_pair("code", "configured-test-code")- .append_pair("state", ¶meters["state"]);+ .append_pair("state", ¶meters["state"])+ .append_pair("iss", EXECUTOR_OAUTH_MCP_URL);HttpClientBuilder::new().build_direct()?.get(callback_url)@@ -408,7 +411,8 @@ startup_timeout_sec = 10callback_url.query_pairs_mut().append_pair("code", "executor-test-code")- .append_pair("state", &state);+ .append_pair("state", &state)+ .append_pair("iss", EXECUTOR_OAUTH_MCP_URL);HttpClientBuilder::new().build_direct()?.get(callback_url)diff --git a/codex-rs/rmcp-client/src/oauth.rs b/codex-rs/rmcp-client/src/oauth.rsindex 304ff21002..6411551261 100644--- a/codex-rs/rmcp-client/src/oauth.rs+++ b/codex-rs/rmcp-client/src/oauth.rs@@ -71,6 +71,7 @@ use tokio::sync::Mutex;use codex_utils_home_dir::find_codex_home;+pub(crate) use self::issuer_binding::validate_authorization_server_endpoints;pub(crate) use self::issuer_binding::validate_refresh_token_issuer;pub(crate) use self::refresh_transaction::install_tokens_in_manager;pub(crate) use self::resolved_store::ResolvedOAuthCredentialStore;diff --git a/codex-rs/rmcp-client/src/oauth/issuer_binding.rs b/codex-rs/rmcp-client/src/oauth/issuer_binding.rsindex 7493117286..5a12bf4024 100644--- a/codex-rs/rmcp-client/src/oauth/issuer_binding.rs+++ b/codex-rs/rmcp-client/src/oauth/issuer_binding.rs@@ -1,9 +1,78 @@use anyhow::Context;use anyhow::Result;+use anyhow::bail;use rmcp::transport::auth::AuthError;use rmcp::transport::auth::AuthorizationMetadata;+use url::Url;use super::StoredOAuthTokens;++/// Reject authorization endpoints that cannot be bound to their actual issuer.+pub(crate) fn validate_authorization_server_endpoints(+ metadata: &AuthorizationMetadata,+) -> Result<()> {+ let authorization_endpoint = Url::parse(&metadata.authorization_endpoint)+ .context("OAuth authorization endpoint must be a valid URL")?;+ let issuer = metadata+ .issuer+ .as_deref()+ .filter(|issuer| !issuer.trim().is_empty())+ .map(Url::parse)+ .transpose()+ .context("OAuth authorization server issuer must be a valid URL")?;+ let issuer_bound_callbacks = metadata+ .additional_fields+ .get("authorization_response_iss_parameter_supported")+ .and_then(serde_json::Value::as_bool)+ .unwrap_or(false);++ if issuer_bound_callbacks {+ if issuer.is_none() {+ bail!("OAuth issuer-bound callbacks require an authorization server issuer");+ }+ return Ok(());+ }++ let token_endpoint =+ Url::parse(&metadata.token_endpoint).context("OAuth token endpoint must be a valid URL")?;++ if let Some(issuer) = issuer {+ if authorization_endpoint.origin() == issuer.origin()+ || authorization_endpoint.origin() == token_endpoint.origin()+ // Remove these narrow compatibility exceptions once both providers support RFC 9207.+ || matches!(+ (+ issuer.as_str(),+ authorization_endpoint.origin().ascii_serialization().as_str(),+ token_endpoint.origin().ascii_serialization().as_str(),+ ),+ (+ "https://api.figma.com/",+ "https://www.figma.com",+ "https://api.figma.com",+ ) | (+ "https://agent.robinhood.com/mcp/trading",+ "https://robinhood.com",+ "https://api.robinhood.com",+ )+ )+ {+ return Ok(());+ }+ bail!(+ "OAuth authorization endpoint origin does not match the authorization server origin without issuer-bound callbacks"+ );+ }++ if token_endpoint.origin() != authorization_endpoint.origin() {+ bail!(+ "OAuth token endpoint origin does not match the authorization server origin without issuer-bound callbacks"+ );+ }++ Ok(())+}+/// Verifies that a stored refresh token remains bound to its original issuer.////// Call this with the same metadata snapshot that RMCP will use for the credentials. Missing ordiff --git a/codex-rs/rmcp-client/src/oauth_client_registration.rs b/codex-rs/rmcp-client/src/oauth_client_registration.rsindex 1406c66fa9..31a547836a 100644--- a/codex-rs/rmcp-client/src/oauth_client_registration.rs+++ b/codex-rs/rmcp-client/src/oauth_client_registration.rs@@ -9,6 +9,8 @@ use rmcp::transport::auth::OAuthHttpClient;use rmcp::transport::auth::OAuthState;use url::Url;+use crate::oauth::validate_authorization_server_endpoints;+/// OAuth client-registration strategy for one interactive HTTP MCP login.#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]pub enum McpOAuthClientRegistration {@@ -39,6 +41,7 @@ pub(crate) async fn start_authorization(AuthorizationManager::new_with_oauth_http_client(server_url, http_client).await?;auth_manager.set_allow_missing_issuer(true);let metadata = auth_manager.resolve_metadata().await?.metadata;+ validate_authorization_server_endpoints(&metadata)?;let authorization_server_issuer = metadata.issuer.clone();let cimd_advertised = metadatadiff --git a/codex-rs/rmcp-client/src/oauth_client_registration_tests.rs b/codex-rs/rmcp-client/src/oauth_client_registration_tests.rsindex 935f999b7a..a776218fd8 100644--- a/codex-rs/rmcp-client/src/oauth_client_registration_tests.rs+++ b/codex-rs/rmcp-client/src/oauth_client_registration_tests.rs@@ -9,6 +9,7 @@ use codex_http_client::HttpClientFactory;use codex_http_client::OutboundProxyPolicy;use http::HeaderMap;use pretty_assertions::assert_eq;+use rmcp::transport::auth::AuthorizationMetadata;use rmcp::transport::auth::OAuthState;use serde_json::Value;use serde_json::json;@@ -23,6 +24,7 @@ use wiremock::matchers::path;use super::McpOAuthClientRegistration;use super::start_authorization;+use crate::oauth::validate_authorization_server_endpoints;use crate::oauth_http_client::OAuthHttpClientAdapter;use crate::utils::MCP_USER_AGENT;use crate::utils::build_default_headers;@@ -209,6 +211,136 @@ async fn registration_selection_preserves_dcr_capabilities_and_exact_redirects()Ok(())}+#[test]+fn legacy_provider_exceptions_require_exact_issuer_and_endpoint_origins() -> Result<()> {+ for (issuer, authorization_endpoint, token_endpoint, accepted) in [+ (+ "https://api.figma.com",+ "https://www.figma.com/oauth/mcp",+ "https://api.figma.com/v1/oauth/token",+ true,+ ),+ (+ "https://agent.robinhood.com/mcp/trading",+ "https://robinhood.com/oauth",+ "https://api.robinhood.com/oauth2/token/",+ true,+ ),+ (+ "https://api.figma.com.attacker.example",+ "https://www.figma.com/oauth/mcp",+ "https://api.figma.com.attacker.example/token",+ false,+ ),+ (+ "https://api.figma.com",+ "https://www.figma.com/oauth/mcp",+ "https://attacker.example/token",+ false,+ ),+ (+ "http://api.figma.com",+ "https://www.figma.com/oauth/mcp",+ "http://api.figma.com/v1/oauth/token",+ false,+ ),+ (+ "https://agent.robinhood.com/mcp/attacker",+ "https://robinhood.com/oauth",+ "https://api.robinhood.com/oauth2/token/",+ false,+ ),+ (+ "https://agent.robinhood.com/mcp/trading",+ "https://robinhood.com.attacker.example/oauth",+ "https://api.robinhood.com/oauth2/token/",+ false,+ ),+ ] {+ let metadata: AuthorizationMetadata = serde_json::from_value(json!({+ "issuer": issuer,+ "authorization_endpoint": authorization_endpoint,+ "token_endpoint": token_endpoint,+ }))?;+ assert_eq!(+ validate_authorization_server_endpoints(&metadata).is_ok(),+ accepted,+ "unexpected validation result for issuer {issuer}",+ );+ }++ Ok(())+}++#[tokio::test]+async fn verified_issuer_can_delegate_authorization_and_token_to_one_origin() -> Result<()> {+ let issuer_server = MockServer::start().await;+ let endpoint_server = MockServer::start().await;+ let issuer = format!("{}/mcp", issuer_server.uri());+ let redirect_uri = format!("http://127.0.0.1:43123/callback/{CALLBACK_ID}");++ Mock::given(method("GET"))+ .and(path("/.well-known/oauth-authorization-server/mcp"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "issuer": issuer,+ "authorization_endpoint": format!("{}/authorize", endpoint_server.uri()),+ "token_endpoint": format!("{}/token", endpoint_server.uri()),+ "registration_endpoint": format!("{}/register", endpoint_server.uri()),+ "token_endpoint_auth_methods_supported": ["none"],+ "code_challenge_methods_supported": ["S256"],+ })))+ .expect(1)+ .mount(&issuer_server)+ .await;+ Mock::given(method("POST"))+ .and(path("/register"))+ .respond_with(|request: &Request| {+ let registration: Value = serde_json::from_slice(&request.body)+ .expect("dynamic registration should contain JSON");+ ResponseTemplate::new(200).set_body_json(json!({+ "client_id": "delegated-provider-client",+ "redirect_uris": registration["redirect_uris"],+ }))+ })+ .expect(1)+ .mount(&endpoint_server)+ .await;+ Mock::given(method("POST"))+ .and(path("/token"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "access_token": "delegated-provider-token",+ "token_type": "Bearer",+ })))+ .expect(1)+ .mount(&endpoint_server)+ .await;++ let (mut state, query) = authorization(+ &issuer_server,+ &redirect_uri,+ McpOAuthClientRegistration::Dcr,+ )+ .await?;+ assert_eq!(query["client_id"], "delegated-provider-client");+ assert_eq!(+ Url::parse(&state.get_authorization_url().await?)?.origin(),+ Url::parse(&endpoint_server.uri())?.origin(),+ );++ state+ .handle_callback_with_issuer("valid-authorization-code", &query["state"], None)+ .await?;+ let token_requests = requests_to(&endpoint_server, "/token").await;+ assert_eq!(token_requests.len(), 1);+ assert!(+ url::form_urlencoded::parse(&token_requests[0].body)+ .any(|(name, _)| name == "code_verifier")+ );+ issuer_server.verify().await;+ endpoint_server.verify().await;+ Ok(())+}+#[tokio::test]async fn resource_headers_follow_same_origin_registration_redirect_and_sdk_auth_wins() -> Result<()>{diff --git a/codex-rs/rmcp-client/src/oauth_http_client.rs b/codex-rs/rmcp-client/src/oauth_http_client.rsindex 6a6429529b..d9838bd4a5 100644--- a/codex-rs/rmcp-client/src/oauth_http_client.rs+++ b/codex-rs/rmcp-client/src/oauth_http_client.rs@@ -21,6 +21,7 @@ use http::header::TRANSFER_ENCODING;use http::header::USER_AGENT;use oauth2::HttpRequest;use oauth2::HttpResponse;+use rmcp::transport::auth::AuthorizationMetadata;use rmcp::transport::auth::OAuthHttpClient;use rmcp::transport::auth::OAuthHttpClientError;use rmcp::transport::auth::OAuthHttpClientFuture;@@ -47,6 +48,8 @@ enum OAuthHttpClientAdapterError {TooManyRedirects,#[error("OAuth HTTP response body exceeds {maximum_bytes} bytes")]ResponseBodyTooLarge { maximum_bytes: usize },+ #[error("OAuth authorization server issuer does not match authorization metadata origin")]+ AuthorizationMetadataIssuerOriginMismatch,}fn oauth_http_client_error(@@ -284,6 +287,18 @@ impl OAuthHttpClientAdapter {request_url = next_url;redirects += 1;};+ if response.status == StatusCode::OK.as_u16()+ && let Ok(metadata) = serde_json::from_slice::<AuthorizationMetadata>(&body)+ && let Some(issuer) = metadata.issuer.as_deref()+ && Url::parse(issuer)+ .map_err(oauth_http_client_error)?+ .origin()+ != request_url.origin()+ {+ return Err(oauth_http_client_error(+ OAuthHttpClientAdapterError::AuthorizationMetadataIssuerOriginMismatch,+ ));+ }let mut builder = oauth2::http::Response::builder().status(response.status);for header in response.headers {builder = builder.header(header.name, header.value);diff --git a/codex-rs/rmcp-client/src/perform_oauth_login.rs b/codex-rs/rmcp-client/src/perform_oauth_login.rsindex c44690263e..873490ed6f 100644--- a/codex-rs/rmcp-client/src/perform_oauth_login.rs+++ b/codex-rs/rmcp-client/src/perform_oauth_login.rs@@ -28,6 +28,7 @@ use crate::StoredOAuthTokens;use crate::WrappedOAuthTokenResponse;use crate::http_client_adapter::StreamableHttpRedirectMode;use crate::oauth::compute_expires_at_millis;+use crate::oauth::validate_authorization_server_endpoints;use crate::oauth_client_registration::McpOAuthClientRegistration;use crate::oauth_client_registration::PreparedOAuthLogin;use crate::oauth_client_registration::start_authorization as start_client_registration;@@ -710,6 +711,7 @@ async fn start_authorization(AuthorizationManager::new_with_oauth_http_client(server_url, http_client).await?;auth_manager.set_allow_missing_issuer(true);let metadata = auth_manager.resolve_metadata().await?.metadata;+ validate_authorization_server_endpoints(&metadata)?;let authorization_server_issuer = metadata.issuer.clone();auth_manager.set_metadata(metadata);auth_manager.configure_client(diff --git a/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rs b/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rsindex cb950a4c26..31c66bad3a 100644--- a/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rs+++ b/codex-rs/rmcp-client/tests/mcp_2026_oauth_discovery.rs@@ -3,12 +3,16 @@ use std::sync::Arc;use std::time::Duration;use anyhow::Context as _;+use codex_config::types::AuthKeyringBackendKind;+use codex_config::types::OAuthCredentialsStoreMode;use codex_exec_server::Environment;use codex_exec_server::HttpClient;+use codex_rmcp_client::McpOAuthClientRegistration;use codex_rmcp_client::OAuthDiscoveryTimeout;use codex_rmcp_client::StreamableHttpOAuthDiscovery;use codex_rmcp_client::StreamableHttpRedirectMode;use codex_rmcp_client::discover_streamable_http_oauth;+use codex_rmcp_client::perform_oauth_login_return_url;use pretty_assertions::assert_eq;use rmcp::transport::auth::AuthError;use serde_json::json;@@ -236,11 +240,8 @@ async fn assert_legacy_oauth_without_starting_an_mcp_session(assert!(matches!(error.downcast_ref::<AuthError>(),- Some(AuthError::AuthorizationServerMismatch {- expected_issuer,- received_issuer,- }) if expected_issuer.trim_end_matches('/') == authorization_server.uri()- && received_issuer == "https://unexpected-issuer.example"+ Some(AuthError::MetadataError(reason))+ if reason.contains("issuer does not match authorization metadata origin")),"expected the original authorization-server issuer to remain bound: {error:#}",);@@ -520,3 +521,164 @@ async fn oauth_discovery_does_not_invent_support_for_an_unauthenticated_legacy_sassert_eq!(local_discovery, None);Ok(())}++#[tokio::test]+async fn interactive_oauth_rejects_untrusted_authorization_metadata() -> anyhow::Result<()> {+ for (metadata_issuer, authorization_metadata_path, issuer_bound_callbacks) in [+ (+ AuthorizationMetadataIssuer::Missing,+ "/.well-known/untrusted-provider",+ false,+ ),+ (+ AuthorizationMetadataIssuer::Mismatched,+ "/.well-known/untrusted-provider",+ true,+ ),+ (+ AuthorizationMetadataIssuer::Mismatched,+ "/metadata.json",+ false,+ ),+ (+ AuthorizationMetadataIssuer::Mismatched,+ "/metadata.json",+ true,+ ),+ (+ AuthorizationMetadataIssuer::Mismatched,+ "/.well-known/oauth-authorization-server",+ false,+ ),+ (+ AuthorizationMetadataIssuer::Mismatched,+ "/.well-known/oauth-authorization-server",+ true,+ ),+ (+ AuthorizationMetadataIssuer::Mismatched,+ "/.well-known/openid-configuration",+ true,+ ),+ (+ AuthorizationMetadataIssuer::Matching,+ "/.well-known/untrusted-provider",+ false,+ ),+ ] {+ let resource_server = MockServer::start().await;+ let authorization_server = MockServer::start().await;+ let attacker_token_server = MockServer::start().await;+ let resource_url = format!("{}/mcp", resource_server.uri());+ let resource_metadata_url = format!("{}/resource-metadata", resource_server.uri());+ let (issuer, expected_error) = match metadata_issuer {+ AuthorizationMetadataIssuer::Missing => (+ None,+ "token endpoint origin does not match the authorization server origin",+ ),+ AuthorizationMetadataIssuer::Mismatched => (+ Some(authorization_server.uri()),+ "issuer does not match authorization metadata origin",+ ),+ AuthorizationMetadataIssuer::Matching => (+ Some(resource_server.uri()),+ "authorization endpoint origin does not match the authorization server origin",+ ),+ };+ let mut authorization_metadata = json!({+ "authorization_endpoint": format!("{}/authorize", authorization_server.uri()),+ "registration_endpoint": format!("{}/register", authorization_server.uri()),+ "token_endpoint": format!("{}/token", attacker_token_server.uri()),+ "authorization_response_iss_parameter_supported": issuer_bound_callbacks,+ "code_challenge_methods_supported": ["S256"],+ });+ if let Some(issuer) = issuer {+ authorization_metadata["issuer"] = json!(issuer);+ }++ Mock::given(method("GET"))+ .and(path("/mcp"))+ .respond_with(ResponseTemplate::new(401).insert_header(+ "www-authenticate",+ format!("Bearer resource_metadata=\"{resource_metadata_url}\""),+ ))+ .expect(2)+ .mount(&resource_server)+ .await;+ Mock::given(method("GET"))+ .and(path("/resource-metadata"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "resource": resource_url,+ "authorization_servers": [format!(+ "{}/.well-known/untrusted-provider",+ resource_server.uri()+ )],+ })))+ .expect(2)+ .mount(&resource_server)+ .await;+ if authorization_metadata_path != "/.well-known/untrusted-provider" {+ Mock::given(method("GET"))+ .and(path("/.well-known/untrusted-provider"))+ .respond_with(+ ResponseTemplate::new(302)+ .insert_header("location", authorization_metadata_path),+ )+ .expect(2)+ .mount(&resource_server)+ .await;+ }+ Mock::given(method("GET"))+ .and(path(authorization_metadata_path))+ .respond_with(ResponseTemplate::new(200).set_body_json(authorization_metadata))+ .expect(2)+ .mount(&resource_server)+ .await;+ Mock::given(method("POST"))+ .respond_with(ResponseTemplate::new(200))+ .expect(0)+ .mount(&attacker_token_server)+ .await;++ for oauth_client_id in [None, Some("preregistered-client")] {+ let error = perform_oauth_login_return_url(+ "untrusted-oauth-metadata",+ &resource_url,+ OAuthCredentialsStoreMode::File,+ AuthKeyringBackendKind::Direct,+ /*http_headers*/ None,+ /*env_http_headers*/ None,+ /*scopes*/ &[],+ oauth_client_id,+ McpOAuthClientRegistration::Dcr,+ /*oauth_resource*/ None,+ Some(/*timeout_secs*/ 5),+ /*callback_port*/ None,+ /*callback_url*/ None,+ local_http_client(),+ StreamableHttpRedirectMode::Legacy,+ )+ .await+ .err()+ .context("untrusted OAuth authorization metadata must fail")?;++ assert!(+ format!("{error:#}").contains(expected_error),+ "unexpected authorization failure for {oauth_client_id:?}: {error:#}",+ );+ }++ assert!(+ attacker_token_server+ .received_requests()+ .await+ .context("attacker token server request recording should be enabled")?+ .is_empty(),+ "the attacker must never receive an authorization code or PKCE verifier",+ );+ attacker_token_server.verify().await;+ authorization_server.verify().await;+ resource_server.verify().await;+ }+ Ok(())+}