Centralize sandbox network and shell credential setup (#62050)

## Why

A missing executor proxy launch config can still require managed networking. Only an explicitly disabled executor proxy should suppress that enforcement.

## What changed

- Prepare executor proxy launch settings and enforcement together, preserving the distinction between missing and disabled proxy configurations.
- Bundle sandbox enforcement, the live proxy, and the environment ID in `SandboxNetwork`, retaining the proxy through shell snapshot setup.
- Share shell-startup credential classification and application through `ShellStartupCredentials`, including protected `zsh` snapshots, supported `bash -c` commands, and unmasked fallback handling.

## Testing

Extend the exec-server sandbox preparation test to verify that an explicitly disabled proxy omits both the proxy launch config and managed-network enforcement.

GitOrigin-RevId: e2f3b543680c9184b6557b81de02a61f0a977e32
This commit is contained in:
viyatb-oai
2026-11-17 13:52:56 +00:00
committed by copyberry
parent 49d657aad0
commit 05ae1b0fdd
16 changed files with 237 additions and 124 deletions
+6 -3
View File
@@ -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,
+6 -3
View File
@@ -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()
+7 -4
View File
@@ -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,
@@ -339,7 +339,7 @@ impl<'a> ToolRuntime<UnifiedExecRequest<'_>, 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<UnifiedExecRequest<'_>, 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<UnifiedExecRequest<'_>, 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,
+15 -5
View File
@@ -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<crate::sandboxing::ExecRequest, CodexErr> {
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<String>,
cwd: PathUri,
env: HashMap<String, String>,
managed_network: Option<ManagedNetworkSandboxContext>,
network_proxy_launch: Option<RemoteNetworkProxyLaunchConfig>,
additional_permissions: Option<&AdditionalPermissionProfile>,
options: ExecOptions,
) -> Result<crate::sandboxing::ExecRequest, CodexErr> {
@@ -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)
}
+41 -11
View File
@@ -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);
@@ -1318,23 +1318,18 @@ impl UnifiedExecProcessManager {
tool_ctx: &ToolCtx,
request: ExecRequest,
network: Option<&NetworkProxy>,
network_proxy_launch: Option<codex_network_proxy::RemoteNetworkProxyLaunchConfig>,
exec_server_env_config: Option<ExecServerEnvConfig>,
shell_snapshot: Option<codex_exec_server::ShellSnapshotRequest>,
windows_sandbox_proxy_settings_mode: codex_sandboxing::WindowsSandboxProxySettingsMode,
tty: bool,
environment: &codex_exec_server::Environment,
) -> Result<UnifiedExecProcess, ToolError> {
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
+1 -3
View File
@@ -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,
+1 -3
View File
@@ -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())
+24 -40
View File
@@ -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(
&params.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)))
}
+7 -2
View File
@@ -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(
&params.argv,
params.arg0.as_deref(),
&request.shell.name,
&request.shell.path,
)
});
let protected = proxy.is_some();
@@ -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<String, String>,
) -> 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<String, String>,
) -> 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<RwLock<CredentialBrokerState>>,
+1
View File
@@ -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;
+1
View File
@@ -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;
+43 -23
View File
@@ -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<WrappedSandboxCommand, SandboxTransformError> {
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))));
+15 -18
View File
@@ -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,