Linux Server absichern - Grundabsicherung für Ubuntu & Debian

Du hast gerade deinen ersten Linux-Server aufgesetzt und fragst dich, wie du ihn absichern kannst? Oder du betreibst bereits Server und möchtest deine Security auf ein solides Fundament stellen? Dann bist du hier richtig.

In diesem Guide zeige ich dir Schritt für Schritt, wie du einen Ubuntu- oder Debian-Server grundlegend absicherst. Wir nutzen dabei bewährte Tools und Frameworks, die von Security-Experten aus aller Welt entwickelt und gepflegt werden.

Was du in diesem Artikel lernst:

Warum du das Rad nicht neu erfinden solltest (DevSec Hardening Framework)
Automatisiertes OS- und SSH-Hardening mit Ansible
Brute-Force-Schutz mit Fail2Ban
Vulnerability Scanning mit OpenVAS/Greenbone
Firewall-Grundlagen mit ufw/iptables
Allgemeine Security Best Practices

Warum etablierte Frameworks nutzen?

Bevor wir loslegen, ein wichtiger Grundsatz: Erfinde das Rad nicht neu.

Es ist verlockend, sich selbst ein Hardening-Script zu schreiben. Ein bisschen SSH-Config hier, ein paar Kernel-Parameter dort. Das Problem: Du wirst mit hoher Wahrscheinlichkeit etwas übersehen, falsch konfigurieren oder veraltete Empfehlungen umsetzen.

Stattdessen solltest du auf Frameworks setzen, die:

Von einer großen Community aus Security-Experten entwickelt werden
Regelmäßig aktualisiert werden
Gegen etablierte Security-Baselines getestet sind
Flexibel konfigurierbar sind
Dokumentiert und nachvollziehbar arbeiten

Das spart nicht nur Zeit, sondern gibt dir auch ein deutlich höheres Sicherheitsniveau.

DevSec Hardening Framework

Das DevSec Hardening Framework (dev-sec.io) ist genau so ein Framework. Es bietet "battle-tested" Hardening-Konfigurationen für Linux, SSH, MySQL und Nginx.

Das Framework:

Wird seit Jahren aktiv entwickelt (4.700+ GitHub Stars, 150+ Contributors)
Basiert auf etablierten Security-Standards (CIS Benchmarks, NSA Guidelines, etc.)
Ist mit Ansible, Chef und Puppet verwendbar
Wird automatisiert gegen Security-Baselines getestet

Wir konzentrieren uns auf Ansible, da es am weitesten verbreitet ist und sich am einfachsten in bestehende Workflows integrieren lässt.

Unterstützte Betriebssysteme

Die Ansible Collection unterstützt unter anderem:

Debian 11, 12, 13
Ubuntu 20.04, 22.04, 24.04
CentOS Stream 9
AlmaLinux 8/9/10
Rocky Linux 8/9/10

Installation der Ansible Collection

Zuerst installierst du Ansible (falls noch nicht vorhanden):

# Ubuntu/Debian
sudo apt update
sudo apt install ansible

# Oder via pip (empfohlen für aktuelle Version)
pip install ansible

Dann installierst du die DevSec Hardening Collection:

ansible-galaxy collection install devsec.hardening

Die Collection enthält mehrere Rollen:

devsec.hardening.os_hardening - Betriebssystem-Hardening
devsec.hardening.ssh_hardening - SSH-Server und Client Hardening
devsec.hardening.mysql_hardening - MySQL/MariaDB Hardening
devsec.hardening.nginx_hardening - Nginx Hardening

OS Hardening mit Ansible

Die Rolle os_hardening kümmert sich um grundlegende Betriebssystem-Sicherheit:

Sichere Kernel-Parameter (sysctl)
Deaktivierung unnötiger Kernel-Module
Sichere Dateisystem-Berechtigungen
Entfernung unnötiger Pakete
Konfiguration von Passwort-Policies
und vieles mehr

Basis-Playbook erstellen

Erstelle ein Playbook hardening.yml:

---
- name: Harden Linux Server
  hosts: all
  become: true
  collections:
    - devsec.hardening
  roles:
    - os_hardening

Wichtige Konfigurationsvariablen

