Lightweight coding agent that runs in your terminal
Rust
Prevent brokered credential aliases from bypassing MITM hooks (#52661)
viyatb-oai65b82cdf96f9
diff --git a/codex-rs/core/tests/suite/network_approval.rs b/codex-rs/core/tests/suite/network_approval.rsindex f59554f5c3..9bf595e64e 100644--- a/codex-rs/core/tests/suite/network_approval.rs+++ b/codex-rs/core/tests/suite/network_approval.rs@@ -16,6 +16,14 @@ use codex_exec_server::REMOTE_ENVIRONMENT_ID;use codex_exec_server::RemoveOptions;use codex_features::Feature;use codex_history::RolloutItem;+#[cfg(unix)]+use codex_network_proxy::CredentialProviderConfig;+#[cfg(unix)]+use codex_network_proxy::MitmHookActionsConfig;+#[cfg(unix)]+use codex_network_proxy::MitmHookConfig;+#[cfg(unix)]+use codex_network_proxy::MitmHookMatchConfig;use codex_network_proxy::NetworkProxyConfig;use codex_network_proxy::PROXY_ACTIVE_ENV_KEY;use codex_protocol::approvals::ExecApprovalKind;@@ -3143,6 +3151,134 @@ async fn approved_network_host_for_one_environment_still_prompts_in_another() ->Ok(())}+#[cfg(unix)]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn agent_started_proxy_denies_brokered_provider_alias() -> Result<()> {+ const REAL_CREDENTIAL: &str = "alias_aaaaaaaaaaaaaaaaaaaaaaaa";+ let upstream = tokio::net::TcpListener::bind("127.0.0.1:0").await?;+ let port = upstream.local_addr()?.port();+ let mut network = NetworkProxyConfig {+ enabled: true,+ proxy_url: "http://127.0.0.1:0".to_string(),+ socks_url: "http://127.0.0.1:0".to_string(),+ // Local requests must stay behind the proxy for their credentials to be masked.+ allow_local_binding: Some(false),+ allow_upstream_proxy: false,+ mitm_hooks: vec![MitmHookConfig {+ host: "localhost".to_string(),+ matcher: MitmHookMatchConfig {+ methods: vec!["GET".to_string()],+ path_prefixes: vec!["/v1".to_string()],+ ..MitmHookMatchConfig::default()+ },+ actions: MitmHookActionsConfig::default(),+ }],+ ..NetworkProxyConfig::default()+ };+ network.set_credential_broker_enabled(/*enabled*/ true);+ network.set_allowed_domains(vec!["localhost".to_string(), "127.0.0.1".to_string()]);+ network.credential_providers.insert(+ "alias_test".to_string(),+ CredentialProviderConfig {+ env: vec!["ALIAS_TEST_TOKEN".to_string()],+ patterns: vec!["alias_[a-z]{24}".to_string()],+ url_prefixes: vec![+ format!("http://localhost:{port}/v1"),+ format!("http://127.0.0.1:{port}/v2"),+ ],+ ..CredentialProviderConfig::default()+ },+ );+ let permission_profile = PermissionProfile::workspace_write_with(+ &[],+ NetworkSandboxPolicy::Enabled,+ /*exclude_tmpdir_env_var*/ false,+ /*exclude_slash_tmp*/ false,+ );+ let server = start_mock_server().await;+ let test = test_codex()+ .with_config(move |config| {+ for feature in [+ Feature::UnifiedExec,+ Feature::ShellSnapshot,+ Feature::NetworkProxy,+ ] {+ config+ .features+ .enable(feature)+ .expect("enable test feature");+ }+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::Never);+ config+ .permissions+ .set_permission_profile(permission_profile.clone())+ .expect("set permission profile");+ config+ .permissions+ .shell_environment_policy+ .r#set+ .insert("ALIAS_TEST_TOKEN".to_string(), REAL_CREDENTIAL.to_string());+ config.permissions.network = Some(+ NetworkProxySpec::from_config_and_constraints(+ network,+ /*requirements*/ None,+ &permission_profile,+ )+ .expect("build brokered managed network proxy"),+ );+ })+ // Credential brokerage currently runs only in the local environment.+ .build(&server)+ .await?;+ let proxy = test+ .session_configured+ .network_proxy+ .as_ref()+ .context("agent did not start its managed network proxy")?;+ let command = r#"printf 'BROKERED:%s\nACTIVE:%s\n' "$ALIAS_TEST_TOKEN" "$CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE""#;+ let call_id = "exec-brokered-provider-alias";+ let mut args = network_exec_args(command);+ args["yield_time_ms"] = json!(30_000);+ let responses =+ mount_exec_network_turn(&server, "resp-brokered-provider-alias", call_id, args).await?;+ test.submit_text_turn("read the brokered credential")+ .await?;+ let output = responses+ .function_call_output_text(call_id)+ .context("agent did not return command output")?;+ assert!(output.contains("ACTIVE:1"), "{output}");+ assert!(!output.contains(REAL_CREDENTIAL));+ let token = output+ .lines()+ .find_map(|line| line.strip_prefix("BROKERED:"))+ .context("agent did not expose its brokered dummy")?;+ assert!(token.starts_with("alias_"));++ // Probe after the command exits so the denial cannot interrupt the tool call.+ let response = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {+ let mut connection = tokio::net::TcpStream::connect(&proxy.http_addr).await?;+ connection+ .write_all(+ format!(+ "GET http://127.0.0.1:{port}/v2/resource HTTP/1.1\r\n\+ Host: 127.0.0.1:{port}\r\nAuthorization: Bearer {token}\r\n\+ Connection: close\r\n\r\n"+ )+ .as_bytes(),+ )+ .await?;+ let mut response = String::new();+ connection.read_to_string(&mut response).await?;+ Ok::<_, std::io::Error>(response)+ })+ .await+ .context("alias denial did not finish")??;+ assert!(response.starts_with("HTTP/1.1 403"), "{response}");+ assert!(response.contains("blocked-by-mitm-hook"), "{response}");+ assert!(!response.contains(REAL_CREDENTIAL));+ Ok(())+}+pub(super) fn guardian_parent_catalog() -> ModelsResponse {let template = codex_models_manager::bundled_models_response().expect("bundled model catalog")diff --git a/codex-rs/network-proxy/src/credential_broker.rs b/codex-rs/network-proxy/src/credential_broker.rsindex bc3e2ffda5..57805c446d 100644--- a/codex-rs/network-proxy/src/credential_broker.rs+++ b/codex-rs/network-proxy/src/credential_broker.rs@@ -1280,11 +1280,29 @@ impl CredentialBroker {headers: &mut HeaderMap,environment_id: Option<&str>,) {+ let state = self.read_state();+ if !state.enabled {+ return;+ }++ let credentials =+ select_credentials(headers, destination, &state.credentials, environment_id);+ for (credential, header_name, header_value) in credentials {+ credential+ .provider+ .insert_request_header(headers, header_name, header_value);+ }+ }++ pub(crate) fn request_matches_hooked_host_alias(+ &self,+ destination: &str,+ headers: &HeaderMap,+ hooked_hosts: &[String],+ environment_id: Option<&str>,+ ) -> bool {let request = if destination.contains("://") {- let Ok(request) = Url::parse(destination) else {- return;- };- Some(request)+ Url::parse(destination).ok()} else {None};@@ -1296,38 +1314,50 @@ impl CredentialBroker {);let state = self.read_state();if !state.enabled {- return;+ return false;}- let credentials = select_credentials(- headers,- &normalized_host,- request.as_ref(),- &state.credentials,- environment_id,- );- if credentials.iter().any(|(credential, _, _)| {- matches!(- &credential.provider,- BrokeredCredentialProvider::Configured(_)- )- }) && let Some(request) = request.as_ref()- {- let Ok(raw_request) = destination.parse::<rama_http::Uri>() else {- return;- };- let raw_path = raw_request.path();- if raw_path != request.path()- || !crate::authorization_path::is_safe_for_authorization(raw_path)- {- return;- }- }- for (credential, header_name, header_value) in credentials {- credential- .provider- .insert_request_header(headers, header_name, header_value);+ let selected_headers =+ select_credentials(headers, destination, &state.credentials, environment_id)+ .into_iter()+ .map(|(_, name, _)| name)+ .collect::<Vec<_>>();+ if selected_headers.is_empty() {+ return false;}+ let matching_credentials = state+ .credentials+ .iter()+ .filter(|credential| {+ credential.belongs_to_environment(environment_id)+ && credential+ .host_bindings()+ .any(|binding| binding.matches_request(&normalized_host, request.as_ref()))+ })+ .collect::<Vec<_>>();++ // Ambiguity removes the whole header, so every translation for a surviving header+ // contributed through equivalent deduplication or Basic-field merging.+ matching_credentials.iter().any(|credential| {+ hooked_hosts.iter().any(|hooked_host| {+ hooked_host != &normalized_host+ && credential+ .host_bindings()+ .any(|binding| binding.matches_hostname(hooked_host))+ }) && matching_credentials.iter().any(|candidate| {+ candidate.provider.same_provider(&credential.provider)+ && candidate.real_value == credential.real_value+ && credential+ .provider+ .translate_request_headers(+ headers,+ &candidate.dummy_value,+ &credential.real_value,+ )+ .iter()+ .any(|(name, _)| selected_headers.contains(name))+ })+ })}fn read_state(&self) -> std::sync::RwLockReadGuard<'_, CredentialBrokerState> {diff --git a/codex-rs/network-proxy/src/credential_broker/destination.rs b/codex-rs/network-proxy/src/credential_broker/destination.rsindex 116ed8d083..ef1dd4a39b 100644--- a/codex-rs/network-proxy/src/credential_broker/destination.rs+++ b/codex-rs/network-proxy/src/credential_broker/destination.rs@@ -116,9 +116,10 @@ impl CredentialDestination {}pub(super) fn matches_host(&self, host: &str, port: u16) -> bool {- if self.port != port {- return false;- }+ self.port == port && self.matches_hostname(host)+ }++ pub(super) fn matches_hostname(&self, host: &str) -> bool {if self.wildcard {host.strip_suffix(&self.host).is_some_and(|prefix| prefix.ends_with('.'))diff --git a/codex-rs/network-proxy/src/credential_broker/providers.rs b/codex-rs/network-proxy/src/credential_broker/providers.rsindex aff11dc1bc..36adc873d1 100644--- a/codex-rs/network-proxy/src/credential_broker/providers.rs+++ b/codex-rs/network-proxy/src/credential_broker/providers.rs@@ -113,6 +113,18 @@ impl CredentialHostBinding {}}+ // Hooks apply to the host regardless of each credential destination's port or path.+ pub(super) fn matches_hostname(&self, host: &str) -> bool {+ match self {+ Self::ConfiguredHosts(destinations) => destinations+ .iter()+ .any(|destination| destination.matches_hostname(host)),+ Self::ExactHost(_) | Self::ExactHosts(_) | Self::HostPattern { .. } => {+ self.matches_host(host, /*port*/ 443)+ }+ }+ }+pub(super) fn requires_mitm(&self, host: &str, port: u16) -> bool {match self {Self::ConfiguredHosts(destinations) => destinationsdiff --git a/codex-rs/network-proxy/src/credential_broker/registry.rs b/codex-rs/network-proxy/src/credential_broker/registry.rsindex d9e1555f03..2f740a0a86 100644--- a/codex-rs/network-proxy/src/credential_broker/registry.rs+++ b/codex-rs/network-proxy/src/credential_broker/registry.rs@@ -10,6 +10,7 @@ use super::matching::is_operational_path_match;use super::providers;use super::source_accepts_credential;use super::source_tracks_credential;+use crate::policy::normalize_host;use base64::Engine;use rama_http::HeaderMap;use rama_http::HeaderName;@@ -189,17 +190,30 @@ pub(super) fn is_builtin_shaped_credential(value: &str) -> bool {pub(super) fn select_credentials<'a>(headers: &HeaderMap,- host: &str,- request: Option<&Url>,+ destination: &str,credentials: &'a [CredentialRecord],environment_id: Option<&str>,) -> Vec<(&'a CredentialRecord, HeaderName, HeaderValue)> {+ let request = if destination.contains("://") {+ let Ok(request) = Url::parse(destination) else {+ return Vec::new();+ };+ Some(request)+ } else {+ None+ };+ let host = normalize_host(+ request+ .as_ref()+ .and_then(Url::host_str)+ .unwrap_or(destination),+ );let mut translated_matches = Vec::<(&CredentialRecord, HeaderName, HeaderValue)>::new();for credential in credentials.iter().filter(|credential| {credential.belongs_to_environment(environment_id)&& credential.host_bindings()- .any(|binding| binding.matches_request(host, request))+ .any(|binding| binding.matches_request(&host, request.as_ref()))}) {for candidate in credentials.iter().filter(|candidate| {candidate.belongs_to_environment(environment_id)@@ -207,7 +221,7 @@ pub(super) fn select_credentials<'a>(&& candidate.real_value == credential.real_value&& candidate.host_bindings()- .any(|binding| binding.matches_request(host, request))+ .any(|binding| binding.matches_request(&host, request.as_ref()))}) {for (name, value) in credential.provider.translate_request_headers(headers,@@ -252,7 +266,7 @@ pub(super) fn select_credentials<'a>(merge_basic_auth_fields(original, &selected[existing].2, &header_value)}){- // Keep the caller's configured-provider raw-path validation for either field.+ // Keep configured-provider raw-path validation for either field.if matches!(credential.provider,BrokeredCredentialProvider::Configured(_)@@ -266,6 +280,23 @@ pub(super) fn select_credentials<'a>(ambiguous_headers.push(header_name);}}+ if selected.iter().any(|(credential, _, _)| {+ matches!(+ &credential.provider,+ BrokeredCredentialProvider::Configured(_)+ )+ }) && let Some(request) = request.as_ref()+ {+ let Ok(raw_request) = destination.parse::<rama_http::Uri>() else {+ return Vec::new();+ };+ let raw_path = raw_request.path();+ if raw_path != request.path()+ || !crate::authorization_path::is_safe_for_authorization(raw_path)+ {+ return Vec::new();+ }+ }selected}diff --git a/codex-rs/network-proxy/src/credential_broker_tests.rs b/codex-rs/network-proxy/src/credential_broker_tests.rsindex a368d2258e..43b62632fe 100644--- a/codex-rs/network-proxy/src/credential_broker_tests.rs+++ b/codex-rs/network-proxy/src/credential_broker_tests.rs@@ -1435,6 +1435,15 @@ fn openai_credentials_bind_only_to_default_and_configured_trusted_hosts() {("attacker.example", dummy.as_str()),] {let mut headers = headers_with_bearer(dummy);+ assert_eq!(+ broker.request_matches_hooked_host_alias(+ host,+ &headers,+ &["api.openai.com".to_string()],+ /*environment_id*/ None,+ ),+ host != "api.openai.com" && expected_credential == "sk-real",+ );broker.inject_request_headers(host, &mut headers);let expected = format!("Bearer {expected_credential}");assert_eq!(authorization(&headers), Some(expected.as_str()), "{host}");@@ -1457,6 +1466,69 @@ fn openai_credentials_bind_only_to_default_and_configured_trusted_hosts() {);}+#[test]+fn selected_openai_credential_matches_ipv6_alias_with_plaintext_fallback() {+ let broker = CredentialBroker::new(/*enabled*/ true);+ let mut env = env_map([+ ("OPENAI_API_KEY", "sk-real"),+ ("OPENAI_BASE_URL", "https://[fd00::1]/v1"),+ ]);+ broker.virtualize_child_env(&mut env);+ for destination in ["https://[fd00::1]/v1/models", "fd00::1"] {+ assert!(broker.request_matches_hooked_host_alias(+ destination,+ &headers_with_bearer(&env["OPENAI_API_KEY"]),+ &["api.openai.com".to_string()],+ /*environment_id*/ None,+ ));+ }+}++#[test]+fn selected_alias_checks_equivalent_and_merged_credential_bindings() {+ let broker = CredentialBroker::new(/*enabled*/ true);+ let register = |env_var: &str, token: &str, host: &str| {+ let mut env = env_map([("GH_HOST", host), (env_var, token)]);+ broker.virtualize_child_env_for_environment(&mut env, Some("selected"));+ env.insert("GH_HOST".to_string(), "alias.example".to_string());+ broker.virtualize_child_env_for_environment(&mut env, Some("selected"));+ env[env_var].clone()+ };+ let first = register("GH_ENTERPRISE_TOKEN", "ghp-first-real", "alias.example");+ let equivalent = register(+ "GITHUB_ENTERPRISE_TOKEN",+ "ghp-first-real",+ "hooked.example",+ );+ let second = register(+ "GITHUB_ENTERPRISE_TOKEN",+ "ghp-second-real",+ "second-hooked.example",+ );+ assert_ne!(first, equivalent);++ assert!(broker.request_matches_hooked_host_alias(+ "alias.example",+ &headers_with_bearer(&equivalent),+ &["hooked.example".to_string()],+ Some("selected"),+ ));+ let basic = STANDARD.encode(format!("{first}:{second}"));+ let headers = headers_with_authorization(&format!("Basic {basic}"));+ assert!(broker.request_matches_hooked_host_alias(+ "alias.example",+ &headers,+ &["second-hooked.example".to_string()],+ Some("selected"),+ ));+ assert!(!broker.request_matches_hooked_host_alias(+ "alias.example",+ &headers,+ &["second-hooked.example".to_string()],+ Some("other"),+ ));+}+#[test]fn github_cloud_credentials_match_ghe_com_host_hint() {let broker = CredentialBroker::new(/*enabled*/ true);diff --git a/codex-rs/network-proxy/src/http_proxy.rs b/codex-rs/network-proxy/src/http_proxy.rsindex b2953d35f1..883b4cef81 100644--- a/codex-rs/network-proxy/src/http_proxy.rs+++ b/codex-rs/network-proxy/src/http_proxy.rs@@ -3,6 +3,7 @@ use crate::config::NetworkMode;use crate::connect_policy::TargetCheckedTcpConnector;use crate::connection_lifecycle::CancelOnShutdown;use crate::mitm;+use crate::mitm_hook::HookEvaluation;use crate::network_policy::BlockDecisionAuditEventArgs;use crate::network_policy::NetworkDecision;use crate::network_policy::NetworkDecisionSource;@@ -16,6 +17,7 @@ use crate::network_policy::emit_block_decision_audit_event;use crate::network_policy::evaluate_host_policy;use crate::policy::normalize_host;use crate::reasons::REASON_METHOD_NOT_ALLOWED;+use crate::reasons::REASON_MITM_HOOK_DENIED;use crate::reasons::REASON_MITM_REQUIRED;use crate::reasons::REASON_NOT_ALLOWED;use crate::reasons::REASON_PROXY_DISABLED;@@ -908,13 +910,70 @@ async fn http_plain_proxy());}- if let Err(err) =- inject_forward_request_credentials(app_state.as_ref(), &request_ctx, &mut req).await+ let credential_destinations =+ match forward_request_credential_destinations(app_state.as_ref(), &request_ctx, &req).await+ {+ Ok(destinations) => destinations,+ Err(err) => {+ return Ok(internal_error(+ "failed to read credential injection config",+ err,+ ));+ }+ };+ // Evaluate the original Authorization header before replacing brokered dummy credentials.+ // Otherwise an unhooked provider alias can receive the real credential without hook policy.+ match app_state+ .evaluate_mitm_hook_request(&host, &req, &credential_destinations)+ .await{- return Ok(internal_error(- "failed to read plaintext credential injection config",- err,- ));+ Ok(HookEvaluation::HookedHostNoMatch) => {+ emit_http_block_decision_audit_event(+ &app_state,+ BlockDecisionAuditEventArgs {+ source: NetworkDecisionSource::ModeGuard,+ reason: REASON_MITM_HOOK_DENIED,+ protocol: NetworkProtocol::Http,+ server_address: host.as_str(),+ server_port: port,+ method: Some(req.method().as_str()),+ client_addr: client.as_deref(),+ },+ );+ let details = PolicyDecisionDetails {+ decision: NetworkPolicyDecision::Deny,+ reason: REASON_MITM_HOOK_DENIED,+ source: NetworkDecisionSource::ModeGuard,+ protocol: NetworkProtocol::Http,+ host: &host,+ port,+ };+ let _ = app_state+ .record_blocked(BlockedRequest::new(BlockedRequestArgs {+ host: host.clone(),+ reason: REASON_MITM_HOOK_DENIED.to_string(),+ client: client.clone(),+ method: Some(req.method().as_str().to_string()),+ mode: None,+ protocol: "http".to_string(),+ decision: Some(details.decision.as_str().to_string()),+ source: Some(details.source.as_str().to_string()),+ port: Some(port),+ }))+ .await;+ let client = client.as_deref().unwrap_or_default();+ warn!(+ "request blocked by MITM hook policy (client={client}, host={host}, method={})",+ req.method()+ );+ return Ok(json_blocked(&host, REASON_MITM_HOOK_DENIED, Some(&details)));+ }+ Ok(HookEvaluation::Matched { .. } | HookEvaluation::NoHooksForHost) => {}+ Err(err) => return Ok(internal_error("failed to evaluate MITM hook policy", err)),+ }++ for destination in credential_destinations {+ app_state.inject_request_credentials(&destination, req.headers_mut());}let client = client.as_deref().unwrap_or_default();@@ -946,11 +1005,11 @@ async fn http_plain_proxy(}}-async fn inject_forward_request_credentials(+async fn forward_request_credential_destinations(app_state: &NetworkProxyState,context: &RequestContext,- req: &mut Request,-) -> Result<()> {+ req: &Request,+) -> Result<Vec<String>> {let authority = context.host_with_port();let scheme = req.uri().scheme_str().unwrap_or("http");// Server-wide OPTIONS may use root-scoped credentials without changing its wire target.@@ -960,16 +1019,11 @@ async fn inject_forward_request_credentials(.map(rama_http::uri::PathAndQuery::as_str).filter(|path| *path != "*").unwrap_or("/");- let destination = format!("{scheme}://{authority}{request_path}");- let unrestricted_plaintext = app_state.plaintext_credential_injection_enabled().await?;- app_state.inject_request_credentials(&destination, req.headers_mut());- if unrestricted_plaintext {- app_state.inject_request_credentials(- &normalize_host(&authority.host.to_string()),- req.headers_mut(),- );+ let mut destinations = vec![format!("{scheme}://{authority}{request_path}")];+ if app_state.plaintext_credential_injection_enabled().await? {+ destinations.push(normalize_host(&authority.host.to_string()));}- Ok(())+ Ok(destinations)}async fn proxy_via_unix_socket(req: Request, socket_path: &str) -> Result<Response> {@@ -1382,9 +1436,12 @@ mod tests {.unwrap();let context = RequestContext::try_from(&req).unwrap();- inject_forward_request_credentials(&state, &context, &mut req)+ for destination in forward_request_credential_destinations(&state, &context, &req).await- .unwrap();+ .unwrap()+ {+ state.inject_request_credentials(&destination, req.headers_mut());+ }let expected = if enabled { real_token } else { dummy };assert_eq!(@@ -1482,9 +1539,12 @@ mod tests {.unwrap();let context = RequestContext::try_from(&req).unwrap();- inject_forward_request_credentials(&state, &context, &mut req)+ for destination in forward_request_credential_destinations(&state, &context, &req).await- .unwrap();+ .unwrap()+ {+ state.inject_request_credentials(&destination, req.headers_mut());+ }let expected = if inject { real_token } else { dummy };assert_eq!(@@ -1497,6 +1557,64 @@ mod tests {}}+ #[tokio::test]+ async fn http_plain_proxy_blocks_brokered_provider_alias_before_credential_injection() {+ let mut network = NetworkProxyConfig {+ allow_local_binding: Some(true),+ credential_broker: true,+ dangerously_allow_plaintext_credential_injection: true,+ mitm: true,+ mitm_hooks: vec![crate::mitm_hook::MitmHookConfig {+ host: "api.github.com".to_string(),+ matcher: crate::mitm_hook::MitmHookMatchConfig {+ methods: vec!["POST".to_string()],+ path_prefixes: vec!["/repos/openai/".to_string()],+ ..crate::mitm_hook::MitmHookMatchConfig::default()+ },+ actions: crate::mitm_hook::MitmHookActionsConfig::default(),+ }],+ ..NetworkProxyConfig::default()+ };+ network.set_allowed_domains(vec!["api.github.com".to_string(), "github.com".to_string()]);+ let state = Arc::new(network_proxy_state_for_policy(network));+ let mut env = HashMap::from([("GH_TOKEN".to_string(), "ghp-real".to_string())]);+ state.virtualize_child_credentials(&mut env);++ for scheme in ["http", "https"] {+ let mut req = Request::builder()+ .method(Method::GET)+ .uri(format!("{scheme}://github.com/repos/openai/codex/issues"))+ .header(header::HOST, "github.com")+ .header(header::AUTHORIZATION, format!("Bearer {}", env["GH_TOKEN"]))+ .body(Body::empty())+ .expect("absolute-form provider-alias request should build");+ req.extensions_mut().insert(state.clone());++ let response = http_plain_proxy(+ /*policy_decider*/ None, /*environment_id*/ None, req,+ )+ .await+ .expect("provider-alias policy should return a response");++ assert_eq!(response.status(), StatusCode::FORBIDDEN);+ assert_eq!(+ response.headers().get("x-proxy-error").unwrap(),+ "blocked-by-mitm-hook"+ );+ }++ let blocked = state.drain_blocked().await.unwrap();+ assert_eq!(blocked.len(), 2);+ assert!(blocked.iter().all(|request| {+ request.host == "github.com"+ && request.reason == REASON_MITM_HOOK_DENIED+ && request.protocol == "http"+ && request.source.as_deref() == Some("mode_guard")+ }));+ assert_eq!(blocked[0].port, Some(80));+ assert_eq!(blocked[1].port, Some(443));+ }+#[tokio::test]async fn http_connect_accept_blocks_hooked_host_in_full_mode_without_mitm_state() {let mut policy = NetworkProxyConfig {diff --git a/codex-rs/network-proxy/src/mitm.rs b/codex-rs/network-proxy/src/mitm.rsindex 60bcc85e34..021afe667e 100644--- a/codex-rs/network-proxy/src/mitm.rs+++ b/codex-rs/network-proxy/src/mitm.rs@@ -77,6 +77,16 @@ struct MitmPolicyContext {app_state: Arc<NetworkProxyState>,}+impl MitmPolicyContext {+ fn credential_destination(&self, req: &Request) -> String {+ let authority = authority_header_value(&self.target_host, self.target_port, &self.scheme);+ let path = path_and_query(req.uri());+ // Server-wide OPTIONS must not borrow authority from a narrower credential URL prefix.+ let credential_path = if path == "*" { "/" } else { &path };+ format!("{}://{authority}{credential_path}", self.scheme)+ }+}+#[derive(Clone)]struct MitmRequestContext {policy: MitmPolicyContext,@@ -248,6 +258,7 @@ async fn handle_mitm_request(}async fn forward_request(req: Request, request_ctx: &MitmRequestContext) -> Result<Response> {+ let credential_destination = request_ctx.policy.credential_destination(&req);let hook_actions = match evaluate_mitm_policy(&req, &request_ctx.policy).await? {MitmPolicyDecision::Allow { hook_actions } => hook_actions,MitmPolicyDecision::Block(response) => return Ok(response),@@ -268,12 +279,6 @@ async fn forward_request(req: Request, request_ctx: &MitmRequestContext) -> Resu.authority(authority.as_str()).path_and_query(path.as_str()).build()?;- // Server-wide OPTIONS must not borrow authority from a narrower credential URL prefix.- let credential_path = if path == "*" { "/" } else { &path };- let credential_destination = format!(- "{}://{authority}{credential_path}",- request_ctx.policy.scheme- );request_ctx.policy.app_state@@ -424,7 +429,11 @@ async fn evaluate_mitm_policy(let hook_actions = match policy.app_state- .evaluate_mitm_hook_request(&policy.target_host, req)+ .evaluate_mitm_hook_request(+ &policy.target_host,+ req,+ &[policy.credential_destination(req)],+ ).await?{HookEvaluation::Matched { actions } => Some(actions),diff --git a/codex-rs/network-proxy/src/mitm_tests.rs b/codex-rs/network-proxy/src/mitm_tests.rsindex 84ceb16b2c..89f77af3fc 100644--- a/codex-rs/network-proxy/src/mitm_tests.rs+++ b/codex-rs/network-proxy/src/mitm_tests.rs@@ -1,10 +1,13 @@use super::*;+use crate::CredentialProviderConfig;use crate::config::NetworkProxyConfig;use crate::reasons::REASON_METHOD_NOT_ALLOWED;use crate::reasons::REASON_MITM_HOOK_DENIED;use crate::reasons::REASON_NOT_ALLOWED_LOCAL;use crate::runtime::network_proxy_state_for_policy;+use base64::Engine as _;+use base64::engine::general_purpose::STANDARD;use codex_utils_absolute_path::AbsolutePathBuf;use pretty_assertions::assert_eq;use rama_http::Body;@@ -14,6 +17,7 @@ use rama_http::Method;use rama_http::Request;use rama_http::StatusCode;use rama_http::header::HeaderName;+use std::collections::HashMap;use tempfile::NamedTempFile;fn github_write_hook() -> crate::mitm_hook::MitmHookConfig {@@ -229,6 +233,149 @@ async fn mitm_policy_allows_matching_hooked_write_in_full_mode() {assert_eq!(app_state.blocked_snapshot().await.unwrap().len(), 0);}+#[tokio::test]+async fn mitm_policy_enforces_brokered_aliases_without_blocking_unrelated_credentials() {+ for hooked_hosts in [+ vec!["api.github.com"],+ vec!["api.github.com", "github.com"],+ vec![],+ ] {+ let network = NetworkProxyConfig {+ credential_broker: true,+ mitm: true,+ allow_local_binding: Some(true),+ mitm_hooks: hooked_hosts+ .iter()+ .map(|host| {+ let mut hook = github_write_hook();+ hook.host = (*host).to_string();+ hook.matcher.methods = vec!["GET".to_string()];+ hook.actions.inject_request_headers.clear();+ hook+ })+ .collect(),+ ..NetworkProxyConfig::default()+ };+ let app_state = Arc::new(network_proxy_state_for_policy(network));+ let mut env = HashMap::from([+ ("GH_TOKEN".to_string(), "ghp-real".to_string()),+ ("OPENAI_API_KEY".to_string(), "sk-real".to_string()),+ ("GH_HOST".to_string(), "enterprise.example".to_string()),+ (+ "GH_ENTERPRISE_TOKEN".to_string(),+ "ghp-enterprise-real".to_string(),+ ),+ ]);+ app_state.virtualize_child_credentials(&mut env);+ let github = format!("Bearer {}", env["GH_TOKEN"]);+ let token = format!("token {}", env["GH_TOKEN"]);+ let basic = format!(+ "Basic {}",+ STANDARD.encode(format!("x-access-token:{}", env["GH_TOKEN"]))+ );+ let openai = format!("Bearer {}", env["OPENAI_API_KEY"]);+ let enterprise = format!("Bearer {}", env["GH_ENTERPRISE_TOKEN"]);+ for (host, authorization, uses_cloud_credential) in [+ ("github.com", Some(github.as_str()), true),+ ("api.astemu.ghe.com", Some(github.as_str()), true),+ ("github.com", Some(token.as_str()), true),+ ("github.com", Some(basic.as_str()), true),+ ("github.com", None, false),+ ("github.com", Some("Bearer unrelated-token"), false),+ ("github.com", Some(openai.as_str()), false),+ ("enterprise.example", Some(enterprise.as_str()), false),+ ] {+ let ctx = policy_ctx(+ app_state.clone(),+ NetworkMode::Full,+ host,+ /*target_port*/ 443,+ );+ let mut req = Request::builder()+ .method(Method::GET)+ .uri("/repos/openai/codex/issues")+ .header(HOST, host)+ .body(Body::empty())+ .unwrap();+ if let Some(value) = authorization {+ req.headers_mut()+ .insert("authorization", HeaderValue::from_str(value).unwrap());+ }+ let denied =+ uses_cloud_credential && !hooked_hosts.is_empty() && !hooked_hosts.contains(&host);+ let response = mitm_blocking_response(&req, &ctx).await.unwrap();+ assert_eq!(+ response.as_ref().map(Response::status),+ denied.then_some(StatusCode::FORBIDDEN),+ "host: {host}, hooks: {hooked_hosts:?}"+ );+ if let Some(response) = response {+ assert_eq!(response.headers()["x-proxy-error"], "blocked-by-mitm-hook");+ }+ }+ }+}++#[tokio::test]+async fn mitm_policy_checks_configured_credential_aliases_at_the_request_destination() {+ let mut hook = github_write_hook();+ hook.host = "api.hooked.example".to_string();+ hook.actions.inject_request_headers.clear();+ let mut network = NetworkProxyConfig {+ credential_broker: true,+ mitm: true,+ allow_local_binding: Some(true),+ mitm_hooks: vec![hook],+ ..NetworkProxyConfig::default()+ };+ network.credential_providers.insert(+ "custom".to_string(),+ CredentialProviderConfig {+ env: vec!["PROVIDER_TOKEN".to_string()],+ patterns: vec!["provider_[a-z]{24}".to_string()],+ // The hooked host need not use the alias's port or path prefix.+ url_prefixes: vec![+ "https://*.hooked.example/v1".to_string(),+ "https://alias.example:8443/v2".to_string(),+ ],+ ..CredentialProviderConfig::default()+ },+ );+ let app_state = Arc::new(network_proxy_state_for_policy(network));+ let mut env = HashMap::from([(+ "PROVIDER_TOKEN".to_string(),+ "provider_abcdefghijklmnopqrstuvwx".to_string(),+ )]);+ app_state.virtualize_child_credentials(&mut env);+ let ctx = policy_ctx(+ app_state,+ NetworkMode::Full,+ "alias.example",+ /*target_port*/ 8443,+ );+ for (path, denied) in [+ ("/v2/models", true),+ ("/v20/models", false),+ ("/v2/../v2/models", false),+ ] {+ let req = Request::builder()+ .uri(path)+ .header(HOST, "alias.example:8443")+ .header("authorization", format!("Bearer {}", env["PROVIDER_TOKEN"]))+ .body(Body::empty())+ .unwrap();+ let response = mitm_blocking_response(&req, &ctx).await.unwrap();+ assert_eq!(+ response.as_ref().map(Response::status),+ denied.then_some(StatusCode::FORBIDDEN),+ "path: {path}"+ );+ if let Some(response) = response {+ assert_eq!(response.headers()["x-proxy-error"], "blocked-by-mitm-hook");+ }+ }+}+#[tokio::test]async fn mitm_policy_blocks_encoded_path_traversal_for_repository_allowlist() {let mut hook = github_write_hook();diff --git a/codex-rs/network-proxy/src/runtime.rs b/codex-rs/network-proxy/src/runtime.rsindex 87457c7464..c816bc358e 100644--- a/codex-rs/network-proxy/src/runtime.rs+++ b/codex-rs/network-proxy/src/runtime.rs@@ -982,10 +982,31 @@ impl NetworkProxyState {&self,host: &str,req: &rama_http::Request,+ credential_destinations: &[String],) -> Result<HookEvaluation> {self.reload_if_needed().await?;- let guard = self.state.read().await;- Ok(evaluate_mitm_hooks(&guard.mitm_hooks, host, req))+ let hooked_hosts = {+ let guard = self.state.read().await;+ match evaluate_mitm_hooks(&guard.mitm_hooks, host, req) {+ HookEvaluation::NoHooksForHost if !guard.mitm_hooks.is_empty() => {+ guard.mitm_hooks.keys().cloned().collect::<Vec<_>>()+ }+ evaluation => return Ok(evaluation),+ }+ };++ if credential_destinations.iter().any(|destination| {+ self.credential_broker.request_matches_hooked_host_alias(+ destination,+ req.headers(),+ &hooked_hosts,+ self.environment_id(),+ )+ }) {+ Ok(HookEvaluation::HookedHostNoMatch)+ } else {+ Ok(HookEvaluation::NoHooksForHost)+ }}pub(crate) async fn host_mitm_requirement(