feat(manager): SCAN inventory, pagination, request limits, graceful shutdown

- 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.
This commit is contained in:
Loki 2026-11-16 12:36:29 +01:00
parent 324ef12b27
commit e456cb583f
Signed by: boba
GPG key ID: 6CDE87BC9A778D97
21 changed files with 1377 additions and 180 deletions

282
tests/manager_api.rs Normal file
View file

@ -0,0 +1,282 @@
//! Manager HTTP API contract: authentication, request validation, body limit,
//! per-IP rate limiting, Redis failure mapping and CORS preflight.
//!
//! The tests drive the production router through `tower::ServiceExt::oneshot`,
//! so they exercise the same layer stack as the daemon without opening a
//! listening socket. The Redis URL points at a closed loopback port; no server
//! is started and no external network is used.
#![cfg(feature = "store-redis")]
use axum::{
Router,
body::Body,
extract::ConnectInfo,
http::{Method, Request, StatusCode, header},
};
use dashmap::DashMap;
use rampart::manager::{
AppState,
api::{
blacklist::{DEFAULT_PAGE_LIMIT, ListQuery, MAX_PAGE_LIMIT, MAX_PAGE_OFFSET},
build_router,
guard::RequestGuard,
guard::limit::MUTATION_MAX_ATTEMPTS,
guard::proxy::TrustedProxies,
},
auth::create_token,
security::CorsPolicy,
};
use std::net::SocketAddr;
use std::sync::Arc;
use tower::ServiceExt;
const SECRET: &str = "0123456789abcdef0123456789abcdef";
const AUDIENCE: &str = "rampart";
const PASSWORD: &str = "correct-horse-battery-staple";
const UNREACHABLE_REDIS: &str = "redis://127.0.0.1:1/0";
const LOGIN_BODY: &str = r#"{"password":"wrong-password"}"#;
const BAN_BODY: &str = r#"{"target":"1.2.3.4","type":"ip","reason":"manual_ban"}"#;
fn peer() -> SocketAddr {
SocketAddr::from(([10, 0, 0, 5], 53_000))
}
fn state(redis_url: &str) -> Arc<AppState> {
Arc::new(AppState {
redis_client: redis::Client::open(redis_url).expect("redis URL must parse"),
jwt_secret: SECRET.to_string(),
jwt_audience: AUDIENCE.to_string(),
jwt_expiration: 3600,
api_password: PASSWORD.to_string(),
login_limiter: DashMap::new(),
})
}
/// Builds the production router with no trusted proxy and no CORS layer.
fn app() -> Router {
build_router(
state(UNREACHABLE_REDIS),
Arc::new(RequestGuard::new(TrustedProxies::default())),
None,
)
}
fn request(method: Method, uri: &str, body: Body) -> Request<Body> {
Request::builder()
.method(method)
.uri(uri)
.extension(ConnectInfo(peer()))
.header(header::CONTENT_TYPE, "application/json")
.body(body)
.expect("request must build")
}
fn authorized(mut request: Request<Body>) -> Request<Body> {
let token = create_token(SECRET, 3600, AUDIENCE).expect("token must be created");
request.headers_mut().insert(
header::AUTHORIZATION,
format!("Bearer {token}").parse().expect("header value must be valid"),
);
request
}
async fn status(router: &Router, request: Request<Body>) -> StatusCode {
router
.clone()
.oneshot(request)
.await
.expect("router must answer")
.status()
}
#[tokio::test]
async fn protected_routes_require_a_token() {
let router = app();
for uri in ["/api/v1/servers", "/api/v1/nodes", "/api/v1/blacklist"] {
let response = status(&router, request(Method::GET, uri, Body::empty())).await;
assert_eq!(response, StatusCode::UNAUTHORIZED, "{uri} must reject anonymous access");
}
}
#[tokio::test]
async fn blacklist_rejects_invalid_targets() {
let router = app();
for target in ["not-an-ip", "10.0.0.0/8", "999.1.1.1", ""] {
let body = format!(r#"{{"target":"{target}","type":"ip","reason":"manual_ban"}}"#);
let response = status(
&router,
authorized(request(Method::POST, "/api/v1/blacklist", Body::from(body))),
)
.await;
assert_eq!(response, StatusCode::BAD_REQUEST, "target '{target}' must be rejected");
}
let body = r#"{"target":"300.1.1.1"}"#;
let response = status(
&router,
authorized(request(Method::DELETE, "/api/v1/blacklist", Body::from(body))),
)
.await;
assert_eq!(response, StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn blacklist_rejects_an_overlong_reason() {
let reason = "a".repeat(257);
let body = format!(r#"{{"target":"1.2.3.4","type":"ip","reason":"{reason}"}}"#);
let response = status(
&app(),
authorized(request(Method::POST, "/api/v1/blacklist", Body::from(body))),
)
.await;
assert_eq!(response, StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn oversized_body_is_rejected_before_the_handler() {
let reason = "a".repeat(9 * 1024);
let body = format!(r#"{{"target":"1.2.3.4","type":"ip","reason":"{reason}"}}"#);
let response = status(
&app(),
authorized(request(Method::POST, "/api/v1/blacklist", Body::from(body))),
)
.await;
assert_eq!(response, StatusCode::PAYLOAD_TOO_LARGE);
}
#[tokio::test]
async fn login_is_rate_limited_per_client() {
let router = app();
for attempt in 1..=5 {
let response = status(
&router,
request(Method::POST, "/api/v1/auth/login", Body::from(LOGIN_BODY)),
)
.await;
assert_eq!(
response,
StatusCode::UNAUTHORIZED,
"attempt {attempt} must reach the password check"
);
}
let response = status(
&router,
request(Method::POST, "/api/v1/auth/login", Body::from(LOGIN_BODY)),
)
.await;
assert_eq!(response, StatusCode::TOO_MANY_REQUESTS);
}
#[tokio::test]
async fn mutating_requests_are_rate_limited_per_client() {
let router = app();
for _ in 0..MUTATION_MAX_ATTEMPTS {
let response = status(
&router,
authorized(request(Method::POST, "/api/v1/blacklist", Body::from(BAN_BODY))),
)
.await;
assert_ne!(
response,
StatusCode::TOO_MANY_REQUESTS,
"budget must cover the first window"
);
}
let response = status(
&router,
authorized(request(Method::POST, "/api/v1/blacklist", Body::from(BAN_BODY))),
)
.await;
assert_eq!(response, StatusCode::TOO_MANY_REQUESTS);
}
#[tokio::test]
async fn redis_failure_is_distinguishable_from_an_empty_fleet() {
let router = app();
for uri in ["/api/v1/nodes", "/api/v1/servers", "/api/v1/blacklist"] {
let response = status(&router, authorized(request(Method::GET, uri, Body::empty()))).await;
assert_eq!(
response,
StatusCode::SERVICE_UNAVAILABLE,
"{uri} must report a store failure"
);
}
}
#[tokio::test]
async fn cors_preflight_answers_only_configured_origins() {
let policy = CorsPolicy::parse(Some("https://admin.example")).expect("policy must parse");
let router = build_router(
state(UNREACHABLE_REDIS),
Arc::new(RequestGuard::new(TrustedProxies::default())),
policy.cors_layer(),
);
let allowed = preflight(&router, "https://admin.example").await;
assert_eq!(allowed.status(), StatusCode::OK);
assert_eq!(
allowed
.headers()
.get(header::ACCESS_CONTROL_ALLOW_ORIGIN)
.and_then(|value| value.to_str().ok()),
Some("https://admin.example")
);
let methods = allowed
.headers()
.get(header::ACCESS_CONTROL_ALLOW_METHODS)
.and_then(|value| value.to_str().ok())
.unwrap_or_default();
assert!(methods.contains("POST"), "preflight must advertise the mutating verb");
let denied = preflight(&router, "https://evil.example").await;
assert_eq!(denied.status(), StatusCode::OK);
assert!(denied.headers().get(header::ACCESS_CONTROL_ALLOW_ORIGIN).is_none());
}
async fn preflight(router: &Router, origin: &str) -> axum::response::Response {
let request = Request::builder()
.method(Method::OPTIONS)
.uri("/api/v1/blacklist")
.header(header::ORIGIN, origin)
.header(header::ACCESS_CONTROL_REQUEST_METHOD, "POST")
.extension(ConnectInfo(peer()))
.body(Body::empty())
.expect("preflight request must build");
router.clone().oneshot(request).await.expect("router must answer")
}
#[test]
fn list_query_is_capped_regardless_of_the_request() {
assert_eq!(
ListQuery {
limit: None,
offset: None
}
.bounds(),
(0, DEFAULT_PAGE_LIMIT)
);
assert_eq!(
ListQuery {
limit: Some(5000),
offset: Some(50)
}
.bounds(),
(50, MAX_PAGE_LIMIT)
);
assert_eq!(
ListQuery {
limit: Some(10),
offset: Some(u64::MAX)
}
.bounds(),
(MAX_PAGE_OFFSET, 10)
);
assert_eq!(
ListQuery {
limit: Some(0),
offset: Some(0)
}
.bounds(),
(0, 0)
);
}

View file

@ -3,10 +3,14 @@
//! 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;
use rampart::manager::security::{CorsPolicy, validate_api_password, validate_jwt_secret, verify_password};
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";
@ -122,3 +126,124 @@ fn login_limiter_blocks_after_five_attempts() {
}
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());
}