⚠️ ACHTUNG: Lies die Dokumentation! Die Standardeinstellungen sind sehr restriktiv. Du musst die Konfiguration an deine Umgebung anpassen, sonst sperrst du dich möglicherweise aus oder blockierst legitime Dienste.

Hier einige wichtige Variablen, die du kennen solltest:

---
- name: Harden Linux Server
  hosts: all
  become: true
  collections:
    - devsec.hardening
  vars:
    # IPv4 Forwarding - WICHTIG für Docker!
    # Standard ist "false", aber Docker braucht Forwarding
    sysctl_overwrite:
      net.ipv4.ip_forward: 1

    # Core Dumps erlauben (für Debugging)
    os_security_kernel_enable_core_dump: false

    # Kernel-Module: Welche sollen NICHT deaktiviert werden?
    os_hardening_disabled_modules_blocklist:
      - cramfs
      - freevxfs
      - hfs
      - hfsplus
      - jffs2
      - udf
      # Wichtig: Wenn du USB-Speicher brauchst, entferne 'usb-storage'
      # - usb-storage

    # Automatische Security-Updates aktivieren
    os_auditd_enabled: true

  roles:
    - os_hardening

Docker-Kompatibilität

Wenn du Docker auf dem Server betreibst, ist IPv4-Forwarding zwingend erforderlich:

vars:
  sysctl_overwrite:
    net.ipv4.ip_forward: 1
    net.ipv4.conf.all.forwarding: 1

Ohne diese Einstellung funktioniert die Netzwerkkommunikation zwischen Docker-Containern nicht!

SSH Hardening

Die Rolle ssh_hardening konfiguriert den SSH-Server und -Client nach aktuellen Best Practices:

Sichere Cipher-Suites und MACs
Deaktivierung unsicherer Authentifizierungsmethoden
Konfiguration von Login-Beschränkungen
Client-seitige Security-Einstellungen

SSH Hardening Playbook

---
- name: Harden SSH
  hosts: all
  become: true
  collections:
    - devsec.hardening
  vars:
    # Welche User dürfen sich per SSH anmelden?
    ssh_allow_users: 'admin deploy'

    # Root-Login komplett deaktivieren
    ssh_permit_root_login: 'no'

    # Nur Key-basierte Authentifizierung
    ssh_password_authentication: false

    # WICHTIG: Wenn du GSSAPI nutzt (z.B. Kerberos)
    # ssh_gssapi_support: true
    # ssh_gssapi_auth: true

    # IPv6 deaktivieren falls nicht benötigt
    # ssh_ipv6_enable: false

    # Custom SSH Port (optional, aber empfohlen)
    # ssh_server_ports: ['2222']

  roles:
    - ssh_hardening

⚠️ Wichtige Warnungen vor dem Ausführen

BEVOR du das SSH-Hardening ausführst:

Stelle sicher, dass dein SSH-Key auf dem Server hinterlegt ist!
```
# Auf deinem lokalen Rechner
ssh-copy-id user@server
```
Teste den Key-Login:
```
ssh -i ~/.ssh/id_ed25519 user@server
```
Habe einen Backup-Zugang (z.B. Konsolen-Zugang beim Hoster, IPMI/iLO)
Wenn du bisher als root per Passwort eingeloggt hast:
- Erstelle zuerst einen Admin-User
- Hinterlege deinen SSH-Key
- Teste den Login
- DANN erst das Hardening ausführen

GSSAPI-Authentifizierung

Wenn dein Setup GSSAPI/Kerberos nutzt, musst du das explizit aktivieren:

vars:
  ssh_gssapi_support: true
  ssh_gssapi_auth: true

Andernfalls wird GSSAPI deaktiviert und du sperrst dich möglicherweise aus!

Fail2Ban - Brute-Force-Schutz

Fail2Ban überwacht Log-Dateien und sperrt IP-Adressen automatisch nach mehreren fehlgeschlagenen Login-Versuchen. Ein absolutes Muss für jeden öffentlich erreichbaren Server.

Installation

sudo apt update
sudo apt install fail2ban

Konfiguration

Fail2Ban verwendet sogenannte "Jails" - Regeln für verschiedene Dienste. Die Konfiguration erfolgt in /etc/fail2ban/jail.local (nicht jail.conf bearbeiten!):

# Konfigurationsdatei erstellen
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

