bashkit 0.5.0

Awesomely fast virtual sandbox with bash and file system
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
131
132

//! Tests for OverlayFs path validation in all methods (issue #652)

use bashkit::{FileSystem, FsLimits, InMemoryFs, OverlayFs};
use std::path::Path;
use std::sync::Arc;

fn make_overlay() -> OverlayFs {
    let lower = Arc::new(InMemoryFs::new()) as Arc<dyn FileSystem>;
    let limits = FsLimits::default();
    OverlayFs::with_limits(lower, limits)
}

// Unicode bidi override character (U+202E) in path
fn bidi_path() -> &'static str {
    "/tmp/evil\u{202E}txt"
}

// Path deeper than max_path_depth
fn deep_path() -> String {
    let mut p = String::from("/");
    for i in 0..200 {
        p.push_str(&format!("d{}/", i));
    }
    p.push_str("file.txt");
    p
}

#[tokio::test]
async fn overlayfs_read_file_rejects_bidi_path() {
    let fs = make_overlay();
    let result = fs.read_file(Path::new(bidi_path())).await;
    assert!(result.is_err(), "read_file should reject bidi path");
}

#[tokio::test]
async fn overlayfs_stat_rejects_bidi_path() {
    let fs = make_overlay();
    let result = fs.stat(Path::new(bidi_path())).await;
    assert!(result.is_err(), "stat should reject bidi path");
}

#[tokio::test]
async fn overlayfs_exists_rejects_bidi_path() {
    let fs = make_overlay();
    let result = fs.exists(Path::new(bidi_path())).await;
    assert!(result.is_err(), "exists should reject bidi path");
}

#[tokio::test]
async fn overlayfs_read_dir_rejects_bidi_path() {
    let fs = make_overlay();
    let result = fs.read_dir(Path::new(bidi_path())).await;
    assert!(result.is_err(), "read_dir should reject bidi path");
}

#[tokio::test]
async fn overlayfs_remove_rejects_bidi_path() {
    let fs = make_overlay();
    let result = fs.remove(Path::new(bidi_path()), false).await;
    assert!(result.is_err(), "remove should reject bidi path");
}

#[tokio::test]
async fn overlayfs_rename_rejects_bidi_source() {
    let fs = make_overlay();
    let result = fs
        .rename(Path::new(bidi_path()), Path::new("/tmp/ok.txt"))
        .await;
    assert!(result.is_err(), "rename should reject bidi source path");
}

#[tokio::test]
async fn overlayfs_rename_rejects_bidi_dest() {
    let fs = make_overlay();
    fs.write_file(Path::new("/tmp/src.txt"), b"data")
        .await
        .unwrap();
    let result = fs
        .rename(Path::new("/tmp/src.txt"), Path::new(bidi_path()))
        .await;
    assert!(result.is_err(), "rename should reject bidi dest path");
}

#[tokio::test]
async fn overlayfs_copy_rejects_bidi_source() {
    let fs = make_overlay();
    let result = fs
        .copy(Path::new(bidi_path()), Path::new("/tmp/ok.txt"))
        .await;
    assert!(result.is_err(), "copy should reject bidi source path");
}

#[tokio::test]
async fn overlayfs_read_link_rejects_bidi_path() {
    let fs = make_overlay();
    let result = fs.read_link(Path::new(bidi_path())).await;
    assert!(result.is_err(), "read_link should reject bidi path");
}

#[tokio::test]
async fn overlayfs_chmod_rejects_bidi_path() {
    let fs = make_overlay();
    let result = fs.chmod(Path::new(bidi_path()), 0o644).await;
    assert!(result.is_err(), "chmod should reject bidi path");
}

#[tokio::test]
async fn overlayfs_read_file_rejects_deep_path() {
    let fs = make_overlay();
    let result = fs.read_file(Path::new(&deep_path())).await;
    assert!(result.is_err(), "read_file should reject deep path");
}

#[tokio::test]
async fn overlayfs_stat_rejects_deep_path() {
    let fs = make_overlay();
    let result = fs.stat(Path::new(&deep_path())).await;
    assert!(result.is_err(), "stat should reject deep path");
}

// Normal paths still work
#[tokio::test]
async fn overlayfs_normal_paths_still_work() {
    let fs = make_overlay();
    fs.write_file(Path::new("/tmp/normal.txt"), b"hello")
        .await
        .unwrap();
    let content = fs.read_file(Path::new("/tmp/normal.txt")).await.unwrap();
    assert_eq!(content, b"hello");
    assert!(fs.exists(Path::new("/tmp/normal.txt")).await.unwrap());
    assert!(fs.stat(Path::new("/tmp/normal.txt")).await.is_ok());
}