fix(security): x/crypto v0.52 + x/net v0.55 (6 CVEs) + govulncheck-Release-Gate — v1.3.1

govulncheck ab sofort fest im Release-Prozess. Baseline-Scan fand 6 aktiv aufgerufene Vulns (SSH-Backup-Pfad internal/services/backup/remote): - 5× golang.org/x/crypto (SSH DoS/Deadlock/Panic: GO-2026-5013/5017/5018/5019/5020) → x/crypto v0.51.0 => v0.52.0 - 1× golang.org/x/net (GO-2026-5026) → v0.53.0 => v0.55.0 Re-Scan danach: "No vulnerabilities found." Go-Quality-Baseline (Makefile + .golangci.yml, portabel): - release-check läuft autom. vor jedem deb/publish: vet → golangci-lint (Rollout: non-blocking) → govulncheck (HARTER Gate) → build → test -race. - make vulncheck / make test-race als eigene Targets. - .golangci.yml: staticcheck/govet/errcheck/ineffassign/unused/misspell + gosec/bodyclose/rowserrcheck/sqlclosecheck/noctx/contextcheck. - go test -race: aktuell 0 Races (Gate sicher). Doku in CLAUDE.md. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
chore(go): go.mod go-Direktive auf 1.26.4 nachgezogen
2026-07-05 22:34:25 +02:00 · 2026-07-04 01:03:56 +02:00 · 2026-06-26 11:30:12 +02:00 · 2026-06-18 15:46:17 +02:00 · 2026-06-15 19:23:37 +02:00 · 2026-06-12 13:42:21 +02:00
36 changed files with 825 additions and 301 deletions
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -0,0 +1,42 @@
+# Go-Quality-Baseline für EdgeGuard (portabel für weitere Go-Projekte).
+# Rollout: erst NON-BLOCKING laufen lassen (Bestand aufräumen), dann in der
+# CI/Makefile auf harten Gate stellen. govulncheck ist bereits ein harter
+# Release-Gate (siehe Makefile: vulncheck / release-check).
+version: "2"
+
+run:
+  timeout: 5m
+  tests: true
+
+linters:
+  enable:
+    # ── Basis ──
+    - staticcheck    # umfangreiche statische Analyse
+    - govet          # go vet
+    - errcheck       # unbehandelte Fehler
+    - ineffassign    # wirkungslose Zuweisungen
+    - unused         # toter Code
+    - misspell       # Tippfehler in Kommentaren/Strings
+    # ── Security (Pflicht bei Kunden-/Finanzdaten) ──
+    - gosec          # SQL-Injection, hardcoded Secrets, schwache Krypto
+    # ── Ressourcen-/Leak-Schutz ──
+    - bodyclose      # nicht geschlossene HTTP-Response-Bodies
+    - rowserrcheck   # fehlendes rows.Err() (database/sql-Muster)
+    - sqlclosecheck  # fehlendes rows/stmt.Close()
+    # ── Context-Hygiene ──
+    - noctx          # HTTP-Requests ohne context
+    - contextcheck   # nicht-vererbte Contexts
+
+  settings:
+    misspell:
+      locale: US
+    gosec:
+      excludes:
+        # G115 (int-Konvertierungs-Overflow) erzeugt in Go 1.26 viele
+        # false positives — bei Bedarf gezielt wieder aktivieren.
+        - G115
+
+# HINWEIS: rowserrcheck/sqlclosecheck zielen auf database/sql. EdgeGuard nutzt
+# pgx/pgxpool — dort greifen sie nur teilweise. Das pgx-Muster (manuelles
+# rows.Next()/Scan() + defer rows.Close() + rows.Err()) bitte weiter per Review
+# absichern; siehe internal/services/*/*.go.
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -13,7 +13,9 @@ Vor jeder Entscheidung über Feldwerte, API-Shapes, Dateinamen, Funktions-Signat

 # EdgeGuard Native (`eg`)

-> Native Neufassung des Docker-basierten EdgeGuard-Stacks. Kein Docker, kein WAF in v1. Zielplattform: **Debian 13 (Trixie), amd64 + arm64**. Auslieferung als signiertes `.deb`.
+> Native Neufassung des Docker-basierten EdgeGuard-Stacks. Kein Docker — alle Dienste nativ unter systemd. Zielplattform: **Debian 13 (Trixie), amd64 + arm64**. Auslieferung als signiertes `.deb`.
+>
+> **Hinweis:** Mehrere ursprüngliche v1-Nicht-Ziele (WAF, IDS/IPS, DHCP, RADIUS) sind inzwischen umgesetzt — siehe „Feature-Stand" weiter unten.

 ---

@@ -67,26 +69,47 @@ ac_search_code(query="<Stichworte>", project_id=8, session_name="$(printenv ARCH
 | **API** | Go 1.26, Gin, GORM (Queries), goose (Migrations) |
 | **UI** | React 19, TypeScript strict, Vite, Ant Design 6, TanStack Query 5 |
 | **DB** | PostgreSQL 16 (Distro-Paket), goose-Migrations in `migrations/` |
-| **State/HA** | KeyDB Active-Active (Redis-kompatibel) |
+| **State/HA** | PostgreSQL Logical Replication + Cluster-Agent-Heartbeat (mTLS); KeyDB Active-Active nur optional (`Recommends`, für Lizenz-Leader-Election/Shared-Cache) |
 | **Proxy/LB** | HAProxy (Distro) — TLS-Termination, L7-Routing, LB |
+| **WAF** | Coraza v3 + OWASP CRS, via HAProxy SPOE (`edgeguard-waf`-Agent) |
+| **IDS/IPS** | CrowdSec + `crowdsec-firewall-bouncer` (nftables) — managed-wenn-installiert (kein Depends) |
 | **VPN** | WireGuard (Kernel-Modul ab 5.6, `wireguard-tools`) |
 | **DNS** | Unbound (Distro) — Forwarder+Cache mit DNSSEC, Cluster-internes Split-Horizon |
+| **DHCP** | Kea (`kea-dhcp4-server`) — managed, default-off |
+| **AAA/RADIUS** | FreeRADIUS (PAP/CHAP, files-based) — managed, default-off |
+| **NTP** | chrony (Distro) |
+| **VIP/HA** | keepalived (VRRP) |
 | **FW** | nftables (Distro) |
 | **Forward-Proxy** | Squid (Distro) |
+| **Auth/SSO** | JWT (lokal) + 2FA/TOTP + OIDC/OAuth2 (Keycloak u. a.) |
 | **TLS** | certbot + webroot-Plugin |
 | **Packaging** | dpkg-deb (direkt, wie mail-gateway + netcell-webpanel) |
 | **Plattform** | Debian 13 Trixie · amd64 + arm64 |

 ---

-## Nicht-Ziele (v1)
+## Feature-Stand (Stand 2026-06)
+
+Über den ursprünglichen v1-Scope hinaus inzwischen **umgesetzt** (waren mal Nicht-Ziele):
+
+- **WAF** — Coraza v3 + OWASP CRS via HAProxy SPOE (`edgeguard-waf`)
+- **IDS/IPS** — CrowdSec + `crowdsec-firewall-bouncer` (nftables-Bouncer); managed-wenn-installiert, kein hartes Depends
+- **DHCP** — Kea `kea-dhcp4-server` (managed, default-off)
+- **RADIUS** — FreeRADIUS PAP/CHAP, files-based (managed, default-off)
+- **SSO** — OIDC/OAuth2 (additiv, Rolle aus DB, lokaler Login bleibt)
+- **2FA** — TOTP
+- **IPv6** — Firewall-Regeln + NAT familienbewusst
+- **HA** — VIP via keepalived (VRRP), PG-Logical-Replication, bidirektionaler Cluster-Heartbeat
+
+Damit ist die ursprüngliche v2-Roadmap (WAF, 2FA, IPv6-FW, OIDC, DHCP, RADIUS) abgearbeitet.
+
+## Nicht-Ziele (weiterhin)

 - **Kein Docker** — alle Dienste nativ unter systemd
- **Kein WAF** (kein Coraza, kein ModSecurity)
- **Kein IDS/IPS** (kein Suricata, kein CrowdSec)
- **Kein DHCP-Server** (kein Kea)
- **Kein RADIUS** (kein FreeRADIUS)
+- **Kein Network-IDS Suricata** — Intrusion-Detection läuft über CrowdSec, nicht über Suricata-Paket-Inspektion
 - **Keine Mail-Verarbeitung** (eigenes Produkt: mail-gateway)
+- **Keine Multi-Tenant-GuardZones**
+- **Keine ISO-Builds** (kein EdgeGuardOS-Klon — nur APT)
 - **Nur Debian 13** — kein Ubuntu, kein Debian 12, kein RHEL

 ---
@@ -108,8 +131,11 @@ HAProxy terminiert TLS auf `:443`, routet per Host-Header an Backends und fällt
 ```bash
 make build            # Host-Architektur (amd64)
 make test             # go test ./...
-make lint             # golangci-lint
-make deb              # amd64 + arm64 .deb
+make test-race        # go test -race ./...   (Race-Detector)
+make lint             # go vet + golangci-lint
+make vulncheck        # govulncheck ./...      (Go-Vuln-DB-Scan)
+make release-check    # Go-Quality-Baseline (läuft autom. vor jedem deb/publish)
+make deb              # amd64 + arm64 .deb     (führt release-check aus)
 make publish          # deb + Upload Gitea Package Registry
 make install-local    # direkt auf Dev-Server installieren (kein .deb)

@@ -117,6 +143,15 @@ make install-local    # direkt auf Dev-Server installieren (kein .deb)
 cd management-ui && bun install && bun run build
 ```

+### Go-Quality-Baseline (PFLICHT vor jedem Release)
+`make deb`/`make publish` führen automatisch `release-check` aus — Reihenfolge:
+**`go vet` → `golangci-lint run` → `govulncheck ./...` → `go build` → `go test -race`**.
+
+- **`govulncheck` ist ein HARTER Gate** — Build bricht ab, wenn der Code eine bekannte CVE tatsächlich aufruft. Tool wird bei Bedarf autom. installiert. Zusätzlich sinnvoll: wöchentlicher CI-Cron (CVEs tauchen auch ohne Code-Änderung auf).
+- **`golangci-lint`** (`.golangci.yml`: staticcheck, govet, errcheck, ineffassign, unused, misspell, **gosec**, **bodyclose**, rowserrcheck, sqlclosecheck, noctx, contextcheck) läuft im **Rollout noch NON-BLOCKING** (Bestand aufräumen), danach auf harten Gate stellen.
+- **`go test -race`** — Race-Detector; findet Nebenläufigkeits-Bugs (Scheduler/Worker), die normale Tests durchlassen.
+- Portabel als „Go-Quality-Baseline" für weitere Go-Projekte gedacht.
+
 ---

 ## Dev-Server Quickstart
@@ -154,7 +189,6 @@ cd management-ui && bun run dev
 │   ├── unbound/               # Config-Generator (Forwarder + Cluster-DNS)
 │   ├── firewall/              # nftables-Generator
 │   ├── cluster/               # Join/Promote/Peer-Discovery
-│   ├── proxy/                 # Write-Proxy → Cluster-Primary
 │   ├── aggregator/            # Cluster-View APIs
 │   └── license/               # Lizenz-Validierung
 ├── management-ui/             # React 19 + AntD 6 (1:1 enconf-Pattern)
@@ -185,7 +219,8 @@ cd management-ui && bun run dev
 - **ORM:** GORM für Queries, nicht für Schema-Verwaltung
 - **Config-Generierung:** Template-Datei in `deploy/*/`, Generator in `internal/*/`
 - **Config-Reload:** `systemctl reload <service>` nach Config-Schreiben
- **Cluster-Writes:** immer über `internal/proxy` → Primary-URL aus KeyDB `cluster:pg-primary-url`
+- **Cluster-Primary-Ermittlung:** zuverlässig über `pg_publication` (`edgeguard_shared`); Primary-URL aus `setup.json` `PrimaryFQDN` via `clusterjoin.NormalizePrimaryURL`. **Kein Write-Proxy** — Schreibzugriffe auf geteilte Tabellen erfolgen am Primary.
+- **Failover:** `edgeguard-ctl promote` ist Logical-Replication-aware (Subscription lösen → `setupReplicationPrimary` → Publisher werden, inkl. PG-Restart für `wal_level=logical`); erholte Nodes danach via `cluster-setup-standby <neuer-primary>` zurückhängen.

 ### Packaging
 - `dpkg-deb` direkt (wie mail-gateway) — kein dh_make/debhelper/fpm
--- a/34
+++ b/34
@@ -10,7 +10,7 @@ LDFLAGS  := -s -w -X main.version=$(VERSION)
 GOFLAGS  := -trimpath -mod=readonly
 export CGO_ENABLED ?= 0

-.PHONY: all help build test lint tidy clean ui \
+.PHONY: all help build test test-race lint vulncheck release-check tidy clean ui \
        build-linux-amd64 build-linux-arm64 \
        deb deb-amd64 deb-arm64 \
        publish publish-amd64 publish-arm64
@@ -61,9 +61,35 @@ build-linux-arm64:
 test:
 	$(GO) test $(GOFLAGS) ./...

+test-race:
+	CGO_ENABLED=1 $(GO) test $(GOFLAGS) -race ./...
+
 lint:
 	$(GO) vet ./...
-	@command -v staticcheck >/dev/null && staticcheck ./... || echo "staticcheck not installed, skipping"
+	@command -v golangci-lint >/dev/null 2>&1 && golangci-lint run \
+	  || echo "golangci-lint nicht installiert (go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest) — übersprungen"
+
+GOBIN := $(shell $(GO) env GOPATH)/bin
+
+# govulncheck — Go-Vuln-DB-Scan. HARTER Release-Gate: bricht ab, wenn der
+# Code eine bekannte Vulnerability tatsächlich aufruft. Tool wird bei Bedarf
+# automatisch installiert.
+vulncheck:
+	@command -v govulncheck >/dev/null 2>&1 || GOFLAGS= $(GO) install golang.org/x/vuln/cmd/govulncheck@latest
+	@PATH="$(GOBIN):$$PATH" govulncheck ./...
+
+# Go-Quality-Baseline — läuft automatisch vor jedem Release (deb/publish).
+# Reihenfolge: vet → golangci-lint (Rollout: NON-BLOCKING) → govulncheck (GATE)
+# → build → test -race. govulncheck bricht bei jedem Fund ab; der Linter ist
+# in der Rollout-Phase noch non-blocking (Bestand aufräumen, dann auf Gate).
+release-check:
+	$(GO) vet ./...
+	@command -v golangci-lint >/dev/null 2>&1 && (golangci-lint run || echo "  ⚠ golangci-lint-Findings (non-blocking, Rollout-Phase)") \
+	  || echo "  golangci-lint nicht installiert — übersprungen (Rollout-Phase)"
+	@$(MAKE) --no-print-directory vulncheck
+	$(GO) build ./...
+	CGO_ENABLED=1 $(GO) test $(GOFLAGS) -race ./...
+	@echo "  ✓ Go-Quality-Baseline bestanden (vet, govulncheck, build, test -race)"

 tidy:
 	$(GO) mod tidy
@@ -74,10 +100,10 @@ ui:
 	    if [ -x "$$(command -v bun)" ]; then bun install --silent && bun run build; \
 	    else npm install --silent && npm run build; fi

-deb-amd64: build-linux-amd64 ui
+deb-amd64: release-check build-linux-amd64 ui
 	@./scripts/apt-repo/build-package.sh amd64 $(VERSION)

-deb-arm64: build-linux-arm64 ui
+deb-arm64: release-check build-linux-arm64 ui
 	@./scripts/apt-repo/build-package.sh arm64 $(VERSION)

 deb: deb-amd64 deb-arm64
--- a/2
+++ b/2
@@ -1 +1 @@
-1.2.97
+1.3.1
--- a/cmd/edgeguard-api/main.go
+++ b/cmd/edgeguard-api/main.go
@@ -431,7 +431,14 @@ func main() {
 		wgReloader := func(ctx context.Context) error {
 			return wgrender.New(pool, secretsBox).Render(ctx)
 		}
-		handlers.NewWireguardHandler(wgIfaces, wgPeers, secretsBox, auditRepo, nodeID, withFW(wgReloader)).Register(authed)
+		// Öffentlicher WG-Endpoint-Host für Peer-Configs = FQDN dieser Node
+		// (aus setup.json). Verhindert den REPLACE_WITH_PUBLIC_HOST-Platzhalter,
+		// an dem Clients sonst keinen Tunnel aufbauen können.
+		wgPublicHost := ""
+		if sst, serr := setupStore.Load(); serr == nil && sst != nil {
+			wgPublicHost = sst.FQDN
+		}
+		handlers.NewWireguardHandler(wgIfaces, wgPeers, secretsBox, auditRepo, nodeID, withFW(wgReloader)).WithPublicHost(wgPublicHost).Register(authed)

 		// Squid forward-proxy reload — re-render squid.conf + reload
 		// squid.service. sudoers im postinst whitelistet das. ACL-Count
--- a/cmd/edgeguard-ctl/cluster_replication.go
+++ b/cmd/edgeguard-ctl/cluster_replication.go
@@ -115,11 +115,29 @@ func cmdClusterInitReplication(args []string) int {
 	}
 	fmt.Printf("→ PostgreSQL %s/%s erkannt\n", pg.Version, pg.Cluster)

+	if err := setupReplicationPrimary(pg); err != nil {
+		fmt.Fprintln(os.Stderr, "cluster-init-replication:", err)
+		return 1
+	}
+
+	fmt.Println()
+	fmt.Println("Nächste Schritte:")
+	fmt.Println("  1) Auf dem Secondary: edgeguard-ctl cluster-setup-standby <primary-ip>")
+	fmt.Println("  2) Cluster-Settings (VIP) auf BEIDEN Nodes separat konfigurieren")
+	fmt.Println("     → Settings → Cluster → VIP/Keepalived")
+	return 0
+}
+
+// setupReplicationPrimary konfiguriert die lokale PG-Instanz als Logical-
+// Replication-Primary: Replikations-Rolle + Secret, conf.d (wal_level=logical),
+// pg_hba, SELECT-Grants, PUBLICATION. Stellt sicher dass wal_level=logical
+// AKTIV ist (Restart nur falls nötig — für wal_level reicht reload nicht).
+// Idempotent. Gemeinsam genutzt von cluster-init-replication und promote.
+func setupReplicationPrimary(pg pgConfig) error {
 	// 1. Passwort generieren
 	pass, err := generatePassword(32)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: generate password:", err)
-		return 1
+		return fmt.Errorf("generate password: %w", err)
 	}

 	// 2. edgeguard_replicator-Rolle anlegen/updaten
@@ -133,21 +151,17 @@ BEGIN
 END
 $$`, egReplUser, egReplUser, pass, egReplUser, pass)
 	if err := psqlExec(roleSQL); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: create replication role:", err)
-		return 1
+		return fmt.Errorf("create replication role: %w", err)
 	}
 	fmt.Printf("✓ Replication-Rolle %q angelegt/aktualisiert\n", egReplUser)

-	// 3. Passwort speichern
+	// 3. Passwort speichern (Ownership an edgeguard-User, damit die API liest)
 	if err := os.MkdirAll(filepath.Dir(egReplSecret), 0o750); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: mkdir:", err)
-		return 1
+		return fmt.Errorf("mkdir: %w", err)
 	}
 	if err := os.WriteFile(egReplSecret, []byte(pass), 0o600); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: write secret:", err)
-		return 1
+		return fmt.Errorf("write secret: %w", err)
 	}
-	// Ownership an edgeguard-api-User übergeben damit die API lesen kann
 	if u, err := user.Lookup("edgeguard"); err == nil {
 		uid, _ := strconv.Atoi(u.Uid)
 		gid, _ := strconv.Atoi(u.Gid)
@@ -156,71 +170,88 @@ $$`, egReplUser, egReplUser, pass, egReplUser, pass)
 	fmt.Printf("✓ Replication-Secret gespeichert: %s\n", egReplSecret)

 	// 4. conf.d/edgeguard-replication.conf schreiben
