edgeguard-native/internal/cluster/confighash.go

package cluster

// Config-Hash berechnet einen deterministischen SHA-256-Hash über alle
// replizierbaren Tabellen — die Grundlage des "Config-Drift"-Banners
// im Cluster-UI. Pattern 1:1 aus mail-gateway/internal/handlers/
// cluster_status.go (driftHashSpec).
//
// Hash-Bildung pro Tabelle:
//   - SELECT md5((to_jsonb(t) - 'id' - 'updated_at' - 'created_at' -
//                <extra-excludes>)::text) AS rh
//                FROM <table> t
//   - SELECT md5(string_agg(rh, '|' ORDER BY rh)) → table-hash
//   - Singleton-Tabellen (mail_config-Stil) hashen die row direkt
//     ohne string_agg.
//
// Outer-Hash: SHA-256 über concat(table-name, 0x00, table-hash, 0x00)
// für jede spec-Tabelle in stabiler Reihenfolge, dann Hex + truncate
// auf 16 chars. 16 hex = 64 bit Entropie reichen für drift-Detection;
// längere Strings frühstückt das UI nur unnötig.
//
// Replizierbar = wird per goose-Migration auf beiden Cluster-Nodes
// gleich angelegt UND vom Operator über die UI mutiert. NICHT drin:
// audit_log (transient log), ha_nodes (cluster-state selbst), licenses
// (per-node), backups (per-node).

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"strings"

	"github.com/jackc/pgx/v5/pgxpool"
)

// hashTable beschreibt eine Tabelle die in den config-hash einfließt.
type hashTable struct {
	Name             string
	Singleton        bool     // dns_settings, ntp_settings → eine row, id=1
	ExtraExclude     []string // Spalten die zusätzlich aus to_jsonb gefiltert werden
	SkipUpdatedAt    bool     // setze true wenn updated_at semantisch relevant ist
	MigrationDefault bool     // Tabelle hat migrations-erzeugte Default-Rows (firewall_zones, ntp_pools…)
	                          // → zählt nicht als "user hat config" bei der Empty-DB-Erkennung
	CustomSQL        string   // wenn gesetzt: direkt als Hash-Query verwenden (überschreibt hashSQL)
}

// hashSpec ist die Reihenfolge-stabile Liste. NEUE Tabellen hier
// ergänzen wenn sie repliziert werden sollen — sonst flackert das
// Drift-Banner.
var hashSpec = []hashTable{
	{Name: "domains"},
	{Name: "backends"},
	{Name: "backend_servers"},
	{Name: "routing_rules"},
	{Name: "tls_certs", ExtraExclude: []string{"last_renewed_at", "last_error"}},

	{Name: "firewall_zones", MigrationDefault: true},
	{Name: "firewall_address_objects"},
	{Name: "firewall_address_groups"},
	{Name: "firewall_services", MigrationDefault: true},
	{Name: "firewall_service_groups", MigrationDefault: true},
	{Name: "firewall_rules"},
	{Name: "firewall_nat_rules"},

	{Name: "wireguard_interfaces"},
	{Name: "wireguard_peers"},
	{Name: "forward_proxy_acls"},

	{Name: "dns_zones"},
	{Name: "dns_records"},

	{Name: "ntp_pools", MigrationDefault: true},

	// network_interfaces + ip_addresses werden seit 0030 repliziert —
	// VLAN/Bridge/Bond-Definitionen und Gateway-IPs müssen auf dem Secondary
	// für Failover bereitstehen. Ethernet-IPs werden im Secondary-Renderer
	// herausgefiltert (eth0 = cloud-init / Keepalived).
	//
	// ip_addresses.interface_id ist ein node-lokaler Autoincrement-PK, der
	// zwischen zwei unabhängigen DBs divergiert (utm-1: eth0=6, utm-2: eth0=1).
	// Wir hashen daher semantisch: address + prefix + flags + interface_name
	// statt interface_id — sonst False-Positive-Drift auf logisch identischen Nodes.
	{Name: "network_interfaces"},
	{Name: "ip_addresses", CustomSQL: `
		SELECT COALESCE(md5(string_agg(rh, '|' ORDER BY rh)), '')
		FROM (
		  SELECT md5(jsonb_build_object(
		    'address',       ia.address,
		    'prefix',        ia.prefix,
		    'is_vip',        ia.is_vip,
		    'active',        ia.active,
		    'vip_priority',  ia.vip_priority,
		    'description',   ia.description,
		    'iface',         ni.name
		  )::text) AS rh
		  FROM ip_addresses ia
		  JOIN network_interfaces ni ON ia.interface_id = ni.id
		) sub`},

	// static_routes, dns_settings, ntp_settings bleiben node-spezifisch.
}

