diff --git a/IT_Abteilung/Security/UFW.md b/IT_Abteilung/Security/UFW.md
index 10c46db..7e28108 100644
--- a/IT_Abteilung/Security/UFW.md
+++ b/IT_Abteilung/Security/UFW.md
@@ -2,7 +2,7 @@
 title: UFW server firewall Profice
 description: 
 published: true
-date: 2026-02-24T08:54:57.458Z
+date: 2026-02-24T08:56:45.279Z
 tags: 
 editor: markdown
 dateCreated: 2026-02-24T08:54:57.458Z
@@ -12,7 +12,7 @@ dateCreated: 2026-02-24T08:54:57.458Z
 
 > **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
+> **Einsatz:** Netzwerksicherheit, Zugriffssteuerung, Portfilterung für alle Serverdienste
 
 ---
 
@@ -23,16 +23,17 @@ dateCreated: 2026-02-24T08:54:57.458Z
 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)
+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)
 
 ---
 
@@ -40,20 +41,13 @@ dateCreated: 2026-02-24T08:54:57.458Z
 
 ### 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.
+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 – auch Dienste, die nur lokal benötigt werden.
+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.
 
-| 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?
+### Architektur
 
 ```plantuml
 @startuml
@@ -61,58 +55,58 @@ Ein Server ohne Firewall ist wie ein Haus mit offenen Türen. Jeder Dienst, der
 skinparam shadowing false
 skinparam roundCorner 10
 
-actor "Internet\n(Anfragen)" as inet
-
 package "Debian Server" {
 
-    [UFW Firewall\n(Paketfilter)] as ufw
+    [UFW\n(Firewall-Frontend)] as ufw
+    [iptables / nftables\n(Kernel-Paketfilter)] as iptables
 
-    package "Erlaubt" {
-        [Port 22 – SSH] as ssh
-        [Port 80 – HTTP] as http
-        [Port 443 – HTTPS] as https
+    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
     }
 
-    package "Blockiert" {
-        [Port 5432 – PostgreSQL] as pg
-        [Port 3000 – Gitea intern] as gitea
-        [Port 8080 – Vaultwarden intern] as vw
-    }
+    ufw --> iptables : Regeln übersetzen
+    iptables --> ssh
+    iptables --> nginx
+    iptables --> gitea
+    iptables --> pg
+    iptables --> vw
 }
 
-inet --> ufw
-ufw --> ssh : Durchgelassen
-ufw --> http : Durchgelassen
-ufw --> https : Durchgelassen
-ufw -[hidden]-> pg
-ufw -[hidden]-> gitea
-ufw -[hidden]-> 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
 ```
 
-**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.
+### UFW vs. iptables vs. nftables
 
-### Regelverarbeitung
+| 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) |
 
-UFW verarbeitet Regeln in der Reihenfolge ihrer Erstellung (von oben nach unten). Die erste zutreffende Regel entscheidet:
+> **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.
 
-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)
+### Grundprinzip: Default Deny
 
-### Begriffe
+Die wichtigste Regel der Firewall-Konfiguration:
 
-| 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 |
+- **Eingehender Verkehr:** Standardmäßig **blockiert** (deny)
+- **Ausgehender Verkehr:** Standardmäßig **erlaubt** (allow)
+- **Explizite Regeln:** Nur die tatsächlich benötigten Ports werden geöffnet
 
 ---
 
@@ -125,68 +119,74 @@ sudo apt update
 sudo apt install -y ufw
 ```
 
-### 2.2 Aktuellen Status prüfen
+### 2.2 Status prüfen
 
 ```bash
 sudo ufw status
 # Ausgabe: Status: inactive
 ```
 
-### 2.3 Standardrichtlinien setzen (Default Policies)
+> **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.
 
-Bevor die Firewall aktiviert wird, müssen die Standardrichtlinien festgelegt werden:
+### 2.3 Standardrichtlinien setzen
 
 ```bash
-# Eingehend: ALLES blockieren (Standard)
+# Eingehenden Verkehr blockieren
 sudo ufw default deny incoming
 
