feat(terminal-browser): support managed proxy sandbox

This commit is contained in:
Felipe Coury
2026-07-06 16:42:07 -03:00
parent 2046175b2c
commit 70d4255207
12 changed files with 524 additions and 28 deletions
+66 -14
View File
@@ -4,6 +4,7 @@ use std::path::Path;
use anyhow::Context;
use anyhow::Result;
use codex_network_proxy::ManagedNetworkSandboxContext;
use codex_protocol::config_types::WindowsSandboxLevel;
use codex_protocol::models::PermissionProfile;
use codex_protocol::permissions::FileSystemAccessMode;
@@ -13,8 +14,10 @@ use codex_protocol::permissions::FileSystemSandboxPolicy;
use codex_protocol::permissions::FileSystemSpecialPath;
use codex_protocol::permissions::NetworkSandboxPolicy;
use codex_sandboxing::SandboxCommand;
use codex_sandboxing::SandboxDirectSpawnRuntime;
use codex_sandboxing::SandboxDirectSpawnTransformRequest;
use codex_sandboxing::SandboxManager;
use codex_sandboxing::SandboxRuntimeProxyArgument;
use codex_sandboxing::SandboxTransformRequest;
use codex_sandboxing::SandboxType;
use codex_sandboxing::SandboxablePreference;
@@ -45,6 +48,13 @@ pub(crate) struct PreparedBrowserLaunch {
pub(crate) arg0: Option<String>,
}
#[derive(Debug, PartialEq, Eq)]
struct BrowserNetworkSandbox {
policy: NetworkSandboxPolicy,
enforce_managed_network: bool,
managed_network: Option<ManagedNetworkSandboxContext>,
}
pub(crate) fn prepare_browser_launch(
binary: &Path,
args: Vec<String>,
@@ -54,12 +64,6 @@ pub(crate) fn prepare_browser_launch(
network_policy: &BrowserNetworkPolicy,
context: &BrowserLaunchContext,
) -> Result<PreparedBrowserLaunch> {
if matches!(network_policy, BrowserNetworkPolicy::ManagedProxy { .. }) {
anyhow::bail!(
"managed terminal-browser networking is not yet supported because Carbonyl needs a loopback CDP listener that the current sandbox cannot permit without bypassing the managed proxy"
);
}
let binary = AbsolutePathBuf::from_absolute_path(binary)
.context("resolve Carbonyl executable path")?
.canonicalize()
@@ -70,15 +74,13 @@ pub(crate) fn prepare_browser_launch(
ensure_isolated_binary_root(&binary_root, browser_root, profile_root, context)?;
let file_system_policy =
browser_file_system_policy(browser_root, profile_root, &binary_root, &env)?;
let network_sandbox_policy = match network_policy {
BrowserNetworkPolicy::Disabled | BrowserNetworkPolicy::ManagedProxy { .. } => {
NetworkSandboxPolicy::Restricted
}
BrowserNetworkPolicy::Direct => NetworkSandboxPolicy::Enabled,
};
let BrowserNetworkSandbox {
policy: network_sandbox_policy,
enforce_managed_network,
managed_network,
} = browser_network_sandbox(network_policy)?;
let permissions =
PermissionProfile::from_runtime_permissions(&file_system_policy, network_sandbox_policy);
let enforce_managed_network = false;
let manager = SandboxManager::new();
let sandbox = manager.select_initial(
&file_system_policy,
@@ -100,7 +102,7 @@ pub(crate) fn prepare_browser_launch(
args,
cwd: browser_root_uri.clone(),
env,
managed_network: None,
managed_network,
additional_permissions: None,
},
permissions: &permissions,
@@ -119,6 +121,7 @@ pub(crate) fn prepare_browser_launch(
},
workspace_roots: &[],
windows_sandbox_proxy_settings_mode: WindowsSandboxProxySettingsMode::Reconcile,
runtime: browser_direct_spawn_runtime(network_policy),
})
.context("prepare Carbonyl sandbox")?;
#[cfg(target_os = "macos")]
@@ -157,6 +160,55 @@ pub(crate) fn prepare_browser_launch(
})
}
fn browser_direct_spawn_runtime(
network_policy: &BrowserNetworkPolicy,
) -> SandboxDirectSpawnRuntime {
let proxy_argument = match network_policy {
BrowserNetworkPolicy::ManagedProxy { .. } => {
SandboxRuntimeProxyArgument::RewriteFromHttpProxy {
argument_prefix: "--proxy-server=".to_string(),
}
}
BrowserNetworkPolicy::Disabled | BrowserNetworkPolicy::Direct => {
SandboxRuntimeProxyArgument::Unchanged
}
};
SandboxDirectSpawnRuntime { proxy_argument }
}
fn browser_network_sandbox(network_policy: &BrowserNetworkPolicy) -> Result<BrowserNetworkSandbox> {
match network_policy {
BrowserNetworkPolicy::Disabled => Ok(BrowserNetworkSandbox {
policy: NetworkSandboxPolicy::Restricted,
enforce_managed_network: false,
managed_network: None,
}),
BrowserNetworkPolicy::Direct => Ok(BrowserNetworkSandbox {
policy: NetworkSandboxPolicy::Enabled,
enforce_managed_network: false,
managed_network: None,
}),
BrowserNetworkPolicy::ManagedProxy { http_addr } => {
anyhow::ensure!(
http_addr.ip().is_loopback(),
"managed terminal-browser proxy must use a loopback address"
);
anyhow::ensure!(
http_addr.port() != 0,
"managed terminal-browser proxy must use a nonzero port"
);
Ok(BrowserNetworkSandbox {
policy: NetworkSandboxPolicy::Restricted,
enforce_managed_network: true,
managed_network: Some(ManagedNetworkSandboxContext {
loopback_ports: vec![http_addr.port()],
allow_local_binding: false,
}),
})
}
}
}
fn ensure_isolated_binary_root(
binary_root: &AbsolutePathBuf,
browser_root: &AbsolutePathBuf,
+103 -13
View File
@@ -1,13 +1,21 @@
use std::collections::HashMap;
use codex_network_proxy::ManagedNetworkSandboxContext;
use codex_protocol::permissions::FileSystemAccessMode;
use codex_protocol::permissions::NetworkSandboxPolicy;
use pretty_assertions::assert_eq;
use super::BrowserNetworkSandbox;
use super::browser_direct_spawn_runtime;
use super::browser_file_system_policy;
use super::browser_network_sandbox;
use super::ensure_isolated_binary_root;
#[cfg(target_os = "macos")]
use super::prepare_browser_launch;
use crate::network::BrowserNetworkPolicy;
use crate::sandbox::BrowserLaunchContext;
use codex_sandboxing::SandboxDirectSpawnRuntime;
use codex_sandboxing::SandboxRuntimeProxyArgument;
use codex_utils_absolute_path::AbsolutePathBuf;
#[test]
@@ -72,28 +80,110 @@ fn browser_policy_can_write_only_its_runtime_root() {
}
#[test]
fn managed_proxy_launches_fail_closed() {
fn managed_proxy_enforces_only_its_exact_loopback_port() {
let http_addr = "127.0.0.1:8080".parse().expect("proxy address");
assert_eq!(
browser_network_sandbox(&BrowserNetworkPolicy::ManagedProxy { http_addr })
.expect("managed proxy sandbox"),
BrowserNetworkSandbox {
policy: NetworkSandboxPolicy::Restricted,
enforce_managed_network: true,
managed_network: Some(ManagedNetworkSandboxContext {
loopback_ports: vec![8_080],
allow_local_binding: false,
}),
},
);
}
#[test]
fn carbonyl_direct_spawn_runtime_rewrites_only_managed_proxy() {
assert_eq!(
browser_direct_spawn_runtime(&BrowserNetworkPolicy::Direct),
SandboxDirectSpawnRuntime {
proxy_argument: SandboxRuntimeProxyArgument::Unchanged,
}
);
assert_eq!(
browser_direct_spawn_runtime(&BrowserNetworkPolicy::ManagedProxy {
http_addr: "127.0.0.1:43128".parse().expect("proxy address"),
}),
SandboxDirectSpawnRuntime {
proxy_argument: SandboxRuntimeProxyArgument::RewriteFromHttpProxy {
argument_prefix: "--proxy-server=".to_string(),
},
}
);
}
#[test]
fn direct_network_preserves_the_unrestricted_network_policy() {
assert_eq!(
browser_network_sandbox(&BrowserNetworkPolicy::Direct).expect("direct network sandbox"),
BrowserNetworkSandbox {
policy: NetworkSandboxPolicy::Enabled,
enforce_managed_network: false,
managed_network: None,
},
);
}
#[test]
fn managed_proxy_rejects_non_loopback_addresses() {
let http_addr = "192.0.2.10:8080".parse().expect("proxy address");
let error = browser_network_sandbox(&BrowserNetworkPolicy::ManagedProxy { http_addr })
.expect_err("non-loopback proxy must be rejected");
assert_eq!(
error.to_string(),
"managed terminal-browser proxy must use a loopback address"
);
}
#[test]
fn managed_proxy_rejects_port_zero() {
let http_addr = "127.0.0.1:0".parse().expect("proxy address");
let error = browser_network_sandbox(&BrowserNetworkPolicy::ManagedProxy { http_addr })
.expect_err("port-zero proxy must be rejected");
assert_eq!(
error.to_string(),
"managed terminal-browser proxy must use a nonzero port"
);
}
#[cfg(target_os = "macos")]
#[test]
fn prepared_managed_proxy_seatbelt_policy_grants_only_the_proxy_port() {
let root = tempfile::tempdir().expect("test root");
let root = AbsolutePathBuf::from_absolute_path(root.path()).expect("absolute test root");
let Err(error) = prepare_browser_launch(
root.join("carbonyl").as_path(),
let binary_root = root.join("carbonyl-bundle");
std::fs::create_dir_all(binary_root.as_path()).expect("create Carbonyl bundle");
let binary = binary_root.join("carbonyl");
std::fs::write(binary.as_path(), "test").expect("create Carbonyl binary");
let browser_root = root.join("runtime");
let launch = prepare_browser_launch(
binary.as_path(),
Vec::new(),
&root.join("runtime"),
&root.join("runtime/profile"),
&browser_root,
&browser_root.join("profile"),
HashMap::new(),
&BrowserNetworkPolicy::ManagedProxy {
http_addr: "127.0.0.1:8080".parse().expect("proxy address"),
},
&BrowserLaunchContext::default(),
) else {
panic!("managed proxy must be rejected");
};
)
.expect("prepare managed Carbonyl launch");
assert!(
error
.to_string()
.contains("without bypassing the managed proxy")
);
assert_eq!(launch.program, "/usr/bin/sandbox-exec");
assert_eq!(launch.args.first().map(String::as_str), Some("-p"));
let policy = launch.args.get(/*index*/ 1).expect("Seatbelt policy");
assert!(policy.contains("(allow network-outbound (remote ip \"localhost:8080\"))"));
assert!(!policy.contains("(allow network-bind (local ip \"*:*\"))"));
assert!(!policy.contains("(allow network-outbound)\n"));
}
#[test]