---
title: UFW server firewall Profice
description: 
published: true
date: 2026-02-24T08:56:45.279Z
tags: 
editor: markdown
dateCreated: 2026-02-24T08:54:57.458Z
---

# UFW Firewall – Vollständige Server-Dokumentation

> **Systemumgebung:** Debian-basierter Server (Debian 12 / Ubuntu 22.04+)
> **Firewall:** UFW (Uncomplicated Firewall) – Frontend für iptables/nftables
> **Einsatz:** Netzwerksicherheit, Zugriffssteuerung, Portfilterung für alle Serverdienste

---

## Inhaltsverzeichnis

1. [Überblick und Funktionsweise](#1-überblick-und-funktionsweise)
2. [Installation und Ersteinrichtung](#2-installation-und-ersteinrichtung)
3. [Grundlegende Regelverwaltung](#3-grundlegende-regelverwaltung)
4. [Erweiterte Regeln](#4-erweiterte-regeln)
5. [Anwendungsprofile](#5-anwendungsprofile)
6. [Regelkonfiguration für unsere Dienste](#6-regelkonfiguration-für-unsere-dienste)
7. [Logging und Überwachung](#7-logging-und-überwachung)
8. [IPv6-Konfiguration](#8-ipv6-konfiguration)
9. [Rate Limiting – Brute-Force-Schutz](#9-rate-limiting--brute-force-schutz)
10. [Port-Weiterleitung und NAT](#10-port-weiterleitung-und-nat)
11. [UFW und Docker](#11-ufw-und-docker)
12. [Regelreihenfolge und Priorität](#12-regelreihenfolge-und-priorität)
13. [Backup und Wiederherstellung](#13-backup-und-wiederherstellung)
14. [Sicherheitshärtung](#14-sicherheitshärtung)
15. [Fehlerbehebung](#15-fehlerbehebung)
16. [Schnellreferenz – Befehle auf einen Blick](#16-schnellreferenz--befehle-auf-einen-blick)

---

## 1. Überblick und Funktionsweise

### Was ist UFW?

UFW (Uncomplicated Firewall) ist ein benutzerfreundliches Frontend für die Linux-Kernel-Firewall (iptables/nftables). Es vereinfacht die Erstellung und Verwaltung von Firewall-Regeln erheblich, ohne auf die Leistungsfähigkeit des darunterliegenden Paketfilters zu verzichten.

### Warum eine Firewall?

Ein Server ohne Firewall ist wie ein Haus mit offenen Türen. Jeder Dienst, der auf einem Port lauscht, ist aus dem gesamten Internet erreichbar. Eine Firewall kontrolliert, welcher Netzwerkverkehr den Server erreichen darf und welcher blockiert wird.

### Architektur

```plantuml
@startuml

skinparam shadowing false
skinparam roundCorner 10

package "Debian Server" {

    [UFW\n(Firewall-Frontend)] as ufw
    [iptables / nftables\n(Kernel-Paketfilter)] as iptables

    package "Geschützte Dienste" {
        [SSH\nPort 22] as ssh
        [Nginx\nPort 80/443] as nginx
        [Gitea\nPort 3000] as gitea
        [PostgreSQL\nPort 5432] as pg
        [Vaultwarden\nPort 8080] as vw
    }

    ufw --> iptables : Regeln übersetzen
    iptables --> ssh
    iptables --> nginx
    iptables --> gitea
    iptables --> pg
    iptables --> vw
}

cloud "Internet" as inet
actor "Administrator\n(SSH)" as admin
actor "Angreifer" as attacker

admin --> ufw : Port 22 erlaubt
inet --> ufw : Port 80/443 erlaubt
attacker --> ufw : Port 5432 blockiert

@enduml
```

### UFW vs. iptables vs. nftables

| Eigenschaft | UFW | iptables | nftables |
|---|---|---|---|
| Benutzerfreundlichkeit | **Sehr hoch** | Niedrig | Mittel |
| Lernkurve | Flach | Steil | Mittel |
| Leistung | Sehr gut | Sehr gut | Sehr gut |
| Flexibilität | Gut (deckt 95% der Fälle ab) | Maximal | Maximal |
| Regelverwaltung | Einfache Befehle | Komplexe Syntax | Moderne Syntax |
| Standard auf Debian/Ubuntu | Verfügbar | Ja (Backend) | Ja (ab Debian 11) |

> **Empfehlung:** UFW ist für die allermeisten Server-Setups ausreichend und der einfachste Weg zu einer sicheren Firewall. Für komplexe Netzwerk-Setups (Multi-NIC, komplexes NAT, Traffic Shaping) kann direktes nftables notwendig sein.

### Grundprinzip: Default Deny

Die wichtigste Regel der Firewall-Konfiguration:

- **Eingehender Verkehr:** Standardmäßig **blockiert** (deny)
- **Ausgehender Verkehr:** Standardmäßig **erlaubt** (allow)
- **Explizite Regeln:** Nur die tatsächlich benötigten Ports werden geöffnet

---

## 2. Installation und Ersteinrichtung

### 2.1 UFW installieren

```bash
sudo apt update
sudo apt install -y ufw
```

### 2.2 Status prüfen

```bash
sudo ufw status
# Ausgabe: Status: inactive
```

> **Wichtig:** UFW ist nach der Installation standardmäßig deaktiviert. Regeln können auch im deaktivierten Zustand hinzugefügt werden und werden beim Aktivieren sofort wirksam.

### 2.3 Standardrichtlinien setzen

```bash
# Eingehenden Verkehr blockieren
sudo ufw default deny incoming

# Ausgehenden Verkehr erlauben
sudo ufw default allow outgoing

# Weitergeleiteten Verkehr blockieren (optional, Standard auf Debian)
sudo ufw default deny routed
```

### 2.4 SSH-Zugang erlauben (KRITISCH – VOR dem Aktivieren!)

```bash
# SSH erlauben (Standard-Port 22)
sudo ufw allow ssh

# Oder mit benutzerdefiniertem Port
sudo ufw allow 2222/tcp
```

> **Warnung:** Wenn UFW aktiviert wird, ohne eine SSH-Regel zu erstellen, wird die aktuelle SSH-Verbindung getrennt und der Server ist nicht mehr erreichbar. Immer zuerst SSH erlauben.

### 2.5 UFW aktivieren

```bash
sudo ufw enable
```

Bestätigungsabfrage:

```
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup
```

UFW ist jetzt aktiv und startet automatisch bei jedem Systemstart.

### 2.6 Status und Regeln anzeigen

```bash
# Kompakte Ansicht
sudo ufw status

# Detaillierte Ansicht mit Regelnummern
sudo ufw status numbered

# Ausführliche Ansicht
sudo ufw status verbose
```

Beispielausgabe von `sudo ufw status verbose`:

```
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), deny (routed)
New profiles: skip

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW IN    Anywhere
22/tcp (v6)                ALLOW IN    Anywhere (v6)
```

---

## 3. Grundlegende Regelverwaltung

### 3.1 Ports erlauben (ALLOW)

```bash
# Einzelnen Port erlauben (TCP und UDP)
sudo ufw allow 80

# Nur TCP
sudo ufw allow 80/tcp

# Nur UDP
sudo ufw allow 53/udp

# Port-Bereich erlauben
sudo ufw allow 6000:6100/tcp

# Dienst nach Name erlauben
sudo ufw allow ssh
sudo ufw allow http
sudo ufw allow https
```

### 3.2 Ports blockieren (DENY)

```bash
# Port blockieren (Paket wird stillschweigend verworfen)
sudo ufw deny 23/tcp

# Port ablehnen mit Antwort (REJECT – Absender wird informiert)
sudo ufw reject 23/tcp
```

| Aktion | Verhalten | Verwendung |
|---|---|---|
| `deny` | Paket wird stillschweigend verworfen | **Standard** – Angreifer erhält keine Information |
| `reject` | Paket wird mit ICMP-Antwort abgelehnt | Für interne Netzwerke, schnellere Timeout-Erkennung |

### 3.3 Regeln entfernen

```bash
# Methode 1: Regel exakt angeben
sudo ufw delete allow 80/tcp

# Methode 2: Nach Regelnummer (empfohlen)
sudo ufw status numbered
# Ausgabe:
# [1] 22/tcp    ALLOW IN    Anywhere
# [2] 80/tcp    ALLOW IN    Anywhere
# [3] 443/tcp   ALLOW IN    Anywhere

sudo ufw delete 2
# Entfernt Regel [2] (Port 80/tcp)
```

> **Hinweis:** Nach dem Löschen einer Regel verschieben sich die Nummern. Bei mehreren Löschungen immer von der höchsten Nummer beginnen oder jeweils `status numbered` neu prüfen.

### 3.4 Regeln einfügen (an bestimmter Position)

```bash
# Regel an Position 1 einfügen (wird als Erstes ausgewertet)
sudo ufw insert 1 deny from 203.0.113.50
```

### 3.5 UFW deaktivieren und zurücksetzen

```bash
# Deaktivieren (Regeln bleiben erhalten)
sudo ufw disable

# Vollständig zurücksetzen (alle Regeln werden gelöscht!)
sudo ufw reset
```

---

## 4. Erweiterte Regeln

### 4.1 IP-basierte Regeln

```bash
# Bestimmte IP erlauben
sudo ufw allow from 192.168.1.100

# Bestimmte IP auf bestimmtem Port erlauben
sudo ufw allow from 192.168.1.100 to any port 22

# Subnetz erlauben
sudo ufw allow from 192.168.1.0/24

# Subnetz auf bestimmtem Port erlauben
sudo ufw allow from 10.0.0.0/8 to any port 5432 proto tcp

# Bestimmte IP blockieren
sudo ufw deny from 203.0.113.50

# Bestimmte IP ablehnen
sudo ufw reject from 203.0.113.50
```

### 4.2 Interface-basierte Regeln

Bei Servern mit mehreren Netzwerkschnittstellen:

```bash
# Nur auf einem bestimmten Interface erlauben
sudo ufw allow in on eth0 to any port 80
sudo ufw allow in on eth1 to any port 5432

# Loopback-Interface (für lokale Dienste)
sudo ufw allow in on lo
```

### 4.3 Richtungsspezifische Regeln

```bash
# Eingehend erlauben
sudo ufw allow in on eth0 to any port 443

# Ausgehend blockieren (z. B. bestimmten ausgehenden Port sperren)
sudo ufw deny out to any port 25
```

### 4.4 Protokoll-spezifische Regeln

```bash
# Nur TCP
sudo ufw allow proto tcp from any to any port 80

# Nur UDP
sudo ufw allow proto udp from any to any port 53

# ICMP (Ping) – wird über /etc/ufw/before.rules gesteuert
# Siehe Abschnitt 14.3
```

### 4.5 Zusammengesetzte Regeln (Vollständige Syntax)

Die vollständige Syntax erlaubt präzise Regeln:

```bash
sudo ufw allow proto tcp from 192.168.1.0/24 to 192.168.1.100 port 5432
#             │          │                     │                │
#             Protokoll  Quell-Netzwerk        Ziel-IP          Ziel-Port
```

Weitere Beispiele:

```bash
# PostgreSQL nur aus dem lokalen Netz
sudo ufw allow proto tcp from 192.168.1.0/24 to any port 5432

# HTTP/HTTPS von überall
sudo ufw allow proto tcp from any to any port 80,443

# DNS (TCP und UDP)
sudo ufw allow proto tcp from any to any port 53
sudo ufw allow proto udp from any to any port 53
```

### 4.6 Multiport-Regeln

```bash
# Mehrere Ports in einer Regel (durch Komma getrennt)
sudo ufw allow proto tcp from any to any port 80,443,8080

# Port-Bereich
sudo ufw allow 6000:6100/tcp
```

---

## 5. Anwendungsprofile

### 5.1 Was sind Anwendungsprofile?

UFW kann mit Anwendungsprofilen arbeiten, die vordefinierte Port-Konfigurationen enthalten. Anwendungen registrieren ihre Profile in `/etc/ufw/applications.d/`.

### 5.2 Verfügbare Profile anzeigen

```bash
# Alle Profile auflisten
sudo ufw app list

# Typische Ausgabe:
# Available applications:
#   Nginx Full
#   Nginx HTTP
#   Nginx HTTPS
#   OpenSSH
```

### 5.3 Profildetails anzeigen

```bash
sudo ufw app info "Nginx Full"
# Ausgabe:
# Profile: Nginx Full
# Title: Web Server (Nginx, HTTP + HTTPS)
# Description: Small, but very powerful and efficient web server
#
# Ports:
#   80,443/tcp
```

### 5.4 Profil verwenden

```bash
# Profil erlauben
sudo ufw allow "Nginx Full"
sudo ufw allow "OpenSSH"

# Profil blockieren
sudo ufw deny "Nginx HTTP"

# Profil-Regel entfernen
sudo ufw delete allow "Nginx Full"
```

### 5.5 Eigene Profile erstellen

Profile für benutzerdefinierte Dienste erstellen:

```bash
sudo nano /etc/ufw/applications.d/gitea
```

```ini
[Gitea]
title=Gitea Git Server
description=Selbst gehostete Git-Plattform
ports=3000/tcp

[Gitea SSH]
title=Gitea SSH
description=Git SSH-Zugang
ports=22/tcp
```

```bash
sudo nano /etc/ufw/applications.d/vaultwarden
```

```ini
[Vaultwarden]
title=Vaultwarden Password Manager
description=Selbst gehosteter Bitwarden-kompatibler Server
ports=8080/tcp

[Vaultwarden WebSocket]
title=Vaultwarden WebSocket
description=Vaultwarden Live-Sync
ports=3012/tcp
```

```bash
sudo nano /etc/ufw/applications.d/wikijs
```

```ini
[Wiki.js]
title=Wiki.js
description=Modernes Wiki-System
ports=3000/tcp
```

```bash
# Profile neu laden
sudo ufw app update Gitea
sudo ufw app update Vaultwarden

# Profil verwenden
sudo ufw allow Gitea
```

---

## 6. Regelkonfiguration für unsere Dienste

### 6.1 Übersicht aller Dienste und Ports

| Dienst | Port | Protokoll | Zugriff | Regel nötig? |
|---|---|---|---|---|
| **SSH** | 22 | TCP | Eingeschränkt (Admin-IPs oder VPN) | **Ja** |
| **HTTP** | 80 | TCP | Öffentlich (Redirect auf HTTPS) | **Ja** |
| **HTTPS** | 443 | TCP | Öffentlich | **Ja** |
| **Gitea** | 3000 | TCP | Nur lokal (hinter Reverse Proxy) | Nein (Standard: deny) |
| **Vaultwarden** | 8080 | TCP | Nur lokal (hinter Reverse Proxy) | Nein (Standard: deny) |
| **Vaultwarden WS** | 3012 | TCP | Nur lokal (hinter Reverse Proxy) | Nein (Standard: deny) |
| **Wiki.js** | 3000 | TCP | Nur lokal (hinter Reverse Proxy) | Nein (Standard: deny) |
| **PostgreSQL** | 5432 | TCP | Nur lokal (localhost) | Nein (Standard: deny) |
| **n8n** | 5678 | TCP | Nur lokal (hinter Reverse Proxy) | Nein (Standard: deny) |

> **Prinzip:** Nur die Ports öffnen, die tatsächlich von außen erreichbar sein müssen. Dienste hinter dem Reverse Proxy (Nginx/Caddy) werden nicht direkt exponiert.

### 6.2 Empfohlene Firewall-Regeln

```bash
# ============================================================
# UFW-Regeln für diesen Server
# ============================================================

# 1. Standardrichtlinien
sudo ufw default deny incoming
sudo ufw default allow outgoing

# 2. SSH – Zugang für Administration
sudo ufw limit ssh
# Oder eingeschränkt auf bestimmte IPs:
# sudo ufw allow from 192.168.1.0/24 to any port 22 proto tcp
# sudo ufw allow from 10.8.0.0/24 to any port 22 proto tcp  # VPN

# 3. HTTP und HTTPS – Öffentlicher Webzugang
sudo ufw allow http
sudo ufw allow https

# 4. Aktivieren
sudo ufw enable
```

Das ist alles. Dienste wie Gitea, Vaultwarden, Wiki.js und PostgreSQL lauschen nur auf `127.0.0.1` und sind hinter dem Reverse Proxy geschützt. Für sie werden keine UFW-Regeln benötigt.

### 6.3 Optionale zusätzliche Regeln

```bash
# PostgreSQL aus dem internen Netz (falls nötig)
sudo ufw allow from 192.168.1.0/24 to any port 5432 proto tcp

# Monitoring (z. B. Prometheus Node Exporter)
sudo ufw allow from 192.168.1.50 to any port 9100 proto tcp

# E-Mail-Versand (SMTP ausgehend – ist standardmäßig erlaubt)
# Falls ausgehend blockiert ist:
# sudo ufw allow out 587/tcp
```

### 6.4 Regeln anzeigen und prüfen

```bash
sudo ufw status numbered verbose
```

Erwartete Ausgabe:

```
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), deny (routed)

     To                         Action      From
     --                         ------      ----
[ 1] 22/tcp                     LIMIT IN    Anywhere
[ 2] 80/tcp                     ALLOW IN    Anywhere
[ 3] 443/tcp                    ALLOW IN    Anywhere
[ 4] 22/tcp (v6)                LIMIT IN    Anywhere (v6)
[ 5] 80/tcp (v6)                ALLOW IN    Anywhere (v6)
[ 6] 443/tcp (v6)               ALLOW IN    Anywhere (v6)
```

---

## 7. Logging und Überwachung

### 7.1 Logging aktivieren

```bash
# Logging-Level setzen
sudo ufw logging on         # Standard (low)
sudo ufw logging low        # Blockierte Pakete
sudo ufw logging medium     # Blockierte + nicht zugeordnete Pakete
sudo ufw logging high       # Alle Pakete (Vorsicht: große Logdateien!)
sudo ufw logging full       # Maximal (nur für Debugging)

# Logging deaktivieren
sudo ufw logging off
```

| Level | Was wird geloggt | Logvolumen |
|---|---|---|
| `off` | Nichts | Keins |
| `low` | Blockierte Pakete, die einer Regel entsprechen | Niedrig |
| `medium` | Blockierte + ungültige + neue Verbindungen | Mittel |
| `high` | Alle Pakete (mit und ohne Rate Limiting) | **Hoch** |
| `full` | Wie high, ohne Rate Limiting | **Sehr hoch** |

> **Empfehlung:** `low` für den Produktivbetrieb. `medium` oder `high` nur temporär zur Diagnose.

### 7.2 Logdateien lesen

UFW schreibt in die Kernel-Log-Datei:

```bash
# UFW-Einträge anzeigen
sudo grep "UFW" /var/log/kern.log | tail -30

# Oder über den Syslog
sudo grep "UFW" /var/log/syslog | tail -30

# Live-Überwachung
sudo tail -f /var/log/kern.log | grep "UFW"

# Nur blockierte Pakete
sudo grep "UFW BLOCK" /var/log/kern.log | tail -20

# Nur erlaubte Pakete (bei medium+ Logging)
sudo grep "UFW ALLOW" /var/log/kern.log | tail -20
```

### 7.3 Log-Einträge verstehen

Beispiel eines blockierten Pakets:

```
Feb 24 14:32:15 server kernel: [UFW BLOCK] IN=eth0 OUT= MAC=... SRC=203.0.113.50 DST=192.168.1.100 LEN=44 TOS=0x00 PREC=0x00 TTL=54 ID=12345 PROTO=TCP SPT=54321 DPT=5432 WINDOW=1024 RES=0x00 SYN URGP=0
```

| Feld | Bedeutung | Beispielwert |
|---|---|---|
| `UFW BLOCK` | Aktion (BLOCK, ALLOW, AUDIT) | Paket wurde blockiert |
| `IN=eth0` | Eingehendes Interface | eth0 |
| `SRC=` | Quell-IP-Adresse | 203.0.113.50 |
| `DST=` | Ziel-IP-Adresse | 192.168.1.100 |
| `PROTO=` | Protokoll | TCP |
| `SPT=` | Quell-Port | 54321 |
| `DPT=` | **Ziel-Port** | 5432 (PostgreSQL!) |
| `SYN` | TCP-Flag | Verbindungsaufbau |

In diesem Beispiel hat jemand von IP `203.0.113.50` versucht, direkt auf PostgreSQL (Port 5432) zuzugreifen, und die Firewall hat den Zugriff blockiert.

### 7.4 Angriffsanalyse-Befehle

```bash
# Top 10 der am häufigsten angegriffenen Ports
sudo grep "UFW BLOCK" /var/log/kern.log | \
  grep -oP "DPT=\K[0-9]+" | \
  sort | uniq -c | sort -rn | head -10

# Top 10 der blockierten Quell-IPs
sudo grep "UFW BLOCK" /var/log/kern.log | \
  grep -oP "SRC=\K[0-9.]+" | \
  sort | uniq -c | sort -rn | head -10

# Blockierte Pakete der letzten 24 Stunden zählen
sudo grep "UFW BLOCK" /var/log/kern.log | \
  grep "$(date +%b\ %d)" | wc -l
```

### 7.5 Eigene UFW-Logdatei einrichten

Um UFW-Logs von den Kernel-Logs zu trennen:

```bash
sudo nano /etc/rsyslog.d/20-ufw.conf
```

```
:msg,contains,"[UFW " /var/log/ufw.log
& stop
```

```bash
sudo systemctl restart rsyslog
```

Logrotation für die neue Datei:

```bash
sudo nano /etc/logrotate.d/ufw
```

```
/var/log/ufw.log {
    daily
    rotate 14
    compress
    delaycompress
    missingok
    notifempty
    postrotate
        /usr/sbin/invoke-rc.d rsyslog rotate > /dev/null 2>&1 || true
    endscript
}
```

---

## 8. IPv6-Konfiguration

### 8.1 IPv6-Unterstützung prüfen und aktivieren

```bash
sudo nano /etc/default/ufw
```

```bash
# IPv6-Unterstützung (Standard: yes)
IPV6=yes
```

```bash
sudo ufw disable && sudo ufw enable
```

### 8.2 IPv6-Regeln

UFW erstellt automatisch IPv6-Regeln parallel zu IPv4-Regeln:

```bash
# Diese Regel erstellt sowohl IPv4- als auch IPv6-Einträge
sudo ufw allow 80/tcp

# Ergebnis in 'ufw status':
# 80/tcp        ALLOW IN    Anywhere
# 80/tcp (v6)   ALLOW IN    Anywhere (v6)
```

Nur IPv6-spezifische Regeln:

```bash
# Bestimmte IPv6-Adresse erlauben
sudo ufw allow from 2001:db8::/32 to any port 22

# IPv6-Adresse blockieren
sudo ufw deny from 2001:db8::1
```

### 8.3 IPv6 deaktivieren (falls nicht benötigt)

Falls der Server kein IPv6 verwendet:

```bash
# In /etc/default/ufw
IPV6=no
```

```bash
sudo ufw disable && sudo ufw enable
```

---

## 9. Rate Limiting – Brute-Force-Schutz

### 9.1 Was ist Rate Limiting?

UFW bietet eingebautes Rate Limiting: Wenn eine IP-Adresse innerhalb von 30 Sekunden mehr als 6 Verbindungsversuche startet, wird sie temporär blockiert.

### 9.2 Rate Limiting aktivieren

```bash
# SSH mit Rate Limiting schützen
sudo ufw limit ssh

# Oder mit benutzerdefiniertem Port
sudo ufw limit 2222/tcp

# Rate Limiting mit Protokoll
sudo ufw limit proto tcp from any to any port 22
```

### 9.3 Rate Limiting vs. Fail2Ban

| Eigenschaft | UFW Rate Limiting | Fail2Ban |
|---|---|---|
| Konfigurierbarkeit | Fest (6 Versuche / 30 Sek.) | Frei konfigurierbar |
| Sperrzeit | Automatisch (Minuten) | Konfigurierbar (Stunden/Tage) |
| Log-Analyse | Nein (Paketebene) | Ja (analysiert Logdateien) |
| Anwendungsspezifisch | Nur Ports | Alle Dienste (SSH, Gitea, Vaultwarden) |
| Ressourcenverbrauch | Minimal | Gering |

> **Empfehlung:** Beide zusammen verwenden. UFW Rate Limiting als erste Verteidigungslinie auf Paketebene, Fail2Ban als intelligentere zweite Stufe, die Anmeldeversuche auf Anwendungsebene analysiert.

### 9.4 Bestehende Allow-Regel durch Limit ersetzen

```bash
# Alte Regel entfernen
sudo ufw delete allow ssh

# Neue Regel mit Rate Limiting
sudo ufw limit ssh
```

---

## 10. Port-Weiterleitung und NAT

### 10.1 IP-Forwarding aktivieren

Für Port-Weiterleitung muss IP-Forwarding im Kernel aktiv sein:

```bash
sudo nano /etc/ufw/sysctl.conf
```

```bash
# IPv4-Forwarding aktivieren
net/ipv4/ip_forward=1

# IPv6-Forwarding (falls benötigt)
# net/ipv6/conf/default/forwarding=1
```

### 10.2 UFW für Forwarding konfigurieren

```bash
sudo nano /etc/default/ufw
```

```bash
# Standardrichtlinie für weitergeleiteten Verkehr
DEFAULT_FORWARD_POLICY="DROP"
# Auf "ACCEPT" setzen, falls dieser Server als Router dient
```

### 10.3 Port-Weiterleitung über before.rules

Für NAT und Port-Weiterleitung müssen die Regeln direkt in `/etc/ufw/before.rules` eingetragen werden:

```bash
sudo nano /etc/ufw/before.rules
```

Vor der Zeile `*filter` folgendes einfügen:

```bash
# NAT-Tabelle für Port-Weiterleitung
*nat
:PREROUTING ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]

# Port 8443 von außen → Port 443 auf internem Server
-A PREROUTING -i eth0 -p tcp --dport 8443 -j DNAT --to-destination 192.168.1.50:443

# Masquerading für weitergeleiteten Verkehr
-A POSTROUTING -s 192.168.1.0/24 -o eth0 -j MASQUERADE

COMMIT
```

```bash
# Weitergeleiteten Verkehr in der UFW erlauben
sudo ufw route allow proto tcp from any to 192.168.1.50 port 443

# Änderungen anwenden
sudo ufw disable && sudo ufw enable
```

### 10.4 Routed-Regeln (für VPN, Container)

```bash
# Verkehr zwischen Interfaces erlauben (z. B. VPN → LAN)
sudo ufw route allow in on tun0 out on eth0

# Verkehr aus einem Docker-Netzwerk erlauben
sudo ufw route allow in on docker0 out on eth0

# Bestimmten weitergeleiteten Port erlauben
sudo ufw route allow proto tcp from any to any port 80
```

---

## 11. UFW und Docker

### 11.1 Das Docker-UFW-Problem

Docker manipuliert iptables-Regeln direkt und umgeht dabei UFW. Das bedeutet, dass ein Docker-Container mit `-p 5432:5432` auch dann von außen erreichbar ist, wenn UFW Port 5432 blockiert.

### 11.2 Lösung: Ports nur auf localhost binden (empfohlen)

Die einfachste und sicherste Lösung:

```yaml
# docker-compose.yml
services:
  vaultwarden:
    ports:
      # ✅ RICHTIG: Nur lokal erreichbar
      - "127.0.0.1:8080:80"

      # ❌ FALSCH: Von überall erreichbar (umgeht UFW!)
      # - "8080:80"
```

### 11.3 Alternative: Docker-iptables deaktivieren

Docker so konfigurieren, dass es die iptables-Regeln nicht manipuliert:

```bash
sudo nano /etc/docker/daemon.json
```

```json
{
  "iptables": false
}
```

```bash
sudo systemctl restart docker
```

> **Warnung:** Mit `"iptables": false` funktionieren Docker-Netzwerke nicht mehr automatisch. Container können sich nicht mehr untereinander oder mit dem Internet verbinden, ohne manuelle Regeln. Diese Option nur verwenden, wenn man die Netzwerk-Konfiguration vollständig selbst verwalten möchte.

### 11.4 Empfohlene Praxis für diesen Server

| Dienst | Port-Binding | Erklärung |
|---|---|---|
| Vaultwarden | `127.0.0.1:8080:80` | Nur über Reverse Proxy |
| Vaultwarden WS | `127.0.0.1:3012:3012` | Nur über Reverse Proxy |
| n8n (falls Docker) | `127.0.0.1:5678:5678` | Nur über Reverse Proxy |

So sind die Dienste nur lokal erreichbar, und der Reverse Proxy (Nginx/Caddy) stellt den öffentlichen HTTPS-Zugang bereit.

---

## 12. Regelreihenfolge und Priorität

### 12.1 Wie UFW Regeln auswertet

UFW wertet Regeln **von oben nach unten** aus. Die erste zutreffende Regel wird angewendet, alle weiteren ignoriert.

```
Eingehendes Paket
       │
       ▼
  Regel 1 ──▶ Trifft zu? → Aktion ausführen (STOP)
       │ Nein
       ▼
  Regel 2 ──▶ Trifft zu? → Aktion ausführen (STOP)
       │ Nein
       ▼
     ...
       │ Nein
       ▼
  Standardrichtlinie ──▶ deny incoming (Paket verworfen)
```

### 12.2 Reihenfolge ist wichtig – Beispiel

```bash
# ❌ FALSCH: Die Allow-Regel kommt zuerst → IP wird NICHT blockiert
sudo ufw allow 80/tcp                    # Regel [1]
sudo ufw deny from 203.0.113.50          # Regel [2] – wird nie erreicht für Port 80

# ✅ RICHTIG: Die Deny-Regel muss VOR der Allow-Regel stehen
sudo ufw insert 1 deny from 203.0.113.50 # Regel [1] – wird zuerst geprüft
sudo ufw allow 80/tcp                    # Regel [2]
```

### 12.3 Verarbeitungsreihenfolge im Detail

UFW verarbeitet Regeln in dieser Reihenfolge:

1. `/etc/ufw/before.rules` – Regeln vor den Benutzerregeln (z. B. ICMP, Loopback)
2. **Benutzerregeln** – Die mit `ufw allow/deny` erstellten Regeln (in `user.rules`)
3. `/etc/ufw/after.rules` – Regeln nach den Benutzerregeln
4. **Standardrichtlinie** – `deny incoming` / `allow outgoing`

---

## 13. Backup und Wiederherstellung

### 13.1 Konfigurationsdateien sichern

```bash
# Vollständiges Backup der UFW-Konfiguration
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
sudo mkdir -p /backup/ufw

sudo tar -czf "/backup/ufw/ufw_backup_${TIMESTAMP}.tar.gz" \
  /etc/ufw/ /etc/default/ufw

echo "Backup erstellt: /backup/ufw/ufw_backup_${TIMESTAMP}.tar.gz"
```

### 13.2 Regeln als reproduzierbares Skript pflegen

Die beste Methode ist, die Regeln als Skript zu dokumentieren:

```bash
sudo nano /opt/scripts/ufw-setup.sh
```

```bash
#!/bin/bash
# ===========================================================
# UFW-Firewall-Setup für unseren Server
# Zuletzt aktualisiert: DATUM
# ===========================================================

set -e

echo "UFW wird konfiguriert..."

# Zurücksetzen
sudo ufw --force reset

# Standardrichtlinien
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH mit Rate Limiting
sudo ufw limit ssh

# Web (HTTP + HTTPS)
sudo ufw allow http
sudo ufw allow https

# Logging
sudo ufw logging on

# Aktivieren
sudo ufw --force enable

echo "UFW-Konfiguration abgeschlossen:"
sudo ufw status verbose
```

```bash
sudo chmod +x /opt/scripts/ufw-setup.sh
```

### 13.3 Wiederherstellung

```bash
# Aus dem Archiv wiederherstellen
sudo ufw disable
sudo tar -xzf /backup/ufw/ufw_backup_YYYYMMDD.tar.gz -C /
sudo ufw enable
sudo ufw status verbose

# Oder: Skript erneut ausführen
sudo /opt/scripts/ufw-setup.sh
```

### 13.4 Regeln auf einen neuen Server übertragen

```bash
# Auf dem alten Server
scp /etc/ufw/user.rules benutzer@neuer-server:/tmp/
scp /etc/ufw/user6.rules benutzer@neuer-server:/tmp/

# Auf dem neuen Server
sudo cp /tmp/user.rules /etc/ufw/
sudo cp /tmp/user6.rules /etc/ufw/
sudo ufw disable && sudo ufw enable
```

---

## 14. Sicherheitshärtung

### 14.1 Checkliste

- [ ] **Standardrichtlinie:** `deny incoming`, `allow outgoing`
- [ ] **SSH erlaubt** (bevor UFW aktiviert wird)
- [ ] **Nur benötigte Ports** geöffnet (22, 80, 443)
- [ ] **Docker-Ports nur auf localhost** gebunden
- [ ] **Rate Limiting** auf SSH aktiviert
- [ ] **Fail2Ban** zusätzlich installiert
- [ ] **Logging** auf `low` aktiviert
- [ ] **IPv6** konfiguriert oder deaktiviert
- [ ] **ICMP-Regeln** geprüft
- [ ] **Regelmäßige Überprüfung** der aktiven Regeln
- [ ] **Backup** der Firewall-Konfiguration vorhanden
- [ ] **Keine überflüssigen Regeln** vorhanden

### 14.2 Minimale Angriffsfläche prüfen

```bash
# Alle offenen Ports auf dem System anzeigen (OHNE Firewall-Sicht)
sudo ss -tlnp

# Was die Firewall durchlässt
sudo ufw status

# Offene Ports von außen testen (von einem anderen Rechner)
nmap -sT server-ip
```

### 14.3 ICMP (Ping) konfigurieren

Standardmäßig erlaubt UFW ICMP (Ping). Um Ping zu blockieren:

```bash
sudo nano /etc/ufw/before.rules
```

Folgende Zeilen finden und `ACCEPT` durch `DROP` ersetzen:

```bash
# Ok ICMP codes for INPUT
-A ufw-before-input -p icmp --icmp-type destination-unreachable -j DROP
-A ufw-before-input -p icmp --icmp-type time-exceeded -j DROP
-A ufw-before-input -p icmp --icmp-type parameter-problem -j DROP
-A ufw-before-input -p icmp --icmp-type echo-request -j DROP
```

```bash
sudo ufw disable && sudo ufw enable
```

> **Hinweis:** Das Blockieren von Ping kann die Netzwerkdiagnose erschweren. In den meisten Fällen ist es sinnvoller, Ping zu erlauben.

### 14.4 Kernel-Netzwerkparameter härten

```bash
sudo nano /etc/ufw/sysctl.conf
```

```bash
# Schutz vor IP-Spoofing
net/ipv4/conf/all/rp_filter=1
net/ipv4/conf/default/rp_filter=1

# ICMP-Redirects ignorieren
net/ipv4/conf/all/accept_redirects=0
net/ipv4/conf/default/accept_redirects=0

# Source-Routing deaktivieren
net/ipv4/conf/all/accept_source_route=0
net/ipv4/conf/default/accept_source_route=0

# SYN-Flood-Schutz
net/ipv4/tcp_syncookies=1

# Broadcast-Ping ignorieren (Smurf-Schutz)
net/ipv4/icmp_echo_ignore_broadcasts=1

# Log Martians (ungültige Quelladressen loggen)
net/ipv4/conf/all/log_martians=1
net/ipv4/conf/default/log_martians=1
```

```bash
sudo ufw disable && sudo ufw enable
```

### 14.5 Regelmäßige Überprüfung (monatlich)

```bash
#!/bin/bash
# /opt/scripts/ufw-audit.sh – Monatlicher Firewall-Check

echo "=== UFW-Sicherheitsaudit $(date) ==="

echo -e "\n--- Aktive Regeln ---"
sudo ufw status numbered verbose

echo -e "\n--- Offene Ports auf dem System ---"
sudo ss -tlnp | grep -v "127.0.0" | grep LISTEN

echo -e "\n--- Blockierte Pakete (letzte 24h) ---"
BLOCKED=$(sudo grep "UFW BLOCK" /var/log/kern.log 2>/dev/null | \
  grep "$(date +%b\ %d)" | wc -l)
echo "Blockierte Pakete heute: $BLOCKED"

echo -e "\n--- Top 5 Angreifer-IPs ---"
sudo grep "UFW BLOCK" /var/log/kern.log 2>/dev/null | \
  grep "$(date +%b\ %d)" | \
  grep -oP "SRC=\K[0-9.]+" | \
  sort | uniq -c | sort -rn | head -5

echo -e "\n--- Top 5 angegriffene Ports ---"
sudo grep "UFW BLOCK" /var/log/kern.log 2>/dev/null | \
  grep "$(date +%b\ %d)" | \
  grep -oP "DPT=\K[0-9]+" | \
  sort | uniq -c | sort -rn | head -5

echo -e "\n=== Audit abgeschlossen ==="
```

```bash
sudo chmod +x /opt/scripts/ufw-audit.sh
```

---

## 15. Fehlerbehebung

### 15.1 UFW lässt sich nicht aktivieren

```bash
# Fehlermeldung: "ERROR: problem running ufw-init"

# 1. iptables-Module prüfen und laden
sudo modprobe ip_tables
sudo modprobe ip6_tables
sudo modprobe nf_conntrack

# 2. iptables/nftables prüfen
sudo iptables -L -n
sudo nft list ruleset

# 3. UFW erneut versuchen
sudo ufw enable
```

### 15.2 Dienst ist trotz Allow-Regel nicht erreichbar

```bash
# 1. Läuft der Dienst?
sudo systemctl status nginx
sudo ss -tlnp | grep :80

# 2. Auf welcher Adresse lauscht der Dienst?
sudo ss -tlnp | grep :80
# "127.0.0.1:80" → Nur lokal erreichbar (Problem!)
# "0.0.0.0:80" → Von überall erreichbar ✅

# 3. Firewall-Regel vorhanden?
sudo ufw status | grep 80

# 4. Wird der Verkehr blockiert?
sudo grep "UFW BLOCK.*DPT=80" /var/log/kern.log | tail -5

# 5. Von außen testen
nmap -p 80 server-ip
```

### 15.3 Dienst ist trotz Deny erreichbar

```bash
# Häufigste Ursache: Docker umgeht UFW

# Docker iptables-Regeln prüfen
sudo iptables -L DOCKER -n -v 2>/dev/null

# Port-Binding prüfen
sudo ss -tlnp | grep :PORTNUMMER
# Falls "0.0.0.0:PORT" → Docker bindet auf allen Interfaces

# Lösung: Port nur auf localhost binden (siehe Abschnitt 11)
```

### 15.4 SSH-Verbindung nach UFW-Aktivierung verloren

Falls der Zugriff gesperrt ist:

1. **Konsole/KVM/IPMI** verwenden (physischer oder virtueller Zugang)
2. Am Server anmelden und UFW deaktivieren:

```bash
sudo ufw disable
sudo ufw allow ssh
sudo ufw enable
```

Falls keine Konsole verfügbar ist:

- **Recovery-Modus** des Hosters nutzen
- Festplatte in ein Rettungssystem mounten
- `/etc/ufw/user.rules` bearbeiten oder UFW deaktivieren über `/etc/ufw/ufw.conf`:

```bash
# In /etc/ufw/ufw.conf
ENABLED=no
```

### 15.5 Regelkonflikte erkennen

```bash
# Alle Regeln mit Nummern anzeigen
sudo ufw status numbered

# Typischer Konflikt:
# [1] DENY IN    203.0.113.0/24       → Blockt das gesamte Subnetz
# [2] ALLOW IN   203.0.113.50 port 22 → Wird NICHT erreicht!

# Lösung: Spezifische Allow-Regel VOR die Deny-Regel setzen
sudo ufw insert 1 allow from 203.0.113.50 to any port 22
```

### 15.6 UFW nach Kernel-Update reparieren

```bash
# Kernel-Module neu laden
sudo modprobe ip_tables
sudo modprobe ip6_tables
sudo modprobe nf_conntrack

# UFW neu starten
sudo ufw disable
sudo ufw enable
```

---

## 16. Schnellreferenz – Befehle auf einen Blick

### Grundbefehle

```bash
sudo ufw enable                      # Aktivieren
sudo ufw disable                     # Deaktivieren
sudo ufw reset                       # Alle Regeln löschen
sudo ufw reload                      # Regeln neu laden
sudo ufw status                      # Status anzeigen
sudo ufw status numbered             # Mit Regelnummern
sudo ufw status verbose              # Ausführlich
```

### Regeln verwalten

```bash
# Erlauben
sudo ufw allow 80/tcp                # Port
sudo ufw allow ssh                   # Dienst
sudo ufw allow from 192.168.1.0/24   # Subnetz
sudo ufw allow from 10.0.0.1 to any port 22  # IP + Port
sudo ufw allow "Nginx Full"          # Anwendungsprofil

# Blockieren
sudo ufw deny 23/tcp                 # Port
sudo ufw deny from 203.0.113.50      # IP

# Rate Limiting
sudo ufw limit ssh                   # Brute-Force-Schutz

# Entfernen
sudo ufw delete allow 80/tcp         # Nach Regel
sudo ufw delete 3                    # Nach Nummer

# Einfügen
sudo ufw insert 1 deny from 1.2.3.4 # An Position 1
```

### Standardrichtlinien

```bash
sudo ufw default deny incoming       # Eingehend blockieren
sudo ufw default allow outgoing      # Ausgehend erlauben
sudo ufw default deny routed         # Weiterleitung blockieren
```

### Logging und Analyse

```bash
sudo ufw logging on                  # Aktivieren (low)
sudo ufw logging medium              # Detaillierter

# Logs lesen
sudo grep "UFW BLOCK" /var/log/kern.log | tail -20
sudo tail -f /var/log/kern.log | grep "UFW"

# Top-Angreifer
sudo grep "UFW BLOCK" /var/log/kern.log | grep -oP "SRC=\K[0-9.]+" | sort | uniq -c | sort -rn | head -10
```

### Anwendungsprofile

```bash
sudo ufw app list                    # Alle Profile
sudo ufw app info "Nginx Full"       # Profildetails
sudo ufw allow "OpenSSH"             # Profil verwenden
```

### Empfohlenes Regelset für diesen Server

```bash
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw limit ssh
sudo ufw allow http
sudo ufw allow https
sudo ufw logging on
sudo ufw enable
```

### Wichtige Dateipfade

```
/etc/ufw/
├── before.rules          # Regeln vor Benutzerregeln (ICMP, Loopback, NAT)
├── after.rules           # Regeln nach Benutzerregeln
├── before6.rules         # IPv6-Regeln vor Benutzerregeln
├── after6.rules          # IPv6-Regeln nach Benutzerregeln
├── user.rules            # Benutzerregeln (IPv4) – von ufw verwaltet
├── user6.rules           # Benutzerregeln (IPv6) – von ufw verwaltet
├── ufw.conf              # UFW-Aktivierungsstatus
├── sysctl.conf           # Kernel-Netzwerkparameter
└── applications.d/       # Anwendungsprofile
    ├── openssh-server
    └── nginx

/etc/default/ufw          # Grundeinstellungen (IPv6, Policy, Module)
/var/log/kern.log          # Firewall-Logs (UFW BLOCK/ALLOW)
/var/log/ufw.log           # Eigene Logdatei (falls konfiguriert)
```

---

> **Letzte Aktualisierung:** *24.02.2026*
> **Autor:** *Administrator*
> **Version:** 1.0