mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
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:
@@ -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,
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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)))
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
|
||||
|
||||
@@ -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>>,
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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))));
|
||||
|
||||
@@ -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,
|
||||
|
||||
Reference in New Issue
Block a user