diff --git a/codex-rs/cli/src/debug_sandbox.rs b/codex-rs/cli/src/debug_sandbox.rs index d47cd5ac12..7858a7b746 100644 --- a/codex-rs/cli/src/debug_sandbox.rs +++ b/codex-rs/cli/src/debug_sandbox.rs @@ -307,12 +307,19 @@ async fn run_command_under_sandbox( config.effective_local_windows_sandbox_type() }; - let transparent_tcp = matches!( - sandbox_type, - SandboxType::Landlock { - transparent_tcp: true + let transparent_tcp = match sandbox_type { + SandboxType::Landlock { transparent_tcp } => { + transparent_tcp + || config + .permissions + .network + .as_ref() + .is_some_and(codex_core::config::NetworkProxySpec::transparent_tcp) } - ); + #[cfg(target_os = "macos")] + SandboxType::Seatbelt => false, + SandboxType::Windows => false, + }; let sandbox = match permission_profile.enforcement() { SandboxEnforcement::Disabled | SandboxEnforcement::External if transparent_tcp => { anyhow::bail!("--transparent-tcp requires a managed Linux sandbox"); diff --git a/codex-rs/config/src/config_requirements.rs b/codex-rs/config/src/config_requirements.rs index a5819448bd..ba158c883a 100644 --- a/codex-rs/config/src/config_requirements.rs +++ b/codex-rs/config/src/config_requirements.rs @@ -451,6 +451,8 @@ pub struct NetworkRequirementsToml { pub http_port: Option, pub socks_port: Option, pub allow_upstream_proxy: Option, + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + pub transparent_tcp: Option, pub dangerously_allow_non_loopback_proxy: Option, pub dangerously_allow_all_unix_sockets: Option, pub domains: Option, @@ -532,6 +534,7 @@ struct RawNetworkRequirementsToml { http_port: Option, socks_port: Option, allow_upstream_proxy: Option, + transparent_tcp: Option, dangerously_allow_non_loopback_proxy: Option, dangerously_allow_all_unix_sockets: Option, domains: Option, @@ -561,6 +564,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml { http_port, socks_port, allow_upstream_proxy, + transparent_tcp, dangerously_allow_non_loopback_proxy, dangerously_allow_all_unix_sockets, domains, @@ -591,6 +595,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml { http_port, socks_port, allow_upstream_proxy, + transparent_tcp, dangerously_allow_non_loopback_proxy, dangerously_allow_all_unix_sockets, domains: domains @@ -644,6 +649,8 @@ pub struct NetworkConstraints { pub http_port: Option, pub socks_port: Option, pub allow_upstream_proxy: Option, + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + pub transparent_tcp: Option, pub dangerously_allow_non_loopback_proxy: Option, pub dangerously_allow_all_unix_sockets: Option, pub domains: Option, @@ -673,6 +680,7 @@ impl From for NetworkConstraints { http_port, socks_port, allow_upstream_proxy, + transparent_tcp, dangerously_allow_non_loopback_proxy, dangerously_allow_all_unix_sockets, domains, @@ -687,6 +695,7 @@ impl From for NetworkConstraints { http_port, socks_port, allow_upstream_proxy, + transparent_tcp, dangerously_allow_non_loopback_proxy, dangerously_allow_all_unix_sockets, domains, @@ -5080,6 +5089,7 @@ command = "python3 /enterprise/hooks/pre.py" [permissions.network] enabled = true allow_upstream_proxy = false + transparent_tcp = true dangerously_allow_all_unix_sockets = true managed_allowed_domains_only = true allow_local_binding = false @@ -5114,6 +5124,7 @@ command = "python3 /enterprise/hooks/pre.py" assert_eq!(sourced_network.source, source); assert_eq!(sourced_network.value.enabled, Some(true)); + assert_eq!(sourced_network.value.transparent_tcp, Some(true)); assert_eq!(sourced_network.value.allow_upstream_proxy, Some(false)); assert_eq!( sourced_network.value.dangerously_allow_all_unix_sockets, diff --git a/codex-rs/config/src/permissions_toml.rs b/codex-rs/config/src/permissions_toml.rs index 66843625ef..8ca827f013 100644 --- a/codex-rs/config/src/permissions_toml.rs +++ b/codex-rs/config/src/permissions_toml.rs @@ -331,6 +331,8 @@ pub struct NetworkToml { pub enabled: Option, pub proxy_url: Option, pub enable_socks5: Option, + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + pub transparent_tcp: Option, pub socks_url: Option, pub enable_socks5_udp: Option, pub allow_upstream_proxy: Option, @@ -543,6 +545,9 @@ impl NetworkToml { if let Some(proxy_url) = self.proxy_url.as_ref() { config.proxy_url = proxy_url.clone(); } + if let Some(transparent_tcp) = self.transparent_tcp { + config.transparent_tcp = transparent_tcp; + } if let Some(enable_socks5) = self.enable_socks5 { config.enable_socks5 = enable_socks5; } diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index 879f6a4d4e..ef17655461 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -3709,6 +3709,10 @@ "socks_url": { "type": "string" }, + "transparent_tcp": { + "description": "Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.", + "type": "boolean" + }, "unix_sockets": { "additionalProperties": { "$ref": "#/definitions/NetworkProxyUnixSocketPermissionToml" @@ -3779,6 +3783,10 @@ "socks_url": { "type": "string" }, + "transparent_tcp": { + "description": "Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.", + "type": "boolean" + }, "unix_sockets": { "$ref": "#/definitions/NetworkUnixSocketPermissionsToml" } diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rs index f201d0c5ac..410bc7239b 100644 --- a/codex-rs/core/src/config/config_tests.rs +++ b/codex-rs/core/src/config/config_tests.rs @@ -1668,6 +1668,7 @@ description = "Day-to-day workspace access." enabled = true proxy_url = "http://127.0.0.1:43128" enable_socks5 = false +transparent_tcp = false allow_upstream_proxy = false mode = "full" @@ -1722,6 +1723,7 @@ strip_request_headers = ["authorization"] ]), }), network: Some(NetworkToml { + transparent_tcp: Some(false), enabled: Some(true), proxy_url: Some("http://127.0.0.1:43128".to_string()), enable_socks5: Some(false), diff --git a/codex-rs/core/src/config/network_proxy_spec.rs b/codex-rs/core/src/config/network_proxy_spec.rs index f47a25ea1a..1791bfc97b 100644 --- a/codex-rs/core/src/config/network_proxy_spec.rs +++ b/codex-rs/core/src/config/network_proxy_spec.rs @@ -112,6 +112,10 @@ impl NetworkProxySpec { host_and_port_from_network_addr(&self.config.proxy_url, /*default_port*/ 3128) } + pub fn transparent_tcp(&self) -> bool { + self.config.transparent_tcp + } + pub fn socks_enabled(&self) -> bool { self.config.enable_socks5 } @@ -546,6 +550,9 @@ impl NetworkProxySpec { if let Some(socks_port) = requirements.socks_port { config.socks_url = format!("http://127.0.0.1:{socks_port}"); } + if let Some(transparent_tcp) = requirements.transparent_tcp { + config.transparent_tcp = transparent_tcp; + } if let Some(allow_upstream_proxy) = requirements.allow_upstream_proxy { config.allow_upstream_proxy = allow_upstream_proxy; constraints.allow_upstream_proxy = Some(allow_upstream_proxy); diff --git a/codex-rs/core/src/config/permissions.rs b/codex-rs/core/src/config/permissions.rs index bd6ddb1f09..396e604b58 100644 --- a/codex-rs/core/src/config/permissions.rs +++ b/codex-rs/core/src/config/permissions.rs @@ -163,6 +163,7 @@ pub(crate) fn apply_network_proxy_feature_config( enabled: feature_config.enabled, proxy_url: feature_config.proxy_url.clone(), enable_socks5: feature_config.enable_socks5, + transparent_tcp: feature_config.transparent_tcp, socks_url: feature_config.socks_url.clone(), enable_socks5_udp: feature_config.enable_socks5_udp, allow_upstream_proxy: feature_config.allow_upstream_proxy, diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs index 83cb50006b..6ff243beb0 100644 --- a/codex-rs/core/src/session/mod.rs +++ b/codex-rs/core/src/session/mod.rs @@ -2182,7 +2182,7 @@ impl Session { commit, previous_config, new_config, - permission_profile_changed, + refresh_network_proxy, mcp_inputs_changed, credential_masking_warning, ) = { @@ -2218,10 +2218,11 @@ impl Session { }); let previous_config = notify_config_contributors .then(|| self.build_effective_session_config(&state.session_configuration)); - let previous_permission_profile = state.session_configuration.permission_profile(); - let updated_permission_profile = updated.permission_profile(); - let permission_profile_changed = - previous_permission_profile != updated_permission_profile; + let current = &state.session_configuration; + let refresh_network_proxy = current.permission_profile() + != updated.permission_profile() + || current.original_config_do_not_use.permissions.network + != updated.original_config_do_not_use.permissions.network; let root_service_tier_changed = updated.parent_thread_id.is_none() && state.session_configuration.step_settings.service_tier != updated.step_settings.service_tier; @@ -2281,7 +2282,7 @@ impl Session { commit, previous_config, new_config, - permission_profile_changed, + refresh_network_proxy, mcp_inputs_changed, credential_masking_warning, ) @@ -2294,7 +2295,7 @@ impl Session { ); } self.emit_config_changed_contributors(previous_config.as_ref(), new_config.as_ref()); - if permission_profile_changed { + if refresh_network_proxy { self.refresh_managed_network_proxy_for_current_permission_profile() .await; } diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs index 0afcca25d7..362bfef633 100644 --- a/codex-rs/core/src/session/tests.rs +++ b/codex-rs/core/src/session/tests.rs @@ -1330,6 +1330,46 @@ async fn new_turn_refreshes_managed_network_proxy_for_sandbox_change() -> anyhow Ok(()) } +#[tokio::test] +async fn switching_profiles_updates_live_transparent_tcp() -> anyhow::Result<()> { + let home = tempfile::tempdir()?; + std::fs::write( + home.path().join(codex_config::CONFIG_TOML_FILE), + r#" +default_permissions = "explicit" +features.network_proxy = true +[permissions.explicit] +extends = ":workspace" +network.enabled = true +[permissions.capture] +extends = "explicit" +network.transparent_tcp = true +"#, + )?; + let config = build_test_config(home.path()).await; + let permissions = config.permissions.permission_profile().clone(); + let session = make_session_with_config(|current| *current = config).await?; + let proxy = session + .services + .network_proxy + .load_full() + .expect("live proxy"); + for (profile, capture) in [("capture", true), ("explicit", false)] { + session + .update_settings(SessionSettingsUpdate { + permission_profile: Some(permissions.clone()), + active_permission_profile: Some(ActivePermissionProfile::new(profile)), + ..Default::default() + }) + .await?; + let prepared = proxy + .proxy() + .prepare_for_optional_environment(HashMap::new(), /*environment_id*/ None)?; + assert_eq!(prepared.sandbox_context.transparent_tcp, capture); + } + Ok(()) +} + #[tokio::test] async fn refresh_clears_disabled_managed_network_proxy() -> anyhow::Result<()> { let permission_profile = PermissionProfile::workspace_write(); diff --git a/codex-rs/core/src/unified_exec/process_manager.rs b/codex-rs/core/src/unified_exec/process_manager.rs index 315dbee402..48fbd2c13d 100644 --- a/codex-rs/core/src/unified_exec/process_manager.rs +++ b/codex-rs/core/src/unified_exec/process_manager.rs @@ -230,7 +230,7 @@ fn exec_server_params_for_request( // Threads sharing an executor and sandbox retries can reuse a public handle // while the executor still retains its previous process. let exec_server_process_id = format!("{process_id}-{}", Uuid::new_v4()); - codex_exec_server::ExecParams { + let mut params = codex_exec_server::ExecParams { process_id: exec_server_process_id.into(), metadata: tool_ctx.map(|ctx| codex_exec_server::ExecMetadata { thread_id: Some(ctx.session.thread_id()), @@ -248,7 +248,16 @@ fn exec_server_params_for_request( enforce_managed_network: request.exec_server_enforce_managed_network, managed_network: request.exec_server_managed_network.clone(), network_proxy: request.exec_server_network_proxy.clone(), + }; + let sandboxed = params.sandbox.is_some(); + // A prepared context uses the local sandbox. A remote proxy uses the executor's OS. + if let Some(local) = &mut params.managed_network { + local.transparent_tcp &= sandboxed && cfg!(target_os = "linux"); } + if let Some(remote) = &mut params.network_proxy { + remote.proxy.transparent_tcp &= sandboxed; + } + params } /// Borrowed process state prepared for a `write_stdin` or poll operation. diff --git a/codex-rs/core/src/unified_exec/process_manager_tests.rs b/codex-rs/core/src/unified_exec/process_manager_tests.rs index 602894ff49..b1cec18525 100644 --- a/codex-rs/core/src/unified_exec/process_manager_tests.rs +++ b/codex-rs/core/src/unified_exec/process_manager_tests.rs @@ -4,6 +4,9 @@ use crate::tools::handlers::unified_exec::preparation::ParsedExecCommand; use crate::unified_exec::clamp_yield_time; use codex_exec_server::ExecOutputStream; use codex_network_proxy::ManagedNetworkSandboxContext; +use codex_network_proxy::NetworkProxyConfig; +use codex_network_proxy::RemoteNetworkProxyConfig; +use codex_network_proxy::RemoteNetworkProxyLaunchConfig; use core_test_support::assert_regex_match; use pretty_assertions::assert_eq; use tokio::sync::Notify; @@ -182,6 +185,7 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() { let managed_network = ManagedNetworkSandboxContext { loopback_ports: vec![43123], allow_local_binding: false, + transparent_tcp: true, ..Default::default() }; let mut request = ExecRequest { @@ -261,7 +265,13 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() { assert_eq!(params.metadata, None); assert_eq!(params.cwd, request.cwd); assert!(params.enforce_managed_network); - assert_eq!(params.managed_network, Some(managed_network)); + assert_eq!( + params.managed_network, + Some(ManagedNetworkSandboxContext { + transparent_tcp: false, + ..managed_network + }) + ); assert!(params.env_policy.is_some()); assert_eq!( params.env, @@ -285,8 +295,6 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() { let mut snapshot_env = params.env; snapshot_env.remove("PATH"); assert_eq!(params_for_request(&request).env, snapshot_env); - request.exec_server_shell_snapshot = None; - request.exec_server_sandbox = Some( codex_exec_server::FileSystemSandboxContext::from_permission_profile( permission_profile, @@ -295,6 +303,7 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() { ); let first = params_for_request(&request); let second = params_for_request(&request); + assert_eq!(first.requests_transparent_tcp(), cfg!(target_os = "linux")); assert_eq!( first .sandbox @@ -305,6 +314,22 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() { assert!(first.process_id.as_str().starts_with("123-")); assert!(second.process_id.as_str().starts_with("123-")); assert_ne!(first.process_id, second.process_id); + + request.exec_server_shell_snapshot = None; + request.exec_server_managed_network = None; + request.exec_server_network_proxy = Some(RemoteNetworkProxyLaunchConfig::new( + RemoteNetworkProxyConfig::from_effective_config(&NetworkProxyConfig { + enabled: true, + transparent_tcp: true, + ..Default::default() + }) + .unwrap(), + )); + assert!(params_for_request(&request).requests_transparent_tcp()); + request.exec_server_sandbox = None; + let proxy = params_for_request(&request).network_proxy.unwrap().proxy; + assert!(proxy.enabled); + assert!(!proxy.transparent_tcp); } #[cfg(windows)] diff --git a/codex-rs/exec-server-protocol/src/protocol.rs b/codex-rs/exec-server-protocol/src/protocol.rs index a34dd61dd4..5977f8caa5 100644 --- a/codex-rs/exec-server-protocol/src/protocol.rs +++ b/codex-rs/exec-server-protocol/src/protocol.rs @@ -158,6 +158,9 @@ pub struct EnvironmentCapabilities { /// Whether executor proxies enforce managed review domains before ordinary allows. #[serde(default, skip_serializing_if = "std::ops::Not::not")] pub network_proxy_review_domains: bool, + /// Whether the executor can capture TCP for a managed Linux sandbox launch. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub network_proxy_transparent_tcp: bool, /// Whether the selected shell can mask executor environment credentials. #[serde(default, skip_serializing_if = "std::ops::Not::not")] credential_masking: bool, @@ -323,6 +326,7 @@ impl EnvironmentInfo { capabilities: EnvironmentCapabilities { network_proxy_launch: true, network_proxy_review_domains: true, + network_proxy_transparent_tcp: cfg!(target_os = "linux"), credential_masking, credential_masking_custom_providers: credential_masking, capability_discovery_sandbox: true, @@ -413,6 +417,18 @@ pub struct ExecParams { pub network_proxy: Option, } +impl ExecParams { + pub fn requests_transparent_tcp(&self) -> bool { + self.network_proxy + .as_ref() + .is_some_and(|launch| launch.proxy.transparent_tcp) + || self + .managed_network + .as_ref() + .is_some_and(|ctx| ctx.transparent_tcp) + } +} + /// Executor ingress for process requests from clients that may omit the sandbox policy cwd. #[derive(Deserialize)] #[serde(rename_all = "camelCase")] @@ -1408,6 +1424,7 @@ mod tests { sandbox: None, enforce_managed_network: true, managed_network: Some(ManagedNetworkSandboxContext { + transparent_tcp: false, loopback_ports: vec![43123, 48081], allow_local_binding: false, allow_unix_sockets: vec!["/tmp/allowed.sock".to_string()], @@ -1540,6 +1557,7 @@ mod tests { sandbox: None, enforce_managed_network: true, managed_network: Some(ManagedNetworkSandboxContext { + transparent_tcp: false, loopback_ports: vec![43123], allow_local_binding: true, allow_unix_sockets: Vec::new(), @@ -1590,6 +1608,7 @@ mod tests { EnvironmentCapabilities { network_proxy_launch: true, network_proxy_review_domains: false, + network_proxy_transparent_tcp: false, credential_masking: false, credential_masking_custom_providers: false, capability_discovery_sandbox: true, diff --git a/codex-rs/exec-server/README.md b/codex-rs/exec-server/README.md index 856b94dc27..20f4a2af72 100644 --- a/codex-rs/exec-server/README.md +++ b/codex-rs/exec-server/README.md @@ -539,6 +539,14 @@ upstream proxy is returned as an error, without retrying directly. ### Transparent TCP +In managed `requirements.toml`, set `enabled = true` and `transparent_tcp = true` in the +network policy table you already use (`[permissions.network]`, `[network_proxy]`, or +`[experimental_network]`). Use one table. Managed SOCKS5 must be enabled. + +Capture defaults to off. When requested through configuration, the controller requires a Linux +executor advertising `networkProxyTransparentTcp`. If the sandbox cannot open or configure +`/dev/net/tun`, the launch fails before the command runs. To opt in at executor startup: + ```sh codex exec-server --linux-sandbox-transparent-tcp --tcp-upstream-proxy proxy:8088 ``` diff --git a/codex-rs/exec-server/src/client.rs b/codex-rs/exec-server/src/client.rs index 82c3f7ca83..90494b58e1 100644 --- a/codex-rs/exec-server/src/client.rs +++ b/codex-rs/exec-server/src/client.rs @@ -845,28 +845,31 @@ impl ExecServerClient { } pub async fn exec(&self, params: ExecParams) -> Result { - self.ensure_network_review_capability(¶ms).await?; + self.ensure_network_proxy_capabilities(¶ms).await?; self.call(EXEC_METHOD, ¶ms).await } - async fn ensure_network_review_capability( + async fn ensure_network_proxy_capabilities( &self, params: &ExecParams, ) -> Result<(), ExecServerError> { - if params - .network_proxy - .as_ref() - .is_some_and(|launch| !launch.proxy.review_domains.is_empty()) - && !self - .environment_info() - .await? - .capabilities - .network_proxy_review_domains - { + let proxy = params.network_proxy.as_ref().map(|launch| &launch.proxy); + let needs_review = proxy.is_some_and(|proxy| !proxy.review_domains.is_empty()); + let needs_capture = params.requests_transparent_tcp(); + if !needs_review && !needs_capture { + return Ok(()); + } + let info = self.environment_info().await?; + if needs_review && !info.capabilities.network_proxy_review_domains { return Err(ExecServerError::Protocol( "selected exec-server does not support managed network review domains".to_string(), )); } + if needs_capture && !info.capabilities.network_proxy_transparent_tcp { + return Err(ExecServerError::Protocol( + "selected exec-server does not support transparent TCP".to_string(), + )); + } Ok(()) } @@ -1144,7 +1147,7 @@ impl ExecServerClient { params: ExecParams, network_policy_decider: Option>, ) -> Result { - self.ensure_network_review_capability(¶ms).await?; + self.ensure_network_proxy_capabilities(¶ms).await?; let policy_decision_timeout_ms = params .network_proxy .as_ref() diff --git a/codex-rs/exec-server/src/local_process.rs b/codex-rs/exec-server/src/local_process.rs index 6817a9badb..e1ff7305a1 100644 --- a/codex-rs/exec-server/src/local_process.rs +++ b/codex-rs/exec-server/src/local_process.rs @@ -568,6 +568,18 @@ impl LocalProcess { params: ExecParams, telemetry: ProcessTelemetry, ) -> Result { + // RPC callers must obtain capture from a proxy started by this executor. + // In-process launches can reuse the controller's own managed listener. + if params.requests_transparent_tcp() + && !params + .network_proxy + .as_ref() + .is_some_and(|launch| launch.proxy.transparent_tcp) + { + return Err(invalid_params( + "transparent TCP requires an executor-local managed proxy".into(), + )); + } self.start_process(params, telemetry) .await .map(|(response, _, _)| response) diff --git a/codex-rs/exec-server/src/process_sandbox.rs b/codex-rs/exec-server/src/process_sandbox.rs index 07d7b4ec0b..5f5f30f52b 100644 --- a/codex-rs/exec-server/src/process_sandbox.rs +++ b/codex-rs/exec-server/src/process_sandbox.rs @@ -115,6 +115,12 @@ pub(crate) async fn prepare_exec_request_with_telemetry( credential_brokers: &RemoteCredentialBrokerCache, telemetry: &ProcessTelemetry, ) -> Result { + let transparent_tcp = params.requests_transparent_tcp(); + if transparent_tcp && (!cfg!(target_os = "linux") || params.sandbox.is_none()) { + return Err(invalid_params( + "transparent TCP requires a managed Linux sandbox".into(), + )); + } if let Some(sandbox) = params.sandbox.as_ref() && sandbox.windows_sandbox_selection == WindowsSandboxSelection::Mxc { @@ -187,6 +193,7 @@ pub(crate) async fn prepare_exec_request_with_telemetry( #[cfg(target_os = "macos")] let sandbox_manager = sandbox_manager .with_allowed_symlinked_codex_home(runtime_paths.allowed_symlinked_codex_home.clone()); + let enforce_managed_network = params.enforce_managed_network || transparent_tcp; let (selection, windows_sandbox_level) = sandbox_selection(sandbox_context); let (program, args) = params .argv @@ -240,7 +247,7 @@ pub(crate) async fn prepare_exec_request_with_telemetry( workspace_roots: Some(&sandbox_context.workspace_roots), runtime_readable_paths: &runtime_readable_paths, selection, - enforce_managed_network: params.enforce_managed_network, + enforce_managed_network, environment_id: None, network: None, sandbox_policy_cwd: &sandbox_context.cwd, @@ -270,7 +277,7 @@ pub(crate) async fn prepare_exec_request_with_telemetry( .map(|root| native_path(root, "sandbox workspace root")) .collect::>()?; request.arg0 = params.arg0.clone(); - let proxy_enforced = params.enforce_managed_network; + let proxy_enforced = enforce_managed_network; let filesystem_overrides = WindowsSandboxFilesystemOverrides::resolve( request.sandbox, &permissions, diff --git a/codex-rs/exec-server/src/process_sandbox_tests.rs b/codex-rs/exec-server/src/process_sandbox_tests.rs index c3256c5560..912419c643 100644 --- a/codex-rs/exec-server/src/process_sandbox_tests.rs +++ b/codex-rs/exec-server/src/process_sandbox_tests.rs @@ -6,7 +6,7 @@ use std::time::Duration; use codex_exec_server_protocol::JSONRPCErrorError; #[cfg(unix)] use codex_file_system::WindowsSandboxSelection; -#[cfg(target_os = "macos")] +#[cfg(any(target_os = "macos", target_os = "linux"))] use codex_network_proxy::ManagedNetworkSandboxContext; use codex_network_proxy::NetworkPolicyAuditObserver; use codex_network_proxy::NetworkPolicyDecider; @@ -245,7 +245,7 @@ async fn sandbox_request_routes_custom_arg0_to_inner_helper() { assert_eq!(prepared.arg0, None); } -#[cfg(target_os = "macos")] +#[cfg(any(target_os = "macos", target_os = "linux"))] fn managed_network_sandbox_request() -> (ExecParams, ExecServerRuntimeOptions) { let cwd: AbsolutePathBuf = std::env::current_dir() .expect("current directory") @@ -278,6 +278,70 @@ fn managed_network_sandbox_request() -> (ExecParams, ExecServerRuntimeOptions) { (params, runtime_paths) } +#[cfg(target_os = "linux")] +#[tokio::test] +async fn proxy_config_selects_transparent_tcp_without_executor_switch() { + let (mut params, runtime_paths) = managed_network_sandbox_request(); + params.enforce_managed_network = false; + let prepare = async |params: &ExecParams| { + prepare_exec_request( + params, + HashMap::new(), + Some(&runtime_paths), + /*network_policy_decider*/ None, + /*network_policy_audit_observer*/ None, + ) + .await + }; + for (toml, expected) in [ + ("enabled = true", false), + ("enabled = true\ntransparent_tcp = true", true), + ] { + let network: codex_config::permissions_toml::NetworkToml = toml::from_str(toml).unwrap(); + params.network_proxy = Some(RemoteNetworkProxyLaunchConfig::new( + RemoteNetworkProxyConfig::from_effective_config(&network.to_network_proxy_config()) + .unwrap(), + )); + let prepared = prepare(¶ms).await.unwrap(); + assert_eq!( + prepared + .command + .iter() + .any(|arg| arg == "--transparent-tcp"), + expected, + "{toml}" + ); + prepared + .network_proxy_handle + .unwrap() + .shutdown() + .await + .unwrap(); + } + params.network_proxy = None; + params.managed_network = Some(ManagedNetworkSandboxContext { + transparent_tcp: true, + ..Default::default() + }); + let local = prepare(¶ms).await.unwrap(); + assert!(local.command.iter().any(|arg| arg == "--transparent-tcp")); + let remote = crate::local_process::LocalProcess::default() + .exec(params.clone(), ProcessTelemetry::default()) + .await + .unwrap_err(); + assert!( + remote + .message + .contains("requires an executor-local managed proxy") + ); + params.sandbox = None; + let err = prepare(¶ms) + .await + .err() + .expect("cannot honor capture on a native launch"); + assert!(err.message.contains("requires a managed Linux sandbox")); +} + #[cfg(target_os = "macos")] fn seatbelt_policy_arg(command: &[String]) -> &str { command @@ -299,6 +363,7 @@ async fn sandbox_request_preserves_prepared_managed_network_policy() { .to_string_lossy() .into_owned(); params.managed_network = Some(ManagedNetworkSandboxContext { + transparent_tcp: false, loopback_ports: vec![43123], allow_local_binding: false, allow_unix_sockets: vec![allowed_socket.clone()], diff --git a/codex-rs/exec-server/tests/exec_process.rs b/codex-rs/exec-server/tests/exec_process.rs index f9fd20869c..7bb9b7d9a6 100644 --- a/codex-rs/exec-server/tests/exec_process.rs +++ b/codex-rs/exec-server/tests/exec_process.rs @@ -525,6 +525,11 @@ async fn shell_snapshot_v2_remote_managed_proxy_uses_prepared_execution_context( const REQUEST_GH_TOKEN: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; const VENDOR_TOKEN: &str = "vendor_abcdefgh"; const CUSTOM_HOST: &str = "chatgpt.com"; + // Sanitizing the 256 profile aliases can take longer on emulated executors. + let startup_timeout = match credential_startup { + CredentialStartup::Profile => Duration::from_secs(90), + _ => Duration::from_secs(30), + }; let configured_provider = shell_name == "bash" && shell_args.first() == Some(&"-c"); let shell_path = format!("/bin/{shell_name}"); if shell_name == "zsh" && !std::path::Path::new(&shell_path).exists() { @@ -802,7 +807,7 @@ async fn shell_snapshot_v2_remote_managed_proxy_uses_prepared_execution_context( command }; let started = timeout( - Duration::from_secs(30), + startup_timeout, backend.start(ExecParams { metadata: Default::default(), process_id: ProcessId::from(format!("managed-snapshot-{attempt}")), @@ -836,7 +841,8 @@ async fn shell_snapshot_v2_remote_managed_proxy_uses_prepared_execution_context( ), }), ) - .await??; + .await + .context("timed out starting shell snapshot process")??; let (stdout, stderr, status, closed) = collect_process_output_from_events(started.process).await?; let expected_stderr = if expect_snapshot_fallback { diff --git a/codex-rs/features/src/feature_configs.rs b/codex-rs/features/src/feature_configs.rs index bfa448f03a..0e0eb6313b 100644 --- a/codex-rs/features/src/feature_configs.rs +++ b/codex-rs/features/src/feature_configs.rs @@ -579,6 +579,9 @@ pub struct NetworkProxyConfigToml { pub proxy_url: Option, #[serde(skip_serializing_if = "Option::is_none")] pub enable_socks5: Option, + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + #[serde(skip_serializing_if = "Option::is_none")] + pub transparent_tcp: Option, #[serde(skip_serializing_if = "Option::is_none")] pub socks_url: Option, #[serde(skip_serializing_if = "Option::is_none")] diff --git a/codex-rs/linux-sandbox/README.md b/codex-rs/linux-sandbox/README.md index d750de23b7..0d9204f0e7 100644 --- a/codex-rs/linux-sandbox/README.md +++ b/codex-rs/linux-sandbox/README.md @@ -23,7 +23,7 @@ The Rust sandbox helper includes the TCP stack. Codex starts it automatically. The Linux host needs distro `bwrap` on `PATH`, user and network namespaces, IPv6, and read/write access to `/dev/net/tun`. Use full managed SOCKS5 mode for native database ports and an isolated PID namespace. -For executor-wide capture and HTTP CONNECT routing, see the [exec-server setup](../exec-server/README.md#transparent-tcp). +For proxy configuration, executor-wide capture and HTTP CONNECT routing, see the [exec-server setup](../exec-server/README.md#transparent-tcp). The private DNS stub maps up to 8,192 names to stable addresses in `198.18.0.0/15` and `fdc0:de00::/96`. The relay sends the original name and port to the attributed proxy; diff --git a/codex-rs/linux-sandbox/src/linux_run_main_tests.rs b/codex-rs/linux-sandbox/src/linux_run_main_tests.rs index 0e8e9acf6e..4938bfca11 100644 --- a/codex-rs/linux-sandbox/src/linux_run_main_tests.rs +++ b/codex-rs/linux-sandbox/src/linux_run_main_tests.rs @@ -506,6 +506,7 @@ fn managed_proxy_inner_command_includes_route_spec() { for managed_network in [ ManagedNetworkSandboxContext::default(), ManagedNetworkSandboxContext { + transparent_tcp: false, loopback_ports: vec![8080, 9090], allow_local_binding: true, allow_unix_sockets: vec!["/tmp/daemon.sock".to_string()], diff --git a/codex-rs/network-proxy/src/config.rs b/codex-rs/network-proxy/src/config.rs index 2922fde98b..517e546347 100644 --- a/codex-rs/network-proxy/src/config.rs +++ b/codex-rs/network-proxy/src/config.rs @@ -137,6 +137,9 @@ pub struct NetworkProxyConfig { #[serde(default = "default_proxy_url")] pub proxy_url: String, pub enable_socks5: bool, + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub transparent_tcp: bool, #[serde(default = "default_socks_url")] pub socks_url: String, pub enable_socks5_udp: bool, @@ -188,6 +191,7 @@ impl Default for NetworkProxyConfig { enabled: false, proxy_url: default_proxy_url(), enable_socks5: true, + transparent_tcp: false, socks_url: default_socks_url(), enable_socks5_udp: true, allow_upstream_proxy: true, @@ -750,6 +754,7 @@ mod tests { assert_eq!( NetworkProxyConfig::default(), NetworkProxyConfig { + transparent_tcp: false, enabled: false, proxy_url: "http://127.0.0.1:3128".to_string(), enable_socks5: true, diff --git a/codex-rs/network-proxy/src/environment_policy.rs b/codex-rs/network-proxy/src/environment_policy.rs index aea0e9b966..6ef992db5a 100644 --- a/codex-rs/network-proxy/src/environment_policy.rs +++ b/codex-rs/network-proxy/src/environment_policy.rs @@ -16,6 +16,9 @@ pub struct EnvironmentNetworkPolicy { /// False or omission leaves activation to the controller and command permissions. #[serde(default, skip_serializing_if = "std::ops::Not::not")] pub requires_proxy: bool, + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub transparent_tcp: bool, pub domains: Option, /// Managed host selectors inherited by every execution in this environment. #[serde(default, skip_serializing_if = "Vec::is_empty")] @@ -33,6 +36,7 @@ impl EnvironmentNetworkPolicy { pub fn from_config(config: &NetworkProxyConfig, managed_allowed_domains_only: bool) -> Self { Self { requires_proxy: config.enabled, + transparent_tcp: config.transparent_tcp, domains: config.domains.clone(), review_domains: config.review_domains.clone(), unix_sockets: config.unix_sockets.clone(), @@ -47,6 +51,7 @@ impl EnvironmentNetworkPolicy { /// Applies attachment-owned traffic settings while preserving inherited denials and proxy setup. pub fn apply_to(&self, config: &mut NetworkProxyConfig) { + config.transparent_tcp |= self.transparent_tcp; // Neither owner nor controller may remove the other's review selectors. for pattern in &self.review_domains { if !config diff --git a/codex-rs/network-proxy/src/proxy.rs b/codex-rs/network-proxy/src/proxy.rs index e65815aaa4..0894489f1c 100644 --- a/codex-rs/network-proxy/src/proxy.rs +++ b/codex-rs/network-proxy/src/proxy.rs @@ -442,6 +442,7 @@ fn reserve_loopback_ephemeral_listener() -> Result { #[derive(Debug, Clone, PartialEq, Eq)] struct NetworkProxyRuntimeSettings { + transparent_tcp: bool, allow_local_binding: bool, allow_unix_sockets: Arc<[String]>, dangerously_allow_all_unix_sockets: bool, @@ -463,6 +464,7 @@ impl NetworkProxyRuntimeSettings { None }; Ok(Self { + transparent_tcp: config.transparent_tcp, allow_local_binding: config.allow_local_binding(), allow_unix_sockets: if cfg!(target_os = "windows") { Arc::default() @@ -486,6 +488,9 @@ struct EnvironmentProxyAddrs { #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct ManagedNetworkSandboxContext { + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub transparent_tcp: bool, /// Loopback proxy ports that sandboxed commands may connect to. #[serde(default)] pub loopback_ports: Vec, @@ -1272,6 +1277,7 @@ impl NetworkProxy { env, sandbox_context: ManagedNetworkSandboxContext { loopback_ports, + transparent_tcp: runtime_settings.transparent_tcp, allow_local_binding: runtime_settings.allow_local_binding, allow_unix_sockets: runtime_settings.allow_unix_sockets.to_vec(), dangerously_allow_all_unix_sockets: runtime_settings @@ -2383,6 +2389,7 @@ mod tests { assert_eq!( prepared.sandbox_context, ManagedNetworkSandboxContext { + transparent_tcp: false, loopback_ports: vec![43128, 48081], allow_local_binding: true, allow_unix_sockets: if cfg!(target_os = "windows") { diff --git a/codex-rs/network-proxy/src/remote_config.rs b/codex-rs/network-proxy/src/remote_config.rs index b5f203425c..edc600570a 100644 --- a/codex-rs/network-proxy/src/remote_config.rs +++ b/codex-rs/network-proxy/src/remote_config.rs @@ -179,6 +179,9 @@ pub struct RemoteNetworkProxyConfig { )] credential_masking: CredentialMaskingConfig, pub enable_socks5: bool, + /// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub transparent_tcp: bool, pub enable_socks5_udp: bool, pub allow_upstream_proxy: bool, pub dangerously_allow_all_unix_sockets: bool, @@ -206,6 +209,7 @@ impl RemoteNetworkProxyConfig { enabled: config.enabled, credential_masking: CredentialMaskingConfig::default(), enable_socks5: config.enable_socks5, + transparent_tcp: config.transparent_tcp, enable_socks5_udp: config.enable_socks5_udp, allow_upstream_proxy: config.allow_upstream_proxy, dangerously_allow_all_unix_sockets: config @@ -239,6 +243,7 @@ impl RemoteNetworkProxyConfig { let mut config = NetworkProxyConfig { enabled: self.enabled, enable_socks5: self.enable_socks5, + transparent_tcp: self.transparent_tcp, enable_socks5_udp: self.enable_socks5_udp, allow_upstream_proxy: self.allow_upstream_proxy, dangerously_allow_all_unix_sockets: Some(self.dangerously_allow_all_unix_sockets), diff --git a/codex-rs/network-proxy/src/state.rs b/codex-rs/network-proxy/src/state.rs index fe94a577e3..608aafed93 100644 --- a/codex-rs/network-proxy/src/state.rs +++ b/codex-rs/network-proxy/src/state.rs @@ -78,6 +78,10 @@ pub fn build_config_state( if brokerage_created_default_allowlist { config.set_allowed_domains(vec!["*".to_string()]); } + anyhow::ensure!( + !config.transparent_tcp || (config.enabled && config.enable_socks5), + "transparent_tcp requires an enabled managed SOCKS5 proxy" + ); crate::config::validate_unix_socket_allowlist_paths(&config, executor_os)?; anyhow::ensure!( !config.credential_broker || config.mitm, diff --git a/codex-rs/sandboxing/src/manager.rs b/codex-rs/sandboxing/src/manager.rs index c4b0dd8868..b95a232328 100644 --- a/codex-rs/sandboxing/src/manager.rs +++ b/codex-rs/sandboxing/src/manager.rs @@ -669,7 +669,9 @@ impl SandboxManager { if self.linux_sandbox_pid_namespace == LinuxSandboxPidNamespace::Inherit { args.insert(0, "--inherit-pid-namespace".to_owned()); } - if self.linux_sandbox_transparent_tcp && managed_network.is_some() { + if managed_network + .is_some_and(|ctx| ctx.transparent_tcp || self.linux_sandbox_transparent_tcp) + { args.insert(0, "--transparent-tcp".to_owned()); } exec.command = std::iter::once(program).chain(args).collect(); diff --git a/codex-rs/tui/src/debug_config.rs b/codex-rs/tui/src/debug_config.rs index 353c4b1766..de13958ec8 100644 --- a/codex-rs/tui/src/debug_config.rs +++ b/codex-rs/tui/src/debug_config.rs @@ -551,6 +551,7 @@ fn format_network_constraints(network: &NetworkConstraints) -> String { enabled, http_port, socks_port, + transparent_tcp, allow_upstream_proxy, dangerously_allow_non_loopback_proxy, dangerously_allow_all_unix_sockets, @@ -571,6 +572,9 @@ fn format_network_constraints(network: &NetworkConstraints) -> String { if let Some(socks_port) = socks_port { parts.push(format!("socks_port={socks_port}")); } + if let Some(transparent_tcp) = transparent_tcp { + parts.push(format!("transparent_tcp={transparent_tcp}")); + } if let Some(allow_upstream_proxy) = allow_upstream_proxy { parts.push(format!("allow_upstream_proxy={allow_upstream_proxy}")); } @@ -903,6 +907,7 @@ interrupt_message = false network: Some(Sourced::new( NetworkConstraints { enabled: Some(true), + transparent_tcp: Some(true), domains: Some(NetworkDomainPermissionsToml { entries: BTreeMap::from([( "example.com".to_string(), @@ -1053,7 +1058,7 @@ interrupt_message = false "enforce_residency: us (source: {requirements_source})" ))); assert!(rendered.contains(&format!( - "network_proxy: enabled=true, domains={{example.com=allow}}, review_domains={{api.example.com}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})" + "network_proxy: enabled=true, transparent_tcp=true, domains={{example.com=allow}}, review_domains={{api.example.com}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})" ))); assert!(!rendered.contains("secret-looking-value")); assert!( diff --git a/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap b/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap index 13c454ee93..697426528e 100644 --- a/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap +++ b/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap @@ -24,5 +24,5 @@ Requirements: - guardian_policy_config: configured (source: MDM managed_config.toml (legacy)) - features: guardian_approval=true (source: MDM managed_config.toml (legacy)) - enforce_residency: us (source: MDM managed_config.toml (legacy)) - - network_proxy: enabled=true, domains={example.com=allow}, review_domains={api.example.com}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy)) + - network_proxy: enabled=true, transparent_tcp=true, domains={example.com=allow}, review_domains={api.example.com}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy)) - permissions.filesystem.deny_read: /home/alice/.gitconfig (source: /etc/codex/requirements.toml)