IAM-12: aktive-sitzungen-verwaltung

internal/session: Selbstbedienungs-Sitzungsuebersicht mit widerrufbarem, SERVERSEITIGEM Zustand — bewusst ein separater Mechanismus neben IAM-02s zustandslosem JWT (das fuer schnelle Modul-zu-Modul-Verifikation ohne Core-Rueckfrage gewaehlt wurde, siehe API-05). Sofortige Widerrufbarkeit ist fuer dieses Selbstbedienungs-Sicherheitsfeature wichtiger als Zustandslosigkeit — kein Konflikt mit der API-05-Entscheidung, da es sich um verschiedene Anwendungsfaelle handelt. Store.Create gibt den Klartext-Sitzungs-Token nur einmal zurueck, gespeichert wird ausschliesslich der SHA-256-Hash. Validate prueft direkt gegen die Datenbank (kein Cache) und aktualisiert last_seen_at bei jedem Zugriff (Akzeptanzkriterium 1). Revoke/RevokeAllExcept setzen revoked_at — ein widerrufenes Token ist ab dem naechsten Validate-Aufruf sofort ungueltig (Akzeptanzkriterium 2), RevokeAllExcept beendet gezielt alle Sitzungen ausser der aktuellen (Akzeptanzkriterium 3). LoginAndCreateSession verwendet auth.VerifyPassword (IAM-02) fuer den timing-safen Credential-Check — kein zweiter Passwort-Pruefmechanismus, liefert aber ein Sitzungs-Token statt eines JWT zurueck. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Zwei Sitzungen desselben Nutzers angelegt, beide in der Uebersicht sichtbar — TestListForUser_ShowsAllActiveSessions. PASS. 2. Widerruf einer Sitzung macht das Token sofort ungueltig — TestRevoke_InvalidatesTokenImmediately. PASS. 3. "Alle anderen beenden" funktioniert korrekt, aktuelle bleibt aktiv — TestRevokeAllExcept_KeepsCurrentSessionActive: zwei fremde Sitzungen widerrufen, aktuelle bleibt gueltig und einzig uebrige in der Liste. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-27 22:29:58 +02:00
19 changed files with 370 additions and 1416 deletions
@@ -129,46 +129,3 @@ Keine Commits in dieser Session.
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-28 23:20 – 23:26 (6m)
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 ### Commits
 - 42466c7 IAM-13: oidc-provider-fuer-drittanwendungen (client-registrierung, authorization-code-flow, jwks ueber API-05-schluessel)
 ### Geänderte Dateien
 - internal/oidc/authcode.go                     |  91 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/oidc/client.go                       | 167 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/oidc/provider.go                     | 251 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/oidc/provider_test.go                | 294 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - migrations/tenant/0003_oidc_provider.down.sql |   2 ++
 - migrations/tenant/0003_oidc_provider.up.sql   |  28 +++++++++++++++++++
 ---
 ## 2026-08-28 23:26 – 23:26 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - internal/oidc/authcode.go                     |  91 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/oidc/client.go                       | 167 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/oidc/provider.go                     | 251 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/oidc/provider_test.go                | 294 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - migrations/tenant/0003_oidc_provider.down.sql |   2 ++
 - migrations/tenant/0003_oidc_provider.up.sql   |  28 +++++++++++++++++++
 ---
 ## 2026-08-28 23:26 – 23:26 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - DEVLOG.md | 32 ++++++++++++++++++++++++++++++++
 ---
@@ -1,86 +0,0 @@
 package moduletrust
 import (
 	"context"
 	"fmt"
 	"sync"
 	"time"
 )
 // StaleCache ist der generische Rechte-/Feature-Flag-Cache-Kontrakt
 // (Akzeptanzkriterium 2): TTL-basiert, mit explizitem, benanntem Verhalten
 // bei abgelaufenem Cache waehrend Core nicht erreichbar ist.
 //
 //   - Get: FAIL-OPEN fuer Lesevorgaenge. Schlaegt der Refresh fehl, aber es
 //     gibt bereits einen (wenn auch abgelaufenen) Stand, wird dieser mit
 //     stale=true zurueckgegeben — Begruendung: ein bereits authentifiziertes
 //     Modul soll mit dem letztbekannten Stand weiterarbeiten koennen statt
 //     hart zu blockieren (siehe "Bekannte Fehler vermeiden" im Ticket).
 //     Existiert noch nie ein Stand, gibt es keinen sinnvollen Fallback —
 //     dann liefert auch Get einen Fehler.
 //   - RequireFresh: FAIL-CLOSED fuer sicherheitskritische Aktionen (z.B.
 //     ein komplett NEUER Login). Nutzt NIEMALS einen zwischengespeicherten
 //     Stand, ruft immer frisch ab — Begruendung: eine neue Vertrauens-
 //     entscheidung darf nicht auf veralteten Daten beruhen, auch wenn das
 //     bedeutet, dass die Aktion bei Core-Ausfall sichtbar fehlschlaegt statt
 //     unsicher "irgendwie" durchgelassen zu werden.
 //
 // LIC-02 (internal/flag.Service) implementiert bereits denselben Kontrakt
 // fuer Feature-Flags — StaleCache verallgemeinert dasselbe Muster fuer
 // JWT-Signaturschluessel, damit beide Faelle derselben dokumentierten
 // Policy folgen.
 type StaleCache[T any] struct {
 	mu        sync.RWMutex
 	value     T
 	hasValue  bool
 	fetchedAt time.Time
 	ttl       time.Duration
 	fetch     func(ctx context.Context) (T, error)
 }
 func NewStaleCache[T any](ttl time.Duration, fetch func(ctx context.Context) (T, error)) *StaleCache[T] {
 	return &StaleCache[T]{ttl: ttl, fetch: fetch}
 }
 // Get liefert den Cache-Wert. FAIL-OPEN: bei Refresh-Fehler wird ein
 // vorhandener, ggf. abgelaufener Stand zurueckgegeben (stale=true).
 func (c *StaleCache[T]) Get(ctx context.Context) (value T, stale bool, err error) {
 	c.mu.RLock()
 	fresh := c.hasValue && time.Since(c.fetchedAt) < c.ttl
 	if fresh {
 		v := c.value
 		c.mu.RUnlock()
 		return v, false, nil
 	}
 	c.mu.RUnlock()
 	newVal, fetchErr := c.fetch(ctx)
 	if fetchErr == nil {
 		c.mu.Lock()
 		c.value, c.hasValue, c.fetchedAt = newVal, true, time.Now()
 		c.mu.Unlock()
 		return newVal, false, nil
 	}
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	if c.hasValue {
 		return c.value, true, nil
 	}
 	var zero T
 	return zero, false, fmt.Errorf("cache leer und refresh fehlgeschlagen: %w", fetchErr)
 }
 // RequireFresh ruft IMMER frisch ab (FAIL-CLOSED) — fuer sicherheitskritische
 // Aktionen, die niemals auf einem zwischengespeicherten Stand basieren duerfen.
 func (c *StaleCache[T]) RequireFresh(ctx context.Context) (T, error) {
 	v, err := c.fetch(ctx)
 	if err != nil {
 		var zero T
 		return zero, fmt.Errorf("core nicht erreichbar, sicherheitskritische aktion abgelehnt: %w", err)
 	}
 	c.mu.Lock()
 	c.value, c.hasValue, c.fetchedAt = v, true, time.Now()
 	c.mu.Unlock()
 	return v, nil
 }
