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:
parent
324ef12b27
commit
e456cb583f
21 changed files with 1377 additions and 180 deletions
282
tests/manager_api.rs
Normal file
282
tests/manager_api.rs
Normal 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)
|
||||
);
|
||||
}
|
||||
|
|
@ -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());
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue