geoblock: purge scannt zusaetzlich INPUT/FORWARD/OUTPUT (Chain-Wechsel raeumt Reste auf)

purge_geoblock_rules() scannt jetzt die konfigurierten Chains PLUS die Standard-
Filter-Chains INPUT/FORWARD/OUTPUT. Damit werden verwaiste geoblock-Regeln auch
dann entfernt, wenn 'chain' zwischen zwei Laeufen geaendert wurde (z.B. INPUT ->
FORWARD) -- vorher blieben die alten Regeln der nicht mehr konfigurierten Chain
stehen. Es werden nur Regeln geloescht, die auf das eigene ipset verweisen.

README: Abschnitt "Manuelle Nutzung" um die Aufraeum-Semantik ergaenzt (jeder
--apply/Service-Restart entfernt alle geoblock-Regeln und setzt sie frisch,
inkl. Reste aus geaenderter ports/protocol/chain-Config).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

README.md

@@ -158,6 +158,18 @@ unten.
 das ipset atomar per `swap`, damit waehrend der Aktualisierung kein Loch
 im Blocking entsteht.
 
+**Aufraeumen bei jedem Lauf:** `--apply` (und damit auch jeder Neustart von
+`geoblock.service`) entfernt zuerst **alle** bestehenden geoblock-Regeln und
+setzt sie danach frisch. Gescannt werden dabei die konfigurierten Chains **plus**
+die Standard-Filter-Chains INPUT/FORWARD/OUTPUT — es werden ausschliesslich
+Regeln geloescht, die auf das eigene `ipset` verweisen (fremde Regeln bleiben
+unberuehrt). Dadurch verschwinden automatisch auch Reste aus frueheren Laeufen
+mit **anderer Config**: geaenderte `ports`/`protocol` ebenso wie eine geaenderte
+`chain`. Konkret heisst das: Stellst du z.B. von `chain = INPUT` auf
+`chain = FORWARD` um und startest den Dienst neu, werden die alten INPUT-Regeln
+automatisch entfernt — du musst nicht von Hand aufraeumen. (Gleiches gilt fuer
+`--remove`, das ebenfalls diesen Purge nutzt.)
+
 **Achtung:** iptables-Regeln sind nicht reboot-persistent. Wer das
 zusaetzlich braucht: `iptables-persistent` / `netfilter-persistent save`
 nutzen — der systemd-Timer sorgt aber ohnehin bei jedem Boot fuer einen
@@ -297,6 +309,49 @@ die Regel-Reihenfolge auch ohne den Watchdog stabil. Ohne bestehendes ipset
 (z.B. bevor je ein `--apply` lief) macht `--reassert` bewusst nichts; das
 Befuellen uebernimmt der taegliche `geoblock.timer`.
 