SSH-Jail konfigurieren

Füge folgende Konfiguration hinzu oder passe sie an:

[DEFAULT]
# Deine eigene IP von Ban ausnehmen (wichtig!)
ignoreip = 127.0.0.1/8 ::1 192.168.1.0/24

# Standard-Einstellungen
bantime = 1h
findtime = 10m
maxretry = 5

# Backend für Debian 12+ (nutzt systemd journal)
backend = systemd

# Firewall-Backend
banaction = nftables-multiport
banaction_allports = nftables-allports

[sshd]
enabled = true
port = ssh
filter = sshd
logpath = %(sshd_log)s
backend = %(sshd_backend)s
maxretry = 3
bantime = 4h
findtime = 10m

Erklärung der Parameter:

Parameter	Bedeutung
`ignoreip`	Diese IPs werden nie gebannt (deine eigene IP!)
`bantime`	Wie lange wird eine IP gesperrt
`findtime`	Zeitfenster für die Fehlversuche
`maxretry`	Anzahl erlaubter Fehlversuche
`backend`	Wie Logs gelesen werden (systemd für moderne Systeme)

Fail2Ban starten

sudo systemctl restart fail2ban
sudo systemctl enable fail2ban
sudo systemctl status fail2ban

Status prüfen und IPs verwalten

# Genereller Status
sudo fail2ban-client status

# Status des SSH-Jails
sudo fail2ban-client status sshd

# IP manuell entbannen (falls du dich selbst ausgesperrt hast)
sudo fail2ban-client set sshd unbanip 192.168.1.100

# IP manuell bannen
sudo fail2ban-client set sshd banip 123.456.789.0

Logs prüfen

# Fail2Ban-Log
sudo tail -f /var/log/fail2ban.log

# Gebannte IPs anzeigen
sudo fail2ban-client status sshd

OpenVAS/Greenbone - Vulnerability Scanning

Um Schwachstellen auf deinem Server zu finden, bevor es Angreifer tun, nutzt du einen Vulnerability Scanner. OpenVAS (jetzt Greenbone Community Edition) ist der führende Open-Source-Scanner.

Was ist OpenVAS/Greenbone?

Die Greenbone Community Edition ist ein vollständiges Vulnerability Management System:

OpenVAS Scanner - Führt Vulnerability Tests durch
Greenbone Vulnerability Manager (gvmd) - Zentrale Verwaltung
Greenbone Security Assistant (GSA) - Web-Interface
Tägliche Updates mit 100.000+ Vulnerability Tests

Wichtig: OpenVAS/Greenbone wird typischerweise NICHT auf dem zu scannenden Server installiert, sondern auf einem separaten Management-Server. Von dort aus scannst du deine Infrastruktur.

Installation mit Docker (empfohlen)

Die einfachste Installation erfolgt über Docker Compose. Greenbone stellt offizielle Container bereit:

# Verzeichnis erstellen
mkdir -p ~/greenbone && cd ~/greenbone

# Docker Compose Datei herunterladen
curl -O https://greenbone.github.io/docs/latest/_static/docker-compose.yml

# Container starten
docker compose up -d

# Feed-Download abwarten (kann 30+ Minuten dauern!)
docker compose logs -f

Zugriff auf das Web-Interface

Nach dem Start erreichst du das Web-Interface unter:

https://localhost:9392

Standard-Login:

Benutzer: admin
Passwort: admin (sofort ändern!)

Grundlegender Scan-Workflow

Target erstellen: Die IP/Hostname des zu scannenden Servers
Task erstellen: Einen Scan-Auftrag mit dem Target
Scan starten: Der Scan kann je nach Umfang Stunden dauern
Report analysieren: Schwachstellen nach Schweregrad priorisieren

Offizielle Dokumentation

Die aktuelle, offizielle Dokumentation findest du unter:

Greenbone Community Docs: greenbone.github.io/docs
OpenVAS Scanner GitHub: github.com/greenbone/openvas-scanner
Community Forum: forum.greenbone.net

Firewall-Grundlagen mit ufw

Wenn dein Server direkt mit einer öffentlichen IP-Adresse im Internet steht (also nicht hinter einer externen Firewall), ist eine lokale Firewall Pflicht.

