Lightweight coding agent that runs in your terminal
Rust
Fix Windows sandbox ACL repair for long runtime paths (#49058)
Darius Kareldf3e439c02ef
diff --git a/codex-rs/windows-sandbox-rs/src/acl.rs b/codex-rs/windows-sandbox-rs/src/acl.rsindex a10e8cdd57..c91fb91a79 100644--- a/codex-rs/windows-sandbox-rs/src/acl.rs+++ b/codex-rs/windows-sandbox-rs/src/acl.rs@@ -99,23 +99,18 @@ fn acl_api_result(path: &Path, operation: &str, code: u32) -> Result<()> {/// # Safety/// Caller must free the returned security descriptor with `LocalFree` and pass an existing path.pub unsafe fn fetch_dacl_handle(path: &Path) -> Result<(*mut ACL, *mut c_void)> {- let wpath = to_wide(path);- let h = CreateFileW(- wpath.as_ptr(),- READ_CONTROL,- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,- std::ptr::null_mut(),- OPEN_EXISTING,- FILE_FLAG_BACKUP_SEMANTICS,- 0,- );- if h == INVALID_HANDLE_VALUE {- return Err(anyhow!("CreateFileW failed for {}", path.display()));- }+ // Rust's file opening supports extended-length paths without changing the+ // caller's spelling or resolving links before the existing reparse checks.+ let handle = OpenOptions::new()+ .access_mode(READ_CONTROL)+ .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)+ .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)+ .open(path)+ .with_context(|| format!("open ACL target {}", path.display()))?;let mut p_sd: *mut c_void = std::ptr::null_mut();let mut p_dacl: *mut ACL = std::ptr::null_mut();let code = GetSecurityInfo(- h,+ handle.as_raw_handle() as _,1, // SE_FILE_OBJECTDACL_SECURITY_INFORMATION,std::ptr::null_mut(),@@ -124,7 +119,6 @@ pub unsafe fn fetch_dacl_handle(path: &Path) -> Result<(*mut ACL, *mut c_void)>std::ptr::null_mut(),&mut p_sd,);- CloseHandle(h);if code != ERROR_SUCCESS {return Err(anyhow!("GetSecurityInfo failed for {}: {}",@@ -576,50 +570,51 @@ unsafe fn ensure_allow_mask_aces_with_inheritance_impl(},});}- let mut added = false;- if !entries.is_empty() {- let mut p_new_dacl: *mut ACL = std::ptr::null_mut();+ let mut p_new_dacl: *mut ACL = std::ptr::null_mut();+ // Collect errors before releasing either allocation so every update path+ // shares the same cleanup, including failure to open the write handle.+ let result = (|| -> Result<bool> {+ if entries.is_empty() {+ return Ok(false);+ }let code2 = SetEntriesInAclW(entries.len() as u32,entries.as_ptr(),p_dacl,&mut p_new_dacl,);- if code2 == ERROR_SUCCESS {- let code3 = SetNamedSecurityInfoW(- to_wide(path).as_ptr() as *mut u16,- 1,- DACL_SECURITY_INFORMATION,- std::ptr::null_mut(),- std::ptr::null_mut(),- p_new_dacl,- std::ptr::null_mut(),- );- if code3 == ERROR_SUCCESS {- added = true;- if !p_new_dacl.is_null() {- LocalFree(p_new_dacl as HLOCAL);- }- } else {- if !p_new_dacl.is_null() {- LocalFree(p_new_dacl as HLOCAL);- }- if !p_sd.is_null() {- LocalFree(p_sd as HLOCAL);- }- return Err(anyhow!("SetNamedSecurityInfoW failed: {code3}"));- }- } else {- if !p_sd.is_null() {- LocalFree(p_sd as HLOCAL);- }+ if code2 != ERROR_SUCCESS {return Err(anyhow!("SetEntriesInAclW failed: {code2}"));}+ // Keep no-op checks read-only; request ACL-write access only when+ // a grant actually needs updating. Use the same long-path support.+ let handle = OpenOptions::new()+ .access_mode(READ_CONTROL | WRITE_DAC)+ .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)+ .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)+ .open(path)+ .context("open ACL target for update")?;+ let code3 = SetSecurityInfo(+ handle.as_raw_handle() as _,+ 1,+ DACL_SECURITY_INFORMATION,+ std::ptr::null_mut(),+ std::ptr::null_mut(),+ p_new_dacl,+ std::ptr::null_mut(),+ );+ if code3 != ERROR_SUCCESS {+ return Err(anyhow!("SetSecurityInfo failed: {code3}"));+ }+ Ok(true)+ })();+ if !p_new_dacl.is_null() {+ LocalFree(p_new_dacl as HLOCAL);}if !p_sd.is_null() {LocalFree(p_sd as HLOCAL);}- Ok(added)+ result}/// Ensure all provided SIDs have an allow ACE with the requested mask on the path.diff --git a/codex-rs/windows-sandbox-rs/src/setup_provisioning/setup_runtime_bin.rs b/codex-rs/windows-sandbox-rs/src/setup_provisioning/setup_runtime_bin.rsindex 24965a7b56..c4173b8a86 100644--- a/codex-rs/windows-sandbox-rs/src/setup_provisioning/setup_runtime_bin.rs+++ b/codex-rs/windows-sandbox-rs/src/setup_provisioning/setup_runtime_bin.rs@@ -19,6 +19,10 @@ use windows_sys::Win32::Storage::FileSystem::FILE_GENERIC_READ;#[path = "setup_runtime_bin_tests.rs"]mod tests;+#[cfg(test)]+#[path = "setup_runtime_long_paths_tests.rs"]+mod long_paths_tests;+pub(super) fn ensure_codex_app_runtime_paths_readable(sandbox_group_psid: *mut c_void,refresh_errors: &mut Vec<String>,diff --git a/codex-rs/windows-sandbox-rs/src/setup_provisioning/setup_runtime_long_paths_tests.rs b/codex-rs/windows-sandbox-rs/src/setup_provisioning/setup_runtime_long_paths_tests.rsnew file mode 100644index 0000000000..4e5df34252--- /dev/null+++ b/codex-rs/windows-sandbox-rs/src/setup_provisioning/setup_runtime_long_paths_tests.rs@@ -0,0 +1,80 @@+//! Exercises runtime ACL repair beyond the legacy Windows path limit while preserving read-only grants.++use super::ensure_runtime_tree_readable;+use crate::LocalSid;+use crate::acl::grant_read_execute_aces;+use crate::path_mask_allows;+use std::fs;+use std::os::windows::ffi::OsStrExt;+use windows_sys::Win32::Storage::FileSystem::DELETE;+use windows_sys::Win32::Storage::FileSystem::FILE_APPEND_DATA;+use windows_sys::Win32::Storage::FileSystem::FILE_GENERIC_EXECUTE;+use windows_sys::Win32::Storage::FileSystem::FILE_GENERIC_READ;+use windows_sys::Win32::Storage::FileSystem::FILE_WRITE_DATA;+use windows_sys::Win32::Storage::FileSystem::WRITE_DAC;++#[test]+fn runtime_repair_handles_long_directory_and_file_paths() {+ let runtime = tempfile::tempdir().expect("runtime directory");+ let mut directory = runtime.path().join("dependency-cache");+ while directory.as_os_str().encode_wide().count() <= 280 {+ directory.push("a".repeat(60));+ }+ fs::create_dir_all(&directory).expect("long runtime directory");+ let module = directory.join("module.js");+ fs::write(&module, b"runtime content").expect("long runtime file");+ let short = runtime.path().join("short.js");+ fs::write(&short, b"short-path control").expect("short runtime file");+ let sandbox_sid = LocalSid::from_string("S-1-5-21-10-20-30-40").expect("test SID");++ for path in [&directory, &module, &short] {+ assert!(+ !path_mask_allows(+ path,+ &[sandbox_sid.as_ptr()],+ FILE_GENERIC_READ | FILE_GENERIC_EXECUTE,+ /*require_all_bits*/ true,+ )+ .expect("read ACL before repair")+ );+ // Exercise the write even for the nested file: a parent grant during+ // traversal could otherwise make its inherited ACL a read-only no-op.+ assert!(+ unsafe {+ grant_read_execute_aces(path, &[sandbox_sid.as_ptr()], /*inheritance*/ 0)+ }+ .expect("grant read/execute on the existing path")+ );+ }++ for _ in 0..2 {+ ensure_runtime_tree_readable(runtime.path(), sandbox_sid.as_ptr())+ .expect("repair the full runtime tree");+ for path in [&directory, &module, &short] {+ assert!(+ path_mask_allows(+ path,+ &[sandbox_sid.as_ptr()],+ FILE_GENERIC_READ | FILE_GENERIC_EXECUTE,+ /*require_all_bits*/ true,+ )+ .expect("read repaired ACL")+ );+ assert!(+ !path_mask_allows(+ path,+ &[sandbox_sid.as_ptr()],+ FILE_WRITE_DATA | FILE_APPEND_DATA | DELETE | WRITE_DAC,+ /*require_all_bits*/ false,+ )+ .expect("repair must not grant write or ACL management")+ );+ assert!(+ !unsafe {+ grant_read_execute_aces(path, &[sandbox_sid.as_ptr()], /*inheritance*/ 0)+ }+ .expect("an already-correct ACL is a no-op")+ );+ }+ }+}