-	// wal_level=logical ist eine Obermenge von replica — unterstützt
-	// sowohl Logical Replication als auch ggfs. physisches WAL-Archiving.
 	if err := os.MkdirAll(pg.ConfD, 0o755); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: conf.d mkdir:", err)
-		return 1
+		return fmt.Errorf("conf.d mkdir: %w", err)
 	}
 	replConf := `# EdgeGuard Logical Replication — automatisch generiert
-# Nicht manuell bearbeiten; wird von edgeguard-ctl cluster-init-replication verwaltet.
+# Nicht manuell bearbeiten; wird von edgeguard-ctl verwaltet.
 wal_level = logical
 max_wal_senders = 10
 max_replication_slots = 20
 max_logical_replication_workers = 4
 wal_keep_size = 512MB
-# Lausche auf localhost + alle konfigurierten Interfaces damit Cluster-Peers
-# sich verbinden können. '*' ist sicher weil pg_hba.conf den Zugriff auf
-# bekannte Replikations-User beschränkt.
+# '*' ist sicher weil pg_hba.conf den Zugriff auf bekannte Replikations-User beschränkt.
 listen_addresses = '*'
 `
 	confPath := filepath.Join(pg.ConfD, "edgeguard-replication.conf")
 	if err := os.WriteFile(confPath, []byte(replConf), 0o644); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: write postgresql conf:", err)
-		return 1
+		return fmt.Errorf("write postgresql conf: %w", err)
 	}
 	fmt.Printf("✓ %s geschrieben (wal_level=logical)\n", confPath)

 	// 5. pg_hba.conf aktualisieren
 	if err := ensureHBAReplication(pg.HBAPath); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: pg_hba.conf:", err)
-		return 1
+		return fmt.Errorf("pg_hba.conf: %w", err)
 	}
 	fmt.Printf("✓ %s aktualisiert\n", pg.HBAPath)

-	// 6. PG reload (damit wal_level + pg_hba aktiv werden)
+	// 6. PG reload (pg_hba aktiv). wal_level/max_wal_senders sind aber
+	// postmaster-Parameter → nur per RESTART aktiv. Nur restarten wenn nötig.
 	if out, err := exec.Command("pg_ctlcluster", pg.Version, pg.Cluster, "reload").CombinedOutput(); err != nil {
-		fmt.Fprintf(os.Stderr, "cluster-init-replication: pg reload failed: %v\n%s\n", err, out)
-		return 1
+		return fmt.Errorf("pg reload: %w: %s", err, strings.TrimSpace(string(out)))
 	}
 	fmt.Printf("✓ PostgreSQL %s/%s neu geladen\n", pg.Version, pg.Cluster)
+	if cur, _ := psqlRun([]string{"-tA", "-c", "SHOW wal_level;"}); strings.TrimSpace(string(cur)) != "logical" {
+		fmt.Println("→ wal_level wechselt auf 'logical' — PostgreSQL-Restart nötig...")
+		if out, err := exec.Command("pg_ctlcluster", pg.Version, pg.Cluster, "restart").CombinedOutput(); err != nil {
+			return fmt.Errorf("pg restart: %w: %s", err, strings.TrimSpace(string(out)))
+		}
+		ready := false
+		deadline := time.Now().Add(60 * time.Second)
+		for time.Now().Before(deadline) {
+			if _, err := psqlRun([]string{"-tA", "-c", "SELECT 1;"}); err == nil {
+				ready = true
+				break
+			}
+			time.Sleep(2 * time.Second)
+		}
+		if !ready {
+			return fmt.Errorf("PostgreSQL kam nach Restart binnen 60s nicht zurück — prüfe PG-Logs")
+		}
+		fmt.Println("✓ PostgreSQL neu gestartet (wal_level=logical aktiv)")
+	}

-	// 7. SELECT-Grants: edgeguard_replicator muss alle zu replizierenden
-	// Tabellen lesen können. DEFAULT PRIVILEGES sichert zukünftige Tabellen.
+	// 7. SELECT-Grants (DEFAULT PRIVILEGES sichert zukünftige Tabellen)
 	grantSQL := fmt.Sprintf(`
 GRANT SELECT ON ALL TABLES IN SCHEMA public TO %s;
 ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO %s;
 `, egReplUser, egReplUser)
 	if err := psqlDBExec("edgeguard", grantSQL); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: grant SELECT:", err)
-		return 1
+		return fmt.Errorf("grant SELECT: %w", err)
 	}
 	fmt.Printf("✓ SELECT auf alle Tabellen für %q gewährt\n", egReplUser)

-	// 8. PUBLICATION erstellen — alle public-Tabellen außer localOnlyTables.
-	// Idempotent: DROP IF EXISTS + CREATE.
+	// 8. PUBLICATION (idempotent: DROP IF EXISTS + CREATE)
 	if err := createPublication(); err != nil {
-		fmt.Fprintln(os.Stderr, "cluster-init-replication: create publication:", err)
-		return 1
+		return fmt.Errorf("create publication: %w", err)
 	}
 	fmt.Printf("✓ PUBLICATION %q erstellt\n", egPubName)
+	return nil
+}

-	fmt.Println()
-	fmt.Println("Nächste Schritte:")
-	fmt.Println("  1) Auf dem Secondary: edgeguard-ctl cluster-setup-standby <primary-ip>")
-	fmt.Println("  2) Cluster-Settings (VIP) auf BEIDEN Nodes separat konfigurieren")
-	fmt.Println("     → Settings → Cluster → VIP/Keepalived")
-	return 0
+// dropSubscriptionIfExists entfernt die lokale Logical-Replication-Subscription
+// idempotent. DISABLE + slot_name=NONE VOR DROP, damit DROP nicht versucht den
+// Slot auf dem (beim Failover evtl. toten) Publisher zu löschen → kein Hängen.
+func dropSubscriptionIfExists() error {
+	dropSQL := fmt.Sprintf(`
+DO $$ BEGIN
+  IF EXISTS (SELECT FROM pg_subscription WHERE subname = '%s') THEN
+    ALTER SUBSCRIPTION %s DISABLE;
+    ALTER SUBSCRIPTION %s SET (slot_name = NONE);
+    DROP SUBSCRIPTION %s;
+  END IF;
+END $$;`, egSubName, egSubName, egSubName, egSubName)
+	return psqlDBExec("edgeguard", dropSQL)
 }

 // createPublication baut die PUBLICATION dynamisch aus allen Tabellen
