Lightweight coding agent that runs in your terminal
Rust
Expand MXC volume grants and resolve deny globs (#44289)
iceweasel-oaid117c2eb02bb
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex ac41557e59..d735f833ad 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -4065,11 +4065,13 @@ dependencies = ["codex-protocol","codex-utils-absolute-path","codex-utils-path-uri",+ "codex-windows-sandbox","learning_mode_windows","pretty_assertions","tempfile","thiserror 2.0.18","tracelogging",+ "windows-sys 0.61.2","wxc_common",]diff --git a/codex-rs/mxc-sandbox/Cargo.toml b/codex-rs/mxc-sandbox/Cargo.tomlindex cf38f09e07..7623d17a45 100644--- a/codex-rs/mxc-sandbox/Cargo.toml+++ b/codex-rs/mxc-sandbox/Cargo.toml@@ -19,6 +19,7 @@ anyhow = { workspace = true }codex-protocol = { workspace = true }codex-utils-absolute-path = { workspace = true }codex-utils-path-uri = { workspace = true }+codex-windows-sandbox = { workspace = true }thiserror = { workspace = true }wxc_common = { workspace = true }@@ -27,6 +28,13 @@ appcontainer_common = { workspace = true }learning_mode_windows = { workspace = true }# 1.2.4 imports OneCore_apiset, which the GNU Windows toolchain does not ship.tracelogging = "=1.2.3"+windows-sys = { version = "0.61", features = [+ "Win32_Foundation",+ "Win32_Storage_FileSystem",+ "Win32_System_Com",+ "Win32_System_SystemInformation",+ "Win32_UI_Shell",+] }[dev-dependencies]pretty_assertions = { workspace = true }diff --git a/codex-rs/mxc-sandbox/src/policy.rs b/codex-rs/mxc-sandbox/src/policy.rsindex 9011a341d3..5d989458fe 100644--- a/codex-rs/mxc-sandbox/src/policy.rs+++ b/codex-rs/mxc-sandbox/src/policy.rs@@ -2,16 +2,24 @@//! access. Denies and read-only carveouts remain separate kernel policy lists.use std::collections::HashMap;+use std::collections::HashSet;use std::path::Path;use std::path::PathBuf;use codex_protocol::protocol::FileSystemPath;use codex_protocol::protocol::FileSystemSpecialPath;+use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathUri;+use codex_windows_sandbox::resolve_windows_deny_read_paths;use thiserror::Error;use wxc_common::cmdline::CommandLineContext;use wxc_common::cmdline::CommandLineError;use wxc_common::cmdline::cmdline_from_argv_for_context;+use wxc_common::filesystem_object::ExistingObjectComparison;+use wxc_common::filesystem_object::compare_existing_filesystem_objects;+use wxc_common::filesystem_object::normalize_object_conflicts;+use wxc_common::logger::Logger;+use wxc_common::logger::Mode;use wxc_common::models::ContainerPolicy;use wxc_common::models::ExecutionRequest;use wxc_common::models::FallbackPolicy;@@ -37,12 +45,18 @@ pub enum PolicyError {RelativeCommandCwd,#[error("MXC symbolic filesystem roots are not implemented")]SymbolicRoots,- #[error("MXC does not support filesystem deny glob patterns")]- DenyGlobs,#[error("MXC requires a Unicode command working directory")]NonUnicodeCommandCwd,#[error("MXC requires Unicode filesystem policy paths")]NonUnicodePolicyPath,+ #[error("{0}")]+ PolicyResolution(String),+ #[error("enumerate MXC volume {path}: {source}")]+ EnumerateVolume {+ path: PathBuf,+ #[source]+ source: std::io::Error,+ },#[error(transparent)]Path(#[from] std::io::Error),#[error(transparent)]@@ -53,6 +67,8 @@ pub fn build_request(command: &MxcCommand,command_cwd: &Path,env: Vec<String>,+ volume_roots: &[PathBuf],+ _platform_read_roots: &[PathBuf],) -> Result<ExecutionRequest, PolicyError> {if command.command.is_empty() {return Err(PolicyError::EmptyCommand);@@ -76,10 +92,6 @@ pub fn build_request({return Err(PolicyError::SymbolicRoots);}- if !fs.get_unreadable_globs_with_cwd(cwd).is_empty() {- return Err(PolicyError::DenyGlobs);- }-let roots = fs.get_writable_roots_with_cwd_preserving_mutable_paths(cwd);let mut write = collect_paths(roots.iter().map(|root| root.root.to_path_buf()))?;let mut read = collect_paths(@@ -88,10 +100,13 @@ pub fn build_request(.filter(|path| !fs.can_write_local_path_with_cwd(path.as_path(), cwd)).map(|path| path.to_path_buf()),)?;+ let absolute_cwd = AbsolutePathBuf::from_absolute_path(cwd)+ .map_err(|error| PolicyError::PolicyResolution(error.to_string()))?;let deny = collect_paths(- fs.get_unreadable_roots_with_cwd(cwd)+ resolve_windows_deny_read_paths(&fs, &absolute_cwd)+ .map_err(PolicyError::PolicyResolution)?.into_iter()- .map(|path| path.to_path_buf()),+ .map(AbsolutePathBuf::into_path_buf),)?;let carveouts = collect_paths(roots.into_iter().flat_map(|root| {let protected = root@@ -112,7 +127,30 @@ pub fn build_request(.map(|(key, path)| (key.clone(), path.clone())),);write.retain(|key, _| !carveouts.contains_key(key) && !deny.contains_key(key));- read.retain(|key, _| !deny.contains_key(key));+ read.retain(|key, _| !write.contains_key(key) && !deny.contains_key(key));+ let volume_roots = volume_roots+ .iter()+ .map(PathUri::from_host_native_path)+ .collect::<std::io::Result<HashSet<_>>>()?;+ prune_unavailable_volume_roots(&mut write, &volume_roots);+ prune_unavailable_volume_roots(&mut read, &volume_roots);+ // Normalize pre-expansion aliases so generated children inherit+ // any tightened access applied to their volume root.+ let normalized = normalize_policy(ContainerPolicy {+ readwrite_paths: unicode_paths(write)?,+ readonly_paths: unicode_paths(read)?,+ denied_paths: unicode_paths(deny)?,+ ..Default::default()+ })?;+ let write = collect_paths(normalized.readwrite_paths.into_iter().map(PathBuf::from))?;+ let read = collect_paths(normalized.readonly_paths.into_iter().map(PathBuf::from))?;+ let deny = collect_paths(normalized.denied_paths.into_iter().map(PathBuf::from))?;+ // If expansion skips an unavailable writable volume, its generated read-only+ // carveouts remain below. Pruning them requires retaining their root provenance,+ // so we accept that rare normalization failure for now.+ let mut write = expand_volume_roots(write, &volume_roots)?;+ write.retain(|key, _| !carveouts.contains_key(key) && !deny.contains_key(key));+ let mut read = expand_volume_roots(read, &volume_roots)?;// Resolve equal-path write overrides before reaching MXC so the native// API receives one effective access mode for each path identity.read.retain(|key, _| !write.contains_key(key) && !deny.contains_key(key));@@ -131,7 +169,7 @@ pub fn build_request(default: egress_default,..Default::default()};- Ok(ExecutionRequest {+ let mut request = ExecutionRequest {script_code: cmdline_from_argv_for_context(&command.command,CommandLineContext::WindowsCreateProcess,@@ -169,7 +207,77 @@ pub fn build_request(..Default::default()},..Default::default()- })+ };+ // Reconcile aliases introduced by expansion. MXC/PSEC separately enforces+ // restrictions on junction-resolved targets at access time.+ request.policy = normalize_policy(request.policy)?;+ Ok(request)+}++fn normalize_policy(mut policy: ContainerPolicy) -> Result<ContainerPolicy, PolicyError> {+ let mut logger = Logger::new(Mode::Buffer);+ if let Some(normalized) =+ normalize_object_conflicts(&policy, &mut logger).map_err(PolicyError::PolicyResolution)?+ {+ policy = normalized;+ }+ Ok(policy)+}++fn prune_unavailable_volume_roots(paths: &mut NativePaths, volume_roots: &HashSet<PathUri>) {+ paths.retain(|key, path| {+ if !volume_roots.contains(key) && path.parent().is_some() {+ return true;+ }+ match std::fs::read_dir(path) {+ Ok(_) => true,+ Err(error) => !inaccessible_volume(&error),+ }+ });+}++// MXC volume-root grants are nonrecursive, so snapshot each root's current+// immediate children as recursive grants. A child created directly under the+// root after policy construction is not granted. MXC/PSEC still enforces+// restrictions on junction-resolved targets at access time.+fn expand_volume_roots(+ paths: NativePaths,+ volume_roots: &HashSet<PathUri>,+) -> Result<NativePaths, PolicyError> {+ let mut expanded = NativePaths::new();+ for (key, path) in paths {+ if volume_roots.contains(&key) || path.parent().is_none() {+ match std::fs::read_dir(&path).and_then(Iterator::collect::<std::io::Result<Vec<_>>>) {+ Ok(entries) => {+ for entry in entries {+ let child = entry.path();+ if child.to_str().is_none() {+ continue;+ }+ // A self-comparison is MXC's public object-identity probe.+ // Generated grants can be skipped; explicit paths fail closed below.+ if compare_existing_filesystem_objects(&child, &child)+ != ExistingObjectComparison::Same+ {+ continue;+ }+ expanded.insert(PathUri::from_host_native_path(&child)?, child);+ }+ }+ // GetLogicalDrives includes disconnected and empty removable+ // drives. They must not prevent commands on available volumes.+ Err(error) if inaccessible_volume(&error) => continue,+ Err(error) => {+ return Err(PolicyError::EnumerateVolume {+ path,+ source: error,+ });+ }+ }+ }+ expanded.insert(key, path);+ }+ Ok(expanded)}fn collect_paths(paths: impl IntoIterator<Item = PathBuf>) -> Result<NativePaths, PolicyError> {@@ -179,6 +287,33 @@ fn collect_paths(paths: impl IntoIterator<Item = PathBuf>) -> Result<NativePaths.collect()}+fn inaccessible_volume(error: &std::io::Error) -> bool {+ if matches!(+ error.kind(),+ std::io::ErrorKind::PermissionDenied+ | std::io::ErrorKind::NotFound+ | std::io::ErrorKind::NetworkUnreachable+ | std::io::ErrorKind::HostUnreachable+ ) {+ return true;+ }+ #[cfg(windows)]+ {+ use windows_sys::Win32::Foundation::ERROR_BAD_NETPATH;+ use windows_sys::Win32::Foundation::ERROR_CONNECTION_UNAVAIL;+ use windows_sys::Win32::Foundation::ERROR_DEVICE_NOT_CONNECTED;+ use windows_sys::Win32::Foundation::ERROR_NOT_READY;+ matches!(+ error.raw_os_error().map(|code| code as u32),+ Some(ERROR_NOT_READY | ERROR_DEVICE_NOT_CONNECTED | ERROR_BAD_NETPATH)+ ) || error.raw_os_error() == Some(ERROR_CONNECTION_UNAVAIL as i32)+ }+ #[cfg(not(windows))]+ {+ false+ }+}+fn unicode_paths(paths: NativePaths) -> Result<Vec<String>, PolicyError> {let mut paths = paths.into_values()diff --git a/codex-rs/mxc-sandbox/src/policy_tests.rs b/codex-rs/mxc-sandbox/src/policy_tests.rsindex 83b091197f..49d8093295 100644--- a/codex-rs/mxc-sandbox/src/policy_tests.rs+++ b/codex-rs/mxc-sandbox/src/policy_tests.rs@@ -61,7 +61,7 @@ fn native_grants_preserve_denies_and_read_only_carveouts() -> Result<()> {]);let profile =PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted);- let request = build_request(&command(&profile, root), root, Vec::new())?;+ let request = build_request(&command(&profile, root), root, Vec::new(), &[], &[])?;let mut expected_read = [root.join(".agents"),root.join(".codex"),@@ -95,21 +95,171 @@ fn native_grants_preserve_denies_and_read_only_carveouts() -> Result<()> {}#[test]-fn unsupported_deny_globs_fail_before_launch() -> Result<()> {- let root = tempfile::tempdir()?;- let fs = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry::new(- FileSystemPath::GlobPattern {- pattern: "**/*.secret".to_owned(),- },- FileSystemAccessMode::Deny,- )]);+fn volume_expansion_does_not_turn_read_only_child_writable() -> Result<()> {+ let temp = tempfile::tempdir()?;+ let canonical = canonical_root(&temp)?;+ let root = canonical.as_path();+ let readonly = root.join("protected");+ let writable = root.join("work");+ std::fs::create_dir(&readonly)?;+ std::fs::create_dir(&writable)?;+ let fs = FileSystemSandboxPolicy::restricted(vec![+ entry(root, FileSystemAccessMode::Write)?,+ entry(&readonly, FileSystemAccessMode::Read)?,+ ]);+ let profile =+ PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted);+ let request = build_request(+ &command(&profile, root),+ root,+ Vec::new(),+ &[root.to_owned()],+ &[],+ )?;+ assert_eq!(+ request.policy.readwrite_paths,+ vec![root.to_str().unwrap(), writable.to_str().unwrap()]+ );+ assert_eq!(+ request.policy.readonly_paths,+ vec![+ root.join(".agents").to_str().unwrap(),+ root.join(".codex").to_str().unwrap(),+ root.join(".git").to_str().unwrap(),+ readonly.to_str().unwrap()+ ]+ );+ Ok(())+}++#[test]+fn volume_expansion_does_not_turn_read_only_alias_writable() -> Result<()> {+ let temp = tempfile::tempdir()?;+ let root = canonical_root(&temp)?;+ let readonly = root.join("protected");+ let alias = root.join("alias");+ std::fs::write(&readonly, "protected")?;+ std::fs::hard_link(&readonly, &alias)?;+ let fs = FileSystemSandboxPolicy::restricted(vec![+ entry(&root, FileSystemAccessMode::Write)?,+ entry(&readonly, FileSystemAccessMode::Read)?,+ ]);let profile =PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted);- let error =- build_request(&command(&profile, root.path()), root.path(), Vec::new()).unwrap_err();+ let request = build_request(+ &command(&profile, &root),+ &root,+ Vec::new(),+ std::slice::from_ref(&root),+ &[],+ )?;+ let alias = alias.display().to_string();assert_eq!(- error.to_string(),- "MXC does not support filesystem deny glob patterns"+ (+ request.policy.readwrite_paths.contains(&alias),+ request.policy.readonly_paths.contains(&alias),+ ),+ (false, true)+ );+ Ok(())+}++#[cfg(unix)]+#[test]+fn volume_expansion_uses_normalized_root_access() -> Result<()> {+ let temp = tempfile::tempdir()?;+ let root = canonical_root(&temp)?;+ let volume = root.join("volume");+ let child = volume.join("child");+ let alias = root.join("alias");+ std::fs::create_dir_all(&child)?;+ std::os::unix::fs::symlink(&volume, &alias)?;+ let fs = FileSystemSandboxPolicy::restricted(vec![+ entry(&volume, FileSystemAccessMode::Write)?,+ entry(&alias, FileSystemAccessMode::Read)?,+ ]);+ let profile =+ PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted);+ let request = build_request(+ &command(&profile, &root),+ &root,+ Vec::new(),+ std::slice::from_ref(&volume),+ &[],+ )?;+ let child = child.display().to_string();+ assert_eq!(+ (+ request.policy.readwrite_paths.contains(&child),+ request.policy.readonly_paths.contains(&child),+ ),+ (false, true)+ );+ Ok(())+}++#[cfg(unix)]+#[test]+fn volume_expansion_skips_uninspectable_children() -> Result<()> {+ let temp = tempfile::tempdir()?;+ let root = canonical_root(&temp)?;+ let uninspectable = root.join("loop");+ std::os::unix::fs::symlink(&uninspectable, &uninspectable)?;+ let denied = root.join("secret");+ std::fs::write(&denied, "secret")?;+ let fs = FileSystemSandboxPolicy::restricted(vec![+ entry(&root, FileSystemAccessMode::Write)?,+ entry(&denied, FileSystemAccessMode::Deny)?,+ ]);+ let profile =+ PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted);+ let request = build_request(+ &command(&profile, &root),+ &root,+ Vec::new(),+ std::slice::from_ref(&root),+ &[],+ )?;+ assert_eq!(+ (request.policy.readwrite_paths, request.policy.denied_paths),+ (+ vec![root.to_str().unwrap().to_owned()],+ vec![denied.to_str().unwrap().to_owned()],+ )+ );+ Ok(())+}++#[test]+fn deny_globs_expand_files_and_directories_before_launch() -> Result<()> {+ let temp = tempfile::tempdir()?;+ let root = canonical_root(&temp)?;+ let nested = root.join("nested");+ std::fs::create_dir(&nested)?;+ let file = nested.join("file.secret");+ let directory = nested.join("directory.secret");+ std::fs::write(&file, "secret")?;+ std::fs::create_dir(&directory)?;+ std::fs::write(nested.join("allowed.txt"), "allowed")?;+ let missing = root.join("explicit.secret");+ let fs = FileSystemSandboxPolicy::restricted(vec![+ entry(&root, FileSystemAccessMode::Write)?,+ entry(&missing, FileSystemAccessMode::Deny)?,+ FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: "**/*.secret".to_owned(),+ },+ FileSystemAccessMode::Deny,+ ),+ ]);+ let profile =+ PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted);+ let request = build_request(&command(&profile, &root), &nested, Vec::new(), &[], &[])?;+ let mut expected = [file, directory, missing];+ expected.sort();+ assert_eq!(+ request.policy.denied_paths,+ expected.map(|path| path.to_str().unwrap().to_owned()));Ok(())}@@ -125,8 +275,14 @@ fn relative_working_directories_fail_before_launch() -> Result<()> {(Path::new("relative"), root.path(), "policy"),(root.path(), Path::new("relative"), "command"),] {- let error =- build_request(&command(&profile, policy_cwd), command_cwd, Vec::new()).unwrap_err();+ let error = build_request(+ &command(&profile, policy_cwd),+ command_cwd,+ Vec::new(),+ &[],+ &[],+ )+ .unwrap_err();assert_eq!(error.to_string(),format!("MXC requires an absolute {kind} working directory")@@ -162,7 +318,8 @@ fn non_unicode_paths_fail_before_launch() -> Result<()> {)?]);let profile =PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted);- let error = build_request(&command(&profile, &root), command_cwd, Vec::new()).unwrap_err();+ let error = build_request(&command(&profile, &root), command_cwd, Vec::new(), &[], &[])+ .unwrap_err();assert_eq!(error.to_string(), expected);}Ok(())