-# Ausgehend: ALLES erlauben (Standard)
+# Ausgehenden Verkehr erlauben
 sudo ufw default allow outgoing
+
+# Weitergeleiteten Verkehr blockieren (optional, Standard auf Debian)
+sudo ufw default deny routed
 ```
 
-> **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!)
+### 2.4 SSH-Zugang erlauben (KRITISCH – VOR dem Aktivieren!)
 
 ```bash
-# SSH MUSS erlaubt werden, bevor UFW aktiviert wird!
-# Sonst sperrt man sich vom Server aus.
+# SSH erlauben (Standard-Port 22)
 sudo ufw allow ssh
-```
 
-Falls SSH auf einem anderen Port läuft:
-
-```bash
+# 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
 ```
 
-Ausgabe:
+Bestätigungsabfrage:
 
 ```
 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).
+UFW ist jetzt aktiv und startet automatisch bei jedem Systemstart.
 
-### 2.6 Status nach Aktivierung prüfen
+### 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
 ```
 
-Erwartete Ausgabe:
+Beispielausgabe von `sudo ufw status verbose`:
 
 ```
 Status: active
 Logging: on (low)
-Default: deny (incoming), allow (outgoing), disabled (routed)
+Default: deny (incoming), allow (outgoing), deny (routed)
 New profiles: skip
 
 To                         Action      From
@@ -195,24 +195,11 @@ To                         Action      From
 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
+### 3.1 Ports erlauben (ALLOW)
 
 ```bash
 # Einzelnen Port erlauben (TCP und UDP)
@@ -225,190 +212,159 @@ sudo ufw allow 80/tcp
 sudo ufw allow 53/udp
 
 # Port-Bereich erlauben
-sudo ufw allow 6000:6010/tcp
+sudo ufw allow 6000:6100/tcp
+
+# Dienst nach Name erlauben
+sudo ufw allow ssh
+sudo ufw allow http
+sudo ufw allow https
 ```
 
-### 3.2 Port blockieren
+### 3.2 Ports blockieren (DENY)
 
 ```bash
-# Port blockieren (still, ohne Antwort)
-sudo ufw deny 3306
+# Port blockieren (Paket wird stillschweigend verworfen)
+sudo ufw deny 23/tcp
 
-# Port ablehnen (mit ICMP-Fehlermeldung)
-sudo ufw reject 3306
+# Port ablehnen mit Antwort (REJECT – Absender wird informiert)
+sudo ufw reject 23/tcp
 ```
 
-| Aktion | Verhalten | Empfehlung |
+| Aktion | Verhalten | Verwendung |
 |---|---|---|
-| `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 |
+| `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 Dienste nach Name erlauben
-
-UFW kennt viele Dienstnamen aus `/etc/services`:
+### 3.3 Regeln entfernen
 
 ```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'
+# Methode 1: Regel exakt angeben
 sudo ufw delete allow 80/tcp
-sudo ufw delete deny 3306
+
+# 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:** 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.
+> **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.6 Regeln einfügen (an bestimmter Position)
+### 3.4 Regeln einfügen (an bestimmter Position)
 
 ```bash
-# Regel an Position 1 einfügen (wird als erstes geprüft)
+# Regel an Position 1 einfügen (wird als Erstes ausgewertet)
 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
+### 3.5 UFW deaktivieren und 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)
+# Deaktivieren (Regeln bleiben erhalten)
 sudo ufw disable
 
-# Wieder aktivieren
-sudo ufw enable
+# Vollständig zurücksetzen (alle Regeln werden gelöscht!)
+sudo ufw reset
 ```
 
 ---
 
 ## 4. Erweiterte Regeln
 
-### 4.1 Regeln nach IP-Adresse
+### 4.1 IP-basierte Regeln
 
 ```bash
-# Bestimmte IP erlauben (alle Ports)
+# 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
 
-# Ganzes Subnetz erlauben
+# 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
+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 komplett sperren (an erster Position!)
-sudo ufw insert 1 deny from 203.0.113.50
+# Bestimmte IP ablehnen
+sudo ufw reject from 203.0.113.50
 ```
 
-### 4.2 Regeln nach Netzwerk-Interface
+### 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
 
-# Nur auf dem Loopback-Interface erlauben
+# Loopback-Interface (für lokale Dienste)
 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
+### 4.3 Richtungsspezifische Regeln
 
 ```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
