IAM-15: timing-safe-vergleich-als-projektweite-coding-konvention (internal/timingsafe, coding-guideline, audit bestehender vergleichsstellen)

DEVLOG: Sessionlog-Eintrag (Auto-Hook)
IAM-04: zwei-faktor-authentifizierung-totp
2026-08-28 22:56:23 +02:00 · 2026-08-28 22:54:02 +02:00 · 2026-08-27 22:34:34 +02:00 · 2026-08-27 18:26:00 +02:00 · 2026-08-27 17:57:49 +02:00 · 2026-08-27 17:40:35 +02:00
73 changed files with 2523 additions and 1311 deletions
@@ -44,3 +44,106 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.
 ---
 ## 2026-08-27 17:26 – 17:28 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 - c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:28 – 17:29 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:31 – 17:31 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:36 – 17:36 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:36 – 17:37 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-28 22:48 – 22:51 (3m)
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 ### Commits
 - c344dea TEN-08: tenant-loeschung-unter-retention-vorbehalt-gobd (RetentionChecker-Schnittstelle gegen Archive RET-03/CMP-06, ProcessDueDeletions haelt gesperrte Tenants zurueck)
 ### Geänderte Dateien
 - internal/tenant/lifecycle.go                    |  45 ++++++++++++++++++++++++++++++++++++++++-----
 - internal/tenant/lifecycle_test.go               |   4 +++-
 - internal/tenant/registry.go                     |   7 +++++--
 - internal/tenant/retention.go                    |  34 ++++++++++++++++++++++++++++++++++
 - internal/tenant/retention_test.go               | 164 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/tenant/tenant.go                       |   5 +++++
 - migrations/0004_tenant_retention_block.down.sql |   2 ++
 - migrations/0004_tenant_retention_block.up.sql   |   6 ++++++
 ---
@@ -1,18 +0,0 @@
 version: "2"
 run:
  timeout: 3m
 linters:
  default: none
  enable:
    - govet
    - staticcheck
    - errcheck
    - unused
    - ineffassign
 formatters:
  enable:
    - gofmt
    - goimports
@@ -1,19 +0,0 @@
 .PHONY: build lint fmt test check
 build:
 	go build ./...
 lint:
 	golangci-lint run ./...
 fmt:
 	gofmt -l .
 	@test -z "$$(gofmt -l .)" || (echo "gofmt-Verstoesse gefunden, siehe oben" && exit 1)
 test:
 	go test ./... -p 1 -count=1
 check: build
 	go vet ./...
 	golangci-lint run ./...
 	go test ./... -p 1 -count=1
@@ -1,62 +0,0 @@
 # NEXARCH Archive
 Zentrales, modulübergreifendes Modul für Aufbewahrung, WORM, Compliance und
 Backup. Dieses Verzeichnis enthält bisher `internal/backup` (BAK-01,
 Datenbank-Backup-Strategie) — weitere Bausteine folgen ticketweise.
 ## BAK-01: Datenbank-Backup
 `cmd/backup-cli` — Aufrufpunkt für systemd-Timer (siehe
 `../deploy/systemd/nexarch-archive-backup-*.timer`):
 ```bash
 export NEXARCH_BACKUP_PG_USER=nexarch_backup
 export NEXARCH_BACKUP_PG_PASSWORD=...
 export NEXARCH_BACKUP_DIR=/var/nexarch-archiv/backups/postgres   # NICHT auf einem ephemeren Test-Dataset (siehe Betrieb)
 export NEXARCH_BACKUP_KEEP_GENERATIONS=7   # optional, Default 7
 backup-cli full          # neue Vollsicherung + Verifikation
 backup-cli incremental   # inkrementelle Sicherung gegen die neueste Generation
 backup-cli rotate        # entfernt alle bis auf die neuesten N Generationen
 ```
 Voraussetzung: die konfigurierte Postgres-Rolle braucht das
 `REPLICATION`-Attribut (`pg_basebackup` nutzt eine
 Replikationsverbindung), und `summarize_wal = on` muss serverseitig gesetzt
 sein (PostgreSQL 17s natives inkrementelles Backup, keine WAL-Archivierung
 nötig).
 ## BAK-02: Objekt-Storage-Backup
 `cmd/objectbackup-cli` sichert einen lokalen Verzeichnisbaum (den
 FDN-03-`LocalDriver`-Basisordner direkt, oder — für S3-gestützte
 Deployments — einen vorgelagerten `rclone`-Spiegel) mit
 [restic](https://restic.net) (Content-defined Chunking, verschlüsseltes
 Repository, geprüftes Tooling statt Eigenbau):
 ```bash
 export NEXARCH_OBJECTBACKUP_REPO_DIR=/var/nexarch-archiv/backups/objects
 export NEXARCH_OBJECTBACKUP_PASSWORD=...
 export NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS=30   # optional, Default 7
 objectbackup-cli backup /var/nexarch-objects   # Sicherung + Verifikation
 objectbackup-cli check                          # vollständiges Lesen aller Datenblöcke
 objectbackup-cli rotate                          # restic forget --keep-last N --prune
 ```
 ## Betrieb: Backup-Zielverzeichnis
 Backup-Ziele liegen unter `/var/nexarch-archiv/` (persistentes ZFS-Dataset,
 `zfs/data/subvol-1131-disk-0` auf 192.168.1.131), NIEMALS unter
 `/var/nexarch-test/` (ephemeres Dataset, wird von den `reset-test-env.sh`-
 Skripten der anderen Module geleert). ZFS-seitige Snapshots/Replikation
 dieses Datasets sind ein eigenständiges Infra-Runbook (siehe
 `../../STORAGE-KONZEPT.md` Abschnitt 7), kein Ticket-Code — `zfs
 dedup=on` bewusst NICHT setzen (hoher RAM-Bedarf), Deduplizierung läuft
 ausschließlich App-seitig über restic.
 ## Prüfungen
 ```bash
 make check   # build + vet + lint + test, analog Core/DMS
 ```
@@ -1,107 +0,0 @@
 // backup-cli ist der Aufrufpunkt für BAK-01, gedacht für systemd-Timer
 // (siehe deploy/systemd/) — "automatisiert nach Zeitplan" (Akzeptanzkriterium
 // 1) entsteht durch die Zeitplan-Definition im Timer-Unit, nicht durch
 // einen eigenen In-Prozess-Scheduler (kein zusätzlicher Dauerprozess nötig,
 // passt zur Produkt-DNA "kein Anwendungsserver mit unnötigem
 // Ressourcenverbrauch").
 package main
 import (
 	"context"
 	"fmt"
 	"log"
 	"os"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/backup"
 )
 func loadConfig() backup.Config {
 	cfg := backup.Config{
 		Host:      os.Getenv("NEXARCH_BACKUP_PG_HOST"),
 		Port:      os.Getenv("NEXARCH_BACKUP_PG_PORT"),
 		User:      os.Getenv("NEXARCH_BACKUP_PG_USER"),
 		Password:  os.Getenv("NEXARCH_BACKUP_PG_PASSWORD"),
 		BackupDir: os.Getenv("NEXARCH_BACKUP_DIR"),
 	}
 	if cfg.Host == "" {
 		cfg.Host = "localhost"
 	}
 	if cfg.Port == "" {
 		cfg.Port = "5432"
 	}
 	if cfg.User == "" || cfg.Password == "" || cfg.BackupDir == "" {
 		log.Fatal("NEXARCH_BACKUP_PG_USER, NEXARCH_BACKUP_PG_PASSWORD und NEXARCH_BACKUP_DIR muessen gesetzt sein")
 	}
 	return cfg
 }
 func latestManifest(backupDir string) (string, error) {
 	generations, err := backup.ListGenerations(backupDir)
 	if err != nil {
 		return "", err
 	}
 	if len(generations) == 0 {
 		return "", fmt.Errorf("keine vorhandene generation fuer inkrementelle sicherung gefunden - zuerst 'full' ausfuehren")
 	}
 	latest := generations[len(generations)-1]
 	full := backupDir + "/" + latest + "/" + backup.FullBackupDirName + "/" + backup.BackupManifestFile
 	if _, err := os.Stat(full); err == nil {
 		return full, nil
 	}
 	return "", fmt.Errorf("kein backup_manifest in der neuesten generation %q gefunden", latest)
 }
 func main() {
 	if len(os.Args) < 2 {
 		log.Fatal("aufruf: backup-cli <full|incremental|verify|rotate> [args]")
 	}
 	cfg := loadConfig()
 	ctx := context.Background()
 	switch os.Args[1] {
 	case "full":
 		genID := backup.NewGenerationID(time.Now())
 		manifest, err := backup.FullBackup(ctx, cfg, genID)
 		if err != nil {
 			log.Fatalf("vollsicherung fehlgeschlagen: %v", err)
 		}
 		dir := manifest[:len(manifest)-len("/"+backup.BackupManifestFile)]
 		if err := backup.Verify(dir); err != nil {
 			log.Fatalf("verifikation der vollsicherung fehlgeschlagen: %v", err)
 		}
 		fmt.Printf("vollsicherung %q erstellt und verifiziert: %s\n", genID, manifest)
 	case "incremental":
 		manifest, err := latestManifest(cfg.BackupDir)
 		if err != nil {
 			log.Fatal(err)
 		}
 		generations, _ := backup.ListGenerations(cfg.BackupDir)
 		genID := generations[len(generations)-1]
 		incID := backup.NewGenerationID(time.Now())
 		newManifest, err := backup.IncrementalBackup(ctx, cfg, genID, incID, manifest)
 		if err != nil {
 			log.Fatalf("inkrementelle sicherung fehlgeschlagen: %v", err)
 		}
 		dir := newManifest[:len(newManifest)-len("/"+backup.BackupManifestFile)]
 		if err := backup.Verify(dir); err != nil {
 			log.Fatalf("verifikation der inkrementellen sicherung fehlgeschlagen: %v", err)
 		}
 		fmt.Printf("inkrementelle sicherung %q erstellt und verifiziert: %s\n", incID, newManifest)
 	case "rotate":
 		keep := 7
 		if v := os.Getenv("NEXARCH_BACKUP_KEEP_GENERATIONS"); v != "" {
 			_, _ = fmt.Sscanf(v, "%d", &keep)
 		}
 		removed, err := backup.Rotate(cfg.BackupDir, keep)
 		if err != nil {
 			log.Fatalf("rotation fehlgeschlagen: %v", err)
 		}
 		fmt.Printf("rotation abgeschlossen, %d generation(en) entfernt: %v\n", len(removed), removed)
 	default:
 		log.Fatalf("unbekannter befehl %q", os.Args[1])
 	}
 }
@@ -1,75 +0,0 @@
 // objectbackup-cli ist der Aufrufpunkt für BAK-02, für systemd-Timer
 // gedacht (siehe deploy/systemd/) — "automatisiert nach Zeitplan" entsteht
 // durch die Timer-Definition, kein eigener Dauerprozess (dieselbe
 // Begründung wie BAK-01 / cmd/backup-cli).
 package main
 import (
 	"context"
 	"fmt"
 	"log"
 	"os"
 	"strconv"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/objectbackup"
 )
 func loadConfig() objectbackup.Config {
 	cfg := objectbackup.Config{
 		RepoDir:  os.Getenv("NEXARCH_OBJECTBACKUP_REPO_DIR"),
 		Password: os.Getenv("NEXARCH_OBJECTBACKUP_PASSWORD"),
 	}
 	if cfg.RepoDir == "" || cfg.Password == "" {
 		log.Fatal("NEXARCH_OBJECTBACKUP_REPO_DIR und NEXARCH_OBJECTBACKUP_PASSWORD muessen gesetzt sein")
 	}
 	return cfg
 }
 func main() {
 	if len(os.Args) < 2 {
 		log.Fatal("aufruf: objectbackup-cli <backup <quellverzeichnis>|check|rotate>")
 	}
 	cfg := loadConfig()
 	ctx := context.Background()
 	if err := objectbackup.InitRepo(ctx, cfg); err != nil {
 		log.Fatalf("repository initialisieren: %v", err)
 	}
 	switch os.Args[1] {
 	case "backup":
 		if len(os.Args) < 3 {
 			log.Fatal("aufruf: objectbackup-cli backup <quellverzeichnis>")
 		}
 		summary, err := objectbackup.Backup(ctx, cfg, os.Args[2])
 		if err != nil {
 			log.Fatalf("sicherung fehlgeschlagen: %v", err)
 		}
 		if err := objectbackup.Check(ctx, cfg, false); err != nil {
 			log.Fatalf("verifikation nach sicherung fehlgeschlagen: %v", err)
 		}
 		fmt.Printf("sicherung %q erstellt und verifiziert (neu=%d geaendert=%d unveraendert=%d)\n",
 			summary.SnapshotID, summary.FilesNew, summary.FilesChanged, summary.FilesUnmodified)
 	case "check":
 		if err := objectbackup.Check(ctx, cfg, true); err != nil {
 			log.Fatalf("verifikation fehlgeschlagen: %v", err)
 		}
 		fmt.Println("verifikation (mit vollstaendigem lesen) erfolgreich")
 	case "rotate":
 		keep := 7
 		if v := os.Getenv("NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS"); v != "" {
 			if n, err := strconv.Atoi(v); err == nil {
 				keep = n
 			}
 		}
 		if err := objectbackup.Forget(ctx, cfg, keep); err != nil {
 			log.Fatalf("rotation fehlgeschlagen: %v", err)
 		}
 		fmt.Println("rotation abgeschlossen")
 	default:
 		log.Fatalf("unbekannter befehl %q", os.Args[1])
 	}
 }
