Initial commit: Rampart v0.2.0

Multi-layer DDoS protection for Minecraft servers.

- rampart-core: Edge node with XDP/eBPF + Rust L7 filtering
- rampart-manager: REST API with JWT auth, Redis sync
- rampart-cli: CLI tool for operators
- velocity-plugin: Domain check, HMAC verify, server registry, load balancer
- paper-plugin: Auto-registration, heartbeat, HMAC verify
- dashboard: React + Vite web UI for management
This commit is contained in:
Loki 2026-07-20 20:53:32 +02:00
commit cf9608ce5d
Signed by: boba
GPG key ID: 253067914055423B
159 changed files with 15341 additions and 0 deletions

View file

@ -0,0 +1,21 @@
use crate::AppState;
use axum::{Json, extract::State};
use serde::Deserialize;
use std::sync::Arc;
#[derive(Deserialize)]
pub struct LoginRequest {
pub password: String,
}
pub async fn login(State(state): State<Arc<AppState>>, Json(req): Json<LoginRequest>) -> Json<serde_json::Value> {
let api_password = std::env::var("API_PASSWORD").unwrap_or_else(|_| "changeme".to_string());
if req.password != api_password {
return Json(serde_json::json!({"error": "invalid password"}));
}
match crate::auth::create_token(&state.jwt_secret, state.jwt_expiration) {
Ok(token) => Json(serde_json::json!({"token": token})),
Err(_) => Json(serde_json::json!({"error": "token creation failed"})),
}
}

View file

@ -0,0 +1,94 @@
use crate::AppState;
use axum::{Json, extract::State};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
#[derive(Debug, Serialize, Deserialize)]
pub struct BlacklistEntry {
pub target: String,
#[serde(rename = "type")]
pub entry_type: String,
pub reason: String,
pub created_at: String,
pub expires_at: Option<String>,
}
#[derive(Serialize)]
pub struct BlacklistResponse {
pub items: Vec<BlacklistEntry>,
pub total: usize,
}
#[derive(Deserialize)]
#[allow(dead_code)]
pub struct AddBlacklistRequest {
pub target: String,
#[serde(rename = "type")]
pub entry_type: String,
pub reason: String,
pub duration_secs: Option<u64>,
}
pub async fn list_blacklist(State(state): State<Arc<AppState>>) -> Json<BlacklistResponse> {
let mut conn = match state.redis_client.get_multiplexed_async_connection().await {
Ok(c) => c,
Err(_) => {
return Json(BlacklistResponse {
items: vec![],
total: 0,
});
},
};
let members: Vec<String> = match redis::cmd("SMEMBERS")
.arg("rampart:blacklist")
.query_async(&mut conn)
.await
{
Ok(m) => m,
Err(_) => {
return Json(BlacklistResponse {
items: vec![],
total: 0,
});
},
};
let items: Vec<BlacklistEntry> = members
.into_iter()
.map(|target| BlacklistEntry {
target,
entry_type: "ip".to_string(),
reason: "manual".to_string(),
created_at: chrono::Utc::now().to_rfc3339(),
expires_at: None,
})
.collect();
let total = items.len();
Json(BlacklistResponse { items, total })
}
pub async fn add_blacklist(
State(state): State<Arc<AppState>>,
Json(req): Json<AddBlacklistRequest>,
) -> Json<serde_json::Value> {
let mut conn = match state.redis_client.get_multiplexed_async_connection().await {
Ok(c) => c,
Err(_) => return Json(serde_json::json!({"error": "redis unavailable"})),
};
let _: () = redis::cmd("SADD")
.arg("rampart:blacklist")
.arg(&req.target)
.query_async(&mut conn)
.await
.unwrap_or_default();
tracing::info!("Added to blacklist: {} ({})", req.target, req.reason);
Json(serde_json::json!({
"status": "added",
"target": req.target,
"reason": req.reason
}))
}

View file

@ -0,0 +1,18 @@
use crate::AppState;
use axum::Json;
use axum::extract::State;
use serde::Serialize;
use std::sync::Arc;
#[derive(Serialize)]
pub struct HealthResponse {
pub status: String,
pub version: String,
}
pub async fn health_check(State(_state): State<Arc<AppState>>) -> Json<HealthResponse> {
Json(HealthResponse {
status: "healthy".to_string(),
version: env!("CARGO_PKG_VERSION").to_string(),
})
}

View file

@ -0,0 +1,5 @@
pub mod auth;
pub mod blacklist;
pub mod health;
pub mod nodes;
pub mod servers;

View file

@ -0,0 +1,43 @@
use crate::AppState;
use axum::{Json, extract::State};
use redis::AsyncCommands;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
#[derive(Debug, Serialize, Deserialize)]
pub struct NodeInfo {
pub id: String,
pub role: String,
pub ip: String,
pub status: String,
pub last_heartbeat: String,
}
#[derive(Serialize)]
pub struct NodesResponse {
pub nodes: Vec<NodeInfo>,
}
pub async fn list_nodes(State(state): State<Arc<AppState>>) -> Json<NodesResponse> {
let mut conn = match state.redis_client.get_multiplexed_async_connection().await {
Ok(c) => c,
Err(_) => return Json(NodesResponse { nodes: vec![] }),
};
let keys: Vec<String> = match redis::cmd("KEYS").arg("rampart:nodes:*").query_async(&mut conn).await {
Ok(k) => k,
Err(_) => return Json(NodesResponse { nodes: vec![] }),
};
let mut nodes = Vec::with_capacity(keys.len());
for key in &keys {
let raw: Option<String> = conn.get(key).await.unwrap_or(None);
if let Some(json) = raw
&& let Ok(node) = serde_json::from_str::<NodeInfo>(&json)
{
nodes.push(node);
}
}
Json(NodesResponse { nodes })
}

View file

@ -0,0 +1,47 @@
use crate::AppState;
use axum::{Json, extract::State};
use redis::AsyncCommands;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
#[derive(Debug, Serialize, Deserialize)]
pub struct ServerEntry {
pub name: String,
#[serde(rename = "type")]
pub server_type: String,
pub ip: String,
pub port: u16,
pub status: String,
pub online: u32,
pub max_players: u32,
pub tps: f64,
}
#[derive(Serialize)]
pub struct ServersResponse {
pub servers: Vec<ServerEntry>,
}
pub async fn list_servers(State(state): State<Arc<AppState>>) -> Json<ServersResponse> {
let mut conn = match state.redis_client.get_multiplexed_async_connection().await {
Ok(c) => c,
Err(_) => return Json(ServersResponse { servers: vec![] }),
};
let keys: Vec<String> = match redis::cmd("KEYS").arg("rampart:servers:*").query_async(&mut conn).await {
Ok(k) => k,
Err(_) => return Json(ServersResponse { servers: vec![] }),
};
let mut servers = Vec::with_capacity(keys.len());
for key in &keys {
let raw: Option<String> = conn.get(key).await.unwrap_or(None);
if let Some(json) = raw
&& let Ok(server) = serde_json::from_str::<ServerEntry>(&json)
{
servers.push(server);
}
}
Json(ServersResponse { servers })
}