Server-Hardening

Was zählt wirklich

Die Server-Basis und die Tailscale-Anleitung erledigen schon das Meiste (Key-only SSH, Cloud-Firewall, kein offener Port). Diese Anleitung ist für den Fall, dass der Server doch öffentlich sein muss (Web auf 80/443).

1 SSH härten

PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
AllowUsers deploy
MaxAuthTries 3
LoginGraceTime 20
X11Forwarding no
AllowAgentForwarding no
AllowTcpForwarding no
ClientAliveInterval 300
ClientAliveCountMax 2
# moderne Krypto (Mozilla "modern") -- ssh-audit prueft das
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com

sshd -t && systemctl reload ssh
# nur schwache Host-Keys entfernen (ed25519 + rsa behalten)
rm -f /etc/ssh/ssh_host_ecdsa_key* /etc/ssh/ssh_host_dsa_key*
systemctl restart ssh

• Port ändern bringt wenig gegen gezielte Angriffe, aber viel Ruhe in den Logs. Wenn, dann in 99-hardening.conf und in der Firewall.
• 2FA für SSH: am elegantesten über Tailscale-SSH im Check-Modus (erzwingt Browser-Re-Auth). Sonst libpam-google-authenticator.

2 Automatische Updates

apt-get install -y unattended-upgrades needrestart apt-listchanges
dpkg-reconfigure -plow unattended-upgrades      # "Yes"

Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Automatic-Reboot-Time "04:12";
Unattended-Upgrade::MailReport "on-change";
Unattended-Upgrade::Mail "du@example.com";   # braucht SMTP-Relay -- oder weglassen und per Log/Monitoring pruefen
Unattended-Upgrade::Remove-Unused-Kernel-Packages "true";

• Debian zusätzlich ${distro_id}:${distro_codename}-updates in Allowed-Origins aufnehmen.
• needrestart startet nach Bibliotheks-Updates die betroffenen Dienste neu (NEEDRESTART_MODE=a in /etc/needrestart/needrestart.conf für unbeaufsichtigt).
• Kernel-Live-Patching (Ubuntu Livepatch, Debian nicht offiziell) spart Reboots – für einen Hobby-Server ist der 04:12-Reboot ok.
• Überwachen: der Netdata-Alarm „Reboot nötig“ bzw. „Pakete veraltet“.

3 nftables & die Docker-Falle

Hinter der Hetzner-Cloud-Firewall – als zweite Schicht, und weil die Cloud-Firewall keine Regeln zwischen Prozessen kennt.

#!/usr/sbin/nft -f
flush ruleset
table inet filter {
  chain input {
    type filter hook input priority 0; policy drop;
    ct state established,related accept
    ct state invalid drop
    iif lo accept
    ip protocol icmp accept
    ip6 nexthdr ipv6-icmp accept
    tcp dport 22 accept
    tcp dport { 80, 443 } accept
    # Rest wird verworfen (policy drop)
  }
}

nft -c -f /etc/nftables.conf && systemctl enable --now nftables

4 CrowdSec

Wertet Logs aus (SSH, nginx/Traefik), erkennt Brute-Force und Scans, und ein Bouncer sperrt die IP (Internet Protocol) in nftables. Plus: die Community-Blocklist bekannter bösartiger IPs (Internet-Protocol-Adressen).

curl -s https://install.crowdsec.net | sh
apt-get install -y crowdsec crowdsec-firewall-bouncer-nftables

cscli collections install crowdsecurity/sshd crowdsecurity/nginx \
  crowdsecurity/http-cve crowdsecurity/base-http-scenarios
systemctl reload crowdsec

# optional: kostenloses Dashboard + Community-Blocklist
cscli console enroll <enroll-key>

cscli metrics          # was wurde geparst, was ausgeloest
cscli decisions list   # aktuell gesperrte IPs
cscli alerts list

fail2ban tut es auch (/etc/fail2ban/jail.local → [sshd] + [recidive], bantime.increment=true). CrowdSec ist moderner, kann HTTP-Angriffe und teilt Bedrohungsdaten – für einen Web-Server die bessere Wahl.

5 Kernel & sysctl

net.ipv4.tcp_syncookies = 1
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.all.accept_redirects = 0
net.ipv6.conf.all.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.all.accept_source_route = 0
net.ipv6.conf.all.accept_source_route = 0
net.ipv4.conf.all.log_martians = 1
kernel.kptr_restrict = 2
kernel.dmesg_restrict = 1
kernel.yama.ptrace_scope = 1
kernel.unprivileged_bpf_disabled = 1
net.core.bpf_jit_harden = 2
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
fs.protected_fifos = 2
fs.protected_regular = 2
fs.suid_dumpable = 0

sysctl --system

Docker/k8s brauchen net.ipv4.ip_forward = 1 – das setzt Docker selbst, nicht überschreiben. rp_filter ggf. auf 2 (loose), wenn asymmetrisches Routing (mehrere Interfaces / Tailscale-Subnet-Router) sonst Pakete verwirft.

6 Nutzer, sudo, Rechte

