use super::settings::Settings;
pub fn validate_security(settings: &Settings) -> Result<(), sdforge::validator::ValidationError> {
validate_webhook_secret(settings)?;
if !settings.rate_limiting.enabled {
return Err(sdforge::validator::ValidationError::new(
"rate_limiting_disabled",
));
}
validate_database_security(settings)?;
#[cfg(feature = "auth")]
validate_jwt_secret(settings)?;
Ok(())
}
fn validate_webhook_secret(settings: &Settings) -> Result<(), sdforge::validator::ValidationError> {
if settings.webhook.secret().is_empty() {
return Err(sdforge::validator::ValidationError::new(
"webhook_secret_empty",
));
}
let weak_secrets = [
"your-webhook-secret",
"your-secret-key",
"secret",
"webhook-secret",
"change-me",
"password",
];
if weak_secrets.contains(&settings.webhook.secret()) {
return Err(sdforge::validator::ValidationError::new(
"webhook_secret_weak",
));
}
if settings.webhook.secret().len() < 32 {
return Err(sdforge::validator::ValidationError::new(
"webhook_secret_short",
));
}
Ok(())
}
fn validate_database_security(
settings: &Settings,
) -> Result<(), sdforge::validator::ValidationError> {
let weak_patterns = ["password=password", "password=postgres", "password=admin"];
if weak_patterns
.iter()
.any(|p| settings.database.url().contains(p))
{
return Err(sdforge::validator::ValidationError::new(
"database_password_weak",
));
}
let env = std::env::var("APP_ENVIRONMENT")
.or_else(|_| std::env::var("CRAWLRS_ENV"))
.unwrap_or_else(|_| "development".to_string());
let is_production = env.eq_ignore_ascii_case("production") || env.eq_ignore_ascii_case("prod");
if is_production {
let password_length = extract_password_length(settings.database.url());
if password_length > 0 && password_length < 16 {
return Err(sdforge::validator::ValidationError::new(
"database_password_short_production",
));
}
}
Ok(())
}
#[cfg(feature = "auth")]
fn validate_jwt_secret(settings: &Settings) -> Result<(), sdforge::validator::ValidationError> {
let jwt_secret = settings.auth.jwt_secret();
if jwt_secret.is_empty() {
return Err(sdforge::validator::ValidationError::new(
"auth_jwt_secret_empty",
));
}
if jwt_secret.len() < 32 {
return Err(sdforge::validator::ValidationError::new(
"auth_jwt_secret_weak",
));
}
Ok(())
}
fn extract_password_length(url: &str) -> usize {
if let Some(at_pos) = url.find('@') {
if let Some(colon_pos) = url[..at_pos].find(':') {
return at_pos - colon_pos - 1;
}
}
0
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_support::ENV_MUTEX;
use crate::config::settings::Settings;
fn build_test_settings() -> Settings {
let mut settings = Settings::default();
settings.webhook.secret = "a-very-strong-webhook-secret-that-is-32-chars!!".to_string();
#[cfg(feature = "auth")]
{
settings.auth.jwt_secret = "a-very-strong-jwt-secret-that-is-32-chars!!".to_string();
}
settings
}
#[test]
fn test_validate_security_valid_settings() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved = std::env::var("APP_ENVIRONMENT").ok();
std::env::set_var("APP_ENVIRONMENT", "development");
let settings = build_test_settings();
assert!(validate_security(&settings).is_ok());
if let Some(v) = saved {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
}
#[test]
fn test_validate_security_empty_webhook_secret() {
let mut settings = build_test_settings();
settings.webhook.secret = String::new();
let result = validate_security(&settings);
assert!(result.is_err());
assert_eq!(result.unwrap_err().code.to_string(), "webhook_secret_empty");
}
#[test]
fn test_validate_security_weak_webhook_secret() {
let mut settings = build_test_settings();
settings.webhook.secret = "your-webhook-secret".to_string();
let result = validate_security(&settings);
assert!(result.is_err());
assert_eq!(result.unwrap_err().code.to_string(), "webhook_secret_weak");
}
#[test]
fn test_validate_security_short_webhook_secret() {
let mut settings = build_test_settings();
settings.webhook.secret = "short-secret".to_string();
let result = validate_security(&settings);
assert!(result.is_err());
assert_eq!(result.unwrap_err().code.to_string(), "webhook_secret_short");
}
#[test]
fn test_validate_security_rate_limiting_disabled() {
let mut settings = build_test_settings();
settings.rate_limiting.enabled = false;
let result = validate_security(&settings);
assert!(result.is_err());
assert_eq!(
result.unwrap_err().code.to_string(),
"rate_limiting_disabled"
);
}
#[test]
fn test_validate_security_weak_database_password() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let mut settings = build_test_settings();
settings.database.url = "postgres://user:password=password@localhost:5432/db".to_string();
let result = validate_security(&settings);
assert!(result.is_err());
assert_eq!(
result.unwrap_err().code.to_string(),
"database_password_weak"
);
}
#[cfg(feature = "auth")]
#[test]
fn test_validate_security_empty_jwt_secret_in_auth_mode() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let mut settings = build_test_settings();
settings.auth.jwt_secret = String::new();
let result = validate_security(&settings);
assert!(result.is_err());
assert_eq!(
result.unwrap_err().code.to_string(),
"auth_jwt_secret_empty"
);
}
}