@@ -1,79 +0,0 @@
 package moduletrust
 import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 )
 type Claims struct {
 	Subject    string `json:"sub"`
 	TenantSlug string `json:"tenant"`
 	jwt.RegisteredClaims
 }
 // Issue signiert ein Token mit dem aktuellen Signierschluessel und traegt
 // dessen KID im JWT-Header ein — der Verifier auf Modulseite waehlt darueber
 // den passenden oeffentlichen Schluessel aus PublicKeySet() aus.
 func (m *KeyManager) Issue(subject, tenantSlug string, ttl time.Duration) (string, error) {
 	key, err := m.SigningKey()
 	if err != nil {
 		return "", err
 	}
 	now := time.Now()
 	claims := Claims{
 		Subject:    subject,
 		TenantSlug: tenantSlug,
 		RegisteredClaims: jwt.RegisteredClaims{
 			IssuedAt:  jwt.NewNumericDate(now),
 			ExpiresAt: jwt.NewNumericDate(now.Add(ttl)),
 		},
 	}
 	token := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims)
 	token.Header["kid"] = key.KID
 	return token.SignedString(key.Private)
 }
 type jwksResponse struct {
 	Keys []jwksKey `json:"keys"`
 }
 type jwksKey struct {
 	Kid       string `json:"kid"`
 	PublicKey string `json:"public_key"` // base64 (raw Ed25519, 32 Byte)
 }
 // ServeJWKS liefert alle bekannten oeffentlichen Schluessel als JSON —
 // Module fragen dies periodisch ab (nicht pro Request), siehe Verifier.
 func (m *KeyManager) ServeJWKS(w http.ResponseWriter, r *http.Request) {
 	set := m.PublicKeySet()
 	resp := jwksResponse{Keys: make([]jwksKey, 0, len(set))}
 	for kid, pub := range set {
 		resp.Keys = append(resp.Keys, jwksKey{Kid: kid, PublicKey: base64.StdEncoding.EncodeToString(pub)})
 	}
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(resp)
 }
 // ParseJWKS dekodiert die JSON-Antwort von ServeJWKS zurueck in kid->PublicKey
 // — Hilfsfunktion fuer Module, die JWKS per HTTP abrufen.
 func ParseJWKS(data []byte) (map[string][]byte, error) {
 	var resp jwksResponse
 	if err := json.Unmarshal(data, &resp); err != nil {
 		return nil, fmt.Errorf("jwks parsen: %w", err)
 	}
 	out := make(map[string][]byte, len(resp.Keys))
 	for _, k := range resp.Keys {
 		raw, err := base64.StdEncoding.DecodeString(k.PublicKey)
 		if err != nil {
 			return nil, fmt.Errorf("oeffentlichen schluessel %q dekodieren: %w", k.Kid, err)
 		}
 		out[k.Kid] = raw
 	}
 	return out, nil
 }
@@ -1,83 +0,0 @@
 // Package moduletrust implementiert Core API-05: asymmetrische JWT-Signatur
 // mit Schluesselverteilung (JWKS), damit DMS/Mail/Archive/Workflow JWTs
 // LOKAL verifizieren koennen, ohne pro Aufruf einen synchronen Request an
 // Core zu stellen — Core darf Fundament sein, ohne zum Flaschenhals zu
 // werden (siehe Entscheidungsverlauf "Vertrauensstellung Core<->Module" in
 // nexarch-state.json). IAM-02s HS256-Session-Cookie (Browser-Login) bleibt
 // unangetastet — dies ist ein zusaetzlicher, getrennter Vertrauensmechanismus
 // fuer Modul-zu-Modul/Modul-zu-Core-Aufrufe.
 package moduletrust
 import (
 	"crypto/ed25519"
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
 	"sync"
 )
 type KeyPair struct {
 	KID     string
 	Private ed25519.PrivateKey
 	Public  ed25519.PublicKey
 }
 // KeyManager haelt ALLE noch gueltigen Schluesselpaare — nicht nur das
 // aktuell signierende. Rotate erzeugt ein neues Paar und behaelt die alten
 // fuer die Verifikation bereits ausgestellter Tokens (Akzeptanzkriterium 3:
 // Rotation ohne Ausfallzeit fuer andere Module).
 type KeyManager struct {
 	mu   sync.RWMutex
 	keys []KeyPair // aeltestes zuerst, neuestes zuletzt
 }
 func NewKeyManager() (*KeyManager, error) {
 	m := &KeyManager{}
 	if _, err := m.Rotate(); err != nil {
 		return nil, err
 	}
 	return m, nil
 }
 // Rotate erzeugt ein neues Ed25519-Schluesselpaar mit eigener KID und macht
 // es zum aktuellen Signierschluessel. Aeltere Schluessel bleiben in
 // PublicKeySet() erhalten, damit bereits ausgestellte Tokens weiterhin
 // verifizierbar sind.
 func (m *KeyManager) Rotate() (KeyPair, error) {
 	pub, priv, err := ed25519.GenerateKey(nil)
 	if err != nil {
 		return KeyPair{}, fmt.Errorf("schluesselpaar erzeugen: %w", err)
 	}
 	kidBytes := make([]byte, 8)
 	if _, err := rand.Read(kidBytes); err != nil {
 		return KeyPair{}, fmt.Errorf("kid erzeugen: %w", err)
 	}
 	kp := KeyPair{KID: hex.EncodeToString(kidBytes), Private: priv, Public: pub}
 	m.mu.Lock()
 	m.keys = append(m.keys, kp)
 	m.mu.Unlock()
 	return kp, nil
 }
 // SigningKey liefert den aktuellen (neuesten) Schluessel zum Signieren neuer Tokens.
 func (m *KeyManager) SigningKey() (KeyPair, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	if len(m.keys) == 0 {
 		return KeyPair{}, fmt.Errorf("moduletrust: kein schluessel vorhanden")
 	}
 	return m.keys[len(m.keys)-1], nil
 }
 // PublicKeySet liefert ALLE bekannten oeffentlichen Schluessel (kid ->
 // public key) — die Grundlage fuer den JWKS-Endpunkt.
 func (m *KeyManager) PublicKeySet() map[string]ed25519.PublicKey {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	out := make(map[string]ed25519.PublicKey, len(m.keys))
 	for _, k := range m.keys {
 		out[k.KID] = k.Public
 	}
 	return out
 }
@@ -1,214 +0,0 @@
 package moduletrust
 import (
 	"context"
 	"crypto/ed25519"
 	"errors"
 	"net/http"
 	"sync"
 	"testing"
 	"time"
 )
 func TestIssueAndVerify_RoundTrip(t *testing.T) {
 	km, err := NewKeyManager()
 	if err != nil {
 		t.Fatalf("new key manager: %v", err)
 	}
 	token, err := km.Issue("user-1", "acme", time.Hour)
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		return km.PublicKeySet(), nil
 	})
 	claims, err := v.Verify(context.Background(), token)
 	if err != nil {
 		t.Fatalf("verify: %v", err)
 	}
 	if claims.Subject != "user-1" || claims.TenantSlug != "acme" {
 		t.Fatalf("claims unerwartet: %+v", claims)
 	}
 }
 // Akzeptanzkriterium 1: Verifikation lokal, kein Request pro Aufruf.
 func TestVerify_DoesNotFetchPerCall(t *testing.T) {
 	km, err := NewKeyManager()
 	if err != nil {
 		t.Fatalf("new key manager: %v", err)
 	}
 	token, err := km.Issue("user-1", "acme", time.Hour)
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	var mu sync.Mutex
 	fetchCalls := 0
 	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		mu.Lock()
 		fetchCalls++
 		mu.Unlock()
 		return km.PublicKeySet(), nil
 	})
 	for i := 0; i < 10; i++ {
 		if _, err := v.Verify(context.Background(), token); err != nil {
 			t.Fatalf("verify %d: %v", i, err)
 		}
 	}
 	mu.Lock()
 	defer mu.Unlock()
 	if fetchCalls != 1 {
 		t.Fatalf("erwartet genau 1 fetch fuer 10 Verify-Aufrufe innerhalb der TTL, habe %d", fetchCalls)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: Core simuliert nicht erreichbar,
 // bereits authentifizierte Nutzer bleiben funktionsfaehig (Fail-Open mit
 // letztbekanntem Schluesselstand).
 func TestVerify_FailsOpenWhenCoreUnreachableButStaleKeysExist(t *testing.T) {
 	km, err := NewKeyManager()
 	if err != nil {
 		t.Fatalf("new key manager: %v", err)
 	}
 	token, err := km.Issue("user-1", "acme", time.Hour)
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	coreDown := false
 	v := NewVerifier(30*time.Millisecond, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		if coreDown {
 			return nil, errors.New("core nicht erreichbar (simuliert)")
 		}
 		return km.PublicKeySet(), nil
 	})
 	// Cache vorwaermen, waehrend Core noch erreichbar ist.
 	if _, err := v.Verify(context.Background(), token); err != nil {
 		t.Fatalf("verify (warm): %v", err)
 	}
 	// "Core abschalten" und TTL ablaufen lassen.
 	coreDown = true
 	time.Sleep(50 * time.Millisecond)
 	if _, err := v.Verify(context.Background(), token); err != nil {
 		t.Fatalf("verify sollte trotz core-ausfall mit letztbekanntem stand funktionieren: %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: neue sicherheitskritische Aktionen
 // (z.B. neuer Login) schlagen bei Core-Ausfall klar fehl statt unsicher
 // durchgelassen zu werden — auch wenn ein (aelterer) Cache-Stand existiert.
 func TestRequireFreshKeys_FailsClosedWhenCoreUnreachable(t *testing.T) {
 	km, err := NewKeyManager()
 	if err != nil {
 		t.Fatalf("new key manager: %v", err)
 	}
 	coreDown := false
 	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		if coreDown {
 			return nil, errors.New("core nicht erreichbar (simuliert)")
 		}
 		return km.PublicKeySet(), nil
 	})
 	// Cache vorwaermen (existiert jetzt ein "veralteter" gueltiger Stand).
 	if _, _, err := v.cache.Get(context.Background()); err != nil {
 		t.Fatalf("warm cache: %v", err)
 	}
 	coreDown = true
 	if err := v.RequireFreshKeys(context.Background()); err == nil {
 		t.Fatal("erwartet fehler (fail-closed) bei core-ausfall, habe nil")
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Schluesselrotation ohne Ausfallzeit —
 // ein bereits ausgestelltes Token bleibt nach Rotation weiterhin
 // verifizierbar, ein zweites (simuliertes) Modul bekommt beide Schluessel.
 func TestRotate_NoDowntimeForAlreadyIssuedTokens(t *testing.T) {
 	km, err := NewKeyManager()
 	if err != nil {
 		t.Fatalf("new key manager: %v", err)
 	}
 	oldToken, err := km.Issue("user-1", "acme", time.Hour)
 	if err != nil {
 		t.Fatalf("issue (alt): %v", err)
 	}
 	if _, err := km.Rotate(); err != nil {
 		t.Fatalf("rotate: %v", err)
 	}
 	newToken, err := km.Issue("user-2", "acme", time.Hour)
 	if err != nil {
 		t.Fatalf("issue (neu): %v", err)
 	}
 	// Simuliertes zweites Modul: fragt den vollstaendigen Schluesselsatz ab.
 	moduleB := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		return km.PublicKeySet(), nil
 	})
 	if _, err := moduleB.Verify(context.Background(), oldToken); err != nil {
 		t.Fatalf("altes token sollte nach rotation weiterhin gueltig sein: %v", err)
 	}
 	if _, err := moduleB.Verify(context.Background(), newToken); err != nil {
 		t.Fatalf("neues token sollte gueltig sein: %v", err)
 	}
 }
 func TestVerify_RejectsUnknownKid(t *testing.T) {
 	km1, _ := NewKeyManager()
 	km2, _ := NewKeyManager() // komplett anderer, unbekannter schluessel
 	token, err := km1.Issue("user-1", "acme", time.Hour)
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		return km2.PublicKeySet(), nil // kennt km1s schluessel nicht
 	})
 	if _, err := v.Verify(context.Background(), token); !errors.Is(err, ErrInvalidToken) {
 		t.Fatalf("erwartet ErrInvalidToken, habe %v", err)
 	}
 }
 func TestJWKSRoundTrip(t *testing.T) {
 	km, _ := NewKeyManager()
 	km.Rotate()
 	var buf []byte
 	rec := &captureWriter{}
 	km.ServeJWKS(rec, nil)
 	buf = rec.body
 	parsed, err := ParseJWKS(buf)
 	if err != nil {
 		t.Fatalf("parse jwks: %v", err)
 	}
 	if len(parsed) != len(km.PublicKeySet()) {
 		t.Fatalf("erwartet %d schluessel, habe %d", len(km.PublicKeySet()), len(parsed))
 	}
 }
 type captureWriter struct {
 	body   []byte
 	header http.Header
 }
 func (w *captureWriter) Header() http.Header {
 	if w.header == nil {
 		w.header = http.Header{}
 	}
 	return w.header
 }
 func (w *captureWriter) Write(p []byte) (int, error) { w.body = append(w.body, p...); return len(p), nil }
 func (w *captureWriter) WriteHeader(statusCode int)  {}
