Fortgeschrittener VPS-Hardening-Leitfaden: Sichern Sie Ihren Server wie ein Profi

Eine einfache VPS-Einrichtung lässt Sie ungeschützt. Standardkonfigurationen, offene Ports und schwache Authentifizierung sind eine offene Einladung. Dieser Leitfaden geht über die Grundlagen hinaus — Kernel-Härtung, Einbruchserkennung, automatisierte Blockierung und Audit-Protokollierung, die Bedrohungen tatsächlich erkennt.

Sie haben bereits SSH-Schlüssel und eine Firewall? Gut. Hier setzen wir an, wo Anfänger-Leitfäden aufhören.

Was dieser Leitfaden abdeckt

Ebene	Werkzeuge	Zweck
Netzwerk	UFW, iptables, fail2ban	Unbefugten Zugriff blockieren
Authentifizierung	SSH-Härtung, 2FA	Brute-Force verhindern
Kernel	sysctl-Tuning	Angriffsfläche reduzieren
Obligatorische Zugriffskontrolle	AppArmor / SELinux	Kompromittierte Dienste eindämmen
Einbruchserkennung	AIDE, auditd	Unbefugte Änderungen erkennen
Protokollierung	rsyslog, logwatch	Alles überwachen
Automatische Updates	unattended-upgrades	Sicherheitslücken patchen

Voraussetzungen

• Ein VPS mit Ubuntu 22.04+ oder Debian 12+ (die meisten Beispiele funktionieren mit geringfügigen Anpassungen auch auf RHEL/Rocky)
• SSH-Schlüssel-Authentifizierung bereits konfiguriert
• Root- oder sudo-Zugriff
• Grundlegende Vertrautheit mit der Linux-Kommandozeile

Empfohlene VPS-Anbieter für sicherheitsbewusste Nutzer:

Anbieter	Warum	Einstiegspreis
Hetzner	EU-Rechenzentren, DSGVO-konform, rohe Leistung	3,79 €/Monat
Hostinger	Erschwingliche KVM mit Snapshot-Backups	4,99 $/Monat
Vultr	Bare-Metal-Optionen, DDoS-Schutz inklusive	6 $/Monat
DigitalOcean	VPC-Netzwerk, verwaltete Firewalls	6 $/Monat

1. SSH-Härtung (über die Grundlagen hinaus)

Sie haben bereits schlüsselbasierte Authentifizierung. Jetzt sichern wir es weiter ab.

SSH auf Nur-Schlüssel beschränken, Root deaktivieren

sudo nano /etc/ssh/sshd_config

Setzen Sie diese Werte:

# Authentifizierung
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
AuthenticationMethods publickey

# Exposition begrenzen
MaxAuthTries 3
MaxSessions 3
LoginGraceTime 30
ClientAliveInterval 300
ClientAliveCountMax 2

# Unnötige Funktionen deaktivieren
X11Forwarding no
AllowTcpForwarding no
AllowAgentForwarding no
PermitTunnel no

# Nur starke Algorithmen verwenden
KexAlgorithms skedf25519-sha256,skedf25519-sha256@libssh.org,diffie-hellman-group16-sha512
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com

Standard-SSH-Port ändern

SSH vom Port 22 wegzuverlegen stoppt die meisten automatisierten Scans:

# Neuen Port hinzufügen (Port 22 noch nicht entfernen!)
Port 2222
Port 22

Starten Sie den Dienst neu und testen Sie mit dem neuen Port, bevor Sie 22 entfernen:

sudo systemctl restart sshd
ssh -p 2222 user@your-server

Sobald bestätigt, entfernen Sie Port 22 und starten Sie erneut neu.

Zwei-Faktor-Authentifizierung hinzufügen

sudo apt install libpam-google-authenticator
google-authenticator

PAM-Konfiguration bearbeiten:

sudo nano /etc/pam.d/sshd

Am Anfang hinzufügen:

auth required pam_google_authenticator.so

sshd_config aktualisieren:

AuthenticationMethods publickey,keyboard-interactive
ChallengeResponseAuthentication yes

Jetzt erfordern Anmeldungen sowohl Ihren SSH-Schlüssel als auch einen TOTP-Code.

2. Firewall-Konfiguration mit UFW + Ratenbegrenzung

Grundlegende UFW-Einrichtung

sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH erlauben (verwenden Sie Ihren benutzerdefinierten Port)
sudo ufw limit 2222/tcp comment 'SSH rate-limited'

