Ubuntu Server 24.04 LTS härten - Grundlegende Sicherheitsmaßnahmen

Schritt-für-Schritt-Anleitung zum Absichern eines frisch installierten Ubuntu Server 24.04 LTS mit Firewall, Fail2Ban und automatischen Updates

Kürzlich habe ich einen Cloud Virtual Private Server (VPS) gemietet mit vorinstalliertem Ubuntu Server 24.04 LTS. Bevor ich jedoch die ersten Services darauf installiere, steht immer der wichtigste Schritt an: die Absicherung des Systems. Ein ungesicherter Server im Internet ist wie eine offene Tür – es dauert oft nur Minuten, bis die ersten automatisierten Angriffsversuche starten.

Die hier beschriebenen Schritte gelten natürlich genauso, wenn du einen Server in deinem Homelab betreibst, der aus dem Internet erreichbar ist. Egal ob Cloud-VPS oder eigene Hardware – die Grundlagen der Absicherung bleiben dieselben.

In diesem Artikel zeige ich dir, wie du einen Ubuntu Server 24.04 LTS mit grundlegenden, aber effektiven Sicherheitsmaßnahmen absicherst. Wir werden gemeinsam die wichtigsten Schritte durchgehen, die jeder Server durchlaufen sollte, bevor er produktiv eingesetzt wird.

Warum Server-Hardening wichtig ist

Selbst in einem privaten Homelab sollte Sicherheit nicht vernachlässigt werden. Die Gründe sind vielfältig:

• Automatisierte Angriffe: Bots scannen permanent das Internet nach offenen Ports und versuchen, sich Zugang zu verschaffen
• Datenschutz: Selbst private Daten verdienen Schutz
• Lerneffekt: Das Implementieren von Best Practices schult das Verständnis für IT-Sicherheit
• Verhindert Missbrauch: Ein kompromittierter Server kann für Spam, DDoS-Angriffe oder Krypto-Mining missbraucht werden

Voraussetzungen

Für diesen Artikel benötigst du:

• Einen frisch installierten Ubuntu Server 24.04 LTS (Noble Numbat)
• Root- oder sudo-Zugriff auf den Server
• SSH-Zugang zum Server
• Grundlegende Linux-Kenntnisse
• Optional: Einen zweiten Rechner für externe Sicherheitstests

Schritt 1: Initiale Bestandsaufnahme - Offene Ports prüfen

Bevor wir mit dem Härten beginnen, sollten wir uns einen Überblick verschaffen, welche Dienste aktuell laufen und welche Ports nach außen exponiert sind. Das ist wichtig, um zu verstehen, was wir absichern müssen.

Lokale Port-Überprüfung

Der Befehl ss (socket statistics) zeigt uns alle lauschenden Ports:

sudo ss -tulpn
Netid State  Recv-Q Send-Q Local Address:Port Peer Address:Port Process
tcp   LISTEN 0      128          0.0.0.0:22        0.0.0.0:*     users:(("sshd",pid=1234,fd=3))
tcp   LISTEN 0      128             [::]:22           [::]:*     users:(("sshd",pid=1234,fd=4))

Parameter erklärt:

• -t = TCP-Verbindungen
• -u = UDP-Verbindungen
• -l = Nur lauschende Sockets
• -p = Zeigt Prozessinformationen
• -n = Numerische Anzeige (keine Namensauflösung)

In diesem Beispiel sehen wir, dass nur SSH (Port 22) lauscht – ein guter Ausgangspunkt für einen frischen Server.

Aktive Dienste auflisten

Schauen wir uns an, welche Dienste auf dem System aktiv sind:

systemctl list-units --type=service --state=running
UNIT                        LOAD   ACTIVE SUB     DESCRIPTION
ssh.service                loaded active running OpenBSD Secure Shell server
systemd-journald.service   loaded active running Journal Service
systemd-udevd.service      loaded active running Rule-based Manager for Device Events

Externe Port-Überprüfung (Optional)

Falls du einen zweiten Rechner im Netzwerk hast, kannst du mit nmap von extern scannen:

nmap -sV 192.168.1.100
Starting Nmap 7.94
Nmap scan report for homelab-srv (192.168.1.100)
Host is up (0.0012s latency).
Not shown: 999 closed ports
PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 9.6p1 Ubuntu 3ubuntu13 (Ubuntu Linux; protocol 2.0)

Schritt 2: System aktualisieren

Der erste und wichtigste Schritt ist, das System auf den neuesten Stand zu bringen. Sicherheitsupdates schließen bekannte Schwachstellen.

sudo apt update
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut... Fertig

