From e1b755849216aacd40574b5ccf9ee18d18b1a867 Mon Sep 17 00:00:00 2001 From: viyatb-oai Date: Thu, 19 Nov 2026 00:00:40 +0000 Subject: [PATCH] Prepare managed proxy settings once per sandbox command (#62386) ## Why Proxy settings are bound to the command's execution environment. Preparing them again at launch can overwrite the settings already bound to the command, including credentials prepared for its shell. ## What changed Have `SandboxManager` prepare the proxy environment and sandbox network context together when the caller hasn't supplied a prepared route. Pass the prepared environment through to the child and use the prepared context for sandbox policy, including macOS Seatbelt's proxy ports and Unix socket rules. ## Testing Add regression coverage for preserving shell-specific credentials and environment-bound proxy settings, reporting proxy setup errors for the requested environment, and deriving Seatbelt rules from the prepared route. GitOrigin-RevId: 7a9b5822d8d53f6c93e6318a19222bf06abf0da0 --- codex-rs/Cargo.lock | 1 - codex-rs/core/src/exec.rs | 103 ++++----- codex-rs/core/src/sandboxing/mod.rs | 7 +- codex-rs/core/src/tasks/user_shell.rs | 2 - codex-rs/core/src/tools/runtimes/mod_tests.rs | 95 ++++++++ codex-rs/core/src/unified_exec/mod_tests.rs | 3 - codex-rs/sandboxing/Cargo.toml | 1 - codex-rs/sandboxing/src/linux.rs | 21 -- codex-rs/sandboxing/src/manager.rs | 59 ++--- codex-rs/sandboxing/src/manager_tests.rs | 199 ++++++++++++++++- codex-rs/sandboxing/src/seatbelt.rs | 177 ++------------- .../src/seatbelt_daemon_socket_tests.rs | 2 - .../sandboxing/src/seatbelt_fcntl_tests.rs | 2 - .../sandboxing/src/seatbelt_network_tests.rs | 2 - codex-rs/sandboxing/src/seatbelt_tests.rs | 208 ++++-------------- codex-rs/sandboxing/src/seatbelt_tls_tests.rs | 2 - codex-rs/sandboxing/src/windows_mxc.rs | 4 +- 17 files changed, 428 insertions(+), 460 deletions(-) diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index 32781708d7..cf44be626c 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -4989,7 +4989,6 @@ dependencies = [ "tempfile", "tokio", "tracing", - "url", "which 8.0.0", ] diff --git a/codex-rs/core/src/exec.rs b/codex-rs/core/src/exec.rs index 755363cc83..252d3de41a 100644 --- a/codex-rs/core/src/exec.rs +++ b/codex-rs/core/src/exec.rs @@ -42,6 +42,7 @@ use codex_sandboxing::SandboxExecutables; use codex_sandboxing::SandboxManager; use codex_sandboxing::SandboxNetwork; use codex_sandboxing::SandboxSelection; +use codex_sandboxing::SandboxTransformError; use codex_sandboxing::SandboxTransformRequest; use codex_sandboxing::SandboxType; use codex_sandboxing::SandboxablePreference; @@ -127,16 +128,6 @@ pub enum ExecCapturePolicy { SensitiveFullBuffer, } -fn network_proxy_environment_error( - network_environment_id: Option<&str>, - err: impl std::fmt::Display, -) -> CodexErr { - let environment_id = network_environment_id.unwrap_or("default"); - CodexErr::Io(io::Error::other(format!( - "failed to prepare network proxy for environment `{environment_id}`: {err}" - ))) -} - /// Mechanism to terminate an exec invocation before it finishes naturally. #[derive(Clone, Debug)] pub enum ExecExpiration { @@ -358,16 +349,6 @@ pub async fn build_exec_request( let manager = SandboxManager::new(); let enforce_managed_network = network.is_some(); - let (env, managed_network) = if let Some(network) = network.as_ref() { - let prepared = network - .prepare_for_optional_environment(env, network_environment_id.as_deref()) - .map_err(|err| { - network_proxy_environment_error(network_environment_id.as_deref(), err) - })?; - (prepared.env, Some(prepared.sandbox_context)) - } else { - (env, None) - }; let sandbox_policy_cwd_uri = PathUri::from_abs_path(sandbox_cwd); let workspace_roots = if windows_sandbox_workspace_roots.is_empty() { std::slice::from_ref(&sandbox_policy_cwd_uri) @@ -386,7 +367,7 @@ pub async fn build_exec_request( args: args.to_vec(), cwd, env, - managed_network, + managed_network: None, additional_permissions: None, }; // An already-bound profile only needs its concrete paths validated. Its Windows @@ -396,29 +377,39 @@ pub async fn build_exec_request( } else { &[] }; + let request = SandboxTransformRequest { + command, + permissions: permission_profile, + workspace_roots: Some(policy_roots), + selection: SandboxSelection::Platform { + preference: SandboxablePreference::Auto, + windows_sandbox: windows_sandbox_type, + }, + network: SandboxNetwork::new( + enforce_managed_network, + network.as_ref(), + network_environment_id.as_deref(), + ), + sandbox_policy_cwd: &sandbox_policy_cwd_uri, + executables: SandboxExecutables::Launcher(if cfg!(windows) { + codex_self_exe.as_deref() + } else { + codex_linux_sandbox_exe.as_deref() + }), + use_legacy_landlock, + windows_sandbox_level, + }; + let wrapped = manager.transform(request).map_err(|err| match err { + SandboxTransformError::EnvironmentNetworkProxy(message) => { + let environment_id = network_environment_id.as_deref().unwrap_or("default"); + CodexErr::Io(io::Error::other(format!( + "failed to prepare network proxy for environment `{environment_id}`: {message}" + ))) + } + other => other.into(), + })?; let request = PreparedLocalExecRequest::from_wrapped( - manager.transform(SandboxTransformRequest { - command, - permissions: permission_profile, - workspace_roots: Some(policy_roots), - selection: SandboxSelection::Platform { - preference: SandboxablePreference::Auto, - windows_sandbox: windows_sandbox_type, - }, - network: SandboxNetwork::new( - enforce_managed_network, - network.as_ref(), - network_environment_id.as_deref(), - ), - sandbox_policy_cwd: &sandbox_policy_cwd_uri, - executables: SandboxExecutables::Launcher(if cfg!(windows) { - codex_self_exe.as_deref() - } else { - codex_linux_sandbox_exe.as_deref() - }), - use_legacy_landlock, - windows_sandbox_level, - })?, + wrapped, expiration, capture_policy, workspace_roots, @@ -616,7 +607,7 @@ async fn exec_windows_sandbox( let ExecParams { command, cwd, - mut env, + env, network, network_environment_id, expiration, @@ -624,13 +615,6 @@ async fn exec_windows_sandbox( windows_sandbox_level, .. } = params; - if let Some(network) = network.as_ref() { - network - .apply_to_env_for_optional_environment(&mut env, network_environment_id.as_deref()) - .map_err(|err| { - network_proxy_environment_error(network_environment_id.as_deref(), err) - })?; - } let network_proxy_restricting_sid = network .as_ref() .map(|network| { @@ -922,9 +906,10 @@ async fn exec( let ExecParams { command, cwd, - mut env, - network, - network_environment_id, + env, + // Retain the proxy for the lifetime of the child. + network: _network, + network_environment_id: _, arg0, expiration, capture_policy, @@ -936,13 +921,6 @@ async fn exec( sandbox_permissions: _, justification: _, } = params; - if let Some(network) = network.as_ref() { - network - .apply_to_env_for_optional_environment(&mut env, network_environment_id.as_deref()) - .map_err(|err| { - network_proxy_environment_error(network_environment_id.as_deref(), err) - })?; - } let (program, args) = command.split_first().ok_or_else(|| { CodexErr::Io(io::Error::new( @@ -957,9 +935,6 @@ async fn exec( arg0: arg0_ref, cwd, network_sandbox_policy, - // The environment already has attempt-scoped proxy settings from - // apply_to_env_for_attempt above. Passing network here would reapply - // non-attempt proxy vars and drop attempt correlation metadata. network: None, stdio_policy: StdioPolicy::RedirectForShellTool, env, diff --git a/codex-rs/core/src/sandboxing/mod.rs b/codex-rs/core/src/sandboxing/mod.rs index b7eab99acd..fa05e254c5 100644 --- a/codex-rs/core/src/sandboxing/mod.rs +++ b/codex-rs/core/src/sandboxing/mod.rs @@ -15,7 +15,6 @@ use crate::spawn::CODEX_SANDBOX_ENV_VAR; use crate::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR; use codex_file_system::FileSystemSandboxContext; use codex_network_proxy::ManagedNetworkSandboxContext; -use codex_network_proxy::NetworkProxy; use codex_network_proxy::RemoteNetworkProxyLaunchConfig; use codex_protocol::config_types::WindowsSandboxLevel; use codex_protocol::error::CodexErr; @@ -135,8 +134,6 @@ impl ExecRequest { command: Vec, cwd: AbsolutePathBuf, env: HashMap, - network: Option, - network_environment_id: Option, expiration: ExecExpiration, capture_policy: ExecCapturePolicy, sandbox: SandboxType, @@ -153,8 +150,8 @@ impl ExecRequest { command, cwd, env, - network, - network_environment_id, + network: None, + network_environment_id: None, sandbox, sandbox_policy_cwd: windows_sandbox_policy_cwd, windows_sandbox_level, diff --git a/codex-rs/core/src/tasks/user_shell.rs b/codex-rs/core/src/tasks/user_shell.rs index 1fb516afaa..1bbc864fdb 100644 --- a/codex-rs/core/src/tasks/user_shell.rs +++ b/codex-rs/core/src/tasks/user_shell.rs @@ -214,8 +214,6 @@ pub(crate) async fn execute_user_shell_command( exec_command, cwd.clone(), exec_env_map, - /*network*/ None, - /*network_environment_id*/ None, timeout_ms.unwrap_or(USER_SHELL_TIMEOUT_MS).into(), ExecCapturePolicy::ShellTool, SandboxType::None, diff --git a/codex-rs/core/src/tools/runtimes/mod_tests.rs b/codex-rs/core/src/tools/runtimes/mod_tests.rs index 23a03b7301..c3c0390a9f 100644 --- a/codex-rs/core/src/tools/runtimes/mod_tests.rs +++ b/codex-rs/core/src/tools/runtimes/mod_tests.rs @@ -95,6 +95,101 @@ async fn test_network_proxy_with_config( .await } +async fn prepare_proxy_capture( + cwd: &AbsolutePathBuf, + proxy: &NetworkProxy, + environment_id: Option<&str>, +) -> codex_protocol::error::Result { + crate::exec::build_exec_request( + crate::exec::ExecParams { + command: vec![ + "/bin/sh".into(), + "-c".into(), + r#"printf '%s' "${CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE:-unset}""#.into(), + ], + cwd: cwd.clone(), + env: HashMap::new(), + network: Some(proxy.clone()), + network_environment_id: environment_id.map(str::to_owned), + expiration: ExecExpiration::DefaultTimeout, + capture_policy: ExecCapturePolicy::ShellTool, + sandbox_permissions: SandboxPermissions::UseDefault, + windows_sandbox_level: WindowsSandboxLevel::Disabled, + justification: None, + arg0: None, + }, + &PermissionProfile::read_only(), + cwd, + &[], + &None, + &None, + SandboxType::None, + /*use_legacy_landlock*/ false, + ) + .await +} + +#[tokio::test] +async fn capture_reports_proxy_setup_errors_for_the_requested_environment() -> anyhow::Result<()> { + let dir = tempdir()?; + let cwd = AbsolutePathBuf::from_absolute_path(dir.path())?; + let proxy = test_network_proxy().await?.for_execution( + "owner", + "capture", + "test-token".into(), + /*environment_policy*/ None, + /*fallback_policy_decider*/ None, + )?; + let error = prepare_proxy_capture(&cwd, &proxy, Some("other")) + .await + .expect_err("a proxy scoped to owner must reject other"); + assert!(matches!( + error.details(), + codex_protocol::error::CodexErrorDetails::Io(_) + )); + assert_eq!( + error.to_string(), + "failed to prepare network proxy for environment `other`: execution-scoped network proxy belongs to environment `owner`, not `other`" + ); + Ok(()) +} + +#[cfg(target_os = "macos")] +#[tokio::test] +async fn capture_preserves_the_proxy_environment_bound_by_build_exec_request() -> anyhow::Result<()> +{ + let dir = tempdir()?; + let cwd = AbsolutePathBuf::from_absolute_path(dir.path())?; + let proxy = test_network_proxy_with_config(NetworkProxyConfig { + enabled: true, + ..Default::default() + }) + .await?; + let before_reload = prepare_proxy_capture(&cwd, &proxy, /*environment_id*/ None).await?; + let mut config = proxy.current_cfg().await?; + config.set_credential_broker_enabled(/*enabled*/ true); + proxy + .replace_config_state(codex_network_proxy::build_config_state( + config, + Default::default(), + codex_utils_path_uri::Platform::native(), + )?) + .await?; + let after_reload = prepare_proxy_capture(&cwd, &proxy, /*environment_id*/ None).await?; + for (request, expected) in [(before_reload, "unset"), (after_reload, "1")] { + let output = crate::sandboxing::execute_env( + request.into_exec_request(), + /*stdout_stream*/ None, + ) + .await?; + assert_eq!( + (output.exit_code, output.stdout.text.as_str()), + (0, expected) + ); + } + Ok(()) +} + #[tokio::test] async fn explicit_escalation_prepares_exec_without_managed_network() -> anyhow::Result<()> { let proxy = test_network_proxy().await?; diff --git a/codex-rs/core/src/unified_exec/mod_tests.rs b/codex-rs/core/src/unified_exec/mod_tests.rs index 9d6e4dca02..b108b1d8fc 100644 --- a/codex-rs/core/src/unified_exec/mod_tests.rs +++ b/codex-rs/core/src/unified_exec/mod_tests.rs @@ -70,14 +70,11 @@ fn test_exec_request( env: HashMap, ) -> ExecRequest { let permission_profile = turn.permission_profile(); - let network = None; let arg0 = None; ExecRequest::new( command, cwd, env, - network, - /*network_environment_id*/ None, ExecExpiration::DefaultTimeout, ExecCapturePolicy::ShellTool, SandboxType::None, diff --git a/codex-rs/sandboxing/Cargo.toml b/codex-rs/sandboxing/Cargo.toml index 64ebac488a..d18f3533a4 100644 --- a/codex-rs/sandboxing/Cargo.toml +++ b/codex-rs/sandboxing/Cargo.toml @@ -28,7 +28,6 @@ serde_json = { workspace = true } regex-lite = { workspace = true } tokio = { workspace = true, features = ["rt", "sync"] } tracing = { workspace = true, features = ["log"] } -url = { workspace = true } which = { workspace = true } [target.'cfg(windows)'.dependencies] diff --git a/codex-rs/sandboxing/src/linux.rs b/codex-rs/sandboxing/src/linux.rs index 924bd198c8..409074439d 100644 --- a/codex-rs/sandboxing/src/linux.rs +++ b/codex-rs/sandboxing/src/linux.rs @@ -56,7 +56,6 @@ pub(super) struct Linux<'a> { pub(super) transparent_tcp: bool, pub(super) sandbox_exe: Option<&'a Path>, pub(super) use_legacy_landlock: bool, - pub(super) enforce_managed_network: bool, pub(super) route: Option, } @@ -70,26 +69,6 @@ impl SandboxBackend for Linux<'_> { let exe = self .sandbox_exe .ok_or(SandboxTransformError::MissingLinuxSandboxExecutable)?; - self.route = match ( - self.enforce_managed_network, - self.route.take(), - &exec.network, - ) { - (false, _, _) => None, - (true, None, Some(proxy)) => { - let prepared = proxy - .prepare_for_optional_environment( - std::mem::take(&mut exec.env), - exec.network_environment_id.as_deref(), - ) - .map_err(|err| { - SandboxTransformError::EnvironmentNetworkProxy(err.to_string()) - })?; - exec.env = prepared.env; - Some(prepared.sandbox_context) - } - (true, context, _) => Some(context.unwrap_or_default()), - }; let mode = LinuxSandboxMode::resolve(self.use_legacy_landlock, self.route.as_ref()); #[cfg(target_os = "linux")] if crate::bwrap::is_wsl1() { diff --git a/codex-rs/sandboxing/src/manager.rs b/codex-rs/sandboxing/src/manager.rs index 0df6171fdb..37235ec2ca 100644 --- a/codex-rs/sandboxing/src/manager.rs +++ b/codex-rs/sandboxing/src/manager.rs @@ -464,7 +464,7 @@ impl SandboxManager { } } } - let command = request.command; + let mut command = request.command; let SandboxNetwork { enforce_managed_network, proxy: network, @@ -540,13 +540,25 @@ impl SandboxManager { .filter(|path| path.to_str().is_none()) .map(OsStr::to_owned); let inner_arg_count = 1 + command.args.len(); + let managed_network = match (command.managed_network, network) { + // A caller-prepared route already includes shell-specific credential handling. + (None, Some(proxy)) => { + let prepared = proxy + .prepare_for_optional_environment(command.env, environment_id) + .map_err(|err| { + SandboxTransformError::EnvironmentNetworkProxy(err.to_string()) + })?; + command.env = prepared.env; + Some(prepared.sandbox_context) + } + (route, _) => route, + }; let wrapped = |request, windows_session| WrappedSandboxCommand { request, windows_session, inner_arg_count, }; - let managed_network = command - .managed_network + let managed_network = managed_network .filter(|_| enforce_managed_network || backend == SandboxType::MacosSeatbelt); let mut argv = Vec::with_capacity(1 + command.args.len()); argv.push(command.program.to_string_lossy().into_owned()); @@ -570,9 +582,12 @@ impl SandboxManager { } let managed_mitm_ca_trust_bundle_path = match request.executables { SandboxExecutables::Executor { .. } => None, - SandboxExecutables::Launcher(_) => { - network.and_then(NetworkProxy::managed_mitm_ca_trust_bundle_path) - } + SandboxExecutables::Launcher(_) => network + .and_then(NetworkProxy::managed_mitm_ca_trust_bundle_path) + .filter(|path| { + path.to_str() + .is_some_and(codex_network_proxy::is_managed_mitm_ca_trust_bundle_path) + }), }; #[cfg(windows)] let mut session = None; @@ -585,15 +600,14 @@ impl SandboxManager { transparent_tcp: self.linux_sandbox_transparent_tcp, sandbox_exe, use_legacy_landlock: request.use_legacy_landlock, - enforce_managed_network, - route: managed_network, + route: enforce_managed_network.then(|| managed_network.unwrap_or_default()), }, #[cfg(target_os = "macos")] SandboxType::MacosSeatbelt => &mut crate::seatbelt::Seatbelt { operation: &self.operation, allowed_symlinked_codex_home: self.allowed_symlinked_codex_home.as_ref(), enforce_managed_network, - route: managed_network, + route: managed_network.as_ref(), }, #[cfg(not(target_os = "macos"))] SandboxType::MacosSeatbelt => return Err(SandboxTransformError::SeatbeltUnavailable), @@ -603,24 +617,15 @@ impl SandboxManager { "native MXC is unavailable on this executor".into(), )); } - let route = match managed_network { - None if enforce_managed_network => { - let proxy = network.ok_or_else(|| { - SandboxTransformError::WindowsMxcPreparation( - "managed networking requires an executor-local proxy".to_string(), - ) - })?; - let prepared = proxy - .prepare_for_optional_environment(exec.env, environment_id) - .map_err(|err| { - SandboxTransformError::EnvironmentNetworkProxy(err.to_string()) - })?; - exec.env = prepared.env; - Some(prepared.sandbox_context) - } - route => route, - }; - &mut crate::windows_mxc::Mxc { sandbox_exe, route } + if enforce_managed_network && managed_network.is_none() { + return Err(SandboxTransformError::WindowsMxcPreparation( + "managed networking requires an executor-local proxy".into(), + )); + } + &mut crate::windows_mxc::Mxc { + sandbox_exe, + route: managed_network.as_ref(), + } } #[cfg(not(windows))] SandboxType::WindowsRestrictedToken => { diff --git a/codex-rs/sandboxing/src/manager_tests.rs b/codex-rs/sandboxing/src/manager_tests.rs index 29d0fb6618..1d3675cacd 100644 --- a/codex-rs/sandboxing/src/manager_tests.rs +++ b/codex-rs/sandboxing/src/manager_tests.rs @@ -538,6 +538,121 @@ async fn inherited_terminal_preserves_native_linux_helper_and_uses_its_dispatch_ Ok(()) } +#[tokio::test] +async fn native_launch_preserves_borrowed_proxy_credentials() -> anyhow::Result<()> { + use codex_network_proxy::CREDENTIAL_BROKER_ACTIVE_ENV_KEY; + use codex_network_proxy::ManagedProxyRouting; + use codex_network_proxy::NetworkProxy; + use codex_network_proxy::NetworkProxyConfig; + use codex_network_proxy::NetworkProxyState; + use codex_network_proxy::RemoteNetworkProxyConfig; + use codex_network_proxy::RemoteNetworkProxyLaunchConfig; + use codex_utils_path_uri::Platform; + + let config = RemoteNetworkProxyConfig::from_effective_config(&NetworkProxyConfig { + enabled: true, + enable_socks5: false, + ..Default::default() + })?; + let state = NetworkProxyState::from_remote_launch_config( + RemoteNetworkProxyLaunchConfig::new(config), + Platform::native(), + &Default::default(), + &HashMap::new(), + )?; + let proxy = NetworkProxy::builder() + .state(state.into()) + .managed_proxy_routing(ManagedProxyRouting::SharedIngress) + .build() + .await?; + let handle = proxy.run().await?; + let dir = tempfile::tempdir()?; + let access_key = dir.path().join("access-key"); + let secret_key = dir.path().join("secret-key"); + std::fs::write(&access_key, "aws-test-access-key")?; + std::fs::write(&secret_key, "aws-test-secret-key")?; + let mut config = proxy.current_cfg().await?; + config.set_credential_broker_enabled(/*enabled*/ true); + config.mitm_hooks = serde_json::from_value(serde_json::json!([{ + "host": "s3.amazonaws.com", + "match": {"schemes": ["https"], "ports": [443], "methods": ["GET"], "path_prefixes": ["/"]}, + "actions": {"aws_sigv4": { + "placeholder_access_key_id": "A", "region": "us-east-1", "service": "s3", + "access_key_id": {"file": access_key}, "secret_access_key": {"file": secret_key} + }} + }]))?; + proxy + .replace_config_state(codex_network_proxy::build_config_state( + config, + Default::default(), + Platform::native(), + )?) + .await?; + let cwd = PathUri::from_abs_path(&AbsolutePathBuf::current_dir()?); + let environment_id = Some("native"); + let token = format!("ghp_{}", "x".repeat(36)); + let raw = HashMap::from([ + ("GH_HOST".into(), "github.enterprise.example".into()), + ("GH_ENTERPRISE_TOKEN".into(), token.clone()), + (CREDENTIAL_BROKER_ACTIVE_ENV_KEY.into(), "1".into()), + ( + "CODEX_NETWORK_PROXY_BROKERED_CREDENTIALS".into(), + "[]".into(), + ), + ]); + let prepared = proxy.prepare_for_optional_environment(raw.clone(), environment_id)?; + assert_ne!(prepared.env["GH_ENTERPRISE_TOKEN"], token); + assert_eq!(prepared.env["AWS_ACCESS_KEY_ID"], "A"); + + let mut stale = prepared.env.clone(); + stale.insert("GH_HOST".into(), "https://bad.example/path".into()); + stale.insert( + "CODEX_NETWORK_PROXY_BROKERED_CREDENTIALS".into(), + "[]".into(), + ); + let mut powershell = prepared.env.clone(); + proxy.restore_and_disable_brokered_credentials(&mut powershell, &mut []); + assert!(!powershell.contains_key(CREDENTIAL_BROKER_ACTIVE_ENV_KEY)); + assert_eq!(powershell["GH_ENTERPRISE_TOKEN"], token); + assert_eq!(powershell["AWS_ACCESS_KEY_ID"], "A"); + + let context = Some(prepared.sandbox_context); + for (env, context, expected) in [ + (&raw, None, &prepared.env), + (&stale, context.clone(), &stale), + (&powershell, context, &powershell), + ] { + let request = SandboxManager::new() + .transform(SandboxTransformRequest { + command: SandboxCommand { + program: "echo".into(), + args: vec![], + cwd: cwd.clone(), + env: env.clone(), + managed_network: context, + additional_permissions: None, + }, + permissions: &PermissionProfile::Disabled, + workspace_roots: None, + selection: SandboxSelection::Explicit(SandboxType::None), + network: SandboxNetwork::new( + /*enforce_managed_network*/ false, + Some(&proxy), + environment_id, + ), + sandbox_policy_cwd: &cwd, + executables: SandboxExecutables::Launcher(None), + use_legacy_landlock: false, + windows_sandbox_level: WindowsSandboxLevel::Disabled, + })? + .into_command_request()?; + assert!(request.network.is_some()); + assert_eq!(request.network_environment_id.as_deref(), environment_id); + assert_eq!(&request.env, expected); + } + handle.shutdown().await +} + #[cfg(unix)] #[tokio::test] async fn linux_helper_uses_effective_managed_policy() -> anyhow::Result<()> { @@ -548,11 +663,10 @@ async fn linux_helper_uses_effective_managed_policy() -> anyhow::Result<()> { } #[cfg(unix)] -async fn check_linux_managed_policy(transparent_tcp: bool) -> anyhow::Result<()> { +async fn proxy_allowing_all_unix_sockets() -> anyhow::Result { use codex_network_proxy::ConfigReloader; use codex_network_proxy::ConfigReloaderFuture; use codex_network_proxy::ConfigState; - use codex_network_proxy::ManagedNetworkSandboxContext; use codex_network_proxy::NetworkProxy; use codex_network_proxy::NetworkProxyConfig; use codex_network_proxy::NetworkProxyConstraints; @@ -584,14 +698,91 @@ async fn check_linux_managed_policy(transparent_tcp: bool) -> anyhow::Result<()> NetworkProxyConstraints::default(), codex_utils_path_uri::Platform::native(), )?; - let network = NetworkProxy::builder() + NetworkProxy::builder() .state(Arc::new(NetworkProxyState::with_reloader( state, Arc::new(TestConfigReloader), ))) .managed_by_codex(/*managed_by_codex*/ false) .build() - .await?; + .await +} + +#[cfg(target_os = "macos")] +#[tokio::test] +async fn seatbelt_uses_prepared_route_over_live_proxy() -> anyhow::Result<()> { + use codex_network_proxy::ManagedNetworkSandboxContext; + use std::net::TcpListener; + use std::os::unix::net::UnixListener; + + let proxy = proxy_allowing_all_unix_sockets().await?; + let dir = tempfile::tempdir_in("/tmp")?; + let cwd = AbsolutePathBuf::from_absolute_path(canonicalize(dir.path())?)?; + let allowed = cwd.join("allowed.sock"); + let unrelated = cwd.join("unrelated.sock"); + let _allowed_listener = UnixListener::bind(&allowed)?; + let _unrelated_listener = UnixListener::bind(&unrelated)?; + let listener = TcpListener::bind(("127.0.0.1", 0))?; + let port = listener.local_addr()?.port(); + let route = ManagedNetworkSandboxContext { + loopback_ports: vec![port], + allow_unix_sockets: vec![allowed.to_string_lossy().into_owned()], + ..Default::default() + }; + let probe = r#" +import socket, sys +try: + socket.socket(socket.AF_UNIX).connect(sys.argv[1]) +except PermissionError: + pass +else: + raise AssertionError("unrelated Unix socket was reachable") +socket.socket(socket.AF_UNIX).connect(sys.argv[2]) +socket.create_connection(("127.0.0.1", int(sys.argv[3]))).close() +"#; + let cwd = PathUri::from_abs_path(&cwd); + let launch = SandboxManager::new().transform(SandboxTransformRequest { + command: SandboxCommand { + program: "/usr/bin/python3".into(), + args: vec![ + "-c".into(), + probe.into(), + unrelated.to_string_lossy().into_owned(), + allowed.to_string_lossy().into_owned(), + port.to_string(), + ], + cwd: cwd.clone(), + env: HashMap::new(), + managed_network: Some(route), + additional_permissions: None, + }, + permissions: &PermissionProfile::read_only(), + workspace_roots: Some(&[]), + selection: SandboxSelection::Explicit(SandboxType::MacosSeatbelt), + network: SandboxNetwork::new( + /*enforce_managed_network*/ true, + Some(&proxy), + /*environment_id*/ None, + ), + sandbox_policy_cwd: &cwd, + executables: SandboxExecutables::Launcher(None), + use_legacy_landlock: false, + windows_sandbox_level: WindowsSandboxLevel::Disabled, + })?; + let output = launch.into_direct_command()?.output()?; + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + Ok(()) +} + +#[cfg(unix)] +async fn check_linux_managed_policy(transparent_tcp: bool) -> anyhow::Result<()> { + use codex_network_proxy::ManagedNetworkSandboxContext; + + let network = proxy_allowing_all_unix_sockets().await?; let prepared = network.prepare_for_optional_environment(HashMap::new(), /*environment_id*/ None)?; let allow_all = prepared.sandbox_context; diff --git a/codex-rs/sandboxing/src/seatbelt.rs b/codex-rs/sandboxing/src/seatbelt.rs index 47f6bf2a39..51553d1092 100644 --- a/codex-rs/sandboxing/src/seatbelt.rs +++ b/codex-rs/sandboxing/src/seatbelt.rs @@ -3,28 +3,22 @@ use crate::SandboxTransformError; use crate::manager::SandboxBackend; use crate::manager::launch::SandboxOperation; use codex_network_proxy::ManagedNetworkSandboxContext; -use codex_network_proxy::NetworkProxy; -use codex_network_proxy::PROXY_URL_ENV_KEYS; -use codex_network_proxy::has_proxy_url_env_vars; -use codex_network_proxy::proxy_url_env_value; use codex_protocol::permissions::FileSystemPolicyProjection; use codex_protocol::permissions::FileSystemSandboxPolicy; use codex_protocol::permissions::NetworkSandboxPolicy; use codex_utils_absolute_path::AbsolutePathBuf; use std::collections::BTreeMap; use std::collections::BTreeSet; -use std::collections::HashMap; use std::collections::VecDeque; use std::path::Path; use std::path::PathBuf; use tracing::warn; -use url::Url; pub(super) struct Seatbelt<'a> { pub(super) operation: &'a SandboxOperation, pub(super) allowed_symlinked_codex_home: Option<&'a AbsolutePathBuf>, pub(super) enforce_managed_network: bool, - pub(super) route: Option, + pub(super) route: Option<&'a ManagedNetworkSandboxContext>, } impl SandboxBackend for Seatbelt<'_> { @@ -36,21 +30,6 @@ impl SandboxBackend for Seatbelt<'_> { ) -> Result<(), SandboxTransformError> { let (file_system_sandbox_policy, network_sandbox_policy) = exec.permission_profile.to_runtime_permissions(); - let managed_network = match (self.route.take(), &exec.network) { - (None, Some(proxy)) => { - let prepared = proxy - .prepare_for_optional_environment( - std::mem::take(&mut exec.env), - exec.network_environment_id.as_deref(), - ) - .map_err(|err| { - SandboxTransformError::EnvironmentNetworkProxy(err.to_string()) - })?; - exec.env = prepared.env; - Some(prepared.sandbox_context) - } - (context, _) => context, - }; let (profile, sockets) = match self.operation { SandboxOperation::Command => (MacosSeatbeltProfile::Process, [].as_slice()), SandboxOperation::InheritedTerminal { allow_unix_sockets } => ( @@ -68,21 +47,14 @@ impl SandboxBackend for Seatbelt<'_> { network_sandbox_policy, sandbox_policy_cwd: policy_cwd, enforce_managed_network: self.enforce_managed_network, - managed_network: managed_network.as_ref(), - environment_id: exec.network_environment_id.as_deref(), - network: exec.network.as_ref(), + managed_network: self.route, extra_allow_unix_sockets: sockets, }, profile, self.allowed_symlinked_codex_home, ) - .map_err(|err| match err { - SeatbeltPreparationError::FileSystem(message) => { - SandboxTransformError::SeatbeltPreparation(message) - } - SeatbeltPreparationError::EnvironmentNetworkProxy(message) => { - SandboxTransformError::EnvironmentNetworkProxy(message) - } + .map_err(|SeatbeltPreparationError::FileSystem(message)| { + SandboxTransformError::SeatbeltPreparation(message) })?; exec.command = std::iter::once(MACOS_PATH_TO_SEATBELT_EXECUTABLE.to_owned()) .chain(args) @@ -116,15 +88,12 @@ pub(crate) enum MacosSeatbeltProfile { #[derive(Debug)] pub(crate) enum SeatbeltPreparationError { FileSystem(String), - EnvironmentNetworkProxy(String), } impl std::fmt::Display for SeatbeltPreparationError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - Self::FileSystem(message) | Self::EnvironmentNetworkProxy(message) => { - f.write_str(message) - } + Self::FileSystem(message) => f.write_str(message), } } } @@ -135,53 +104,6 @@ impl std::fmt::Display for SeatbeltPreparationError { /// already has root access. pub const MACOS_PATH_TO_SEATBELT_EXECUTABLE: &str = "/usr/bin/sandbox-exec"; -fn is_loopback_host(host: &str) -> bool { - host.eq_ignore_ascii_case("localhost") || host == "127.0.0.1" || host == "::1" -} - -fn proxy_scheme_default_port(scheme: &str) -> u16 { - match scheme { - "https" => 443, - "socks5" | "socks5h" | "socks4" | "socks4a" => 1080, - _ => 80, - } -} - -fn proxy_loopback_ports_from_env(env: &HashMap) -> Vec { - let mut ports = BTreeSet::new(); - for key in PROXY_URL_ENV_KEYS { - let Some(proxy_url) = proxy_url_env_value(env, key) else { - continue; - }; - let trimmed = proxy_url.trim(); - if trimmed.is_empty() { - continue; - } - - let candidate = if trimmed.contains("://") { - trimmed.to_string() - } else { - format!("http://{trimmed}") - }; - let Ok(parsed) = Url::parse(&candidate) else { - continue; - }; - let Some(host) = parsed.host_str() else { - continue; - }; - if !is_loopback_host(host) { - continue; - } - - let scheme = parsed.scheme().to_ascii_lowercase(); - let port = parsed - .port() - .unwrap_or_else(|| proxy_scheme_default_port(scheme.as_str())); - ports.insert(port); - } - ports.into_iter().collect() -} - #[derive(Debug, Default)] struct ProxyPolicyInputs { ports: Vec, @@ -232,59 +154,30 @@ struct UnixSocketPathParam { fn proxy_policy_inputs( managed_network: Option<&ManagedNetworkSandboxContext>, - network: Option<&NetworkProxy>, - environment_id: Option<&str>, extra_allow_unix_sockets: &[AbsolutePathBuf], -) -> Result { +) -> ProxyPolicyInputs { let extra_allowed = extra_allow_unix_sockets .iter() .filter_map(|socket_path| normalize_path_for_sandbox(socket_path.as_path())) .collect::>(); - - // Prefer this command's prepared Unix-socket policy. - // Fall back to the live proxy only when no prepared context exists. - let unix_domain_socket_policy = match (managed_network, network) { - (Some(context), _) if context.dangerously_allow_all_unix_sockets => { - UnixDomainSocketPolicy::AllowAll - } - (Some(context), _) => { - UnixDomainSocketPolicy::from_allowlist(&context.allow_unix_sockets, extra_allowed) - } - (None, Some(network)) if network.dangerously_allow_all_unix_sockets() => { - UnixDomainSocketPolicy::AllowAll - } - (None, Some(network)) => { - UnixDomainSocketPolicy::from_allowlist(&network.allow_unix_sockets(), extra_allowed) - } - (None, None) => UnixDomainSocketPolicy::Restricted { - allowed: extra_allowed, - }, - }; - if let Some(managed_network) = managed_network { - return Ok(ProxyPolicyInputs { - ports: managed_network.loopback_ports.clone(), - has_proxy_config: true, - allow_local_binding: managed_network.allow_local_binding, - unix_domain_socket_policy, - }); - } - match network { - Some(network) => { - let mut env = HashMap::new(); - network - .apply_to_env_for_optional_environment(&mut env, environment_id) - .map_err(|err| err.to_string())?; - Ok(ProxyPolicyInputs { - ports: proxy_loopback_ports_from_env(&env), - has_proxy_config: has_proxy_url_env_vars(&env), - allow_local_binding: network.allow_local_binding(), - unix_domain_socket_policy, - }) - } - None => Ok(ProxyPolicyInputs { - unix_domain_socket_policy, + let Some(context) = managed_network else { + return ProxyPolicyInputs { + unix_domain_socket_policy: UnixDomainSocketPolicy::Restricted { + allowed: extra_allowed, + }, ..Default::default() - }), + }; + }; + let unix_domain_socket_policy = if context.dangerously_allow_all_unix_sockets { + UnixDomainSocketPolicy::AllowAll + } else { + UnixDomainSocketPolicy::from_allowlist(&context.allow_unix_sockets, extra_allowed) + }; + ProxyPolicyInputs { + ports: context.loopback_ports.clone(), + has_proxy_config: true, + allow_local_binding: context.allow_local_binding, + unix_domain_socket_policy, } } @@ -414,18 +307,6 @@ fn dynamic_network_policy_for_network( return format!("{policy}{MACOS_SEATBELT_NETWORK_POLICY}"); } - if proxy.has_proxy_config { - // Proxy configuration is present but we could not infer any valid loopback endpoints. - // Fail closed to avoid silently widening network access in proxy-enforced sessions. - return String::new(); - } - - if enforce_managed_network { - // Managed network requirements are active but no usable proxy endpoints - // are available. Fail closed for network access. - return String::new(); - } - if network_policy.is_enabled() { // No proxy env is configured: retain the existing full-network behavior. let mut policy = String::from("(allow network-outbound)\n(allow network-inbound)\n"); @@ -873,8 +754,6 @@ pub(crate) struct CreateSeatbeltCommandArgsParams<'a> { pub sandbox_policy_cwd: &'a Path, pub enforce_managed_network: bool, pub managed_network: Option<&'a ManagedNetworkSandboxContext>, - pub environment_id: Option<&'a str>, - pub network: Option<&'a NetworkProxy>, pub extra_allow_unix_sockets: &'a [AbsolutePathBuf], } @@ -902,8 +781,6 @@ pub(crate) fn create_seatbelt_command_args_with_profile( sandbox_policy_cwd, enforce_managed_network, managed_network, - environment_id, - network, extra_allow_unix_sockets, } = args; @@ -1049,13 +926,7 @@ pub(crate) fn create_seatbelt_command_args_with_profile( } }; - let proxy = proxy_policy_inputs( - managed_network, - network, - environment_id, - extra_allow_unix_sockets, - ) - .map_err(SeatbeltPreparationError::EnvironmentNetworkProxy)?; + let proxy = proxy_policy_inputs(managed_network, extra_allow_unix_sockets); let network_policy = dynamic_network_policy_for_network(network_sandbox_policy, enforce_managed_network, &proxy); diff --git a/codex-rs/sandboxing/src/seatbelt_daemon_socket_tests.rs b/codex-rs/sandboxing/src/seatbelt_daemon_socket_tests.rs index 5c316edc36..41f2be8bae 100644 --- a/codex-rs/sandboxing/src/seatbelt_daemon_socket_tests.rs +++ b/codex-rs/sandboxing/src/seatbelt_daemon_socket_tests.rs @@ -67,8 +67,6 @@ assert p.recv(2) == b'ok' sandbox_policy_cwd: workspace.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, extra_allow_unix_sockets: &[AbsolutePathBuf::from_absolute_path(root).unwrap()], }) .unwrap(); diff --git a/codex-rs/sandboxing/src/seatbelt_fcntl_tests.rs b/codex-rs/sandboxing/src/seatbelt_fcntl_tests.rs index 277bb30978..2a534fdfac 100644 --- a/codex-rs/sandboxing/src/seatbelt_fcntl_tests.rs +++ b/codex-rs/sandboxing/src/seatbelt_fcntl_tests.rs @@ -113,8 +113,6 @@ fn restricted_policies_deny_mutating_fcntls_through_read_only_descriptors() { sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, extra_allow_unix_sockets: &[], }) .expect("generated Seatbelt arguments"); diff --git a/codex-rs/sandboxing/src/seatbelt_network_tests.rs b/codex-rs/sandboxing/src/seatbelt_network_tests.rs index 6c005cc4ec..00974402a9 100644 --- a/codex-rs/sandboxing/src/seatbelt_network_tests.rs +++ b/codex-rs/sandboxing/src/seatbelt_network_tests.rs @@ -41,8 +41,6 @@ fn managed_local_binding_does_not_allow_external_dns() { sandbox_policy_cwd: workspace.path(), enforce_managed_network: true, managed_network: Some(&managed_network), - environment_id: None, - network: None, extra_allow_unix_sockets: &[], }) .expect("generated Seatbelt arguments"); diff --git a/codex-rs/sandboxing/src/seatbelt_tests.rs b/codex-rs/sandboxing/src/seatbelt_tests.rs index cb58967dcf..b2a23b42e8 100644 --- a/codex-rs/sandboxing/src/seatbelt_tests.rs +++ b/codex-rs/sandboxing/src/seatbelt_tests.rs @@ -158,8 +158,7 @@ fn seatbelt_allows_semaphore_limit_sysconf() { sandbox_policy_cwd: workspace.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("create seatbelt args"); @@ -224,8 +223,7 @@ fn filesystem_helper_platform_defaults_do_not_grant_applications_directory() { sandbox_policy_cwd: workspace.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }, profile, @@ -304,8 +302,7 @@ fn process_platform_defaults_allow_scratch_without_granting_it_to_filesystem_hel sandbox_policy_cwd: workspace.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }, profile, @@ -478,8 +475,7 @@ fn explicit_unreadable_paths_are_excluded_from_full_disk_read_and_write_access() sandbox_policy_cwd: Path::new("/"), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -618,8 +614,7 @@ denied /bin/mv "$workspace" "$destination/workspace" sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("generate full Seatbelt policy"); @@ -672,8 +667,7 @@ fn scoped_or_nonliteral_basename_denies_still_block_directory_moves() { sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("generate full Seatbelt policy"); @@ -809,8 +803,7 @@ fn nested_protected_paths_cannot_be_bypassed_by_renaming_ancestors() { sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("create seatbelt policy") @@ -909,8 +902,7 @@ fn prepared_managed_network_context_allows_only_its_proxy_ports() { sandbox_policy_cwd: Path::new("/"), enforce_managed_network: true, managed_network: Some(&managed_network), - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -923,108 +915,12 @@ fn prepared_managed_network_context_allows_only_its_proxy_ports() { assert!(!policy.contains("(allow network-outbound)\n")); assert!(!policy.contains("(allow system-socket (socket-domain AF_UNIX))")); assert!(!policy.contains("(allow network-outbound (remote unix-socket))")); -} - -#[tokio::test] -async fn prepared_managed_network_context_takes_precedence_over_live_proxy_socket_policy() --> anyhow::Result<()> { - let cwd = TempDir::new().expect("temp cwd"); - let file_system_policy = FileSystemSandboxPolicy::read_only(); - let network_config = NetworkProxyConfig { - enabled: true, - mode: NetworkMode::Full, - dangerously_allow_all_unix_sockets: Some(true), - ..Default::default() - }; - let state = build_config_state( - network_config, - NetworkProxyConstraints::default(), - codex_utils_path_uri::Platform::native(), - )?; - let network_proxy = NetworkProxy::builder() - .state(Arc::new(NetworkProxyState::with_reloader( - state, - Arc::new(TestConfigReloader), - ))) - .managed_by_codex(/*managed_by_codex*/ false) - .build() - .await?; - let prepared_socket = "/tmp/codex-prepared-use"; - let explicit_socket = "/tmp/codex-browser-use"; - let managed_network = ManagedNetworkSandboxContext { - loopback_ports: vec![43123], - allow_unix_sockets: vec![prepared_socket.to_string(), "relative.sock".to_string()], - ..Default::default() - }; - let extra_allow_unix_sockets = vec![absolute_path(explicit_socket)]; - let args = create_seatbelt_command_args(CreateSeatbeltCommandArgsParams { - command: vec!["/usr/bin/true".to_string()], - file_system_sandbox_policy: &file_system_policy, - network_sandbox_policy: NetworkSandboxPolicy::Restricted, - sandbox_policy_cwd: cwd.path(), - enforce_managed_network: true, - managed_network: Some(&managed_network), - environment_id: None, - network: Some(&network_proxy), - extra_allow_unix_sockets: &extra_allow_unix_sockets, - }) - .expect("create seatbelt args"); - - let policy = seatbelt_policy_arg(&args); - assert!(policy.contains("(allow network-outbound (remote ip \"localhost:43123\"))")); - assert!(policy.contains("(allow system-socket (socket-domain AF_UNIX))")); assert!(!policy.contains("(allow network-bind (local unix-socket))")); - assert!(!policy.contains("(allow network-outbound (remote unix-socket))")); - let expected_explicit_socket = normalize_path_for_sandbox(Path::new(explicit_socket)) - .expect("explicit socket root should normalize"); - let expected_prepared_socket = normalize_path_for_sandbox(Path::new(prepared_socket)) - .expect("prepared socket root should normalize"); - assert_eq!( - args.iter() - .filter(|arg| arg.starts_with("-DUNIX_SOCKET_PATH_")) - .cloned() - .collect::>(), - vec![ - format!( - "-DUNIX_SOCKET_PATH_0={}", - expected_explicit_socket.display() - ), - format!( - "-DUNIX_SOCKET_PATH_1={}", - expected_prepared_socket.display() - ), - ] - ); - - // An empty prepared policy must not inherit the live proxy's allow-all grant. - let managed_network = ManagedNetworkSandboxContext { - loopback_ports: vec![43123], - ..Default::default() - }; - let args = create_seatbelt_command_args(CreateSeatbeltCommandArgsParams { - command: vec!["/usr/bin/true".to_string()], - file_system_sandbox_policy: &file_system_policy, - network_sandbox_policy: NetworkSandboxPolicy::Restricted, - sandbox_policy_cwd: cwd.path(), - enforce_managed_network: true, - managed_network: Some(&managed_network), - environment_id: None, - network: Some(&network_proxy), - extra_allow_unix_sockets: &[], - }) - .expect("create seatbelt args for empty prepared policy"); - - let policy = seatbelt_policy_arg(&args); - assert!(policy.contains("(allow network-outbound (remote ip \"localhost:43123\"))")); - assert!(!policy.contains("(allow system-socket (socket-domain AF_UNIX))")); - assert!(!policy.contains("(allow network-bind (local unix-socket))")); - assert!(!policy.contains("(allow network-outbound (remote unix-socket))")); assert!( !args .iter() .any(|arg| arg.starts_with("-DUNIX_SOCKET_PATH_")) ); - Ok(()) } #[test] @@ -1051,8 +947,7 @@ fn explicit_unreadable_paths_are_excluded_from_readable_roots() { sandbox_policy_cwd: Path::new("/"), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -1201,8 +1096,7 @@ fn unreadable_glob_policy_includes_canonicalized_static_prefix() { sandbox_policy_cwd: temp_dir.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("generate Seatbelt command"); @@ -1272,8 +1166,7 @@ fn preferences_access_requires_unrestricted_reads() { sandbox_policy_cwd: cwd, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }, profile, @@ -1387,8 +1280,7 @@ fn restricted_reads_cannot_read_preferences_outside_allowed_roots() { sandbox_policy_cwd: workspace.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -1606,8 +1498,7 @@ fn create_seatbelt_args_allowlists_explicit_unix_socket_paths_without_proxy() { sandbox_policy_cwd: cwd.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &extra_allow_unix_sockets, }) .unwrap(); @@ -1659,6 +1550,8 @@ async fn create_seatbelt_args_merges_proxy_and_explicit_unix_socket_paths() -> a .managed_by_codex(/*managed_by_codex*/ false) .build() .await?; + let prepared = network_proxy + .prepare_for_optional_environment(Default::default(), /*environment_id*/ None)?; let extra_allow_unix_sockets = vec![absolute_path(explicit_socket)]; let args = create_seatbelt_command_args(CreateSeatbeltCommandArgsParams { @@ -1667,9 +1560,8 @@ async fn create_seatbelt_args_merges_proxy_and_explicit_unix_socket_paths() -> a network_sandbox_policy: NetworkSandboxPolicy::Restricted, sandbox_policy_cwd: cwd.path(), enforce_managed_network: false, - managed_network: None, - environment_id: None, - network: Some(&network_proxy), + managed_network: Some(&prepared.sandbox_context), + extra_allow_unix_sockets: &extra_allow_unix_sockets, }) .unwrap(); @@ -1709,8 +1601,7 @@ fn create_seatbelt_args_preserves_full_network_with_explicit_unix_socket_paths() sandbox_policy_cwd: cwd.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &extra_allow_unix_sockets, }) .unwrap(); @@ -1899,8 +1790,7 @@ fn create_seatbelt_args_with_read_only_git_and_codex_subpaths() { sandbox_policy_cwd: &cwd, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -2052,8 +1942,7 @@ fn create_seatbelt_args_with_read_only_git_and_codex_subpaths() { sandbox_policy_cwd: &cwd, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -2095,8 +1984,7 @@ fn create_seatbelt_args_with_read_only_git_and_codex_subpaths() { sandbox_policy_cwd: &cwd, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -2150,8 +2038,7 @@ fn create_seatbelt_args_rejects_symlinked_writable_root() { sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect_err("symlinked workspace should be rejected"); @@ -2196,8 +2083,7 @@ fn seatbelt_prevents_writable_root_replacement() { sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2243,8 +2129,7 @@ fn create_seatbelt_args_uses_literal_non_directory_writable_roots() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("file writable root should be supported"); @@ -2297,8 +2182,7 @@ fn seatbelt_allows_file_root_replacement_and_deletion() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2324,8 +2208,7 @@ fn seatbelt_allows_file_root_replacement_and_deletion() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("deleted file roots should remain usable by later commands"); @@ -2355,8 +2238,7 @@ fn seatbelt_file_root_does_not_follow_replacement_symlink() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2396,8 +2278,7 @@ fn seatbelt_protects_file_root_replaced_with_directory() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2449,8 +2330,7 @@ fn seatbelt_does_not_follow_rebound_writable_root_ancestor() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2492,8 +2372,7 @@ fn seatbelt_prevents_writable_directory_root_rename() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2537,8 +2416,7 @@ fn seatbelt_protects_writable_root_created_as_directory() { sandbox_policy_cwd: tmp.path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2618,8 +2496,7 @@ fn seatbelt_protects_aws_in_extra_writable_home() { sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2698,8 +2575,7 @@ fn seatbelt_protects_case_variants_of_metadata() { sandbox_policy_cwd: &workspace, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2769,8 +2645,7 @@ fn seatbelt_protects_resolved_target_of_symlinked_metadata_directory() { sandbox_policy_cwd: &writable_root, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("build seatbelt command"); @@ -2840,8 +2715,7 @@ fn create_seatbelt_args_block_first_time_dot_codex_creation_with_metadata_name_r sandbox_policy_cwd: repo_root.as_path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -2899,8 +2773,7 @@ fn create_seatbelt_args_with_read_only_git_pointer_file() { sandbox_policy_cwd: &cwd, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -2942,8 +2815,7 @@ fn create_seatbelt_args_with_read_only_git_pointer_file() { sandbox_policy_cwd: &cwd, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); @@ -3000,8 +2872,7 @@ fn workspace_write_protects_linked_worktree_gitdir_under_tmp() { sandbox_policy_cwd: &worktree, enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .expect("create seatbelt args"); @@ -3076,8 +2947,7 @@ fn create_seatbelt_args_for_cwd_as_git_repo() { sandbox_policy_cwd: vulnerable_root.as_path(), enforce_managed_network: false, managed_network: None, - environment_id: None, - network: None, + extra_allow_unix_sockets: &[], }) .unwrap(); diff --git a/codex-rs/sandboxing/src/seatbelt_tls_tests.rs b/codex-rs/sandboxing/src/seatbelt_tls_tests.rs index ee0bfb2838..8af7d08014 100644 --- a/codex-rs/sandboxing/src/seatbelt_tls_tests.rs +++ b/codex-rs/sandboxing/src/seatbelt_tls_tests.rs @@ -155,8 +155,6 @@ fn trust_evaluation_agent_access_follows_network_policy() { sandbox_policy_cwd: workspace.path(), enforce_managed_network: managed_network.is_some(), managed_network, - environment_id: None, - network: None, extra_allow_unix_sockets: extra_unix_sockets, }) .expect("generated Seatbelt arguments"); diff --git a/codex-rs/sandboxing/src/windows_mxc.rs b/codex-rs/sandboxing/src/windows_mxc.rs index 513a228450..5230b7ad70 100644 --- a/codex-rs/sandboxing/src/windows_mxc.rs +++ b/codex-rs/sandboxing/src/windows_mxc.rs @@ -10,7 +10,7 @@ use std::path::Path; pub(super) struct Mxc<'a> { pub(super) sandbox_exe: Option<&'a Path>, - pub(super) route: Option, + pub(super) route: Option<&'a ManagedNetworkSandboxContext>, } impl SandboxBackend for Mxc<'_> { @@ -28,7 +28,7 @@ impl SandboxBackend for Mxc<'_> { command: std::mem::take(&mut exec.command), permission_profile: &exec.permission_profile, sandbox_policy_cwd: policy_cwd, - managed_network: self.route.as_ref(), + managed_network: self.route, env: &mut exec.env, }) .map_err(|err| SandboxTransformError::WindowsMxcPreparation(err.to_string()))?;