Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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) -> Self
where
D: NetworkPolicyDecider,
@@ -222,6 +240,8 @@ impl NetworkProxyBuilder {
{
let runtime = config::resolve_runtime(&current_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, &current_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.rs
new file mode 100644
index 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(())
+}