sudo apt upgrade -y
Die folgenden Pakete werden aktualisiert:
  base-files curl libcurl4 openssh-client openssh-server
5 aktualisiert, 0 neu installiert, 0 zu entfernen und 0 nicht aktualisiert.

Falls Kernel-Updates installiert wurden, ist ein Neustart erforderlich:

sudo reboot

Schritt 3: UFW Firewall einrichten

UFW (Uncomplicated Firewall) ist eine benutzerfreundliche Frontend-Lösung für iptables. Sie ermöglicht es uns, schnell und einfach Firewall-Regeln zu definieren.

UFW installieren und konfigurieren

sudo apt install ufw -y

sudo ufw allow 22/tcp comment 'SSH'
Regeln aktualisiert
Regeln aktualisiert (v6)

Setze die Standard-Policy (eingehende Verbindungen blockieren, ausgehende erlauben):

sudo ufw default deny incoming
sudo ufw default allow outgoing
Standard-Eingangsrichtlinie auf 'deny' geändert
Standard-Ausgangsrichtlinie auf 'allow' geändert

Aktiviere die Firewall:

sudo ufw enable
Firewall ist aktiv und wird beim Systemstart aktiviert

Überprüfe den Status:

sudo ufw status verbose
Status: Aktiv
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)
Neue Profile: skip

Zu                         Aktion      Von
--                         ------      ---
22/tcp                     ALLOW IN    Anywhere                   # SSH
22/tcp (v6)                ALLOW IN    Anywhere (v6)              # SSH

Weitere Ports für Services freigeben

Je nach deinen Anforderungen kannst du weitere Ports freigeben. Hier einige häufige Beispiele:

 Webserver
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'

 Docker Swarm (Beispiel)
 sudo ufw allow 2377/tcp comment 'Docker Swarm'

 Proxmox Web-Interface (falls benötigt)
 sudo ufw allow 8006/tcp comment 'Proxmox Web UI'

Schritt 4: Benutzerverwaltung und sudo-Rechte

Es ist eine Best Practice, nicht als root zu arbeiten und sudo-Zugriffe einzuschränken. Wichtig: Wir richten dies ein, BEVOR wir SSH härten und den root-Login deaktivieren, um uns nicht auszusperren!

Neuen Benutzer anlegen (falls noch nicht vorhanden)

sudo adduser frank
Neues Passwort eingeben:
Passwort wiederholen:
Vollständigen Namen eingeben []: Frank

Benutzer zur sudo-Gruppe hinzufügen

sudo usermod -aG sudo frank

sudo-Zugriff überprüfen

sudo whoami
[sudo] Passwort für frank:
root

Root-Account deaktivieren (Optional)

Falls du sicher bist, dass du root nicht mehr benötigst:

sudo passwd -l root
passwd: Passwortablaufdaten geändert

Schritt 5: SSH absichern

SSH ist meist der einzige von außen erreichbare Dienst auf einem Server. Deshalb ist es besonders wichtig, diesen gut abzusichern.

SSH-Schlüsselpaare verwenden

Falls du noch keine SSH-Keys verwendest, erstelle zunächst auf deinem lokalen Rechner ein Schlüsselpaar:

ssh-keygen -t ed25519 -C "homelab-server"
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/frank/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase): #### Passwort eingeben!
Your identification has been saved in /home/frank/.ssh/id_ed25519
Your public key has been saved in /home/frank/.ssh/id_ed25519.pub

Kopiere den öffentlichen Schlüssel auf den Server:

ssh-copy-id ubuntu@192.168.1.100
Number of key(s) added: 1

Now try logging into the machine, with: "ssh 'ubuntu@192.168.1.100'"

Teste die Anmeldung mit dem Schlüssel:

ssh ubuntu@192.168.1.100
Welcome to Ubuntu 24.04 LTS (GNU/Linux 6.8.0-45-generic x86_64)

SSH-Konfiguration härten

Jetzt passen wir die SSH-Konfiguration an. Erstelle zunächst ein Backup:

sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.backup

Bearbeite die Konfiguration:

sudo nano /etc/ssh/sshd_config

# Port ändern (optional, aber empfohlen)
Port 2222

# Nur SSH Protocol 2 verwenden
Protocol 2

# Root-Login verbieten
PermitRootLogin no

# Passwort-Authentifizierung deaktivieren (erst nach SSH-Key-Test!)
PasswordAuthentication no
PubkeyAuthentication yes

# Leere Passwörter verbieten
PermitEmptyPasswords no

# X11-Forwarding deaktivieren (falls nicht benötigt)
X11Forwarding no

