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
3
Cargo.lock
generated
3
Cargo.lock
generated
|
|
@ -2110,6 +2110,7 @@ dependencies = [
|
||||||
"tokio",
|
"tokio",
|
||||||
"tokio-splice",
|
"tokio-splice",
|
||||||
"toml",
|
"toml",
|
||||||
|
"tower",
|
||||||
"tower-http 0.7.1",
|
"tower-http 0.7.1",
|
||||||
"tracing",
|
"tracing",
|
||||||
"tracing-subscriber",
|
"tracing-subscriber",
|
||||||
|
|
@ -3201,8 +3202,10 @@ dependencies = [
|
||||||
"bitflags 2.13.2",
|
"bitflags 2.13.2",
|
||||||
"bytes",
|
"bytes",
|
||||||
"http",
|
"http",
|
||||||
|
"http-body",
|
||||||
"percent-encoding",
|
"percent-encoding",
|
||||||
"pin-project-lite",
|
"pin-project-lite",
|
||||||
|
"tokio",
|
||||||
"tower-layer",
|
"tower-layer",
|
||||||
"tower-service",
|
"tower-service",
|
||||||
]
|
]
|
||||||
|
|
|
||||||
|
|
@ -68,7 +68,7 @@ ratatui = "0.30"
|
||||||
crossterm = "0.29"
|
crossterm = "0.29"
|
||||||
|
|
||||||
axum = "0.8"
|
axum = "0.8"
|
||||||
tower-http = { version = "0.7", features = ["cors"] }
|
tower-http = { version = "0.7", features = ["cors", "timeout"] }
|
||||||
jsonwebtoken = { version = "11", features = ["aws_lc_rs"] }
|
jsonwebtoken = { version = "11", features = ["aws_lc_rs"] }
|
||||||
|
|
||||||
redis = { version = "1.7", optional = true, features = ["tokio-comp", "connection-manager"] }
|
redis = { version = "1.7", optional = true, features = ["tokio-comp", "connection-manager"] }
|
||||||
|
|
@ -76,3 +76,7 @@ maxminddb = { version = "0.32", optional = true }
|
||||||
tokio-splice = { version = "0.2", optional = true }
|
tokio-splice = { version = "0.2", optional = true }
|
||||||
libbpf-rs = { version = "0.27", optional = true }
|
libbpf-rs = { version = "0.27", optional = true }
|
||||||
libc = { version = "0.2", optional = true }
|
libc = { version = "0.2", optional = true }
|
||||||
|
|
||||||
|
[dev-dependencies]
|
||||||
|
# `ServiceExt::oneshot` drives the axum router in integration tests.
|
||||||
|
tower = { version = "0.5", features = ["util"] }
|
||||||
|
|
|
||||||
31
docs/api.md
31
docs/api.md
|
|
@ -64,6 +64,8 @@ Authorization: Bearer <token>
|
||||||
|
|
||||||
### `GET /api/v1/blacklist` 🔒
|
### `GET /api/v1/blacklist` 🔒
|
||||||
|
|
||||||
|
Query: `limit` (по умолчанию 100, максимум 1000) и `offset` (максимум 10000).
|
||||||
|
|
||||||
```json
|
```json
|
||||||
{
|
{
|
||||||
"items": [
|
"items": [
|
||||||
|
|
@ -75,9 +77,16 @@ Authorization: Bearer <token>
|
||||||
```
|
```
|
||||||
|
|
||||||
Источник: Redis set `rampart:blacklist` и hash `rampart:blacklist:metadata`.
|
Источник: Redis set `rampart:blacklist` и hash `rampart:blacklist:metadata`.
|
||||||
|
Записи читаются через `SSCAN` порциями, поэтому set никогда не выгружается целиком;
|
||||||
|
порядок страниц не определён (Redis set) и при параллельных изменениях страницы
|
||||||
|
могут пересекаться. `total` — размер set по `SCARD`, он может включать истёкшие
|
||||||
|
записи, которые API скрывает в `items`.
|
||||||
|
|
||||||
Метаданные содержат причину, время создания и абсолютный срок истечения; API
|
Метаданные содержат причину, время создания и абсолютный срок истечения; API
|
||||||
скрывает истёкшие записи. Старые set-записи без метаданных получают один
|
скрывает истёкшие записи. `GET` ничего не пишет в Redis: старые set-записи без
|
||||||
ограниченный срок в пять минут при первом чтении или восстановлении edge.
|
метаданных показываются с временной записью «пять минут» только для чтения, а
|
||||||
|
сама метаданные восстанавливаются одноразовым фоновым backfill при старте
|
||||||
|
manager (или при восстановлении снимка edge).
|
||||||
|
|
||||||
### `POST /api/v1/blacklist` 🔒
|
### `POST /api/v1/blacklist` 🔒
|
||||||
|
|
||||||
|
|
@ -89,6 +98,9 @@ Authorization: Bearer <token>
|
||||||
// с duration_secs и expires_at_unix опубликовано в rampart:blacklist:events.
|
// с duration_secs и expires_at_unix опубликовано в rampart:blacklist:events.
|
||||||
```
|
```
|
||||||
|
|
||||||
|
`target` — одиночный IPv4/IPv6-адрес (CIDR не поддерживается), `reason` — не
|
||||||
|
длиннее 256 байт; иначе `400 Bad Request`.
|
||||||
|
|
||||||
Edge подписывается на Pub/Sub перед загрузкой снимка из Redis. Поэтому события,
|
Edge подписывается на Pub/Sub перед загрузкой снимка из Redis. Поэтому события,
|
||||||
пришедшие во время загрузки, будут применены после снимка. При старте и после
|
пришедшие во время загрузки, будут применены после снимка. При старте и после
|
||||||
переподключения активные Redis-баны восстанавливаются с оставшимся TTL; новые
|
переподключения активные Redis-баны восстанавливаются с оставшимся TTL; новые
|
||||||
|
|
@ -112,6 +124,9 @@ Edge подписывается на Pub/Sub перед загрузкой сн
|
||||||
|
|
||||||
Список зарегистрированных edge-нод из Redis (`rampart:nodes:*`, heartbeat).
|
Список зарегистрированных edge-нод из Redis (`rampart:nodes:*`, heartbeat).
|
||||||
|
|
||||||
|
Если Redis недоступен, API возвращает `503 Service Unavailable`; пустой массив
|
||||||
|
означает исправное, но пустое окружение.
|
||||||
|
|
||||||
```json
|
```json
|
||||||
{
|
{
|
||||||
"nodes": [
|
"nodes": [
|
||||||
|
|
@ -129,8 +144,16 @@ Edge подписывается на Pub/Sub перед загрузкой сн
|
||||||
|
|
||||||
- drain нод через API или CLI;
|
- drain нод через API или CLI;
|
||||||
- webhooks, metrics summary, challenge management;
|
- webhooks, metrics summary, challenge management;
|
||||||
- регистрации нод через `POST /api/v1/nodes`;
|
- регистрации нод через `POST /api/v1/nodes`.
|
||||||
- rate limiting на сами запросы API (кроме login).
|
|
||||||
|
## Ограничения запросов
|
||||||
|
|
||||||
|
- Тело запроса — не больше 8 КиБ (`413`), любой запрос — не дольше 10 секунд.
|
||||||
|
- `/api/v1/auth/login` — 5 попыток в минуту с одного клиентского адреса (`429`).
|
||||||
|
- `POST`/`DELETE /api/v1/blacklist` (и любые будущие mutating-методы) — 30 запросов
|
||||||
|
в минуту с одного клиентского адреса (`429`); успешный login сбрасывает счётчик.
|
||||||
|
- Клиентский адрес — TCP peer, если запрос не пришёл с сети из
|
||||||
|
`MANAGER_TRUSTED_PROXIES`; только тогда используется `X-Forwarded-For`.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,14 +1,17 @@
|
||||||
//! Rampart manager daemon: HTTP API in front of the redis state store.
|
//! Rampart manager daemon: HTTP API in front of the redis state store.
|
||||||
|
|
||||||
use axum::{
|
|
||||||
Router, middleware,
|
|
||||||
routing::{get, post},
|
|
||||||
};
|
|
||||||
use dashmap::DashMap;
|
use dashmap::DashMap;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
|
use rampart::manager::api;
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
use rampart::manager::sync;
|
use rampart::manager::sync;
|
||||||
use rampart::manager::{AppState, api, auth, security};
|
use rampart::manager::{
|
||||||
|
AppState, SharedState,
|
||||||
|
api::{build_router, guard},
|
||||||
|
security,
|
||||||
|
};
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
|
use tokio::sync::watch;
|
||||||
use tracing_subscriber::EnvFilter;
|
use tracing_subscriber::EnvFilter;
|
||||||
|
|
||||||
#[tokio::main]
|
#[tokio::main]
|
||||||
|
|
@ -39,7 +42,7 @@ async fn main() -> anyhow::Result<()> {
|
||||||
let api_password = std::env::var("API_PASSWORD").map_err(|_| anyhow::anyhow!("API_PASSWORD must be set"))?;
|
let api_password = std::env::var("API_PASSWORD").map_err(|_| anyhow::anyhow!("API_PASSWORD must be set"))?;
|
||||||
security::validate_api_password(&api_password)?;
|
security::validate_api_password(&api_password)?;
|
||||||
|
|
||||||
let state = Arc::new(AppState {
|
let state: SharedState = Arc::new(AppState {
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
redis_client,
|
redis_client,
|
||||||
jwt_secret,
|
jwt_secret,
|
||||||
|
|
@ -48,41 +51,77 @@ async fn main() -> anyhow::Result<()> {
|
||||||
api_password,
|
api_password,
|
||||||
login_limiter: DashMap::new(),
|
login_limiter: DashMap::new(),
|
||||||
});
|
});
|
||||||
|
let guard = Arc::new(guard::RequestGuard::from_env()?);
|
||||||
|
|
||||||
|
// Background tasks share one shutdown signal, so SIGTERM stops them together
|
||||||
|
// with the HTTP server instead of leaving detached tasks behind.
|
||||||
|
let (shutdown_tx, shutdown_rx) = watch::channel(false);
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
tokio::spawn(sync::heartbeat::start_heartbeat_check(state.clone()));
|
let heartbeat = spawn_heartbeat(state.clone(), shutdown_rx.clone());
|
||||||
|
let eviction = guard::spawn_eviction(state.clone(), guard.clone(), shutdown_rx.clone());
|
||||||
let public = Router::new()
|
// One-shot legacy migration; losing it on shutdown is harmless because the
|
||||||
.route("/api/v1/health", get(api::inventory::health::health_check))
|
// read path no longer depends on the metadata being present.
|
||||||
.route("/api/v1/auth/login", post(api::auth::login));
|
|
||||||
|
|
||||||
// Redis-backed routes only exist together with the feature; the manager bails
|
|
||||||
// out above without it, so 501 stubs here would be unreachable code.
|
|
||||||
let protected = Router::new();
|
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
let protected = protected
|
tokio::spawn(api::blacklist::backfill_legacy_metadata(state.clone()));
|
||||||
.route("/api/v1/servers", get(api::inventory::servers::list_servers))
|
|
||||||
.route(
|
|
||||||
"/api/v1/blacklist",
|
|
||||||
get(api::blacklist::list_blacklist)
|
|
||||||
.post(api::blacklist::add_blacklist)
|
|
||||||
.delete(api::blacklist::remove_blacklist),
|
|
||||||
)
|
|
||||||
.route("/api/v1/nodes", get(api::inventory::nodes::list_nodes));
|
|
||||||
let protected = protected.route_layer(middleware::from_fn_with_state(state.clone(), auth::auth_middleware));
|
|
||||||
|
|
||||||
let cors_policy = security::CorsPolicy::parse(std::env::var("CORS_ORIGIN").ok().as_deref())?;
|
let cors_policy = security::CorsPolicy::parse(std::env::var("CORS_ORIGIN").ok().as_deref())?;
|
||||||
tracing::info!("CORS policy: {cors_policy:?}");
|
tracing::info!("CORS policy: {cors_policy:?}");
|
||||||
|
|
||||||
let mut app = Router::new().merge(public).merge(protected).with_state(state);
|
let app = build_router(state, guard, cors_policy.cors_layer());
|
||||||
if let Some(cors) = cors_policy.cors_layer() {
|
|
||||||
app = app.layer(cors);
|
|
||||||
}
|
|
||||||
|
|
||||||
let addr = "0.0.0.0:8080";
|
let addr = "0.0.0.0:8080";
|
||||||
tracing::info!("Manager API listening on {addr}");
|
|
||||||
let listener = tokio::net::TcpListener::bind(addr).await?;
|
let listener = tokio::net::TcpListener::bind(addr).await?;
|
||||||
|
tracing::info!("Manager API listening on {addr}");
|
||||||
let app = app.into_make_service_with_connect_info::<std::net::SocketAddr>();
|
let app = app.into_make_service_with_connect_info::<std::net::SocketAddr>();
|
||||||
axum::serve(listener, app).await?;
|
|
||||||
|
// Graceful shutdown drains in-flight requests, so a ban removal that already
|
||||||
|
// reached a handler is written to Redis before the process exits.
|
||||||
|
axum::serve(listener, app)
|
||||||
|
.with_graceful_shutdown(shutdown_signal())
|
||||||
|
.await?;
|
||||||
|
|
||||||
|
let _ = shutdown_tx.send(true);
|
||||||
|
let _ = eviction.await;
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
let _ = heartbeat.await;
|
||||||
|
tracing::info!("manager stopped");
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Spawns the heartbeat check loop and stops it on the shared shutdown signal.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
fn spawn_heartbeat(state: SharedState, mut shutdown: watch::Receiver<bool>) -> tokio::task::JoinHandle<()> {
|
||||||
|
tokio::spawn(async move {
|
||||||
|
tokio::select! {
|
||||||
|
() = sync::heartbeat::start_heartbeat_check(state) => {},
|
||||||
|
_ = shutdown.changed() => {},
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resolves on `SIGTERM` or Ctrl-C, whichever arrives first.
|
||||||
|
async fn shutdown_signal() {
|
||||||
|
let ctrl_c = async {
|
||||||
|
if let Err(error) = tokio::signal::ctrl_c().await {
|
||||||
|
tracing::error!("failed to listen for Ctrl-C: {error}");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
#[cfg(unix)]
|
||||||
|
let terminate = async {
|
||||||
|
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) {
|
||||||
|
Ok(mut signal) => {
|
||||||
|
signal.recv().await;
|
||||||
|
},
|
||||||
|
Err(error) => {
|
||||||
|
tracing::error!("failed to listen for SIGTERM: {error}");
|
||||||
|
std::future::pending::<()>().await;
|
||||||
|
},
|
||||||
|
}
|
||||||
|
};
|
||||||
|
#[cfg(not(unix))]
|
||||||
|
let terminate = std::future::pending::<()>();
|
||||||
|
tokio::select! {
|
||||||
|
() = ctrl_c => {},
|
||||||
|
() = terminate => {},
|
||||||
|
}
|
||||||
|
tracing::info!("shutdown signal received: draining in-flight requests");
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,10 +1,11 @@
|
||||||
//! `POST /api/v1/auth/login`: password check with a per-IP attempt limiter.
|
//! `POST /api/v1/auth/login`: password check with a per-IP attempt limiter.
|
||||||
|
|
||||||
use crate::manager::AppState;
|
use crate::manager::AppState;
|
||||||
|
use crate::manager::api::guard::{RequestGuard, limit};
|
||||||
use axum::{
|
use axum::{
|
||||||
Json,
|
Extension, Json,
|
||||||
extract::{ConnectInfo, State},
|
extract::{ConnectInfo, State},
|
||||||
http::StatusCode,
|
http::{HeaderMap, StatusCode},
|
||||||
};
|
};
|
||||||
use dashmap::DashMap;
|
use dashmap::DashMap;
|
||||||
use serde::Deserialize;
|
use serde::Deserialize;
|
||||||
|
|
@ -14,20 +15,30 @@ use std::{
|
||||||
time::{Duration, Instant},
|
time::{Duration, Instant},
|
||||||
};
|
};
|
||||||
|
|
||||||
const LOGIN_WINDOW: Duration = Duration::from_secs(60);
|
/// Window of the login limiter, exported for the eviction sweep.
|
||||||
const LOGIN_MAX_ATTEMPTS: u32 = 5;
|
pub const LOGIN_WINDOW: Duration = limit::LOGIN_WINDOW;
|
||||||
|
/// Login attempts allowed per window and source address.
|
||||||
|
pub const LOGIN_MAX_ATTEMPTS: u32 = limit::LOGIN_MAX_ATTEMPTS;
|
||||||
|
|
||||||
#[derive(Deserialize)]
|
#[derive(Deserialize)]
|
||||||
pub struct LoginRequest {
|
pub struct LoginRequest {
|
||||||
pub password: String,
|
pub password: String,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Verifies the API password and returns a bearer token.
|
||||||
|
///
|
||||||
|
/// The client address comes from [`RequestGuard`]: the transport peer unless a
|
||||||
|
/// trusted reverse proxy forwarded the request. The attempt counter is reset
|
||||||
|
/// after a successful login so a legitimate administrator starts clean.
|
||||||
pub async fn login(
|
pub async fn login(
|
||||||
State(state): State<Arc<AppState>>,
|
State(state): State<Arc<AppState>>,
|
||||||
ConnectInfo(addr): ConnectInfo<SocketAddr>,
|
ConnectInfo(addr): ConnectInfo<SocketAddr>,
|
||||||
|
Extension(guard): Extension<Arc<RequestGuard>>,
|
||||||
|
headers: HeaderMap,
|
||||||
Json(req): Json<LoginRequest>,
|
Json(req): Json<LoginRequest>,
|
||||||
) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
|
) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
|
||||||
if !allow_login_attempt(&state.login_limiter, addr.ip()) {
|
let ip = guard.client_ip(addr.ip(), &headers);
|
||||||
|
if !allow_login_attempt(&state.login_limiter, ip) {
|
||||||
return Err((
|
return Err((
|
||||||
StatusCode::TOO_MANY_REQUESTS,
|
StatusCode::TOO_MANY_REQUESTS,
|
||||||
Json(serde_json::json!({"error": "too many requests"})),
|
Json(serde_json::json!({"error": "too many requests"})),
|
||||||
|
|
@ -40,6 +51,7 @@ pub async fn login(
|
||||||
Json(serde_json::json!({"error": "invalid password"})),
|
Json(serde_json::json!({"error": "invalid password"})),
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
reset_login_attempts(&state.login_limiter, ip);
|
||||||
|
|
||||||
match crate::manager::auth::create_token(&state.jwt_secret, state.jwt_expiration, &state.jwt_audience) {
|
match crate::manager::auth::create_token(&state.jwt_secret, state.jwt_expiration, &state.jwt_audience) {
|
||||||
Ok(token) => Ok(Json(serde_json::json!({"token": token}))),
|
Ok(token) => Ok(Json(serde_json::json!({"token": token}))),
|
||||||
|
|
@ -52,19 +64,13 @@ pub async fn login(
|
||||||
|
|
||||||
/// Records a login attempt for `ip` and reports whether it is within the window.
|
/// Records a login attempt for `ip` and reports whether it is within the window.
|
||||||
///
|
///
|
||||||
/// The limiter allows `LOGIN_MAX_ATTEMPTS` attempts per `LOGIN_WINDOW` and
|
/// The limiter allows [`LOGIN_MAX_ATTEMPTS`] attempts per [`LOGIN_WINDOW`] and
|
||||||
/// resets the counter when the window elapses.
|
/// resets the counter when the window elapses.
|
||||||
pub fn allow_login_attempt(limiter: &DashMap<IpAddr, (Instant, u32)>, ip: IpAddr) -> bool {
|
pub fn allow_login_attempt(limiter: &DashMap<IpAddr, (Instant, u32)>, ip: IpAddr) -> bool {
|
||||||
let now = Instant::now();
|
limit::check_attempt(limiter, ip, LOGIN_WINDOW, LOGIN_MAX_ATTEMPTS)
|
||||||
let mut slot = limiter.entry(ip).or_insert((now, 0));
|
}
|
||||||
let (last_reset, attempts) = &mut *slot;
|
|
||||||
if now.duration_since(*last_reset) >= LOGIN_WINDOW {
|
/// Clears the login counter of `ip` after a successful authentication.
|
||||||
*last_reset = now;
|
pub fn reset_login_attempts(limiter: &DashMap<IpAddr, (Instant, u32)>, ip: IpAddr) {
|
||||||
*attempts = 1;
|
limit::reset_attempts(limiter, ip);
|
||||||
} else if *attempts >= LOGIN_MAX_ATTEMPTS {
|
|
||||||
return false;
|
|
||||||
} else {
|
|
||||||
*attempts += 1;
|
|
||||||
}
|
|
||||||
true
|
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,14 @@
|
||||||
|
//! Blacklist endpoints: paginated listing plus add and remove mutations.
|
||||||
|
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
/// Entries returned when the request does not set `limit`.
|
||||||
|
pub const DEFAULT_PAGE_LIMIT: u64 = 100;
|
||||||
|
/// Upper bound of `limit`, independent of the request.
|
||||||
|
pub const MAX_PAGE_LIMIT: u64 = 1000;
|
||||||
|
/// Upper bound of `offset`, which bounds the work of a single request.
|
||||||
|
pub const MAX_PAGE_OFFSET: u64 = 10_000;
|
||||||
|
|
||||||
#[derive(Debug, Serialize, Deserialize)]
|
#[derive(Debug, Serialize, Deserialize)]
|
||||||
pub struct BlacklistEntry {
|
pub struct BlacklistEntry {
|
||||||
pub target: String,
|
pub target: String,
|
||||||
|
|
@ -13,11 +22,10 @@ pub struct BlacklistEntry {
|
||||||
#[derive(Serialize)]
|
#[derive(Serialize)]
|
||||||
pub struct BlacklistResponse {
|
pub struct BlacklistResponse {
|
||||||
pub items: Vec<BlacklistEntry>,
|
pub items: Vec<BlacklistEntry>,
|
||||||
pub total: usize,
|
pub total: u64,
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Deserialize)]
|
#[derive(Deserialize)]
|
||||||
#[allow(dead_code)]
|
|
||||||
pub struct AddBlacklistRequest {
|
pub struct AddBlacklistRequest {
|
||||||
pub target: String,
|
pub target: String,
|
||||||
#[serde(rename = "type")]
|
#[serde(rename = "type")]
|
||||||
|
|
@ -31,6 +39,29 @@ pub struct RemoveBlacklistRequest {
|
||||||
pub target: String,
|
pub target: String,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// `limit`/`offset` query parameters of the list endpoint.
|
||||||
|
#[derive(Debug, Default, Deserialize)]
|
||||||
|
pub struct ListQuery {
|
||||||
|
pub limit: Option<u64>,
|
||||||
|
pub offset: Option<u64>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ListQuery {
|
||||||
|
/// Resolves the request into `(offset, limit)` inside the hard bounds.
|
||||||
|
///
|
||||||
|
/// Missing values use [`DEFAULT_PAGE_LIMIT`] and zero, a too-large `limit`
|
||||||
|
/// is clamped to [`MAX_PAGE_LIMIT`] and a too-large `offset` to
|
||||||
|
/// [`MAX_PAGE_OFFSET`], so no request can ask for the whole set.
|
||||||
|
#[must_use]
|
||||||
|
pub fn bounds(&self) -> (u64, u64) {
|
||||||
|
let limit = self.limit.unwrap_or(DEFAULT_PAGE_LIMIT).min(MAX_PAGE_LIMIT);
|
||||||
|
let offset = self.offset.unwrap_or(0).min(MAX_PAGE_OFFSET);
|
||||||
|
(offset, limit)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
mod backfill;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
mod common;
|
mod common;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
|
|
@ -38,6 +69,8 @@ mod list;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
mod mutate;
|
mod mutate;
|
||||||
|
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
pub use backfill::backfill_legacy_metadata;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
pub use list::list_blacklist;
|
pub use list::list_blacklist;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
|
|
|
||||||
82
src/manager/api/blacklist/backfill.rs
Normal file
82
src/manager/api/blacklist/backfill.rs
Normal file
|
|
@ -0,0 +1,82 @@
|
||||||
|
//! One-shot startup backfill of legacy blacklist metadata.
|
||||||
|
//!
|
||||||
|
//! Older managers wrote `rampart:blacklist` members without a record in
|
||||||
|
//! `rampart:blacklist:metadata`. The read path is side-effect free now, so the
|
||||||
|
//! repair happens once at startup instead of on every `GET`: set members are
|
||||||
|
//! iterated with SSCAN, read in HMGET batches and filled with HSETNX, which
|
||||||
|
//! never overwrites metadata written by a concurrent add.
|
||||||
|
|
||||||
|
use super::common::{
|
||||||
|
BLACKLIST_KEY, BLACKLIST_METADATA_KEY, PAGE_SCAN_BATCH, legacy_metadata, redis_error, redis_unavailable,
|
||||||
|
};
|
||||||
|
use crate::manager::{AppState, SharedState};
|
||||||
|
use axum::{Json, http::StatusCode};
|
||||||
|
use std::net::IpAddr;
|
||||||
|
|
||||||
|
type ApiResult<T> = Result<T, (StatusCode, Json<serde_json::Value>)>;
|
||||||
|
|
||||||
|
/// Repairs legacy members in the background; failures are logged, not fatal.
|
||||||
|
pub async fn backfill_legacy_metadata(state: SharedState) {
|
||||||
|
match backfill(&state).await {
|
||||||
|
Ok(0) => {},
|
||||||
|
Ok(filled) => tracing::info!("blacklist metadata backfill repaired {filled} legacy entries"),
|
||||||
|
Err((_, Json(body))) => tracing::warn!("blacklist metadata backfill skipped: {body}"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Walks the ban set and persists fallback metadata for members without any.
|
||||||
|
///
|
||||||
|
/// Returns the number of repaired members. A Redis failure aborts the run: the
|
||||||
|
/// next manager start retries, and the read path keeps serving meanwhile.
|
||||||
|
async fn backfill(state: &AppState) -> ApiResult<usize> {
|
||||||
|
let mut conn = state
|
||||||
|
.redis_client
|
||||||
|
.get_multiplexed_async_connection()
|
||||||
|
.await
|
||||||
|
.map_err(redis_unavailable)?;
|
||||||
|
let now = chrono::Utc::now().timestamp();
|
||||||
|
let mut cursor = 0_u64;
|
||||||
|
let mut filled = 0_usize;
|
||||||
|
loop {
|
||||||
|
let (next, members): (u64, Vec<String>) = redis::cmd("SSCAN")
|
||||||
|
.arg(BLACKLIST_KEY)
|
||||||
|
.arg(cursor)
|
||||||
|
.arg("COUNT")
|
||||||
|
.arg(PAGE_SCAN_BATCH)
|
||||||
|
.query_async(&mut conn)
|
||||||
|
.await
|
||||||
|
.map_err(redis_error)?;
|
||||||
|
let targets: Vec<String> = members
|
||||||
|
.into_iter()
|
||||||
|
.filter(|target| target.parse::<IpAddr>().is_ok())
|
||||||
|
.collect();
|
||||||
|
if !targets.is_empty() {
|
||||||
|
let existing: Vec<Option<String>> = redis::cmd("HMGET")
|
||||||
|
.arg(BLACKLIST_METADATA_KEY)
|
||||||
|
.arg(&targets)
|
||||||
|
.query_async(&mut conn)
|
||||||
|
.await
|
||||||
|
.map_err(redis_error)?;
|
||||||
|
for (target, encoded) in targets.iter().zip(existing) {
|
||||||
|
if encoded.is_some() {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
let encoded = serde_json::to_string(&legacy_metadata(now)).map_err(|_| {
|
||||||
|
super::common::api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to encode blacklist metadata")
|
||||||
|
})?;
|
||||||
|
let _: i64 = redis::cmd("HSETNX")
|
||||||
|
.arg(BLACKLIST_METADATA_KEY)
|
||||||
|
.arg(target)
|
||||||
|
.arg(encoded)
|
||||||
|
.query_async(&mut conn)
|
||||||
|
.await
|
||||||
|
.map_err(redis_error)?;
|
||||||
|
filled += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
cursor = next;
|
||||||
|
if cursor == 0 {
|
||||||
|
return Ok(filled);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -1,5 +1,8 @@
|
||||||
|
//! Shared keys, metadata records and request validation of the blacklist API.
|
||||||
|
|
||||||
use axum::{Json, http::StatusCode};
|
use axum::{Json, http::StatusCode};
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
|
use std::net::IpAddr;
|
||||||
|
|
||||||
#[derive(Serialize)]
|
#[derive(Serialize)]
|
||||||
pub(super) struct BlacklistEvent<'a> {
|
pub(super) struct BlacklistEvent<'a> {
|
||||||
|
|
@ -23,9 +26,17 @@ pub(super) const BLACKLIST_CHANNEL: &str = "rampart:blacklist:events";
|
||||||
pub(super) const DEFAULT_BAN_DURATION_SECS: u64 = 300;
|
pub(super) const DEFAULT_BAN_DURATION_SECS: u64 = 300;
|
||||||
pub(super) const LEGACY_BAN_DURATION_SECS: u64 = 300;
|
pub(super) const LEGACY_BAN_DURATION_SECS: u64 = 300;
|
||||||
pub(super) const MAX_BAN_DURATION_SECS: u64 = 31_536_000;
|
pub(super) const MAX_BAN_DURATION_SECS: u64 = 31_536_000;
|
||||||
|
/// Maximum accepted length of a ban reason, in bytes.
|
||||||
|
pub(super) const MAX_REASON_BYTES: usize = 256;
|
||||||
|
/// Batch size of SSCAN/HMGET/MGET calls on the blacklist.
|
||||||
|
pub(super) const PAGE_SCAN_BATCH: usize = 100;
|
||||||
pub(super) const ADD_BAN_SCRIPT: &str = "redis.call('HSET', KEYS[2], ARGV[1], ARGV[2]); redis.call('SADD', KEYS[1], ARGV[1]); redis.call('PUBLISH', KEYS[3], ARGV[3]); return 1";
|
pub(super) const ADD_BAN_SCRIPT: &str = "redis.call('HSET', KEYS[2], ARGV[1], ARGV[2]); redis.call('SADD', KEYS[1], ARGV[1]); redis.call('PUBLISH', KEYS[3], ARGV[3]); return 1";
|
||||||
pub(super) const REMOVE_BAN_SCRIPT: &str = "redis.call('SREM', KEYS[1], ARGV[1]); redis.call('HDEL', KEYS[2], ARGV[1]); redis.call('PUBLISH', KEYS[3], ARGV[2]); return 1";
|
pub(super) const REMOVE_BAN_SCRIPT: &str = "redis.call('SREM', KEYS[1], ARGV[1]); redis.call('HDEL', KEYS[2], ARGV[1]); redis.call('PUBLISH', KEYS[3], ARGV[2]); return 1";
|
||||||
|
|
||||||
|
/// Metadata shown for a set member written by an older manager.
|
||||||
|
///
|
||||||
|
/// The read path only displays this record; persisting it is the job of the
|
||||||
|
/// startup backfill, so a GET never writes to Redis.
|
||||||
pub(super) fn legacy_metadata(now: i64) -> BlacklistMetadata {
|
pub(super) fn legacy_metadata(now: i64) -> BlacklistMetadata {
|
||||||
BlacklistMetadata {
|
BlacklistMetadata {
|
||||||
created_at_unix: now,
|
created_at_unix: now,
|
||||||
|
|
@ -55,10 +66,34 @@ pub(super) fn event_payload(
|
||||||
.map_err(|_| api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to serialize blacklist event"))
|
.map_err(|_| api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to serialize blacklist event"))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(super) fn parse_ip(target: &str) -> Result<std::net::IpAddr, (StatusCode, Json<serde_json::Value>)> {
|
/// Validates the `target` of a mutate request.
|
||||||
target
|
///
|
||||||
.parse()
|
/// The Redis ban snapshot is keyed by a single address, so a CIDR network is
|
||||||
.map_err(|_| api_error(StatusCode::BAD_REQUEST, "target must be an IP address"))
|
/// syntactically valid but unsupported and is rejected with an explicit message
|
||||||
|
/// instead of being stored as an entry the edges cannot apply.
|
||||||
|
pub(super) fn validate_target(target: &str) -> Result<IpAddr, (StatusCode, Json<serde_json::Value>)> {
|
||||||
|
let target = target.trim();
|
||||||
|
if let Ok(ip) = target.parse::<IpAddr>() {
|
||||||
|
return Ok(ip);
|
||||||
|
}
|
||||||
|
if crate::manager::security::IpNet::parse(target).is_ok() {
|
||||||
|
return Err(api_error(
|
||||||
|
StatusCode::BAD_REQUEST,
|
||||||
|
"CIDR targets are not supported; ban a single IP address",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
Err(api_error(
|
||||||
|
StatusCode::BAD_REQUEST,
|
||||||
|
"target must be a valid IPv4 or IPv6 address",
|
||||||
|
))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Rejects a `reason` longer than [`MAX_REASON_BYTES`] bytes.
|
||||||
|
pub(super) fn validate_reason(reason: &str) -> Result<(), (StatusCode, Json<serde_json::Value>)> {
|
||||||
|
if reason.len() > MAX_REASON_BYTES {
|
||||||
|
return Err(api_error(StatusCode::BAD_REQUEST, "reason must not exceed 256 bytes"));
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(super) fn api_error(status: StatusCode, message: &str) -> (StatusCode, Json<serde_json::Value>) {
|
pub(super) fn api_error(status: StatusCode, message: &str) -> (StatusCode, Json<serde_json::Value>) {
|
||||||
|
|
|
||||||
|
|
@ -1,79 +1,131 @@
|
||||||
|
//! `GET /api/v1/blacklist`: paginated, read-only view of the Redis bans.
|
||||||
|
//!
|
||||||
|
//! The endpoint never writes: legacy members keep showing a read-only fallback
|
||||||
|
//! record and are persisted by [`super::backfill_legacy_metadata`] at startup,
|
||||||
|
//! so retries and shared caches see an idempotent response.
|
||||||
|
|
||||||
use super::common::{
|
use super::common::{
|
||||||
BLACKLIST_KEY, BLACKLIST_METADATA_KEY, BlacklistMetadata, format_timestamp, legacy_metadata, redis_error,
|
BLACKLIST_KEY, BLACKLIST_METADATA_KEY, BlacklistMetadata, PAGE_SCAN_BATCH, format_timestamp, legacy_metadata,
|
||||||
redis_unavailable,
|
redis_error, redis_unavailable,
|
||||||
};
|
};
|
||||||
use super::{BlacklistEntry, BlacklistResponse};
|
use super::{BlacklistEntry, BlacklistResponse, ListQuery};
|
||||||
use crate::manager::AppState;
|
use crate::manager::AppState;
|
||||||
use axum::{Json, extract::State, http::StatusCode};
|
use axum::{
|
||||||
use redis::AsyncCommands;
|
Json,
|
||||||
|
extract::{Query, State},
|
||||||
|
http::StatusCode,
|
||||||
|
};
|
||||||
|
use redis::aio::MultiplexedConnection;
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
|
use std::net::IpAddr;
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
type ApiResult<T> = Result<T, (StatusCode, Json<serde_json::Value>)>;
|
||||||
|
|
||||||
pub async fn list_blacklist(
|
pub async fn list_blacklist(
|
||||||
State(state): State<Arc<AppState>>,
|
State(state): State<Arc<AppState>>,
|
||||||
) -> Result<Json<BlacklistResponse>, (StatusCode, Json<serde_json::Value>)> {
|
Query(query): Query<ListQuery>,
|
||||||
|
) -> ApiResult<Json<BlacklistResponse>> {
|
||||||
|
let (offset, limit) = query.bounds();
|
||||||
let mut conn = state
|
let mut conn = state
|
||||||
.redis_client
|
.redis_client
|
||||||
.get_multiplexed_async_connection()
|
.get_multiplexed_async_connection()
|
||||||
.await
|
.await
|
||||||
.map_err(redis_unavailable)?;
|
.map_err(redis_unavailable)?;
|
||||||
let members: Vec<String> = redis::cmd("SMEMBERS")
|
let total: u64 = redis::cmd("SCARD")
|
||||||
.arg(BLACKLIST_KEY)
|
.arg(BLACKLIST_KEY)
|
||||||
.query_async(&mut conn)
|
.query_async(&mut conn)
|
||||||
.await
|
.await
|
||||||
.map_err(redis_error)?;
|
.map_err(redis_error)?;
|
||||||
let metadata: HashMap<String, String> = conn.hgetall(BLACKLIST_METADATA_KEY).await.map_err(redis_error)?;
|
if limit == 0 {
|
||||||
let now = chrono::Utc::now().timestamp();
|
return Ok(Json(BlacklistResponse {
|
||||||
let mut items = Vec::with_capacity(members.len());
|
items: Vec::new(),
|
||||||
|
total,
|
||||||
for target in members {
|
}));
|
||||||
let Ok(ip) = target.parse::<std::net::IpAddr>() else {
|
|
||||||
continue;
|
|
||||||
};
|
|
||||||
let record = match metadata.get(&target) {
|
|
||||||
Some(encoded) => match serde_json::from_str::<BlacklistMetadata>(encoded) {
|
|
||||||
Ok(record) => record,
|
|
||||||
Err(_) => continue,
|
|
||||||
},
|
|
||||||
None => {
|
|
||||||
let legacy = legacy_metadata(now);
|
|
||||||
let encoded = serde_json::to_string(&legacy).map_err(|_| {
|
|
||||||
super::common::api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to encode blacklist metadata")
|
|
||||||
})?;
|
|
||||||
let inserted: i64 = redis::cmd("HSETNX")
|
|
||||||
.arg(BLACKLIST_METADATA_KEY)
|
|
||||||
.arg(&target)
|
|
||||||
.arg(encoded)
|
|
||||||
.query_async(&mut conn)
|
|
||||||
.await
|
|
||||||
.map_err(redis_error)?;
|
|
||||||
if inserted == 1 {
|
|
||||||
legacy
|
|
||||||
} else {
|
|
||||||
let current: Option<String> =
|
|
||||||
conn.hget(BLACKLIST_METADATA_KEY, &target).await.map_err(redis_error)?;
|
|
||||||
match current.and_then(|value| serde_json::from_str(&value).ok()) {
|
|
||||||
Some(record) => record,
|
|
||||||
None => continue,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
};
|
|
||||||
if record.expires_at_unix <= now
|
|
||||||
|| chrono::DateTime::from_timestamp(record.created_at_unix, 0).is_none()
|
|
||||||
|| chrono::DateTime::from_timestamp(record.expires_at_unix, 0).is_none()
|
|
||||||
{
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
items.push(BlacklistEntry {
|
|
||||||
target: ip.to_string(),
|
|
||||||
entry_type: "ip".to_string(),
|
|
||||||
reason: record.reason,
|
|
||||||
created_at: format_timestamp(record.created_at_unix),
|
|
||||||
expires_at: Some(format_timestamp(record.expires_at_unix)),
|
|
||||||
});
|
|
||||||
}
|
}
|
||||||
|
|
||||||
let total = items.len();
|
// SSCAN is capped at the requested window, so the set is never materialised.
|
||||||
|
let targets = scan_targets(&mut conn, offset.saturating_add(limit)).await?;
|
||||||
|
let page: Vec<String> = targets
|
||||||
|
.into_iter()
|
||||||
|
.skip(usize::try_from(offset).unwrap_or(usize::MAX))
|
||||||
|
.take(usize::try_from(limit).unwrap_or(usize::MAX))
|
||||||
|
.collect();
|
||||||
|
let metadata = load_metadata(&mut conn, &page).await?;
|
||||||
|
let now = chrono::Utc::now().timestamp();
|
||||||
|
let items = page
|
||||||
|
.iter()
|
||||||
|
.filter_map(|target| entry(target, metadata.get(target), now))
|
||||||
|
.collect();
|
||||||
Ok(Json(BlacklistResponse { items, total }))
|
Ok(Json(BlacklistResponse { items, total }))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Collects at most `wanted` set members with SSCAN.
|
||||||
|
async fn scan_targets(conn: &mut MultiplexedConnection, wanted: u64) -> ApiResult<Vec<String>> {
|
||||||
|
let mut targets = Vec::new();
|
||||||
|
let mut cursor = 0_u64;
|
||||||
|
loop {
|
||||||
|
let (next, batch): (u64, Vec<String>) = redis::cmd("SSCAN")
|
||||||
|
.arg(BLACKLIST_KEY)
|
||||||
|
.arg(cursor)
|
||||||
|
.arg("COUNT")
|
||||||
|
.arg(PAGE_SCAN_BATCH)
|
||||||
|
.query_async(conn)
|
||||||
|
.await
|
||||||
|
.map_err(redis_error)?;
|
||||||
|
targets.extend(batch);
|
||||||
|
cursor = next;
|
||||||
|
if cursor == 0 || u64::try_from(targets.len()).unwrap_or(u64::MAX) >= wanted {
|
||||||
|
return Ok(targets);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fetches metadata for `targets` in HMGET batches.
|
||||||
|
///
|
||||||
|
/// A present key with an unparseable record maps to `None`, which the caller
|
||||||
|
/// skips; an absent key means the member predates metadata and gets a fallback.
|
||||||
|
async fn load_metadata(
|
||||||
|
conn: &mut MultiplexedConnection,
|
||||||
|
targets: &[String],
|
||||||
|
) -> ApiResult<HashMap<String, Option<BlacklistMetadata>>> {
|
||||||
|
let mut metadata = HashMap::with_capacity(targets.len());
|
||||||
|
for chunk in targets.chunks(PAGE_SCAN_BATCH) {
|
||||||
|
let values: Vec<Option<String>> = redis::cmd("HMGET")
|
||||||
|
.arg(BLACKLIST_METADATA_KEY)
|
||||||
|
.arg(chunk)
|
||||||
|
.query_async(conn)
|
||||||
|
.await
|
||||||
|
.map_err(redis_error)?;
|
||||||
|
for (target, encoded) in chunk.iter().zip(values) {
|
||||||
|
metadata.insert(
|
||||||
|
target.clone(),
|
||||||
|
encoded.and_then(|value| serde_json::from_str(&value).ok()),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(metadata)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Builds one response entry, dropping expired and malformed records.
|
||||||
|
fn entry(target: &str, metadata: Option<&Option<BlacklistMetadata>>, now: i64) -> Option<BlacklistEntry> {
|
||||||
|
let ip: IpAddr = target.parse().ok()?;
|
||||||
|
let record = match metadata {
|
||||||
|
Some(Some(record)) => record.clone(),
|
||||||
|
Some(None) => return None,
|
||||||
|
None => legacy_metadata(now),
|
||||||
|
};
|
||||||
|
if record.expires_at_unix <= now
|
||||||
|
|| chrono::DateTime::from_timestamp(record.created_at_unix, 0).is_none()
|
||||||
|
|| chrono::DateTime::from_timestamp(record.expires_at_unix, 0).is_none()
|
||||||
|
{
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
Some(BlacklistEntry {
|
||||||
|
target: ip.to_string(),
|
||||||
|
entry_type: "ip".to_string(),
|
||||||
|
reason: record.reason,
|
||||||
|
created_at: format_timestamp(record.created_at_unix),
|
||||||
|
expires_at: Some(format_timestamp(record.expires_at_unix)),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,6 +1,9 @@
|
||||||
|
//! `POST`/`DELETE /api/v1/blacklist`: validated ban and unban mutations.
|
||||||
|
|
||||||
use super::common::{
|
use super::common::{
|
||||||
ADD_BAN_SCRIPT, BLACKLIST_CHANNEL, BLACKLIST_KEY, BLACKLIST_METADATA_KEY, DEFAULT_BAN_DURATION_SECS,
|
ADD_BAN_SCRIPT, BLACKLIST_CHANNEL, BLACKLIST_KEY, BLACKLIST_METADATA_KEY, DEFAULT_BAN_DURATION_SECS,
|
||||||
MAX_BAN_DURATION_SECS, REMOVE_BAN_SCRIPT, api_error, event_payload, parse_ip, redis_error, redis_unavailable,
|
MAX_BAN_DURATION_SECS, REMOVE_BAN_SCRIPT, api_error, event_payload, redis_error, redis_unavailable,
|
||||||
|
validate_reason, validate_target,
|
||||||
};
|
};
|
||||||
use super::{AddBlacklistRequest, RemoveBlacklistRequest};
|
use super::{AddBlacklistRequest, RemoveBlacklistRequest};
|
||||||
use crate::manager::AppState;
|
use crate::manager::AppState;
|
||||||
|
|
@ -11,7 +14,8 @@ pub async fn add_blacklist(
|
||||||
State(state): State<Arc<AppState>>,
|
State(state): State<Arc<AppState>>,
|
||||||
Json(req): Json<AddBlacklistRequest>,
|
Json(req): Json<AddBlacklistRequest>,
|
||||||
) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
|
) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
|
||||||
let ip = parse_ip(&req.target)?;
|
let ip = validate_target(&req.target)?;
|
||||||
|
validate_reason(&req.reason)?;
|
||||||
if req.entry_type != "ip" {
|
if req.entry_type != "ip" {
|
||||||
return Err(api_error(
|
return Err(api_error(
|
||||||
StatusCode::BAD_REQUEST,
|
StatusCode::BAD_REQUEST,
|
||||||
|
|
@ -73,7 +77,7 @@ pub async fn remove_blacklist(
|
||||||
State(state): State<Arc<AppState>>,
|
State(state): State<Arc<AppState>>,
|
||||||
Json(req): Json<RemoveBlacklistRequest>,
|
Json(req): Json<RemoveBlacklistRequest>,
|
||||||
) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
|
) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
|
||||||
let ip = parse_ip(&req.target)?;
|
let ip = validate_target(&req.target)?;
|
||||||
let target = ip.to_string();
|
let target = ip.to_string();
|
||||||
let event = event_payload(&target, "unban", 0, None)?;
|
let event = event_payload(&target, "unban", 0, None)?;
|
||||||
let mut conn = state
|
let mut conn = state
|
||||||
|
|
|
||||||
89
src/manager/api/guard/limit.rs
Normal file
89
src/manager/api/guard/limit.rs
Normal file
|
|
@ -0,0 +1,89 @@
|
||||||
|
//! Per-IP attempt throttling for login and mutating requests.
|
||||||
|
//!
|
||||||
|
//! Both limiters share one representation, `IpAddr -> (window start, attempts)`.
|
||||||
|
//! A counter resets when its window elapses, a successful login clears the entry
|
||||||
|
//! outright, and an eviction sweep keeps the map from growing one entry per
|
||||||
|
//! source address forever.
|
||||||
|
|
||||||
|
use super::RequestGuard;
|
||||||
|
use axum::{
|
||||||
|
Json,
|
||||||
|
extract::{Request, State},
|
||||||
|
http::StatusCode,
|
||||||
|
middleware::Next,
|
||||||
|
response::Response,
|
||||||
|
};
|
||||||
|
use dashmap::DashMap;
|
||||||
|
use std::net::IpAddr;
|
||||||
|
use std::sync::Arc;
|
||||||
|
use std::time::{Duration, Instant};
|
||||||
|
|
||||||
|
/// Sliding window of the login limiter.
|
||||||
|
pub const LOGIN_WINDOW: Duration = Duration::from_secs(60);
|
||||||
|
/// Login attempts allowed per window and source address.
|
||||||
|
pub const LOGIN_MAX_ATTEMPTS: u32 = 5;
|
||||||
|
/// Sliding window of the mutating-request limiter.
|
||||||
|
pub const MUTATION_WINDOW: Duration = Duration::from_secs(60);
|
||||||
|
/// Mutating requests allowed per window and source address.
|
||||||
|
pub const MUTATION_MAX_ATTEMPTS: u32 = 30;
|
||||||
|
|
||||||
|
/// Records one attempt for `ip` and reports whether it is allowed.
|
||||||
|
///
|
||||||
|
/// The first attempt after `window` starts a fresh window; once `max` attempts
|
||||||
|
/// were spent the call returns `false` without extending the window.
|
||||||
|
pub fn check_attempt(limiter: &DashMap<IpAddr, (Instant, u32)>, ip: IpAddr, window: Duration, max: u32) -> bool {
|
||||||
|
let now = Instant::now();
|
||||||
|
let mut slot = limiter.entry(ip).or_insert((now, 0));
|
||||||
|
let (window_start, attempts) = &mut *slot;
|
||||||
|
if now.duration_since(*window_start) >= window {
|
||||||
|
*window_start = now;
|
||||||
|
*attempts = 1;
|
||||||
|
} else if *attempts >= max {
|
||||||
|
return false;
|
||||||
|
} else {
|
||||||
|
*attempts += 1;
|
||||||
|
}
|
||||||
|
true
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Drops the counter of `ip`, used after a successful login.
|
||||||
|
pub fn reset_attempts(limiter: &DashMap<IpAddr, (Instant, u32)>, ip: IpAddr) {
|
||||||
|
limiter.remove(&ip);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Removes every counter whose window already elapsed.
|
||||||
|
pub fn evict_idle(limiter: &DashMap<IpAddr, (Instant, u32)>, window: Duration) {
|
||||||
|
let now = Instant::now();
|
||||||
|
limiter.retain(|_, (window_start, _)| now.duration_since(*window_start) < window);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Reports whether `method` changes server state and therefore is rate limited.
|
||||||
|
#[must_use]
|
||||||
|
pub fn is_mutating(method: &axum::http::Method) -> bool {
|
||||||
|
matches!(
|
||||||
|
*method,
|
||||||
|
axum::http::Method::POST | axum::http::Method::PUT | axum::http::Method::PATCH | axum::http::Method::DELETE
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Middleware that throttles mutating requests per client address.
|
||||||
|
///
|
||||||
|
/// Read-only requests pass through untouched so the limiter never affects the
|
||||||
|
/// inventory and blacklist views. Authenticated mutations share one budget per
|
||||||
|
/// address, regardless of which endpoint they target.
|
||||||
|
pub async fn rate_limit_mutations(
|
||||||
|
State(guard): State<Arc<RequestGuard>>,
|
||||||
|
request: Request,
|
||||||
|
next: Next,
|
||||||
|
) -> Result<Response, (StatusCode, Json<serde_json::Value>)> {
|
||||||
|
if is_mutating(request.method()) {
|
||||||
|
let ip = guard.request_client_ip(&request);
|
||||||
|
if !guard.allow_mutation(ip) {
|
||||||
|
return Err((
|
||||||
|
StatusCode::TOO_MANY_REQUESTS,
|
||||||
|
Json(serde_json::json!({"error": "too many requests"})),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(next.run(request).await)
|
||||||
|
}
|
||||||
111
src/manager/api/guard/mod.rs
Normal file
111
src/manager/api/guard/mod.rs
Normal file
|
|
@ -0,0 +1,111 @@
|
||||||
|
//! HTTP hardening shared by the manager endpoints.
|
||||||
|
//!
|
||||||
|
//! Owns the [`RequestGuard`] (proxy-aware client address plus the mutating
|
||||||
|
//! request limiter), the per-IP attempt helpers and [`build_router`], so the
|
||||||
|
//! daemon and the integration tests exercise the same body limit, timeout, CORS
|
||||||
|
//! and rate-limit stack.
|
||||||
|
|
||||||
|
pub mod limit;
|
||||||
|
pub mod proxy;
|
||||||
|
mod router;
|
||||||
|
|
||||||
|
use axum::extract::ConnectInfo;
|
||||||
|
pub use limit::{check_attempt, evict_idle, reset_attempts};
|
||||||
|
pub use proxy::{TRUSTED_PROXIES_ENV, TrustedProxies};
|
||||||
|
pub use router::{MAX_BODY_BYTES, REQUEST_TIMEOUT, build_router};
|
||||||
|
|
||||||
|
use crate::manager::SharedState;
|
||||||
|
use axum::{extract::Request, http::HeaderMap};
|
||||||
|
use dashmap::DashMap;
|
||||||
|
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
|
||||||
|
use std::sync::Arc;
|
||||||
|
use std::time::{Duration, Instant};
|
||||||
|
use tokio::sync::watch;
|
||||||
|
use tokio::task::JoinHandle;
|
||||||
|
|
||||||
|
/// How often the background eviction task sweeps idle limiter entries.
|
||||||
|
const EVICTION_INTERVAL: Duration = Duration::from_secs(60);
|
||||||
|
|
||||||
|
/// Per-request security context: trusted proxies and the mutation budget.
|
||||||
|
pub struct RequestGuard {
|
||||||
|
trusted_proxies: TrustedProxies,
|
||||||
|
mutations: DashMap<IpAddr, (Instant, u32)>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RequestGuard {
|
||||||
|
/// Builds a guard for `trusted_proxies` with an empty mutation budget.
|
||||||
|
#[must_use]
|
||||||
|
pub fn new(trusted_proxies: TrustedProxies) -> Self {
|
||||||
|
Self {
|
||||||
|
trusted_proxies,
|
||||||
|
mutations: DashMap::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Builds a guard from `MANAGER_TRUSTED_PROXIES`.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// Fails when the variable contains a malformed network entry.
|
||||||
|
pub fn from_env() -> anyhow::Result<Self> {
|
||||||
|
Ok(Self::new(TrustedProxies::from_env()?))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resolves the client address from the peer address and forwarded chain.
|
||||||
|
#[must_use]
|
||||||
|
pub fn client_ip(&self, peer: IpAddr, headers: &HeaderMap) -> IpAddr {
|
||||||
|
self.trusted_proxies.client_ip(peer, headers.get("x-forwarded-for"))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resolves the client address of `request`, falling back to the unspecified
|
||||||
|
/// address when the server was built without connect info.
|
||||||
|
#[must_use]
|
||||||
|
pub fn request_client_ip(&self, request: &Request) -> IpAddr {
|
||||||
|
let peer = request
|
||||||
|
.extensions()
|
||||||
|
.get::<ConnectInfo<SocketAddr>>()
|
||||||
|
.map_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED), |info| info.0.ip());
|
||||||
|
self.client_ip(peer, request.headers())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Records one mutating request for `ip` and reports whether it is allowed.
|
||||||
|
pub fn allow_mutation(&self, ip: IpAddr) -> bool {
|
||||||
|
check_attempt(
|
||||||
|
&self.mutations,
|
||||||
|
ip,
|
||||||
|
limit::MUTATION_WINDOW,
|
||||||
|
limit::MUTATION_MAX_ATTEMPTS,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Drops mutation counters whose window elapsed.
|
||||||
|
pub fn evict_idle(&self) {
|
||||||
|
evict_idle(&self.mutations, limit::MUTATION_WINDOW);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Sweeps idle login and mutation counters until shutdown is requested.
|
||||||
|
///
|
||||||
|
/// Without the sweep a long-lived manager keeps one map entry per source
|
||||||
|
/// address forever, which slowly turns the limiters into a memory leak.
|
||||||
|
pub async fn run_eviction(state: SharedState, guard: Arc<RequestGuard>, mut shutdown: watch::Receiver<bool>) {
|
||||||
|
let mut ticker = tokio::time::interval(EVICTION_INTERVAL);
|
||||||
|
ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||||
|
loop {
|
||||||
|
tokio::select! {
|
||||||
|
_ = ticker.tick() => {
|
||||||
|
evict_idle(&state.login_limiter, limit::LOGIN_WINDOW);
|
||||||
|
guard.evict_idle();
|
||||||
|
},
|
||||||
|
changed = shutdown.changed() => {
|
||||||
|
if changed.is_err() || *shutdown.borrow_and_update() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Spawns [`run_eviction`] on the current runtime.
|
||||||
|
pub fn spawn_eviction(state: SharedState, guard: Arc<RequestGuard>, shutdown: watch::Receiver<bool>) -> JoinHandle<()> {
|
||||||
|
tokio::spawn(run_eviction(state, guard, shutdown))
|
||||||
|
}
|
||||||
86
src/manager/api/guard/proxy.rs
Normal file
86
src/manager/api/guard/proxy.rs
Normal file
|
|
@ -0,0 +1,86 @@
|
||||||
|
//! Proxy-aware client address resolution.
|
||||||
|
//!
|
||||||
|
//! Behind a reverse proxy every request arrives from the proxy address, so a
|
||||||
|
//! per-IP limiter would throttle all administrators together. `X-Forwarded-For`
|
||||||
|
//! is therefore trusted only when the TCP peer belongs to an explicitly
|
||||||
|
//! configured network; otherwise the header is ignored and the peer address is
|
||||||
|
//! used, which keeps a directly connected client from spoofing its identity.
|
||||||
|
|
||||||
|
use crate::manager::security::IpNet;
|
||||||
|
use anyhow::Result;
|
||||||
|
use axum::http::HeaderValue;
|
||||||
|
use std::net::IpAddr;
|
||||||
|
|
||||||
|
/// Environment variable listing trusted proxy networks, comma separated.
|
||||||
|
pub const TRUSTED_PROXIES_ENV: &str = "MANAGER_TRUSTED_PROXIES";
|
||||||
|
|
||||||
|
/// Networks whose `X-Forwarded-For` header is trusted.
|
||||||
|
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||||
|
pub struct TrustedProxies {
|
||||||
|
nets: Vec<IpNet>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TrustedProxies {
|
||||||
|
/// Parses a comma-separated list of networks.
|
||||||
|
///
|
||||||
|
/// An empty or whitespace-only value trusts no proxy, which is the safe
|
||||||
|
/// default for a manager exposed directly.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// Fails on an empty entry or on a malformed address/CIDR, so a typo cannot
|
||||||
|
/// silently widen the trust boundary.
|
||||||
|
pub fn parse(raw: &str) -> Result<Self> {
|
||||||
|
let raw = raw.trim();
|
||||||
|
if raw.is_empty() {
|
||||||
|
return Ok(Self::default());
|
||||||
|
}
|
||||||
|
let mut nets = Vec::new();
|
||||||
|
for entry in raw.split(',') {
|
||||||
|
let entry = entry.trim();
|
||||||
|
if entry.is_empty() {
|
||||||
|
anyhow::bail!("{TRUSTED_PROXIES_ENV} contains an empty entry");
|
||||||
|
}
|
||||||
|
nets.push(IpNet::parse(entry)?);
|
||||||
|
}
|
||||||
|
Ok(Self { nets })
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Reads [`TRUSTED_PROXIES_ENV`] from the process environment.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// Propagates the same validation as [`TrustedProxies::parse`].
|
||||||
|
pub fn from_env() -> Result<Self> {
|
||||||
|
Self::parse(&std::env::var(TRUSTED_PROXIES_ENV).unwrap_or_default())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Reports whether `ip` is a configured proxy.
|
||||||
|
#[must_use]
|
||||||
|
pub fn is_trusted(&self, ip: IpAddr) -> bool {
|
||||||
|
self.nets.iter().any(|net| net.contains(ip))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resolves the client address for a request from `peer`.
|
||||||
|
///
|
||||||
|
/// The forwarded chain is walked from right to left, skipping proxies the
|
||||||
|
/// manager trusts, and the first untrusted hop wins: that is the address
|
||||||
|
/// the nearest trusted proxy observed. A malformed chain falls back to the
|
||||||
|
/// last trusted hop resolved so far, never to an unvalidated entry.
|
||||||
|
#[must_use]
|
||||||
|
pub fn client_ip(&self, peer: IpAddr, forwarded_for: Option<&HeaderValue>) -> IpAddr {
|
||||||
|
if !self.is_trusted(peer) {
|
||||||
|
return peer;
|
||||||
|
}
|
||||||
|
let Some(chain) = forwarded_for.and_then(|value| value.to_str().ok()) else {
|
||||||
|
return peer;
|
||||||
|
};
|
||||||
|
let mut resolved = peer;
|
||||||
|
for entry in chain.split(',').rev() {
|
||||||
|
match entry.trim().parse::<IpAddr>() {
|
||||||
|
Ok(ip) if !self.is_trusted(ip) => return ip,
|
||||||
|
Ok(ip) => resolved = ip,
|
||||||
|
Err(_) => break,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
resolved
|
||||||
|
}
|
||||||
|
}
|
||||||
76
src/manager/api/guard/router.rs
Normal file
76
src/manager/api/guard/router.rs
Normal file
|
|
@ -0,0 +1,76 @@
|
||||||
|
//! Router assembly for the manager API.
|
||||||
|
//!
|
||||||
|
//! Every deployment path, including integration tests, builds the router here
|
||||||
|
//! so the body limit, request deadline, CORS policy and per-IP rate limiting
|
||||||
|
//! cannot drift between the daemon and its tests.
|
||||||
|
|
||||||
|
use super::RequestGuard;
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
use super::limit::rate_limit_mutations;
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
use crate::manager::auth;
|
||||||
|
use crate::manager::{SharedState, api};
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
use axum::middleware;
|
||||||
|
use axum::{
|
||||||
|
Extension, Router,
|
||||||
|
extract::DefaultBodyLimit,
|
||||||
|
http::StatusCode,
|
||||||
|
routing::{get, post},
|
||||||
|
};
|
||||||
|
use std::sync::Arc;
|
||||||
|
use std::time::Duration;
|
||||||
|
use tower_http::{cors::CorsLayer, timeout::TimeoutLayer};
|
||||||
|
|
||||||
|
/// Hard cap on any request body accepted by the manager API.
|
||||||
|
///
|
||||||
|
/// The largest documented payload is a blacklist entry with a 256-byte reason,
|
||||||
|
/// so 8 KiB leaves room for JSON overhead while keeping an unauthenticated
|
||||||
|
/// client from buffering megabytes.
|
||||||
|
pub const MAX_BODY_BYTES: usize = 8 * 1024;
|
||||||
|
/// Whole-request deadline, including authentication and a Redis round trip.
|
||||||
|
pub const REQUEST_TIMEOUT: Duration = Duration::from_secs(10);
|
||||||
|
|
||||||
|
/// Builds the complete manager router.
|
||||||
|
///
|
||||||
|
/// `cors` is the layer derived from `CORS_ORIGIN`; `None` serves no cross-origin
|
||||||
|
/// policy at all. The returned router is ready to be attached to a listener
|
||||||
|
/// through `into_make_service_with_connect_info`, which the handlers require for
|
||||||
|
/// the client address.
|
||||||
|
pub fn build_router(state: SharedState, guard: Arc<RequestGuard>, cors: Option<CorsLayer>) -> Router {
|
||||||
|
let public = Router::new()
|
||||||
|
.route("/api/v1/health", get(api::inventory::health::health_check))
|
||||||
|
.route("/api/v1/auth/login", post(api::auth::login));
|
||||||
|
|
||||||
|
// Redis-backed routes only exist together with the feature; the manager
|
||||||
|
// refuses to start without it, so 501 stubs here would be unreachable.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
let protected = Router::new()
|
||||||
|
.route("/api/v1/servers", get(api::inventory::servers::list_servers))
|
||||||
|
.route(
|
||||||
|
"/api/v1/blacklist",
|
||||||
|
get(api::blacklist::list_blacklist)
|
||||||
|
.post(api::blacklist::add_blacklist)
|
||||||
|
.delete(api::blacklist::remove_blacklist),
|
||||||
|
)
|
||||||
|
.route("/api/v1/nodes", get(api::inventory::nodes::list_nodes))
|
||||||
|
.route_layer(middleware::from_fn_with_state(guard.clone(), rate_limit_mutations))
|
||||||
|
.route_layer(middleware::from_fn_with_state(state.clone(), auth::auth_middleware));
|
||||||
|
#[cfg(not(feature = "store-redis"))]
|
||||||
|
let protected = Router::new();
|
||||||
|
|
||||||
|
let mut app = Router::new()
|
||||||
|
.merge(public)
|
||||||
|
.merge(protected)
|
||||||
|
.with_state(state)
|
||||||
|
.layer(Extension(guard))
|
||||||
|
.layer(DefaultBodyLimit::max(MAX_BODY_BYTES))
|
||||||
|
.layer(TimeoutLayer::with_status_code(
|
||||||
|
StatusCode::REQUEST_TIMEOUT,
|
||||||
|
REQUEST_TIMEOUT,
|
||||||
|
));
|
||||||
|
if let Some(cors) = cors {
|
||||||
|
app = app.layer(cors);
|
||||||
|
}
|
||||||
|
app
|
||||||
|
}
|
||||||
|
|
@ -1,6 +1,66 @@
|
||||||
//! Manager API inventory: health, nodes and servers.
|
//! Manager API inventory: health, nodes and servers.
|
||||||
//!
|
//!
|
||||||
//! Owns the read-side endpoints that describe the fleet as the manager sees it.
|
//! Owns the read-side endpoints that describe the fleet as the manager sees it,
|
||||||
|
//! plus the shared SCAN/MGET reader that keeps those reads non-blocking.
|
||||||
|
|
||||||
pub mod health;
|
pub mod health;
|
||||||
pub mod nodes;
|
pub mod nodes;
|
||||||
pub mod servers;
|
pub mod servers;
|
||||||
|
|
||||||
|
/// SCAN and MGET batch size of a fleet read.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
const READ_BATCH: usize = 100;
|
||||||
|
|
||||||
|
/// Reads every value stored under `pattern` via SCAN and batched MGET.
|
||||||
|
///
|
||||||
|
/// SCAN is used instead of `KEYS` because the latter blocks Redis for every
|
||||||
|
/// edge in the fleet. Values are fetched in MGET batches instead of one GET per
|
||||||
|
/// key, so a large fleet costs a bounded number of round trips.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// Returns the Redis error unchanged: the caller answers 503, because an empty
|
||||||
|
/// fleet and an unreachable store must stay distinguishable.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
pub(super) async fn scan_values(
|
||||||
|
conn: &mut redis::aio::MultiplexedConnection,
|
||||||
|
pattern: &str,
|
||||||
|
) -> redis::RedisResult<Vec<String>> {
|
||||||
|
use futures::StreamExt;
|
||||||
|
use redis::AsyncCommands;
|
||||||
|
|
||||||
|
let opts = redis::ScanOptions::default()
|
||||||
|
.with_pattern(pattern)
|
||||||
|
.with_count(READ_BATCH);
|
||||||
|
let mut iter = conn.scan_options::<String>(opts).await?;
|
||||||
|
let mut keys = Vec::new();
|
||||||
|
while let Some(key) = iter.next().await {
|
||||||
|
keys.push(key?);
|
||||||
|
}
|
||||||
|
drop(iter);
|
||||||
|
|
||||||
|
let mut values = Vec::with_capacity(keys.len());
|
||||||
|
for chunk in keys.chunks(READ_BATCH) {
|
||||||
|
let batch: Vec<Option<String>> = redis::cmd("MGET").arg(chunk).query_async(conn).await?;
|
||||||
|
values.extend(batch.into_iter().flatten());
|
||||||
|
}
|
||||||
|
Ok(values)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses every value that is a valid JSON record, skipping corrupt entries.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
pub(super) fn decode_all<T: serde::de::DeserializeOwned>(values: &[String]) -> Vec<T> {
|
||||||
|
values
|
||||||
|
.iter()
|
||||||
|
.filter_map(|value| serde_json::from_str(value).ok())
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Maps a Redis read failure to 503 so it cannot be mistaken for an empty fleet.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
pub(super) fn unavailable(error: &redis::RedisError) -> (axum::http::StatusCode, axum::Json<serde_json::Value>) {
|
||||||
|
tracing::error!("inventory Redis read failed: {error}");
|
||||||
|
(
|
||||||
|
axum::http::StatusCode::SERVICE_UNAVAILABLE,
|
||||||
|
axum::Json(serde_json::json!({"error": "redis unavailable"})),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,13 +1,17 @@
|
||||||
|
//! `GET /api/v1/nodes`: registered edge nodes from the Redis heartbeat keys.
|
||||||
|
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
use crate::manager::AppState;
|
use crate::manager::AppState;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
use axum::{Json, extract::State};
|
use axum::{Json, extract::State, http::StatusCode};
|
||||||
#[cfg(feature = "store-redis")]
|
|
||||||
use redis::AsyncCommands;
|
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
/// SCAN pattern of node records.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
const NODES_PATTERN: &str = "rampart:nodes:*";
|
||||||
|
|
||||||
#[derive(Debug, Serialize, Deserialize)]
|
#[derive(Debug, Serialize, Deserialize)]
|
||||||
pub struct NodeInfo {
|
pub struct NodeInfo {
|
||||||
pub id: String,
|
pub id: String,
|
||||||
|
|
@ -22,27 +26,24 @@ pub struct NodesResponse {
|
||||||
pub nodes: Vec<NodeInfo>,
|
pub nodes: Vec<NodeInfo>,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Lists the fleet with SSCAN-style iteration and batched reads.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// Returns 503 when Redis is unreachable or a command fails; an empty `nodes`
|
||||||
|
/// array then always means a healthy but empty fleet.
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
pub async fn list_nodes(State(state): State<Arc<AppState>>) -> Json<NodesResponse> {
|
pub async fn list_nodes(
|
||||||
let mut conn = match state.redis_client.get_multiplexed_async_connection().await {
|
State(state): State<Arc<AppState>>,
|
||||||
Ok(c) => c,
|
) -> Result<Json<NodesResponse>, (StatusCode, Json<serde_json::Value>)> {
|
||||||
Err(_) => return Json(NodesResponse { nodes: vec![] }),
|
let mut conn = state
|
||||||
};
|
.redis_client
|
||||||
|
.get_multiplexed_async_connection()
|
||||||
let keys: Vec<String> = match redis::cmd("KEYS").arg("rampart:nodes:*").query_async(&mut conn).await {
|
.await
|
||||||
Ok(k) => k,
|
.map_err(|error| super::unavailable(&error))?;
|
||||||
Err(_) => return Json(NodesResponse { nodes: vec![] }),
|
let values = super::scan_values(&mut conn, NODES_PATTERN)
|
||||||
};
|
.await
|
||||||
|
.map_err(|error| super::unavailable(&error))?;
|
||||||
let mut nodes = Vec::with_capacity(keys.len());
|
Ok(Json(NodesResponse {
|
||||||
for key in &keys {
|
nodes: super::decode_all(&values),
|
||||||
let raw: Option<String> = conn.get(key).await.unwrap_or(None);
|
}))
|
||||||
if let Some(json) = raw
|
|
||||||
&& let Ok(node) = serde_json::from_str::<NodeInfo>(&json)
|
|
||||||
{
|
|
||||||
nodes.push(node);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Json(NodesResponse { nodes })
|
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,13 +1,17 @@
|
||||||
|
//! `GET /api/v1/servers`: backend servers from the Redis registry keys.
|
||||||
|
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
use crate::manager::AppState;
|
use crate::manager::AppState;
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
use axum::{Json, extract::State};
|
use axum::{Json, extract::State, http::StatusCode};
|
||||||
#[cfg(feature = "store-redis")]
|
|
||||||
use redis::AsyncCommands;
|
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
/// SCAN pattern of server records.
|
||||||
|
#[cfg(feature = "store-redis")]
|
||||||
|
const SERVERS_PATTERN: &str = "rampart:servers:*";
|
||||||
|
|
||||||
#[derive(Debug, Serialize, Deserialize)]
|
#[derive(Debug, Serialize, Deserialize)]
|
||||||
pub struct ServerEntry {
|
pub struct ServerEntry {
|
||||||
pub name: String,
|
pub name: String,
|
||||||
|
|
@ -23,27 +27,24 @@ pub struct ServersResponse {
|
||||||
pub servers: Vec<ServerEntry>,
|
pub servers: Vec<ServerEntry>,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Lists the registry with SCAN and batched MGET reads.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// Returns 503 when Redis is unreachable or a command fails; an empty `servers`
|
||||||
|
/// array then always means a healthy but empty registry.
|
||||||
#[cfg(feature = "store-redis")]
|
#[cfg(feature = "store-redis")]
|
||||||
pub async fn list_servers(State(state): State<Arc<AppState>>) -> Json<ServersResponse> {
|
pub async fn list_servers(
|
||||||
let mut conn = match state.redis_client.get_multiplexed_async_connection().await {
|
State(state): State<Arc<AppState>>,
|
||||||
Ok(c) => c,
|
) -> Result<Json<ServersResponse>, (StatusCode, Json<serde_json::Value>)> {
|
||||||
Err(_) => return Json(ServersResponse { servers: vec![] }),
|
let mut conn = state
|
||||||
};
|
.redis_client
|
||||||
|
.get_multiplexed_async_connection()
|
||||||
let keys: Vec<String> = match redis::cmd("KEYS").arg("rampart:servers:*").query_async(&mut conn).await {
|
.await
|
||||||
Ok(k) => k,
|
.map_err(|error| super::unavailable(&error))?;
|
||||||
Err(_) => return Json(ServersResponse { servers: vec![] }),
|
let values = super::scan_values(&mut conn, SERVERS_PATTERN)
|
||||||
};
|
.await
|
||||||
|
.map_err(|error| super::unavailable(&error))?;
|
||||||
let mut servers = Vec::with_capacity(keys.len());
|
Ok(Json(ServersResponse {
|
||||||
for key in &keys {
|
servers: super::decode_all(&values),
|
||||||
let raw: Option<String> = conn.get(key).await.unwrap_or(None);
|
}))
|
||||||
if let Some(json) = raw
|
|
||||||
&& let Ok(server) = serde_json::from_str::<ServerEntry>(&json)
|
|
||||||
{
|
|
||||||
servers.push(server);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Json(ServersResponse { servers })
|
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,3 +1,11 @@
|
||||||
|
//! Manager HTTP API.
|
||||||
|
//!
|
||||||
|
//! Owns the route handlers (`auth`, `blacklist`, `inventory`) and the shared
|
||||||
|
//! HTTP hardening in [`guard`], including the only supported way to assemble
|
||||||
|
//! the service.
|
||||||
pub mod auth;
|
pub mod auth;
|
||||||
pub mod blacklist;
|
pub mod blacklist;
|
||||||
|
pub mod guard;
|
||||||
pub mod inventory;
|
pub mod inventory;
|
||||||
|
|
||||||
|
pub use guard::build_router;
|
||||||
|
|
|
||||||
|
|
@ -7,8 +7,9 @@
|
||||||
//! `CORS_ORIGIN` value instead of silently allowing every origin.
|
//! `CORS_ORIGIN` value instead of silently allowing every origin.
|
||||||
|
|
||||||
use anyhow::{Result, bail};
|
use anyhow::{Result, bail};
|
||||||
|
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
|
||||||
use subtle::ConstantTimeEq;
|
use subtle::ConstantTimeEq;
|
||||||
use tower_http::cors::{AllowOrigin, Any, CorsLayer};
|
use tower_http::cors::{AllowOrigin, CorsLayer};
|
||||||
|
|
||||||
/// Minimum length of `API_PASSWORD` in characters.
|
/// Minimum length of `API_PASSWORD` in characters.
|
||||||
const MIN_API_PASSWORD_CHARS: usize = 16;
|
const MIN_API_PASSWORD_CHARS: usize = 16;
|
||||||
|
|
@ -117,19 +118,95 @@ impl CorsPolicy {
|
||||||
|
|
||||||
/// Builds the axum CORS layer for this policy.
|
/// Builds the axum CORS layer for this policy.
|
||||||
///
|
///
|
||||||
|
/// The layer only configures origins, methods and headers, so a browser
|
||||||
|
/// preflight reaches the same endpoints the API documents. It does not
|
||||||
|
/// enable credentials: the manager authenticates with a bearer token.
|
||||||
|
///
|
||||||
/// Returns `None` for [`CorsPolicy::Deny`] so the router is served without
|
/// Returns `None` for [`CorsPolicy::Deny`] so the router is served without
|
||||||
/// any cross-origin layer.
|
/// any cross-origin layer.
|
||||||
#[must_use]
|
#[must_use]
|
||||||
pub fn cors_layer(&self) -> Option<CorsLayer> {
|
pub fn cors_layer(&self) -> Option<CorsLayer> {
|
||||||
match self {
|
let origin = match self {
|
||||||
Self::Deny => None,
|
Self::Deny => return None,
|
||||||
Self::Any => Some(CorsLayer::new().allow_origin(Any)),
|
Self::Any => AllowOrigin::any(),
|
||||||
Self::AllowList(origins) => {
|
Self::AllowList(origins) => {
|
||||||
let allowed = origins
|
let allowed = origins
|
||||||
.iter()
|
.iter()
|
||||||
.filter_map(|origin| axum::http::HeaderValue::from_str(origin).ok());
|
.filter_map(|origin| axum::http::HeaderValue::from_str(origin).ok());
|
||||||
Some(CorsLayer::new().allow_origin(AllowOrigin::list(allowed)))
|
AllowOrigin::list(allowed)
|
||||||
},
|
},
|
||||||
|
};
|
||||||
|
Some(
|
||||||
|
CorsLayer::new()
|
||||||
|
.allow_origin(origin)
|
||||||
|
.allow_methods([
|
||||||
|
axum::http::Method::GET,
|
||||||
|
axum::http::Method::POST,
|
||||||
|
axum::http::Method::DELETE,
|
||||||
|
])
|
||||||
|
.allow_headers([axum::http::header::AUTHORIZATION, axum::http::header::CONTENT_TYPE]),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An IPv4 or IPv6 network in CIDR notation.
|
||||||
|
///
|
||||||
|
/// A bare address parses as a host route (`/32` or `/128`). Used for the
|
||||||
|
/// `MANAGER_TRUSTED_PROXIES` policy, where a too-broad entry would let a
|
||||||
|
/// client spoof its address through `X-Forwarded-For`.
|
||||||
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||||
|
pub struct IpNet {
|
||||||
|
addr: IpAddr,
|
||||||
|
prefix: u8,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl IpNet {
|
||||||
|
/// Parses `10.0.0.0/8`, `2001:db8::/32` or a bare address.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// Fails when the address or the prefix is malformed, and when the prefix
|
||||||
|
/// length exceeds the address width (32 or 128 bits).
|
||||||
|
pub fn parse(value: &str) -> Result<Self> {
|
||||||
|
let value = value.trim();
|
||||||
|
let (addr, prefix) = match value.split_once('/') {
|
||||||
|
Some((addr, prefix)) => (addr, Some(prefix)),
|
||||||
|
None => (value, None),
|
||||||
|
};
|
||||||
|
let addr: IpAddr = addr
|
||||||
|
.parse()
|
||||||
|
.map_err(|_| anyhow::anyhow!("'{value}' is not an IP address or CIDR network"))?;
|
||||||
|
let width = if addr.is_ipv4() { 32 } else { 128 };
|
||||||
|
let prefix = match prefix {
|
||||||
|
Some(prefix) => prefix
|
||||||
|
.parse::<u8>()
|
||||||
|
.map_err(|_| anyhow::anyhow!("'{value}' has an invalid prefix length"))?,
|
||||||
|
None => width,
|
||||||
|
};
|
||||||
|
if prefix > width {
|
||||||
|
bail!("'{value}' prefix length exceeds the {width}-bit address width");
|
||||||
|
}
|
||||||
|
Ok(Self { addr, prefix })
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Reports whether `ip` belongs to this network.
|
||||||
|
#[must_use]
|
||||||
|
pub fn contains(&self, ip: IpAddr) -> bool {
|
||||||
|
match (self.addr, ip) {
|
||||||
|
(IpAddr::V4(net), IpAddr::V4(ip)) => mask_v4(net, self.prefix) == mask_v4(ip, self.prefix),
|
||||||
|
(IpAddr::V6(net), IpAddr::V6(ip)) => mask_v6(net, self.prefix) == mask_v6(ip, self.prefix),
|
||||||
|
_ => false,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Returns the network bits of `addr`; a zero prefix masks everything.
|
||||||
|
fn mask_v4(addr: Ipv4Addr, prefix: u8) -> u32 {
|
||||||
|
let shift = u32::from(32_u8.saturating_sub(prefix));
|
||||||
|
u32::from(addr) & u32::MAX.checked_shl(shift).unwrap_or(0)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the network bits of `addr`; a zero prefix masks everything.
|
||||||
|
fn mask_v6(addr: Ipv6Addr, prefix: u8) -> u128 {
|
||||||
|
let shift = u32::from(128_u8.saturating_sub(prefix));
|
||||||
|
u128::from(addr) & u128::MAX.checked_shl(shift).unwrap_or(0)
|
||||||
|
}
|
||||||
|
|
|
||||||
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
|
//! Regression tests for the authentication bypass where an empty
|
||||||
//! `API_PASSWORD` matched an empty login (`verify_password("", "")`).
|
//! `API_PASSWORD` matched an empty login (`verify_password("", "")`).
|
||||||
|
|
||||||
|
use axum::http::HeaderValue;
|
||||||
use dashmap::DashMap;
|
use dashmap::DashMap;
|
||||||
use rampart::manager::api::auth::allow_login_attempt;
|
use rampart::manager::api::auth::{allow_login_attempt, reset_login_attempts};
|
||||||
use rampart::manager::security::{CorsPolicy, validate_api_password, validate_jwt_secret, verify_password};
|
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::net::IpAddr;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
const STRONG_PASSWORD: &str = "correct-horse-battery-staple";
|
const STRONG_PASSWORD: &str = "correct-horse-battery-staple";
|
||||||
const STRONG_SECRET: &str = "0123456789abcdef0123456789abcdef";
|
const STRONG_SECRET: &str = "0123456789abcdef0123456789abcdef";
|
||||||
|
|
@ -122,3 +126,124 @@ fn login_limiter_blocks_after_five_attempts() {
|
||||||
}
|
}
|
||||||
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());
|
||||||
|
}
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue