1use crate::{
57 config::{
58 AuditConfig, AuditStorage, CookieSameSite, JwtAlgorithm, PasswordHashAlgorithm,
59 RateLimitConfig, SecurityConfig,
60 },
61 prelude::{AuthFrameworkResult, hours, minutes},
62};
63use std::time::Duration;
64
65#[derive(Debug, Clone, PartialEq)]
67pub enum SecurityPreset {
68 Development,
78
79 Balanced,
89
90 HighSecurity,
102
103 Paranoid,
115}
116
117#[derive(Debug, Clone)]
119pub struct SecurityIssue {
120 pub severity: SecuritySeverity,
122 pub component: String,
124 pub description: String,
126 pub suggestion: String,
128 pub blocks_production: bool,
130}
131
132#[derive(Debug, Clone, PartialEq, PartialOrd)]
134pub enum SecuritySeverity {
135 Info,
137 Warning,
139 Error,
141 Critical,
143}
144
145impl SecurityPreset {
146 pub fn to_config(&self) -> SecurityConfig {
148 match self {
149 SecurityPreset::Development => SecurityConfig {
150 min_password_length: 6,
151 require_password_complexity: false,
152 password_hash_algorithm: PasswordHashAlgorithm::Bcrypt, jwt_algorithm: JwtAlgorithm::HS256,
154 secret_key: None, secure_cookies: false, cookie_same_site: CookieSameSite::Lax,
157 csrf_protection: false, session_timeout: hours(24), },
160 SecurityPreset::Balanced => SecurityConfig {
161 min_password_length: 8,
162 require_password_complexity: true,
163 password_hash_algorithm: PasswordHashAlgorithm::Argon2,
164 jwt_algorithm: JwtAlgorithm::HS256,
165 secret_key: None,
166 secure_cookies: true,
167 cookie_same_site: CookieSameSite::Lax,
168 csrf_protection: true,
169 session_timeout: hours(8),
170 },
171 SecurityPreset::HighSecurity => SecurityConfig {
172 min_password_length: 12,
173 require_password_complexity: true,
174 password_hash_algorithm: PasswordHashAlgorithm::Argon2,
175 jwt_algorithm: JwtAlgorithm::RS256, secret_key: None,
177 secure_cookies: true,
178 cookie_same_site: CookieSameSite::Strict,
179 csrf_protection: true,
180 session_timeout: hours(2), },
182 SecurityPreset::Paranoid => SecurityConfig {
183 min_password_length: 16,
184 require_password_complexity: true,
185 password_hash_algorithm: PasswordHashAlgorithm::Argon2,
186 jwt_algorithm: JwtAlgorithm::RS512, secret_key: None,
188 secure_cookies: true,
189 cookie_same_site: CookieSameSite::Strict,
190 csrf_protection: true,
191 session_timeout: minutes(30), },
193 }
194 }
195
196 pub fn to_rate_limit_config(&self) -> RateLimitConfig {
198 match self {
199 SecurityPreset::Development => RateLimitConfig {
200 enabled: false, max_requests: 1000,
202 window: Duration::from_secs(60),
203 burst: 100,
204 },
205 SecurityPreset::Balanced => RateLimitConfig {
206 enabled: true,
207 max_requests: 100,
208 window: Duration::from_secs(60),
209 burst: 20,
210 },
211 SecurityPreset::HighSecurity => RateLimitConfig {
212 enabled: true,
213 max_requests: 60, window: Duration::from_secs(60),
215 burst: 10,
216 },
217 SecurityPreset::Paranoid => RateLimitConfig {
218 enabled: true,
219 max_requests: 30, window: Duration::from_secs(60),
221 burst: 5,
222 },
223 }
224 }
225
226 pub fn to_audit_config(&self) -> AuditConfig {
228 match self {
229 SecurityPreset::Development => AuditConfig {
230 enabled: false, log_success: false,
232 log_failures: true, log_permissions: false,
234 log_tokens: false,
235 storage: AuditStorage::Tracing,
236 },
237 SecurityPreset::Balanced => AuditConfig {
238 enabled: true,
239 log_success: false, log_failures: true,
241 log_permissions: true,
242 log_tokens: false, storage: AuditStorage::Tracing,
244 },
245 SecurityPreset::HighSecurity => AuditConfig {
246 enabled: true,
247 log_success: true,
248 log_failures: true,
249 log_permissions: true,
250 log_tokens: false,
251 storage: AuditStorage::Tracing, },
253 SecurityPreset::Paranoid => AuditConfig {
254 enabled: true,
255 log_success: true,
256 log_failures: true,
257 log_permissions: true,
258 log_tokens: true, storage: AuditStorage::Tracing, },
261 }
262 }
263
264 pub async fn validate_environment(&self) -> AuthFrameworkResult<Vec<SecurityIssue>> {
266 let mut issues = Vec::new();
267
268 let is_production = self.is_production_environment();
270 let is_development = self.is_development_environment();
271
272 match (self, is_production, is_development) {
274 (SecurityPreset::Development, true, false) => {
275 issues.push(SecurityIssue {
276 severity: SecuritySeverity::Critical,
277 component: "Security Preset".to_string(),
278 description: "Development security preset used in production environment".to_string(),
279 suggestion: "Use SecurityPreset::HighSecurity or SecurityPreset::Paranoid for production".to_string(),
280 blocks_production: true,
281 });
282 }
283 (SecurityPreset::Balanced, true, false) => {
284 issues.push(SecurityIssue {
285 severity: SecuritySeverity::Warning,
286 component: "Security Preset".to_string(),
287 description:
288 "Balanced security preset in production - consider higher security"
289 .to_string(),
290 suggestion: "Consider SecurityPreset::HighSecurity for better protection"
291 .to_string(),
292 blocks_production: false,
293 });
294 }
295 _ => {} }
297
298 self.validate_jwt_secret(&mut issues);
300
301 if is_production && self.requires_secure_cookies() {
303 self.validate_https_requirement(&mut issues);
304 }
305
306 self.validate_storage_security(&mut issues);
308
309 self.validate_environment_variables(&mut issues);
311
312 Ok(issues)
313 }
314
315 pub async fn security_audit(&self) -> AuthFrameworkResult<SecurityAuditReport> {
317 let issues = self.validate_environment().await?;
318
319 let critical_count = issues
320 .iter()
321 .filter(|i| i.severity == SecuritySeverity::Critical)
322 .count();
323 let error_count = issues
324 .iter()
325 .filter(|i| i.severity == SecuritySeverity::Error)
326 .count();
327 let warning_count = issues
328 .iter()
329 .filter(|i| i.severity == SecuritySeverity::Warning)
330 .count();
331
332 let overall_status = if critical_count > 0 {
333 SecurityAuditStatus::Critical
334 } else if error_count > 0 {
335 SecurityAuditStatus::Failed
336 } else if warning_count > 0 {
337 SecurityAuditStatus::Warning
338 } else {
339 SecurityAuditStatus::Passed
340 };
341
342 Ok(SecurityAuditReport {
343 preset: self.clone(),
344 status: overall_status,
345 issues,
346 critical_count,
347 error_count,
348 warning_count,
349 recommendations: self.get_security_recommendations(),
350 })
351 }
352
353 pub fn get_security_recommendations(&self) -> Vec<String> {
355 let mut recommendations = Vec::new();
356
357 match self {
358 SecurityPreset::Development => {
359 recommendations.push(
360 "â ī¸ Development preset detected - ensure this is not used in production"
361 .to_string(),
362 );
363 recommendations
364 .push("đ Set JWT_SECRET environment variable with a secure value".to_string());
365 recommendations
366 .push("đ Enable audit logging when moving to production".to_string());
367 }
368 SecurityPreset::Balanced => {
369 recommendations.push(
370 "đ Consider upgrading to HighSecurity for sensitive applications".to_string(),
371 );
372 recommendations
373 .push("đ Monitor authentication patterns for suspicious activity".to_string());
374 recommendations.push("đ Regularly rotate JWT secrets and API keys".to_string());
375 }
376 SecurityPreset::HighSecurity => {
377 recommendations
378 .push("â
Good security configuration for production use".to_string());
379 recommendations
380 .push("đ Ensure RSA keys are properly managed and rotated".to_string());
381 recommendations.push("đ Monitor failed authentication attempts".to_string());
382 recommendations.push(
383 "đĄī¸ Consider multi-factor authentication for admin accounts".to_string(),
384 );
385 }
386 SecurityPreset::Paranoid => {
387 recommendations
388 .push("đĄī¸ Maximum security enabled - monitor performance impact".to_string());
389 recommendations.push(
390 "⥠Consider connection pooling to handle strict rate limits".to_string(),
391 );
392 recommendations.push("đ Implement comprehensive security monitoring".to_string());
393 recommendations
394 .push("đ¨ Set up alerting for all authentication failures".to_string());
395 }
396 }
397
398 recommendations
399 }
400
401 fn is_production_environment(&self) -> bool {
404 std::env::var("ENVIRONMENT").as_deref() == Ok("production")
405 || std::env::var("ENV").as_deref() == Ok("production")
406 || std::env::var("NODE_ENV").as_deref() == Ok("production")
407 || std::env::var("RUST_ENV").as_deref() == Ok("production")
408 || std::env::var("KUBERNETES_SERVICE_HOST").is_ok()
409 }
410
411 fn is_development_environment(&self) -> bool {
412 std::env::var("ENVIRONMENT").as_deref() == Ok("development")
413 || std::env::var("ENV").as_deref() == Ok("development")
414 || std::env::var("NODE_ENV").as_deref() == Ok("development")
415 || std::env::var("RUST_ENV").as_deref() == Ok("development")
416 || cfg!(debug_assertions)
417 }
418
419 fn requires_secure_cookies(&self) -> bool {
420 matches!(
421 self,
422 SecurityPreset::Balanced | SecurityPreset::HighSecurity | SecurityPreset::Paranoid
423 )
424 }
425
426 fn validate_jwt_secret(&self, issues: &mut Vec<SecurityIssue>) {
427 if let Ok(secret) = std::env::var("JWT_SECRET") {
428 let min_length = match self {
429 SecurityPreset::Development => 16,
430 SecurityPreset::Balanced => 32,
431 SecurityPreset::HighSecurity => 64,
432 SecurityPreset::Paranoid => 128,
433 };
434
435 if secret.len() < min_length {
436 issues.push(SecurityIssue {
437 severity: if matches!(self, SecurityPreset::Development) {
438 SecuritySeverity::Warning
439 } else {
440 SecuritySeverity::Error
441 },
442 component: "JWT Secret".to_string(),
443 description: format!(
444 "JWT secret too short ({} chars, need {}+)",
445 secret.len(),
446 min_length
447 ),
448 suggestion: format!(
449 "Generate a longer secret: `openssl rand -base64 {}`",
450 min_length * 3 / 4
451 ),
452 blocks_production: !matches!(self, SecurityPreset::Development),
453 });
454 }
455
456 if secret.to_lowercase().contains("secret")
458 || secret.to_lowercase().contains("password")
459 || secret.contains("123")
460 {
461 issues.push(SecurityIssue {
462 severity: SecuritySeverity::Error,
463 component: "JWT Secret".to_string(),
464 description: "JWT secret contains weak patterns or common words".to_string(),
465 suggestion:
466 "Use a cryptographically secure random string: `openssl rand -base64 64`"
467 .to_string(),
468 blocks_production: true,
469 });
470 }
471 } else {
472 issues.push(SecurityIssue {
473 severity: SecuritySeverity::Critical,
474 component: "JWT Secret".to_string(),
475 description: "JWT_SECRET environment variable not set".to_string(),
476 suggestion: "Set JWT_SECRET environment variable with a secure random value"
477 .to_string(),
478 blocks_production: true,
479 });
480 }
481 }
482
483 fn validate_https_requirement(&self, issues: &mut Vec<SecurityIssue>) {
484 let has_tls_cert =
487 std::env::var("TLS_CERT_PATH").is_ok() || std::env::var("SSL_CERT_PATH").is_ok();
488 let behind_proxy = std::env::var("HTTPS").as_deref() == Ok("on")
489 || std::env::var("HTTP_X_FORWARDED_PROTO").as_deref() == Ok("https");
490
491 if !has_tls_cert && !behind_proxy {
492 issues.push(SecurityIssue {
493 severity: SecuritySeverity::Warning,
494 component: "HTTPS".to_string(),
495 description: "HTTPS configuration not detected".to_string(),
496 suggestion: "Ensure HTTPS is properly configured for secure cookie transmission"
497 .to_string(),
498 blocks_production: false,
499 });
500 }
501 }
502
503 fn validate_storage_security(&self, issues: &mut Vec<SecurityIssue>) {
504 if let Ok(db_url) = std::env::var("DATABASE_URL")
506 && db_url.starts_with("postgresql://")
507 && !db_url.contains("sslmode=require")
508 {
509 issues.push(SecurityIssue {
510 severity: SecuritySeverity::Warning,
511 component: "Database".to_string(),
512 description: "Database connection may not be using SSL".to_string(),
513 suggestion: "Add sslmode=require to DATABASE_URL for encrypted connections"
514 .to_string(),
515 blocks_production: false,
516 });
517 }
518
519 if let Ok(redis_url) = std::env::var("REDIS_URL")
520 && !redis_url.starts_with("rediss://")
521 && !redis_url.contains("tls")
522 {
523 issues.push(SecurityIssue {
524 severity: SecuritySeverity::Info,
525 component: "Redis".to_string(),
526 description: "Redis connection may not be using TLS".to_string(),
527 suggestion: "Consider using rediss:// URL or enabling TLS for Redis connections"
528 .to_string(),
529 blocks_production: false,
530 });
531 }
532 }
533
534 fn validate_environment_variables(&self, issues: &mut Vec<SecurityIssue>) {
535 let sensitive_vars = [
536 "JWT_SECRET",
537 "DATABASE_URL",
538 "REDIS_URL",
539 "OAUTH_CLIENT_SECRET",
540 ];
541
542 for var in &sensitive_vars {
543 if let Ok(value) = std::env::var(var)
544 && value.len() < 20
545 {
546 issues.push(SecurityIssue {
547 severity: SecuritySeverity::Warning,
548 component: "Environment Variables".to_string(),
549 description: format!("{} appears to be too short", var),
550 suggestion: format!(
551 "Ensure {} contains a sufficiently long, secure value",
552 var
553 ),
554 blocks_production: false,
555 });
556 }
557 }
558 }
559}
560
561#[derive(Debug, Clone)]
563pub struct SecurityAuditReport {
564 pub preset: SecurityPreset,
565 pub status: SecurityAuditStatus,
566 pub issues: Vec<SecurityIssue>,
567 pub critical_count: usize,
568 pub error_count: usize,
569 pub warning_count: usize,
570 pub recommendations: Vec<String>,
571}
572
573#[derive(Debug, Clone, PartialEq)]
575pub enum SecurityAuditStatus {
576 Passed,
578 Warning,
580 Failed,
582 Critical,
584}
585
586impl SecurityAuditReport {
587 pub fn print_report(&self) {
589 println!("đ Security Audit Report");
590 println!("========================");
591 println!("Preset: {:?}", self.preset);
592 println!("Status: {}", self.status_emoji());
593 println!();
594
595 if self.issues.is_empty() {
596 println!("â
No security issues found!");
597 } else {
598 println!("đ Issues Summary:");
599 println!(" Critical: {}", self.critical_count);
600 println!(" Errors: {}", self.error_count);
601 println!(" Warnings: {}", self.warning_count);
602 println!();
603
604 for issue in &self.issues {
605 println!(
606 "{} {}: {}",
607 issue.severity.emoji(),
608 issue.component,
609 issue.description
610 );
611 println!(" đĄ {}", issue.suggestion);
612 println!();
613 }
614 }
615
616 if !self.recommendations.is_empty() {
617 println!("đ Recommendations:");
618 for rec in &self.recommendations {
619 println!(" {}", rec);
620 }
621 println!();
622 }
623
624 println!("{}", self.get_summary_message());
625 }
626
627 fn status_emoji(&self) -> &str {
628 match self.status {
629 SecurityAuditStatus::Passed => "â
Passed",
630 SecurityAuditStatus::Warning => "â ī¸ Warning",
631 SecurityAuditStatus::Failed => "â Failed",
632 SecurityAuditStatus::Critical => "đ¨ Critical",
633 }
634 }
635
636 fn get_summary_message(&self) -> String {
637 match self.status {
638 SecurityAuditStatus::Passed => "đ Security audit passed! Your configuration meets security requirements.".to_string(),
639 SecurityAuditStatus::Warning => "â ī¸ Security audit completed with warnings. Consider addressing the issues above.".to_string(),
640 SecurityAuditStatus::Failed => "â Security audit failed. Please address the errors before deploying to production.".to_string(),
641 SecurityAuditStatus::Critical => "đ¨ Critical security issues found! Do not deploy to production until these are resolved.".to_string(),
642 }
643 }
644
645 pub fn is_production_ready(&self) -> bool {
647 matches!(
648 self.status,
649 SecurityAuditStatus::Passed | SecurityAuditStatus::Warning
650 )
651 }
652
653 pub fn get_blocking_issues(&self) -> Vec<&SecurityIssue> {
655 self.issues
656 .iter()
657 .filter(|issue| issue.blocks_production)
658 .collect()
659 }
660}
661
662impl SecuritySeverity {
663 fn emoji(&self) -> &str {
664 match self {
665 SecuritySeverity::Info => "âšī¸ ",
666 SecuritySeverity::Warning => "â ī¸ ",
667 SecuritySeverity::Error => "â",
668 SecuritySeverity::Critical => "đ¨",
669 }
670 }
671}
672
673impl std::fmt::Display for SecuritySeverity {
674 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
675 match self {
676 SecuritySeverity::Info => write!(f, "INFO"),
677 SecuritySeverity::Warning => write!(f, "WARNING"),
678 SecuritySeverity::Error => write!(f, "ERROR"),
679 SecuritySeverity::Critical => write!(f, "CRITICAL"),
680 }
681 }
682}