mirror of
https://github.com/storytold/designcraft.git
synced 2026-11-19 00:27:11 +00:00
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.
This commit is contained in:
1 parent
13bd801db2
commit
697279c56f
2 files changed
+477
-5
No files matched your search
@@ -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<Path>) -> 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<PathBuf, String> {
|
||||
///
|
||||
/// 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<PathBuf, String> {
|
||||
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<PathBuf, String> {
|
||||
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<OsString> = 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<Self> {
|
||||
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<Self> {
|
||||
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<PathBuf>, 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");
|
||||
|
||||
+5
-2
@@ -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
|
||||
|
||||
Reference in new issue
Block a user