From 697279c56f74b38d4211d3291e0ea297a04747ef Mon Sep 17 00:00:00 2001 From: Adithya Shankaran <72570811+adikshan11@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:01:52 +0530 Subject: [PATCH] Automation roots: refuse a network, device or non-disk verbatim path before the file system is asked about it (#2799) Refuse UNC, device and non-disk verbatim paths in automation roots by their form, before any file-system lookup, and judge each symlink from its own text. This closes the NTLM/WebDAV leak where canonicalize was asked about a path first. --- crates/engine/src/file_access.rs | 475 ++++++++++++++++++++++++++++++- docs/mcp.md | 7 +- 2 files changed, 477 insertions(+), 5 deletions(-) diff --git a/crates/engine/src/file_access.rs b/crates/engine/src/file_access.rs index e1127dd5f..ed4f03dea 100644 --- a/crates/engine/src/file_access.rs +++ b/crates/engine/src/file_access.rs @@ -13,6 +13,11 @@ //! (`/work2` isn't inside `/work`), in the case the file system stores (so a case-variant name //! reaches the same folder on an ordinary Windows volume, and a distinct sibling in a //! case-sensitive one stays outside). Two roots don't make their common parent one. +//! - On Windows a network path (`\\server\share`, `\\?\UNC\...`, WebDAV's `\\host@SSL\share`), a +//! device path (`\\.\...`) or a verbatim path that isn't a disk (a volume by its `\\?\Volume{…}` name is local) is refused by its name before +//! the file system is asked about it, unless a root is on that same server and share (or that +//! same verbatim prefix). Looking such a path up would contact a host the agent chose. A link +//! whose text leads to one is refused before it is followed. //! - Read and write access are separate: a root given alone grants only its own kind of access. //! //! Roots are in force on a thread inside [`confine`], and in the whole process after @@ -24,7 +29,7 @@ //! guard against other programs on the computer. use std::cell::RefCell; -use std::ffi::OsString; +use std::ffi::{OsStr, OsString}; use std::path::{Component, Path, PathBuf}; use std::sync::{Arc, OnceLock}; @@ -110,7 +115,8 @@ impl AutomationRoots { Access::Write => Err(format!("automation filesystem access is not granted: write authority is absent: {}", path.display())), }; } - let resolved = resolve(path)?; + let folders: Vec<&Path> = roots.iter().map(|r| r.resolved.as_path()).collect(); + let resolved = resolve(path, &folders)?; if roots.iter().any(|r| inside(&resolved, &r.resolved)) { return Ok(()); } @@ -210,7 +216,10 @@ pub fn check_write(path: impl AsRef) -> Result<(), String> { /// `path` made absolute with its links followed; for a path that doesn't exist (yet), its nearest /// existing folder's links followed and the rest appended. -fn resolve(path: &Path) -> Result { +/// +/// A Windows network, device or non-disk verbatim prefix is refused before any of that, unless one +/// of `roots` (resolved folders) already stands on the same server and share or the same verbatim prefix. +fn resolve(path: &Path, roots: &[&Path]) -> Result { if path.as_os_str().is_empty() { return Err("automation path rejected: path is empty".into()); } @@ -218,7 +227,26 @@ fn resolve(path: &Path) -> Result { if cfg!(windows) && path.components().any(|c| matches!(c, Component::Normal(n) if is_device_name(&n.to_string_lossy()))) { return Err(format!("automation path rejected: reserved device names are not allowed: {}", path.display())); } + // Win32 trims a trailing period or space from a name where it looks one up, but not always from a name in the middle: refused as given. + if cfg!(windows) && has_trimmed_name(path) { + return Err(format!("automation path rejected: a name Windows trims: {}", path.display())); + } + // Before `absolute` too: on Windows that call asks the system about the path. + if let Some(why) = refused_prefix(path, roots) { + return Err(format!("automation path rejected: {why}: {}", path.display())); + } let absolute = std::path::absolute(path).map_err(|e| format!("automation path rejected: cannot resolve {}: {e}", path.display()))?; + if let Some(why) = refused_prefix(&absolute, roots) { + return Err(format!("automation path rejected: {why}: {}", path.display())); + } + // A link is judged by its own text: canonicalizing one that leads to a network path would + // contact that host. Only Windows has such prefixes. One walk of the whole path covers every + // shorter one the loop below tries. + if cfg!(windows) + && let Some(why) = link_leads_to_refused_prefix(&absolute, roots) + { + return Err(format!("automation path rejected: {why}: {}", path.display())); + } // The names below the nearest existing folder, last first. let mut missing: Vec = vec![]; let mut at = absolute.as_path(); @@ -273,6 +301,213 @@ pub(crate) fn is_device_name(component: &str) -> bool { matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CLOCK$" | "CONIN$" | "CONOUT$") || numbered("COM") || numbered("LPT") } +/// A Windows path prefix that isn't a local disk: opening or even resolving a path that starts +/// with one can reach another computer. +#[derive(Debug)] +enum OffDisk { + /// `\\server\share` or `\\?\UNC\server\share`; WebDAV's `\\host@SSL\share` is a server name too. + Unc(OsString, OsString), + /// `\\.\device`, which no root stands on: a configured one is canonicalized to a disk path. + Device, + /// `\\?\` followed by anything but a drive or `UNC`. + Verbatim(OsString), +} + +impl OffDisk { + /// The prefix of `path` when it isn't a local disk. A drive letter, a path without a prefix + /// and every path off Windows give `None`. + fn of(path: &Path) -> Option { + use std::path::Prefix; + let Some(Component::Prefix(prefix)) = path.components().next() else { return Self::unparsed(path) }; + match prefix.kind() { + Prefix::Disk(_) | Prefix::VerbatimDisk(_) => None, + Prefix::UNC(server, share) | Prefix::VerbatimUNC(server, share) => Some(Self::Unc(server.to_os_string(), share.to_os_string())), + Prefix::DeviceNS(_) => Some(Self::Device), + // A volume named by its GUID (a folder a volume is mounted in) is on this computer. + Prefix::Verbatim(rest) if is_volume_name(rest) => None, + Prefix::Verbatim(rest) => Some(Self::Verbatim(rest.to_os_string())), + } + } + + /// A Windows path `std` finds no prefix in, though Windows reads one: two separators that aren't a whole + /// `\\server\share` (`\\server`, `\\\x`) name a computer, so that is a UNC path with no share; `\??\` is + /// the NT form of `\\?\` (`\??\UNC\server\share`), so that is a device path. + fn unparsed(path: &Path) -> Option { + let bytes = path.as_os_str().as_encoded_bytes(); + let separator = |b: Option<&u8>| matches!(b, Some(b'\\' | b'/')); + if !cfg!(windows) { + None + } else if separator(bytes.first()) && separator(bytes.get(1)) { + Some(Self::Unc(OsString::new(), OsString::new())) + } else if bytes.get(..4).is_some_and(|b| b.eq_ignore_ascii_case(br"\??\")) { + Some(Self::Device) + } else { + None + } + } + + /// The refusal for a path with this prefix, which names the prefix. + fn refusal(&self) -> &'static str { + match self { + Self::Unc(..) => "UNC paths are refused unless a root is on the same server and share", + Self::Device => "device paths are refused", + Self::Verbatim(_) => "verbatim paths are refused unless a root uses the same prefix", + } + } + + /// Whether `other` is the same server and share, or the same verbatim prefix, the ASCII case aside. This + /// decides only whether that host may be contacted; [`inside`] still decides the folder. + fn same_as(&self, other: &Self) -> bool { + let same = |a: &OsString, b: &OsString| a.eq_ignore_ascii_case(b); + match (self, other) { + (Self::Unc(server, share), Self::Unc(other_server, other_share)) => same(server, other_server) && same(share, other_share), + (Self::Verbatim(rest), Self::Verbatim(other)) => same(rest, other), + _ => false, + } + } +} + +/// Why `path` must not be looked up: it starts with a Windows network, device or non-disk +/// verbatim prefix and none of `roots` stands on that same server and share or verbatim prefix. A local path gives `None`. +fn refused_prefix(path: &Path, roots: &[&Path]) -> Option<&'static str> { + let prefix = OffDisk::of(path)?; + if roots.iter().filter_map(|root| OffDisk::of(root)).any(|root| root.same_as(&prefix)) { None } else { Some(prefix.refusal()) } +} + +/// How many links in a row [`link_leads_to_refused_prefix`] follows before it gives up and refuses. +const MAX_LINK_HOPS: usize = 40; + +/// How many spellings of a path one walk scans in all, so a hostile set of links can't make it +/// scan without end. +const MAX_SPELLINGS: usize = 1024; + +/// The refusal for a link in `path`, taken from the link's own text. +/// +/// Folders are inspected from the top down with [`std::fs::symlink_metadata`], which doesn't follow +/// a link, and a link's target is read with [`std::fs::read_link`]. A link to a network path is +/// therefore refused before [`std::fs::canonicalize`] could open that host, also when the link is +/// only an ancestor of the name. A link whose target can't be read, the one after +/// [`MAX_LINK_HOPS`] in a row, or a walk past [`MAX_SPELLINGS`] spellings, is refused rather than +/// opened. +fn link_leads_to_refused_prefix(path: &Path, roots: &[&Path]) -> Option<&'static str> { + follow_links(path, roots, &mut std::collections::HashSet::new(), MAX_LINK_HOPS) +} + +/// [`link_leads_to_refused_prefix`] for one spelling of the path. `judged` holds every spelling the +/// walk has scanned (so none is scanned twice, nor in a cycle forever) and `hops_left` the links +/// still allowed in this chain, which the other spelling of a target does not use up. +fn follow_links(path: &Path, roots: &[&Path], judged: &mut std::collections::HashSet, hops_left: usize) -> Option<&'static str> { + // A \\?\ path is opened as written, so a link before its `..` is followed; rebuilding the path below would pop that link unseen. + if matches!(path.components().next(), Some(Component::Prefix(p)) if p.kind().is_verbatim()) + && path.components().any(|c| c == Component::ParentDir) + { + return Some("parent traversal in a verbatim path"); + } + // Without a trailing separator: Windows reads `remote\` as a folder to go into, so a link named `remote` would be followed by the + // probe itself, to wherever it leads, instead of being seen as a link. + let normalized: PathBuf = path.components().collect(); + let path = normalized.as_path(); + if !judged.insert(path.to_path_buf()) { + return None; + } + if judged.len() > MAX_SPELLINGS { + return Some("too many links"); + } + let mut ancestors: Vec<&Path> = path.ancestors().collect(); + ancestors.reverse(); + for prefix in ancestors { + if prefix.as_os_str().is_empty() { + continue; + } + if let Some(why) = refused_prefix(prefix, roots) { + return Some(why); + } + let meta = match std::fs::symlink_metadata(prefix) { + Ok(meta) => meta, + // Nothing is there, so no link is below it. + Err(e) if matches!(e.kind(), std::io::ErrorKind::NotFound | std::io::ErrorKind::NotADirectory) => return None, + // Anything else (no permission to look): a link below it can't be seen, so don't go on. + Err(_) => return Some("a folder that can't be looked at"), + }; + if !meta.file_type().is_symlink() { + continue; + } + if hops_left == 0 { + return Some("too many links"); + } + let Ok(target) = std::fs::read_link(prefix) else { return Some("a link that leads nowhere") }; + if cfg!(windows) && is_native_name(&target) { + return Some("device paths are refused"); + } + // Win32 lookups trim a trailing period or space, the kernel follows a link target as written: the two could name different things. + if cfg!(windows) && has_trimmed_name(&target) { + return Some("a link to a name Windows trims"); + } + // Judged as written: joined onto the link's folder, a bare `\\server` would keep that folder's drive. + if let Some(why) = refused_prefix(&target, roots) { + return Some(why); + } + let joined = match prefix.parent() { + Some(parent) if !target.is_absolute() && !parent.as_os_str().is_empty() => parent.join(target), + _ => target, + }; + let next = match path.strip_prefix(prefix) { + Ok(rest) if !rest.as_os_str().is_empty() => joined.join(rest), + _ => joined, + }; + if let Some(why) = refused_prefix(&next, roots) { + return Some(why); + } + // Windows takes the `..` of a relative target by name, so `missing\..\remote` is `remote` + // though `missing` isn't there: judge that spelling as well as the one written. + let by_name = lexical(&next); + if by_name != next + && let Some(why) = follow_links(&by_name, roots, judged, hops_left - 1) + { + return Some(why); + } + return follow_links(&next, roots, judged, hops_left - 1); + } + None +} + +/// Whether `rest` (the part after `\\?\`) names a volume by its GUID, `Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}`: a local volume, such as the one +/// a folder is a mount point of. +fn is_volume_name(rest: &OsStr) -> bool { + let bytes = rest.as_encoded_bytes(); + bytes.len() == 44 + && bytes.get(..7).is_some_and(|b| b.eq_ignore_ascii_case(b"Volume{")) + && bytes.ends_with(b"}") + && bytes[7..43].iter().enumerate().all(|(i, b)| if matches!(i, 8 | 13 | 18 | 23) { *b == b'-' } else { b.is_ascii_hexdigit() }) +} + +/// Whether `path` is a name that starts with one separator and no drive (`\Device\Mup\server\share`, `\RPC Control\x`, +/// `\??\UNC\x`, `\work`), as a link may hold one: `std` sees no prefix in it, yet the system reads it in its own object +/// namespace or on the link's drive, and may follow it to wherever it names. Joined onto the link's folder it would look local. +fn is_native_name(path: &Path) -> bool { + matches!(path.as_os_str().as_encoded_bytes(), [b'\\', rest @ ..] if rest.first() != Some(&b'\\')) +} + +/// Whether any plain name in `path` ends in a period or a space, which Win32 path handling trims before it looks the name up. +fn has_trimmed_name(path: &Path) -> bool { + path.components().any(|c| matches!(c, Component::Normal(n) if n.as_encoded_bytes().last().is_some_and(|b| matches!(b, b'.' | b' ')))) +} + +/// `path` with its `.` and `..` taken by name, never above its root. +fn lexical(path: &Path) -> PathBuf { + let mut out = PathBuf::new(); + for component in path.components() { + match component { + Component::ParentDir => { + out.pop(); + } + Component::CurDir => {} + other => out.push(other), + } + } + out +} + #[cfg(test)] mod tests { use super::*; @@ -545,6 +780,240 @@ mod tests { let _ = std::fs::remove_dir_all(base); } + /// A path with no Windows prefix, a drive letter, and every path off Windows have no off-disk prefix to refuse. + #[test] + fn a_local_path_has_no_off_disk_prefix() { + for p in ["/home/me/a.designcraft", "a.designcraft", r"C:\Projects\a.designcraft", r"\\?\C:\Projects\a.designcraft"] { + assert!(OffDisk::of(Path::new(p)).is_none(), "{p}"); + assert_eq!(refused_prefix(Path::new(p), &[]), None, "{p}"); + } + } + + /// A network, device or non-disk verbatim path is refused by its name before the file system is + /// asked, so no host the agent names is contacted. The error names the prefix; it is not the + /// error that opening the path would give. Nothing here touches the network. + #[cfg(windows)] + #[test] + fn a_network_path_is_refused_before_it_is_opened() { + let (base, roots) = folders("unc"); + let paths = [ + (r"\\203.0.113.5\s\x.designcraft", "UNC"), + (r"\\?\UNC\203.0.113.5\s\x.designcraft", "UNC"), + ("//203.0.113.5/s/x.designcraft", "UNC"), + (r"\\host@SSL\share\x.designcraft", "UNC"), + (r"\\host@SSL@443\share\x.designcraft", "UNC"), + (r"\\203.0.113.5", "UNC"), + (r"\\\203.0.113.5\s\x.designcraft", "UNC"), + ("//203.0.113.5", "UNC"), + (r"\\.\PhysicalDrive0", "device path"), + (r"\\?\GLOBALROOT\Device\Mup\203.0.113.5\s\x.designcraft", "verbatim path"), + (r"\??\UNC\203.0.113.5\s\x.designcraft", "device path"), + ]; + for (p, kind) in paths { + for access in [Access::Read, Access::Write] { + let e = roots.check(p, access).unwrap_err(); + assert!(e.starts_with("automation path rejected:"), "{p}: {e}"); + assert!(e.contains(kind), "{p}: {e}"); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{p}: {e}"); + } + } + let e = roots.check(s(base.join("outside/secret.designcraft")), Access::Read).unwrap_err(); + assert!(e.contains("outside the read root"), "a local path is still judged by its folder: {e}"); + let verbatim = format!(r"\\?\{}", s(base.join("in").join("a.designcraft"))); + assert_eq!(roots.check(&verbatim, Access::Read), Ok(()), "a verbatim disk path is a local path: {verbatim}"); + let _ = std::fs::remove_dir_all(base); + } + + /// A root on a share lets that server and share through (either spelling, any ASCII case) and nothing else. + #[cfg(windows)] + #[test] + fn a_root_on_a_share_lets_only_that_share_through() { + assert!(OffDisk::of(Path::new(r"\\?\Volume{00000000-0000-0000-0000-000000000000}\x")).is_none(), "a volume by GUID is local"); + assert!(OffDisk::of(Path::new(r"\\?\Volume{remote}\x")).is_some(), "a name that is not a GUID is not a volume"); + let share = [Path::new(r"\\?\UNC\FileServer\Projects\work")]; + assert_eq!(refused_prefix(Path::new(r"\\fileserver\projects\a.designcraft"), &share), None); + assert_eq!(refused_prefix(Path::new(r"\\?\UNC\FILESERVER\PROJECTS\a.designcraft"), &share), None); + assert!(refused_prefix(Path::new(r"\\fileserver\secret\a.designcraft"), &share).is_some(), "another share"); + assert!(refused_prefix(Path::new(r"\\203.0.113.5\Projects\a.designcraft"), &share).is_some(), "another server"); + let work = [Path::new(r"\\?\UNC\work\Projects\w")]; + assert!(refused_prefix(Path::new("\\\\wor\u{212a}\\Projects\\a.designcraft"), &work).is_some(), "U+212A is not k"); + assert!(refused_prefix(Path::new(r"\\.\PhysicalDrive0"), &share).is_some(), "a share is not a device"); + let device = [Path::new(r"\\.\PhysicalDrive0")]; + assert!(refused_prefix(Path::new(r"\\.\PhysicalDrive0"), &device).is_some(), "a device is refused even when a root names it"); + } + + /// A link whose text is a bare `\\server` (no share) is refused as written: joined onto the link's folder + /// it would read as a local path and pass. + #[cfg(windows)] + #[test] + fn a_link_to_a_bare_server_name_is_refused() { + let (base, roots) = folders("unc-link-bare"); + let link = base.join("in").join("bare"); + if std::os::windows::fs::symlink_dir(r"\\203.0.113.5", &link).is_err() { + eprintln!("skipped: symbolic links can't be made here"); + let _ = std::fs::remove_dir_all(base); + return; + } + let e = roots.check(s(link.join("x.designcraft")), Access::Read).unwrap_err(); + assert!(e.contains("UNC"), "{e}"); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}"); + let _ = std::fs::remove_dir_all(base); + } + + /// Nine links that each go through `sub\..\` to the next are nine links, not a reason to give up: both + /// spellings of each target are judged once. + #[cfg(windows)] + #[test] + fn a_chain_of_links_with_parent_names_is_followed_in_few_steps() { + let (base, roots) = folders("link-chain"); + let folder = base.join("in"); + std::fs::create_dir_all(folder.join("sub")).unwrap(); + for n in 1..=9 { + let target = if n == 9 { "sub".to_string() } else { format!(r"sub\..\l{}", n + 1) }; + if std::os::windows::fs::symlink_dir(&target, folder.join(format!("l{n}"))).is_err() { + eprintln!("skipped: symbolic links can't be made here"); + let _ = std::fs::remove_dir_all(base); + return; + } + } + assert_eq!(roots.check(s(folder.join("l1").join("x.designcraft")), Access::Read), Ok(())); + let _ = std::fs::remove_dir_all(base); + } + + /// A name that starts with one separator and no drive is a native or rooted name, whichever object directory it + /// names (`\Device`, `\RPC Control`, `\BaseNamedObjects`, `\??`): a link to it is refused, and it is the same + /// with the rest of the path after it. + #[test] + fn rooted_names_without_a_drive_are_native_names() { + for p in + [r"\Device", r"\Device\Mup\203.0.113.5\s", r"\RPC Control\remote", r"\BaseNamedObjects\x", r"\??\UNC\x\y", r"\GLOBAL??", r"\work", r"\"] + { + assert!(is_native_name(Path::new(p)), "{p}"); + } + for p in [r"Device", r"work\x", r"C:\x", r"C:\Device", r"\\server\share", r"\\?\C:\x", ""] { + assert!(!is_native_name(Path::new(p)), "{p}"); + } + } + + /// A link whose text is a native NT name (`\Device\Mup\server\share`) isn't a local path just because + /// `std` sees no prefix in it: it is refused as written, before it is joined onto the link's folder. + #[cfg(windows)] + #[test] + fn a_link_to_a_native_device_name_is_refused() { + let (base, roots) = folders("native-link"); + let link = base.join("in").join("native"); + if std::os::windows::fs::symlink_dir(r"\Device\Mup\203.0.113.5\s", &link).is_err() + || std::fs::read_link(&link).ok().as_deref() != Some(std::path::Path::new(r"\Device\Mup\203.0.113.5\s")) + { + eprintln!("skipped: this system can't make that link, or stores its text differently"); + let _ = std::fs::remove_dir_all(base); + return; + } + let e = roots.check(s(link.join("x.designcraft")), Access::Read).unwrap_err(); + assert!(e.contains("device path"), "{e}"); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}"); + let _ = std::fs::remove_dir_all(base); + } + + /// A link whose target ends in a period or a space (`remote.`) is refused as written: Win32 lookups trim + /// that ending but the kernel follows the text as it is, so the two could name different things. + #[cfg(windows)] + #[test] + fn a_link_to_a_name_windows_trims_is_refused() { + let (base, roots) = folders("trimmed-link"); + let link = base.join("in").join("trimmed"); + if std::os::windows::fs::symlink_dir(r"remote.", &link).is_err() { + eprintln!("skipped: symbolic links can't be made here"); + let _ = std::fs::remove_dir_all(base); + return; + } + let e = roots.check(s(link.join("x.designcraft")), Access::Read).unwrap_err(); + assert!(e.contains("name Windows trims"), "{e}"); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}"); + let _ = std::fs::remove_dir_all(base); + } + + /// A path that names a link with a trailing separator (`remote\`) is judged as the link: Windows reads that as a + /// folder to go into, and would follow the link to a network path to find out what it is. + #[cfg(windows)] + #[test] + fn a_link_with_a_trailing_separator_is_judged_as_the_link() { + let (base, roots) = folders("slashed-link"); + let link = base.join("in").join("slashed"); + if std::os::windows::fs::symlink_dir(r"\\203.0.113.5\s", &link).is_err() { + eprintln!("skipped: symbolic links can't be made here"); + let _ = std::fs::remove_dir_all(base); + return; + } + let e = roots.check(format!(r"{}\", link.display()), Access::Read).unwrap_err(); + assert!(e.contains("UNC"), "{e}"); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}"); + let _ = std::fs::remove_dir_all(base); + } + + /// A path with a name that ends in a space (`remote \x`) is refused as given: Windows keeps that space in the + /// middle of a path but trims it when it looks the folder up by itself, so the two could name different things. + #[cfg(windows)] + #[test] + fn a_path_with_a_name_windows_trims_is_refused() { + let (base, roots) = folders("trimmed-path"); + let e = roots.check(s(base.join("in").join("remote ").join("x.designcraft")), Access::Read).unwrap_err(); + assert!(e.contains("name Windows trims"), "{e}"); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}"); + let _ = std::fs::remove_dir_all(base); + } + + #[cfg(windows)] + #[test] + fn a_verbatim_path_with_a_parent_name_is_refused() { + let (base, roots) = folders("verbatim-dotdot"); + let p = format!(r"\\?\{}\..\a.designcraft", s(base.join("in").join("sub"))); + let e = roots.check(&p, Access::Read).unwrap_err(); + assert!(e.contains("parent traversal in a verbatim path"), "{p}: {e}"); + let _ = std::fs::remove_dir_all(base); + } + + /// A link whose relative target goes through a missing folder and back (`missing\..\remote`) is + /// judged with the `..` taken by name too, as Windows takes it: `remote` is a link to a network path. + #[cfg(windows)] + #[test] + fn a_relative_link_through_a_missing_folder_still_reaches_the_network_check() { + let (base, roots) = folders("unc-link-dotdot"); + let (remote, alias) = (base.join("in").join("remote"), base.join("in").join("alias")); + if std::os::windows::fs::symlink_dir(r"\\203.0.113.5\s", &remote).is_err() { + eprintln!("skipped: symbolic links can't be made here"); + let _ = std::fs::remove_dir_all(base); + return; + } + assert!(std::os::windows::fs::symlink_dir(r"missing\..\remote", &alias).is_ok()); + let e = roots.check(s(alias.join("x.designcraft")), Access::Read).unwrap_err(); + assert!(e.contains("UNC"), "{e}"); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}"); + let _ = std::fs::remove_dir_all(base); + } + + /// A link whose text names a network path, or that has one as a folder on the way, is refused + /// from that text before the link is followed: following it would contact the host. + #[cfg(windows)] + #[test] + fn a_link_to_a_network_path_is_refused_before_it_is_followed() { + let (base, roots) = folders("unc-link"); + let file_link = base.join("in/leak.designcraft"); + if std::os::windows::fs::symlink_file(r"\\203.0.113.5\s\x.designcraft", &file_link).is_err() { + eprintln!("skipped: symbolic links can't be made here"); + let _ = std::fs::remove_dir_all(base); + return; + } + let folder_link = base.join("in/folder-leak"); + assert!(std::os::windows::fs::symlink_dir(r"\\203.0.113.5\s", &folder_link).is_ok()); + for path in [file_link, folder_link.join("x.designcraft")] { + let e = roots.check(s(path.clone()), Access::Read).unwrap_err(); + assert!(e.contains("UNC"), "{}: {e}", path.display()); + assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{}: {e}", path.display()); + } + let _ = std::fs::remove_dir_all(base); + } + #[test] fn scopes_nest_and_stay_on_their_thread() { let (base, roots) = folders("scopes"); diff --git a/docs/mcp.md b/docs/mcp.md index 38b7acfbb..cedd6dd81 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -142,8 +142,11 @@ config works across the suite) keep the agent to the folders you give it: its nearest existing folder's links are followed and the rest must be plain names, so `..` below a folder that doesn't exist is refused, as is a link that leads nowhere (writing through it would create its target). The result is compared with each root by whole folder names: `/work2/x` is not - inside `/work`. On Windows case is ignored, UNC paths (`\\server\share\...`) are resolved like - drive-letter ones, and device names (`CON`, `NUL`, `COM1`, `COM¹`, including before a colon) are refused. + inside `/work`. On Windows case is ignored, and device names (`CON`, `NUL`, `COM1`, `COM¹`, including before a colon) are refused. + A network path (`\\server\share\...`, `\\?\UNC\...`, WebDAV's `\\host@SSL\share\...`), a device path (`\\.\...`) or a + verbatim path that isn't a disk (a volume by its `\\?\Volume{…}` name is local) is refused by its name before anything looks it up, since looking it up would + contact that host, unless a root is on the same server and share (or the same verbatim prefix). A link whose + target is one of those is refused from the link's text, before it is followed. A \\?\ path with a `..` in it is refused, since Windows opens such a path as written and would follow a link before the `..`. On Windows a name that ends in a period or a space, in a path or as a link's target, is refused too, since Windows trims it where it looks a name up. - A refused path is an ordinary tool error the agent can read and correct, for example `automation path rejected: outside the write root /work/project/out: /etc/x.designcraft` (with several, `outside the write roots /work/project/out, /tmp/scratch: ...`) or