+# 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 Ausgehende Regeln
-
-Standardmäßig ist der ausgehende Verkehr erlaubt. Falls eine strengere Kontrolle gewünscht ist:
+### 4.4 Protokoll-spezifische Regeln
 
 ```bash
-# Ausgehend: Standardmäßig blockieren
-sudo ufw default deny outgoing
+# Nur TCP
+sudo ufw allow proto tcp from any to any port 80
 
-# 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
+# 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
 ```
 
-> **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 Zusammengesetzte Regeln (Vollständige Syntax)
 
-### 4.5 Regelbeispiele: Kombiniert
+Die vollständige Syntax erlaubt präzise Regeln:
 
 ```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
+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
+```
 
-# Webserver nur über HTTPS, HTTP nur für Redirect
-sudo ufw allow 443/tcp
-sudo ufw allow 80/tcp
+Weitere Beispiele:
 
-# 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
+```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
 ```
 
 ---
@@ -417,59 +373,52 @@ sudo ufw allow from 10.0.0.6 to any port 25 proto tcp
 
 ### 5.1 Was sind Anwendungsprofile?
 
-UFW kann Regeln für bekannte Anwendungen als Profile verwalten. Profile definieren Ports und Protokolle in einer benannten Konfiguration.
+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 auf einem Debian-Server:
-
-```
-Available applications:
-  Nginx Full
-  Nginx HTTP
-  Nginx HTTPS
-  OpenSSH
+# Typische Ausgabe:
+# Available applications:
+#   Nginx Full
+#   Nginx HTTP
+#   Nginx HTTPS
+#   OpenSSH
 ```
 
 ### 5.3 Profildetails anzeigen
 
 ```bash
-sudo ufw app info 'Nginx Full'
+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
 ```
 
-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
+### 5.4 Profil verwenden
 
 ```bash
-# Anwendungsprofil erlauben
-sudo ufw allow 'Nginx Full'
-sudo ufw allow 'Nginx HTTPS'
-sudo ufw allow 'OpenSSH'
+# Profil erlauben
+sudo ufw allow "Nginx Full"
+sudo ufw allow "OpenSSH"
 
-# Anwendungsprofil blockieren
-sudo ufw deny 'Nginx HTTP'
+# Profil blockieren
+sudo ufw deny "Nginx HTTP"
 
-# Anwendungsprofil-Regel löschen
-sudo ufw delete allow 'Nginx Full'
+# Profil-Regel entfernen
+sudo ufw delete allow "Nginx Full"
 ```
 
 ### 5.5 Eigene Profile erstellen
 
-Profile werden als Dateien in `/etc/ufw/applications.d/` gespeichert:
+Profile für benutzerdefinierte Dienste erstellen:
 
 ```bash
 sudo nano /etc/ufw/applications.d/gitea
@@ -478,13 +427,13 @@ sudo nano /etc/ufw/applications.d/gitea
 ```ini
 [Gitea]
 title=Gitea Git Server
-description=Selbst gehosteter Git-Server
+description=Selbst gehostete Git-Plattform
 ports=3000/tcp
 
-[Gitea Full]
-title=Gitea Git Server (Web + SSH)
-description=Gitea Webinterface und SSH-Zugang
-ports=3000/tcp|22/tcp
+[Gitea SSH]
+title=Gitea SSH
+description=Git SSH-Zugang
+ports=22/tcp
 ```
 
 ```bash