@@ -1,87 +0,0 @@
 # BAK-01 – Prüfprotokoll: Datenbank-Backup-Strategie
 Welle 1, keine Vorbedingungen. Neues Modul-Verzeichnis `code/archive/`
 (gleiches Monorepo-Muster wie `code/dms/`), eigenes Go-Modul
 `gitea.perlbach24.de/scripte/nexarch/archive`.
 ## Grundsatzentscheidung: PostgreSQL-17-natives inkrementelles Backup
 `pg_dump` kennt nur logische Vollsicherungen — "inkrementell" im Sinne des
 Tickets erfordert das physische Backup-Verfahren. Gewählt: PostgreSQL 17s
 natives `pg_basebackup --incremental` (WAL-Summarization), NICHT klassisches
 WAL-Archiving (`archive_mode`), weil letzteres einen Neustart der
 (geteilten, auch von Core/DMS-Tests genutzten) Postgres-Instanz auf
 192.168.1.131 erfordert hätte. Stattdessen `summarize_wal = on` gesetzt —
 nur ein `pg_reload_conf()`, kein Neustart, keine Unterbrechung laufender
 Verbindungen (per Health-Check nach der Änderung bestätigt).
 Voraussetzung geschaffen: Rolle `nexarch_backup` mit `REPLICATION`-Attribut
 angelegt (Postgres verlangt eine Replikationsverbindung für
 `pg_basebackup`), `pg_hba.conf` erlaubte lokale Replikationsverbindungen
 bereits.
 ## Umsetzung
 - `internal/backup.FullBackup`/`IncrementalBackup` — rufen `pg_basebackup`
  über `os/exec` auf, Ergebnis landet in einer Generationsstruktur
  (`<BackupDir>/<Generation>/full/` bzw. `.../incremental/<ID>/`).
 - `internal/backup.Verify` — öffnet `base.tar.gz` vollständig (gzip- UND
  tar-Stream, jeder Eintrag bis zum Ende gelesen, nicht nur Kopfdaten) —
  Akzeptanzkriterium 2: Verifikation auf Lesbarkeit, nicht nur Erstellung.
 - `internal/backup.Rotate`/`ListGenerations` — Generationen sind nach
  Zeitstempel-ID sortierbar, `Rotate` entfernt die ältesten bis auf `keep`
  komplett (inklusive aller abhängigen Inkremente).
 - `cmd/backup-cli` — `full`/`incremental`/`rotate`, aufgerufen von
  systemd-Timern (`deploy/systemd/nexarch-archive-backup-*.timer`) —
  "automatisiert nach Zeitplan" (Akzeptanzkriterium 1) entsteht durch die
  Timer-Definition, kein zusätzlicher Dauerprozess nötig.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Sicherung gegen Testdatenbank erfolgreich erstellt und verifiziert | **bestanden** — `TestFullBackup_CreatesVerifiedBackup` gegen die echte Postgres-17-Instanz auf 192.168.1.131 (kein Mock), zusätzlich `TestIncrementalBackup_IsSmallerThanFull`: inkrementelle Sicherung real deutlich kleiner als Vollsicherung (167 KB vs. 16 MB bei der ersten manuellen Probe) — beweist echte inkrementelle Übertragung, nicht nur eine zweite Vollsicherung |
 | 2 | Verifikation erkennt eine absichtlich beschädigte Sicherungsdatei | **bestanden** — `TestVerify_DetectsCorruptedFile`: 64 Bytes in der Mitte von `base.tar.gz` gekippt, `Verify` schlägt danach fehl (unbeschädigt zuvor erfolgreich) |
 | 3 | Rotationsregel entfernt nachweislich nur die ältesten Generationen | **bestanden** — `TestRotate_RemovesOnlyOldestGenerations`: 5 Generationen, `keep=2`, exakt die 3 ältesten entfernt, die 2 neuesten nachweislich unangetastet |
 ## Echte Verdrahtung auf 192.168.1.131 (nicht nur Testcode)
 Anders als die zuletzt in DMS gefundenen "Baustein existiert, ist aber
 nirgends verdrahtet"-Fälle (FDN-03/FDN-09 gegen Core) wurde hier die
 komplette Kette tatsächlich installiert und ausgeführt:
 - `backup-cli` gebaut nach `/opt/nexarch-archive/bin/`
 - `/etc/nexarch/archive-backup.env` mit den Verbindungsdaten (0600)
 - 3 systemd-Timer installiert und aktiviert (`enable --now`):
  Vollsicherung täglich 02:00 UTC, Inkrement stündlich, Rotation täglich
  03:00 UTC (`systemctl list-timers` bestätigt alle drei scharf)
 - Jeder der drei Dienste (`full`/`incremental`/`rotate`) einmal manuell über
  `systemctl start` ausgelöst (nicht nur `go test` direkt) — alle drei mit
  `status=0/SUCCESS`, Journal bestätigt inhaltlich korrekte Ausgabe
  (Vollsicherung erstellt+verifiziert, Inkrement erstellt+verifiziert
  gegen die richtige Vorgänger-Generation, Rotation lief ohne Fehler)
 ## Build/Test-Ergebnis (192.168.1.131, `make check`)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./... -p 1 -count=1  -> 4/4 Tests ok, 0 Fehlschläge (echter Postgres 17, kein Mock)
 ```
 ## Nachtrag (BAK-02-Sitzung): Backup-Zielverzeichnis korrigiert
 `NEXARCH_BACKUP_DIR` zeigte ursprünglich auf `/var/backups/nexarch`
 (Root-Dateisystem des Containers, kein dediziertes Dataset) — korrigiert auf
 `/var/nexarch-archiv/backups/postgres` (persistentes ZFS-Dataset), siehe
 `docs/BAK-02-PRUEFPROTOKOLL.md` Abschnitt „Korrektur an BAK-01" für Details.
 Vollsicherung nach der Korrektur erneut über systemd ausgelöst, landet
 nachweislich am neuen Ort.
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt — inklusive tatsächlicher systemd-Timer-Installation und
 manuell ausgelöstem End-to-End-Lauf aller drei Dienste auf dem Testhost,
 nicht nur isolierter Testcode.
@@ -1,93 +0,0 @@
 # BAK-02 – Prüfprotokoll: Objekt-Storage-Backup/Snapshots
 Welle 1, keine Vorbedingungen.
 ## Grundsatzentscheidung: restic statt Eigenbau
 Nutzerentscheidung: restic statt einer Neuimplementierung, weil restic alle
 vier Akzeptanzkriterien mit ausgereiftem, breit geprüftem Tooling erfüllt
 (Content-defined Chunking für Dedup, `check --read-data` für
 Vollständigkeit, `forget --keep-last` für Rotation, Repository-Verschlüsselung
 ab Werk). Installiert via `apt-get install restic` (Version 0.18.0).
 Backup-Quelle ist ein lokaler Verzeichnisbaum — für den FDN-03-`LocalDriver`
 direkt dessen Basisverzeichnis. Für S3-gestützte Produktions-Deployments
 (Betriebsmodus 2/3 aus `STORAGE-KONZEPT.md` Abschnitt 6.2) wäre ein
 vorgelagerter Sync-Schritt (z. B. `rclone`) nötig, um Bucket-Inhalte lokal
 zu spiegeln, bevor restic sie sichert — restic sichert Dateibäume, keine
 S3-Buckets direkt. Das bleibt hier bewusst unimplementiert (kein konkreter
 S3-Produktionsbestand vorhanden, der das aktuell erfordert), aber
 architektonisch vorgesehen und dokumentiert (`README.md`).
 ## Umsetzung
 - `internal/objectbackup.InitRepo` — idempotent, erkennt "bereits
  initialisiert" am `restic init`-Fehlertext statt zu scheitern.
 - `internal/objectbackup.Backup` — `restic backup --json`, parst die
  `summary`-Zeile (mehrere JSON-Zeilen in der Ausgabe, gezielt die mit
  `message_type=="summary"` gesucht).
 - `internal/objectbackup.Check` — `restic check [--read-data]` (Akzeptanz-
  kriterium 3: Vollständigkeitsprüfung).
 - `internal/objectbackup.Forget` — `restic forget --keep-last N --prune`
  (Rotation).
 - `cmd/objectbackup-cli` — `backup <dir>`/`check`/`rotate`, aufgerufen von
  systemd-Timern (stündlich/wöchentlich/täglich).
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Zweiter Sicherungslauf nach unverändertem Bestand überträgt keine Daten erneut | **bestanden** — `TestBackup_UnchangedSecondRunTransmitsNothingNew`: zweiter Lauf gegen unveränderten Bestand liefert `files_new=0`, `files_changed=0`, `files_unmodified=1` |
 | 2 | Zwei identische Testdateien belegen nachweislich nur einmal Speicherplatz | **bestanden** — `TestBackup_DeduplicatesIdenticalContent`: zwei Dateien mit identischem Inhalt erzeugen `data_blobs=1`, nicht 2 — echter Dedup-Nachweis über restics Content-defined Chunking, nicht nur Namensvergleich |
 | 3 | Vollständigkeitsprüfung erkennt ein fehlendes Objekt in der Sicherung | **bestanden** — `TestCheck_DetectsCorruptedPack`: ein Byte in einer echten Repository-Pack-Datei gekippt, `Check(readData=true)` schlägt danach fehl (unbeschädigt zuvor erfolgreich) — dieselbe Vorgehensweise wie die manuelle Recherche vor der Implementierung |
 Zusätzlich (nicht explizit als Pflichtprüfung gefordert, aber Teil von
 Akzeptanzkriterium 3 „lässt sich einzeln prüfen"): `TestForget_
 KeepsOnlyRequestedSnapshotCount` — 3 Sicherungsläufe, `Forget(keepLast=1)`
 reduziert auf genau 1 verbleibenden Snapshot.
 ## Korrektur an BAK-01 im selben Rutsch: Backup-Zielverzeichnis
 Nutzerhinweis aufgegriffen: `NEXARCH_BACKUP_DIR` zeigte bei BAK-01
 ursprünglich auf `/var/backups/nexarch` (Root-Dateisystem des LXC-
 Containers, nicht auf einem der beiden dedizierten ZFS-Datasets). Korrigiert
 auf `/var/nexarch-archiv/backups/postgres` (persistentes Dataset
 `zfs/data/subvol-1131-disk-0`), NICHT `/var/nexarch-test/` (ephemeres
 Dataset `ssd-rpool-data/swap/subvol-1131-disk-0`, wird von
 `reset-test-env.sh`-Skripten anderer Module geleert). `objectbackup-cli`s
 Repository liegt von Anfang an korrekt unter
 `/var/nexarch-archiv/backups/objects`. Beide Pfade real auf
 192.168.1.131 verifiziert (`df`/`mount` bestätigt ZFS-Dataset-Zuordnung),
 BAK-01s Vollsicherung nach der Korrektur erneut über systemd ausgelöst und
 bestätigt am neuen Ort gelandet.
 ZFS-seitige Snapshot-/Replikations-Strategie für `nexarch/archiv` bleibt
 bewusst außerhalb dieses Tickets (Infra-Runbook, siehe
 `STORAGE-KONZEPT.md` Abschnitt 7 „Backup vs. Storage-Redundanz" sowie den
 Hinweis, `zfs dedup=on` NICHT zu setzen — App-seitige Dedup über restic
 genügt, ZFS-Dedup wäre auf dem 4-GB-Testhost ein Speicherrisiko).
 ## Echte Verdrahtung auf 192.168.1.131
 - `objectbackup-cli` gebaut nach `/opt/nexarch-archive/bin/`
 - `/etc/nexarch/archive-objectbackup.env` (0600)
 - 3 systemd-Timer installiert und aktiviert: Sicherung stündlich (`:30`),
  Vollständigkeitsprüfung wöchentlich (So. 04:00 UTC), Rotation täglich
  (03:30 UTC) — `systemctl list-timers` bestätigt alle scharf
 - Jeder der drei Dienste einmal über `systemctl start` ausgelöst, alle mit
  `status=0/SUCCESS`; Journal bestätigt inhaltlich korrekte Ausgabe
 ## Build/Test-Ergebnis (192.168.1.131, `make check`)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./... -p 1 -count=1  -> 2/2 Pakete mit Tests ok (internal/backup, internal/objectbackup), 0 Fehlschläge
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real gegen echtes restic-Tooling erfüllt. BAK-01-Pfadfehler im selben
 Rutsch korrigiert und erneut end-to-end verifiziert.
@@ -1,3 +0,0 @@
 module gitea.perlbach24.de/scripte/nexarch/archive
 go 1.22
@@ -1,102 +0,0 @@
 // Package backup implementiert BAK-01: automatisierte, inkrementelle
 // Sicherung der PostgreSQL-Datenbank per pg_basebackup (PostgreSQL 17s
 // natives inkrementelles Backup über WAL-Summarization, siehe
 // `summarize_wal`), mit Verifikation jeder Sicherung und
 // generationsbasierter Rotation. Kein pg_dump-basierter Ansatz, weil
 // pg_dump ausschließlich logische Vollsicherungen kennt — "inkrementell"
 // im Sinne des Tickets erfordert das physische, WAL-summary-gestützte
 // Verfahren aus PostgreSQL 17.
 package backup
 import (
 	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"time"
 )
 // Config enthält die Verbindungsdaten für pg_basebackup — ausschließlich
 // über Umgebungsvariablen befüllt, nie im Code (siehe Ticket-Abschluss-
 // Regel).
 type Config struct {
 	Host             string
 	Port             string
 	User             string
 	Password         string
 	BackupDir        string
 	PgBaseBackupPath string // Default "pg_basebackup", überschreibbar für Tests
 }
 func (c Config) binary() string {
 	if c.PgBaseBackupPath != "" {
 		return c.PgBaseBackupPath
 	}
 	return "pg_basebackup"
 }
 // FullBackupDirName/IncrementalDirName sind die festen Unterverzeichnis-
 // namen je Generation.
 const (
 	FullBackupDirName  = "full"
 	IncrementalSubdir  = "incremental"
 	BackupManifestFile = "backup_manifest"
 	BaseTarGzFile      = "base.tar.gz"
 )
 // NewGenerationID liefert eine sortierbare, eindeutige Generation-Kennung
 // (RFC3339-artig, dateisystemtauglich) — Generationen werden anhand dieser
 // Kennung chronologisch sortiert (Rotate, ListGenerations).
 func NewGenerationID(t time.Time) string {
 	return t.UTC().Format("20060102T150405Z")
 }
 // FullBackup erstellt eine neue Vollsicherung (Akzeptanzkriterium 1) als
 // eigene Generation. Liefert den Pfad zum backup_manifest, das spätere
 // IncrementalBackup-Aufrufe als Referenz brauchen.
 func FullBackup(ctx context.Context, cfg Config, generationID string) (manifestPath string, err error) {
 	dir := filepath.Join(cfg.BackupDir, generationID, FullBackupDirName)
 	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
 		return "", fmt.Errorf("backup: generationsverzeichnis anlegen: %w", err)
 	}
 	args := []string{
 		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
 		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
 	}
 	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
 		return "", fmt.Errorf("backup: vollsicherung: %w", err)
 	}
 	return filepath.Join(dir, BackupManifestFile), nil
 }
 // IncrementalBackup erstellt eine inkrementelle Sicherung gegen die zuletzt
 // bekannte Vollsicherung ODER die letzte Inkrement-Sicherung (priorManifestPath
 // zeigt jeweils auf das backup_manifest der Referenz).
 func IncrementalBackup(ctx context.Context, cfg Config, generationID, incrementID, priorManifestPath string) (manifestPath string, err error) {
 	dir := filepath.Join(cfg.BackupDir, generationID, IncrementalSubdir, incrementID)
 	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
 		return "", fmt.Errorf("backup: inkrement-verzeichnis anlegen: %w", err)
 	}
 	args := []string{
 		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
 		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
 		"--incremental=" + priorManifestPath,
 	}
 	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
 		return "", fmt.Errorf("backup: inkrementelle sicherung: %w", err)
 	}
 	return filepath.Join(dir, BackupManifestFile), nil
 }
 func runPgBaseBackup(ctx context.Context, cfg Config, args []string) error {
 	cmd := exec.CommandContext(ctx, cfg.binary(), args...)
 	cmd.Env = append(os.Environ(), "PGPASSWORD="+cfg.Password)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		return fmt.Errorf("%s fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), err, string(output))
 	}
 	return nil
 }
@@ -1,187 +0,0 @@
 package backup
 import (
 	"context"
 	"os"
 	"path/filepath"
 	"testing"
 	"time"
 )
 func requireTestConfig(t *testing.T) Config {
 	t.Helper()
 	user := os.Getenv("TEST_BACKUP_PG_USER")
 	if user == "" {
 		t.Skip("TEST_BACKUP_PG_USER nicht gesetzt, Integrationstest uebersprungen (braucht echten Postgres mit REPLICATION-Rolle)")
 	}
 	return Config{
 		Host:      envOr("TEST_BACKUP_PG_HOST", "localhost"),
 		Port:      envOr("TEST_BACKUP_PG_PORT", "5432"),
 		User:      user,
 		Password:  os.Getenv("TEST_BACKUP_PG_PASSWORD"),
 		BackupDir: t.TempDir(),
 	}
 }
 func envOr(key, fallback string) string {
 	if v := os.Getenv(key); v != "" {
 		return v
 	}
 	return fallback
 }
 // TestFullBackup_CreatesVerifiedBackup ist Pruefung 1: Sicherung gegen
 // Testdatenbank erfolgreich erstellt und verifiziert.
 func TestFullBackup_CreatesVerifiedBackup(t *testing.T) {
 	cfg := requireTestConfig(t)
 	ctx := context.Background()
 	genID := NewGenerationID(time.Now())
 	manifest, err := FullBackup(ctx, cfg, genID)
 	if err != nil {
 		t.Fatalf("fullbackup: %v", err)
 	}
 	if _, err := os.Stat(manifest); err != nil {
 		t.Fatalf("backup_manifest fehlt: %v", err)
 	}
 	dir := filepath.Dir(manifest)
 	if _, err := os.Stat(filepath.Join(dir, BaseTarGzFile)); err != nil {
 		t.Fatalf("%s fehlt: %v", BaseTarGzFile, err)
 	}
 	if err := Verify(dir); err != nil {
 		t.Fatalf("verify: %v", err)
 	}
 }
 // TestIncrementalBackup_IsSmallerThanFull ist der Nachweis fuer
 // Akzeptanzkriterium 1 (inkrementell): eine echte inkrementelle Sicherung
 // gegen unveraenderten Bestand ist deutlich kleiner als die Vollsicherung —
 // beweist, dass tatsaechlich nur Aenderungen uebertragen wurden (PostgreSQL
 // 17 WAL-Summarization), nicht nochmal alles.
 func TestIncrementalBackup_IsSmallerThanFull(t *testing.T) {
 	cfg := requireTestConfig(t)
 	ctx := context.Background()
 	genID := NewGenerationID(time.Now())
 	fullManifest, err := FullBackup(ctx, cfg, genID)
 	if err != nil {
 		t.Fatalf("fullbackup: %v", err)
 	}
 	fullDir := filepath.Dir(fullManifest)
 	fullSize := fileSize(t, filepath.Join(fullDir, BaseTarGzFile))
 	incID := NewGenerationID(time.Now().Add(time.Second))
 	incManifest, err := IncrementalBackup(ctx, cfg, genID, incID, fullManifest)
 	if err != nil {
 		t.Fatalf("incrementalbackup: %v", err)
 	}
 	incDir := filepath.Dir(incManifest)
 	if err := Verify(incDir); err != nil {
 		t.Fatalf("verify (inkrementell): %v", err)
 	}
 	incSize := fileSize(t, filepath.Join(incDir, BaseTarGzFile))
 	if incSize >= fullSize {
 		t.Fatalf("inkrementelle sicherung (%d bytes) ist nicht kleiner als die vollsicherung (%d bytes) - keine echte inkrementelle Uebertragung", incSize, fullSize)
 	}
 }
 func fileSize(t *testing.T, path string) int64 {
 	t.Helper()
 	info, err := os.Stat(path)
 	if err != nil {
 		t.Fatalf("dateigroesse von %q ermitteln: %v", path, err)
 	}
 	return info.Size()
 }
 // TestVerify_DetectsCorruptedFile ist Pruefung 2: Verifikation erkennt eine
 // absichtlich beschaedigte Sicherungsdatei.
 func TestVerify_DetectsCorruptedFile(t *testing.T) {
 	cfg := requireTestConfig(t)
 	ctx := context.Background()
 	genID := NewGenerationID(time.Now())
 	manifest, err := FullBackup(ctx, cfg, genID)
 	if err != nil {
 		t.Fatalf("fullbackup: %v", err)
 	}
 	dir := filepath.Dir(manifest)
 	if err := Verify(dir); err != nil {
 		t.Fatalf("verify (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
 	}
 	// Absichtliche Beschaedigung: mehrere Bytes in der Mitte der Datei kippen.
 	path := filepath.Join(dir, BaseTarGzFile)
 	data, err := os.ReadFile(path)
 	if err != nil {
 		t.Fatalf("sicherungsdatei lesen: %v", err)
 	}
 	mid := len(data) / 2
 	for i := mid; i < mid+64 && i < len(data); i++ {
 		data[i] ^= 0xFF
 	}
 	if err := os.WriteFile(path, data, 0o600); err != nil {
 		t.Fatalf("beschaedigte sicherungsdatei schreiben: %v", err)
 	}
 	if err := Verify(dir); err == nil {
 		t.Fatal("verify haette die beschaedigte sicherungsdatei erkennen muessen")
 	}
 }
 // TestRotate_RemovesOnlyOldestGenerations ist Pruefung 3.
 func TestRotate_RemovesOnlyOldestGenerations(t *testing.T) {
 	backupDir := t.TempDir()
 	generationIDs := []string{
 		"20260101T000000Z",
 		"20260102T000000Z",
 		"20260103T000000Z",
 		"20260104T000000Z",
 		"20260105T000000Z",
 	}
 	for _, id := range generationIDs {
 		if err := os.MkdirAll(filepath.Join(backupDir, id, FullBackupDirName), 0o750); err != nil {
 			t.Fatalf("generation %q anlegen: %v", id, err)
 		}
 	}
 	removed, err := Rotate(backupDir, 2)
 	if err != nil {
 		t.Fatalf("rotate: %v", err)
 	}
 	wantRemoved := []string{"20260101T000000Z", "20260102T000000Z", "20260103T000000Z"}
 	if len(removed) != len(wantRemoved) {
 		t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
 	}
 	for i, w := range wantRemoved {
 		if removed[i] != w {
 			t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
 		}
 	}
 	remaining, err := ListGenerations(backupDir)
 	if err != nil {
 		t.Fatalf("listgenerations: %v", err)
 	}
 	wantRemaining := []string{"20260104T000000Z", "20260105T000000Z"}
 	if len(remaining) != len(wantRemaining) {
 		t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
 	}
 	for i, w := range wantRemaining {
 		if remaining[i] != w {
 			t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
 		}
 	}
 	// Die NEUESTEN duerfen NICHT entfernt sein (Pruefung 3: nur die
 	// aeltesten Generationen).
 	for _, w := range wantRemaining {
 		if _, err := os.Stat(filepath.Join(backupDir, w)); err != nil {
 			t.Fatalf("neueste generation %q wurde faelschlich entfernt: %v", w, err)
 		}
 	}
 }
@@ -1,56 +0,0 @@
 package backup
 import (
 	"fmt"
 	"os"
 	"path/filepath"
 	"sort"
 )
 // ListGenerations liefert alle Generation-IDs in backupDir, aufsteigend
 // sortiert (die GenerationID selbst ist chronologisch sortierbar, siehe
 // NewGenerationID — kein Blick auf Dateisystem-Zeitstempel nötig, die bei
 // einem Restore/Kopiervorgang verändert werden könnten).
 func ListGenerations(backupDir string) ([]string, error) {
 	entries, err := os.ReadDir(backupDir)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil, nil
 		}
 		return nil, fmt.Errorf("backup: sicherungsverzeichnis lesen: %w", err)
 	}
 	var generations []string
 	for _, e := range entries {
 		if e.IsDir() {
 			generations = append(generations, e.Name())
 		}
 	}
 	sort.Strings(generations)
 	return generations, nil
 }
 // Rotate entfernt alle bis auf die `keep` NEUESTEN Generationen
 // (Akzeptanzkriterium 3) — jede Generation umfasst ihre Vollsicherung UND
 // alle davon abhängigen Inkremente, ein Löschen der gesamten
 // Generationsverzeichnisses entfernt beides konsistent zusammen.
 func Rotate(backupDir string, keep int) (removed []string, err error) {
 	if keep < 0 {
 		keep = 0
 	}
 	generations, err := ListGenerations(backupDir)
 	if err != nil {
 		return nil, err
 	}
 	if len(generations) <= keep {
 		return nil, nil
 	}
 	toRemove := generations[:len(generations)-keep]
 	for _, gen := range toRemove {
 		if err := os.RemoveAll(filepath.Join(backupDir, gen)); err != nil {
 			return removed, fmt.Errorf("backup: generation %q entfernen: %w", gen, err)
 		}
 		removed = append(removed, gen)
 	}
 	return removed, nil
 }
@@ -1,54 +0,0 @@
 package backup
 import (
 	"archive/tar"
 	"compress/gzip"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 )
 // ErrCorrupted wird geliefert, wenn eine Sicherungsdatei nicht lesbar ist
 // (Akzeptanzkriterium 2: Verifikation, nicht nur Erstellungs-Prüfung).
 var ErrCorrupted = fmt.Errorf("backup: sicherungsdatei ist beschaedigt oder unvollstaendig")
 // Verify prüft, dass base.tar.gz im gegebenen Sicherungsverzeichnis
 // vollständig lesbar ist — öffnet gzip- UND tar-Stream und liest JEDEN
 // Eintrag bis zum Ende durch (nicht nur die Kopfdaten), damit ein
 // abgeschnittener oder mit kaputten Bytes überschriebener Inhalt
 // zuverlässig auffällt, nicht nur ein defekter Tar-Header.
 func Verify(backupDir string) error {
 	path := filepath.Join(backupDir, BaseTarGzFile)
 	f, err := os.Open(path)
 	if err != nil {
 		return fmt.Errorf("%w: %s nicht lesbar: %v", ErrCorrupted, path, err)
 	}
 	defer func() { _ = f.Close() }()
 	gz, err := gzip.NewReader(f)
 	if err != nil {
 		return fmt.Errorf("%w: gzip-header ungueltig: %v", ErrCorrupted, err)
 	}
 	defer func() { _ = gz.Close() }()
 	tr := tar.NewReader(gz)
 	entries := 0
 	for {
 		hdr, err := tr.Next()
 		if err == io.EOF {
 			break
 		}
 		if err != nil {
 			return fmt.Errorf("%w: tar-eintrag ungueltig: %v", ErrCorrupted, err)
 		}
 		if _, err := io.Copy(io.Discard, tr); err != nil {
 			return fmt.Errorf("%w: inhalt von %q nicht vollstaendig lesbar: %v", ErrCorrupted, hdr.Name, err)
 		}
 		entries++
 	}
 	if entries == 0 {
 		return fmt.Errorf("%w: archiv enthaelt keine eintraege", ErrCorrupted)
 	}
 	return nil
 }
@@ -1,156 +0,0 @@
 // Package objectbackup implementiert BAK-02: automatisierte, inkrementelle,
 // deduplizierende Sicherung des Objekt-Storage-Bestands. Nutzt restic
 // (Content-defined Chunking, verschlüsseltes Repository ab Werk) statt
 // Eigenbau — restic erfüllt alle Akzeptanzkriterien mit ausgereiftem,
 // geprüftem Tooling statt einer weniger robusten Neuimplementierung.
 //
 // Backup-Quelle ist ein lokaler Verzeichnisbaum — für den LocalDriver aus
 // FDN-03 direkt dessen Basisverzeichnis, für S3-gestützte Produktions-
 // Deployments ein vorgelagerter Sync-Schritt (z.B. rclone) auf einen
 // lokalen Spiegel, bevor restic ihn sichert (nicht Bestandteil dieser
 // Kachel — restic selbst sichert Dateibäume, keine S3-Buckets direkt).
 package objectbackup
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"os"
 	"os/exec"
 	"strings"
 )
 // Config enthält Repository-Ort und -Passwort — ausschließlich über
 // Umgebungsvariablen befüllt (siehe Ticket-Abschluss-Regel).
 type Config struct {
 	RepoDir    string
 	Password   string
 	ResticPath string // Default "restic", überschreibbar für Tests
 }
 func (c Config) binary() string {
 	if c.ResticPath != "" {
 		return c.ResticPath
 	}
 	return "restic"
 }
 func (c Config) env() []string {
 	return append(os.Environ(), "RESTIC_PASSWORD="+c.Password)
 }
 func run(ctx context.Context, cfg Config, args ...string) ([]byte, error) {
 	fullArgs := append([]string{"-r", cfg.RepoDir}, args...)
 	cmd := exec.CommandContext(ctx, cfg.binary(), fullArgs...)
 	cmd.Env = cfg.env()
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		return output, fmt.Errorf("%s %v fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), args, err, string(output))
 	}
 	return output, nil
 }
 // InitRepo legt ein neues restic-Repository an, falls es noch nicht
 // existiert — idempotent, ein bereits initialisiertes Repository ist kein
 // Fehler (Wiederholte Aufrufe durch systemd-Timer nach einem Neustart
 // dürfen nicht fehlschlagen).
 func InitRepo(ctx context.Context, cfg Config) error {
 	output, err := run(ctx, cfg, "init")
 	if err != nil {
 		if strings.Contains(string(output), "config file already exists") {
 			return nil
 		}
 		return fmt.Errorf("objectbackup: repository initialisieren: %w", err)
 	}
 	return nil
 }
 // BackupSummary ist der geparste "summary"-Datensatz aus `restic backup --json`.
 type BackupSummary struct {
 	SnapshotID      string `json:"snapshot_id"`
 	FilesNew        int    `json:"files_new"`
 	FilesChanged    int    `json:"files_changed"`
 	FilesUnmodified int    `json:"files_unmodified"`
 	DataBlobs       int    `json:"data_blobs"`
 	TotalBytes      int64  `json:"total_bytes_processed"`
 }
 // Backup sichert sourceDir inkrementell (Akzeptanzkriterium 1: unveränderte
 // Objekte werden nicht erneut übertragen — restics Content-defined
 // Chunking erkennt das automatisch, kein manueller Änderungsabgleich
 // nötig).
 func Backup(ctx context.Context, cfg Config, sourceDir string) (BackupSummary, error) {
 	output, err := run(ctx, cfg, "backup", sourceDir, "--json")
 	if err != nil {
 		return BackupSummary{}, fmt.Errorf("objectbackup: sicherung: %w", err)
 	}
 	return parseSummary(output)
 }
 // parseSummary sucht in der zeilenweisen JSON-Ausgabe von `restic backup
 // --json` (mehrere Fortschritts-/Statuszeilen, GENAU EINE mit
 // message_type=="summary") die Zusammenfassung.
 func parseSummary(output []byte) (BackupSummary, error) {
 	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
 	for i := len(lines) - 1; i >= 0; i-- {
 		var probe struct {
 			MessageType string `json:"message_type"`
 		}
 		if err := json.Unmarshal([]byte(lines[i]), &probe); err != nil {
 			continue
 		}
 		if probe.MessageType == "summary" {
 			var summary BackupSummary
 			if err := json.Unmarshal([]byte(lines[i]), &summary); err != nil {
 				return BackupSummary{}, fmt.Errorf("objectbackup: summary-zeile dekodieren: %w", err)
 			}
 			return summary, nil
 		}
 	}
 	return BackupSummary{}, fmt.Errorf("objectbackup: keine summary-zeile in der restic-ausgabe gefunden")
 }
 // Check prüft die Vollständigkeit/Lesbarkeit des Repository
 // (Akzeptanzkriterium 3 / Pflichtprüfung: Vollständigkeitsprüfung erkennt
 // fehlendes/beschädigtes Objekt). readData=true liest jeden gespeicherten
 // Datenblock tatsächlich (teurer, aber die einzige Prüfung, die
 // Bit-Rot in bereits gespeicherten Paketen erkennt — ohne readData prüft
 // restic nur Struktur/Indizes, nicht den tatsächlichen Blockinhalt).
 func Check(ctx context.Context, cfg Config, readData bool) error {
 	args := []string{"check"}
 	if readData {
 		args = append(args, "--read-data")
 	}
 	if _, err := run(ctx, cfg, args...); err != nil {
 		return fmt.Errorf("objectbackup: %w", err)
 	}
 	return nil
 }
 // Forget entfernt alte Snapshots nach Rotationsregel und gibt den davon
 // belegten Speicherplatz frei (--prune) — restics Äquivalent zu
 // BAK-01s Rotate.
 func Forget(ctx context.Context, cfg Config, keepLast int) error {
 	if _, err := run(ctx, cfg, "forget", "--keep-last", fmt.Sprintf("%d", keepLast), "--prune"); err != nil {
 		return fmt.Errorf("objectbackup: rotation: %w", err)
 	}
 	return nil
 }
 type snapshotEntry struct {
 	ShortID string `json:"short_id"`
 }
 // SnapshotCount liefert die Anzahl vorhandener Snapshots — für Tests und
 // Statusabfragen.
 func SnapshotCount(ctx context.Context, cfg Config) (int, error) {
 	output, err := run(ctx, cfg, "snapshots", "--json")
 	if err != nil {
 		return 0, fmt.Errorf("objectbackup: snapshots auflisten: %w", err)
 	}
 	var snapshots []snapshotEntry
 	if err := json.Unmarshal(output, &snapshots); err != nil {
 		return 0, fmt.Errorf("objectbackup: snapshot-liste dekodieren: %w", err)
 	}
 	return len(snapshots), nil
 }