ufw installieren und aktivieren

# Installation
sudo apt install ufw

# SSH ZUERST erlauben (sonst sperrst du dich aus!)
sudo ufw allow ssh
# oder bei Custom-Port:
# sudo ufw allow 2222/tcp

# Firewall aktivieren
sudo ufw enable

# Status prüfen
sudo ufw status verbose

Grundlegende Regeln

# Alles blockieren, dann gezielt freigeben
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH (Port 22)
sudo ufw allow ssh

# HTTP & HTTPS
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

# Spezifische IP erlauben
sudo ufw allow from 192.168.1.0/24

# Port für bestimmte IP
sudo ufw allow from 192.168.1.100 to any port 3306

# Regel entfernen
sudo ufw delete allow 80/tcp

# Status mit Nummern (zum Löschen)
sudo ufw status numbered
sudo ufw delete 3

Wichtige Prinzipien

Deny by Default: Alles blockieren, was nicht explizit erlaubt ist
Least Privilege: Nur die Ports öffnen, die wirklich benötigt werden
SSH immer zuerst: Bevor du ufw enable ausführst, SSH erlauben!
Testen: Nach Änderungen testen, ob alles noch funktioniert

Allgemeine Best Practices

1. Minimale Installation

Installiere nur Pakete, die du wirklich brauchst:

# Installierte Pakete auflisten
dpkg --list

# Unnötige Pakete entfernen
sudo apt remove --purge <paketname>
sudo apt autoremove

Je weniger Software läuft, desto kleiner die Angriffsfläche.

2. sudo richtig konfigurieren

Benutzer sollten nur die Befehle ausführen können, die sie wirklich brauchen:

# Datei /etc/sudoers.d/webadmin erstellen
sudo visudo -f /etc/sudoers.d/webadmin

Beispiel für einen Web-Admin, der nur Nginx und Certbot verwalten darf:

webadmin ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx
webadmin ALL=(ALL) NOPASSWD: /usr/bin/systemctl reload nginx
webadmin ALL=(ALL) NOPASSWD: /usr/bin/certbot *

3. Regelmäßige Updates

# Manuell
sudo apt update && sudo apt upgrade

# Automatische Security-Updates (Ubuntu/Debian)
sudo apt install unattended-upgrades
sudo dpkg-reconfigure unattended-upgrades

4. Logging und Monitoring

Logs zentral sammeln: rsyslog, journald
Log-Rotation konfigurieren: /etc/logrotate.d/
Monitoring einrichten: Prometheus, Zabbix, Netdata
Alerts konfigurieren: Bei ungewöhnlichen Aktivitäten

5. Backup-Strategie

3-2-1 Regel: 3 Kopien, 2 verschiedene Medien, 1 off-site
Backups testen: Regelmäßig Restore-Tests durchführen
Verschlüsselte Backups: Besonders bei Cloud-Storage

Zusammenfassung: Deine Checkliste

Hier deine Checkliste für die Server-Grundabsicherung:

[ ] Admin-User erstellen und SSH-Key hinterlegen
[ ] Root-Login deaktivieren (erst nach Test des Admin-Users!)
[ ] DevSec OS-Hardening mit Ansible anwenden
[ ] DevSec SSH-Hardening mit Ansible anwenden
[ ] Fail2Ban installieren und SSH-Jail konfigurieren
[ ] Firewall (ufw) konfigurieren und aktivieren
[ ] Automatische Updates aktivieren
[ ] OpenVAS-Scan durchführen und Findings beheben
[ ] Unnötige Dienste deaktivieren
[ ] sudo-Berechtigungen prüfen und einschränken
[ ] Backup-Strategie implementieren
[ ] Monitoring einrichten

Weiterführende Ressourcen

DevSec Hardening Framework: dev-sec.io
Ansible Galaxy - devsec.hardening: galaxy.ansible.com/devsec/hardening
Greenbone/OpenVAS Docs: greenbone.github.io/docs
CIS Benchmarks: cisecurity.org/cis-benchmarks
Fail2Ban Dokumentation: fail2ban.org

Fragen oder Feedback? Schreib mir eine E-Mail oder diskutiere im Kommentarbereich.

Dieser Artikel wird regelmäßig aktualisiert. Letztes Update: Dezember 2024