diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index b2d5c0a75b..f24ae66962 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -1644,7 +1644,7 @@ impl CodexMessageProcessor { }; let exec_params = ExecParams { command, - cwd, + cwd: cwd.clone(), expiration, env, network: started_network_proxy @@ -1665,7 +1665,7 @@ impl CodexMessageProcessor { Some(policy) => match self.config.permissions.sandbox_policy.can_set(&policy) { Ok(()) => { let file_system_sandbox_policy = - codex_protocol::permissions::FileSystemSandboxPolicy::from(&policy); + codex_protocol::permissions::FileSystemSandboxPolicy::from_legacy_sandbox_policy(&policy, &cwd); let network_sandbox_policy = codex_protocol::permissions::NetworkSandboxPolicy::from(&policy); (policy, file_system_sandbox_policy, network_sandbox_policy) diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs index 20bbbbae65..9aa41deffc 100644 --- a/codex-rs/core/src/codex.rs +++ b/codex-rs/core/src/codex.rs @@ -960,18 +960,26 @@ impl SessionConfiguration { if let Some(approval_policy) = updates.approval_policy { next_configuration.approval_policy.set(approval_policy)?; } + let mut sandbox_or_cwd_changed = false; if let Some(sandbox_policy) = updates.sandbox_policy.clone() { next_configuration.sandbox_policy.set(sandbox_policy)?; - next_configuration.file_system_sandbox_policy = - FileSystemSandboxPolicy::from(next_configuration.sandbox_policy.get()); next_configuration.network_sandbox_policy = NetworkSandboxPolicy::from(next_configuration.sandbox_policy.get()); + sandbox_or_cwd_changed = true; } if let Some(windows_sandbox_level) = updates.windows_sandbox_level { next_configuration.windows_sandbox_level = windows_sandbox_level; } if let Some(cwd) = updates.cwd.clone() { next_configuration.cwd = cwd; + sandbox_or_cwd_changed = true; + } + if sandbox_or_cwd_changed { + next_configuration.file_system_sandbox_policy = + FileSystemSandboxPolicy::from_legacy_sandbox_policy( + next_configuration.sandbox_policy.get(), + &next_configuration.cwd, + ); } if let Some(app_server_client_name) = updates.app_server_client_name.clone() { next_configuration.app_server_client_name = Some(app_server_client_name); diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rs index f7ef78b26d..91c4665506 100644 --- a/codex-rs/core/src/config/mod.rs +++ b/codex-rs/core/src/config/mod.rs @@ -2004,7 +2004,8 @@ impl Config { } } } - let file_system_sandbox_policy = FileSystemSandboxPolicy::from(&sandbox_policy); + let file_system_sandbox_policy = + FileSystemSandboxPolicy::from_legacy_sandbox_policy(&sandbox_policy, &resolved_cwd); let network_sandbox_policy = NetworkSandboxPolicy::from(&sandbox_policy); ( configured_network_proxy_config, @@ -2330,7 +2331,10 @@ impl Config { if effective_sandbox_policy == original_sandbox_policy { file_system_sandbox_policy } else { - FileSystemSandboxPolicy::from(&effective_sandbox_policy) + FileSystemSandboxPolicy::from_legacy_sandbox_policy( + &effective_sandbox_policy, + &resolved_cwd, + ) }; let effective_network_sandbox_policy = if effective_sandbox_policy == original_sandbox_policy { diff --git a/codex-rs/core/src/landlock.rs b/codex-rs/core/src/landlock.rs index d022adbc78..e90daf37f2 100644 --- a/codex-rs/core/src/landlock.rs +++ b/codex-rs/core/src/landlock.rs @@ -33,7 +33,8 @@ pub async fn spawn_command_under_linux_sandbox

( where P: AsRef, { - let file_system_sandbox_policy = FileSystemSandboxPolicy::from(sandbox_policy); + let file_system_sandbox_policy = + FileSystemSandboxPolicy::from_legacy_sandbox_policy(sandbox_policy, sandbox_policy_cwd); let network_sandbox_policy = NetworkSandboxPolicy::from(sandbox_policy); let args = create_linux_sandbox_command_args_for_policies( command, diff --git a/codex-rs/core/src/safety.rs b/codex-rs/core/src/safety.rs index d2e74beed8..274262a55f 100644 --- a/codex-rs/core/src/safety.rs +++ b/codex-rs/core/src/safety.rs @@ -204,6 +204,7 @@ mod tests { use codex_protocol::protocol::FileSystemSpecialPath; use codex_protocol::protocol::RejectConfig; use codex_utils_absolute_path::AbsolutePathBuf; + use pretty_assertions::assert_eq; use tempfile::TempDir; #[test] @@ -403,4 +404,47 @@ mod tests { SafetyCheck::AskUser, ); } + + #[test] + fn explicit_read_only_subpaths_prevent_auto_approval_for_external_sandbox() { + let tmp = TempDir::new().unwrap(); + let cwd = tmp.path().to_path_buf(); + let blocked_path = cwd.join("docs").join("blocked.txt"); + let docs_absolute = AbsolutePathBuf::resolve_path_against_base("docs", &cwd).unwrap(); + let action = ApplyPatchAction::new_add_for_test(&blocked_path, "".to_string()); + let sandbox_policy = SandboxPolicy::ExternalSandbox { + network_access: codex_protocol::protocol::NetworkAccess::Restricted, + }; + let file_system_sandbox_policy = FileSystemSandboxPolicy::restricted(vec![ + FileSystemSandboxEntry { + path: FileSystemPath::Special { + value: FileSystemSpecialPath::CurrentWorkingDirectory, + }, + access: FileSystemAccessMode::Write, + }, + FileSystemSandboxEntry { + path: FileSystemPath::Path { + path: docs_absolute, + }, + access: FileSystemAccessMode::Read, + }, + ]); + + assert!(!is_write_patch_constrained_to_writable_paths( + &action, + &file_system_sandbox_policy, + &cwd, + )); + assert_eq!( + assess_patch_safety( + &action, + AskForApproval::OnRequest, + &sandbox_policy, + &file_system_sandbox_policy, + &cwd, + WindowsSandboxLevel::Disabled, + ), + SafetyCheck::AskUser, + ); + } } diff --git a/codex-rs/linux-sandbox/src/linux_run_main.rs b/codex-rs/linux-sandbox/src/linux_run_main.rs index 2f1b1b6b3c..e6304d2d60 100644 --- a/codex-rs/linux-sandbox/src/linux_run_main.rs +++ b/codex-rs/linux-sandbox/src/linux_run_main.rs @@ -233,7 +233,10 @@ fn resolve_sandbox_policies( } } (Some(sandbox_policy), None) => EffectiveSandboxPolicies { - file_system_sandbox_policy: FileSystemSandboxPolicy::from(&sandbox_policy), + file_system_sandbox_policy: FileSystemSandboxPolicy::from_legacy_sandbox_policy( + &sandbox_policy, + sandbox_policy_cwd, + ), network_sandbox_policy: NetworkSandboxPolicy::from(&sandbox_policy), sandbox_policy, }, diff --git a/codex-rs/protocol/src/permissions.rs b/codex-rs/protocol/src/permissions.rs index 4e2f2fbad7..abe9bc581b 100644 --- a/codex-rs/protocol/src/permissions.rs +++ b/codex-rs/protocol/src/permissions.rs @@ -163,6 +163,34 @@ impl FileSystemSandboxPolicy { } } + /// Converts a legacy sandbox policy into an equivalent filesystem policy + /// for the provided cwd. + /// + /// Legacy `WorkspaceWrite` policies may list readable roots that live + /// under an already-writable root. Those paths were redundant in the + /// legacy model and should not become read-only carveouts when projected + /// into split filesystem policy. + pub fn from_legacy_sandbox_policy(sandbox_policy: &SandboxPolicy, cwd: &Path) -> Self { + let mut file_system_policy = Self::from(sandbox_policy); + if matches!(sandbox_policy, SandboxPolicy::WorkspaceWrite { .. }) { + let legacy_writable_roots = sandbox_policy.get_writable_roots_with_cwd(cwd); + file_system_policy.entries.retain(|entry| { + if entry.access != FileSystemAccessMode::Read { + return true; + } + + match &entry.path { + FileSystemPath::Path { path } => !legacy_writable_roots + .iter() + .any(|root| root.is_path_writable(path.as_path())), + FileSystemPath::Special { .. } => true, + } + }); + } + + file_system_policy + } + /// Returns true when filesystem reads are unrestricted. pub fn has_full_disk_read_access(&self) -> bool { match self.kind { @@ -236,7 +264,13 @@ impl FileSystemSandboxPolicy { } let cwd_absolute = AbsolutePathBuf::from_absolute_path(cwd).ok(); - let unreadable_roots = self.get_unreadable_roots_with_cwd(cwd); + let read_only_roots = dedup_absolute_paths( + self.entries + .iter() + .filter(|entry| !entry.access.can_write()) + .filter_map(|entry| resolve_file_system_path(&entry.path, cwd_absolute.as_ref())) + .collect(), + ); let mut writable_roots = Vec::new(); if self.has_root_access(FileSystemAccessMode::can_write) && let Some(cwd_absolute) = cwd_absolute.as_ref() @@ -260,9 +294,13 @@ impl FileSystemSandboxPolicy { .into_iter() .map(|root| { let mut read_only_subpaths = default_read_only_subpaths_for_writable_root(&root); + // Narrower explicit non-write entries carve out broader writable roots. + // More specific write entries still remain writable because they appear + // as separate WritableRoot values and are checked independently. read_only_subpaths.extend( - unreadable_roots + read_only_roots .iter() + .filter(|path| path.as_path() != root.as_path()) .filter(|path| path.as_path().starts_with(root.as_path())) .cloned(), ); diff --git a/codex-rs/protocol/src/protocol.rs b/codex-rs/protocol/src/protocol.rs index f51e3e6b72..68df6b4486 100644 --- a/codex-rs/protocol/src/protocol.rs +++ b/codex-rs/protocol/src/protocol.rs @@ -3197,12 +3197,6 @@ mod tests { use tempfile::NamedTempFile; use tempfile::TempDir; - fn sorted_paths(paths: Vec) -> Vec { - let mut sorted: Vec = paths.into_iter().map(|path| path.to_path_buf()).collect(); - sorted.sort(); - sorted - } - fn sorted_writable_roots(roots: Vec) -> Vec<(PathBuf, Vec)> { let mut sorted_roots: Vec<(PathBuf, Vec)> = roots .into_iter() @@ -3220,6 +3214,53 @@ mod tests { sorted_roots } + fn sandbox_policy_allows_read(policy: &SandboxPolicy, path: &Path, cwd: &Path) -> bool { + if policy.has_full_disk_read_access() { + return true; + } + + policy + .get_readable_roots_with_cwd(cwd) + .iter() + .any(|root| path.starts_with(root.as_path())) + || policy + .get_writable_roots_with_cwd(cwd) + .iter() + .any(|root| path.starts_with(root.root.as_path())) + } + + fn sandbox_policy_allows_write(policy: &SandboxPolicy, path: &Path, cwd: &Path) -> bool { + if policy.has_full_disk_write_access() { + return true; + } + + policy + .get_writable_roots_with_cwd(cwd) + .iter() + .any(|root| root.is_path_writable(path)) + } + + fn sandbox_policy_probe_paths(policy: &SandboxPolicy, cwd: &Path) -> Vec { + let mut paths = vec![cwd.to_path_buf()]; + paths.extend( + policy + .get_readable_roots_with_cwd(cwd) + .into_iter() + .map(|path| path.to_path_buf()), + ); + for root in policy.get_writable_roots_with_cwd(cwd) { + paths.push(root.root.to_path_buf()); + paths.extend( + root.read_only_subpaths + .into_iter() + .map(|path| path.to_path_buf()), + ); + } + paths.sort(); + paths.dedup(); + paths + } + fn assert_same_sandbox_policy_semantics( expected: &SandboxPolicy, actual: &SandboxPolicy, @@ -3241,14 +3282,25 @@ mod tests { actual.include_platform_defaults(), expected.include_platform_defaults() ); - assert_eq!( - sorted_paths(actual.get_readable_roots_with_cwd(cwd)), - sorted_paths(expected.get_readable_roots_with_cwd(cwd)) - ); - assert_eq!( - sorted_writable_roots(actual.get_writable_roots_with_cwd(cwd)), - sorted_writable_roots(expected.get_writable_roots_with_cwd(cwd)) - ); + let mut probe_paths = sandbox_policy_probe_paths(expected, cwd); + probe_paths.extend(sandbox_policy_probe_paths(actual, cwd)); + probe_paths.sort(); + probe_paths.dedup(); + + for path in probe_paths { + assert_eq!( + sandbox_policy_allows_read(actual, &path, cwd), + sandbox_policy_allows_read(expected, &path, cwd), + "read access mismatch for {}", + path.display() + ); + assert_eq!( + sandbox_policy_allows_write(actual, &path, cwd), + sandbox_policy_allows_write(expected, &path, cwd), + "write access mismatch for {}", + path.display() + ); + } } #[test] @@ -3471,6 +3523,67 @@ mod tests { ); } + #[test] + fn restricted_file_system_policy_treats_read_entries_as_read_only_subpaths() { + let cwd = TempDir::new().expect("tempdir"); + let docs = + AbsolutePathBuf::resolve_path_against_base("docs", cwd.path()).expect("resolve docs"); + let docs_public = AbsolutePathBuf::resolve_path_against_base("docs/public", cwd.path()) + .expect("resolve docs/public"); + let policy = FileSystemSandboxPolicy::restricted(vec![ + FileSystemSandboxEntry { + path: FileSystemPath::Special { + value: FileSystemSpecialPath::CurrentWorkingDirectory, + }, + access: FileSystemAccessMode::Write, + }, + FileSystemSandboxEntry { + path: FileSystemPath::Path { path: docs.clone() }, + access: FileSystemAccessMode::Read, + }, + FileSystemSandboxEntry { + path: FileSystemPath::Path { + path: docs_public.clone(), + }, + access: FileSystemAccessMode::Write, + }, + ]); + + assert!(!policy.has_full_disk_write_access()); + assert_eq!( + sorted_writable_roots(policy.get_writable_roots_with_cwd(cwd.path())), + vec![ + (cwd.path().to_path_buf(), vec![docs.to_path_buf()]), + (docs_public.to_path_buf(), Vec::new()), + ] + ); + } + + #[test] + fn legacy_workspace_write_nested_readable_root_stays_writable() { + let cwd = TempDir::new().expect("tempdir"); + let docs = + AbsolutePathBuf::resolve_path_against_base("docs", cwd.path()).expect("resolve docs"); + let policy = SandboxPolicy::WorkspaceWrite { + writable_roots: vec![], + read_only_access: ReadOnlyAccess::Restricted { + include_platform_defaults: true, + readable_roots: vec![docs], + }, + network_access: false, + exclude_tmpdir_env_var: true, + exclude_slash_tmp: true, + }; + + assert_eq!( + sorted_writable_roots( + FileSystemSandboxPolicy::from_legacy_sandbox_policy(&policy, cwd.path()) + .get_writable_roots_with_cwd(cwd.path()) + ), + vec![(cwd.path().to_path_buf(), Vec::new())] + ); + } + #[test] fn file_system_policy_rejects_legacy_bridge_for_non_workspace_writes() { let cwd = if cfg!(windows) { @@ -3508,6 +3621,8 @@ mod tests { .expect("resolve readable root"); let writable_root = AbsolutePathBuf::resolve_path_against_base("writable", cwd.path()) .expect("resolve writable root"); + let nested_readable_root = AbsolutePathBuf::resolve_path_against_base("docs", cwd.path()) + .expect("resolve nested readable root"); let policies = [ SandboxPolicy::DangerFullAccess, SandboxPolicy::ExternalSandbox { @@ -3544,10 +3659,20 @@ mod tests { exclude_tmpdir_env_var: false, exclude_slash_tmp: true, }, + SandboxPolicy::WorkspaceWrite { + writable_roots: vec![], + read_only_access: ReadOnlyAccess::Restricted { + include_platform_defaults: true, + readable_roots: vec![nested_readable_root], + }, + network_access: false, + exclude_tmpdir_env_var: true, + exclude_slash_tmp: true, + }, ]; for expected in policies { - let actual = FileSystemSandboxPolicy::from(&expected) + let actual = FileSystemSandboxPolicy::from_legacy_sandbox_policy(&expected, cwd.path()) .to_legacy_sandbox_policy(NetworkSandboxPolicy::from(&expected), cwd.path()) .expect("legacy bridge should preserve legacy policy semantics");