@@ -1,67 +0,0 @@
 package moduletrust
 import (
 	"context"
 	"crypto/ed25519"
 	"errors"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 )
 var ErrInvalidToken = errors.New("moduletrust: ungueltiges token")
 // KeyFetchFunc holt den aktuellen Schluesselsatz von Core (z.B. per HTTP-GET
 // auf ServeJWKS + ParseJWKS). Wird vom Verifier nur bei abgelaufener TTL
 // aufgerufen — NICHT bei jeder Verify()-Anfrage (Akzeptanzkriterium 1).
 type KeyFetchFunc func(ctx context.Context) (map[string]ed25519.PublicKey, error)
 // Verifier ist die Modulseite von API-05: verifiziert JWTs LOKAL gegen einen
 // per StaleCache zwischengespeicherten Schluesselsatz, ohne pro Aufruf einen
 // synchronen Request an Core zu stellen.
 type Verifier struct {
 	cache *StaleCache[map[string]ed25519.PublicKey]
 }
 func NewVerifier(ttl time.Duration, fetch KeyFetchFunc) *Verifier {
 	return &Verifier{cache: NewStaleCache(ttl, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		return fetch(ctx)
 	})}
 }
 // Verify prueft die Signatur LOKAL gegen den (ggf. abgelaufenen, aber
 // vorhandenen) Schluesselsatz — FAIL-OPEN fuer bereits ausgestellte Tokens
 // (Akzeptanzkriterium 2): ist Core nicht erreichbar, aber ein alter
 // Schluesselsatz bekannt, wird damit weiter verifiziert.
 func (v *Verifier) Verify(ctx context.Context, tokenString string) (*Claims, error) {
 	keys, _, err := v.cache.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
 	claims := &Claims{}
 	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
 		if _, ok := t.Method.(*jwt.SigningMethodEd25519); !ok {
 			return nil, ErrInvalidToken
 		}
 		kid, _ := t.Header["kid"].(string)
 		pub, ok := keys[kid]
 		if !ok {
 			return nil, ErrInvalidToken
 		}
 		return pub, nil
 	})
 	if err != nil || !token.Valid {
 		return nil, ErrInvalidToken
 	}
 	return claims, nil
 }
 // RequireFreshKeys ruft IMMER frisch von Core ab (FAIL-CLOSED) — fuer
 // sicherheitskritische Aktionen wie einen komplett neuen Login
 // (Akzeptanzkriterium 2): schlaegt klar fehl, wenn Core nicht erreichbar
 // ist, statt auf einem veralteten Schluesselsatz zu vertrauen.
 func (v *Verifier) RequireFreshKeys(ctx context.Context) error {
 	_, err := v.cache.RequireFresh(ctx)
 	return err
 }
@@ -1,91 +0,0 @@
 package oidc
 import (
 	"context"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // AuthCodeTTL folgt RFC 6749 Empfehlung: Authorization Codes sind extrem
 // kurzlebig, der Client tauscht sie sofort gegen ein Token.
 const AuthCodeTTL = 60 * time.Second
 var ErrInvalidAuthCode = errors.New("oidc: ungueltiger, abgelaufener oder bereits verwendeter authorization code")
 // AuthCodeData ist das Ergebnis eines eingeloesten Authorization Codes.
 type AuthCodeData struct {
 	ClientID    string
 	UserID      string
 	RedirectURI string
 	Scopes      []string
 }
 // AuthCodeStore verwaltet Authorization Codes innerhalb GENAU EINER Tenant-Datenbank.
 type AuthCodeStore struct {
 	pool *pgxpool.Pool
 }
 func NewAuthCodeStore(pool *pgxpool.Pool) *AuthCodeStore {
 	return &AuthCodeStore{pool: pool}
 }
 // Issue erzeugt einen neuen Authorization Code (Akzeptanzkriterium 2, Schritt
 // 1 des Flows) — gespeichert wird nur der Hash, das Klartext-Code wird per
 // Redirect an den Client uebertragen (Standard-OAuth2-Verhalten, der Code
 // selbst ist einmalig und kurzlebig genug, dass die Redirect-URL kein
 // nennenswertes Risiko darstellt).
 func (s *AuthCodeStore) Issue(ctx context.Context, clientID, userID, redirectURI string, scopes []string) (code string, err error) {
 	code, err = randomToken(32)
 	if err != nil {
 		return "", fmt.Errorf("code erzeugen: %w", err)
 	}
 	hash := hashSecret(code)
 	expiresAt := time.Now().Add(AuthCodeTTL)
 	_, err = s.pool.Exec(ctx, `
 		INSERT INTO oidc_auth_codes (code_hash, client_id, user_id, redirect_uri, scopes, expires_at)
 		VALUES ($1, $2, $3, $4, $5, $6)
 	`, hash, clientID, userID, redirectURI, scopes, expiresAt)
 	if err != nil {
 		return "", fmt.Errorf("code speichern: %w", err)
 	}
 	return code, nil
 }
 // Consume loest einen Authorization Code genau einmal ein (Akzeptanzkriterium
 // 2, Schritt 2 des Flows) — atomar ueber die WHERE-Klausel (used_at IS NULL
 // AND expires_at > now()), gleiches Muster wie internal/authtoken (IAM-03).
 func (s *AuthCodeStore) Consume(ctx context.Context, code, clientID, redirectURI string) (AuthCodeData, error) {
 	hash := hashSecret(code)
 	var data AuthCodeData
 	var storedClientID, storedRedirectURI string
 	row := s.pool.QueryRow(ctx, `
 		UPDATE oidc_auth_codes
 		SET used_at = now()
 		WHERE code_hash = $1 AND used_at IS NULL AND expires_at > now()
 		RETURNING client_id, user_id, redirect_uri, scopes
 	`, hash)
 	if err := row.Scan(&storedClientID, &data.UserID, &storedRedirectURI, &data.Scopes); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return AuthCodeData{}, ErrInvalidAuthCode
 		}
 		return AuthCodeData{}, fmt.Errorf("code einloesen: %w", err)
 	}
 	// client_id und redirect_uri muessen exakt zu denen des urspruenglichen
 	// Authorize-Aufrufs passen (RFC 6749 4.1.3) — sonst koennte ein Code, der
 	// fuer Client A ausgestellt wurde, bei Client B eingeloest werden.
 	if storedClientID != clientID || storedRedirectURI != redirectURI {
 		return AuthCodeData{}, ErrInvalidAuthCode
 	}
 	data.ClientID = storedClientID
 	data.RedirectURI = storedRedirectURI
 	return data, nil
 }