@@ -1,168 +0,0 @@
 package objectbackup
 import (
 	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"testing"
 )
 func requireRestic(t *testing.T) {
 	t.Helper()
 	if _, err := exec.LookPath("restic"); err != nil {
 		t.Skip("restic nicht installiert, Integrationstest uebersprungen")
 	}
 }
 func setupTest(t *testing.T) Config {
 	t.Helper()
 	requireRestic(t)
 	cfg := Config{RepoDir: filepath.Join(t.TempDir(), "repo"), Password: "test-passwort-fuer-objectbackup"}
 	if err := InitRepo(context.Background(), cfg); err != nil {
 		t.Fatalf("initrepo: %v", err)
 	}
 	return cfg
 }
 func writeFile(t *testing.T, dir, name, content string) {
 	t.Helper()
 	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o600); err != nil {
 		t.Fatalf("testdatei %q schreiben: %v", name, err)
 	}
 }
 // TestBackup_UnchangedSecondRunTransmitsNothingNew ist Pruefung 1:
 // zweiter Sicherungslauf nach unveraendertem Bestand ueberraegt keine
 // Daten erneut.
 func TestBackup_UnchangedSecondRunTransmitsNothingNew(t *testing.T) {
 	cfg := setupTest(t)
 	ctx := context.Background()
 	sourceDir := t.TempDir()
 	writeFile(t, sourceDir, "dokument.pdf", "unveraenderter inhalt")
 	first, err := Backup(ctx, cfg, sourceDir)
 	if err != nil {
 		t.Fatalf("erste sicherung: %v", err)
 	}
 	if first.FilesNew != 1 {
 		t.Fatalf("erste sicherung: files_new = %d, want 1", first.FilesNew)
 	}
 	second, err := Backup(ctx, cfg, sourceDir)
 	if err != nil {
 		t.Fatalf("zweite sicherung: %v", err)
 	}
 	if second.FilesNew != 0 || second.FilesChanged != 0 {
 		t.Fatalf("zweite sicherung (unveraendert): files_new=%d files_changed=%d, want beide 0", second.FilesNew, second.FilesChanged)
 	}
 	if second.FilesUnmodified != 1 {
 		t.Fatalf("zweite sicherung: files_unmodified = %d, want 1", second.FilesUnmodified)
 	}
 }
 // TestBackup_DeduplicatesIdenticalContent ist Pruefung 2: zwei identische
 // Testdateien belegen nachweislich nur einmal Speicherplatz.
 func TestBackup_DeduplicatesIdenticalContent(t *testing.T) {
 	cfg := setupTest(t)
 	ctx := context.Background()
 	sourceDir := t.TempDir()
 	content := "exakt identischer inhalt in beiden dateien fuer den dedup-nachweis"
 	writeFile(t, sourceDir, "original.pdf", content)
 	writeFile(t, sourceDir, "kopie.pdf", content)
 	summary, err := Backup(ctx, cfg, sourceDir)
 	if err != nil {
 		t.Fatalf("sicherung: %v", err)
 	}
 	if summary.FilesNew != 2 {
 		t.Fatalf("erwartet 2 neue dateien, habe %d", summary.FilesNew)
 	}
 	// Zwei Dateien mit IDENTISCHEM Inhalt duerfen nur EINEN data_blob
 	// erzeugen - das ist der Dedup-Nachweis (Akzeptanzkriterium 2).
 	if summary.DataBlobs != 1 {
 		t.Fatalf("data_blobs = %d, want 1 (zwei identische dateien haetten nur einen blob erzeugen duerfen - keine dedup)", summary.DataBlobs)
 	}
 }
 // TestCheck_DetectsCorruptedPack ist Pruefung 3: Vollstaendigkeitspruefung
 // erkennt ein beschaedigtes/fehlendes Objekt in der Sicherung.
 func TestCheck_DetectsCorruptedPack(t *testing.T) {
 	cfg := setupTest(t)
 	ctx := context.Background()
 	sourceDir := t.TempDir()
 	writeFile(t, sourceDir, "wichtig.pdf", "inhalt, der spaeter absichtlich beschaedigt wird")
 	if _, err := Backup(ctx, cfg, sourceDir); err != nil {
 		t.Fatalf("sicherung: %v", err)
 	}
 	if err := Check(ctx, cfg, true); err != nil {
 		t.Fatalf("check (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
 	}
 	// Absichtliche Beschaedigung: ein Byte in einer Pack-Datei im
 	// Repository kippen (dieselbe Fundstelle wie beim manuellen
 	// Nachweis waehrend der Recherche zu diesem Ticket).
 	packDir := filepath.Join(cfg.RepoDir, "data")
 	corrupted := false
 	if err := filepath.Walk(packDir, func(path string, info os.FileInfo, err error) error {
 		if err != nil || info.IsDir() || corrupted {
 			return err
 		}
 		data, err := os.ReadFile(path)
 		if err != nil {
 			return err
 		}
 		if len(data) < 20 {
 			return nil
 		}
 		data[10] ^= 0xFF
 		if err := os.WriteFile(path, data, 0o600); err != nil {
 			return err
 		}
 		corrupted = true
 		return nil
 	}); err != nil {
 		t.Fatalf("pack-datei beschaedigen: %v", err)
 	}
 	if !corrupted {
 		t.Fatal("keine pack-datei zum beschaedigen gefunden - testaufbau fehlerhaft")
 	}
 	if err := Check(ctx, cfg, true); err == nil {
 		t.Fatal("check haette die beschaedigte pack-datei erkennen muessen")
 	}
 }
 // TestForget_KeepsOnlyRequestedSnapshotCount prueft die Rotation.
 func TestForget_KeepsOnlyRequestedSnapshotCount(t *testing.T) {
 	cfg := setupTest(t)
 	ctx := context.Background()
 	sourceDir := t.TempDir()
 	for i := 0; i < 3; i++ {
 		writeFile(t, sourceDir, "f.txt", "version "+string(rune('a'+i)))
 		if _, err := Backup(ctx, cfg, sourceDir); err != nil {
 			t.Fatalf("sicherung %d: %v", i, err)
 		}
 	}
 	before, err := SnapshotCount(ctx, cfg)
 	if err != nil {
 		t.Fatalf("snapshotcount (vorher): %v", err)
 	}
 	if before != 3 {
 		t.Fatalf("erwartet 3 snapshots vor rotation, habe %d", before)
 	}
 	if err := Forget(ctx, cfg, 1); err != nil {
 		t.Fatalf("forget: %v", err)
 	}
 	after, err := SnapshotCount(ctx, cfg)
 	if err != nil {
 		t.Fatalf("snapshotcount (nachher): %v", err)
 	}
 	if after != 1 {
 		t.Fatalf("erwartet 1 snapshot nach rotation (keep-last 1), habe %d", after)
 	}
 }
@@ -7,6 +7,8 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 func main() {
@@ -15,16 +17,38 @@ func main() {
 		log.Fatalf("config: %v", err)
 	}
-	pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
+	ctx := context.Background()
 	registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
 	if err != nil {
-		log.Fatalf("db: %v", err)
+		log.Fatalf("registry db: %v", err)
 	}
-	defer pool.Close()
+	defer registryPool.Close()
 	adminPool, err := db.Connect(ctx, cfg.AdminDSN)
 	if err != nil {
 		log.Fatalf("admin db: %v", err)
 	}
 	defer adminPool.Close()
 	registry := tenant.NewRegistry(registryPool)
 	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
 	tenantHandler := tenant.NewHandler(provisioner)
 	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
 	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
 	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
 	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
 	superadmins := user.NewSuperadminStore(registryPool)
 	userHandler := user.NewHandler(nil, superadmins)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
 	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
@@ -1,9 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Datenbank-Vollsicherung (BAK-01)
 After=network.target postgresql.service
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-backup.env
 ExecStart=__INSTALL_DIR__/bin/backup-cli full
@@ -1,9 +0,0 @@
 [Unit]
 Description=Taeglicher Zeitplan fuer NEXARCH Archive Datenbank-Vollsicherung (BAK-01)
 [Timer]
 OnCalendar=*-*-* 02:00:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -1,9 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Datenbank-Inkrementalsicherung (BAK-01)
 After=network.target postgresql.service
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-backup.env
 ExecStart=__INSTALL_DIR__/bin/backup-cli incremental
@@ -1,9 +0,0 @@
 [Unit]
 Description=Stuendlicher Zeitplan fuer NEXARCH Archive Datenbank-Inkrementalsicherung (BAK-01)
 [Timer]
 OnCalendar=*-*-* *:00:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -1,9 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Sicherungsgenerationen-Rotation (BAK-01)
 After=network.target
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-backup.env
 ExecStart=__INSTALL_DIR__/bin/backup-cli rotate
@@ -1,9 +0,0 @@
 [Unit]
 Description=Taeglicher Zeitplan fuer NEXARCH Archive Sicherungsgenerationen-Rotation (BAK-01)
 [Timer]
 OnCalendar=*-*-* 03:00:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -1,9 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Objekt-Storage-Sicherung (BAK-02)
 After=network.target
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-objectbackup.env
 ExecStart=__INSTALL_DIR__/bin/objectbackup-cli backup __OBJECT_SOURCE_DIR__
@@ -1,9 +0,0 @@
 [Unit]
 Description=Stuendlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Sicherung (BAK-02)
 [Timer]
 OnCalendar=*-*-* *:30:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -1,9 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Objekt-Storage-Sicherung Vollstaendigkeitspruefung (BAK-02)
 After=network.target
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-objectbackup.env
 ExecStart=__INSTALL_DIR__/bin/objectbackup-cli check
@@ -1,9 +0,0 @@
 [Unit]
 Description=Woechentlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Vollstaendigkeitspruefung (BAK-02)
 [Timer]
 OnCalendar=Sun *-*-* 04:00:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -1,9 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Objekt-Storage-Sicherung Rotation (BAK-02)
 After=network.target
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-objectbackup.env
 ExecStart=__INSTALL_DIR__/bin/objectbackup-cli rotate
@@ -1,9 +0,0 @@
 [Unit]
 Description=Taeglicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Rotation (BAK-02)
 [Timer]
 OnCalendar=*-*-* 03:30:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -0,0 +1,73 @@
 # NEXARCH Core – Projektweite Sicherheits-Coding-Konventionen
 Stand: 2026-08-28. Ticket: IAM-15. Ergänzt `docs/TESTSTRATEGIE-CORE.md` (QA-01) um Coding-Regeln,
 die als Code-Review-Checkliste gelten — keine dieser Regeln ist optional oder "nur für ein Modul".
 ## 1. Warum dieses Dokument existiert
 Eine sicherheitsrelevante Coding-Regel, die nur einmal an einer Stelle vorgemacht statt projektweit
 verankert wird, wird beim nächsten neuen Vergleich vergessen. Das gilt für jede Regel in diesem
 Dokument gleichermaßen — die erste Regel (SQL) ist bereits als Konvention etabliert, die zweite
 (timing-safe Vergleich, IAM-15) macht sie hier zum ersten Mal explizit schriftlich.
 ## 2. Regel: Kein `fmt.Sprintf` für SQL-Bestandteile aus Nutzereingabe
 **Spalten-/Tabellennamen ausschließlich aus statischen Konstanten bzw. einem geschlossenen
 Enum/Switch-Typ, nie aus Nutzereingabe oder generischem String-Zusammenbau — auch nicht hinter
 einer Whitelist-Funktion.** Werte (nicht Bezeichner) gehören als Parameter (`$1`, `$2`, …) in die
 Query, niemals interpoliert.
 Lehre aus beiden Altsystemen (`known-issues-archivdms.md` Punkt 10, `known-issues-archivmail.md`
 Punkt 12): dynamische Tabellennamen via `fmt.Sprintf`, nur durch eine fragile Whitelist-Funktion
 abgesichert. Siehe DMS/Mail `SRC-11` für die board-spezifische Umsetzung dieser Regel im
 Suchindex-Kontext.
 **Referenzbeispiel (korrekt):** `internal/tenant/lifecycle.go`, `ProcessDueDeletions` — Statuswerte
 und IDs ausschließlich als Parameter (`$1`, `$2`, …), niemals interpoliert; der einzige Einsatz von
 `fmt.Sprintf` im Package baut einen **Datenbanknamen aus einem bereits validierten Slug**
 (`dbNameForSlug`, `slugPattern` in `tenant.go` erzwingt `^[a-z][a-z0-9_]{1,48}$` vor jeder
 Verwendung) — keine ungeprüfte Nutzereingabe erreicht die Query.
 ## 3. Regel: Timing-safe Vergleich für jede sicherheitsrelevante Zugriffsentscheidung (IAM-15)
 **Jeder Vergleich, der eine sicherheitsrelevante Zugriffsentscheidung trifft — Passwort-Hash, Token,
 Signatur, 2FA-Code/-Wiederherstellungscode — nutzt einen timing-safe/constant-time Vergleich, nie
 den regulären `==`-Operator.** Ein naiver `==`-Vergleich zweier Byte-Folgen bricht bei der ersten
 abweichenden Stelle ab; die dadurch messbare Laufzeitdifferenz lässt sich aus der Ferne ausmessen und
 erlaubt ein Byte-für-Byte-Erraten des korrekten Werts (Timing-Angriff).
 **So wird es gemacht:** `internal/timingsafe` (dieses Ticket) bündelt die kanonische Implementierung
 (`crypto/subtle.ConstantTimeCompare`) für neue Vergleichsstellen:
 ```go
 import "gitea.perlbach24.de/scripte/nexarch/internal/timingsafe"
 if !timingsafe.EqualString(providedCode, expectedCode) {
    return ErrInvalid
 }
 ```
 Ausnahme: `bcrypt.CompareHashAndPassword` (Passwort-Hashes) ist bereits von Haus aus timing-safe —
 hier ist kein zusätzlicher Wrapper nötig.
 ### 3.1 Audit bestehender Vergleichsstellen (Prüfung 2)
 Durchgeführt 2026-08-28, Ergebnis: **alle bestehenden sicherheitsrelevanten Vergleichsstellen
 implementierten die Regel bereits korrekt**, unabhängig voneinander mit `crypto/subtle` — nichts
 musste korrigiert werden (Akzeptanzkriterium 3, „ggf.").
 | Ort | Was wird verglichen | Fundstelle |
 |---|---|---|
 | `internal/totp/totp.go`, `Validate` | TOTP-Code (2FA) | nutzte bereits `subtle.ConstantTimeCompare` direkt, in diesem Ticket auf `timingsafe.EqualString` umgestellt (erster Verwender des neuen Packages) |
 | `internal/webhook/dispatcher.go`, `VerifySignature` | HMAC-Webhook-Signatur | `subtle.ConstantTimeCompare(expectedBytes, gotBytes)` |
 | `internal/moduleregistry/credentials.go`, `Authenticate` | Service-Credential-Secret-Hash | eigene `timingSafeEqual`-Hilfsfunktion, gleiches Muster |
 | `internal/authtoken/token.go`, `Consume` (Passwort-Reset/Einladung) | Einmal-Token | Hash-Lookup über DB-Index (`WHERE token_hash = $1`), kein manueller Byte-Vergleich nötig — bei zufälligen, hochentropischen Token ist der indexierte Hash-Abgleich gleichwertig sicher |
 Neue Vergleichsstellen sollen `internal/timingsafe` verwenden, statt das Muster erneut inline zu
 duplizieren — bestehende Stellen müssen dafür nicht umgebaut werden (kein Umbau angrenzender
 Bereiche über Board-Branch-Grenzen hinweg).
 ## 4. Wie diese Liste wächst
 Neue projektweite Sicherheits-Coding-Regeln werden hier ergänzt, sobald sie (wie SQL-Sprintf und
 timing-safe Vergleich) mehr als einmal unabhängig als Lehre auftauchen — nicht vorab spekulativ.
@@ -2,4 +2,16 @@ module gitea.perlbach24.de/scripte/nexarch
 go 1.22
-require github.com/jackc/pgx/v5 v5.6.0
+require (
 	github.com/golang-jwt/jwt/v5 v5.3.1
 	github.com/jackc/pgx/v5 v5.6.0
 	golang.org/x/crypto v0.17.0
 )
 require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 )
@@ -0,0 +1,30 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
 github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
 github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
 github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
 golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
 golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -0,0 +1,67 @@
 package auth
 import (
 	"encoding/json"
 	"net/http"
 	"time"
 )
 // Handler stellt Login/Logout als HTTP-Endpunkte bereit. Registrierung,
 // Passwort-Reset, 2FA, SSO/LDAP und Rate-Limiting sind ausdruecklich nicht
 // Teil dieser Kachel (siehe IAM-03..07).
 type Handler struct {
 	login *LoginService
 }
 func NewHandler(login *LoginService) *Handler {
 	return &Handler{login: login}
 }
 type loginRequest struct {
 	Email    string `json:"email"`
 	Password string `json:"password"`
 }
 func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
 	var req loginRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	token, err := h.login.Login(r.Context(), req.Email, req.Password)
 	if err != nil {
 		http.Error(w, ErrInvalidCredentials.Error(), http.StatusUnauthorized)
 		return
 	}
 	http.SetCookie(w, &http.Cookie{
 		Name:     CookieName,
 		Value:    token,
 		Path:     "/",
 		HttpOnly: true,
 		Secure:   true,
 		SameSite: http.SameSiteStrictMode,
 		MaxAge:   int(AccessTokenTTL.Seconds()),
 	})
 	w.WriteHeader(http.StatusOK)
 }
 // Logout loescht das Session-Cookie. Da JWT hier bewusst zustandslos bleibt
 // (kein serverseitiger Blocklist-Speicher — das waere ueber "Grundgerüst"
 // hinaus und widerspraeche der projektweiten zustandslosen-JWT-Entscheidung),
 // bleibt ein bereits ausgestelltes Token bis zu seinem Ablauf technisch
 // gueltig, wenn es separat vom Cookie extrahiert und wiederverwendet wird.
 func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
 	http.SetCookie(w, &http.Cookie{
 		Name:     CookieName,
 		Value:    "",
 		Path:     "/",
 		HttpOnly: true,
 		Secure:   true,
 		SameSite: http.SameSiteStrictMode,
 		MaxAge:   -1,
 		Expires:  time.Unix(0, 0),
 	})
 	w.WriteHeader(http.StatusOK)
 }
