From a97124e8cc670bb0940d5077877e9678e3cb4c06 Mon Sep 17 00:00:00 2001 From: blockmandev <194144408+blockmandev@users.noreply.github.com> Date: Fri, 13 Nov 2026 09:26:39 -0600 Subject: [PATCH 1/2] insbx on Windows: a writable root's grant is kept, so a run no longer walks the tree Measured on this repository (17,752 objects): the sandbox itself starts in 0.1 s, but every run granted each writable root to a per-run SID and revoked it after, and NTFS writes an inherited ACE into every object beneath a folder: 2.3 s per walk. `insbx run -w -- cmd /c echo ok` took 4.7 s, and 14-20 s under network deny (5-7 walks: the run SID, the offline account, its read of the current folder, each granted and revoked). incode runs one `insbx run` per shell command, so every tool call paid it. Now each writable root has its own SID, from the SHA-256 of its path (S-1-5-21-1111111111-2222222222-4141414141-a-b-c-d, hashed by Windows' CNG, no new dependency). The first run on a folder grants it (one walk); the grant is kept, and later runs read the folder's own ACL to see it is there. As OpenAI Codex's Windows sandbox does (a capability SID per writable root). The offline account's ACEs on roots and on a current folder are kept too. After: the same `echo ok` takes 0.05 s (allow) and 0.1 s (deny); the first run on a folder still walks it once. What keeps it confined: - the command's token carries the run SID (its temp directory, still per run and revoked after) and the SIDs of THIS run's roots only; the helper refuses any SID not of those shapes. A kept grant on another folder names a SID the token does not hold. - a root grant that fails part-way is taken off again, so the next run walks and reports it instead of trusting a half-granted tree. - a root holding insbx's own state (%LOCALAPPDATA%\insbx) is refused. What it costs, documented: - under network deny, a folder an earlier run was given stays READABLE to the offline account in later runs (never writable); - a file moved into a root keeps its old ACL, so the command cannot write it (fails closed) until `insbx revoke `. New: `insbx grants` (kept folders, and whether each still carries its grant) and `insbx revoke ... | --all`. Found by the new tests: a SID sub-authority above u32::MAX (the first choice, 4343434343) is stored by Windows as 4294967295, so the ACE named a different SID from the token's; a test now checks every prefix part. Tests (Windows, real insbx-offline account): 81 unit, 24 escape, none skipped. New: a kept grant is made once then only read (a file moved in is not re-granted until revoke), a kept grant is writable only to runs naming the folder, revoke takes root and account ACEs back, a part-way failure is not trusted. --- crates/sandbox/README.md | 61 ++-- crates/sandbox/src/helper.rs | 1 + crates/sandbox/src/lib.rs | 28 +- crates/sandbox/src/main.rs | 99 ++++- crates/sandbox/src/windows/acl.rs | 488 +++++++++++++++++++++---- crates/sandbox/src/windows/helper.rs | 12 +- crates/sandbox/src/windows/mod.rs | 148 +++++++- crates/sandbox/src/windows/token.rs | 38 +- crates/sandbox/tests/escape_windows.rs | 94 ++++- 9 files changed, 828 insertions(+), 141 deletions(-) diff --git a/crates/sandbox/README.md b/crates/sandbox/README.md index bc809d3..5e45279 100644 --- a/crates/sandbox/README.md +++ b/crates/sandbox/README.md @@ -206,19 +206,28 @@ Windows. This crate's port is checked by its tests - **Writes.** The command runs under a *write-restricted token*: it reads anything its user can, but writes only where the user may **and** one of the token's restricting SIDs is granted. Those are a private SID made for - this run, `Everyone` (so `> NUL` works) and the logon SID (so the command - can start). The run's SID is granted `Modify`, as one inheritable ACE, on - each writable root and on the run's private temp directory, and nowhere - else. `read-only` grants only the temp directory. -- **The grant is per run.** Before the command starts, the ACE is added to - each root; after it exits, it is removed. NTFS writes an inherited ACE into - every object beneath a root, so this takes time in proportion to the tree - (incode measured about 2.5 s each way on 18,673 files). No file's contents - or modification time change, and incode found the tree's ACLs - byte-identical afterwards. A grant is written down first - (`%LOCALAPPDATA%\insbx\grants`). If `insbx` crashes, the next run removes - the ACE it left. A drive root and any folder holding your user profile - are refused as roots. + this run (granted `Modify` on the run's private temp directory only), the + SID of each of this run's writable roots (below), `Everyone` (so `> NUL` + works) and the logon SID (so the command can start). `read-only` grants + only the temp directory. +- **A root's grant is kept.** NTFS writes an inherited ACE into every object + beneath a folder, so granting one takes time in proportion to its tree + (2.3 s per walk measured on 17,752 objects). A per-run grant walked each + root twice per run (grant and revoke), and five to seven times under + network deny: `echo` took 4.7 s, and 14-20 s with the network denied, on + a repository that size. So each writable root has its own SID, derived + from its path, and its `Modify` ACE is made by the first run on the folder + and then **kept**: later runs read the folder's own ACL to see it is + there, and walk nothing. A run's token carries the SIDs of its own roots + only, so a kept grant lets no other run write there. `insbx grants` lists + kept folders; `insbx revoke |--all` takes their grants back. No + file's contents or modification time change. A drive root, any folder + holding your user profile, and insbx's own state folder are refused as + roots. +- **The temp directory's grant is per run.** It is added before the command + starts and removed after it exits, and written down first + (`%LOCALAPPDATA%\insbx\grants`): if `insbx` crashes, the next run removes + the ACE it left. - **Everything it starts.** The command starts suspended, goes into a job object, and only then runs. Everything it starts is in the job too and cannot leave it. The job is killed when the command exits, at the @@ -252,8 +261,10 @@ Windows. This crate's port is checked by its tests dies with `CreateFileMapping ..., Win32 error 5` (measured by incode). Use `cmd` or PowerShell natively, or `INSBX_BACKEND=wsl` for a POSIX shell. `insbx mcp` scripts default to PowerShell on Windows. -- **Grants are visible.** While a run lasts, every object under a root - carries the run's ACE, and the grant and revoke cost time on large trees. +- **Grants are visible, and kept.** Every object under a root that a run + has used carries the root's ACE until `insbx revoke`. A file moved into a + root from elsewhere keeps the ACL it had, so the command cannot write it + until `insbx revoke ` and the next run grants the tree again. ### Network natively: `insbx setup-windows` @@ -323,11 +334,14 @@ What changes for the command: without it starts at `C:\` (so `Set-Content x.txt` wrote `C:\x.txt`). So during a run the command can see the names in, say, your profile folder and `AppData\Local\Temp` on the way to a project under them. -- **Writes** need both the account (the token's normal check) and the run's - private SID (its restricted check), so each root gets an ACE for each. - Another run's command, also the account but with another run SID, cannot - write your run's roots. The account's ACE on a folder is shared by runs - that grant the same folder, and removed only when the last of them ends. +- **Writes** need both the account (the token's normal check) and the + root's own SID (its restricted check), so each root gets an ACE for each. + Another run's command, also the account but without that root's SID, + cannot write your run's roots. The account's ACEs on roots and on the + folder a run starts in are kept with the roots' own, so a later + network-deny run may READ a folder an earlier one was given, never write + it; `insbx revoke` takes them back too. Its ACEs on the temp directory and + the `insbx` program last the run. With `--fs off` the command is not write-restricted but is still the account: it can write the folder it starts in and its temp directory, and what the account itself may write. @@ -366,8 +380,8 @@ runner after `insbx setup-windows` (CI runs it; the runner is an administrator): TCP to a local server and to the internet refused under `deny` with the filesystem confined, read-only and off (and allowed without `deny`); UDP refused; writes confined, temp writable, exit codes and -"not found" passed through both helpers; the account's ACE present during a -run and gone after; two concurrent runs sharing a root (the second ending +"not found" passed through both helpers; the account's ACE on a root kept +after a run and gone after `insbx revoke`; two concurrent runs sharing a root (the second ending first leaves the first its grant, and cannot write the first's other root); the proxy letting through only its allowlist, a direct connection refused; `insbx mcp` running a deny sandbox's PowerShell script as the account. @@ -520,7 +534,8 @@ holds the proxy and the temp directory. symlinks, children, read-only, `deny_read`, TCP under `deny`, the proxy, the environment, the wall limit); - on Windows (`tests/escape_windows.rs`, with only `cmd` and PowerShell): - writes outside the root, the grant held during the run and gone after, + writes outside the root, a root's grant kept and writable only to runs + that name it, the temp grant gone after the run, `insbx revoke`, read-only and its private temp, child `cmd` and PowerShell, a planted program in the current folder, the wall limit and killing `insbx` taking the whole tree, the job's memory and CPU limits, the environment, exit diff --git a/crates/sandbox/src/helper.rs b/crates/sandbox/src/helper.rs index 65d8e9f..1960f9e 100644 --- a/crates/sandbox/src/helper.rs +++ b/crates/sandbox/src/helper.rs @@ -303,6 +303,7 @@ mod tests { strict: true, supervise: false, sid: None, + root_sids: Vec::new(), parent_pid: Some(7), offline: Offline::No, offline_record: None, diff --git a/crates/sandbox/src/lib.rs b/crates/sandbox/src/lib.rs index 67086f2..e26a05b 100644 --- a/crates/sandbox/src/lib.rs +++ b/crates/sandbox/src/lib.rs @@ -20,7 +20,8 @@ //! //! On macOS the helper runs under `sandbox-exec` with a generated Seatbelt //! profile instead of Landlock. On Windows, which has no `exec`, the parent -//! grants the writable roots to a private per-run SID first, and the helper +//! makes sure each writable root carries its own kept grant and grants the +//! temp directory to a private per-run SID first, and the helper //! starts the command under a write-restricted token, in a job object, and //! stays to supervise it (see [`windows`]). The helper is the calling binary //! re-executed with a private first argument, so a program that embeds this @@ -96,10 +97,15 @@ pub struct EnterSpec { /// SIGKILL, which nothing can forward) the whole group dies with it. #[serde(default)] pub supervise: bool, - /// Windows: the run's private SID, granted on its writable roots and - /// temp directory; the helper restricts the command's token to it. + /// Windows: the run's private SID, granted on its temp directory; the + /// helper restricts the command's token to it and [`Self::root_sids`]. #[serde(default)] pub sid: Option, + /// Windows: the kept SIDs of this run's writable roots + /// (`windows::acl::root_sid`), the token's other restricting SIDs. Only + /// these roots' kept grants are writable to the command. + #[serde(default)] + pub root_sids: Vec, /// Windows: the parent's process id. The helper watches it and ends the /// command's job if the parent dies (there is no parent-death signal). #[serde(default)] @@ -118,6 +124,7 @@ pub struct EnterSpec { /// and, under network deny or proxy on Windows, the offline account. struct RunIdentity { sid: Option, + root_sids: Vec, offline: Offline, offline_record: Option, } @@ -128,6 +135,7 @@ impl RunIdentity { fn caller() -> Self { Self { sid: None, + root_sids: Vec::new(), offline: Offline::No, offline_record: None, } @@ -139,6 +147,7 @@ impl RunIdentity { fn of(lease: Option<&windows::acl::Lease>, offline: Option<&windows::offline::Ready>) -> Self { Self { sid: lease.map(|l| l.sid().to_string()), + root_sids: lease.map(|l| l.root_sids().to_vec()).unwrap_or_default(), offline: if offline.is_some() { Offline::Launch } else { @@ -390,6 +399,7 @@ impl Sandbox { strict: self.strict, supervise: own_group, sid: identity.sid, + root_sids: identity.root_sids, parent_pid: Some(std::process::id()), offline: identity.offline, offline_record: identity.offline_record, @@ -473,15 +483,18 @@ impl Sandbox { // started in, so it can work there at all. grant.push(real(cwd)); } - grant.push(temp.path.clone()); + // The account's reads are what neither a root nor the temp directory + // already gives it. + let mut granted = grant.clone(); + granted.push(temp.path.clone()); let account = offline.as_ref().map(|ready| { - let reads = windows::offline_reads(&grant, &real(cwd), &real(helper)); + let reads = windows::offline_reads(&granted, &real(cwd), &real(helper)); windows::acl::OfflineGrant { user: ready.sid.clone(), // PowerShell lists the current folder's parent to start in // it at all. parents: windows::offline_parents( - &grant, + &granted, &reads, &real(cwd), windows::profiles_dir().as_deref(), @@ -489,7 +502,7 @@ impl Sandbox { reads, } }); - match windows::acl::Lease::acquire(&grant, account) { + match windows::acl::Lease::acquire(&grant, &temp.path, account) { Ok(lease) => Ok(Some(lease)), Err(e) if self.strict => Err(e), Err(e) => { @@ -915,6 +928,7 @@ mod tests { strict: true, supervise: false, sid: None, + root_sids: Vec::new(), parent_pid: Some(7), offline: Offline::Launch, offline_record: Some(PathBuf::from(r"C:\ProgramData\insbx\offline.conf")), diff --git a/crates/sandbox/src/main.rs b/crates/sandbox/src/main.rs index a3393f2..af82831 100644 --- a/crates/sandbox/src/main.rs +++ b/crates/sandbox/src/main.rs @@ -29,6 +29,19 @@ USAGE: natively (an offline account the firewall cuts off). --read lets that account read a folder (a toolchain); --remove undoes all of it + insbx grants Windows: the folders whose write grant is kept, and whether + each still carries it + insbx revoke ... | --all + Windows: take a folder's kept grant back; its next run grants + it again, files moved in since included + +KEPT GRANTS (Windows): + A writable root's grant is written into every file beneath it, so it is made by the + first run on that folder and then KEPT: later runs only check it, instead of walking + the tree twice per run. Each folder has its own SID, and a run's token carries only + its own roots' SIDs, so a kept grant lets no other run write there. A file moved into + a root from elsewhere keeps its old ACL (not writable to the command) until + `insbx revoke `. MCP OPTIONS (the ceilings; an agent can ask for less, never more): --root where sandboxes live (default: /insbx-mcp-) @@ -131,7 +144,14 @@ mod windows_backend { if backend == Backend::Wsl && !matches!( sub, - "" | "-h" | "--help" | "help" | "-V" | "--version" | "setup-windows" + "" | "-h" + | "--help" + | "help" + | "-V" + | "--version" + | "setup-windows" + | "grants" + | "revoke" ) { return Some(forward(args)); @@ -336,6 +356,8 @@ fn real_main(args: Vec) -> Result { "run" => run(parse(&args[1..])?), "mcp" => mcp(&args[1..]), "setup-windows" => setup_windows(&args[1..]), + "grants" => grants(), + "revoke" => revoke(&args[1..]), other => Err(format!("unknown command `{other}` (try `insbx --help`)")), } } @@ -367,6 +389,81 @@ fn run(o: Options) -> Result { Ok(outcome.code()) } +/// `insbx grants`: every folder whose write grant is kept +/// (`incord_sandbox::windows::kept_folders`), one per line, `granted` or +/// `missing` (its ACE is gone: the next run grants it again). +fn grants() -> Result { + #[cfg(windows)] + { + let kept = incord_sandbox::windows::kept_folders()?; + if kept.is_empty() { + println!("insbx grants: none kept"); + } + for k in kept { + let state = if k.granted { "granted" } else { "missing" }; + println!("{state:<8} {}", strip_verbatim(&k.path)); + } + Ok(0) + } + #[cfg(not(windows))] + { + Err("kept grants are Windows only: Landlock and Seatbelt grant nothing on disk".into()) + } +} + +/// `insbx revoke ... | --all`: take kept grants back +/// (`incord_sandbox::windows::revoke_kept`), the offline account's too when +/// it is set up. Every folder is tried; the exit code is 1 when any failed. +fn revoke(args: &[OsString]) -> Result { + let words: Vec<&str> = args + .iter() + .map(|a| a.to_str().ok_or("an argument is not valid Unicode")) + .collect::>()?; + if words.is_empty() { + return Err("revoke what? give folders, or --all".into()); + } + #[cfg(windows)] + { + use incord_sandbox::windows; + let folders: Vec = if words == ["--all"] { + windows::kept_folders()? + .into_iter() + .map(|k| k.path) + .collect() + } else if words.contains(&"--all") { + return Err("--all takes no folders".into()); + } else { + words + .iter() + .map(|w| std::fs::canonicalize(w).map_err(|e| format!("{w}: {e}"))) + .collect::>()? + }; + let account = windows::offline_setup().ok().map(|r| r.sid); + let mut failed = false; + for folder in folders { + match windows::revoke_kept(&folder, account.as_deref()) { + Ok(()) => println!("insbx revoke: {}", strip_verbatim(&folder)), + Err(e) => { + eprintln!("insbx revoke: {}: {e}", strip_verbatim(&folder)); + failed = true; + } + } + } + Ok(i32::from(failed)) + } + #[cfg(not(windows))] + { + Err("kept grants are Windows only: Landlock and Seatbelt grant nothing on disk".into()) + } +} + +/// A path as the user wrote it: `canonicalize`'s `\\?\` dropped. +#[cfg(windows)] +fn strip_verbatim(p: &std::path::Path) -> String { + let s = p.display().to_string(); + s.strip_prefix(r"\\?\").map_or(s.clone(), str::to_string) +} + /// `insbx setup-windows`: see [`incord_sandbox::windows::offline`]. fn setup_windows(args: &[OsString]) -> Result { let args: Vec = args diff --git a/crates/sandbox/src/windows/acl.rs b/crates/sandbox/src/windows/acl.rs index b299619..b699ad3 100644 --- a/crates/sandbox/src/windows/acl.rs +++ b/crates/sandbox/src/windows/acl.rs @@ -1,24 +1,57 @@ -//! The grant: one inheritable `Modify` ACE per writable root, for one run. +//! The grant: one inheritable `Modify` ACE per writable root, kept across +//! runs, and one per run on its private temp directory. //! -//! Ported from incode's `sandbox::windows::acl`. incode grants once per -//! session and keeps the roots granted across commands; `insbx` runs one -//! command per policy, so each run gets its own SID and its own [`Lease`]: -//! granted when the command is prepared, revoked when the lease drops after -//! it exits. Two runs at once never share a SID, so neither can write the -//! other's roots. +//! Ported from incode's `sandbox::windows::acl`, which grants once per +//! session and keeps the roots granted across commands. +//! +//! # Writable roots: kept, one SID per folder +//! +//! Granting a folder writes the ACE into every object beneath it (NTFS +//! inheritance is stored, not computed), so it costs time linear in the tree: +//! measured 2.3 s per walk on 17,752 objects, and a run used to walk its +//! roots twice (grant and revoke), five to seven times under network deny. +//! incode drives one `insbx run` per shell command, so every command paid it. +//! Now each root has its own SID, derived from its path ([`root_sid`], +//! [`super::root_sid_from_digest`]), and its grant is KEPT after the run: +//! the first run on a folder walks it once, and every later run only reads +//! the folder's own ACL to see the grant is there ([`passes_down`]). As +//! OpenAI Codex's Windows sandbox does (`codex-rs/windows-sandbox-rs`, +//! `cap.rs`: a capability SID per writable root, persisted). +//! +//! What keeps that confined: the command's token carries the SIDs of THIS +//! run's roots only ([`Lease::root_sids`]). A kept grant on another folder +//! names a SID the token does not hold, so it is not writable, exactly as a +//! folder never granted. `insbx revoke |--all` takes kept grants back +//! ([`revoke_kept`]); `insbx grants` lists them ([`kept_folders`]). +//! +//! What it costs: a file moved INTO a root from elsewhere keeps the ACL it +//! had and lacks the root's inherited ACE until the root is granted again, +//! so the command cannot write it (it fails closed); `insbx revoke ` +//! and the next run re-grants the whole tree. +//! +//! # The temp directory: one SID per run +//! +//! The run's private temp directory is new and empty, so its grant is +//! cheap, and it stays per run: granted to the run's own SID when the +//! command is prepared, revoked when the [`Lease`] drops after it exits. Two +//! runs at once never share that SID, so neither can write the other's temp +//! directory, even with the same roots. //! //! # Network deny: the offline account's share //! //! When the command runs as the offline account ([`super::offline`]), the //! token's normal access check is the account's, not the user's, so each root //! also gets an ACE for the account (`Modify`), and the current folder and -//! the helper program one for reading. Writes still need the run's SID too -//! (the token's restricted check), so a root granted to the account for one -//! run is not writable by another run's command. The account's ACE on a path -//! is one ACE however many runs granted it (a grant merges into it), so a run -//! that ends removes it only when no other live run still lists that path, -//! and leaves read access when another only reads it -//! ([`super::offline::still_needed`]). +//! the helper program one for reading. Writes still need the root's own SID +//! too (the token's restricted check), so a root granted to the account for +//! one run is not writable by another run's command unless that run names +//! the same root. The account's ACEs on roots and on a current FOLDER are +//! kept like the roots' own: a later network-deny run may READ a folder an +//! earlier one was granted, never write it. Its ACEs on the temp directory +//! and on a read FILE (the helper program) last the run: one ACE however +//! many runs granted it (a grant merges into it), so a run that ends removes +//! it only when no other live run still lists that path, and leaves read +//! access when another only reads it ([`super::offline::still_needed`]). //! //! # Network deny: what the account creates stays the user's to re-ACL //! @@ -75,6 +108,7 @@ use windows_sys::Win32::Security::Authorization::{ EXPLICIT_ACCESS_W, GRANT_ACCESS, NO_MULTIPLE_TRUSTEE, REVOKE_ACCESS, SE_FILE_OBJECT, TRUSTEE_IS_SID, TRUSTEE_IS_UNKNOWN, TRUSTEE_W, }; +use windows_sys::Win32::Security::Cryptography::{BCryptHash, BCRYPT_SHA256_ALG_HANDLE}; use windows_sys::Win32::Security::{ AclSizeInformation, AddAccessAllowedAceEx, AddAce, EqualSid, GetAce, GetAclInformation, GetLengthSid, GetSecurityDescriptorControl, InitializeAcl, InitializeSecurityDescriptor, @@ -91,7 +125,10 @@ use windows_sys::Win32::System::Threading::{ use super::offline::{still_needed, Need}; use super::token::{current_user_sid, last_error, sid, sid_to_string, wide, LocalPtr, OwnedHandle}; -use super::{fold_nested, is_listed, is_session_sid, refuse_broad, session_sid, GrantRecord}; +use super::{ + fold_nested, is_listed, is_session_sid, kept_text, parse_kept, path_key, refuse_broad, + root_sid_from_digest, session_sid, GrantRecord, +}; /// The rights granted on a root: `icacls`'s `M` (read, write, execute, /// delete). @@ -179,15 +216,20 @@ fn refuse_ungrantable(roots: &[PathBuf], profile: Option<&str>) -> Result<(), St Ok(()) } -/// One run's grant on its roots. Dropping it revokes them. +/// One run's grant: its roots' kept grants, checked or made, and its temp +/// directory's own. Dropping it revokes what was the run's alone (the temp +/// directory, a read file, a listed parent); the kept grants stay. pub(crate) struct Lease { record: GrantRecord, path: PathBuf, - /// The roots and read paths a grant was attempted on, so far: what - /// dropping the lease takes back. + /// The per-run paths a grant was attempted on, so far: what dropping the + /// lease takes back. The temp directory only, as a root. roots: Vec, reads: Vec, parents: Vec, + /// The kept SIDs of this run's writable roots ([`root_sid`]), for the + /// command's token. + root_sids: Vec, /// The named mutex that tells a later sweep this run is alive. _alive: OwnedHandle, } @@ -201,27 +243,36 @@ impl std::fmt::Debug for Lease { } impl Lease { - /// Grant `roots` (the writable roots and the run's temp directory) to a - /// new private SID, and with `offline` to the offline account as well, - /// after sweeping what a crashed run left. + /// Make sure each of `roots` (the writable roots) carries its kept grant, + /// granting the ones that do not yet; grant `temp` (the run's private + /// temp directory) to a new private SID; and with `offline`, the offline + /// account's share as well. The crash sweep runs first. /// /// # Errors - /// When a root may not or could not be granted. Nothing this call granted - /// is left behind on failure. + /// When a root may not or could not be granted. What this call granted + /// for the run alone is not left behind on failure; a root whose grant + /// failed part-way has it taken off again ([`keep_root`]), so the next + /// run tries again instead of trusting it. /// /// The steps: the roots are checked ([`refuse_ungrantable`]) and folded, - /// the account's share narrowed ([`OfflineGrant::grantable`]), the sweep - /// run and the grant written down, then the roots granted - /// ([`Lease::grant_roots`]), the account's read paths + /// the account's share narrowed ([`OfflineGrant::grantable`]) and its + /// read paths split into folders (kept) and files (this run's), the + /// sweep run and the run's grant written down, then the temp directory + /// granted ([`Lease::grant_roots`]), the roots' kept grants checked or + /// made ([`Lease::keep_roots`]), the account's read paths /// ([`Lease::grant_reads`]) and its parents ([`Lease::grant_parents`]). /// A step that fails returns with the lease, which drops and so takes /// back what the steps before it listed. + /// + /// Called by `crate::Sandbox::windows_lease` (lib.rs), once per run. pub(crate) fn acquire( roots: &[PathBuf], + temp: &Path, offline: Option, ) -> Result { let profile = std::env::var("USERPROFILE").ok(); refuse_ungrantable(roots, profile.as_deref())?; + refuse_state_dir(roots)?; let roots = fold_nested(roots); let offline = offline .map(|o| o.grantable(profile.as_deref())) @@ -230,15 +281,18 @@ impl Lease { Some(o) => (Some(o.user), o.reads, o.parents), None => (None, Vec::new(), Vec::new()), }; + let (kept_reads, reads): (Vec, Vec) = + reads.into_iter().partition(|r| r.is_dir()); let dir = records_dir(); std::fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?; sweep(&dir); let (rid, alive) = claim_rid(&dir)?; + let temp = vec![temp.to_path_buf()]; let mut lease = Self { record: GrantRecord { sid: session_sid(rid), - roots: roots.clone(), + roots: temp.clone(), user, reads: reads.clone(), parents: parents.clone(), @@ -247,20 +301,42 @@ impl Lease { roots: Vec::new(), reads: Vec::new(), parents: Vec::new(), + root_sids: Vec::new(), _alive: alive, }; // Written down BEFORE anything is granted, so a crash at any point // after this is swept. std::fs::write(&lease.path, lease.record.to_text()) .map_err(|e| format!("{}: {e}", lease.path.display()))?; - lease.grant_roots(&roots)?; + lease.grant_roots(&temp)?; + lease.keep_roots(&roots)?; if let Some(user) = lease.record.user.clone() { + for read in &kept_reads { + keep_read(read, &user).map_err(|e| { + format!( + "could not let the offline account read {}: {e}", + read.display() + ) + })?; + } lease.grant_reads(&reads, &user)?; lease.grant_parents(&parents, &user); } Ok(lease) } + /// Check or make each root's kept grant ([`keep_root`]), for + /// [`Lease::acquire`], collecting the SIDs the command's token carries. + /// Stops at the first that fails. + fn keep_roots(&mut self, roots: &[PathBuf]) -> Result<(), String> { + for root in roots { + let sid = keep_root(root, self.record.user.as_deref()) + .map_err(|e| format!("workspace-write could not grant {}: {e}", root.display()))?; + self.root_sids.push(sid); + } + Ok(()) + } + /// Grant each root in turn ([`grant_root`]), for [`Lease::acquire`], /// stopping at the first that fails. fn grant_roots(&mut self, roots: &[PathBuf]) -> Result<(), String> { @@ -307,10 +383,17 @@ impl Lease { } } - /// The SID the command's token is restricted to. + /// The run's own SID, granted on its temp directory: the token's first + /// restricting SID, and the one its default DACL names. pub(crate) fn sid(&self) -> &str { &self.record.sid } + + /// The kept SIDs of this run's writable roots: the token's other + /// restricting SIDs, and the only root SIDs it carries. + pub(crate) fn root_sids(&self) -> &[String] { + &self.root_sids + } } impl Drop for Lease { @@ -418,6 +501,206 @@ fn grant_root(root: &Path, sid_text: &str, user: Option<&str>) -> Result<(), Str Ok(()) } +/// The kept SID of the writable root `root`: [`super::root_sid_from_digest`] +/// of the SHA-256 of its [`path_key`] (case and spelling folded, so +/// `C:\W` and `c:/w/` are one root), hashed by Windows' own CNG. +/// +/// # Errors +/// When the hash cannot be computed. +pub(crate) fn root_sid(root: &Path) -> Result { + let key = path_key(&root.to_string_lossy()); + let mut digest = [0u8; 32]; + let input = key.as_bytes(); + let len = u32::try_from(input.len()).map_err(|_| "the path is too long to hash")?; + // SAFETY: the SHA-256 pseudo-handle needs no open or close; the input + // and output buffers are valid for the lengths passed. + let status = unsafe { + BCryptHash( + BCRYPT_SHA256_ALG_HANDLE, + std::ptr::null(), + 0, + input.as_ptr(), + len, + digest.as_mut_ptr(), + 32, + ) + }; + if status != 0 { + return Err(format!("BCryptHash failed with status {status:#x}")); + } + Ok(root_sid_from_digest(&digest)) +} + +/// Make sure `root` carries its kept grant, for [`Lease::keep_roots`]: +/// `Modify` to [`root_sid`], and with the offline account `user`, `Modify` +/// to the account and the user's own ACL rights beneath ([`keep_acl_rights`]). +/// Each is read off the folder's own ACL first ([`passes_down`]) and made +/// only when missing, so a root granted before costs one ACL read, not a +/// walk of its tree. The SID. +/// +/// A grant that fails part-way (a file beneath the user may not re-ACL) has +/// the root's ACE taken off again, so the next run walks and reports it +/// again instead of finding the ACE on the folder and trusting a tree only +/// part granted. Under the ACL lock throughout, so two runs granting the +/// same new folder do not both walk it. +fn keep_root(root: &Path, user: Option<&str>) -> Result { + let sid = root_sid(root)?; + let _lock = AclLock::take()?; + if !passes_down(root, &sid, MODIFY)? { + if let Err(e) = change(root, &sid, Change::Grant(MODIFY)) { + let _ = change(root, &sid, Change::Revoke); + return Err(e); + } + } + if let Some(user) = user { + if !passes_down(root, user, MODIFY)? { + if let Err(e) = grant_account(root, user, MODIFY) { + let _ = change(root, user, Change::Revoke); + return Err(e); + } + } + keep_acl_rights(root)?; + } + remember_kept(root); + Ok(sid) +} + +/// Make sure the offline account `user` may read the folder `dir` (the +/// current folder of a network-deny run), kept like a root's grant: made +/// once, checked by one ACL read after that. +fn keep_read(dir: &Path, user: &str) -> Result<(), String> { + let _lock = AclLock::take()?; + if !passes_down(dir, user, READ_EXECUTE)? { + if let Err(e) = grant_account(dir, user, READ_EXECUTE) { + let _ = change(dir, user, Change::Revoke); + return Err(e); + } + } + remember_kept(dir); + Ok(()) +} + +/// Refuse a root that holds insbx's own state (`%LOCALAPPDATA%\insbx`: the +/// crash records and the kept list), for [`Lease::acquire`]: a command +/// that could write there could forge a record for the sweep. +fn refuse_state_dir(roots: &[PathBuf]) -> Result<(), String> { + let Some(state) = records_dir().parent().map(Path::to_path_buf) else { + return Ok(()); + }; + let state_key = path_key(&state.to_string_lossy()); + for root in roots { + let key = path_key(&root.to_string_lossy()); + let holds = state_key == key + || state_key.starts_with(&format!("{key}\\")) + || key.starts_with(&format!("{state_key}\\")); + if holds { + return Err(format!( + "workspace-write refuses {}: it holds insbx's own records ({})", + root.display(), + state.display() + )); + } + } + Ok(()) +} + +/// The kept-grants list's file: `%LOCALAPPDATA%\insbx\kept`. +fn kept_file() -> PathBuf { + records_dir() + .parent() + .map_or_else(|| PathBuf::from("insbx-kept"), |d| d.join("kept")) +} + +/// Add `path` to the kept list, unless it is there already. Only for +/// listing ([`super::parse_kept`]); a failure to write it is said, not +/// fatal: the grant itself is in the folder's ACL. +fn remember_kept(path: &Path) { + let file = kept_file(); + let mut kept = std::fs::read_to_string(&file) + .map(|t| parse_kept(&t)) + .unwrap_or_default(); + let key = path_key(&path.to_string_lossy()); + if kept.iter().any(|k| path_key(&k.to_string_lossy()) == key) { + return; + } + kept.push(path.to_path_buf()); + if let Err(e) = std::fs::write(&file, kept_text(&kept)) { + eprintln!( + "insbx: could not add {} to the kept-grants list {} ({e}); `insbx grants` will \ + not show it", + path.display(), + file.display() + ); + } +} + +/// One kept folder, for `insbx grants`. +#[derive(Debug, Clone)] +pub struct KeptFolder { + pub path: PathBuf, + /// Whether the folder still carries its root SID's grant. + pub granted: bool, +} + +/// Every folder the kept list names that still exists, each with whether +/// its grant is still on it. Folders that are gone are dropped from the +/// list. +/// +/// # Errors +/// When the list cannot be read. +pub fn kept_folders() -> Result, String> { + let _lock = AclLock::take()?; + let file = kept_file(); + let text = match std::fs::read_to_string(&file) { + Ok(t) => t, + Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()), + Err(e) => return Err(format!("{}: {e}", file.display())), + }; + let all = parse_kept(&text); + let live: Vec = all.iter().filter(|p| p.exists()).cloned().collect(); + if live.len() != all.len() { + let _ = std::fs::write(&file, kept_text(&live)); + } + Ok(live + .into_iter() + .map(|path| { + let granted = root_sid(&path) + .and_then(|sid| passes_down(&path, &sid, MODIFY)) + .unwrap_or(false); + KeptFolder { path, granted } + }) + .collect()) +} + +/// Take `path`'s kept grants back: its root SID's ACE, and with the offline +/// account `user`, the account's ACEs on it; then drop it from the kept +/// list. The user's own ACL rights stay ([`keep_acl_rights`] says why). A +/// run that is using the folder right now loses its writes there. The next +/// run with it as a root grants the whole tree again, which also reaches +/// files moved in since. +/// +/// # Errors +/// When an ACE cannot be removed; the folder stays listed then. +pub fn revoke_kept(path: &Path, user: Option<&str>) -> Result<(), String> { + let _lock = AclLock::take()?; + let key = path_key(&path.to_string_lossy()); + if path.exists() { + change(path, &root_sid(path)?, Change::Revoke)?; + if let Some(user) = user { + change(path, user, Change::Revoke)?; + } + } + let file = kept_file(); + let kept = std::fs::read_to_string(&file) + .map(|t| parse_kept(&t)) + .unwrap_or_default(); + let left: Vec = kept + .into_iter() + .filter(|k| path_key(&k.to_string_lossy()) != key) + .collect(); + std::fs::write(&file, kept_text(&left)).map_err(|e| format!("{}: {e}", file.display())) +} + /// Grant the account `rights` on `path`, inherited beneath a folder. A /// listing ACE already on the folder (another run's parent) is taken off /// first and put back after: `SetEntriesInAclW` may merge a grant into an @@ -1166,21 +1449,23 @@ mod tests { ); } - /// **A GRANT THAT FAILS PART-WAY TAKES BACK WHAT IT ALREADY GRANTED**: - /// the first root is granted, the second refuses (its ACL may be read but - /// not changed: an `OWNER RIGHTS` ACE takes the owner's implicit - /// `WRITE_DAC` away), and the lease the failure drops revokes the first - /// root and what propagated beneath it. The second root's revoke fails as - /// its grant did, so the record is kept for the next sweep, naming that - /// root alone. + /// **A GRANT THAT FAILS PART-WAY IS NOT TRUSTED, AND THE RUN'S OWN GRANT + /// IS TAKEN BACK**: the first root gets its kept grant, the second + /// refuses (its ACL may be read but not changed: an `OWNER RIGHTS` ACE + /// takes the owner's implicit `WRITE_DAC` away), so the run is refused. + /// The first root's grant is kept, as after any run; the second carries + /// no root SID for a later run to trust; the lease the failure drops + /// revokes the run's own SID from its temp directory, and its record goes. #[test] - fn a_grant_that_fails_part_way_takes_back_what_it_granted() { + fn a_grant_that_fails_part_way_is_not_trusted_and_the_runs_own_is_taken_back() { let dir = tempfile::tempdir().expect("tempdir"); // Folded in this order: `a-` before `b-`. let granted = dir.path().join("a-granted"); let locked = dir.path().join("b-locked"); + let temp = dir.path().join("t"); std::fs::create_dir(&granted).expect("granted root"); std::fs::create_dir(&locked).expect("locked root"); + std::fs::create_dir(&temp).expect("temp"); let beneath = granted.join("made-before.txt"); std::fs::write(&beneath, "x").expect("write"); // An elevated process (a CI runner) leaves explicit full-control ACEs @@ -1205,7 +1490,7 @@ mod tests { String::from_utf8_lossy(&set.stdout) ); - let err = match Lease::acquire(&[granted.clone(), locked.clone()], None) { + let err = match Lease::acquire(&[granted.clone(), locked.clone()], &temp, None) { Err(err) => err, Ok(_) => panic!( "the locked root refused nothing (elevated: {}):\n{}", @@ -1221,35 +1506,114 @@ mod tests { "{err}" ); - let kept: Vec<(PathBuf, GrantRecord)> = std::fs::read_dir(records_dir()) + let granted_sid = root_sid(&granted).expect("sid"); + for path in [&granted, &beneath] { + let acl = acl_of(path); + assert!( + acl.contains(&granted_sid), + "kept: {}: {acl}", + path.display() + ); + } + let locked_acl = acl_of(&locked); + assert!( + !locked_acl.contains(&root_sid(&locked).expect("sid")), + "no grant to trust on the locked root: {locked_acl}" + ); + let temp_acl = acl_of(&temp); + assert!( + !temp_acl.contains(super::super::SID_PREFIX), + "the run's SID was revoked from its temp: {temp_acl}" + ); + let left = std::fs::read_dir(records_dir()) .expect("records") .flatten() - .map(|e| e.path()) - .filter_map(|p| { - let record = GrantRecord::parse(&std::fs::read_to_string(&p).ok()?)?; - Some((p, record)) - }) - .filter(|(_, r)| r.roots.contains(&locked) || r.roots.contains(&granted)) - .collect(); - for (path, _) in &kept { - // This test's own record: the locked root goes with the tempdir. - let _ = std::fs::remove_file(path); + .filter_map(|e| GrantRecord::parse(&std::fs::read_to_string(e.path()).ok()?)) + .any(|r| r.roots.contains(&temp)); + assert!(!left, "the run's record was removed"); + revoke_kept(&granted, None).expect("revoke"); + } + + /// **A KEPT GRANT IS MADE ONCE, THEN ONLY READ; REVOKE TAKES IT BACK**: + /// the first lease walks the root (a file beneath gets the root's ACE); + /// a file then MOVED in keeps the ACL it had, and the second lease leaves + /// it so, which shows the second lease did not walk the tree (a walk + /// would have given it the ACE). `revoke_kept` takes the ACE off the root + /// and its files and drops the root from the kept list; the next lease + /// walks again, and the moved file gets the ACE. + #[test] + fn a_kept_grant_is_made_once_then_only_read_and_revoke_takes_it_back() { + let dir = tempfile::tempdir().expect("tempdir"); + let root = dir.path().join("root"); + let outside = dir.path().join("outside"); + std::fs::create_dir(&root).expect("root"); + std::fs::create_dir(&outside).expect("outside"); + let beneath = root.join("before.txt"); + std::fs::write(&beneath, "x").expect("write"); + let sid = root_sid(&root).expect("sid"); + let temp = |n: &str| { + let t = dir.path().join(n); + std::fs::create_dir(&t).expect("temp"); + t + }; + + let first = Lease::acquire(std::slice::from_ref(&root), &temp("t1"), None).expect("first"); + assert_eq!(first.root_sids(), std::slice::from_ref(&sid)); + drop(first); + assert!(acl_of(&root).contains(&sid), "kept on the root"); + assert!(acl_of(&beneath).contains(&sid), "and beneath it"); + let listed = kept_folders().expect("list"); + assert!( + listed.iter().any(|k| k.path == root && k.granted), + "listed as granted: {listed:?}" + ); + + let moved = root.join("moved.txt"); + std::fs::write(outside.join("moved.txt"), "y").expect("write"); + std::fs::rename(outside.join("moved.txt"), &moved).expect("move in"); + assert!(!acl_of(&moved).contains(&sid), "a moved file keeps its ACL"); + + let second = + Lease::acquire(std::slice::from_ref(&root), &temp("t2"), None).expect("second"); + assert_eq!(second.root_sids(), std::slice::from_ref(&sid)); + drop(second); + assert!( + !acl_of(&moved).contains(&sid), + "the second lease walked the tree: {}", + acl_of(&moved) + ); + + revoke_kept(&root, None).expect("revoke"); + for path in [&root, &beneath] { + let acl = acl_of(path); + assert!(!acl.contains(&sid), "revoked: {}: {acl}", path.display()); } - assert_eq!(kept.len(), 1, "one record kept for the next sweep"); - let record = &kept[0].1; - assert_eq!( - record.roots, - vec![locked.clone()], - "the granted root was revoked" + assert!( + !kept_folders().expect("list").iter().any(|k| k.path == root), + "no longer listed" ); - for path in [&granted, &beneath] { - let acl = std::process::Command::new("icacls") - .arg(path) - .output() - .expect("icacls"); - let acl = String::from_utf8_lossy(&acl.stdout); - assert!(!acl.contains(&record.sid), "{}: {acl}", path.display()); + let third = Lease::acquire(std::slice::from_ref(&root), &temp("t3"), None).expect("third"); + drop(third); + assert!( + acl_of(&moved).contains(&sid), + "granted again, the whole tree: {}", + acl_of(&moved) + ); + revoke_kept(&root, None).expect("cleanup"); + } + + /// **A ROOT HOLDING INSBX'S OWN RECORDS IS REFUSED**: a command that + /// could write there could forge a record for the sweep. + #[test] + fn a_root_holding_insbx_state_is_refused() { + let state = records_dir(); + let parent = state.parent().expect("state dir").to_path_buf(); + for root in [parent, state] { + let err = refuse_state_dir(std::slice::from_ref(&root)).expect_err("refused"); + assert!(err.contains("holds insbx's own records"), "{err}"); } + let elsewhere = tempfile::tempdir().expect("tempdir"); + assert!(refuse_state_dir(&[elsewhere.path().to_path_buf()]).is_ok()); } } diff --git a/crates/sandbox/src/windows/helper.rs b/crates/sandbox/src/windows/helper.rs index fc49c34..5156c02 100644 --- a/crates/sandbox/src/windows/helper.rs +++ b/crates/sandbox/src/windows/helper.rs @@ -57,7 +57,8 @@ use super::job_flags; use super::offline::HELPER_PROCESS_SDDL; use super::token::{dacl_of, last_error, restricted, security_descriptor, wide, OwnedHandle}; use super::{ - batch_command_line, command_line, is_batch, is_session_sid, resolve_program, JobLimits, + batch_command_line, command_line, is_batch, is_root_sid, is_session_sid, resolve_program, + JobLimits, }; use crate::policy::FsMode; use crate::{EnterSpec, InnerLaunch, Offline, ENTER_ARG, EXIT_SANDBOX, INNER_ARG, INNER_ENV}; @@ -388,7 +389,9 @@ fn environment_block() -> Result, String> { } } -/// The token for a confined run, restricted to the run's SID. +/// The token for a confined run, restricted to the run's SID and its roots' +/// kept SIDs. Any SID not of either shape is refused, so a spec cannot point +/// the token at a SID that is granted somewhere real. fn confining_token(spec: &EnterSpec) -> Result { let sid = spec .sid @@ -397,7 +400,10 @@ fn confining_token(spec: &EnterSpec) -> Result { if !is_session_sid(sid) { return Err(format!("{sid} is not an insbx run SID")); } - restricted(sid) + if let Some(bad) = spec.root_sids.iter().find(|s| !is_root_sid(s)) { + return Err(format!("{bad} is not an insbx root SID")); + } + restricted(sid, &spec.root_sids) } /// A job that kills everything in it when its last handle closes, with the diff --git a/crates/sandbox/src/windows/mod.rs b/crates/sandbox/src/windows/mod.rs index 1d4157b..4a4176f 100644 --- a/crates/sandbox/src/windows/mod.rs +++ b/crates/sandbox/src/windows/mod.rs @@ -15,9 +15,12 @@ //! SIDs are: //! //! - a private SID made for this one run -//! (`S-1-5-21-1111111111-2222222222-4242424242-`), granted on each -//! writable root and the run's private temp directory and nowhere else -//! ([`acl`]); +//! (`S-1-5-21-1111111111-2222222222-4242424242-`), granted on the +//! run's private temp directory and nowhere else ([`acl`]); +//! - each of this run's writable roots' own SID +//! (`S-1-5-21-1111111111-2222222222-4141414141----`, from the +//! SHA-256 of its path, [`root_sid_from_digest`]), whose grant on that root +//! is kept across runs ([`acl`]); //! - `Everyone`, so `> NUL` still works; //! - this logon's SID, so the command can use its window station and desktop //! and start at all. @@ -36,10 +39,11 @@ //! NTFS inheritance is written into every object beneath a root, not computed //! at access time, so granting a root costs time linear in its size (incode //! measured 2.4-2.6 s each way on 18,673 objects) and touches every object's -//! security descriptor, though no file's contents or mtime. The revoke after -//! the run is exact (an `icacls /save` of the tree was byte-identical before -//! and after). A run that crashes leaves its ACE; the next run sweeps it -//! ([`acl`]). +//! security descriptor, though no file's contents or mtime. So a root's grant +//! is made by the first run on it and KEPT: later runs read the root's own +//! ACL to see it is there and walk nothing. `insbx revoke` takes it back +//! exactly. The temp directory's grant is per run: revoked after it, and a +//! run that crashes leaves its ACE for the next run's sweep ([`acl`]). //! //! # Reads: `deny_read` is NOT enforced //! @@ -102,6 +106,8 @@ pub(crate) mod setup; #[cfg(windows)] mod token; +#[cfg(windows)] +pub use acl::{kept_folders, revoke_kept, KeptFolder}; #[cfg(windows)] pub(crate) use helper::enter; @@ -151,6 +157,76 @@ pub fn is_session_sid(sid: &str) -> bool { .is_some_and(|(rid, r)| rid == r.to_string()) } +/// Every writable root's own SID starts with this ([`root_sid_from_digest`]). +/// A different domain part from [`SID_PREFIX`], so the crash sweep, which +/// only ever revokes run SIDs, never touches a kept grant. Every part must +/// fit in 32 bits: Windows stores a larger one as `4294967295`, and the ACE +/// would then name a different SID from the token's. +pub const ROOT_SID_PREFIX: &str = "S-1-5-21-1111111111-2222222222-4141414141-"; + +/// A writable root's SID, from the SHA-256 of its [`path_key`] (`acl::root_sid` +/// computes the digest): the prefix and the digest's first 16 bytes as four +/// decimal sub-authorities. The same folder always gets the same SID, so its +/// grant can be kept across runs and checked with one read of the folder's +/// own ACL instead of re-made by walking every file beneath it. +/// +/// Not a secret, as a run SID is not: a confined command cannot add a SID to +/// its own token (`CreateRestrictedToken` on a restricted token intersects +/// the restricting SIDs), and only insbx's helper builds tokens, with the SIDs +/// of the run's own roots and no others ([`is_root_sid`]). +#[must_use] +pub fn root_sid_from_digest(digest: &[u8; 32]) -> String { + let part = + |i: usize| u32::from_le_bytes([digest[i], digest[i + 1], digest[i + 2], digest[i + 3]]); + format!( + "{ROOT_SID_PREFIX}{}-{}-{}-{}", + part(0), + part(4), + part(8), + part(12) + ) +} + +/// Whether `sid` has the shape of a root SID: the prefix and exactly four +/// decimal sub-authorities, written as Windows writes them. The helper +/// refuses any other in a spec's `root_sids`. +#[must_use] +pub fn is_root_sid(sid: &str) -> bool { + let Some(rest) = sid.strip_prefix(ROOT_SID_PREFIX) else { + return false; + }; + let parts: Vec<&str> = rest.split('-').collect(); + parts.len() == 4 + && parts + .iter() + .all(|p| p.parse::().is_ok_and(|n| n.to_string() == *p)) +} + +/// The kept-grants list (`%LOCALAPPDATA%\insbx\kept`): one folder per line, +/// for `insbx grants` and `insbx revoke --all`. Only a listing: whether a +/// folder is granted is read from its own ACL, never from here, so an edited +/// list can neither grant nor hide a grant. Blank lines and a second spelling +/// of the same folder ([`path_key`]) are dropped. +#[must_use] +pub fn parse_kept(text: &str) -> Vec { + let mut seen = Vec::new(); + let mut out = Vec::new(); + for line in text.lines().map(str::trim).filter(|l| !l.is_empty()) { + let key = path_key(line); + if !seen.contains(&key) { + seen.push(key); + out.push(PathBuf::from(line)); + } + } + out +} + +/// [`parse_kept`]'s file, written back. +#[must_use] +pub fn kept_text(paths: &[PathBuf]) -> String { + paths.iter().map(|p| format!("{}\n", p.display())).collect() +} + /// The restricted token's default DACL, in SDDL: the user, SYSTEM and the /// run's SID, all full access. Objects the command creates without a /// descriptor of their own (its own process and threads) get this, and @@ -183,8 +259,9 @@ pub fn fs_status(fs: &Fs) -> Status { _ => "writes only beneath the writable roots and the run's private temp directory", }; Status::Enforced(format!( - "write-restricted token: reads anywhere, {writes} (each granted to a private per-run \ - SID, revoked after the run), the null device, and anywhere Everyone may write" + "write-restricted token: reads anywhere, {writes} (each root granted to its own SID, \ + kept for later runs until `insbx revoke`; the temp directory to a per-run SID, revoked \ + after the run), the null device, and anywhere Everyone may write" )) } @@ -772,6 +849,59 @@ mod tests { } } + #[test] + fn a_root_sid_is_four_sub_authorities_from_the_digest_and_nothing_else_passes() { + let mut digest = [0u8; 32]; + digest[0] = 1; // 1 little-endian + digest[4..8].copy_from_slice(&u32::MAX.to_le_bytes()); + digest[12] = 7; + digest[31] = 0xff; // past the 16 bytes used: no effect + let sid = root_sid_from_digest(&digest); + assert_eq!(sid, format!("{ROOT_SID_PREFIX}1-4294967295-0-7")); + assert!(is_root_sid(&sid)); + assert!(!is_session_sid(&sid), "a root SID is never a run SID"); + for bad in [ + ROOT_SID_PREFIX.to_string(), + format!("{ROOT_SID_PREFIX}1-2-3"), + format!("{ROOT_SID_PREFIX}1-2-3-4-5"), + format!("{ROOT_SID_PREFIX}1-2-3-04"), + format!("{ROOT_SID_PREFIX}1-2-3-4294967296"), + format!("{ROOT_SID_PREFIX}1-2-3-x"), + session_sid(77), + "S-1-1-0".to_string(), + "S-1-5-21-1111111111-2222222222-3333333333-1-2-3-4".to_string(), + ] { + assert!(!is_root_sid(&bad), "{bad}"); + } + // Different digests, different SIDs. + digest[8] = 1; + assert_ne!(root_sid_from_digest(&digest), sid); + } + + /// Windows stores a sub-authority above `u32::MAX` as `4294967295`, so a + /// prefix with one would name a different SID on disk than in the token + /// (it did: `4343434343`). + #[test] + fn every_part_of_both_sid_prefixes_fits_in_32_bits() { + for prefix in [SID_PREFIX, ROOT_SID_PREFIX] { + for part in prefix.trim_end_matches('-').split('-').skip(1) { + assert!(part.parse::().is_ok(), "{prefix}: {part}"); + } + } + } + + #[test] + fn the_kept_list_drops_blank_lines_and_second_spellings() { + let text = "C:\\w\\a\n\n \nc:/W/A/\nD:\\b c\n"; + let kept = parse_kept(text); + assert_eq!( + kept, + vec![PathBuf::from(r"C:\w\a"), PathBuf::from(r"D:\b c")] + ); + assert_eq!(parse_kept(&kept_text(&kept)), kept); + assert!(parse_kept("").is_empty()); + } + #[test] fn the_default_dacl_names_the_user_system_and_the_run() { assert_eq!( diff --git a/crates/sandbox/src/windows/token.rs b/crates/sandbox/src/windows/token.rs index 7258495..75572b1 100644 --- a/crates/sandbox/src/windows/token.rs +++ b/crates/sandbox/src/windows/token.rs @@ -71,10 +71,13 @@ pub(crate) fn sid(s: &str) -> Result { } /// A write-restricted token for one run: this process's token with every -/// privilege but `SeChangeNotify` removed, restricted to `run_sid`, -/// `Everyone` and the logon SID, so it writes only where one of them is -/// granted. Its default DACL lets the command open its own process. -pub(crate) fn restricted(run_sid: &str) -> Result { +/// privilege but `SeChangeNotify` removed, restricted to `run_sid` (the +/// run's temp directory), `root_sids` (this run's writable roots' kept +/// grants, `acl::root_sid`), `Everyone` and the logon SID, so it writes only +/// where one of them is granted. Its default DACL lets the command open its +/// own process. Called by `helper::confining_token`, which has checked every +/// SID's shape. +pub(crate) fn restricted(run_sid: &str, root_sids: &[String]) -> Result { // SAFETY: Win32 handle work; each call is checked and every handle this // owns is closed. The SIDs and the array outlive the calls that read // them. @@ -85,22 +88,20 @@ pub(crate) fn restricted(run_sid: &str) -> Result { } let base = OwnedHandle(base); let private = sid(run_sid)?; + let roots = root_sids + .iter() + .map(|s| sid(s)) + .collect::, _>>()?; let everyone = sid(EVERYONE)?; let logon = logon_sid(base.0)?; - let restricting = [ - SID_AND_ATTRIBUTES { - Sid: private.0, + let restricting: Vec = std::iter::once(&private) + .chain(&roots) + .chain([&everyone, &logon]) + .map(|s| SID_AND_ATTRIBUTES { + Sid: s.0, Attributes: 0, - }, - SID_AND_ATTRIBUTES { - Sid: everyone.0, - Attributes: 0, - }, - SID_AND_ATTRIBUTES { - Sid: logon.0, - Attributes: 0, - }, - ]; + }) + .collect(); let mut token: HANDLE = std::ptr::null_mut(); if CreateRestrictedToken( base.0, @@ -117,7 +118,8 @@ pub(crate) fn restricted(run_sid: &str) -> Result { return Err(last_error("CreateRestrictedToken")); } let token = OwnedHandle(token); - drop((private, everyone, logon)); + drop(restricting); + drop((private, roots, everyone, logon)); let user = token_user_sid(base.0)?; set_default_dacl(token.0, &super::default_dacl_sddl(&user, run_sid))?; Ok(token) diff --git a/crates/sandbox/tests/escape_windows.rs b/crates/sandbox/tests/escape_windows.rs index 0b3f49d..1e21c84 100644 --- a/crates/sandbox/tests/escape_windows.rs +++ b/crates/sandbox/tests/escape_windows.rs @@ -27,6 +27,8 @@ use serde_json::{json, Value}; const INSBX: &str = env!("CARGO_BIN_EXE_insbx"); /// Every run SID starts with this (`incord_sandbox::windows::SID_PREFIX`). const SID_MARK: &str = "4242424242"; +/// Every root's kept SID has this (`incord_sandbox::windows::ROOT_SID_PREFIX`). +const KEEP_MARK: &str = "4141414141"; /// The offline account (`incord_sandbox::windows::offline::ACCOUNT`). const OFFLINE: &str = "insbx-offline"; @@ -195,20 +197,62 @@ fn writes_land_only_inside_the_writable_root() { assert!(!outside.exists(), "wrote outside the root: {}", text(&o)); } +/// The root's grant is its own SID's, kept after the run (later runs only +/// check it); the temp directory's is the run's SID, gone with the run. +/// `insbx grants` lists the root and `insbx revoke` takes the grant back. #[test] -fn the_grant_is_held_for_the_run_and_revoked_after() { +fn the_roots_grant_is_kept_the_temp_grant_is_not_and_revoke_takes_it_back() { let d = dirs(); - let o = cmd(&d.ws, &["-w", "."], "icacls ."); + let o = cmd(&d.ws, &["-w", "."], "icacls . & icacls %TEMP%"); + let during = text(&o); + assert!(during.contains(KEEP_MARK), "the root's own ACE: {during}"); + assert!(during.contains(SID_MARK), "the temp's run ACE: {during}"); + let after = icacls(&d.ws); + assert!(after.contains(KEEP_MARK), "kept after the run: {after}"); + assert!(!after.contains(SID_MARK), "no run SID on the root: {after}"); + + let ws = d.ws.display().to_string().to_ascii_lowercase(); + let listed = text(&insbx(&["grants"], &d.ws)).to_ascii_lowercase(); assert!( - text(&o).contains(SID_MARK), - "the root carries the run's ACE during the run: {}", - text(&o) + listed + .lines() + .any(|l| l.starts_with("granted") && l.ends_with(&ws)), + "{listed}" ); - let after = icacls(&d.ws); + let o = insbx(&["revoke", "."], &d.ws); + assert_eq!(o.status.code(), Some(0), "{}", text(&o)); + let revoked = icacls(&d.ws); + assert!(!revoked.contains(KEEP_MARK), "{revoked}"); + let listed = text(&insbx(&["grants"], &d.ws)).to_ascii_lowercase(); + assert!(!listed.contains(&ws), "{listed}"); +} + +/// A kept grant lets no other run write there: a run whose roots do not +/// include the folder holds no SID its ACE names. +#[test] +fn a_kept_grant_is_writable_only_to_runs_that_name_the_folder() { + let d = dirs(); + let o = cmd(&d.out, &["-w", "."], "echo a> first.txt"); + assert!(d.out.join("first.txt").exists(), "{}", text(&o)); + assert!(icacls(&d.out).contains(KEEP_MARK), "kept on out"); + let target = d.out.join("from-ws.txt"); + let o = cmd( + &d.ws, + &["-w", "."], + &format!("echo bad> {} & echo ok> mine.txt", target.display()), + ); + assert!(d.ws.join("mine.txt").exists(), "{}", text(&o)); assert!( - !after.contains(SID_MARK), - "the ACE outlived the run: {after}" + !target.exists(), + "a run for ws wrote in out's kept grant: {}", + text(&o) ); + // Control: naming out again, it writes. + let o = cmd(&d.out, &["-w", "."], "echo b> second.txt"); + assert!(d.out.join("second.txt").exists(), "{}", text(&o)); + for dir in [&d.ws, &d.out] { + insbx(&["revoke", dir.to_str().expect("utf8")], dir); + } } #[test] @@ -900,15 +944,17 @@ fn under_network_deny_writes_stay_confined_and_exit_codes_pass_through() { assert_eq!(o.status.code(), Some(127), "{}", text(&o)); } +/// Under network deny the account's ACE on a root is kept with the root's +/// own, and `insbx revoke` takes both back. #[test] -fn the_offline_accounts_grant_lasts_the_run_and_no_longer() { - if !needs_offline("the_offline_accounts_grant_lasts_the_run") { +fn the_offline_accounts_grant_on_a_root_is_kept_until_revoked() { + if !needs_offline("the_offline_accounts_grant_on_a_root_is_kept") { return; } let d = dirs(); let o = cmd(&d.ws, &["--net", "deny", "-w", "."], "icacls . & whoami"); let during = text(&o); - assert!(during.contains(SID_MARK), "{during}"); + assert!(during.contains(KEEP_MARK), "{during}"); assert!(during.contains(OFFLINE), "the account's ACE: {during}"); assert!( during @@ -917,11 +963,14 @@ fn the_offline_accounts_grant_lasts_the_run_and_no_longer() { "whoami names the offline account: {during}" ); let after = icacls(&d.ws); + assert!(after.contains(KEEP_MARK), "{after}"); + assert!(after.contains(OFFLINE), "kept: {after}"); assert!(!after.contains(SID_MARK), "{after}"); - assert!( - !after.contains(OFFLINE), - "the account's ACE outlived the run: {after}" - ); + let o = insbx(&["revoke", "."], &d.ws); + assert_eq!(o.status.code(), Some(0), "{}", text(&o)); + let revoked = icacls(&d.ws); + assert!(!revoked.contains(KEEP_MARK), "{revoked}"); + assert!(!revoked.contains(OFFLINE), "{revoked}"); } #[test] @@ -968,8 +1017,8 @@ fn concurrent_deny_runs_share_a_root_and_cannot_write_each_others() { while !d.ws.join("started.txt").exists() && Instant::now() < deadline { std::thread::sleep(Duration::from_millis(100)); } - // B: the same workspace only. `out` carries the account's ACE (A's), - // but not B's run SID: B cannot write there. + // B: the same workspace only. `out` carries the account's ACE and out's + // own kept SID, which B's token does not hold: B cannot write there. let o = cmd( &d.ws, &["--net", "deny", "-w", "."], @@ -991,7 +1040,11 @@ fn concurrent_deny_runs_share_a_root_and_cannot_write_each_others() { "A lost its grant when B ended: {}", text(&a) ); - assert!(!icacls(&d.ws).contains(OFFLINE), "{}", icacls(&d.ws)); + for dir in [&d.ws, &other] { + let o = insbx(&["revoke", dir.to_str().expect("utf8")], &d.ws); + assert_eq!(o.status.code(), Some(0), "{}", text(&o)); + assert!(!icacls(dir).contains(OFFLINE), "{}", icacls(dir)); + } } /// The account's ACE lines in `icacls` output. @@ -1110,6 +1163,11 @@ fn powershell_under_network_deny_starts_in_the_current_folder() { ); assert!(offline_aces(&icacls(&sibling)).is_empty()); assert!(offline_aces(&icacls(&d.out)).is_empty()); + // The workspace is the run's root: its grant, the account's included, + // is kept until revoked. + assert!(!offline_aces(&icacls(&d.ws)).is_empty(), "kept on the root"); + let o = insbx(&["revoke", "."], &d.ws); + assert_eq!(o.status.code(), Some(0), "{}", text(&o)); assert!(offline_aces(&icacls(&d.ws)).is_empty()); } From 443b2439ad8ed6ae391c81ca50fd4967002d950b Mon Sep 17 00:00:00 2001 From: blockmandev <194144408+blockmandev@users.noreply.github.com> Date: Fri, 13 Nov 2026 09:41:53 -0600 Subject: [PATCH 2/2] insbx kept grants: the test proves no walk by the lease's own record; moved-in files need icacls /reset CI's windows runner showed the moved-file signal proves nothing: a file moved into a root is not re-ACL'd by any walk (here too, once looked at), so it could not show whether the second lease walked. The lease now records the roots whose grant it had to make; the test asserts the first lease walks, the second does not, and the one after revoke walks again. Docs that said revoke + the next run reaches moved-in files are corrected: no grant does (nor did the per-run one); icacls /reset does, and the test shows it. --- crates/sandbox/README.md | 5 +- crates/sandbox/src/main.rs | 4 +- crates/sandbox/src/windows/acl.rs | 83 ++++++++++++++++++++++--------- 3 files changed, 65 insertions(+), 27 deletions(-) diff --git a/crates/sandbox/README.md b/crates/sandbox/README.md index 5e45279..aafeebe 100644 --- a/crates/sandbox/README.md +++ b/crates/sandbox/README.md @@ -263,8 +263,9 @@ Windows. This crate's port is checked by its tests `insbx mcp` scripts default to PowerShell on Windows. - **Grants are visible, and kept.** Every object under a root that a run has used carries the root's ACE until `insbx revoke`. A file moved into a - root from elsewhere keeps the ACL it had, so the command cannot write it - until `insbx revoke ` and the next run grants the tree again. + root from elsewhere keeps the ACL it had (no grant re-ACLs it, kept or + per run), so the command cannot write it until `icacls /reset` + gives it its folder's ACL. ### Network natively: `insbx setup-windows` diff --git a/crates/sandbox/src/main.rs b/crates/sandbox/src/main.rs index af82831..7a19ad6 100644 --- a/crates/sandbox/src/main.rs +++ b/crates/sandbox/src/main.rs @@ -33,7 +33,7 @@ USAGE: each still carries it insbx revoke ... | --all Windows: take a folder's kept grant back; its next run grants - it again, files moved in since included + it again KEPT GRANTS (Windows): A writable root's grant is written into every file beneath it, so it is made by the @@ -41,7 +41,7 @@ KEPT GRANTS (Windows): the tree twice per run. Each folder has its own SID, and a run's token carries only its own roots' SIDs, so a kept grant lets no other run write there. A file moved into a root from elsewhere keeps its old ACL (not writable to the command) until - `insbx revoke `. + `icacls /reset` gives it its folder's. MCP OPTIONS (the ceilings; an agent can ask for less, never more): --root where sandboxes live (default: /insbx-mcp-) diff --git a/crates/sandbox/src/windows/acl.rs b/crates/sandbox/src/windows/acl.rs index b699ad3..2021464 100644 --- a/crates/sandbox/src/windows/acl.rs +++ b/crates/sandbox/src/windows/acl.rs @@ -24,10 +24,10 @@ //! folder never granted. `insbx revoke |--all` takes kept grants back //! ([`revoke_kept`]); `insbx grants` lists them ([`kept_folders`]). //! -//! What it costs: a file moved INTO a root from elsewhere keeps the ACL it -//! had and lacks the root's inherited ACE until the root is granted again, -//! so the command cannot write it (it fails closed); `insbx revoke ` -//! and the next run re-grants the whole tree. +//! A file moved INTO a root from elsewhere keeps the ACL it had: no grant's +//! walk re-ACLs it (measured, and so it was with the per-run grant too), so +//! the command cannot write it (it fails closed). `icacls /reset` +//! gives it its folder's ACL, the root's ACE included. //! //! # The temp directory: one SID per run //! @@ -230,6 +230,9 @@ pub(crate) struct Lease { /// The kept SIDs of this run's writable roots ([`root_sid`]), for the /// command's token. root_sids: Vec, + /// The roots whose grant this lease had to make (walking their trees); + /// a root granted before is only read, and is not here. + walked: Vec, /// The named mutex that tells a later sweep this run is alive. _alive: OwnedHandle, } @@ -302,6 +305,7 @@ impl Lease { reads: Vec::new(), parents: Vec::new(), root_sids: Vec::new(), + walked: Vec::new(), _alive: alive, }; // Written down BEFORE anything is granted, so a crash at any point @@ -330,13 +334,22 @@ impl Lease { /// Stops at the first that fails. fn keep_roots(&mut self, roots: &[PathBuf]) -> Result<(), String> { for root in roots { - let sid = keep_root(root, self.record.user.as_deref()) + let (sid, walked) = keep_root(root, self.record.user.as_deref()) .map_err(|e| format!("workspace-write could not grant {}: {e}", root.display()))?; self.root_sids.push(sid); + if walked { + self.walked.push(root.clone()); + } } Ok(()) } + /// The roots whose grant this lease made, walking their trees. + #[cfg(test)] + fn walked(&self) -> &[PathBuf] { + &self.walked + } + /// Grant each root in turn ([`grant_root`]), for [`Lease::acquire`], /// stopping at the first that fails. fn grant_roots(&mut self, roots: &[PathBuf]) -> Result<(), String> { @@ -536,17 +549,19 @@ pub(crate) fn root_sid(root: &Path) -> Result { /// to the account and the user's own ACL rights beneath ([`keep_acl_rights`]). /// Each is read off the folder's own ACL first ([`passes_down`]) and made /// only when missing, so a root granted before costs one ACL read, not a -/// walk of its tree. The SID. +/// walk of its tree. The SID, and whether a grant had to be made (a walk). /// /// A grant that fails part-way (a file beneath the user may not re-ACL) has /// the root's ACE taken off again, so the next run walks and reports it /// again instead of finding the ACE on the folder and trusting a tree only /// part granted. Under the ACL lock throughout, so two runs granting the /// same new folder do not both walk it. -fn keep_root(root: &Path, user: Option<&str>) -> Result { +fn keep_root(root: &Path, user: Option<&str>) -> Result<(String, bool), String> { let sid = root_sid(root)?; let _lock = AclLock::take()?; + let mut walked = false; if !passes_down(root, &sid, MODIFY)? { + walked = true; if let Err(e) = change(root, &sid, Change::Grant(MODIFY)) { let _ = change(root, &sid, Change::Revoke); return Err(e); @@ -554,15 +569,16 @@ fn keep_root(root: &Path, user: Option<&str>) -> Result { } if let Some(user) = user { if !passes_down(root, user, MODIFY)? { + walked = true; if let Err(e) = grant_account(root, user, MODIFY) { let _ = change(root, user, Change::Revoke); return Err(e); } } - keep_acl_rights(root)?; + walked |= keep_acl_rights(root)?; } remember_kept(root); - Ok(sid) + Ok((sid, walked)) } /// Make sure the offline account `user` may read the folder `dir` (the @@ -676,8 +692,8 @@ pub fn kept_folders() -> Result, String> { /// account `user`, the account's ACEs on it; then drop it from the kept /// list. The user's own ACL rights stay ([`keep_acl_rights`] says why). A /// run that is using the folder right now loses its writes there. The next -/// run with it as a root grants the whole tree again, which also reaches -/// files moved in since. +/// run with it as a root grants the whole tree again (files moved in keep +/// their own ACL even then; `icacls /reset` fixes one). /// /// # Errors /// When an ACE cannot be removed; the folder stays listed then. @@ -1536,11 +1552,11 @@ mod tests { /// **A KEPT GRANT IS MADE ONCE, THEN ONLY READ; REVOKE TAKES IT BACK**: /// the first lease walks the root (a file beneath gets the root's ACE); - /// a file then MOVED in keeps the ACL it had, and the second lease leaves - /// it so, which shows the second lease did not walk the tree (a walk - /// would have given it the ACE). `revoke_kept` takes the ACE off the root - /// and its files and drops the root from the kept list; the next lease - /// walks again, and the moved file gets the ACE. + /// the second only reads the root's ACL and walks nothing. `revoke_kept` + /// takes the ACE off the root and its files and drops the root from the + /// kept list; the next lease walks again. A file MOVED in keeps the ACL + /// it had through all of it (no walk re-ACLs it, kept grant or not), and + /// `icacls /reset` gives it the folder's. #[test] fn a_kept_grant_is_made_once_then_only_read_and_revoke_takes_it_back() { let dir = tempfile::tempdir().expect("tempdir"); @@ -1559,6 +1575,11 @@ mod tests { let first = Lease::acquire(std::slice::from_ref(&root), &temp("t1"), None).expect("first"); assert_eq!(first.root_sids(), std::slice::from_ref(&sid)); + assert_eq!( + first.walked(), + std::slice::from_ref(&root), + "the first walks" + ); drop(first); assert!(acl_of(&root).contains(&sid), "kept on the root"); assert!(acl_of(&beneath).contains(&sid), "and beneath it"); @@ -1576,12 +1597,9 @@ mod tests { let second = Lease::acquire(std::slice::from_ref(&root), &temp("t2"), None).expect("second"); assert_eq!(second.root_sids(), std::slice::from_ref(&sid)); + assert!(second.walked().is_empty(), "the second only reads the ACL"); drop(second); - assert!( - !acl_of(&moved).contains(&sid), - "the second lease walked the tree: {}", - acl_of(&moved) - ); + assert!(!acl_of(&moved).contains(&sid), "{}", acl_of(&moved)); revoke_kept(&root, None).expect("revoke"); for path in [&root, &beneath] { @@ -1594,12 +1612,31 @@ mod tests { ); let third = Lease::acquire(std::slice::from_ref(&root), &temp("t3"), None).expect("third"); + assert_eq!( + third.walked(), + std::slice::from_ref(&root), + "revoked: walks again" + ); drop(third); assert!( - acl_of(&moved).contains(&sid), + acl_of(&beneath).contains(&sid), "granted again, the whole tree: {}", - acl_of(&moved) + acl_of(&beneath) + ); + // The moved file: not reached by the walk either; `icacls /reset` + // rebuilds its ACL from its folder's. + assert!(!acl_of(&moved).contains(&sid), "{}", acl_of(&moved)); + let reset = std::process::Command::new("icacls") + .arg(&moved) + .arg("/reset") + .output() + .expect("icacls"); + assert!( + reset.status.success(), + "{}", + String::from_utf8_lossy(&reset.stdout) ); + assert!(acl_of(&moved).contains(&sid), "reset: {}", acl_of(&moved)); revoke_kept(&root, None).expect("cleanup"); }