1use crate::error::SettingsError;
2use serde::{Deserialize, Serialize};
3use std::sync::RwLock;
4
5#[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
14pub trait PinHasher: Send + Sync {
16 fn hash(&self, pin: &str) -> String;
17 fn verify(&self, pin: &str, hash: &str) -> bool;
18}
19
20pub 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
46pub 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}