use super::*;
#[test]
fn components_split_like_posix() {
assert_eq!(basename("/a/b/c.txt"), "c.txt");
assert_eq!(basename("/a/b/"), "b");
assert_eq!(basename("plain"), "plain");
assert_eq!(basename("/"), "");
assert_eq!(dirname("/a/b/c"), "/a/b");
assert_eq!(dirname("/a/b/"), "/a");
assert_eq!(dirname("/c"), "/");
assert_eq!(dirname("c"), ".");
assert_eq!(dirname("/"), "/");
assert_eq!(extension("a/b.tar.gz").as_deref(), Some("gz"));
assert_eq!(extension("a/.env"), None);
assert_eq!(extension("a/no_ext"), None);
}
#[test]
fn windows_paths_are_understood() {
assert_eq!(basename(r"C:\Users\ada\file.txt"), "file.txt");
assert_eq!(basename(r"C:\Users\ada\"), "ada");
assert_eq!(dirname(r"C:\Users\ada"), r"C:\Users");
assert_eq!(dirname(r"C:\Users"), r"C:\");
assert_eq!(dirname(r"C:\"), r"C:\");
assert_eq!(extension(r"C:\a\b.TXT").as_deref(), Some("TXT"));
assert!(is_absolute(r"C:\Users"));
assert!(is_absolute("C:/Users"));
assert!(is_absolute(r"\\server\share"));
assert!(is_absolute(r"\windows-root-relative"));
assert!(!is_absolute("C:relative"));
assert!(!is_absolute(r"relative\file"));
assert_eq!(basename(r"C:\a/b\c.txt"), "c.txt");
}
#[test]
fn join_never_discards_the_base() {
let s = |v: &[&str]| -> Vec<String> { v.iter().map(|s| s.to_string()).collect() };
assert_eq!(join(&s(&["/srv", "app", "file.txt"])), "/srv/app/file.txt");
assert_eq!(join(&s(&["/srv/", "/app/"])), "/srv/app/");
assert_eq!(join(&s(&["/srv", "/etc/passwd"])), "/srv/etc/passwd");
assert_eq!(join(&s(&["a", "", "b"])), "a/b");
assert_eq!(join(&s(&["/"])), "/");
assert_eq!(
join(&s(&[r"C:\Users", "ada", "x.txt"])),
r"C:\Users\ada\x.txt"
);
assert_eq!(join(&s(&[r"C:\srv", r"\etc\passwd"])), r"C:\srv\etc\passwd");
assert_eq!(join(&s(&["C:", "x"])), "C:x");
assert_eq!(join(&s(&["C:", "..", "x"])), r"C:..\x");
assert!(!is_absolute(&join(&s(&["C:", "x"]))));
assert_eq!(normalize(&join(&s(&["C:", "..", "x"]))), r"C:..\x");
assert_eq!(join(&s(&["C:x", "y"])), r"C:x\y");
}
#[test]
fn degenerate_inputs_hold_up() {
assert_eq!(join(&[]), "");
assert_eq!(join(&["".into(), "".into()]), "");
assert_eq!(basename(""), "");
assert_eq!(dirname(""), ".");
assert_eq!(extension(""), None);
assert!(!is_absolute(""));
assert_eq!(normalize("//"), "//");
assert_eq!(normalize("/a/b/"), "/a/b");
assert_eq!(normalize(r"C:\a\"), r"C:\a");
assert_eq!(normalize("C:x"), "C:x");
assert_eq!(dirname(r"C:x"), "C:");
assert_eq!(dirname(r"\\server\share"), r"\\server");
assert_eq!(dirname(r"\\server"), r"\\");
assert_eq!(normalize("///ax/y"), "//ax/y");
assert_eq!(normalize("//C:x/.."), "//");
assert_eq!(basename("//C:x"), "C:x");
assert_eq!(dirname("//C:x/y"), "//C:x");
let attack = format!("/base/{}etc/passwd", "../".repeat(1000));
assert_eq!(normalize(&attack), "/etc/passwd");
let relative_attack = "../".repeat(500) + "x";
assert_eq!(
normalize(&relative_attack),
format!("{}x", "../".repeat(500))
);
}
#[test]
fn normalize_resolves_dots_without_escaping_the_root() {
assert_eq!(normalize("/a/b/../c/./d"), "/a/c/d");
assert_eq!(normalize("/a/../../etc"), "/etc");
assert_eq!(normalize("a//b///c"), "a/b/c");
assert_eq!(normalize("./x"), "x");
assert_eq!(normalize("../x"), "../x");
assert_eq!(normalize("a/.."), ".");
assert_eq!(normalize("/"), "/");
assert_eq!(normalize(""), ".");
assert_eq!(normalize(r"C:\a\..\..\etc"), r"C:\etc");
assert_eq!(normalize(r"C:\a\.\b"), r"C:\a\b");
assert_eq!(normalize(r"C:/mixed\style/x"), r"C:\mixed\style\x");
assert_eq!(normalize(r"\\server\share\..\other"), r"\\server\other");
}
#[test]
fn traversal_is_defeated_in_both_path_styles() {
let under = |base: &str, untrusted: &str| normalize(&join(&[base.into(), untrusted.into()]));
for (base, sep) in [
("/srv/app", "/"),
(r"C:\srv\app", "\\"),
(r"\\srv\app", "\\"),
] {
let inside = format!("{base}{sep}");
for attack in [
"../../../../etc/passwd",
r"..\..\..\..\etc\passwd",
r"../..\../..\etc/passwd",
"..//..///../x",
"a/../../../../x",
"./../../x",
] {
let out = under(base, attack);
assert!(
!out.starts_with(&inside),
"{base} + {attack:?} must not pass a prefix check: {out}"
);
assert!(
!out.replace('\\', "/").split('/').any(|s| s == ".."),
"{base} + {attack:?} left a `..`: {out}"
);
}
for benign in ["a/b/../c", r"a\b\..\c", "./a/b/../c", "a//b/././../c"] {
assert_eq!(
under(base, benign),
format!("{inside}a{sep}c"),
"{benign:?}"
);
}
assert!(under(base, "/etc/passwd").starts_with(&inside));
assert!(under(base, r"\etc\passwd").starts_with(&inside));
assert!(under(base, "C:/etc").starts_with(&inside));
}
assert_eq!(normalize("/base/.../..a/x"), "/base/.../..a/x");
assert_eq!(normalize("/base/.. /x"), "/base/.. /x");
assert_eq!(normalize(r"C:\base\...\x"), r"C:\base\...\x");
assert_eq!(normalize("/../../etc"), "/etc");
assert_eq!(normalize(r"C:\..\..\etc"), r"C:\etc");
assert_eq!(normalize(r"\\srv\..\..\etc"), r"\\etc");
assert_eq!(normalize(r"\..\..\etc"), r"\etc");
assert_eq!(normalize(r"C:..\x"), r"C:..\x");
assert!(!is_absolute(r"C:..\x"));
}
fn assert_normalize_invariants(input: &str) {
let normalized = normalize(input);
if is_absolute(&normalized) {
assert!(
!normalized
.replace('\\', "/")
.split('/')
.any(|seg| seg == ".."),
"{input:?} -> {normalized:?} kept a dot-dot in an absolute path"
);
}
assert_eq!(
normalize(&normalized),
normalized,
"normalize is not idempotent for {input:?}"
);
assert_eq!(
split_root(&normalized).0,
split_root(input).0,
"{input:?} -> {normalized:?} changed the root"
);
assert_eq!(
is_absolute(&normalized),
is_absolute(input),
"{input:?} -> {normalized:?} changed rootedness"
);
assert!(
input.contains('\\') || !normalized.contains('\\'),
"{input:?} -> {normalized:?} invented a backslash"
);
assert!(
!is_windows_style(input) || !normalized.contains('/'),
"{input:?} -> {normalized:?} mixed separator styles"
);
}
#[test]
fn normalize_holds_for_every_short_path() {
const ALPHABET: [char; 6] = ['/', '\\', '.', ':', 'C', ' '];
const LEN: usize = 6;
let mut input = String::new();
for len in 0..=LEN {
let mut digits = vec![0usize; len];
loop {
input.clear();
input.extend(digits.iter().map(|&d| ALPHABET[d]));
assert_normalize_invariants(&input);
let mut place = len;
let mut wrapped = true;
while place > 0 {
place -= 1;
digits[place] += 1;
if digits[place] < ALPHABET.len() {
wrapped = false;
break;
}
digits[place] = 0;
}
if wrapped {
break;
}
}
}
}
proptest::proptest! {
#[test]
fn prop_normalize_never_leaves_dotdot_and_is_idempotent(
pieces in proptest::collection::vec(
proptest::prelude::prop_oneof![
proptest::prelude::Just("a"),
proptest::prelude::Just("bb"),
proptest::prelude::Just(".."),
proptest::prelude::Just("."),
proptest::prelude::Just(""),
proptest::prelude::Just("/"),
proptest::prelude::Just("\\"),
proptest::prelude::Just("C:"),
proptest::prelude::Just("C:\\"),
proptest::prelude::Just("x/y"),
proptest::prelude::Just("..."),
proptest::prelude::Just("..a"),
proptest::prelude::Just(" "),
],
0..8,
),
separators in proptest::collection::vec(0u8..3, 0..8),
) {
let mut input = String::new();
for (i, piece) in pieces.iter().enumerate() {
input.push_str(piece);
match separators.get(i).copied().unwrap_or(0) {
1 => input.push('/'),
2 => input.push('\\'),
_ => {}
}
}
assert_normalize_invariants(&input);
for base in ["/srv/app", r"C:\srv\app", r"\\srv\app"] {
let under = join(&[base.to_string(), input.clone()]);
assert_normalize_invariants(&under);
proptest::prop_assert!(
is_absolute(&normalize(&under)),
"{:?} under {} lost its root", input, base
);
}
let under_drive = join(&["C:".to_string(), input.clone()]);
assert_normalize_invariants(&under_drive);
proptest::prop_assert!(
!is_absolute(&normalize(&under_drive)),
"{:?} under C: became anchored: {:?}", input, under_drive
);
}
}