1use crate::errors::{AuthError, Result};
4use crate::storage::AuthStorage;
5use std::collections::HashMap;
6use std::sync::Arc;
7use tracing::{debug, info, warn};
8
9pub type UserInfo = crate::auth::UserInfo;
11
12pub struct CredentialCheckResult {
21 pub user_id: String,
23 pub mfa_enabled: bool,
25}
26
27pub struct UserManager {
36 storage: Arc<dyn AuthStorage>,
37}
38
39impl UserManager {
40 pub fn new(storage: Arc<dyn AuthStorage>) -> Self {
47 Self { storage }
48 }
49
50 fn api_key_storage_key(api_key: &str) -> String {
53 format!(
54 "api_key_h:{}",
55 crate::storage::key_names::digest("api_key", api_key)
56 )
57 }
58
59 fn legacy_api_key_storage_key(api_key: &str) -> String {
61 format!("api_key:{api_key}")
62 }
63
64 fn revoked_marker_key(api_key: &str) -> String {
69 format!(
70 "api_key_revoked:{}",
71 crate::storage::key_names::digest("api_key", api_key)
72 )
73 }
74
75 async fn get_api_key_row(&self, api_key: &str, storage_key: &str) -> Result<Option<Vec<u8>>> {
86 if let Some(row) = self.storage.get_kv(storage_key).await? {
87 return Ok(Some(row));
88 }
89 let legacy_key = Self::legacy_api_key_storage_key(api_key);
90 let Some(row) = self.storage.get_kv(&legacy_key).await? else {
91 return self.storage.get_kv(storage_key).await;
94 };
95
96 let ttl = match serde_json::from_slice::<serde_json::Value>(&row)
97 .ok()
98 .and_then(|v| v["expires_at"].as_str().map(str::to_owned))
99 .and_then(|s| s.parse::<chrono::DateTime<chrono::Utc>>().ok())
100 .map(|at| at - chrono::Utc::now())
101 {
102 Some(left) if left <= chrono::Duration::zero() => return Ok(Some(row)),
104 Some(left) => left.to_std().ok().map(|d| {
106 std::time::Duration::from_secs(d.as_secs() + u64::from(d.subsec_nanos() > 0))
107 }),
108 None => None,
109 };
110
111 self.storage.store_kv(storage_key, &row, ttl).await?;
112 if self
113 .storage
114 .get_kv(&Self::revoked_marker_key(api_key))
115 .await?
116 .is_some()
117 {
118 self.storage.delete_kv(storage_key).await?;
120 return Ok(None);
121 }
122 self.storage.delete_kv(&legacy_key).await?;
123 Ok(Some(row))
124 }
125
126 pub async fn create_api_key(
133 &self,
134 user_id: &str,
135 expires_in: Option<std::time::Duration>,
136 ) -> Result<String> {
137 debug!("Creating API key for user '{}'", user_id);
138
139 let api_key = format!("ak_{}", crate::utils::crypto::generate_token(32));
141
142 let key_data = serde_json::json!({
144 "user_id": user_id,
145 "created_at": chrono::Utc::now(),
146 "expires_at": expires_in.map(|d| chrono::Utc::now() + chrono::Duration::from_std(d).unwrap_or(chrono::Duration::days(365 * 10)))
147 });
148
149 let storage_key = Self::api_key_storage_key(&api_key);
152 self.storage
153 .store_kv(&storage_key, key_data.to_string().as_bytes(), expires_in)
154 .await?;
155
156 info!("API key created for user '{}'", user_id);
157 Ok(api_key)
158 }
159
160 pub async fn validate_api_key(&self, api_key: &str) -> Result<UserInfo> {
168 debug!("Validating API key");
169
170 let storage_key = Self::api_key_storage_key(api_key);
171 if let Some(key_data) = self.get_api_key_row(api_key, &storage_key).await? {
172 let key_info: serde_json::Value = serde_json::from_slice(&key_data)?;
173
174 if let Some(user_id) = key_info["user_id"].as_str() {
175 if let Some(expires_at_str) = key_info["expires_at"].as_str() {
177 let expires_at: chrono::DateTime<chrono::Utc> = expires_at_str
178 .parse()
179 .map_err(|_| AuthError::token("Invalid API key expiration"))?;
180
181 if chrono::Utc::now() > expires_at {
182 return Err(AuthError::token("API key expired"));
183 }
184 }
185
186 Ok(UserInfo {
188 id: user_id.to_string(),
189 username: format!("api_user_{}", user_id),
190 email: None,
191 name: None,
192 roles: vec!["api_user".to_string()].into(),
193 active: true,
194 email_verified: false,
195 attributes: crate::types::UserAttributes::empty(),
196 })
197 } else {
198 Err(AuthError::token("Invalid API key format"))
199 }
200 } else {
201 Err(AuthError::token("Invalid API key"))
202 }
203 }
204
205 pub async fn revoke_api_key(&self, api_key: &str) -> Result<()> {
212 debug!("Revoking API key");
213
214 let storage_key = Self::api_key_storage_key(api_key);
215 let legacy_key = Self::legacy_api_key_storage_key(api_key);
216 let found_legacy = self.storage.get_kv(&legacy_key).await?.is_some();
220 let found_new = self.storage.get_kv(&storage_key).await?.is_some();
221 if found_new || found_legacy {
222 self.storage
225 .store_kv(
226 &Self::revoked_marker_key(api_key),
227 b"1",
228 Some(std::time::Duration::from_secs(300)),
229 )
230 .await?;
231 self.storage.delete_kv(&legacy_key).await?;
234 self.storage.delete_kv(&storage_key).await?;
235 info!("API key revoked");
236 Ok(())
237 } else {
238 Err(AuthError::token("API key not found"))
239 }
240 }
241
242 pub async fn validate_username(&self, username: &str) -> Result<bool> {
250 debug!("Validating username format: '{}'", username);
251
252 let is_valid = username.len() >= 3
253 && username.len() <= 32
254 && username
255 .chars()
256 .all(|c| c.is_alphanumeric() || c == '_' || c == '-');
257
258 Ok(is_valid)
259 }
260
261 pub async fn validate_display_name(&self, display_name: &str) -> Result<bool> {
268 debug!("Validating display name format");
269
270 let is_valid = !display_name.is_empty()
271 && display_name.len() <= 100
272 && !display_name.trim().is_empty();
273
274 Ok(is_valid)
275 }
276
277 pub async fn validate_password_strength(&self, password: &str) -> Result<bool> {
287 debug!("Validating password strength");
288 let strength = crate::utils::password::check_password_strength(password);
289 let is_valid = crate::utils::password::meets_production_strength(strength.level);
290 if !is_valid {
291 warn!(
292 "Password validation failed - Actual: {:?}, Feedback: {}",
293 strength.level,
294 strength.feedback.join(", ")
295 );
296 }
297 Ok(is_valid)
298 }
299
300 pub async fn validate_user_input(&self, input: &str) -> Result<bool> {
312 debug!("Validating user input");
313
314 if input.is_empty() || input.len() > 1000 {
315 return Ok(false);
316 }
317
318 if !input.chars().all(|c| {
320 if c.is_control() {
321 matches!(c, ' ' | '\t' | '\n' | '\r')
322 } else {
323 !matches!(c, '<' | '>')
324 }
325 }) {
326 return Ok(false);
327 }
328
329 let lower = input.to_ascii_lowercase();
330 if lower.contains("%3c") || lower.contains("%3e") || lower.contains("%00") {
331 return Ok(false);
332 }
333 if lower.contains("javascript:")
334 || lower.contains("data:")
335 || lower.contains("file:")
336 || lower.contains("jndi:")
337 {
338 return Ok(false);
339 }
340 if input.contains("${") || input.contains("{{") {
341 return Ok(false);
342 }
343 if input.contains("../") || input.contains("..\\") {
344 return Ok(false);
345 }
346 if input.contains('\0') {
347 return Ok(false);
348 }
349 if lower.contains("; drop")
350 || lower.contains(";drop")
351 || lower.contains("' drop")
352 || lower.contains("'; drop")
353 || lower.contains("--")
354 {
355 return Ok(false);
356 }
357
358 Ok(true)
359 }
360
361 pub async fn get_user_info(&self, user_id: &str) -> Result<UserInfo> {
369 debug!("Getting user info for '{}'", user_id);
370
371 let key = format!("user:{}", user_id);
372 if let Some(data) = self.storage.get_kv(&key).await? {
373 let user_data: serde_json::Value = serde_json::from_slice(&data)
374 .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
375
376 Ok(UserInfo {
377 id: user_data["user_id"].as_str().unwrap_or(user_id).to_string(),
378 username: user_data["username"].as_str().unwrap_or("").to_string(),
379 email: user_data["email"].as_str().map(String::from),
380 name: user_data["name"].as_str().map(String::from),
381 roles: user_data["roles"]
382 .as_array()
383 .map(|arr| {
384 arr.iter()
385 .filter_map(|v| v.as_str().map(String::from))
386 .collect::<Vec<_>>()
387 })
388 .unwrap_or_else(|| vec!["user".to_string()])
389 .into(),
390 active: user_data["active"].as_bool().unwrap_or(true),
391 email_verified: user_data["email_verified"].as_bool().unwrap_or(false),
392 attributes: crate::types::UserAttributes::empty(),
393 })
394 } else {
395 Err(AuthError::validation(format!("User '{user_id}' not found")))
396 }
397 }
398
399 pub async fn list_users(
407 &self,
408 limit: Option<usize>,
409 offset: Option<usize>,
410 active_only: bool,
411 ) -> Result<Vec<UserInfo>> {
412 let bytes = self.storage.get_kv("users:index").await?;
413 let user_ids: Vec<String> = match bytes {
414 Some(bytes) => serde_json::from_slice(&bytes)
415 .map_err(|e| AuthError::internal(format!("Failed to parse user index: {e}")))?,
416 None => return Ok(Vec::new()),
417 };
418
419 let skip = offset.unwrap_or(0);
420 let take = limit.unwrap_or(usize::MAX);
421 let mut users = Vec::new();
422
423 for user_id in user_ids.into_iter().skip(skip) {
424 let user = self.get_user_info(&user_id).await?;
425 if active_only && !user.active {
426 continue;
427 }
428 users.push(user);
429 if users.len() >= take {
430 break;
431 }
432 }
433
434 Ok(users)
435 }
436
437 pub async fn user_exists(&self, user_id: &str) -> Result<bool> {
446 debug!("Checking if user '{}' exists", user_id);
447
448 if user_id.is_empty() {
449 return Ok(false);
450 }
451
452 let key = format!("user:{}", user_id);
453 Ok(self.storage.get_kv(&key).await?.is_some())
454 }
455
456 pub async fn register_user(
468 &self,
469 username: &str,
470 email: &str,
471 password: &str,
472 ) -> Result<String> {
473 debug!("Registering new user: {}", username);
474
475 let username_key = format!("user:username:{}", username);
476 if self.storage.get_kv(&username_key).await?.is_some() {
477 return Err(AuthError::validation("Username already exists".to_string()));
478 }
479
480 let email_key = format!("user:email:{}", email);
481 if self.storage.get_kv(&email_key).await?.is_some() {
482 return Err(AuthError::validation("Email already exists".to_string()));
483 }
484
485 let user_id = crate::utils::string::generate_id(Some("user"));
486
487 let password_hash = bcrypt::hash(password, bcrypt::DEFAULT_COST)
488 .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
489
490 let user_data = serde_json::json!({
491 "user_id": user_id,
492 "username": username,
493 "email": email,
494 "password_hash": password_hash,
495 "roles": ["user"],
496 "active": true,
497 "email_verified": false,
498 "created_at": chrono::Utc::now().to_rfc3339(),
499 });
500
501 let user_key = format!("user:{}", user_id);
502 self.storage
503 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
504 .await?;
505
506 self.storage
507 .store_kv(&username_key, user_id.as_bytes(), None)
508 .await?;
509 self.storage
510 .store_kv(&email_key, user_id.as_bytes(), None)
511 .await?;
512
513 let index_key = "users:index";
515 let mut ids: Vec<String> = match self.storage.get_kv(index_key).await? {
516 Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
517 None => vec![],
518 };
519 ids.push(user_id.clone());
520 if let Ok(idx_json) = serde_json::to_vec(&ids)
521 && let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await
522 {
523 warn!("Failed to update user index during registration: {}", e);
524 }
525
526 let creds_key = format!("user:credentials:{}", username);
528 let creds_hash = match crate::utils::password::hash_password_argon2id(password) {
529 Ok(h) => h,
530 Err(e) => {
531 warn!("Failed to hash credentials for user '{}': {}", username, e);
532 return Ok(user_id);
533 }
534 };
535 let creds_data = serde_json::json!({
536 "user_id": user_id,
537 "username": username,
538 "email": email,
539 "password_hash": creds_hash,
540 "created_at": chrono::Utc::now().to_rfc3339(),
541 });
542 if let Err(e) = self
543 .storage
544 .store_kv(&creds_key, creds_data.to_string().as_bytes(), None)
545 .await
546 {
547 warn!("Failed to store credentials for user '{}': {}", username, e);
548 }
549
550 info!("User '{}' registered successfully", username);
551 Ok(user_id)
552 }
553
554 pub async fn delete_user(&self, username: &str) -> Result<()> {
561 debug!("Deleting user: {}", username);
562
563 let username_key = format!("user:username:{}", username);
564 let user_id_data = self
565 .storage
566 .get_kv(&username_key)
567 .await?
568 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
569
570 let user_id = String::from_utf8(user_id_data)
571 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
572
573 let user_key = format!("user:{}", user_id);
575 if let Some(user_data_bytes) = self.storage.get_kv(&user_key).await?
576 && let Ok(user_json_str) = String::from_utf8(user_data_bytes)
577 && let Ok(user_data) = serde_json::from_str::<serde_json::Value>(&user_json_str)
578 && let Some(email) = user_data.get("email").and_then(|v| v.as_str())
579 && let Err(e) = self
580 .storage
581 .delete_kv(&format!("user:email:{}", email))
582 .await
583 {
584 warn!(
585 "Failed to delete email index for user '{}': {}",
586 username, e
587 );
588 }
589
590 let index_key = "users:index";
592 if let Ok(Some(bytes)) = self.storage.get_kv(index_key).await {
593 let mut ids: Vec<String> = serde_json::from_slice(&bytes).unwrap_or_default();
594 ids.retain(|id| id != &user_id);
595 if let Ok(idx_json) = serde_json::to_vec(&ids)
596 && let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await
597 {
598 warn!(
599 "Failed to update user index during deletion of '{}': {}",
600 username, e
601 );
602 }
603 }
604
605 if let Err(e) = self.storage.delete_kv(&user_key).await {
606 warn!("Failed to delete user record for '{}': {}", username, e);
607 }
608 if let Err(e) = self.storage.delete_kv(&username_key).await {
609 warn!("Failed to delete username index for '{}': {}", username, e);
610 }
611 if let Err(e) = self
612 .storage
613 .delete_kv(&format!("user:credentials:{}", username))
614 .await
615 {
616 warn!("Failed to delete credentials for '{}': {}", username, e);
617 }
618 if let Err(e) = self
619 .storage
620 .delete_kv(&format!("user:{}:totp_secret", user_id))
621 .await
622 {
623 warn!("Failed to delete TOTP secret for '{}': {}", username, e);
624 }
625 if let Err(e) = self
626 .storage
627 .delete_kv(&format!("user:{}:backup_codes", user_id))
628 .await
629 {
630 warn!("Failed to delete backup codes for '{}': {}", username, e);
631 }
632
633 info!("User '{}' deleted successfully", username);
634 Ok(())
635 }
636
637 pub async fn delete_user_by_id(&self, user_id: &str) -> Result<()> {
644 let username = self.get_username_by_id(user_id).await?;
645 self.delete_user(&username).await
646 }
647
648 pub async fn update_user_roles(&self, user_id: &str, roles: &[String]) -> Result<()> {
655 let user_key = format!("user:{}", user_id);
656 let bytes = self
657 .storage
658 .get_kv(&user_key)
659 .await?
660 .ok_or(AuthError::UserNotFound)?;
661 let mut user_data: serde_json::Value =
662 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
663 user_data["roles"] = serde_json::json!(roles);
664 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
665 self.storage
666 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
667 .await?;
668 info!("Roles updated for user '{}'", user_id);
669 Ok(())
670 }
671
672 pub async fn set_user_active(&self, user_id: &str, active: bool) -> Result<()> {
679 let user_key = format!("user:{}", user_id);
680 let bytes = self
681 .storage
682 .get_kv(&user_key)
683 .await?
684 .ok_or(AuthError::UserNotFound)?;
685 let mut user_data: serde_json::Value =
686 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
687 user_data["active"] = serde_json::json!(active);
688 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
689 self.storage
690 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
691 .await?;
692 info!("User '{}' active status set to {}", user_id, active);
693 Ok(())
694 }
695
696 pub async fn update_user_email(&self, user_id: &str, email: &str) -> Result<()> {
703 let user_key = format!("user:{}", user_id);
704 let bytes = self
705 .storage
706 .get_kv(&user_key)
707 .await?
708 .ok_or(AuthError::UserNotFound)?;
709 let mut user_data: serde_json::Value =
710 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
711
712 let new_email_key = format!("user:email:{}", email);
713 if let Some(existing_user_id) = self.storage.get_kv(&new_email_key).await? {
714 let existing_user_id = String::from_utf8(existing_user_id)
715 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {e}")))?;
716 if existing_user_id != user_id {
717 return Err(AuthError::validation("Email already exists".to_string()));
718 }
719 }
720
721 if let Some(old_email) = user_data.get("email").and_then(|value| value.as_str())
722 && old_email != email
723 {
724 self.storage
725 .delete_kv(&format!("user:email:{}", old_email))
726 .await?;
727 }
728
729 user_data["email"] = serde_json::json!(email);
730 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
731
732 self.storage
733 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
734 .await?;
735 self.storage
736 .store_kv(&new_email_key, user_id.as_bytes(), None)
737 .await?;
738
739 Ok(())
740 }
741
742 pub async fn verify_user_password(&self, user_id: &str, password: &str) -> Result<bool> {
750 let user_key = format!("user:{}", user_id);
751 let bytes = self
752 .storage
753 .get_kv(&user_key)
754 .await?
755 .ok_or(AuthError::UserNotFound)?;
756 let user_data: serde_json::Value =
757 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
758 let hash = user_data["password_hash"]
759 .as_str()
760 .ok_or_else(|| AuthError::internal("User has no password hash".to_string()))?;
761 bcrypt::verify(password, hash)
762 .map_err(|e| AuthError::crypto(format!("Password verification failed: {}", e)))
763 }
764
765 pub async fn get_username_by_id(&self, user_id: &str) -> Result<String> {
772 let user_key = format!("user:{}", user_id);
773 let bytes = self
774 .storage
775 .get_kv(&user_key)
776 .await?
777 .ok_or(AuthError::UserNotFound)?;
778 let user_data: serde_json::Value =
779 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
780 user_data["username"]
781 .as_str()
782 .map(|s| s.to_string())
783 .ok_or_else(|| AuthError::internal("User has no username field".to_string()))
784 }
785
786 pub async fn username_exists(&self, username: &str) -> Result<bool> {
795 Ok(self
796 .storage
797 .get_kv(&format!("user:username:{}", username))
798 .await?
799 .is_some())
800 }
801
802 pub async fn email_exists(&self, email: &str) -> Result<bool> {
811 Ok(self
812 .storage
813 .get_kv(&format!("user:email:{}", email))
814 .await?
815 .is_some())
816 }
817
818 pub async fn get_user_by_username(
826 &self,
827 username: &str,
828 ) -> Result<HashMap<String, serde_json::Value>> {
829 let username_key = format!("user:username:{}", username);
830 let user_id_data = self
831 .storage
832 .get_kv(&username_key)
833 .await?
834 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
835 let user_id = String::from_utf8(user_id_data)
836 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
837 let user_key = format!("user:{}", user_id);
838 let user_data = self
839 .storage
840 .get_kv(&user_key)
841 .await?
842 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
843 let user_obj: serde_json::Value = serde_json::from_slice(&user_data)
844 .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
845 if let Some(obj) = user_obj.as_object() {
846 Ok(obj
847 .into_iter()
848 .map(|(k, v)| (k.clone(), v.clone()))
849 .collect())
850 } else {
851 Err(AuthError::validation(
852 "Invalid user data structure".to_string(),
853 ))
854 }
855 }
856
857 pub async fn get_user_profile(
865 &self,
866 user_id: &str,
867 ) -> Result<crate::providers::ProviderProfile> {
868 let user_key = format!("user:{}", user_id);
869 if let Ok(Some(bytes)) = self.storage.get_kv(&user_key).await
870 && let Ok(user_data) = serde_json::from_slice::<serde_json::Value>(&bytes)
871 {
872 let username = user_data["username"].as_str().map(|s| s.to_string());
873 let email = user_data["email"].as_str().map(|s| s.to_string());
874 let name = user_data["name"].as_str().map(|s| s.to_string());
875 let email_verified = user_data["email_verified"].as_bool();
876
877 let mut additional_data = std::collections::HashMap::new();
878 if let Some(obj) = user_data.as_object() {
879 for (k, v) in obj {
880 match k.as_str() {
881 "user_id" | "username" | "email" | "name" | "email_verified"
882 | "password_hash" | "created_at" | "updated_at" => {}
883 _ => {
884 additional_data.insert(k.clone(), v.clone());
885 }
886 }
887 }
888 }
889
890 return Ok(crate::providers::ProviderProfile {
891 id: Some(user_id.to_string()),
892 provider: Some("local".to_string()),
893 username,
894 name,
895 email,
896 email_verified,
897 picture: None,
898 locale: None,
899 additional_data,
900 });
901 }
902 Err(AuthError::UserNotFound)
903 }
904
905 pub async fn get_user_roles(&self, user_id: &str) -> Result<Vec<String>> {
913 let user_key = format!("user:{}", user_id);
914 if let Ok(Some(data)) = self.storage.get_kv(&user_key).await
915 && let Ok(v) = serde_json::from_slice::<serde_json::Value>(&data)
916 && let Some(arr) = v.get("roles").and_then(|r| r.as_array())
917 {
918 let roles: Vec<String> = arr
919 .iter()
920 .filter_map(|v| v.as_str().map(String::from))
921 .collect();
922 if !roles.is_empty() {
923 return Ok(roles);
924 }
925 }
926 Ok(vec!["user".to_string()])
927 }
928
929 pub async fn verify_login_credentials(
944 &self,
945 username: &str,
946 password: &str,
947 ) -> Result<Option<CredentialCheckResult>> {
948 use crate::utils::password::verify_password_argon2id;
949
950 if username.is_empty() || password.is_empty() {
951 return Ok(None);
952 }
953
954 let user_key = format!("user:credentials:{username}");
955 let stored_bytes = match self.storage.get_kv(&user_key).await? {
956 Some(bytes) => bytes,
957 None => {
958 let _ = verify_password_argon2id(
960 password,
961 "$argon2id$v=19$m=19456,t=2,p=1$dGVzdHNhbHRmb3J0aW1pbmc$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
962 );
963 return Ok(None);
964 }
965 };
966
967 let user_data_str = String::from_utf8(stored_bytes)
968 .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
969 let user_data: serde_json::Value = serde_json::from_str(&user_data_str)
970 .map_err(|e| AuthError::internal(format!("Failed to parse user JSON: {e}")))?;
971
972 let password_hash = user_data["password_hash"].as_str().ok_or_else(|| {
973 AuthError::internal("Missing password hash in user record".to_string())
974 })?;
975
976 if !verify_password_argon2id(password, password_hash).unwrap_or(false) {
977 return Ok(None);
978 }
979
980 let user_id = user_data["user_id"]
981 .as_str()
982 .ok_or_else(|| AuthError::internal("Missing user_id in user record".to_string()))?
983 .to_string();
984
985 let canonical_key = format!("user:{}", user_id);
987 if let Ok(Some(canonical_bytes)) = self.storage.get_kv(&canonical_key).await
988 && let Ok(canonical_str) = String::from_utf8(canonical_bytes)
989 && let Ok(canonical_data) = serde_json::from_str::<serde_json::Value>(&canonical_str)
990 && !canonical_data["active"].as_bool().unwrap_or(true)
991 {
992 return Ok(None);
993 }
994
995 let mfa_enabled = matches!(
996 self.storage
997 .get_kv(&format!("mfa_enabled:{}", user_id))
998 .await,
999 Ok(Some(_))
1000 );
1001
1002 Ok(Some(CredentialCheckResult {
1003 user_id,
1004 mfa_enabled,
1005 }))
1006 }
1007
1008 pub async fn update_user_password(&self, username: &str, new_password: &str) -> Result<()> {
1015 debug!("Updating password for user: {}", username);
1016
1017 crate::utils::validation::validate_password(new_password)
1018 .map_err(|e| AuthError::validation(format!("Password validation failed: {e}")))?;
1019
1020 let username_key = format!("user:username:{}", username);
1021 let user_id_data = self
1022 .storage
1023 .get_kv(&username_key)
1024 .await?
1025 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
1026 let user_id = String::from_utf8(user_id_data)
1027 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
1028
1029 let user_key = format!("user:{}", user_id);
1030 let user_bytes = self
1031 .storage
1032 .get_kv(&user_key)
1033 .await?
1034 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
1035 let mut user_data: serde_json::Value = serde_json::from_slice(&user_bytes)
1036 .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
1037
1038 let password_hash = bcrypt::hash(new_password, bcrypt::DEFAULT_COST)
1039 .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
1040 user_data["password_hash"] = serde_json::json!(password_hash);
1041 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
1042 self.storage
1043 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
1044 .await?;
1045
1046 let creds_key = format!("user:credentials:{}", username);
1048 let creds_hash = crate::utils::password::hash_password_argon2id(new_password)
1049 .map_err(|e| AuthError::crypto(format!("Failed to hash login credentials: {e}")))?;
1050 let creds_bytes =
1051 self.storage.get_kv(&creds_key).await?.ok_or_else(|| {
1052 AuthError::internal("Login credentials record not found".to_string())
1053 })?;
1054 let mut creds: serde_json::Value = serde_json::from_slice(&creds_bytes)
1055 .map_err(|e| AuthError::internal(format!("Failed to parse credentials record: {e}")))?;
1056 creds["password_hash"] = serde_json::json!(creds_hash);
1057 creds["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
1058 self.storage
1059 .store_kv(&creds_key, creds.to_string().as_bytes(), None)
1060 .await?;
1061
1062 info!("Password updated for user: {}", username);
1063 Ok(())
1064 }
1065
1066 pub async fn update_user_password_by_id(
1073 &self,
1074 user_id: &str,
1075 new_password: &str,
1076 ) -> Result<()> {
1077 let username = self.get_username_by_id(user_id).await?;
1078 self.update_user_password(&username, new_password).await
1079 }
1080}
1081
1082#[cfg(test)]
1083mod tests {
1084 use super::*;
1085 use crate::storage::MemoryStorage;
1086
1087 fn make_manager() -> UserManager {
1088 UserManager::new(Arc::new(MemoryStorage::new()))
1089 }
1090
1091 #[tokio::test]
1094 async fn test_register_user_success() {
1095 let mgr = make_manager();
1096 let id = mgr
1097 .register_user("alice", "alice@example.com", "StrongP@ss1!")
1098 .await
1099 .unwrap();
1100 assert!(id.starts_with("user"));
1101 }
1102
1103 #[tokio::test]
1104 async fn test_register_user_duplicate_username() {
1105 let mgr = make_manager();
1106 mgr.register_user("bob", "bob@example.com", "StrongP@ss1!")
1107 .await
1108 .unwrap();
1109 let err = mgr
1110 .register_user("bob", "bob2@example.com", "StrongP@ss1!")
1111 .await;
1112 assert!(err.is_err());
1113 }
1114
1115 #[tokio::test]
1116 async fn test_register_user_duplicate_email() {
1117 let mgr = make_manager();
1118 mgr.register_user("carol", "dup@example.com", "StrongP@ss1!")
1119 .await
1120 .unwrap();
1121 let err = mgr
1122 .register_user("carol2", "dup@example.com", "StrongP@ss1!")
1123 .await;
1124 assert!(err.is_err());
1125 }
1126
1127 #[tokio::test]
1130 async fn test_get_user_info_success() {
1131 let mgr = make_manager();
1132 let id = mgr
1133 .register_user("dave", "dave@example.com", "StrongP@ss1!")
1134 .await
1135 .unwrap();
1136 let info = mgr.get_user_info(&id).await.unwrap();
1137 assert_eq!(info.username, "dave");
1138 assert!(info.active);
1139 }
1140
1141 #[tokio::test]
1142 async fn test_get_user_info_not_found() {
1143 let mgr = make_manager();
1144 assert!(mgr.get_user_info("nonexistent").await.is_err());
1145 }
1146
1147 #[tokio::test]
1150 async fn test_user_exists_true() {
1151 let mgr = make_manager();
1152 let id = mgr
1153 .register_user("eve", "eve@example.com", "StrongP@ss1!")
1154 .await
1155 .unwrap();
1156 assert!(mgr.user_exists(&id).await.unwrap());
1157 }
1158
1159 #[tokio::test]
1160 async fn test_user_exists_false() {
1161 let mgr = make_manager();
1162 assert!(!mgr.user_exists("nobody").await.unwrap());
1163 }
1164
1165 #[tokio::test]
1166 async fn test_user_exists_empty_id() {
1167 let mgr = make_manager();
1168 assert!(!mgr.user_exists("").await.unwrap());
1169 }
1170
1171 #[tokio::test]
1174 async fn test_delete_user_success() {
1175 let mgr = make_manager();
1176 let id = mgr
1177 .register_user("frank", "frank@example.com", "StrongP@ss1!")
1178 .await
1179 .unwrap();
1180 mgr.delete_user("frank").await.unwrap();
1181 assert!(!mgr.user_exists(&id).await.unwrap());
1182 }
1183
1184 #[tokio::test]
1185 async fn test_delete_user_not_found() {
1186 let mgr = make_manager();
1187 assert!(mgr.delete_user("ghost").await.is_err());
1188 }
1189
1190 #[tokio::test]
1191 async fn test_delete_user_by_id() {
1192 let mgr = make_manager();
1193 let id = mgr
1194 .register_user("gina", "gina@example.com", "StrongP@ss1!")
1195 .await
1196 .unwrap();
1197 mgr.delete_user_by_id(&id).await.unwrap();
1198 assert!(!mgr.user_exists(&id).await.unwrap());
1199 }
1200
1201 #[tokio::test]
1204 async fn test_list_users_empty() {
1205 let mgr = make_manager();
1206 let users = mgr.list_users(None, None, false).await.unwrap();
1207 assert!(users.is_empty());
1208 }
1209
1210 #[tokio::test]
1211 async fn test_list_users_with_limit_and_offset() {
1212 let mgr = make_manager();
1213 mgr.register_user("u1", "u1@example.com", "StrongP@ss1!")
1214 .await
1215 .unwrap();
1216 mgr.register_user("u2", "u2@example.com", "StrongP@ss1!")
1217 .await
1218 .unwrap();
1219 mgr.register_user("u3", "u3@example.com", "StrongP@ss1!")
1220 .await
1221 .unwrap();
1222 let page = mgr.list_users(Some(1), Some(1), false).await.unwrap();
1223 assert_eq!(page.len(), 1);
1224 }
1225
1226 #[tokio::test]
1229 async fn test_verify_password_correct() {
1230 let mgr = make_manager();
1231 let id = mgr
1232 .register_user("hank", "hank@example.com", "StrongP@ss1!")
1233 .await
1234 .unwrap();
1235 assert!(mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1236 }
1237
1238 #[tokio::test]
1239 async fn test_verify_password_incorrect() {
1240 let mgr = make_manager();
1241 let id = mgr
1242 .register_user("ivan", "ivan@example.com", "StrongP@ss1!")
1243 .await
1244 .unwrap();
1245 assert!(!mgr.verify_user_password(&id, "wrong").await.unwrap());
1246 }
1247
1248 #[tokio::test]
1249 async fn test_verify_password_user_not_found() {
1250 let mgr = make_manager();
1251 assert!(mgr.verify_user_password("ghost", "x").await.is_err());
1252 }
1253
1254 #[tokio::test]
1257 async fn test_update_password() {
1258 let mgr = make_manager();
1259 let id = mgr
1260 .register_user("jack", "jack@example.com", "StrongP@ss1!")
1261 .await
1262 .unwrap();
1263 mgr.update_user_password("jack", "NewStr0ng!Pass")
1264 .await
1265 .unwrap();
1266 assert!(
1267 mgr.verify_user_password(&id, "NewStr0ng!Pass")
1268 .await
1269 .unwrap()
1270 );
1271 assert!(!mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1272 }
1273
1274 #[tokio::test]
1275 async fn test_update_password_user_not_found() {
1276 let mgr = make_manager();
1277 assert!(
1278 mgr.update_user_password("ghost", "NewStr0ng!Pass")
1279 .await
1280 .is_err()
1281 );
1282 }
1283
1284 #[tokio::test]
1287 async fn test_update_user_roles() {
1288 let mgr = make_manager();
1289 let id = mgr
1290 .register_user("kate", "kate@example.com", "StrongP@ss1!")
1291 .await
1292 .unwrap();
1293 mgr.update_user_roles(&id, &["admin".into(), "user".into()])
1294 .await
1295 .unwrap();
1296 let info = mgr.get_user_info(&id).await.unwrap();
1297 assert!(info.roles.contains("admin"));
1298 }
1299
1300 #[tokio::test]
1301 async fn test_update_user_roles_not_found() {
1302 let mgr = make_manager();
1303 assert!(
1304 mgr.update_user_roles("ghost", &["admin".into()])
1305 .await
1306 .is_err()
1307 );
1308 }
1309
1310 #[tokio::test]
1313 async fn test_set_user_active_disable() {
1314 let mgr = make_manager();
1315 let id = mgr
1316 .register_user("leon", "leon@example.com", "StrongP@ss1!")
1317 .await
1318 .unwrap();
1319 mgr.set_user_active(&id, false).await.unwrap();
1320 let info = mgr.get_user_info(&id).await.unwrap();
1321 assert!(!info.active);
1322 }
1323
1324 #[tokio::test]
1325 async fn test_set_user_active_not_found() {
1326 let mgr = make_manager();
1327 assert!(mgr.set_user_active("ghost", false).await.is_err());
1328 }
1329
1330 #[tokio::test]
1333 async fn test_update_user_email() {
1334 let mgr = make_manager();
1335 let id = mgr
1336 .register_user("mary", "mary@example.com", "StrongP@ss1!")
1337 .await
1338 .unwrap();
1339 mgr.update_user_email(&id, "mary_new@example.com")
1340 .await
1341 .unwrap();
1342 let info = mgr.get_user_info(&id).await.unwrap();
1343 assert_eq!(info.email.as_deref(), Some("mary_new@example.com"));
1344 }
1345
1346 #[tokio::test]
1347 async fn test_update_user_email_already_taken() {
1348 let mgr = make_manager();
1349 mgr.register_user("n1", "taken@example.com", "StrongP@ss1!")
1350 .await
1351 .unwrap();
1352 let id2 = mgr
1353 .register_user("n2", "n2@example.com", "StrongP@ss1!")
1354 .await
1355 .unwrap();
1356 assert!(
1357 mgr.update_user_email(&id2, "taken@example.com")
1358 .await
1359 .is_err()
1360 );
1361 }
1362
1363 #[tokio::test]
1366 async fn test_create_and_validate_api_key() {
1367 let mgr = make_manager();
1368 let id = mgr
1369 .register_user("oscar", "oscar@example.com", "StrongP@ss1!")
1370 .await
1371 .unwrap();
1372 let key = mgr.create_api_key(&id, None).await.unwrap();
1373 assert!(key.starts_with("ak_"));
1374 let info = mgr.validate_api_key(&key).await.unwrap();
1375 assert_eq!(info.id, id);
1376 }
1377
1378 #[tokio::test]
1379 async fn test_validate_api_key_invalid() {
1380 let mgr = make_manager();
1381 assert!(mgr.validate_api_key("bad_key").await.is_err());
1382 }
1383
1384 #[tokio::test]
1385 async fn test_revoke_api_key() {
1386 let mgr = make_manager();
1387 let id = mgr
1388 .register_user("pat", "pat@example.com", "StrongP@ss1!")
1389 .await
1390 .unwrap();
1391 let key = mgr.create_api_key(&id, None).await.unwrap();
1392 mgr.revoke_api_key(&key).await.unwrap();
1393 assert!(mgr.validate_api_key(&key).await.is_err());
1394 }
1395
1396 #[tokio::test]
1397 async fn test_revoke_api_key_not_found() {
1398 let mgr = make_manager();
1399 assert!(mgr.revoke_api_key("nonexistent").await.is_err());
1400 }
1401
1402 #[tokio::test]
1405 async fn test_validate_username_valid() {
1406 let mgr = make_manager();
1407 assert!(mgr.validate_username("good_user-1").await.unwrap());
1408 }
1409
1410 #[tokio::test]
1411 async fn test_validate_username_too_short() {
1412 let mgr = make_manager();
1413 assert!(!mgr.validate_username("ab").await.unwrap());
1414 }
1415
1416 #[tokio::test]
1417 async fn test_validate_username_special_chars() {
1418 let mgr = make_manager();
1419 assert!(!mgr.validate_username("user@name").await.unwrap());
1420 }
1421
1422 #[tokio::test]
1425 async fn test_validate_display_name_valid() {
1426 let mgr = make_manager();
1427 assert!(mgr.validate_display_name("Alice Bob").await.unwrap());
1428 }
1429
1430 #[tokio::test]
1431 async fn test_validate_display_name_empty() {
1432 let mgr = make_manager();
1433 assert!(!mgr.validate_display_name("").await.unwrap());
1434 }
1435
1436 #[tokio::test]
1437 async fn test_validate_display_name_only_whitespace() {
1438 let mgr = make_manager();
1439 assert!(!mgr.validate_display_name(" ").await.unwrap());
1440 }
1441
1442 #[tokio::test]
1445 async fn test_validate_password_strong() {
1446 let mgr = make_manager();
1447 assert!(
1448 mgr.validate_password_strength("C0mpl3x!P@ssw0rd")
1449 .await
1450 .unwrap()
1451 );
1452 }
1453
1454 #[tokio::test]
1455 async fn test_validate_password_weak() {
1456 let mgr = make_manager();
1457 assert!(!mgr.validate_password_strength("123").await.unwrap());
1458 }
1459
1460 #[tokio::test]
1463 async fn test_validate_user_input_clean() {
1464 let mgr = make_manager();
1465 assert!(mgr.validate_user_input("Hello World 123").await.unwrap());
1466 }
1467
1468 #[tokio::test]
1469 async fn test_validate_user_input_html_tags() {
1470 let mgr = make_manager();
1471 assert!(
1472 !mgr.validate_user_input("<script>alert(1)</script>")
1473 .await
1474 .unwrap()
1475 );
1476 }
1477
1478 #[tokio::test]
1479 async fn test_validate_user_input_sql_injection() {
1480 let mgr = make_manager();
1481 assert!(
1482 !mgr.validate_user_input("'; drop table users--")
1483 .await
1484 .unwrap()
1485 );
1486 }
1487
1488 #[tokio::test]
1489 async fn test_validate_user_input_template_injection() {
1490 let mgr = make_manager();
1491 assert!(!mgr.validate_user_input("${evil}").await.unwrap());
1492 }
1493
1494 #[tokio::test]
1495 async fn test_validate_user_input_path_traversal() {
1496 let mgr = make_manager();
1497 assert!(!mgr.validate_user_input("../../etc/passwd").await.unwrap());
1498 }
1499
1500 #[tokio::test]
1501 async fn test_validate_user_input_javascript_uri() {
1502 let mgr = make_manager();
1503 assert!(
1504 !mgr.validate_user_input("javascript:alert(1)")
1505 .await
1506 .unwrap()
1507 );
1508 }
1509
1510 #[tokio::test]
1511 async fn test_validate_user_input_empty() {
1512 let mgr = make_manager();
1513 assert!(!mgr.validate_user_input("").await.unwrap());
1514 }
1515
1516 #[tokio::test]
1517 async fn test_validate_user_input_encoded_tags() {
1518 let mgr = make_manager();
1519 assert!(!mgr.validate_user_input("%3cscript%3e").await.unwrap());
1520 }
1521
1522 #[tokio::test]
1525 async fn test_username_exists() {
1526 let mgr = make_manager();
1527 mgr.register_user("quinn", "quinn@example.com", "StrongP@ss1!")
1528 .await
1529 .unwrap();
1530 assert!(mgr.username_exists("quinn").await.unwrap());
1531 assert!(!mgr.username_exists("noone").await.unwrap());
1532 }
1533
1534 #[tokio::test]
1535 async fn test_email_exists() {
1536 let mgr = make_manager();
1537 mgr.register_user("ross", "ross@example.com", "StrongP@ss1!")
1538 .await
1539 .unwrap();
1540 assert!(mgr.email_exists("ross@example.com").await.unwrap());
1541 assert!(!mgr.email_exists("nobody@example.com").await.unwrap());
1542 }
1543
1544 #[tokio::test]
1547 async fn test_get_user_by_username() {
1548 let mgr = make_manager();
1549 mgr.register_user("sam", "sam@example.com", "StrongP@ss1!")
1550 .await
1551 .unwrap();
1552 let data = mgr.get_user_by_username("sam").await.unwrap();
1553 assert_eq!(data["username"].as_str(), Some("sam"));
1554 }
1555
1556 #[tokio::test]
1557 async fn test_get_user_by_username_not_found() {
1558 let mgr = make_manager();
1559 assert!(mgr.get_user_by_username("ghost").await.is_err());
1560 }
1561
1562 #[tokio::test]
1565 async fn test_get_user_profile() {
1566 let mgr = make_manager();
1567 let id = mgr
1568 .register_user("tina", "tina@example.com", "StrongP@ss1!")
1569 .await
1570 .unwrap();
1571 let profile = mgr.get_user_profile(&id).await.unwrap();
1572 assert_eq!(profile.username.as_deref(), Some("tina"));
1573 assert_eq!(profile.email.as_deref(), Some("tina@example.com"));
1574 assert!(!profile.additional_data.contains_key("password_hash"));
1576 }
1577
1578 #[tokio::test]
1579 async fn test_get_user_profile_not_found() {
1580 let mgr = make_manager();
1581 assert!(mgr.get_user_profile("ghost").await.is_err());
1582 }
1583
1584 #[tokio::test]
1587 async fn test_get_user_roles_default() {
1588 let mgr = make_manager();
1589 let id = mgr
1590 .register_user("uma", "uma@example.com", "StrongP@ss1!")
1591 .await
1592 .unwrap();
1593 let roles = mgr.get_user_roles(&id).await.unwrap();
1594 assert!(roles.contains(&"user".to_string()));
1595 }
1596
1597 #[tokio::test]
1598 async fn test_get_user_roles_not_found_returns_default() {
1599 let mgr = make_manager();
1600 let roles = mgr.get_user_roles("ghost").await.unwrap();
1601 assert_eq!(roles, vec!["user".to_string()]);
1602 }
1603
1604 #[tokio::test]
1607 async fn test_verify_login_credentials_success() {
1608 let mgr = make_manager();
1609 mgr.register_user("vera", "vera@example.com", "StrongP@ss1!")
1610 .await
1611 .unwrap();
1612 let result = mgr
1613 .verify_login_credentials("vera", "StrongP@ss1!")
1614 .await
1615 .unwrap();
1616 assert!(result.is_some());
1617 assert!(!result.unwrap().mfa_enabled);
1618 }
1619
1620 #[tokio::test]
1621 async fn test_verify_login_credentials_wrong_password() {
1622 let mgr = make_manager();
1623 mgr.register_user("wanda", "wanda@example.com", "StrongP@ss1!")
1624 .await
1625 .unwrap();
1626 let result = mgr
1627 .verify_login_credentials("wanda", "wrong")
1628 .await
1629 .unwrap();
1630 assert!(result.is_none());
1631 }
1632
1633 #[tokio::test]
1634 async fn test_verify_login_credentials_unknown_user() {
1635 let mgr = make_manager();
1636 let result = mgr
1637 .verify_login_credentials("ghost", "StrongP@ss1!")
1638 .await
1639 .unwrap();
1640 assert!(result.is_none());
1641 }
1642
1643 #[tokio::test]
1644 async fn test_verify_login_credentials_empty_inputs() {
1645 let mgr = make_manager();
1646 assert!(
1647 mgr.verify_login_credentials("", "pass")
1648 .await
1649 .unwrap()
1650 .is_none()
1651 );
1652 assert!(
1653 mgr.verify_login_credentials("user", "")
1654 .await
1655 .unwrap()
1656 .is_none()
1657 );
1658 }
1659
1660 #[tokio::test]
1661 async fn test_verify_login_credentials_deactivated() {
1662 let mgr = make_manager();
1663 let id = mgr
1664 .register_user("xena", "xena@example.com", "StrongP@ss1!")
1665 .await
1666 .unwrap();
1667 mgr.set_user_active(&id, false).await.unwrap();
1668 let result = mgr
1669 .verify_login_credentials("xena", "StrongP@ss1!")
1670 .await
1671 .unwrap();
1672 assert!(result.is_none());
1673 }
1674
1675 #[tokio::test]
1678 async fn test_get_username_by_id() {
1679 let mgr = make_manager();
1680 let id = mgr
1681 .register_user("yara", "yara@example.com", "StrongP@ss1!")
1682 .await
1683 .unwrap();
1684 let username = mgr.get_username_by_id(&id).await.unwrap();
1685 assert_eq!(username, "yara");
1686 }
1687
1688 #[tokio::test]
1689 async fn test_get_username_by_id_not_found() {
1690 let mgr = make_manager();
1691 assert!(mgr.get_username_by_id("ghost").await.is_err());
1692 }
1693
1694 #[tokio::test]
1697 async fn test_list_users_active_only() {
1698 let mgr = make_manager();
1699 let id1 = mgr
1700 .register_user("active1", "active1@example.com", "StrongP@ss1!")
1701 .await
1702 .unwrap();
1703 let id2 = mgr
1704 .register_user("inactive1", "inactive1@example.com", "StrongP@ss1!")
1705 .await
1706 .unwrap();
1707 mgr.set_user_active(&id2, false).await.unwrap();
1708
1709 let all = mgr.list_users(None, None, false).await.unwrap();
1710 let active = mgr.list_users(None, None, true).await.unwrap();
1711 assert!(all.len() > active.len());
1712 assert!(active.iter().all(|u| u.active));
1713 assert!(all.iter().any(|u| u.id == id1));
1715 assert!(all.iter().any(|u| u.id == id2));
1716 }
1717}