mirror of
https://github.com/openai/codex.git
synced 2026-11-16 22:00:36 +00:00
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:
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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"
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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
|
||||
```
|
||||
|
||||
@@ -845,28 +845,31 @@ impl ExecServerClient {
|
||||
}
|
||||
|
||||
pub async fn exec(&self, params: ExecParams) -> Result<ExecResponse, ExecServerError> {
|
||||
self.ensure_network_review_capability(¶ms).await?;
|
||||
self.ensure_network_proxy_capabilities(¶ms).await?;
|
||||
self.call(EXEC_METHOD, ¶ms).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(¶ms).await?;
|
||||
self.ensure_network_proxy_capabilities(¶ms).await?;
|
||||
let policy_decision_timeout_ms = params
|
||||
.network_proxy
|
||||
.as_ref()
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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(¶ms).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(¶ms).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(¶ms)
|
||||
.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()],
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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")]
|
||||
|
||||
@@ -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()],
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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!(
|
||||
|
||||
+1
-1
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user