# MaxAuthTries begrenzen
MaxAuthTries 3

# LoginGraceTime reduzieren
LoginGraceTime 20

# Nur bestimmte Benutzer erlauben (optional)
AllowUsers ubuntu

# Nur IPv4 verwenden (optional)
AddressFamily inet

sudo ufw allow 2222/tcp comment 'SSH custom port'
sudo ufw delete allow 22/tcp

Überprüfe die Konfiguration auf Syntaxfehler:

sudo sshd -t
# Keine Ausgabe bedeutet: Alles OK!

Aktiviere und starte den SSH-Dienst neu:

sudo systemctl enable ssh
sudo systemctl restart ssh.socket

Wichtig: Öffne eine zweite SSH-Verbindung zum Server, BEVOR du die erste schließt, um sicherzustellen, dass du dich noch einloggen kannst!

Schritt 6: Fail2Ban installieren und konfigurieren

Fail2Ban überwacht Log-Dateien und sperrt IP-Adressen nach wiederholten fehlgeschlagenen Login-Versuchen automatisch. Das schützt vor Brute-Force-Angriffen.

Installation

sudo apt install fail2ban -y

Konfiguration

Fail2Ban verwendet eine jail.conf, die wir nicht direkt bearbeiten sollten. Stattdessen erstellen wir eine jail.local:

sudo nano /etc/fail2ban/jail.local

[DEFAULT]
# Banzeit: 1 Stunde
bantime = 3600

# Zeitfenster, in dem die Versuche gezählt werden: 10 Minuten
findtime = 600

# Maximale Anzahl fehlgeschlagener Versuche
maxretry = 5

# Ignoriere lokale IPs (passe dies an dein Netzwerk an)
ignoreip = 127.0.0.1/8 ::1 192.168.1.0/24

[sshd]
enabled = true
port = 2222
# Falls du den Standard-Port 22 verwendest, ändere dies entsprechend
logpath = %(sshd_log)s
backend = %(sshd_backend)s

Starte Fail2Ban und aktiviere den Autostart:

sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Überprüfe den Status:

sudo fail2ban-client status
Status
|- Number of jail:      1
`- Jail list:   sshd

Details zu einem spezifischen Jail:

sudo fail2ban-client status sshd
Status for the jail: sshd
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /var/log/auth.log
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

Fail2Ban testen (Optional)

Um zu testen, ob Fail2Ban funktioniert, kannst du von einem anderen Rechner aus mehrfach mit einem falschen Passwort versuchen, dich einzuloggen:

ssh ubuntu@192.168.1.100 -p 2222
ubuntu@192.168.1.100's password: #### Falsches Passwort eingeben
Permission denied, please try again.
# Nach 5 Versuchen: Connection refused

Die IP wird nun für 1 Stunde gesperrt. Du kannst dies überprüfen:

sudo fail2ban-client status sshd
Status for the jail: sshd
|- Currently banned: 1
`- Banned IP list:   192.168.1.50

Falls du eine IP manuell entsperren möchtest:

sudo fail2ban-client set sshd unbanip 192.168.1.50

Schritt 7: Automatische Sicherheitsupdates einrichten

Sicherheitsupdates sollten zeitnah eingespielt werden. Mit unattended-upgrades können wir dies automatisieren.

Installation

sudo apt install unattended-upgrades -y

Konfiguration

Bearbeite die Konfigurationsdatei:

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

Unattended-Upgrade::Allowed-Origins {
    "${distro_id}:${distro_codename}";
    "${distro_id}:${distro_codename}-security";
    // Auch wichtige Updates installieren (optional)
    // "${distro_id}:${distro_codename}-updates";
};

// Pakete, die NICHT automatisch aktualisiert werden sollen
Unattended-Upgrade::Package-Blacklist {
    // Beispiel: "docker-ce";
};

// Automatisch neustart, falls erforderlich (Vorsicht im Homelab!)
Unattended-Upgrade::Automatic-Reboot "false";

// Falls Neustart aktiviert: Uhrzeit festlegen
Unattended-Upgrade::Automatic-Reboot-Time "02:00";

// E-Mail-Benachrichtigung (optional)
// Unattended-Upgrade::Mail "deine@email.de";
// Unattended-Upgrade::MailReport "on-change";

// Alte Kernel automatisch entfernen
Unattended-Upgrade::Remove-Unused-Kernel-Packages "true";
Unattended-Upgrade::Remove-Unused-Dependencies "true";

Aktiviere automatische Updates:

sudo dpkg-reconfigure -plow unattended-upgrades
# Wähle "Ja" aus

Überprüfe die Konfiguration:

