feat!: universal redesign — drop Minecraft stack, single-crate architecture

- remove Java plugins (velocity/paper), dashboard, all MC-specific code
  (handshake, death_code, varint, hostname-HMAC); available in history pre-v0.2
- merge crates/* into one package with src/bin/{rampart,rampart-manager,rampart-cli}
- ProtocolHandler trait + registry (no implementations yet), universal PoW kept
- XDP: universal L3/L4 filter (xdp/core/) + pluggable hook API (xdp/hooks/),
  fix IPv6 saddr bug; clang build verified
- docs: bilingual knowledge base (docs/kb/: attacks x4, defense-levels,
  practice x3), rewrite README/architecture for universal concept
- TODO.md v4.0: <=300-line module limit, competitor benchmark section (ref/)
- deploy/CI/docs cleanup: no MC references, new binary names

cargo build/clippy(-D warnings)/test green (55 tests)
This commit is contained in:
Loki 2026-08-24 01:50:22 +02:00
parent 7d15dfd45e
commit 08e26df73f
Signed by: boba
GPG key ID: 6CDE87BC9A778D97
179 changed files with 5044 additions and 11519 deletions

80
src/traffic/alert.rs Normal file
View file

@ -0,0 +1,80 @@
use std::fmt;
use std::net::Ipv4Addr;
use std::time::Instant;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AlertLevel {
Info,
Warning,
Critical,
}
impl fmt::Display for AlertLevel {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
AlertLevel::Info => write!(f, "INFO"),
AlertLevel::Warning => write!(f, "WARNING"),
AlertLevel::Critical => write!(f, "CRITICAL"),
}
}
}
#[derive(Clone)]
pub struct Alert {
pub level: AlertLevel,
pub message: String,
pub ip: Option<Ipv4Addr>,
pub pps: f64,
pub timestamp: Instant,
}
impl Alert {
pub fn new(level: AlertLevel, message: String, ip: Option<Ipv4Addr>, pps: f64) -> Self {
Self {
level,
message,
ip,
pps,
timestamp: Instant::now(),
}
}
}
impl fmt::Display for Alert {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.ip {
Some(ip) => write!(
f,
"[{}] {} | IP: {} | PPS: {:.2}",
self.level, self.message, ip, self.pps
),
None => write!(f, "[{}] {} | PPS: {:.2}", self.level, self.message, self.pps),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_alert_display_with_ip() {
let alert = Alert::new(
AlertLevel::Critical,
"possible attack".into(),
Some(Ipv4Addr::new(192, 168, 1, 1)),
100500.0,
);
let s = alert.to_string();
assert!(s.contains("CRITICAL"));
assert!(s.contains("192.168.1.1"));
}
#[test]
fn test_alert_display_without_ip() {
let alert = Alert::new(AlertLevel::Info, "traffic spike".into(), None, 5000.0);
let s = alert.to_string();
assert!(s.contains("INFO"));
assert!(s.contains("traffic spike"));
}
}

93
src/traffic/detector.rs Normal file
View file

@ -0,0 +1,93 @@
use crate::traffic::profiler::TrafficProfiler;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AttackStatus {
Normal,
Suspicious,
UnderAttack,
}
pub struct AttackDetector {
profiler: TrafficProfiler,
consecutive_anomalies: u32,
}
impl Default for AttackDetector {
fn default() -> Self {
Self::new()
}
}
impl AttackDetector {
pub fn new() -> Self {
Self {
profiler: TrafficProfiler::new(),
consecutive_anomalies: 0,
}
}
pub fn analyze(&mut self, pps: f64) -> AttackStatus {
self.profiler.record(pps);
let score = self.profiler.anomaly_score(pps);
if score > 3.0 {
self.consecutive_anomalies += 1;
} else {
self.consecutive_anomalies = 0;
}
if self.consecutive_anomalies >= 3 {
AttackStatus::UnderAttack
} else if score > 2.0 {
AttackStatus::Suspicious
} else {
AttackStatus::Normal
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_attack_status_normal() {
let mut d = AttackDetector::new();
for _ in 0..10 {
d.analyze(100.0);
}
assert_eq!(d.analyze(100.0), AttackStatus::Normal);
}
#[test]
fn test_attack_status_suspicious() {
let mut d = AttackDetector::new();
for _ in 0..10 {
d.analyze(1.0);
}
assert_eq!(d.analyze(5.0), AttackStatus::Suspicious);
}
#[test]
fn test_attack_status_under_attack() {
let mut d = AttackDetector::new();
for _ in 0..10 {
d.analyze(1.0);
}
d.analyze(10_000.0);
d.analyze(10_000.0);
assert_eq!(d.analyze(10_000.0), AttackStatus::UnderAttack);
}
#[test]
fn test_consecutive_resets_on_normal() {
let mut d = AttackDetector::new();
for _ in 0..10 {
d.analyze(1.0);
}
d.analyze(100.0);
d.analyze(100.0);
d.analyze(1.0);
assert_eq!(d.analyze(1.0), AttackStatus::Normal);
}
}

57
src/traffic/ewma.rs Normal file
View file

@ -0,0 +1,57 @@
use std::time::Instant;
pub struct Ewma {
value: f64,
last: Instant,
alpha: f64,
}
impl Ewma {
pub fn new(alpha: f64) -> Self {
Self {
value: 0.0,
last: Instant::now(),
alpha,
}
}
pub fn update(&mut self, sample: f64) {
let now = Instant::now();
let elapsed = now.duration_since(self.last).as_secs_f64();
let steps = elapsed.max(1.0);
let weight = (1.0 - self.alpha).powf(steps);
self.value = self.value * weight + sample * (1.0 - weight);
self.last = now;
}
pub fn value(&self) -> f64 {
self.value
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_ewma_initial() {
let ewma = Ewma::new(0.125);
assert_eq!(ewma.value(), 0.0);
}
#[test]
fn test_ewma_update() {
let mut ewma = Ewma::new(1.0);
ewma.update(100.0);
assert!((ewma.value() - 100.0).abs() < 1.0);
}
#[test]
fn test_ewma_convergence() {
let mut ewma = Ewma::new(0.5);
for _ in 0..10 {
ewma.update(50.0);
}
assert!((ewma.value() - 50.0).abs() < 1.0);
}
}

7
src/traffic/mod.rs Normal file
View file

@ -0,0 +1,7 @@
//! Профилирование трафика, детектор атак и репутация IP.
pub mod alert;
pub mod detector;
pub mod ewma;
pub mod profiler;
pub mod reputation;

85
src/traffic/profiler.rs Normal file
View file

@ -0,0 +1,85 @@
use crate::traffic::ewma::Ewma;
use std::time::Instant;
pub struct TrafficProfiler {
slots: [Ewma; 168],
current_slot: usize,
epoch: Instant,
}
impl Default for TrafficProfiler {
fn default() -> Self {
Self::new()
}
}
impl TrafficProfiler {
pub fn new() -> Self {
Self {
slots: std::array::from_fn(|_| Ewma::new(0.125)),
current_slot: 0,
epoch: Instant::now(),
}
}
fn slot_index(&self) -> usize {
(self.epoch.elapsed().as_secs() / 3600) as usize % 168
}
pub fn record(&mut self, pps: f64) {
self.current_slot = self.slot_index();
self.slots[self.current_slot].update(pps);
}
pub fn baseline(&self) -> f64 {
self.slots[self.slot_index()].value()
}
pub fn anomaly_score(&self, pps: f64) -> f64 {
let base = self.baseline();
if base <= 0.0 {
return 0.0;
}
(pps / base).min(10.0)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_profiler_record_and_baseline() {
let mut p = TrafficProfiler::new();
p.record(1000.0);
p.record(1100.0);
let base = p.baseline();
assert!(base > 0.0);
}
#[test]
fn test_anomaly_score_normal() {
let mut p = TrafficProfiler::new();
for _ in 0..10 {
p.record(100.0);
}
let score = p.anomaly_score(100.0);
assert!(score < 2.0);
}
#[test]
fn test_anomaly_score_capped() {
let mut p = TrafficProfiler::new();
for _ in 0..10 {
p.record(1.0);
}
let score = p.anomaly_score(1_000_000.0);
assert!((score - 10.0).abs() < 0.001);
}
#[test]
fn test_anomaly_score_zero_baseline() {
let p = TrafficProfiler::new();
assert_eq!(p.anomaly_score(100.0), 0.0);
}
}

110
src/traffic/reputation.rs Normal file
View file

@ -0,0 +1,110 @@
use dashmap::DashMap;
use std::net::IpAddr;
use std::sync::Arc;
pub struct IpReputation {
scores: Arc<DashMap<IpAddr, i32>>,
}
impl Default for IpReputation {
fn default() -> Self {
Self::new()
}
}
impl IpReputation {
pub fn new() -> Self {
Self {
scores: Arc::new(DashMap::new()),
}
}
pub fn record_good(&self, ip: IpAddr) {
let mut entry = self.scores.entry(ip).or_insert(0);
*entry = (*entry + 1).min(100);
}
pub fn record_bad(&self, ip: IpAddr) {
let mut entry = self.scores.entry(ip).or_insert(0);
*entry = (*entry - 10).max(-100);
}
pub fn score(&self, ip: IpAddr) -> i32 {
self.scores.get(&ip).map(|v| *v).unwrap_or(0)
}
pub fn is_trusted(&self, ip: IpAddr) -> bool {
self.score(ip) > 50
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
fn v4(octets: [u8; 4]) -> IpAddr {
IpAddr::V4(Ipv4Addr::from(octets))
}
#[test]
fn test_reputation_initial_score() {
let rep = IpReputation::new();
assert_eq!(rep.score(v4([192, 168, 1, 1])), 0);
}
#[test]
fn test_reputation_good() {
let rep = IpReputation::new();
let ip = v4([10, 0, 0, 1]);
rep.record_good(ip);
assert_eq!(rep.score(ip), 1);
}
#[test]
fn test_reputation_bad() {
let rep = IpReputation::new();
let ip = v4([10, 0, 0, 2]);
rep.record_bad(ip);
assert_eq!(rep.score(ip), -10);
}
#[test]
fn test_reputation_cap_positive() {
let rep = IpReputation::new();
let ip = v4([10, 0, 0, 3]);
for _ in 0..200 {
rep.record_good(ip);
}
assert_eq!(rep.score(ip), 100);
}
#[test]
fn test_reputation_cap_negative() {
let rep = IpReputation::new();
let ip = v4([10, 0, 0, 4]);
for _ in 0..20 {
rep.record_bad(ip);
}
assert_eq!(rep.score(ip), -100);
}
#[test]
fn test_is_trusted() {
let rep = IpReputation::new();
let ip = v4([10, 0, 0, 5]);
assert!(!rep.is_trusted(ip));
for _ in 0..51 {
rep.record_good(ip);
}
assert!(rep.is_trusted(ip));
}
#[test]
fn test_reputation_v6() {
let rep = IpReputation::new();
let ip = IpAddr::V6(Ipv6Addr::LOCALHOST);
rep.record_bad(ip);
assert_eq!(rep.score(ip), -10);
}
}