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