use anyhow::{Context, Result};
use std::fs;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SecretIssueSeverity {
Error,
Warning,
}
#[derive(Debug, Clone)]
pub struct SecretIssue {
pub var_name: String,
pub policy_rule: String,
pub severity: SecretIssueSeverity,
pub reason: String,
}
impl std::fmt::Display for SecretIssue {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let sev = match self.severity {
SecretIssueSeverity::Error => "ERROR",
SecretIssueSeverity::Warning => "WARN",
};
write!(
f,
"[{}] {} ({}): {}",
sev, self.var_name, self.policy_rule, self.reason
)
}
}
#[derive(Debug, Clone)]
pub struct SecretsValidationReport {
pub issues: Vec<SecretIssue>,
}
impl SecretsValidationReport {
pub fn has_errors(&self) -> bool {
self.issues
.iter()
.any(|i| i.severity == SecretIssueSeverity::Error)
}
pub fn is_clean(&self) -> bool {
self.issues.is_empty()
}
}
fn check_secret_source(var_name: &str, env: &Environment, issues: &mut Vec<SecretIssue>) {
let has_inline = env_non_empty(var_name).is_some();
let has_file = env_non_empty(&format!("{var_name}_FILE")).is_some();
let has_vault = env_non_empty(&format!("{var_name}_VAULT_REF")).is_some();
if !has_inline && !has_file && !has_vault {
return;
}
let has_secure = has_file || has_vault;
match env {
Environment::Dev => { }
Environment::Staging => {
if has_vault {
issues.push(SecretIssue {
var_name: var_name.to_string(),
policy_rule: "UNRESOLVED_VAULT_REF_IN_STAGING".to_string(),
severity: SecretIssueSeverity::Error,
reason: format!(
"{var_name}_VAULT_REF is set in staging, but runtime vault resolution is not configured; materialize the secret before startup"
),
});
}
if has_inline && !has_secure {
issues.push(SecretIssue {
var_name: var_name.to_string(),
policy_rule: "INLINE_SECRET_IN_STAGING".to_string(),
severity: SecretIssueSeverity::Warning,
reason: format!(
"{var_name} is set as an inline env var in staging; \
prefer *_FILE or *_VAULT_REF for secret sourcing"
),
});
}
}
Environment::Prod | Environment::Unknown(_) => {
if has_vault {
issues.push(SecretIssue {
var_name: var_name.to_string(),
policy_rule: "UNRESOLVED_VAULT_REF_IN_PROD".to_string(),
severity: SecretIssueSeverity::Error,
reason: format!(
"{var_name}_VAULT_REF is set in '{}', but runtime vault resolution is not configured; materialize the secret before startup",
env.as_str()
),
});
}
if has_inline && !has_secure {
issues.push(SecretIssue {
var_name: var_name.to_string(),
policy_rule: "INLINE_SECRET_IN_PROD".to_string(),
severity: SecretIssueSeverity::Error,
reason: format!(
"{var_name} is set as an inline env var in '{}'; \
only *_FILE or *_VAULT_REF sourcing is allowed",
env.as_str()
),
});
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Environment {
Dev,
Staging,
Prod,
Unknown(String),
}
pub fn env_non_empty(name: &str) -> Option<String> {
std::env::var(name)
.ok()
.map(|v| v.trim().to_string())
.filter(|v| !v.is_empty())
}
pub(crate) fn jwt_allowlist_mixes_hmac_and_asymmetric(raw: &str) -> bool {
let mut has_hmac = false;
let mut has_asymmetric = false;
for alg in raw.split(',').map(str::trim).filter(|alg| !alg.is_empty()) {
let upper = alg.to_ascii_uppercase();
if upper.starts_with("HS") {
has_hmac = true;
} else if upper.starts_with("RS")
|| upper.starts_with("PS")
|| upper.starts_with("ES")
|| upper == "EDDSA"
{
has_asymmetric = true;
}
}
has_hmac && has_asymmetric
}
fn jwt_allowlist_is_hmac_only(raw: Option<&str>) -> bool {
let Some(raw) = raw else {
return true;
};
let mut has_hmac = false;
for alg in raw.split(',').map(str::trim).filter(|alg| !alg.is_empty()) {
let upper = alg.to_ascii_uppercase();
if upper.starts_with("HS") {
has_hmac = true;
} else if upper.starts_with("RS")
|| upper.starts_with("PS")
|| upper.starts_with("ES")
|| upper == "EDDSA"
{
return false;
}
}
has_hmac
}
fn provider_bundle_uses_jwks() -> bool {
let Ok(Some(raw)) = read_env_or_file("KRAB_JWT_PROVIDERS_JSON") else {
return false;
};
serde_json::from_str::<serde_json::Value>(&raw)
.ok()
.and_then(|value| value.as_array().cloned())
.is_some_and(|providers| {
providers.iter().any(|provider| {
provider
.get("jwks_url")
.and_then(|v| v.as_str())
.is_some_and(|url| !url.trim().is_empty())
})
})
}
pub fn read_env_or_file(name: &str) -> Result<Option<String>> {
if let Some(value) = env_non_empty(name) {
return Ok(Some(value));
}
let file_var = format!("{name}_FILE");
if let Some(path) = env_non_empty(&file_var) {
let raw = fs::read_to_string(&path)
.with_context(|| format!("failed to read {} from file path '{}'", file_var, path))?;
let value = raw.trim().to_string();
anyhow::ensure!(
!value.is_empty(),
"{} points to empty file '{}'",
file_var,
path
);
return Ok(Some(value));
}
let vault_ref_var = format!("{name}_VAULT_REF");
if let Some(vault_ref) = env_non_empty(&vault_ref_var) {
anyhow::bail!(
"{} is set to '{}' but runtime vault resolution is not configured; materialize the secret before startup or provide {} / {}_FILE",
vault_ref_var,
vault_ref,
name,
name
);
}
Ok(None)
}
impl Environment {
pub fn from_env() -> Self {
match std::env::var("KRAB_ENVIRONMENT") {
Ok(v) if v.eq_ignore_ascii_case("dev") || v.eq_ignore_ascii_case("local") => Self::Dev,
Ok(v) if v.eq_ignore_ascii_case("staging") => Self::Staging,
Ok(v) if v.eq_ignore_ascii_case("prod") || v.eq_ignore_ascii_case("production") => {
Self::Prod
}
Ok(v) => Self::Unknown(v),
Err(_) => Self::Dev,
}
}
pub fn as_str(&self) -> &str {
match self {
Self::Dev => "dev",
Self::Staging => "staging",
Self::Prod => "prod",
Self::Unknown(v) => v.as_str(),
}
}
}
#[derive(Debug, Clone)]
pub struct HttpConfig {
pub auth_mode: String,
pub service_auth_scope: String,
pub rate_limit_capacity: u64,
pub rate_limit_refill_per_sec: u64,
pub rate_limit_fail_open: bool,
pub auth_fail_window_secs: u64,
pub auth_fail_threshold: u64,
pub trust_proxy_headers: bool,
pub cors_origins: Vec<String>,
pub cors_allow_any_origin: bool,
}
impl HttpConfig {
pub fn from_env() -> Self {
let environment = Environment::from_env();
let env_bool = |name: &str| {
std::env::var(name)
.map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
.ok()
};
let cors_origins = std::env::var("KRAB_CORS_ORIGINS")
.map(|v| {
v.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
})
.unwrap_or_default();
Self {
auth_mode: std::env::var("KRAB_AUTH_MODE").unwrap_or_else(|_| "jwt".to_string()),
service_auth_scope: std::env::var("KRAB_SERVICE_AUTH_SCOPE")
.unwrap_or_else(|_| "service:internal".to_string()),
rate_limit_capacity: std::env::var("KRAB_RATE_LIMIT_CAPACITY")
.ok()
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(120),
rate_limit_refill_per_sec: std::env::var("KRAB_RATE_LIMIT_REFILL_PER_SEC")
.ok()
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(60),
rate_limit_fail_open: env_bool("KRAB_RATE_LIMIT_FAIL_OPEN")
.unwrap_or(matches!(environment, Environment::Dev)),
auth_fail_window_secs: std::env::var("KRAB_AUTH_FAILURE_WINDOW_SECS")
.ok()
.and_then(|v| v.parse::<u64>().ok())
.filter(|&v| v > 0)
.unwrap_or(60),
auth_fail_threshold: std::env::var("KRAB_AUTH_FAILURE_THRESHOLD")
.ok()
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(100),
trust_proxy_headers: env_bool("KRAB_TRUST_PROXY_HEADERS").unwrap_or(false),
cors_origins,
cors_allow_any_origin: matches!(environment, Environment::Dev),
}
}
}
#[derive(Debug, Clone)]
pub struct KrabConfig {
pub environment: Environment,
pub service_name: String,
pub host: String,
pub port: u16,
pub log_filter: String,
pub http: HttpConfig,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ConfigError {
InvalidPort {
raw: String,
},
}
impl std::fmt::Display for ConfigError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::InvalidPort { raw } => {
write!(f, "invalid KRAB_PORT='{}': expected integer 0-65535", raw)
}
}
}
}
impl std::error::Error for ConfigError {}
fn parse_port_from_env(default_port: u16) -> Result<u16, ConfigError> {
match std::env::var("KRAB_PORT") {
Ok(raw) => {
let trimmed = raw.trim();
if trimmed.is_empty() {
Ok(default_port)
} else {
trimmed
.parse::<u16>()
.map_err(|_| ConfigError::InvalidPort {
raw: trimmed.to_string(),
})
}
}
Err(_) => Ok(default_port),
}
}
impl KrabConfig {
pub fn from_env_checked(
default_service_name: &str,
default_port: u16,
) -> Result<Self, ConfigError> {
let port = parse_port_from_env(default_port)?;
Ok(Self {
environment: Environment::from_env(),
service_name: std::env::var("KRAB_SERVICE_NAME")
.unwrap_or_else(|_| default_service_name.to_string()),
host: std::env::var("KRAB_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
port,
log_filter: std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string()),
http: HttpConfig::from_env(),
})
}
pub fn validate(&self) -> anyhow::Result<()> {
let has_non_empty = |name: &str| !std::env::var(name).unwrap_or_default().trim().is_empty();
match self.environment {
Environment::Dev => return Ok(()),
Environment::Staging | Environment::Prod | Environment::Unknown(_) => {}
}
if self.http.cors_origins.is_empty() {
anyhow::bail!(
"KRAB_CORS_ORIGINS must be explicitly configured in '{}' environment; refusing wildcard CORS",
self.environment.as_str()
);
}
let auth_mode = self.http.auth_mode.as_str();
if auth_mode.eq_ignore_ascii_case("static") {
anyhow::bail!(
"KRAB_AUTH_MODE=static is not allowed in '{}' environment; use KRAB_AUTH_MODE=jwt (or oidc) with provider-based validation",
self.environment.as_str()
);
} else if auth_mode.eq_ignore_ascii_case("jwt") || auth_mode.eq_ignore_ascii_case("oidc") {
let has_provider_json = has_non_empty("KRAB_JWT_PROVIDERS_JSON");
let has_provider_json_file = has_non_empty("KRAB_JWT_PROVIDERS_JSON_FILE");
let has_provider_json_vault_ref = has_non_empty("KRAB_JWT_PROVIDERS_JSON_VAULT_REF");
let token = std::env::var("KRAB_BEARER_TOKEN").unwrap_or_default();
if !token.trim().is_empty() {
anyhow::bail!(
"KRAB_BEARER_TOKEN must be unset/empty in '{}' environment when KRAB_AUTH_MODE={} \
(static bearer tokens are not allowed outside dev)",
self.environment.as_str(),
auth_mode
);
}
let has_keys = has_non_empty("KRAB_JWT_KEYS_JSON");
let has_secret = has_non_empty("KRAB_JWT_SECRET");
let has_keys_file = has_non_empty("KRAB_JWT_KEYS_JSON_FILE");
let has_secret_file = has_non_empty("KRAB_JWT_SECRET_FILE");
let has_keys_vault_ref = has_non_empty("KRAB_JWT_KEYS_JSON_VAULT_REF");
let has_secret_vault_ref = has_non_empty("KRAB_JWT_SECRET_VAULT_REF");
let has_issuer = has_non_empty("KRAB_OIDC_ISSUER");
let has_audience = has_non_empty("KRAB_OIDC_AUDIENCE");
let jwks_url = std::env::var("KRAB_OIDC_JWKS_URL").unwrap_or_default();
let has_jwks_url = !jwks_url.trim().is_empty();
if has_jwks_url && !jwks_url.trim().starts_with("https://") {
anyhow::bail!(
"KRAB_OIDC_JWKS_URL must use https:// in '{}' environment; keys fetched over \
plain HTTP can be substituted by anyone on the path",
self.environment.as_str()
);
}
let has_secure_secret_source =
has_keys_file || has_secret_file || has_keys_vault_ref || has_secret_vault_ref;
if (has_keys || has_secret) && !has_secure_secret_source {
anyhow::bail!(
"In '{}' environment, inline KRAB_JWT_SECRET/KRAB_JWT_KEYS_JSON is forbidden; use *_FILE or *_VAULT_REF secret sourcing",
self.environment.as_str()
);
}
let has_provider_bundle =
has_provider_json || has_provider_json_file || has_provider_json_vault_ref;
let has_fallback_provider_tuple =
(has_keys || has_secret || has_keys_file || has_secret_file || has_jwks_url)
&& has_issuer
&& has_audience;
if !has_provider_bundle && !has_fallback_provider_tuple {
anyhow::bail!(
"JWT/OIDC provider configuration required in '{}' environment; set KRAB_JWT_PROVIDERS_JSON \
or provide KRAB_OIDC_ISSUER + KRAB_OIDC_AUDIENCE + a key source: KRAB_OIDC_JWKS_URL, \
or secure secret sourcing via KRAB_JWT_SECRET_FILE/KRAB_JWT_KEYS_JSON_FILE (or *_VAULT_REF)",
self.environment.as_str()
);
}
if has_provider_bundle {
self.require_issuer_and_audience_in_provider_bundle()?;
}
if let Some(raw) = env_non_empty("KRAB_JWT_ALLOWED_ALGS") {
if jwt_allowlist_mixes_hmac_and_asymmetric(&raw) {
anyhow::bail!(
"KRAB_JWT_ALLOWED_ALGS='{}' mixes HMAC (HS*) and asymmetric \
(RS*/PS*/ES*/EdDSA) algorithm families; split verification across \
providers with distinct key material instead of allowing both \
families against the same keys",
raw
);
}
}
let allowlist = env_non_empty("KRAB_JWT_ALLOWED_ALGS");
if jwt_allowlist_is_hmac_only(allowlist.as_deref())
&& (has_jwks_url || provider_bundle_uses_jwks())
{
anyhow::bail!(
"A JWKS URL is configured (KRAB_OIDC_JWKS_URL or a provider's jwks_url) but \
KRAB_JWT_ALLOWED_ALGS {} allows only HMAC algorithms, which never verify \
against a published key set; set KRAB_JWT_ALLOWED_ALGS to the provider's \
signing algorithms (for example RS256)",
match &allowlist {
Some(raw) => format!("('{raw}')"),
None => "(unset, default HS256)".to_string(),
}
);
}
} else {
anyhow::bail!(
"Unsupported KRAB_AUTH_MODE='{}' in '{}' environment; use jwt or oidc",
auth_mode,
self.environment.as_str()
);
}
Ok(())
}
fn require_issuer_and_audience_in_provider_bundle(&self) -> anyhow::Result<()> {
let raw = match read_env_or_file("KRAB_JWT_PROVIDERS_JSON") {
Ok(Some(raw)) => raw,
Ok(None) => return Ok(()),
Err(err) => {
return Err(err.context(format!(
"KRAB_JWT_PROVIDERS_JSON could not be resolved in '{}' environment",
self.environment.as_str()
)))
}
};
let parsed: serde_json::Value = serde_json::from_str(&raw)
.map_err(|err| anyhow::anyhow!("KRAB_JWT_PROVIDERS_JSON is not valid JSON: {err}"))?;
let providers = parsed
.as_array()
.ok_or_else(|| anyhow::anyhow!("KRAB_JWT_PROVIDERS_JSON must be a JSON array"))?;
for (index, provider) in providers.iter().enumerate() {
let name = provider
.get("name")
.and_then(|v| v.as_str())
.map(ToString::to_string)
.unwrap_or_else(|| format!("#{index}"));
let non_empty = |key: &str| {
provider
.get(key)
.and_then(|v| v.as_str())
.map(str::trim)
.is_some_and(|v| !v.is_empty())
};
if !non_empty("issuer") || !non_empty("audience") {
anyhow::bail!(
"JWT provider '{}' in KRAB_JWT_PROVIDERS_JSON must declare non-empty \
'issuer' and 'audience' in '{}' environment; issuer/audience validation \
only runs when they are configured, so leaving them unset would accept \
tokens from any issuer for any audience",
name,
self.environment.as_str()
);
}
if let Some(url) = provider
.get("jwks_url")
.and_then(|v| v.as_str())
.map(str::trim)
.filter(|v| !v.is_empty())
{
if !url.starts_with("https://") {
anyhow::bail!(
"JWT provider '{}' in KRAB_JWT_PROVIDERS_JSON has a jwks_url that does not \
use https:// in '{}' environment; keys fetched over plain HTTP can be \
substituted by anyone on the path",
name,
self.environment.as_str()
);
}
}
}
Ok(())
}
const SECRET_VARS: &'static [&'static str] = &[
"DATABASE_URL",
"KRAB_REDIS_URL",
"KRAB_SMTP_PASSWORD",
"KRAB_JWT_SECRET",
"KRAB_JWT_KEYS_JSON",
"KRAB_JWT_PROVIDERS_JSON",
"KRAB_BEARER_TOKEN",
];
pub fn validate_secrets_sources(&self) -> SecretsValidationReport {
let mut issues = Vec::new();
for var in Self::SECRET_VARS {
check_secret_source(var, &self.environment, &mut issues);
}
if !matches!(self.environment, Environment::Dev)
&& env_non_empty("KRAB_BEARER_TOKEN").is_some()
{
issues.push(SecretIssue {
var_name: "KRAB_BEARER_TOKEN".to_string(),
policy_rule: "STATIC_TOKEN_IN_NON_DEV".to_string(),
severity: SecretIssueSeverity::Error,
reason: format!(
"KRAB_BEARER_TOKEN must be unset in '{}' environment; \
static bearer tokens are only allowed in dev",
self.environment.as_str()
),
});
}
SecretsValidationReport { issues }
}
pub fn validate_all(&self) -> anyhow::Result<SecretsValidationReport> {
self.validate()?;
let report = self.validate_secrets_sources();
if report.has_errors() {
let first_error = report
.issues
.iter()
.find(|i| i.severity == SecretIssueSeverity::Error)
.unwrap();
anyhow::bail!(
"Secrets policy violation: {} ({})",
first_error.reason,
first_error.policy_rule
);
}
Ok(report)
}
}
#[cfg(test)]
mod tests {
use super::*;
use serial_test::serial;
use std::sync::{Mutex, OnceLock};
static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
fn env_lock() -> std::sync::MutexGuard<'static, ()> {
match ENV_LOCK.get_or_init(|| Mutex::new(())).lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
}
}
fn clear_auth_env() {
for key in [
"KRAB_ENVIRONMENT",
"KRAB_AUTH_MODE",
"KRAB_BEARER_TOKEN",
"KRAB_JWT_SECRET",
"KRAB_JWT_SECRET_FILE",
"KRAB_JWT_SECRET_VAULT_REF",
"KRAB_JWT_KEYS_JSON",
"KRAB_JWT_KEYS_JSON_FILE",
"KRAB_JWT_KEYS_JSON_VAULT_REF",
"KRAB_JWT_PROVIDERS_JSON",
"KRAB_JWT_PROVIDERS_JSON_FILE",
"KRAB_JWT_PROVIDERS_JSON_VAULT_REF",
"KRAB_OIDC_ISSUER",
"KRAB_OIDC_AUDIENCE",
"KRAB_JWT_ALLOWED_ALGS",
"KRAB_CORS_ORIGINS",
"KRAB_TRUST_PROXY_HEADERS",
"KRAB_RATE_LIMIT_FAIL_OPEN",
"KRAB_AUTH_FAILURE_WINDOW_SECS",
"KRAB_AUTH_FAILURE_THRESHOLD",
] {
std::env::remove_var(key);
}
}
#[test]
#[serial]
fn validate_rejects_static_in_non_local_env() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "staging");
std::env::set_var("KRAB_AUTH_MODE", "static");
std::env::set_var("KRAB_BEARER_TOKEN", "token");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(err.contains("KRAB_AUTH_MODE=static is not allowed"));
}
#[test]
#[serial]
fn validate_requires_provider_configuration_in_non_local_jwt_mode() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(err.contains("JWT/OIDC provider configuration required"));
}
#[test]
#[serial]
fn validate_accepts_static_mode_in_dev() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "dev");
std::env::set_var("KRAB_AUTH_MODE", "static");
std::env::set_var("KRAB_BEARER_TOKEN", "token");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
assert!(cfg.validate().is_ok());
}
#[test]
#[serial]
fn validate_accepts_oidc_tuple_in_non_local_env() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "staging");
std::env::set_var("KRAB_AUTH_MODE", "oidc");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_JWT_SECRET_FILE", "/run/secrets/krab_jwt_secret");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
assert!(cfg.validate().is_ok());
}
#[test]
#[serial]
fn validate_rejects_inline_secret_in_non_local_env() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_JWT_SECRET", "secret-inline");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(err.contains("inline KRAB_JWT_SECRET/KRAB_JWT_KEYS_JSON is forbidden"));
}
#[test]
#[serial]
fn validate_rejects_empty_cors_origins_in_staging() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "staging");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_JWT_SECRET_FILE", "/run/secrets/krab_jwt_secret");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(err.contains("KRAB_CORS_ORIGINS must be explicitly configured"));
}
#[test]
#[serial]
fn validate_accepts_a_jwks_url_as_the_key_source_and_requires_https() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var("KRAB_JWT_ALLOWED_ALGS", "RS256");
std::env::set_var("KRAB_OIDC_JWKS_URL", "https://issuer.example.com/jwks");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("valid port");
let accepted = cfg.validate();
std::env::set_var("KRAB_OIDC_JWKS_URL", "http://issuer.example.com/jwks");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("valid port");
let rejected = cfg.validate();
std::env::remove_var("KRAB_OIDC_JWKS_URL");
std::env::remove_var("KRAB_JWT_ALLOWED_ALGS");
assert!(accepted.is_ok(), "{accepted:?}");
assert!(rejected.unwrap_err().to_string().contains("https://"));
}
#[test]
#[serial]
fn validate_rejects_jwks_with_an_hmac_only_allowlist() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var("KRAB_OIDC_JWKS_URL", "https://issuer.example.com/jwks");
let validate = || {
KrabConfig::from_env_checked("users", 3002)
.expect("valid port")
.validate()
};
let default_allowlist = validate();
std::env::set_var("KRAB_JWT_ALLOWED_ALGS", "HS256,HS512");
let explicit_hmac = validate();
std::env::set_var("KRAB_JWT_ALLOWED_ALGS", "RS256");
let asymmetric = validate();
std::env::remove_var("KRAB_OIDC_JWKS_URL");
std::env::remove_var("KRAB_JWT_ALLOWED_ALGS");
std::env::set_var(
"KRAB_JWT_PROVIDERS_JSON",
r#"[{"name":"idp","issuer":"https://i","audience":"a","jwks_url":"https://i/jwks"}]"#,
);
let bundle_default = validate();
std::env::set_var("KRAB_JWT_ALLOWED_ALGS", "RS256");
std::env::set_var(
"KRAB_JWT_PROVIDERS_JSON",
r#"[{"name":"idp","issuer":"https://i","audience":"a","jwks_url":"http://i/jwks"}]"#,
);
let bundle_plain_http = validate();
std::env::remove_var("KRAB_JWT_ALLOWED_ALGS");
std::env::remove_var("KRAB_JWT_PROVIDERS_JSON");
let err = bundle_plain_http.unwrap_err().to_string();
assert!(err.contains("does not use https://"), "{err}");
for result in [&default_allowlist, &explicit_hmac, &bundle_default] {
let err = result.as_ref().unwrap_err().to_string();
assert!(err.contains("allows only HMAC"), "{err}");
}
assert!(asymmetric.is_ok(), "{asymmetric:?}");
}
#[test]
#[serial]
fn local_is_an_alias_of_dev() {
let _guard = env_lock();
for value in ["local", "LOCAL", "Local"] {
std::env::set_var("KRAB_ENVIRONMENT", value);
assert_eq!(Environment::from_env(), Environment::Dev, "{value}");
}
std::env::set_var("KRAB_ENVIRONMENT", "locale");
assert_eq!(
Environment::from_env(),
Environment::Unknown("locale".to_string())
);
std::env::set_var("KRAB_ENVIRONMENT", "local");
std::env::set_var("KRAB_TEST_LOCAL_ALIAS_SECRET", "inline-value");
let mut issues = Vec::new();
check_secret_source(
"KRAB_TEST_LOCAL_ALIAS_SECRET",
&Environment::from_env(),
&mut issues,
);
std::env::remove_var("KRAB_TEST_LOCAL_ALIAS_SECRET");
std::env::remove_var("KRAB_ENVIRONMENT");
assert!(issues.is_empty(), "{issues:?}");
}
#[test]
#[serial]
fn validate_rejects_empty_cors_origins_in_an_unknown_environment() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prdo");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_JWT_SECRET_FILE", "/run/secrets/krab_jwt_secret");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(
err.contains("KRAB_CORS_ORIGINS must be explicitly configured"),
"{err}"
);
}
#[test]
#[serial]
fn validate_accepts_non_empty_cors_origins_in_staging() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "staging");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_JWT_SECRET_FILE", "/run/secrets/krab_jwt_secret");
std::env::set_var(
"KRAB_CORS_ORIGINS",
"https://app.example.com,https://admin.example.com",
);
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
assert!(cfg.validate().is_ok());
}
#[test]
#[serial]
fn from_env_rejects_invalid_port_value() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_PORT", "invalid-port");
let err = KrabConfig::from_env_checked("users", 3002)
.expect_err("invalid KRAB_PORT should return a typed config error");
assert_eq!(
err,
ConfigError::InvalidPort {
raw: "invalid-port".to_string()
}
);
assert!(err.to_string().contains("invalid KRAB_PORT='invalid-port'"));
std::env::remove_var("KRAB_PORT");
}
#[test]
#[serial]
fn from_env_checked_reads_port_and_defaults_service_name() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_PORT", "4711");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
assert_eq!(cfg.port, 4711);
assert_eq!(cfg.service_name, "users");
std::env::remove_var("KRAB_PORT");
}
fn clear_secrets_env() {
clear_auth_env();
for key in [
"DATABASE_URL",
"DATABASE_URL_FILE",
"DATABASE_URL_VAULT_REF",
"KRAB_REDIS_URL",
"KRAB_REDIS_URL_FILE",
"KRAB_REDIS_URL_VAULT_REF",
"KRAB_SMTP_PASSWORD",
"KRAB_SMTP_PASSWORD_FILE",
"KRAB_SMTP_PASSWORD_VAULT_REF",
] {
std::env::remove_var(key);
}
}
#[test]
#[serial]
fn secrets_policy_allows_inline_in_dev() {
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "dev");
std::env::set_var("DATABASE_URL", "postgres://localhost/krab");
std::env::set_var("KRAB_REDIS_URL", "redis://localhost");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let report = cfg.validate_secrets_sources();
assert!(report.is_clean(), "dev should allow inline secrets");
}
#[test]
#[serial]
fn secrets_policy_warns_inline_in_staging() {
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "staging");
std::env::set_var("DATABASE_URL", "postgres://staging/krab");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let report = cfg.validate_secrets_sources();
assert!(!report.is_clean());
assert!(
!report.has_errors(),
"staging inline should warn, not error"
);
let issue = &report.issues[0];
assert_eq!(issue.var_name, "DATABASE_URL");
assert_eq!(issue.policy_rule, "INLINE_SECRET_IN_STAGING");
assert_eq!(issue.severity, SecretIssueSeverity::Warning);
}
#[test]
#[serial]
fn secrets_policy_rejects_inline_in_prod() {
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("DATABASE_URL", "postgres://prod/krab");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let report = cfg.validate_secrets_sources();
assert!(report.has_errors());
let issue = report
.issues
.iter()
.find(|i| i.var_name == "DATABASE_URL")
.expect("expected DATABASE_URL issue");
assert_eq!(issue.policy_rule, "INLINE_SECRET_IN_PROD");
assert_eq!(issue.severity, SecretIssueSeverity::Error);
}
#[test]
#[serial]
fn secrets_policy_accepts_file_sourced_in_prod() {
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("DATABASE_URL_FILE", "/run/secrets/db_url");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let report = cfg.validate_secrets_sources();
let db_issues: Vec<_> = report
.issues
.iter()
.filter(|i| i.var_name == "DATABASE_URL")
.collect();
assert!(
db_issues.is_empty(),
"file-sourced secret should pass in prod"
);
}
#[test]
#[serial]
fn secrets_policy_report_contains_explicit_reasons() {
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("DATABASE_URL", "postgres://prod/krab");
std::env::set_var("KRAB_REDIS_URL", "redis://prod");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let report = cfg.validate_secrets_sources();
assert!(report.issues.len() >= 2);
for issue in &report.issues {
assert!(
!issue.reason.is_empty(),
"every issue must have a human-readable reason"
);
assert!(
!issue.policy_rule.is_empty(),
"every issue must have a machine-readable policy rule"
);
}
}
#[test]
#[serial]
fn read_env_or_file_prefers_inline_value_over_file() {
let _guard = env_lock();
std::env::set_var("KRAB_TEST_SECRET", "inline-secret");
std::env::set_var("KRAB_TEST_SECRET_FILE", "ignored-file-path");
let resolved = read_env_or_file("KRAB_TEST_SECRET").expect("inline secret should resolve");
assert_eq!(resolved.as_deref(), Some("inline-secret"));
std::env::remove_var("KRAB_TEST_SECRET");
std::env::remove_var("KRAB_TEST_SECRET_FILE");
}
#[test]
#[serial]
fn read_env_or_file_reads_file_when_inline_missing() {
let _guard = env_lock();
std::env::remove_var("KRAB_TEST_SECRET");
let path = std::env::current_dir().unwrap().join(format!(
"krab_test_secret_{}_{}.txt",
std::process::id(),
1
));
std::fs::write(&path, "file-secret\n").expect("failed to write temp secret file");
std::env::set_var("KRAB_TEST_SECRET_FILE", path.to_string_lossy().to_string());
let resolved = read_env_or_file("KRAB_TEST_SECRET").expect("file secret should resolve");
assert_eq!(resolved.as_deref(), Some("file-secret"));
std::env::remove_var("KRAB_TEST_SECRET_FILE");
let _ = std::fs::remove_file(path);
}
#[test]
#[serial]
fn read_env_or_file_rejects_empty_file_contents() {
let _guard = env_lock();
std::env::remove_var("KRAB_TEST_SECRET");
let path = std::env::current_dir().unwrap().join(format!(
"krab_test_secret_empty_{}_{}.txt",
std::process::id(),
1
));
std::fs::write(&path, "\n\n").expect("failed to write empty temp secret file");
std::env::set_var("KRAB_TEST_SECRET_FILE", path.to_string_lossy().to_string());
let err = read_env_or_file("KRAB_TEST_SECRET")
.unwrap_err()
.to_string();
assert!(err.contains("KRAB_TEST_SECRET_FILE points to empty file"));
std::env::remove_var("KRAB_TEST_SECRET_FILE");
let _ = std::fs::remove_file(path);
}
#[test]
#[serial]
fn read_env_or_file_rejects_unresolved_vault_ref() {
let _guard = env_lock();
std::env::remove_var("KRAB_TEST_SECRET");
std::env::remove_var("KRAB_TEST_SECRET_FILE");
std::env::set_var("KRAB_TEST_SECRET_VAULT_REF", "vault://kv/krab/test-secret");
let err = read_env_or_file("KRAB_TEST_SECRET")
.unwrap_err()
.to_string();
assert!(err.contains("KRAB_TEST_SECRET_VAULT_REF is set"));
assert!(err.contains("runtime vault resolution is not configured"));
std::env::remove_var("KRAB_TEST_SECRET_VAULT_REF");
}
#[test]
#[serial]
fn validate_all_rejects_prod_inline_secret_even_with_oidc_tuple_present() {
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var("KRAB_JWT_SECRET", "inline-secret");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate_all().unwrap_err().to_string();
assert!(err.contains("inline KRAB_JWT_SECRET/KRAB_JWT_KEYS_JSON is forbidden"));
}
#[test]
#[serial]
fn validate_all_rejects_prod_static_bearer_even_when_file_secret_present() {
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var("KRAB_JWT_SECRET_FILE", "/run/secrets/krab_jwt_secret");
std::env::set_var("KRAB_BEARER_TOKEN", "still-not-allowed");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate_all().unwrap_err().to_string();
assert!(err.contains("KRAB_BEARER_TOKEN must be unset/empty"));
}
#[test]
#[serial]
fn validate_all_rejects_prod_unresolved_provider_vault_ref_without_materialized_secret_source()
{
let _guard = env_lock();
clear_secrets_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var(
"KRAB_JWT_PROVIDERS_JSON_VAULT_REF",
"vault://kv/krab/providers-json",
);
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate_all().unwrap_err().to_string();
assert!(
err.contains("JWT/OIDC provider configuration required")
|| err.contains("Secrets policy violation")
|| err.contains("KRAB_JWT_PROVIDERS_JSON could not be resolved"),
"unexpected error: {err}"
);
}
#[test]
#[serial]
fn validate_rejects_provider_bundle_missing_audience_in_prod() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var(
"KRAB_JWT_PROVIDERS_JSON",
r#"[{"name":"main","issuer":"https://issuer.example.com","keys":{"default":"k"}}]"#,
);
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(
err.contains("must declare non-empty 'issuer' and 'audience'"),
"unexpected error: {err}"
);
}
#[test]
#[serial]
fn validate_rejects_provider_bundle_missing_issuer_in_staging() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "staging");
std::env::set_var("KRAB_AUTH_MODE", "oidc");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var(
"KRAB_JWT_PROVIDERS_JSON",
r#"[{"name":"main","audience":"krab-api","keys":{"default":"k"}}]"#,
);
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(
err.contains("must declare non-empty 'issuer' and 'audience'"),
"unexpected error: {err}"
);
}
#[test]
#[serial]
fn validate_accepts_provider_bundle_with_issuer_and_audience_in_prod() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var(
"KRAB_JWT_PROVIDERS_JSON",
r#"[{"name":"main","issuer":"https://issuer.example.com","audience":"krab-api","keys":{"default":"k"}}]"#,
);
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
assert!(cfg.validate().is_ok());
}
#[test]
fn jwt_allowlist_family_mix_detection() {
use super::jwt_allowlist_mixes_hmac_and_asymmetric as mixed;
assert!(mixed("HS256,RS256"));
assert!(mixed("hs512, es256"));
assert!(mixed("RS384,EdDSA,HS256"));
assert!(!mixed("HS256,HS384"));
assert!(!mixed("RS256,ES256,PS512,EdDSA"));
assert!(!mixed(""));
assert!(!mixed("HS256,garbage"));
assert!(!mixed("garbage,RS256"));
}
#[test]
#[serial]
fn validate_rejects_mixed_algorithm_families_in_prod() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_JWT_SECRET_FILE", "/run/secrets/krab_jwt_secret");
std::env::set_var("KRAB_JWT_ALLOWED_ALGS", "HS256,RS256");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
let err = cfg.validate().unwrap_err().to_string();
assert!(
err.contains("mixes HMAC (HS*) and asymmetric"),
"unexpected error: {err}"
);
}
#[test]
#[serial]
fn validate_accepts_single_family_allowlist_in_prod() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "prod");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var("KRAB_CORS_ORIGINS", "https://app.example.com");
std::env::set_var("KRAB_OIDC_ISSUER", "https://issuer.example.com");
std::env::set_var("KRAB_OIDC_AUDIENCE", "krab-api");
std::env::set_var("KRAB_JWT_SECRET_FILE", "/run/secrets/krab_jwt_secret");
std::env::set_var("KRAB_JWT_ALLOWED_ALGS", "RS256,ES256");
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
assert!(cfg.validate().is_ok());
}
#[test]
#[serial]
fn validate_accepts_provider_bundle_without_issuer_in_dev() {
let _guard = env_lock();
clear_auth_env();
std::env::set_var("KRAB_ENVIRONMENT", "dev");
std::env::set_var("KRAB_AUTH_MODE", "jwt");
std::env::set_var(
"KRAB_JWT_PROVIDERS_JSON",
r#"[{"name":"main","keys":{"default":"k"}}]"#,
);
let cfg = KrabConfig::from_env_checked("users", 3002).expect("test env has a valid port");
assert!(cfg.validate().is_ok());
}
#[test]
#[serial]
fn http_config_reads_auth_failure_knobs() {
let _guard = env_lock();
clear_auth_env();
let cfg = HttpConfig::from_env();
assert_eq!(cfg.auth_fail_window_secs, 60);
assert_eq!(cfg.auth_fail_threshold, 100);
std::env::set_var("KRAB_AUTH_FAILURE_WINDOW_SECS", "30");
std::env::set_var("KRAB_AUTH_FAILURE_THRESHOLD", "15");
let cfg = HttpConfig::from_env();
assert_eq!(cfg.auth_fail_window_secs, 30);
assert_eq!(cfg.auth_fail_threshold, 15);
std::env::set_var("KRAB_AUTH_FAILURE_WINDOW_SECS", "0");
std::env::set_var("KRAB_AUTH_FAILURE_THRESHOLD", "invalid");
let cfg = HttpConfig::from_env();
assert_eq!(cfg.auth_fail_window_secs, 60);
assert_eq!(cfg.auth_fail_threshold, 100);
std::env::set_var("KRAB_AUTH_FAILURE_THRESHOLD", "0");
let cfg = HttpConfig::from_env();
assert_eq!(cfg.auth_fail_threshold, 0);
clear_auth_env();
}
}