diff --git a/codex-rs/cli/src/debug_sandbox.rs b/codex-rs/cli/src/debug_sandbox.rs index 97ad59cd34..80cf5f10e2 100644 --- a/codex-rs/cli/src/debug_sandbox.rs +++ b/codex-rs/cli/src/debug_sandbox.rs @@ -28,6 +28,7 @@ use codex_protocol::models::SandboxEnforcement; use codex_protocol::permissions::NetworkSandboxPolicy; use codex_sandboxing::SandboxCommand; use codex_sandboxing::SandboxManager; +use codex_sandboxing::SandboxNetwork; use codex_sandboxing::SandboxSelection; use codex_sandboxing::SandboxTransformRequest; use codex_sandboxing::SandboxType as SandboxBackend; @@ -438,9 +439,11 @@ async fn run_command_under_sandbox( workspace_roots: workspace_roots.as_deref(), runtime_readable_paths: None, selection: SandboxSelection::Explicit(sandbox), - enforce_managed_network: network.is_some(), - network: network.as_ref(), - environment_id: None, + network: SandboxNetwork::new( + network.is_some(), + network.as_ref(), + /*environment_id*/ None, + ), sandbox_policy_cwd: &cwd, sandbox_exe: sandbox_exe.as_deref(), use_legacy_landlock, diff --git a/codex-rs/core/src/exec.rs b/codex-rs/core/src/exec.rs index a24be17863..8ebcc690e3 100644 --- a/codex-rs/core/src/exec.rs +++ b/codex-rs/core/src/exec.rs @@ -38,6 +38,7 @@ use codex_protocol::protocol::ExecCommandOutputDeltaEvent; use codex_protocol::protocol::ExecOutputStream; use codex_sandboxing::SandboxCommand; use codex_sandboxing::SandboxManager; +use codex_sandboxing::SandboxNetwork; use codex_sandboxing::SandboxSelection; use codex_sandboxing::SandboxTransformRequest; use codex_sandboxing::SandboxType; @@ -413,9 +414,11 @@ pub async fn build_exec_request( workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(sandbox_type), - enforce_managed_network, - environment_id: network_environment_id.as_deref(), - network: network.as_ref(), + network: SandboxNetwork::new( + enforce_managed_network, + network.as_ref(), + network_environment_id.as_deref(), + ), sandbox_policy_cwd: &sandbox_policy_cwd_uri, sandbox_exe: if cfg!(windows) { codex_self_exe.as_deref() diff --git a/codex-rs/core/src/shell_snapshot_sandbox.rs b/codex-rs/core/src/shell_snapshot_sandbox.rs index a5ff1bbb6a..8b49584c26 100644 --- a/codex-rs/core/src/shell_snapshot_sandbox.rs +++ b/codex-rs/core/src/shell_snapshot_sandbox.rs @@ -17,6 +17,7 @@ use codex_protocol::models::FileSystemPermissions; use codex_protocol::models::PermissionProfile; use codex_sandboxing::SandboxCommand; use codex_sandboxing::SandboxManager; +use codex_sandboxing::SandboxNetwork; use codex_sandboxing::SandboxSelection; use codex_sandboxing::SandboxTransformRequest; use codex_sandboxing::SandboxType; @@ -87,7 +88,7 @@ impl ShellSnapshotSandbox { sandbox_exe: attempt.sandbox_exe.cloned(), use_legacy_landlock: attempt.use_legacy_landlock, windows_sandbox_level: attempt.windows_sandbox_level, - network: attempt.network_proxy(network).cloned(), + network: network.cloned(), environment_id: environment_id.to_string(), additional_permissions: additional_permissions.cloned(), network_denial_cancellation_token: attempt.network_denial_cancellation_token.clone(), @@ -168,9 +169,11 @@ impl ShellSnapshotSandbox { workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(self.sandbox), - enforce_managed_network: self.enforce_managed_network, - environment_id: Some(&self.environment_id), - network: self.network.as_ref(), + network: SandboxNetwork::new( + self.enforce_managed_network, + self.network.as_ref(), + Some(&self.environment_id), + ), sandbox_policy_cwd: &self.sandbox_policy_cwd, sandbox_exe: self.sandbox_exe.as_deref(), use_legacy_landlock: self.use_legacy_landlock, diff --git a/codex-rs/core/src/tools/runtimes/unified_exec.rs b/codex-rs/core/src/tools/runtimes/unified_exec.rs index 849795fb50..2f789f813a 100644 --- a/codex-rs/core/src/tools/runtimes/unified_exec.rs +++ b/codex-rs/core/src/tools/runtimes/unified_exec.rs @@ -339,7 +339,7 @@ impl<'a> ToolRuntime, UnifiedExecAttempt> for UnifiedExec ) })?); } - (env, None, launch.proxy.enabled.then_some(launch)) + (env, None, Some(launch)) } Some(network) => { let child_environment = snapshot_credential_context @@ -617,6 +617,7 @@ impl<'a> ToolRuntime, UnifiedExecAttempt> for UnifiedExec prepared.cwd.clone(), env, managed_network_context, + network_proxy_launch, additional_permissions.as_ref(), options, ) @@ -647,7 +648,6 @@ impl<'a> ToolRuntime, UnifiedExecAttempt> for UnifiedExec ctx, request, managed_network, - network_proxy_launch, req.exec_server_env_config.clone(), req.shell_snapshot.clone(), windows_sandbox_proxy_settings_mode, diff --git a/codex-rs/core/src/tools/sandboxing.rs b/codex-rs/core/src/tools/sandboxing.rs index c501dfded3..3613c7f7d7 100644 --- a/codex-rs/core/src/tools/sandboxing.rs +++ b/codex-rs/core/src/tools/sandboxing.rs @@ -16,6 +16,7 @@ use codex_file_system::FileSystemSandboxContext; use codex_file_system::WindowsSandboxSelection; use codex_network_proxy::ManagedNetworkSandboxContext; use codex_network_proxy::NetworkProxy; +use codex_network_proxy::RemoteNetworkProxyLaunchConfig; use codex_protocol::approvals::ExecPolicyAmendment; use codex_protocol::config_types::WindowsSandboxLevel; use codex_protocol::error::CodexErr; @@ -28,6 +29,7 @@ pub(crate) use codex_protocol::sandbox::SandboxOverride; use codex_sandboxing::SandboxCommand; use codex_sandboxing::SandboxExecRequest; use codex_sandboxing::SandboxManager; +use codex_sandboxing::SandboxNetwork; use codex_sandboxing::SandboxSelection; use codex_sandboxing::SandboxTransformRequest; use codex_sandboxing::SandboxType; @@ -502,7 +504,6 @@ impl<'a> SandboxAttempt<'a> { network: Option<&NetworkProxy>, environment_id: Option<&str>, ) -> Result { - let network = self.network_proxy(network); let mut request = self .manager .transform(SandboxTransformRequest { @@ -511,9 +512,7 @@ impl<'a> SandboxAttempt<'a> { workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(self.sandbox), - enforce_managed_network: self.enforce_managed_network, - environment_id, - network, + network: SandboxNetwork::new(self.enforce_managed_network, network, environment_id), sandbox_policy_cwd: self.sandbox_cwd, sandbox_exe: self.sandbox_exe.map(std::path::PathBuf::as_path), use_legacy_landlock: self.use_legacy_landlock, @@ -530,12 +529,14 @@ impl<'a> SandboxAttempt<'a> { .await } + #[allow(clippy::too_many_arguments)] pub async fn env_for_exec_server( &self, argv: Vec, cwd: PathUri, env: HashMap, managed_network: Option, + network_proxy_launch: Option, additional_permissions: Option<&AdditionalPermissionProfile>, options: ExecOptions, ) -> Result { @@ -559,7 +560,17 @@ impl<'a> SandboxAttempt<'a> { crate::sandboxing::ExecRequest::from_sandbox_exec_request(request, options, Vec::new()) .await?; exec_request.exec_server_managed_network = managed_network; + // A controller-only proxy may be disabled on the executor. With no launch config, + // a sandboxed attempt can still require managed networking. + let proxy_disabled = network_proxy_launch + .as_ref() + .is_some_and(|launch| !launch.proxy.enabled); + if !proxy_disabled { + exec_request.exec_server_network_proxy = network_proxy_launch; + } if self.sandbox_requested { + exec_request.exec_server_enforce_managed_network = + self.enforce_managed_network && !proxy_disabled; exec_request.exec_server_sandbox = Some(FileSystemSandboxContext { permissions: exec_server_permissions, sandbox_override: self.sandbox_override, @@ -575,7 +586,6 @@ impl<'a> SandboxAttempt<'a> { windows_sandbox_proxy_settings_mode: None, use_legacy_landlock: self.use_legacy_landlock, }); - exec_request.exec_server_enforce_managed_network = self.enforce_managed_network; } Ok(exec_request) } diff --git a/codex-rs/core/src/tools/sandboxing_tests.rs b/codex-rs/core/src/tools/sandboxing_tests.rs index 8465631cb0..76af09ef0f 100644 --- a/codex-rs/core/src/tools/sandboxing_tests.rs +++ b/codex-rs/core/src/tools/sandboxing_tests.rs @@ -402,13 +402,14 @@ async fn exec_server_env_keeps_command_native_and_carries_sandbox_context() { "printf 'cafĂ© au lait'".to_string(), String::new(), ]; - let prepare = async |attempt: &SandboxAttempt<'_>| { + let prepare = async |attempt: &SandboxAttempt<'_>, route, proxy_launch| { attempt .env_for_exec_server( argv.clone(), cwd_uri.clone(), HashMap::new(), - Some(managed_network.clone()), + route, + proxy_launch, /*additional_permissions*/ None, crate::sandboxing::ExecOptions { expiration: crate::exec::ExecExpiration::DefaultTimeout, @@ -417,9 +418,13 @@ async fn exec_server_env_keeps_command_native_and_carries_sandbox_context() { ) .await }; - let request = prepare(&attempt) - .await - .expect("prepare remote exec request"); + let request = prepare( + &attempt, + Some(managed_network.clone()), + /*proxy_launch*/ None, + ) + .await + .expect("prepare remote exec request"); assert!(!attempt.is_escalated()); assert_eq!(request.command, argv); @@ -450,9 +455,13 @@ async fn exec_server_env_keeps_command_native_and_carries_sandbox_context() { ); attempt.sandbox_override = SandboxOverride::EscalatedSandboxWithRestrictions; - let escalated_request = prepare(&attempt) - .await - .expect("prepare approved escalation with retained sandbox restrictions"); + let escalated_request = prepare( + &attempt, + Some(managed_network.clone()), + /*proxy_launch*/ None, + ) + .await + .expect("prepare approved escalation with retained sandbox restrictions"); let mut expected_context = request.exec_server_sandbox.expect("sandbox context"); expected_context.sandbox_override = SandboxOverride::EscalatedSandboxWithRestrictions; assert_eq!( @@ -460,10 +469,31 @@ async fn exec_server_env_keeps_command_native_and_carries_sandbox_context() { Some(expected_context) ); + let disabled_proxy = codex_network_proxy::RemoteNetworkProxyConfig::from_effective_config( + &codex_network_proxy::NetworkProxyConfig { + enabled: false, + ..Default::default() + }, + ) + .expect("valid disabled proxy"); + let request = prepare( + &attempt, + /*route*/ None, + Some(RemoteNetworkProxyLaunchConfig::new(disabled_proxy)), + ) + .await + .expect("prepare remote command with a controller-only proxy"); + assert!(!request.exec_server_enforce_managed_network); + assert!(request.exec_server_network_proxy.is_none()); + attempt.sandbox_requested = false; - let request = prepare(&attempt) - .await - .expect("prepare unsandboxed remote exec request"); + let request = prepare( + &attempt, + Some(managed_network.clone()), + /*proxy_launch*/ None, + ) + .await + .expect("prepare unsandboxed remote exec request"); assert!(attempt.is_escalated()); assert_eq!(request.exec_server_sandbox, None); diff --git a/codex-rs/core/src/unified_exec/process_manager.rs b/codex-rs/core/src/unified_exec/process_manager.rs index 9da4ede137..1b8e339ab4 100644 --- a/codex-rs/core/src/unified_exec/process_manager.rs +++ b/codex-rs/core/src/unified_exec/process_manager.rs @@ -1318,23 +1318,18 @@ impl UnifiedExecProcessManager { tool_ctx: &ToolCtx, request: ExecRequest, network: Option<&NetworkProxy>, - network_proxy_launch: Option, exec_server_env_config: Option, shell_snapshot: Option, windows_sandbox_proxy_settings_mode: codex_sandboxing::WindowsSandboxProxySettingsMode, tty: bool, environment: &codex_exec_server::Environment, ) -> Result { - let network_policy_decider = network_proxy_launch + let network_policy_decider = request + .exec_server_network_proxy .as_ref() .filter(|launch| launch.policy_decision_timeout_ms.is_some()) .and_then(|launch| network?.remote_policy_decider(launch.proxy.allow_local_binding)); - let missing_remote_proxy = - environment.is_remote() && network.is_some() && network_proxy_launch.is_none(); let request = ExecRequest { - exec_server_enforce_managed_network: request.exec_server_enforce_managed_network - && !missing_remote_proxy, - exec_server_network_proxy: network_proxy_launch, exec_server_env_config, exec_server_shell_snapshot: shell_snapshot, ..request diff --git a/codex-rs/core/tests/windows_sandbox.rs b/codex-rs/core/tests/windows_sandbox.rs index 6d69ee376f..ade38deb3e 100644 --- a/codex-rs/core/tests/windows_sandbox.rs +++ b/codex-rs/core/tests/windows_sandbox.rs @@ -518,9 +518,7 @@ async fn windows_elevated_temp_only_core_and_direct_spawn_enforce_carveouts() -> workspace_roots: Some(std::slice::from_ref(&cwd_uri)), runtime_readable_paths: None, selection: SandboxSelection::Explicit(SandboxType::WindowsRestrictedToken), - enforce_managed_network: false, - environment_id: None, - network: None, + network: Default::default(), sandbox_policy_cwd: &cwd_uri, sandbox_exe: Some(codex.as_path()), use_legacy_landlock: false, diff --git a/codex-rs/exec-server/src/fs_sandbox.rs b/codex-rs/exec-server/src/fs_sandbox.rs index 831cf8aef0..e2e3a21c8e 100644 --- a/codex-rs/exec-server/src/fs_sandbox.rs +++ b/codex-rs/exec-server/src/fs_sandbox.rs @@ -130,9 +130,7 @@ impl FileSystemSandboxRunner { workspace_roots: Some(&sandbox.workspace_roots), runtime_readable_paths: Some(&helper_readable_paths), selection, - enforce_managed_network: false, - network: None, - environment_id: None, + network: Default::default(), sandbox_policy_cwd: &sandbox.cwd, sandbox_exe: if cfg!(windows) { Some(helper.as_path()) diff --git a/codex-rs/exec-server/src/process_sandbox.rs b/codex-rs/exec-server/src/process_sandbox.rs index 02309d3fed..ae1620cd2b 100644 --- a/codex-rs/exec-server/src/process_sandbox.rs +++ b/codex-rs/exec-server/src/process_sandbox.rs @@ -1,4 +1,5 @@ use std::collections::HashMap; +#[cfg(windows)] use std::path::Path; use std::sync::Arc; @@ -8,7 +9,6 @@ use codex_exec_server_protocol::ProcessStartErrorData; use codex_file_system::WindowsSandboxSelection; use codex_network_proxy::CHILD_ONLY_CA_ENV_KEYS; use codex_network_proxy::CUSTOM_CA_ENV_KEYS; -use codex_network_proxy::CredentialMaskingFailureMode; use codex_network_proxy::ManagedNetworkSandboxContext; use codex_network_proxy::ManagedProxyRouting; use codex_network_proxy::NetworkPolicyAuditObserver; @@ -17,9 +17,11 @@ use codex_network_proxy::NetworkProxy; use codex_network_proxy::NetworkProxyHandle; use codex_network_proxy::NetworkProxyState; use codex_network_proxy::RemoteCredentialBrokerCache; +use codex_network_proxy::ShellStartupCredentials; use codex_network_proxy::is_managed_mitm_ca_trust_bundle_path; use codex_sandboxing::SandboxCommand; use codex_sandboxing::SandboxManager; +use codex_sandboxing::SandboxNetwork; use codex_sandboxing::SandboxTransformRequest; use codex_sandboxing::WrappedSandboxCommand; #[cfg(windows)] @@ -36,21 +38,6 @@ use crate::rpc::internal_error; use crate::rpc::invalid_params; use crate::sandbox_selection::sandbox_selection; -const CREDENTIAL_MASKING_FAILURE_MODE: CredentialMaskingFailureMode = - CredentialMaskingFailureMode::Warn; - -pub(crate) fn supports_credential_snapshot(params: &ExecParams) -> bool { - cfg!(any(target_os = "linux", target_os = "macos")) - && params.arg0.is_none() - && params.shell_snapshot.as_ref().is_some_and(|snapshot| { - snapshot.shell.name == "zsh" - && matches!(params.argv.as_slice(), [program, flag, _] - if program == &snapshot.shell.path - && flag == "-lc" - && Path::new(program).file_name().is_some_and(|name| name == "zsh")) - }) -} - #[tracing::instrument( name = "codex.exec_server.process_prepare_sandbox", skip_all, @@ -201,9 +188,11 @@ pub(crate) async fn prepare_exec_request_with_telemetry( workspace_roots: Some(&sandbox_context.workspace_roots), runtime_readable_paths: Some(&runtime_readable_paths), selection, - enforce_managed_network, - environment_id: None, - network: proxy_handle.as_ref().and_then(NetworkProxyHandle::proxy), + network: SandboxNetwork::new( + enforce_managed_network, + proxy_handle.as_ref().and_then(NetworkProxyHandle::proxy), + /*environment_id*/ None, + ), sandbox_policy_cwd: &sandbox_context.cwd, sandbox_exe: if cfg!(windows) { Some(runtime_paths.codex_self_exe.as_path()) @@ -320,36 +309,31 @@ async fn prepare_managed_network( ) .await .map_err(|err| internal_error(err.to_string()))?; - let supported_shell = matches!(params.argv.as_slice(), [program, flag, _] - if Path::new(program).file_name().is_some_and(|name| name == "bash") && flag == "-c") - && !["BASH_ENV", "ENV", "SSH_CLIENT", "SSH2_CLIENT"] - .iter() - .any(|key| env.contains_key(*key)); + let credentials = credential_masking.then(|| { + ShellStartupCredentials::for_command( + ¶ms.argv, + params.arg0.as_deref(), + params + .shell_snapshot + .as_ref() + .map(|snapshot| (snapshot.shell.name.as_str(), snapshot.shell.path.as_str())), + &env, + ) + }); let mut prepared = proxy .prepare_for_optional_environment(env, /*environment_id*/ None) .map_err(|err| { internal_error(format!("failed to prepare executor network proxy: {err}")) })?; - if credential_masking { - if supports_credential_snapshot(params) { - // Requested snapshots trust startup profiles before masking their captured state. - proxy.restore_and_disable_brokered_credentials(&mut prepared.env, &mut []); - } else if cfg!(any(target_os = "linux", target_os = "macos")) - && supported_shell - && params.arg0.is_none() - && params.shell_snapshot.is_none() - { - proxy - .handle_unmasked_credentials(&mut prepared.env, CREDENTIAL_MASKING_FAILURE_MODE) - .map_err(|err| invalid_params(err.to_string()))?; - } else { + if let Some(credentials) = credentials { + if matches!(credentials, ShellStartupCredentials::UnmaskedCommand) { tracing::warn!( "Credential masking is unavailable for this shell startup; preserving shell profiles and snapshots and running with unmasked credentials." ); - // Restore this child's environment without disabling translation of placeholders - // issued to earlier commands in the same environment. - proxy.restore_and_disable_brokered_credentials(&mut prepared.env, &mut []); } + credentials + .apply(&proxy, &mut prepared.env) + .map_err(|err| invalid_params(err.to_string()))?; } Ok((prepared.env, Some(prepared.sandbox_context), Some(handle))) } diff --git a/codex-rs/exec-server/src/shell_snapshot.rs b/codex-rs/exec-server/src/shell_snapshot.rs index 2c90d5d584..5c5397e48f 100644 --- a/codex-rs/exec-server/src/shell_snapshot.rs +++ b/codex-rs/exec-server/src/shell_snapshot.rs @@ -38,7 +38,6 @@ use tokio::time::Instant; use crate::FileSystemSandboxContext; use crate::local_process::apply_exec_metadata; use crate::local_process::shell_environment_policy; -use crate::process_sandbox::supports_credential_snapshot; use crate::protocol::ExecEnvPolicy; use crate::protocol::ExecParams; use crate::protocol::ShellSnapshotRequest; @@ -46,6 +45,7 @@ use crate::rpc::internal_error; use crate::rpc::invalid_params; use crate::shell_snapshot_process::SnapshotCapture; use crate::telemetry::ExecServerTelemetry; +use codex_network_proxy::ShellStartupCredentials; const MAX_CACHED_SNAPSHOTS: usize = 16; const MAX_SNAPSHOT_BYTES: usize = 512 * 1024; @@ -144,7 +144,12 @@ impl ShellSnapshotCache { .network_proxy .as_ref() .is_some_and(|launch| launch.proxy.credential_masking_enabled()) - && supports_credential_snapshot(params) + && ShellStartupCredentials::supports_snapshot( + ¶ms.argv, + params.arg0.as_deref(), + &request.shell.name, + &request.shell.path, + ) }); let protected = proxy.is_some(); diff --git a/codex-rs/network-proxy/src/credential_broker.rs b/codex-rs/network-proxy/src/credential_broker.rs index 727e9df5a0..ddcfecb5fa 100644 --- a/codex-rs/network-proxy/src/credential_broker.rs +++ b/codex-rs/network-proxy/src/credential_broker.rs @@ -56,6 +56,71 @@ pub enum CredentialMaskingFailureMode { Error, } +/// How the proxy handles brokered credentials while an executor shell starts. +#[derive(Clone, Copy)] +pub enum ShellStartupCredentials { + ProtectedSnapshot, + MaskedCommand, + UnmaskedCommand, +} + +impl ShellStartupCredentials { + /// Only this exact login invocation can be replayed from a protected snapshot. + pub fn supports_snapshot( + argv: &[String], + arg0: Option<&str>, + shell_name: &str, + shell_path: &str, + ) -> bool { + cfg!(any(target_os = "linux", target_os = "macos")) + && arg0.is_none() + && shell_name == "zsh" + && matches!(argv, [program, flag, _] if program == shell_path && flag == "-lc" + && std::path::Path::new(program).file_name().is_some_and(|name| name == "zsh")) + } + + /// Classify the original shell environment before proxy preparation rewrites it. + pub fn for_command( + argv: &[String], + arg0: Option<&str>, + snapshot_shell: Option<(&str, &str)>, + env: &HashMap, + ) -> Self { + if let Some((name, path)) = snapshot_shell { + if Self::supports_snapshot(argv, arg0, name, path) { + return Self::ProtectedSnapshot; + } + } else if cfg!(any(target_os = "linux", target_os = "macos")) + && arg0.is_none() + && matches!(argv, [program, flag, _] if std::path::Path::new(program).file_name().is_some_and(|name| name == "bash") && flag == "-c") + && !["BASH_ENV", "ENV", "SSH_CLIENT", "SSH2_CLIENT"] + .iter() + .any(|key| env.contains_key(*key)) + { + return Self::MaskedCommand; + } + Self::UnmaskedCommand + } + + /// Apply the startup decision to this child only. Earlier commands retain their bindings. + pub fn apply( + self, + proxy: &crate::NetworkProxy, + env: &mut HashMap, + ) -> anyhow::Result<()> { + match self { + Self::MaskedCommand => { + proxy.handle_unmasked_credentials(env, CredentialMaskingFailureMode::Warn) + } + // Both start with real credentials. Protected snapshots mask the captured state afterward. + Self::ProtectedSnapshot | Self::UnmaskedCommand => { + proxy.restore_and_disable_brokered_credentials(env, &mut []); + Ok(()) + } + } + } +} + #[derive(Clone)] pub(crate) struct CredentialBroker { state: Arc>, diff --git a/codex-rs/network-proxy/src/lib.rs b/codex-rs/network-proxy/src/lib.rs index 31edd05567..c4471e964a 100644 --- a/codex-rs/network-proxy/src/lib.rs +++ b/codex-rs/network-proxy/src/lib.rs @@ -64,6 +64,7 @@ pub use credential_broker::CredentialBrokerContext; pub use credential_broker::CredentialBrokerEnvironment; pub use credential_broker::CredentialMaskingFailureMode; pub use credential_broker::CredentialProviderConfig; +pub use credential_broker::ShellStartupCredentials; pub use credential_broker::brokered_credential_binding_env_keys; pub use credential_broker::brokered_credential_dummy_env_keys; pub use credential_broker::brokered_credential_env_keys; diff --git a/codex-rs/sandboxing/src/lib.rs b/codex-rs/sandboxing/src/lib.rs index 638204c04b..990d1159e6 100644 --- a/codex-rs/sandboxing/src/lib.rs +++ b/codex-rs/sandboxing/src/lib.rs @@ -34,6 +34,7 @@ pub use linux_pid_namespace::LinuxSandboxPidNamespace; pub use manager::SandboxCommand; pub use manager::SandboxExecRequest; pub use manager::SandboxManager; +pub use manager::SandboxNetwork; pub use manager::SandboxSelection; pub use manager::SandboxTransformError; pub use manager::SandboxTransformRequest; diff --git a/codex-rs/sandboxing/src/manager.rs b/codex-rs/sandboxing/src/manager.rs index b2c9cbea3d..6ffe2a4c67 100644 --- a/codex-rs/sandboxing/src/manager.rs +++ b/codex-rs/sandboxing/src/manager.rs @@ -143,6 +143,30 @@ pub enum SandboxSelection { RequirePlatform, } +/// Network enforcement for one launch. A proxy may be required without a live proxy +/// on this host. The command carries any already-prepared route. +#[derive(Default)] +pub struct SandboxNetwork<'a> { + enforce_managed_network: bool, + /// The caller keeps the proxy listeners alive while the child uses them. + proxy: Option<&'a NetworkProxy>, + environment_id: Option<&'a str>, +} + +impl<'a> SandboxNetwork<'a> { + pub fn new( + enforce_managed_network: bool, + proxy: Option<&'a NetworkProxy>, + environment_id: Option<&'a str>, + ) -> Self { + Self { + enforce_managed_network, + proxy, + environment_id, + } + } +} + /// Bundled arguments for sandbox transformation. /// /// This keeps call sites self-documenting when several fields are optional. @@ -155,10 +179,7 @@ pub struct SandboxTransformRequest<'a> { /// bundle, if any. With `None`, the sandbox manager looks up the live proxy's CA bundle. pub runtime_readable_paths: Option<&'a [AbsolutePathBuf]>, pub selection: SandboxSelection, - pub enforce_managed_network: bool, - pub environment_id: Option<&'a str>, - /// Live proxy for this launch. The caller keeps its listeners alive while the child uses them. - pub network: Option<&'a NetworkProxy>, + pub network: SandboxNetwork<'a>, pub sandbox_policy_cwd: &'a PathUri, pub sandbox_exe: Option<&'a Path>, // TODO(anp): Reconcile these backend inputs with the supplied sandbox context @@ -415,12 +436,14 @@ impl SandboxManager { request: SandboxTransformRequest<'_>, ) -> Result { let command = request.command; - let network = request.network; + let SandboxNetwork { + enforce_managed_network, + proxy: network, + environment_id, + } = request.network; let is_file_system_helper = matches!(self.operation, SandboxOperation::FileSystemHelper); if is_file_system_helper - && (network.is_some() - || request.enforce_managed_network - || command.managed_network.is_some()) + && (network.is_some() || enforce_managed_network || command.managed_network.is_some()) { return Err(SandboxTransformError::InvalidPolicy(io::Error::new( io::ErrorKind::InvalidInput, @@ -453,7 +476,7 @@ impl SandboxManager { } #[cfg(windows)] if backend == SandboxType::WindowsRestrictedToken - && request.enforce_managed_network + && enforce_managed_network && request.windows_sandbox_level != WindowsSandboxLevel::Elevated { return Err(SandboxTransformError::WindowsSandboxPreparation( @@ -481,7 +504,7 @@ impl SandboxManager { }; let managed_network = command .managed_network - .filter(|_| request.enforce_managed_network || backend == SandboxType::MacosSeatbelt); + .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()); argv.extend(command.args); @@ -493,7 +516,7 @@ impl SandboxManager { sandbox_policy_cwd: request.sandbox_policy_cwd.clone(), env: command.env, network: network.cloned(), - network_environment_id: request.environment_id.map(str::to_owned), + network_environment_id: environment_id.map(str::to_owned), sandbox: backend, windows_sandbox_level: request.windows_sandbox_level, permission_profile: policy.permissions, @@ -521,14 +544,14 @@ impl SandboxManager { )); } let route = match managed_network { - None if request.enforce_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, request.environment_id) + .prepare_for_optional_environment(exec.env, environment_id) .map_err(|err| { SandboxTransformError::EnvironmentNetworkProxy(err.to_string()) })?; @@ -572,7 +595,7 @@ impl SandboxManager { let managed_network = match (managed_network, network) { (None, Some(proxy)) => { let prepared = proxy - .prepare_for_optional_environment(exec.env, request.environment_id) + .prepare_for_optional_environment(exec.env, environment_id) .map_err(|err| { SandboxTransformError::EnvironmentNetworkProxy(err.to_string()) })?; @@ -597,9 +620,9 @@ impl SandboxManager { file_system_sandbox_policy: &file_system_sandbox_policy, network_sandbox_policy, sandbox_policy_cwd: &pending.native_sandbox_policy_cwd, - enforce_managed_network: request.enforce_managed_network, + enforce_managed_network, managed_network: managed_network.as_ref(), - environment_id: request.environment_id, + environment_id, network, extra_allow_unix_sockets: sockets, }, @@ -626,11 +649,11 @@ impl SandboxManager { let exe = request .sandbox_exe .ok_or(SandboxTransformError::MissingLinuxSandboxExecutable)?; - let route = match (request.enforce_managed_network, managed_network, network) { + let route = match (enforce_managed_network, managed_network, network) { (false, _, _) => None, (true, None, Some(proxy)) => { let prepared = proxy - .prepare_for_optional_environment(exec.env, request.environment_id) + .prepare_for_optional_environment(exec.env, environment_id) .map_err(|err| { SandboxTransformError::EnvironmentNetworkProxy(err.to_string()) })?; @@ -680,11 +703,8 @@ impl SandboxManager { let session = WindowsSessionPolicy { workspace_roots: policy.workspace_roots, filesystem_overrides, - proxy_enforced: request.enforce_managed_network, - restricting_sid: windows_proxy_restricting_sid( - network, - request.environment_id, - )?, + proxy_enforced: enforce_managed_network, + restricting_sid: windows_proxy_restricting_sid(network, environment_id)?, proxy_settings_mode, }; return Ok(wrapped(exec, Some(Box::new(session)))); diff --git a/codex-rs/sandboxing/src/manager_tests.rs b/codex-rs/sandboxing/src/manager_tests.rs index 3024edd515..820f2d135b 100644 --- a/codex-rs/sandboxing/src/manager_tests.rs +++ b/codex-rs/sandboxing/src/manager_tests.rs @@ -1,5 +1,6 @@ use super::SandboxCommand; use super::SandboxManager; +use super::SandboxNetwork; use super::SandboxSelection; use super::SandboxTransformRequest; use super::SandboxType; @@ -117,9 +118,11 @@ fn unsandboxed_transform_preserves_foreign_cwd_and_unrestricted_file_system_poli workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(SandboxType::None), - enforce_managed_network: false, - environment_id: Some("remote"), - network: None, + network: SandboxNetwork::new( + /*enforce_managed_network*/ false, + /*proxy*/ None, + Some("remote"), + ), sandbox_policy_cwd: &cwd_uri, sandbox_exe: None, use_legacy_landlock: false, @@ -181,9 +184,7 @@ fn symlinked_workspace_reports_seatbelt_preparation_error() { workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(SandboxType::MacosSeatbelt), - enforce_managed_network: false, - environment_id: None, - network: None, + network: Default::default(), sandbox_policy_cwd: &workspace_uri, sandbox_exe: None, use_legacy_landlock: false, @@ -238,9 +239,7 @@ fn transform_additional_permissions_enable_network_for_external_sandbox() { workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(SandboxType::None), - enforce_managed_network: false, - environment_id: None, - network: None, + network: Default::default(), sandbox_policy_cwd: &cwd_uri, sandbox_exe: None, use_legacy_landlock: false, @@ -329,9 +328,7 @@ fn transform_additional_permissions_preserves_denied_entries() { workspace_roots: Some(roots), runtime_readable_paths: Some(&[]), selection: SandboxSelection::Explicit(SandboxType::None), - enforce_managed_network: false, - network: None, - environment_id: None, + network: Default::default(), sandbox_policy_cwd: &cwd_uri, sandbox_exe: None, use_legacy_landlock: false, @@ -410,9 +407,7 @@ fn sandbox_transform_request(cwd: &PathUri, sandbox: SandboxType) -> SandboxTran workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(sandbox), - enforce_managed_network: false, - environment_id: None, - network: None, + network: Default::default(), sandbox_policy_cwd: cwd, sandbox_exe: None, use_legacy_landlock: false, @@ -734,9 +729,11 @@ async fn check_linux_managed_policy(transparent_tcp: bool) -> anyhow::Result<()> workspace_roots: None, runtime_readable_paths: None, selection: SandboxSelection::Explicit(SandboxType::LinuxSeccomp), - enforce_managed_network, - environment_id: None, - network: live_proxy.then_some(&network), + network: SandboxNetwork::new( + enforce_managed_network, + live_proxy.then_some(&network), + /*environment_id*/ None, + ), sandbox_policy_cwd: &cwd_uri, sandbox_exe: Some(std::path::Path::new("/tmp/codex-linux-sandbox")), use_legacy_landlock: false,