@@ -0,0 +1,56 @@
 package auth
 import (
 	"context"
 	"errors"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 var ErrInvalidCredentials = errors.New("auth: E-Mail oder Passwort falsch")
 // LoginService arbeitet gegen GENAU EINE Tenant-Datenbank (uebergeben ueber
 // den TenantUserStore-Pool) — das Login ist damit strukturell auf den
 // richtigen Tenant gescopt, siehe user.TenantUserStore.GetByEmailForAuth.
 type LoginService struct {
 	users  *user.TenantUserStore
 	issuer *TokenIssuer
 	// tenantSlug identifiziert im ausgestellten Token, gegen welchen Mandanten
 	// eingeloggt wurde (fuer nachgelagerte Pruefungen, z.B. Middleware-Logs).
 	tenantSlug string
 }
 func NewLoginService(users *user.TenantUserStore, issuer *TokenIssuer, tenantSlug string) *LoginService {
 	return &LoginService{users: users, issuer: issuer, tenantSlug: tenantSlug}
 }
 // Login liefert bei falscher E-Mail UND bei falschem Passwort denselben
 // Fehler (ErrInvalidCredentials), um keine Rueckschluesse auf die Existenz
 // eines Kontos zuzulassen (User-Enumeration-Schutz).
 func (s *LoginService) Login(ctx context.Context, email, password string) (string, error) {
 	creds, err := s.users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		// Trotzdem einen bcrypt-Vergleich gegen einen Dummy-Hash ausfuehren,
 		// damit die Antwortzeit bei unbekannter E-Mail nicht messbar kuerzer
 		// ist als bei falschem Passwort (Timing-Seitenkanal).
 		VerifyPassword(dummyHash, password)
 		return "", ErrInvalidCredentials
 	}
 	if creds.User.Status != user.StatusActive {
 		return "", ErrInvalidCredentials
 	}
 	if !VerifyPassword(creds.PasswordHash, password) {
 		return "", ErrInvalidCredentials
 	}
 	return s.issuer.Issue(creds.User.ID, s.tenantSlug)
 }
 // dummyHash ist ein echter bcrypt-Hash (Kostenfaktor BcryptCost) eines
 // beliebigen Platzhalter-Klartexts — bewusst KEIN kaputtes Format, da
 // bcrypt.CompareHashAndPassword bei ungueltigem Hash sofort ohne den
 // eigentlichen Kostenfaktor-Vergleich zurueckkehrt und die
 // Timing-Angleichung damit wirkungslos waere.
 const dummyHash = "$2a$12$cmwiETrG9DK5/uTM2fg4uetngYUspKjME5P8fNpk0QYTaO64N0r3C"