+## INPUT vs FORWARD (Dienst hinter Firewall/Router)
+
+`chain` entscheidet, welchen Traffic Geoblocking ueberhaupt zu sehen bekommt:
+
+- **`INPUT`** — Pakete, die **an diesen Host selbst** gerichtet sind. Richtig,
+  wenn der geschuetzte Dienst (Webserver, VPN, …) **auf demselben Host** laeuft,
+  auf dem auch `geoblock.py` die Regeln setzt.
+- **`FORWARD`** — Pakete, die dieser Host **weiterleitet/routet**, statt sie
+  selbst anzunehmen. Noetig, wenn `geoblock.py` auf einer **Firewall/einem
+  Router** laeuft und der eigentliche Dienst auf einem **dahinterliegenden Host**
+  sitzt (klassisch: Portweiterleitung/DNAT von der Firewall auf einen internen
+  Server). Solche Pakete laufen durch die FORWARD-Chain und werden von einer
+  INPUT-Regel **nie** gesehen.
+
+**Typisches Symptom fuer den FORWARD-Fall:** Set stimmt (`ipset test` = is in),
+die DROP-Regel steht in INPUT ganz oben — und trotzdem kommt die Verbindung
+durch, weil das Paket gar nicht ueber INPUT laeuft. `tcpdump` zeigt dann als
+Ziel eine **interne/private IP** (der Backend-Host), nicht die des Firewall-Hosts
+selbst. Gegencheck auf dem Firewall-Host:
+
+```bash
+sudo iptables -t nat -L PREROUTING -n -v | grep <port>   # DNAT-Portweiterleitung vorhanden?
+sudo iptables -L FORWARD -n -v --line-numbers            # laeuft der Traffic hier durch?
+```
+
+Gibt es eine DNAT-Weiterleitung, muss die Chain auf `FORWARD` (oder zur
+Sicherheit beides):
+
+```ini
+[geoblock]
+chain = INPUT, FORWARD
+```
+
+Bei mehreren Chains legt `--apply` die Regeln in **jeder** an, `--remove` raeumt
+in jeder auf, und `--reassert`/`--status`/der Watchdog pruefen/korrigieren jede
+Chain einzeln. Der `src`-Match (Quell-IP = echter Client) funktioniert in FORWARD
+genauso wie in INPUT, weil DNAT nur das Ziel umschreibt, nicht die Quelle.
+
+> **Endian & Co.:** Laeuft der Dienst (z.B. der OpenVPN-Server) hinter der
+> Appliance und wird per Portweiterleitung erreicht, ist FORWARD der richtige
+> Ort. Kombiniere das am besten mit dem Reassert-Watchdog (Abschnitt oben), da
+> die Appliance auch die FORWARD-Chain bei jedem Reload neu baut.
+
 ## Verbindungstest (Test-Webserver)
 
 `geoblock_testserver.py` ist ein winziger HTTP-Server ohne
@@ -412,7 +467,10 @@ inkl. Perfdata (Alter in Sekunden, Anzahl geblockter IP-Bereiche).
 Siehe Kommentare in der Datei selbst — kurz:
 
 - `countries`: Komma-Liste ISO-3166-1-alpha-2 Codes (z.B. `RU, CN, KP, IR`)
-- `chain`: iptables-Chain (`INPUT` = eingehender Traffic zu diesem Host)
+- `chain`: iptables-Chain(s), eine oder komma-getrennt mehrere. `INPUT` =
+  Traffic zu diesem Host (Standard); `FORWARD` = durch diesen Host **gerouteter**
+  Traffic (Dienst hinter Firewall/Router, per Portweiterleitung/DNAT). Beides
+  zugleich: `chain = INPUT, FORWARD`. Siehe Abschnitt "INPUT vs FORWARD" unten.
 - `interface`: optional, nur ein Interface pruefen
 - `log`: iptables-LOG-Eintrag vor dem DROP (dmesg/kern.log) an/aus
 - `ipset_name`: Name des ipset-Sets

geoblock.ini.example

@@ -4,8 +4,13 @@
 ;            grossgeschrieben, egal), die geblockt werden sollen.
 ;            Liste der Codes: https://www.ipdeny.com/ipblocks/
 ;
-; chain:     iptables-Chain, in die die DROP-Regel eingehaengt wird.
-;            INPUT = Verbindungen ZU diesem Host (Standard-Anwendungsfall).
+; chain:     iptables-Chain(s), in die die DROP-Regel eingehaengt wird. Eine
+;            oder komma-getrennt mehrere.
+;            INPUT   = Verbindungen ZU diesem Host (Standard-Anwendungsfall).
+;            FORWARD = durch diesen Host GEROUTETER Traffic -- noetig, wenn der
+;                      zu schuetzende Dienst hinter einer Firewall/einem Router
+;                      liegt (z.B. Portweiterleitung/DNAT auf einen internen
+;                      Host). Beides zugleich: "chain = INPUT, FORWARD".
 ;
 ; interface: optional, z.B. eth0 -- nur Traffic auf diesem Interface pruefen.
 ;            Leer lassen = alle Interfaces.

geoblock.py

@@ -78,6 +78,13 @@ import urllib.error
 
 ZONE_URL_TMPL = "https://www.ipdeny.com/ipblocks/data/countries/{cc}.zone"
 