@@ -1,167 +0,0 @@
 // Package oidc implementiert Core IAM-13: NEXARCH als OIDC/OAuth2-Provider,
 // damit Drittanwendungen eines Mandanten sich gegen NEXARCH-Benutzerkonten
 // authentifizieren koennen. Baut bewusst auf der bestehenden JWKS-
 // Infrastruktur (internal/moduletrust, API-05) auf statt ein zweites
 // Schluesselsystem zu bauen — siehe provider.go.
 package oidc
 import (
 	"context"
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/subtle"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	ErrClientNotFound     = errors.New("oidc: client nicht gefunden")
 	ErrInvalidClientAuth  = errors.New("oidc: ungueltige client-authentifizierung")
 	ErrRedirectURINotAllowed = errors.New("oidc: redirect_uri ist fuer diesen client nicht registriert")
 )
 // Client ist eine bei NEXARCH registrierte Drittanwendung
 // (Akzeptanzkriterium 1). AllowedScopes begrenzt, welche Scopes ein Token
 // fuer diesen Client tragen darf — unabhaengig davon, was beim Authorize-
 // Aufruf angefragt wird (Akzeptanzkriterium 3 / Pruefung 3).
 type Client struct {
 	ID            string
 	Name          string
 	ClientID      string
 	RedirectURIs  []string
 	AllowedScopes []string
 }
 // ClientStore verwaltet OAuth2-Clients innerhalb GENAU EINER Tenant-
 // Datenbank (gleiches Muster wie internal/user.TenantUserStore, IAM-03).
 type ClientStore struct {
 	pool *pgxpool.Pool
 }
 func NewClientStore(pool *pgxpool.Pool) *ClientStore {
 	return &ClientStore{pool: pool}
 }
 // Register legt einen neuen OAuth2-Client an (Akzeptanzkriterium 1). Das
 // Client-Secret wird NUR hier im Klartext zurueckgegeben, gespeichert wird
 // ausschliesslich dessen SHA-256-Hash — gleiches Muster wie
 // internal/moduleregistry.Provision (API-02).
 func (s *ClientStore) Register(ctx context.Context, name string, redirectURIs, allowedScopes []string) (clientID, clientSecret string, err error) {
 	if name == "" {
 		return "", "", errors.New("oidc: name darf nicht leer sein")
 	}
 	if len(redirectURIs) == 0 {
 		return "", "", errors.New("oidc: mindestens eine redirect_uri ist erforderlich")
 	}
 	clientID, err = randomToken(16)
 	if err != nil {
 		return "", "", fmt.Errorf("client-id erzeugen: %w", err)
 	}
 	clientSecret, err = randomToken(32)
 	if err != nil {
 		return "", "", fmt.Errorf("client-secret erzeugen: %w", err)
 	}
 	hash := hashSecret(clientSecret)
 	_, err = s.pool.Exec(ctx, `
 		INSERT INTO oidc_clients (name, client_id, secret_hash, redirect_uris, allowed_scopes)
 		VALUES ($1, $2, $3, $4, $5)
 	`, name, clientID, hash, redirectURIs, allowedScopes)
 	if err != nil {
 		return "", "", fmt.Errorf("client speichern: %w", err)
 	}
 	return clientID, clientSecret, nil
 }
 func (s *ClientStore) getByClientID(ctx context.Context, clientID string) (Client, []byte, error) {
 	var c Client
 	var storedHash []byte
 	row := s.pool.QueryRow(ctx, `
 		SELECT id, name, client_id, redirect_uris, allowed_scopes, secret_hash
 		FROM oidc_clients WHERE client_id = $1
 	`, clientID)
 	if err := row.Scan(&c.ID, &c.Name, &c.ClientID, &c.RedirectURIs, &c.AllowedScopes, &storedHash); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return Client{}, nil, ErrClientNotFound
 		}
 		return Client{}, nil, fmt.Errorf("client laden: %w", err)
 	}
 	return c, storedHash, nil
 }
 // Get laedt einen Client ohne Secret-Pruefung (fuer den Authorize-Schritt,
 // der kein Client-Secret kennt — der Browser des Endnutzers, nicht die
 // Drittanwendung selbst, ruft /oidc/authorize auf).
 func (s *ClientStore) Get(ctx context.Context, clientID string) (Client, error) {
 	c, _, err := s.getByClientID(ctx, clientID)
 	return c, err
 }
 // Authenticate prueft Client-ID + Secret timing-safe (Akzeptanzkriterium 2,
 // Token-Endpunkt) — gleiches Muster wie internal/moduleregistry.Authenticate (API-02).
 func (s *ClientStore) Authenticate(ctx context.Context, clientID, clientSecret string) (Client, error) {
 	c, storedHash, err := s.getByClientID(ctx, clientID)
 	if err != nil {
 		return Client{}, err
 	}
 	if !timingSafeEqual(hashSecret(clientSecret), storedHash) {
 		return Client{}, ErrInvalidClientAuth
 	}
 	return c, nil
 }
 // ValidateRedirectURI erzwingt exakten Abgleich gegen die registrierte
 // Liste (kein Praefix-/Wildcard-Match) — Standardhaertung gegen Open-Redirect
 // im Authorization-Code-Flow.
 func (c Client) ValidateRedirectURI(redirectURI string) error {
 	for _, allowed := range c.RedirectURIs {
 		if allowed == redirectURI {
 			return nil
 		}
 	}
 	return ErrRedirectURINotAllowed
 }
 // GrantedScopes schraenkt die angefragten Scopes auf das ein, was fuer den
 // Client tatsaechlich erlaubt ist (Akzeptanzkriterium 3) — nie mehr
 // gewaehren, als bei der Registrierung zugestanden wurde.
 func (c Client) GrantedScopes(requested []string) []string {
 	allowed := make(map[string]bool, len(c.AllowedScopes))
 	for _, s := range c.AllowedScopes {
 		allowed[s] = true
 	}
 	var granted []string
 	for _, s := range requested {
 		if allowed[s] {
 			granted = append(granted, s)
 		}
 	}
 	return granted
 }
 func randomToken(n int) (string, error) {
 	buf := make([]byte, n)
 	if _, err := rand.Read(buf); err != nil {
 		return "", err
 	}
 	return hex.EncodeToString(buf), nil
 }
 func hashSecret(secret string) []byte {
 	sum := sha256.Sum256([]byte(secret))
 	return sum[:]
 }
 // timingSafeEqual folgt demselben Referenzmuster wie internal/moduleregistry
 // (API-02) — projektweite Konvention aus SICHERHEITSKONZEPT.md / IAM-15.
 func timingSafeEqual(a, b []byte) bool {
 	if len(a) != len(b) {
 		return false
 	}
 	return subtle.ConstantTimeCompare(a, b) == 1
 }