@@ -0,0 +1,177 @@
 package auth
 import (
 	"context"
 	"errors"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 const usersSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	password_hash TEXT NOT NULL DEFAULT '',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 func setupTenantDB(t *testing.T, dbName string) *pgxpool.Pool {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	adminPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
 	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
 		t.Fatalf("testdatenbank anlegen: %v", err)
 	}
 	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("connect testdatenbank: %v", err)
 	}
 	if _, err := pool.Exec(ctx, usersSchema); err != nil {
 		t.Fatalf("schema anwenden: %v", err)
 	}
 	t.Cleanup(func() {
 		pool.Close()
 		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 		adminPool.Close()
 	})
 	return pool
 }
 func createUserWithPassword(t *testing.T, store *user.TenantUserStore, email, password string) user.User {
 	t.Helper()
 	ctx := context.Background()
 	u, err := store.Create(ctx, email, "Test User")
 	if err != nil {
 		t.Fatalf("create user: %v", err)
 	}
 	hash, err := HashPassword(password)
 	if err != nil {
 		t.Fatalf("hash password: %v", err)
 	}
 	if err := store.SetPasswordHash(ctx, u.ID, hash); err != nil {
 		t.Fatalf("set password: %v", err)
 	}
 	return u
 }
 func TestLoginService_SuccessAndWrongPassword(t *testing.T) {
 	pool := setupTenantDB(t, "test_iam02_login")
 	store := user.NewTenantUserStore(pool)
 	createUserWithPassword(t, store, "alice@example.com", "korrektes-passwort")
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	login := NewLoginService(store, issuer, "acme")
 	token, err := login.Login(context.Background(), "alice@example.com", "korrektes-passwort")
 	if err != nil {
 		t.Fatalf("login: %v", err)
 	}
 	if token == "" {
 		t.Fatal("erwartet nicht-leeres token")
 	}
 	if _, err := login.Login(context.Background(), "alice@example.com", "falsches-passwort"); !errors.Is(err, ErrInvalidCredentials) {
 		t.Fatalf("erwartet ErrInvalidCredentials, habe %v", err)
 	}
 	if _, err := login.Login(context.Background(), "unbekannt@example.com", "irgendwas"); !errors.Is(err, ErrInvalidCredentials) {
 		t.Fatalf("erwartet ErrInvalidCredentials bei unbekannter email, habe %v", err)
 	}
 }
 // Pruefung 1: kein Cross-Tenant-Login moeglich, obwohl dieselbe E-Mail in
 // zwei unterschiedlichen Tenant-Datenbanken mit unterschiedlichen Passwoertern
 // existiert.
 func TestLoginService_NoCrossTenantLogin(t *testing.T) {
 	poolA := setupTenantDB(t, "test_iam02_tenant_a")
 	poolB := setupTenantDB(t, "test_iam02_tenant_b")
 	storeA := user.NewTenantUserStore(poolA)
 	storeB := user.NewTenantUserStore(poolB)
 	createUserWithPassword(t, storeA, "shared@example.com", "passwort-tenant-a")
 	createUserWithPassword(t, storeB, "shared@example.com", "passwort-tenant-b")
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	loginA := NewLoginService(storeA, issuer, "tenant-a")
 	// Login gegen Tenant A mit dem Passwort von Tenant B darf nicht klappen,
 	// obwohl die E-Mail-Adresse identisch ist — die Store-Instanz kennt
 	// strukturell nur die Zeilen ihrer eigenen Datenbank.
 	if _, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-b"); !errors.Is(err, ErrInvalidCredentials) {
 		t.Fatalf("erwartet ErrInvalidCredentials fuer fremdes tenant-passwort, habe %v", err)
 	}
 	token, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-a")
 	if err != nil {
 		t.Fatalf("login gegen eigenen tenant sollte klappen: %v", err)
 	}
 	claims, err := issuer.Verify(token)
 	if err != nil {
 		t.Fatalf("verify: %v", err)
 	}
 	if claims.TenantSlug != "tenant-a" {
 		t.Fatalf("token tenant = %q, want tenant-a", claims.TenantSlug)
 	}
 }
 // Akzeptanzkriterium 3: geschuetzte Route ohne gueltige Session nicht erreichbar.
 func TestRequireAuth_BlocksWithoutValidCookie(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	protected := RequireAuth(issuer, func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 	// Kein Cookie.
 	req := httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
 	rec := httptest.NewRecorder()
 	protected(rec, req)
 	if rec.Code != http.StatusUnauthorized {
 		t.Fatalf("ohne cookie: status = %d, want 401", rec.Code)
 	}
 	// Manipuliertes Cookie.
 	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
 	req.AddCookie(&http.Cookie{Name: CookieName, Value: "kaputt.token.hier"})
 	rec = httptest.NewRecorder()
 	protected(rec, req)
 	if rec.Code != http.StatusUnauthorized {
 		t.Fatalf("mit kaputtem cookie: status = %d, want 401", rec.Code)
 	}
 	// Gueltiges Token.
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
 	req.AddCookie(&http.Cookie{Name: CookieName, Value: token})
 	rec = httptest.NewRecorder()
 	protected(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("mit gueltigem cookie: status = %d, want 200", rec.Code)
 	}
 }
@@ -0,0 +1,41 @@
 package auth
 import (
 	"context"
 	"net/http"
 )
 const CookieName = "nexarch_session"
 type contextKey int
 const claimsContextKey contextKey = iota
 // RequireAuth schuetzt eine Route: ohne gueltiges, nicht abgelaufenes Token
 // im Session-Cookie wird 401 zurueckgegeben und der Handler nicht aufgerufen
 // (IAM-02 Akzeptanzkriterium 3).
 func RequireAuth(issuer *TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		cookie, err := r.Cookie(CookieName)
 		if err != nil {
 			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
 			return
 		}
 		claims, err := issuer.Verify(cookie.Value)
 		if err != nil {
 			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
 			return
 		}
 		ctx := context.WithValue(r.Context(), claimsContextKey, claims)
 		next(w, r.WithContext(ctx))
 	}
 }
 // ClaimsFromContext liest die Claims, die RequireAuth in den Request-Context
 // gelegt hat.
 func ClaimsFromContext(ctx context.Context) (*Claims, bool) {
 	c, ok := ctx.Value(claimsContextKey).(*Claims)
 	return c, ok
 }
@@ -0,0 +1,28 @@
 // Package auth implementiert Core IAM-02: Login/Logout, Passwort-Hashing und
 // die Middleware zum Schutz von Routen. Autorisierung (was ein Benutzer darf)
 // ist ausdruecklich NICHT Teil dieses Pakets, siehe RBAC-01 — auth prueft nur
 // "wer bin ich" (Casbin-Architekturprinzip, siehe IAM-02-Ticket).
 package auth
 import "golang.org/x/crypto/bcrypt"
 // BcryptCost ist bewusst explizit festgelegt statt bcrypt.DefaultCost (10)
 // unreflektiert zu uebernehmen (IAM-02 Akzeptanzkriterium 4). Kostenfaktor 12
 // wurde gegen die Ziel-Login-Latenz benchmarkt, siehe password_bench_test.go
 // und den Pruefungs-Eintrag in der Commit-Nachricht.
 const BcryptCost = 12
 func HashPassword(plain string) (string, error) {
 	hash, err := bcrypt.GenerateFromPassword([]byte(plain), BcryptCost)
 	if err != nil {
 		return "", err
 	}
 	return string(hash), nil
 }
 // VerifyPassword ist timing-safe: bcrypt.CompareHashAndPassword vergleicht
 // konstant in der Zeit bzgl. des Hash-Inhalts (Referenzimplementierung fuer
 // die projektweite Timing-safe-Vergleich-Konvention aus IAM-02).
 func VerifyPassword(hash, plain string) bool {
 	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
 }
@@ -0,0 +1,42 @@
 package auth
 import (
 	"testing"
 	"time"
 )
 // TargetLoginLatency ist der Zielwert aus IAM-02 Akzeptanzkriterium 4: der
 // bcrypt-Vergleich allein darf die Login-Latenz nicht dominieren. 400ms ist
 // grosszuegig genug, um auf unterschiedlicher Hardware stabil zu sein, aber
 // eng genug, um eine versehentliche Kostenfaktor-Explosion (z.B. 16 statt 12)
 // zuverlaessig aufzudecken.
 const TargetLoginLatency = 400 * time.Millisecond
 // TestBcryptCostAgainstLatencyTarget misst die tatsaechliche Dauer eines
 // Passwort-Vergleichs mit dem festgelegten BcryptCost und dokumentiert das
 // Ergebnis (IAM-02 Pruefung 4).
 func TestBcryptCostAgainstLatencyTarget(t *testing.T) {
 	hash, err := HashPassword("benchmark-passwort")
 	if err != nil {
 		t.Fatalf("hash: %v", err)
 	}
 	start := time.Now()
 	if !VerifyPassword(hash, "benchmark-passwort") {
 		t.Fatal("verifikation haette erfolgreich sein muessen")
 	}
 	elapsed := time.Since(start)
 	t.Logf("bcrypt-vergleich mit cost=%d dauerte %s (ziel: unter %s)", BcryptCost, elapsed, TargetLoginLatency)
 	if elapsed > TargetLoginLatency {
 		t.Fatalf("bcrypt-vergleich zu langsam: %s > ziel %s", elapsed, TargetLoginLatency)
 	}
 }
 func BenchmarkVerifyPassword(b *testing.B) {
 	hash, _ := HashPassword("benchmark-passwort")
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		VerifyPassword(hash, "benchmark-passwort")
 	}
 }
@@ -0,0 +1,28 @@
 package auth
 import "testing"
 func TestHashAndVerifyPassword(t *testing.T) {
 	hash, err := HashPassword("s3hr-geheim!")
 	if err != nil {
 		t.Fatalf("hash: %v", err)
 	}
 	if hash == "s3hr-geheim!" {
 		t.Fatal("passwort wurde nicht gehasht")
 	}
 	if !VerifyPassword(hash, "s3hr-geheim!") {
 		t.Fatal("erwartet erfolgreiche verifikation")
 	}
 	if VerifyPassword(hash, "falsches-passwort") {
 		t.Fatal("erwartet fehlgeschlagene verifikation")
 	}
 }
 func TestDummyHashIsValidBcryptHash(t *testing.T) {
 	// Stellt sicher, dass der Timing-Angleichs-Hash in login.go tatsaechlich
 	// ein gueltiges bcrypt-Format hat und den vollen Kostenfaktor durchlaeuft
 	// (siehe Kommentar dort) statt sofort mit einem Format-Fehler abzubrechen.
 	if VerifyPassword(dummyHash, "irgendein-text") {
 		t.Fatal("dummyHash sollte fuer beliebigen text nicht passen")
 	}
 }
@@ -0,0 +1,63 @@
 package auth
 import (
 	"errors"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 )
 // AccessTokenTTL ist bewusst kurz gehalten (Session-Ablauf statt langlebiger
 // Tokens), passend zur "so vertrauenswuerdig wie noetig"-Produkt-DNA.
 const AccessTokenTTL = 30 * time.Minute
 var ErrInvalidToken = errors.New("auth: ungueltiges oder abgelaufenes token")
 type Claims struct {
 	UserID     string `json:"uid"`
 	TenantSlug string `json:"tenant"`
 	jwt.RegisteredClaims
 }
 // TokenIssuer signiert/verifiziert JWTs mit einem HMAC-Secret. Das
 // asymmetrische Core-weite Signaturschema (API-05, kid-Rotation) ist
 // ausdruecklich nicht Teil dieser Kachel — hier geht es nur um das
 // Login-Grundgerüst innerhalb eines einzelnen Core-Prozesses.
 type TokenIssuer struct {
 	secret []byte
 }
 func NewTokenIssuer(secret string) *TokenIssuer {
 	return &TokenIssuer{secret: []byte(secret)}
 }
 func (i *TokenIssuer) Issue(userID, tenantSlug string) (string, error) {
 	now := time.Now()
 	claims := Claims{
 		UserID:     userID,
 		TenantSlug: tenantSlug,
 		RegisteredClaims: jwt.RegisteredClaims{
 			IssuedAt:  jwt.NewNumericDate(now),
 			ExpiresAt: jwt.NewNumericDate(now.Add(AccessTokenTTL)),
 		},
 	}
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	return token.SignedString(i.secret)
 }
 // Verify prueft Signatur UND Ablauf (jwt.ParseWithClaims lehnt abgelaufene
 // Tokens automatisch ab) — der Signaturvergleich in golang-jwt ist
 // timing-safe (hmac.Equal).
 func (i *TokenIssuer) Verify(tokenString string) (*Claims, error) {
 	claims := &Claims{}
 	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
 		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
 			return nil, ErrInvalidToken
 		}
 		return i.secret, nil
 	})
 	if err != nil || !token.Valid {
 		return nil, ErrInvalidToken
 	}
 	return claims, nil
 }
@@ -0,0 +1,82 @@
 package auth
 import (
 	"strings"
 	"testing"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 )
 func TestTokenIssueAndVerify(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	claims, err := issuer.Verify(token)
 	if err != nil {
 		t.Fatalf("verify: %v", err)
 	}
 	if claims.UserID != "user-1" || claims.TenantSlug != "acme" {
 		t.Fatalf("claims unerwartet: %+v", claims)
 	}
 }
 // Pruefung 2: Token-Manipulationstest.
 func TestTokenVerify_RejectsManipulatedPayload(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	parts := strings.Split(token, ".")
 	if len(parts) != 3 {
 		t.Fatalf("unerwartetes token-format: %d teile", len(parts))
 	}
 	// Payload-Segment leicht veraendern (Signatur passt danach nicht mehr).
 	tampered := parts[0] + "." + parts[1] + "x" + "." + parts[2]
 	if _, err := issuer.Verify(tampered); err == nil {
 		t.Fatal("erwartet fehler bei manipuliertem token, habe nil")
 	}
 }
 func TestTokenVerify_RejectsWrongSecret(t *testing.T) {
 	issuer := NewTokenIssuer("secret-a")
 	other := NewTokenIssuer("secret-b")
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	if _, err := other.Verify(token); err == nil {
 		t.Fatal("erwartet fehler bei falschem secret, habe nil")
 	}
 }
 // Pruefung 3: abgelaufenes Token erzwingt Neuanmeldung.
 func TestTokenVerify_RejectsExpiredToken(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	claims := Claims{
 		UserID:     "user-1",
 		TenantSlug: "acme",
 		RegisteredClaims: jwt.RegisteredClaims{
 			IssuedAt:  jwt.NewNumericDate(time.Now().Add(-2 * AccessTokenTTL)),
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Minute)),
 		},
 	}
 	tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	expired, err := tok.SignedString([]byte("test-secret-nur-fuer-tests"))
 	if err != nil {
 		t.Fatalf("signieren: %v", err)
 	}
 	if _, err := issuer.Verify(expired); err == nil {
 		t.Fatal("erwartet fehler bei abgelaufenem token, habe nil")
 	}
 }
@@ -10,8 +10,15 @@ import (
 // connection info, superadmin accounts) — see nexarch-state.json
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
-	ListenAddr  string
+	ListenAddr string
 	// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
 	RegistryDSN string
 	// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
 	// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
 	AdminDSN string
 	// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
 	// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
 	TenantDSNTemplate string
 }
 func Load() (Config, error) {
@@ -20,10 +27,25 @@ func Load() (Config, error) {
 		return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
 	}
 	adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
 	if adminDSN == "" {
 		return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
 	}
 	dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
 	if dsnTemplate == "" {
 		return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
 	}
 	addr := os.Getenv("NEXARCH_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8080"
 	}
-	return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
+	return Config{
 		ListenAddr:        addr,
 		RegistryDSN:       dsn,
 		AdminDSN:          adminDSN,
 		TenantDSNTemplate: dsnTemplate,
 	}, nil
 }
@@ -0,0 +1,45 @@
 package tenant
 import (
 	"encoding/json"
 	"net/http"
 )
 // Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
 // (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
 // Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
 // TEN-01 und werden dort nachgezogen.
 type Handler struct {
 	provisioner *Provisioner
 }
 func NewHandler(p *Provisioner) *Handler {
 	return &Handler{provisioner: p}
 }
 type createTenantRequest struct {
 	Slug string `json:"slug"`
 	Name string `json:"name"`
 }
 func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
 	var req createTenantRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
 	if err != nil {
 		if err == ErrInvalidSlug {
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
 		http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusCreated)
 	_ = json.NewEncoder(w).Encode(t)
 }
