[object Object]
Minecraft RCON Protokoll Absicherung: Socket-Hardening & Anti-Brute-Force
Das Remote Console (RCON) Protokoll von Minecraft ermöglicht die Ausführung beliebiger Server-Befehle über eine TCP-Verbindung. Ein Angreifer, der ein RCON-Passwort knackt, erhält uneingeschränkte Administrator-Rechte auf dem Server (op, stop, whitelist off, Ausführung von NBT-Befehlen). Da das originale Source-RCON-Protokoll aus dem Jahr 2004 stammt und von Haus aus weder Verschlüsselung noch Brute-Force-Schutz bietet, erfordert der Betrieb im Internet strikte Sicherheitsmaßnahmen.
In dieser Anleitung analysieren wir typische RCON-Angriffsvektoren und demonstrieren, wie wir die Minecraft Cloud Bridge auf KiroCloud gegen Angriffe absichern.
1. Schwachstellen des nativen RCON-Protokolls
Das Standard-RCON-Protokoll von Minecraft Vanilla und PaperMC weist gravierende Schwachstellen auf:
- Keine Transportverschlüsselung: Passwörter und Konsolenausgaben werden im Klartext über TCP übertragen. In unverschlüsselten Netzwerken können sie per Paket-Sniffing (
tcpdump, Wireshark) mitgelesen werden. - Fehlendes Rate-Limiting: Der Minecraft-Server begrenzt fehlgeschlagene Login-Versuche nicht. Angreifer können Tausende Passwörter pro Sekunde ausprobieren, ohne gesperrt zu werden.
- Pufferüberläufe & Single-Threaded Bottlenecks: Ein TCP-SYN-Flood oder das Senden von Paketen mit manipulierter Längenangabe kann den Haupt-Server-Thread blockieren und TPS-Einbrüche verursachen.
2. Architektonische Schutzschichten
Um diese Risiken zu eliminieren, darf der RCON-Port niemals direkt im öffentlichen Internet erreichbar sein. Auf KiroCloud wird folgende Architektur erzwungen:
┌────────────────────────────────┐
│ KiroCloud Dashboard Server │
└───────────────┬────────────────┘
│ TLS-gesicherter interner Tunnel (WireGuard / VPN)
▼
┌────────────────────────────────┐
│ Reverse Proxy / RCON Gateway │ ◄─── Fail2ban / IP Whitelist
└───────────────┬────────────────┘
│ Loopback Socket (127.0.0.1:25575)
▼
┌────────────────────────────────┐
│ Minecraft Server Prozess │
└────────────────────────────────┘
3. Implementierung eines Anti-Brute-Force Proxys mit Node.js
Wenn du eine externe Bridge für RCON betreibst, fange fehlgeschlagene Login-Versuche mit einer Token-Bucket-Rate-Limitierung ab:
import net from 'node:net';
interface FailedAttempt {
count: number;
blockedUntil: number;
}
const failedLogins = new Map<string, FailedAttempt>();
const MAX_ATTEMPTS = 5;
const LOCKOUT_MS = 15 * 60 * 1000; // 15 Minuten Sperre
export function createProtectedRconClient(host: string, port: number, clientIp: string) {
const now = Date.now();
const state = failedLogins.get(clientIp);
if (state && state.blockedUntil > now) {
const remainingSec = Math.ceil((state.blockedUntil - now) / 1000);
throw new Error(`IP ${clientIp} ist wegen zu vieler Fehlversuche für noch ${remainingSec}s gesperrt.`);
}
const socket = new net.Socket();
socket.connect(port, host);
// Authentifizierungslogik & Paketverarbeitung
socket.on('data', (data) => {
// Bei RCON gibt Type 2 (SERVERDATA_AUTH_RESPONSE) mit ID -1 einen Fehlschlag an
const responseId = data.readInt32LE(4);
if (responseId === -1) {
const attempts = (state?.count ?? 0) + 1;
console.warn(`[RCON Security] Fehlgeschlagener RCON-Login von ${clientIp} (Versuch ${attempts}/${MAX_ATTEMPTS})`);
if (attempts >= MAX_ATTEMPTS) {
failedLogins.set(clientIp, { count: attempts, blockedUntil: now + LOCKOUT_MS });
socket.destroy();
} else {
failedLogins.set(clientIp, { count: attempts, blockedUntil: 0 });
}
}
});
return socket;
}
4. Server-Konfiguration: Best Practices in server.properties
Konfiguriere deinen Minecraft-Server nach folgenden Regeln:
# RCON aktivieren
enable-rcon=true
# Port niemals auf 0.0.0.0 binden, sondern nur auf localhost
rcon.port=25575
server-ip=127.0.0.1
# Starkes, kryptografisch zufälliges Passwort (mindestens 32 Zeichen, z. B. via: openssl rand -base64 24)
rcon.password=DEIN_SICHERES_32_STELLIGES_PASSWORT
# Broadcast-Nachrichten an OPs einschränken
broadcast-rcon-to-ops=false
5. Befehls-Sanitisierung gegen Command-Injection
Wenn dein Discord-Bot RCON-Befehle aus Nutzeingaben generiert (z. B. /whitelist add [Name]), musst du Eingaben strikt validieren:
// GEFÄHRLICH: Angreifer könnte 'luca\nop luca' übergeben!
const badCommand = `whitelist add ${userInput}`;
// SICHER: Nur alphanumerische Zeichen und Unterstriche erlauben
export function sanitizePlayerName(name: string): string {
if (!/^[a-zA-Z0-9_]{3,16}$/.test(name)) {
throw new Error('Ungültiger Spielername (nur 3-16 Buchstaben, Zahlen und Unterstriche erlaubt).');
}
return name;
}
Mit dieser doppelten Absicherung aus Loopback-Isolation und strikter Befehlsvalidierung bleibt dein Minecraft-Server gegen unberechtigte RCON-Zugriffe geschützt.
Luca Lichtenwald
Spezialisiert auf hochverfügbare Discord-Bot-Infrastrukturen, V8-Memory-Tuning und kryptografische Zero-Trust-Architekturen.