Ihor_Zhekov/WikiJS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: create IT_Abteilung/Security/UFW

Browse Source
This commit is contained in:
Administrator
2026-02-24 08:54:59 +00:00
committed by Jane Doe
parent 9a720c74da
commit 2747f218e9
1 changed files with 818 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

818
IT_Abteilung/Security/UFW.md Normal file
View File

@@ -0,0 +1,818 @@
---
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