---
title: UFW server firewall Profice
description: 
published: true
date: 2026-02-24T08:54:57.458Z
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:** Netzwerk-Absicherung, Portfilterung, Zugriffskontrolle für alle Server-Dienste

---

## 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. [Regeln für unsere Server-Dienste](#6-regeln-für-unsere-server-dienste)
7. [Rate Limiting – Verbindungsbegrenzung](#7-rate-limiting--verbindungsbegrenzung)
8. [Logging und Überwachung](#8-logging-und-überwachung)
9. [IPv6-Konfiguration](#9-ipv6-konfiguration)
10. [Erweiterte Konfiguration (ufw-Dateien)](#10-erweiterte-konfiguration-ufw-dateien)
11. [Port-Weiterleitung und NAT](#11-port-weiterleitung-und-nat)
12. [Docker und UFW](#12-docker-und-ufw)
13. [Fehlerbehebung](#13-fehlerbehebung)
14. [Best Practices und Sicherheitshärtung](#14-best-practices-und-sicherheitshärtung)
15. [Schnellreferenz – Befehle auf einen Blick](#15-schnellreferenz--befehle-auf-einen-blick)

---

## 1. Überblick und Funktionsweise

### Was ist UFW?

UFW (Uncomplicated Firewall) ist ein benutzerfreundliches Frontend für den Linux-Paketfilter `iptables` (bzw. `nftables` auf neueren Systemen). Es vereinfacht die Verwaltung von Firewall-Regeln erheblich, ohne auf die Flexibilität von iptables 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 – auch Dienste, die nur lokal benötigt werden.

| Ohne Firewall | Mit UFW |
|---|---|
| Alle Ports offen | Nur erlaubte Ports offen |
| PostgreSQL (5432) aus dem Internet erreichbar | PostgreSQL nur lokal erreichbar |
| Jeder Dienst ist ein Angriffsziel | Angriffsfläche minimiert |
| Kein Schutz vor Port-Scans | Port-Scans sehen nur erlaubte Dienste |

### Wie funktioniert UFW?

```plantuml
@startuml

skinparam shadowing false
skinparam roundCorner 10

actor "Internet\n(Anfragen)" as inet

package "Debian Server" {

    [UFW Firewall\n(Paketfilter)] as ufw

    package "Erlaubt" {
        [Port 22 – SSH] as ssh
        [Port 80 – HTTP] as http
        [Port 443 – HTTPS] as https
    }

    package "Blockiert" {
        [Port 5432 – PostgreSQL] as pg
        [Port 3000 – Gitea intern] as gitea
        [Port 8080 – Vaultwarden intern] as vw
    }
}

inet --> ufw
ufw --> ssh : Durchgelassen
ufw --> http : Durchgelassen
ufw --> https : Durchgelassen
ufw -[hidden]-> pg
ufw -[hidden]-> gitea
ufw -[hidden]-> vw

@enduml
```

**Prinzip:** UFW prüft jedes eingehende und ausgehende Netzwerkpaket anhand der definierten Regeln. Pakete, die keiner Regel entsprechen, werden gemäß der Standardrichtlinie (Default Policy) behandelt – in der Regel verworfen.

### Regelverarbeitung

UFW verarbeitet Regeln in der Reihenfolge ihrer Erstellung (von oben nach unten). Die erste zutreffende Regel entscheidet:

1. Paket kommt an → UFW prüft Regel 1
2. Trifft Regel 1 zu? → Aktion ausführen (allow/deny), fertig
3. Trifft nicht zu? → Nächste Regel prüfen
4. Keine Regel trifft zu → Default Policy anwenden (deny)

### Begriffe

| Begriff | Beschreibung |
|---|---|
| **Eingehend (incoming)** | Pakete, die von außen zum Server kommen |
| **Ausgehend (outgoing)** | Pakete, die vom Server nach außen gehen |
| **Allow** | Verbindung erlauben |
| **Deny** | Verbindung still verwerfen (kein Feedback) |
| **Reject** | Verbindung ablehnen (mit Fehlermeldung) |
| **Limit** | Verbindung erlauben, aber Rate begrenzen |
| **Default Policy** | Standardverhalten für nicht-geregelte Pakete |

---

## 2. Installation und Ersteinrichtung

### 2.1 UFW installieren

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

### 2.2 Aktuellen Status prüfen

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

### 2.3 Standardrichtlinien setzen (Default Policies)

Bevor die Firewall aktiviert wird, müssen die Standardrichtlinien festgelegt werden:

```bash
# Eingehend: ALLES blockieren (Standard)
sudo ufw default deny incoming

# Ausgehend: ALLES erlauben (Standard)
sudo ufw default allow outgoing
```

> **Erklärung:** Mit diesen Einstellungen wird jeder eingehende Verkehr blockiert, es sei denn, eine explizite Regel erlaubt ihn. Ausgehender Verkehr (Updates, DNS, E-Mail-Versand) bleibt erlaubt.

### 2.4 SSH erlauben (KRITISCH – vor dem Aktivieren!)

```bash
# SSH MUSS erlaubt werden, bevor UFW aktiviert wird!
# Sonst sperrt man sich vom Server aus.
sudo ufw allow ssh
```

Falls SSH auf einem anderen Port läuft:

```bash
sudo ufw allow 2222/tcp
```

### 2.5 UFW aktivieren

```bash
sudo ufw enable
```

Ausgabe:

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

> **Warnung:** UFW NUR aktivieren, nachdem SSH erlaubt wurde. Bei einer Remote-Verbindung (SSH) ohne SSH-Regel ist der Server nicht mehr erreichbar. In diesem Fall hilft nur noch physischer Zugang oder eine Konsole (KVM/IPMI).

### 2.6 Status nach Aktivierung prüfen

```bash
sudo ufw status verbose
```

Erwartete Ausgabe:

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

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

### 2.7 UFW beim Systemstart

UFW startet nach der Aktivierung automatisch beim Booten. Dies wird über den Dienst gesteuert:

```bash
# Status prüfen
sudo systemctl status ufw

# Autostart prüfen
sudo systemctl is-enabled ufw
# Ausgabe: enabled
```

---

## 3. Grundlegende Regelverwaltung

### 3.1 Port erlauben

```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:6010/tcp
```

### 3.2 Port blockieren

```bash
# Port blockieren (still, ohne Antwort)
sudo ufw deny 3306

# Port ablehnen (mit ICMP-Fehlermeldung)
sudo ufw reject 3306
```

| Aktion | Verhalten | Empfehlung |
|---|---|---|
| `deny` | Paket wird still verworfen, Absender erhält keine Antwort | **Empfohlen** – gibt Angreifern keine Information |
| `reject` | Paket wird abgelehnt, Absender erhält eine Fehlermeldung | Nur für interne Netzwerke – hilft beim Debugging |

### 3.3 Dienste nach Name erlauben

UFW kennt viele Dienstnamen aus `/etc/services`:

```bash
sudo ufw allow ssh          # Port 22
sudo ufw allow http         # Port 80
sudo ufw allow https        # Port 443
sudo ufw allow 'DNS'        # Port 53
```

Verfügbare Dienstnamen anzeigen:

```bash
less /etc/services
```

### 3.4 Regeln anzeigen

```bash
# Kompakte Ansicht
sudo ufw status

# Ausführliche Ansicht
sudo ufw status verbose

# Mit Regelnummern (wichtig zum Löschen)
sudo ufw status numbered
```

Beispielausgabe mit Nummern:

```
Status: active

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

### 3.5 Regeln löschen

```bash
# Methode 1: Nach Regelnummer löschen (empfohlen)
sudo ufw status numbered
sudo ufw delete 3

# Methode 2: Regel exakt wiederholen mit 'delete'
sudo ufw delete allow 80/tcp
sudo ufw delete deny 3306
```

> **Hinweis:** Beim Löschen nach Nummer verschieben sich die Nummern. Immer von der höchsten Nummer nach unten löschen, oder nach jeder Löschung erneut `ufw status numbered` ausführen.

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

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

# Regel an Position 3 einfügen
sudo ufw insert 3 allow from 192.168.1.0/24 to any port 5432
```

### 3.7 UFW zurücksetzen

```bash
# Alle Regeln löschen und UFW deaktivieren
sudo ufw reset

# Danach: Standardrichtlinien neu setzen, Regeln neu erstellen, aktivieren
```

### 3.8 UFW deaktivieren (temporär)

```bash
# Firewall deaktivieren (Regeln bleiben gespeichert)
sudo ufw disable

# Wieder aktivieren
sudo ufw enable
```

---

## 4. Erweiterte Regeln

### 4.1 Regeln nach IP-Adresse

```bash
# Bestimmte IP erlauben (alle Ports)
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

# Ganzes Subnetz erlauben
sudo ufw allow from 192.168.1.0/24

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

# Bestimmte IP blockieren
sudo ufw deny from 203.0.113.50

# Bestimmte IP komplett sperren (an erster Position!)
sudo ufw insert 1 deny from 203.0.113.50
```

### 4.2 Regeln nach Netzwerk-Interface

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

# Nur auf dem Loopback-Interface erlauben
sudo ufw allow in on lo

# Auf einem internen Interface erlauben
sudo ufw allow in on eth1 from 10.0.0.0/8 to any port 5432
```

### 4.3 Regeln nach Zieladresse

```bash
# Nur an eine bestimmte Server-IP erlauben
sudo ufw allow from 192.168.1.0/24 to 192.168.1.100 port 443 proto tcp
```

### 4.4 Ausgehende Regeln

Standardmäßig ist der ausgehende Verkehr erlaubt. Falls eine strengere Kontrolle gewünscht ist:

```bash
# Ausgehend: Standardmäßig blockieren
sudo ufw default deny outgoing

# Dann gezielt erlauben:
sudo ufw allow out 53            # DNS
sudo ufw allow out 80/tcp        # HTTP (Updates)
sudo ufw allow out 443/tcp       # HTTPS (Updates)
sudo ufw allow out 587/tcp       # SMTP (E-Mail-Versand)
sudo ufw allow out 123/udp       # NTP (Zeitsynchronisation)
sudo ufw allow out 22/tcp        # SSH ausgehend
```

> **Hinweis:** Ausgehenden Verkehr zu blockieren erhöht die Sicherheit, erfordert aber eine sorgfältige Planung aller benötigten Dienste. Für die meisten Server ist `default allow outgoing` ausreichend.

### 4.5 Regelbeispiele: Kombiniert

```bash
# PostgreSQL nur aus dem internen Netz auf Interface eth1
sudo ufw allow in on eth1 from 192.168.1.0/24 to any port 5432 proto tcp

# Webserver nur über HTTPS, HTTP nur für Redirect
sudo ufw allow 443/tcp
sudo ufw allow 80/tcp

# E-Mail-Server nur von bestimmten IPs
sudo ufw allow from 10.0.0.5 to any port 25 proto tcp
sudo ufw allow from 10.0.0.6 to any port 25 proto tcp
```

---

## 5. Anwendungsprofile

### 5.1 Was sind Anwendungsprofile?

UFW kann Regeln für bekannte Anwendungen als Profile verwalten. Profile definieren Ports und Protokolle in einer benannten Konfiguration.

### 5.2 Verfügbare Profile anzeigen

```bash
sudo ufw app list
```

Typische Ausgabe auf einem Debian-Server:

```
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 Profile verwenden

```bash
# Anwendungsprofil erlauben
sudo ufw allow 'Nginx Full'
sudo ufw allow 'Nginx HTTPS'
sudo ufw allow 'OpenSSH'

# Anwendungsprofil blockieren
sudo ufw deny 'Nginx HTTP'

# Anwendungsprofil-Regel löschen
sudo ufw delete allow 'Nginx Full'
```

### 5.5 Eigene Profile erstellen

Profile werden als Dateien in `/etc/ufw/applications.d/` gespeichert:

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

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

[Gitea Full]
title=Gitea Git Server (Web + SSH)
description=Gitea Webinterface und SSH-Zugang
ports=3000/tcp|22/tcp
```

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

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

[Vaultwarden Full]
title=Vaultwarden mit WebSocket
description=Vaultwarden Webinterface und WebSocket
ports=8080/tcp|3012/tcp
```

```bash
# Profile aktualisieren
sudo ufw app update Gitea
sudo ufw app update Vaultwarden

# Neue Profile prüfen
sudo ufw app list
sudo ufw app info 'Gitea'
```

> **Hinweis:** Anwendungsprofile sind für die Dokumentation und Klarheit nützlich, stellen aber keine zusätzliche Sicherheit dar. Sie erstellen dieselben iptables-Regeln wie manuelle Port-Regeln.

---

## 6. Regeln für unsere Server-Dienste

### 6.1 Empfohlenes Regelwerk

Basierend auf den Diensten, die auf diesem Server laufen (SSH, Nginx als Reverse Proxy, PostgreSQL lokal, Gitea, Vaultwarden, Wiki.js, n8n), ergibt sich folgendes Regelwerk:

```bash
# ===========================================================
#  UFW-Regelwerk – Produktivserver
# ===========================================================

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

# 2. SSH (Fernzugriff)
sudo ufw limit ssh comment 'SSH - Rate Limited'

# 3. HTTP und HTTPS (Reverse Proxy – Nginx/Caddy)
sudo ufw allow 80/tcp comment 'HTTP - Redirect + Lets Encrypt'
sudo ufw allow 443/tcp comment 'HTTPS - Nginx Reverse Proxy'

# 4. UFW aktivieren
sudo ufw enable
```

### 6.2 Was wird NICHT freigegeben

Die folgenden Dienste laufen auf `localhost` und sind über den Reverse Proxy erreichbar. Sie benötigen **keine** UFW-Regel:

| Dienst | Interner Port | Zugriff über |
|---|---|---|
| Gitea | `127.0.0.1:3000` | `https://git.example.de` (Nginx) |
| Vaultwarden | `127.0.0.1:8080` | `https://vault.example.de` (Nginx) |
| Vaultwarden WS | `127.0.0.1:3012` | `https://vault.example.de` (Nginx) |
| Wiki.js | `127.0.0.1:3001` | `https://wiki.example.de` (Nginx) |
| n8n | `127.0.0.1:5678` | `https://n8n.example.de` (Nginx) |
| PostgreSQL | `127.0.0.1:5432` | Nur lokal, kein externer Zugriff |

> **Sicherheitsprinzip:** Nur der Reverse Proxy (Ports 80/443) ist aus dem Internet erreichbar. Alle internen Dienste binden auf `127.0.0.1` und sind von außen unsichtbar.

### 6.3 Optionale Regeln

```bash
# SSH nur aus dem internen Netzwerk (höhere Sicherheit)
sudo ufw delete allow ssh
sudo ufw allow from 192.168.1.0/24 to any port 22 proto tcp comment 'SSH - Nur internes Netz'

# PostgreSQL aus dem internen Netzwerk (falls andere Server darauf zugreifen)
sudo ufw allow from 192.168.1.0/24 to any port 5432 proto tcp comment 'PostgreSQL - Internes Netz'
```

### 6.4 Regelwerk prüfen

```bash
sudo ufw status verbose
```

Erwartete Ausgabe:

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

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

Drei Regeln (plus IPv6-Gegenstücke) – sauber und minimal.

---

## 7. Rate Limiting – Verbindungsbegrenzung

### 7.1 Was ist Rate Limiting?

UFW kann die Anzahl der Verbindungsversuche pro IP-Adresse begrenzen. Wenn eine IP-Adresse innerhalb von 30 Sekunden mehr als 6 Verbindungsversuche auf einem Port unternimmt, wird sie temporär blockiert.

### 7.2 Rate Limiting aktivieren

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

# Oder für einen bestimmten Port
sudo ufw limit 2222/tcp
```

### 7.3 Rate Limiting prüfen

```bash
sudo ufw status verbose
```

```
To                         Action      From
--                         ------      ----
22/tcp                     LIMIT IN    Anywhere
```

### 7.4 Wie UFW Rate Limiting funktioniert

Die Standardwerte sind fest eingestellt:

| Parameter | Wert |
|---|---|
| Maximale Verbindungen | 6 innerhalb von 30 Sekunden |
| Aktion bei Überschreitung | Verbindung verwerfen (DROP) |
| Protokoll | Gilt pro Quell-IP |

> **Hinweis:** Für feingranulares Rate Limiting (andere Schwellenwerte, andere Zeitfenster) ist Fail2Ban besser geeignet. UFW `limit` ist ein einfacher, effektiver Basisschutz.

### 7.5 Rate Limiting vs. Fail2Ban

| Eigenschaft | UFW `limit` | Fail2Ban |
|---|---|---|
| Konfigurierbarkeit | Fest (6/30s) | Voll konfigurierbar |
| Log-basiert | Nein (nur Pakete) | Ja (analysiert Logdateien) |
| Anwendungsebene | Nein | Ja (erkennt fehlgeschlagene Logins) |
| Sperrzeit | Bis Rate sinkt | Konfigurierbar (Minuten bis Tage) |
| Empfehlung | Basisschutz | **Ergänzend zu UFW verwenden** |

**Empfehlung:** Beide kombinieren – UFW `limit` als erste Verteidigungslinie, Fail2Ban für anwendungsspezifischen Schutz.

---

## 8. Logging und Überwachung

### 8.1 Logging aktivieren

```bash
# Logging-Stufe setzen
sudo ufw logging on          # Standard (low)
sudo ufw logging low         # Blockierte Pakete loggen
sudo ufw logging medium      # + erlaubte Pakete mit Rate Limiting
sudo ufw logging high        # + alle erlaubten Pakete
sudo ufw logging full        # Maximales Logging (Performance-Auswirkung)

# Logging deaktivieren
sudo ufw logging off
```

| Stufe | Was wird geloggt | Empfehlung |
|---|---|---|
| `off` | Nichts | Nicht empfohlen |
| `low` | Blockierte Pakete | **Empfohlen für Produktion** |
| `medium` | + Rate-Limited-Pakete | Zur Analyse |
| `high` | + Alle erlaubten Pakete | Nur temporär |
| `full` | Alles | Nur zum Debugging |

### 8.2 Logdateien

UFW schreibt in die System-Logdateien:

```bash
# UFW-Logs anzeigen
sudo tail -f /var/log/ufw.log

# Oder über journald
sudo journalctl -k | grep UFW

# Letzte 50 blockierte Verbindungen
sudo grep "UFW BLOCK" /var/log/ufw.log | tail -50

# Letzte 50 erlaubte Verbindungen
sudo grep "UFW ALLOW" /var/log/ufw.log | tail -50
```

### 8.3 Log-Einträge lesen

Beispiel eines blockierten Pakets:

```
Feb 24 14:23:15 server kernel: [UFW BLOCK] IN=eth0 OUT= MAC=aa:bb:cc:dd:ee:ff
SRC=203.0.113.50 DST=192.168.1.100 LEN=44 TOS=0x00 PROTO=TCP SPT=54321 DPT=5432
```

| Feld | Bedeutung |
|---|---|
| `UFW BLOCK` | Paket wurde blockiert |
| `IN=eth0` | Eingehendes Interface |
| `SRC=203.0.113.50` | Quell-IP-Adresse |
| `DST=192.168.1.100` | Ziel-IP-Adresse (unser Server) |
| `PROTO=TCP` | Protokoll |
| `SPT=54321` | Quell-Port |
| `DPT=5432` | Ziel-Port (hier: PostgreSQL) |

### 8.4 Häufig blockierte Verbindungen analysieren

```bash
# Top 20 blockierte Quell-IPs
sudo grep "UFW BLOCK" /var/log/ufw.log | \
  grep -oP "SRC=\K[0-9.]+" | sort | uniq -c | sort -rn | head -20

# Top 20 blockierte Ziel-Ports
sudo grep "UFW BLOCK" /var/log/ufw.log | \
  grep -oP "DPT=\K[0-9]+" | sort | uniq -c | sort -rn | head -20

# Blockierungen der letzten Stunde
sudo grep "UFW BLOCK" /var/log/ufw.log | \
  grep "$(date +'%b %d %H')" | wc -l
```

### 8.5 Logrotation

UFW-Logs werden automatisch über logrotate verwaltet:

```bash
# Konfiguration prüfen
cat /etc/logrotate.d/ufw
```

Standardmäßig werden die Logs täglich rotiert und 14 Tage aufbewahrt.

---

## 9. IPv6-Konfiguration

### 9.1 IPv6 in UFW aktivieren

UFW unterstützt IPv6 standardmäßig. Die Einstellung ist in der UFW-Konfiguration:

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

```bash
# IPv6 aktivieren (Standard)
IPV6=yes
```

Nach Änderungen:

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

### 9.2 IPv6-Regeln

IPv6-Regeln werden automatisch als Gegenstück zu IPv4-Regeln erstellt:

```bash
# Erstellt automatisch eine IPv4- UND IPv6-Regel
sudo ufw allow 443/tcp

# Ausgabe in ufw status:
# 443/tcp                    ALLOW IN    Anywhere
# 443/tcp (v6)               ALLOW IN    Anywhere (v6)
```

Nur IPv6 erlauben:

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

# IPv6 Loopback
sudo ufw allow from ::1
```

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

Falls der Server kein IPv6 nutzt:

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

```bash
IPV6=no
```

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

---

## 10. Erweiterte Konfiguration (ufw-Dateien)

### 10.1 Konfigurationsdateien im Überblick

| Datei | Zweck |
|---|---|
| `/etc/default/ufw` | Grundeinstellungen (IPv6, Policies, Module) |
| `/etc/ufw/before.rules` | Regeln VOR den benutzerdefinierten Regeln |
| `/etc/ufw/after.rules` | Regeln NACH den benutzerdefinierten Regeln |
| `/etc/ufw/user.rules` | Vom Benutzer erstellte Regeln (automatisch verwaltet) |
| `/etc/ufw/sysctl.conf` | Kernel-Netzwerkparameter |
| `/etc/ufw/applications.d/` | Anwendungsprofile |

> **Wichtig:** `user.rules` und `user6.rules` werden von UFW automatisch verwaltet. Diese Dateien nicht manuell bearbeiten – Änderungen werden beim nächsten `ufw`-Be