@@ -1,251 +0,0 @@
 package oidc
 import (
 	"encoding/base64"
 	"encoding/json"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
 )
 // IDTokenTTL: kurzlebig wie ein normales Access-Token (Produkt-DNA "so
 // vertrauenswuerdig wie noetig"), ein Refresh-Flow ist ausdruecklich nicht
 // Teil dieser Kachel (kleinste Loesung, die die Akzeptanzkriterien erfuellt).
 const IDTokenTTL = 15 * time.Minute
 // IDTokenClaims sind die vom Client verifizierbaren Angaben ueber den
 // angemeldeten Benutzer — signiert mit demselben Schluesselmaterial wie
 // Modul-zu-Modul-Tokens (internal/moduletrust, API-05), aber mit eigener,
 // OIDC-spezifischer Struktur (aud, scope), da moduletrust.Claims dafuer
 // nicht vorgesehen ist. Kein zweites Schluesselsystem — nur eine zweite
 // Claims-Form desselben Signierschluessels.
 type IDTokenClaims struct {
 	Subject    string   `json:"sub"`
 	TenantSlug string   `json:"tenant"`
 	Scopes     []string `json:"scope"`
 	jwt.RegisteredClaims
 }
 // Handler buendelt die drei OIDC-Endpunkte. issuerURL identifiziert NEXARCH
 // als Aussteller (iss-Claim, Standard-OIDC-Feld).
 type Handler struct {
 	clients   *ClientStore
 	authCodes *AuthCodeStore
 	keys      *moduletrust.KeyManager
 	issuerURL string
 }
 func NewHandler(clients *ClientStore, authCodes *AuthCodeStore, keys *moduletrust.KeyManager, issuerURL string) *Handler {
 	return &Handler{clients: clients, authCodes: authCodes, keys: keys, issuerURL: issuerURL}
 }
 type registerClientRequest struct {
 	Name          string   `json:"name"`
 	RedirectURIs  []string `json:"redirect_uris"`
 	AllowedScopes []string `json:"allowed_scopes"`
 }
 type registerClientResponse struct {
 	ClientID     string `json:"client_id"`
 	ClientSecret string `json:"client_secret"`
 }
 // RegisterClient ist Akzeptanzkriterium 1: eine Drittanwendung wird als
 // OAuth2-Client registriert. Muss hinter auth.RequireAuth haengen — nur
 // angemeldete Benutzer des jeweiligen Mandanten duerfen Clients fuer ihren
 // eigenen Mandanten anlegen (ClientStore ist bereits auf die Tenant-DB des
 // Aufrufers gebunden, siehe NewHandler-Aufstellung im jeweiligen Modul-Server).
 func (h *Handler) RegisterClient(w http.ResponseWriter, r *http.Request) {
 	if _, ok := auth.ClaimsFromContext(r.Context()); !ok {
 		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
 		return
 	}
 	var req registerClientRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltiger request-body", http.StatusBadRequest)
 		return
 	}
 	clientID, clientSecret, err := h.clients.Register(r.Context(), req.Name, req.RedirectURIs, req.AllowedScopes)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusCreated)
 	_ = json.NewEncoder(w).Encode(registerClientResponse{ClientID: clientID, ClientSecret: clientSecret})
 }
 // Authorize ist Schritt 1 des Authorization-Code-Flows (Akzeptanzkriterium 2).
 // Muss hinter auth.RequireAuth haengen — der aufrufende Browser ist bereits
 // als NEXARCH-Benutzer angemeldet, hier wird nur noch der Client geprueft
 // und ein Code fuer GENAU DIESEN Benutzer ausgestellt.
 func (h *Handler) Authorize(w http.ResponseWriter, r *http.Request) {
 	claims, ok := auth.ClaimsFromContext(r.Context())
 	if !ok {
 		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
 		return
 	}
 	q := r.URL.Query()
 	if q.Get("response_type") != "code" {
 		http.Error(w, "nur response_type=code wird unterstuetzt", http.StatusBadRequest)
 		return
 	}
 	clientID := q.Get("client_id")
 	redirectURI := q.Get("redirect_uri")
 	state := q.Get("state")
 	requestedScopes := splitScopes(q.Get("scope"))
 	client, err := h.clients.Get(r.Context(), clientID)
 	if err != nil {
 		http.Error(w, "unbekannter client", http.StatusBadRequest)
 		return
 	}
 	if err := client.ValidateRedirectURI(redirectURI); err != nil {
 		// Bewusst KEIN Redirect zu einer nicht registrierten redirect_uri —
 		// Open-Redirect-Schutz geht vor Komfort, Fehler wird direkt angezeigt.
 		http.Error(w, "redirect_uri ist fuer diesen client nicht registriert", http.StatusBadRequest)
 		return
 	}
 	granted := client.GrantedScopes(requestedScopes)
 	code, err := h.authCodes.Issue(r.Context(), client.ClientID, claims.UserID, redirectURI, granted)
 	if err != nil {
 		http.Error(w, "code konnte nicht ausgestellt werden", http.StatusInternalServerError)
 		return
 	}
 	target, err := url.Parse(redirectURI)
 	if err != nil {
 		http.Error(w, "ungueltige redirect_uri", http.StatusBadRequest)
 		return
 	}
 	values := target.Query()
 	values.Set("code", code)
 	if state != "" {
 		values.Set("state", state)
 	}
 	target.RawQuery = values.Encode()
 	http.Redirect(w, r, target.String(), http.StatusFound)
 }
 // Token ist Schritt 2 des Authorization-Code-Flows (Akzeptanzkriterium 2):
 // die Drittanwendung tauscht den Code serverseitig gegen ein ID-Token.
 func (h *Handler) Token(w http.ResponseWriter, r *http.Request) {
 	if err := r.ParseForm(); err != nil {
 		http.Error(w, "ungueltiger request-body", http.StatusBadRequest)
 		return
 	}
 	if r.PostForm.Get("grant_type") != "authorization_code" {
 		http.Error(w, "nur grant_type=authorization_code wird unterstuetzt", http.StatusBadRequest)
 		return
 	}
 	clientID := r.PostForm.Get("client_id")
 	clientSecret := r.PostForm.Get("client_secret")
 	code := r.PostForm.Get("code")
 	redirectURI := r.PostForm.Get("redirect_uri")
 	client, err := h.clients.Authenticate(r.Context(), clientID, clientSecret)
 	if err != nil {
 		http.Error(w, "client-authentifizierung fehlgeschlagen", http.StatusUnauthorized)
 		return
 	}
 	data, err := h.authCodes.Consume(r.Context(), code, client.ClientID, redirectURI)
 	if err != nil {
 		http.Error(w, "authorization code ungueltig, abgelaufen oder bereits verwendet", http.StatusBadRequest)
 		return
 	}
 	idToken, err := h.issueIDToken(data)
 	if err != nil {
 		http.Error(w, "token konnte nicht ausgestellt werden", http.StatusInternalServerError)
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(map[string]any{
 		"id_token":     idToken,
 		"access_token": idToken, // kein separates Access-Token-Format in dieser Kachel — das ID-Token traegt bereits Subject+Scopes.
 		"token_type":   "Bearer",
 		"expires_in":   int(IDTokenTTL.Seconds()),
 		"scope":        strings.Join(data.Scopes, " "),
 	})
 }
 func (h *Handler) issueIDToken(data AuthCodeData) (string, error) {
 	key, err := h.keys.SigningKey()
 	if err != nil {
 		return "", err
 	}
 	now := time.Now()
 	claims := IDTokenClaims{
 		Subject: data.UserID,
 		Scopes:  data.Scopes,
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    h.issuerURL,
 			Audience:  jwt.ClaimStrings{data.ClientID},
 			IssuedAt:  jwt.NewNumericDate(now),
 			ExpiresAt: jwt.NewNumericDate(now.Add(IDTokenTTL)),
 		},
 	}
 	token := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims)
 	token.Header["kid"] = key.KID
 	return token.SignedString(key.Private)
 }
 // jwk / jwkSet folgen RFC 8037 (Ed25519 als OKP-Schluesseltyp) — im
 // Unterschied zu moduletrust.ServeJWKS (internes, vereinfachtes Format fuer
 // Modul-zu-Modul-Kommunikation) muss dieser Endpunkt von generischen,
 // standardkonformen OIDC-Client-Bibliotheken Dritter lesbar sein
 // (Akzeptanzkriterium 3). Beide Endpunkte liefern dieselben Schluessel aus
 // demselben KeyManager — kein zweites Schluesselsystem, nur ein zweites,
 // spezifikationskonformes Format desselben Materials.
 type jwk struct {
 	Kty string `json:"kty"`
 	Crv string `json:"crv"`
 	Kid string `json:"kid"`
 	X   string `json:"x"`
 	Use string `json:"use"`
 	Alg string `json:"alg"`
 }
 type jwkSet struct {
 	Keys []jwk `json:"keys"`
 }
 func (h *Handler) JWKS(w http.ResponseWriter, r *http.Request) {
 	set := h.keys.PublicKeySet()
 	resp := jwkSet{Keys: make([]jwk, 0, len(set))}
 	for kid, pub := range set {
 		resp.Keys = append(resp.Keys, jwk{
 			Kty: "OKP",
 			Crv: "Ed25519",
 			Kid: kid,
 			X:   base64.RawURLEncoding.EncodeToString(pub),
 			Use: "sig",
 			Alg: "EdDSA",
 		})
 	}
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(resp)
 }
 func splitScopes(raw string) []string {
 	if raw == "" {
 		return nil
 	}
 	return strings.Fields(raw)
 }
