Allow network policy to enable transparent TCP capture (#61851)

## What changed

- Add `transparent_tcp` to network configuration and managed requirements, defaulting to off. When enabled, route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy without requiring an executor startup flag.
- Propagate the setting through local and remote execution, require an enabled SOCKS5 proxy, and check the executor's `networkProxyTransparentTcp` capability before remote launches.
- Refresh the live proxy when switching between permission profiles with different network settings.

## Testing

Add coverage for configuration-driven sandbox capture, rejection of unsupported launch contexts, execution parameter propagation, and live permission profile changes.

GitOrigin-RevId: c4db87056de116f433a128806bef673802f35397
This commit is contained in:
viyatb-oai
2026-11-16 18:19:16 +00:00
committed by copyberry
parent fef47a6769
commit effad7568c
29 changed files with 312 additions and 39 deletions
+12 -5
View File
@@ -307,12 +307,19 @@ async fn run_command_under_sandbox(
config.effective_local_windows_sandbox_type()
};
let transparent_tcp = matches!(
sandbox_type,
SandboxType::Landlock {
transparent_tcp: true
let transparent_tcp = match sandbox_type {
SandboxType::Landlock { transparent_tcp } => {
transparent_tcp
|| config
.permissions
.network
.as_ref()
.is_some_and(codex_core::config::NetworkProxySpec::transparent_tcp)
}
);
#[cfg(target_os = "macos")]
SandboxType::Seatbelt => false,
SandboxType::Windows => false,
};
let sandbox = match permission_profile.enforcement() {
SandboxEnforcement::Disabled | SandboxEnforcement::External if transparent_tcp => {
anyhow::bail!("--transparent-tcp requires a managed Linux sandbox");
@@ -451,6 +451,8 @@ pub struct NetworkRequirementsToml {
pub http_port: Option<u16>,
pub socks_port: Option<u16>,
pub allow_upstream_proxy: Option<bool>,
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
pub transparent_tcp: Option<bool>,
pub dangerously_allow_non_loopback_proxy: Option<bool>,
pub dangerously_allow_all_unix_sockets: Option<bool>,
pub domains: Option<NetworkDomainPermissionsToml>,
@@ -532,6 +534,7 @@ struct RawNetworkRequirementsToml {
http_port: Option<u16>,
socks_port: Option<u16>,
allow_upstream_proxy: Option<bool>,
transparent_tcp: Option<bool>,
dangerously_allow_non_loopback_proxy: Option<bool>,
dangerously_allow_all_unix_sockets: Option<bool>,
domains: Option<NetworkDomainPermissionsToml>,
@@ -561,6 +564,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml {
http_port,
socks_port,
allow_upstream_proxy,
transparent_tcp,
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains,
@@ -591,6 +595,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml {
http_port,
socks_port,
allow_upstream_proxy,
transparent_tcp,
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains: domains
@@ -644,6 +649,8 @@ pub struct NetworkConstraints {
pub http_port: Option<u16>,
pub socks_port: Option<u16>,
pub allow_upstream_proxy: Option<bool>,
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
pub transparent_tcp: Option<bool>,
pub dangerously_allow_non_loopback_proxy: Option<bool>,
pub dangerously_allow_all_unix_sockets: Option<bool>,
pub domains: Option<NetworkDomainPermissionsToml>,
@@ -673,6 +680,7 @@ impl From<NetworkRequirementsToml> for NetworkConstraints {
http_port,
socks_port,
allow_upstream_proxy,
transparent_tcp,
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains,
@@ -687,6 +695,7 @@ impl From<NetworkRequirementsToml> for NetworkConstraints {
http_port,
socks_port,
allow_upstream_proxy,
transparent_tcp,
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains,
@@ -5080,6 +5089,7 @@ command = "python3 /enterprise/hooks/pre.py"
[permissions.network]
enabled = true
allow_upstream_proxy = false
transparent_tcp = true
dangerously_allow_all_unix_sockets = true
managed_allowed_domains_only = true
allow_local_binding = false
@@ -5114,6 +5124,7 @@ command = "python3 /enterprise/hooks/pre.py"
assert_eq!(sourced_network.source, source);
assert_eq!(sourced_network.value.enabled, Some(true));
assert_eq!(sourced_network.value.transparent_tcp, Some(true));
assert_eq!(sourced_network.value.allow_upstream_proxy, Some(false));
assert_eq!(
sourced_network.value.dangerously_allow_all_unix_sockets,
+5
View File
@@ -331,6 +331,8 @@ pub struct NetworkToml {
pub enabled: Option<bool>,
pub proxy_url: Option<String>,
pub enable_socks5: Option<bool>,
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
pub transparent_tcp: Option<bool>,
pub socks_url: Option<String>,
pub enable_socks5_udp: Option<bool>,
pub allow_upstream_proxy: Option<bool>,
@@ -543,6 +545,9 @@ impl NetworkToml {
if let Some(proxy_url) = self.proxy_url.as_ref() {
config.proxy_url = proxy_url.clone();
}
if let Some(transparent_tcp) = self.transparent_tcp {
config.transparent_tcp = transparent_tcp;
}
if let Some(enable_socks5) = self.enable_socks5 {
config.enable_socks5 = enable_socks5;
}
+8
View File
@@ -3709,6 +3709,10 @@
"socks_url": {
"type": "string"
},
"transparent_tcp": {
"description": "Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.",
"type": "boolean"
},
"unix_sockets": {
"additionalProperties": {
"$ref": "#/definitions/NetworkProxyUnixSocketPermissionToml"
@@ -3779,6 +3783,10 @@
"socks_url": {
"type": "string"
},
"transparent_tcp": {
"description": "Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.",
"type": "boolean"
},
"unix_sockets": {
"$ref": "#/definitions/NetworkUnixSocketPermissionsToml"
}
+2
View File
@@ -1668,6 +1668,7 @@ description = "Day-to-day workspace access."
enabled = true
proxy_url = "http://127.0.0.1:43128"
enable_socks5 = false
transparent_tcp = false
allow_upstream_proxy = false
mode = "full"
@@ -1722,6 +1723,7 @@ strip_request_headers = ["authorization"]
]),
}),
network: Some(NetworkToml {
transparent_tcp: Some(false),
enabled: Some(true),
proxy_url: Some("http://127.0.0.1:43128".to_string()),
enable_socks5: Some(false),
@@ -112,6 +112,10 @@ impl NetworkProxySpec {
host_and_port_from_network_addr(&self.config.proxy_url, /*default_port*/ 3128)
}
pub fn transparent_tcp(&self) -> bool {
self.config.transparent_tcp
}
pub fn socks_enabled(&self) -> bool {
self.config.enable_socks5
}
@@ -546,6 +550,9 @@ impl NetworkProxySpec {
if let Some(socks_port) = requirements.socks_port {
config.socks_url = format!("http://127.0.0.1:{socks_port}");
}
if let Some(transparent_tcp) = requirements.transparent_tcp {
config.transparent_tcp = transparent_tcp;
}
if let Some(allow_upstream_proxy) = requirements.allow_upstream_proxy {
config.allow_upstream_proxy = allow_upstream_proxy;
constraints.allow_upstream_proxy = Some(allow_upstream_proxy);
+1
View File
@@ -163,6 +163,7 @@ pub(crate) fn apply_network_proxy_feature_config(
enabled: feature_config.enabled,
proxy_url: feature_config.proxy_url.clone(),
enable_socks5: feature_config.enable_socks5,
transparent_tcp: feature_config.transparent_tcp,
socks_url: feature_config.socks_url.clone(),
enable_socks5_udp: feature_config.enable_socks5_udp,
allow_upstream_proxy: feature_config.allow_upstream_proxy,
+8 -7
View File
@@ -2182,7 +2182,7 @@ impl Session {
commit,
previous_config,
new_config,
permission_profile_changed,
refresh_network_proxy,
mcp_inputs_changed,
credential_masking_warning,
) = {
@@ -2218,10 +2218,11 @@ impl Session {
});
let previous_config = notify_config_contributors
.then(|| self.build_effective_session_config(&state.session_configuration));
let previous_permission_profile = state.session_configuration.permission_profile();
let updated_permission_profile = updated.permission_profile();
let permission_profile_changed =
previous_permission_profile != updated_permission_profile;
let current = &state.session_configuration;
let refresh_network_proxy = current.permission_profile()
!= updated.permission_profile()
|| current.original_config_do_not_use.permissions.network
!= updated.original_config_do_not_use.permissions.network;
let root_service_tier_changed = updated.parent_thread_id.is_none()
&& state.session_configuration.step_settings.service_tier
!= updated.step_settings.service_tier;
@@ -2281,7 +2282,7 @@ impl Session {
commit,
previous_config,
new_config,
permission_profile_changed,
refresh_network_proxy,
mcp_inputs_changed,
credential_masking_warning,
)
@@ -2294,7 +2295,7 @@ impl Session {
);
}
self.emit_config_changed_contributors(previous_config.as_ref(), new_config.as_ref());
if permission_profile_changed {
if refresh_network_proxy {
self.refresh_managed_network_proxy_for_current_permission_profile()
.await;
}
+40
View File
@@ -1330,6 +1330,46 @@ async fn new_turn_refreshes_managed_network_proxy_for_sandbox_change() -> anyhow
Ok(())
}
#[tokio::test]
async fn switching_profiles_updates_live_transparent_tcp() -> anyhow::Result<()> {
let home = tempfile::tempdir()?;
std::fs::write(
home.path().join(codex_config::CONFIG_TOML_FILE),
r#"
default_permissions = "explicit"
features.network_proxy = true
[permissions.explicit]
extends = ":workspace"
network.enabled = true
[permissions.capture]
extends = "explicit"
network.transparent_tcp = true
"#,
)?;
let config = build_test_config(home.path()).await;
let permissions = config.permissions.permission_profile().clone();
let session = make_session_with_config(|current| *current = config).await?;
let proxy = session
.services
.network_proxy
.load_full()
.expect("live proxy");
for (profile, capture) in [("capture", true), ("explicit", false)] {
session
.update_settings(SessionSettingsUpdate {
permission_profile: Some(permissions.clone()),
active_permission_profile: Some(ActivePermissionProfile::new(profile)),
..Default::default()
})
.await?;
let prepared = proxy
.proxy()
.prepare_for_optional_environment(HashMap::new(), /*environment_id*/ None)?;
assert_eq!(prepared.sandbox_context.transparent_tcp, capture);
}
Ok(())
}
#[tokio::test]
async fn refresh_clears_disabled_managed_network_proxy() -> anyhow::Result<()> {
let permission_profile = PermissionProfile::workspace_write();
@@ -230,7 +230,7 @@ fn exec_server_params_for_request(
// Threads sharing an executor and sandbox retries can reuse a public handle
// while the executor still retains its previous process.
let exec_server_process_id = format!("{process_id}-{}", Uuid::new_v4());
codex_exec_server::ExecParams {
let mut params = codex_exec_server::ExecParams {
process_id: exec_server_process_id.into(),
metadata: tool_ctx.map(|ctx| codex_exec_server::ExecMetadata {
thread_id: Some(ctx.session.thread_id()),
@@ -248,7 +248,16 @@ fn exec_server_params_for_request(
enforce_managed_network: request.exec_server_enforce_managed_network,
managed_network: request.exec_server_managed_network.clone(),
network_proxy: request.exec_server_network_proxy.clone(),
};
let sandboxed = params.sandbox.is_some();
// A prepared context uses the local sandbox. A remote proxy uses the executor's OS.
if let Some(local) = &mut params.managed_network {
local.transparent_tcp &= sandboxed && cfg!(target_os = "linux");
}
if let Some(remote) = &mut params.network_proxy {
remote.proxy.transparent_tcp &= sandboxed;
}
params
}
/// Borrowed process state prepared for a `write_stdin` or poll operation.
@@ -4,6 +4,9 @@ use crate::tools::handlers::unified_exec::preparation::ParsedExecCommand;
use crate::unified_exec::clamp_yield_time;
use codex_exec_server::ExecOutputStream;
use codex_network_proxy::ManagedNetworkSandboxContext;
use codex_network_proxy::NetworkProxyConfig;
use codex_network_proxy::RemoteNetworkProxyConfig;
use codex_network_proxy::RemoteNetworkProxyLaunchConfig;
use core_test_support::assert_regex_match;
use pretty_assertions::assert_eq;
use tokio::sync::Notify;
@@ -182,6 +185,7 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() {
let managed_network = ManagedNetworkSandboxContext {
loopback_ports: vec![43123],
allow_local_binding: false,
transparent_tcp: true,
..Default::default()
};
let mut request = ExecRequest {
@@ -261,7 +265,13 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() {
assert_eq!(params.metadata, None);
assert_eq!(params.cwd, request.cwd);
assert!(params.enforce_managed_network);
assert_eq!(params.managed_network, Some(managed_network));
assert_eq!(
params.managed_network,
Some(ManagedNetworkSandboxContext {
transparent_tcp: false,
..managed_network
})
);
assert!(params.env_policy.is_some());
assert_eq!(
params.env,
@@ -285,8 +295,6 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() {
let mut snapshot_env = params.env;
snapshot_env.remove("PATH");
assert_eq!(params_for_request(&request).env, snapshot_env);
request.exec_server_shell_snapshot = None;
request.exec_server_sandbox = Some(
codex_exec_server::FileSystemSandboxContext::from_permission_profile(
permission_profile,
@@ -295,6 +303,7 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() {
);
let first = params_for_request(&request);
let second = params_for_request(&request);
assert_eq!(first.requests_transparent_tcp(), cfg!(target_os = "linux"));
assert_eq!(
first
.sandbox
@@ -305,6 +314,22 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() {
assert!(first.process_id.as_str().starts_with("123-"));
assert!(second.process_id.as_str().starts_with("123-"));
assert_ne!(first.process_id, second.process_id);
request.exec_server_shell_snapshot = None;
request.exec_server_managed_network = None;
request.exec_server_network_proxy = Some(RemoteNetworkProxyLaunchConfig::new(
RemoteNetworkProxyConfig::from_effective_config(&NetworkProxyConfig {
enabled: true,
transparent_tcp: true,
..Default::default()
})
.unwrap(),
));
assert!(params_for_request(&request).requests_transparent_tcp());
request.exec_server_sandbox = None;
let proxy = params_for_request(&request).network_proxy.unwrap().proxy;
assert!(proxy.enabled);
assert!(!proxy.transparent_tcp);
}
#[cfg(windows)]
@@ -158,6 +158,9 @@ pub struct EnvironmentCapabilities {
/// Whether executor proxies enforce managed review domains before ordinary allows.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub network_proxy_review_domains: bool,
/// Whether the executor can capture TCP for a managed Linux sandbox launch.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub network_proxy_transparent_tcp: bool,
/// Whether the selected shell can mask executor environment credentials.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
credential_masking: bool,
@@ -323,6 +326,7 @@ impl EnvironmentInfo {
capabilities: EnvironmentCapabilities {
network_proxy_launch: true,
network_proxy_review_domains: true,
network_proxy_transparent_tcp: cfg!(target_os = "linux"),
credential_masking,
credential_masking_custom_providers: credential_masking,
capability_discovery_sandbox: true,
@@ -413,6 +417,18 @@ pub struct ExecParams {
pub network_proxy: Option<RemoteNetworkProxyLaunchConfig>,
}
impl ExecParams {
pub fn requests_transparent_tcp(&self) -> bool {
self.network_proxy
.as_ref()
.is_some_and(|launch| launch.proxy.transparent_tcp)
|| self
.managed_network
.as_ref()
.is_some_and(|ctx| ctx.transparent_tcp)
}
}
/// Executor ingress for process requests from clients that may omit the sandbox policy cwd.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
@@ -1408,6 +1424,7 @@ mod tests {
sandbox: None,
enforce_managed_network: true,
managed_network: Some(ManagedNetworkSandboxContext {
transparent_tcp: false,
loopback_ports: vec![43123, 48081],
allow_local_binding: false,
allow_unix_sockets: vec!["/tmp/allowed.sock".to_string()],
@@ -1540,6 +1557,7 @@ mod tests {
sandbox: None,
enforce_managed_network: true,
managed_network: Some(ManagedNetworkSandboxContext {
transparent_tcp: false,
loopback_ports: vec![43123],
allow_local_binding: true,
allow_unix_sockets: Vec::new(),
@@ -1590,6 +1608,7 @@ mod tests {
EnvironmentCapabilities {
network_proxy_launch: true,
network_proxy_review_domains: false,
network_proxy_transparent_tcp: false,
credential_masking: false,
credential_masking_custom_providers: false,
capability_discovery_sandbox: true,
+8
View File
@@ -539,6 +539,14 @@ upstream proxy is returned as an error, without retrying directly.
### Transparent TCP
In managed `requirements.toml`, set `enabled = true` and `transparent_tcp = true` in the
network policy table you already use (`[permissions.network]`, `[network_proxy]`, or
`[experimental_network]`). Use one table. Managed SOCKS5 must be enabled.
Capture defaults to off. When requested through configuration, the controller requires a Linux
executor advertising `networkProxyTransparentTcp`. If the sandbox cannot open or configure
`/dev/net/tun`, the launch fails before the command runs. To opt in at executor startup:
```sh
codex exec-server --linux-sandbox-transparent-tcp --tcp-upstream-proxy proxy:8088
```
+16 -13
View File
@@ -845,28 +845,31 @@ impl ExecServerClient {
}
pub async fn exec(&self, params: ExecParams) -> Result<ExecResponse, ExecServerError> {
self.ensure_network_review_capability(&params).await?;
self.ensure_network_proxy_capabilities(&params).await?;
self.call(EXEC_METHOD, &params).await
}
async fn ensure_network_review_capability(
async fn ensure_network_proxy_capabilities(
&self,
params: &ExecParams,
) -> Result<(), ExecServerError> {
if params
.network_proxy
.as_ref()
.is_some_and(|launch| !launch.proxy.review_domains.is_empty())
&& !self
.environment_info()
.await?
.capabilities
.network_proxy_review_domains
{
let proxy = params.network_proxy.as_ref().map(|launch| &launch.proxy);
let needs_review = proxy.is_some_and(|proxy| !proxy.review_domains.is_empty());
let needs_capture = params.requests_transparent_tcp();
if !needs_review && !needs_capture {
return Ok(());
}
let info = self.environment_info().await?;
if needs_review && !info.capabilities.network_proxy_review_domains {
return Err(ExecServerError::Protocol(
"selected exec-server does not support managed network review domains".to_string(),
));
}
if needs_capture && !info.capabilities.network_proxy_transparent_tcp {
return Err(ExecServerError::Protocol(
"selected exec-server does not support transparent TCP".to_string(),
));
}
Ok(())
}
@@ -1144,7 +1147,7 @@ impl ExecServerClient {
params: ExecParams,
network_policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,
) -> Result<Session, ExecServerError> {
self.ensure_network_review_capability(&params).await?;
self.ensure_network_proxy_capabilities(&params).await?;
let policy_decision_timeout_ms = params
.network_proxy
.as_ref()
+12
View File
@@ -568,6 +568,18 @@ impl LocalProcess {
params: ExecParams,
telemetry: ProcessTelemetry,
) -> Result<ExecResponse, JSONRPCErrorError> {
// RPC callers must obtain capture from a proxy started by this executor.
// In-process launches can reuse the controller's own managed listener.
if params.requests_transparent_tcp()
&& !params
.network_proxy
.as_ref()
.is_some_and(|launch| launch.proxy.transparent_tcp)
{
return Err(invalid_params(
"transparent TCP requires an executor-local managed proxy".into(),
));
}
self.start_process(params, telemetry)
.await
.map(|(response, _, _)| response)
+9 -2
View File
@@ -115,6 +115,12 @@ pub(crate) async fn prepare_exec_request_with_telemetry(
credential_brokers: &RemoteCredentialBrokerCache,
telemetry: &ProcessTelemetry,
) -> Result<PreparedExecRequest, JSONRPCErrorError> {
let transparent_tcp = params.requests_transparent_tcp();
if transparent_tcp && (!cfg!(target_os = "linux") || params.sandbox.is_none()) {
return Err(invalid_params(
"transparent TCP requires a managed Linux sandbox".into(),
));
}
if let Some(sandbox) = params.sandbox.as_ref()
&& sandbox.windows_sandbox_selection == WindowsSandboxSelection::Mxc
{
@@ -187,6 +193,7 @@ pub(crate) async fn prepare_exec_request_with_telemetry(
#[cfg(target_os = "macos")]
let sandbox_manager = sandbox_manager
.with_allowed_symlinked_codex_home(runtime_paths.allowed_symlinked_codex_home.clone());
let enforce_managed_network = params.enforce_managed_network || transparent_tcp;
let (selection, windows_sandbox_level) = sandbox_selection(sandbox_context);
let (program, args) = params
.argv
@@ -240,7 +247,7 @@ pub(crate) async fn prepare_exec_request_with_telemetry(
workspace_roots: Some(&sandbox_context.workspace_roots),
runtime_readable_paths: &runtime_readable_paths,
selection,
enforce_managed_network: params.enforce_managed_network,
enforce_managed_network,
environment_id: None,
network: None,
sandbox_policy_cwd: &sandbox_context.cwd,
@@ -270,7 +277,7 @@ pub(crate) async fn prepare_exec_request_with_telemetry(
.map(|root| native_path(root, "sandbox workspace root"))
.collect::<Result<_, _>>()?;
request.arg0 = params.arg0.clone();
let proxy_enforced = params.enforce_managed_network;
let proxy_enforced = enforce_managed_network;
let filesystem_overrides = WindowsSandboxFilesystemOverrides::resolve(
request.sandbox,
&permissions,
@@ -6,7 +6,7 @@ use std::time::Duration;
use codex_exec_server_protocol::JSONRPCErrorError;
#[cfg(unix)]
use codex_file_system::WindowsSandboxSelection;
#[cfg(target_os = "macos")]
#[cfg(any(target_os = "macos", target_os = "linux"))]
use codex_network_proxy::ManagedNetworkSandboxContext;
use codex_network_proxy::NetworkPolicyAuditObserver;
use codex_network_proxy::NetworkPolicyDecider;
@@ -245,7 +245,7 @@ async fn sandbox_request_routes_custom_arg0_to_inner_helper() {
assert_eq!(prepared.arg0, None);
}
#[cfg(target_os = "macos")]
#[cfg(any(target_os = "macos", target_os = "linux"))]
fn managed_network_sandbox_request() -> (ExecParams, ExecServerRuntimeOptions) {
let cwd: AbsolutePathBuf = std::env::current_dir()
.expect("current directory")
@@ -278,6 +278,70 @@ fn managed_network_sandbox_request() -> (ExecParams, ExecServerRuntimeOptions) {
(params, runtime_paths)
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn proxy_config_selects_transparent_tcp_without_executor_switch() {
let (mut params, runtime_paths) = managed_network_sandbox_request();
params.enforce_managed_network = false;
let prepare = async |params: &ExecParams| {
prepare_exec_request(
params,
HashMap::new(),
Some(&runtime_paths),
/*network_policy_decider*/ None,
/*network_policy_audit_observer*/ None,
)
.await
};
for (toml, expected) in [
("enabled = true", false),
("enabled = true\ntransparent_tcp = true", true),
] {
let network: codex_config::permissions_toml::NetworkToml = toml::from_str(toml).unwrap();
params.network_proxy = Some(RemoteNetworkProxyLaunchConfig::new(
RemoteNetworkProxyConfig::from_effective_config(&network.to_network_proxy_config())
.unwrap(),
));
let prepared = prepare(&params).await.unwrap();
assert_eq!(
prepared
.command
.iter()
.any(|arg| arg == "--transparent-tcp"),
expected,
"{toml}"
);
prepared
.network_proxy_handle
.unwrap()
.shutdown()
.await
.unwrap();
}
params.network_proxy = None;
params.managed_network = Some(ManagedNetworkSandboxContext {
transparent_tcp: true,
..Default::default()
});
let local = prepare(&params).await.unwrap();
assert!(local.command.iter().any(|arg| arg == "--transparent-tcp"));
let remote = crate::local_process::LocalProcess::default()
.exec(params.clone(), ProcessTelemetry::default())
.await
.unwrap_err();
assert!(
remote
.message
.contains("requires an executor-local managed proxy")
);
params.sandbox = None;
let err = prepare(&params)
.await
.err()
.expect("cannot honor capture on a native launch");
assert!(err.message.contains("requires a managed Linux sandbox"));
}
#[cfg(target_os = "macos")]
fn seatbelt_policy_arg(command: &[String]) -> &str {
command
@@ -299,6 +363,7 @@ async fn sandbox_request_preserves_prepared_managed_network_policy() {
.to_string_lossy()
.into_owned();
params.managed_network = Some(ManagedNetworkSandboxContext {
transparent_tcp: false,
loopback_ports: vec![43123],
allow_local_binding: false,
allow_unix_sockets: vec![allowed_socket.clone()],
+8 -2
View File
@@ -525,6 +525,11 @@ async fn shell_snapshot_v2_remote_managed_proxy_uses_prepared_execution_context(
const REQUEST_GH_TOKEN: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
const VENDOR_TOKEN: &str = "vendor_abcdefgh";
const CUSTOM_HOST: &str = "chatgpt.com";
// Sanitizing the 256 profile aliases can take longer on emulated executors.
let startup_timeout = match credential_startup {
CredentialStartup::Profile => Duration::from_secs(90),
_ => Duration::from_secs(30),
};
let configured_provider = shell_name == "bash" && shell_args.first() == Some(&"-c");
let shell_path = format!("/bin/{shell_name}");
if shell_name == "zsh" && !std::path::Path::new(&shell_path).exists() {
@@ -802,7 +807,7 @@ async fn shell_snapshot_v2_remote_managed_proxy_uses_prepared_execution_context(
command
};
let started = timeout(
Duration::from_secs(30),
startup_timeout,
backend.start(ExecParams {
metadata: Default::default(),
process_id: ProcessId::from(format!("managed-snapshot-{attempt}")),
@@ -836,7 +841,8 @@ async fn shell_snapshot_v2_remote_managed_proxy_uses_prepared_execution_context(
),
}),
)
.await??;
.await
.context("timed out starting shell snapshot process")??;
let (stdout, stderr, status, closed) =
collect_process_output_from_events(started.process).await?;
let expected_stderr = if expect_snapshot_fallback {
+3
View File
@@ -579,6 +579,9 @@ pub struct NetworkProxyConfigToml {
pub proxy_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_socks5: Option<bool>,
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
#[serde(skip_serializing_if = "Option::is_none")]
pub transparent_tcp: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub socks_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
+1 -1
View File
@@ -23,7 +23,7 @@ The Rust sandbox helper includes the TCP stack. Codex starts it automatically.
The Linux host needs distro `bwrap` on `PATH`, user and network namespaces, IPv6,
and read/write access to `/dev/net/tun`.
Use full managed SOCKS5 mode for native database ports and an isolated PID namespace.
For executor-wide capture and HTTP CONNECT routing, see the [exec-server setup](../exec-server/README.md#transparent-tcp).
For proxy configuration, executor-wide capture and HTTP CONNECT routing, see the [exec-server setup](../exec-server/README.md#transparent-tcp).
The private DNS stub maps up to 8,192 names to stable addresses in `198.18.0.0/15`
and `fdc0:de00::/96`. The relay sends the original name and port to the attributed proxy;
@@ -506,6 +506,7 @@ fn managed_proxy_inner_command_includes_route_spec() {
for managed_network in [
ManagedNetworkSandboxContext::default(),
ManagedNetworkSandboxContext {
transparent_tcp: false,
loopback_ports: vec![8080, 9090],
allow_local_binding: true,
allow_unix_sockets: vec!["/tmp/daemon.sock".to_string()],
+5
View File
@@ -137,6 +137,9 @@ pub struct NetworkProxyConfig {
#[serde(default = "default_proxy_url")]
pub proxy_url: String,
pub enable_socks5: bool,
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub transparent_tcp: bool,
#[serde(default = "default_socks_url")]
pub socks_url: String,
pub enable_socks5_udp: bool,
@@ -188,6 +191,7 @@ impl Default for NetworkProxyConfig {
enabled: false,
proxy_url: default_proxy_url(),
enable_socks5: true,
transparent_tcp: false,
socks_url: default_socks_url(),
enable_socks5_udp: true,
allow_upstream_proxy: true,
@@ -750,6 +754,7 @@ mod tests {
assert_eq!(
NetworkProxyConfig::default(),
NetworkProxyConfig {
transparent_tcp: false,
enabled: false,
proxy_url: "http://127.0.0.1:3128".to_string(),
enable_socks5: true,
@@ -16,6 +16,9 @@ pub struct EnvironmentNetworkPolicy {
/// False or omission leaves activation to the controller and command permissions.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub requires_proxy: bool,
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub transparent_tcp: bool,
pub domains: Option<NetworkDomainPermissions>,
/// Managed host selectors inherited by every execution in this environment.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
@@ -33,6 +36,7 @@ impl EnvironmentNetworkPolicy {
pub fn from_config(config: &NetworkProxyConfig, managed_allowed_domains_only: bool) -> Self {
Self {
requires_proxy: config.enabled,
transparent_tcp: config.transparent_tcp,
domains: config.domains.clone(),
review_domains: config.review_domains.clone(),
unix_sockets: config.unix_sockets.clone(),
@@ -47,6 +51,7 @@ impl EnvironmentNetworkPolicy {
/// Applies attachment-owned traffic settings while preserving inherited denials and proxy setup.
pub fn apply_to(&self, config: &mut NetworkProxyConfig) {
config.transparent_tcp |= self.transparent_tcp;
// Neither owner nor controller may remove the other's review selectors.
for pattern in &self.review_domains {
if !config
+7
View File
@@ -442,6 +442,7 @@ fn reserve_loopback_ephemeral_listener() -> Result<StdTcpListener> {
#[derive(Debug, Clone, PartialEq, Eq)]
struct NetworkProxyRuntimeSettings {
transparent_tcp: bool,
allow_local_binding: bool,
allow_unix_sockets: Arc<[String]>,
dangerously_allow_all_unix_sockets: bool,
@@ -463,6 +464,7 @@ impl NetworkProxyRuntimeSettings {
None
};
Ok(Self {
transparent_tcp: config.transparent_tcp,
allow_local_binding: config.allow_local_binding(),
allow_unix_sockets: if cfg!(target_os = "windows") {
Arc::default()
@@ -486,6 +488,9 @@ struct EnvironmentProxyAddrs {
#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ManagedNetworkSandboxContext {
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub transparent_tcp: bool,
/// Loopback proxy ports that sandboxed commands may connect to.
#[serde(default)]
pub loopback_ports: Vec<u16>,
@@ -1272,6 +1277,7 @@ impl NetworkProxy {
env,
sandbox_context: ManagedNetworkSandboxContext {
loopback_ports,
transparent_tcp: runtime_settings.transparent_tcp,
allow_local_binding: runtime_settings.allow_local_binding,
allow_unix_sockets: runtime_settings.allow_unix_sockets.to_vec(),
dangerously_allow_all_unix_sockets: runtime_settings
@@ -2383,6 +2389,7 @@ mod tests {
assert_eq!(
prepared.sandbox_context,
ManagedNetworkSandboxContext {
transparent_tcp: false,
loopback_ports: vec![43128, 48081],
allow_local_binding: true,
allow_unix_sockets: if cfg!(target_os = "windows") {
@@ -179,6 +179,9 @@ pub struct RemoteNetworkProxyConfig {
)]
credential_masking: CredentialMaskingConfig,
pub enable_socks5: bool,
/// Route outbound TCP from managed Linux sandbox commands through the managed SOCKS5 proxy.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub transparent_tcp: bool,
pub enable_socks5_udp: bool,
pub allow_upstream_proxy: bool,
pub dangerously_allow_all_unix_sockets: bool,
@@ -206,6 +209,7 @@ impl RemoteNetworkProxyConfig {
enabled: config.enabled,
credential_masking: CredentialMaskingConfig::default(),
enable_socks5: config.enable_socks5,
transparent_tcp: config.transparent_tcp,
enable_socks5_udp: config.enable_socks5_udp,
allow_upstream_proxy: config.allow_upstream_proxy,
dangerously_allow_all_unix_sockets: config
@@ -239,6 +243,7 @@ impl RemoteNetworkProxyConfig {
let mut config = NetworkProxyConfig {
enabled: self.enabled,
enable_socks5: self.enable_socks5,
transparent_tcp: self.transparent_tcp,
enable_socks5_udp: self.enable_socks5_udp,
allow_upstream_proxy: self.allow_upstream_proxy,
dangerously_allow_all_unix_sockets: Some(self.dangerously_allow_all_unix_sockets),
+4
View File
@@ -78,6 +78,10 @@ pub fn build_config_state(
if brokerage_created_default_allowlist {
config.set_allowed_domains(vec!["*".to_string()]);
}
anyhow::ensure!(
!config.transparent_tcp || (config.enabled && config.enable_socks5),
"transparent_tcp requires an enabled managed SOCKS5 proxy"
);
crate::config::validate_unix_socket_allowlist_paths(&config, executor_os)?;
anyhow::ensure!(
!config.credential_broker || config.mitm,
+3 -1
View File
@@ -669,7 +669,9 @@ impl SandboxManager {
if self.linux_sandbox_pid_namespace == LinuxSandboxPidNamespace::Inherit {
args.insert(0, "--inherit-pid-namespace".to_owned());
}
if self.linux_sandbox_transparent_tcp && managed_network.is_some() {
if managed_network
.is_some_and(|ctx| ctx.transparent_tcp || self.linux_sandbox_transparent_tcp)
{
args.insert(0, "--transparent-tcp".to_owned());
}
exec.command = std::iter::once(program).chain(args).collect();
+6 -1
View File
@@ -551,6 +551,7 @@ fn format_network_constraints(network: &NetworkConstraints) -> String {
enabled,
http_port,
socks_port,
transparent_tcp,
allow_upstream_proxy,
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
@@ -571,6 +572,9 @@ fn format_network_constraints(network: &NetworkConstraints) -> String {
if let Some(socks_port) = socks_port {
parts.push(format!("socks_port={socks_port}"));
}
if let Some(transparent_tcp) = transparent_tcp {
parts.push(format!("transparent_tcp={transparent_tcp}"));
}
if let Some(allow_upstream_proxy) = allow_upstream_proxy {
parts.push(format!("allow_upstream_proxy={allow_upstream_proxy}"));
}
@@ -903,6 +907,7 @@ interrupt_message = false
network: Some(Sourced::new(
NetworkConstraints {
enabled: Some(true),
transparent_tcp: Some(true),
domains: Some(NetworkDomainPermissionsToml {
entries: BTreeMap::from([(
"example.com".to_string(),
@@ -1053,7 +1058,7 @@ interrupt_message = false
"enforce_residency: us (source: {requirements_source})"
)));
assert!(rendered.contains(&format!(
"network_proxy: enabled=true, domains={{example.com=allow}}, review_domains={{api.example.com}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})"
"network_proxy: enabled=true, transparent_tcp=true, domains={{example.com=allow}}, review_domains={{api.example.com}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})"
)));
assert!(!rendered.contains("secret-looking-value"));
assert!(
@@ -24,5 +24,5 @@ Requirements:
- guardian_policy_config: configured (source: MDM managed_config.toml (legacy))
- features: guardian_approval=true (source: MDM managed_config.toml (legacy))
- enforce_residency: us (source: MDM managed_config.toml (legacy))
- network_proxy: enabled=true, domains={example.com=allow}, review_domains={api.example.com}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy))
- network_proxy: enabled=true, transparent_tcp=true, domains={example.com=allow}, review_domains={api.example.com}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy))
- permissions.filesystem.deny_read: /home/alice/.gitconfig (source: /etc/codex/requirements.toml)