Lightweight coding agent that runs in your terminal
Rust
Propagate Windows sandbox ACL update failures (#39279)
iceweasel-oai88c39c457891
diff --git a/codex-rs/windows-sandbox-rs/src/acl.rs b/codex-rs/windows-sandbox-rs/src/acl.rsindex 97e5726edb..e35777ab78 100644--- a/codex-rs/windows-sandbox-rs/src/acl.rs+++ b/codex-rs/windows-sandbox-rs/src/acl.rs@@ -56,6 +56,14 @@ const GENERIC_READ_MASK: u32 = 0x8000_0000;const GENERIC_WRITE_MASK: u32 = 0x4000_0000;const DENY_ACCESS: i32 = 3;+fn acl_api_result(path: &Path, operation: &str, code: u32) -> Result<()> {+ if code == ERROR_SUCCESS {+ Ok(())+ } else {+ Err(anyhow!("{operation} failed for {}: {code}", path.display()))+ }+}+/// Fetch DACL via handle-based query; caller must LocalFree the returned SD.////// # Safety@@ -625,10 +633,17 @@ unsafe fn add_deny_ace(path: &Path, psid: *mut c_void, kind: DenyAceKind) -> Res&mut p_sd,);if code != ERROR_SUCCESS {- return Err(anyhow!("GetNamedSecurityInfoW failed: {code}"));+ if !p_sd.is_null() {+ LocalFree(p_sd as HLOCAL);+ }+ return Err(anyhow!(+ "GetNamedSecurityInfoW failed for {}: {code}",+ path.display()+ ));}- let mut added = false;- if !kind.already_present(p_dacl, psid) {+ let result = if kind.already_present(p_dacl, psid) {+ Ok(false)+ } else {let trustee = TRUSTEE_W {pMultipleTrustee: std::ptr::null_mut(),MultipleTrusteeOperation: 0,@@ -643,7 +658,9 @@ unsafe fn add_deny_ace(path: &Path, psid: *mut c_void, kind: DenyAceKind) -> Resexplicit.Trustee = trustee;let mut p_new_dacl: *mut ACL = std::ptr::null_mut();let code2 = SetEntriesInAclW(1, &explicit, p_dacl, &mut p_new_dacl);- if code2 == ERROR_SUCCESS {+ let result = if let Err(err) = acl_api_result(path, "SetEntriesInAclW", code2) {+ Err(err)+ } else {let code3 = SetNamedSecurityInfoW(to_wide(path).as_ptr() as *mut u16,1,@@ -653,18 +670,17 @@ unsafe fn add_deny_ace(path: &Path, psid: *mut c_void, kind: DenyAceKind) -> Resp_new_dacl,std::ptr::null_mut(),);- if code3 == ERROR_SUCCESS {- added = true;- }- if !p_new_dacl.is_null() {- LocalFree(p_new_dacl as HLOCAL);- }+ acl_api_result(path, "SetNamedSecurityInfoW", code3).map(|()| true)+ };+ if !p_new_dacl.is_null() {+ LocalFree(p_new_dacl as HLOCAL);}- }+ result+ };if !p_sd.is_null() {LocalFree(p_sd as HLOCAL);}- Ok(added)+ result}/// Adds a deny ACE to prevent reads for the given SID on the target path.@@ -680,6 +696,10 @@ pub unsafe fn add_deny_read_ace(path: &Path, psid: *mut c_void) -> Result<bool>add_deny_ace(path, psid, DenyAceKind::Read)}+#[cfg(test)]+#[path = "acl_tests.rs"]+mod tests;+pub unsafe fn revoke_ace(path: &Path, psid: *mut c_void) {let mut p_sd: *mut c_void = std::ptr::null_mut();let mut p_dacl: *mut ACL = std::ptr::null_mut();diff --git a/codex-rs/windows-sandbox-rs/src/acl_tests.rs b/codex-rs/windows-sandbox-rs/src/acl_tests.rsnew file mode 100644index 0000000000..96ad375ceb--- /dev/null+++ b/codex-rs/windows-sandbox-rs/src/acl_tests.rs@@ -0,0 +1,15 @@+use super::acl_api_result;+use pretty_assertions::assert_eq;+use windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED;++#[test]+fn deny_ace_update_failure_is_an_error() {+ let path = std::path::Path::new(r"C:\world-writable");+ let error = acl_api_result(path, "SetNamedSecurityInfoW", ERROR_ACCESS_DENIED)+ .expect_err("access denied must not look like an already-present ACE");++ assert_eq!(+ error.to_string(),+ r"SetNamedSecurityInfoW failed for C:\world-writable: 5"+ );+}diff --git a/codex-rs/windows-sandbox-rs/src/audit.rs b/codex-rs/windows-sandbox-rs/src/audit.rsindex 58dd15c2c8..5dd2a58466 100644--- a/codex-rs/windows-sandbox-rs/src/audit.rs+++ b/codex-rs/windows-sandbox-rs/src/audit.rs@@ -12,6 +12,7 @@ use crate::setup::effective_write_roots_for_permissions;use crate::token::LocalSid;use crate::token::world_sid;use anyhow::Result;+use anyhow::anyhow;use std::collections::HashSet;use std::ffi::OsStr;use std::ffi::c_void;@@ -228,20 +229,21 @@ pub fn apply_world_writable_scan_and_denies_for_permissions(if flagged.is_empty() {return Ok(());}- if let Err(err) = apply_capability_denies_for_world_writable_for_permissions(+ let result = apply_capability_denies_for_world_writable_for_permissions(codex_home,&flagged,permissions,cwd,env_map,logs_base_dir,- ) {+ );+ if let Err(err) = &result {log_note(&format!("AUDIT: failed to apply capability deny ACEs: {err}"),logs_base_dir,);}- Ok(())+ result}fn apply_capability_denies_for_world_writable_for_permissions(@@ -282,6 +284,23 @@ fn apply_capability_denies_for_world_writable_for_permissions(} else {(vec![LocalSid::from_string(&caps.readonly)?], Vec::new())};+ apply_capability_denies_to_paths(+ flagged,+ &workspace_roots,+ &active_sids,+ logs_base_dir,+ |path, sid| unsafe { add_deny_write_ace(path, sid) },+ )+}++fn apply_capability_denies_to_paths(+ flagged: &[PathBuf],+ workspace_roots: &[PathBuf],+ active_sids: &[LocalSid],+ logs_base_dir: Option<&Path>,+ mut apply_deny: impl FnMut(&Path, *mut c_void) -> Result<bool>,+) -> Result<()> {+ let mut errors = Vec::new();for path in flagged {if workspace_roots.iter()@@ -289,31 +308,39 @@ fn apply_capability_denies_for_world_writable_for_permissions({continue;}- for active_sid in &active_sids {- let res = unsafe { add_deny_write_ace(path, active_sid.as_ptr()) };- match res {+ for active_sid in active_sids {+ match apply_deny(path, active_sid.as_ptr()) {Ok(true) => log_note(&format!("AUDIT: applied capability deny ACE to {}", path.display()),logs_base_dir,),Ok(false) => {}- Err(err) => log_note(- &format!(+ Err(err) => {+ let error = format!("AUDIT: failed to apply capability deny ACE to {}: {}",path.display(),err- ),- logs_base_dir,- ),+ );+ log_note(&error, logs_base_dir);+ errors.push(error);+ }}}}- Ok(())+ if errors.is_empty() {+ Ok(())+ } else {+ Err(anyhow!(errors.join("; ")))+ }}#[cfg(test)]mod tests {+ use super::apply_capability_denies_to_paths;use super::gather_candidates;+ use crate::token::LocalSid;+ use anyhow::anyhow;+ use pretty_assertions::assert_eq;use std::collections::HashMap;use std::fs;@@ -347,4 +374,27 @@ mod tests {assert!(candidates.contains(&canon_b));assert!(candidates.contains(&canon_space));}++ #[test]+ fn deny_ace_failure_is_propagated_after_other_paths_are_attempted() {+ let failed_path = std::path::PathBuf::from(r"C:\failed");+ let successful_path = std::path::PathBuf::from(r"C:\protected");+ let flagged = vec![failed_path.clone(), successful_path];+ let active_sids = vec![LocalSid::from_string("S-1-1-0").expect("world SID")];+ let mut attempted = Vec::new();++ let error =+ apply_capability_denies_to_paths(&flagged, &[], &active_sids, None, |path, _sid| {+ attempted.push(path.to_path_buf());+ if path == failed_path {+ Err(anyhow!("access denied"))+ } else {+ Ok(true)+ }+ })+ .expect_err("a failed deny ACE must fail preflight");++ assert_eq!(attempted, flagged);+ assert!(error.to_string().contains(r"C:\failed"));+ }}