Restrict filesystem helper sandbox access (#38561)

## Why

Filesystem helpers only need access to their own executables. Granting access to
the containing directories also makes unrelated sibling files readable.

## What changed

- Allow filesystem helpers to read the Codex and Linux sandbox executables
  directly instead of their parent directories.
- Give macOS filesystem helpers a narrower Seatbelt profile that omits the
  normal process sandbox's `/Applications` read access.
- Preserve the existing platform defaults for normal sandboxed processes.

## Testing

Add unit and integration coverage for direct and symlinked sibling-file access,
sandboxed copies, allowed workspace reads, and the macOS-specific Seatbelt
profiles.

GitOrigin-RevId: 9380c6868a695bdf2275baa74bd5e8a30a64ba1b
This commit is contained in:
jif
2026-08-14 11:47:12 +00:00
committed by copyberry
parent 486df09a00
commit 3134ab6572
6 changed files with 245 additions and 48 deletions
+30 -33
View File
@@ -118,7 +118,7 @@ impl FileSystemSandboxRunner {
sandbox_context: &FileSystemSandboxContext,
) -> Result<SandboxExecRequest, JSONRPCErrorError> {
let helper = &self.runtime_paths.codex_self_exe;
let sandbox_manager = SandboxManager::new();
let sandbox_manager = SandboxManager::for_file_system_helpers();
let sandbox = sandbox_manager.select_initial(
permission_profile,
SandboxablePreference::Require,
@@ -196,16 +196,11 @@ fn native_workspace_root(root: &PathUri) -> Result<AbsolutePathBuf, JSONRPCError
}
fn helper_read_roots(runtime_paths: &ExecServerRuntimePaths) -> Vec<AbsolutePathBuf> {
let mut roots = Vec::new();
for path in std::iter::once(runtime_paths.codex_self_exe.as_path())
.chain(runtime_paths.codex_linux_sandbox_exe.as_deref())
let mut roots = vec![runtime_paths.codex_self_exe.clone()];
if let Some(path) = &runtime_paths.codex_linux_sandbox_exe
&& !roots.contains(path)
{
if let Some(parent) = path.parent()
&& let Ok(root) = AbsolutePathBuf::from_absolute_path(parent)
&& !roots.contains(&root)
{
roots.push(root);
}
roots.push(path.clone());
}
roots
}
@@ -458,13 +453,7 @@ mod tests {
writable.clone(),
FileSystemAccessMode::Write,
)]);
let readable = AbsolutePathBuf::from_absolute_path(
runtime_paths
.codex_self_exe
.parent()
.expect("current exe parent"),
)
.expect("absolute readable path");
let readable = runtime_paths.codex_self_exe.clone();
add_helper_runtime_permissions(
&mut policy,
@@ -680,7 +669,7 @@ mod tests {
}
#[test]
fn helper_permissions_include_helper_read_root_without_additional_permissions() {
fn helper_permissions_include_only_the_helper_executable() {
let codex_self_exe = std::env::current_exe().expect("current exe");
let runtime_paths =
ExecServerRuntimePaths::new(codex_self_exe, /*codex_linux_sandbox_exe*/ None)
@@ -688,13 +677,11 @@ mod tests {
let cwd = AbsolutePathBuf::from_absolute_path(std::env::temp_dir().as_path())
.expect("absolute cwd");
let mut policy = restricted_policy(Vec::new());
let readable = AbsolutePathBuf::from_absolute_path(
runtime_paths
.codex_self_exe
.parent()
.expect("current exe parent"),
)
.expect("absolute readable path");
let parent = runtime_paths
.codex_self_exe
.parent()
.expect("current exe parent");
let sibling = parent.join("credentials.json");
add_helper_runtime_permissions(
&mut policy,
@@ -702,11 +689,15 @@ mod tests {
cwd.as_path(),
);
assert!(policy.can_read_path_with_cwd(readable.as_path(), cwd.as_path()));
assert!(
policy.can_read_path_with_cwd(runtime_paths.codex_self_exe.as_path(), cwd.as_path())
);
assert!(!policy.can_read_path_with_cwd(parent.as_path(), cwd.as_path()));
assert!(!policy.can_read_path_with_cwd(sibling.as_path(), cwd.as_path()));
}
#[test]
fn helper_permissions_include_linux_sandbox_alias_parent() {
fn helper_permissions_include_only_linux_sandbox_alias_executable() {
let root = tempfile::tempdir().expect("temp dir");
let codex_self_exe = root.path().join("bin").join("codex");
let codex_linux_sandbox_exe = root.path().join("aliases").join("codex-linux-sandbox");
@@ -716,10 +707,12 @@ mod tests {
let cwd = AbsolutePathBuf::from_absolute_path(std::env::temp_dir().as_path())
.expect("absolute cwd");
let mut policy = restricted_policy(Vec::new());
let codex_parent = AbsolutePathBuf::from_absolute_path(root.path().join("bin"))
.expect("absolute codex parent");
let alias_parent = AbsolutePathBuf::from_absolute_path(root.path().join("aliases"))
.expect("absolute alias parent");
let codex_parent = runtime_paths.codex_self_exe.parent().expect("codex parent");
let alias = runtime_paths
.codex_linux_sandbox_exe
.as_ref()
.expect("linux sandbox alias");
let alias_parent = alias.parent().expect("alias parent");
add_helper_runtime_permissions(
&mut policy,
@@ -727,8 +720,12 @@ mod tests {
cwd.as_path(),
);
assert!(policy.can_read_path_with_cwd(codex_parent.as_path(), cwd.as_path()));
assert!(policy.can_read_path_with_cwd(alias_parent.as_path(), cwd.as_path()));
assert!(
policy.can_read_path_with_cwd(runtime_paths.codex_self_exe.as_path(), cwd.as_path())
);
assert!(policy.can_read_path_with_cwd(alias.as_path(), cwd.as_path()));
assert!(!policy.can_read_path_with_cwd(codex_parent.as_path(), cwd.as_path()));
assert!(!policy.can_read_path_with_cwd(alias_parent.as_path(), cwd.as_path()));
}
fn restricted_policy(entries: Vec<FileSystemSandboxEntry>) -> FileSystemSandboxPolicy {
@@ -2,8 +2,14 @@ use anyhow::Context;
use anyhow::Result;
use codex_exec_server::CopyOptions;
use codex_exec_server::CreateDirectoryOptions;
#[cfg(unix)]
use codex_exec_server::ExecServerRuntimePaths;
#[cfg(unix)]
use codex_exec_server::ExecutorFileSystem;
use codex_exec_server::FILE_READ_CHUNK_SIZE;
use codex_exec_server::FileMetadata;
#[cfg(unix)]
use codex_exec_server::LocalFileSystem;
use codex_exec_server::ReadDirectoryEntry;
use codex_exec_server::RemoveOptions;
use codex_exec_server::WalkEntry;
@@ -703,6 +709,90 @@ async fn file_system_sandboxed_metadata_and_read_allow_readable_root(
Ok(())
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn sandboxed_file_operations_cannot_read_helper_siblings() -> Result<()> {
let helper_paths = crate::common::exec_server::test_codex_helper_paths()?;
let root = TempDir::new()?;
let runtime_dir = root.path().join("runtime");
let workspace = root.path().join("workspace");
std::fs::create_dir(&runtime_dir)?;
std::fs::create_dir(&workspace)?;
let helper = runtime_dir.join("codex-test-helper");
std::fs::hard_link(&helper_paths.codex_exe, &helper)
.or_else(|_| std::fs::copy(&helper_paths.codex_exe, &helper).map(|_| ()))?;
let linux_sandbox = if helper_paths.codex_linux_sandbox_exe.is_some() {
let alias = runtime_dir.join("codex-linux-sandbox");
std::fs::hard_link(&helper, &alias)
.or_else(|_| std::fs::copy(&helper, &alias).map(|_| ()))?;
Some(alias)
} else {
None
};
let file_system =
LocalFileSystem::with_runtime_paths(ExecServerRuntimePaths::new(helper, linux_sandbox)?);
let sibling = runtime_dir.join("credentials.json");
std::fs::write(&sibling, "secret")?;
let escaping_link = workspace.join("credentials-link");
std::os::unix::fs::symlink(&sibling, &escaping_link)?;
let sandbox = workspace_write_sandbox(workspace.clone());
let allowed_file = workspace.join("allowed.txt");
std::fs::write(&allowed_file, b"allowed")?;
let allowed_contents = file_system
.read_file(
&PathUri::from_host_native_path(&allowed_file)?,
Some(&sandbox),
)
.await?;
assert_eq!(allowed_contents, b"allowed");
#[cfg(target_os = "macos")]
assert!(
file_system
.read_directory(
&PathUri::from_host_native_path("/Applications")?,
Some(&sandbox)
)
.await
.is_err(),
"filesystem helpers should not inherit the normal process sandbox's /Applications access"
);
let sibling_uri = PathUri::from_host_native_path(&sibling)?;
let destination = PathUri::from_host_native_path(workspace.join("copied.json"))?;
for path in [sibling, escaping_link] {
let path = PathUri::from_host_native_path(path)?;
assert!(
file_system.read_file(&path, Some(&sandbox)).await.is_err(),
"sandboxed read unexpectedly accessed helper sibling {path}"
);
assert!(
file_system
.read_file_stream(&path, Some(&sandbox))
.await
.is_err(),
"sandboxed streaming unexpectedly accessed helper sibling {path}"
);
}
assert!(
file_system
.copy(
&sibling_uri,
&destination,
CopyOptions { recursive: false },
Some(&sandbox),
)
.await
.is_err(),
"sandboxed copy unexpectedly accessed helper sibling {sibling_uri}"
);
Ok(())
}
pub(crate) async fn assert_canonicalize_resolves_directory_alias(
implementation: FileSystemImplementation,
create_directory_alias: impl FnOnce(&Path, &Path) -> Result<()>,
+30 -14
View File
@@ -11,6 +11,8 @@ use crate::policy_transforms::should_require_platform_sandbox;
use crate::resolve_windows_elevated_filesystem_overrides;
#[cfg(target_os = "windows")]
use crate::resolve_windows_restricted_token_filesystem_overrides;
#[cfg(target_os = "macos")]
use crate::seatbelt::MacosSeatbeltProfile;
#[cfg(target_os = "windows")]
use crate::windows_sandbox_uses_elevated_backend;
use codex_network_proxy::ManagedNetworkSandboxContext;
@@ -262,11 +264,22 @@ impl std::error::Error for SandboxTransformError {
}
#[derive(Default)]
pub struct SandboxManager;
pub struct SandboxManager {
#[cfg(target_os = "macos")]
seatbelt_profile: MacosSeatbeltProfile,
}
impl SandboxManager {
pub fn new() -> Self {
Self
Self::default()
}
/// Creates a manager that applies the narrower runtime profile required by filesystem helpers.
pub fn for_file_system_helpers() -> Self {
Self {
#[cfg(target_os = "macos")]
seatbelt_profile: MacosSeatbeltProfile::FileSystemHelper,
}
}
pub fn select_initial(
@@ -347,23 +360,26 @@ impl SandboxManager {
SandboxType::MacosSeatbelt => {
use crate::seatbelt::CreateSeatbeltCommandArgsParams;
use crate::seatbelt::MACOS_PATH_TO_SEATBELT_EXECUTABLE;
use crate::seatbelt::create_seatbelt_command_args;
use crate::seatbelt::create_seatbelt_command_args_with_profile;
let pending = pending_sandboxed_request?;
let (file_system_sandbox_policy, network_sandbox_policy) = pending
.effective_permission_profile
.to_runtime_permissions();
let mut args = create_seatbelt_command_args(CreateSeatbeltCommandArgsParams {
command: os_argv_to_strings(argv),
file_system_sandbox_policy: &file_system_sandbox_policy,
network_sandbox_policy,
sandbox_policy_cwd: pending.native_sandbox_policy_cwd.as_path(),
enforce_managed_network,
managed_network,
environment_id,
network,
extra_allow_unix_sockets: &[],
})
let mut args = create_seatbelt_command_args_with_profile(
CreateSeatbeltCommandArgsParams {
command: os_argv_to_strings(argv),
file_system_sandbox_policy: &file_system_sandbox_policy,
network_sandbox_policy,
sandbox_policy_cwd: pending.native_sandbox_policy_cwd.as_path(),
enforce_managed_network,
managed_network,
environment_id,
network,
extra_allow_unix_sockets: &[],
},
self.seatbelt_profile,
)
.map_err(SandboxTransformError::EnvironmentNetworkProxy)?;
let mut full_command = Vec::with_capacity(1 + args.len());
full_command.push(MACOS_PATH_TO_SEATBELT_EXECUTABLE.to_string());
@@ -171,7 +171,6 @@
(allow file-read* (subpath "/Library/Preferences"))
(allow file-read* (subpath "/opt/homebrew/lib"))
(allow file-read* (subpath "/usr/local/lib"))
(allow file-read* (subpath "/Applications"))
; Terminal basics and device handles.
(allow file-read* (regex "^/dev/fd/(0|1|2)$"))
+19
View File
@@ -22,6 +22,15 @@ const MACOS_SEATBELT_BASE_POLICY: &str = include_str!("seatbelt_base_policy.sbpl
const MACOS_SEATBELT_NETWORK_POLICY: &str = include_str!("seatbelt_network_policy.sbpl");
const MACOS_RESTRICTED_READ_ONLY_PLATFORM_DEFAULTS: &str =
include_str!("restricted_read_only_platform_defaults.sbpl");
const MACOS_PROCESS_APPLICATIONS_READ_POLICY: &str =
r#"(allow file-read* (subpath "/Applications"))"#;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub(crate) enum MacosSeatbeltProfile {
#[default]
Process,
FileSystemHelper,
}
/// When working with `sandbox-exec`, only consider `sandbox-exec` in `/usr/bin`
/// to defend against an attacker trying to inject a malicious version on the
@@ -622,6 +631,13 @@ pub struct CreateSeatbeltCommandArgsParams<'a> {
pub fn create_seatbelt_command_args(
args: CreateSeatbeltCommandArgsParams<'_>,
) -> Result<Vec<String>, String> {
create_seatbelt_command_args_with_profile(args, MacosSeatbeltProfile::Process)
}
pub(crate) fn create_seatbelt_command_args_with_profile(
args: CreateSeatbeltCommandArgsParams<'_>,
profile: MacosSeatbeltProfile,
) -> Result<Vec<String>, String> {
let CreateSeatbeltCommandArgsParams {
command,
@@ -747,6 +763,9 @@ pub fn create_seatbelt_command_args(
];
if include_platform_defaults {
policy_sections.push(MACOS_RESTRICTED_READ_ONLY_PLATFORM_DEFAULTS.to_string());
if profile == MacosSeatbeltProfile::Process {
policy_sections.push(MACOS_PROCESS_APPLICATIONS_READ_POLICY.to_string());
}
}
let full_policy = policy_sections.join("\n");
+76
View File
@@ -1,11 +1,13 @@
use super::CreateSeatbeltCommandArgsParams;
use super::MACOS_PATH_TO_SEATBELT_EXECUTABLE;
use super::MACOS_SEATBELT_BASE_POLICY;
use super::MacosSeatbeltProfile;
use super::ProxyPolicyInputs;
use super::UnixDomainSocketPolicy;
use super::build_seatbelt_unreadable_glob_policy;
use super::create_seatbelt_command_args;
use super::create_seatbelt_command_args_for_legacy_policy;
use super::create_seatbelt_command_args_with_profile;
use super::dynamic_network_policy;
use super::normalize_path_for_sandbox;
use super::seatbelt_regex_for_unreadable_glob;
@@ -122,6 +124,80 @@ fn base_policy_allows_kmp_registration_shm_read_create_and_unlink() {
);
}
#[test]
fn filesystem_helper_platform_defaults_do_not_grant_applications_directory() {
let workspace = TempDir::new().expect("temp workspace");
let workspace_root = AbsolutePathBuf::from_absolute_path(workspace.path())
.expect("workspace path should be absolute");
let file_system_policy = FileSystemSandboxPolicy::restricted(vec![
FileSystemSandboxEntry::new(
FileSystemPath::Path {
path: workspace_root,
},
FileSystemAccessMode::Read,
),
FileSystemSandboxEntry::new(
FileSystemPath::Special {
value: FileSystemSpecialPath::Minimal,
},
FileSystemAccessMode::Read,
),
]);
let list_directory = |path: &Path, profile: MacosSeatbeltProfile| {
let args = create_seatbelt_command_args_with_profile(
CreateSeatbeltCommandArgsParams {
command: vec!["/bin/ls".to_string(), path.display().to_string()],
file_system_sandbox_policy: &file_system_policy,
network_sandbox_policy: NetworkSandboxPolicy::Restricted,
sandbox_policy_cwd: workspace.path(),
enforce_managed_network: false,
managed_network: None,
environment_id: None,
network: None,
extra_allow_unix_sockets: &[],
},
profile,
)
.expect("build restricted seatbelt command");
Command::new(MACOS_PATH_TO_SEATBELT_EXECUTABLE)
.args(args)
.current_dir(workspace.path())
.output()
.expect("run restricted seatbelt command")
};
let allowed = list_directory(workspace.path(), MacosSeatbeltProfile::FileSystemHelper);
let allowed_stderr = String::from_utf8_lossy(&allowed.stderr);
if !allowed.status.success()
&& allowed_stderr.contains("sandbox-exec: sandbox_apply: Operation not permitted")
{
return;
}
assert!(
allowed.status.success(),
"the explicitly allowed workspace should remain readable: {allowed_stderr}"
);
let process_allowed = list_directory(Path::new("/Applications"), MacosSeatbeltProfile::Process);
let process_allowed_stderr = String::from_utf8_lossy(&process_allowed.stderr);
assert!(
process_allowed.status.success(),
"normal process sandboxes should preserve /Applications access: {process_allowed_stderr}"
);
let denied = list_directory(
Path::new("/Applications"),
MacosSeatbeltProfile::FileSystemHelper,
);
let denied_stderr = String::from_utf8_lossy(&denied.stderr);
assert!(
!denied.status.success() && denied_stderr.contains("Operation not permitted"),
"filesystem helper platform defaults should not grant /Applications: {denied_stderr}"
);
}
#[test]
fn create_seatbelt_args_routes_network_through_proxy_ports() {
let policy = dynamic_network_policy(