sudo unattended-upgrades --dry-run --debug

Schritt 8: Abschließende Sicherheitsprüfung

Nachdem wir alle Maßnahmen umgesetzt haben, führen wir eine finale Überprüfung durch.

Offene Ports erneut prüfen

sudo ss -tulpn | grep LISTEN
tcp   LISTEN 0      128          0.0.0.0:2222      0.0.0.0:*     users:(("sshd",pid=1234,fd=3))

Perfekt! Nur noch unser angepasster SSH-Port ist offen.

UFW-Status überprüfen

sudo ufw status numbered
Status: Aktiv

     Zu                         Aktion      Von
     --                         ------      ---
[ 1] 2222/tcp                   ALLOW IN    Anywhere                   # SSH custom port
[ 2] 2222/tcp (v6)              ALLOW IN    Anywhere (v6)              # SSH custom port

Fail2Ban-Status prüfen

sudo systemctl status fail2ban
● fail2ban.service - Fail2Ban Service
     Loaded: loaded (/lib/systemd/system/fail2ban.service; enabled; preset: enabled)
     Active: active (running) since Mon 2025-11-04 10:15:32 UTC; 2h ago

Externe Port-Überprüfung (falls möglich)

nmap -sV 192.168.1.100 -p 1-65535
Starting Nmap 7.94
Nmap scan report for homelab-srv (192.168.1.100)
Host is up (0.0012s latency).
Not shown: 65534 filtered ports
PORT     STATE SERVICE VERSION
2222/tcp open  ssh     OpenSSH 9.6p1 Ubuntu 3ubuntu13

Ausgezeichnet! Von außen ist nur noch der angepasste SSH-Port sichtbar.

Login-Versuche in den Logs prüfen

sudo tail -n 20 /var/log/auth.log
Nov  4 10:30:15 homelab-srv sshd[2456]: Accepted publickey for ubuntu from 192.168.1.50
Nov  4 10:30:15 homelab-srv sshd[2456]: pam_unix(sshd:session): session opened for user ubuntu

Zusätzliche Maßnahmen (Optional)

Je nach deinen Anforderungen kannst du weitere Sicherheitsmaßnahmen ergreifen:

AppArmor-Status überprüfen

AppArmor (Application Armor) ist ein Mandatory Access Control (MAC) System, das in Ubuntu vorinstalliert ist. Es schränkt die Berechtigungen einzelner Programme ein, indem es sie in Sicherheitsprofile “einsperrt”. So kann beispielsweise ein kompromittierter Webserver nur auf die Dateien zugreifen, die er wirklich benötigt.

Ubuntu 24.04 kommt mit AppArmor vorinstalliert. Überprüfe, ob es aktiv ist:

sudo aa-status
apparmor module is loaded.
49 profiles are loaded.
49 profiles are in enforce mode.

Automatische Sicherheits-Audits mit Lynis

Lynis ist ein Open-Source-Sicherheits-Audit-Tool, das dein System auf Schwachstellen und Konfigurationsprobleme überprüft. Es scannt hunderte von Sicherheitsaspekten (SSH-Konfiguration, Firewall-Einstellungen, Kernel-Parameter, installierte Pakete, etc.) und gibt dir einen detaillierten Bericht mit Verbesserungsvorschlägen.

sudo apt install lynis -y
sudo lynis audit system
# Lynis führt einen umfassenden Sicherheits-Scan durch

Zwei-Faktor-Authentifizierung für SSH (2FA)

Für maximale Sicherheit kannst du 2FA mit Google Authenticator einrichten:

sudo apt install libpam-google-authenticator -y
google-authenticator
# Folge den Anweisungen und scanne den QR-Code mit deiner Authenticator-App

Fazit

Natürlich ist IT-Sicherheit ein fortlaufender Prozess. Überprüfe regelmäßig die Logs, halte das System aktuell und passe die Sicherheitsmaßnahmen an deine sich ändernden Anforderungen an.

Nächste Schritte

Jetzt, wo dein Server abgesichert ist, kannst du mit dem Installieren deiner Services beginnen. Hier einige Ideen:

• Docker und Docker Compose installieren
• Einen Reverse Proxy wie Traefik oder Nginx Proxy Manager einrichten
• Monitoring-Tools wie Prometheus und Grafana aufsetzen
• Backup-Lösungen implementieren

Referenzen

• Ubuntu Server Guide - Security
• UFW Documentation
• Fail2Ban Official Documentation
• OpenSSH Security Best Practices
• CIS Ubuntu Linux 24.04 LTS Benchmark

Viel Erfolg beim Härten deines Servers und viel Spaß in deinem Homelab!