use log::{debug, error, info, warn};
use std::collections::HashSet;
use std::sync::Arc;
use super::env_validation::{
LoggingSecurityWarning, LoggingWarningType, SecurityValidationResult, SensitiveVarWarning,
SensitiveVarWarningType, WarningSeverity,
};
#[derive(Debug, Clone)]
pub struct EnvVarWhitelist {
pub allowed_prefixes: Vec<&'static str>,
pub allowed_names: HashSet<&'static str>,
pub sensitive_vars: HashSet<&'static str>,
pub forbidden_vars: HashSet<&'static str>,
}
impl Default for EnvVarWhitelist {
fn default() -> Self {
Self {
allowed_prefixes: vec!["CRAWLRS_", "APP_", "DATABASE_", "RUST_", "HTTP_", "HTTPS_"],
allowed_names: HashSet::from([
"APP_ENVIRONMENT",
"APP_PORT",
"DB_HOST",
"DB_PORT",
"DB_USER",
"DB_PASSWORD",
"DB_NAME",
"DATABASE_URL",
"DATABASE_MAX_CONNECTIONS",
"SERVER_HOST",
"SERVER_PORT",
"SEARCH_ENGINE_GOOGLE_ENABLED",
"SEARCH_ENGINE_BING_ENABLED",
"SEARCH_ENGINE_BAIDU_ENABLED",
"SEARCH_ENGINE_SOGOU_ENABLED",
"SEARCH_ENGINE_DEFAULT",
"FLARESOLVERR_HOST",
"FLARESOLVERR_PORT",
"FLARESOLVERR_AUTO_START",
"FLARESOLVERR_LOG_LEVEL",
"FLARESOLVERR_CAPTCHA_SOLVER",
"CHROME_HOST",
"CHROME_PORT",
"RATE_LIMITING_ENABLED",
"RATE_LIMITING_DEFAULT_RPM",
"CONCURRENCY_DEFAULT_TEAM_LIMIT",
"CONCURRENCY_TASK_LOCK_DURATION",
"METRICS_ENABLED",
"METRICS_PORT",
"PROMETHEUS_PORT",
"GRAFANA_PASSWORD",
"PGADMIN_PASSWORD",
"DATA_VOLUME_PATH",
"LLM_API_KEY",
"LLM_MODEL",
"LLM_API_BASE_URL",
"GOOGLE_SEARCH_API_KEY",
"GOOGLE_SEARCH_CX",
"BING_SEARCH_API_KEY",
"BAIDU_SEARCH_API_KEY",
"SOGOU_SEARCH_API_KEY",
]),
sensitive_vars: HashSet::from([
"DB_PASSWORD",
"DATABASE_URL",
"DATABASE_PASSWORD",
"LLM_API_KEY",
"OPENAI_API_KEY",
"ANTHROPIC_API_KEY",
"GOOGLE_SEARCH_API_KEY",
"GOOGLE_SEARCH_CX",
"BING_SEARCH_API_KEY",
"BAIDU_SEARCH_API_KEY",
"SOGOU_SEARCH_API_KEY",
"GRAFANA_PASSWORD",
"PGADMIN_PASSWORD",
"AWS_ACCESS_KEY_ID",
"AWS_SECRET_ACCESS_KEY",
"AWS_SESSION_TOKEN",
"AWS_SECURITY_TOKEN",
"AWS_SECRET_KEY",
"S3_ACCESS_KEY_ID",
"S3_SECRET_ACCESS_KEY",
"S3_SECRET_KEY",
"SMTP_PASSWORD",
"SMTP_USERNAME",
"MAIL_PASSWORD",
"MAIL_USERNAME",
"SENDGRID_API_KEY",
"MAILGUN_API_KEY",
"JWT_SECRET",
"JWT_SIGNING_KEY",
"JWT_PRIVATE_KEY",
"JWT_PUBLIC_KEY",
"ENCRYPTION_KEY",
"SECRET_KEY",
"MASTER_KEY",
"PRIVATE_KEY",
"API_SECRET",
"API_KEY",
"SECRET_TOKEN",
"ACCESS_TOKEN",
"REFRESH_TOKEN",
"SESSION_SECRET",
"SESSION_KEY",
"COOKIE_SECRET",
"OAUTH_CLIENT_SECRET",
"OAUTH_ACCESS_TOKEN",
"GITHUB_TOKEN",
"GITLAB_TOKEN",
"STRIPE_SECRET_KEY",
"STRIPE_API_KEY",
"TWILIO_AUTH_TOKEN",
"TWILIO_ACCOUNT_SID",
"PROXY_PASSWORD",
"PROXY_USERNAME",
"ADMIN_PASSWORD",
"ROOT_PASSWORD",
"SUPERUSER_PASSWORD",
]),
forbidden_vars: HashSet::from([
"CARGO_INCREMENTAL",
"RUSTFLAGS",
"LD_PRELOAD",
"DYLD_INSERT_LIBRARIES",
]),
}
}
}
#[derive(Debug, Clone)]
pub enum EnvVarCheckResult {
Allowed(String),
Sensitive { name: String, masked_value: String },
Unknown(String),
Forbidden { name: String, reason: String },
}
#[derive(Debug, Clone)]
pub struct EnvVarSecurityReport {
pub detected_variables: Vec<String>,
pub allowed_variables: Vec<String>,
pub unknown_variables: Vec<String>,
pub sensitive_variables: Vec<String>,
pub forbidden_variables: Vec<String>,
pub security_score: u8,
pub warnings: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct EnvVarSecurityMonitor {
whitelist: Arc<EnvVarWhitelist>,
}
impl EnvVarSecurityMonitor {
pub fn new(whitelist: EnvVarWhitelist) -> Self {
Self {
whitelist: Arc::new(whitelist),
}
}
}
impl Default for EnvVarSecurityMonitor {
fn default() -> Self {
Self::new(EnvVarWhitelist::default())
}
}
impl EnvVarSecurityMonitor {
pub fn check_variable(&self, name: &str, value: &str) -> EnvVarCheckResult {
let name = name.to_uppercase();
if self.whitelist.forbidden_vars.contains(name.as_str()) {
error!("Forbidden environment variable detected: {}", name);
return EnvVarCheckResult::Forbidden {
name: name.to_string(),
reason: format!(
"Environment variable '{}' is forbidden for security reasons",
name
),
};
}
if self.whitelist.sensitive_vars.contains(name.as_str()) {
debug!("Sensitive environment variable detected: {}", name);
return EnvVarCheckResult::Sensitive {
name: name.to_string(),
masked_value: self.mask_value(value),
};
}
if self.whitelist.allowed_names.contains(name.as_str()) {
debug!("Allowed environment variable: {}", name);
return EnvVarCheckResult::Allowed(name.to_string());
}
for prefix in &self.whitelist.allowed_prefixes {
if name.starts_with(prefix) {
debug!("Allowed environment variable by prefix: {}", name);
return EnvVarCheckResult::Allowed(name.to_string());
}
}
warn!("Unknown environment variable detected: {}", name);
EnvVarCheckResult::Unknown(name.to_string())
}
fn mask_value(&self, value: &str) -> String {
let chars: Vec<char> = value.chars().collect();
if chars.len() <= 4 {
return "****".to_string();
}
let visible_chars = 2;
let start: String = chars[..visible_chars].iter().collect();
let end: String = chars[chars.len() - visible_chars..].iter().collect();
let masked_length = chars.len() - (visible_chars * 2);
format!("{}*{}{}", start, "*".repeat(masked_length.min(20)), end)
}
pub fn generate_security_report(&self) -> EnvVarSecurityReport {
let mut detected = Vec::new();
let mut allowed = Vec::new();
let mut unknown = Vec::new();
let mut sensitive = Vec::new();
let mut forbidden = Vec::new();
let mut warnings = Vec::new();
for (name, value) in std::env::vars() {
detected.push(name.clone());
match self.check_variable(&name, &value) {
EnvVarCheckResult::Allowed(_) => {
allowed.push(name);
}
EnvVarCheckResult::Sensitive { name, .. } => {
sensitive.push(name);
}
EnvVarCheckResult::Unknown(name) => {
unknown.push(name.clone());
warnings.push(format!("Unknown environment variable: {}. Consider adding it to the whitelist if needed.", name));
}
EnvVarCheckResult::Forbidden { name, reason } => {
forbidden.push(name.clone());
warnings.push(format!("CRITICAL: {} - {}", name, reason));
}
}
}
let total = detected.len();
let unknown_count = unknown.len();
let forbidden_count = forbidden.len();
let score: i32 = if total == 0 {
100
} else {
let base_score: i32 = 100;
let unknown_penalty = ((unknown_count as f64 / total as f64) * 20.0) as i32;
let forbidden_penalty = ((forbidden_count as f64 / total as f64) * 100.0) as i32;
base_score
.saturating_sub(unknown_penalty)
.saturating_sub(forbidden_penalty)
};
EnvVarSecurityReport {
detected_variables: detected,
allowed_variables: allowed,
unknown_variables: unknown,
sensitive_variables: sensitive,
forbidden_variables: forbidden,
security_score: score as u8,
warnings,
}
}
pub fn log_security_warnings(&self) {
let report = self.generate_security_report();
info!("=== Environment Variable Security Report ===");
info!("Total variables: {}", report.detected_variables.len());
info!("Allowed: {}", report.allowed_variables.len());
info!(
"Sensitive: {} (masked in logs)",
report.sensitive_variables.len()
);
info!("Unknown: {}", report.unknown_variables.len());
info!("Forbidden: {}", report.forbidden_variables.len());
info!("Security Score: {}/100", report.security_score);
if !report.warnings.is_empty() {
warn!("Security Warnings:");
for warning in &report.warnings {
warn!(" - {}", warning);
}
}
if report.security_score < 70 {
error!("Security score is below acceptable level! Review the warnings above.");
}
}
pub fn get_masked_value(&self, name: &str, value: &str) -> String {
let upper_name = name.to_uppercase();
if self.whitelist.sensitive_vars.contains(upper_name.as_str()) {
self.mask_value(value)
} else {
value.to_string()
}
}
}
const WEAK_DEFAULT_VALUES: [&str; 15] = [
"password", "secret", "changeme", "default", "test", "demo", "example", "123456", "admin",
"root", "qwerty", "letmein", "welcome", "monkey", "dragon",
];
const TEST_VALUE_PATTERNS: [&str; 9] = [
"test_", "demo_", "example_", "sample_", "fake_", "mock_", "xxx", "yyy", "zzz",
];
fn collect_sensitive_var_warnings(
var_name: &str,
environment: &str,
warnings: &mut Vec<SensitiveVarWarning>,
) {
if let Ok(value) = std::env::var(var_name) {
let lower_value = value.to_lowercase();
if let Some(warning) = empty_value_warning(var_name, &value, environment) {
warnings.push(warning);
return;
}
if let Some(warning) =
weak_default_value_warning(var_name, &lower_value, &WEAK_DEFAULT_VALUES)
{
warnings.push(warning);
}
if let Some(warning) =
test_value_warning(var_name, &lower_value, &TEST_VALUE_PATTERNS, environment)
{
warnings.push(warning);
}
if let Some(warning) = short_value_warning(var_name, &value) {
warnings.push(warning);
}
if let Some(warning) = insecure_pattern_warning(var_name, &lower_value) {
warnings.push(warning);
}
}
}
impl EnvVarSecurityMonitor {
pub fn validate_sensitive_values(&self, environment: &str) -> Vec<SensitiveVarWarning> {
let mut warnings = Vec::new();
for var_name in &self.whitelist.sensitive_vars {
collect_sensitive_var_warnings(var_name, environment, &mut warnings);
}
warnings
}
pub fn validate_logging_security(&self) -> Vec<LoggingSecurityWarning> {
let mut warnings = Vec::new();
Self::check_log_level(&mut warnings);
Self::check_log_file_path(&mut warnings);
self.check_sensitive_var_logging(&mut warnings);
warnings
}
fn check_log_level(warnings: &mut Vec<LoggingSecurityWarning>) {
if let Ok(log_level) = std::env::var("RUST_LOG") {
let lower_level = log_level.to_lowercase();
if lower_level.contains("debug") || lower_level.contains("trace") {
warnings.push(LoggingSecurityWarning {
warning_type: LoggingWarningType::VerboseLogLevel,
message: format!(
"Log level set to '{}', sensitive information may leak into logs",
log_level
),
recommendation: "Use INFO or WARN level in production".to_string(),
});
}
}
}
fn check_log_file_path(warnings: &mut Vec<LoggingSecurityWarning>) {
if let Ok(log_file) = std::env::var("LOG_FILE") {
if log_file.starts_with("/tmp") || log_file.starts_with("/var/tmp") {
warnings.push(LoggingSecurityWarning {
warning_type: LoggingWarningType::InsecureLogPath,
message: format!("Log file path '{}' is in a temporary directory, which may cause permission issues", log_file),
recommendation: "Store log files in a secure directory".to_string(),
});
}
}
}
fn check_sensitive_var_logging(&self, warnings: &mut Vec<LoggingSecurityWarning>) {
for var_name in &self.whitelist.sensitive_vars {
let debug_var = format!("{}_DEBUG", var_name);
let log_var = format!("{}_LOG", var_name);
if std::env::var(&debug_var).is_ok() {
warnings.push(LoggingSecurityWarning {
warning_type: LoggingWarningType::SensitiveVarDebug,
message: format!(
"Debug variable '{}' found, which may leak the value of sensitive variable '{}'",
debug_var, var_name
),
recommendation: "Remove this debug variable".to_string(),
});
}
if std::env::var(&log_var).is_ok() {
warnings.push(LoggingSecurityWarning {
warning_type: LoggingWarningType::SensitiveVarLogging,
message: format!(
"Logging variable '{}' found, which may log the value of sensitive variable '{}'",
log_var, var_name
),
recommendation: "Remove this logging variable".to_string(),
});
}
}
}
pub fn perform_full_security_validation(&self, environment: &str) -> SecurityValidationResult {
let sensitive_warnings = self.validate_sensitive_values(environment);
let logging_warnings = self.validate_logging_security();
let critical_count = sensitive_warnings
.iter()
.filter(|w| w.severity == WarningSeverity::Critical)
.count();
let high_count = sensitive_warnings
.iter()
.filter(|w| w.severity == WarningSeverity::High)
.count();
let is_secure = critical_count == 0 && high_count == 0;
SecurityValidationResult {
is_secure,
sensitive_var_warnings: sensitive_warnings,
logging_warnings,
critical_issues_count: critical_count,
high_issues_count: high_count,
}
}
}
fn empty_value_warning(
var_name: &str,
value: &str,
environment: &str,
) -> Option<SensitiveVarWarning> {
if value.is_empty() && environment == "production" {
return Some(SensitiveVarWarning {
var_name: var_name.to_string(),
warning_type: SensitiveVarWarningType::EmptyValue,
message: format!(
"Sensitive environment variable {} is empty in production, which may be a security risk",
var_name
),
severity: WarningSeverity::Critical,
});
}
None
}
fn weak_default_value_warning(
var_name: &str,
lower_value: &str,
weak_defaults: &[&str],
) -> Option<SensitiveVarWarning> {
for weak in weak_defaults {
if lower_value.contains(weak) {
return Some(SensitiveVarWarning {
var_name: var_name.to_string(),
warning_type: SensitiveVarWarningType::WeakDefaultValue,
message: format!(
"Sensitive environment variable {} contains weak default value pattern: '{}'",
var_name, weak
),
severity: WarningSeverity::High,
});
}
}
None
}
fn test_value_warning(
var_name: &str,
lower_value: &str,
test_patterns: &[&str],
environment: &str,
) -> Option<SensitiveVarWarning> {
for pattern in test_patterns {
if lower_value.contains(pattern) {
return Some(SensitiveVarWarning {
var_name: var_name.to_string(),
warning_type: SensitiveVarWarningType::TestValue,
message: format!(
"Sensitive environment variable {} contains test value pattern: '{}'",
var_name, pattern
),
severity: if environment == "production" {
WarningSeverity::Critical
} else {
WarningSeverity::Medium
},
});
}
}
None
}
fn short_value_warning(var_name: &str, value: &str) -> Option<SensitiveVarWarning> {
if value.len() < 16 && !value.is_empty() {
return Some(SensitiveVarWarning {
var_name: var_name.to_string(),
warning_type: SensitiveVarWarningType::ShortValue,
message: format!(
"Sensitive environment variable {} value too short ({} characters); a strong key of at least 32 characters is recommended",
var_name,
value.len()
),
severity: WarningSeverity::Medium,
});
}
None
}
fn insecure_pattern_warning(var_name: &str, lower_value: &str) -> Option<SensitiveVarWarning> {
if lower_value == var_name.to_lowercase() {
return Some(SensitiveVarWarning {
var_name: var_name.to_string(),
warning_type: SensitiveVarWarningType::InsecurePattern,
message: format!(
"Sensitive environment variable {} value equals its variable name, which is a serious security issue",
var_name
),
severity: WarningSeverity::Critical,
});
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_env_var_check_allowed() {
let monitor = EnvVarSecurityMonitor::default();
assert!(matches!(
monitor.check_variable("APP_ENVIRONMENT", "development"),
EnvVarCheckResult::Allowed(_)
));
}
#[test]
fn test_env_var_check_sensitive() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, masked_value } =
monitor.check_variable("DB_PASSWORD", "mysecretpassword")
{
assert_eq!(name, "DB_PASSWORD");
assert!(masked_value.contains('*'));
assert!(!masked_value.contains("mysecretpassword"));
} else {
panic!("Expected Sensitive result");
}
}
#[test]
fn test_env_var_check_forbidden() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Forbidden { name, reason } =
monitor.check_variable("LD_PRELOAD", "/malicious.so")
{
assert_eq!(name, "LD_PRELOAD");
assert!(reason.contains("forbidden"));
} else {
panic!("Expected Forbidden result");
}
}
#[test]
fn test_mask_value() {
let monitor = EnvVarSecurityMonitor::default();
assert_eq!(monitor.mask_value("123"), "****");
let masked = monitor.mask_value("myverylongpassword123");
assert!(masked.starts_with("my"));
assert!(masked.ends_with("23"));
assert!(masked.contains('*'));
}
#[test]
fn test_aws_credentials_detection() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("AWS_ACCESS_KEY_ID", "AKIAIOSFODNN7EXAMPLE")
{
assert_eq!(name, "AWS_ACCESS_KEY_ID");
} else {
panic!("AWS_ACCESS_KEY_ID 应该被识别为敏感变量");
}
if let EnvVarCheckResult::Sensitive { name, .. } = monitor.check_variable(
"AWS_SECRET_ACCESS_KEY",
"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
) {
assert_eq!(name, "AWS_SECRET_ACCESS_KEY");
} else {
panic!("AWS_SECRET_ACCESS_KEY 应该被识别为敏感变量");
}
}
#[test]
fn test_smtp_credentials_detection() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("SMTP_PASSWORD", "smtp_password_123")
{
assert_eq!(name, "SMTP_PASSWORD");
} else {
panic!("SMTP_PASSWORD 应该被识别为敏感变量");
}
}
#[test]
fn test_jwt_credentials_detection() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("JWT_SECRET", "jwt_super_secret_key")
{
assert_eq!(name, "JWT_SECRET");
} else {
panic!("JWT_SECRET 应该被识别为敏感变量");
}
}
#[test]
fn test_encryption_key_detection() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("ENCRYPTION_KEY", "encryption_key_123")
{
assert_eq!(name, "ENCRYPTION_KEY");
} else {
panic!("ENCRYPTION_KEY 应该被识别为敏感变量");
}
}
#[test]
fn test_session_secret_detection() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("SESSION_SECRET", "session_secret_key")
{
assert_eq!(name, "SESSION_SECRET");
} else {
panic!("SESSION_SECRET 应该被识别为敏感变量");
}
}
#[test]
fn test_oauth_credentials_detection() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("OAUTH_CLIENT_SECRET", "oauth_client_secret")
{
assert_eq!(name, "OAUTH_CLIENT_SECRET");
} else {
panic!("OAUTH_CLIENT_SECRET 应该被识别为敏感变量");
}
}
#[test]
fn test_third_party_api_keys_detection() {
let monitor = EnvVarSecurityMonitor::default();
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("STRIPE_SECRET_KEY", "sk_test_123456")
{
assert_eq!(name, "STRIPE_SECRET_KEY");
} else {
panic!("STRIPE_SECRET_KEY 应该被识别为敏感变量");
}
if let EnvVarCheckResult::Sensitive { name, .. } =
monitor.check_variable("TWILIO_AUTH_TOKEN", "twilio_auth_token")
{
assert_eq!(name, "TWILIO_AUTH_TOKEN");
} else {
panic!("TWILIO_AUTH_TOKEN 应该被识别为敏感变量");
}
}
#[test]
fn test_env_var_whitelist_default_fields() {
let whitelist = EnvVarWhitelist::default();
assert!(!whitelist.allowed_prefixes.is_empty());
assert!(whitelist.allowed_prefixes.contains(&"CRAWLRS_"));
assert!(whitelist.allowed_prefixes.contains(&"APP_"));
assert!(whitelist.allowed_prefixes.contains(&"DATABASE_"));
assert!(whitelist.allowed_prefixes.contains(&"RUST_"));
assert!(whitelist.allowed_prefixes.contains(&"HTTP_"));
assert!(whitelist.allowed_prefixes.contains(&"HTTPS_"));
assert!(!whitelist.allowed_names.is_empty());
assert!(whitelist.allowed_names.contains("APP_ENVIRONMENT"));
assert!(whitelist.allowed_names.contains("DATABASE_URL"));
assert!(whitelist.allowed_names.contains("SERVER_PORT"));
assert!(whitelist.allowed_names.contains("LLM_API_KEY"));
assert!(!whitelist.sensitive_vars.is_empty());
assert!(whitelist.sensitive_vars.contains("DB_PASSWORD"));
assert!(whitelist.sensitive_vars.contains("JWT_SECRET"));
assert!(whitelist.sensitive_vars.contains("AWS_SECRET_ACCESS_KEY"));
assert!(whitelist.sensitive_vars.contains("SMTP_PASSWORD"));
assert!(!whitelist.forbidden_vars.is_empty());
assert!(whitelist.forbidden_vars.contains("LD_PRELOAD"));
assert!(whitelist.forbidden_vars.contains("RUSTFLAGS"));
assert!(whitelist.forbidden_vars.contains("CARGO_INCREMENTAL"));
assert!(whitelist.forbidden_vars.contains("DYLD_INSERT_LIBRARIES"));
}
#[test]
fn test_env_var_security_monitor_new_constructor() {
let whitelist = EnvVarWhitelist::default();
let monitor = EnvVarSecurityMonitor::new(whitelist);
let result = monitor.check_variable("APP_PORT", "8080");
assert!(matches!(result, EnvVarCheckResult::Allowed(_)));
}
#[test]
fn test_check_variable_prefix_only_match() {
let monitor = EnvVarSecurityMonitor::default();
let result = monitor.check_variable("CRAWLRS_CUSTOM_FEATURE_XYZ", "enabled");
assert!(matches!(result, EnvVarCheckResult::Allowed(_)));
if let EnvVarCheckResult::Allowed(name) = result {
assert_eq!(name, "CRAWLRS_CUSTOM_FEATURE_XYZ");
}
}
#[test]
fn test_check_variable_unknown() {
let monitor = EnvVarSecurityMonitor::default();
let result = monitor.check_variable("ZZZ_UNKNOWN_RANDOM_VAR", "value");
assert!(matches!(result, EnvVarCheckResult::Unknown(_)));
if let EnvVarCheckResult::Unknown(name) = result {
assert_eq!(name, "ZZZ_UNKNOWN_RANDOM_VAR");
}
}
#[test]
fn test_check_variable_lowercase_input_uppercased() {
let monitor = EnvVarSecurityMonitor::default();
let result = monitor.check_variable("db_password", "mysecret");
assert!(matches!(result, EnvVarCheckResult::Sensitive { .. }));
if let EnvVarCheckResult::Sensitive { name, .. } = result {
assert_eq!(name, "DB_PASSWORD");
}
}
#[test]
fn test_mask_value_exactly_four_chars() {
let monitor = EnvVarSecurityMonitor::default();
assert_eq!(monitor.mask_value("abcd"), "****");
assert_eq!(monitor.mask_value("ab"), "****");
assert_eq!(monitor.mask_value(""), "****");
}
#[test]
fn test_mask_value_long_value_capped_at_20_stars() {
let monitor = EnvVarSecurityMonitor::default();
let long_value = "abcdefghijklmnopqrstuvwxyz0123456789";
let masked = monitor.mask_value(long_value);
assert!(masked.starts_with("ab"));
assert!(masked.ends_with("89"));
let star_count = masked.matches('*').count();
assert!(star_count <= 21);
assert_eq!(star_count, 21);
}
#[test]
fn test_get_masked_value_sensitive() {
let monitor = EnvVarSecurityMonitor::default();
let masked = monitor.get_masked_value("DB_PASSWORD", "mysecretpassword");
assert!(masked.contains('*'));
assert!(!masked.contains("mysecretpassword"));
}
#[test]
fn test_get_masked_value_non_sensitive() {
let monitor = EnvVarSecurityMonitor::default();
let value = monitor.get_masked_value("APP_PORT", "8080");
assert_eq!(value, "8080");
}
#[test]
fn test_env_var_security_report_construction() {
let report = EnvVarSecurityReport {
detected_variables: vec!["VAR1".to_string(), "VAR2".to_string()],
allowed_variables: vec!["VAR1".to_string()],
unknown_variables: vec!["VAR2".to_string()],
sensitive_variables: vec![],
forbidden_variables: vec![],
security_score: 85,
warnings: vec!["test warning".to_string()],
};
assert_eq!(report.detected_variables.len(), 2);
assert_eq!(report.allowed_variables.len(), 1);
assert_eq!(report.unknown_variables.len(), 1);
assert!(report.sensitive_variables.is_empty());
assert!(report.forbidden_variables.is_empty());
assert_eq!(report.security_score, 85);
assert_eq!(report.warnings.len(), 1);
}
#[test]
fn test_generate_security_report_structure() {
let monitor = EnvVarSecurityMonitor::default();
let report = monitor.generate_security_report();
assert!(report.security_score <= 100);
let total_classified = report.allowed_variables.len()
+ report.unknown_variables.len()
+ report.sensitive_variables.len()
+ report.forbidden_variables.len();
assert_eq!(report.detected_variables.len(), total_classified);
}
#[test]
fn test_log_security_warnings_does_not_panic() {
let monitor = EnvVarSecurityMonitor::default();
monitor.log_security_warnings();
}
#[test]
fn test_env_var_check_result_variants() {
let allowed = EnvVarCheckResult::Allowed("VAR".to_string());
let sensitive = EnvVarCheckResult::Sensitive {
name: "SECRET".to_string(),
masked_value: "****".to_string(),
};
let unknown = EnvVarCheckResult::Unknown("UNKNOWN".to_string());
let forbidden = EnvVarCheckResult::Forbidden {
name: "BAD".to_string(),
reason: "forbidden".to_string(),
};
match allowed {
EnvVarCheckResult::Allowed(n) => assert_eq!(n, "VAR"),
_ => panic!("Expected Allowed"),
}
match sensitive {
EnvVarCheckResult::Sensitive { name, masked_value } => {
assert_eq!(name, "SECRET");
assert_eq!(masked_value, "****");
}
_ => panic!("Expected Sensitive"),
}
match unknown {
EnvVarCheckResult::Unknown(n) => assert_eq!(n, "UNKNOWN"),
_ => panic!("Expected Unknown"),
}
match forbidden {
EnvVarCheckResult::Forbidden { name, reason } => {
assert_eq!(name, "BAD");
assert!(reason.contains("forbidden"));
}
_ => panic!("Expected Forbidden"),
}
}
}