Skip to main content

second_brain_api/
file_modes.rs

1use std::io::ErrorKind;
2use std::os::unix::fs::PermissionsExt;
3use std::path::{Path, PathBuf};
4
5pub fn make_private(
6    data_dir: &Path,
7    db_path: &Path,
8    index_dir: &Path,
9) -> Vec<(PathBuf, std::io::Error)> {
10    let mut failures = Vec::new();
11    set_mode(data_dir, 0o700, &mut failures);
12    for name in ["api.token", "sync.key"] {
13        set_mode(&data_dir.join(name), 0o600, &mut failures);
14    }
15    for suffix in ["", "-wal", "-shm"] {
16        let mut path = db_path.as_os_str().to_owned();
17        path.push(suffix);
18        set_mode(Path::new(&path), 0o600, &mut failures);
19    }
20    restrict_tree(index_dir, &mut failures);
21    failures
22}
23
24fn restrict_tree(dir: &Path, failures: &mut Vec<(PathBuf, std::io::Error)>) {
25    match std::fs::metadata(dir) {
26        Ok(meta) if meta.is_dir() => {}
27        Ok(_) => return,
28        Err(e) if e.kind() == ErrorKind::NotFound => return,
29        Err(e) => return failures.push((dir.to_path_buf(), e)),
30    }
31    set_mode(dir, 0o700, failures);
32    let entries = match std::fs::read_dir(dir) {
33        Ok(entries) => entries,
34        Err(e) => return failures.push((dir.to_path_buf(), e)),
35    };
36    for entry in entries {
37        let entry = match entry {
38            Ok(entry) => entry,
39            Err(e) => {
40                failures.push((dir.to_path_buf(), e));
41                continue;
42            }
43        };
44        let path = entry.path();
45        match entry.file_type() {
46            Ok(t) if t.is_dir() => restrict_tree(&path, failures),
47            Ok(t) if t.is_file() => set_mode(&path, 0o600, failures),
48            Ok(_) => {}
49            Err(e) => failures.push((path, e)),
50        }
51    }
52}
53
54fn set_mode(path: &Path, mode: u32, failures: &mut Vec<(PathBuf, std::io::Error)>) {
55    match std::fs::metadata(path) {
56        Ok(meta) if meta.permissions().mode() & 0o777 == mode => return,
57        Ok(_) => {}
58        Err(e) if e.kind() == ErrorKind::NotFound => return,
59        Err(e) => return failures.push((path.to_path_buf(), e)),
60    }
61    if let Err(e) = std::fs::set_permissions(path, std::fs::Permissions::from_mode(mode)) {
62        failures.push((path.to_path_buf(), e));
63    }
64}
65
66#[cfg(test)]
67mod tests {
68    use super::*;
69
70    fn set(p: &Path, mode: u32) {
71        std::fs::set_permissions(p, std::fs::Permissions::from_mode(mode)).unwrap();
72    }
73
74    fn mode(p: &Path) -> u32 {
75        std::fs::symlink_metadata(p).unwrap().permissions().mode() & 0o777
76    }
77
78    fn touch(p: &Path, m: u32) {
79        std::fs::write(p, "x").unwrap();
80        set(p, m);
81    }
82
83    #[test]
84    fn tightens_an_existing_install() {
85        let root = tempfile::tempdir().unwrap();
86        let data = root.path().join(".second-brain");
87        let index = data.join("brain.indexes");
88        let nested = index.join("tantivy");
89        std::fs::create_dir_all(&nested).unwrap();
90        set(&data, 0o775);
91        set(&index, 0o775);
92        set(&nested, 0o775);
93        let files = [
94            data.join("brain.db"),
95            data.join("brain.db-wal"),
96            data.join("brain.db-shm"),
97            data.join("sync.key"),
98            data.join("api.token"),
99            index.join("vectors.usearch"),
100            nested.join("meta.json"),
101        ];
102        for f in &files {
103            touch(f, 0o664);
104        }
105
106        let failures = make_private(&data, &data.join("brain.db"), &index);
107
108        assert!(failures.is_empty(), "{failures:?}");
109        for dir in [&data, &index, &nested] {
110            assert_eq!(mode(dir), 0o700, "{}", dir.display());
111        }
112        for f in &files {
113            assert_eq!(mode(f), 0o600, "{}", f.display());
114        }
115    }
116
117    #[test]
118    fn a_db_outside_the_data_dir_is_tightened_too() {
119        let root = tempfile::tempdir().unwrap();
120        let data = root.path().join("data");
121        let elsewhere = root.path().join("elsewhere");
122        std::fs::create_dir_all(&data).unwrap();
123        std::fs::create_dir_all(&elsewhere).unwrap();
124        let db = elsewhere.join("custom.db");
125        touch(&db, 0o644);
126        touch(&elsewhere.join("custom.db-wal"), 0o644);
127        let index = elsewhere.join("custom.indexes");
128        std::fs::create_dir(&index).unwrap();
129        touch(&index.join("f"), 0o644);
130
131        assert!(make_private(&data, &db, &index).is_empty());
132        assert_eq!(mode(&db), 0o600);
133        assert_eq!(mode(&elsewhere.join("custom.db-wal")), 0o600);
134        assert_eq!(mode(&index), 0o700);
135        assert_eq!(mode(&index.join("f")), 0o600);
136    }
137
138    #[test]
139    fn missing_paths_are_skipped_without_failures() {
140        let root = tempfile::tempdir().unwrap();
141        let data = root.path().join("absent");
142        assert!(
143            make_private(&data, &data.join("brain.db"), &data.join("brain.indexes")).is_empty()
144        );
145    }
146
147    #[test]
148    fn symlinks_in_the_index_are_not_followed() {
149        let root = tempfile::tempdir().unwrap();
150        let outside = root.path().join("outside.txt");
151        touch(&outside, 0o644);
152        let index = root.path().join("brain.indexes");
153        std::fs::create_dir(&index).unwrap();
154        std::os::unix::fs::symlink(&outside, index.join("link")).unwrap();
155
156        make_private(root.path(), &root.path().join("brain.db"), &index);
157
158        assert_eq!(mode(&outside), 0o644);
159    }
160}