@@ -0,0 +1,78 @@
 package tenant
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
 // PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
 // (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
 // Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
 type Provisioner struct {
 	// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
 	// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
 	// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
 	adminPool *pgxpool.Pool
 	registry  *Registry
 	// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
 	// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
 	dsnTemplate string
 }
 func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
 	return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
 }
 // Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
 // Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
 // damit kein verwaister, unregistrierter Tenant zurueckbleibt.
 func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
 	if err := ValidateSlug(slug); err != nil {
 		return Tenant{}, err
 	}
 	dbName := dbNameForSlug(slug)
 	// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
 	// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
 	if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
 		return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
 	}
 	t := Tenant{
 		Slug:   slug,
 		Name:   name,
 		DBName: dbName,
 		DBDSN:  fmt.Sprintf(p.dsnTemplate, dbName),
 		Status: StatusActive,
 	}
 	tx, err := p.registry.pool.Begin(ctx)
 	if err != nil {
 		p.rollbackDatabase(ctx, dbName)
 		return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
 	}
 	created, err := p.registry.insertTx(ctx, tx, t)
 	if err != nil {
 		_ = tx.Rollback(ctx)
 		p.rollbackDatabase(ctx, dbName)
 		return Tenant{}, err
 	}
 	if err := tx.Commit(ctx); err != nil {
 		p.rollbackDatabase(ctx, dbName)
 		return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
 	}
 	return created, nil
 }
 // rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
 // Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
 func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
 	_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 }
@@ -0,0 +1,105 @@
 package tenant
 import (
 	"context"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
 // Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
 // fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
 //
 // TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
 //
 //	postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
 func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	adminPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
 	defer adminPool.Close()
 	registryPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("registry pool: %v", err)
 	}
 	defer registryPool.Close()
 	if _, err := registryPool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS tenants (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			slug TEXT NOT NULL UNIQUE,
 			name TEXT NOT NULL,
 			db_name TEXT NOT NULL UNIQUE,
 			db_dsn TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'active',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		)`); err != nil {
 		t.Fatalf("registry-schema: %v", err)
 	}
 	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
 	registry := NewRegistry(registryPool)
 	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
 	t.Cleanup(func() {
 		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
 		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
 		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
 	})
 	tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
 	if err != nil {
 		t.Fatalf("provision acme: %v", err)
 	}
 	tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
 	if err != nil {
 		t.Fatalf("provision globex: %v", err)
 	}
 	if tenantA.DBName == tenantB.DBName {
 		t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
 	}
 	// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
 	// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
 	// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
 	poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
 	if err != nil {
 		t.Fatalf("connect tenant a: %v", err)
 	}
 	defer poolA.Close()
 	var globexVisible bool
 	err = poolA.QueryRow(ctx, `
 		SELECT EXISTS (
 			SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
 		)
 	`, tenantB.DBName).Scan(&globexVisible)
 	if err != nil {
 		t.Fatalf("pruefung tenant-trennung: %v", err)
 	}
 	// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
 	// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
 	// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
 	var currentDB string
 	if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(&currentDB); err != nil {
 		t.Fatalf("current_database: %v", err)
 	}
 	if currentDB != tenantA.DBName {
 		t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
 	}
 	if currentDB == tenantB.DBName {
 		t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
 	}
 }
@@ -0,0 +1,69 @@
 package tenant
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
 // Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
 // niemals Geschaeftsdaten eines Mandanten.
 type Registry struct {
 	pool *pgxpool.Pool
 }
 func NewRegistry(pool *pgxpool.Pool) *Registry {
 	return &Registry{pool: pool}
 }
 // insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
 // damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
 func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
 	row := tx.QueryRow(ctx, `
 		INSERT INTO tenants (slug, name, db_name, db_dsn, status)
 		VALUES ($1, $2, $3, $4, $5)
 		RETURNING id, created_at
 	`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
 	if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
 		return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
 	}
 	return t, nil
 }
 func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
 	var t Tenant
 	row := r.pool.QueryRow(ctx, `
 		SELECT id, slug, name, db_name, db_dsn, status, created_at
 		FROM tenants WHERE slug = $1
 	`, slug)
 	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
 		return Tenant{}, fmt.Errorf("tenant laden: %w", err)
 	}
 	return t, nil
 }
 func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
 	rows, err := r.pool.Query(ctx, `
 		SELECT id, slug, name, db_name, db_dsn, status, created_at
 		FROM tenants ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("tenants auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Tenant
 	for rows.Next() {
 		var t Tenant
 		if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
 			return nil, fmt.Errorf("tenant lesen: %w", err)
 		}
 		out = append(out, t)
 	}
 	return out, rows.Err()
 }
@@ -0,0 +1,42 @@
 // Package tenant implements Core TEN-01: die Control-Plane-Registry und die
 // Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
 package tenant
 import (
 	"errors"
 	"regexp"
 	"time"
 )
 type Status string
 const (
 	StatusActive Status = "active"
 )
 type Tenant struct {
 	ID        string
 	Slug      string
 	Name      string
 	DBName    string
 	DBDSN     string
 	Status    Status
 	CreatedAt time.Time
 }
 // slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
 // der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
 var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
 var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
 func ValidateSlug(slug string) error {
 	if !slugPattern.MatchString(slug) {
 		return ErrInvalidSlug
 	}
 	return nil
 }
 func dbNameForSlug(slug string) string {
 	return "tenant_" + slug
 }
@@ -0,0 +1,35 @@
 package tenant
 import "testing"
 func TestValidateSlug(t *testing.T) {
 	cases := []struct {
 		slug    string
 		wantErr bool
 	}{
 		{"acme", false},
 		{"acme_gmbh", false},
 		{"a1", false},
 		{"", true},
 		{"a", true},
 		{"1acme", true},
 		{"Acme", true},
 		{"acme-gmbh", true},
 		{"acme;drop table tenants", true},
 	}
 	for _, c := range cases {
 		err := ValidateSlug(c.slug)
 		if (err != nil) != c.wantErr {
 			t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
 		}
 	}
 }
 func TestDBNameForSlug(t *testing.T) {
 	got := dbNameForSlug("acme")
 	want := "tenant_acme"
 	if got != want {
 		t.Errorf("dbNameForSlug() = %q, want %q", got, want)
 	}
 }
@@ -0,0 +1,30 @@
 // Package timingsafe stellt die kanonische Implementierung der projektweiten
 // Coding-Konvention aus IAM-15 bereit: jeder Vergleich, der eine
 // sicherheitsrelevante Zugriffsentscheidung trifft (Passwort-Hash, Token,
 // Signatur, 2FA-Wiederherstellungscode), nutzt einen timing-safe/constant-time
 // Vergleich, nie den regulaeren ==-Operator. Siehe docs/CODING-GUIDELINES-CORE.md.
 //
 // Bestehende Vergleichsstellen (internal/totp, internal/webhook,
 // internal/moduleregistry) implementieren dasselbe Muster bereits inline mit
 // crypto/subtle direkt — dieses Package buendelt es fuer neue Vergleichsstellen,
 // ersetzt die bestehenden nicht zwangsweise (kein Umbau angrenzender Bereiche).
 package timingsafe
 import "crypto/subtle"
 // Equal vergleicht zwei Byte-Slices timing-safe. Unterschiedliche Laenge gilt
 // als "nicht gleich", ohne dass die Laufzeit dabei die Laenge verraet, die
 // zum Ergebnis gefuehrt hat, mehr als durch den Laengenunterschied ohnehin
 // unvermeidbar waere.
 func Equal(a, b []byte) bool {
 	if len(a) != len(b) {
 		return false
 	}
 	return subtle.ConstantTimeCompare(a, b) == 1
 }
 // EqualString ist die String-Variante von Equal fuer den haeufigen Fall,
 // dass beide Seiten bereits als string vorliegen (z. B. TOTP-Codes).
 func EqualString(a, b string) bool {
 	return Equal([]byte(a), []byte(b))
 }
@@ -0,0 +1,36 @@
 package timingsafe
 import "testing"
 func TestEqual_SameBytes(t *testing.T) {
 	if !Equal([]byte("geheimnis"), []byte("geheimnis")) {
 		t.Fatal("identische Byte-Slices sollten gleich sein")
 	}
 }
 func TestEqual_DifferentBytes(t *testing.T) {
 	if Equal([]byte("geheimnis"), []byte("anders123")) {
 		t.Fatal("unterschiedliche Byte-Slices sollten ungleich sein")
 	}
 }
 func TestEqual_DifferentLength(t *testing.T) {
 	if Equal([]byte("kurz"), []byte("laengererstring")) {
 		t.Fatal("unterschiedliche Laenge sollte immer ungleich sein")
 	}
 }
 func TestEqual_EmptyVsEmpty(t *testing.T) {
 	if !Equal([]byte(""), []byte("")) {
 		t.Fatal("zwei leere Slices sollten gleich sein")
 	}
 }
 func TestEqualString_MatchesEqual(t *testing.T) {
 	if !EqualString("abc123", "abc123") {
 		t.Fatal("identische Strings sollten gleich sein")
 	}
 	if EqualString("abc123", "xyz789") {
 		t.Fatal("unterschiedliche Strings sollten ungleich sein")
 	}
 }
@@ -0,0 +1,42 @@
 package totp
 import (
 	"context"
 	"errors"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 var ErrSecondFactorRequired = errors.New("totp: zweiter faktor erforderlich")
 // LoginWithTOTP komponiert IAM-02s LoginService mit der 2FA-Pruefung, ohne
 // LoginService selbst zu veraendern. Ist 2FA fuer den Benutzer aktiv, MUSS
 // totpCode gueltig sein (Akzeptanzkriterium 2) — ein leerer/falscher Code
 // wird zuverlaessig abgewiesen, auch bei korrektem Passwort.
 func LoginWithTOTP(ctx context.Context, users *user.TenantUserStore, totpStore *Store, login *auth.LoginService, email, password, totpCode string) (token string, err error) {
 	creds, err := users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		return "", auth.ErrInvalidCredentials
 	}
 	enabled, err := totpStore.IsEnabled(ctx, creds.User.ID)
 	if err != nil {
 		return "", err
 	}
 	if enabled {
 		if totpCode == "" {
 			return "", ErrSecondFactorRequired
 		}
 		ok, err := totpStore.VerifyLoginCode(ctx, creds.User.ID, totpCode)
 		if err != nil {
 			return "", err
 		}
 		if !ok {
 			return "", ErrSecondFactorRequired
 		}
 	}
 	return login.Login(ctx, email, password)
 }
@@ -0,0 +1,163 @@
 package totp
 import (
 	"context"
 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	ErrInvalidCode      = errors.New("totp: code ungueltig")
 	ErrNotConfirmed     = errors.New("totp: einrichtung noch nicht bestaetigt")
 	ErrRecoveryCodeUsed = errors.New("totp: wiederherstellungscode bereits verwendet oder ungueltig")
 )
 const RecoveryCodeCount = 10
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // BeginSetup erzeugt ein neues Secret fuer einen Benutzer und speichert es
 // als NOCH NICHT bestaetigt — der Code muss vor Aktivierung einmal
 // verifiziert werden (Akzeptanzkriterium 1).
 func (s *Store) BeginSetup(ctx context.Context, userID, issuer, accountName string) (secret, provisioningURI string, err error) {
 	secret, err = GenerateSecret()
 	if err != nil {
 		return "", "", err
 	}
 	_, err = s.pool.Exec(ctx, `
 		INSERT INTO totp_credentials (user_id, secret, confirmed)
 		VALUES ($1, $2, false)
 		ON CONFLICT (user_id) DO UPDATE SET secret = $2, confirmed = false
 	`, userID, secret)
 	if err != nil {
 		return "", "", fmt.Errorf("totp-einrichtung speichern: %w", err)
 	}
 	return secret, ProvisioningURI(issuer, accountName, secret), nil
 }
 // ConfirmSetup verifiziert den ersten eingegebenen Code und aktiviert 2FA
 // erst dann (Akzeptanzkriterium 1). Bei Erfolg werden einmalig
 // Wiederherstellungscodes erzeugt und im Klartext zurueckgegeben — gespeichert
 // wird nur deren Hash.
 func (s *Store) ConfirmSetup(ctx context.Context, userID, code string) (recoveryCodes []string, err error) {
 	var secret string
 	if err := s.pool.QueryRow(ctx, `
 		SELECT secret FROM totp_credentials WHERE user_id = $1
 	`, userID).Scan(&secret); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrNotConfirmed
 		}
 		return nil, fmt.Errorf("secret lesen: %w", err)
 	}
 	ok, err := Validate(secret, code, time.Now())
 	if err != nil {
 		return nil, err
 	}
 	if !ok {
 		return nil, ErrInvalidCode
 	}
 	if _, err := s.pool.Exec(ctx, `UPDATE totp_credentials SET confirmed = true WHERE user_id = $1`, userID); err != nil {
 		return nil, fmt.Errorf("bestaetigung speichern: %w", err)
 	}
 	recoveryCodes, err = s.generateRecoveryCodes(ctx, userID)
 	if err != nil {
 		return nil, err
 	}
 	return recoveryCodes, nil
 }
 func (s *Store) generateRecoveryCodes(ctx context.Context, userID string) ([]string, error) {
 	codes := make([]string, RecoveryCodeCount)
 	for i := range codes {
 		buf := make([]byte, 8)
 		if _, err := rand.Read(buf); err != nil {
 			return nil, fmt.Errorf("wiederherstellungscode erzeugen: %w", err)
 		}
 		code := hex.EncodeToString(buf)
 		codes[i] = code
 		hash := hashRecoveryCode(code)
 		if _, err := s.pool.Exec(ctx, `
 			INSERT INTO totp_recovery_codes (user_id, code_hash) VALUES ($1, $2)
 		`, userID, hash); err != nil {
 			return nil, fmt.Errorf("wiederherstellungscode speichern: %w", err)
 		}
 	}
 	return codes, nil
 }
 // IsEnabled prueft, ob 2FA fuer einen Benutzer aktiv (bestaetigt) ist.
 func (s *Store) IsEnabled(ctx context.Context, userID string) (bool, error) {
 	var confirmed bool
 	err := s.pool.QueryRow(ctx, `SELECT confirmed FROM totp_credentials WHERE user_id = $1`, userID).Scan(&confirmed)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return false, nil
 		}
 		return false, fmt.Errorf("status lesen: %w", err)
 	}
 	return confirmed, nil
 }
 // VerifyLoginCode akzeptiert entweder einen gueltigen TOTP-Code oder einen
 // noch nicht verwendeten Wiederherstellungscode (Akzeptanzkriterium 2 + 3).
 func (s *Store) VerifyLoginCode(ctx context.Context, userID, code string) (bool, error) {
 	var secret string
 	var confirmed bool
 	err := s.pool.QueryRow(ctx, `SELECT secret, confirmed FROM totp_credentials WHERE user_id = $1`, userID).Scan(&secret, &confirmed)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) || !confirmed {
 			return false, nil
 		}
 		return false, fmt.Errorf("secret lesen: %w", err)
 	}
 	if !confirmed {
 		return false, nil
 	}
 	if ok, err := Validate(secret, code, time.Now()); err != nil {
 		return false, err
 	} else if ok {
 		return true, nil
 	}
 	return s.consumeRecoveryCode(ctx, userID, code)
 }
 // consumeRecoveryCode markiert einen Wiederherstellungscode atomar als
 // verwendet (WHERE used_at IS NULL) — ein bereits verbrauchter Code kann
 // nicht doppelt eingeloest werden (Akzeptanzkriterium 3 / Pruefung 2).
 func (s *Store) consumeRecoveryCode(ctx context.Context, userID, code string) (bool, error) {
 	hash := hashRecoveryCode(code)
 	tag, err := s.pool.Exec(ctx, `
 		UPDATE totp_recovery_codes SET used_at = now()
 		WHERE user_id = $1 AND code_hash = $2 AND used_at IS NULL
 	`, userID, hash)
 	if err != nil {
 		return false, fmt.Errorf("wiederherstellungscode einloesen: %w", err)
 	}
 	return tag.RowsAffected() == 1, nil
 }
 func hashRecoveryCode(code string) []byte {
 	sum := sha256.Sum256([]byte(code))
 	return sum[:]
 }
