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.
238 lines
7.5 KiB
Rust
238 lines
7.5 KiB
Rust
//! Edge daemon runtime: component assembly, background tasks and listener
|
|
//! startup.
|
|
|
|
use crate::config::Config;
|
|
use crate::engine::challenge::DifficultyAdjuster;
|
|
use crate::engine::listener;
|
|
use crate::engine::subnet::monitor;
|
|
use crate::engine::tunnel::Gateway;
|
|
use crate::filter::blacklist::Blacklist;
|
|
use crate::filter::rate_limit::RateLimiter;
|
|
use crate::metrics;
|
|
use crate::store::clickhouse::{ClickHouseEvent, ClickHouseWriter};
|
|
use crate::traffic::hook::TrafficHook;
|
|
use crate::traffic::intel::detector::{AttackDetector, AttackStatus};
|
|
use crate::traffic::intel::reputation::IpReputation;
|
|
use crate::traffic::profile::alert::{AlertDispatcher, send_webhook};
|
|
use std::sync::Arc;
|
|
use std::sync::Mutex;
|
|
use std::sync::atomic::{AtomicU64, Ordering};
|
|
use std::time::Duration;
|
|
use tokio::sync::oneshot;
|
|
use tokio::sync::watch;
|
|
use tracing_subscriber::EnvFilter;
|
|
|
|
use super::services::{build_registry, build_whitelist, start_subnet_tracker, start_xdp};
|
|
use super::shutdown::{RunExit, spawn_shutdown_drain};
|
|
|
|
fn attack_status_value(status: AttackStatus) -> i64 {
|
|
match status {
|
|
AttackStatus::Normal => 0,
|
|
AttackStatus::Suspicious => 1,
|
|
AttackStatus::UnderAttack => 2,
|
|
}
|
|
}
|
|
|
|
/// Entry point of the edge daemon (`rampart`).
|
|
///
|
|
/// Returns [`RunExit`]; the binary decides whether and how the process ends.
|
|
///
|
|
/// # Errors
|
|
/// Startup failures: unreadable config, empty protocol registry, listener error.
|
|
pub async fn run() -> anyhow::Result<RunExit> {
|
|
tracing_subscriber::fmt()
|
|
.with_env_filter(EnvFilter::from_default_env().add_directive("rampart=info".parse()?))
|
|
.init();
|
|
|
|
let config_path = std::env::var("RAMPART_CONFIG").unwrap_or_else(|_| "/etc/rampart/config.toml".to_string());
|
|
let config = Arc::new(Config::from_file(&config_path)?);
|
|
|
|
let registry = Arc::new(build_registry(&config));
|
|
if registry.is_empty() {
|
|
anyhow::bail!(
|
|
"no protocol plugins compiled; available feature flags: protocol-http, \
|
|
store-redis, geoip, xdp, io-uring. Build with --features protocol-http \
|
|
or link an external ProtocolHandler implementation"
|
|
);
|
|
}
|
|
let whitelist = build_whitelist(&config)?;
|
|
|
|
let rate_limiter = Arc::new(RateLimiter::new(
|
|
config.limits.rate_limit_pps,
|
|
config.limits.rate_limit_burst,
|
|
));
|
|
let blacklist = Arc::new(Blacklist::new());
|
|
let reputation = Arc::new(IpReputation::new());
|
|
let detector = Arc::new(Mutex::new(AttackDetector::new()));
|
|
let hook = Arc::new(TrafficHook::new(
|
|
reputation.clone(),
|
|
blacklist.clone(),
|
|
config.detect.autoban.clone(),
|
|
config.ban.ban_duration_secs,
|
|
));
|
|
let alert_dispatcher = AlertDispatcher::new();
|
|
let webhook_url = config.detect.alert.webhook_url.clone();
|
|
let allowed_1s = Arc::new(AtomicU64::new(0));
|
|
|
|
let (shutdown_tx, shutdown_rx) = watch::channel(false);
|
|
let (drain_tx, drain_rx) = oneshot::channel();
|
|
|
|
spawn_shutdown_drain(shutdown_tx.clone(), drain_tx);
|
|
|
|
#[cfg(feature = "store-redis")]
|
|
if let Some(redis_url) = &config.store.redis_url
|
|
&& !redis_url.is_empty()
|
|
{
|
|
let bl = blacklist.clone();
|
|
let sd = shutdown_rx.clone();
|
|
let url = redis_url.clone();
|
|
tokio::spawn(async move {
|
|
let client = match redis::Client::open(url.as_str()) {
|
|
Ok(c) => c,
|
|
Err(e) => {
|
|
tracing::warn!("Invalid redis_url: {e}, blacklist sync disabled");
|
|
return;
|
|
},
|
|
};
|
|
let local_events = bl.subscribe_local_bans();
|
|
let publisher_client = client.clone();
|
|
let publisher_blacklist = bl.clone();
|
|
let publisher_shutdown = sd.clone();
|
|
tokio::spawn(async move {
|
|
crate::store::start_local_ban_publisher(
|
|
publisher_client,
|
|
publisher_blacklist,
|
|
local_events,
|
|
publisher_shutdown,
|
|
)
|
|
.await;
|
|
});
|
|
crate::store::start_blacklist_sync(&client, bl, sd).await;
|
|
});
|
|
}
|
|
|
|
if config.metrics.enabled {
|
|
let metrics_addr = format!("0.0.0.0:{}", config.metrics.port);
|
|
tracing::info!("Metrics server listening on {metrics_addr}");
|
|
tokio::spawn(async move {
|
|
metrics::run_metrics_server(&metrics_addr).await;
|
|
});
|
|
}
|
|
|
|
let clickhouse: Option<Arc<tokio::sync::Mutex<ClickHouseWriter>>> = match &config.store.clickhouse_url {
|
|
Some(url) if !url.is_empty() => {
|
|
let writer = Arc::new(tokio::sync::Mutex::new(ClickHouseWriter::new(url)));
|
|
crate::store::clickhouse::start_flush_task(writer.clone(), shutdown_rx.clone());
|
|
Some(writer)
|
|
},
|
|
_ => None,
|
|
};
|
|
|
|
let xdp_filter = start_xdp(&config, &shutdown_rx, &blacklist)?;
|
|
let subnet_tracker = start_subnet_tracker(&config);
|
|
monitor::spawn(
|
|
&config.detect.prefix,
|
|
Duration::from_secs(config.ban.ban_duration_secs),
|
|
blacklist.clone(),
|
|
!config.proxy_protocol.ingress_enabled,
|
|
subnet_tracker.clone(),
|
|
xdp_filter.clone(),
|
|
shutdown_rx.clone(),
|
|
);
|
|
|
|
let rl = rate_limiter.clone();
|
|
let bl = blacklist.clone();
|
|
let det = detector.clone();
|
|
let intel = hook.clone();
|
|
let a1s = allowed_1s.clone();
|
|
let ch = clickhouse.clone();
|
|
let mut sd = shutdown_rx.clone();
|
|
tokio::spawn(async move {
|
|
let mut sec_tick = tokio::time::interval(Duration::from_secs(1));
|
|
let mut min_tick = tokio::time::interval(Duration::from_secs(60));
|
|
sec_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
|
min_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
|
loop {
|
|
tokio::select! {
|
|
biased;
|
|
_ = sd.changed() => {
|
|
if *sd.borrow() {
|
|
return;
|
|
}
|
|
}
|
|
_ = sec_tick.tick() => {
|
|
let pps = a1s.swap(0, Ordering::Relaxed) as f64;
|
|
let cps = intel.take_cps() as f64;
|
|
metrics::INTEL_CPS.set(cps as i64);
|
|
let status = det.lock().expect("detector lock poisoned").analyze(pps, cps);
|
|
metrics::ATTACK_STATUS.set(attack_status_value(status));
|
|
if let Some(alert) = alert_dispatcher.on_status(status) {
|
|
// Deduplication: an alert is emitted only on an attack state transition.
|
|
metrics::INTEL_ALERTS_TOTAL.inc();
|
|
tracing::warn!(pps, cps, "{alert}");
|
|
push_attack_event(&ch, pps).await;
|
|
if let Some(url) = webhook_url.clone() {
|
|
tokio::spawn(send_webhook(url, alert.clone()));
|
|
}
|
|
}
|
|
if status == AttackStatus::UnderAttack {
|
|
let banned = intel.ban_offenders();
|
|
if banned > 0 {
|
|
tracing::info!(banned, "escalation: offenders auto-banned during attack");
|
|
}
|
|
}
|
|
}
|
|
_ = min_tick.tick() => {
|
|
rl.sweep();
|
|
bl.clear_expired();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
tracing::info!("Rampart edge starting on {}:{}", config.bind.address, config.bind.port);
|
|
tracing::info!("Upstreams: {:?}", config.backend.upstreams);
|
|
|
|
// The configured difficulty is the floor and the starting point; the
|
|
// adjuster only raises it under load.
|
|
let adjuster = Arc::new(Mutex::new(DifficultyAdjuster::with_floor(config.pow.difficulty)));
|
|
let gateway = Arc::new(Gateway::new(
|
|
config.clone(),
|
|
rate_limiter,
|
|
blacklist,
|
|
adjuster,
|
|
whitelist,
|
|
reputation,
|
|
xdp_filter,
|
|
clickhouse,
|
|
allowed_1s,
|
|
registry,
|
|
subnet_tracker,
|
|
));
|
|
tokio::select! {
|
|
result = listener::run(config, gateway, hook, shutdown_rx) => {
|
|
result?;
|
|
Ok(RunExit::Ok)
|
|
}
|
|
// The drain timeout fired: hand the signal back so the binary can end the
|
|
// process immediately, replacing the former `process::exit(0)`.
|
|
_ = drain_rx => Ok(RunExit::DrainTimeout),
|
|
}
|
|
}
|
|
|
|
async fn push_attack_event(writer: &Option<Arc<tokio::sync::Mutex<ClickHouseWriter>>>, pps: f64) {
|
|
let Some(writer) = writer else {
|
|
return;
|
|
};
|
|
let event = ClickHouseEvent {
|
|
timestamp: chrono::Utc::now(),
|
|
event_type: "attack".to_string(),
|
|
ip: String::new(),
|
|
data_float: pps,
|
|
data_int: 0,
|
|
data_string: "under_attack".to_string(),
|
|
};
|
|
if let Err(e) = writer.lock().await.push(event).await {
|
|
tracing::debug!("clickhouse push error: {e}");
|
|
}
|
|
}
|