- Inventory nodes/servers use cursor SCAN plus MGET batches instead of KEYS and per-key GET; a Redis error returns 503 instead of an empty fleet. - GET /blacklist no longer writes: the legacy metadata backfill moved to a one-shot startup task. The list endpoint paginates (limit 100, max 1000, offset max 10000) instead of dumping SMEMBERS. - Router-wide DefaultBodyLimit 8 KiB and TimeoutLayer 10 s; every mutating endpoint is rate limited (30/min per client IP) with idle eviction, and the login limiter resets on success. reason > 256 bytes and malformed targets are rejected with 400. - SIGTERM/Ctrl-C trigger graceful shutdown; the heartbeat and eviction tasks are cancelled and joined so in-flight ban edits reach Redis. - MANAGER_TRUSTED_PROXIES enables X-Forwarded-For (right-to-left walk) only for configured proxy networks; otherwise the TCP peer is used. - tests/manager_api.rs covers 401/400/413/429/503 and CORS preflight through the real router; manager_security gains limiter and proxy-IP tests.
249 lines
8.2 KiB
Rust
249 lines
8.2 KiB
Rust
//! Management-plane security: API password/JWT policy and the CORS downgrade.
|
|
//!
|
|
//! Regression tests for the authentication bypass where an empty
|
|
//! `API_PASSWORD` matched an empty login (`verify_password("", "")`).
|
|
|
|
use axum::http::HeaderValue;
|
|
use dashmap::DashMap;
|
|
use rampart::manager::api::auth::{allow_login_attempt, reset_login_attempts};
|
|
use rampart::manager::api::guard::limit::{LOGIN_MAX_ATTEMPTS, check_attempt, evict_idle};
|
|
use rampart::manager::api::guard::proxy::TrustedProxies;
|
|
use rampart::manager::security::{CorsPolicy, IpNet, validate_api_password, validate_jwt_secret, verify_password};
|
|
use std::net::IpAddr;
|
|
use std::time::Duration;
|
|
|
|
const STRONG_PASSWORD: &str = "correct-horse-battery-staple";
|
|
const STRONG_SECRET: &str = "0123456789abcdef0123456789abcdef";
|
|
|
|
#[test]
|
|
fn rejects_empty_api_password() {
|
|
let err = validate_api_password("").expect_err("empty password must be rejected");
|
|
assert!(err.to_string().contains("must not be empty"));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_whitespace_only_api_password() {
|
|
assert!(validate_api_password(" ").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_short_api_password() {
|
|
let short = "a".repeat(15);
|
|
let err = validate_api_password(&short).expect_err("15 characters must be rejected");
|
|
assert!(err.to_string().contains("at least 16"));
|
|
assert!(validate_api_password(&"a".repeat(16)).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_placeholder_api_password() {
|
|
assert!(validate_api_password("changeme").is_err());
|
|
assert!(validate_api_password("ChangeMe").is_err());
|
|
assert!(validate_api_password(" changeme ").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn accepts_strong_api_password() {
|
|
assert!(validate_api_password(STRONG_PASSWORD).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn empty_stored_password_never_verifies() {
|
|
assert!(!verify_password("", ""));
|
|
assert!(!verify_password("anything", ""));
|
|
}
|
|
|
|
#[test]
|
|
fn verify_password_matches_exact_value_only() {
|
|
assert!(verify_password(STRONG_PASSWORD, STRONG_PASSWORD));
|
|
assert!(!verify_password("wrong-password", STRONG_PASSWORD));
|
|
assert!(!verify_password("short", STRONG_PASSWORD));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_empty_or_short_jwt_secret() {
|
|
assert!(validate_jwt_secret("").is_err());
|
|
assert!(validate_jwt_secret(&" ".repeat(64)).is_err());
|
|
assert!(validate_jwt_secret(&"a".repeat(31)).is_err());
|
|
let err = validate_jwt_secret(" \t\n").expect_err("whitespace must be rejected");
|
|
assert!(err.to_string().contains("non-whitespace"));
|
|
}
|
|
|
|
#[test]
|
|
fn accepts_strong_jwt_secret() {
|
|
assert!(validate_jwt_secret(STRONG_SECRET).is_ok());
|
|
assert!(validate_jwt_secret(&format!(" {STRONG_SECRET} ")).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn cors_without_explicit_origin_is_denied() {
|
|
assert_eq!(CorsPolicy::parse(None).expect("unset is valid"), CorsPolicy::Deny);
|
|
assert_eq!(CorsPolicy::parse(Some("")).expect("empty is valid"), CorsPolicy::Deny);
|
|
assert_eq!(
|
|
CorsPolicy::parse(Some(" ")).expect("blank is valid"),
|
|
CorsPolicy::Deny
|
|
);
|
|
assert!(CorsPolicy::Deny.cors_layer().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn cors_wildcard_requires_explicit_flag() {
|
|
assert_eq!(
|
|
CorsPolicy::parse(Some("*")).expect("wildcard is valid"),
|
|
CorsPolicy::Any
|
|
);
|
|
assert!(CorsPolicy::Any.cors_layer().is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn cors_origin_list_is_trimmed() {
|
|
let policy = CorsPolicy::parse(Some("https://a.example, https://b.example")).expect("list must parse");
|
|
assert_eq!(
|
|
policy,
|
|
CorsPolicy::AllowList(vec!["https://a.example".to_owned(), "https://b.example".to_owned()])
|
|
);
|
|
assert!(policy.cors_layer().is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn cors_rejects_empty_entries_and_mixed_wildcard() {
|
|
assert!(CorsPolicy::parse(Some("https://a.example,")).is_err());
|
|
assert!(CorsPolicy::parse(Some("https://a.example,*")).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn cors_rejects_invalid_header_value() {
|
|
// A newline inside an origin is a header-injection attempt, not a valid value.
|
|
assert!(CorsPolicy::parse(Some("https://evil.example\nSet-Cookie: x")).is_err());
|
|
assert!(CorsPolicy::parse(Some("https://evil.example/\u{7f}")).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn login_limiter_blocks_after_five_attempts() {
|
|
let limiter = DashMap::new();
|
|
let ip = IpAddr::from([127, 0, 0, 1]);
|
|
for _ in 0..5 {
|
|
assert!(allow_login_attempt(&limiter, ip));
|
|
}
|
|
assert!(!allow_login_attempt(&limiter, ip));
|
|
}
|
|
|
|
#[test]
|
|
fn successful_login_resets_the_counter() {
|
|
let limiter = DashMap::new();
|
|
let ip = IpAddr::from([127, 0, 0, 1]);
|
|
for _ in 0..LOGIN_MAX_ATTEMPTS {
|
|
assert!(allow_login_attempt(&limiter, ip));
|
|
}
|
|
assert!(!allow_login_attempt(&limiter, ip));
|
|
|
|
reset_login_attempts(&limiter, ip);
|
|
for _ in 0..LOGIN_MAX_ATTEMPTS {
|
|
assert!(
|
|
allow_login_attempt(&limiter, ip),
|
|
"a successful login must give a fresh budget"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn idle_limiter_entries_are_evicted() {
|
|
let limiter = DashMap::new();
|
|
let first = IpAddr::from([127, 0, 0, 1]);
|
|
let second = IpAddr::from([127, 0, 0, 2]);
|
|
assert!(check_attempt(&limiter, first, Duration::from_secs(60), 5));
|
|
assert!(check_attempt(&limiter, second, Duration::from_secs(60), 5));
|
|
|
|
evict_idle(&limiter, Duration::from_secs(600));
|
|
assert_eq!(limiter.len(), 2, "a live window must survive the sweep");
|
|
|
|
evict_idle(&limiter, Duration::ZERO);
|
|
assert!(limiter.is_empty(), "expired counters must not accumulate forever");
|
|
}
|
|
|
|
#[test]
|
|
fn forwarded_for_is_ignored_from_an_untrusted_peer() {
|
|
let proxies = TrustedProxies::parse("10.0.0.0/8").expect("network must parse");
|
|
let peer: IpAddr = "203.0.113.7".parse().expect("peer must parse");
|
|
let forwarded = HeaderValue::from_static("198.51.100.9");
|
|
assert_eq!(proxies.client_ip(peer, Some(&forwarded)), peer);
|
|
}
|
|
|
|
#[test]
|
|
fn forwarded_for_is_used_from_a_trusted_peer() {
|
|
let proxies = TrustedProxies::parse("10.0.0.0/8,2001:db8::/32").expect("networks must parse");
|
|
let peer: IpAddr = "10.1.2.3".parse().expect("peer must parse");
|
|
let forwarded = HeaderValue::from_static("203.0.113.9");
|
|
assert_eq!(
|
|
proxies.client_ip(peer, Some(&forwarded)),
|
|
"203.0.113.9".parse::<IpAddr>().expect("client must parse")
|
|
);
|
|
let v6_peer: IpAddr = "2001:db8::5".parse().expect("peer must parse");
|
|
assert_eq!(
|
|
proxies.client_ip(v6_peer, Some(&forwarded)),
|
|
"203.0.113.9".parse::<IpAddr>().expect("client must parse")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn forwarded_chain_is_walked_right_to_left() {
|
|
let proxies = TrustedProxies::parse("10.0.0.0/8").expect("network must parse");
|
|
let peer: IpAddr = "10.1.2.3".parse().expect("peer must parse");
|
|
|
|
let chain = HeaderValue::from_static("203.0.113.9, 10.9.9.9");
|
|
assert_eq!(
|
|
proxies.client_ip(peer, Some(&chain)),
|
|
"203.0.113.9".parse::<IpAddr>().expect("client must parse")
|
|
);
|
|
|
|
// The leftmost entry is client supplied: the nearest untrusted hop wins.
|
|
let spoofed = HeaderValue::from_static("1.2.3.4, 198.51.100.7");
|
|
assert_eq!(
|
|
proxies.client_ip(peer, Some(&spoofed)),
|
|
"198.51.100.7".parse::<IpAddr>().expect("client must parse")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_forwarded_chain_falls_back_to_the_peer() {
|
|
let proxies = TrustedProxies::parse("10.0.0.0/8").expect("network must parse");
|
|
let peer: IpAddr = "10.1.2.3".parse().expect("peer must parse");
|
|
assert_eq!(proxies.client_ip(peer, None), peer);
|
|
let garbage = HeaderValue::from_static("not-an-address");
|
|
assert_eq!(proxies.client_ip(peer, Some(&garbage)), peer);
|
|
}
|
|
|
|
#[test]
|
|
fn trusted_proxy_list_rejects_malformed_entries() {
|
|
assert!(
|
|
!TrustedProxies::parse("")
|
|
.expect("empty is valid")
|
|
.is_trusted("10.0.0.1".parse().expect("ip"))
|
|
);
|
|
assert!(TrustedProxies::parse("10.0.0.0/8,").is_err());
|
|
assert!(TrustedProxies::parse("10.0.0.0/33").is_err());
|
|
assert!(TrustedProxies::parse("not-a-network").is_err());
|
|
assert!(TrustedProxies::parse("::/129").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn ip_net_matches_the_configured_prefix() {
|
|
let network = IpNet::parse("192.168.1.0/24").expect("network must parse");
|
|
assert!(network.contains("192.168.1.200".parse().expect("ip")));
|
|
assert!(!network.contains("192.168.2.1".parse().expect("ip")));
|
|
assert!(!network.contains("::ffff:192.168.1.1".parse().expect("ip")));
|
|
|
|
let host = IpNet::parse("192.168.1.5").expect("host route must parse");
|
|
assert!(host.contains("192.168.1.5".parse().expect("ip")));
|
|
assert!(!host.contains("192.168.1.6".parse().expect("ip")));
|
|
|
|
let v6 = IpNet::parse("2001:db8::/32").expect("network must parse");
|
|
assert!(v6.contains("2001:db8::1".parse().expect("ip")));
|
|
assert!(!v6.contains("2001:db9::1".parse().expect("ip")));
|
|
|
|
assert!(
|
|
IpNet::parse("0.0.0.0/0")
|
|
.expect("default route must parse")
|
|
.contains("203.0.113.1".parse().expect("ip"))
|
|
);
|
|
assert!(IpNet::parse("bad").is_err());
|
|
}
|