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}