brows3_lib/credentials/
keychain.rs1use crate::error::{AppError, Result};
2use keyring::Entry;
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::fs;
6use std::path::{Path, PathBuf};
7
8const SERVICE_NAME: &str = "brows3-credentials";
9const FALLBACK_SECRETS_FILE: &str = "secrets.json";
10
11#[derive(Debug, Default, Serialize, Deserialize)]
12struct SecretsData {
13 #[serde(default)]
14 secrets: HashMap<String, String>,
15}
16
17pub struct KeychainStorage {
19 app_name: String,
20 fallback_path: PathBuf,
21 force_fallback: bool,
22}
23
24impl KeychainStorage {
25 pub fn new(app_name: &str, config_dir: &Path, force_fallback: bool) -> Self {
26 Self {
27 app_name: app_name.to_string(),
28 fallback_path: config_dir.join(FALLBACK_SECRETS_FILE),
29 force_fallback,
30 }
31 }
32
33 fn get_entry(&self, key: &str) -> Result<Entry> {
34 Entry::new(SERVICE_NAME, &format!("{}-{}", self.app_name, key))
35 .map_err(|e| AppError::KeychainError(e.to_string()))
36 }
37
38 #[cfg(target_os = "linux")]
39 fn get_legacy_linux_entry(&self, key: &str) -> Result<Entry> {
40 let credential = keyring::keyutils::KeyutilsCredential::new_with_target(
41 None,
42 SERVICE_NAME,
43 &format!("{}-{}", self.app_name, key),
44 )
45 .map_err(|e| AppError::KeychainError(e.to_string()))?;
46
47 Ok(Entry::new_with_credential(Box::new(credential)))
48 }
49
50 fn read_fallback_secrets(&self) -> Result<SecretsData> {
51 if !self.fallback_path.exists() {
52 return Ok(SecretsData::default());
53 }
54
55 let content = fs::read_to_string(&self.fallback_path)?;
56 if content.trim().is_empty() {
57 return Ok(SecretsData::default());
58 }
59
60 serde_json::from_str(&content).map_err(|e| {
61 AppError::SerializationError(format!("Failed to parse fallback secrets store: {}", e))
62 })
63 }
64
65 fn write_fallback_secrets(&self, data: &SecretsData) -> Result<()> {
66 let content = serde_json::to_string_pretty(data)?;
67 super::write_private_file(&self.fallback_path, content.as_bytes())
68 }
69
70 fn store_fallback(&self, key: &str, secret: &str) -> Result<()> {
71 let mut data = self.read_fallback_secrets()?;
72 data.secrets.insert(key.to_string(), secret.to_string());
73 self.write_fallback_secrets(&data)
74 }
75
76 fn get_fallback(&self, key: &str) -> Result<String> {
77 let data = self.read_fallback_secrets()?;
78 data.secrets.get(key).cloned().ok_or_else(|| {
79 AppError::KeychainError("Secret not found in fallback storage".to_string())
80 })
81 }
82
83 fn delete_fallback(&self, key: &str) -> Result<()> {
84 let mut data = self.read_fallback_secrets()?;
85 data.secrets.remove(key);
86 self.write_fallback_secrets(&data)
87 }
88
89 pub fn store(&self, key: &str, secret: &str) -> Result<()> {
91 if self.force_fallback {
92 return self.store_fallback(key, secret);
93 }
94
95 let entry = self.get_entry(key)?;
96 match entry.set_password(secret) {
97 Ok(()) => {
98 self.delete_fallback(key)?;
99 Ok(())
100 }
101 Err(err) => {
102 log::warn!(
103 "Native keychain store failed for '{}', falling back to local secrets file: {}",
104 key,
105 err
106 );
107 self.store_fallback(key, secret)
108 }
109 }
110 }
111
112 pub fn get(&self, key: &str) -> Result<String> {
114 if self.force_fallback {
115 return self.get_fallback(key);
116 }
117
118 if let Some(secret) = self.read_fallback_secrets()?.secrets.get(key) {
120 return Ok(secret.clone());
121 }
122 let entry = self.get_entry(key)?;
123 match entry.get_password() {
124 Ok(secret) => Ok(secret),
125 Err(err) => {
126 log::warn!("Native keychain read failed for '{}': {}", key, err);
127
128 #[cfg(target_os = "linux")]
133 if let Ok(legacy_entry) = self.get_legacy_linux_entry(key) {
134 if let Ok(secret) = legacy_entry.get_password() {
135 if let Err(migration_err) = entry.set_password(&secret) {
136 log::warn!(
137 "Secret Service migration failed for '{}', using local fallback: {}",
138 key,
139 migration_err
140 );
141 self.store_fallback(key, &secret)?;
142 } else {
143 let _ = legacy_entry.delete_credential();
144 let _ = self.delete_fallback(key);
145 }
146 return Ok(secret);
147 }
148 }
149
150 log::warn!("Trying local secrets file for '{}'", key);
151 self.get_fallback(key)
152 }
153 }
154 }
155
156 pub fn delete(&self, key: &str) -> Result<()> {
158 if self.force_fallback {
159 return self.delete_fallback(key);
160 }
161
162 let entry = self.get_entry(key)?;
163 if let Err(err) = entry.delete_credential() {
164 if !matches!(err, keyring::Error::NoEntry) {
165 return Err(AppError::KeychainError(err.to_string()));
166 }
167 log::warn!(
168 "Native keychain delete failed for '{}', clearing local fallback if present: {}",
169 key,
170 err
171 );
172 }
173 #[cfg(target_os = "linux")]
174 if let Ok(legacy_entry) = self.get_legacy_linux_entry(key) {
175 let _ = legacy_entry.delete_credential();
176 }
177 self.delete_fallback(key)
178 }
179
180 pub fn exists(&self, key: &str) -> bool {
182 self.get(key).is_ok()
183 }
184}
185
186#[cfg(test)]
187mod tests {
188 use super::KeychainStorage;
189
190 #[test]
191 fn fallback_value_is_authoritative_even_when_native_storage_is_enabled() {
192 let dir = tempfile::tempdir().unwrap();
193 let storage = KeychainStorage::new("isolated-review-test", dir.path(), false);
194 storage.store_fallback("revision", "new-value").unwrap();
195 assert_eq!(storage.get("revision").unwrap(), "new-value");
197 }
198
199 #[test]
200 fn fallback_replacement_keeps_other_secrets_and_reports_corrupt_storage() {
201 let directory = tempfile::tempdir().unwrap();
202 let storage = KeychainStorage::new("test", directory.path(), true);
203 storage.store("first", "first-secret").unwrap();
204 storage.store("second", "second-secret").unwrap();
205 assert_eq!(storage.get("first").unwrap(), "first-secret");
206 #[cfg(unix)]
207 {
208 use std::os::unix::fs::PermissionsExt;
209 assert_eq!(
210 std::fs::metadata(&storage.fallback_path)
211 .unwrap()
212 .permissions()
213 .mode()
214 & 0o777,
215 0o600
216 );
217 }
218 std::fs::write(&storage.fallback_path, "{invalid").unwrap();
219 assert!(storage.delete("first").is_err());
220 assert_eq!(
221 std::fs::read_to_string(&storage.fallback_path).unwrap(),
222 "{invalid"
223 );
224 }
225
226 #[test]
227 fn failed_private_file_replacement_preserves_the_destination() {
228 let directory = tempfile::tempdir().unwrap();
229 let destination = directory.path().join("existing");
230 std::fs::create_dir(&destination).unwrap();
231 std::fs::write(destination.join("keep"), "original").unwrap();
232 assert!(crate::credentials::write_private_file(&destination, b"replacement").is_err());
233 assert_eq!(
234 std::fs::read_to_string(destination.join("keep")).unwrap(),
235 "original"
236 );
237 assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 1);
238 }
239
240 #[test]
241 fn forced_fallback_stores_reads_and_deletes_secret() {
242 let config_dir =
243 std::env::temp_dir().join(format!("brows3-keychain-test-{}", uuid::Uuid::new_v4()));
244 let storage = KeychainStorage::new("brows3-test", &config_dir, true);
245
246 storage.store("profile-1", "secret-value").unwrap();
247 assert_eq!(storage.get("profile-1").unwrap(), "secret-value");
248
249 storage.delete("profile-1").unwrap();
250 assert!(storage.get("profile-1").is_err());
251
252 let _ = std::fs::remove_dir_all(config_dir);
253 }
254}