Skip to main content

brows3_lib/credentials/
keychain.rs

1use 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
17/// Secure credential storage using OS keychain
18pub 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    /// Store a secret in the OS keychain
90    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    /// Retrieve a secret from the OS keychain
113    pub fn get(&self, key: &str) -> Result<String> {
114        if self.force_fallback {
115            return self.get_fallback(key);
116        }
117
118        // Fallback writes supersede native values left behind by a failed write.
119        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                // v0.2.43 and older selected Linux kernel keyutils, whose
129                // entries disappear on reboot. If an entry is still present
130                // in this login session, migrate it immediately to Secret
131                // Service (or the fallback file if Secret Service is down).
132                #[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    /// Delete a secret from the OS keychain
157    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    /// Check if a secret exists in the keychain
181    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        // Must return without touching the real OS keychain.
196        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}