From 16e78a3c8b929c67b3ad336cfbc8762421393e85 Mon Sep 17 00:00:00 2001 From: canvrno-oai Date: Wed, 27 May 2026 15:38:41 -0700 Subject: [PATCH] initial --- codex-rs/Cargo.lock | 1 + .../request_processors/account_processor.rs | 2 + codex-rs/cli/src/login.rs | 7 +- codex-rs/codex-client/Cargo.toml | 6 + codex-rs/codex-client/src/custom_ca.rs | 5 + codex-rs/codex-client/src/lib.rs | 5 + codex-rs/codex-client/src/outbound_proxy.rs | 618 ++++++++++++++++++ .../src/outbound_proxy/windows.rs | 366 +++++++++++ .../codex-client/src/route_diagnostics.rs | 25 + codex-rs/core/src/config/mod.rs | 9 + codex-rs/login/src/auth/default_client.rs | 43 +- codex-rs/login/src/auth/manager.rs | 70 +- codex-rs/login/src/auth/mod.rs | 1 + codex-rs/login/src/auth/revoke.rs | 12 +- codex-rs/login/src/device_code_auth.rs | 21 +- codex-rs/login/src/lib.rs | 3 +- codex-rs/login/src/outbound_proxy.rs | 19 + codex-rs/login/src/server.rs | 64 +- 18 files changed, 1244 insertions(+), 33 deletions(-) create mode 100644 codex-rs/codex-client/src/outbound_proxy.rs create mode 100644 codex-rs/codex-client/src/outbound_proxy/windows.rs create mode 100644 codex-rs/login/src/outbound_proxy.rs diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index 27b66293e1..6a6f7894c9 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -2340,6 +2340,7 @@ dependencies = [ "tracing", "tracing-opentelemetry", "tracing-subscriber", + "windows-sys 0.52.0", "zstd 0.13.3", ] diff --git a/codex-rs/app-server/src/request_processors/account_processor.rs b/codex-rs/app-server/src/request_processors/account_processor.rs index 17d78fb20b..c34122376c 100644 --- a/codex-rs/app-server/src/request_processors/account_processor.rs +++ b/codex-rs/app-server/src/request_processors/account_processor.rs @@ -327,6 +327,8 @@ impl AccountRequestProcessor { config.cli_auth_credentials_store_mode, ) }; + let mut opts = opts; + opts.set_network_config(config.network.as_ref()); #[cfg(debug_assertions)] let opts = { let mut opts = opts; diff --git a/codex-rs/cli/src/login.rs b/codex-rs/cli/src/login.rs index 6fdc62fdb1..2c70d82968 100644 --- a/codex-rs/cli/src/login.rs +++ b/codex-rs/cli/src/login.rs @@ -117,13 +117,15 @@ pub async fn login_with_chatgpt( codex_home: PathBuf, forced_chatgpt_workspace_id: Option>, cli_auth_credentials_store_mode: AuthCredentialsStoreMode, + network: Option<&codex_config::types::NetworkConfigToml>, ) -> std::io::Result<()> { - let opts = ServerOptions::new( + let mut opts = ServerOptions::new( codex_home, CLIENT_ID.to_string(), forced_chatgpt_workspace_id, cli_auth_credentials_store_mode, ); + opts.set_network_config(network); let server = run_login_server(opts)?; print_login_server_start(server.actual_port, &server.auth_url); @@ -147,6 +149,7 @@ pub async fn run_login_with_chatgpt(cli_config_overrides: CliConfigOverrides) -> config.codex_home.to_path_buf(), forced_chatgpt_workspace_id, config.cli_auth_credentials_store_mode, + config.network.as_ref(), ) .await { @@ -283,6 +286,7 @@ pub async fn run_login_with_device_code( forced_chatgpt_workspace_id, config.cli_auth_credentials_store_mode, ); + opts.set_network_config(config.network.as_ref()); if let Some(iss) = issuer_base_url { opts.issuer = iss; } @@ -322,6 +326,7 @@ pub async fn run_login_with_device_code_fallback_to_browser( forced_chatgpt_workspace_id, config.cli_auth_credentials_store_mode, ); + opts.set_network_config(config.network.as_ref()); if let Some(iss) = issuer_base_url { opts.issuer = iss; } diff --git a/codex-rs/codex-client/Cargo.toml b/codex-rs/codex-client/Cargo.toml index 184505eb55..cca70228db 100644 --- a/codex-rs/codex-client/Cargo.toml +++ b/codex-rs/codex-client/Cargo.toml @@ -25,6 +25,12 @@ tracing-opentelemetry = { workspace = true } codex-utils-rustls-provider = { workspace = true } zstd = { workspace = true } +[target.'cfg(target_os = "windows")'.dependencies] +windows-sys = { version = "0.52", features = [ + "Win32_Foundation", + "Win32_Networking_WinHttp", +] } + [lints] workspace = true diff --git a/codex-rs/codex-client/src/custom_ca.rs b/codex-rs/codex-client/src/custom_ca.rs index 1a211beedf..d86e9760bc 100644 --- a/codex-rs/codex-client/src/custom_ca.rs +++ b/codex-rs/codex-client/src/custom_ca.rs @@ -182,6 +182,11 @@ pub fn build_reqwest_client_with_custom_ca( build_reqwest_client_with_env(&ProcessEnv, builder) } +/// Returns whether process environment selects a Codex custom CA bundle. +pub(crate) fn custom_ca_env_configured() -> bool { + ProcessEnv.configured_ca_bundle().is_some() +} + /// Builds a rustls client config when a Codex custom CA bundle is configured. /// /// This is the websocket-facing sibling of [`build_reqwest_client_with_custom_ca`]. When diff --git a/codex-rs/codex-client/src/lib.rs b/codex-rs/codex-client/src/lib.rs index b3b23b2989..982a785607 100644 --- a/codex-rs/codex-client/src/lib.rs +++ b/codex-rs/codex-client/src/lib.rs @@ -3,6 +3,7 @@ mod chatgpt_hosts; mod custom_ca; mod default_client; mod error; +mod outbound_proxy; mod request; mod retry; mod route_diagnostics; @@ -26,6 +27,10 @@ pub use crate::default_client::CodexHttpClient; pub use crate::default_client::CodexRequestBuilder; pub use crate::error::StreamError; pub use crate::error::TransportError; +pub use crate::outbound_proxy::BuildProxiedHttpClientError; +pub use crate::outbound_proxy::OutboundProxyConfig; +pub use crate::outbound_proxy::OutboundProxyMode; +pub use crate::outbound_proxy::build_reqwest_client_for_route; pub use crate::request::PreparedRequestBody; pub use crate::request::Request; pub use crate::request::RequestBody; diff --git a/codex-rs/codex-client/src/outbound_proxy.rs b/codex-rs/codex-client/src/outbound_proxy.rs new file mode 100644 index 0000000000..ef51db4eb0 --- /dev/null +++ b/codex-rs/codex-client/src/outbound_proxy.rs @@ -0,0 +1,618 @@ +//! Conservative outbound proxy selection for resolver-aware clients. +//! +//! This module keeps the default path as close as possible to the existing +//! reqwest builder behavior. Explicit environment proxies are delegated back to +//! reqwest so its existing proxy and `NO_PROXY` behavior stays in control. The +//! Windows system resolver is only consulted when there is no explicit env +//! proxy and the caller allows system discovery. + +use std::collections::HashMap; +use std::fmt; +use std::io; +use std::sync::Mutex; +use std::sync::OnceLock; +use std::time::Duration; +use std::time::Instant; + +use crate::custom_ca::BuildCustomCaTransportError; +use crate::custom_ca::build_reqwest_client_with_custom_ca; +use crate::custom_ca::custom_ca_env_configured; +use crate::route_diagnostics::RouteDiagnostic; +use crate::route_diagnostics::RouteFailureClass; +use crate::route_diagnostics::RouteSource; +use crate::route_diagnostics::RouteTarget; +use crate::route_diagnostics::SystemProxyEnvOverride; +use thiserror::Error; + +const SYSTEM_PROXY_CACHE_TTL: Duration = Duration::from_secs(300); + +#[cfg(target_os = "windows")] +mod windows; + +/// How a resolver-aware client should choose an outbound proxy. +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] +pub enum OutboundProxyMode { + /// Preserve explicit env proxy behavior, then use supported system discovery. + #[default] + Auto, + /// Preserve only the existing reqwest/env proxy path. + Env, + /// Require supported system discovery after explicit config/env handling. + System, + /// Disable proxy use for this client. + Direct, +} + +/// Optional route-selection inputs for resolver-aware clients. +#[derive(Default, Clone, PartialEq, Eq)] +pub struct OutboundProxyConfig { + pub mode: OutboundProxyMode, + pub proxy_url: Option, +} + +impl fmt::Debug for OutboundProxyConfig { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("OutboundProxyConfig") + .field("mode", &self.mode) + .field( + "proxy_url", + &self.proxy_url.as_ref().map(|_| ""), + ) + .finish() + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum ProxyCacheMode { + Use, + Bypass, +} + +/// Error while building a resolver-aware reqwest client. +#[derive(Debug, Error)] +pub enum BuildProxiedHttpClientError { + #[error(transparent)] + CustomCa(#[from] BuildCustomCaTransportError), + + #[error("Failed to configure outbound proxy selected for {target}")] + InvalidProxyConfig { target: RouteTarget }, + + #[error("System proxy resolution for {target} failed: {failure}")] + SystemProxyUnavailable { + target: RouteTarget, + failure: RouteFailureClass, + }, +} + +impl From for io::Error { + fn from(error: BuildProxiedHttpClientError) -> Self { + match error { + BuildProxiedHttpClientError::CustomCa(error) => error.into(), + BuildProxiedHttpClientError::InvalidProxyConfig { .. } + | BuildProxiedHttpClientError::SystemProxyUnavailable { .. } => io::Error::other(error), + } + } +} + +/// Builds a reqwest client with conservative route selection and shared CA handling. +pub fn build_reqwest_client_for_route( + builder: reqwest::ClientBuilder, + request_url: &str, + target: RouteTarget, + config: Option<&OutboundProxyConfig>, +) -> Result { + let builder = + configure_proxy_for_route(builder, request_url, target, config, ProxyCacheMode::Use)?; + build_reqwest_client_with_custom_ca(builder).map_err(Into::into) +} + +fn configure_proxy_for_route( + builder: reqwest::ClientBuilder, + request_url: &str, + target: RouteTarget, + config: Option<&OutboundProxyConfig>, + cache_mode: ProxyCacheMode, +) -> Result { + let config = config.cloned().unwrap_or_default(); + let custom_ca_configured = custom_ca_env_configured(); + let origin = RequestOrigin::parse(request_url); + + if config.mode == OutboundProxyMode::Direct { + RouteDiagnostic::direct(target, RouteSource::Disabled, custom_ca_configured).emit_opt_in(); + return Ok(builder.no_proxy()); + } + + if origin.as_ref().is_some_and(no_proxy_env_matches_origin) { + RouteDiagnostic::direct(target, RouteSource::Env, custom_ca_configured).emit_opt_in(); + return Ok(builder); + } + + if let Some(proxy_url) = config + .proxy_url + .as_deref() + .filter(|value| !value.is_empty()) + { + return configure_concrete_proxy( + builder, + target, + RouteSource::ConfigOverride, + proxy_url, + custom_ca_configured, + ); + } + + if let Some(origin) = origin.as_ref() + && let Some(proxy_url) = env_proxy_for_origin(origin) + { + RouteDiagnostic::proxy(target, RouteSource::Env, &proxy_url, custom_ca_configured) + .emit_opt_in(); + return Ok(builder); + } + + if conventional_proxy_env_present() { + RouteDiagnostic::direct(target, RouteSource::Env, custom_ca_configured).emit_opt_in(); + return Ok(builder); + } + + if config.mode == OutboundProxyMode::Env + || !SystemProxyEnvOverride::from_env().system_discovery_enabled() + { + RouteDiagnostic::direct(target, RouteSource::Disabled, custom_ca_configured).emit_opt_in(); + return Ok(builder); + } + + if !system_proxy_supported() { + if config.mode == OutboundProxyMode::System { + RouteDiagnostic::unavailable( + target, + RouteSource::Unavailable, + RouteFailureClass::PacUnavailable, + custom_ca_configured, + ) + .emit_opt_in(); + return Err(BuildProxiedHttpClientError::SystemProxyUnavailable { + target, + failure: RouteFailureClass::PacUnavailable, + }); + } + return Ok(builder); + } + + let Some(origin) = origin else { + RouteDiagnostic::unavailable( + target, + RouteSource::Error, + RouteFailureClass::InvalidProxyConfig, + custom_ca_configured, + ) + .emit_opt_in(); + return if config.mode == OutboundProxyMode::System { + Err(BuildProxiedHttpClientError::SystemProxyUnavailable { + target, + failure: RouteFailureClass::InvalidProxyConfig, + }) + } else { + Ok(builder) + }; + }; + + match resolve_system_proxy(request_url, &origin, cache_mode) { + SystemProxyDecision::Direct { source } => { + RouteDiagnostic::direct(target, source, custom_ca_configured).emit_opt_in(); + Ok(builder) + } + SystemProxyDecision::Proxy { source, url } => { + configure_concrete_proxy(builder, target, source, &url, custom_ca_configured) + } + SystemProxyDecision::Unavailable { source, failure } => { + RouteDiagnostic::unavailable(target, source, failure, custom_ca_configured) + .emit_opt_in(); + if config.mode == OutboundProxyMode::System { + Err(BuildProxiedHttpClientError::SystemProxyUnavailable { target, failure }) + } else { + Ok(builder) + } + } + } +} + +const fn system_proxy_supported() -> bool { + cfg!(target_os = "windows") +} + +fn configure_concrete_proxy( + builder: reqwest::ClientBuilder, + target: RouteTarget, + source: RouteSource, + proxy_url: &str, + custom_ca_configured: bool, +) -> Result { + let proxy = match reqwest::Proxy::all(proxy_url) { + Ok(proxy) => proxy, + Err(_source) => { + RouteDiagnostic::unavailable( + target, + source, + RouteFailureClass::InvalidProxyConfig, + custom_ca_configured, + ) + .emit_opt_in(); + return Err(BuildProxiedHttpClientError::InvalidProxyConfig { target }); + } + }; + RouteDiagnostic::proxy(target, source, proxy_url, custom_ca_configured).emit_opt_in(); + Ok(builder.proxy(proxy)) +} + +#[derive(Debug, Clone, PartialEq, Eq)] +struct RequestOrigin { + scheme: String, + host: String, + port: u16, +} + +impl RequestOrigin { + fn parse(request_url: &str) -> Option { + let uri = request_url.parse::().ok()?; + let scheme = uri.scheme_str()?.to_ascii_lowercase(); + let host = uri.host()?.trim_matches(['[', ']']).to_ascii_lowercase(); + let port = uri + .port_u16() + .or_else(|| default_port_for_scheme(&scheme))?; + Some(Self { scheme, host, port }) + } + + fn cache_key(&self) -> String { + format!("{}://{}:{}", self.scheme, self.host, self.port) + } +} + +fn default_port_for_scheme(scheme: &str) -> Option { + match scheme { + "http" => Some(80), + "https" => Some(443), + _ => None, + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +enum SystemProxyDecision { + Direct { + source: RouteSource, + }, + Proxy { + source: RouteSource, + url: String, + }, + Unavailable { + source: RouteSource, + failure: RouteFailureClass, + }, +} + +fn resolve_system_proxy( + request_url: &str, + origin: &RequestOrigin, + cache_mode: ProxyCacheMode, +) -> SystemProxyDecision { + if cache_mode == ProxyCacheMode::Use + && let Some(decision) = cached_system_proxy_decision(origin) + { + return decision; + } + + let decision = resolve_platform_system_proxy(request_url, origin); + cache_system_proxy_decision(origin, decision.clone()); + decision +} + +#[cfg(target_os = "windows")] +fn resolve_platform_system_proxy(request_url: &str, origin: &RequestOrigin) -> SystemProxyDecision { + windows::resolve(request_url, origin) +} + +#[cfg(not(target_os = "windows"))] +fn resolve_platform_system_proxy( + _request_url: &str, + _origin: &RequestOrigin, +) -> SystemProxyDecision { + SystemProxyDecision::Unavailable { + source: RouteSource::Unavailable, + failure: RouteFailureClass::PacUnavailable, + } +} + +#[derive(Debug, Clone)] +struct CachedSystemProxyDecision { + decision: SystemProxyDecision, + expires_at: Instant, +} + +static SYSTEM_PROXY_CACHE: OnceLock>> = + OnceLock::new(); + +fn cached_system_proxy_decision(origin: &RequestOrigin) -> Option { + let cache = SYSTEM_PROXY_CACHE.get_or_init(|| Mutex::new(HashMap::new())); + let mut cache = cache.lock().ok()?; + let key = origin.cache_key(); + let cached = cache.get(&key)?; + if cached.expires_at > Instant::now() { + return Some(cached.decision.clone()); + } + cache.remove(&key); + None +} + +fn cache_system_proxy_decision(origin: &RequestOrigin, decision: SystemProxyDecision) { + let cache = SYSTEM_PROXY_CACHE.get_or_init(|| Mutex::new(HashMap::new())); + if let Ok(mut cache) = cache.lock() { + cache.insert( + origin.cache_key(), + CachedSystemProxyDecision { + decision, + expires_at: Instant::now() + SYSTEM_PROXY_CACHE_TTL, + }, + ); + } +} + +fn conventional_proxy_env_present() -> bool { + proxy_env_value("HTTPS_PROXY").is_some() + || proxy_env_value("HTTP_PROXY").is_some() + || proxy_env_value("ALL_PROXY").is_some() +} + +fn env_proxy_for_origin(origin: &RequestOrigin) -> Option { + if origin.scheme == "https" { + proxy_env_value("HTTPS_PROXY").or_else(|| proxy_env_value("ALL_PROXY")) + } else if origin.scheme == "http" { + proxy_env_value("HTTP_PROXY").or_else(|| proxy_env_value("ALL_PROXY")) + } else { + proxy_env_value("ALL_PROXY") + } +} + +fn proxy_env_value(upper: &str) -> Option { + let lower = upper.to_ascii_lowercase(); + std::env::var(upper) + .ok() + .filter(|value| !value.is_empty()) + .or_else(|| std::env::var(lower).ok().filter(|value| !value.is_empty())) +} + +fn no_proxy_env_matches_origin(origin: &RequestOrigin) -> bool { + let Some(no_proxy) = proxy_env_value("NO_PROXY") else { + return false; + }; + no_proxy_matches_origin(&no_proxy, origin) +} + +fn no_proxy_matches_origin(no_proxy: &str, origin: &RequestOrigin) -> bool { + no_proxy + .split(',') + .map(str::trim) + .filter(|entry| !entry.is_empty()) + .any(|entry| no_proxy_entry_matches_origin(entry, origin)) +} + +fn no_proxy_entry_matches_origin(entry: &str, origin: &RequestOrigin) -> bool { + if entry == "*" { + return true; + } + + let mut entry = entry + .strip_prefix("http://") + .or_else(|| entry.strip_prefix("https://")) + .unwrap_or(entry) + .trim_matches(['[', ']']) + .to_ascii_lowercase(); + let mut port = None; + let parsed_host_port = entry.rsplit_once(':').and_then(|(host, candidate_port)| { + if host.contains(':') { + return None; + } + candidate_port + .parse::() + .ok() + .map(|parsed_port| (host.to_string(), parsed_port)) + }); + if let Some((host, parsed_port)) = parsed_host_port { + entry = host; + port = Some(parsed_port); + } + if port.is_some_and(|port| port != origin.port) { + return false; + } + + if let Some(suffix) = entry.strip_prefix('.') { + return origin.host == suffix || origin.host.ends_with(&format!(".{suffix}")); + } + + if entry.contains('*') { + return wildcard_host_match(&entry, &origin.host); + } + + origin.host == entry || origin.host.ends_with(&format!(".{entry}")) +} + +fn wildcard_host_match(pattern: &str, host: &str) -> bool { + let mut remaining = host; + let mut first = true; + for part in pattern.split('*') { + if part.is_empty() { + continue; + } + if first && !pattern.starts_with('*') { + let Some(stripped) = remaining.strip_prefix(part) else { + return false; + }; + remaining = stripped; + } else { + let Some(index) = remaining.find(part) else { + return false; + }; + remaining = &remaining[index + part.len()..]; + } + first = false; + } + pattern.ends_with('*') || remaining.is_empty() +} + +#[derive(Debug, Clone, PartialEq, Eq)] +enum ParsedProxyListDecision { + Direct, + Proxy(String), + UnsupportedScheme, + Unavailable, +} + +fn parse_proxy_list(input: &str, target_scheme: &str) -> ParsedProxyListDecision { + let mut saw_unsupported = false; + let mut http_fallback = None; + for token in input + .split(';') + .map(str::trim) + .filter(|token| !token.is_empty()) + { + if target_scheme == "https" + && http_fallback.is_none() + && let Some(ParsedProxyListDecision::Proxy(url)) = parse_proxy_key_token(token, "http") + { + http_fallback = Some(url); + } + match parse_proxy_token(token, target_scheme) { + ParsedProxyListDecision::Direct => return ParsedProxyListDecision::Direct, + ParsedProxyListDecision::Proxy(url) => return ParsedProxyListDecision::Proxy(url), + ParsedProxyListDecision::UnsupportedScheme => saw_unsupported = true, + ParsedProxyListDecision::Unavailable => {} + } + } + + if let Some(url) = http_fallback { + ParsedProxyListDecision::Proxy(url) + } else if saw_unsupported { + ParsedProxyListDecision::UnsupportedScheme + } else { + ParsedProxyListDecision::Unavailable + } +} + +fn parse_proxy_token(token: &str, target_scheme: &str) -> ParsedProxyListDecision { + if token.eq_ignore_ascii_case("DIRECT") { + return ParsedProxyListDecision::Direct; + } + + if let Some(decision) = parse_proxy_key_token(token, target_scheme) { + return decision; + } + if token.contains('=') { + return ParsedProxyListDecision::Unavailable; + } + + if let Some((scheme, hostport)) = token.split_once(' ') { + let scheme = scheme.trim().to_ascii_lowercase(); + let hostport = hostport.trim(); + return match scheme.as_str() { + "proxy" | "http" => proxy_url_from_hostport("http", hostport), + "https" => proxy_url_from_hostport("https", hostport), + "socks" | "socks4" | "socks5" => ParsedProxyListDecision::UnsupportedScheme, + _ => ParsedProxyListDecision::Unavailable, + }; + } + + proxy_url_from_hostport("http", token) +} + +fn parse_proxy_key_token(token: &str, target_scheme: &str) -> Option { + let (key, value) = token.split_once('=')?; + if key.trim().eq_ignore_ascii_case(target_scheme) { + Some(proxy_url_from_hostport("http", value.trim())) + } else { + Some(ParsedProxyListDecision::Unavailable) + } +} + +fn proxy_url_from_hostport(proxy_scheme: &str, hostport: &str) -> ParsedProxyListDecision { + if hostport.is_empty() { + return ParsedProxyListDecision::Unavailable; + } + if hostport.contains("://") { + return ParsedProxyListDecision::Proxy(hostport.to_string()); + } + ParsedProxyListDecision::Proxy(format!("{proxy_scheme}://{hostport}")) +} + +impl fmt::Display for ParsedProxyListDecision { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Direct => f.write_str("direct"), + Self::Proxy(_) => f.write_str("proxy"), + Self::UnsupportedScheme => f.write_str("unsupported_scheme"), + Self::Unavailable => f.write_str("unavailable"), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use pretty_assertions::assert_eq; + + #[test] + fn parses_pac_proxy_tokens() { + assert_eq!( + parse_proxy_list("PROXY proxy.internal:8080; DIRECT", "https"), + ParsedProxyListDecision::Proxy("http://proxy.internal:8080".to_string()) + ); + assert_eq!( + parse_proxy_list("HTTPS proxy.internal:8443", "https"), + ParsedProxyListDecision::Proxy("https://proxy.internal:8443".to_string()) + ); + } + + #[test] + fn parses_static_winhttp_proxy_entries_for_target_scheme() { + assert_eq!( + parse_proxy_list("http=web-proxy:8080;https=secure-proxy:8443", "https"), + ParsedProxyListDecision::Proxy("http://secure-proxy:8443".to_string()) + ); + assert_eq!( + parse_proxy_list("proxy.internal:8080", "https"), + ParsedProxyListDecision::Proxy("http://proxy.internal:8080".to_string()) + ); + } + + #[test] + fn reports_direct_and_unsupported_proxy_tokens() { + assert_eq!( + parse_proxy_list("PROXY proxy.internal:8080; DIRECT", "https"), + ParsedProxyListDecision::Proxy("http://proxy.internal:8080".to_string()) + ); + assert_eq!( + parse_proxy_list("DIRECT; PROXY proxy.internal:8080", "https"), + ParsedProxyListDecision::Direct + ); + assert_eq!( + parse_proxy_list("DIRECT", "https"), + ParsedProxyListDecision::Direct + ); + assert_eq!( + parse_proxy_list("SOCKS proxy.internal:1080", "https"), + ParsedProxyListDecision::UnsupportedScheme + ); + } + + #[test] + fn no_proxy_matches_exact_suffix_wildcard_and_port() { + let origin = RequestOrigin { + scheme: "https".to_string(), + host: "auth.openai.com".to_string(), + port: 443, + }; + assert!(no_proxy_matches_origin("auth.openai.com", &origin)); + assert!(no_proxy_matches_origin(".openai.com", &origin)); + assert!(no_proxy_matches_origin("*.openai.com", &origin)); + assert!(no_proxy_matches_origin("auth.openai.com:443", &origin)); + assert!(!no_proxy_matches_origin("auth.openai.com:8443", &origin)); + } +} diff --git a/codex-rs/codex-client/src/outbound_proxy/windows.rs b/codex-rs/codex-client/src/outbound_proxy/windows.rs new file mode 100644 index 0000000000..f786560201 --- /dev/null +++ b/codex-rs/codex-client/src/outbound_proxy/windows.rs @@ -0,0 +1,366 @@ +use std::ffi::c_void; +use std::ptr; + +use super::ParsedProxyListDecision; +use super::RequestOrigin; +use super::SystemProxyDecision; +use super::no_proxy_matches_origin; +use super::parse_proxy_list; +use crate::route_diagnostics::RouteFailureClass; +use crate::route_diagnostics::RouteSource; +use windows_sys::Win32::Foundation::FALSE; +use windows_sys::Win32::Foundation::GetLastError; +use windows_sys::Win32::Foundation::GlobalFree; +use windows_sys::Win32::Foundation::TRUE; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_AUTODETECTION_FAILED; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_BAD_AUTO_PROXY_SCRIPT; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_CANNOT_CONNECT; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_CONNECTION_ERROR; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_INVALID_URL; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_LOGIN_FAILURE; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_NAME_NOT_RESOLVED; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SCRIPT_EXECUTION_ERROR; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_CERT_CN_INVALID; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_CERT_DATE_INVALID; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_CERT_REV_FAILED; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_CERT_REVOKED; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_CERT_WRONG_USAGE; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_CHANNEL_ERROR; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_FAILURE; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_INVALID_CA; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_SECURE_INVALID_CERT; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_TIMEOUT; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_UNHANDLED_SCRIPT_TYPE; +use windows_sys::Win32::Networking::WinHttp::ERROR_WINHTTP_UNRECOGNIZED_SCHEME; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_ACCESS_TYPE_NAMED_PROXY; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_ACCESS_TYPE_NO_PROXY; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_AUTO_DETECT_TYPE_DHCP; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_AUTO_DETECT_TYPE_DNS_A; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_AUTOPROXY_AUTO_DETECT; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_AUTOPROXY_CONFIG_URL; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_AUTOPROXY_OPTIONS; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_CURRENT_USER_IE_PROXY_CONFIG; +use windows_sys::Win32::Networking::WinHttp::WINHTTP_PROXY_INFO; +use windows_sys::Win32::Networking::WinHttp::WinHttpCloseHandle; +use windows_sys::Win32::Networking::WinHttp::WinHttpGetIEProxyConfigForCurrentUser; +use windows_sys::Win32::Networking::WinHttp::WinHttpGetProxyForUrl; +use windows_sys::Win32::Networking::WinHttp::WinHttpOpen; +use windows_sys::core::PWSTR; + +pub(super) fn resolve(request_url: &str, origin: &RequestOrigin) -> SystemProxyDecision { + let ie_config = match current_user_ie_proxy_config() { + Ok(config) => config, + Err(failure) => { + return SystemProxyDecision::Unavailable { + source: RouteSource::Error, + failure, + }; + } + }; + + if let Some(pac_url) = ie_config.auto_config_url.as_deref() { + let decision = resolve_with_pac_url(request_url, origin, pac_url); + if !matches!(decision, SystemProxyDecision::Unavailable { .. }) { + return decision; + } + } + + if ie_config.auto_detect { + let decision = resolve_with_auto_detect(request_url, origin); + if !matches!(decision, SystemProxyDecision::Unavailable { .. }) { + return decision; + } + } + + if let Some(proxy) = ie_config.static_proxy.as_deref() { + if ie_config + .proxy_bypass + .as_deref() + .is_some_and(|bypass| proxy_bypass_matches_origin(bypass, origin)) + { + return SystemProxyDecision::Direct { + source: RouteSource::WindowsStatic, + }; + } + return proxy_list_decision(proxy, origin, RouteSource::WindowsStatic); + } + + if ie_config.auto_config_url.is_some() || ie_config.auto_detect { + SystemProxyDecision::Unavailable { + source: RouteSource::WindowsWinHttpPac, + failure: RouteFailureClass::PacUnavailable, + } + } else { + SystemProxyDecision::Direct { + source: RouteSource::Direct, + } + } +} + +fn resolve_with_pac_url( + request_url: &str, + origin: &RequestOrigin, + pac_url: &str, +) -> SystemProxyDecision { + let pac_url = wide_null(pac_url); + let options = WINHTTP_AUTOPROXY_OPTIONS { + dwFlags: WINHTTP_AUTOPROXY_CONFIG_URL, + dwAutoDetectFlags: 0, + lpszAutoConfigUrl: pac_url.as_ptr(), + lpvReserved: ptr::null_mut(), + dwReserved: 0, + fAutoLogonIfChallenged: TRUE, + }; + resolve_with_winhttp_options(request_url, origin, options) +} + +fn resolve_with_auto_detect(request_url: &str, origin: &RequestOrigin) -> SystemProxyDecision { + let options = WINHTTP_AUTOPROXY_OPTIONS { + dwFlags: WINHTTP_AUTOPROXY_AUTO_DETECT, + dwAutoDetectFlags: WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A, + lpszAutoConfigUrl: ptr::null(), + lpvReserved: ptr::null_mut(), + dwReserved: 0, + fAutoLogonIfChallenged: TRUE, + }; + resolve_with_winhttp_options(request_url, origin, options) +} + +fn resolve_with_winhttp_options( + request_url: &str, + origin: &RequestOrigin, + mut options: WINHTTP_AUTOPROXY_OPTIONS, +) -> SystemProxyDecision { + let Some(session) = WinHttpSession::open() else { + return SystemProxyDecision::Unavailable { + source: RouteSource::WindowsWinHttpPac, + failure: classify_winhttp_error(last_error()), + }; + }; + + let request_url = wide_null(request_url); + let mut proxy_info = WINHTTP_PROXY_INFO { + dwAccessType: WINHTTP_ACCESS_TYPE_NO_PROXY, + lpszProxy: ptr::null_mut(), + lpszProxyBypass: ptr::null_mut(), + }; + let ok = unsafe { + WinHttpGetProxyForUrl( + session.0, + request_url.as_ptr(), + &mut options, + &mut proxy_info, + ) + }; + if ok == FALSE { + return SystemProxyDecision::Unavailable { + source: RouteSource::WindowsWinHttpPac, + failure: classify_winhttp_error(last_error()), + }; + } + + let proxy_info = ProxyInfo::from_raw(proxy_info); + if proxy_info.access_type == WINHTTP_ACCESS_TYPE_NO_PROXY { + return SystemProxyDecision::Direct { + source: RouteSource::WindowsWinHttpPac, + }; + } + if proxy_info.access_type != WINHTTP_ACCESS_TYPE_NAMED_PROXY { + return SystemProxyDecision::Unavailable { + source: RouteSource::WindowsWinHttpPac, + failure: RouteFailureClass::PacUnavailable, + }; + } + let Some(proxy) = proxy_info.proxy.as_deref() else { + return SystemProxyDecision::Unavailable { + source: RouteSource::WindowsWinHttpPac, + failure: RouteFailureClass::PacUnavailable, + }; + }; + proxy_list_decision(proxy, origin, RouteSource::WindowsWinHttpPac) +} + +fn proxy_list_decision( + proxy_list: &str, + origin: &RequestOrigin, + source: RouteSource, +) -> SystemProxyDecision { + match parse_proxy_list(proxy_list, &origin.scheme) { + ParsedProxyListDecision::Direct => SystemProxyDecision::Direct { source }, + ParsedProxyListDecision::Proxy(url) => SystemProxyDecision::Proxy { source, url }, + ParsedProxyListDecision::UnsupportedScheme => SystemProxyDecision::Unavailable { + source, + failure: RouteFailureClass::UnsupportedProxyScheme, + }, + ParsedProxyListDecision::Unavailable => SystemProxyDecision::Unavailable { + source, + failure: RouteFailureClass::PacUnavailable, + }, + } +} + +fn current_user_ie_proxy_config() -> Result { + let mut raw = WINHTTP_CURRENT_USER_IE_PROXY_CONFIG { + fAutoDetect: FALSE, + lpszAutoConfigUrl: ptr::null_mut(), + lpszProxy: ptr::null_mut(), + lpszProxyBypass: ptr::null_mut(), + }; + let ok = unsafe { WinHttpGetIEProxyConfigForCurrentUser(&mut raw) }; + if ok == FALSE { + return Err(classify_winhttp_error(last_error())); + } + + let auto_config_url = GlobalWideString::from_raw(raw.lpszAutoConfigUrl).into_string(); + let static_proxy = GlobalWideString::from_raw(raw.lpszProxy).into_string(); + let proxy_bypass = GlobalWideString::from_raw(raw.lpszProxyBypass).into_string(); + + Ok(IeProxyConfig { + auto_detect: raw.fAutoDetect != FALSE, + auto_config_url, + static_proxy, + proxy_bypass, + }) +} + +#[derive(Debug)] +struct IeProxyConfig { + auto_detect: bool, + auto_config_url: Option, + static_proxy: Option, + proxy_bypass: Option, +} + +struct ProxyInfo { + access_type: u32, + proxy: Option, + _proxy_bypass: Option, +} + +impl ProxyInfo { + fn from_raw(raw: WINHTTP_PROXY_INFO) -> Self { + Self { + access_type: raw.dwAccessType, + proxy: GlobalWideString::from_raw(raw.lpszProxy).into_string(), + _proxy_bypass: GlobalWideString::from_raw(raw.lpszProxyBypass).into_string(), + } + } +} + +struct GlobalWideString(PWSTR); + +impl GlobalWideString { + fn from_raw(ptr: PWSTR) -> Self { + Self(ptr) + } + + fn into_string(self) -> Option { + if self.0.is_null() { + return None; + } + let string = unsafe { wide_ptr_to_string(self.0) }; + if string.is_empty() { + None + } else { + Some(string) + } + } +} + +impl Drop for GlobalWideString { + fn drop(&mut self) { + if !self.0.is_null() { + unsafe { + GlobalFree(self.0.cast::()); + } + } + } +} + +struct WinHttpSession(*mut c_void); + +impl WinHttpSession { + fn open() -> Option { + let agent = wide_null("Codex"); + let handle = unsafe { + WinHttpOpen( + agent.as_ptr(), + WINHTTP_ACCESS_TYPE_NO_PROXY, + ptr::null(), + ptr::null(), + 0, + ) + }; + if handle.is_null() { + None + } else { + Some(Self(handle)) + } + } +} + +impl Drop for WinHttpSession { + fn drop(&mut self) { + if !self.0.is_null() { + unsafe { + WinHttpCloseHandle(self.0); + } + } + } +} + +fn proxy_bypass_matches_origin(proxy_bypass: &str, origin: &RequestOrigin) -> bool { + proxy_bypass.split([';', ',']).map(str::trim).any(|entry| { + if entry.eq_ignore_ascii_case("") { + !origin.host.contains('.') + } else { + no_proxy_matches_origin(entry, origin) + } + }) +} + +fn wide_null(value: &str) -> Vec { + value.encode_utf16().chain(std::iter::once(0)).collect() +} + +unsafe fn wide_ptr_to_string(ptr: PWSTR) -> String { + let mut len = 0; + while unsafe { *ptr.add(len) } != 0 { + len += 1; + } + let slice = unsafe { std::slice::from_raw_parts(ptr, len) }; + String::from_utf16_lossy(slice) +} + +fn last_error() -> u32 { + unsafe { GetLastError() } +} + +fn classify_winhttp_error(code: u32) -> RouteFailureClass { + match code { + ERROR_WINHTTP_TIMEOUT => RouteFailureClass::ConnectTimeout, + ERROR_WINHTTP_LOGIN_FAILURE => RouteFailureClass::ProxyAuthenticationRequired, + ERROR_WINHTTP_AUTODETECTION_FAILED + | ERROR_WINHTTP_BAD_AUTO_PROXY_SCRIPT + | ERROR_WINHTTP_SCRIPT_EXECUTION_ERROR + | ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT + | ERROR_WINHTTP_UNHANDLED_SCRIPT_TYPE => RouteFailureClass::PacUnavailable, + ERROR_WINHTTP_SECURE_CERT_CN_INVALID + | ERROR_WINHTTP_SECURE_CERT_DATE_INVALID + | ERROR_WINHTTP_SECURE_CERT_REVOKED + | ERROR_WINHTTP_SECURE_CERT_REV_FAILED + | ERROR_WINHTTP_SECURE_CERT_WRONG_USAGE + | ERROR_WINHTTP_SECURE_CHANNEL_ERROR + | ERROR_WINHTTP_SECURE_FAILURE + | ERROR_WINHTTP_SECURE_INVALID_CA + | ERROR_WINHTTP_SECURE_INVALID_CERT => RouteFailureClass::TlsError, + ERROR_WINHTTP_INVALID_URL | ERROR_WINHTTP_UNRECOGNIZED_SCHEME => { + RouteFailureClass::InvalidProxyConfig + } + ERROR_WINHTTP_CANNOT_CONNECT + | ERROR_WINHTTP_CONNECTION_ERROR + | ERROR_WINHTTP_NAME_NOT_RESOLVED => RouteFailureClass::ResolverError, + _ => RouteFailureClass::ResolverError, + } +} diff --git a/codex-rs/codex-client/src/route_diagnostics.rs b/codex-rs/codex-client/src/route_diagnostics.rs index d234db3e93..7bb576eca8 100644 --- a/codex-rs/codex-client/src/route_diagnostics.rs +++ b/codex-rs/codex-client/src/route_diagnostics.rs @@ -187,9 +187,12 @@ pub enum RouteSource { ConfigOverride, Env, System, + WindowsWinHttpPac, + WindowsStatic, Direct, Disabled, Unavailable, + Error, } impl fmt::Display for RouteSource { @@ -198,9 +201,12 @@ impl fmt::Display for RouteSource { Self::ConfigOverride => "config_override", Self::Env => "env", Self::System => "system", + Self::WindowsWinHttpPac => "windows_winhttp_pac", + Self::WindowsStatic => "windows_static", Self::Direct => "direct", Self::Disabled => "disabled", Self::Unavailable => "unavailable", + Self::Error => "error", }) } } @@ -401,6 +407,25 @@ impl RouteDiagnostic { "outbound route diagnostic" ); } + + /// Emit a redacted structured info event when diagnostics are explicitly enabled. + pub fn emit_opt_in(&self) { + if !network_diagnostics_enabled() { + return; + } + let failure = self + .failure + .map(|failure| failure.to_string()) + .unwrap_or_else(|| "none".to_string()); + tracing::info!( + route_target = %self.target, + source = %self.source, + decision = %self.decision, + failure = %failure, + custom_ca_configured = self.custom_ca_configured, + "opt-in outbound route diagnostic" + ); + } } #[cfg(test)] diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rs index 051064f279..59ff6b913b 100644 --- a/codex-rs/core/src/config/mod.rs +++ b/codex-rs/core/src/config/mod.rs @@ -43,6 +43,7 @@ use codex_config::types::McpServerDisabledReason; use codex_config::types::McpServerTransportConfig; use codex_config::types::MemoriesConfig; use codex_config::types::ModelAvailabilityNuxConfig; +use codex_config::types::NetworkConfigToml; use codex_config::types::Notice; use codex_config::types::OAuthCredentialsStoreMode; use codex_config::types::SessionPickerViewMode; @@ -928,6 +929,9 @@ pub struct Config { /// Base URL for requests to ChatGPT (as opposed to the OpenAI API). pub chatgpt_base_url: String, + /// Host outbound proxy selection settings for resolver-aware clients. + pub network: Option, + /// Optional path override for the host-owned apps MCP server. pub apps_mcp_path_override: Option, @@ -1103,6 +1107,10 @@ impl AuthManagerConfig for Config { fn chatgpt_base_url(&self) -> String { self.chatgpt_base_url.clone() } + + fn network_config(&self) -> Option { + self.network.clone() + } } #[derive(Clone, Default)] @@ -3527,6 +3535,7 @@ impl Config { chatgpt_base_url: cfg .chatgpt_base_url .unwrap_or("https://chatgpt.com/backend-api/".to_string()), + network: cfg.network, apps_mcp_path_override, apps_mcp_product_sku: cfg.apps_mcp_product_sku.clone(), realtime_audio: cfg diff --git a/codex-rs/login/src/auth/default_client.rs b/codex-rs/login/src/auth/default_client.rs index ee51edf9b5..d6bdfef791 100644 --- a/codex-rs/login/src/auth/default_client.rs +++ b/codex-rs/login/src/auth/default_client.rs @@ -4,9 +4,12 @@ //! Use [`crate::default_client`] or [`codex_login::default_client`] from other crates in this //! workspace. -use codex_client::BuildCustomCaTransportError; +use codex_client::BuildProxiedHttpClientError; use codex_client::CodexHttpClient; pub use codex_client::CodexRequestBuilder; +use codex_client::OutboundProxyConfig; +use codex_client::RouteTarget; +use codex_client::build_reqwest_client_for_route; use codex_client::build_reqwest_client_with_custom_ca; use codex_client::with_chatgpt_cloudflare_cookie_store; use codex_terminal_detection::user_agent; @@ -36,6 +39,7 @@ pub static USER_AGENT_SUFFIX: LazyLock>> = LazyLock::new(|| pub const DEFAULT_ORIGINATOR: &str = "codex_cli_rs"; pub const CODEX_INTERNAL_ORIGINATOR_OVERRIDE_ENV_VAR: &str = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"; pub const RESIDENCY_HEADER_NAME: &str = "x-openai-internal-codex-residency"; +const DEFAULT_AUTH_ROUTE_URL: &str = "https://auth.openai.com/oauth/token"; pub use codex_config::ResidencyRequirement; @@ -194,6 +198,13 @@ pub fn create_client() -> CodexHttpClient { CodexHttpClient::new(inner) } +pub fn create_client_with_proxy_config( + outbound_proxy_config: Option<&OutboundProxyConfig>, +) -> CodexHttpClient { + let inner = build_reqwest_client_with_proxy_config(outbound_proxy_config); + CodexHttpClient::new(inner) +} + /// Builds the default reqwest client used for ordinary Codex HTTP traffic. /// /// This starts from the standard Codex user agent, default headers, and sandbox-specific proxy @@ -201,7 +212,13 @@ pub fn create_client() -> CodexHttpClient { /// `SSL_CERT_FILE`. The function remains infallible for compatibility with existing call sites, so /// a custom-CA or builder failure is logged and falls back to `reqwest::Client::new()`. pub fn build_reqwest_client() -> reqwest::Client { - try_build_reqwest_client().unwrap_or_else(|error| { + build_reqwest_client_with_proxy_config(/*outbound_proxy_config*/ None) +} + +pub fn build_reqwest_client_with_proxy_config( + outbound_proxy_config: Option<&OutboundProxyConfig>, +) -> reqwest::Client { + try_build_reqwest_client_with_proxy_config(outbound_proxy_config).unwrap_or_else(|error| { tracing::warn!(error = %error, "failed to build default reqwest client"); with_chatgpt_cloudflare_cookie_store(reqwest::Client::builder()) .build() @@ -219,14 +236,30 @@ pub fn build_reqwest_client() -> reqwest::Client { /// /// Callers that need a structured CA-loading failure instead of the legacy logged fallback can use /// this method directly. -pub fn try_build_reqwest_client() -> Result { +pub fn try_build_reqwest_client() -> Result { + try_build_reqwest_client_with_proxy_config(/*outbound_proxy_config*/ None) +} + +pub fn try_build_reqwest_client_with_proxy_config( + outbound_proxy_config: Option<&OutboundProxyConfig>, +) -> Result { let mut builder = reqwest::Client::builder().default_headers(default_headers()); - if is_sandboxed() { + let sandboxed = is_sandboxed(); + if sandboxed { builder = builder.no_proxy(); } builder = with_chatgpt_cloudflare_cookie_store(builder); - build_reqwest_client_with_custom_ca(builder) + if sandboxed { + return build_reqwest_client_with_custom_ca(builder).map_err(Into::into); + } + + build_reqwest_client_for_route( + builder, + DEFAULT_AUTH_ROUTE_URL, + RouteTarget::Auth, + outbound_proxy_config, + ) } pub fn default_headers() -> HeaderMap { diff --git a/codex-rs/login/src/auth/manager.rs b/codex-rs/login/src/auth/manager.rs index 22e2c9f3b9..1882263749 100644 --- a/codex-rs/login/src/auth/manager.rs +++ b/codex-rs/login/src/auth/manager.rs @@ -26,6 +26,7 @@ use codex_protocol::config_types::ModelProviderAuthInfo; use super::external_bearer::BearerTokenRefresher; use super::revoke::revoke_auth_tokens; +use super::revoke::revoke_auth_tokens_with_proxy_config; pub use crate::auth::agent_identity::AgentIdentityAuth; pub use crate::auth::storage::AgentIdentityAuthRecord; pub use crate::auth::storage::AuthDotJson; @@ -34,11 +35,15 @@ use crate::auth::storage::create_auth_storage; use crate::auth::util::try_parse_error_message; use crate::default_client::build_reqwest_client; use crate::default_client::create_client; +use crate::default_client::create_client_with_proxy_config; +use crate::outbound_proxy::outbound_proxy_config_from_network_config; use crate::token_data::TokenData; use crate::token_data::parse_chatgpt_jwt_claims; use crate::token_data::parse_jwt_expiration; use codex_client::CodexHttpClient; +use codex_client::OutboundProxyConfig; use codex_config::types::AuthCredentialsStoreMode; +use codex_config::types::NetworkConfigToml; use codex_protocol::account::PlanType as AccountPlanType; use codex_protocol::auth::PlanType as InternalPlanType; use codex_protocol::auth::RefreshTokenFailedError; @@ -203,9 +208,10 @@ impl CodexAuth { auth_dot_json: AuthDotJson, auth_credentials_store_mode: AuthCredentialsStoreMode, chatgpt_base_url: Option<&str>, + outbound_proxy_config: Option<&OutboundProxyConfig>, ) -> std::io::Result { let auth_mode = auth_dot_json.resolved_mode(); - let client = create_client(); + let client = create_client_with_proxy_config(outbound_proxy_config); if auth_mode == ApiAuthMode::ApiKey { let Some(api_key) = auth_dot_json.openai_api_key.as_deref() else { return Err(std::io::Error::other("API key auth is missing a key.")); @@ -250,6 +256,7 @@ impl CodexAuth { /*enable_codex_api_key_env*/ false, auth_credentials_store_mode, chatgpt_base_url, + /*outbound_proxy_config*/ None, ) .await } @@ -622,6 +629,7 @@ pub async fn enforce_login_restrictions(config: &AuthConfig) -> std::io::Result< /*enable_codex_api_key_env*/ true, config.auth_credentials_store_mode, config.chatgpt_base_url.as_deref(), + /*outbound_proxy_config*/ None, ) .await? else { @@ -735,6 +743,7 @@ async fn load_auth( enable_codex_api_key_env: bool, auth_credentials_store_mode: AuthCredentialsStoreMode, chatgpt_base_url: Option<&str>, + outbound_proxy_config: Option<&OutboundProxyConfig>, ) -> std::io::Result> { // API key via env var takes precedence over any other auth method. if enable_codex_api_key_env && let Some(api_key) = read_codex_api_key_from_env() { @@ -753,6 +762,7 @@ async fn load_auth( auth_dot_json, AuthCredentialsStoreMode::Ephemeral, chatgpt_base_url, + outbound_proxy_config, ) .await?; return Ok(Some(auth)); @@ -781,6 +791,7 @@ async fn load_auth( auth_dot_json, auth_credentials_store_mode, chatgpt_base_url, + outbound_proxy_config, ) .await?; Ok(Some(auth)) @@ -1261,6 +1272,7 @@ pub struct AuthManager { chatgpt_base_url: Option, refresh_lock: Semaphore, external_auth: RwLock>>, + outbound_proxy_config: Option, } /// Configuration view required to construct a shared [`AuthManager`]. @@ -1281,6 +1293,11 @@ pub trait AuthManagerConfig { /// Returns the ChatGPT backend base URL used for first-party backend authorization. fn chatgpt_base_url(&self) -> String; + + /// Returns host outbound proxy settings for auth-owned HTTP clients. + fn network_config(&self) -> Option { + None + } } impl Debug for AuthManager { @@ -1298,6 +1315,7 @@ impl Debug for AuthManager { &self.forced_chatgpt_workspace_id, ) .field("chatgpt_base_url", &self.chatgpt_base_url) + .field("outbound_proxy_config", &self.outbound_proxy_config) .field("has_external_auth", &self.has_external_auth()) .finish_non_exhaustive() } @@ -1313,12 +1331,30 @@ impl AuthManager { enable_codex_api_key_env: bool, auth_credentials_store_mode: AuthCredentialsStoreMode, chatgpt_base_url: Option, + ) -> Self { + Self::new_with_proxy_config( + codex_home, + enable_codex_api_key_env, + auth_credentials_store_mode, + chatgpt_base_url, + /*outbound_proxy_config*/ None, + ) + .await + } + + pub async fn new_with_proxy_config( + codex_home: PathBuf, + enable_codex_api_key_env: bool, + auth_credentials_store_mode: AuthCredentialsStoreMode, + chatgpt_base_url: Option, + outbound_proxy_config: Option, ) -> Self { let managed_auth = load_auth( &codex_home, enable_codex_api_key_env, auth_credentials_store_mode, chatgpt_base_url.as_deref(), + outbound_proxy_config.as_ref(), ) .await .ok() @@ -1337,6 +1373,7 @@ impl AuthManager { chatgpt_base_url, refresh_lock: Semaphore::new(/*permits*/ 1), external_auth: RwLock::new(None), + outbound_proxy_config, } } @@ -1358,6 +1395,7 @@ impl AuthManager { chatgpt_base_url: None, refresh_lock: Semaphore::new(/*permits*/ 1), external_auth: RwLock::new(None), + outbound_proxy_config: None, }) } @@ -1378,6 +1416,7 @@ impl AuthManager { chatgpt_base_url: None, refresh_lock: Semaphore::new(/*permits*/ 1), external_auth: RwLock::new(None), + outbound_proxy_config: None, }) } @@ -1398,6 +1437,7 @@ impl AuthManager { external_auth: RwLock::new(Some( Arc::new(BearerTokenRefresher::new(config)) as Arc )), + outbound_proxy_config: None, }) } @@ -1536,6 +1576,7 @@ impl AuthManager { self.enable_codex_api_key_env, self.auth_credentials_store_mode, self.chatgpt_base_url.as_deref(), + self.outbound_proxy_config.as_ref(), ) .await .ok() @@ -1626,13 +1667,19 @@ impl AuthManager { config: &impl AuthManagerConfig, enable_codex_api_key_env: bool, ) -> Arc { - let auth_manager = Self::shared( - config.codex_home(), - enable_codex_api_key_env, - config.cli_auth_credentials_store_mode(), - Some(config.chatgpt_base_url()), - ) - .await; + let auth_manager = Arc::new( + Self::new_with_proxy_config( + config.codex_home(), + enable_codex_api_key_env, + config.cli_auth_credentials_store_mode(), + Some(config.chatgpt_base_url()), + config + .network_config() + .as_ref() + .map(outbound_proxy_config_from_network_config), + ) + .await, + ); auth_manager.set_forced_chatgpt_workspace_id(config.forced_chatgpt_workspace_id()); auth_manager } @@ -1779,7 +1826,12 @@ impl AuthManager { let auth_dot_json = self .auth_cached() .and_then(|auth| auth.get_current_auth_json()); - if let Err(err) = revoke_auth_tokens(auth_dot_json.as_ref()).await { + if let Err(err) = revoke_auth_tokens_with_proxy_config( + auth_dot_json.as_ref(), + self.outbound_proxy_config.as_ref(), + ) + .await + { tracing::warn!("failed to revoke auth tokens during logout: {err}"); } let result = logout_all_stores(&self.codex_home, self.auth_credentials_store_mode)?; diff --git a/codex-rs/login/src/auth/mod.rs b/codex-rs/login/src/auth/mod.rs index 167ccd3f75..f31e7421b2 100644 --- a/codex-rs/login/src/auth/mod.rs +++ b/codex-rs/login/src/auth/mod.rs @@ -12,4 +12,5 @@ pub use error::RefreshTokenFailedError; pub use error::RefreshTokenFailedReason; pub use manager::*; pub(crate) use revoke::revoke_auth_tokens; +pub(crate) use revoke::revoke_auth_tokens_with_proxy_config; pub(crate) use revoke::should_revoke_auth_tokens; diff --git a/codex-rs/login/src/auth/revoke.rs b/codex-rs/login/src/auth/revoke.rs index b6a9fef4bb..4ff41c6467 100644 --- a/codex-rs/login/src/auth/revoke.rs +++ b/codex-rs/login/src/auth/revoke.rs @@ -10,6 +10,7 @@ use std::time::Duration; use codex_app_server_protocol::AuthMode as ApiAuthMode; use codex_client::CodexHttpClient; +use codex_client::OutboundProxyConfig; use super::manager::CLIENT_ID; use super::manager::REFRESH_TOKEN_URL_OVERRIDE_ENV_VAR; @@ -17,7 +18,7 @@ use super::manager::REVOKE_TOKEN_URL; use super::manager::REVOKE_TOKEN_URL_OVERRIDE_ENV_VAR; use super::storage::AuthDotJson; use super::util::try_parse_error_message; -use crate::default_client::create_client; +use crate::default_client::create_client_with_proxy_config; use crate::token_data::TokenData; const REVOKE_HTTP_TIMEOUT: Duration = Duration::from_secs(10); @@ -54,12 +55,19 @@ struct RevokeTokenRequest<'a> { pub(crate) async fn revoke_auth_tokens( auth_dot_json: Option<&AuthDotJson>, +) -> Result<(), std::io::Error> { + revoke_auth_tokens_with_proxy_config(auth_dot_json, /*outbound_proxy_config*/ None).await +} + +pub(crate) async fn revoke_auth_tokens_with_proxy_config( + auth_dot_json: Option<&AuthDotJson>, + outbound_proxy_config: Option<&OutboundProxyConfig>, ) -> Result<(), std::io::Error> { let Some((token, kind)) = auth_dot_json.and_then(revocable_token) else { return Ok(()); }; - let client = create_client(); + let client = create_client_with_proxy_config(outbound_proxy_config); let endpoint = revoke_token_endpoint(); revoke_oauth_token(&client, endpoint.as_str(), token, kind, REVOKE_HTTP_TIMEOUT).await } diff --git a/codex-rs/login/src/device_code_auth.rs b/codex-rs/login/src/device_code_auth.rs index 4b9cb7c321..da62e20f30 100644 --- a/codex-rs/login/src/device_code_auth.rs +++ b/codex-rs/login/src/device_code_auth.rs @@ -8,7 +8,8 @@ use std::time::Instant; use crate::pkce::PkceCodes; use crate::server::ServerOptions; -use codex_client::build_reqwest_client_with_custom_ca; +use codex_client::RouteTarget; +use codex_client::build_reqwest_client_for_route; use std::io; const ANSI_BLUE: &str = "\x1b[94m"; @@ -157,9 +158,15 @@ fn print_device_code_prompt(verification_url: &str, code: &str) { } pub async fn request_device_code(opts: &ServerOptions) -> std::io::Result { - let client = build_reqwest_client_with_custom_ca(reqwest::Client::builder())?; let base_url = opts.issuer.trim_end_matches('/'); let api_base_url = format!("{base_url}/api/accounts"); + let user_code_endpoint = format!("{api_base_url}/deviceauth/usercode"); + let client = build_reqwest_client_for_route( + reqwest::Client::builder(), + &user_code_endpoint, + RouteTarget::Auth, + opts.outbound_proxy_config.as_ref(), + )?; let uc = request_user_code(&client, &api_base_url, &opts.client_id).await?; Ok(DeviceCode { @@ -174,9 +181,15 @@ pub async fn complete_device_code_login( opts: ServerOptions, device_code: DeviceCode, ) -> std::io::Result<()> { - let client = build_reqwest_client_with_custom_ca(reqwest::Client::builder())?; let base_url = opts.issuer.trim_end_matches('/'); let api_base_url = format!("{base_url}/api/accounts"); + let token_endpoint = format!("{api_base_url}/deviceauth/token"); + let client = build_reqwest_client_for_route( + reqwest::Client::builder(), + &token_endpoint, + RouteTarget::Auth, + opts.outbound_proxy_config.as_ref(), + )?; let code_resp = poll_for_token( &client, @@ -199,6 +212,7 @@ pub async fn complete_device_code_login( &redirect_uri, &pkce, &code_resp.authorization_code, + opts.outbound_proxy_config.as_ref(), ) .await .map_err(|err| std::io::Error::other(format!("device code exchange failed: {err}")))?; @@ -217,6 +231,7 @@ pub async fn complete_device_code_login( tokens.access_token, tokens.refresh_token, opts.cli_auth_credentials_store_mode, + opts.outbound_proxy_config.as_ref(), ) .await } diff --git a/codex-rs/login/src/lib.rs b/codex-rs/login/src/lib.rs index 990cf8b80e..d89753facf 100644 --- a/codex-rs/login/src/lib.rs +++ b/codex-rs/login/src/lib.rs @@ -3,10 +3,11 @@ pub mod auth_env_telemetry; pub mod token_data; mod device_code_auth; +mod outbound_proxy; mod pkce; mod server; -pub use codex_client::BuildCustomCaTransportError as BuildLoginHttpClientError; +pub use codex_client::BuildProxiedHttpClientError as BuildLoginHttpClientError; pub use codex_config::types::AuthCredentialsStoreMode; pub use device_code_auth::DeviceCode; pub use device_code_auth::complete_device_code_login; diff --git a/codex-rs/login/src/outbound_proxy.rs b/codex-rs/login/src/outbound_proxy.rs new file mode 100644 index 0000000000..edbb92d74b --- /dev/null +++ b/codex-rs/login/src/outbound_proxy.rs @@ -0,0 +1,19 @@ +use codex_client::OutboundProxyConfig; +use codex_client::OutboundProxyMode; +use codex_config::types::NetworkConfigToml; +use codex_config::types::NetworkProxyMode; + +pub(crate) fn outbound_proxy_config_from_network_config( + network: &NetworkConfigToml, +) -> OutboundProxyConfig { + let mode = match network.proxy_mode.unwrap_or_default() { + NetworkProxyMode::Auto => OutboundProxyMode::Auto, + NetworkProxyMode::Env => OutboundProxyMode::Env, + NetworkProxyMode::System => OutboundProxyMode::System, + NetworkProxyMode::Direct => OutboundProxyMode::Direct, + }; + OutboundProxyConfig { + mode, + proxy_url: network.proxy_url.clone(), + } +} diff --git a/codex-rs/login/src/server.rs b/codex-rs/login/src/server.rs index 3961374a46..4cfab3ca12 100644 --- a/codex-rs/login/src/server.rs +++ b/codex-rs/login/src/server.rs @@ -26,10 +26,11 @@ use std::time::Duration; use crate::auth::AuthDotJson; use crate::auth::load_auth_dot_json; -use crate::auth::revoke_auth_tokens; +use crate::auth::revoke_auth_tokens_with_proxy_config; use crate::auth::save_auth; use crate::auth::should_revoke_auth_tokens; use crate::default_client::originator; +use crate::outbound_proxy::outbound_proxy_config_from_network_config; use crate::pkce::PkceCodes; use crate::pkce::generate_pkce; use crate::token_data::TokenData; @@ -37,11 +38,14 @@ use crate::token_data::parse_chatgpt_jwt_claims; use base64::Engine; use chrono::Utc; use codex_app_server_protocol::AuthMode; -use codex_client::build_reqwest_client_with_custom_ca; +use codex_client::OutboundProxyConfig; +use codex_client::RouteTarget; +use codex_client::build_reqwest_client_for_route; use codex_client::emit_auth_http_status; use codex_client::emit_auth_network_environment_snapshot; use codex_client::emit_auth_transport_failure; use codex_config::types::AuthCredentialsStoreMode; +use codex_config::types::NetworkConfigToml; use codex_utils_template::Template; use rand::RngCore; use serde_json::Value as JsonValue; @@ -75,6 +79,7 @@ pub struct ServerOptions { pub forced_chatgpt_workspace_id: Option>, pub codex_streamlined_login: bool, pub cli_auth_credentials_store_mode: AuthCredentialsStoreMode, + pub outbound_proxy_config: Option, } impl ServerOptions { @@ -95,8 +100,13 @@ impl ServerOptions { forced_chatgpt_workspace_id, codex_streamlined_login: false, cli_auth_credentials_store_mode, + outbound_proxy_config: None, } } + + pub fn set_network_config(&mut self, network: Option<&NetworkConfigToml>) { + self.outbound_proxy_config = network.map(outbound_proxy_config_from_network_config); + } } /// Handle for a running login callback server. @@ -338,8 +348,15 @@ async fn process_request( } }; - match exchange_code_for_tokens(&opts.issuer, &opts.client_id, redirect_uri, pkce, &code) - .await + match exchange_code_for_tokens( + &opts.issuer, + &opts.client_id, + redirect_uri, + pkce, + &code, + opts.outbound_proxy_config.as_ref(), + ) + .await { Ok(tokens) => { if let Err(message) = ensure_workspace_allowed( @@ -355,9 +372,14 @@ async fn process_request( ); } // Obtain API key via token-exchange and persist - let api_key = obtain_api_key(&opts.issuer, &opts.client_id, &tokens.id_token) - .await - .ok(); + let api_key = obtain_api_key( + &opts.issuer, + &opts.client_id, + &tokens.id_token, + opts.outbound_proxy_config.as_ref(), + ) + .await + .ok(); if let Err(err) = persist_tokens_async( &opts.codex_home, api_key.clone(), @@ -365,6 +387,7 @@ async fn process_request( tokens.access_token.clone(), tokens.refresh_token.clone(), opts.cli_auth_credentials_store_mode, + opts.outbound_proxy_config.as_ref(), ) .await { @@ -720,6 +743,7 @@ pub(crate) async fn exchange_code_for_tokens( redirect_uri: &str, pkce: &PkceCodes, code: &str, + outbound_proxy_config: Option<&OutboundProxyConfig>, ) -> io::Result { #[derive(serde::Deserialize)] struct TokenResponse { @@ -728,9 +752,14 @@ pub(crate) async fn exchange_code_for_tokens( refresh_token: String, } - emit_auth_network_environment_snapshot(/*operation*/ "oauth_token_exchange"); - let client = build_reqwest_client_with_custom_ca(reqwest::Client::builder())?; let token_endpoint = format!("{}/oauth/token", issuer.trim_end_matches('/')); + emit_auth_network_environment_snapshot(/*operation*/ "oauth_token_exchange"); + let client = build_reqwest_client_for_route( + reqwest::Client::builder(), + &token_endpoint, + RouteTarget::Auth, + outbound_proxy_config, + )?; info!( issuer = %sanitize_url_for_logging(issuer), token_endpoint = %sanitize_url_for_logging(&token_endpoint), @@ -799,6 +828,7 @@ pub(crate) async fn persist_tokens_async( access_token: String, refresh_token: String, auth_credentials_store_mode: AuthCredentialsStoreMode, + outbound_proxy_config: Option<&OutboundProxyConfig>, ) -> io::Result<()> { // Reuse existing synchronous logic but run it off the async runtime. let codex_home = codex_home.to_path_buf(); @@ -836,7 +866,9 @@ pub(crate) async fn persist_tokens_async( .map_err(|e| io::Error::other(format!("persist task failed: {e}")))??; if should_revoke_auth_tokens(previous_auth.as_ref(), &auth) - && let Err(err) = revoke_auth_tokens(previous_auth.as_ref()).await + && let Err(err) = + revoke_auth_tokens_with_proxy_config(previous_auth.as_ref(), outbound_proxy_config) + .await { warn!("failed to revoke superseded auth tokens after login: {err}"); } @@ -1128,15 +1160,21 @@ pub(crate) async fn obtain_api_key( issuer: &str, client_id: &str, id_token: &str, + outbound_proxy_config: Option<&OutboundProxyConfig>, ) -> io::Result { // Token exchange for an API key access token #[derive(serde::Deserialize)] struct ExchangeResp { access_token: String, } - emit_auth_network_environment_snapshot(/*operation*/ "api_key_exchange"); - let client = build_reqwest_client_with_custom_ca(reqwest::Client::builder())?; let token_endpoint = format!("{}/oauth/token", issuer.trim_end_matches('/')); + emit_auth_network_environment_snapshot(/*operation*/ "api_key_exchange"); + let client = build_reqwest_client_for_route( + reqwest::Client::builder(), + &token_endpoint, + RouteTarget::Auth, + outbound_proxy_config, + )?; let resp = client .post(token_endpoint) .header("Content-Type", "application/x-www-form-urlencoded") @@ -1241,6 +1279,7 @@ mod tests { "new-access".to_string(), "new-refresh".to_string(), AuthCredentialsStoreMode::File, + /*outbound_proxy_config*/ None, ) .await?; @@ -1301,6 +1340,7 @@ mod tests { "new-access".to_string(), "shared-refresh".to_string(), AuthCredentialsStoreMode::File, + /*outbound_proxy_config*/ None, ) .await?;