Security:
- An empty API_PASSWORD passed validation (only the literal "changeme" was
rejected) and verify_password("", "") returned true, so a login with an
empty password minted an admin token. Require >= 16 characters and >= 32
non-whitespace bytes for JWT_SECRET; verify rejects an empty stored secret.
- syn_challenge_enabled required a real challenge_secret_hex: the public
placeholder from config.h is now rejected in every spelling.
- docker-compose: Redis/ClickHouse/Grafana are loopback-only and every
password uses ${VAR:?} instead of a default. An exposed Redis was a way to
lift bans and publish unbans to the whole fleet with one redis-cli.
- Empty CORS_ORIGIN no longer means "allow any origin".
- ban_cidr / userspace blacklist validate and mask prefixes; CIDR bans are
stored as ranges, so a /24 or /64 ban actually covers the subnet (before,
only the network address was blocked).
Availability:
- ClickHouse client has connect/request timeouts and no mutex held across
await: a hung analytics backend can no longer freeze the ban path. Events
go through a bounded buffer with a drop counter.
- Redis uses a ConnectionManager with per-command timeouts; pubsub and
reconcile reset the backoff after success; publish cannot block shutdown.
- Ban durations from pubsub are clamped and use checked_add; the sync task
survives panics instead of silently dying.
- Blacklist TOCTOU (remove_if) and replace_redis no longer empties the table
during a Redis reconnect.
- RateLimiter and reputation have hard caps with incremental eviction instead
of an unbounded DashMap and a stop-the-world retain.
- The attack detector scores before updating its baseline and needs several
quiet windows to leave UnderAttack, so a sustained flood keeps banning new
offenders instead of ending after one tick.
- accept() backs off on EMFILE/ENFILE, shutdown Err is treated as shutdown,
a global semaphore bounds in-flight connections, rate limiting runs before
PoW, whitelisted IPs are never banned, and connect/handshake/relay have
timeouts with an idle budget.
- PoW uses the configured difficulty as a floor, the clamp is enforced, and
nonce framing survives split segments and coalesced handshake bytes.
- Subnet tracker memory is capped (prefixes and per-prefix sources) and the
monitor bans with the configured TTL.
CI and docs:
- CI runs the test suite with --no-default-features --features protocol-http;
make ebpf fails on errors; the secrets gate catches weak compose defaults.
- doctor skips protected endpoints without a token and exits non-zero on
failure; a drain timeout returns exit code 1.
- TODO §2b records the review findings, what is fixed and what is deferred;
configuration/testing docs describe the new XDP and secret semantics.
84 lines
2.5 KiB
Rust
84 lines
2.5 KiB
Rust
//! Decoding and validation of blacklist events received from Redis.
|
|
//!
|
|
//! A remote or stale manager must not be able to ban an address for an
|
|
//! arbitrary duration, so every ban is range-checked against
|
|
//! [`MAX_BAN_DURATION_SECS`] before it reaches the in-memory table.
|
|
|
|
use crate::filter::blacklist::{Blacklist, MAX_BAN_DURATION_SECS};
|
|
use redis::Msg;
|
|
use serde::Deserialize;
|
|
use std::time::Duration;
|
|
|
|
#[derive(Deserialize)]
|
|
struct BlacklistEvent {
|
|
ip: String,
|
|
action: String,
|
|
#[serde(default = "default_duration")]
|
|
duration_secs: u64,
|
|
#[serde(default)]
|
|
expires_at_unix: Option<i64>,
|
|
}
|
|
|
|
fn default_duration() -> u64 {
|
|
300
|
|
}
|
|
|
|
pub(super) fn handle(msg: &Msg, blacklist: &Blacklist) -> anyhow::Result<()> {
|
|
let payload: String = msg.get_payload()?;
|
|
let event: BlacklistEvent = serde_json::from_str(&payload)?;
|
|
let ip: std::net::IpAddr = event.ip.parse()?;
|
|
|
|
match event.action.as_str() {
|
|
"ban" => {
|
|
let duration = match event.expires_at_unix {
|
|
Some(expires_at) => absolute_duration(expires_at)?,
|
|
None => checked_duration(event.duration_secs)?,
|
|
};
|
|
match duration {
|
|
Some(duration) => {
|
|
blacklist.add_redis(ip, duration, "manager_event");
|
|
tracing::info!(ip = %event.ip, "blacklist add via Redis");
|
|
},
|
|
None => {
|
|
blacklist.remove_redis(ip);
|
|
tracing::info!(ip = %event.ip, "blacklist expiry already passed");
|
|
},
|
|
}
|
|
},
|
|
"unban" => {
|
|
blacklist.remove_redis(ip);
|
|
tracing::info!(ip = %event.ip, "blacklist remove via Redis");
|
|
},
|
|
action => anyhow::bail!("unknown blacklist action: {action}"),
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Converts an absolute expiry into the remaining ban duration.
|
|
///
|
|
/// Returns `Ok(None)` when the expiry is already in the past.
|
|
fn absolute_duration(expires_at: i64) -> anyhow::Result<Option<Duration>> {
|
|
if chrono::DateTime::from_timestamp(expires_at, 0).is_none() {
|
|
anyhow::bail!("invalid blacklist event expiry timestamp");
|
|
}
|
|
let remaining = expires_at.saturating_sub(chrono::Utc::now().timestamp());
|
|
if remaining <= 0 {
|
|
return Ok(None);
|
|
}
|
|
let remaining = u64::try_from(remaining)?;
|
|
if remaining > MAX_BAN_DURATION_SECS {
|
|
anyhow::bail!("blacklist event expiry exceeds {MAX_BAN_DURATION_SECS}s");
|
|
}
|
|
Ok(Some(Duration::from_secs(remaining)))
|
|
}
|
|
|
|
/// Validates a relative ban duration.
|
|
fn checked_duration(secs: u64) -> anyhow::Result<Option<Duration>> {
|
|
if secs > MAX_BAN_DURATION_SECS {
|
|
anyhow::bail!("blacklist event duration {secs}s exceeds {MAX_BAN_DURATION_SECS}s");
|
|
}
|
|
if secs == 0 {
|
|
return Ok(None);
|
|
}
|
|
Ok(Some(Duration::from_secs(secs)))
|
|
}
|