@@ -334,15 +365,7 @@ func cmdClusterSetupStandby(args []string) int {
 	fmt.Printf("✓ Replication-Credentials von %s:%d erhalten\n", primaryHost, *agentPort)

 	// 2. Bestehende Subscription löschen (idempotent)
-	dropSQL := fmt.Sprintf(`
-DO $$ BEGIN
-  IF EXISTS (SELECT FROM pg_subscription WHERE subname = '%s') THEN
-    ALTER SUBSCRIPTION %s DISABLE;
-    ALTER SUBSCRIPTION %s SET (slot_name = NONE);
-    DROP SUBSCRIPTION %s;
-  END IF;
-END $$;`, egSubName, egSubName, egSubName, egSubName)
-	if err := psqlDBExec("edgeguard", dropSQL); err != nil {
+	if err := dropSubscriptionIfExists(); err != nil {
 		// Nicht fatal — wenn PG noch keine Subscription kennt ist das OK
 		fmt.Printf("  → keine bestehende Subscription gefunden (ok)\n")
 	} else {
--- a/cmd/edgeguard-ctl/promote.go
+++ b/cmd/edgeguard-ctl/promote.go
@@ -4,8 +4,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"os/exec"
-	"path/filepath"
 	"strings"
 	"time"

@@ -14,18 +12,22 @@ import (
 	"git.netcell-it.de/projekte/edgeguard-native/internal/keepalived"
 )

-// cmdPromote promotes this node's PostgreSQL instance from Hot-Standby
-// to Primary. Manual failover — keine automatische Promotion, um Split-Brain
-// in 2-Node-Clustern ohne externen Quorum zu verhindern.
+// cmdPromote befördert diese Node zum Logical-Replication-Primary. Manuelles
+// Failover — keine automatische Promotion, um Split-Brain in 2-Node-Clustern
+// ohne externes Quorum zu verhindern.
+//
+// Hintergrund: Die Replikation ist LOGICAL (Publication/Subscription), nicht
+// physisch. Ein Subscriber ist eine normale beschreibbare PG-Instanz (nie „in
+// recovery", kein standby.signal). „Promote" heißt darum: Subscription zum
+// (toten/alten) Primary lösen und selbst Publisher werden.
 //
 // Ablauf:
-//  1. Prüfen ob standby.signal vorhanden (wir sind wirklich Standby)
-//  2. pg_ctlcluster promote → PG wird Primary
-//  3. Warten bis pg_is_in_recovery() = false
-//  4. ha_nodes.pg_role auf 'primary' setzen
-//  5. KeyDB cluster:pg-primary-url auf lokal setzen
-//  6. keepalived.conf neu rendern (Primary bekommt Priorität 200)
-//  7. keepalived reload
+//  1. Idempotenz-Check: schon Publisher ohne Subscription → fertig
+//  2. Subscription lösen (DISABLE + slot_name=NONE + DROP)
+//  3. setupReplicationPrimary: Rolle/Secret/conf.d/pg_hba/Grants/Publication
+//     + sicherstellen dass wal_level=logical aktiv ist (PG-Restart falls nötig)
+//  4. ha_nodes.pg_role/role = 'primary'
+//  5. keepalived neu rendern (Primary = Priorität 200 = MASTER → übernimmt VIP)
 func cmdPromote(args []string) int {
 	pg, err := detectPGConfig()
 	if err != nil {
@@ -33,51 +35,43 @@ func cmdPromote(args []string) int {
 		return 1
 	}

-	// 1. Standby-Signal prüfen
-	signalPath := filepath.Join(pg.DataDir, "standby.signal")
-	if _, err := os.Stat(signalPath); os.IsNotExist(err) {
-		fmt.Fprintf(os.Stderr,
-			"promote: %s nicht gefunden — diese Node ist kein PG-Standby oder wurde bereits promoted.\n",
-			signalPath)
-		return 1
+	// 1. Idempotenz: bereits Publisher (Primary) ohne Subscription?
+	pubOut, _ := psqlDBRun("edgeguard", []string{"-tA", "-c",
+		fmt.Sprintf("SELECT count(*) FROM pg_publication WHERE pubname='%s';", egPubName)})
+	subOut, _ := psqlDBRun("edgeguard", []string{"-tA", "-c",
+		fmt.Sprintf("SELECT count(*) FROM pg_subscription WHERE subname='%s';", egSubName)})
+	hasPub := strings.TrimSpace(string(pubOut)) == "1"
+	hasSub := strings.TrimSpace(string(subOut)) == "1"
+	if hasPub && !hasSub {
+		fmt.Println("✓ Diese Node ist bereits Logical-Replication-Primary (Publication vorhanden, keine Subscription). Nichts zu tun.")
+		return 0
 	}

-	fmt.Printf("→ Promoting PostgreSQL %s/%s zu Primary...\n", pg.Version, pg.Cluster)
-	if out, err := exec.Command("pg_ctlcluster", pg.Version, pg.Cluster, "promote").
-		CombinedOutput(); err != nil {
-		fmt.Fprintf(os.Stderr, "promote: pg_ctlcluster promote: %v\n%s\n", err, out)
-		return 1
-	}
-	fmt.Println("✓ pg_ctlcluster promote gesendet")
+	fmt.Printf("→ Promote zu Logical-Replication-Primary (PostgreSQL %s/%s)...\n", pg.Version, pg.Cluster)

-	// 2. Warten bis PG wirklich Primary ist (pg_is_in_recovery = false)
-	fmt.Print("→ Warte auf PG Primary-Mode")
-	deadline := time.Now().Add(60 * time.Second)
-	for time.Now().Before(deadline) {
-		out, err := psqlRun([]string{"-tA", "-c", "SELECT pg_is_in_recovery();"})
-		if err == nil && strings.TrimSpace(string(out)) == "f" {
-			break
+	// 2. Subscription zum alten/toten Primary lösen
+	if hasSub {
+		if err := dropSubscriptionIfExists(); err != nil {
+			fmt.Fprintln(os.Stderr, "promote: Subscription lösen:", err)
+			return 1
 		}
-		fmt.Print(".")
-		time.Sleep(2 * time.Second)
+		fmt.Println("✓ Subscription zum alten Primary entfernt")
 	}
-	fmt.Println()
-	// Nochmal prüfen
-	out, err := psqlRun([]string{"-tA", "-c", "SELECT pg_is_in_recovery();"})
-	if err != nil || strings.TrimSpace(string(out)) != "f" {
-		fmt.Fprintln(os.Stderr, "promote: PG ist nach 60s noch in recovery — prüfe PG-Logs")
+
+	// 3. Diese Node als Publisher einrichten (inkl. wal_level=logical + Restart)
+	if err := setupReplicationPrimary(pg); err != nil {
+		fmt.Fprintln(os.Stderr, "promote:", err)
 		return 1
 	}
-	fmt.Println("✓ PostgreSQL ist jetzt Primary")

-	// 3. ha_nodes.pg_role + role aktualisieren
+	// 4. ha_nodes-Rolle aktualisieren
 	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 	defer cancel()

 	pool, err := database.Open(ctx, database.ConnStringFromEnv())
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "promote: db connect:", err)
-		fmt.Println("  → ha_nodes manuell updaten: UPDATE ha_nodes SET pg_role='primary', role='primary' WHERE id='<local-id>';")
+		fmt.Println("  → ha_nodes manuell: UPDATE ha_nodes SET pg_role='primary', role='primary' WHERE id='<local-id>';")
 	} else {
 		defer pool.Close()
 		localID, err := loadLocalID()
@@ -93,15 +87,7 @@ func cmdPromote(args []string) int {
 		}
 	}

-	// 4. KeyDB cluster:pg-primary-url updaten
-	if err := updateKeyDBPrimaryURL(); err != nil {
-		fmt.Fprintf(os.Stderr, "promote: KeyDB update: %v\n", err)
-		fmt.Println("  → Manuell: redis-cli SET cluster:pg-primary-url 'postgres://edgeguard@/edgeguard'")
-	} else {
-		fmt.Println("✓ KeyDB cluster:pg-primary-url aktualisiert")
-	}
-
-	// 5. Keepalived.conf neu rendern (Primary = Priorität 200)
+	// 5. keepalived.conf neu rendern (Primary = MASTER, Priority 200 → VIP)
 	if pool != nil {
 		localID, _ := loadLocalID()
 		kg := keepalived.New(pool, localID)
@@ -109,9 +95,9 @@ func cmdPromote(args []string) int {
 		defer renderCancel()
 		if err := kg.Render(renderCtx); err != nil {
 			fmt.Fprintf(os.Stderr, "promote: keepalived render: %v\n", err)
-			fmt.Println("  → Manuell: edgeguard-ctl render-config --only=keepalived")
+			fmt.Println("  → Manuell: sudo -u edgeguard edgeguard-ctl render-config --only=keepalived")
 		} else {
-			fmt.Println("✓ keepalived.conf neu gerendert (Priority 200)")
+			fmt.Println("✓ keepalived.conf neu gerendert (MASTER, Priority 200)")
 		}
 	}

@@ -119,8 +105,8 @@ func cmdPromote(args []string) int {
 	fmt.Println("✓ Promotion abgeschlossen. Diese Node ist jetzt der primäre EdgeGuard-Knoten.")
 	fmt.Println()
 	fmt.Println("Empfohlene Nachschritte:")
-	fmt.Println("  1) sudo systemctl restart edgeguard-api  (falls noch nicht laufend)")
-	fmt.Println("  2) Alte Primary-Node nach Recovery als neuen Standby einrichten:")
+	fmt.Println("  1) sudo systemctl restart edgeguard-api")
+	fmt.Println("  2) Übrige/erholte Nodes als Standby auf DIESE Node zeigen lassen:")
 	fmt.Println("     edgeguard-ctl cluster-setup-standby <diese-node-ip>")
 	return 0
 }
@@ -136,25 +122,3 @@ func loadLocalID() (string, error) {
 	}
 	return c.NodeID, nil
 }
-
-// updateKeyDBPrimaryURL schreibt den lokalen PG-DSN als cluster:pg-primary-url
-// in KeyDB, damit alle Nodes im Cluster Writes an diese Node schicken.
-func updateKeyDBPrimaryURL() error {
-	// edgeguard-api nutzt Unix-Socket-Auth, der DSN ist immer lokal.
-	const localDSN = "postgres://edgeguard@/edgeguard?host=/var/run/postgresql"
-	out, err := exec.Command("redis-cli",
-		"-s", "/var/run/keydb/keydb.sock",
-		"SET", "cluster:pg-primary-url", localDSN,
-	).CombinedOutput()
-	if err != nil {
-		// Fallback: Standard-Port
-		out2, err2 := exec.Command("redis-cli",
-			"-p", "6379",
-			"SET", "cluster:pg-primary-url", localDSN,
-		).CombinedOutput()
-		if err2 != nil {
-			return fmt.Errorf("%v: %s / %v: %s", err, out, err2, out2)
-		}
-	}
-	return nil
-}
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1,6 +1,8 @@
 # EdgeGuard — Architektur

-> Status: **v0.1 (Entwurf)** · Stand: 2026-05-08 · Ziel-Plattformen: Debian 13 (Trixie) + Ubuntu 24.04 LTS (Noble Numbat), Architekturen amd64 + arm64.
+> Status: **in Produktion** (v1.2.x) · Entwurf: 2026-05-08 · **Cluster/HA-Abschnitte an Ist-Stand angeglichen: 2026-06-06** · Plattform: Debian 13 (Trixie), amd64 + arm64.
+>
+> ⚠️ **Lesehinweis:** Dieses Dokument war ursprünglich ein Entwurf. Mehrere Cluster/HA-Annahmen wurden anders umgesetzt — maßgeblich sind die mit „**Ist-Stand**" markierten Stellen (§0, §6–§9). Kurzfassung: **Logical Replication** statt Streaming, **keepalived/VRRP** statt Hoster-Floating-IP, **KeyDB optional/ungenutzt** (Cluster-State in PostgreSQL), **kein Write-Proxy**.

 EdgeGuard ist die native Neufassung des bisherigen Docker-basierten Reverse-Proxy/Loadbalancer/Forward-Proxy/VPN-Stacks. Vorbild für Architektur, Build-System und Cluster-Modell ist [`mail-gateway`](../../mail-gateway/docs/architecture.md) (`nmg`); UI-Pattern und Bootstrap-Onliner stammen aus [`netcell-webpanel`](../../netcell-webpanel/CLAUDE.md) (`enconf`).

@@ -8,14 +10,14 @@ EdgeGuard ist die native Neufassung des bisherigen Docker-basierten Reverse-Prox

 ## 0. Leitplanken (nicht verhandelbar)

- **Kein Docker.** Alle Dienste nativ unter `systemd`, installiert via `apt`. Distro-Pakete für Drittsoftware (HAProxy, Squid, WireGuard, Unbound, PostgreSQL, KeyDB, certbot), eigene `.deb`-Pakete für EdgeGuard-Code (api, ui, ctl).
- **Plattform-Matrix:** Debian 13 (Trixie) **und** Ubuntu 24.04 LTS (Noble Numbat), je amd64 + arm64. Alle vier Targets gleichberechtigt.
+- **Kein Docker.** Alle Dienste nativ unter `systemd`, installiert via `apt`. Distro-Pakete für Drittsoftware (HAProxy, Squid, WireGuard, Unbound, PostgreSQL, keepalived, chrony, certbot), eigene `.deb`-Pakete für EdgeGuard-Code (api, ui, ctl).
+- **Plattform:** **Debian 13 (Trixie), amd64 + arm64.** Nur Trixie — die Build-/Publish-Pipeline (`Makefile`, `scripts/apt-repo/`) zielt ausschließlich auf `trixie`. _(Eine frühere Ubuntu-24.04-Matrix war geplant, ist aber nicht implementiert.)_
 - **Auslieferung:** signierte `.deb`-Pakete + Meta-Paket via APT. Bootstrap ist der enconf-analoge curl-Onliner `curl -fsSL https://get.edgeguard.netcell-it.de | sudo bash`.
- **HA nativ als Cluster:** N symmetrische Peers, **KeyDB Active-Active** für Shared State + **PostgreSQL Streaming Replication** (single writer, transparenter API-Write-Proxy) + **Floating-IP des Hosters** für HTTP/HTTPS-Ingress (nicht VRRP, nicht DNS-RR).
- **Kein WAF, kein IDS, kein DHCP, kein RADIUS, keine Mail-Funktion in v1.** Mail-Gateway ist eigenes Produkt (`nmg`); WAF/CrowdSec/Suricata kommen ggf. in v2.
+- **HA nativ als Cluster (Ist-Stand 2026-06):** N symmetrische Peers, **PostgreSQL Logical Replication** (ein Publisher/Primary `edgeguard_shared` → N Subscriber; node-lokale Tabellen ausgenommen) + **keepalived/VRRP** für den VIP-Failover (HTTP/HTTPS-Ingress) + **mTLS-Cluster-Agent** (:8443) für Heartbeat/Cert-Sync/Aggregation. **KeyDB ist optional** (`Recommends`) und im Code praktisch ungenutzt; ein Write-Proxy existiert nicht (Writes erfolgen am Primary). _(Der ursprüngliche Entwurf — KeyDB Active-Active, PG-Streaming-Replication mit transparentem Write-Proxy, Floating-IP-statt-VRRP — wurde so nicht umgesetzt; Details in §6–§9.)_
+- **WAF, IDS/IPS, DHCP, RADIUS inzwischen umgesetzt** (Stand 2026-06): WAF via Coraza+SPOE, IDS/IPS via CrowdSec, DHCP via Kea, RADIUS via FreeRADIUS. Mail-Funktion bleibt ausgeschlossen — Mail-Gateway ist eigenes Produkt (`nmg`).
 - **Migrations:** `goose` (SQL-Dateien), nicht GORM AutoMigrate.

-**Nicht-Ziele (ausdrücklich):** kein WAF, kein Network-IDS (Suricata), kein IPS (CrowdSec), kein DHCP-Server (Kea), kein RADIUS, keine Mail-Verarbeitung, keine Multi-Tenant-GuardZones in v1, keine ISO-Builds (kein EdgeGuardOS-Klon — nur APT).
+**Nicht-Ziele (weiterhin):** kein Network-IDS via Suricata (IDS/IPS läuft über CrowdSec), keine Mail-Verarbeitung, keine Multi-Tenant-GuardZones, keine ISO-Builds (kein EdgeGuardOS-Klon — nur APT). _(Historisch waren auch WAF/DHCP/RADIUS/IPS Nicht-Ziele — siehe oben, inzwischen umgesetzt.)_

 ---

@@ -33,12 +35,13 @@ EdgeGuard ist die native Neufassung des bisherigen Docker-basierten Reverse-Prox

 | Komponente | Rolle |
 |---|---|
-| `edgeguard-api` | Go/Gin REST-API, bindet `127.0.0.1:9443`, Reads aus lokaler PG, Writes an Cluster-Primary |
-| `edgeguard-scheduler` | Cron-artige Jobs (ACME-Renewal-Hook, Backup, Health-Aggregation, License-Heartbeat) |
-| `edgeguard-ctl` | CLI für Setup/Wartung (`initdb`, `migrate`, `cluster-join`, `promote`, `dump-config`) |
+| `edgeguard-api` | Go/Gin REST-API, bindet `127.0.0.1:9443`, Reads/Writes auf lokaler PG. Geteilte Tabellen werden vom Primary per Logical Replication an Subscriber verteilt; Writes sollen am Primary erfolgen (keine Write-Proxy-Umleitung im Code). |
+| `edgeguard-waf` | Coraza-WAF-Agent (HAProxy SPOE) — Binary im `edgeguard-api`-Paket, eigene systemd-Unit |
+| `edgeguard-scheduler` | Cron-artige Jobs (ACME-Renewal-Hook, Backup, Health-Aggregation, Stale-Node-Sweep, License-Heartbeat) |
+| `edgeguard-ctl` | CLI für Setup/Wartung (`initdb`, `migrate`, `cluster-join`, `promote`, `cluster-init-replication`, `cluster-setup-standby`, `dump-config`) |
 | `management-ui` | React 19 + AntD 6 + Vite, statisch unter `/usr/share/edgeguard/ui/`, von `edgeguard-api` per gin `StaticFS` ausgeliefert (HAProxy proxied Management-FQDN dorthin) |
-| **PostgreSQL 16** | Single Source of Truth — Domains, Backends, Routing-Rules, ACLs, Peers, etc. |
-| **KeyDB** (Redis-kompatibel) | Active-Active-Replication, Cluster-State, Locks, Rate-Counter, Pub/Sub für Config-Reload |
+| **PostgreSQL 16/17** | Single Source of Truth — Domains, Backends, Routing-Rules, ACLs, Peers, Cluster-State (`ha_nodes`), Lizenz etc. |
+| **KeyDB** (optional) | `Recommends`, im Code praktisch ungenutzt — kein Redis-Client in `go.mod`. Cluster-State/Heartbeat/Locks liegen in PostgreSQL, nicht in KeyDB. |

 ---

@@ -61,10 +64,15 @@ EdgeGuard ist die native Neufassung des bisherigen Docker-basierten Reverse-Prox
 │   ├── wireguard/                 # WireGuard-Config-Generator (wg-quick + wg syncconf)
 │   ├── unbound/                   # Unbound-Config-Generator (Forwarder + Cluster-DNS)
 │   ├── firewall/                  # nftables-Ruleset-Generator
-│   ├── cluster/                   # Join/Promote/Peer-Discovery, KeyDB-Replication-Setup, pg_basebackup
-│   ├── proxy/                     # API-Write-Proxy-Middleware (Replica → Primary), mTLS-Calls
-│   ├── aggregator/                # Cluster-View-APIs (alle Backends, alle Peers, alle Health-States)
-│   └── license/                   # License-Validation, License-Leader-Election (KeyDB-Lock)
+│   ├── cluster/                   # Join/Promote/Peer-Discovery, Heartbeat, Logical-Replication-Setup, confighash
+│   ├── keepalived/                # keepalived/VRRP-Config-Generator (VIP-Failover)
+│   ├── chrony/                    # chrony-Config-Generator (NTP)
+│   ├── kea/                       # Kea-DHCP4-Config-Generator
+│   ├── freeradius/                # FreeRADIUS-Config-Generator (RADIUS)
+│   ├── crowdsec/                  # CrowdSec-IDS/IPS-Management (managed-wenn-installiert)
+│   ├── waf/                       # Coraza-WAF-Engine + SPOE-Agent-Logik
+│   ├── aggregator/                # Cluster-View-APIs via mTLS (read-only Fan-Out + Trigger-Actions)
+│   └── license/                   # License-Validation (jeder Node verifiziert eigenständig — KEINE KeyDB-Leader-Election)
 ├── management-ui/                 # React 19 + AntD 6 + Vite (Struktur 1:1 wie netcell-webpanel/management-ui/)
 ├── packaging/
 │   └── debian/
@@ -94,17 +102,17 @@ EdgeGuard ist die native Neufassung des bisherigen Docker-basierten Reverse-Prox

 ## 3. Debian-Pakete

-Drei Pakete + Meta — analog nmg, kein WAF-Paket weil kein WAF in v1.
+Drei Pakete + Meta — analog nmg. Der WAF-Agent `edgeguard-waf` ist **kein eigenes Paket**, sondern liegt als zusätzliches Binary im `edgeguard-api`-Paket (eigene systemd-Unit).

 | Paket | Arch | Inhalt | Depends |
 |---|---|---|---|
-| `edgeguard-api` | amd64, arm64 | `/usr/bin/edgeguard-{api,scheduler,ctl}`, Unit-Files, Migrations, Default-Configs | `postgresql-16`, `keydb-server`, `haproxy`, `squid`, `wireguard-tools`, `unbound`, `nftables`, `certbot`, `openssl` |
+| `edgeguard-api` | amd64, arm64 | `/usr/bin/edgeguard-{api,scheduler,ctl,waf}`, Unit-Files, Migrations, Default-Configs | `postgresql-16 \| postgresql-17`, `haproxy (>=2.8)`, `squid`, `wireguard-tools`, `unbound`, `chrony`, `kea-dhcp4-server`, `freeradius`, `nftables`, `keepalived`, `certbot`, `openssl`, `sudo`, `adduser`, `systemd`, `ca-certificates`, `ulogd2`, `ulogd2-json` u. a. · _Recommends:_ `edgeguard-keydb`, `apparmor`, `fail2ban` · _CrowdSec: managed-wenn-installiert (kein Depends)_ |
 | `edgeguard-ui` | all | `/usr/share/edgeguard/ui/` (statische Build-Artefakte) | `edgeguard-api (= ${binary:Version})` |
 | `edgeguard-meta` | all | keine Dateien, nur `Depends` | `edgeguard-api`, `edgeguard-ui` |

-Pro Release: 1 arch-spezifisch × 2 Dists × 2 Arches = 4 `.deb` + 2 arch-agnostische × 2 Dists = 4 `.deb` → **8 Artefakte je Release**.
+Pro Release: 1 arch-spezifisches Paket (`edgeguard-api`) × **1 Dist (trixie)** × 2 Arches = 2 `.deb` + 2 arch-agnostische (`edgeguard-ui`, `edgeguard-meta`) = **4 Artefakte je Release**. (Build/Publish-Pipeline zielt nur auf `trixie`.)

-**KeyDB-Herkunft:** KeyDB ist weder in `trixie` noch `noble` in den offiziellen Repos. Wir bauen es aus Source (amd64 + arm64), veröffentlichen es parallel im eigenen APT-Repo. `edgeguard-api` `Depends: keydb-server` löst aus unserem Repo aus.
+**KeyDB-Herkunft:** KeyDB ist optional (`Recommends: edgeguard-keydb`), nicht in den offiziellen trixie-Repos. Falls genutzt, aus Source gebaut + im eigenen APT-Repo veröffentlicht. Im aktuellen Code wird KeyDB nicht benötigt — siehe §7.

 **Build-Werkzeug:** **direkter `dpkg-deb`-Build** analog WebPanel/EdgeGuardOS-Pattern. **Nicht** `dh_make`/`debhelper`, **nicht** `fpm`. Konsistenz mit existierendem Workflow.

@@ -162,7 +170,8 @@ Entspricht FHS — keine Überraschungen für Admins, Lintian-clean.

 | Unit | Typ | Depends-on | User | Restart |
 |---|---|---|---|---|
-| `edgeguard-api.service` | `simple` | `postgresql.service`, `keydb-server.service` | `edgeguard` | `on-failure`, `RestartSec=5` |
+| `edgeguard-api.service` | `simple` | `Requires=postgresql.service`; `After=`/`Wants=keydb-server.service` (KeyDB nur weich/optional) | `edgeguard` | `on-failure`, `RestartSec=5` |
+| `edgeguard-waf.service` | `simple` | `edgeguard-api.service` (Coraza SPOE-Agent) | `edgeguard` | `on-failure` |
 | `edgeguard-scheduler.service` | `simple` | `edgeguard-api.service` | `edgeguard` | `on-failure` |
 | `edgeguard-cert-deploy.path` | `path` | — | — | — |
 | `edgeguard-firewall.service` | `oneshot`, `RemainAfterExit=true` | — | root | — |
@@ -183,7 +192,7 @@ SystemCallFilter=@system-service
 ReadWritePaths=/var/lib/edgeguard /var/log/edgeguard /etc/edgeguard
 ```

-Drittsoftware (HAProxy, Squid, WireGuard via `wg-quick@.service`, Unbound, nftables) läuft als **Distro-Units**. EdgeGuard generiert deren Config + signalisiert Reload, übernimmt aber die Service-Verwaltung **nicht**.
+Drittsoftware läuft als **Distro-Units** — EdgeGuard generiert deren Config + signalisiert Reload/Restart, übernimmt aber die Service-Verwaltung weitgehend nicht. Renderer existieren für: **HAProxy, Squid, WireGuard (`wg-quick@.service`), Unbound, nftables, keepalived, chrony, Kea (`kea-dhcp4-server`), FreeRADIUS** (letzte beide default-off). **CrowdSec** (`crowdsec` + `crowdsec-firewall-bouncer`) wird gemanagt, wenn installiert (kein Depends).

 API bindet auf `127.0.0.1:9443` (nicht öffentlich). HAProxy terminiert TLS auf `:443`, leitet `/.well-known/acme-challenge/*` und Management-FQDN-Traffic an die API weiter, routet alle anderen Hosts per ACL an die User-Backends.

@@ -191,29 +200,28 @@ API bindet auf `127.0.0.1:9443` (nicht öffentlich). HAProxy terminiert TLS auf

 ## 6. Datenbank-Setup

- **PostgreSQL 16**, Distro-Paket `postgresql-16`.
- **Verbindung:** Unix-Socket (`/var/run/postgresql`) für lokale Reads + Writes der API. TCP/5432 mit TLS-Client-Cert nur zwischen Cluster-Peers für Streaming Replication.
- **Topologie:** **ein logischer Primary** zu jedem Zeitpunkt, N Read-Replicas. Lokale API liest immer aus lokaler PG; Writes routet die API-Write-Proxy-Middleware transparent an den aktuellen Primary (KeyDB-Key `cluster:pg-primary-url`).
- **Migrations:** `goose` (SQL-Dateien in `internal/database/migrations/`, via `//go:embed` ins Binary gepackt). **Nicht** GORM AutoMigrate.
+- **PostgreSQL 16/17**, Distro-Paket `postgresql-16 | postgresql-17`.
+- **Verbindung:** Unix-Socket (`/var/run/postgresql`) für lokale Reads + Writes der API. TCP/5432 (Rolle `edgeguard_replicator`) nur zwischen Cluster-Peers für die Logical-Replication-Verbindung.
+- **Topologie (Ist-Stand):** **Logical Replication** — ein Primary publiziert `edgeguard_shared` (alle Tabellen außer `localOnlyTables`), N Subscriber (`edgeguard_sub`, `wal_level=logical`, Initialkopie via `copy_data=true`). Jeder Node hat eine **eigene beschreibbare** PG-Instanz; geteilte Config fließt vom Primary zu den Subscribern. **Es gibt keinen Write-Proxy** — Schreibzugriffe auf geteilte Tabellen müssen am Primary erfolgen; ein Subscriber-Write auf eine replizierte Tabelle würde nicht propagieren (Drift-Banner erkennt das via `config_hash`). Primary-Erkennung zuverlässig über `pg_publication`; der Standby-Bootstrap läuft per Logical Subscription (kein `pg_basebackup` im aktiven Pfad).
+- **node-lokale Tabellen** (nicht repliziert): `ha_nodes`, `network_interfaces`, `ip_addresses`, `static_routes`, `cluster_settings`, `dns_settings`, `ntp_settings`, `dhcp_settings`, `radius_settings`, `system_settings`, `join_tokens_used`, `audit_log`, `alert_events`, `backups`, `goose_db_version` (Liste: `cmd/edgeguard-ctl/cluster_replication.go` `localOnlyTables`).
+- **Migrations:** `goose` (SQL-Dateien in `internal/database/migrations/`, via `//go:embed`). **Nicht** GORM AutoMigrate.

-GORM bleibt als ORM für Query-Komfort; nur das Schema-Management wechselt zu `goose`.
+GORM bleibt als ORM für Query-Komfort; Schema-Management läuft über `goose`.

 ---

-## 7. KeyDB Active-Active
+## 7. Cluster-State & KeyDB (Ist-Stand: PostgreSQL-zentrisch)

-KeyDB ersetzt Redis. **Active-Active Replication** (Multi-Master, operation-basiert, split-brain-tolerant).
+> **Hinweis:** Der ursprüngliche Entwurf sah KeyDB Active-Active als Cluster-State-Layer vor. **Im Code ist das nicht umgesetzt** — es gibt **keinen Redis/KeyDB-Client** (`go.mod` enthält nur `pgx`). KeyDB ist optional (`Recommends`) und wird vom laufenden System nicht benötigt.

-**Verwendung:**
- `cluster:pg-primary-url` — wer ist aktueller PG-Primary?
- `cluster:license-leader` — Lock für License-Heartbeat (`SET … NX EX 60`)
- `cluster:license-status` — Cache des Lizenz-Validate-Ergebnisses (TTL 24 h)
- `cluster:nodes:<node-id>` — Heartbeat-Marker (TTL 2 min)
- `ratelimit:<scope>:<key>` — Rate-Counter (HINCRBY-Ops mergen korrekt)
- `acme:lock:<domain>` — verhindert Parallel-Issue auf zwei Nodes
- Pub/Sub: `edgeguard:config-changed` — alle Nodes regenerieren Config
+**Wie Cluster-State tatsächlich gehalten wird:**
+- **PG-Primary** — über `pg_publication` (`edgeguard_shared`) ermittelt; die Peer-Adresse für Pushes stammt aus `setup.json` `PrimaryFQDN`.
+- **Node-Heartbeat/-Status** — Spalten `last_seen`/`status` in PG `ha_nodes`. Jeder Node bumpt seine Row alle 30s (`runClusterHeartbeat`); Secondary→Primary (`runPrimaryPush`) und Primary→Secondary (`runPeerPush`) pushen sich gegenseitig per mTLS (30s, bidirektional). `SweepStaleNodes` (Scheduler) flippt Peers nach 2 min ohne Heartbeat auf `offline`.
+- **Lizenz** — jeder Node verifiziert **eigenständig** gegen `license.netcell-it.com` (kein Leader-Lock); Ergebnis in PG `licenses`.
+- **ACME** — kein verteilter Issue-Lock implementiert (Single-Node-Default; bei Cluster Issue am aktiven/Primary-Node).
+- `cluster:pg-primary-url` in KeyDB wird von `edgeguard-ctl promote` **geschrieben, falls KeyDB läuft**, aber von der API **nie gelesen** (advisory/Altlast).

-KeyDB hört nur auf `127.0.0.1:6379` für lokale Clients und `<node-ip>:16379` (TLS) für Peer-Replication.
+_Falls KeyDB künftig wieder eingeführt wird (Rate-Limiting-Counter, Pub/Sub-Config-Reload): hört auf `127.0.0.1:6379` lokal und `<node-ip>:16379` (TLS) für Peer-Replication. Derzeit ungenutzt._

 ---

@@ -234,7 +242,7 @@ Unbound erfüllt zwei Rollen, beide aus PG generiert:
 - **Local-Zone** `eg.cluster.` enthält A/AAAA-Records aller Cluster-Peers (Node-Hostnamen aus PG `ha_nodes`).
 - Beispiel: `node1.eg.cluster → 10.42.0.11`, `node2.eg.cluster → 10.42.0.12`.
 - Wird bei jedem Node-Join/-Leave aus PG regeneriert + via `edgeguard:config-changed` Pub/Sub auf allen Peers neu geladen (`unbound-control reload`).
- Cluster-interner Traffic (PG-Replication, KeyDB-Replication, mTLS-API-Calls, Cert-Push) löst Peer-Adressen ausschließlich über diese Zone auf — kein DNS-Roundtrip ins öffentliche Internet, keine `/etc/hosts`-Synchronisation.
+- Cluster-interner Traffic (PG-Logical-Replication, mTLS-Agent-Calls auf :8443, Cert-Push) löst Peer-Adressen ausschließlich über diese Zone auf — kein DNS-Roundtrip ins öffentliche Internet, keine `/etc/hosts`-Synchronisation.
 - `<node-name>.eg.cluster` ist **nicht extern erreichbar** (nur über Unbound der Cluster-Peers).

 ### Config-Schichten
@@ -253,54 +261,56 @@ Reload via `unbound-control reload` (kein Restart, keine Cache-Invalidierung au

 ## 8. Cluster-Topologie & HA pro Service

-**N symmetrische Peers** (1 … N Nodes, jeder vollwertig). Keine VRRP, keine Master/Backup-Rollen für Daten-Services. Public-IP: **Floating-IP des Hosters** (siehe §9).
+**N symmetrische Peers** (1 … N Nodes, jeder vollwertig). Public-IP-Failover via **VIP/VRRP (keepalived)** — siehe §9 (der ursprünglich geplante „Floating-IP statt VRRP"-Ansatz wurde **nicht** umgesetzt).

 | Service | HA-Strategie |
 |---|---|
-| **HAProxy** | stateless, pro Node identisch. Floating-IP zeigt zum aktuellen aktiven Node; bei Node-Ausfall API-Call zum Hoster (oder manueller Switch) reicht. ACME-Issue nur auf License-Leader (KeyDB-Lock); Zerts werden via PG/mTLS an alle verteilt. |
-| **Squid** | stateless (Cache lokal, kein Sync nötig). Pro Node identische ACL-Config. |
+| **VIP/keepalived** | VRRP (`vrrp_instance`), MASTER/BACKUP per `pg_role` (primary→prio 200/MASTER, standby→100/BACKUP). VIPs aus `ip_addresses` (`is_vip=true`). Trägt den HTTP/HTTPS-Ingress. |
+| **HAProxy** | stateless, pro Node identisch. Hört auf der VIP des aktiven Node. ACME-Issue ohne verteilten Lock (Single-/Primary-Node); Zerts werden via mTLS (`/agent/cluster/tls-certs`) an alle verteilt. |
+| **Squid** | stateless (Cache lokal). Pro Node identische ACL-Config. |
 | **WireGuard** | siehe §8.1 |
-| **Unbound** | stateless (Cache lokal). Pro Node identische Forwarder-Config + identische Cluster-internen Local-Zones (siehe §7.5). |
-| **nftables** | pro Node identisch, Ruleset aus PG generiert. `crowdsec_blocklist`/`threat_intel_blocklist`-Sets entfallen in v1 (kein CrowdSec). |
-| **edgeguard-api** | pro Node, Reads lokal, Writes via Proxy zu Primary. |
-| **edgeguard-ui** | statisch, pro Node identisch. |
-| **PostgreSQL** | Streaming Replication, manueller Promote (siehe nmg §6.2). |
-| **KeyDB** | Active-Active. |
+| **Unbound** | stateless (Cache lokal). Pro Node identische Forwarder-Config + Cluster-Local-Zones (§7.5). |
+| **nftables** | pro Node, Ruleset aus PG generiert. CrowdSec-Blocklist via `crowdsec-firewall-bouncer` (eigene Sets), wenn CrowdSec installiert. |
+| **edgeguard-api** | pro Node, Reads lokal. Writes auf geteilte Tabellen am Primary (kein Write-Proxy). |
+| **edgeguard-ui / edgeguard-waf** | statisch bzw. pro Node identisch. |
+| **PostgreSQL** | **Logical Replication** (Publisher→Subscriber), manueller Promote (§8.2). |
+| **KeyDB** | optional/ungenutzt (§7). |

 ### 8.1 WireGuard im Cluster

 Drei Optionen, für v1 wählen wir **Option A**:

- **A — Geteilte Server-Identität (gewählt):** alle Peers haben **denselben** Server-Privatkey + dasselbe Listen-Port. Floating-IP routet UDP zum aktiven Node. Bei Failover: Floating-IP wandert, Clients schicken Pakete zum neuen Node, neuer Handshake (~1–2s Latenz beim ersten Paket). Replay-Protection-Counter werden nicht repliziert — beim Failover macht der Client neuen Handshake, alte Counter sind irrelevant.
+- **A — Geteilte Server-Identität (gewählt):** alle Peers haben **denselben** Server-Privatkey + dasselbe Listen-Port. Die **VIP (keepalived)** trägt das WireGuard-UDP zum aktiven Node. Bei Failover: VIP wandert, Clients schicken Pakete zum neuen Node, neuer Handshake (~1–2s Latenz beim ersten Paket). Replay-Protection-Counter werden nicht repliziert — beim Failover macht der Client neuen Handshake, alte Counter sind irrelevant.
 - B — Pro Node eigene Identität, Client kennt alle: Client-Configs haben mehrere `[Peer]`-Blöcke. Aufwendiger zu provisionieren, kein Failover-Vorteil.
 - C — Aktiv/Standby per License-Leader-Pattern: nur ein Node hat WireGuard aktiv, andere idle. Verschwendet Kapazität.

-**Begründung A:** Privatkey ist in PG (verschlüsselt mit `edgeguard.key`), wird beim Cluster-Join an neue Peers verteilt. WireGuard handelt selbständig neue Sessions aus, kein State-Sync nötig. Operation-Tools (Peer hinzufügen/entfernen) wirken auf alle Nodes via `edgeguard:config-changed` Pub/Sub + lokales `wg syncconf`.
+**Begründung A:** Privatkey liegt verschlüsselt in PG, wird per Logical Replication an die Peers verteilt. WireGuard handelt selbständig neue Sessions aus, kein State-Sync nötig. Peer-Änderungen propagieren über die Logical Replication; Secondaries erkennen die Änderung am `config_hash` (`runSecondaryConfigRender`, 5-min-Tick) und re-rendern lokal → `wg syncconf`.

 ### 8.2 Manual Promote (PG-Primary-Failover)

-1:1 nmg-Pattern (siehe `mail-gateway/docs/architecture.md` §6.2). Bei Ausfall des Primary antworten Config-Writes mit `503 + actionable Error`. Admin promotet via UI/CLI. Datenebene (HAProxy/Squid/WireGuard/Unbound) läuft unbeeinträchtigt weiter, weil jeder Node eine lokale PG-Replica hat.
+Bei Ausfall des Primary läuft die Datenebene (HAProxy/Squid/WireGuard/Unbound) weiter, weil jeder Node eine lokale, lesbare PG-Instanz (Logical-Subscriber) hat. Schreibzugriffe auf geteilte Config müssen am Primary erfolgen — fällt der Primary aus, promotet der Admin manuell via **`edgeguard-ctl promote`**. Das ist Logical-Replication-aware: es löst die Subscription zum toten Primary (`DISABLE` + `slot_name=NONE` + `DROP`, hängt also nicht am toten Publisher), richtet die Node via `setupReplicationPrimary` als Publisher ein (Rolle/Secret/`wal_level=logical` inkl. **PG-Restart** falls nötig/Publication), setzt `ha_nodes.pg_role='primary'` und rendert keepalived (→ MASTER, übernimmt die VIP). Erholte Nodes danach mit `edgeguard-ctl cluster-setup-standby <neuer-primary>` zurückhängen. **Achtung:** echtes Cross-Node-Failover ist nur im Drill testbar — die Bausteine (Drop-Subscription, Publication, Restart) sind dieselben wie in `cluster-init-replication`/`cluster-setup-standby`.

-### 8.3 License-Leader-Election
+### 8.3 License-Verifikation

-Ein einziger Node kontaktiert `license.netcell-it.com` (KeyDB-Lock, 60-s-TTL). Ergebnis cluster-weit in `cluster:license-status` (TTL 24 h). `active_servers`-Verbrauchswert = Count der Peers mit Heartbeat < 2 min.
+**Kein Leader-Election** (anders als ursprünglich geplant). Jeder Node verifiziert **eigenständig** gegen `license.netcell-it.com` (Scheduler-Tick), Ergebnis in PG `licenses`. `active_servers` = Anzahl Peers mit Heartbeat < 2 min (aus `ha_nodes`). Ein KeyDB-Lock existiert nicht.

 ---

-## 9. Public-Ingress — Floating-IP statt VRRP
+## 9. Public-Ingress — VIP via keepalived/VRRP

-**Problem:** HTTP-Clients machen kein automatisches Failover bei DNS-RR (anders als MTAs). Ein toter A-Record = 50% Fehler bis DNS-TTL.
+> **Ist-Stand:** Umgesetzt ist **VIP-Failover über keepalived (VRRP)** — nicht der ursprünglich angedachte „Floating-IP des Hosters"-Ansatz. Es gibt **keinen** Hoster-API-Code und **keinen** `POST /cluster/promote-this-node`-Endpoint.

-**Entscheidung:** **Floating-IP des Hosters**. Der Hoster bietet eine API zum Umroute der IP zwischen Servern (z. B. via REST oder DNS-Update bei dynamischer Anycast-Lösung). Failover dauert Sekunden, kein VRRP-Drama, kein "VIP verschwindet"-Problem aus dem alten Setup.
+**Mechanik (`internal/keepalived`):**
+- Renderer erzeugt `/etc/keepalived/keepalived.conf` mit `vrrp_instance` (unicast peer, `virtual_router_id`, `authentication`).
+- **State/Priorität aus `pg_role`:** Primary → `state MASTER`, `priority 200`; Standby → `state BACKUP`, `priority 100`.
+- **VIPs** kommen aus `ip_addresses` (`is_vip=true`, `active=true`), inkl. Interface; managed via `systemctl reload-or-restart keepalived`.
+- Bei Node-/PG-Ausfall übernimmt VRRP die VIP auf den verbleibenden Node (Sekundenbereich).

-Optionen pro Hoster:
-1. **Provider-Floating-IP** (gewünscht): API-Call schaltet IP um. EdgeGuard exponiert `POST /api/v1/cluster/promote-this-node`, das die Hoster-API aufruft.
-2. **DNS-RR mit kurzer TTL (60s)** als Notlösung wenn keine Floating-IP verfügbar.
-3. **Anycast/BGP** als Premium-Variante (für Enterprise).
+**Tooling:** `GET/PUT /cluster/vip-settings`, `GET /cluster/vip-status`, `POST /cluster/vip-test` (Letzteres bewegt eine VIP testweise per `ip addr add/del` zwischen Nodes — kein Hoster-Call).

-**v1-Default:** Single-Node mit fest zugewiesener Floating-IP. Cluster-Erweiterung kommt mit Phase 2.
+**v1-Default:** Single-Node. Im Cluster trägt der MASTER (Primary) die VIP.

-⚑ **OFFEN:** Welcher Hoster ist Standard? API-Spec dokumentieren sobald geklärt.
+⚑ **OFFEN (Altlast-Bereinigung):** Doku-Abschnitte/Code, die noch „Floating-IP des Hosters" implizieren, sind historisch — der reale Pfad ist keepalived/VRRP.

 ---

@@ -312,7 +322,7 @@ curl -fsSL https://get.edgeguard.netcell-it.de | sudo bash

 Schritte (idempotent, analog `netcell-webpanel/install.sh`):

-1. **OS-Detection** (`/etc/os-release`): nur Trixie *oder* Noble, sonst Abbruch.
+1. **OS-Detection** (`/etc/os-release`): nur Debian 13 (Trixie), sonst Abbruch.
 2. **Arch-Detection**: nur amd64 *oder* arm64.
 3. **Base-Deps:** `curl gnupg ca-certificates apt-transport-https`.
 4. **APT-Keyrings:**
@@ -329,7 +339,7 @@ curl -fsSL https://get.edgeguard.netcell-it.de | sudo bash -s -- \
  --token <cluster-join-token>
 ```

-`edgeguard-ctl cluster-join` führt aus: PG-Basebackup vom Primary, KeyDB-Replication-Setup, Node-Registrierung in `ha_nodes`, TLS-Cert-Pull via mTLS, Config-Regeneration, Service-Start.
+`edgeguard-ctl cluster-join` führt aus: TLS-Cert-Pull via mTLS (CSR→issue-cert), Node-Registrierung in `ha_nodes` (`autoRegister`), Setup als **Logical-Replication-Subscriber** (`cluster-setup-standby`: `CREATE SUBSCRIPTION … copy_data=true`, Initialkopie der geteilten Tabellen), Config-Regeneration, Service-Start. _(Kein `pg_basebackup`, kein KeyDB-Setup — beides war nur im ursprünglichen Entwurf.)_

 ---

@@ -337,7 +347,7 @@ curl -fsSL https://get.edgeguard.netcell-it.de | sudo bash -s -- \

 - **Primärquelle:** Gitea Package Registry (`https://git.netcell-it.de/api/packages/projekte/debian`).
 - **Kunden-Mirror:** `https://apt.netcell-it.de/edgeguard/` (rsync von Gitea).
- **Suiten:** `stable` · `testing` · `security` — pro Codename (`trixie`, `noble`).
+- **Suiten:** `stable` · `testing` · `security` — Codename `trixie`.
 - **Signatur:** GPG-Key `netcell-edgeguard-signing`, ausgeliefert in `/etc/apt/keyrings/`.
 - **Update-Check-API:** `GET /api/v1/system/package-versions` → pro `edgeguard-*`-Paket `{name, installed, available, reboot_required}`.
 - **Upgrade-Trigger:** `POST /api/v1/system/upgrade` startet `systemd-run --unit=edgeguard-upgrade.service --collect …` (HTTP-Response geht VOR dem Upgrade raus, weil API beim Self-Update stirbt — Pattern aus `netcell-webpanel/management-agent/internal/handlers/update.go:105`).
@@ -355,13 +365,13 @@ Build-/Release-Scripts identisch zu `mail-gateway/scripts/apt-repo/`.
 - **Lizenzserver:** `https://license.netcell-it.com` (öffentlich, kein API-Key).
 - **Verify-Endpoint:** `GET /api/v1/licenses/{key}/verify?system_id={fp}&system_name={host}&active_domains={n}`.
 - **Fingerprint:** `SHA256(/etc/machine-id + erste-aktive-MAC + hostname)`.
- **Caching:** Live → KeyDB `cluster:license-status` (TTL 24h) → `/var/lib/edgeguard/trial.json` (30 Tage) → `expired`.
- **Leader-Election** wie nmg §6.3.
+- **Caching:** Live-Verify → Ergebnis in PG `licenses` → `/var/lib/edgeguard/trial.json` (30-Tage-Trial-Fallback) → `expired`.
+- **Keine Leader-Election** — jeder Node verifiziert eigenständig (§8.3).

 ### 12.2 ACME

 - **certbot** (Distro-Paket) mit `--webroot=/var/lib/edgeguard/acme` — HAProxy ACL `path_beg /.well-known/acme-challenge/` proxied diese Pfade an `edgeguard-api`, das die Challenge-Tokens aus der Webroot-Dir ausliefert.
- **Lock vor Issue:** `acme:lock:<domain>` in KeyDB verhindert Parallel-Issue auf zwei Nodes.
+- **Cluster-Locking:** derzeit **kein** verteilter Issue-Lock implementiert (Single-Node-Default; im Cluster sollte ACME am Primary/aktiven Node laufen). _(Der ursprünglich geplante KeyDB-`acme:lock:<domain>` existiert nicht.)_
 - **Deploy-Hook:** schreibt fertiges PEM (cert+chain+key kombiniert) nach `/etc/edgeguard/tls/<domain>.pem` und triggert `systemctl reload haproxy`. HAProxy lädt den `crt /etc/edgeguard/tls/`-Verzeichnisinhalt neu.
 - **Cert-Verteilung im Cluster:** Issuing-Node pushed via mTLS-API an alle Peers, Zerts landen in `/etc/edgeguard/tls/`.

@@ -384,14 +394,12 @@ Komponentenbibliothek, Theme, Layouts, Navigations-Struktur, Form-Patterns, i18n

 ## 14. Plattform-Matrix

-| Distribution | Codename | Arch | Status v1 |
+| Distribution | Codename | Arch | Status |
 |---|---|---|---|
 | Debian 13 | trixie | amd64 | Tier 1 |
 | Debian 13 | trixie | arm64 | Tier 1 |
-| Ubuntu 24.04 LTS | noble | amd64 | Tier 1 |
-| Ubuntu 24.04 LTS | noble | arm64 | Tier 1 |

-Andere Distributionen (Debian 12, Ubuntu 22.04, RHEL/Rocky) sind **nicht unterstützt**. Installer bricht hart ab.
+**Nur Debian 13 (Trixie).** Die Build-/Publish-Pipeline (`Makefile`, `scripts/apt-repo/`) zielt ausschließlich auf `trixie`; der Installer bricht auf anderem OS hart ab. _(Eine ursprünglich geplante Ubuntu-24.04-„noble"-Matrix ist nicht implementiert.)_ Andere Distributionen (Debian 12, Ubuntu, RHEL/Rocky) sind **nicht unterstützt**.

 ---

@@ -402,7 +410,7 @@ EdgeGuard-Native ist eigenes Repo (`git.netcell-it.de/projekte/edgeguard-native`
 1. **Frische Installation** auf Test-VM via `install.sh`.
 2. **Config-Export** aus altem Stack (`edgeguard-ctl export --from-docker`) — liest aus alter PG, schreibt in neues Format.
 3. **Validierung** Side-by-Side (alter Stack auf einem Server, neuer Stack auf anderem, Traffic vergleichen).
-4. **Cutover** via Floating-IP-Switch.
+4. **Cutover** via VIP-Umzug (keepalived) bzw. DNS-Umstellung.

 Der alte `proxy-lb-waf`-Code bleibt für Bestandskunden im Wartungsmodus, keine neuen Features.

@@ -410,6 +418,6 @@ Der alte `proxy-lb-waf`-Code bleibt für Bestandskunden im Wartungsmodus, keine

 ## Offene Punkte

- **Hoster + Floating-IP-API** (§9): Spec dokumentieren.
- **WireGuard-State-Replication** in der Praxis testen (Handshake-Latenz nach Floating-IP-Switch messen).
+- **Failover-Drill:** `edgeguard-ctl promote` (Logical-aware) + anschließendes `cluster-setup-standby` in einem echten 2-Node-Failover durchspielen (inkl. VIP-Umzug, WireGuard-Handshake-Latenz). _(Code-Altlasten `internal/proxy`-Stub und `promote.go`-`standby.signal` wurden 2026-06 bereinigt.)_
+- **Optional KeyDB** (Rate-Limit-Counter, Pub/Sub-Config-Reload) — falls je benötigt; aktuell ungenutzt.
 - **`get.edgeguard.netcell-it.de`** anlegen oder Übergangs-URL auf `apt.netcell-it.de/edgeguard/install.sh` nutzen.
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module git.netcell-it.de/projekte/edgeguard-native

-go 1.26.0
+go 1.26.4

 require (
 	github.com/corazawaf/coraza/v3 v3.7.0
@@ -16,7 +16,7 @@ require (
 	github.com/pquerna/otp v1.5.0
 	github.com/pressly/goose/v3 v3.27.1
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
-	golang.org/x/crypto v0.51.0
+	golang.org/x/crypto v0.52.0
 	golang.org/x/oauth2 v0.36.0
 )

@@ -79,9 +79,9 @@ require (
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/arch v0.8.0 // indirect
 	golang.org/x/mod v0.35.0 // indirect
-	golang.org/x/net v0.53.0 // indirect
+	golang.org/x/net v0.55.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/sys v0.44.0 // indirect
+	golang.org/x/sys v0.45.0 // indirect
 	golang.org/x/text v0.37.0 // indirect
 	golang.org/x/tools v0.44.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
--- a/go.sum
+++ b/go.sum
@@ -186,18 +186,18 @@ go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
 golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI=
-golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8=
+golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988=
+golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc=
 golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
 golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
-golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
-golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
+golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8=
+golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=
 golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
 golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
-golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
+golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
 golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
 golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
--- a/internal/chrony/chrony.cfg.tpl
+++ b/internal/chrony/chrony.cfg.tpl
@@ -13,14 +13,16 @@
 {{end}}

 # ── Listen-Bind ────────────────────────────────────────────────
-# Wenn nichts ausser localhost gebound ist, lassen wir bindaddress
-# weg (chrony default = alle Interfaces). Sonst explizite bindaddress
-# pro IP. Mit serve_clients=false wird port 0 → kein Listen-Socket
-# (= reiner Client).
+# KEIN bindaddress: chrony honoriert nur EINE bindaddress pro Adress-
+# familie — bei mehreren Listen-IPs (z. B. mehrere VLAN-/Cluster-VIPs)
+# würde nur die letzte gebunden, alle anderen NTP-Clients liefen ins
+# Leere. Stattdessen lauscht chrony auf allen Interfaces; WER bedient
+# wird, regeln die allow-ACL UNTEN + die nftables-Regeln (UDP/123 wird
+# nur auf den konfigurierten Listen-IPs/VIPs geöffnet, nicht öffentlich).
+# Bonus: failover-robust — chrony bedient automatisch jede VIP, die der
+# Node gerade hält, ohne Restart bei Master-Wechsel.
+# serve_clients=false → port 0 → kein Listen-Socket (reiner Client).
 {{if .Settings.ServeClients}}
-{{- range .ListenAddresses}}
-bindaddress {{.}}
-{{- end}}
 {{- range .AllowACLs}}
 allow {{.}}
 {{- end}}
--- a/internal/chrony/chrony_test.go
+++ b/internal/chrony/chrony_test.go
@@ -0,0 +1,53 @@
+package chrony
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"git.netcell-it.de/projekte/edgeguard-native/internal/models"
+)
+
+func render(t *testing.T, v View) string {
+	t.Helper()
+	var b bytes.Buffer
+	if err := tpl.Execute(&b, v); err != nil {
+		t.Fatalf("execute: %v", err)
+	}
+	return b.String()
+}
+
+// Mehrere Listen-IPs (VLAN-/Cluster-VIPs): chrony honoriert nur EINE
+// bindaddress pro Adressfamilie → wir dürfen GAR KEINE bindaddress emittieren,
+// sondern bind-all + allow-ACL. Sonst würde nur eine VIP gebunden und alle
+// anderen NTP-Clients liefen ins Leere (Regressions-Schutz).
+func TestRender_NoBindaddress_ServesAllVIPs(t *testing.T) {
+	v := View{
+		Settings:        &models.NTPSettings{ServeClients: true, MakestepSecs: 1, MakestepLimit: 3},
+		AllowACLs:       []string{"10.0.0.0/8", "192.168.0.0/16"},
+		ListenAddresses: []string{"10.0.5.1", "10.0.20.1", "10.10.20.1", "10.0.50.1"},
+	}
+	out := render(t, v)
+	// Auf die DIREKTIVE prüfen (Zeilenanfang), nicht aufs Wort — der
+	// erklärende Kommentar im Template enthält „bindaddress" absichtlich.
+	if strings.Contains(out, "\nbindaddress ") {
+		t.Fatalf("chrony darf KEIN bindaddress emittieren (nur eine pro Familie wird gebunden):\n%s", out)
+	}
+	for _, acl := range []string{"allow 10.0.0.0/8", "allow 192.168.0.0/16"} {
+		if !strings.Contains(out, acl) {
+			t.Fatalf("erwarte %q im Output:\n%s", acl, out)
+		}
+	}
+}
+
+// serve_clients=false → reiner Client: port 0, kein Listen-Socket, kein allow.
+func TestRender_NoServeClients_Port0(t *testing.T) {
+	v := View{Settings: &models.NTPSettings{ServeClients: false, MakestepSecs: 1, MakestepLimit: 3}}
+	out := render(t, v)
+	if !strings.Contains(out, "port 0") {
+		t.Fatalf("erwarte 'port 0' bei serve_clients=false:\n%s", out)
+	}
+	if strings.Contains(out, "\nallow ") {
+		t.Fatalf("kein allow bei serve_clients=false:\n%s", out)
+	}
+}
--- a/internal/database/migrations/0043_domains_redirect_to.sql
+++ b/internal/database/migrations/0043_domains_redirect_to.sql
@@ -0,0 +1,8 @@
+-- +goose Up
+-- redirect_to: wenn gesetzt, liefert HAProxy für diese Domain einen 301 auf
+-- die angegebene Ziel-URL (Domain-zu-Domain-Weiterleitung) statt sie auf ein
+-- Backend zu routen. Leerstring = keine Weiterleitung (Normalbetrieb).
+ALTER TABLE domains ADD COLUMN IF NOT EXISTS redirect_to text NOT NULL DEFAULT '';
+
+-- +goose Down
+ALTER TABLE domains DROP COLUMN IF EXISTS redirect_to;
--- a/internal/firewall/firewall.go
+++ b/internal/firewall/firewall.go
@@ -177,14 +177,14 @@ type RuleLeg struct {
 // template just emits one nft line per "leg" of the cross-product.
 type ResolvedRule struct {
 	ID       int64
-	Action   string  // accept | drop | reject
+	Action   string // accept | drop | reject
 	Log      bool
 	Name     string
 	Priority int

-	SrcIfaces []string  // empty = any
-	DstIfaces []string  // empty = any
-	SrcAddrs  []string  // each is an nft expression like "1.2.3.4" or "10.0.0.0/24" or "{ 1.2.3.4, 5.6.7.8 }"
+	SrcIfaces []string // empty = any
+	DstIfaces []string // empty = any
+	SrcAddrs  []string // each is an nft expression like "1.2.3.4" or "10.0.0.0/24" or "{ 1.2.3.4, 5.6.7.8 }"
 	DstAddrs  []string
 	Services  []ResolvedService // empty = any
 	Comment   string
@@ -192,16 +192,16 @@ type ResolvedRule struct {

 // ResolvedNATRule is one nat-rule joined with iface-sets.
 type ResolvedNATRule struct {
-	ID       int64
-	Kind     string // dnat | snat | masquerade
-	Priority int
-	InIfaces []string
-	OutIfaces []string
-	Proto    string  // empty = any
-	SrcCIDR  string
-	DstCIDR  string
-	DPortStart, DPortEnd int
-	TargetAddr string
+	ID                             int64
+	Kind                           string // dnat | snat | masquerade
+	Priority                       int
+	InIfaces                       []string
+	OutIfaces                      []string
+	Proto                          string // empty = any
+	SrcCIDR                        string
+	DstCIDR                        string
+	DPortStart, DPortEnd           int
+	TargetAddr                     string
 	TargetPortStart, TargetPortEnd int
 	// L3 ist "ip" oder "ip6" — Adressfamilie der Regel (aus SrcCIDR/
 	// DstCIDR/TargetAddr abgeleitet). TargetHost ist TargetAddr, bei
@@ -209,14 +209,14 @@ type ResolvedNATRule struct {
 	// nft-dnat-Syntax.
 	L3         string
 	TargetHost string
-	Comment  string
+	Comment    string
 }

 // ResolvedService is one nft (proto, dport-spec) tuple.
 type ResolvedService struct {
-	Proto      string // tcp|udp|icmp|icmpv6
-	PortStart  int    // 0 = no port match
-	PortEnd    int
+	Proto     string // tcp|udp|icmp|icmpv6
+	PortStart int    // 0 = no port match
+	PortEnd   int
 }

 func (g *Generator) loadView(ctx context.Context) (*View, error) {
@@ -269,6 +269,31 @@ func (g *Generator) loadView(ctx context.Context) (*View, error) {
 	}
 	peerRows.Close()

+	// ── Heartbeat-IPs aus cluster_settings ins Peer-Set ──
+	// Der VRRP-Heartbeat (VI_HB) läuft über hb_src_ip/hb_peer_ip (z.B.
+	// 169.254.0.1/.2) — diese stehen NICHT in ha_nodes. Ohne sie würde die
+	// VRRP-Accept-Regel den Heartbeat-Pfad nicht abdecken. Best-effort:
+	// fehlt cluster_settings (Single-Node), bleibt es bei den ha_nodes-IPs.
+	var hbSrc, hbPeer *string
+	if err := g.Pool.QueryRow(ctx,
+		`SELECT hb_src_ip, hb_peer_ip FROM cluster_settings WHERE id = 1`).
+		Scan(&hbSrc, &hbPeer); err == nil {
+		for _, ip := range []*string{hbSrc, hbPeer} {
+			if ip == nil {
+				continue
+			}
+			parsed := net.ParseIP(*ip)
+			if parsed == nil {
+				continue
+			}
+			if parsed.To4() != nil {
+				view.PeerIPv4 = append(view.PeerIPv4, parsed.String())
+			} else {
+				view.PeerIPv6 = append(view.PeerIPv6, parsed.String())
+			}
+		}
+	}
+
 	// ── Lade Address-Objects + Groups → ID → ResolvedAddr-list ──
 	addrObjs, err := g.loadAddrObjects(ctx)
 	if err != nil {
@@ -777,15 +802,15 @@ ORDER BY priority DESC, id ASC`)
 	out := []ResolvedRule{}
 	for rows.Next() {
 		var (
-			id                   int64
-			name, action, com    string
-			pr                   int
-			log                  bool
-			srcZone, dstZone     string
-			srcObjID, srcGrpID   *int64
-			dstObjID, dstGrpID   *int64
-			srcCIDR, dstCIDR     *string
-			svcObjID, svcGrpID   *int64
+			id                 int64
+			name, action, com  string
+			pr                 int
+			log                bool
+			srcZone, dstZone   string
+			srcObjID, srcGrpID *int64
+			dstObjID, dstGrpID *int64
+			srcCIDR, dstCIDR   *string
+			svcObjID, svcGrpID *int64
 		)
 		if err := rows.Scan(
 			&id, &name, &pr, &action, &log, &com,
@@ -842,12 +867,12 @@ ORDER BY priority DESC, id ASC`)
 	out := []ResolvedNATRule{}
 	for rows.Next() {
 		var (
-			id          int64
-			pr          int
-			kind, com   string
+			id                                       int64
+			pr                                       int
+			kind, com                                string
 			inZone, outZone, proto, srcCIDR, dstCIDR *string
-			dpStart, dpEnd, tpStart, tpEnd int
-			targetAddr  string
+			dpStart, dpEnd, tpStart, tpEnd           int
+			targetAddr                               string
 		)
 		if err := rows.Scan(
 			&id, &pr, &kind, &com,
@@ -861,7 +886,7 @@ ORDER BY priority DESC, id ASC`)
 		r := ResolvedNATRule{
 			ID: id, Kind: kind, Priority: pr, Comment: com,
 			DPortStart: dpStart, DPortEnd: dpEnd,
-			TargetAddr: targetAddr,
+			TargetAddr:      targetAddr,
 			TargetPortStart: tpStart, TargetPortEnd: tpEnd,
 		}
 		if proto != nil {
--- a/internal/firewall/ruleset.nft.tpl
+++ b/internal/firewall/ruleset.nft.tpl
@@ -55,6 +55,13 @@ table inet edgeguard {
        tcp dport 5432 ip6 saddr @peer_ipv6 accept
        tcp dport 6379 ip  saddr @peer_ipv4 accept
        tcp dport 6379 ip6 saddr @peer_ipv6 accept
+        # Cluster-internal: VRRP-Advertisements (keepalived VIP-Failover, Proto 112).
+        # OHNE diese Regel überleben Adverts nur via conntrack-Reverse-Matching —
+        # läuft ein conntrack-Eintrag ab/wird geflusht, werden Adverts gedroppt →
+        # der Peer promotet sich → VIP-Flapping/Split-Brain. peer_ipv4/6 enthält
+        # Public- UND Heartbeat-IPs (ha_nodes + cluster_settings.hb_*).
+        ip  protocol vrrp ip  saddr @peer_ipv4 accept
+        ip6 nexthdr  vrrp ip6 saddr @peer_ipv6 accept

        # ── Service-Auto-Rules (DNS/Squid/WG/...) ──
        # Aus dem laufenden Service-State abgeleitet — Operator
--- a/internal/handlers/cluster.go
+++ b/internal/handlers/cluster.go
@@ -925,6 +925,14 @@ func (h *ClusterHandler) AgentRegisterPeer(c *gin.Context) {
 	if req.PublicIP != "" {
 		v := req.PublicIP
 		n.PublicIP = &v
+	} else if ip := c.ClientIP(); ip != "" {
+		// Der Push-Payload (autoRegister, Primary→Secondary) trägt KEINE
+		// public_ip → sonst bliebe sie NULL und der Peer fehlt im nft-
+		// peer_ipv4-Set → VRRP-Adverts nur via conntrack → Flapping. Der
+		// pushende Peer verbindet sich über mTLS von seiner EIGEN-IP (nicht
+		// der VIP — der Kernel nimmt die primäre Interface-IP als Source),
+		// genau wie preRegisterJoiner die Joiner-IP übernimmt. Selbstheilend.
+		n.PublicIP = &ip
 	}
 	if req.InternalIP != "" {
 		v := req.InternalIP
--- a/internal/handlers/system.go
+++ b/internal/handlers/system.go
@@ -194,6 +194,8 @@ var servicesToCheck = []struct{ Label, Unit string }{
 	{"unbound", "unbound"},
 	{"chrony", "chrony"},
 	{"squid", "squid"},
+	{"kea-dhcp4", "kea-dhcp4-server"},
+	{"freeradius", "freeradius"},
 	{"postgresql", "postgresql"},
 	{"crowdsec", "crowdsec"},
 	{"crowdsec-firewall-bouncer", "crowdsec-firewall-bouncer"},
--- a/internal/handlers/wireguard.go
+++ b/internal/handlers/wireguard.go
@@ -32,6 +32,10 @@ type WireguardHandler struct {
 	Audit    *audit.Repo
 	NodeID   string
 	Reloader func(ctx context.Context) error
+	// PublicHost ist der öffentliche Host (FQDN/IP), den Clients als
+	// WireGuard-Endpoint anwählen. Wird in heruntergeladene Peer-Configs
+	// geschrieben (statt eines Platzhalters). Leer → Platzhalter (Fallback).
+	PublicHost string
 }

 func NewWireguardHandler(
@@ -45,6 +49,12 @@ func NewWireguardHandler(
 	return &WireguardHandler{Ifaces: ifaces, Peers: peers, Box: box, Audit: a, NodeID: nodeID, Reloader: reloader}
 }

+// WithPublicHost setzt den öffentlichen Endpoint-Host für Peer-Configs.
+func (h *WireguardHandler) WithPublicHost(host string) *WireguardHandler {
+	h.PublicHost = strings.TrimSpace(host)
+	return h
+}
+
 func (h *WireguardHandler) reload(ctx context.Context, op string) {
 	if h.Reloader == nil {
 		return
@@ -702,11 +712,15 @@ func (h *WireguardHandler) peerConfigText(ctx context.Context, peerID int64) (st
 		clientAllowedIPs += ", " + strings.TrimSpace(*ifc.ClientRoutes)
 	}
 	fmt.Fprintf(&b, "AllowedIPs = %s\n", clientAllowedIPs)
-	// Endpoint — the operator's public host:port that peers dial.
-	// We don't know this here (could be a CNAME or behind a load
-	// balancer); leave a placeholder the operator must fill in.
+	// Endpoint — der öffentliche Host:Port, den Clients anwählen. Standard
+	// ist der FQDN dieser Node (PublicHost, aus setup.json). Nur wenn der
+	// nicht ermittelbar ist, bleibt ein Platzhalter den der Operator füllt.
 	if ifc.ListenPort != nil {
-		fmt.Fprintf(&b, "Endpoint = REPLACE_WITH_PUBLIC_HOST:%d\n", *ifc.ListenPort)
+		host := h.PublicHost
+		if host == "" {
+			host = "REPLACE_WITH_PUBLIC_HOST"
+		}
+		fmt.Fprintf(&b, "Endpoint = %s:%d\n", host, *ifc.ListenPort)
 	}
 	if p.Keepalive != nil && *p.Keepalive > 0 {
 		fmt.Fprintf(&b, "PersistentKeepalive = %d\n", *p.Keepalive)
--- a/internal/haproxy/haproxy.cfg.tpl
+++ b/internal/haproxy/haproxy.cfg.tpl
@@ -113,6 +113,11 @@ frontend public_https
    # www-Redirect: {{$d.RedirectFromHost}} → {{$d.Name}}
    http-request redirect prefix https://{{$d.Name}} code 301 if { hdr(host) -i {{$d.RedirectFromHost}} }
    {{- end}}
+    {{- if $d.RedirectTo}}
+    # Domain-Redirect (301): {{$d.Name}} → {{$d.RedirectTo}} (immer auf Ziel-Root,
+    # terminiert vor use_backend → diese Domain routet auf kein Backend).
+    http-request redirect location {{$d.RedirectTo}} code 301 if { hdr(host) -i {{$d.Name}} }
+    {{- end}}
    {{- if $d.MaintenanceMode}}
    # Wartungs-Modus für {{$d.Name}} — alle Requests werden mit 503 beantwortet.
    http-request return status 503 content-type "text/plain; charset=utf-8" string "{{$d.MaintMessage}}" if { hdr(host) -i {{$d.Name}} }
--- a/internal/haproxy/haproxy.go
+++ b/internal/haproxy/haproxy.go
@@ -212,6 +212,11 @@ type DomainView struct {
 	//   to-www    → Name="www.example.com" → "example.com" (strip www.-Prefix)
 	RedirectFromHost string

+	// RedirectTo: HAProxy-safe 301-Ziel-URL für eine Domain→Domain-Weiterleitung
+	// (z. B. "https://zkm.netcell-it.de"). Leer = kein Redirect. Schattet das
+	// gleichnamige Feld aus dem eingebetteten models.Domain (sanitisiert).
+	RedirectTo string
+
 	// ResponseHeaders: Custom-Headers die HAProxy auf jede Response für
 	// diese Domain setzt. Werte sind bereits HAProxy-safe escaped
 	// (Quotes → ', Newlines → Space).
@@ -313,6 +318,7 @@ func (g *Generator) loadView(ctx context.Context) (*View, error) {
 			HSTSHeader:       buildHSTSHeader(d),
 			MaintMessage:     buildMaintMessage(d),
 			RedirectFromHost: buildRedirectFromHost(d),
+			RedirectTo:       buildRedirectTo(d),
 			ResponseHeaders:  headersByDomain[d.ID],
 		}
 		if d.MaxBodyKB > 0 {
@@ -429,3 +435,23 @@ func buildRedirectFromHost(d models.Domain) string {
 		return ""
 	}
 }
+
+// buildRedirectTo liefert die 301-Ziel-URL HAProxy-safe, oder "" wenn kein
+// Redirect gesetzt ist bzw. die URL ungültig erscheint. Defensiv: nur
+// http(s)-URLs ohne Whitespace/Steuerzeichen/Quotes — sonst würde die
+// `redirect location <url>`-Zeile die HAProxy-Config sprengen. Im Zweifel
+// lieber KEIN Redirect rendern als eine kaputte Config auszuliefern.
+func buildRedirectTo(d models.Domain) string {
+	u := strings.TrimSpace(d.RedirectTo)
+	if u == "" {
+		return ""
+	}
+	lower := strings.ToLower(u)
+	if !strings.HasPrefix(lower, "http://") && !strings.HasPrefix(lower, "https://") {
+		return ""
+	}
+	if strings.ContainsAny(u, " \t\r\n\"'`\\{}") {
+		return ""
+	}
+	return u
+}
--- a/internal/haproxy/haproxy_test.go
+++ b/internal/haproxy/haproxy_test.go
@@ -170,6 +170,45 @@ func TestRender_WWWRedirectToWWW(t *testing.T) {
 	}
 }

+func TestRender_RedirectTo(t *testing.T) {
+	v := View{
+		Domains: []DomainView{
+			{
+				Domain: models.Domain{
+					ID: 1, Name: "kvs.netcell-it.de", Active: true,
+					RedirectTo: "https://zkm.netcell-it.de",
+				},
+				RedirectTo: "https://zkm.netcell-it.de",
+			},
+		},
+	}
+	out := renderView(t, v)
+	want := `http-request redirect location https://zkm.netcell-it.de code 301 if { hdr(host) -i kvs.netcell-it.de }`
+	if !strings.Contains(out, want) {
+		t.Errorf("missing domain→domain 301 redirect line:\n%s", out)
+	}
+}
+
+func TestBuildRedirectTo(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"https://zkm.netcell-it.de", "https://zkm.netcell-it.de"},
+		{"  https://zkm.netcell-it.de  ", "https://zkm.netcell-it.de"}, // getrimmt
+		{"http://x.de", "http://x.de"},
+		{"", ""},
+		{"zkm.netcell-it.de", ""},           // kein Schema
+		{"ftp://x.de", ""},                  // falsches Schema
+		{"https://x .de", ""},               // Whitespace → unsafe
+		{"https://x\"de", ""},               // Quote → unsafe
+		{"javascript:alert(1)", ""},         // kein http(s)
+	}
+	for _, c := range cases {
+		got := buildRedirectTo(models.Domain{RedirectTo: c.in})
+		if got != c.want {
+			t.Errorf("buildRedirectTo(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
 func TestBuildHSTSHeader(t *testing.T) {
 	cases := []struct {
 		name string
--- a/internal/keepalived/keepalived.conf.tpl
+++ b/internal/keepalived/keepalived.conf.tpl
@@ -2,21 +2,32 @@ global_defs {
    router_id {{ .RouterID }}
    script_user root
    enable_script_security
+    # GARP: beim Master-Wechsel Gratuitous-ARP forciert senden (repeat) UND
+    # periodisch auffrischen (master_refresh) — sonst lässt der Upstream-Switch
+    # die VIP-MAC altern und die Failover-IP wird nach Minuten unerreichbar.
+    # Ergänzt durch den Priming-Ping in keepalived-master.sh (Traffic AUS der VIP).
+    # (vrrp_garp_interval/gna NICHT setzen: keepalived 2.3.x lehnt 0 ab, Default passt.)
+    vrrp_garp_master_repeat 5
+    vrrp_garp_master_refresh 60
 }

+{{/* KEIN weight: in einer vrrp_sync_group ignoriert keepalived gewichtete
+     Track-Scripts ("ignoring tracked script ... with weights due to SYNC
+     group") → die Health-Checks wären wirkungslos. Ohne weight wirken sie
+     als binäre FAULT-Trigger: schlägt ein Check fall-mal in Folge fehl,
+     geht die Instanz (und via Sync-Group der ganze Node) in FAULT → der
+     gesunde Peer übernimmt. Für einen 2-Node-Cluster die saubere Semantik. */}}
 vrrp_script chk_edgeguard {
    script "/usr/lib/edgeguard/keepalived-check.sh"
    interval 2
-    weight -50
-    fall 3
+    fall 8
    rise 2
 }
 {{ if .GWCheckIP }}
 vrrp_script chk_gateway {
    script "/usr/lib/edgeguard/keepalived-gw-check.sh {{ .GWCheckIP }}"
    interval 5
-    weight -110
-    fall 2
+    fall 5
    rise 2
 }
 {{ end }}
@@ -33,7 +44,8 @@ vrrp_instance VI_1 {
    interface {{ .Interface }}
    virtual_router_id {{ .RouterID }}
    priority {{ .Priority }}
-    advert_int 1
+    advert_int 2
+    nopreempt
 {{ if .SrcIP }}    unicast_src_ip {{ .SrcIP }}
    unicast_peer {
        {{ .PeerIP }}
@@ -59,7 +71,8 @@ vrrp_instance VI_HB {
    interface {{ .HBInterface }}
    virtual_router_id {{ .HBRouterID }}
    priority {{ .Priority }}
-    advert_int 1
+    advert_int 2
+    nopreempt
 {{ if .HBSrcIP }}    unicast_src_ip {{ .HBSrcIP }}
    unicast_peer {
        {{ .HBPeerIP }}
--- a/internal/keepalived/keepalived.go
+++ b/internal/keepalived/keepalived.go
@@ -167,17 +167,19 @@ func (g *generator) buildView(cs *models.ClusterSettings, vips []VIPEntry, local
 		v.HBRouterID = 52
 	}

-	// pg_role=standby ist das härtere Signal — ein Standby-Node ist niemals
-	// MASTER, auch wenn role='primary' noch aus dem Join-Prozess stammt.
-	// Reihenfolge: standby → BACKUP; sonst primary-Check.
+	// State IMMER BACKUP: das Template setzt `nopreempt`, und nopreempt wirkt
+	// in keepalived NUR, wenn die Instanz im BACKUP-Zustand startet (bei state
+	// MASTER wird nopreempt ignoriert). Die Priorität entscheidet weiterhin die
+	// Initial-Election (primary=200 gewinnt), aber ein erholter Node reißt die
+	// VIP NICHT mehr zurück → kein Flap-Back / Split-Brain. Deckt sich mit der
+	// "kein Auto-Promote"-Philosophie: Promotion bleibt manuell.
+	// pg_role=standby ist das härtere Signal (Standby ist nie bevorzugter Node).
+	v.State = "BACKUP"
 	if local.PGRole == "standby" {
-		v.State = "BACKUP"
 		v.Priority = 100
 	} else if local.PGRole == "primary" || local.Role == "primary" {
-		v.State = "MASTER"
 		v.Priority = 200
 	} else {
-		v.State = "BACKUP"
 		v.Priority = 100
 	}

--- a/internal/keepalived/keepalived_test.go
+++ b/internal/keepalived/keepalived_test.go
@@ -0,0 +1,112 @@
+package keepalived
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"git.netcell-it.de/projekte/edgeguard-native/internal/models"
+)
+
+func render(t *testing.T, v View) string {
+	t.Helper()
+	var buf bytes.Buffer
+	if err := tpl.Execute(&buf, v); err != nil {
+		t.Fatalf("template execute: %v", err)
+	}
+	return buf.String()
+}
+
+// Split-Brain-Schutz: jede vrrp_instance MUSS `nopreempt` tragen, sonst reißt
+// ein erholter Node die VIP zurück → Flapping. nopreempt wirkt nur bei state
+// BACKUP — also muss auch der bevorzugte Node BACKUP starten.
+func testView() View {
+	return View{
+		State: "BACKUP", Interface: "eth0", RouterID: 51, Priority: 200,
+		SrcIP: "89.163.205.6", PeerIP: "89.163.205.8", AuthPass: "edgeguard",
+		VIPs:        []VIPEntry{{Address: "89.163.205.100", Prefix: 24, Device: "eth0"}},
+		HBInterface: "ens19", HBSrcIP: "169.254.0.1", HBPeerIP: "169.254.0.2", HBRouterID: 52,
+		GWCheckIP: "89.163.205.1",
+	}
+}
+
+func TestTemplateNopreemptOnBothInstances(t *testing.T) {
+	out := render(t, testView())
+	if n := strings.Count(out, "nopreempt"); n != 2 {
+		t.Fatalf("erwarte nopreempt in VI_1 UND VI_HB (2×), gefunden: %d\n%s", n, out)
+	}
+	if strings.Contains(out, "state MASTER") {
+		t.Fatalf("kein Node darf state MASTER starten (nopreempt würde ignoriert):\n%s", out)
+	}
+	if c := strings.Count(out, "state BACKUP"); c != 2 {
+		t.Fatalf("erwarte state BACKUP in beiden Instanzen, gefunden: %d", c)
+	}
+}
+
+// GARP muss forciert + periodisch aufgefrischt werden, sonst altert die
+// VIP-MAC am Upstream-Switch und die Failover-IP wird unerreichbar.
+func TestTemplateGARPRefresh(t *testing.T) {
+	out := render(t, testView())
+	for _, want := range []string{"vrrp_garp_master_refresh", "vrrp_garp_master_repeat"} {
+		if !strings.Contains(out, want) {
+			t.Fatalf("global_defs sollte %q enthalten:\n%s", want, out)
+		}
+	}
+}
+
+// advert_int 2 (statt 1): Master-Down ~6s — reißt nicht bei kurzen
+// VM-/Heartbeat-Hiccups (Flapping-Schutz im virtualisierten Cluster).
+func TestTemplateAdvertInt(t *testing.T) {
+	out := render(t, testView())
+	if strings.Contains(out, "advert_int 1\n") {
+		t.Fatalf("advert_int sollte 2 sein (nicht 1):\n%s", out)
+	}
+	if c := strings.Count(out, "advert_int 2"); c != 2 {
+		t.Fatalf("erwarte advert_int 2 in beiden Instanzen, gefunden: %d", c)
+	}
+}
+
+// Track-Scripts dürfen KEIN weight haben: in einer vrrp_sync_group ignoriert
+// keepalived gewichtete Scripts → Health-Checks wären wirkungslos. Ohne weight
+// wirken sie als FAULT-Trigger.
+func TestTemplateTrackScriptsUnweighted(t *testing.T) {
+	out := render(t, testView())
+	if strings.Contains(out, "weight") {
+		t.Fatalf("Track-Scripts dürfen kein weight tragen (Sync-Group ignoriert sie sonst):\n%s", out)
+	}
+}
+
+// gw-Check darf nicht zu zucken (fall 5, nicht fall 2) — ein kurzer Upstream-
+// Blip soll keinen Failover erzwingen.
+func TestTemplateGatewayCheckNotTwitchy(t *testing.T) {
+	out := render(t, testView())
+	if !strings.Contains(out, "fall 5") {
+		t.Fatalf("chk_gateway sollte fall 5 nutzen:\n%s", out)
+	}
+}
+
+// buildView: State immer BACKUP, Priorität aus pg_role.
+func TestBuildViewStateAlwaysBackup(t *testing.T) {
+	g := &generator{localID: "n1"}
+	cs := &models.ClusterSettings{VRRPRouterID: 51}
+	pub := "89.163.205.6"
+	cases := []struct {
+		pgRole, role string
+		wantPrio     int
+	}{
+		{"primary", "primary", 200},
+		{"standby", "primary", 100},
+		{"", "primary", 200},
+		{"", "", 100},
+	}
+	for _, c := range cases {
+		local := &models.HANode{ID: "n1", PGRole: c.pgRole, Role: c.role, PublicIP: &pub}
+		v := g.buildView(cs, nil, local, nil)
+		if v.State != "BACKUP" {
+			t.Errorf("pg_role=%q role=%q: State=%q, erwarte immer BACKUP (nopreempt)", c.pgRole, c.role, v.State)
+		}
+		if v.Priority != c.wantPrio {
+			t.Errorf("pg_role=%q role=%q: Priority=%d, erwarte %d", c.pgRole, c.role, v.Priority, c.wantPrio)
+		}
+	}
+}
--- a/internal/models/domain.go
+++ b/internal/models/domain.go
@@ -19,6 +19,7 @@ type Domain struct {
 	MaxBodyKB          int       `gorm:"column:max_body_kb"          json:"max_body_kb"`
 	DisableH3          bool      `gorm:"column:disable_h3"           json:"disable_h3"`
 	Notes              *string   `gorm:"column:notes"                json:"notes,omitempty"`
+	RedirectTo         string    `gorm:"column:redirect_to"          json:"redirect_to"` // ""=aus; sonst 301-Ziel-URL (Domain→Domain)
 	CreatedAt          time.Time `gorm:"column:created_at"           json:"created_at"`
 	UpdatedAt          time.Time `gorm:"column:updated_at"           json:"updated_at"`
 }
--- a/internal/proxy/.gitkeep
+++ b/internal/proxy/.gitkeep
--- a/internal/services/audit/audit.go
+++ b/internal/services/audit/audit.go
@@ -258,9 +258,13 @@ func (r *Repo) Cleanup(ctx context.Context, keepDays int) (int64, error) {
 	if r == nil || r.Pool == nil || keepDays <= 0 {
 		return 0, nil
 	}
+	// make_interval(days => $1) nimmt $1 als int — sauber typisiert. Der frühere
+	// ($1::text || ' days')::interval-Ansatz scheiterte, weil keepDays als int
+	// übergeben wird und pgx int nicht als text (OID 25) encoden kann
+	// ("cannot find encode plan") → Cleanup lief nie.
 	tag, err := r.Pool.Exec(ctx, `
 DELETE FROM audit_log
-WHERE created_at < NOW() - ($1::text || ' days')::interval`, keepDays)
+WHERE created_at < NOW() - make_interval(days => $1)`, keepDays)
 	if err != nil {
 		return 0, err
 	}
--- a/internal/services/domains/domains.go
+++ b/internal/services/domains/domains.go
@@ -24,7 +24,7 @@ SELECT id, name, active, primary_backend_id, http_to_https,
       hsts_enabled, hsts_max_age, hsts_subdomains, hsts_preload,
       maintenance_mode, maintenance_message, www_redirect,
       rate_limit_rps, max_body_kb, disable_h3,
-       notes, created_at, updated_at
+       notes, redirect_to, created_at, updated_at
 FROM domains
 `

@@ -65,17 +65,17 @@ func (r *Repo) Create(ctx context.Context, d models.Domain) (*models.Domain, err
 INSERT INTO domains (name, active, primary_backend_id, http_to_https,
                     hsts_enabled, hsts_max_age, hsts_subdomains, hsts_preload,
                     maintenance_mode, maintenance_message, www_redirect,
-                     rate_limit_rps, max_body_kb, disable_h3, notes)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+                     rate_limit_rps, max_body_kb, disable_h3, notes, redirect_to)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
 RETURNING id, name, active, primary_backend_id, http_to_https,
          hsts_enabled, hsts_max_age, hsts_subdomains, hsts_preload,
          maintenance_mode, maintenance_message, www_redirect,
          rate_limit_rps, max_body_kb, disable_h3,
-          notes, created_at, updated_at`,
+          notes, redirect_to, created_at, updated_at`,
 		d.Name, d.Active, d.PrimaryBackendID, d.HTTPToHTTPS,
 		d.HSTSEnabled, d.HSTSMaxAge, d.HSTSSubdomains, d.HSTSPreload,
 		d.MaintenanceMode, d.MaintenanceMessage, d.WWWRedirect,
-		d.RateLimitRPS, d.MaxBodyKB, d.DisableH3, d.Notes)
+		d.RateLimitRPS, d.MaxBodyKB, d.DisableH3, d.Notes, d.RedirectTo)
 	return scanDomain(row)
 }

@@ -100,17 +100,18 @@ UPDATE domains SET
   max_body_kb = $13,
   disable_h3 = $14,
   notes = $15,
+   redirect_to = $16,
   updated_at = NOW()
-WHERE id = $16
+WHERE id = $17
 RETURNING id, name, active, primary_backend_id, http_to_https,
          hsts_enabled, hsts_max_age, hsts_subdomains, hsts_preload,
          maintenance_mode, maintenance_message, www_redirect,
          rate_limit_rps, max_body_kb, disable_h3,
-          notes, created_at, updated_at`,
+          notes, redirect_to, created_at, updated_at`,
 		d.Name, d.Active, d.PrimaryBackendID, d.HTTPToHTTPS,
 		d.HSTSEnabled, d.HSTSMaxAge, d.HSTSSubdomains, d.HSTSPreload,
 		d.MaintenanceMode, d.MaintenanceMessage, d.WWWRedirect,
-		d.RateLimitRPS, d.MaxBodyKB, d.DisableH3, d.Notes, id)
+		d.RateLimitRPS, d.MaxBodyKB, d.DisableH3, d.Notes, d.RedirectTo, id)
 	out, err := scanDomain(row)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
@@ -139,7 +140,7 @@ func scanDomain(row interface{ Scan(...any) error }) (*models.Domain, error) {
 		&d.HSTSEnabled, &d.HSTSMaxAge, &d.HSTSSubdomains, &d.HSTSPreload,
 		&d.MaintenanceMode, &d.MaintenanceMessage, &d.WWWRedirect,
 		&d.RateLimitRPS, &d.MaxBodyKB, &d.DisableH3,
-		&d.Notes, &d.CreatedAt, &d.UpdatedAt,
+		&d.Notes, &d.RedirectTo, &d.CreatedAt, &d.UpdatedAt,
 	); err != nil {
 		return nil, err
 	}
--- a/internal/services/ipaddresses/apply.go
+++ b/internal/services/ipaddresses/apply.go
@@ -40,11 +40,17 @@ func (g *Generator) render(ctx context.Context, excludeEthernet bool) error {
 		prefix int
 	}

+	// is_vip-Adressen werden NIE statisch gebunden — sie gehören
+	// ausschließlich keepalived (nur der VRRP-Master trägt die VIP). Würde
+	// der Apply sie statisch binden, läge die VIP nach einem Failover auf
+	// BEIDEN Nodes (statisch hier + keepalived drüben) → Duplicate-IP/ARP-
+	// Konflikt → Tunnel/LAN bricht. Deshalb hart ausschließen.
 	q := `
 		SELECT ni.name, ia.address, ia.prefix
 		FROM ip_addresses ia
 		JOIN network_interfaces ni ON ni.id = ia.interface_id
-		WHERE ia.active = true`
+		WHERE ia.active = true
+		  AND ia.is_vip = false`
 	if excludeEthernet {
 		q += `
 		  AND ni.type != 'ethernet'`
--- a/internal/wireguard/systemd.go
+++ b/internal/wireguard/systemd.go
@@ -1,15 +1,42 @@
 package wireguard

 import (
+	"bytes"
 	"fmt"
 	"os/exec"
 )

 // wg-quick is managed via systemd unit instances (wg-quick@<iface>).
-// Reload-via-syncconf would be cheaper (no link flap) but needs more
-// per-change diffing — for v1 we restart the unit, which takes ~1s
-// and re-establishes peers cleanly. The sudoers entry shipped in
-// postinst whitelists exactly these three commands.
+// Für ein BEREITS laufendes Interface werden Config-Änderungen per
+// `wg syncconf` LIVE angewendet (siehe syncWGQuick) — ohne Link-Flap,
+// damit bestehende Tunnel nie abreißen. Nur das erstmalige Hochfahren
+// (Interface noch nicht vorhanden) nutzt `systemctl start`. restart bleibt
+// als Fallback, falls syncconf nicht erlaubt/möglich ist. Die sudoers-
+// Einträge (postinst) whitelisten exakt diese Kommandos.
+
+// interfaceExists meldet ob das wg-Interface aktuell existiert (also von
+// wg-quick bereits hochgefahren wurde). `ip link show` braucht kein root.
+func interfaceExists(iface string) bool {
+	return exec.Command("/usr/bin/ip", "link", "show", iface).Run() == nil
+}
+
+// syncWGQuick wendet Config-Änderungen LIVE auf ein laufendes Interface an
+// (`wg syncconf`) — Peers werden hinzugefügt/entfernt/aktualisiert und der
+// Listen-Port gesetzt, OHNE den Tunnel abzureißen. `wg-quick strip` liefert
+// die reine wg-Config (ohne Address/MTU/Routes-Direktiven). Beides braucht
+// root (Config ist root:root 700) → sudo.
+func syncWGQuick(iface string) error {
+	stripped, err := exec.Command("sudo", "-n", "/usr/bin/wg-quick", "strip", iface).Output()
+	if err != nil {
+		return fmt.Errorf("wg-quick strip %s: %w", iface, err)
+	}
+	sync := exec.Command("sudo", "-n", "/usr/bin/wg", "syncconf", iface, "/dev/stdin")
+	sync.Stdin = bytes.NewReader(stripped)
+	if out, err := sync.CombinedOutput(); err != nil {
+		return fmt.Errorf("wg syncconf %s: %w: %s", iface, err, string(out))
+	}
+	return nil
+}

 func startWGQuick(iface string) error {
 	cmd := exec.Command("sudo", "-n", "/usr/bin/systemctl", "start", "wg-quick@"+iface+".service")
--- a/internal/wireguard/wireguard.go
+++ b/internal/wireguard/wireguard.go
@@ -12,6 +12,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"path/filepath"
 	"sort"
@@ -254,9 +255,24 @@ func (g *Generator) renderIface(ctx context.Context, ifc models.WireguardInterfa
 		return fmt.Errorf("symlink: %w", err)
 	}
 	_ = enableWGQuick(ifc.Name)
-	if !changed {
-		return startWGQuick(ifc.Name)
+
+	// Läuft das Interface schon, werden Änderungen LIVE per `wg syncconf`
+	// angewendet — KEIN Tunnel-Abbruch (WireGuard darf nie abreißen). Nur
+	// das erstmalige Hochfahren nutzt `systemctl start`.
+	if interfaceExists(ifc.Name) {
+		if !changed {
+			return nil // läuft + Config unverändert → nichts zu tun
+		}
+		if err := syncWGQuick(ifc.Name); err != nil {
+			// Fallback (z. B. sudoers noch ohne syncconf): voller Neustart.
+			// Bricht den Tunnel kurz ab — nur Notnagel.
+			slog.Warn("wireguard: wg syncconf fehlgeschlagen, Fallback auf restart (kurzer Tunnel-Flap)",
+				"iface", ifc.Name, "error", err)
+			return restartWGQuick(ifc.Name)
+		}
+		return nil
 	}
-	return restartWGQuick(ifc.Name)
+	// Interface noch nicht oben → erstmalig hochfahren.
+	return startWGQuick(ifc.Name)
 }

--- a/management-ui/src/i18n/locales/de/common.json
+++ b/management-ui/src/i18n/locales/de/common.json
@@ -533,6 +533,8 @@
    "wwwRedirectNone": "Kein Redirect",
    "wwwRedirectToNaked": "→ naked (ohne www)",
    "wwwRedirectToWWW": "→ www",
+    "redirectTo": "Weiterleitung (301) nach",
+    "redirectToHint": "Leitet ALLE Anfragen dieser Domain per 301 auf die Ziel-URL um (z. B. https://zkm.netcell-it.de) — immer auf die Ziel-Root. Ist es gesetzt, routet die Domain auf kein Backend. Die Domain braucht trotzdem ein eigenes TLS-Zertifikat. Leer = aus.",
    "rateLimit": "Rate-Limit (pro Client-IP)",
    "rateLimitHint": "Max. Requests pro Sekunde je Client-IP. HAProxy zählt über ein 10-Sekunden-Fenster pro Stick-Table (max. 100k IPs). 0 = aus.",
    "maxBody": "Max. Request-Body",
--- a/management-ui/src/i18n/locales/en/common.json
+++ b/management-ui/src/i18n/locales/en/common.json
@@ -533,6 +533,8 @@
    "wwwRedirectNone": "No redirect",
    "wwwRedirectToNaked": "→ naked (no www)",
    "wwwRedirectToWWW": "→ www",
+    "redirectTo": "Redirect (301) to",
+    "redirectToHint": "Redirects ALL requests for this domain with a 301 to the target URL (e.g. https://zkm.netcell-it.de) — always to the target root. When set, the domain routes to no backend. The domain still needs its own TLS certificate. Empty = off.",
    "rateLimit": "Rate limit (per client IP)",
    "rateLimitHint": "Max requests per second per client IP. HAProxy counts over a 10-second window per stick table (max. 100k IPs). 0 = off.",
    "maxBody": "Max request body",
--- a/management-ui/src/pages/Domains/Detail.tsx
+++ b/management-ui/src/pages/Domains/Detail.tsx
@@ -27,6 +27,7 @@ interface Domain {
  hsts_subdomains: boolean; hsts_preload: boolean
  maintenance_mode: boolean; maintenance_message?: string | null
  www_redirect: '' | 'to-naked' | 'to-www'
+  redirect_to: string
  rate_limit_rps: number; max_body_kb: number
  disable_h3: boolean
  notes?: string | null
@@ -40,6 +41,7 @@ interface DomainFormValues {
  hsts_subdomains: boolean; hsts_preload: boolean
  maintenance_mode: boolean; maintenance_message?: string
  www_redirect: '' | 'to-naked' | 'to-www'
+  redirect_to: string
  rate_limit_rps: number; max_body_kb: number
  disable_h3: boolean
  notes?: string
@@ -272,6 +274,7 @@ export default function DomainDetailPage() {
                maintenance_mode: domain.maintenance_mode,
                maintenance_message: domain.maintenance_message ?? '',
                www_redirect: domain.www_redirect ?? '',
+                redirect_to: domain.redirect_to ?? '',
                rate_limit_rps: domain.rate_limit_rps ?? 0,
                max_body_kb: domain.max_body_kb ?? 0,
                disable_h3: domain.disable_h3 ?? false,
@@ -333,6 +336,10 @@ export default function DomainDetailPage() {
                ]} />
              </Form.Item>

+              <Form.Item label={t('domains.redirectTo')} name="redirect_to" extra={t('domains.redirectToHint')}>
+                <Input placeholder="https://ziel-domain.de" allowClear />
+              </Form.Item>
+
              <Form.Item label={t('domains.maintenance')} name="maintenance_mode" valuePropName="checked"
                extra={t('domains.maintenanceHint')}>
                <Switch />
--- a/packaging/debian/edgeguard-api/DEBIAN/postinst
+++ b/packaging/debian/edgeguard-api/DEBIAN/postinst
@@ -111,6 +111,9 @@ edgeguard ALL=(root) NOPASSWD: /bin/systemctl enable wg-quick@*.service
 edgeguard ALL=(root) NOPASSWD: /bin/systemctl disable wg-quick@*.service
 edgeguard ALL=(root) NOPASSWD: /usr/bin/wg show all dump
 edgeguard ALL=(root) NOPASSWD: /usr/bin/wg show *
+# WireGuard Live-Reload ohne Tunnel-Abbruch: wg syncconf + wg-quick strip
+edgeguard ALL=(root) NOPASSWD: /usr/bin/wg syncconf *
+edgeguard ALL=(root) NOPASSWD: /usr/bin/wg-quick strip *
 # WireGuard symlink: /etc/wireguard/ ist root:root 700; edgeguard-api
 # legt Symlinks an damit wg-quick@<iface> die Configs findet.
 edgeguard ALL=(root) NOPASSWD: /bin/ln -sf /etc/edgeguard/wireguard/* /etc/wireguard/*
@@ -842,6 +845,25 @@ EOSQL
        # atomic-write (tempfile → rename) durchführen kann.
        install -d -m 0755 /etc/keepalived
        chown "$EG_USER":"$EG_USER" /etc/keepalived
+        # ── keepalived systemd drop-in: Boot-Race-Fix ──────────────────
+        # keepalived referenziert VIP-Devices (vlanXXX), die erst von
+        # edgeguard-interfaces.service angelegt werden. Ohne Ordering startet
+        # keepalived vor den VLANs (beide nur After=network-online.target) →
+        # "interface vlanX doesn't exist" → permanenter CONFIG-Crash OHNE
+        # Auto-Recovery (keepalived bleibt nach Reboot tot). After=/Wants=
+        # wartet auf die Interfaces; Restart=on-failure ist das Sicherheitsnetz.
+        install -d /etc/systemd/system/keepalived.service.d
+        cat > /etc/systemd/system/keepalived.service.d/10-edgeguard.conf <<'KEEPALIVEDDROPIN'
+[Unit]
+After=edgeguard-interfaces.service
+Wants=edgeguard-interfaces.service
+StartLimitIntervalSec=0
+
+[Service]
+Restart=on-failure
+RestartSec=3
+KEEPALIVEDDROPIN
+        systemctl daemon-reload
        sudo -n -u "$EG_USER" /usr/bin/edgeguard-ctl render-config --only=keepalived || true
        if [ -f /etc/keepalived/keepalived.conf ]; then
            systemctl enable keepalived >/dev/null 2>&1 || true
--- a/packaging/scripts/keepalived-master.sh
+++ b/packaging/scripts/keepalived-master.sh
@@ -7,6 +7,21 @@
 logger -t keepalived -p daemon.warning \
    "MASTER: VIP übernommen — PG-Rolle ist noch '$(cat /var/lib/edgeguard/pg_role 2>/dev/null || echo standby)'. Für PG-Failover: edgeguard-ctl promote"

+# ── Upstream-ARP/Routing für die Failover-VIP(s) aktualisieren ──
+# Manche Hoster lernen die neue MAC einer Failover-IP NICHT zuverlässig über
+# Gratuitous-ARP, sondern erst, wenn sie Traffic VON der IP sehen. Ohne das ist
+# die VIP nach einem Schwenk von außen unerreichbar. Wir pingen daher den
+# Default-Gateway aus jeder Public-IP (inkl. VIP) an (source via -I), damit der
+# Upstream die MAC sofort umlernt. Hintergrund-Pings, damit notify nicht blockt.
+WAN_DEV="$(ip -4 route show default 2>/dev/null | awk '{for(i=1;i<=NF;i++) if($i=="dev"){print $(i+1); exit}}')"
+WAN_GW="$(ip -4 route show default 2>/dev/null | awk '{for(i=1;i<=NF;i++) if($i=="via"){print $(i+1); exit}}')"
+if [ -n "$WAN_DEV" ] && [ -n "$WAN_GW" ]; then
+    for vip in $(ip -4 -o addr show dev "$WAN_DEV" scope global 2>/dev/null | awk '{print $4}' | cut -d/ -f1); do
+        ping -I "$vip" -c 3 -W 1 "$WAN_GW" >/dev/null 2>&1 &
+    done
+    logger -t keepalived -p daemon.info "MASTER: Upstream-ARP via Ping aus VIP(s) auf $WAN_GW ($WAN_DEV) angestoßen"
+fi
+
 # Dienste reloaden/starten damit sie die neu aktiven VIPs binden.
 # Squid + Unbound + HAProxy binden beim Start an spezifische IPs — war der Dienst
 # während des BACKUP-Zustands gecrasht oder gestoppt, muss er gestartet werden.
Author	SHA1	Message	Date
Debian	d15774f1cd	fix(security): x/crypto v0.52 + x/net v0.55 (6 CVEs) + govulncheck-Release-Gate — v1.3.1 govulncheck ab sofort fest im Release-Prozess. Baseline-Scan fand 6 aktiv aufgerufene Vulns (SSH-Backup-Pfad internal/services/backup/remote): - 5× golang.org/x/crypto (SSH DoS/Deadlock/Panic: GO-2026-5013/5017/5018/5019/5020) → x/crypto v0.51.0 => v0.52.0 - 1× golang.org/x/net (GO-2026-5026) → v0.53.0 => v0.55.0 Re-Scan danach: "No vulnerabilities found." Go-Quality-Baseline (Makefile + .golangci.yml, portabel): - release-check läuft autom. vor jedem deb/publish: vet → golangci-lint (Rollout: non-blocking) → govulncheck (HARTER Gate) → build → test -race. - make vulncheck / make test-race als eigene Targets. - .golangci.yml: staticcheck/govet/errcheck/ineffassign/unused/misspell + gosec/bodyclose/rowserrcheck/sqlclosecheck/noctx/contextcheck. - go test -race: aktuell 0 Races (Gate sicher). Doku in CLAUDE.md. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-05 22:34:25 +02:00
Debian	4c1e0e9926	chore(go): go.mod go-Direktive auf 1.26.4 nachgezogen Build-Host-Toolchain ist go1.26.4; go.mod stand noch auf 1.26.0. Direktive nachgezogen — Binaries wurden (GOTOOLCHAIN=auto, lokal>=Direktive) ohnehin schon mit 1.26.4 gebaut, daher kein Binary-/Runtime-Change, kein Redeploy nötig. go build/vet/test mit 1.26.4 grün. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-04 01:03:56 +02:00
Debian	2495bf022b	fix(scheduler): Audit-Cleanup lief nie (int-als-text Encode-Fehler) — v1.3.0 Der tägliche audit_log-Cleanup (cmd/edgeguard-scheduler) schlug auf beiden Nodes jeden Tag fehl: "audit cleanup failed" keep_days=90 error: unable to encode 90 into text format for text (OID 25): cannot find encode plan Ursache: audit.go nutzte `($1::text \|\| ' days')::interval`, übergab keepDays aber als int → pgx kann int nicht als text (OID 25) encoden. Folge: Cleanup lief nie, tägliches WARN-Rauschen + langfristig unbegrenztes audit_log-Wachstum (Einträge >keep_days wurden nie gelöscht). Fix: `NOW() - make_interval(days => $1)` — $1 bleibt sauber int-typisiert. Gegen Live-DB validiert (gültige Syntax, 0 betroffene Rows aktuell). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 11:30:12 +02:00
Debian	25ec98161f	fix(chrony): kein Multi-bindaddress — NTP-Server bediente nur eine VIP — v1.2.109 chrony honoriert nur EINE bindaddress pro Adressfamilie. Der Generator emittierte aber eine bindaddress PRO Listen-IP (mehrere VLAN-/Cluster-VIPs) → chrony band nur die letzte (10.0.50.1), alle anderen Clients (z. B. auf 10.0.5.1) erreichten den NTP-Server NICHT. Ein Restart hilft nicht (Config-Bug, nicht stale binding). Fix: chrony.cfg.tpl emittiert KEIN bindaddress mehr → bind-all; WER bedient wird, regeln die allow-ACL + die nftables-Regeln (UDP/123 nur auf den Listen-IPs/VIPs offen, nicht öffentlich). Zugleich failover-robust: chrony bedient automatisch jede VIP, die der Node gerade hält, ohne Restart bei Master-Wechsel. Test: internal/chrony/chrony_test.go (kein bindaddress, allow vorhanden; port 0 bei serve_clients=false). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-18 15:46:17 +02:00
Debian	79cd68e460	feat(domains): 301-Weiterleitung Domain→Domain (redirect_to) — v1.2.108 Neue Domain kann per 301 auf eine andere Domain/URL umgeleitet werden, statt auf ein Backend zu routen (Use-Case: kvs.netcell-it.de → https://zkm.netcell-it.de, inkl. HTTPS). Variante (a): immer auf Ziel-Root (`redirect location`), pfad- unabhängig. - Migration 0043: domains.redirect_to text NOT NULL DEFAULT '' - Model + domains-Service (SELECT/INSERT/UPDATE/scan) - HAProxy-Generator: buildRedirectTo() sanitisiert (nur http(s), kein Whitespace/Quotes → sonst kein Redirect statt kaputter Config); Template emittiert `http-request redirect location <url> code 301 if hdr(host)`. Terminiert vor use_backend → Redirect-Domain routet auf kein Backend. http→https läuft über den vorhandenen :80-Redirect (zwei Hops, inkl. TLS). - UI: Feld „Weiterleitung (301) nach" im Domain-Formular (de/en) - Tests: Render-Zeile + buildRedirectTo-Sanitisierung Hinweis: Die Redirect-Domain braucht weiterhin ein eigenes TLS-Zert (ACME). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-15 19:23:37 +02:00
Debian	f3c76f6d18	fix(cluster): selbstheilende public_ip + advert_int 2 (Flapping) — v1.2.107 Zwei keepalived-Flapping-Restursachen: 1) Strukturell: der Cluster-Push (autoRegister, Primary→Secondary) trägt KEINE public_ip → der Empfänger AgentRegisterPeer ließ sie NULL → Peer fehlte im nft-peer_ipv4-Set → VRRP-Adverts (eth0/VI_1) nur via conntrack → Flapping. (utm-1 lernte utm-2 korrekt via Joiner-Client-IP in preRegisterJoiner; die Gegenrichtung fehlte.) Fix: AgentRegisterPeer fällt bei leerem req.PublicIP auf die mTLS-Client-IP (c.ClientIP()) zurück — die EIGEN-IP des Peers, nicht die VIP. Selbstheilend, überlebt Re-Joins/Failover. 2) advert_int 1 → 2 (Master-Down ~6s statt ~3s): reißt nicht mehr bei kurzen VM-/Heartbeat-Hiccups (VI_HB). Trade-off: Failover-Erkennung ~6s. Tests: advert_int 2 im Render. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-12 13:42:21 +02:00
Debian	b2fc7b7dee	fix(cluster): chk_edgeguard fall 3→8 — Upgrade-Restart triggert keinen Failover — v1.2.106 Seit v1.2.105 (Track-Scripts ohne weight = FAULT-Trigger) löste jeder edgeguard-api-Restart beim Deploy einen Failover aus (kurze Health-Check-Fehler während Stop/Render/Restart reichten bei fall 3 = 6s). fall 8 (16s) lässt einen normalen Upgrade-Restart durchrutschen; ein echter API-Tod schwenkt weiter in 16s. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-07 19:14:08 +02:00
Debian	9b563baaa1	fix(cluster): keepalived Track-Scripts ohne weight (Sync-Group) — v1.2.105 `keepalived -t` zeigte "ignoring tracked script chk_edgeguard/chk_gateway with weights due to SYNC group": gewichtete Track-Scripts werden in einer vrrp_sync_group ignoriert → Health-Check-Failover (Gateway weg / API tot) griff NICHT. Fix: weight entfernt → Scripts wirken als binäre FAULT-Trigger (fall-mal Fehler → Instanz+Sync-Group FAULT → gesunder Peer übernimmt). Für 2-Node-Cluster die korrekte Semantik. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-07 19:07:24 +02:00
Debian	d8b8fef680	fix(cluster): keepalived 2.3.x lehnt vrrp_garp_interval 0 ab — entfernt — v1.2.104 v1.2.103 hatte vrrp_garp_interval 0 / vrrp_gna_interval 0 aus dem Legacy-Template übernommen. keepalived 2.3.3 lehnt 0 ab (Range [0.000001, …]) → "invalid", `keepalived -t` schlägt fehl (keepalived ignoriert sie zwar mit Warnung und läuft, aber latentes Risiko bei striktem Start). Entfernt — Default passt. Die wirksame Anti-Aging-Direktive vrrp_garp_master_refresh 60 + master_repeat 5 bleiben. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-07 19:02:02 +02:00
Debian	fd8125247c	fix(cluster): VIP-Failover am Upstream zuverlässig — GARP + Priming-Ping — v1.2.103 Nach v1.2.102 (VIP nicht mehr statisch gebunden) wandert die Public-VIP .100 erstmals wirklich per keepalived zwischen den Node-MACs. Der Hosting-Upstream lernte die neue MAC aber nicht zuverlässig → .100 nach Schwenk von außen unerreichbar (vorher maskiert, weil .100 statisch dauerhaft auf utm-1 lag). Zwei Mechanismen ergänzt: 1) keepalived.conf.tpl global_defs: vrrp_garp_master_repeat 5 + vrrp_garp_master_refresh 60 (+ vrrp_garp_interval/gna 0, aus Legacy-Template verloren gegangen) → forciertes GARP beim Wechsel + periodische Auffrischung, damit die VIP-MAC am Switch nicht altert. 2) keepalived-master.sh: neuer Master pingt den Default-Gateway aus jeder Public-IP/VIP an (ping -I <vip>) → Upstream sieht Traffic VON der VIP und lernt die MAC sofort. Manche Hoster relearnen nur so, nicht via GARP. Test: keepalived_test.go prüft GARP-Direktiven im Render. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-07 18:56:32 +02:00
Debian	7b6409b631	fix(cluster): VIPs nie statisch binden — Duplicate-IP-Kernbug — v1.2.102 Ergänzt v1.2.101: der ip-addresses-Apply (internal/services/ipaddresses/ apply.go) band ALLE aktiven Adressen statisch — inkl. is_vip. RenderSecondary (das eth0 ausschließt) ist toter Code, wird nie aufgerufen. Folge: die VIP (89.163.205.100 + VLAN-Gateways 10.0.x.1) lag auf dem Node statisch gebunden, UNABHÄNGIG von keepalived. Sobald keepalived die VIP per Failover auf den Peer legte, lag sie auf BEIDEN Nodes → Duplicate-IP/ARP- Konflikt → UniFi-Tunnel/LAN bricht (erklärt „utm-1 stoppen → sofort stabil": der Konflikt verschwindet, nicht VRRP-Failover). Fix: Render-Query schließt is_vip hart aus (AND ia.is_vip = false) → VIPs gehören ausschließlich keepalived (nur der VRRP-Master trägt sie). Gilt für beide Render-Pfade. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-07 18:09:17 +02:00
Debian	a2450a759c	fix(cluster): keepalived Split-Brain + Boot-Race behoben — v1.2.101 Ursache der „WireGuard reißt immer wieder ab"-Abrisse war NICHT die UniFi, sondern keepalived-Flapping im HA-Cluster: die VIP 89.163.205.100 (an der die UniFi-Site-to-Site hängt) wanderte bei ~17 VRRP-Wahlen/Tag zwischen utm-1/utm-2 → Tunnel-Abriss bei jeder Wahl. Drei Bugs: 1) Firewall ließ VRRP (IP-Proto 112) zwischen den Cluster-Peers NICHT zu (policy drop). Adverts überlebten nur via conntrack-Reverse-Matching → bei conntrack-Ablauf gedroppt → Peer promotet sich → Split-Brain. Fix: ruleset.nft.tpl erlaubt `ip/ip6 ... vrrp saddr @peer_ipv4/6`; firewall.go nimmt zusätzlich hb_src_ip/hb_peer_ip aus cluster_settings ins Peer-Set (deckt den Heartbeat-Pfad 169.254.0.x ab). 2) Kein nopreempt → erholter Node riss die VIP sofort zurück (Flap-Back); aggressiver gw-Check (fall 2 → 10s-Blip = Failover). Fix: keepalived.conf.tpl mit `nopreempt` in VI_1+VI_HB, chk_gateway fall 2→5; keepalived.go setzt State immer BACKUP (nopreempt wirkt nur in BACKUP), Priorität 200/100 aus pg_role bleibt → deckt sich mit „manuelles Promote". 3) keepalived-Boot-Race: Unit startete vor vlan500 (nur After=network-online) → „interface vlan500 doesn't exist" → permanenter CONFIG-Crash ohne Recovery (keepalived nach Reboot tot). Fix: postinst legt Drop-in mit After=/Wants=edgeguard-interfaces.service + Restart=on-failure an. Neuer Test internal/keepalived/keepalived_test.go (nopreempt/BACKUP/fall). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-07 17:49:04 +02:00
Debian	91e51890dd	fix(wireguard): Tunnel reißt nie ab + Client-Endpoint auto-befüllt — v1.2.100 Zwei Bugs, die WireGuard-Verbindungen verhinderten/abrissen: 1) Client-Config-Endpoint war hartkodierter Platzhalter REPLACE_WITH_PUBLIC_HOST → neue Clients bauten nie einen Tunnel auf (Host löst nicht auf). Jetzt: WireguardHandler.PublicHost (aus setup.json FQDN, main.go) → Endpoint = <fqdn>:<port>. Platzhalter nur noch als Fallback wenn FQDN unbekannt. 2) Renderer machte bei JEDER Config-Änderung 'systemctl restart wg-quick@<iface>' → voller Link-Flap, alle Peers droppen (verstößt gegen 'wireguard darf nie abbrechen'). Jetzt: laufendes Interface → 'wg-quick strip \| wg syncconf' (Peers/Listen-Port live, KEIN Abbruch); nur erstmaliges Hochfahren via systemctl start; restart nur noch als Fallback mit WARN. interfaceExists() via 'ip link show'. Neue sudoers: wg syncconf , wg-quick strip . Ein edgeguard-api-Restart (Deploy) fasst wg-quick@<iface> nicht an → Tunnel bleibt während Deploy bestehen. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-06 20:51:52 +02:00
Debian	7611572062	refactor(cluster): promote auf Logical-Replication umgestellt + internal/proxy-Stub entfernt — v1.2.99 Code-Altlasten aus dem Architektur-Audit bereinigt: - internal/proxy: leerer .gitkeep-Stub (geplanter Write-Proxy nie implementiert) entfernt — keine Go-Referenzen. - promote.go: war reines Physical-Replication-Failover (standby.signal + pg_ctlcluster promote + pg_is_in_recovery) und damit auf dem Logical-Setup TOT (ein Subscriber hat kein standby.signal / ist nie in recovery → Abbruch bei Schritt 1). Neu Logical-aware: Idempotenz-Check (schon Publisher ohne Subscription → fertig) → Subscription lösen (DISABLE+slot_name=NONE+DROP, hängt nicht am toten Publisher) → setupReplicationPrimary (Publisher werden) → ha_nodes.pg_role=primary → keepalived MASTER. Toter KeyDB-Update (cluster:pg-primary-url, wurde nie gelesen) entfernt. - setupReplicationPrimary + dropSubscriptionIfExists aus cluster-init-replication/cluster-setup-standby extrahiert (DRY, bewährte SQL wiederverwendet). WICHTIG: setupReplicationPrimary stellt jetzt sicher dass wal_level=logical AKTIV ist — PG-RESTART falls nötig (reload reicht für wal_level/max_wal_senders nicht; Secondary hat wal_level=replica). Idempotent: Restart nur wenn wal_level != logical. - Doku (CLAUDE.md + architecture.md) auf den bereinigten Stand gezogen. Hinweis: echtes Cross-Node-Failover ist nur im Drill testbar; Build/vet/Tests grün, Bausteine sind die bereits produktiv genutzten SQL-Primitive. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-06 18:26:52 +02:00
Debian	3b5bf578a0	docs(architecture): Cluster/HA-Abschnitte an Ist-Stand angeglichen (code-verifiziert) architecture.md war Entwurfsstand; Cluster/HA wich stark vom Code ab. Per 5 parallelen Code-Audits verifiziert + korrigiert: - Replikation: Streaming/physisch → LOGICAL (edgeguard_shared/edgeguard_sub, wal_level=logical, copy_data=true); localOnlyTables dokumentiert; pg_basebackup nur Legacy. - VIP/Ingress (§9): 'Floating-IP statt VRRP' war invertiert → real keepalived/VRRP (prio aus pg_role, VIPs aus ip_addresses); kein Hoster-API/promote-this-node. - KeyDB (§7): Active-Active-State-Layer NICHT umgesetzt (kein Redis-Client in go.mod); Cluster-State/Heartbeat/Locks in PostgreSQL; KeyDB optional (Recommends). license-leader/acme:lock/cluster:nodes = nur Kommentare. - Write-Path: internal/proxy ist leerer Stub; kein Write-Proxy → Writes am Primary. - Plattform: nur Debian 13 trixie (Pipeline), Ubuntu/noble nicht implementiert. - §1/§5/§8 + Strukturbaum/Depends/Units an reale Renderer (keepalived/chrony/kea/freeradius/crowdsec/waf) angeglichen. Offene Punkte: Code-Altlasten (proxy-Stub, standby.signal in promote.go). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-06 17:46:56 +02:00
Debian	bf211ca273	docs: Feature-Stand nachgezogen — WAF/IDS-IPS/DHCP/RADIUS/OIDC/2FA umgesetzt CLAUDE.md + architecture.md spiegelten noch den ursprünglichen v1-Scope (WAF/IDS/IPS/DHCP/RADIUS als Nicht-Ziele) wider. Real umgesetzt: WAF (Coraza+SPOE), IDS/IPS (CrowdSec, managed-wenn-installiert), DHCP (Kea), RADIUS (FreeRADIUS), OIDC-SSO, 2FA, IPv6-FW. Nicht-Ziele bereinigt (verbleibend: Suricata-Network-IDS, Docker, Mail, Multi-Tenant, ISO, Debian-only). Stack-Tabelle + Paket-Tabelle/Depends an control angeglichen; edgeguard-waf als Binary im edgeguard-api-Paket dokumentiert. KeyDB als optional (Recommends) korrigiert; Cluster-Primary-Ermittlung via pg_publication/setup.json statt KeyDB; Doku-Drift internal/proxy (nicht vorhanden) markiert. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-06 17:34:10 +02:00
Debian	becd068637	fix(ui): freeradius + kea-dhcp4 in Service-Status-Grid aufnehmen — v1.2.98 Das Dashboard-Service-Grid (servicesToCheck in system.go) listete weder freeradius (RADIUS, v1.2.93) noch kea-dhcp4-server (DHCP, v1.2.92). Beide sind via Depends installiert + default-disabled → erscheinen jetzt als 'Inaktiv' bis aktiviert. systemctl show liefert für disabled Units sauber inactive, kein Fehler. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-06 17:05:01 +02:00
@@ -1 +1 @@
 .2.97
 .3.1