@@ -0,0 +1,185 @@
 package totp
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 func setupTest(t *testing.T) (*Store, *user.TenantUserStore, string, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS users (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS totp_credentials (
 			user_id UUID PRIMARY KEY REFERENCES users(id), secret TEXT NOT NULL,
 			confirmed BOOLEAN NOT NULL DEFAULT false, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS totp_recovery_codes (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL REFERENCES users(id),
 			code_hash BYTEA NOT NULL UNIQUE, used_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	userStore := user.NewTenantUserStore(pool)
 	email := fmt.Sprintf("totp-test-%d@example.com", time.Now().UnixNano())
 	u, err := userStore.Create(ctx, email, "TOTP Test")
 	if err != nil {
 		t.Fatalf("create user: %v", err)
 	}
 	hash, err := auth.HashPassword("korrektes-passwort")
 	if err != nil {
 		t.Fatalf("hash: %v", err)
 	}
 	if err := userStore.SetPasswordHash(ctx, u.ID, hash); err != nil {
 		t.Fatalf("set password: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewStore(pool), userStore, u.ID, cleanup
 }
 // Akzeptanzkriterium 1: Einrichtung per QR-Code (URI), Bestaetigung vor Aktivierung.
 func TestBeginAndConfirmSetup(t *testing.T) {
 	store, _, userID, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	secret, uri, err := store.BeginSetup(ctx, userID, "NEXARCH", "user@example.com")
 	if err != nil {
 		t.Fatalf("begin setup: %v", err)
 	}
 	if uri == "" {
 		t.Fatal("erwartet nicht-leere provisioning-uri")
 	}
 	enabled, err := store.IsEnabled(ctx, userID)
 	if err != nil {
 		t.Fatalf("is enabled (vor bestaetigung): %v", err)
 	}
 	if enabled {
 		t.Fatal("erwartet NICHT aktiviert vor bestaetigung")
 	}
 	// Falscher Code darf nicht aktivieren.
 	if _, err := store.ConfirmSetup(ctx, userID, "000000"); !errors.Is(err, ErrInvalidCode) && err == nil {
 		t.Fatalf("erwartet ablehnung bei falschem code, habe err=%v", err)
 	}
 	code, err := GenerateCode(secret, time.Now())
 	if err != nil {
 		t.Fatalf("generate code: %v", err)
 	}
 	recoveryCodes, err := store.ConfirmSetup(ctx, userID, code)
 	if err != nil {
 		t.Fatalf("confirm setup: %v", err)
 	}
 	if len(recoveryCodes) != RecoveryCodeCount {
 		t.Fatalf("erwartet %d wiederherstellungscodes, habe %d", RecoveryCodeCount, len(recoveryCodes))
 	}
 	enabled, err = store.IsEnabled(ctx, userID)
 	if err != nil {
 		t.Fatalf("is enabled (nach bestaetigung): %v", err)
 	}
 	if !enabled {
 		t.Fatal("erwartet aktiviert nach erfolgreicher bestaetigung")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: Login ohne zweiten Faktor bei aktivem
 // 2FA wird zuverlaessig abgewiesen.
 func TestLoginWithTOTP_RequiresSecondFactorWhenEnabled(t *testing.T) {
 	store, userStore, userID, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	secret, _, err := store.BeginSetup(ctx, userID, "NEXARCH", "user@example.com")
 	if err != nil {
 		t.Fatalf("begin setup: %v", err)
 	}
 	code, _ := GenerateCode(secret, time.Now())
 	if _, err := store.ConfirmSetup(ctx, userID, code); err != nil {
 		t.Fatalf("confirm setup: %v", err)
 	}
 	u, err := userStore.Get(ctx, userID)
 	if err != nil {
 		t.Fatalf("get user: %v", err)
 	}
 	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
 	loginService := auth.NewLoginService(userStore, issuer, "acme")
 	// Korrektes Passwort, aber KEIN 2FA-Code -> abgewiesen.
 	if _, err := LoginWithTOTP(ctx, userStore, store, loginService, u.Email, "korrektes-passwort", ""); !errors.Is(err, ErrSecondFactorRequired) {
 		t.Fatalf("erwartet ErrSecondFactorRequired ohne code, habe %v", err)
 	}
 	// Korrektes Passwort + korrekter aktueller Code -> erfolgreich.
 	loginCode, _ := GenerateCode(secret, time.Now())
 	token, err := LoginWithTOTP(ctx, userStore, store, loginService, u.Email, "korrektes-passwort", loginCode)
 	if err != nil {
 		t.Fatalf("login mit gueltigem 2fa-code: %v", err)
 	}
 	if token == "" {
 		t.Fatal("erwartet gueltiges token")
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 2: Wiederherstellungscode nach Nutzung als
 // verbraucht getestet.
 func TestVerifyLoginCode_RecoveryCodeIsSingleUse(t *testing.T) {
 	store, _, userID, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	secret, _, err := store.BeginSetup(ctx, userID, "NEXARCH", "user@example.com")
 	if err != nil {
 		t.Fatalf("begin setup: %v", err)
 	}
 	code, _ := GenerateCode(secret, time.Now())
 	recoveryCodes, err := store.ConfirmSetup(ctx, userID, code)
 	if err != nil {
 		t.Fatalf("confirm setup: %v", err)
 	}
 	recovery := recoveryCodes[0]
 	ok, err := store.VerifyLoginCode(ctx, userID, recovery)
 	if err != nil {
 		t.Fatalf("verify (erste nutzung): %v", err)
 	}
 	if !ok {
 		t.Fatal("erwartet erfolgreiche erste nutzung des wiederherstellungscodes")
 	}
 	ok, err = store.VerifyLoginCode(ctx, userID, recovery)
 	if err != nil {
 		t.Fatalf("verify (zweite nutzung): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet abgelehnt bei erneuter nutzung desselben wiederherstellungscodes")
 	}
 }
@@ -0,0 +1,105 @@
 // Package totp implementiert Core IAM-04: TOTP-basierte Zwei-Faktor-
 // Authentifizierung (RFC 6238, aufbauend auf HOTP RFC 4226) mit stdlib
 // crypto/hmac+sha1 — kein externes Modul noetig.
 package totp
 import (
 	"crypto/hmac"
 	"crypto/rand"
 	"crypto/sha1"
 	"encoding/base32"
 	"encoding/binary"
 	"fmt"
 	"net/url"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/internal/timingsafe"
 )
 // StepSeconds ist das TOTP-Zeitfenster (RFC-6238-Standard: 30 Sekunden).
 const StepSeconds = 30
 // DefaultSkewSteps ist die dokumentierte Zeitversatz-Toleranz
 // (Akzeptanzkriterium/Pruefung 3): +/- 1 Schritt = +/- 30 Sekunden um die
 // aktuelle Serverzeit, insgesamt ein 90-Sekunden-Fenster. Grosszuegig genug
 // fuer leicht abweichende Client-Uhren, eng genug um ein TOTP-Fenster nicht
 // unbrauchbar lange gueltig zu lassen.
 const DefaultSkewSteps = 1
 // GenerateSecret erzeugt ein neues, zufaelliges TOTP-Secret (20 Byte, wie von
 // Authenticator-Apps erwartet), Base32-kodiert ohne Padding.
 func GenerateSecret() (string, error) {
 	buf := make([]byte, 20)
 	if _, err := rand.Read(buf); err != nil {
 		return "", fmt.Errorf("secret erzeugen: %w", err)
 	}
 	return base32.StdEncoding.WithPadding(base32.NoPadding).EncodeToString(buf), nil
 }
 // ProvisioningURI liefert die otpauth://-URI fuer den QR-Code
 // (Akzeptanzkriterium 1) — das eigentliche QR-Rendering ist Frontend-Sache
 // (IAM-08), hier wird nur die standardkonforme URI erzeugt.
 func ProvisioningURI(issuer, accountName, secret string) string {
 	label := url.PathEscape(issuer) + ":" + url.PathEscape(accountName)
 	q := url.Values{}
 	q.Set("secret", secret)
 	q.Set("issuer", issuer)
 	q.Set("algorithm", "SHA1")
 	q.Set("digits", "6")
 	q.Set("period", fmt.Sprintf("%d", StepSeconds))
 	return fmt.Sprintf("otpauth://totp/%s?%s", label, q.Encode())
 }
 // GenerateCode berechnet den 6-stelligen TOTP-Code fuer secret zum Zeitpunkt t.
 func GenerateCode(secret string, t time.Time) (string, error) {
 	key, err := decodeSecret(secret)
 	if err != nil {
 		return "", err
 	}
 	counter := uint64(t.Unix() / StepSeconds)
 	return hotp(key, counter), nil
 }
 // Validate prueft code gegen secret mit der dokumentierten Zeitversatz-
 // Toleranz (DefaultSkewSteps) um t. Vergleich ist timing-safe.
 func Validate(secret, code string, t time.Time) (bool, error) {
 	key, err := decodeSecret(secret)
 	if err != nil {
 		return false, err
 	}
 	counter := int64(t.Unix() / StepSeconds)
 	for delta := -DefaultSkewSteps; delta <= DefaultSkewSteps; delta++ {
 		candidate := hotp(key, uint64(counter+int64(delta)))
 		if timingsafe.EqualString(candidate, code) {
 			return true, nil
 		}
 	}
 	return false, nil
 }
 func decodeSecret(secret string) ([]byte, error) {
 	key, err := base32.StdEncoding.WithPadding(base32.NoPadding).DecodeString(secret)
 	if err != nil {
 		return nil, fmt.Errorf("secret dekodieren: %w", err)
 	}
 	return key, nil
 }
 // hotp implementiert RFC 4226 mit HMAC-SHA1, 6 Ziffern.
 func hotp(key []byte, counter uint64) string {
 	buf := make([]byte, 8)
 	binary.BigEndian.PutUint64(buf, counter)
 	mac := hmac.New(sha1.New, key)
 	mac.Write(buf)
 	sum := mac.Sum(nil)
 	offset := sum[len(sum)-1] & 0x0f
 	code := (uint32(sum[offset]&0x7f) << 24) |
 		(uint32(sum[offset+1]) << 16) |
 		(uint32(sum[offset+2]) << 8) |
 		uint32(sum[offset+3])
 	return fmt.Sprintf("%06d", code%1000000)
 }
@@ -0,0 +1,79 @@
 package totp
 import (
 	"testing"
 	"time"
 )
 func TestGenerateAndValidateCode_RoundTrip(t *testing.T) {
 	secret, err := GenerateSecret()
 	if err != nil {
 		t.Fatalf("generate secret: %v", err)
 	}
 	now := time.Now()
 	code, err := GenerateCode(secret, now)
 	if err != nil {
 		t.Fatalf("generate code: %v", err)
 	}
 	if len(code) != 6 {
 		t.Fatalf("erwartet 6-stelligen code, habe %q", code)
 	}
 	ok, err := Validate(secret, code, now)
 	if err != nil {
 		t.Fatalf("validate: %v", err)
 	}
 	if !ok {
 		t.Fatal("erwartet gueltigen code")
 	}
 	wrongCode := "000000"
 	if code == wrongCode {
 		wrongCode = "111111"
 	}
 	ok, err = Validate(secret, wrongCode, now)
 	if err != nil {
 		t.Fatalf("validate (falsch): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet ungueltig fuer falschen code")
 	}
 }
 // Akzeptanzkriterium/Pruefung 3: Zeitversatz-Toleranz dokumentiert (siehe
 // DefaultSkewSteps = 1 Schritt = 30s) und getestet.
 func TestValidate_ClockSkewTolerance(t *testing.T) {
 	secret, err := GenerateSecret()
 	if err != nil {
 		t.Fatalf("generate secret: %v", err)
 	}
 	now := time.Now()
 	// Code aus dem VORHERIGEN Zeitfenster (bis zu 30s in der Vergangenheit)
 	// muss innerhalb der dokumentierten Toleranz noch akzeptiert werden.
 	pastCode, err := GenerateCode(secret, now.Add(-25*time.Second))
 	if err != nil {
 		t.Fatalf("generate code (past): %v", err)
 	}
 	ok, err := Validate(secret, pastCode, now)
 	if err != nil {
 		t.Fatalf("validate (past): %v", err)
 	}
 	if !ok {
 		t.Fatal("erwartet gueltig innerhalb der dokumentierten skew-toleranz (25s)")
 	}
 	// Code weit ausserhalb der Toleranz (mehrere Schritte in der
 	// Vergangenheit) muss abgelehnt werden.
 	farPastCode, err := GenerateCode(secret, now.Add(-5*time.Minute))
 	if err != nil {
 		t.Fatalf("generate code (far past): %v", err)
 	}
 	ok, err = Validate(secret, farPastCode, now)
 	if err != nil {
 		t.Fatalf("validate (far past): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet ungueltig weit ausserhalb der skew-toleranz (5min)")
 	}
 }
@@ -0,0 +1,66 @@
 package user
 import (
 	"encoding/json"
 	"errors"
 	"net/http"
 )
 // Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
 // Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
 // dieser Kachel und daher hier noch nicht angebunden.
 type Handler struct {
 	users       *TenantUserStore
 	superadmins *SuperadminStore
 }
 func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
 	return &Handler{users: users, superadmins: superadmins}
 }
 type createUserRequest struct {
 	Email string `json:"email"`
 	Name  string `json:"name"`
 }
 func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
 	var req createUserRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	u, err := h.users.Create(r.Context(), req.Email, req.Name)
 	writeUserResult(w, u, err)
 }
 // CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
 // bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
 func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
 	var req createUserRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
 	writeUserResult(w, u, err)
 }
 func writeUserResult(w http.ResponseWriter, u User, err error) {
 	if err != nil {
 		switch {
 		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
 			http.Error(w, err.Error(), http.StatusBadRequest)
 		case errors.Is(err, ErrNotFound):
 			http.Error(w, err.Error(), http.StatusNotFound)
 		default:
 			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
 		}
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusCreated)
 	_ = json.NewEncoder(w).Encode(u)
 }
@@ -0,0 +1,173 @@
 package user
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
 // uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
 // TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
 // fuer dasselbe Muster.
 func setupTestDB(t *testing.T, dbName, schemaSQL string) *pgxpool.Pool {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	adminPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
 	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
 		t.Fatalf("testdatenbank anlegen: %v", err)
 	}
 	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("connect testdatenbank: %v", err)
 	}
 	if _, err := pool.Exec(ctx, schemaSQL); err != nil {
 		t.Fatalf("schema anwenden: %v", err)
 	}
 	t.Cleanup(func() {
 		pool.Close()
 		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 		adminPool.Close()
 	})
 	return pool
 }
 const usersSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 const superadminsSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE superadmins (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 // Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
 func TestTenantUserStore_CRUD(t *testing.T) {
 	pool := setupTestDB(t, "test_iam01_users", usersSchema)
 	store := NewTenantUserStore(pool)
 	ctx := context.Background()
 	created, err := store.Create(ctx, "alice@example.com", "Alice")
 	if err != nil {
 		t.Fatalf("create: %v", err)
 	}
 	if created.Status != StatusActive {
 		t.Fatalf("erwartet status active, hat %q", created.Status)
 	}
 	got, err := store.Get(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if got.Email != "alice@example.com" {
 		t.Fatalf("get email = %q", got.Email)
 	}
 	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
 	if err != nil {
 		t.Fatalf("update: %v", err)
 	}
 	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
 		t.Fatalf("update ergebnis unerwartet: %+v", updated)
 	}
 	list, err := store.List(ctx)
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 	if len(list) != 1 {
 		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
 	}
 	deactivated, err := store.Deactivate(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("deactivate: %v", err)
 	}
 	if deactivated.Status != StatusInactive {
 		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
 	}
 	// Negativfall: doppelte E-Mail-Adresse.
 	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
 		t.Fatalf("create second: %v", err)
 	}
 	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
 		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
 	}
 	// Negativfall: fehlender Benutzer.
 	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
 		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
 // SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
 // keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
 func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
 	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
 	store := NewSuperadminStore(pool)
 	ctx := context.Background()
 	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
 	if err != nil {
 		t.Fatalf("create superadmin: %v", err)
 	}
 	if created.Status != StatusActive {
 		t.Fatalf("erwartet status active, hat %q", created.Status)
 	}
 	got, err := store.Get(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if got.Email != "root@nexarch.internal" {
 		t.Fatalf("get email = %q", got.Email)
 	}
 	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
 		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
 	}
 	deactivated, err := store.Deactivate(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("deactivate: %v", err)
 	}
 	if deactivated.Status != StatusInactive {
 		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
 	}
 }
@@ -0,0 +1,77 @@
 package user
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
 // Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
 // Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
 // TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
 // koennte (IAM-01, "ohne Sonderbehandlung im Code").
 type SuperadminStore struct {
 	pool *pgxpool.Pool
 }
 func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
 	return &SuperadminStore{pool: pool}
 }
 func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
 	if err := ValidateEmail(email); err != nil {
 		return User{}, err
 	}
 	var u User
 	u.Email, u.Name, u.Status = email, name, StatusActive
 	row := s.pool.QueryRow(ctx, `
 		INSERT INTO superadmins (email, name, status)
 		VALUES ($1, $2, $3)
 		RETURNING id, created_at, updated_at
 	`, u.Email, u.Name, u.Status)
 	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
 		return User{}, mapWriteErr(err)
 	}
 	return u, nil
 }
 func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM superadmins WHERE id = $1
 	`, id))
 }
 func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM superadmins ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("superadmins auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []User
 	for rows.Next() {
 		var u User
 		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("superadmin lesen: %w", err)
 		}
 		out = append(out, u)
 	}
 	return out, rows.Err()
 }
 func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		UPDATE superadmins SET status = $2, updated_at = now()
 		WHERE id = $1
 		RETURNING id, email, name, status, created_at, updated_at
 	`, id, StatusInactive))
 }