@@ -494,85 +443,100 @@ sudo nano /etc/ufw/applications.d/vaultwarden
 ```ini
 [Vaultwarden]
 title=Vaultwarden Password Manager
-description=Bitwarden-kompatibler Passwort-Server
+description=Selbst gehosteter Bitwarden-kompatibler Server
 ports=8080/tcp
 
-[Vaultwarden Full]
-title=Vaultwarden mit WebSocket
-description=Vaultwarden Webinterface und WebSocket
-ports=8080/tcp|3012/tcp
+[Vaultwarden WebSocket]
+title=Vaultwarden WebSocket
+description=Vaultwarden Live-Sync
+ports=3012/tcp
 ```
 
 ```bash
-# Profile aktualisieren
+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
 
-# Neue Profile prüfen
-sudo ufw app list
-sudo ufw app info 'Gitea'
+# Profil verwenden
+sudo ufw allow 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. Regelkonfiguration für unsere Dienste
 
-### 6.1 Empfohlenes Regelwerk
+### 6.1 Übersicht aller Dienste und Ports
 
-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:
+| 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-Regelwerk – Produktivserver
-# ===========================================================
+# ============================================================
+# UFW-Regeln für diesen Server
+# ============================================================
 
 # 1. Standardrichtlinien
 sudo ufw default deny incoming
 sudo ufw default allow outgoing
 
-# 2. SSH (Fernzugriff)
-sudo ufw limit ssh comment 'SSH - Rate Limited'
+# 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 (Reverse Proxy – Nginx/Caddy)
-sudo ufw allow 80/tcp comment 'HTTP - Redirect + Lets Encrypt'
-sudo ufw allow 443/tcp comment 'HTTPS - Nginx Reverse Proxy'
+# 3. HTTP und HTTPS – Öffentlicher Webzugang
+sudo ufw allow http
+sudo ufw allow https
 
-# 4. UFW aktivieren
+# 4. Aktivieren
 sudo ufw enable
 ```
 
-### 6.2 Was wird NICHT freigegeben
+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.
 
-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
+### 6.3 Optionale zusätzliche 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 Netz (falls nötig)
+sudo ufw allow from 192.168.1.0/24 to any port 5432 proto tcp
 
-# 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'
+# 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 Regelwerk prüfen
+### 6.4 Regeln anzeigen und prüfen
 
 ```bash
-sudo ufw status verbose
+sudo ufw status numbered verbose
 ```
 
 Erwartete Ausgabe:
@@ -580,219 +544,191 @@ Erwartete Ausgabe:
 ```
 Status: active
 Logging: on (low)
-Default: deny (incoming), allow (outgoing), disabled (routed)
+Default: deny (incoming), allow (outgoing), deny (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)
+     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)
 ```
 
-Drei Regeln (plus IPv6-Gegenstücke) – sauber und minimal.
-
 ---
 
-## 7. Rate Limiting – Verbindungsbegrenzung
+## 7. Logging und Überwachung
 
-### 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
+### 7.1 Logging 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-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
 ```
 
-| Stufe | Was wird geloggt | Empfehlung |
+| Level | Was wird geloggt | Logvolumen |
 |---|---|---|
-| `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 |
+| `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** |
 
-### 8.2 Logdateien
+> **Empfehlung:** `low` für den Produktivbetrieb. `medium` oder `high` nur temporär zur Diagnose.
 
-UFW schreibt in die System-Logdateien:
+### 7.2 Logdateien lesen
+
+UFW schreibt in die Kernel-Log-Datei:
 
 ```bash
-# UFW-Logs anzeigen
-sudo tail -f /var/log/ufw.log
+# UFW-Einträge anzeigen
+sudo grep "UFW" /var/log/kern.log | tail -30
 
-# Oder über journald
-sudo journalctl -k | grep UFW
+# Oder über den Syslog
+sudo grep "UFW" /var/log/syslog | tail -30
 
-# Letzte 50 blockierte Verbindungen
-sudo grep "UFW BLOCK" /var/log/ufw.log | tail -50
+# Live-Überwachung
+sudo tail -f /var/log/kern.log | grep "UFW"
 
-# Letzte 50 erlaubte Verbindungen
-sudo grep "UFW ALLOW" /var/log/ufw.log | tail -50
+# 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
 ```
 
-### 8.3 Log-Einträge lesen
+### 7.3 Log-Einträge verstehen
 
 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
+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 |
-|---|---|
-| `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) |
+| 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 |
 
-### 8.4 Häufig blockierte Verbindungen analysieren
+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 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 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 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
+# 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
 