// hashSQL rendert die SHA-Input-SQL für eine Tabelle.
func hashSQL(t hashTable) string {
	excl := []string{"'id'"}
	if !t.SkipUpdatedAt {
		excl = append(excl, "'updated_at'")
	}
	excl = append(excl, "'created_at'")
	for _, c := range t.ExtraExclude {
		excl = append(excl, "'"+c+"'")
	}
	subtract := strings.Join(excl, " - ")
	if t.Singleton {
		return `SELECT COALESCE(md5((to_jsonb(t) - ` + subtract + `)::text), '')
		        FROM ` + t.Name + ` t WHERE id = 1`
	}
	return `SELECT COALESCE(md5(string_agg(rh, '|' ORDER BY rh)), '')
	        FROM (
	          SELECT md5((to_jsonb(t) - ` + subtract + `)::text) AS rh
	          FROM ` + t.Name + ` t
	        ) sub`
}

// ComputeConfigHash gibt den 16-hex-char-Hash über alle Spec-Tabellen
// zurück. Fehlende Tabellen (transienter schema-flux) werden als
// leerer Per-Table-Hash behandelt — kein Abbruch.
//
// Gibt "" zurück wenn alle user-konfigurierbaren Tabellen leer sind
// (Singleton- und MigrationDefault-Tabellen zählen nicht als User-Config).
// Das verhindert False-Positive-Drift-Banner auf frisch gejointen Secondaries.
func ComputeConfigHash(ctx context.Context, pool *pgxpool.Pool) (string, error) {
	if pool == nil {
		return "", fmt.Errorf("nil pool")
	}
	h := sha256.New()
	hasUserConfig := false
	for _, t := range hashSpec {
		var s string
		sql := t.CustomSQL
		if sql == "" {
			sql = hashSQL(t)
		}
		if err := pool.QueryRow(ctx, sql).Scan(&s); err != nil {
			// Migration fehlt o.ä. → leeren string nehmen, weiter.
			s = ""
		}
		if s != "" && !t.Singleton && !t.MigrationDefault {
			hasUserConfig = true
		}
		h.Write([]byte(t.Name))
		h.Write([]byte{0})
		h.Write([]byte(s))
		h.Write([]byte{0})
	}
	if !hasUserConfig {
		// Frisch gejoincter Secondary oder komplett leere DB →
		// leerer String signalisiert "kein Drift prüfen" im Status-Handler.
		return "", nil
	}
	return hex.EncodeToString(h.Sum(nil))[:16], nil
}

// RefreshLocalHash berechnet den Hash und schreibt ihn in die eigene
// ha_nodes-Row. Idempotent. Verwendet vom Scheduler + Cluster-Status-
// Handler (on-demand).
func RefreshLocalHash(ctx context.Context, pool *pgxpool.Pool, localID string) (string, error) {
	if pool == nil || localID == "" {
		return "", nil
	}
	hash, err := ComputeConfigHash(ctx, pool)
	if err != nil {
		return "", err
	}
	_, err = pool.Exec(ctx, `
UPDATE ha_nodes SET config_hash = $1, updated_at = NOW() WHERE id = $2`,
		hash, localID)
	return hash, err
}