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