guard/tests/manager_security.rs
loki5512344 c1a076a4a3
fix(core): close auth bypass, hangs and memory leaks found by review
Security:
- An empty API_PASSWORD passed validation (only the literal "changeme" was
  rejected) and verify_password("", "") returned true, so a login with an
  empty password minted an admin token. Require >= 16 characters and >= 32
  non-whitespace bytes for JWT_SECRET; verify rejects an empty stored secret.
- syn_challenge_enabled required a real challenge_secret_hex: the public
  placeholder from config.h is now rejected in every spelling.
- docker-compose: Redis/ClickHouse/Grafana are loopback-only and every
  password uses ${VAR:?} instead of a default. An exposed Redis was a way to
  lift bans and publish unbans to the whole fleet with one redis-cli.
- Empty CORS_ORIGIN no longer means "allow any origin".
- ban_cidr / userspace blacklist validate and mask prefixes; CIDR bans are
  stored as ranges, so a /24 or /64 ban actually covers the subnet (before,
  only the network address was blocked).

Availability:
- ClickHouse client has connect/request timeouts and no mutex held across
  await: a hung analytics backend can no longer freeze the ban path. Events
  go through a bounded buffer with a drop counter.
- Redis uses a ConnectionManager with per-command timeouts; pubsub and
  reconcile reset the backoff after success; publish cannot block shutdown.
- Ban durations from pubsub are clamped and use checked_add; the sync task
  survives panics instead of silently dying.
- Blacklist TOCTOU (remove_if) and replace_redis no longer empties the table
  during a Redis reconnect.
- RateLimiter and reputation have hard caps with incremental eviction instead
  of an unbounded DashMap and a stop-the-world retain.
- The attack detector scores before updating its baseline and needs several
  quiet windows to leave UnderAttack, so a sustained flood keeps banning new
  offenders instead of ending after one tick.
- accept() backs off on EMFILE/ENFILE, shutdown Err is treated as shutdown,
  a global semaphore bounds in-flight connections, rate limiting runs before
  PoW, whitelisted IPs are never banned, and connect/handshake/relay have
  timeouts with an idle budget.
- PoW uses the configured difficulty as a floor, the clamp is enforced, and
  nonce framing survives split segments and coalesced handshake bytes.
- Subnet tracker memory is capped (prefixes and per-prefix sources) and the
  monitor bans with the configured TTL.

CI and docs:
- CI runs the test suite with --no-default-features --features protocol-http;
  make ebpf fails on errors; the secrets gate catches weak compose defaults.
- doctor skips protected endpoints without a token and exits non-zero on
  failure; a drain timeout returns exit code 1.
- TODO §2b records the review findings, what is fixed and what is deferred;
  configuration/testing docs describe the new XDP and secret semantics.
2026-11-16 12:06:23 +01:00

124 lines
3.9 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 dashmap::DashMap;
use rampart::manager::api::auth::allow_login_attempt;
use rampart::manager::security::{CorsPolicy, validate_api_password, validate_jwt_secret, verify_password};
use std::net::IpAddr;
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));
}