protocol-http (compile-time feature): - HttpHandler: incremental HTTP/1.1 request parse (fragment-safe), header size/timeout limits, method whitelist, Host required, blocked_paths, optional User-Agent requirement - [protocol.http] config section; registry wiring behind feature XDP globals: - src/xdp/globals.rs: XdpGlobals + build_rodata_image() mirroring xdp/core/config.h layout; set via OpenMapMut::set_initial_value() before load ([xdp] section: ports, udp policy, throttle, challenge) - wire set_globals into rampart binary startup fix: gate preflight() behind xdp feature (dead code without it)
404 lines
10 KiB
Rust
404 lines
10 KiB
Rust
//! Секции единого конфига платформы.
|
||
|
||
use serde::Deserialize;
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct BindConfig {
|
||
#[serde(default = "default_bind_address")]
|
||
pub address: String,
|
||
#[serde(default = "default_bind_port")]
|
||
pub port: u16,
|
||
}
|
||
|
||
impl Default for BindConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
address: default_bind_address(),
|
||
port: default_bind_port(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_bind_address() -> String {
|
||
"0.0.0.0".to_string()
|
||
}
|
||
fn default_bind_port() -> u16 {
|
||
25565
|
||
}
|
||
|
||
/// Generic upstream-бэкенды (список addr:port) за edge-нодой.
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct BackendConfig {
|
||
#[serde(default = "default_upstreams")]
|
||
pub upstreams: Vec<String>,
|
||
}
|
||
|
||
impl Default for BackendConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
upstreams: default_upstreams(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_upstreams() -> Vec<String> {
|
||
vec!["127.0.0.1:25566".to_string()]
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct WorkerConfig {
|
||
#[serde(default = "default_worker_count")]
|
||
pub count: usize,
|
||
}
|
||
|
||
impl Default for WorkerConfig {
|
||
fn default() -> Self {
|
||
Self { count: 4 }
|
||
}
|
||
}
|
||
|
||
fn default_worker_count() -> usize {
|
||
4
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct LimitsConfig {
|
||
#[serde(default = "default_handshake_timeout")]
|
||
pub handshake_timeout_secs: u64,
|
||
#[serde(default = "default_max_connections_per_ip")]
|
||
pub max_connections_per_ip: u32,
|
||
#[serde(default = "default_rate_limit_pps")]
|
||
pub rate_limit_pps: f64,
|
||
#[serde(default = "default_rate_limit_burst")]
|
||
pub rate_limit_burst: f64,
|
||
}
|
||
|
||
impl Default for LimitsConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
handshake_timeout_secs: default_handshake_timeout(),
|
||
max_connections_per_ip: default_max_connections_per_ip(),
|
||
rate_limit_pps: default_rate_limit_pps(),
|
||
rate_limit_burst: default_rate_limit_burst(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_handshake_timeout() -> u64 {
|
||
5
|
||
}
|
||
fn default_max_connections_per_ip() -> u32 {
|
||
10
|
||
}
|
||
fn default_rate_limit_pps() -> f64 {
|
||
5.0
|
||
}
|
||
fn default_rate_limit_burst() -> f64 {
|
||
10.0
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct BanConfig {
|
||
#[serde(default = "default_ban_duration")]
|
||
pub ban_duration_secs: u64,
|
||
}
|
||
|
||
impl Default for BanConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
ban_duration_secs: default_ban_duration(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_ban_duration() -> u64 {
|
||
3600
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct StoreConfig {
|
||
pub redis_url: Option<String>,
|
||
#[serde(default = "default_blacklist_cache_ttl")]
|
||
pub blacklist_cache_ttl_secs: u64,
|
||
pub clickhouse_url: Option<String>,
|
||
}
|
||
|
||
impl Default for StoreConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
redis_url: None,
|
||
blacklist_cache_ttl_secs: default_blacklist_cache_ttl(),
|
||
clickhouse_url: None,
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_blacklist_cache_ttl() -> u64 {
|
||
300
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct XdpConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_xdp_interface")]
|
||
pub interface: String,
|
||
#[serde(default = "default_xdp_port_start")]
|
||
pub protected_port_start: u16,
|
||
#[serde(default = "default_xdp_port_end")]
|
||
pub protected_port_end: u16,
|
||
/// "pass" | "drop" | "rate-limit" → G_UDP_POLICY.
|
||
#[serde(default = "default_xdp_udp_policy")]
|
||
pub udp_policy: String,
|
||
#[serde(default = "default_xdp_udp_hit_count")]
|
||
pub udp_rate_hit_count: u32,
|
||
#[serde(default = "default_xdp_udp_window_ms")]
|
||
pub udp_rate_window_ms: u64,
|
||
#[serde(default)]
|
||
pub syn_challenge_enabled: bool,
|
||
/// 128-битный hex (16 символов) для G_CHALLENGE_SECRET; None = плейсхолдер из config.h.
|
||
#[serde(default)]
|
||
pub challenge_secret_hex: Option<String>,
|
||
#[serde(default = "default_xdp_challenge_timeout_ms")]
|
||
pub challenge_timeout_ms: u32,
|
||
#[serde(default = "default_xdp_throttle_enabled")]
|
||
pub throttle_enabled: bool,
|
||
#[serde(default = "default_xdp_events_enabled")]
|
||
pub events_enabled: bool,
|
||
}
|
||
|
||
impl Default for XdpConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
interface: default_xdp_interface(),
|
||
protected_port_start: default_xdp_port_start(),
|
||
protected_port_end: default_xdp_port_end(),
|
||
udp_policy: default_xdp_udp_policy(),
|
||
udp_rate_hit_count: default_xdp_udp_hit_count(),
|
||
udp_rate_window_ms: default_xdp_udp_window_ms(),
|
||
syn_challenge_enabled: false,
|
||
challenge_secret_hex: None,
|
||
challenge_timeout_ms: default_xdp_challenge_timeout_ms(),
|
||
throttle_enabled: default_xdp_throttle_enabled(),
|
||
events_enabled: default_xdp_events_enabled(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_xdp_interface() -> String {
|
||
"eth0".to_string()
|
||
}
|
||
fn default_xdp_port_start() -> u16 {
|
||
1
|
||
}
|
||
fn default_xdp_port_end() -> u16 {
|
||
65535
|
||
}
|
||
fn default_xdp_udp_policy() -> String {
|
||
"pass".to_string()
|
||
}
|
||
fn default_xdp_udp_hit_count() -> u32 {
|
||
100
|
||
}
|
||
fn default_xdp_udp_window_ms() -> u64 {
|
||
1000
|
||
}
|
||
fn default_xdp_challenge_timeout_ms() -> u32 {
|
||
3000
|
||
}
|
||
fn default_xdp_throttle_enabled() -> bool {
|
||
true
|
||
}
|
||
fn default_xdp_events_enabled() -> bool {
|
||
true
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct LoggingConfig {
|
||
#[serde(default = "default_log_level")]
|
||
pub level: String,
|
||
#[serde(default = "default_log_format")]
|
||
pub format: String,
|
||
}
|
||
|
||
impl Default for LoggingConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
level: default_log_level(),
|
||
format: default_log_format(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_log_level() -> String {
|
||
"info".to_string()
|
||
}
|
||
fn default_log_format() -> String {
|
||
"text".to_string()
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct MetricsConfig {
|
||
#[serde(default = "default_metrics_enabled")]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_metrics_port")]
|
||
pub port: u16,
|
||
}
|
||
|
||
impl Default for MetricsConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: default_metrics_enabled(),
|
||
port: default_metrics_port(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_metrics_enabled() -> bool {
|
||
true
|
||
}
|
||
fn default_metrics_port() -> u16 {
|
||
9090
|
||
}
|
||
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct PowConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_pow_difficulty")]
|
||
pub difficulty: u8,
|
||
}
|
||
|
||
impl Default for PowConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
difficulty: default_pow_difficulty(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_pow_difficulty() -> u8 {
|
||
4
|
||
}
|
||
|
||
/// Секция `[detect]`: детекторы распределённых атак.
|
||
#[derive(Debug, Clone, Default, Deserialize)]
|
||
pub struct DetectConfig {
|
||
#[serde(default)]
|
||
pub prefix: DetectPrefixConfig,
|
||
#[serde(default)]
|
||
pub autoban: DetectAutobanConfig,
|
||
#[serde(default)]
|
||
pub alert: DetectAlertConfig,
|
||
}
|
||
|
||
/// Секция `[detect.autoban]`: авто-бан источников по репутации и сигналам
|
||
/// детектора атак. Порог сравнивается со скором [`crate::traffic::reputation::IpReputation`],
|
||
/// TTL берётся из `ban.ban_duration_secs`.
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct DetectAutobanConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_autoban_reputation_threshold")]
|
||
pub reputation_threshold: i32,
|
||
}
|
||
|
||
impl Default for DetectAutobanConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
reputation_threshold: default_autoban_reputation_threshold(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_autoban_reputation_threshold() -> i32 {
|
||
-50
|
||
}
|
||
|
||
/// Секция `[detect.alert]`: webhook-алерты на переходах состояния атаки
|
||
/// («атака началась» / «атака закончилась»).
|
||
#[derive(Debug, Clone, Default, Deserialize)]
|
||
pub struct DetectAlertConfig {
|
||
#[serde(default)]
|
||
pub webhook_url: Option<String>,
|
||
}
|
||
|
||
/// Секция `[detect.prefix]`: subnet-level детектор распределённых атак.
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct DetectPrefixConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_prefix_syn_threshold")]
|
||
pub syn_threshold: u64,
|
||
#[serde(default = "default_prefix_window_secs")]
|
||
pub window_secs: u64,
|
||
#[serde(default = "default_prefix_min_unique_sources")]
|
||
pub min_unique_sources: u64,
|
||
}
|
||
|
||
impl Default for DetectPrefixConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
syn_threshold: default_prefix_syn_threshold(),
|
||
window_secs: default_prefix_window_secs(),
|
||
min_unique_sources: default_prefix_min_unique_sources(),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn default_prefix_syn_threshold() -> u64 {
|
||
500
|
||
}
|
||
fn default_prefix_window_secs() -> u64 {
|
||
10
|
||
}
|
||
fn default_prefix_min_unique_sources() -> u64 {
|
||
16
|
||
}
|
||
|
||
/// Секция `[protocol]`: протокольные обработчики (plugin-by-feature).
|
||
#[cfg(feature = "protocol-http")]
|
||
#[derive(Debug, Clone, Default, Deserialize)]
|
||
pub struct ProtocolConfig {
|
||
#[serde(default)]
|
||
pub http: HttpProtocolConfig,
|
||
}
|
||
|
||
/// Секция `[protocol.http]`: политика HTTP/1.1-обработчика на edge-ноде.
|
||
#[cfg(feature = "protocol-http")]
|
||
#[derive(Debug, Clone, Deserialize)]
|
||
pub struct HttpProtocolConfig {
|
||
#[serde(default = "default_http_max_header_bytes")]
|
||
pub max_header_bytes: usize,
|
||
#[serde(default = "default_http_timeout_secs")]
|
||
pub timeout_secs: u64,
|
||
#[serde(default)]
|
||
pub blocked_paths: Vec<String>,
|
||
#[serde(default)]
|
||
pub require_user_agent: bool,
|
||
}
|
||
|
||
#[cfg(feature = "protocol-http")]
|
||
impl Default for HttpProtocolConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
max_header_bytes: default_http_max_header_bytes(),
|
||
timeout_secs: default_http_timeout_secs(),
|
||
blocked_paths: Vec::new(),
|
||
require_user_agent: false,
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(feature = "protocol-http")]
|
||
fn default_http_max_header_bytes() -> usize {
|
||
8192
|
||
}
|
||
#[cfg(feature = "protocol-http")]
|
||
fn default_http_timeout_secs() -> u64 {
|
||
5
|
||
}
|