Files
WikiJS/IT_Abteilung/Security/UFW.md

818 lines
21 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
---
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