Tighten Windows fs helper launch flow

This commit is contained in:
David Wiesen
2026-06-11 18:03:01 -07:00
parent 2d494102c9
commit a489ddd490
2 changed files with 174 additions and 94 deletions
+33 -94
View File
@@ -62,16 +62,12 @@ impl FileSystemSandboxRunner {
request: FsHelperRequest,
) -> Result<FsHelperPayload, JSONRPCErrorError> {
let cwd = sandbox_cwd(sandbox)?;
let helper_paths = self.helper_paths_for_launch()?;
let mut file_system_policy = sandbox.permissions.file_system_sandbox_policy();
// The sandboxed child re-enters Codex as the filesystem helper. On Windows
// that executable can be a materialized copy under CODEX_HOME/.sandbox-bin,
// so derive helper read roots from the exact helper path we will launch.
let helper_read_roots = if sandbox.use_legacy_landlock {
Vec::new()
} else {
helper_read_roots(
&helper_paths.sandboxed_helper,
&self.runtime_paths.codex_self_exe,
self.runtime_paths.codex_linux_sandbox_exe.as_ref(),
)
};
@@ -83,55 +79,16 @@ impl FileSystemSandboxRunner {
&file_system_policy,
network_policy,
);
let command =
self.sandbox_exec_request(&permission_profile, &cwd, sandbox, &helper_paths)?;
let command = self.sandbox_exec_request(&permission_profile, &cwd, sandbox)?;
let request_json = serde_json::to_vec(&request).map_err(json_error)?;
run_command(command, request_json).await
}
fn helper_paths_for_launch(&self) -> Result<FsHelperLaunchPaths, JSONRPCErrorError> {
#[cfg(target_os = "windows")]
{
// Windows sandbox launch grants are prepared around the executable
// path that the sandbox will spawn. When exec-server is embedded or
// hosted, `current_exe()` can point at the host process instead of
// the configured Codex binary, so materialize the runtime-provided
// helper and use that exact path for the sandboxed fs-helper.
let codex_home = codex_utils_home_dir::find_codex_home().map_err(|err| {
internal_error(format!(
"windows fs sandbox helper failed to resolve CODEX_HOME: {err}"
))
})?;
let sandboxed_helper = codex_windows_sandbox::resolve_exe_for_launch(
self.runtime_paths.codex_self_exe.as_path(),
codex_home.as_path(),
);
let sandboxed_helper = AbsolutePathBuf::from_absolute_path(sandboxed_helper.as_path())
.map_err(|err| {
internal_error(format!(
"windows fs sandbox helper path is not absolute: {err}"
))
})?;
Ok(FsHelperLaunchPaths {
sandboxed_helper,
windows_wrapper: self.runtime_paths.codex_self_exe.clone(),
})
}
#[cfg(not(target_os = "windows"))]
{
Ok(FsHelperLaunchPaths {
sandboxed_helper: self.runtime_paths.codex_self_exe.clone(),
})
}
}
fn sandbox_exec_request(
&self,
permission_profile: &PermissionProfile,
cwd: &AbsolutePathBuf,
sandbox_context: &FileSystemSandboxContext,
helper_paths: &FsHelperLaunchPaths,
) -> Result<PreparedFsHelperCommand, JSONRPCErrorError> {
let sandbox_manager = SandboxManager::new();
let (file_system_policy, network_policy) = permission_profile.to_runtime_permissions();
@@ -143,8 +100,9 @@ impl FileSystemSandboxRunner {
/*has_managed_network_requirements*/ false,
);
let command = SandboxCommand {
program: helper_paths
.sandboxed_helper
program: self
.runtime_paths
.codex_self_exe
.as_path()
.as_os_str()
.to_owned(),
@@ -169,8 +127,14 @@ impl FileSystemSandboxRunner {
.map_err(|err| invalid_request(format!("failed to prepare fs sandbox: {err}")))?;
#[cfg(target_os = "windows")]
if command.sandbox == codex_sandboxing::SandboxType::WindowsRestrictedToken {
let request_file =
windows::wrap_sandbox_exec_request(&mut command, &helper_paths.windows_wrapper)?;
windows::materialize_sandboxed_helper(
&mut command,
&self.runtime_paths.codex_self_exe,
)?;
let request_file = windows::wrap_sandbox_exec_request(
&mut command,
&self.runtime_paths.codex_self_exe,
)?;
return Ok(PreparedFsHelperCommand::with_windows_wrapper_request_file(
command,
request_file,
@@ -180,12 +144,6 @@ impl FileSystemSandboxRunner {
}
}
struct FsHelperLaunchPaths {
sandboxed_helper: AbsolutePathBuf,
#[cfg(target_os = "windows")]
windows_wrapper: AbsolutePathBuf,
}
struct PreparedFsHelperCommand {
request: SandboxExecRequest,
#[cfg(target_os = "windows")]
@@ -348,8 +306,25 @@ async fn run_command(
command: PreparedFsHelperCommand,
request_json: Vec<u8>,
) -> Result<FsHelperPayload, JSONRPCErrorError> {
let output = run_child_command(command, request_json).await?;
if !output.success {
let PreparedFsHelperCommand {
request,
#[cfg(target_os = "windows")]
_windows_wrapper_request_file,
} = command;
let mut child = spawn_child_command(request)?;
let mut stdin = child
.stdin
.take()
.ok_or_else(|| internal_error("failed to open fs sandbox helper stdin".to_string()))?;
stdin.write_all(&request_json).await.map_err(io_error)?;
stdin.shutdown().await.map_err(io_error)?;
drop(stdin);
let output = child.wait_with_output().await.map_err(io_error)?;
#[cfg(target_os = "windows")]
drop(_windows_wrapper_request_file);
if !output.status.success() {
return Err(internal_error(format!(
"fs sandbox helper failed with status {status}: {stderr}",
status = output.status,
@@ -363,35 +338,6 @@ async fn run_command(
}
}
struct FsHelperCommandOutput {
success: bool,
status: String,
stdout: Vec<u8>,
stderr: Vec<u8>,
}
async fn run_child_command(
command: PreparedFsHelperCommand,
request_json: Vec<u8>,
) -> Result<FsHelperCommandOutput, JSONRPCErrorError> {
let mut child = spawn_child_command(command.request)?;
let mut stdin = child
.stdin
.take()
.ok_or_else(|| internal_error("failed to open fs sandbox helper stdin".to_string()))?;
stdin.write_all(&request_json).await.map_err(io_error)?;
stdin.shutdown().await.map_err(io_error)?;
drop(stdin);
let output = child.wait_with_output().await.map_err(io_error)?;
Ok(FsHelperCommandOutput {
success: output.status.success(),
status: output.status.to_string(),
stdout: output.stdout,
stderr: output.stderr,
})
}
fn spawn_child_command(
SandboxExecRequest {
command: argv,
@@ -450,7 +396,6 @@ mod tests {
use crate::ExecServerRuntimePaths;
use super::FileSystemSandboxRunner;
use super::FsHelperLaunchPaths;
use super::add_helper_runtime_permissions;
use super::helper_env;
use super::helper_env_from_vars;
@@ -618,14 +563,8 @@ mod tests {
let permission_profile =
PermissionProfile::from_runtime_permissions(&file_system_policy, network_policy);
let sandbox_context = sandbox_context_with_cwd(&file_system_policy, cwd.clone());
let helper_paths = FsHelperLaunchPaths {
sandboxed_helper: runner.runtime_paths.codex_self_exe.clone(),
#[cfg(target_os = "windows")]
windows_wrapper: runner.runtime_paths.codex_self_exe.clone(),
};
let request = runner
.sandbox_exec_request(&permission_profile, &cwd, &sandbox_context, &helper_paths)
.sandbox_exec_request(&permission_profile, &cwd, &sandbox_context)
.expect("sandbox exec request");
assert_eq!(request.request.env.get(&path_key), Some(&path));
@@ -6,9 +6,33 @@ use codex_sandboxing::SandboxExecRequest;
use codex_utils_absolute_path::AbsolutePathBuf;
use crate::rpc::internal_error;
use crate::rpc::invalid_request;
const WINDOWS_SANDBOX_WRAPPER_SETUP_ENV_ALLOWLIST: &[&str] = &["USERNAME", "USERPROFILE"];
pub(super) fn materialize_sandboxed_helper(
request: &mut SandboxExecRequest,
source: &AbsolutePathBuf,
) -> Result<(), JSONRPCErrorError> {
let codex_home = codex_utils_home_dir::find_codex_home().map_err(|err| {
internal_error(format!(
"windows fs sandbox helper failed to resolve CODEX_HOME: {err}"
))
})?;
let helper =
codex_windows_sandbox::resolve_exe_for_launch(source.as_path(), codex_home.as_path());
let helper = AbsolutePathBuf::from_absolute_path(helper.as_path()).map_err(|err| {
internal_error(format!(
"windows fs sandbox helper path is not absolute: {err}"
))
})?;
let Some(program) = request.command.first_mut() else {
return Err(invalid_request("fs sandbox command was empty".to_string()));
};
*program = helper.as_path().to_string_lossy().into_owned();
Ok(())
}
pub(super) fn wrap_sandbox_exec_request(
request: &mut SandboxExecRequest,
helper: &AbsolutePathBuf,
@@ -136,17 +160,48 @@ impl Drop for WindowsSandboxWrapperRequestFile {
mod tests {
use std::collections::HashMap;
use std::ffi::OsString;
use std::path::PathBuf;
use codex_protocol::config_types::WindowsSandboxLevel;
use codex_protocol::models::PermissionProfile;
use codex_protocol::permissions::FileSystemSandboxPolicy;
use codex_protocol::permissions::NetworkSandboxPolicy;
use codex_sandboxing::SandboxExecRequest;
use codex_sandboxing::SandboxType;
use codex_utils_absolute_path::AbsolutePathBuf;
use pretty_assertions::assert_eq;
use super::WindowsSandboxWrapperRequestFile;
use super::add_wrapper_setup_env_from_vars;
use super::materialize_sandboxed_helper;
use super::wrapper_request_dir;
struct EnvVarGuard {
key: &'static str,
original: Option<OsString>,
}
impl EnvVarGuard {
fn set(key: &'static str, value: &std::ffi::OsStr) -> Self {
let original = std::env::var_os(key);
unsafe {
std::env::set_var(key, value);
}
Self { key, original }
}
}
impl Drop for EnvVarGuard {
fn drop(&mut self) {
unsafe {
match &self.original {
Some(value) => std::env::set_var(self.key, value),
None => std::env::remove_var(self.key),
}
}
}
}
#[test]
fn wrapper_setup_env_preserves_only_setup_identity() {
let mut env = HashMap::from([("PATH".to_string(), r"C:\Windows\System32".to_string())]);
@@ -209,4 +264,90 @@ mod tests {
assert!(!path.exists());
}
#[test]
fn materialized_helper_rewrites_inner_command_path() {
let codex_home = tempfile::TempDir::new().expect("codex home");
let _guard = EnvVarGuard::set("CODEX_HOME", codex_home.path().as_os_str());
let helper_dir = tempfile::TempDir::new().expect("helper dir");
let configured_helper = helper_dir.path().join("configured-codex-helper.exe");
std::fs::write(&configured_helper, b"helper").expect("write configured helper");
let configured_helper =
AbsolutePathBuf::from_absolute_path(&configured_helper).expect("absolute helper");
let cwd = AbsolutePathBuf::from_absolute_path(helper_dir.path()).expect("absolute cwd");
let file_system_sandbox_policy = FileSystemSandboxPolicy::read_only();
let mut request = SandboxExecRequest {
command: vec![
configured_helper.as_path().display().to_string(),
"--codex-run-as-fs-helper".to_string(),
],
cwd,
env: HashMap::new(),
network: None,
sandbox: SandboxType::WindowsRestrictedToken,
windows_sandbox_level: WindowsSandboxLevel::RestrictedToken,
windows_sandbox_private_desktop: false,
permission_profile: PermissionProfile::read_only(),
file_system_sandbox_policy,
network_sandbox_policy: NetworkSandboxPolicy::Restricted,
arg0: None,
};
materialize_sandboxed_helper(&mut request, &configured_helper)
.expect("materialize sandboxed helper");
let materialized_helper = PathBuf::from(&request.command[0]);
assert_eq!(
materialized_helper.file_name(),
configured_helper.as_path().file_name()
);
assert_eq!(
materialized_helper
.parent()
.and_then(std::path::Path::file_name),
Some(std::ffi::OsStr::new(".sandbox-bin"))
);
assert!(materialized_helper.exists());
}
#[test]
fn wrapper_request_preserves_elevated_level() {
let codex_home = tempfile::TempDir::new().expect("codex home");
let _guard = EnvVarGuard::set("CODEX_HOME", codex_home.path().as_os_str());
let command_cwd =
AbsolutePathBuf::from_absolute_path(codex_home.path()).expect("absolute command cwd");
let file_system_sandbox_policy = FileSystemSandboxPolicy::read_only();
let mut request = SandboxExecRequest {
command: vec![
"helper.exe".to_string(),
"--codex-run-as-fs-helper".to_string(),
],
cwd: command_cwd,
env: HashMap::new(),
network: None,
sandbox: SandboxType::WindowsRestrictedToken,
windows_sandbox_level: WindowsSandboxLevel::Elevated,
windows_sandbox_private_desktop: true,
permission_profile: PermissionProfile::read_only(),
file_system_sandbox_policy,
network_sandbox_policy: NetworkSandboxPolicy::Restricted,
arg0: None,
};
let wrapper = AbsolutePathBuf::from_absolute_path(codex_home.path().join("codex.exe"))
.expect("absolute wrapper");
let request_file = super::wrap_sandbox_exec_request(&mut request, &wrapper)
.expect("wrap sandbox exec request");
let wrapper_request: codex_windows_sandbox::WindowsSandboxWrapperRequest =
serde_json::from_slice(
&std::fs::read(&request_file.path).expect("read wrapper request"),
)
.expect("decode wrapper request");
assert_eq!(
wrapper_request.windows_sandbox_level,
WindowsSandboxLevel::Elevated
);
assert_eq!(wrapper_request.windows_sandbox_private_desktop, true);
}
}