guard/src/app/runtime.rs
loki5512344 f85ea6c380
feat(xdp): auto-ban from ringbuf events; fix feature gating, exit path, pow flake
- xdp: real 24-byte xdp_event parsing (fixes LE byte-swap of src IP),
  opt-in [xdp] auto_ban (RATE_LIMIT always, CONN_DROP at fails>=threshold;
  EVENT_BAN/POLICY_DROP excluded by design), rampart_xdp_autobans_total;
  wired in app before load(); 10 tests in tests/xdp_events.rs
- build: --no-default-features compiles — redis paths cfg-gated behind
  store-redis, manager fail-fasts without it; CI gates the config now
- app: RunExit enum replaces process::exit in lib; single exit site in main
- tests: seed PoW roundtrip token (was ~1/16 flaky; 50 pre-fix fails -> 0)
- docs: TODO statuses refreshed (round 2)
2026-09-16 00:49:41 +02:00

219 lines
8.3 KiB
Rust

//! Runtime edge-демона: сборка компонентов, фоновые задачи и запуск listener.
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,
}
}
/// Точка входа edge-демона (`rampart`): то, что делал `main` бинаря.
///
/// Возвращает [`RunExit`] — выбор кода и самого завершения делает бинарь.
///
/// # Errors
/// Ошибки старта: нечитаемый конфиг, пустой реестр протоколов, сбой listener.
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;
},
};
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,
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) {
// Дедупликация: алерт только на переходе состояния атаки.
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);
let adjuster = Arc::new(Mutex::new(DifficultyAdjuster::default()));
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)
}
// Drain-таймаут сработал: возвращаем сигнал бинарю завершить процесс
// немедленно, как это делал прежний `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}");
}
}