+# Standard-Filter-Chains, die beim Aufraeumen IMMER mitgescannt werden -- auch
+# wenn sie gerade nicht in 'chain' konfiguriert sind. So werden verwaiste
+# geoblock-Regeln entfernt, wenn 'chain' zwischen zwei Laeufen geaendert wurde
+# (z.B. von INPUT auf FORWARD umgestellt). Rein additiv zum Scan: es werden nur
+# Regeln geloescht, die auf UNSER ipset verweisen -- fremde Regeln bleiben unberuehrt.
+STANDARD_FILTER_CHAINS = ("INPUT", "FORWARD", "OUTPUT")
+
 # Wird in main() aus der .ini gesetzt (log_file). None = keine Datei-Logs.
 LOG_FILE = None
 
@@ -164,9 +171,16 @@ def load_config(path):
         if pr not in ("tcp", "udp"):
             raise ValueError(f"Ungueltiges Protokoll '{pr}' in 'protocol' (erlaubt: tcp, udp)")
 
+    # chain: eine oder (komma-getrennt) mehrere iptables-Chains. INPUT = Traffic ZU
+    # diesem Host, FORWARD = durch diesen Host GEROUTETER Traffic (z.B. Portweiter-
+    # leitung/DNAT auf einen internen Host hinter einer Firewall/Router). "INPUT, FORWARD"
+    # deckt beides ab. Default: INPUT.
+    chains_raw = sec.get("chain", "INPUT").strip()
+    chains = [c.strip() for c in chains_raw.split(",") if c.strip()] or ["INPUT"]
+
     return {
         "countries": countries,
-        "chain": sec.get("chain", "INPUT").strip(),
+        "chains": chains,
         "interface": sec.get("interface", "").strip(),
         "log": sec.getboolean("log", fallback=False),
         "log_prefix": sec.get("log_prefix", "GEOBLOCK-DROP:").strip(),
@@ -301,31 +315,40 @@ def _list_chain_rules(chain):
 
 
 def purge_geoblock_rules(cfg, dry_run=False):
-    """Loescht ALLE Regeln in der Chain, die auf das geoblock-ipset verweisen
+    """Loescht in allen konfigurierten Chains PLUS den Standard-Filter-Chains
+    (INPUT/FORWARD/OUTPUT) alle Regeln, die auf das geoblock-ipset verweisen
     (--match-set <name> src) -- unabhaengig von Proto/Port/Variante.
 
     Dadurch werden auch alte Regeln aus frueheren --apply-Laeufen mit anderer
-    ini (z.B. andere Ports/Protokolle) sauber entfernt, die build_rule_variants(cfg)
-    fuer die AKTUELLE Config gar nicht mehr kennt. Wir rekonstruieren das Loesch-
-    Kommando direkt aus 'iptables -S' (per shlex, damit z.B. das --log-prefix mit
-    Leerzeichen erhalten bleibt), statt die Args selbst nachzubauen -- so passt das
-    -D immer exakt zur real existierenden Regel.
+    ini sauber entfernt: andere Ports/Protokolle (kennt build_rule_variants(cfg)
+    nicht mehr) UND andere Chains (z.B. nach Umstellung von INPUT auf FORWARD --
+    die verwaisten INPUT-Regeln werden dank Standard-Chain-Scan trotzdem gefunden).
+    Wir rekonstruieren das Loesch-Kommando direkt aus 'iptables -S' (per shlex,
+    damit z.B. das --log-prefix mit Leerzeichen erhalten bleibt), statt die Args
+    selbst nachzubauen -- so passt das -D immer exakt zur real existierenden Regel.
     """
     name = cfg["ipset_name"]
-    chain = cfg["chain"]
     needle = f"--match-set {name} src"
+    # Konfigurierte Chains PLUS die Standard-Filter-Chains scannen (dedupliziert,
+    # Reihenfolge erhalten). Faengt auch verwaiste Regeln ab, wenn 'chain' seit dem
+    # letzten Lauf geaendert wurde (z.B. INPUT -> FORWARD): die alten INPUT-Regeln
+    # werden trotzdem gefunden und entfernt.
+    scan_chains = list(dict.fromkeys(list(cfg["chains"]) + list(STANDARD_FILTER_CHAINS)))
     removed = 0
-    for line in _list_chain_rules(chain):
-        if needle not in line:
-            continue
-        tokens = shlex.split(line)  # z.B. ["-A", "INPUT", "-m", "set", ...]
-        # "-A <chain> <rest>"  ->  "iptables -D <chain> <rest>"
-        run(["iptables", "-D"] + tokens[1:], dry_run=dry_run, check=False)
-        removed += 1
-    if removed:
-        log(f"{removed} bestehende geoblock-Regel(n) aus Chain '{chain}' entfernt (Set '{name}')")
-    else:
-        log(f"Keine bestehenden geoblock-Regeln in Chain '{chain}' gefunden")
+    for chain in scan_chains:
+        n = 0
+        for line in _list_chain_rules(chain):
+            if needle not in line:
+                continue
+            tokens = shlex.split(line)  # z.B. ["-A", "INPUT", "-m", "set", ...]
+            # "-A <chain> <rest>"  ->  "iptables -D <chain> <rest>"
+            run(["iptables", "-D"] + tokens[1:], dry_run=dry_run, check=False)
+            n += 1
+        if n:
+            log(f"{n} bestehende geoblock-Regel(n) aus Chain '{chain}' entfernt (Set '{name}')")
+        removed += n
+    if not removed:
+        log(f"Keine bestehenden geoblock-Regeln gefunden (gescannt: {', '.join(scan_chains)})")
     return removed
 
 
@@ -344,40 +367,50 @@ def set_iptables_rules(cfg, dry_run=False):
     name = cfg["ipset_name"]
     set_match = ["-m", "set", "--match-set", name, "src"]
     iface_opt = ["-i", cfg["interface"]] if cfg["interface"] else []
-    for variant in build_rule_variants(cfg):
-        proto_args = _variant_match_args(variant)
-        port_args = _variant_port_args(variant)
-        label = _variant_label(variant)
+    for chain in cfg["chains"]:
+        for variant in build_rule_variants(cfg):
+            proto_args = _variant_match_args(variant)
+            port_args = _variant_port_args(variant)
+            label = _variant_label(variant)
 
-        run(["iptables", "-I", cfg["chain"]] + iface_opt + proto_args + set_match +
-            port_args + ["-j", "DROP"], dry_run=dry_run)
-        log(f"DROP-Regel am Anfang von Chain '{cfg['chain']}' aktiv fuer Set '{name}' ({label})")
+            run(["iptables", "-I", chain] + iface_opt + proto_args + set_match +
+                port_args + ["-j", "DROP"], dry_run=dry_run)
+            log(f"DROP-Regel am Anfang von Chain '{chain}' aktiv fuer Set '{name}' ({label})")
 
-        if cfg["log"]:
-            run(["iptables", "-I", cfg["chain"]] + iface_opt + proto_args + set_match +
-                port_args + ["-j", "LOG", "--log-prefix", cfg["log_prefix"] + " "], dry_run=dry_run)
-            log(f"LOG-Regel am Anfang von Chain '{cfg['chain']}' aktiv ({label})")
+            if cfg["log"]:
+                run(["iptables", "-I", chain] + iface_opt + proto_args + set_match +
+                    port_args + ["-j", "LOG", "--log-prefix", cfg["log_prefix"] + " "], dry_run=dry_run)
+                log(f"LOG-Regel am Anfang von Chain '{chain}' aktiv ({label})")
 
 
-def geoblock_rules_on_top(cfg):
-    """Prueft, ob die geoblock-Regeln (noch) ganz am Anfang der Chain stehen.
-
-    Gibt (on_top, present) zurueck:
+def _chain_rules_position(chain, ipset_name):
+    """(on_top, present) fuer eine EINZELNE Chain.
       present : ob ueberhaupt geoblock-Regeln in der Chain vorhanden sind
       on_top  : ob sie luueckenlos die ERSTEN Regeln der Chain sind (Index 0..k-1)
-
-    Ist present=True aber on_top=False, sind unsere Regeln nach unten gerutscht
-    (z.B. weil eine gemanagte Firewall die Chain neu gebaut und eigene Regeln
-    davor eingehaengt hat) -- dann sollten sie neu an den Anfang gesetzt werden.
     """
-    needle = f"--match-set {cfg['ipset_name']} src"
-    rules = _list_chain_rules(cfg["chain"])  # geordnete Liste der '-A ...'-Regeln
+    needle = f"--match-set {ipset_name} src"
+    rules = _list_chain_rules(chain)  # geordnete Liste der '-A ...'-Regeln
     idx = [i for i, ln in enumerate(rules) if needle in ln]
     present = bool(idx)
     on_top = present and idx == list(range(len(idx)))
     return on_top, present
 
 
+def geoblock_rules_on_top(cfg):
+    """Aggregiert die Regel-Position ueber ALLE konfigurierten Chains.
+
+    Gibt (on_top, present) zurueck:
+      on_top  : True nur, wenn in JEDER konfigurierten Chain die Regeln vorhanden
+                UND ganz oben sind (Index 0..k-1). Sonst False -> --reassert sollte
+                korrigieren (fehlende neu setzen, verrutschte wieder nach oben).
+      present : True, wenn mindestens eine Chain geoblock-Regeln hat.
+    """
+    results = [_chain_rules_position(ch, cfg["ipset_name"]) for ch in cfg["chains"]]
+    on_top = all(on for on, _ in results)
+    present = any(pr for _, pr in results)
+    return on_top, present
+
+
 def reassert_rules(cfg, dry_run=False):
     """Watchdog: stellt sicher, dass die geoblock-Regeln am ANFANG der Chain stehen
     -- OHNE die Zonefiles neu von ipdeny zu laden (nutzt das bestehende ipset).
@@ -475,18 +508,19 @@ def show_status(cfg):
         print(f"ipset '{name}' existiert nicht (noch nicht aktiv).")
 
     variants = build_rule_variants(cfg)
-    for variant in variants:
-        active = iptables_rule_exists(cfg["chain"], name, cfg["interface"], variant=variant)
-        print(f"iptables DROP-Regel in Chain '{cfg['chain']}' ({_variant_label(variant)}) aktiv: {active}")
+    for chain in cfg["chains"]:
+        for variant in variants:
+            active = iptables_rule_exists(chain, name, cfg["interface"], variant=variant)
+            print(f"iptables DROP-Regel in Chain '{chain}' ({_variant_label(variant)}) aktiv: {active}")
 
-    on_top, present = geoblock_rules_on_top(cfg)
-    if not present:
-        print(f"Regel-Position in Chain '{cfg['chain']}': keine geoblock-Regeln vorhanden")
-    elif on_top:
-        print(f"Regel-Position in Chain '{cfg['chain']}': am Anfang (ok)")
-    else:
-        print(f"Regel-Position in Chain '{cfg['chain']}': NACH UNTEN GERUTSCHT "
-              f"-- '--reassert' oder '--apply' setzt sie wieder an den Anfang")
+        on_top, present = _chain_rules_position(chain, name)
+        if not present:
+            print(f"Regel-Position in Chain '{chain}': keine geoblock-Regeln vorhanden")
+        elif on_top:
+            print(f"Regel-Position in Chain '{chain}': am Anfang (ok)")
+        else:
+            print(f"Regel-Position in Chain '{chain}': NACH UNTEN GERUTSCHT "
+                  f"-- '--reassert' oder '--apply' setzt sie wieder an den Anfang")
 
     print(f"Konfigurierte Laender: {', '.join(c.upper() for c in cfg['countries'])}")
     if cfg["ports"]: