Files
codex/codex-rs/windows-sandbox-rs/src/wrapper_tests.rs
T
malsamiri-oai c8c1ee5da8 Transport large Windows sandbox launch payloads through the environment (#47919)
## Why

Expanded recursive deny lists can exceed the Windows command-line limit, preventing sandbox wrappers and setup helpers from launching.

## What changed

- Use chunked environment transport for wrapper and non-elevating setup payloads above 24,000 UTF-16 code units, preserving the existing argument protocol for smaller requests.
- Share the transport with the MXC launcher, supporting payloads up to 16 MiB with Unicode-safe chunking and validation.
- Keep transport variables out of the workload environment and remove inherited chunks before launching setup helpers.

## Testing

Add coverage for transport boundaries, Unicode round trips, malformed payload rejection, environment cleanup, and large payloads crossing Windows process creation. Extend the elevated sandbox integration test with 1,000 nested denied files to verify read restrictions and `AGENTS.md` discovery with a payload exceeding the command-line limit.

GitOrigin-RevId: 8ef92fdc7d534143f0eac76036a2173a6f585d08
2026-09-24 19:15:17 +00:00

196 lines
7.9 KiB
Rust

use std::collections::HashMap;
use std::path::Path;
use std::path::PathBuf;
use codex_protocol::config_types::WindowsSandboxLevel;
use codex_protocol::models::PermissionProfile;
use codex_utils_absolute_path::AbsolutePathBuf;
use pretty_assertions::assert_eq;
use super::CODEX_HOME_FLAG;
use super::CODEX_WINDOWS_SANDBOX_ARG1;
use super::COMMAND_CWD_FLAG;
use super::DENY_READ_PATHS_JSON_FLAG;
use super::DENY_WRITE_PATHS_JSON_FLAG;
use super::ENV_JSON_FLAG;
use super::NETWORK_PROXY_RESTRICTING_SID_FLAG;
use super::PERMISSION_PROFILE_FLAG;
use super::PRESERVE_PROXY_SETTINGS_FLAG;
use super::PRIVATE_DESKTOP_NAME_FLAG;
use super::PROXY_ENFORCED_FLAG;
use super::READ_ROOTS_INCLUDE_PLATFORM_DEFAULTS_FLAG;
use super::READ_ROOTS_JSON_FLAG;
use super::SANDBOX_LEVEL_FLAG;
use super::WORKSPACE_ROOT_FLAG;
use super::WRITE_ROOTS_JSON_FLAG;
use super::create_windows_sandbox_command_args_for_permission_profile;
use super::parse_windows_sandbox_wrapper_args;
#[test]
fn large_deny_list_uses_environment_without_changing_the_request() {
let temp = tempfile::tempdir().expect("tempdir");
let cwd = AbsolutePathBuf::from_absolute_path(temp.path()).expect("absolute command cwd");
let paths = (0..1000)
.map(|index| {
AbsolutePathBuf::from_absolute_path(format!(r"C:\private\nested\file-{index}.txt"))
.unwrap()
})
.collect::<Vec<_>>();
let expected_env = HashMap::from([("Path".to_string(), r"C:\Windows\System32".to_string())]);
let mut env = expected_env.clone();
crate::environment_transport::encode("must not reach workload", &mut env).unwrap();
let profile = PermissionProfile::read_only();
let command = vec![
"codex.exe".to_string(),
"--codex-run-as-fs-helper".to_string(),
];
let args = create_windows_sandbox_command_args_for_permission_profile(
command.clone(),
&cwd,
std::slice::from_ref(&cwd),
&mut env,
&profile,
WindowsSandboxLevel::RestrictedToken,
/*proxy_enforced*/ true,
/*network_proxy_restricting_sid*/ Some("S-1-5-21-100-200-300-400"),
crate::WindowsSandboxProxySettingsMode::Preserve,
/*read_roots_override*/ None,
/*read_roots_include_platform_defaults*/ true,
/*write_roots_override*/ None,
&paths,
&paths,
temp.path(),
)
.unwrap();
assert_eq!(
args,
vec![CODEX_WINDOWS_SANDBOX_ARG1, crate::launch_environment::ARG]
);
let decoded = crate::environment_transport::decode(env).unwrap();
let parsed =
parse_windows_sandbox_wrapper_args(serde_json::from_str(&decoded).unwrap()).unwrap();
let desktop = crate::desktop::LaunchDesktop::open_private(&parsed.private_desktop_name)
.expect("wrapper must receive a live private desktop");
drop(desktop);
assert_eq!(parsed.deny_read_paths_override, paths);
assert_eq!(parsed.deny_write_paths_override, paths);
assert_eq!(parsed.env_map, expected_env);
assert_eq!(parsed.permission_profile, profile);
assert_eq!(parsed.command, command);
assert_eq!(parsed.command_cwd, cwd);
assert_eq!(parsed.workspace_roots, vec![cwd]);
assert_eq!(parsed.proxy_enforced, true);
assert_eq!(parsed.read_roots_include_platform_defaults, true);
assert_eq!(
parsed.network_proxy_restricting_sid.as_deref(),
Some("S-1-5-21-100-200-300-400")
);
assert_eq!(
parsed.proxy_settings_mode,
crate::WindowsSandboxProxySettingsMode::Preserve
);
}
#[test]
fn windows_wrapper_args_round_trip() {
let temp = tempfile::tempdir().expect("tempdir");
let command_cwd =
AbsolutePathBuf::from_absolute_path(temp.path()).expect("absolute command cwd");
let workspace_roots = vec![
command_cwd.clone(),
AbsolutePathBuf::from_absolute_path(Path::new(r"D:\other-workspace"))
.expect("absolute workspace root"),
];
let mut env = HashMap::from([("Path".to_string(), r"C:\Windows\System32".to_string())]);
let permission_profile = PermissionProfile::read_only();
let read_roots_override = vec![PathBuf::from(r"C:\read")];
let write_roots_override = vec![PathBuf::from(r"C:\write")];
let deny_read_paths_override = vec![
AbsolutePathBuf::from_absolute_path(Path::new(r"C:\blocked-read"))
.expect("absolute deny-read"),
];
let deny_write_paths_override = vec![
AbsolutePathBuf::from_absolute_path(Path::new(r"C:\blocked-write"))
.expect("absolute deny-write"),
];
let args = create_windows_sandbox_command_args_for_permission_profile(
vec![
"codex.exe".to_string(),
"--codex-run-as-fs-helper".to_string(),
],
&command_cwd,
workspace_roots.as_slice(),
&mut env,
&permission_profile,
WindowsSandboxLevel::RestrictedToken,
/*proxy_enforced*/ true,
/*network_proxy_restricting_sid*/ Some("S-1-5-21-100-200-300-400"),
crate::WindowsSandboxProxySettingsMode::Preserve,
Some(read_roots_override.as_slice()),
/*read_roots_include_platform_defaults*/ true,
Some(write_roots_override.as_slice()),
deny_read_paths_override.as_slice(),
deny_write_paths_override.as_slice(),
temp.path(),
)
.expect("build wrapper args");
assert_eq!(args[0], CODEX_WINDOWS_SANDBOX_ARG1);
assert!(args.contains(&CODEX_HOME_FLAG.to_string()));
assert!(args.contains(&COMMAND_CWD_FLAG.to_string()));
assert!(args.contains(&WORKSPACE_ROOT_FLAG.to_string()));
assert!(args.contains(&PERMISSION_PROFILE_FLAG.to_string()));
assert!(args.contains(&ENV_JSON_FLAG.to_string()));
assert!(args.contains(&SANDBOX_LEVEL_FLAG.to_string()));
assert!(args.contains(&PROXY_ENFORCED_FLAG.to_string()));
assert!(args.contains(&NETWORK_PROXY_RESTRICTING_SID_FLAG.to_string()));
assert!(args.contains(&PRESERVE_PROXY_SETTINGS_FLAG.to_string()));
assert!(args.contains(&READ_ROOTS_JSON_FLAG.to_string()));
assert!(args.contains(&READ_ROOTS_INCLUDE_PLATFORM_DEFAULTS_FLAG.to_string()));
assert!(args.contains(&WRITE_ROOTS_JSON_FLAG.to_string()));
assert!(args.contains(&DENY_READ_PATHS_JSON_FLAG.to_string()));
assert!(args.contains(&DENY_WRITE_PATHS_JSON_FLAG.to_string()));
let parsed =
parse_windows_sandbox_wrapper_args(args[1..].to_vec()).expect("parse wrapper args");
assert_eq!(
parsed.command,
vec!["codex.exe", "--codex-run-as-fs-helper"]
);
assert_eq!(parsed.command_cwd, command_cwd);
assert_eq!(parsed.workspace_roots, workspace_roots);
assert_eq!(parsed.env_map, env);
assert_eq!(parsed.permission_profile, permission_profile);
assert_eq!(
parsed.windows_sandbox_level,
WindowsSandboxLevel::RestrictedToken
);
let desktop = crate::desktop::LaunchDesktop::open_private(&parsed.private_desktop_name)
.expect("wrapper must receive a live private desktop");
drop(desktop);
assert_eq!(parsed.proxy_enforced, true);
assert_eq!(
parsed.network_proxy_restricting_sid.as_deref(),
Some("S-1-5-21-100-200-300-400")
);
assert_eq!(
parsed.proxy_settings_mode,
crate::WindowsSandboxProxySettingsMode::Preserve
);
assert_eq!(parsed.read_roots_override, Some(read_roots_override));
assert_eq!(parsed.read_roots_include_platform_defaults, true);
assert_eq!(parsed.write_roots_override, Some(write_roots_override));
assert_eq!(parsed.deny_read_paths_override, deny_read_paths_override);
assert_eq!(parsed.deny_write_paths_override, deny_write_paths_override);
let mut missing_desktop_args = args[1..].to_vec();
let name_index = missing_desktop_args
.iter()
.position(|arg| arg == PRIVATE_DESKTOP_NAME_FLAG)
.expect("private desktop name argument");
missing_desktop_args.drain(name_index..name_index + 2);
assert!(parse_windows_sandbox_wrapper_args(missing_desktop_args).is_err());
}