mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
Tie Linux sandbox proxy bridges to the launcher lifetime (#61898)
## Why Host proxy bridges must close active connections when a sandbox exits or is cancelled. Proxy descriptor exhaustion must also leave synthetic mount cleanup able to run. ## What changed - Run host proxy bridges as threads in an outer supervisor that forwards signals and preserves the sandbox command's exit status. Use parent-death signals to terminate supervised children when their parent exits. - Give bridge routes private descriptor tables where supported, retry accepts after descriptor exhaustion, and keep mount cleanup in a separate supervisor. - Create the transparent TCP namespace in the bubblewrap child after re-executing the sandbox helper, clearing inherited credentials from memory and restoring dumpability for user namespace ID mapping. ## Testing Add regression tests for bridge teardown after normal exit, process-group cancellation, launcher termination, and caller-thread exit; exit status propagation with inherited `SIGCHLD` ignored; and SOCKS connectivity and synthetic mount cleanup under descriptor pressure. GitOrigin-RevId: dd297af98e9383942098fab5683ef2474c5ae554
This commit is contained in:
@@ -38,7 +38,11 @@ struct SystemBwrapCapabilities {
|
||||
|
||||
static LAUNCHER: OnceLock<BubblewrapLauncher> = OnceLock::new();
|
||||
|
||||
pub(crate) fn exec_bwrap(mut argv: Vec<String>, preserved_files: Vec<File>) -> ! {
|
||||
pub(crate) fn exec_bwrap(
|
||||
mut argv: Vec<String>,
|
||||
preserved_files: Vec<File>,
|
||||
transparent_tcp: bool,
|
||||
) -> ! {
|
||||
if argv
|
||||
.iter()
|
||||
.take_while(|arg| arg.as_str() != "--")
|
||||
@@ -53,7 +57,11 @@ pub(crate) fn exec_bwrap(mut argv: Vec<String>, preserved_files: Vec<File>) -> !
|
||||
translate_legacy_bwrap_fd_mounts(&mut argv)
|
||||
.unwrap_or_else(|error| panic!("invalid legacy bubblewrap fd mount: {error}"));
|
||||
}
|
||||
exec_system_bwrap(&launcher.program, argv, preserved_files)
|
||||
make_files_inheritable(&preserved_files);
|
||||
if transparent_tcp {
|
||||
crate::tcp_net_setup::exec_setup(launcher.program.as_path(), &argv[1..]);
|
||||
}
|
||||
exec_system_bwrap(&launcher.program, argv)
|
||||
}
|
||||
BubblewrapLauncher::Bundled(launcher) => launcher.exec(argv, preserved_files),
|
||||
BubblewrapLauncher::Unavailable => {
|
||||
@@ -223,14 +231,7 @@ fn system_bwrap_capabilities(system_bwrap_path: &Path) -> Option<SystemBwrapCapa
|
||||
})
|
||||
}
|
||||
|
||||
fn exec_system_bwrap(
|
||||
program: &AbsolutePathBuf,
|
||||
argv: Vec<String>,
|
||||
preserved_files: Vec<File>,
|
||||
) -> ! {
|
||||
// System bwrap runs across an exec boundary, so preserved fds must survive exec.
|
||||
make_files_inheritable(&preserved_files);
|
||||
|
||||
fn exec_system_bwrap(program: &AbsolutePathBuf, argv: Vec<String>) -> ! {
|
||||
let program_path = program.as_path().display().to_string();
|
||||
let program = CString::new(program.as_path().as_os_str().as_bytes())
|
||||
.unwrap_or_else(|err| panic!("invalid system bubblewrap path: {err}"));
|
||||
|
||||
@@ -23,8 +23,10 @@ use crate::launcher::exec_bwrap;
|
||||
use crate::launcher::initialize_bwrap_launcher;
|
||||
use crate::launcher::preferred_bwrap_supports_argv0;
|
||||
use crate::managed_tcp::Relay;
|
||||
use crate::proxy_routing::HostProxyBridge;
|
||||
use crate::proxy_routing::activate_proxy_routes_in_netns;
|
||||
use crate::proxy_routing::prepare_host_proxy_route_spec;
|
||||
use crate::proxy_routing::start_host_proxy_bridges;
|
||||
use crate::seccomp::ProxyRouting;
|
||||
use crate::seccomp::apply_sandbox_policies_to_current_thread;
|
||||
use codex_network_proxy::ManagedNetworkSandboxContext;
|
||||
@@ -142,6 +144,8 @@ pub struct LinuxSandboxCommand {
|
||||
/// 2. Apply in-process restrictions (no_new_privs + seccomp).
|
||||
/// 3. `execvp` into the final command.
|
||||
pub fn run_main() -> ! {
|
||||
let caller_pid = unsafe { libc::getppid() };
|
||||
crate::tcp_net_setup::dispatch();
|
||||
let LinuxSandboxCommand {
|
||||
sandbox_policy_cwd,
|
||||
command_cwd,
|
||||
@@ -290,21 +294,25 @@ pub fn run_main() -> ! {
|
||||
// Outer stage: bubblewrap first, then re-enter this binary in the
|
||||
// sandboxed environment to apply seccomp. This path never falls back
|
||||
// to legacy Landlock on failure.
|
||||
let (proxy_route_spec, proxy_controls) = if let Some(context) = managed_network.as_ref() {
|
||||
let (proxy_route_spec, proxy_bridges) = if let Some(context) = managed_network.as_ref() {
|
||||
// Older explicit-proxy callers may omit ports. The new transparent
|
||||
// switch always requires the executor's trusted ingress port list.
|
||||
let ports = (transparent_tcp || !context.loopback_ports.is_empty())
|
||||
.then_some(context.loopback_ports.as_slice());
|
||||
let (proxy_route_spec, controls) = prepare_host_proxy_route_spec(ports, routing)
|
||||
let (proxy_route_spec, bridges) = prepare_host_proxy_route_spec(ports, routing)
|
||||
.unwrap_or_else(|err| panic!("failed to prepare host proxy routing bridge: {err}"));
|
||||
(Some(proxy_route_spec), controls)
|
||||
(Some(proxy_route_spec), bridges)
|
||||
} else {
|
||||
(None, Vec::new())
|
||||
};
|
||||
let options = BwrapOptions {
|
||||
mount_proc: !no_proc && !inherit_pid_namespace,
|
||||
inherit_pid_namespace,
|
||||
network_mode: bwrap_network_mode(network_sandbox_policy, allow_network_for_proxy),
|
||||
network_mode: if transparent_tcp {
|
||||
BwrapNetworkMode::PreparedProxy
|
||||
} else {
|
||||
bwrap_network_mode(network_sandbox_policy, allow_network_for_proxy)
|
||||
},
|
||||
mask_wsl_interop: !file_system_sandbox_policy.has_full_disk_write_access()
|
||||
&& Path::new(WSL_INTEROP_DIR).is_dir(),
|
||||
mask_wslg_distro: (!file_system_sandbox_policy.has_full_disk_write_access()
|
||||
@@ -336,13 +344,13 @@ pub fn run_main() -> ! {
|
||||
command,
|
||||
});
|
||||
run_bwrap_with_proc_fallback(
|
||||
caller_pid,
|
||||
&sandbox_policy_cwd,
|
||||
command_cwd.as_deref(),
|
||||
&file_system_sandbox_policy,
|
||||
options,
|
||||
inner,
|
||||
proxy_controls,
|
||||
transparent_tcp,
|
||||
proxy_bridges,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -419,16 +427,26 @@ fn ensure_legacy_landlock_mode_supports_policy(
|
||||
}
|
||||
|
||||
fn run_bwrap_with_proc_fallback(
|
||||
caller_pid: libc::pid_t,
|
||||
sandbox_policy_cwd: &Path,
|
||||
command_cwd: Option<&Path>,
|
||||
file_system_sandbox_policy: &FileSystemSandboxPolicy,
|
||||
mut options: BwrapOptions,
|
||||
inner: Vec<String>,
|
||||
proxy_controls: Vec<File>,
|
||||
transparent_tcp: bool,
|
||||
proxy_bridges: Vec<HostProxyBridge>,
|
||||
) -> ! {
|
||||
let transparent_tcp = options.network_mode == BwrapNetworkMode::PreparedProxy;
|
||||
let command_cwd = command_cwd.unwrap_or(sandbox_policy_cwd);
|
||||
|
||||
// An inherited SIG_IGN would auto-reap bubblewrap before we can collect
|
||||
// its exit status. The preflight also waits for its own bubblewrap child.
|
||||
if unsafe { libc::signal(libc::SIGCHLD, libc::SIG_DFL) } == libc::SIG_ERR {
|
||||
panic!(
|
||||
"failed to reset SIGCHLD: {}",
|
||||
std::io::Error::last_os_error()
|
||||
);
|
||||
}
|
||||
|
||||
// Select before the preflight, whose synthetic policy omits writable roots.
|
||||
initialize_bwrap_launcher(
|
||||
file_system_sandbox_policy,
|
||||
@@ -448,13 +466,7 @@ fn run_bwrap_with_proc_fallback(
|
||||
options.mount_proc = false;
|
||||
}
|
||||
|
||||
let tcp_files = transparent_tcp.then(|| {
|
||||
let files = crate::tcp_namespace::create()
|
||||
.unwrap_or_else(|err| panic!("failed to create private TCP namespace: {err}"));
|
||||
options.network_mode = BwrapNetworkMode::PreparedProxy;
|
||||
files
|
||||
});
|
||||
let mut bwrap_args = build_bwrap_argv(
|
||||
let bwrap_args = build_bwrap_argv(
|
||||
inner,
|
||||
file_system_sandbox_policy,
|
||||
sandbox_policy_cwd,
|
||||
@@ -462,18 +474,24 @@ fn run_bwrap_with_proc_fallback(
|
||||
options,
|
||||
)
|
||||
.unwrap_or_else(|err| exit_with_bwrap_build_error(err));
|
||||
if let Some(files) = tcp_files {
|
||||
crate::tcp_net_setup::prepare(
|
||||
files,
|
||||
if !proxy_bridges.is_empty() && bwrap_args.synthetic_mount_targets.is_empty() {
|
||||
// This launcher would otherwise exec bubblewrap directly. Preserve
|
||||
// --die-with-parent now that it stays alive to serve the proxy.
|
||||
kill_on_parent_death(caller_pid);
|
||||
}
|
||||
// Host bridge threads must stay in the host network namespace. Only the
|
||||
// bubblewrap child enters the private namespace and receives its TUN and resolver.
|
||||
let mut bwrap_args = start_bwrap_supervisors(bwrap_args, proxy_bridges);
|
||||
if transparent_tcp {
|
||||
crate::tcp_net_setup::mount_resolver(
|
||||
&mut bwrap_args,
|
||||
file_system_sandbox_policy,
|
||||
sandbox_policy_cwd,
|
||||
)
|
||||
.unwrap_or_else(|err| panic!("failed to prepare transparent TCP namespace: {err}"));
|
||||
}
|
||||
bwrap_args.preserved_files.extend(proxy_controls);
|
||||
apply_inner_command_argv0(&mut bwrap_args.args);
|
||||
run_or_exec_bwrap(bwrap_args);
|
||||
exec_bwrap(bwrap_args.args, bwrap_args.preserved_files, transparent_tcp);
|
||||
}
|
||||
|
||||
fn bwrap_network_mode(
|
||||
@@ -596,47 +614,81 @@ fn resolve_true_command() -> String {
|
||||
"true".to_string()
|
||||
}
|
||||
|
||||
fn run_or_exec_bwrap(bwrap_args: crate::bwrap::BwrapArgs) -> ! {
|
||||
if bwrap_args.synthetic_mount_targets.is_empty() {
|
||||
exec_bwrap(bwrap_args.args, bwrap_args.preserved_files);
|
||||
/// With both supervisors, the launcher runs `proxy supervisor -> mount cleanup supervisor -> bubblewrap`.
|
||||
/// Each optional supervisor waits for its child. Separate descriptor tables
|
||||
/// let mount cleanup proceed even when proxy connections exhaust theirs.
|
||||
/// Returns only in the process that will exec bubblewrap.
|
||||
fn start_bwrap_supervisors(
|
||||
mut bwrap_args: crate::bwrap::BwrapArgs,
|
||||
proxy_bridges: Vec<HostProxyBridge>,
|
||||
) -> crate::bwrap::BwrapArgs {
|
||||
if bwrap_args.synthetic_mount_targets.is_empty() && proxy_bridges.is_empty() {
|
||||
return bwrap_args;
|
||||
}
|
||||
run_bwrap_in_child_with_synthetic_mount_cleanup(bwrap_args);
|
||||
|
||||
let setup_signal_mask = ForwardedSignalMask::block();
|
||||
// Register before either fork so markers name the PID the caller will reap.
|
||||
let registrations = register_synthetic_mount_targets(&bwrap_args.synthetic_mount_targets);
|
||||
|
||||
if !proxy_bridges.is_empty() {
|
||||
let child_pid = fork_supervised_child();
|
||||
if child_pid > 0 {
|
||||
drop(bwrap_args.preserved_files);
|
||||
// Bridge threads inherit the blocked signals. The supervising thread
|
||||
// receives cancellation and forwards it to the child.
|
||||
start_host_proxy_bridges(proxy_bridges);
|
||||
supervise_child(child_pid, &setup_signal_mask, || {});
|
||||
}
|
||||
bwrap_args.preserved_files.extend(
|
||||
proxy_bridges
|
||||
.into_iter()
|
||||
.map(HostProxyBridge::into_sandbox_control),
|
||||
);
|
||||
}
|
||||
|
||||
if !registrations.is_empty() {
|
||||
let child_pid = fork_supervised_child();
|
||||
if child_pid > 0 {
|
||||
drop(bwrap_args.preserved_files);
|
||||
supervise_child(child_pid, &setup_signal_mask, || {
|
||||
cleanup_synthetic_mount_targets(®istrations);
|
||||
});
|
||||
}
|
||||
}
|
||||
setup_signal_mask.restore();
|
||||
bwrap_args
|
||||
}
|
||||
|
||||
fn run_bwrap_in_child_with_synthetic_mount_cleanup(bwrap_args: crate::bwrap::BwrapArgs) -> ! {
|
||||
let crate::bwrap::BwrapArgs {
|
||||
args,
|
||||
preserved_files,
|
||||
synthetic_mount_targets,
|
||||
} = bwrap_args;
|
||||
let setup_signal_mask = ForwardedSignalMask::block();
|
||||
let synthetic_mount_registrations = register_synthetic_mount_targets(&synthetic_mount_targets);
|
||||
fn fork_supervised_child() -> libc::pid_t {
|
||||
let parent_pid = unsafe { libc::getpid() };
|
||||
let pid = unsafe { libc::fork() };
|
||||
if pid < 0 {
|
||||
let err = std::io::Error::last_os_error();
|
||||
panic!("failed to fork for bubblewrap: {err}");
|
||||
}
|
||||
|
||||
if pid == 0 {
|
||||
reset_forwarded_signal_handlers_to_default();
|
||||
setup_signal_mask.restore();
|
||||
let setpgid_res = unsafe { libc::setpgid(0, 0) };
|
||||
if setpgid_res < 0 {
|
||||
let err = std::io::Error::last_os_error();
|
||||
panic!("failed to place bubblewrap child in its own process group: {err}");
|
||||
}
|
||||
terminate_with_parent(parent_pid);
|
||||
exec_bwrap(args, preserved_files);
|
||||
kill_on_parent_death(parent_pid);
|
||||
}
|
||||
pid
|
||||
}
|
||||
|
||||
drop(preserved_files);
|
||||
fn supervise_child(
|
||||
pid: libc::pid_t,
|
||||
setup_signal_mask: &ForwardedSignalMask,
|
||||
cleanup: impl FnOnce(),
|
||||
) -> ! {
|
||||
let signal_forwarders = install_bwrap_signal_forwarders(pid);
|
||||
setup_signal_mask.restore();
|
||||
let status = wait_for_bwrap_child(pid);
|
||||
let cleanup_signal_mask = ForwardedSignalMask::block();
|
||||
BWRAP_CHILD_PID.store(0, Ordering::SeqCst);
|
||||
cleanup_synthetic_mount_targets(&synthetic_mount_registrations);
|
||||
cleanup();
|
||||
signal_forwarders.restore();
|
||||
cleanup_signal_mask.restore();
|
||||
exit_with_wait_status(status);
|
||||
@@ -681,15 +733,17 @@ impl ForwardedSignalMask {
|
||||
}
|
||||
}
|
||||
|
||||
fn terminate_with_parent(parent_pid: libc::pid_t) {
|
||||
let res = unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) };
|
||||
fn kill_on_parent_death(parent_pid: libc::pid_t) {
|
||||
// Match bubblewrap's --die-with-parent even while the child has TERM blocked
|
||||
// for mount registration or cleanup.
|
||||
let res = unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGKILL) };
|
||||
if res < 0 {
|
||||
let err = std::io::Error::last_os_error();
|
||||
panic!("failed to set bubblewrap child parent-death signal: {err}");
|
||||
panic!("failed to set sandbox parent-death signal: {err}");
|
||||
}
|
||||
if unsafe { libc::getppid() } != parent_pid {
|
||||
unsafe {
|
||||
libc::raise(libc::SIGTERM);
|
||||
libc::raise(libc::SIGKILL);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -780,6 +834,9 @@ fn wait_for_bwrap_child(pid: libc::pid_t) -> libc::c_int {
|
||||
fn register_synthetic_mount_targets(
|
||||
targets: &[crate::bwrap::SyntheticMountTarget],
|
||||
) -> Vec<SyntheticMountTargetRegistration> {
|
||||
if targets.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
with_synthetic_mount_registry_lock(|| {
|
||||
targets
|
||||
.iter()
|
||||
@@ -1117,7 +1174,7 @@ fn run_bwrap_in_child_capture_stderr(bwrap_args: crate::bwrap::BwrapArgs) -> Str
|
||||
close_fd_or_panic(write_fd, "close write end in bubblewrap child");
|
||||
}
|
||||
|
||||
exec_bwrap(args, preserved_files);
|
||||
exec_bwrap(args, preserved_files, /*transparent_tcp*/ false);
|
||||
}
|
||||
|
||||
let signal_forwarders = install_bwrap_signal_forwarders(pid);
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Manage privileged bridge processes and transfer their loopback TCP listeners.
|
||||
//! Isolate host proxy descriptors and transfer loopback listeners from the sandbox.
|
||||
//!
|
||||
//! Received descriptors are CLOEXEC and owned even when validation rejects them.
|
||||
//! Shape validation does not authenticate the sender: the caller must retain exclusive
|
||||
@@ -26,10 +26,54 @@ use std::os::fd::AsFd;
|
||||
use std::os::fd::AsRawFd;
|
||||
use std::os::fd::FromRawFd;
|
||||
use std::os::fd::OwnedFd;
|
||||
use std::os::fd::RawFd;
|
||||
use std::os::unix::net::UnixStream;
|
||||
|
||||
const LISTENER_MESSAGE: u8 = 1;
|
||||
|
||||
/// Give one route its own descriptor budget. Its relay threads inherit this table.
|
||||
///
|
||||
/// # Safety
|
||||
/// Call only on a fresh bridge thread with no owned descriptors. The supervisor must
|
||||
/// keep the bootstrap socket open at `control` until the caller signals readiness.
|
||||
pub(crate) unsafe fn private_bridge_control(control: RawFd) -> io::Result<UnixStream> {
|
||||
// SAFETY: UNSHARE copies the calling thread's table before closing the upper range.
|
||||
if unsafe {
|
||||
libc::syscall(
|
||||
libc::SYS_close_range,
|
||||
control as u32 + 1,
|
||||
u32::MAX,
|
||||
libc::CLOSE_RANGE_UNSHARE,
|
||||
)
|
||||
} == 0
|
||||
{
|
||||
for fd in 3..control {
|
||||
let _ = close_fd(fd);
|
||||
}
|
||||
} else {
|
||||
// Older kernels support CLONE_FILES without close_range.
|
||||
// SAFETY: unshare takes only flags and changes this thread's table.
|
||||
if unsafe { libc::unshare(libc::CLONE_FILES) } == -1 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let mut inherited = Vec::new();
|
||||
for entry in std::fs::read_dir("/proc/thread-self/fd")? {
|
||||
if let Ok(fd) = entry?.file_name().to_string_lossy().parse::<RawFd>()
|
||||
&& fd > libc::STDERR_FILENO
|
||||
&& fd != control
|
||||
{
|
||||
inherited.push(fd);
|
||||
}
|
||||
}
|
||||
// The directory handle has dropped. No other thread can reuse these numbers.
|
||||
for fd in inherited {
|
||||
let _ = close_fd(fd);
|
||||
}
|
||||
}
|
||||
// SAFETY: this thread owns the private copy of the supervisor's live socket.
|
||||
Ok(unsafe { UnixStream::from_raw_fd(control) })
|
||||
}
|
||||
|
||||
pub(crate) fn send_listener(channel: &UnixStream, listener: &TcpListener) -> io::Result<()> {
|
||||
let descriptors = [listener.as_fd()];
|
||||
let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];
|
||||
@@ -113,24 +157,7 @@ pub(crate) fn receive_listener(channel: &UnixStream) -> io::Result<TcpListener>
|
||||
Ok(listener)
|
||||
}
|
||||
|
||||
pub(crate) fn harden_bridge_process(expected_parent_pid: libc::pid_t) -> io::Result<()> {
|
||||
detach_bridge_stdio()?;
|
||||
set_parent_death_signal(expected_parent_pid)?;
|
||||
codex_process_hardening::disable_process_dumping()
|
||||
}
|
||||
|
||||
fn set_parent_death_signal(expected_parent_pid: libc::pid_t) -> io::Result<()> {
|
||||
let res = unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) };
|
||||
if res != 0 {
|
||||
Err(io::Error::last_os_error())
|
||||
} else if unsafe { libc::getppid() } != expected_parent_pid {
|
||||
Err(io::Error::other("parent process already exited"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn detach_bridge_stdio() -> io::Result<()> {
|
||||
pub(crate) fn detach_bridge_stdio() -> io::Result<()> {
|
||||
let null_read_fd = unsafe { libc::open(c"/dev/null".as_ptr(), libc::O_RDONLY) };
|
||||
if null_read_fd < 0 {
|
||||
let err = io::Error::last_os_error();
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use crate::proxy_lifecycle::close_fd;
|
||||
use crate::proxy_lifecycle::harden_bridge_process;
|
||||
use crate::proxy_lifecycle::detach_bridge_stdio;
|
||||
use crate::proxy_lifecycle::move_fd_above_stdio;
|
||||
use crate::proxy_lifecycle::private_bridge_control;
|
||||
use crate::proxy_lifecycle::receive_listener;
|
||||
use crate::proxy_lifecycle::send_listener;
|
||||
use crate::seccomp::ProxyRouting;
|
||||
@@ -11,6 +12,7 @@ use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
use std::collections::BTreeMap;
|
||||
use std::collections::HashMap;
|
||||
use std::collections::btree_map::Entry;
|
||||
use std::fs::File;
|
||||
use std::io;
|
||||
use std::io::Read;
|
||||
@@ -21,9 +23,9 @@ use std::net::Shutdown;
|
||||
use std::net::SocketAddr;
|
||||
use std::net::TcpListener;
|
||||
use std::net::TcpStream;
|
||||
use std::os::fd::AsFd;
|
||||
use std::os::fd::AsRawFd;
|
||||
use std::os::fd::FromRawFd;
|
||||
use std::os::fd::OwnedFd;
|
||||
use std::os::unix::net::UnixStream;
|
||||
use std::sync::Arc;
|
||||
use std::sync::mpsc;
|
||||
@@ -57,13 +59,84 @@ struct ProxyRoutePlan {
|
||||
has_proxy_config: bool,
|
||||
}
|
||||
|
||||
/// One bootstrap socketpair per upstream endpoint. Only the sandbox end crosses exec.
|
||||
pub(crate) struct HostProxyBridge {
|
||||
endpoint: SocketAddr,
|
||||
routing: ProxyRouting,
|
||||
host_control: UnixStream,
|
||||
sandbox_control: File,
|
||||
attribution_token: Option<String>,
|
||||
}
|
||||
|
||||
impl HostProxyBridge {
|
||||
pub(crate) fn into_sandbox_control(self) -> File {
|
||||
self.sandbox_control
|
||||
}
|
||||
}
|
||||
|
||||
/// Start bridge threads only in the outer supervisor, after the child inherits
|
||||
/// the command's stdio. If setup fails, closing a host socket fails the handoff.
|
||||
pub(crate) fn start_host_proxy_bridges(bridges: Vec<HostProxyBridge>) {
|
||||
let mut startup_stderr = None;
|
||||
let result: io::Result<()> = bridges
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.try_for_each(|(index, bridge)| {
|
||||
drop(bridge.sandbox_control);
|
||||
if index == 0 {
|
||||
// Reuse the slot freed above for diagnostics, even at the FD limit.
|
||||
// The child already inherited its stdio; detach ours before starting any worker.
|
||||
startup_stderr = io::stderr()
|
||||
.as_fd()
|
||||
.try_clone_to_owned()
|
||||
.ok()
|
||||
.map(File::from);
|
||||
detach_bridge_stdio()?;
|
||||
}
|
||||
let control_fd = bridge.host_control.as_raw_fd();
|
||||
let token = bridge.attribution_token.clone();
|
||||
let (ready, initialized) = mpsc::channel();
|
||||
let worker = std::thread::Builder::new()
|
||||
.name("codex-proxy".to_string())
|
||||
.spawn(move || {
|
||||
// SAFETY: this new thread owns no FDs. The supervisor holds the socket
|
||||
// until ready and its own descriptor table is unaffected.
|
||||
let control = unsafe { private_bridge_control(control_fd)? };
|
||||
ready.send(()).map_err(io::Error::other)?;
|
||||
run_host_bridge(bridge.endpoint, bridge.routing, control, token)
|
||||
})?;
|
||||
if initialized.recv().is_ok() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Reclaim the failed worker's task slot before falling back on hosts that
|
||||
// prohibit private FD tables.
|
||||
let _ = worker.join();
|
||||
std::thread::Builder::new()
|
||||
.name("codex-proxy".to_string())
|
||||
.spawn(move || {
|
||||
run_host_bridge(
|
||||
bridge.endpoint,
|
||||
bridge.routing,
|
||||
bridge.host_control,
|
||||
bridge.attribution_token,
|
||||
)
|
||||
})?;
|
||||
Ok(())
|
||||
});
|
||||
if let (Err(err), Some(mut stderr)) = (result, startup_stderr) {
|
||||
let _ = writeln!(stderr, "failed to start host proxy bridges: {err}");
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn prepare_host_proxy_route_spec(
|
||||
port_allowlist: Option<&[u16]>,
|
||||
routing: ProxyRouting,
|
||||
) -> io::Result<(String, Vec<File>)> {
|
||||
) -> io::Result<(String, Vec<HostProxyBridge>)> {
|
||||
// The outer supervisor holds the upstream credential and host sockets.
|
||||
codex_process_hardening::disable_process_dumping()?;
|
||||
let (attribution_token, plan) = extract_attribution_token_and_plan(std::env::vars().collect());
|
||||
// SAFETY: the sandbox helper is single-threaded here, before it forks bridge workers or
|
||||
// executes the user command.
|
||||
// SAFETY: bubblewrap and the host bridge threads have not been started yet.
|
||||
unsafe {
|
||||
std::env::remove_var(PROXY_ATTRIBUTION_TOKEN_ENV_KEY);
|
||||
}
|
||||
@@ -77,7 +150,7 @@ pub(crate) fn prepare_host_proxy_route_spec(
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidInput, message));
|
||||
}
|
||||
|
||||
// Validate the entire plan before forking any host-side workers or sending
|
||||
// Validate the entire plan before starting any host-side workers or sending
|
||||
// attribution. An empty enforced list grants no routes.
|
||||
if let Some(ports) = port_allowlist
|
||||
&& plan
|
||||
@@ -91,36 +164,30 @@ pub(crate) fn prepare_host_proxy_route_spec(
|
||||
));
|
||||
}
|
||||
|
||||
let mut control_by_endpoint = BTreeMap::new();
|
||||
for route in &plan.routes {
|
||||
if control_by_endpoint.contains_key(&route.endpoint) {
|
||||
continue;
|
||||
}
|
||||
let control = spawn_host_bridge(
|
||||
route.endpoint,
|
||||
routing,
|
||||
attribution_token.as_deref(),
|
||||
&mut control_by_endpoint,
|
||||
)?;
|
||||
control_by_endpoint.insert(route.endpoint, control);
|
||||
}
|
||||
|
||||
let mut bridges = BTreeMap::new();
|
||||
let mut routes = Vec::with_capacity(plan.routes.len());
|
||||
for route in plan.routes {
|
||||
let Some(control) = control_by_endpoint.get(&route.endpoint) else {
|
||||
return Err(io::Error::other(format!(
|
||||
"missing bootstrap channel for endpoint {}",
|
||||
route.endpoint
|
||||
)));
|
||||
let bridge = match bridges.entry(route.endpoint) {
|
||||
Entry::Occupied(entry) => entry.into_mut(),
|
||||
Entry::Vacant(entry) => {
|
||||
let (host, sandbox) = UnixStream::pair()?;
|
||||
entry.insert(HostProxyBridge {
|
||||
endpoint: route.endpoint,
|
||||
routing,
|
||||
host_control: UnixStream::from(move_fd_above_stdio(host.into())?),
|
||||
sandbox_control: File::from(move_fd_above_stdio(sandbox.into())?),
|
||||
attribution_token: attribution_token.clone(),
|
||||
})
|
||||
}
|
||||
};
|
||||
routes.push(ProxyRouteEntry {
|
||||
env_key: route.env_key,
|
||||
control_fd: control.as_raw_fd(),
|
||||
control_fd: bridge.sandbox_control.as_raw_fd(),
|
||||
});
|
||||
}
|
||||
|
||||
let spec = serde_json::to_string(&ProxyRouteSpec { routes }).map_err(io::Error::other)?;
|
||||
Ok((spec, control_by_endpoint.into_values().collect()))
|
||||
Ok((spec, bridges.into_values().collect()))
|
||||
}
|
||||
|
||||
fn extract_attribution_token_and_plan(
|
||||
@@ -329,51 +396,6 @@ fn rewrite_proxy_env_value(proxy_url: &str, local_port: u16) -> Option<String> {
|
||||
Some(rewritten)
|
||||
}
|
||||
|
||||
fn spawn_host_bridge(
|
||||
endpoint: SocketAddr,
|
||||
routing: ProxyRouting,
|
||||
attribution_token: Option<&str>,
|
||||
inherited_controls: &mut BTreeMap<SocketAddr, File>,
|
||||
) -> io::Result<File> {
|
||||
let (host_control, control) = UnixStream::pair()?;
|
||||
let host_control = UnixStream::from(move_fd_above_stdio(host_control.into())?);
|
||||
let mut control = UnixStream::from(move_fd_above_stdio(control.into())?);
|
||||
control.set_read_timeout(Some(HANDOFF_TIMEOUT))?;
|
||||
let parent_pid = unsafe { libc::getpid() };
|
||||
let pid = unsafe { libc::fork() };
|
||||
if pid < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
|
||||
if pid == 0 {
|
||||
drop(control);
|
||||
// A worker must not retain another route's inner bootstrap endpoint.
|
||||
// Drop this child's inherited owners; the parent's copies are unaffected by fork.
|
||||
inherited_controls.clear();
|
||||
let result = run_host_bridge(
|
||||
endpoint,
|
||||
routing,
|
||||
host_control,
|
||||
attribution_token,
|
||||
parent_pid,
|
||||
);
|
||||
if result.is_err() {
|
||||
unsafe { libc::_exit(1) };
|
||||
}
|
||||
unsafe { libc::_exit(0) };
|
||||
}
|
||||
|
||||
drop(host_control);
|
||||
let mut ready = [0_u8; 1];
|
||||
control.read_exact(&mut ready)?;
|
||||
if ready != [HOST_BRIDGE_READY] {
|
||||
return Err(io::Error::other(
|
||||
"host bridge did not acknowledge readiness",
|
||||
));
|
||||
}
|
||||
Ok(File::from(OwnedFd::from(control)))
|
||||
}
|
||||
|
||||
/// Each connection worker holds a permit until it exits.
|
||||
pub(super) struct ConnectionSlots(Arc<Semaphore>);
|
||||
|
||||
@@ -403,22 +425,25 @@ fn run_host_bridge(
|
||||
endpoint: SocketAddr,
|
||||
routing: ProxyRouting,
|
||||
mut control: UnixStream,
|
||||
attribution_token: Option<&str>,
|
||||
parent_pid: libc::pid_t,
|
||||
attribution_token: Option<String>,
|
||||
) -> io::Result<()> {
|
||||
harden_bridge_process(parent_pid)?;
|
||||
control.write_all(&[HOST_BRIDGE_READY])?;
|
||||
// The outer helper must launch bubblewrap before this listener can arrive.
|
||||
// The socket keeps its isolated network namespace even though we accept in
|
||||
// the host process; newly opened upstream sockets use our host namespace.
|
||||
// The listener stays in the sandbox network namespace. Connections to the
|
||||
// upstream proxy are opened here in the host network namespace.
|
||||
let listener = receive_listener(&control)?;
|
||||
control.write_all(&[HOST_BRIDGE_READY])?;
|
||||
drop(control);
|
||||
|
||||
let attribution_token = attribution_token.map(str::to_owned);
|
||||
let slots = ConnectionSlots::new();
|
||||
loop {
|
||||
let (client_stream, _) = listener.accept()?;
|
||||
let client_stream = match listener.accept() {
|
||||
Ok((stream, _)) => stream,
|
||||
// Keep the listener available when descriptor pressure subsides.
|
||||
Err(err) if matches!(err.raw_os_error(), Some(libc::EMFILE | libc::ENFILE)) => {
|
||||
std::thread::sleep(Duration::from_millis(/*millis*/ 100));
|
||||
continue;
|
||||
}
|
||||
Err(err) => return Err(err),
|
||||
};
|
||||
let attribution_token = attribution_token.clone();
|
||||
slots.spawn(routing, move || {
|
||||
let mut tcp_stream = match TcpStream::connect(endpoint) {
|
||||
|
||||
@@ -2,8 +2,12 @@
|
||||
//! takes ownership of all three received descriptors before any workload exec.
|
||||
|
||||
use crate::bwrap::BwrapArgs;
|
||||
use crate::exec_util::make_files_inheritable;
|
||||
use crate::proxy_lifecycle::move_fd_above_stdio;
|
||||
use codex_protocol::protocol::FileSystemSandboxPolicy;
|
||||
use codex_sandboxing::landlock::CODEX_LINUX_SANDBOX_ARG0;
|
||||
use std::ffi::OsStr;
|
||||
use std::ffi::OsString;
|
||||
use std::fs::File;
|
||||
use std::io;
|
||||
use std::io::Seek;
|
||||
@@ -11,10 +15,59 @@ use std::io::Write;
|
||||
use std::os::fd::AsRawFd;
|
||||
use std::os::fd::FromRawFd;
|
||||
use std::os::fd::OwnedFd;
|
||||
use std::os::unix::process::CommandExt;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
pub(super) fn prepare(
|
||||
files: [File; 3],
|
||||
const SETUP_ARG: &str = "--setup-transparent-tcp";
|
||||
|
||||
/// Replace the forked supervisor image before creating user-namespace ID maps.
|
||||
/// Exec drops the inherited attribution token from memory and restores normal
|
||||
/// dumpability so an unprivileged caller can write its own UID/GID mappings.
|
||||
pub(super) fn exec_setup(bwrap: &Path, args: &[String]) -> ! {
|
||||
let err = Command::new("/proc/self/exe")
|
||||
.arg0(CODEX_LINUX_SANDBOX_ARG0)
|
||||
.arg(SETUP_ARG)
|
||||
.arg(bwrap)
|
||||
.args(args)
|
||||
.exec();
|
||||
panic!("failed to exec transparent TCP setup: {err}")
|
||||
}
|
||||
|
||||
pub(super) fn dispatch() {
|
||||
let mut args = std::env::args_os().skip(1);
|
||||
if args.next().as_deref() != Some(OsStr::new(SETUP_ARG)) {
|
||||
return;
|
||||
}
|
||||
let program = args
|
||||
.next()
|
||||
.unwrap_or_else(|| panic!("missing system bubblewrap path"));
|
||||
let mut args: Vec<OsString> = args.collect();
|
||||
let separator = args
|
||||
.iter()
|
||||
.position(|arg| arg == "--")
|
||||
.filter(|separator| separator + 1 < args.len())
|
||||
.unwrap_or_else(|| panic!("missing inner sandbox command"));
|
||||
let files = crate::tcp_namespace::create()
|
||||
.unwrap_or_else(|err| panic!("failed to create private TCP namespace: {err}"));
|
||||
let numbers = files
|
||||
.each_ref()
|
||||
.map(|fd| fd.as_raw_fd().to_string())
|
||||
.join(",");
|
||||
args.splice(
|
||||
separator + 2..separator + 2,
|
||||
[
|
||||
"--transparent-tcp".into(),
|
||||
"--transparent-tcp-fd".into(),
|
||||
numbers.into(),
|
||||
],
|
||||
);
|
||||
make_files_inheritable(&files);
|
||||
let err = Command::new(program).arg0("bwrap").args(args).exec();
|
||||
panic!("failed to exec bubblewrap in transparent TCP namespace: {err}")
|
||||
}
|
||||
|
||||
pub(super) fn mount_resolver(
|
||||
bwrap: &mut BwrapArgs,
|
||||
policy: &FileSystemSandboxPolicy,
|
||||
cwd: &Path,
|
||||
@@ -33,23 +86,11 @@ pub(super) fn prepare(
|
||||
let mut resolv = File::from(move_fd_above_stdio(fd)?);
|
||||
resolv.write_all(b"nameserver 127.0.0.53\n")?;
|
||||
resolv.rewind()?;
|
||||
let numbers = files
|
||||
.each_ref()
|
||||
.map(|f| f.as_raw_fd().to_string())
|
||||
.join(",");
|
||||
let separator = bwrap
|
||||
.args
|
||||
.iter()
|
||||
.position(|arg| arg == "--")
|
||||
.ok_or_else(|| io::Error::other("missing inner command"))?;
|
||||
bwrap.args.splice(
|
||||
separator + 2..separator + 2,
|
||||
[
|
||||
"--transparent-tcp".into(),
|
||||
"--transparent-tcp-fd".into(),
|
||||
numbers,
|
||||
],
|
||||
);
|
||||
bwrap.args.splice(
|
||||
separator..separator,
|
||||
[
|
||||
@@ -64,7 +105,6 @@ pub(super) fn prepare(
|
||||
],
|
||||
);
|
||||
bwrap.preserved_files.push(resolv);
|
||||
bwrap.preserved_files.extend(files);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user