use super::{AuthServerConfig, EXTERNAL_LOGIN_ACK, MIN_INTERNAL_API_KEY_LEN};
pub fn is_private_proxy_addr(ip: &std::net::IpAddr) -> bool {
match ip {
std::net::IpAddr::V4(v4) => v4.is_loopback() || v4.is_private() || v4.is_link_local(),
std::net::IpAddr::V6(v6) => {
v6.is_loopback() || v6.is_unique_local() || v6.is_unicast_link_local()
},
}
}
fn env_flag(key: &str) -> Option<bool> {
std::env::var(key)
.ok()
.and_then(|raw| match raw.trim().to_ascii_lowercase().as_str() {
"1" | "true" | "yes" | "on" => Some(true),
"0" | "false" | "no" | "off" => Some(false),
_ => {
tracing::warn!(
env = key,
value = %raw,
"{}", crate::i18n::translate_detail("logs-server-config-unrecognized-boolean", &[])
);
None
},
})
}
fn env_num<T: std::str::FromStr>(key: &str) -> Option<T> {
std::env::var(key).ok().and_then(|raw| match raw.trim().parse::<T>() {
Ok(v) => Some(v),
Err(_) => {
tracing::warn!(env = key, value = %raw, "{}", crate::i18n::translate_detail("logs-server-config-unrecognized-number", &[]));
None
},
})
}
impl AuthServerConfig {
pub fn validate(&self) -> Result<(), String> {
if self.internal_api_key.is_empty() {
return Err("server-internal-api-key-missing::".to_string());
}
let key_too_short = self.internal_api_key.len() < MIN_INTERNAL_API_KEY_LEN;
let login_unacked = self.external_login_enabled
&& !self.external_bind.is_loopback()
&& self.external_login_ack.as_deref() != Some(EXTERNAL_LOGIN_ACK);
if self.strict_security {
if key_too_short {
return Err(format!(
"server-internal-api-key-too-short::{}",
self.internal_api_key.len()
));
}
if login_unacked {
return Err(format!(
"server-external-login-unacknowledged::{}",
self.external_bind
));
}
} else {
if key_too_short {
tracing::warn!(
len = self.internal_api_key.len(),
min = MIN_INTERNAL_API_KEY_LEN,
"{}",
crate::i18n::translate_detail("logs-server-internal-api-key-too-short", &[])
);
}
if login_unacked {
tracing::warn!(
bind = %self.external_bind,
"{}",
crate::i18n::translate_detail(
"logs-server-external-login-unacknowledged",
&[]
)
);
}
if self.external_bind.is_unspecified() || self.internal_bind.is_unspecified() {
tracing::warn!(
external_bind = %self.external_bind,
internal_bind = %self.internal_bind,
"{}",
crate::i18n::translate_detail("logs-server-wildcard-bind-default", &[])
);
}
}
for ip in &self.rate_limit_trusted_proxies {
if !is_private_proxy_addr(ip) {
return Err(format!("server-trusted-proxy-not-private::{}", ip));
}
}
Ok(())
}
}
impl Default for AuthServerConfig {
fn default() -> Self {
Self {
external_port: 8080,
external_bind: std::net::IpAddr::from([0, 0, 0, 0]),
internal_port: 8081,
internal_bind: std::net::IpAddr::from([0, 0, 0, 0]),
external_rate_limit_per_ip: 100,
rate_limit_max_entries: 100_000,
rate_limit_trusted_proxies: Vec::new(),
internal_api_key: String::new(),
external_body_limit: 256 * 1024, internal_body_limit: 1024 * 1024, external_login_enabled: false,
api_key_lockout_threshold: env_num("GARRISON_API_KEY_LOCKOUT_THRESHOLD").unwrap_or(10),
api_key_lockout_window_secs: env_num("GARRISON_API_KEY_LOCKOUT_WINDOW_SECS")
.unwrap_or(300),
health_details_enabled: env_flag("GARRISON_HEALTH_DETAILS").unwrap_or(false),
strict_security: env_flag("GARRISON_STRICT_SECURITY").unwrap_or(false),
external_login_ack: std::env::var("GARRISON_EXTERNAL_LOGIN_ACK")
.ok()
.filter(|s| !s.is_empty()),
}
}
}