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 pub async fn create_api_key(
57 &self,
58 user_id: &str,
59 expires_in: Option<std::time::Duration>,
60 ) -> Result<String> {
61 debug!("Creating API key for user '{}'", user_id);
62
63 let api_key = format!("ak_{}", crate::utils::crypto::generate_token(32));
65
66 let key_data = serde_json::json!({
68 "user_id": user_id,
69 "created_at": chrono::Utc::now(),
70 "expires_at": expires_in.map(|d| chrono::Utc::now() + chrono::Duration::from_std(d).unwrap_or(chrono::Duration::days(365 * 10)))
71 });
72
73 let storage_key = format!("api_key:{}", api_key);
74 self.storage
75 .store_kv(&storage_key, key_data.to_string().as_bytes(), expires_in)
76 .await?;
77
78 info!("API key created for user '{}'", user_id);
79 Ok(api_key)
80 }
81
82 pub async fn validate_api_key(&self, api_key: &str) -> Result<UserInfo> {
90 debug!("Validating API key");
91
92 let storage_key = format!("api_key:{}", api_key);
93 if let Some(key_data) = self.storage.get_kv(&storage_key).await? {
94 let key_info: serde_json::Value = serde_json::from_slice(&key_data)?;
95
96 if let Some(user_id) = key_info["user_id"].as_str() {
97 if let Some(expires_at_str) = key_info["expires_at"].as_str() {
99 let expires_at: chrono::DateTime<chrono::Utc> = expires_at_str
100 .parse()
101 .map_err(|_| AuthError::token("Invalid API key expiration"))?;
102
103 if chrono::Utc::now() > expires_at {
104 return Err(AuthError::token("API key expired"));
105 }
106 }
107
108 Ok(UserInfo {
110 id: user_id.to_string(),
111 username: format!("api_user_{}", user_id),
112 email: None,
113 name: None,
114 roles: vec!["api_user".to_string()].into(),
115 active: true,
116 email_verified: false,
117 attributes: crate::types::UserAttributes::empty(),
118 })
119 } else {
120 Err(AuthError::token("Invalid API key format"))
121 }
122 } else {
123 Err(AuthError::token("Invalid API key"))
124 }
125 }
126
127 pub async fn revoke_api_key(&self, api_key: &str) -> Result<()> {
134 debug!("Revoking API key");
135
136 let storage_key = format!("api_key:{}", api_key);
137 if self.storage.get_kv(&storage_key).await?.is_some() {
138 self.storage.delete_kv(&storage_key).await?;
139 info!("API key revoked");
140 Ok(())
141 } else {
142 Err(AuthError::token("API key not found"))
143 }
144 }
145
146 pub async fn validate_username(&self, username: &str) -> Result<bool> {
154 debug!("Validating username format: '{}'", username);
155
156 let is_valid = username.len() >= 3
157 && username.len() <= 32
158 && username
159 .chars()
160 .all(|c| c.is_alphanumeric() || c == '_' || c == '-');
161
162 Ok(is_valid)
163 }
164
165 pub async fn validate_display_name(&self, display_name: &str) -> Result<bool> {
172 debug!("Validating display name format");
173
174 let is_valid = !display_name.is_empty()
175 && display_name.len() <= 100
176 && !display_name.trim().is_empty();
177
178 Ok(is_valid)
179 }
180
181 pub async fn validate_password_strength(&self, password: &str) -> Result<bool> {
191 debug!("Validating password strength");
192 let strength = crate::utils::password::check_password_strength(password);
193 let is_valid = crate::utils::password::meets_production_strength(strength.level);
194 if !is_valid {
195 warn!(
196 "Password validation failed - Actual: {:?}, Feedback: {}",
197 strength.level,
198 strength.feedback.join(", ")
199 );
200 }
201 Ok(is_valid)
202 }
203
204 pub async fn validate_user_input(&self, input: &str) -> Result<bool> {
216 debug!("Validating user input");
217
218 if input.is_empty() || input.len() > 1000 {
219 return Ok(false);
220 }
221
222 if !input.chars().all(|c| {
224 if c.is_control() {
225 matches!(c, ' ' | '\t' | '\n' | '\r')
226 } else {
227 !matches!(c, '<' | '>')
228 }
229 }) {
230 return Ok(false);
231 }
232
233 let lower = input.to_ascii_lowercase();
234 if lower.contains("%3c") || lower.contains("%3e") || lower.contains("%00") {
235 return Ok(false);
236 }
237 if lower.contains("javascript:")
238 || lower.contains("data:")
239 || lower.contains("file:")
240 || lower.contains("jndi:")
241 {
242 return Ok(false);
243 }
244 if input.contains("${") || input.contains("{{") {
245 return Ok(false);
246 }
247 if input.contains("../") || input.contains("..\\") {
248 return Ok(false);
249 }
250 if input.contains('\0') {
251 return Ok(false);
252 }
253 if lower.contains("; drop")
254 || lower.contains(";drop")
255 || lower.contains("' drop")
256 || lower.contains("'; drop")
257 || lower.contains("--")
258 {
259 return Ok(false);
260 }
261
262 Ok(true)
263 }
264
265 pub async fn get_user_info(&self, user_id: &str) -> Result<UserInfo> {
273 debug!("Getting user info for '{}'", user_id);
274
275 let key = format!("user:{}", user_id);
276 if let Some(data) = self.storage.get_kv(&key).await? {
277 let user_data: serde_json::Value = serde_json::from_slice(&data)
278 .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
279
280 Ok(UserInfo {
281 id: user_data["user_id"].as_str().unwrap_or(user_id).to_string(),
282 username: user_data["username"].as_str().unwrap_or("").to_string(),
283 email: user_data["email"].as_str().map(String::from),
284 name: user_data["name"].as_str().map(String::from),
285 roles: user_data["roles"]
286 .as_array()
287 .map(|arr| {
288 arr.iter()
289 .filter_map(|v| v.as_str().map(String::from))
290 .collect::<Vec<_>>()
291 })
292 .unwrap_or_else(|| vec!["user".to_string()])
293 .into(),
294 active: user_data["active"].as_bool().unwrap_or(true),
295 email_verified: user_data["email_verified"].as_bool().unwrap_or(false),
296 attributes: crate::types::UserAttributes::empty(),
297 })
298 } else {
299 Err(AuthError::validation(format!("User '{user_id}' not found")))
300 }
301 }
302
303 pub async fn list_users(
311 &self,
312 limit: Option<usize>,
313 offset: Option<usize>,
314 active_only: bool,
315 ) -> Result<Vec<UserInfo>> {
316 let bytes = self.storage.get_kv("users:index").await?;
317 let user_ids: Vec<String> = match bytes {
318 Some(bytes) => serde_json::from_slice(&bytes)
319 .map_err(|e| AuthError::internal(format!("Failed to parse user index: {e}")))?,
320 None => return Ok(Vec::new()),
321 };
322
323 let skip = offset.unwrap_or(0);
324 let take = limit.unwrap_or(usize::MAX);
325 let mut users = Vec::new();
326
327 for user_id in user_ids.into_iter().skip(skip) {
328 let user = self.get_user_info(&user_id).await?;
329 if active_only && !user.active {
330 continue;
331 }
332 users.push(user);
333 if users.len() >= take {
334 break;
335 }
336 }
337
338 Ok(users)
339 }
340
341 pub async fn user_exists(&self, user_id: &str) -> Result<bool> {
350 debug!("Checking if user '{}' exists", user_id);
351
352 if user_id.is_empty() {
353 return Ok(false);
354 }
355
356 let key = format!("user:{}", user_id);
357 Ok(self.storage.get_kv(&key).await?.is_some())
358 }
359
360 pub async fn register_user(
372 &self,
373 username: &str,
374 email: &str,
375 password: &str,
376 ) -> Result<String> {
377 debug!("Registering new user: {}", username);
378
379 let username_key = format!("user:username:{}", username);
380 if self.storage.get_kv(&username_key).await?.is_some() {
381 return Err(AuthError::validation("Username already exists".to_string()));
382 }
383
384 let email_key = format!("user:email:{}", email);
385 if self.storage.get_kv(&email_key).await?.is_some() {
386 return Err(AuthError::validation("Email already exists".to_string()));
387 }
388
389 let user_id = crate::utils::string::generate_id(Some("user"));
390
391 let password_hash = bcrypt::hash(password, bcrypt::DEFAULT_COST)
392 .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
393
394 let user_data = serde_json::json!({
395 "user_id": user_id,
396 "username": username,
397 "email": email,
398 "password_hash": password_hash,
399 "roles": ["user"],
400 "active": true,
401 "email_verified": false,
402 "created_at": chrono::Utc::now().to_rfc3339(),
403 });
404
405 let user_key = format!("user:{}", user_id);
406 self.storage
407 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
408 .await?;
409
410 self.storage
411 .store_kv(&username_key, user_id.as_bytes(), None)
412 .await?;
413 self.storage
414 .store_kv(&email_key, user_id.as_bytes(), None)
415 .await?;
416
417 let index_key = "users:index";
419 let mut ids: Vec<String> = match self.storage.get_kv(index_key).await? {
420 Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
421 None => vec![],
422 };
423 ids.push(user_id.clone());
424 if let Ok(idx_json) = serde_json::to_vec(&ids) {
425 if let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await {
426 warn!("Failed to update user index during registration: {}", e);
427 }
428 }
429
430 let creds_key = format!("user:credentials:{}", username);
432 let creds_hash = match crate::utils::password::hash_password_argon2id(password) {
433 Ok(h) => h,
434 Err(e) => {
435 warn!("Failed to hash credentials for user '{}': {}", username, e);
436 return Ok(user_id);
437 }
438 };
439 let creds_data = serde_json::json!({
440 "user_id": user_id,
441 "username": username,
442 "email": email,
443 "password_hash": creds_hash,
444 "created_at": chrono::Utc::now().to_rfc3339(),
445 });
446 if let Err(e) = self
447 .storage
448 .store_kv(&creds_key, creds_data.to_string().as_bytes(), None)
449 .await
450 {
451 warn!("Failed to store credentials for user '{}': {}", username, e);
452 }
453
454 info!("User '{}' registered successfully", username);
455 Ok(user_id)
456 }
457
458 pub async fn delete_user(&self, username: &str) -> Result<()> {
465 debug!("Deleting user: {}", username);
466
467 let username_key = format!("user:username:{}", username);
468 let user_id_data = self
469 .storage
470 .get_kv(&username_key)
471 .await?
472 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
473
474 let user_id = String::from_utf8(user_id_data)
475 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
476
477 let user_key = format!("user:{}", user_id);
479 if let Some(user_data_bytes) = self.storage.get_kv(&user_key).await?
480 && let Ok(user_json_str) = String::from_utf8(user_data_bytes)
481 && let Ok(user_data) = serde_json::from_str::<serde_json::Value>(&user_json_str)
482 && let Some(email) = user_data.get("email").and_then(|v| v.as_str())
483 {
484 if let Err(e) = self
485 .storage
486 .delete_kv(&format!("user:email:{}", email))
487 .await
488 {
489 warn!(
490 "Failed to delete email index for user '{}': {}",
491 username, e
492 );
493 }
494 }
495
496 let index_key = "users:index";
498 if let Ok(Some(bytes)) = self.storage.get_kv(index_key).await {
499 let mut ids: Vec<String> = serde_json::from_slice(&bytes).unwrap_or_default();
500 ids.retain(|id| id != &user_id);
501 if let Ok(idx_json) = serde_json::to_vec(&ids) {
502 if let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await {
503 warn!(
504 "Failed to update user index during deletion of '{}': {}",
505 username, e
506 );
507 }
508 }
509 }
510
511 if let Err(e) = self.storage.delete_kv(&user_key).await {
512 warn!("Failed to delete user record for '{}': {}", username, e);
513 }
514 if let Err(e) = self.storage.delete_kv(&username_key).await {
515 warn!("Failed to delete username index for '{}': {}", username, e);
516 }
517 if let Err(e) = self
518 .storage
519 .delete_kv(&format!("user:credentials:{}", username))
520 .await
521 {
522 warn!("Failed to delete credentials for '{}': {}", username, e);
523 }
524 if let Err(e) = self
525 .storage
526 .delete_kv(&format!("user:{}:totp_secret", user_id))
527 .await
528 {
529 warn!("Failed to delete TOTP secret for '{}': {}", username, e);
530 }
531 if let Err(e) = self
532 .storage
533 .delete_kv(&format!("user:{}:backup_codes", user_id))
534 .await
535 {
536 warn!("Failed to delete backup codes for '{}': {}", username, e);
537 }
538
539 info!("User '{}' deleted successfully", username);
540 Ok(())
541 }
542
543 pub async fn delete_user_by_id(&self, user_id: &str) -> Result<()> {
550 let username = self.get_username_by_id(user_id).await?;
551 self.delete_user(&username).await
552 }
553
554 pub async fn update_user_roles(&self, user_id: &str, roles: &[String]) -> Result<()> {
561 let user_key = format!("user:{}", user_id);
562 let bytes = self
563 .storage
564 .get_kv(&user_key)
565 .await?
566 .ok_or(AuthError::UserNotFound)?;
567 let mut user_data: serde_json::Value =
568 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
569 user_data["roles"] = serde_json::json!(roles);
570 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
571 self.storage
572 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
573 .await?;
574 info!("Roles updated for user '{}'", user_id);
575 Ok(())
576 }
577
578 pub async fn set_user_active(&self, user_id: &str, active: bool) -> Result<()> {
585 let user_key = format!("user:{}", user_id);
586 let bytes = self
587 .storage
588 .get_kv(&user_key)
589 .await?
590 .ok_or(AuthError::UserNotFound)?;
591 let mut user_data: serde_json::Value =
592 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
593 user_data["active"] = serde_json::json!(active);
594 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
595 self.storage
596 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
597 .await?;
598 info!("User '{}' active status set to {}", user_id, active);
599 Ok(())
600 }
601
602 pub async fn update_user_email(&self, user_id: &str, email: &str) -> Result<()> {
609 let user_key = format!("user:{}", user_id);
610 let bytes = self
611 .storage
612 .get_kv(&user_key)
613 .await?
614 .ok_or(AuthError::UserNotFound)?;
615 let mut user_data: serde_json::Value =
616 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
617
618 let new_email_key = format!("user:email:{}", email);
619 if let Some(existing_user_id) = self.storage.get_kv(&new_email_key).await? {
620 let existing_user_id = String::from_utf8(existing_user_id)
621 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {e}")))?;
622 if existing_user_id != user_id {
623 return Err(AuthError::validation("Email already exists".to_string()));
624 }
625 }
626
627 if let Some(old_email) = user_data.get("email").and_then(|value| value.as_str())
628 && old_email != email
629 {
630 self.storage
631 .delete_kv(&format!("user:email:{}", old_email))
632 .await?;
633 }
634
635 user_data["email"] = serde_json::json!(email);
636 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
637
638 self.storage
639 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
640 .await?;
641 self.storage
642 .store_kv(&new_email_key, user_id.as_bytes(), None)
643 .await?;
644
645 Ok(())
646 }
647
648 pub async fn verify_user_password(&self, user_id: &str, password: &str) -> Result<bool> {
656 let user_key = format!("user:{}", user_id);
657 let bytes = self
658 .storage
659 .get_kv(&user_key)
660 .await?
661 .ok_or(AuthError::UserNotFound)?;
662 let user_data: serde_json::Value =
663 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
664 let hash = user_data["password_hash"]
665 .as_str()
666 .ok_or_else(|| AuthError::internal("User has no password hash".to_string()))?;
667 bcrypt::verify(password, hash)
668 .map_err(|e| AuthError::crypto(format!("Password verification failed: {}", e)))
669 }
670
671 pub async fn get_username_by_id(&self, user_id: &str) -> Result<String> {
678 let user_key = format!("user:{}", user_id);
679 let bytes = self
680 .storage
681 .get_kv(&user_key)
682 .await?
683 .ok_or(AuthError::UserNotFound)?;
684 let user_data: serde_json::Value =
685 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
686 user_data["username"]
687 .as_str()
688 .map(|s| s.to_string())
689 .ok_or_else(|| AuthError::internal("User has no username field".to_string()))
690 }
691
692 pub async fn username_exists(&self, username: &str) -> Result<bool> {
701 Ok(self
702 .storage
703 .get_kv(&format!("user:username:{}", username))
704 .await?
705 .is_some())
706 }
707
708 pub async fn email_exists(&self, email: &str) -> Result<bool> {
717 Ok(self
718 .storage
719 .get_kv(&format!("user:email:{}", email))
720 .await?
721 .is_some())
722 }
723
724 pub async fn get_user_by_username(
732 &self,
733 username: &str,
734 ) -> Result<HashMap<String, serde_json::Value>> {
735 let username_key = format!("user:username:{}", username);
736 let user_id_data = self
737 .storage
738 .get_kv(&username_key)
739 .await?
740 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
741 let user_id = String::from_utf8(user_id_data)
742 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
743 let user_key = format!("user:{}", user_id);
744 let user_data = self
745 .storage
746 .get_kv(&user_key)
747 .await?
748 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
749 let user_obj: serde_json::Value = serde_json::from_slice(&user_data)
750 .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
751 if let Some(obj) = user_obj.as_object() {
752 Ok(obj
753 .into_iter()
754 .map(|(k, v)| (k.clone(), v.clone()))
755 .collect())
756 } else {
757 Err(AuthError::validation(
758 "Invalid user data structure".to_string(),
759 ))
760 }
761 }
762
763 pub async fn get_user_profile(
771 &self,
772 user_id: &str,
773 ) -> Result<crate::providers::ProviderProfile> {
774 let user_key = format!("user:{}", user_id);
775 if let Ok(Some(bytes)) = self.storage.get_kv(&user_key).await
776 && let Ok(user_data) = serde_json::from_slice::<serde_json::Value>(&bytes)
777 {
778 let username = user_data["username"].as_str().map(|s| s.to_string());
779 let email = user_data["email"].as_str().map(|s| s.to_string());
780 let name = user_data["name"].as_str().map(|s| s.to_string());
781 let email_verified = user_data["email_verified"].as_bool();
782
783 let mut additional_data = std::collections::HashMap::new();
784 if let Some(obj) = user_data.as_object() {
785 for (k, v) in obj {
786 match k.as_str() {
787 "user_id" | "username" | "email" | "name" | "email_verified"
788 | "password_hash" | "created_at" | "updated_at" => {}
789 _ => {
790 additional_data.insert(k.clone(), v.clone());
791 }
792 }
793 }
794 }
795
796 return Ok(crate::providers::ProviderProfile {
797 id: Some(user_id.to_string()),
798 provider: Some("local".to_string()),
799 username,
800 name,
801 email,
802 email_verified,
803 picture: None,
804 locale: None,
805 additional_data,
806 });
807 }
808 Err(AuthError::UserNotFound)
809 }
810
811 pub async fn get_user_roles(&self, user_id: &str) -> Result<Vec<String>> {
819 let user_key = format!("user:{}", user_id);
820 if let Ok(Some(data)) = self.storage.get_kv(&user_key).await
821 && let Ok(v) = serde_json::from_slice::<serde_json::Value>(&data)
822 && let Some(arr) = v.get("roles").and_then(|r| r.as_array())
823 {
824 let roles: Vec<String> = arr
825 .iter()
826 .filter_map(|v| v.as_str().map(String::from))
827 .collect();
828 if !roles.is_empty() {
829 return Ok(roles);
830 }
831 }
832 Ok(vec!["user".to_string()])
833 }
834
835 pub async fn verify_login_credentials(
850 &self,
851 username: &str,
852 password: &str,
853 ) -> Result<Option<CredentialCheckResult>> {
854 use crate::utils::password::verify_password_argon2id;
855
856 if username.is_empty() || password.is_empty() {
857 return Ok(None);
858 }
859
860 let user_key = format!("user:credentials:{username}");
861 let stored_bytes = match self.storage.get_kv(&user_key).await? {
862 Some(bytes) => bytes,
863 None => {
864 let _ = verify_password_argon2id(
866 password,
867 "$argon2id$v=19$m=19456,t=2,p=1$dGVzdHNhbHRmb3J0aW1pbmc$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
868 );
869 return Ok(None);
870 }
871 };
872
873 let user_data_str = String::from_utf8(stored_bytes)
874 .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
875 let user_data: serde_json::Value = serde_json::from_str(&user_data_str)
876 .map_err(|e| AuthError::internal(format!("Failed to parse user JSON: {e}")))?;
877
878 let password_hash = user_data["password_hash"].as_str().ok_or_else(|| {
879 AuthError::internal("Missing password hash in user record".to_string())
880 })?;
881
882 if !verify_password_argon2id(password, password_hash).unwrap_or(false) {
883 return Ok(None);
884 }
885
886 let user_id = user_data["user_id"]
887 .as_str()
888 .ok_or_else(|| AuthError::internal("Missing user_id in user record".to_string()))?
889 .to_string();
890
891 let canonical_key = format!("user:{}", user_id);
893 if let Ok(Some(canonical_bytes)) = self.storage.get_kv(&canonical_key).await
894 && let Ok(canonical_str) = String::from_utf8(canonical_bytes)
895 && let Ok(canonical_data) = serde_json::from_str::<serde_json::Value>(&canonical_str)
896 && !canonical_data["active"].as_bool().unwrap_or(true)
897 {
898 return Ok(None);
899 }
900
901 let mfa_enabled = matches!(
902 self.storage
903 .get_kv(&format!("mfa_enabled:{}", user_id))
904 .await,
905 Ok(Some(_))
906 );
907
908 Ok(Some(CredentialCheckResult {
909 user_id,
910 mfa_enabled,
911 }))
912 }
913
914 pub async fn update_user_password(&self, username: &str, new_password: &str) -> Result<()> {
921 debug!("Updating password for user: {}", username);
922
923 crate::utils::validation::validate_password(new_password)
924 .map_err(|e| AuthError::validation(format!("Password validation failed: {e}")))?;
925
926 let username_key = format!("user:username:{}", username);
927 let user_id_data = self
928 .storage
929 .get_kv(&username_key)
930 .await?
931 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
932 let user_id = String::from_utf8(user_id_data)
933 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
934
935 let user_key = format!("user:{}", user_id);
936 let user_bytes = self
937 .storage
938 .get_kv(&user_key)
939 .await?
940 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
941 let mut user_data: serde_json::Value = serde_json::from_slice(&user_bytes)
942 .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
943
944 let password_hash = bcrypt::hash(new_password, bcrypt::DEFAULT_COST)
945 .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
946 user_data["password_hash"] = serde_json::json!(password_hash);
947 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
948 self.storage
949 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
950 .await?;
951
952 let creds_key = format!("user:credentials:{}", username);
954 let creds_hash = crate::utils::password::hash_password_argon2id(new_password)
955 .map_err(|e| AuthError::crypto(format!("Failed to hash login credentials: {e}")))?;
956 let creds_bytes =
957 self.storage.get_kv(&creds_key).await?.ok_or_else(|| {
958 AuthError::internal("Login credentials record not found".to_string())
959 })?;
960 let mut creds: serde_json::Value = serde_json::from_slice(&creds_bytes)
961 .map_err(|e| AuthError::internal(format!("Failed to parse credentials record: {e}")))?;
962 creds["password_hash"] = serde_json::json!(creds_hash);
963 creds["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
964 self.storage
965 .store_kv(&creds_key, creds.to_string().as_bytes(), None)
966 .await?;
967
968 info!("Password updated for user: {}", username);
969 Ok(())
970 }
971
972 pub async fn update_user_password_by_id(
979 &self,
980 user_id: &str,
981 new_password: &str,
982 ) -> Result<()> {
983 let username = self.get_username_by_id(user_id).await?;
984 self.update_user_password(&username, new_password).await
985 }
986}
987
988#[cfg(test)]
989mod tests {
990 use super::*;
991 use crate::storage::MemoryStorage;
992
993 fn make_manager() -> UserManager {
994 UserManager::new(Arc::new(MemoryStorage::new()))
995 }
996
997 #[tokio::test]
1000 async fn test_register_user_success() {
1001 let mgr = make_manager();
1002 let id = mgr
1003 .register_user("alice", "alice@example.com", "StrongP@ss1!")
1004 .await
1005 .unwrap();
1006 assert!(id.starts_with("user"));
1007 }
1008
1009 #[tokio::test]
1010 async fn test_register_user_duplicate_username() {
1011 let mgr = make_manager();
1012 mgr.register_user("bob", "bob@example.com", "StrongP@ss1!")
1013 .await
1014 .unwrap();
1015 let err = mgr
1016 .register_user("bob", "bob2@example.com", "StrongP@ss1!")
1017 .await;
1018 assert!(err.is_err());
1019 }
1020
1021 #[tokio::test]
1022 async fn test_register_user_duplicate_email() {
1023 let mgr = make_manager();
1024 mgr.register_user("carol", "dup@example.com", "StrongP@ss1!")
1025 .await
1026 .unwrap();
1027 let err = mgr
1028 .register_user("carol2", "dup@example.com", "StrongP@ss1!")
1029 .await;
1030 assert!(err.is_err());
1031 }
1032
1033 #[tokio::test]
1036 async fn test_get_user_info_success() {
1037 let mgr = make_manager();
1038 let id = mgr
1039 .register_user("dave", "dave@example.com", "StrongP@ss1!")
1040 .await
1041 .unwrap();
1042 let info = mgr.get_user_info(&id).await.unwrap();
1043 assert_eq!(info.username, "dave");
1044 assert!(info.active);
1045 }
1046
1047 #[tokio::test]
1048 async fn test_get_user_info_not_found() {
1049 let mgr = make_manager();
1050 assert!(mgr.get_user_info("nonexistent").await.is_err());
1051 }
1052
1053 #[tokio::test]
1056 async fn test_user_exists_true() {
1057 let mgr = make_manager();
1058 let id = mgr
1059 .register_user("eve", "eve@example.com", "StrongP@ss1!")
1060 .await
1061 .unwrap();
1062 assert!(mgr.user_exists(&id).await.unwrap());
1063 }
1064
1065 #[tokio::test]
1066 async fn test_user_exists_false() {
1067 let mgr = make_manager();
1068 assert!(!mgr.user_exists("nobody").await.unwrap());
1069 }
1070
1071 #[tokio::test]
1072 async fn test_user_exists_empty_id() {
1073 let mgr = make_manager();
1074 assert!(!mgr.user_exists("").await.unwrap());
1075 }
1076
1077 #[tokio::test]
1080 async fn test_delete_user_success() {
1081 let mgr = make_manager();
1082 let id = mgr
1083 .register_user("frank", "frank@example.com", "StrongP@ss1!")
1084 .await
1085 .unwrap();
1086 mgr.delete_user("frank").await.unwrap();
1087 assert!(!mgr.user_exists(&id).await.unwrap());
1088 }
1089
1090 #[tokio::test]
1091 async fn test_delete_user_not_found() {
1092 let mgr = make_manager();
1093 assert!(mgr.delete_user("ghost").await.is_err());
1094 }
1095
1096 #[tokio::test]
1097 async fn test_delete_user_by_id() {
1098 let mgr = make_manager();
1099 let id = mgr
1100 .register_user("gina", "gina@example.com", "StrongP@ss1!")
1101 .await
1102 .unwrap();
1103 mgr.delete_user_by_id(&id).await.unwrap();
1104 assert!(!mgr.user_exists(&id).await.unwrap());
1105 }
1106
1107 #[tokio::test]
1110 async fn test_list_users_empty() {
1111 let mgr = make_manager();
1112 let users = mgr.list_users(None, None, false).await.unwrap();
1113 assert!(users.is_empty());
1114 }
1115
1116 #[tokio::test]
1117 async fn test_list_users_with_limit_and_offset() {
1118 let mgr = make_manager();
1119 mgr.register_user("u1", "u1@example.com", "StrongP@ss1!")
1120 .await
1121 .unwrap();
1122 mgr.register_user("u2", "u2@example.com", "StrongP@ss1!")
1123 .await
1124 .unwrap();
1125 mgr.register_user("u3", "u3@example.com", "StrongP@ss1!")
1126 .await
1127 .unwrap();
1128 let page = mgr.list_users(Some(1), Some(1), false).await.unwrap();
1129 assert_eq!(page.len(), 1);
1130 }
1131
1132 #[tokio::test]
1135 async fn test_verify_password_correct() {
1136 let mgr = make_manager();
1137 let id = mgr
1138 .register_user("hank", "hank@example.com", "StrongP@ss1!")
1139 .await
1140 .unwrap();
1141 assert!(mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1142 }
1143
1144 #[tokio::test]
1145 async fn test_verify_password_incorrect() {
1146 let mgr = make_manager();
1147 let id = mgr
1148 .register_user("ivan", "ivan@example.com", "StrongP@ss1!")
1149 .await
1150 .unwrap();
1151 assert!(!mgr.verify_user_password(&id, "wrong").await.unwrap());
1152 }
1153
1154 #[tokio::test]
1155 async fn test_verify_password_user_not_found() {
1156 let mgr = make_manager();
1157 assert!(mgr.verify_user_password("ghost", "x").await.is_err());
1158 }
1159
1160 #[tokio::test]
1163 async fn test_update_password() {
1164 let mgr = make_manager();
1165 let id = mgr
1166 .register_user("jack", "jack@example.com", "StrongP@ss1!")
1167 .await
1168 .unwrap();
1169 mgr.update_user_password("jack", "NewStr0ng!Pass")
1170 .await
1171 .unwrap();
1172 assert!(
1173 mgr.verify_user_password(&id, "NewStr0ng!Pass")
1174 .await
1175 .unwrap()
1176 );
1177 assert!(!mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1178 }
1179
1180 #[tokio::test]
1181 async fn test_update_password_user_not_found() {
1182 let mgr = make_manager();
1183 assert!(
1184 mgr.update_user_password("ghost", "NewStr0ng!Pass")
1185 .await
1186 .is_err()
1187 );
1188 }
1189
1190 #[tokio::test]
1193 async fn test_update_user_roles() {
1194 let mgr = make_manager();
1195 let id = mgr
1196 .register_user("kate", "kate@example.com", "StrongP@ss1!")
1197 .await
1198 .unwrap();
1199 mgr.update_user_roles(&id, &["admin".into(), "user".into()])
1200 .await
1201 .unwrap();
1202 let info = mgr.get_user_info(&id).await.unwrap();
1203 assert!(info.roles.contains(&"admin".to_string()));
1204 }
1205
1206 #[tokio::test]
1207 async fn test_update_user_roles_not_found() {
1208 let mgr = make_manager();
1209 assert!(
1210 mgr.update_user_roles("ghost", &["admin".into()])
1211 .await
1212 .is_err()
1213 );
1214 }
1215
1216 #[tokio::test]
1219 async fn test_set_user_active_disable() {
1220 let mgr = make_manager();
1221 let id = mgr
1222 .register_user("leon", "leon@example.com", "StrongP@ss1!")
1223 .await
1224 .unwrap();
1225 mgr.set_user_active(&id, false).await.unwrap();
1226 let info = mgr.get_user_info(&id).await.unwrap();
1227 assert!(!info.active);
1228 }
1229
1230 #[tokio::test]
1231 async fn test_set_user_active_not_found() {
1232 let mgr = make_manager();
1233 assert!(mgr.set_user_active("ghost", false).await.is_err());
1234 }
1235
1236 #[tokio::test]
1239 async fn test_update_user_email() {
1240 let mgr = make_manager();
1241 let id = mgr
1242 .register_user("mary", "mary@example.com", "StrongP@ss1!")
1243 .await
1244 .unwrap();
1245 mgr.update_user_email(&id, "mary_new@example.com")
1246 .await
1247 .unwrap();
1248 let info = mgr.get_user_info(&id).await.unwrap();
1249 assert_eq!(info.email.as_deref(), Some("mary_new@example.com"));
1250 }
1251
1252 #[tokio::test]
1253 async fn test_update_user_email_already_taken() {
1254 let mgr = make_manager();
1255 mgr.register_user("n1", "taken@example.com", "StrongP@ss1!")
1256 .await
1257 .unwrap();
1258 let id2 = mgr
1259 .register_user("n2", "n2@example.com", "StrongP@ss1!")
1260 .await
1261 .unwrap();
1262 assert!(
1263 mgr.update_user_email(&id2, "taken@example.com")
1264 .await
1265 .is_err()
1266 );
1267 }
1268
1269 #[tokio::test]
1272 async fn test_create_and_validate_api_key() {
1273 let mgr = make_manager();
1274 let id = mgr
1275 .register_user("oscar", "oscar@example.com", "StrongP@ss1!")
1276 .await
1277 .unwrap();
1278 let key = mgr.create_api_key(&id, None).await.unwrap();
1279 assert!(key.starts_with("ak_"));
1280 let info = mgr.validate_api_key(&key).await.unwrap();
1281 assert_eq!(info.id, id);
1282 }
1283
1284 #[tokio::test]
1285 async fn test_validate_api_key_invalid() {
1286 let mgr = make_manager();
1287 assert!(mgr.validate_api_key("bad_key").await.is_err());
1288 }
1289
1290 #[tokio::test]
1291 async fn test_revoke_api_key() {
1292 let mgr = make_manager();
1293 let id = mgr
1294 .register_user("pat", "pat@example.com", "StrongP@ss1!")
1295 .await
1296 .unwrap();
1297 let key = mgr.create_api_key(&id, None).await.unwrap();
1298 mgr.revoke_api_key(&key).await.unwrap();
1299 assert!(mgr.validate_api_key(&key).await.is_err());
1300 }
1301
1302 #[tokio::test]
1303 async fn test_revoke_api_key_not_found() {
1304 let mgr = make_manager();
1305 assert!(mgr.revoke_api_key("nonexistent").await.is_err());
1306 }
1307
1308 #[tokio::test]
1311 async fn test_validate_username_valid() {
1312 let mgr = make_manager();
1313 assert!(mgr.validate_username("good_user-1").await.unwrap());
1314 }
1315
1316 #[tokio::test]
1317 async fn test_validate_username_too_short() {
1318 let mgr = make_manager();
1319 assert!(!mgr.validate_username("ab").await.unwrap());
1320 }
1321
1322 #[tokio::test]
1323 async fn test_validate_username_special_chars() {
1324 let mgr = make_manager();
1325 assert!(!mgr.validate_username("user@name").await.unwrap());
1326 }
1327
1328 #[tokio::test]
1331 async fn test_validate_display_name_valid() {
1332 let mgr = make_manager();
1333 assert!(mgr.validate_display_name("Alice Bob").await.unwrap());
1334 }
1335
1336 #[tokio::test]
1337 async fn test_validate_display_name_empty() {
1338 let mgr = make_manager();
1339 assert!(!mgr.validate_display_name("").await.unwrap());
1340 }
1341
1342 #[tokio::test]
1343 async fn test_validate_display_name_only_whitespace() {
1344 let mgr = make_manager();
1345 assert!(!mgr.validate_display_name(" ").await.unwrap());
1346 }
1347
1348 #[tokio::test]
1351 async fn test_validate_password_strong() {
1352 let mgr = make_manager();
1353 assert!(
1354 mgr.validate_password_strength("C0mpl3x!P@ssw0rd")
1355 .await
1356 .unwrap()
1357 );
1358 }
1359
1360 #[tokio::test]
1361 async fn test_validate_password_weak() {
1362 let mgr = make_manager();
1363 assert!(!mgr.validate_password_strength("123").await.unwrap());
1364 }
1365
1366 #[tokio::test]
1369 async fn test_validate_user_input_clean() {
1370 let mgr = make_manager();
1371 assert!(mgr.validate_user_input("Hello World 123").await.unwrap());
1372 }
1373
1374 #[tokio::test]
1375 async fn test_validate_user_input_html_tags() {
1376 let mgr = make_manager();
1377 assert!(
1378 !mgr.validate_user_input("<script>alert(1)</script>")
1379 .await
1380 .unwrap()
1381 );
1382 }
1383
1384 #[tokio::test]
1385 async fn test_validate_user_input_sql_injection() {
1386 let mgr = make_manager();
1387 assert!(
1388 !mgr.validate_user_input("'; drop table users--")
1389 .await
1390 .unwrap()
1391 );
1392 }
1393
1394 #[tokio::test]
1395 async fn test_validate_user_input_template_injection() {
1396 let mgr = make_manager();
1397 assert!(!mgr.validate_user_input("${evil}").await.unwrap());
1398 }
1399
1400 #[tokio::test]
1401 async fn test_validate_user_input_path_traversal() {
1402 let mgr = make_manager();
1403 assert!(!mgr.validate_user_input("../../etc/passwd").await.unwrap());
1404 }
1405
1406 #[tokio::test]
1407 async fn test_validate_user_input_javascript_uri() {
1408 let mgr = make_manager();
1409 assert!(
1410 !mgr.validate_user_input("javascript:alert(1)")
1411 .await
1412 .unwrap()
1413 );
1414 }
1415
1416 #[tokio::test]
1417 async fn test_validate_user_input_empty() {
1418 let mgr = make_manager();
1419 assert!(!mgr.validate_user_input("").await.unwrap());
1420 }
1421
1422 #[tokio::test]
1423 async fn test_validate_user_input_encoded_tags() {
1424 let mgr = make_manager();
1425 assert!(!mgr.validate_user_input("%3cscript%3e").await.unwrap());
1426 }
1427
1428 #[tokio::test]
1431 async fn test_username_exists() {
1432 let mgr = make_manager();
1433 mgr.register_user("quinn", "quinn@example.com", "StrongP@ss1!")
1434 .await
1435 .unwrap();
1436 assert!(mgr.username_exists("quinn").await.unwrap());
1437 assert!(!mgr.username_exists("noone").await.unwrap());
1438 }
1439
1440 #[tokio::test]
1441 async fn test_email_exists() {
1442 let mgr = make_manager();
1443 mgr.register_user("ross", "ross@example.com", "StrongP@ss1!")
1444 .await
1445 .unwrap();
1446 assert!(mgr.email_exists("ross@example.com").await.unwrap());
1447 assert!(!mgr.email_exists("nobody@example.com").await.unwrap());
1448 }
1449
1450 #[tokio::test]
1453 async fn test_get_user_by_username() {
1454 let mgr = make_manager();
1455 mgr.register_user("sam", "sam@example.com", "StrongP@ss1!")
1456 .await
1457 .unwrap();
1458 let data = mgr.get_user_by_username("sam").await.unwrap();
1459 assert_eq!(data["username"].as_str(), Some("sam"));
1460 }
1461
1462 #[tokio::test]
1463 async fn test_get_user_by_username_not_found() {
1464 let mgr = make_manager();
1465 assert!(mgr.get_user_by_username("ghost").await.is_err());
1466 }
1467
1468 #[tokio::test]
1471 async fn test_get_user_profile() {
1472 let mgr = make_manager();
1473 let id = mgr
1474 .register_user("tina", "tina@example.com", "StrongP@ss1!")
1475 .await
1476 .unwrap();
1477 let profile = mgr.get_user_profile(&id).await.unwrap();
1478 assert_eq!(profile.username.as_deref(), Some("tina"));
1479 assert_eq!(profile.email.as_deref(), Some("tina@example.com"));
1480 assert!(!profile.additional_data.contains_key("password_hash"));
1482 }
1483
1484 #[tokio::test]
1485 async fn test_get_user_profile_not_found() {
1486 let mgr = make_manager();
1487 assert!(mgr.get_user_profile("ghost").await.is_err());
1488 }
1489
1490 #[tokio::test]
1493 async fn test_get_user_roles_default() {
1494 let mgr = make_manager();
1495 let id = mgr
1496 .register_user("uma", "uma@example.com", "StrongP@ss1!")
1497 .await
1498 .unwrap();
1499 let roles = mgr.get_user_roles(&id).await.unwrap();
1500 assert!(roles.contains(&"user".to_string()));
1501 }
1502
1503 #[tokio::test]
1504 async fn test_get_user_roles_not_found_returns_default() {
1505 let mgr = make_manager();
1506 let roles = mgr.get_user_roles("ghost").await.unwrap();
1507 assert_eq!(roles, vec!["user".to_string()]);
1508 }
1509
1510 #[tokio::test]
1513 async fn test_verify_login_credentials_success() {
1514 let mgr = make_manager();
1515 mgr.register_user("vera", "vera@example.com", "StrongP@ss1!")
1516 .await
1517 .unwrap();
1518 let result = mgr
1519 .verify_login_credentials("vera", "StrongP@ss1!")
1520 .await
1521 .unwrap();
1522 assert!(result.is_some());
1523 assert!(!result.unwrap().mfa_enabled);
1524 }
1525
1526 #[tokio::test]
1527 async fn test_verify_login_credentials_wrong_password() {
1528 let mgr = make_manager();
1529 mgr.register_user("wanda", "wanda@example.com", "StrongP@ss1!")
1530 .await
1531 .unwrap();
1532 let result = mgr
1533 .verify_login_credentials("wanda", "wrong")
1534 .await
1535 .unwrap();
1536 assert!(result.is_none());
1537 }
1538
1539 #[tokio::test]
1540 async fn test_verify_login_credentials_unknown_user() {
1541 let mgr = make_manager();
1542 let result = mgr
1543 .verify_login_credentials("ghost", "StrongP@ss1!")
1544 .await
1545 .unwrap();
1546 assert!(result.is_none());
1547 }
1548
1549 #[tokio::test]
1550 async fn test_verify_login_credentials_empty_inputs() {
1551 let mgr = make_manager();
1552 assert!(
1553 mgr.verify_login_credentials("", "pass")
1554 .await
1555 .unwrap()
1556 .is_none()
1557 );
1558 assert!(
1559 mgr.verify_login_credentials("user", "")
1560 .await
1561 .unwrap()
1562 .is_none()
1563 );
1564 }
1565
1566 #[tokio::test]
1567 async fn test_verify_login_credentials_deactivated() {
1568 let mgr = make_manager();
1569 let id = mgr
1570 .register_user("xena", "xena@example.com", "StrongP@ss1!")
1571 .await
1572 .unwrap();
1573 mgr.set_user_active(&id, false).await.unwrap();
1574 let result = mgr
1575 .verify_login_credentials("xena", "StrongP@ss1!")
1576 .await
1577 .unwrap();
1578 assert!(result.is_none());
1579 }
1580
1581 #[tokio::test]
1584 async fn test_get_username_by_id() {
1585 let mgr = make_manager();
1586 let id = mgr
1587 .register_user("yara", "yara@example.com", "StrongP@ss1!")
1588 .await
1589 .unwrap();
1590 let username = mgr.get_username_by_id(&id).await.unwrap();
1591 assert_eq!(username, "yara");
1592 }
1593
1594 #[tokio::test]
1595 async fn test_get_username_by_id_not_found() {
1596 let mgr = make_manager();
1597 assert!(mgr.get_username_by_id("ghost").await.is_err());
1598 }
1599
1600 #[tokio::test]
1603 async fn test_list_users_active_only() {
1604 let mgr = make_manager();
1605 let id1 = mgr
1606 .register_user("active1", "active1@example.com", "StrongP@ss1!")
1607 .await
1608 .unwrap();
1609 let id2 = mgr
1610 .register_user("inactive1", "inactive1@example.com", "StrongP@ss1!")
1611 .await
1612 .unwrap();
1613 mgr.set_user_active(&id2, false).await.unwrap();
1614
1615 let all = mgr.list_users(None, None, false).await.unwrap();
1616 let active = mgr.list_users(None, None, true).await.unwrap();
1617 assert!(all.len() > active.len());
1618 assert!(active.iter().all(|u| u.active));
1619 assert!(all.iter().any(|u| u.id == id1));
1621 assert!(all.iter().any(|u| u.id == id2));
1622 }
1623}