API-01: rest-api-grundgeruest-versionierung

internal/apiserver: Server.Handle(version, pattern, h) registriert Routen
unter /api/{version}/... (Akzeptanzkriterium 1) — verschiedene Versionen
sind unabhaengige Pfade im ServeMux, eine neue Version beeintraechtigt
bestehende nicht. HandleV1 ist die Kurzform fuer die aktuelle Hauptversion.

Einheitliches Fehlerschema {"error":{"code","message"}} ueber WriteError
(Akzeptanzkriterium 2) — bewusst NICHT auth.RequireAuth aus IAM-02
wiederverwendet, da dessen Klartext-Fehlerantworten nicht zum einheitlichen
JSON-Schema passen wuerden; stattdessen authAndTenantContext nutzt
auth.TokenIssuer.Verify direkt (dieselbe Kryptographie, keine Duplikation)
und antwortet im API-01-Schema, auch bei 401.

authAndTenantContext ist die Middleware, die JEDEM ueber Handle registrierten
Endpunkt Tenant-/Benutzerkontext bereitstellt (Akzeptanzkriterium 3, ueber
apiserver.FromContext abrufbar) — kein Handler prueft Auth selbst.
loggingMiddleware protokolliert jede Anfrage strukturiert.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Fehlerhafte Anfrage liefert ueber mehrere Endpunkte hinweg dasselbe
   Fehlerschema (Stichprobe) — TestErrorFormat_ConsistentAcrossEndpoints:
   zwei unabhaengige Endpunkte, beide liefern 401 im identischen
   {"error":{"code","message"}}-Schema. PASS.
2. Middleware-Kette nachweislich von jedem Endpunkt durchlaufen —
   TestMiddleware_SetsRequestContextForEveryEndpoint: zwei Endpunkte lesen
   RequestContext, beide erhalten korrekten UserID/TenantSlug aus dem Token. PASS.
3. Versionswechsel (fiktive v2-Route) ohne v1 zu beeintraechtigen —
   TestVersioning_V2DoesNotAffectV1: v1 vor und nach Anlage von v2 liefert
   unveraendert dieselbe Antwort. PASS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

DEVLOG.md

@@ -129,21 +129,3 @@ Keine Commits in dieser Session.
 - 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 ++++++
-
----

docs/CODING-GUIDELINES-CORE.md

@@ -1,73 +0,0 @@
-# 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.

internal/apiserver/context.go

@@ -0,0 +1,20 @@
+package apiserver
+
+import "context"
+
+type contextKey int
+
+const requestContextKey contextKey = iota
+
+// RequestContext ist der Tenant-/Benutzerkontext, den die Middleware-Kette
+// fuer nachgelagerte Handler bereitstellt (Akzeptanzkriterium 3).
+type RequestContext struct {
+	UserID     string
+	TenantSlug string
+}
+
+// FromContext liest den von der Middleware gesetzten Kontext.
+func FromContext(ctx context.Context) (RequestContext, bool) {
+	rc, ok := ctx.Value(requestContextKey).(RequestContext)
+	return rc, ok
+}

internal/apiserver/errors.go

