Skip to main content

rip_settings/
lock.rs

1use crate::error::SettingsError;
2use serde::{Deserialize, Serialize};
3use std::sync::RwLock;
4
5/// Stored lock state.
6#[derive(Serialize, Deserialize, Clone, Debug, Default)]
7pub struct LockState {
8    pub enabled: bool,
9    pub pin_hash: Option<String>,
10    pub timeout_ms: u64,
11    pub last_unlock_ms: i64,
12}
13
14/// PIN hasher trait for customizable hashing.
15pub trait PinHasher: Send + Sync {
16    fn hash(&self, pin: &str) -> String;
17    fn verify(&self, pin: &str, hash: &str) -> bool;
18}
19
20/// Default hasher using Argon2id.
21pub struct DefaultPinHasher;
22
23impl PinHasher for DefaultPinHasher {
24    fn hash(&self, pin: &str) -> String {
25        use argon2::{Argon2, PasswordHasher};
26
27        Argon2::default()
28            .hash_password(pin.as_bytes())
29            .expect("Argon2 hashing failed")
30            .to_string()
31    }
32
33    fn verify(&self, pin: &str, hash: &str) -> bool {
34        use argon2::password_hash::phc::PasswordHash;
35        use argon2::{Argon2, PasswordVerifier};
36
37        let Ok(parsed) = PasswordHash::new(hash) else {
38            return false;
39        };
40        Argon2::default()
41            .verify_password(pin.as_bytes(), &parsed)
42            .is_ok()
43    }
44}
45
46/// Manages PIN-based settings locking.
47pub struct SettingsLockManager {
48    state: RwLock<LockState>,
49    hasher: Box<dyn PinHasher>,
50    min_pin_length: usize,
51}
52
53impl SettingsLockManager {
54    pub fn new() -> Self {
55        Self {
56            state: RwLock::new(LockState::default()),
57            hasher: Box::new(DefaultPinHasher),
58            min_pin_length: 4,
59        }
60    }
61
62    pub fn with_hasher(mut self, hasher: impl PinHasher + 'static) -> Self {
63        self.hasher = Box::new(hasher);
64        self
65    }
66
67    pub fn with_min_pin_length(mut self, length: usize) -> Self {
68        self.min_pin_length = length;
69        self
70    }
71
72    pub fn load_state(&self, data: &[u8]) -> Result<(), SettingsError> {
73        if data.is_empty() {
74            return Ok(());
75        }
76        let state: LockState =
77            serde_json::from_slice(data).map_err(|e| SettingsError::ParseError(e.to_string()))?;
78        *self
79            .state
80            .write()
81            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))? = state;
82        Ok(())
83    }
84
85    pub fn save_state(&self) -> Result<Vec<u8>, SettingsError> {
86        let state = self
87            .state
88            .read()
89            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?
90            .clone();
91        serde_json::to_vec(&state).map_err(SettingsError::Serialization)
92    }
93
94    #[must_use]
95    pub fn is_lock_enabled(&self) -> bool {
96        self.state.read().unwrap_or_else(|e| e.into_inner()).enabled
97    }
98
99    #[must_use]
100    pub fn is_locked(&self) -> bool {
101        let state = self.state.read().unwrap_or_else(|e| e.into_inner());
102        if !state.enabled {
103            return false;
104        }
105        if state.timeout_ms == 0 {
106            return true;
107        }
108        let now = chrono::Utc::now().timestamp_millis();
109        (now - state.last_unlock_ms) > state.timeout_ms as i64
110    }
111
112    pub fn enable_lock(&self, pin: &str) -> Result<(), SettingsError> {
113        if pin.len() < self.min_pin_length {
114            return Err(SettingsError::PinTooShort {
115                min_length: self.min_pin_length,
116            });
117        }
118
119        let mut state = self
120            .state
121            .write()
122            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
123        state.enabled = true;
124        state.pin_hash = Some(self.hasher.hash(pin));
125        Ok(())
126    }
127
128    pub fn disable_lock(&self, pin: &str) -> Result<(), SettingsError> {
129        if !self.validate_pin(pin)? {
130            return Err(SettingsError::InvalidPin);
131        }
132
133        let mut state = self
134            .state
135            .write()
136            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
137        state.enabled = false;
138        state.pin_hash = None;
139        state.last_unlock_ms = 0;
140        Ok(())
141    }
142
143    pub fn validate_pin(&self, pin: &str) -> Result<bool, SettingsError> {
144        let state = self
145            .state
146            .read()
147            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
148        match &state.pin_hash {
149            Some(hash) => Ok(self.hasher.verify(pin, hash)),
150            None => Ok(false),
151        }
152    }
153
154    pub fn unlock(&self, pin: &str) -> Result<(), SettingsError> {
155        if !self.validate_pin(pin)? {
156            return Err(SettingsError::InvalidPin);
157        }
158
159        let mut state = self
160            .state
161            .write()
162            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
163        state.last_unlock_ms = chrono::Utc::now().timestamp_millis();
164        Ok(())
165    }
166
167    pub fn lock(&self) {
168        let mut state = self.state.write().unwrap_or_else(|e| e.into_inner());
169        state.last_unlock_ms = 0;
170    }
171
172    pub fn set_timeout(&self, timeout_ms: u64) {
173        let mut state = self.state.write().unwrap_or_else(|e| e.into_inner());
174        state.timeout_ms = timeout_ms;
175    }
176
177    pub fn change_pin(&self, current_pin: &str, new_pin: &str) -> Result<(), SettingsError> {
178        if !self.validate_pin(current_pin)? {
179            return Err(SettingsError::InvalidPin);
180        }
181        if new_pin.len() < self.min_pin_length {
182            return Err(SettingsError::PinTooShort {
183                min_length: self.min_pin_length,
184            });
185        }
186
187        let mut state = self
188            .state
189            .write()
190            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
191        state.pin_hash = Some(self.hasher.hash(new_pin));
192        Ok(())
193    }
194
195    #[must_use]
196    pub fn has_pin_set(&self) -> bool {
197        self.state
198            .read()
199            .unwrap_or_else(|e| e.into_inner())
200            .pin_hash
201            .is_some()
202    }
203}
204
205impl Default for SettingsLockManager {
206    fn default() -> Self {
207        Self::new()
208    }
209}
210
211#[cfg(test)]
212mod tests {
213    use super::*;
214
215    #[test]
216    fn test_lock_lifecycle() {
217        let manager = SettingsLockManager::new();
218
219        assert!(!manager.is_lock_enabled());
220        assert!(!manager.is_locked());
221
222        manager.enable_lock("1234").unwrap();
223        assert!(manager.is_lock_enabled());
224        assert!(manager.is_locked());
225
226        manager.unlock("1234").unwrap();
227        assert!(manager.is_locked());
228
229        manager.set_timeout(999_999_999);
230        manager.unlock("1234").unwrap();
231        assert!(!manager.is_locked());
232
233        assert!(manager.unlock("0000").is_err());
234    }
235
236    #[test]
237    fn test_pin_too_short() {
238        let manager = SettingsLockManager::new();
239        assert!(matches!(
240            manager.enable_lock("12"),
241            Err(SettingsError::PinTooShort { .. })
242        ));
243    }
244
245    #[test]
246    fn test_change_pin() {
247        let manager = SettingsLockManager::new();
248        manager.enable_lock("1234").unwrap();
249
250        assert!(manager.change_pin("1234", "5678").is_ok());
251        assert!(manager.validate_pin("5678").unwrap());
252        assert!(!manager.validate_pin("1234").unwrap());
253    }
254}