# Web-Traffic erlauben
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'

# Aktivieren
sudo ufw enable

Die limit-Regel begrenzt automatisch die Verbindungsrate — 6 Verbindungen pro 30 Sekunden, danach wird blockiert.

Fortgeschritten: iptables-Regeln zur DDoS-Abwehr

Für Server unter hohem Traffic fügen Sie diese iptables-Regeln hinzu:

# Ungültige Pakete verwerfen
sudo iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

# Port-Scanning blockieren
sudo iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
sudo iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP

# Neue Verbindungen ratenbegrenzen (SYN-Flood-Schutz)
sudo iptables -A INPUT -p tcp --syn -m limit --limit 25/second --limit-burst 50 -j ACCEPT
sudo iptables -A INPUT -p tcp --syn -j DROP

# ICMP begrenzen (Ping-Flood-Schutz)
sudo iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s --limit-burst 4 -j ACCEPT
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

Regeln speichern, damit sie nach Neustarts bestehen bleiben:

sudo apt install iptables-persistent
sudo netfilter-persistent save

3. Fail2Ban: Intelligenter Brute-Force-Schutz

Installation und Konfiguration

sudo apt install fail2ban
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

/etc/fail2ban/jail.local bearbeiten:

[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 3
banaction = ufw
backend = systemd

# E-Mail-Benachrichtigungen (optional)
destemail = you@example.com
action = %(action_mwl)s

[sshd]
enabled = true
port = 2222
maxretry = 3
bantime = 86400

[sshd-ddos]
enabled = true
port = 2222

# nginx schützen
[nginx-http-auth]
enabled = true
filter = nginx-http-auth
logpath = /var/log/nginx/error.log
maxretry = 3

[nginx-botsearch]
enabled = true
filter = nginx-botsearch
logpath = /var/log/nginx/access.log
maxretry = 2

# Schutz vor wiederholten 404-Fehlern (Scanner)
[nginx-404]
enabled = true
port = http,https
filter = nginx-404
logpath = /var/log/nginx/access.log
maxretry = 10
findtime = 60
bantime = 3600

Den nginx-404-Filter erstellen:

sudo nano /etc/fail2ban/filter.d/nginx-404.conf

[Definition]
failregex = ^<HOST> .* "(GET|POST|HEAD).*" 404
ignoreregex =

fail2ban starten:

sudo systemctl enable fail2ban
sudo systemctl start fail2ban
sudo fail2ban-client status

4. Kernel-Härtung mit sysctl

Diese Einstellungen reduzieren die Angriffsfläche Ihres Kernels:

sudo nano /etc/sysctl.d/99-hardening.conf

# IP-Weiterleitung deaktivieren (außer bei Docker/VPN-Betrieb)
net.ipv4.ip_forward = 0
net.ipv6.conf.all.forwarding = 0

# IP-Spoofing verhindern
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# ICMP-Umleitungen ignorieren
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv6.conf.all.accept_redirects = 0

# Keine ICMP-Umleitungen senden
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0

# Quellgeroutete Pakete ignorieren
net.ipv4.conf.all.accept_source_route = 0
net.ipv6.conf.all.accept_source_route = 0

# SYN-Cookies aktivieren (SYN-Flood-Schutz)
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 2048
net.ipv4.tcp_synack_retries = 2

# Verdächtige Pakete protokollieren
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1

# IPv6 deaktivieren, falls nicht benötigt
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1

# Kernel härten
kernel.randomize_va_space = 2
kernel.kptr_restrict = 2
kernel.dmesg_restrict = 1
kernel.perf_event_paranoid = 3
kernel.yama.ptrace_scope = 2

# Unprivilegierte User-Namespaces einschränken
kernel.unprivileged_userns_clone = 0

# Dateisystem-Härtung
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
fs.suid_dumpable = 0

Sofort anwenden:

sudo sysctl --system

Docker-Nutzer: Behalten Sie net.ipv4.ip_forward = 1 bei, wenn Sie Container betreiben. Docker benötigt dies für die Netzwerkkommunikation.

5. AppArmor: Obligatorische Zugriffskontrolle

AppArmor beschränkt Programme auf eine begrenzte Menge von Ressourcen — selbst wenn ein Angreifer eine Schwachstelle ausnutzt, kann er dem Profil nicht entkommen.

Aktivieren und Status prüfen

sudo apt install apparmor apparmor-utils apparmor-profiles apparmor-profiles-extra
sudo aa-status

Profile für wichtige Dienste erzwingen

# Verfügbare Profile auflisten
sudo aa-unconfined

# nginx in den Erzwingungsmodus setzen
sudo aa-enforce /etc/apparmor.d/usr.sbin.nginx

# Ein Profil für eine benutzerdefinierte Anwendung erstellen
sudo aa-genprof /usr/local/bin/myapp

Benutzerdefinierte Profile erstellen

Für Anwendungen ohne vorhandene Profile:

# Im Beschwerdemodus starten (protokolliert Verstöße, blockiert aber nicht)
sudo aa-complain /path/to/application

# Die Anwendung normal ausführen, alle Funktionen durchspielen
# Dann Protokolle überprüfen und in den Erzwingungsmodus wechseln
sudo aa-logprof
sudo aa-enforce /path/to/application

6. Einbruchserkennung mit AIDE

AIDE (Advanced Intrusion Detection Environment) überwacht die Dateiintegrität — es warnt Sie, wenn Systemdateien unerwartet geändert werden.

Installation und Initialisierung

sudo apt install aide
sudo aideinit
sudo cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db

Konfigurieren, was überwacht werden soll

sudo nano /etc/aide/aide.conf

Benutzerdefinierte Regeln hinzufügen:

# Kritische Systemverzeichnisse überwachen
/etc p+i+u+g+sha256
/bin p+i+u+g+sha256
/sbin p+i+u+g+sha256
/usr/bin p+i+u+g+sha256
/usr/sbin p+i+u+g+sha256

# Web-Root überwachen
/var/www p+i+u+g+sha256

# Verrauschte Verzeichnisse ausschließen
!/var/log
!/var/cache
!/tmp

Tägliche Überprüfungen automatisieren

sudo crontab -e

Hinzufügen:

0 5 * * * /usr/bin/aide --check | mail -s "AIDE Report $(hostname)" you@example.com

7. Audit-Protokollierung mit auditd

Verfolgen Sie, wer was auf Ihrem System tut:

sudo apt install auditd audispd-plugins

Audit-Regeln hinzufügen

sudo nano /etc/audit/rules.d/hardening.rules

# Authentifizierung überwachen
-w /etc/pam.d/ -p wa -k auth_changes
-w /etc/shadow -p wa -k shadow_changes
-w /etc/passwd -p wa -k passwd_changes

# SSH-Konfiguration überwachen
-w /etc/ssh/sshd_config -p wa -k sshd_config

# sudo-Nutzung überwachen
-w /var/log/auth.log -p wa -k auth_log
-w /etc/sudoers -p wa -k sudoers

# Cron überwachen
-w /etc/crontab -p wa -k cron_changes
-w /etc/cron.d/ -p wa -k cron_changes
-w /var/spool/cron/ -p wa -k cron_changes

# Netzwerkkonfiguration überwachen
-w /etc/hosts -p wa -k hosts_changes
-w /etc/network/ -p wa -k network_changes

# Kernel-Module überwachen
-w /sbin/insmod -p x -k kernel_modules
-w /sbin/modprobe -p x -k kernel_modules
-w /sbin/rmmod -p x -k kernel_modules

# Alle von Root ausgeführten Befehle protokollieren
-a always,exit -F arch=b64 -F euid=0 -S execve -k root_commands

# Regeln unveränderlich machen (Neustart zum Ändern erforderlich)
-e 2

auditd neustarten:

sudo systemctl restart auditd

Audit-Protokolle durchsuchen:

# Alle sudo-Ereignisse finden
sudo ausearch -k sudoers

# SSH-Konfigurationsänderungen finden
sudo ausearch -k sshd_config

8. Automatische Sicherheitsupdates

Verpassen Sie nie einen kritischen Patch:

sudo apt install unattended-upgrades apt-listchanges
sudo dpkg-reconfigure -plow unattended-upgrades

Konfigurieren Sie, was automatisch aktualisiert wird:

sudo nano /etc/apt/apt.conf.d/50unattended-upgrades

Unattended-Upgrade::Allowed-Origins {
    "${distro_id}:${distro_codename}-security";
    "${distro_id}ESMApps:${distro_codename}-apps-security";
};

Unattended-Upgrade::AutoFixInterruptedDpkg "true";
Unattended-Upgrade::Remove-Unused-Dependencies "true";
Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Automatic-Reboot-Time "04:00";

// E-Mail-Benachrichtigungen
Unattended-Upgrade::Mail "you@example.com";
Unattended-Upgrade::MailReport "on-change";

9. Shared Memory und /tmp absichern

Shared-Memory-Angriffe verhindern:

sudo nano /etc/fstab

Hinzufügen:

tmpfs /run/shm tmpfs defaults,noexec,nosuid,nodev 0 0
tmpfs /tmp tmpfs defaults,noexec,nosuid,nodev,size=2G 0 0

Neu einbinden:

sudo mount -o remount /run/shm
sudo mount -o remount /tmp

Hinweis: noexec auf /tmp kann einige Installer stören. Bei Bedarf temporär mit exec neu einbinden: sudo mount -o remount,exec /tmp

10. Protokollüberwachung mit Logwatch

Tägliche Sicherheitszusammenfassungen erhalten:

sudo apt install logwatch

Konfigurieren:

sudo nano /etc/logwatch/conf/logwatch.conf

Output = mail
MailTo = you@example.com
Detail = High
Range = yesterday
Service = All

Testen:

sudo logwatch --detail High --mailto you@example.com --range today

Sicherheits-Checkliste

Gehen Sie diese nach der Härtung durch:

Prüfung	Befehl	Erwartet
SSH-Root deaktiviert	grep PermitRootLogin /etc/ssh/sshd_config	no
Passwort-Auth aus	grep PasswordAuthentication /etc/ssh/sshd_config	no
Firewall aktiv	sudo ufw status	active
Fail2ban läuft	sudo fail2ban-client status	Aktive Jails aufgelistet
AppArmor geladen	sudo aa-status	Profile im Erzwingungsmodus
AIDE initialisiert	sudo aide --check	Keine unerwarteten Änderungen
Auto-Updates an	apt-config dump | grep Unattended	"1"
Offene Ports minimal	sudo ss -tlnp	Nur erwartete Ports
Kernel gehärtet	sysctl kernel.randomize_va_space	2

Laufende Wartung

Härtung ist keine einmalige Sache. Planen Sie Folgendes ein:

• Täglich: Fail2ban-Sperren überprüfen (sudo fail2ban-client status sshd)
• Wöchentlich: AIDE-Berichte prüfen, Authentifizierungsprotokolle überprüfen
• Monatlich: Alle Pakete aktualisieren, offene Ports überprüfen, nach neuen CVEs suchen
• Vierteljährlich: Benutzerkonten prüfen, SSH-Schlüssel rotieren, Firewall-Regeln überprüfen

Beste VPS-Anbieter für Sicherheit

Anbieter	Sicherheitsfunktionen	Am besten für
Hostinger	KVM-Isolation, DDoS-Schutz, Backups	Bestes Preis-Leistungs-Verhältnis — starke Sicherheit zu niedrigen Kosten
Hetzner	EU-Datenschutzgesetze, dedizierte Firewall, Snapshots	Datenschutzorientierte Deployments
Vultr	DDoS-Schutz, Firewall-API, Bare Metal	Hochsicherheits-Workloads
DigitalOcean	VPC, verwaltete Firewalls, Monitoring	Team-Umgebungen
Linode	Kostenlose DDoS-Abwehr, Longview-Monitoring	Monitoring-intensive Setups

Hostinger bietet das beste Gleichgewicht zwischen Sicherheitsfunktionen und Preis — KVM-Virtualisierung gewährleistet vollständige Isolation von anderen Mietern, und ihr automatisiertes Backup-System bietet Ihnen Wiederherstellungsoptionen, falls etwas schiefgeht.

Fazit

Ein gehärteter VPS besteht nicht nur aus einer Firewall. Es sind Schichten: Netzwerkfilterung, Authentifizierungskontrollen, Kernel-Einschränkungen, obligatorische Zugriffskontrolle, Dateiintegritätsüberwachung und automatisiertes Patching. Jede Schicht fängt ab, was die anderen übersehen.

Beginnen Sie mit SSH-Härtung und fail2ban (sofortige Wirkung), fügen Sie dann Kernel-Tuning und AppArmor hinzu (tieferer Schutz) und schließen Sie mit AIDE und auditd ab (Erkennung und Forensik).

Kein Server ist unhackbar. Aber ein richtig gehärteter VPS bringt Angreifer dazu, sich leichteren Zielen zuzuwenden — und genau das ist das Ziel.