@@ -0,0 +1,173 @@
 package user
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgconn"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
 // Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
 // uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
 type TenantUserStore struct {
 	pool *pgxpool.Pool
 }
 func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
 	return &TenantUserStore{pool: pool}
 }
 func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
 	if err := ValidateEmail(email); err != nil {
 		return User{}, err
 	}
 	var u User
 	u.Email, u.Name, u.Status = email, name, StatusActive
 	row := s.pool.QueryRow(ctx, `
 		INSERT INTO users (email, name, status)
 		VALUES ($1, $2, $3)
 		RETURNING id, created_at, updated_at
 	`, u.Email, u.Name, u.Status)
 	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
 		return User{}, mapWriteErr(err)
 	}
 	return u, nil
 }
 func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM users WHERE id = $1
 	`, id))
 }
 func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM users ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("benutzer auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []User
 	for rows.Next() {
 		var u User
 		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("benutzer lesen: %w", err)
 		}
 		out = append(out, u)
 	}
 	return out, rows.Err()
 }
 // Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
 // Feld unveraendert.
 func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
 	if email != "" {
 		if err := ValidateEmail(email); err != nil {
 			return User{}, err
 		}
 	}
 	row := s.pool.QueryRow(ctx, `
 		UPDATE users
 		SET email = COALESCE(NULLIF($2, ''), email),
 		    name = COALESCE(NULLIF($3, ''), name),
 		    updated_at = now()
 		WHERE id = $1
 		RETURNING id, email, name, status, created_at, updated_at
 	`, id, email, name)
 	u, err := scanUser(row)
 	if err != nil {
 		return User{}, mapWriteErr(err)
 	}
 	return u, nil
 }
 // Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
 func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		UPDATE users SET status = $2, updated_at = now()
 		WHERE id = $1
 		RETURNING id, email, name, status, created_at, updated_at
 	`, id, StatusInactive))
 }
 // SetPasswordHash schreibt einen bereits berechneten bcrypt-Hash (siehe
 // internal/auth, IAM-02). Der Store selbst kennt kein Klartext-Passwort.
 func (s *TenantUserStore) SetPasswordHash(ctx context.Context, id, hash string) error {
 	tag, err := s.pool.Exec(ctx, `
 		UPDATE users SET password_hash = $2, updated_at = now() WHERE id = $1
 	`, id, hash)
 	if err != nil {
 		return fmt.Errorf("passwort setzen: %w", err)
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrNotFound
 	}
 	return nil
 }
 // AuthCredentials wird ausschliesslich fuer den Login-Pfad (internal/auth)
 // verwendet und traegt bewusst den password_hash, damit er nicht ueber den
 // regulaeren User-Typ/JSON-Serialisierungspfad nach aussen dringen kann.
 type AuthCredentials struct {
 	User         User
 	PasswordHash string
 }
 // GetByEmailForAuth liefert Benutzer + Passwort-Hash zu einer E-Mail-Adresse
 // aus GENAU DIESER Tenant-Datenbank — der Tenant-Scope ergibt sich damit
 // zwingend aus dem verwendeten Pool, es gibt keine Moeglichkeit, versehentlich
 // ueber Tenant-Grenzen hinweg zu suchen (bekannter archivmail-Fehler, siehe
 // IAM-02 "Bekannte Fehler vermeiden").
 func (s *TenantUserStore) GetByEmailForAuth(ctx context.Context, email string) (AuthCredentials, error) {
 	var c AuthCredentials
 	row := s.pool.QueryRow(ctx, `
 		SELECT id, email, name, status, created_at, updated_at, password_hash
 		FROM users WHERE email = $1
 	`, email)
 	if err := row.Scan(&c.User.ID, &c.User.Email, &c.User.Name, &c.User.Status,
 		&c.User.CreatedAt, &c.User.UpdatedAt, &c.PasswordHash); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return AuthCredentials{}, ErrNotFound
 		}
 		return AuthCredentials{}, fmt.Errorf("anmeldedaten lesen: %w", err)
 	}
 	return c, nil
 }
 func scanUser(row pgx.Row) (User, error) {
 	var u User
 	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return User{}, ErrNotFound
 		}
 		return User{}, fmt.Errorf("benutzer lesen: %w", err)
 	}
 	return u, nil
 }
 // mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
 // einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
 func mapWriteErr(err error) error {
 	var pgErr *pgconn.PgError
 	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
 		return ErrEmailTaken
 	}
 	if errors.Is(err, pgx.ErrNoRows) {
 		return ErrNotFound
 	}
 	return fmt.Errorf("benutzer schreiben: %w", err)
 }
@@ -0,0 +1,42 @@
 // Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
 // CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
 // gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
 // dagegen mandantenuebergreifend in der Registry und sind ueber
 // SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
 // tenant_id-NULL-Sonderfall in User.
 package user
 import (
 	"errors"
 	"regexp"
 	"time"
 )
 type Status string
 const (
 	StatusActive   Status = "active"
 	StatusInactive Status = "inactive"
 )
 type User struct {
 	ID        string
 	Email     string
 	Name      string
 	Status    Status
 	CreatedAt time.Time
 	UpdatedAt time.Time
 }
 var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
 var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
 var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
 var ErrNotFound = errors.New("user: nicht gefunden")
 func ValidateEmail(email string) error {
 	if !emailPattern.MatchString(email) {
 		return ErrInvalidEmail
 	}
 	return nil
 }
@@ -0,0 +1,24 @@
 package user
 import "testing"
 func TestValidateEmail(t *testing.T) {
 	cases := []struct {
 		email   string
 		wantErr bool
 	}{
 		{"a@b.de", false},
 		{"a.b+c@sub.example.com", false},
 		{"", true},
 		{"keine-email", true},
 		{"a@b", true},
 		{"@b.de", true},
 	}
 	for _, c := range cases {
 		err := ValidateEmail(c.email)
 		if (err != nil) != c.wantErr {
 			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
 		}
 	}
 }
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS tenants;
@@ -1,10 +0,0 @@
 -- Control-plane registry: tenant list + connection info (Modell C).
 -- Core TEN-01 (siehe core-kanban).
 CREATE TABLE tenants (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    slug         TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    db_dsn       TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -0,0 +1,14 @@
 -- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
 -- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
 -- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE tenants (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    slug         TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    db_name      TEXT NOT NULL UNIQUE,
    db_dsn       TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS superadmins;
@@ -0,0 +1,14 @@
 -- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
 -- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
 -- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
 -- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
 -- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
 -- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
 CREATE TABLE superadmins (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email        TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS users;
@@ -0,0 +1,16 @@
 -- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
 -- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
 -- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
 -- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
 -- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
 -- nur innerhalb dieser einen Tenant-Datenbank.
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email        TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -0,0 +1 @@
 ALTER TABLE users DROP COLUMN password_hash;
@@ -0,0 +1,3 @@
 -- Passwort-Hash-Spalte fuer Login (IAM-02, siehe core-kanban/tickets/IAM-02.md).
 -- Enthaelt AUSSCHLIESSLICH den bcrypt-Hash, niemals das Klartext-Passwort.
 ALTER TABLE users ADD COLUMN password_hash TEXT NOT NULL DEFAULT '';
@@ -0,0 +1,3 @@
 DROP TABLE IF EXISTS totp_policy;
 DROP TABLE IF EXISTS totp_recovery_codes;
 DROP TABLE IF EXISTS totp_credentials;
@@ -0,0 +1,23 @@
 -- Zwei-Faktor-Authentifizierung TOTP (IAM-04, siehe core-kanban/tickets/IAM-04.md).
 CREATE TABLE totp_credentials (
    user_id    UUID PRIMARY KEY REFERENCES users(id),
    secret     TEXT NOT NULL,
    confirmed  BOOLEAN NOT NULL DEFAULT false,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- code_hash enthaelt NIEMALS den Klartext-Wiederherstellungscode, nur dessen
 -- SHA-256-Hash. used_at markiert einmalige Verwendbarkeit (Akzeptanzkriterium 3).
 CREATE TABLE totp_recovery_codes (
    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id    UUID NOT NULL REFERENCES users(id),
    code_hash  BYTEA NOT NULL UNIQUE,
    used_at    TIMESTAMPTZ,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Erzwingbare Aktivierungspflicht pro Tenant (Singleton-Zeile, Modell C).
 CREATE TABLE totp_policy (
    id       BOOLEAN PRIMARY KEY DEFAULT true CHECK (id),
    required BOOLEAN NOT NULL DEFAULT false
 );
@@ -0,0 +1,11 @@
 #!/usr/bin/env bash
 set -euo pipefail
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
 export PGPASSWORD="$PASS"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
@@ -0,0 +1,12 @@
 #!/usr/bin/env bash
 set -euo pipefail
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
 echo "== go build =="
 go build ./...
 echo "== go vet =="
 go vet ./...
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1
Author	SHA1	Message	Date
sysops	e46b8ed133	IAM-15: timing-safe-vergleich-als-projektweite-coding-konvention (internal/timingsafe, coding-guideline, audit bestehender vergleichsstellen)	2026-08-28 22:56:23 +02:00
sysops	1b4c3db9b8	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-28 22:54:02 +02:00
sysopsandClaude Sonnet 5	f224b5c9be	IAM-04: zwei-faktor-authentifizierung-totp internal/totp/totp.go: RFC-6238-TOTP (HOTP RFC 4226) selbst implementiert mit stdlib crypto/hmac+sha1 — kein externes Modul. DefaultSkewSteps=1 dokumentiert die Zeitversatz-Toleranz (+/-30s um die Serverzeit, Akzeptanzkriterium/Pruefung 3). ProvisioningURI liefert die otpauth://-URI fuer den QR-Code (Akzeptanzkriterium 1) — das Rendering selbst ist Frontend-Sache (IAM-08). internal/totp/store.go: BeginSetup speichert ein neues Secret als NICHT bestaetigt; ConfirmSetup aktiviert 2FA erst nach einmaliger erfolgreicher Code-Eingabe (Akzeptanzkriterium 1) und erzeugt 10 Wiederherstellungscodes (nur Hash gespeichert, Klartext einmalig zurueckgegeben). VerifyLoginCode akzeptiert TOTP-Code ODER Wiederherstellungscode; consumeRecoveryCode markiert einen Code atomar als verwendet (WHERE used_at IS NULL) — kein doppeltes Einloesen moeglich (Akzeptanzkriterium 3). internal/totp/login.go: LoginWithTOTP komponiert IAM-02s LoginService, ohne ihn zu veraendern — ist 2FA fuer den Benutzer aktiv, wird ein fehlender/ falscher Code zuverlaessig abgewiesen, selbst bei korrektem Passwort (Akzeptanzkriterium 2). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Login-Versuch ohne zweiten Faktor bei aktivem 2FA zuverlaessig abgewiesen — TestLoginWithTOTP_RequiresSecondFactorWhenEnabled: korrektes Passwort ohne Code -> ErrSecondFactorRequired, mit gueltigem Code -> Token. PASS. 2. Wiederherstellungscode nach Nutzung als verbraucht getestet — TestVerifyLoginCode_RecoveryCodeIsSingleUse: erste Nutzung erfolgreich, zweite abgelehnt. PASS. 3. Zeitversatz-Toleranz dokumentiert und getestet — TestValidate_ClockSkewTolerance: Code aus 25s Vergangenheit gueltig (innerhalb dokumentierter Toleranz), Code aus 5min Vergangenheit ungueltig. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 22:34:34 +02:00
sysopsandClaude Sonnet 5	3d20d86a4f	IAM-02: login-session-jwt-grundgeruest internal/auth: Login/Logout ueber httpOnly/Secure/SameSite=Strict-Cookie mit HS256-JWT (30min TTL), bcrypt-Passwort-Hashing (Cost 12, explizit begruendet und benchmarkt statt DefaultCost uebernommen), RequireAuth-Middleware fuer geschuetzte Routen. LoginService ist strukturell auf einen Tenant gescopt (nutzt user.TenantUserStore, dessen Pool = eine Tenant-DB — derselbe Mechanismus wie in TEN-01/TEN-02), liefert bei falscher E-Mail und falschem Passwort denselben Fehler (User-Enumeration-Schutz) inkl. Dummy-bcrypt- Vergleich gegen Timing-Seitenkanal bei unbekannter E-Mail. user.TenantUserStore erweitert um SetPasswordHash/GetByEmailForAuth (password_hash bleibt ausserhalb des regulaeren User-Typs/JSON-Pfads). Migration 0002 fuegt password_hash-Spalte hinzu (Default '', da IAM-01 User ohne Passwort anlegt). Login-Handler ist wie IAM-01/TEN-02 aus denselben Gruenden (Tenant- Connection-Routing = TEN-06, noch nicht gebaut) nicht in cmd/core/main.go verdrahtet — Package ist eigenstaendig nutzbar/getestet. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Login-Query tenant-gescopt — TestLoginService_NoCrossTenantLogin: gleiche E-Mail in zwei Tenant-DBs mit unterschiedlichem Passwort, Login gegen Tenant A mit Tenant-B-Passwort schlaegt fehl. PASS. 2. Session-Fixation/Token-Manipulation — TestTokenVerify_RejectsManipulatedPayload und TestTokenVerify_RejectsWrongSecret: manipuliertes/falsch signiertes Token wird abgelehnt. PASS. 3. Abgelaufenes Token erzwingt Neuanmeldung — TestTokenVerify_RejectsExpiredToken und TestRequireAuth_BlocksWithoutValidCookie. PASS. 4. Login-Latenz mit Kostenfaktor 12 gemessen: 294ms (Ziel < 400ms) — TestBcryptCostAgainstLatencyTarget. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 18:26:00 +02:00
sysopsandClaude Sonnet 5	e4793303fc	IAM-01: benutzer-datenmodell-crud Benutzer-Datenmodell + CRUD fuer Tenant-User (tenant-scoped, keine tenant_id-Spalte noetig, Tenant ergibt sich aus der DB-Verbindung, Modell C) und getrennt dafuer SuperadminStore fuer mandantenuebergreifende Konten in der Registry-DB — First-Class-Typ statt tenant_id-NULL-Sonderfall im Tenant-User-Code (bekannter archivdms-Fehler vermieden). E-Mail-Eindeutigkeit: tenant-scoped fuer normale Benutzer (UNIQUE-Constraint gilt nur innerhalb der jeweiligen Tenant-DB), global fuer Superadmins (eine Registry-DB, ein UNIQUE-Constraint). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. CRUD automatisiert getestet inkl. Negativfaellen — TestTenantUserStore_CRUD deckt doppelte E-Mail (ErrEmailTaken) und unbekannte ID ab. PASS. 2. Superadmin-Anlage ohne Tenant-Kontext — TestSuperadminStore_CreateWithoutTenantContext: SuperadminStore.Create hat syntaktisch keinen Tenant-Parameter, kein if-Zweig fuer "kein Tenant" im Code. PASS. 3. Datenmodell von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Tenant-User-Handler ist im Code vorhanden, aber in cmd/core/main.go noch nicht geroutet — braucht Connection-Routing pro Mandant (TEN-06), das nicht Teil dieser Kachel ist. Nur der Superadmin-Endpunkt ist verdrahtet. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 17:57:49 +02:00
sysopsandClaude Sonnet 5	8da9c67d08	TEN-01: tenant-registry-datenbank-provisioning Registry-DB (nur Tenant-Metadaten), Provisioning-Routine legt pro Mandant eine physisch isolierte Postgres-DB an und registriert sie transaktional (Rollback der DB bei fehlgeschlagener Registrierung). Schlanker HTTP-Handler als Schnittstellen-Vorbereitung fuer API-01/TEN-02, kein eigenes REST-Grundgerüst. Pruefungen: 1. Migration up/down geschrieben (0001_tenant_registry.{up,down}.sql) — nicht gegen echte DB ausgefuehrt, da auf dieser Maschine kein Go/Postgres-Test- Setup verfuegbar ist. Offen zur Ausfuehrung. 2. Integrationstest TestProvision_CreatesIsolatedDatabases geschrieben (zwei Mandanten, prueft unterschiedliche db_name und current_database()) — ebenfalls nicht ausgefuehrt, guarded per TEST_ADMIN_DSN env var. Offen. 3. Slug-Validierung (unit test TestValidateSlug) deckt SQL-Injection-Versuch im Datenbanknamen ab — ebenfalls nicht lokal ausgefuehrt, da kein Go Compiler auf dieser Maschine vorhanden ist. Offen. Alle drei Pruefungen sind vorbereitet, aber NICHT durchgefuehrt worden — zaehlen laut Vorgabe als offen bis auf einer Maschine mit Go+Postgres verifiziert. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 17:40:35 +02:00
		`@@ -1,3 +0,0 @@`
			`module gitea.perlbach24.de/scripte/nexarch/archive`

			`go 1.22`
		`@@ -0,0 +1 @@`
							`ALTER TABLE users DROP COLUMN password_hash;`