• Arbeiten als Nicht-Root (deploy), sudo nur wo nötig. NOPASSWD ausschließlich für skriptbare Einzelbefehle (/etc/sudoers.d/deploy: deploy ALL=(root) NOPASSWD: /usr/bin/systemctl restart app).
• Ungenutzte Konten sperren: usermod -L -e 1 <user>. Der cloud-init-Default-User bleibt (Hetzner braucht ihn), aber Passwort-Login ist ja aus.
• Dienst-Konten ohne Shell: usermod -s /usr/sbin/nologin <svc>.
• Falls du lokale Nutzer mit Passwort hast: Alterung in /etc/login.defs (PASS_MAX_DAYS 365), starke Hashes (yescrypt ist Default auf Debian 12).
• umask 027 in /etc/profile.d/, /root auf 700.

7 Docker/Podman härten

{
  "no-new-privileges": true,
  "icc": false,
  "userland-proxy": false,
  "live-restore": true,
  "log-driver": "json-file",
  "log-opts": { "max-size": "10m", "max-file": "3" }
}

• Im Compose je Service: security_opt: ["no-new-privileges:true"], cap_drop: ["ALL"] (+ cap_add nur was nötig), read_only: true mit tmpfs für Schreibpfade.
• Nie --privileged, nie /var/run/docker.sock in einen Container (= Root auf dem Host). Ausnahmen (Traefik, Watchtower) read-only und nur wenn wirklich nötig, besser ein Socket-Proxy.
• Images: Tags und Digests pinnen, regelmässig docker scout cves <image> oder trivy image <image>.
• Rootless: Podman rootless (die container-host-Anleitung) oder Docker rootless-Modus – ein Container-Ausbruch landet dann nicht als Root auf dem Host.
• docker-bench-security gibt eine Checkliste mit Punkten.

8 auditd & Integrität

-w /etc/passwd -p wa -k identity
-w /etc/shadow -p wa -k identity
-w /etc/sudoers -p wa -k scope
-w /etc/sudoers.d/ -p wa -k scope
-w /etc/ssh/sshd_config -p wa -k sshd
-w /etc/ssh/sshd_config.d/ -p wa -k sshd
-a always,exit -F arch=b64 -S execve -F euid=0 -F auid>=1000 -F auid!=-1 -k root_cmd
-e 2

apt-get install -y auditd
augenrules --load && auditctl -l
ausearch -k sshd -ts today        # wer hat sshd_config angefasst

• Datei-Integrität: debsums -c (leicht, prüft Paketdateien) – oder AIDE (gründlich, aber Pflege: nach jedem Update aide --update).
• Die audit-Logs in den Monitoring-Kanal (Netdata liest /var/log/audit/audit.log), oder wöchentlich per Cron aureport --auth --summary ansehen.

9 Prüfen: Lynis, ssh-audit

apt-get install -y lynis
lynis audit system            # "Hardening index" 0-100, Ziel ~70+, plus konkrete Vorschlaege

ssh-audit dienste            # SSH-Krypto bewerten (pip install ssh-audit oder docker)
nmap -Pn -p- dienste          # von aussen -> nur 22/80/443 (oder nur 80/443 mit Tailscale)

• Web: internet.nl (TLS, DNSSEC, Header, Mail), securityheaders.com, für Nextcloud scan.nextcloud.com.
• Wiederholen: nach jedem grösseren Update Lynis erneut, den Index beobachten. Ein-, zweimal im Jahr nmap von außen.

+ Was Übertreibung ist

Für einen 1–3-Personen-Server holen diese Dinge fast nichts mehr raus, kosten aber viel Pflege – erst machen, wenn ein konkreter Grund da ist:

• Eigene AppArmor/SELinux (Security-Enhanced Linux)-Profile schreiben (die Distro-Defaults anlassen reicht).
• Der volle CIS-Benchmark Punkt für Punkt.
• Ein HIDS/IDS außer CrowdSec (Wazuh, OSSEC, Suricata) – Rauschen, Pflege, kaum Mehrwert bei einem Server.
• Strenges Egress-Filtering (raus-Regeln in nftables) – bricht ständig Updates/Container und schützt wenig.
• Verschlüsselte Root-Partition – auf einem Cloud-Server ohne physischen Zugriff wenig sinnvoll, Hetzner sieht die Platte ohnehin nicht (aber Backups verschlüsseln – ja!).

+ Hardening ab cloud-init

Alles Obige einmal in die Basis-cloud-init, dann startet jeder neue Server gehardened.

packages: [ unattended-upgrades, needrestart, nftables, auditd, lynis ]
write_files:
  - path: /etc/ssh/sshd_config.d/99-hardening.conf
    content: |
      PermitRootLogin no
      PasswordAuthentication no
      KbdInteractiveAuthentication no
      MaxAuthTries 3
  - path: /etc/sysctl.d/99-hardening.conf
    content: |
      kernel.kptr_restrict = 2
      kernel.dmesg_restrict = 1
      fs.protected_regular = 2
  - path: /etc/nftables.conf
    content: |
      #!/usr/sbin/nft -f
      flush ruleset
      table inet filter { chain input {
        type filter hook input priority 0; policy drop;
        ct state established,related accept ; iif lo accept ; ct state invalid drop
        ip protocol icmp accept ; ip6 nexthdr ipv6-icmp accept
        tcp dport { 22, 80, 443 } accept
      } }
runcmd:
  - systemctl reload ssh
  - sysctl --system
  - systemctl enable --now nftables
  - curl -s https://install.crowdsec.net | sh
  - apt-get install -y crowdsec crowdsec-firewall-bouncer-nftables

Danach einmal lynis audit system und einen Snapshot – ab dem up bootet jeder Server so.