-# Blockierungen der letzten Stunde
-sudo grep "UFW BLOCK" /var/log/ufw.log | \
-  grep "$(date +'%b %d %H')" | wc -l
+# Blockierte Pakete der letzten 24 Stunden zählen
+sudo grep "UFW BLOCK" /var/log/kern.log | \
+  grep "$(date +%b\ %d)" | wc -l
 ```
 
-### 8.5 Logrotation
+### 7.5 Eigene UFW-Logdatei einrichten
 
-UFW-Logs werden automatisch über logrotate verwaltet:
+Um UFW-Logs von den Kernel-Logs zu trennen:
 
 ```bash
-# Konfiguration prüfen
-cat /etc/logrotate.d/ufw
+sudo nano /etc/rsyslog.d/20-ufw.conf
 ```
 
-Standardmäßig werden die Logs täglich rotiert und 14 Tage aufbewahrt.
+```
+: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
+}
+```
 
 ---
 
-## 9. IPv6-Konfiguration
+## 8. IPv6-Konfiguration
 
-### 9.1 IPv6 in UFW aktivieren
-
-UFW unterstützt IPv6 standardmäßig. Die Einstellung ist in der UFW-Konfiguration:
+### 8.1 IPv6-Unterstützung prüfen und aktivieren
 
 ```bash
 sudo nano /etc/default/ufw
 ```
 
 ```bash
-# IPv6 aktivieren (Standard)
+# IPv6-Unterstützung (Standard: yes)
 IPV6=yes
 ```
 
-Nach Änderungen:
-
 ```bash
 sudo ufw disable && sudo ufw enable
 ```
 
-### 9.2 IPv6-Regeln
+### 8.2 IPv6-Regeln
 
-IPv6-Regeln werden automatisch als Gegenstück zu IPv4-Regeln erstellt:
+UFW erstellt automatisch IPv6-Regeln parallel zu IPv4-Regeln:
 
 ```bash
-# Erstellt automatisch eine IPv4- UND IPv6-Regel
-sudo ufw allow 443/tcp
+# Diese Regel erstellt sowohl IPv4- als auch IPv6-Einträge
+sudo ufw allow 80/tcp
 
-# Ausgabe in ufw status:
-# 443/tcp                    ALLOW IN    Anywhere
-# 443/tcp (v6)               ALLOW IN    Anywhere (v6)
+# Ergebnis in 'ufw status':
+# 80/tcp        ALLOW IN    Anywhere
+# 80/tcp (v6)   ALLOW IN    Anywhere (v6)
 ```
 
-Nur IPv6 erlauben:
+Nur IPv6-spezifische Regeln:
 
 ```bash
-# Explizite IPv6-Adresse
+# Bestimmte IPv6-Adresse erlauben
 sudo ufw allow from 2001:db8::/32 to any port 22
 
-# IPv6 Loopback
-sudo ufw allow from ::1
+# IPv6-Adresse blockieren
+sudo ufw deny from 2001:db8::1
 ```
 
-### 9.3 IPv6 deaktivieren (falls nicht benötigt)
+### 8.3 IPv6 deaktivieren (falls nicht benötigt)
 
-Falls der Server kein IPv6 nutzt:
-
-```bash
-sudo nano /etc/default/ufw
-```
+Falls der Server kein IPv6 verwendet:
 
 ```bash
+# In /etc/default/ufw
 IPV6=no
 ```
 
@@ -802,17 +738,658 @@ sudo ufw disable && sudo ufw enable
 
 ---
 
-## 10. Erweiterte Konfiguration (ufw-Dateien)
+## 9. Rate Limiting – Brute-Force-Schutz
 
-### 10.1 Konfigurationsdateien im Überblick
+### 9.1 Was ist Rate Limiting?
 
-| 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 |
+UFW bietet eingebautes Rate Limiting: Wenn eine IP-Adresse innerhalb von 30 Sekunden mehr als 6 Verbindungsversuche startet, wird sie temporär blockiert.
 
-> **Wichtig:** `user.rules` und `user6.rules` werden von UFW automatisch verwaltet. Diese Dateien nicht manuell bearbeiten – Änderungen werden beim nächsten `ufw`-Be
\ No newline at end of file
+### 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