Lightweight coding agent that runs in your terminal
Rust
Allow dedicated listeners for managed network proxies (#45463)
iceweasel-oai99b3ab2131a8
diff --git a/codex-rs/network-proxy/src/lib.rs b/codex-rs/network-proxy/src/lib.rsindex 7f9a52bf37..dd8df15aca 100644--- a/codex-rs/network-proxy/src/lib.rs+++ b/codex-rs/network-proxy/src/lib.rs@@ -83,6 +83,7 @@ pub use proxy::Args;pub use proxy::CODEX_PROXY_GIT_SSH_COMMAND_MARKER;pub use proxy::DEFAULT_NO_PROXY_VALUE;pub use proxy::ManagedNetworkSandboxContext;+pub use proxy::ManagedProxyRouting;pub use proxy::NO_PROXY_ENV_KEYS;pub use proxy::NetworkProxy;pub use proxy::NetworkProxyBuilder;diff --git a/codex-rs/network-proxy/src/proxy.rs b/codex-rs/network-proxy/src/proxy.rsindex 8c1f7484ab..c49917a2f2 100644--- a/codex-rs/network-proxy/src/proxy.rs+++ b/codex-rs/network-proxy/src/proxy.rs@@ -1,4 +1,7 @@mod execution_scope;+#[cfg(test)]+#[path = "proxy/managed_routing_tests.rs"]+mod managed_routing_tests;use crate::attribution::PROXY_ATTRIBUTION_TOKEN_ENV_KEY;use crate::config;@@ -56,7 +59,6 @@ struct ReservedListeners {}impl ReservedListeners {- #[cfg(not(target_os = "windows"))]fn new(http: StdTcpListener, socks: Option<StdTcpListener>) -> Self {Self {http: Mutex::new(Some(http)),@@ -110,7 +112,6 @@ impl ReservedListenerSet {})}- #[cfg(not(target_os = "windows"))]fn into_reserved_listeners(self) -> Arc<ReservedListeners> {Arc::new(ReservedListeners::new(self.http_listener,@@ -124,12 +125,23 @@ impl ReservedListenerSet {}}+/// Selects how managed sandbox clients reach their logical proxy instance.+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]+pub enum ManagedProxyRouting {+ /// Use shared SID-attributed ingress when available and dedicated listeners otherwise.+ #[default]+ SharedIngress,+ /// Reserve private loopback TCP ports for sandboxes that enforce endpoint access directly.+ DedicatedListeners,+}+#[derive(Clone)]pub struct NetworkProxyBuilder {state: Option<Arc<NetworkProxyState>>,http_addr: Option<SocketAddr>,socks_addr: Option<SocketAddr>,managed_by_codex: bool,+ managed_proxy_routing: ManagedProxyRouting,policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,blocked_request_observer: Option<Arc<dyn BlockedRequestObserver>>,}@@ -141,6 +153,7 @@ impl Default for NetworkProxyBuilder {http_addr: None,socks_addr: None,managed_by_codex: true,+ managed_proxy_routing: ManagedProxyRouting::default(),policy_decider: None,blocked_request_observer: None,}@@ -168,6 +181,11 @@ impl NetworkProxyBuilder {self}+ pub fn managed_proxy_routing(mut self, managed_proxy_routing: ManagedProxyRouting) -> Self {+ self.managed_proxy_routing = managed_proxy_routing;+ self+ }+pub fn policy_decider<D>(mut self, decider: D) -> SelfwhereD: NetworkPolicyDecider,@@ -222,6 +240,8 @@ impl NetworkProxyBuilder {{let runtime = config::resolve_runtime(¤t_cfg)?;#[cfg(target_os = "windows")]+ let shared_ingress_addrs = if self.managed_proxy_routing+ == ManagedProxyRouting::SharedIngress{let (managed_http_addr, managed_socks_addr) =config::clamp_bind_addrs(runtime.http_addr, runtime.socks_addr, ¤t_cfg);@@ -233,10 +253,15 @@ impl NetworkProxyBuilder {let http_addr = ingress.http_addr();let socks_addr = ingress.socks_addr();windows_ingress = Some(ingress);- (http_addr, socks_addr, None)- }+ Some((http_addr, socks_addr))+ } else {+ None+ };#[cfg(not(target_os = "windows"))]- {+ let shared_ingress_addrs: Option<(SocketAddr, SocketAddr)> = None;+ if let Some((http_addr, socks_addr)) = shared_ingress_addrs {+ (http_addr, socks_addr, None)+ } else {let reserved = reserve_loopback_ephemeral_listeners(current_cfg.enable_socks5).context("reserve managed loopback proxy listeners")?;let http_addr = reserved.http_addr()?;@@ -294,6 +319,7 @@ impl NetworkProxyBuilder {socks5_udp_enabled: current_cfg.enable_socks5_udp,runtime_settings: Arc::new(RwLock::new(runtime_settings)),reserved_listeners,+ managed_proxy_routing: self.managed_proxy_routing,policy_decider: self.policy_decider,environment_proxies: Arc::new(Mutex::new(HashMap::new())),execution_scope: None,@@ -534,6 +560,7 @@ pub struct NetworkProxy {socks5_udp_enabled: bool,runtime_settings: Arc<RwLock<NetworkProxyRuntimeSettings>>,reserved_listeners: Option<Arc<ReservedListeners>>,+ managed_proxy_routing: ManagedProxyRouting,policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,environment_proxies: Arc<Mutex<HashMap<String, EnvironmentProxy>>>,execution_scope: Option<Arc<ExecutionScope>>,@@ -556,6 +583,7 @@ impl PartialEq for NetworkProxy {fn eq(&self, other: &Self) -> bool {self.http_addr == other.http_addr&& self.socks_addr() == other.socks_addr()+ && self.managed_proxy_routing == other.managed_proxy_routing&& self.runtime_settings() == other.runtime_settings()}}diff --git a/codex-rs/network-proxy/src/proxy/managed_routing_tests.rs b/codex-rs/network-proxy/src/proxy/managed_routing_tests.rsnew file mode 100644index 0000000000..c13402a9f6--- /dev/null+++ b/codex-rs/network-proxy/src/proxy/managed_routing_tests.rs@@ -0,0 +1,122 @@+//! Dedicated managed proxy routing regression coverage.+//! Each proxy must use distinct loopback listeners while preserving HTTP and SOCKS policy.++use super::*;+use crate::config::NetworkProxyConfig;+use crate::state::network_proxy_state_for_policy;+use pretty_assertions::assert_eq;+use std::net::Ipv4Addr;+use std::time::Duration;+use tokio::io::AsyncReadExt;+use tokio::io::AsyncWriteExt;+use tokio::net::TcpStream;++#[tokio::test]+async fn dedicated_listeners_preserve_http_and_socks_policy_without_restricted_tokens() -> Result<()>+{+ let origin = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).await?;+ let origin_port = origin.local_addr()?.port();+ let origin_task = tokio::spawn(async move {+ while let Ok((mut stream, _)) = origin.accept().await {+ tokio::spawn(async move {+ let mut request = [0; 1024];+ let _ = stream.read(&mut request).await;+ let _ = stream+ .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")+ .await;+ });+ }+ });+ let mut handles = Vec::new();+ let mut addresses = Vec::new();+ for allowed in [true, false] {+ let mut config = NetworkProxyConfig {+ enabled: true,+ mode: crate::NetworkMode::Full,+ ..NetworkProxyConfig::default()+ };+ config.set_allowed_domains(vec![if allowed {+ "127.0.0.1".to_string()+ } else {+ "unreachable.invalid".to_string()+ }]);+ let proxy = NetworkProxy::builder()+ .state(Arc::new(network_proxy_state_for_policy(config)))+ .managed_proxy_routing(ManagedProxyRouting::DedicatedListeners)+ .build()+ .await?;+ handles.push(proxy.run().await?);+ let proxy = proxy.for_execution(+ "environment",+ "execution",+ "token".to_string(),+ /*environment_policy*/ None,+ /*fallback_policy_decider*/ None,+ )?;+ let prepared =+ proxy.prepare_for_optional_environment(HashMap::new(), /*environment_id*/ None)?;+ let http = prepared.env["HTTP_PROXY"]+ .trim_start_matches("http://")+ .parse::<SocketAddr>()?;+ let socks = prepared.env["ALL_PROXY"]+ .trim_start_matches("socks5h://")+ .parse::<SocketAddr>()?;+ let mut ports = vec![http.port(), socks.port()];+ ports.sort_unstable();+ assert_eq!(+ prepared.sandbox_context,+ ManagedNetworkSandboxContext {+ loopback_ports: ports,+ allow_local_binding: false,+ }+ );+ assert_eq!(+ (http.ip(), socks.ip()),+ (Ipv4Addr::LOCALHOST.into(), Ipv4Addr::LOCALHOST.into())+ );+ for addr in [http, socks] {+ assert!(!addresses.contains(&addr));+ addresses.push(addr);+ }+ #[cfg(target_os = "windows")]+ {+ assert_eq!(+ proxy.network_proxy_restricting_sid(/*environment_id*/ None),+ None+ );+ assert!(+ !prepared+ .env+ .contains_key(WINDOWS_SANDBOX_PROXY_PORTS_ENV_KEY)+ );+ }+ tokio::time::timeout(Duration::from_secs(5), async {+ let mut stream = TcpStream::connect(http).await?;+ stream.write_all(format!(+ "GET http://127.0.0.1:{origin_port}/ HTTP/1.1\r\nHost: 127.0.0.1:{origin_port}\r\nConnection: close\r\n\r\n"+ ).as_bytes()).await?;+ let mut response = Vec::new();+ stream.read_to_end(&mut response).await?;+ let status = if allowed { "200" } else { "403" };+ assert_eq!(String::from_utf8(response)?.split_whitespace().nth(1), Some(status));++ let mut stream = TcpStream::connect(socks).await?;+ stream.write_all(&[5, 1, 0]).await?;+ let mut greeting = [0; 2];+ stream.read_exact(&mut greeting).await?;+ assert_eq!(greeting, [5, 0]);+ let mut connect = vec![5, 1, 0, 1, 127, 0, 0, 1];+ connect.extend_from_slice(&origin_port.to_be_bytes());+ stream.write_all(&connect).await?;+ let mut reply = [0; 4];+ stream.read_exact(&mut reply).await?;+ assert_eq!(reply[1] == 0, allowed);+ Ok::<(), anyhow::Error>(())+ }).await??;+ }+ for handle in handles {+ handle.shutdown().await?;+ }+ origin_task.abort();+ Ok(())+}