@@ -1,294 +0,0 @@
 package oidc
 import (
 	"context"
 	"crypto/ed25519"
 	"encoding/base64"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"os"
 	"strings"
 	"testing"
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
 )
 // newProviderTestSetup baut Tenant-DB-Schema (users, oidc_clients,
 // oidc_auth_codes) direkt gegen TEST_ADMIN_DSN auf, analog zum Muster in
 // internal/tenant/lifecycle_test.go — braucht kein volles Tenant-Provisioning,
 // nur eine isolierte Datenbank fuer diesen Testlauf.
 func newProviderTestSetup(t *testing.T) (*Handler, *pgxpool.Pool, 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 EXTENSION IF NOT EXISTS pgcrypto;
 		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',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS oidc_clients (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			name TEXT NOT NULL,
 			client_id TEXT NOT NULL UNIQUE,
 			secret_hash BYTEA NOT NULL,
 			redirect_uris TEXT[] NOT NULL,
 			allowed_scopes TEXT[] NOT NULL,
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS oidc_auth_codes (
 			code_hash BYTEA PRIMARY KEY,
 			client_id TEXT NOT NULL REFERENCES oidc_clients(client_id),
 			user_id UUID NOT NULL REFERENCES users(id),
 			redirect_uri TEXT NOT NULL,
 			scopes TEXT[] NOT NULL,
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			expires_at TIMESTAMPTZ NOT NULL,
 			used_at TIMESTAMPTZ
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	keys, err := moduletrust.NewKeyManager()
 	if err != nil {
 		t.Fatalf("keymanager: %v", err)
 	}
 	clients := NewClientStore(pool)
 	authCodes := NewAuthCodeStore(pool)
 	handler := NewHandler(clients, authCodes, keys, "https://core.test.nexarch.example")
 	cleanup := func() {
 		ctx := context.Background()
 		_, _ = pool.Exec(ctx, `DROP TABLE IF EXISTS oidc_auth_codes, oidc_clients, users CASCADE`)
 		pool.Close()
 	}
 	return handler, pool, cleanup
 }
 func createTestUser(t *testing.T, pool *pgxpool.Pool, email string) string {
 	t.Helper()
 	var id string
 	err := pool.QueryRow(context.Background(), `
 		INSERT INTO users (email, name) VALUES ($1, $2) RETURNING id
 	`, email, "Test Nutzer").Scan(&id)
 	if err != nil {
 		t.Fatalf("testnutzer anlegen: %v", err)
 	}
 	return id
 }
 // Akzeptanzkriterium 1 (Client-Registrierung) + 2 (voller Flow) + 3 (JWKS-
 // Verifikation, Scope-Einschraenkung). Deckt Pruefungen 1-3 ab.
 func TestFullAuthorizationCodeFlow(t *testing.T) {
 	handler, pool, cleanup := newProviderTestSetup(t)
 	defer cleanup()
 	ctx := context.Background()
 	userID := createTestUser(t, pool, "nutzer@acme.example")
 	// Pruefung 1 / Akzeptanzkriterium 1: Client registriert sich.
 	clientID, clientSecret, err := handler.clients.Register(ctx, "Test-Drittanwendung",
 		[]string{"https://app.example.com/callback"},
 		[]string{"openid", "profile"}, // erlaubte Scopes: KEIN "admin"
 	)
 	if err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	// Session-Cookie fuer den Authorize-Aufruf ausstellen, exakt wie ein
 	// echter Browser ihn haette — RequireAuth uebernimmt die Verifikation,
 	// dieselbe Middleware wie in Produktion (nicht simuliert).
 	issuer := auth.NewTokenIssuer("test-session-secret")
 	sessionToken, err := issuer.Issue(userID, "acme")
 	if err != nil {
 		t.Fatalf("session-token ausstellen: %v", err)
 	}
 	authorizeURL := "/oidc/authorize?" + url.Values{
 		"response_type": {"code"},
 		"client_id":     {clientID},
 		"redirect_uri":  {"https://app.example.com/callback"},
 		// admin wird angefragt, ist aber NICHT erlaubt -> muss herausgefiltert werden.
 		"scope": {"openid profile admin"},
 		"state": {"xyz123"},
 	}.Encode()
 	req := httptest.NewRequest(http.MethodGet, authorizeURL, nil)
 	req.AddCookie(&http.Cookie{Name: auth.CookieName, Value: sessionToken})
 	rec := httptest.NewRecorder()
 	protected := auth.RequireAuth(issuer, handler.Authorize)
 	protected(rec, req)
 	if rec.Code != http.StatusFound {
 		t.Fatalf("authorize: status = %d, want %d, body: %s", rec.Code, http.StatusFound, rec.Body.String())
 	}
 	loc, err := url.Parse(rec.Header().Get("Location"))
 	if err != nil {
 		t.Fatalf("redirect-location parsen: %v", err)
 	}
 	if loc.Query().Get("state") != "xyz123" {
 		t.Fatalf("state = %q, want xyz123 (muss unveraendert durchgereicht werden)", loc.Query().Get("state"))
 	}
 	code := loc.Query().Get("code")
 	if code == "" {
 		t.Fatal("erwartet gesetzten code-Parameter in der redirect-URL")
 	}
 	// Pruefung 1 / Akzeptanzkriterium 2: Code gegen Token tauschen.
 	tokenForm := url.Values{
 		"grant_type":    {"authorization_code"},
 		"code":          {code},
 		"redirect_uri":  {"https://app.example.com/callback"},
 		"client_id":     {clientID},
 		"client_secret": {clientSecret},
 	}
 	tokenReq := httptest.NewRequest(http.MethodPost, "/oidc/token", strings.NewReader(tokenForm.Encode()))
 	tokenReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 	tokenRec := httptest.NewRecorder()
 	handler.Token(tokenRec, tokenReq)
 	if tokenRec.Code != http.StatusOK {
 		t.Fatalf("token: status = %d, want 200, body: %s", tokenRec.Code, tokenRec.Body.String())
 	}
 	var tokenResp struct {
 		IDToken string `json:"id_token"`
 		Scope   string `json:"scope"`
 	}
 	if err := decodeJSON(tokenRec.Body.Bytes(), &tokenResp); err != nil {
 		t.Fatalf("token-response dekodieren: %v", err)
 	}
 	// Akzeptanzkriterium 3 / Pruefung 3: "admin" wurde herausgefiltert.
 	grantedScopes := strings.Fields(tokenResp.Scope)
 	for _, s := range grantedScopes {
 		if s == "admin" {
 			t.Fatal("nicht erlaubter scope 'admin' wurde dennoch gewaehrt")
 		}
 	}
 	if !containsAll(grantedScopes, "openid", "profile") {
 		t.Fatalf("erwartete scopes openid+profile, habe %v", grantedScopes)
 	}
 	// Pruefung 2 / Akzeptanzkriterium 3: ausgestelltes Token gegen JWKS verifizieren.
 	jwksRec := httptest.NewRecorder()
 	handler.JWKS(jwksRec, httptest.NewRequest(http.MethodGet, "/oidc/jwks.json", nil))
 	var jwks jwkSet
 	if err := decodeJSON(jwksRec.Body.Bytes(), &jwks); err != nil {
 		t.Fatalf("jwks dekodieren: %v", err)
 	}
 	if len(jwks.Keys) == 0 {
 		t.Fatal("jwks enthaelt keine schluessel")
 	}
 	parsedToken, err := jwt.ParseWithClaims(tokenResp.IDToken, &IDTokenClaims{}, func(tok *jwt.Token) (interface{}, error) {
 		kid, _ := tok.Header["kid"].(string)
 		for _, k := range jwks.Keys {
 			if k.Kid == kid {
 				pub, err := decodeBase64URLEd25519(k.X)
 				if err != nil {
 					return nil, err
 				}
 				return ed25519.PublicKey(pub), nil
 			}
 		}
 		return nil, jwt.ErrTokenUnverifiable
 	})
 	if err != nil || !parsedToken.Valid {
 		t.Fatalf("id-token gegen jwks verifizieren: %v (valid=%v)", err, parsedToken != nil && parsedToken.Valid)
 	}
 	claims := parsedToken.Claims.(*IDTokenClaims)
 	if claims.Subject != userID {
 		t.Fatalf("sub = %q, want %q", claims.Subject, userID)
 	}
 	if len(claims.Audience) != 1 || claims.Audience[0] != clientID {
 		t.Fatalf("aud = %v, want [%q]", claims.Audience, clientID)
 	}
 }
 // Pruefung 3 (dediziert): Client, der einen Scope anfragt, den er bei der
 // Registrierung nicht erhalten hat, bekommt ihn unter keinen Umstaenden.
 func TestGrantedScopes_NeverExceedsAllowed(t *testing.T) {
 	c := Client{AllowedScopes: []string{"openid", "profile"}}
 	granted := c.GrantedScopes([]string{"openid", "admin", "profile", "billing"})
 	if !containsAll(granted, "openid", "profile") || len(granted) != 2 {
 		t.Fatalf("granted = %v, want genau [openid profile]", granted)
 	}
 }
 func TestValidateRedirectURI_RejectsUnregistered(t *testing.T) {
 	c := Client{RedirectURIs: []string{"https://app.example.com/callback"}}
 	if err := c.ValidateRedirectURI("https://boese-seite.example.com/callback"); err == nil {
 		t.Fatal("erwartet fehler fuer nicht registrierte redirect_uri")
 	}
 	if err := c.ValidateRedirectURI("https://app.example.com/callback"); err != nil {
 		t.Fatalf("registrierte redirect_uri sollte akzeptiert werden: %v", err)
 	}
 }
 func TestAuthCodeStore_CannotBeConsumedTwice(t *testing.T) {
 	handler, pool, cleanup := newProviderTestSetup(t)
 	defer cleanup()
 	ctx := context.Background()
 	userID := createTestUser(t, pool, "einmalig@acme.example")
 	clientID, _, err := handler.clients.Register(ctx, "Einmal-Client", []string{"https://a.example/cb"}, []string{"openid"})
 	if err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	code, err := handler.authCodes.Issue(ctx, clientID, userID, "https://a.example/cb", []string{"openid"})
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	if _, err := handler.authCodes.Consume(ctx, code, clientID, "https://a.example/cb"); err != nil {
 		t.Fatalf("erster consume sollte funktionieren: %v", err)
 	}
 	if _, err := handler.authCodes.Consume(ctx, code, clientID, "https://a.example/cb"); err == nil {
 		t.Fatal("zweiter consume desselben codes haette fehlschlagen muessen")
 	}
 }
 func containsAll(haystack []string, needles ...string) bool {
 	set := make(map[string]bool, len(haystack))
 	for _, h := range haystack {
 		set[h] = true
 	}
 	for _, n := range needles {
 		if !set[n] {
 			return false
 		}
 	}
 	return true
 }
 func decodeJSON(data []byte, v any) error {
 	return json.Unmarshal(data, v)
 }
 func decodeBase64URLEd25519(s string) ([]byte, error) {
 	return base64.RawURLEncoding.DecodeString(s)
 }
@@ -0,0 +1,35 @@
 package session
 import (
 	"context"
 	"fmt"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 // LoginAndCreateSession prueft die Anmeldedaten mit demselben timing-safen
 // bcrypt-Vergleich wie IAM-02s LoginService (kein zweiter Credential-Check),
 // erzeugt bei Erfolg aber eine widerrufbare Sitzung statt eines
 // zustandslosen JWT — das ist der Bearer-Token fuer diese Selbstbedienungs-
 // Funktion.
 func LoginAndCreateSession(ctx context.Context, users *user.TenantUserStore, sessions *Store, email, password, deviceInfo, ip string) (sessionToken string, err error) {
 	creds, err := users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		return "", fmt.Errorf("anmeldedaten pruefen: %w", err)
 	}
 	if creds.User.Status != user.StatusActive {
 		return "", fmt.Errorf("konto nicht aktiv")
 	}
 	// Wiederverwendung von IAM-02s timing-safem bcrypt-Vergleich, kein
 	// zweiter Passwort-Pruefmechanismus.
 	if !auth.VerifyPassword(creds.PasswordHash, password) {
 		return "", fmt.Errorf("anmeldedaten ungueltig")
 	}
 	_, sessionToken, err = sessions.Create(ctx, creds.User.ID, deviceInfo, ip)
 	if err != nil {
 		return "", fmt.Errorf("sitzung anlegen: %w", err)
 	}
 	return sessionToken, nil
 }
@@ -0,0 +1,142 @@
 // Package session implementiert Core IAM-12: Selbstbedienungs-Sitzungs-
 // uebersicht mit Geraete-/Zugriffsinformationen und gezieltem Widerruf.
 // Bewusst serverseitig und widerrufbar — ein separater Mechanismus neben
 // IAM-02s zustandslosem JWT (das fuer schnelle Modul-zu-Modul-Verifikation
 // ohne Core-Rueckfrage gewaehlt wurde, siehe API-05). Fuer den
 // Selbstbedienungs-Anwendungsfall hier ist sofortige Widerrufbarkeit
 // wichtiger als Zustandslosigkeit.
 package session
 import (
 	"context"
 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var ErrSessionInvalid = errors.New("session: sitzung ungueltig oder widerrufen")
 type Session struct {
 	ID         string
 	UserID     string
 	DeviceInfo string
 	IP         string
 	CreatedAt  time.Time
 	LastSeenAt time.Time
 }
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // Create legt eine neue Sitzung an und liefert den Klartext-Token NUR an den
 // Aufrufer zurueck (als Cookie-Wert) — gespeichert wird ausschliesslich der Hash.
 func (s *Store) Create(ctx context.Context, userID, deviceInfo, ip string) (id, token string, err error) {
 	token, err = randomToken()
 	if err != nil {
 		return "", "", fmt.Errorf("token erzeugen: %w", err)
 	}
 	hash := hashToken(token)
 	err = s.pool.QueryRow(ctx, `
 		INSERT INTO sessions (user_id, token_hash, device_info, ip)
 		VALUES ($1, $2, $3, $4)
 		RETURNING id
 	`, userID, hash, deviceInfo, ip).Scan(&id)
 	if err != nil {
 		return "", "", fmt.Errorf("sitzung anlegen: %w", err)
 	}
 	return id, token, nil
 }
 // Validate prueft ein Sitzungs-Token direkt gegen die Datenbank — kein
 // Cache, ein widerrufenes Token ist beim naechsten Zugriffsversuch sofort
 // ungueltig (Akzeptanzkriterium 2). Erfolgreiche Validierung aktualisiert
 // last_seen_at (Akzeptanzkriterium 1: letzter Zugriff).
 func (s *Store) Validate(ctx context.Context, token string) (Session, error) {
 	hash := hashToken(token)
 	var sess Session
 	err := s.pool.QueryRow(ctx, `
 		UPDATE sessions SET last_seen_at = now()
 		WHERE token_hash = $1 AND revoked_at IS NULL
 		RETURNING id, user_id, device_info, ip, created_at, last_seen_at
 	`, hash).Scan(&sess.ID, &sess.UserID, &sess.DeviceInfo, &sess.IP, &sess.CreatedAt, &sess.LastSeenAt)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return Session{}, ErrSessionInvalid
 		}
 		return Session{}, fmt.Errorf("sitzung pruefen: %w", err)
 	}
 	return sess, nil
 }
 // ListForUser liefert alle NICHT widerrufenen Sitzungen eines Benutzers
 // (Akzeptanzkriterium 1).
 func (s *Store) ListForUser(ctx context.Context, userID string) ([]Session, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT id, user_id, device_info, ip, created_at, last_seen_at
 		FROM sessions WHERE user_id = $1 AND revoked_at IS NULL
 		ORDER BY last_seen_at DESC
 	`, userID)
 	if err != nil {
 		return nil, fmt.Errorf("sitzungen auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Session
 	for rows.Next() {
 		var sess Session
 		if err := rows.Scan(&sess.ID, &sess.UserID, &sess.DeviceInfo, &sess.IP, &sess.CreatedAt, &sess.LastSeenAt); err != nil {
 			return nil, fmt.Errorf("sitzung lesen: %w", err)
 		}
 		out = append(out, sess)
 	}
 	return out, rows.Err()
 }
 // Revoke widerruft eine einzelne Sitzung sofort (Akzeptanzkriterium 2).
 func (s *Store) Revoke(ctx context.Context, sessionID string) error {
 	_, err := s.pool.Exec(ctx, `UPDATE sessions SET revoked_at = now() WHERE id = $1`, sessionID)
 	if err != nil {
 		return fmt.Errorf("sitzung widerrufen: %w", err)
 	}
 	return nil
 }
 // RevokeAllExcept beendet alle Sitzungen eines Benutzers ausser der
 // angegebenen (Akzeptanzkriterium 3: "alle anderen beenden", aktuelle
 // Sitzung bleibt bestehen).
 func (s *Store) RevokeAllExcept(ctx context.Context, userID, keepSessionID string) error {
 	_, err := s.pool.Exec(ctx, `
 		UPDATE sessions SET revoked_at = now()
 		WHERE user_id = $1 AND id <> $2 AND revoked_at IS NULL
 	`, userID, keepSessionID)
 	if err != nil {
 		return fmt.Errorf("andere sitzungen widerrufen: %w", err)
 	}
 	return nil
 }
 func randomToken() (string, error) {
 	buf := make([]byte, 32)
 	if _, err := rand.Read(buf); err != nil {
 		return "", err
 	}
 	return hex.EncodeToString(buf), nil
 }
 func hashToken(token string) []byte {
 	sum := sha256.Sum256([]byte(token))
 	return sum[:]
 }
@@ -0,0 +1,174 @@
 package session
 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 sessions (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL REFERENCES users(id),
 			token_hash BYTEA NOT NULL UNIQUE, device_info TEXT NOT NULL DEFAULT '', ip TEXT NOT NULL DEFAULT '',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_seen_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			revoked_at TIMESTAMPTZ
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	userStore := user.NewTenantUserStore(pool)
 	email := fmt.Sprintf("session-test-%d@example.com", time.Now().UnixNano())
 	u, err := userStore.Create(ctx, email, "Session Test")
 	if err != nil {
 		t.Fatalf("create user: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewStore(pool), userStore, u.ID, cleanup
 }
 // Akzeptanzkriterium 1 + Pruefung 1: zwei Sitzungen angelegt, beide in der
 // Uebersicht sichtbar.
 func TestListForUser_ShowsAllActiveSessions(t *testing.T) {
 	store, _, userID, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, _, err := store.Create(ctx, userID, "Chrome auf Windows", "10.0.0.1"); err != nil {
 		t.Fatalf("create session 1: %v", err)
 	}
 	if _, _, err := store.Create(ctx, userID, "Safari auf iPhone", "10.0.0.2"); err != nil {
 		t.Fatalf("create session 2: %v", err)
 	}
 	sessions, err := store.ListForUser(ctx, userID)
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 	if len(sessions) != 2 {
 		t.Fatalf("erwartet 2 sitzungen, habe %d", len(sessions))
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Widerruf macht das Token sofort ungueltig.
 func TestRevoke_InvalidatesTokenImmediately(t *testing.T) {
 	store, _, userID, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	sessionID, token, err := store.Create(ctx, userID, "Firefox", "10.0.0.3")
 	if err != nil {
 		t.Fatalf("create: %v", err)
 	}
 	if _, err := store.Validate(ctx, token); err != nil {
 		t.Fatalf("validate vor widerruf: %v", err)
 	}
 	if err := store.Revoke(ctx, sessionID); err != nil {
 		t.Fatalf("revoke: %v", err)
 	}
 	if _, err := store.Validate(ctx, token); !errors.Is(err, ErrSessionInvalid) {
 		t.Fatalf("erwartet ErrSessionInvalid sofort nach widerruf, habe %v", err)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: "alle anderen beenden" funktioniert,
 // aktuelle Sitzung bleibt aktiv.
 func TestRevokeAllExcept_KeepsCurrentSessionActive(t *testing.T) {
 	store, _, userID, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	currentID, currentToken, err := store.Create(ctx, userID, "aktuelles geraet", "10.0.0.4")
 	if err != nil {
 		t.Fatalf("create current: %v", err)
 	}
 	_, otherToken1, err := store.Create(ctx, userID, "anderes geraet 1", "10.0.0.5")
 	if err != nil {
 		t.Fatalf("create other 1: %v", err)
 	}
 	_, otherToken2, err := store.Create(ctx, userID, "anderes geraet 2", "10.0.0.6")
 	if err != nil {
 		t.Fatalf("create other 2: %v", err)
 	}
 	if err := store.RevokeAllExcept(ctx, userID, currentID); err != nil {
 		t.Fatalf("revoke all except: %v", err)
 	}
 	if _, err := store.Validate(ctx, currentToken); err != nil {
 		t.Fatalf("aktuelle sitzung sollte weiterhin gueltig sein: %v", err)
 	}
 	if _, err := store.Validate(ctx, otherToken1); !errors.Is(err, ErrSessionInvalid) {
 		t.Fatalf("andere sitzung 1 sollte widerrufen sein, habe %v", err)
 	}
 	if _, err := store.Validate(ctx, otherToken2); !errors.Is(err, ErrSessionInvalid) {
 		t.Fatalf("andere sitzung 2 sollte widerrufen sein, habe %v", err)
 	}
 	remaining, err := store.ListForUser(ctx, userID)
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 	if len(remaining) != 1 || remaining[0].ID != currentID {
 		t.Fatalf("erwartet genau die aktuelle sitzung uebrig, habe %+v", remaining)
 	}
 }
 func TestLoginAndCreateSession(t *testing.T) {
 	store, userStore, userID, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	u, err := userStore.Get(ctx, userID)
 	if err != nil {
 		t.Fatalf("get user: %v", err)
 	}
 	hash, err := auth.HashPassword("korrektes-passwort")
 	if err != nil {
 		t.Fatalf("hash: %v", err)
 	}
 	if err := userStore.SetPasswordHash(ctx, userID, hash); err != nil {
 		t.Fatalf("set password: %v", err)
 	}
 	token, err := LoginAndCreateSession(ctx, userStore, store, u.Email, "korrektes-passwort", "Test-Client", "127.0.0.1")
 	if err != nil {
 		t.Fatalf("login and create session: %v", err)
 	}
 	if _, err := store.Validate(ctx, token); err != nil {
 		t.Fatalf("validate: %v", err)
 	}
 	if _, err := LoginAndCreateSession(ctx, userStore, store, u.Email, "falsches-passwort", "Test-Client", "127.0.0.1"); err == nil {
 		t.Fatal("erwartet fehler bei falschem passwort")
 	}
 }
@@ -1,2 +0,0 @@
 DROP TABLE oidc_auth_codes;
 DROP TABLE oidc_clients;
@@ -1,28 +0,0 @@
 -- IAM-13: NEXARCH als OIDC-Provider fuer Drittanwendungen eines Mandanten.
 -- Client-Registrierung und Authorization-Codes leben pro Mandant (nicht in
 -- der zentralen Registry), weil ein OAuth2-Client konzeptionell zu genau
 -- einem Kunden gehoert (siehe core-kanban/tickets/IAM-13.md).
 CREATE TABLE oidc_clients (
    id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name           TEXT NOT NULL,
    client_id      TEXT NOT NULL UNIQUE,
    secret_hash    BYTEA NOT NULL,
    redirect_uris  TEXT[] NOT NULL,
    allowed_scopes TEXT[] NOT NULL,
    created_at     TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Auth-Codes sind bewusst kurzlebig und einmal verwendbar (RFC 6749 4.1.2):
 -- used_at IS NULL in der WHERE-Klausel beim Einloesen macht das Konsumieren
 -- atomar, gleiches Muster wie internal/authtoken (IAM-03).
 CREATE TABLE oidc_auth_codes (
    code_hash     BYTEA PRIMARY KEY,
    client_id     TEXT NOT NULL REFERENCES oidc_clients(client_id),
    user_id       UUID NOT NULL REFERENCES users(id),
    redirect_uri  TEXT NOT NULL,
    scopes        TEXT[] NOT NULL,
    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
    expires_at    TIMESTAMPTZ NOT NULL,
    used_at       TIMESTAMPTZ
 );
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS sessions;
@@ -0,0 +1,18 @@
 -- Aktive-Sitzungen-Verwaltung (IAM-12, siehe core-kanban/tickets/IAM-12.md).
 -- Bewusst SERVERSEITIG mit widerrufbarem Zustand — anders als IAM-02s
 -- zustandsloses JWT (API-05-Entscheidung fuer Modul-zu-Modul-Vertrauen),
 -- braucht die Selbstbedienungs-Sitzungsuebersicht einen Ort, an dem eine
 -- einzelne Sitzung sofort und nachweislich ungueltig gemacht werden kann.
 -- token_hash enthaelt NIEMALS den Klartext-Token, nur dessen SHA-256-Hash.
 CREATE TABLE sessions (
    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id       UUID NOT NULL REFERENCES users(id),
    token_hash    BYTEA NOT NULL UNIQUE,
    device_info   TEXT NOT NULL DEFAULT '',
    ip            TEXT NOT NULL DEFAULT '',
    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
    last_seen_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
    revoked_at    TIMESTAMPTZ
 );
 CREATE INDEX sessions_user_idx ON sessions (user_id);
@@ -1,16 +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."
@@ -1,18 +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
		`@@ -1,2 +0,0 @@`
			`DROP TABLE oidc_auth_codes;`
			`DROP TABLE oidc_clients;`