Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Restrict Windows sandbox default object access to the logon session (#47361)

viyatb-oaic6ad6f33eb1f
diff --git a/codex-rs/windows-sandbox-rs/src/token.rs b/codex-rs/windows-sandbox-rs/src/token.rs
index 2fa88012bf..4f8e437af8 100644
--- a/codex-rs/windows-sandbox-rs/src/token.rs
+++ b/codex-rs/windows-sandbox-rs/src/token.rs
@@ -51,27 +51,32 @@ struct TokenDefaultDaclInfo {
default_dacl: *mut ACL,
}
-/// Sets a permissive default DACL so sandboxed processes can create pipes/IPC objects
-/// without hitting ACCESS_DENIED when PowerShell builds pipelines.
-unsafe fn set_default_dacl(h_token: HANDLE, sids: &[*mut c_void]) -> Result<()> {
- if sids.is_empty() {
- return Ok(());
- }
- let entries: Vec<EXPLICIT_ACCESS_W> = sids
- .iter()
- .map(|sid| EXPLICIT_ACCESS_W {
- grfAccessPermissions: GENERIC_ALL,
- grfAccessMode: GRANT_ACCESS,
- grfInheritance: 0,
- Trustee: TRUSTEE_W {
- pMultipleTrustee: std::ptr::null_mut(),
- MultipleTrusteeOperation: 0,
- TrusteeForm: TRUSTEE_IS_SID,
- TrusteeType: TRUSTEE_IS_UNKNOWN,
- ptstrName: *sid as *mut u16,
- },
- })
- .collect();
+/// Keep child-process and IPC access within the runner's logon session.
+/// Elevated runners have distinct logon SIDs even when they use the same account.
+unsafe fn set_default_dacl(h_token: HANDLE, logon_sid: *mut c_void) -> Result<()> {
+ let owner_rights = LocalSid::from_string("S-1-3-4")?;
+ // The shared account also owns these objects. An OWNER RIGHTS ACE suppresses
+ // its implicit WRITE_DAC grant, which would otherwise let a different logon
+ // rewrite this DACL. The creating logon retains full access explicitly.
+ let entries = [
+ (logon_sid, GENERIC_ALL),
+ (
+ owner_rights.as_ptr(),
+ windows_sys::Win32::Storage::FileSystem::READ_CONTROL,
+ ),
+ ]
+ .map(|(sid, access)| EXPLICIT_ACCESS_W {
+ grfAccessPermissions: access,
+ grfAccessMode: GRANT_ACCESS,
+ grfInheritance: 0,
+ Trustee: TRUSTEE_W {
+ pMultipleTrustee: std::ptr::null_mut(),
+ MultipleTrusteeOperation: 0,
+ TrusteeForm: TRUSTEE_IS_SID,
+ TrusteeType: TRUSTEE_IS_UNKNOWN,
+ ptstrName: sid as *mut u16,
+ },
+ });
let mut p_new_dacl: *mut ACL = std::ptr::null_mut();
let res = SetEntriesInAclW(
entries.len() as u32,
@@ -508,15 +513,14 @@ unsafe fn create_token_with_caps_from(
return Err(anyhow!("CreateRestrictedToken failed: {}", GetLastError()));
}
- // Additional restricting SIDs are identity markers, not capabilities. Deliberately exclude
- // them from the default DACL so possessing a route identity cannot grant object access.
- let mut dacl_sids: Vec<*mut c_void> = Vec::with_capacity(psid_capabilities.len() + 2);
- dacl_sids.push(psid_logon);
- dacl_sids.push(psid_everyone);
- dacl_sids.extend_from_slice(psid_capabilities);
- set_default_dacl(new_token, &dacl_sids)?;
-
- enable_single_privilege(new_token, "SeChangeNotifyPrivilege")?;
+ // Filesystem and route capabilities may be shared between launches. They
+ // must not grant access to another launch's processes, threads, or IPC.
+ if let Err(error) = set_default_dacl(new_token, psid_logon)
+ .and_then(|()| enable_single_privilege(new_token, "SeChangeNotifyPrivilege"))
+ {
+ CloseHandle(new_token);
+ return Err(error);
+ }
Ok(new_token)
}
diff --git a/codex-rs/windows-sandbox-rs/src/token_tests.rs b/codex-rs/windows-sandbox-rs/src/token_tests.rs
index 63178355b1..cb54b15c6c 100644
--- a/codex-rs/windows-sandbox-rs/src/token_tests.rs
+++ b/codex-rs/windows-sandbox-rs/src/token_tests.rs
@@ -1,4 +1,5 @@
use super::*;
+use pretty_assertions::assert_eq;
use windows_sys::Win32::Security::EqualSid;
use windows_sys::Win32::Security::TokenRestrictedSids;
@@ -67,3 +68,164 @@ fn elevated_token_includes_network_proxy_restricting_sid() -> Result<()> {
assert!(has_network_proxy_sid?);
Ok(())
}
+
+#[test]
+fn default_objects_deny_other_logons_even_with_the_same_owner() -> Result<()> {
+ use std::os::windows::io::AsRawHandle;
+ use std::os::windows::io::FromRawHandle;
+ use std::os::windows::io::OwnedHandle;
+ use windows_sys::Win32::Security::ACCESS_ALLOWED_ACE;
+ use windows_sys::Win32::Security::AccessCheck;
+ use windows_sys::Win32::Security::DuplicateToken;
+ use windows_sys::Win32::Security::GENERIC_MAPPING;
+ use windows_sys::Win32::Security::GetAce;
+ use windows_sys::Win32::Security::InitializeSecurityDescriptor;
+ use windows_sys::Win32::Security::MapGenericMask;
+ use windows_sys::Win32::Security::SECURITY_DESCRIPTOR;
+ use windows_sys::Win32::Security::SecurityImpersonation;
+ use windows_sys::Win32::Security::SetSecurityDescriptorDacl;
+ use windows_sys::Win32::Security::SetSecurityDescriptorGroup;
+ use windows_sys::Win32::Security::SetSecurityDescriptorOwner;
+ use windows_sys::Win32::Storage::FileSystem::READ_CONTROL;
+ use windows_sys::Win32::Storage::FileSystem::WRITE_DAC;
+ use windows_sys::Win32::System::Threading::PROCESS_ALL_ACCESS;
+ use windows_sys::Win32::System::Threading::PROCESS_CREATE_THREAD;
+ use windows_sys::Win32::System::Threading::PROCESS_QUERY_INFORMATION;
+ use windows_sys::Win32::System::Threading::PROCESS_TERMINATE;
+ use windows_sys::Win32::System::Threading::PROCESS_VM_OPERATION;
+ use windows_sys::Win32::System::Threading::PROCESS_VM_READ;
+ use windows_sys::Win32::System::Threading::PROCESS_VM_WRITE;
+
+ unsafe {
+ let base = OwnedHandle::from_raw_handle(get_current_token_for_restriction()? as _);
+ let base_raw = base.as_raw_handle() as HANDLE;
+ let capability = LocalSid::from_string("S-1-5-21-10-20-30-40")?;
+ let victim =
+ OwnedHandle::from_raw_handle(create_workspace_write_token_with_caps_and_user_from(
+ base_raw,
+ &[capability.as_ptr()],
+ &[],
+ )? as _);
+ let mut needed = 0;
+ GetTokenInformation(
+ victim.as_raw_handle() as _,
+ TokenDefaultDacl,
+ std::ptr::null_mut(),
+ 0,
+ &mut needed,
+ );
+ let mut buffer = vec![0u8; needed as usize];
+ ensure!(
+ GetTokenInformation(
+ victim.as_raw_handle() as _,
+ TokenDefaultDacl,
+ buffer.as_mut_ptr().cast(),
+ needed,
+ &mut needed
+ ) != 0,
+ "GetTokenInformation(TokenDefaultDacl) failed: {}",
+ GetLastError()
+ );
+ let default_dacl = std::ptr::read_unaligned(buffer.as_ptr().cast::<TokenDefaultDaclInfo>());
+ let mapping = GENERIC_MAPPING {
+ GenericRead: READ_CONTROL | PROCESS_VM_READ | PROCESS_QUERY_INFORMATION,
+ GenericWrite: READ_CONTROL | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
+ GenericExecute: READ_CONTROL,
+ GenericAll: PROCESS_ALL_ACCESS,
+ };
+ // Object creation maps the token default DACL's generic ACE masks to
+ // object-specific rights. AccessCheck expects that mapping already done.
+ for index in 0..u32::from((*default_dacl.default_dacl).AceCount) {
+ let mut ace = std::ptr::null_mut();
+ ensure!(GetAce(default_dacl.default_dacl, index, &mut ace) != 0);
+ MapGenericMask(&mut (*ace.cast::<ACCESS_ALLOWED_ACE>()).Mask, &mapping);
+ }
+ let mut owner = get_user_sid_bytes(base_raw)?;
+ let mut descriptor: SECURITY_DESCRIPTOR = std::mem::zeroed();
+ let sd = std::ptr::addr_of_mut!(descriptor).cast();
+ ensure!(InitializeSecurityDescriptor(sd, 1) != 0);
+ ensure!(SetSecurityDescriptorOwner(sd, owner.as_mut_ptr().cast(), 0) != 0);
+ ensure!(SetSecurityDescriptorGroup(sd, owner.as_mut_ptr().cast(), 0) != 0);
+ ensure!(SetSecurityDescriptorDacl(sd, 1, default_dacl.default_dacl, 0) != 0);
+
+ // Model another logon of the same account without the victim's logon
+ // SID. Build from the base token, retaining the shared user, Everyone,
+ // and filesystem capability in the write-restricting SID set.
+ let mut logon = get_logon_sid_bytes(base_raw)?;
+ let mut everyone = world_sid()?;
+ let disabled = SID_AND_ATTRIBUTES {
+ Sid: logon.as_mut_ptr().cast(),
+ Attributes: 0,
+ };
+ let restricting = [
+ capability.as_ptr(),
+ owner.as_mut_ptr().cast(),
+ everyone.as_mut_ptr().cast(),
+ ]
+ .map(|sid| SID_AND_ATTRIBUTES {
+ Sid: sid,
+ Attributes: 0,
+ });
+ let mut other = 0;
+ ensure!(
+ CreateRestrictedToken(
+ base_raw,
+ DISABLE_MAX_PRIVILEGE | LUA_TOKEN | WRITE_RESTRICTED,
+ 1,
+ &disabled,
+ 0,
+ std::ptr::null(),
+ restricting.len() as u32,
+ restricting.as_ptr(),
+ &mut other
+ ) != 0,
+ "CreateRestrictedToken(other logon) failed: {}",
+ GetLastError()
+ );
+ let other = OwnedHandle::from_raw_handle(other as _);
+ for (token, same_logon) in [(&victim, true), (&other, false)] {
+ let mut impersonation = 0;
+ ensure!(
+ DuplicateToken(
+ token.as_raw_handle() as _,
+ SecurityImpersonation,
+ &mut impersonation
+ ) != 0,
+ "DuplicateToken failed: {}",
+ GetLastError()
+ );
+ let impersonation = OwnedHandle::from_raw_handle(impersonation as _);
+ for access in [
+ PROCESS_VM_READ,
+ PROCESS_VM_WRITE,
+ PROCESS_VM_OPERATION,
+ PROCESS_CREATE_THREAD,
+ PROCESS_TERMINATE,
+ PROCESS_QUERY_INFORMATION,
+ WRITE_DAC,
+ 0x43a,
+ ] {
+ let mut privileges = [0u64; 128];
+ let mut privilege_bytes = std::mem::size_of_val(&privileges) as u32;
+ let mut granted = 0;
+ let mut allowed = 0;
+ ensure!(
+ AccessCheck(
+ sd,
+ impersonation.as_raw_handle() as _,
+ access,
+ &mapping,
+ privileges.as_mut_ptr().cast(),
+ &mut privilege_bytes,
+ &mut granted,
+ &mut allowed
+ ) != 0,
+ "AccessCheck failed: {}",
+ GetLastError()
+ );
+ assert_eq!(allowed != 0, same_logon, "access {access:#x}");
+ }
+ }
+ }
+ Ok(())
+}