strict-path 0.2.0

Secure path handling for untrusted input. Prevents directory traversal, symlink escapes, and 19+ real-world CVE attack patterns.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::PathBoundary;
#[cfg(feature = "virtual-path")]
use crate::VirtualRoot;

#[cfg(feature = "virtual-path")]
#[test]
fn virtualpath_create_parent_dir_all_creates_chain() {
    let td = tempfile::tempdir().unwrap();
    let root = td.path().join("root");
    std::fs::create_dir_all(&root).unwrap();

    let vroot: VirtualRoot = VirtualRoot::try_new(&root).unwrap();
    let vp = vroot.virtual_join("a/b/c/file.txt").unwrap();

    // No parents exist yet under root
    assert!(!root.join("a").exists());

    // Recursively create parent chain up to "a/b/c"
    vp.create_parent_dir_all().unwrap();
    assert!(root.join("a/b/c").is_dir());
}

#[cfg(feature = "virtual-path")]
#[test]
fn virtualpath_create_parent_dir_non_recursive_fails_when_grandparents_missing() {
    let td = tempfile::tempdir().unwrap();
    let root = td.path().join("root");
    std::fs::create_dir_all(&root).unwrap();

    // Pre-create only the top-level parent "a"; leave "a/b" missing
    std::fs::create_dir_all(root.join("a")).unwrap();

    let vroot: VirtualRoot = VirtualRoot::try_new(&root).unwrap();
    let vp = vroot.virtual_join("a/b/c/file.txt").unwrap();

    // Non-recursive create should fail because "a/b" is missing
    let res = vp.create_parent_dir();
    assert!(res.is_err());
    assert!(!root.join("a/b/c").exists());
}

#[test]
fn strictpath_parent_helpers_parity() {
    let td = tempfile::tempdir().unwrap();
    let root = td.path().join("root");
    std::fs::create_dir_all(&root).unwrap();

    let restriction: PathBoundary = PathBoundary::try_new(&root).unwrap();
    let jp = restriction.strict_join("x/y/z").unwrap();

    // Recursive parent creation
    jp.create_parent_dir_all().unwrap();
    assert!(root.join("x/y").is_dir());

    // Non-recursive when immediate grandparent missing should fail
    let jp2 = restriction.strict_join("m/n/o/p").unwrap();
    // Create only m; leave m/n missing
    std::fs::create_dir_all(root.join("m")).unwrap();
    let res = jp2.create_parent_dir();
    assert!(res.is_err());
}

#[cfg(feature = "virtual-path")]
#[test]
fn root_parent_helpers_are_noops() {
    let td = tempfile::tempdir().unwrap();
    let root_jp: crate::path::strict_path::StrictPath<()> =
        crate::path::strict_path::StrictPath::with_boundary(td.path()).unwrap();
    let root_vp: crate::path::virtual_path::VirtualPath<()> =
        crate::path::virtual_path::VirtualPath::with_root(td.path()).unwrap();

    // Root has no parent; helpers should be Ok and no-ops
    root_jp.create_parent_dir().unwrap();
    root_jp.create_parent_dir_all().unwrap();
    root_vp.create_parent_dir().unwrap();
    root_vp.create_parent_dir_all().unwrap();
}

#[test]
fn create_dir_non_recursive_requires_parent() {
    let td = tempfile::tempdir().unwrap();
    let restriction: crate::PathBoundary = crate::PathBoundary::try_new(td.path()).unwrap();
    let missing_parent = restriction.strict_join("p/newdir").unwrap();
    assert!(missing_parent.create_dir().is_err());

    // Create the parent, then non-recursive create should succeed
    let parent = restriction.strict_join("p").unwrap();
    parent.create_dir_all().unwrap();
    missing_parent.create_dir().unwrap();
    assert!(td.path().join("p/newdir").is_dir());
}

#[cfg(feature = "virtual-path")]
#[test]
fn virtualpath_create_dir_non_recursive_behaves_like_system() {
    let td = tempfile::tempdir().unwrap();
    let vroot: crate::VirtualRoot = crate::VirtualRoot::try_new(td.path()).unwrap();
    let vp = vroot.virtual_join("a/b").unwrap();
    // Parent missing, non-recursive create fails
    assert!(vp.create_dir().is_err());
    // After creating parent, it works
    vroot.virtual_join("a").unwrap().create_dir_all().unwrap();
    vp.create_dir().unwrap();
    assert!(td.path().join("a/b").is_dir());
}

#[cfg(feature = "virtual-path")]
#[test]
fn parent_dir_all_is_idempotent() {
    let td = tempfile::tempdir().unwrap();
    let vroot: crate::VirtualRoot = crate::VirtualRoot::try_new(td.path()).unwrap();
    let vp = vroot.virtual_join("x/y/z/file.txt").unwrap();
    vp.create_parent_dir_all().unwrap();
    vp.create_parent_dir_all().unwrap();
    assert!(td.path().join("x/y/z").is_dir());
}

#[cfg(feature = "virtual-path")]
#[test]
fn virtual_semantics_for_parent_helpers() {
    let td = tempfile::tempdir().unwrap();
    let vroot: crate::VirtualRoot = crate::VirtualRoot::try_new(td.path()).unwrap();
    // Path attempts to traverse above; virtual semantics clamp to "/q/r.txt"
    let vp = vroot.virtual_join("a/../../q/r.txt").unwrap();
    assert_eq!(vp.virtualpath_display().to_string(), "/q/r.txt");
    vp.create_parent_dir_all().unwrap();
    // Only q is created under the restricted path root; no stray "a"
    assert!(td.path().join("q").is_dir());
    assert!(!td.path().join("a").exists());
}