@@ -0,0 +1,31 @@
+// Package apiserver implementiert Core API-01: das REST-Grundgerüst mit
+// URL-Versionierung, einheitlichem Fehlerformat und Middleware-Kette
+// (Auth, Tenant-/Benutzerkontext, Logging).
+package apiserver
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// errorBody ist das EINE Fehlerschema fuer alle Endpunkte unter /api/{version}/
+// (Akzeptanzkriterium 2).
+type errorBody struct {
+	Error struct {
+		Code    string `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+// WriteError schreibt einen Fehler im einheitlichen Schema. code ist ein
+// stabiler, maschinenlesbarer Bezeichner (z.B. "unauthenticated"), message
+// ein fuer Menschen lesbarer deutscher Text.
+func WriteError(w http.ResponseWriter, status int, code, message string) {
+	var body errorBody
+	body.Error.Code = code
+	body.Error.Message = message
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(body)
+}

internal/apiserver/middleware.go

@@ -0,0 +1,56 @@
+package apiserver
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// authAndTenantContext prueft die Session (wiederverwendet auth.TokenIssuer.Verify
+// aus IAM-02 — keine zweite JWT-Implementierung) und setzt bei Erfolg
+// RequestContext fuer nachgelagerte Handler (Akzeptanzkriterium 3). Anders
+// als auth.RequireAuth (Klartext-Fehler) antwortet diese Middleware im
+// einheitlichen API-01-Fehlerschema (Akzeptanzkriterium 2), damit ALLE
+// Endpunkte unter /api/{version}/ dasselbe Format liefern, auch bei
+// Auth-Fehlern.
+func authAndTenantContext(issuer *auth.TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		cookie, err := r.Cookie(auth.CookieName)
+		if err != nil {
+			WriteError(w, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+			return
+		}
+
+		claims, err := issuer.Verify(cookie.Value)
+		if err != nil {
+			WriteError(w, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+			return
+		}
+
+		rc := RequestContext{UserID: claims.UserID, TenantSlug: claims.TenantSlug}
+		next(w, r.WithContext(context.WithValue(r.Context(), requestContextKey, rc)))
+	}
+}
+
+type statusRecorder struct {
+	http.ResponseWriter
+	status int
+}
+
+func (s *statusRecorder) WriteHeader(code int) {
+	s.status = code
+	s.ResponseWriter.WriteHeader(code)
+}
+
+// loggingMiddleware protokolliert jede Anfrage strukturiert.
+func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
+		start := time.Now()
+		next(rec, r)
+		slog.Info("api-anfrage", "method", r.Method, "path", r.URL.Path, "status", rec.status, "dauer", time.Since(start))
+	}
+}

internal/apiserver/server.go

@@ -0,0 +1,37 @@
+package apiserver
+
+import (
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// Server registriert versionierte API-Routen (Akzeptanzkriterium 1: unter
+// /api/{version}/...) und verdrahtet fuer jede Route dieselbe Middleware-
+// Kette (Logging -> Auth+Tenantkontext -> Handler).
+type Server struct {
+	mux    *http.ServeMux
+	issuer *auth.TokenIssuer
+}
+
+func NewServer(issuer *auth.TokenIssuer) *Server {
+	return &Server{mux: http.NewServeMux(), issuer: issuer}
+}
+
+// Handle registriert pattern unter der angegebenen Version, z.B.
+// Handle("v1", "/things", h) -> erreichbar unter /api/v1/things. Verschiedene
+// Versionen sind unabhaengige Pfade — eine neue Version beeintraechtigt
+// bestehende nicht (Akzeptanzkriterium 1 / Pruefung 3).
+func (s *Server) Handle(version, pattern string, h http.HandlerFunc) {
+	full := "/api/" + version + pattern
+	s.mux.HandleFunc(full, loggingMiddleware(authAndTenantContext(s.issuer, h)))
+}
+
+// HandleV1 ist die Kurzform fuer die aktuelle Hauptversion.
+func (s *Server) HandleV1(pattern string, h http.HandlerFunc) {
+	s.Handle("v1", pattern, h)
+}
+
+func (s *Server) Handler() http.Handler {
+	return s.mux
+}

internal/apiserver/server_test.go

@@ -0,0 +1,149 @@
+package apiserver
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+func newTestServer() (*Server, *auth.TokenIssuer) {
+	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
+	return NewServer(issuer), issuer
+}
+
+func withAuthCookie(req *http.Request, token string) *http.Request {
+	req.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
+	return req
+}
+
+// Akzeptanzkriterium 1: API unter versioniertem Pfad erreichbar.
+func TestHandleV1_RegistersUnderVersionedPath(t *testing.T) {
+	srv, issuer := newTestServer()
+	srv.HandleV1("/things", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	req := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1 (Stichprobe): mehrere Endpunkte liefern
+// bei fehlerhafter Anfrage dasselbe Fehlerschema.
+func TestErrorFormat_ConsistentAcrossEndpoints(t *testing.T) {
+	srv, _ := newTestServer()
+	srv.HandleV1("/endpunkt-a", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+	srv.HandleV1("/endpunkt-b", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	for _, path := range []string{"/api/v1/endpunkt-a", "/api/v1/endpunkt-b"} {
+		req := httptest.NewRequest(http.MethodGet, path, nil) // ohne cookie -> 401
+		rec := httptest.NewRecorder()
+		srv.Handler().ServeHTTP(rec, req)
+
+		if rec.Code != http.StatusUnauthorized {
+			t.Fatalf("%s: status = %d, want 401", path, rec.Code)
+		}
+		var body errorBody
+		if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+			t.Fatalf("%s: fehlerantwort nicht im erwarteten json-schema: %v (body: %s)", path, err, rec.Body.String())
+		}
+		if body.Error.Code == "" || body.Error.Message == "" {
+			t.Fatalf("%s: erwartet nicht-leeren code/message, habe %+v", path, body)
+		}
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Middleware-Kette setzt Tenant-/
+// Benutzerkontext zuverlaessig, nachweislich fuer mehrere Endpunkte.
+func TestMiddleware_SetsRequestContextForEveryEndpoint(t *testing.T) {
+	srv, issuer := newTestServer()
+
+	var gotA, gotB RequestContext
+	srv.HandleV1("/kontext-a", func(w http.ResponseWriter, r *http.Request) {
+		gotA, _ = FromContext(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+	srv.HandleV1("/kontext-b", func(w http.ResponseWriter, r *http.Request) {
+		gotB, _ = FromContext(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+
+	token, err := issuer.Issue("user-42", "tenant-x")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	for path, got := range map[string]*RequestContext{"/api/v1/kontext-a": &gotA, "/api/v1/kontext-b": &gotB} {
+		req := withAuthCookie(httptest.NewRequest(http.MethodGet, path, nil), token)
+		rec := httptest.NewRecorder()
+		srv.Handler().ServeHTTP(rec, req)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("%s: status = %d, want 200", path, rec.Code)
+		}
+		if got.UserID != "user-42" || got.TenantSlug != "tenant-x" {
+			t.Fatalf("%s: request-context unerwartet: %+v", path, *got)
+		}
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 3: eine neue v2-Route laesst sich anlegen,
+// ohne v1 zu beeintraechtigen.
+func TestVersioning_V2DoesNotAffectV1(t *testing.T) {
+	srv, issuer := newTestServer()
+	srv.HandleV1("/things", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("v1-antwort"))
+	})
+	srv.Handle("v2", "/things", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("v2-antwort"))
+	})
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	reqV1 := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	recV1 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV1, reqV1)
+	if recV1.Body.String() != "v1-antwort" {
+		t.Fatalf("v1 antwort = %q, want v1-antwort", recV1.Body.String())
+	}
+
+	reqV2 := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v2/things", nil), token)
+	recV2 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV2, reqV2)
+	if recV2.Body.String() != "v2-antwort" {
+		t.Fatalf("v2 antwort = %q, want v2-antwort", recV2.Body.String())
+	}
+
+	// v1 nach dem Anlegen von v2 erneut pruefen — unveraendert.
+	reqV1Again := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	recV1Again := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV1Again, reqV1Again)
+	if recV1Again.Body.String() != "v1-antwort" {
+		t.Fatalf("v1 antwort nach v2-anlage = %q, want weiterhin v1-antwort", recV1Again.Body.String())
+	}
+}
+
+func TestAuthAndTenantContext_RejectsInvalidToken(t *testing.T) {
+	srv, _ := newTestServer()
+	srv.HandleV1("/geschuetzt", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	req := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/geschuetzt", nil), "kaputtes.token.hier")
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("status = %d, want 401", rec.Code)
+	}
+}

internal/timingsafe/timingsafe.go

@@ -1,30 +0,0 @@
-// 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))
-}

internal/timingsafe/timingsafe_test.go

@@ -1,36 +0,0 @@
-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")
-	}
-}

internal/totp/login.go

@@ -1,42 +0,0 @@
-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)
-}

internal/totp/store.go

@@ -1,163 +0,0 @@
-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[:]
-}

internal/totp/store_test.go

@@ -1,185 +0,0 @@
-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")
-	}
-}

internal/totp/totp.go

@@ -1,105 +0,0 @@
-// 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)
-}

internal/totp/totp_test.go

@@ -1,79 +0,0 @@
-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)")
-	}
-}

migrations/tenant/0003_totp.down.sql

@@ -1,3 +0,0 @@
-DROP TABLE IF EXISTS totp_policy;
-DROP TABLE IF EXISTS totp_recovery_codes;
-DROP TABLE IF EXISTS totp_credentials;

migrations/tenant/0003_totp.up.sql

@@ -1,23 +0,0 @@
--- 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
-);

scripts/reset-test-env.sh

@@ -1,11 +1,16 @@
 #!/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."

scripts/run-checks.sh

@@ -1,12 +1,18 @@
 #!/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