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:
viyatb-oai
2026-11-19 00:17:19 +00:00
committed by copyberry
parent f7dece07d0
commit e1b7558492
17 changed files with 428 additions and 460 deletions
-1
View File
@@ -4989,7 +4989,6 @@ dependencies = [
"tempfile",
"tokio",
"tracing",
"url",
"which 8.0.0",
]
+39 -64
View File
@@ -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,
+2 -5
View File
@@ -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,
-2
View File
@@ -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,
-1
View File
@@ -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]
-21
View File
@@ -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() {
+32 -27
View File
@@ -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 => {
+195 -4
View File
@@ -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;
+24 -153
View File
@@ -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");
+39 -169
View File
@@ -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");
+2 -2
View File
@@ -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()))?;