IAM-05: ldap-active-directory-anbindung

internal/ldapsync: Client ist eine Schnittstelle (Search() liefert Entry- Liste) — in dieser Umgebung steht kein echter LDAP/AD-Server zur Verfuegung (analog AUD-05/Archive), daher ist die Sync-/Rollenzuordnungs-Logik vollstaendig gegen einen Fake getestet, eine echte Verbindungspruefung gegen LDAP/AD steht noch aus. RoleMappingStore (Akzeptanzkriterium 3): explizite Erlaubnis-Matrix LDAP-Gruppe -> Rolle. HighestRoleFor vergibt NUR fuer explizit gemappte Gruppen eine Rolle — eine unbekannte Gruppe, auch wenn ihr Name zufaellig wie eine interne Rolle aussieht ("tenant_admin", "superadmin"), traegt strukturell nichts bei (kein Code-Pfad, der eine ungemappte Gruppe je einer Rolle zuordnet) — behebt die aus archivmail bekannte Privilege-Escalation- Fehlerklasse von Grund auf statt nachtraeglich zu haerten. Syncer.Run ruft Search() als ALLERERSTES auf; schlaegt es fehl, wird ohne jede Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2). Pro Eintrag isolierte Fehler landen in SyncResult.Failed, ohne andere Eintraege zu beeintraechtigen. Deaktivierung in LDAP wird als users.Deactivate uebernommen (Akzeptanzkriterium 3). ldap_config speichert bewusst nur den NAMEN einer Umgebungsvariable fuer das Bind-Passwort, nie das Passwort selbst. internal/rbac (RBAC-01) wurde 1:1 aus dem rbac-01-Branch uebernommen (git show aus derselben Repo-Historie) — IAM-05 haengt an RBAC-01 fuer die Rollenzuweisung, beide Boards leben aber auf getrennten, noch nicht gemergten Feature-Branches ohne gemeinsame Historie. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Rollen-Erlaubnis-Matrix mit Positiv- und Negativfaellen automatisiert getestet (keine Privilege-Escalation) — TestRoleMapping_PositiveAndNegativeCases: gemappte Gruppe liefert Rolle, unbekannte Gruppe und rollen-aehnlich benannte, aber nie gemappte Gruppen liefern keine. PASS. 2. Synchronisationslauf mit fehlerhafter/nicht erreichbarer LDAP-Quelle bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen — TestSyncer_AbortsCleanlyOnSourceError: bestehendes Konto bleibt nach fehlgeschlagenem Lauf unveraendert aktiv. PASS. 3. Deaktivierung eines Benutzers in LDAP wird bei naechster Synchronisation korrekt uebernommen — TestSyncer_AppliesDeactivationOnNextRun: erster Lauf legt aktiven Benutzer an, zweiter Lauf mit Disabled=true setzt ihn auf inaktiv. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
IAM-02: login-session-jwt-grundgeruest
2026-08-27 22:39:10 +02:00 · 2026-08-27 18:26:00 +02:00 · 2026-08-27 17:57:49 +02:00
40 changed files with 1839 additions and 274 deletions
@@ -8,6 +8,7 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 func main() {
@@ -34,12 +35,20 @@ func main() {
 	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
 	tenantHandler := tenant.NewHandler(provisioner)
 	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
 	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
 	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
 	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
 	superadmins := user.NewSuperadminStore(registryPool)
 	userHandler := user.NewHandler(nil, superadmins)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
-	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
+	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
 	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
@@ -2,13 +2,16 @@ module gitea.perlbach24.de/scripte/nexarch
 go 1.22
-require github.com/jackc/pgx/v5 v5.6.0
+require (
 	github.com/golang-jwt/jwt/v5 v5.3.1
 	github.com/jackc/pgx/v5 v5.6.0
 	golang.org/x/crypto v0.17.0
 )
 require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	golang.org/x/crypto v0.17.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 )
@@ -1,6 +1,8 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
 github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
@@ -1,96 +0,0 @@
 // Package audit implementiert Core AUD-01: das zentrale, vom allgemeinen
 // Anwendungs-Log getrennte Audit-Datenmodell fuer sicherheits- und
 // compliancerelevante Ereignisse (wer, was, wann, an welchem Tenant).
 // Unveraenderlichkeit (Append-only) ist AUD-02, Export/Filter-API ist AUD-03
 // — dieses Paket liefert nur das Datenmodell und den EINEN zentralen
 // Schreibpfad (Akzeptanzkriterium 3).
 package audit
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // SystemTenant ist der reservierte Tenant-Bezug fuer mandantenuebergreifende
 // Ereignisse (z.B. Superadmin-Aktionen) — es gibt bewusst KEINEN Weg, ein
 // Ereignis ganz ohne Tenant-Bezug zu schreiben (Akzeptanzkriterium 2).
 const SystemTenant = "system"
 var ErrMissingTenant = errors.New("audit: tenant_slug darf nicht leer sein")
 var ErrMissingActor = errors.New("audit: actor darf nicht leer sein")
 var ErrMissingAction = errors.New("audit: action darf nicht leer sein")
 // Event ist ein strukturiertes Audit-Ereignis (Akzeptanzkriterium 1: Akteur,
 // Aktion, Zielobjekt, Zeitpunkt, Tenant).
 type Event struct {
 	TenantSlug string
 	Actor      string
 	Action     string
 	Target     string
 	Metadata   map[string]any
 	OccurredAt time.Time
 }
 // Log ist der EINE zentrale Schreibpfad fuer Audit-Ereignisse — es gibt
 // bewusst keine zweite Schreibmoeglichkeit, damit kein Handler versehentlich
 // direkt in audit_events schreibt und dabei die Validierung umgeht
 // (Akzeptanzkriterium 3).
 type Log struct {
 	pool *pgxpool.Pool
 }
 func NewLog(pool *pgxpool.Pool) *Log {
 	return &Log{pool: pool}
 }
 // Record persistiert genau einen Audit-Eintrag. Fehlender Tenant-Bezug wird
 // bereits hier abgewiesen (klarer Fehler statt Constraint-Verletzung im
 // Normalfall) — die Datenbank-CHECK-Constraint aus der Migration ist die
 // zweite, unumgehbare Verteidigungslinie (Akzeptanzkriterium 2 / Pruefung 2).
 func (l *Log) Record(ctx context.Context, e Event) error {
 	if e.TenantSlug == "" {
 		return ErrMissingTenant
 	}
 	if e.Actor == "" {
 		return ErrMissingActor
 	}
 	if e.Action == "" {
 		return ErrMissingAction
 	}
 	if e.Metadata == nil {
 		e.Metadata = map[string]any{}
 	}
 	metadataJSON, err := json.Marshal(e.Metadata)
 	if err != nil {
 		return fmt.Errorf("metadaten serialisieren: %w", err)
 	}
 	if e.OccurredAt.IsZero() {
 		e.OccurredAt = time.Now()
 	}
 	_, err = l.pool.Exec(ctx, `
 		INSERT INTO audit_events (occurred_at, tenant_slug, actor, action, target, metadata)
 		VALUES ($1, $2, $3, $4, $5, $6)
 	`, e.OccurredAt, e.TenantSlug, e.Actor, e.Action, e.Target, metadataJSON)
 	if err != nil {
 		return fmt.Errorf("audit-ereignis schreiben: %w", err)
 	}
 	return nil
 }
 // CountByTenant ist eine schlanke Lesehilfe fuer Tests/Diagnose — die
 // eigentliche Filter-/Export-API ist AUD-03, hier bewusst nicht vorgezogen.
 func (l *Log) CountByTenant(ctx context.Context, tenantSlug string) (int, error) {
 	var n int
 	if err := l.pool.QueryRow(ctx, `
 		SELECT count(*) FROM audit_events WHERE tenant_slug = $1
 	`, tenantSlug).Scan(&n); err != nil {
 		return 0, fmt.Errorf("audit-ereignisse zaehlen: %w", err)
 	}
 	return n, nil
 }
@@ -1,132 +0,0 @@
 package audit
 import (
 	"context"
 	"errors"
 	"os"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupAuditTest(t *testing.T) (*Log, *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 TABLE IF NOT EXISTS audit_events (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
 			actor TEXT NOT NULL CHECK (actor <> ''),
 			action TEXT NOT NULL CHECK (action <> ''),
 			target TEXT NOT NULL,
 			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
 		)`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug LIKE 'test\_%' ESCAPE '\' OR tenant_slug = $1`, SystemTenant)
 		pool.Close()
 	}
 	return NewLog(pool), pool, cleanup
 }
 // Akzeptanzkriterium 1 + Pruefung 1: ein sicherheitsrelevanter Vorgang
 // (hier: fehlgeschlagener Login) erzeugt zuverlaessig genau einen Eintrag.
 func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
 	log, pool, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	err := log.Record(ctx, Event{
 		TenantSlug: "test_acme",
 		Actor:      "alice@example.com",
 		Action:     "iam.login_failed",
 		Target:     "user:alice@example.com",
 		Metadata:   map[string]any{"reason": "falsches passwort"},
 	})
 	if err != nil {
 		t.Fatalf("record: %v", err)
 	}
 	count, err := log.CountByTenant(ctx, "test_acme")
 	if err != nil {
 		t.Fatalf("count: %v", err)
 	}
 	if count != 1 {
 		t.Fatalf("erwartet genau 1 audit-eintrag, habe %d", count)
 	}
 	var actor, action, target string
 	if err := pool.QueryRow(ctx, `
 		SELECT actor, action, target FROM audit_events WHERE tenant_slug = 'test_acme'
 	`).Scan(&actor, &action, &target); err != nil {
 		t.Fatalf("eintrag lesen: %v", err)
 	}
 	if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
 		t.Fatalf("eintrag unerwartet: actor=%q action=%q target=%q", actor, action, target)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2 (App-Ebene): fehlender Tenant-Bezug wird
 // bereits vom zentralen Schreibpfad abgewiesen.
 func TestRecord_RejectsMissingTenant(t *testing.T) {
 	log, _, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	err := log.Record(ctx, Event{TenantSlug: "", Actor: "alice", Action: "irgendwas"})
 	if !errors.Is(err, ErrMissingTenant) {
 		t.Fatalf("erwartet ErrMissingTenant, habe %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2 (DB-Ebene): selbst ein direkter INSERT,
 // der Log.Record umgeht, wird durch die CHECK-Constraint verhindert — der
 // Schutz haengt nicht allein von der Go-Validierung ab.
 func TestConstraint_RejectsMissingTenantAtDatabaseLevel(t *testing.T) {
 	_, pool, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	_, err := pool.Exec(ctx, `
 		INSERT INTO audit_events (tenant_slug, actor, action, target)
 		VALUES ('', 'alice', 'irgendwas', 'ziel')
 	`)
 	if err == nil {
 		t.Fatal("erwartet fehler durch CHECK-constraint bei leerem tenant_slug, habe nil")
 	}
 }
 func TestRecord_RejectsMissingActorAndAction(t *testing.T) {
 	log, _, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "", Action: "x"}); !errors.Is(err, ErrMissingActor) {
 		t.Fatalf("erwartet ErrMissingActor, habe %v", err)
 	}
 	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "alice", Action: ""}); !errors.Is(err, ErrMissingAction) {
 		t.Fatalf("erwartet ErrMissingAction, habe %v", err)
 	}
 }
 func TestRecord_SystemTenantForCrossTenantEvents(t *testing.T) {
 	log, _, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := log.Record(ctx, Event{TenantSlug: SystemTenant, Actor: "superadmin", Action: "tenant.provisioned", Target: "tenant:acme"}); err != nil {
 		t.Fatalf("record mit SystemTenant: %v", err)
 	}
 }
@@ -0,0 +1,67 @@
 package auth
 import (
 	"encoding/json"
 	"net/http"
 	"time"
 )
 // Handler stellt Login/Logout als HTTP-Endpunkte bereit. Registrierung,
 // Passwort-Reset, 2FA, SSO/LDAP und Rate-Limiting sind ausdruecklich nicht
 // Teil dieser Kachel (siehe IAM-03..07).
 type Handler struct {
 	login *LoginService
 }
 func NewHandler(login *LoginService) *Handler {
 	return &Handler{login: login}
 }
 type loginRequest struct {
 	Email    string `json:"email"`
 	Password string `json:"password"`
 }
 func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
 	var req loginRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	token, err := h.login.Login(r.Context(), req.Email, req.Password)
 	if err != nil {
 		http.Error(w, ErrInvalidCredentials.Error(), http.StatusUnauthorized)
 		return
 	}
 	http.SetCookie(w, &http.Cookie{
 		Name:     CookieName,
 		Value:    token,
 		Path:     "/",
 		HttpOnly: true,
 		Secure:   true,
 		SameSite: http.SameSiteStrictMode,
 		MaxAge:   int(AccessTokenTTL.Seconds()),
 	})
 	w.WriteHeader(http.StatusOK)
 }
 // Logout loescht das Session-Cookie. Da JWT hier bewusst zustandslos bleibt
 // (kein serverseitiger Blocklist-Speicher — das waere ueber "Grundgerüst"
 // hinaus und widerspraeche der projektweiten zustandslosen-JWT-Entscheidung),
 // bleibt ein bereits ausgestelltes Token bis zu seinem Ablauf technisch
 // gueltig, wenn es separat vom Cookie extrahiert und wiederverwendet wird.
 func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
 	http.SetCookie(w, &http.Cookie{
 		Name:     CookieName,
 		Value:    "",
 		Path:     "/",
 		HttpOnly: true,
 		Secure:   true,
 		SameSite: http.SameSiteStrictMode,
 		MaxAge:   -1,
 		Expires:  time.Unix(0, 0),
 	})
 	w.WriteHeader(http.StatusOK)
 }
@@ -0,0 +1,56 @@
 package auth
 import (
 	"context"
 	"errors"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 var ErrInvalidCredentials = errors.New("auth: E-Mail oder Passwort falsch")
 // LoginService arbeitet gegen GENAU EINE Tenant-Datenbank (uebergeben ueber
 // den TenantUserStore-Pool) — das Login ist damit strukturell auf den
 // richtigen Tenant gescopt, siehe user.TenantUserStore.GetByEmailForAuth.
 type LoginService struct {
 	users  *user.TenantUserStore
 	issuer *TokenIssuer
 	// tenantSlug identifiziert im ausgestellten Token, gegen welchen Mandanten
 	// eingeloggt wurde (fuer nachgelagerte Pruefungen, z.B. Middleware-Logs).
 	tenantSlug string
 }
 func NewLoginService(users *user.TenantUserStore, issuer *TokenIssuer, tenantSlug string) *LoginService {
 	return &LoginService{users: users, issuer: issuer, tenantSlug: tenantSlug}
 }
 // Login liefert bei falscher E-Mail UND bei falschem Passwort denselben
 // Fehler (ErrInvalidCredentials), um keine Rueckschluesse auf die Existenz
 // eines Kontos zuzulassen (User-Enumeration-Schutz).
 func (s *LoginService) Login(ctx context.Context, email, password string) (string, error) {
 	creds, err := s.users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		// Trotzdem einen bcrypt-Vergleich gegen einen Dummy-Hash ausfuehren,
 		// damit die Antwortzeit bei unbekannter E-Mail nicht messbar kuerzer
 		// ist als bei falschem Passwort (Timing-Seitenkanal).
 		VerifyPassword(dummyHash, password)
 		return "", ErrInvalidCredentials
 	}
 	if creds.User.Status != user.StatusActive {
 		return "", ErrInvalidCredentials
 	}
 	if !VerifyPassword(creds.PasswordHash, password) {
 		return "", ErrInvalidCredentials
 	}
 	return s.issuer.Issue(creds.User.ID, s.tenantSlug)
 }
 // dummyHash ist ein echter bcrypt-Hash (Kostenfaktor BcryptCost) eines
 // beliebigen Platzhalter-Klartexts — bewusst KEIN kaputtes Format, da
 // bcrypt.CompareHashAndPassword bei ungueltigem Hash sofort ohne den
 // eigentlichen Kostenfaktor-Vergleich zurueckkehrt und die
 // Timing-Angleichung damit wirkungslos waere.
 const dummyHash = "$2a$12$cmwiETrG9DK5/uTM2fg4uetngYUspKjME5P8fNpk0QYTaO64N0r3C"
@@ -0,0 +1,177 @@
 package auth
 import (
 	"context"
 	"errors"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 const usersSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	password_hash TEXT NOT NULL DEFAULT '',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 func setupTenantDB(t *testing.T, dbName string) *pgxpool.Pool {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	adminPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
 	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
 		t.Fatalf("testdatenbank anlegen: %v", err)
 	}
 	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("connect testdatenbank: %v", err)
 	}
 	if _, err := pool.Exec(ctx, usersSchema); err != nil {
 		t.Fatalf("schema anwenden: %v", err)
 	}
 	t.Cleanup(func() {
 		pool.Close()
 		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 		adminPool.Close()
 	})
 	return pool
 }
 func createUserWithPassword(t *testing.T, store *user.TenantUserStore, email, password string) user.User {
 	t.Helper()
 	ctx := context.Background()
 	u, err := store.Create(ctx, email, "Test User")
 	if err != nil {
 		t.Fatalf("create user: %v", err)
 	}
 	hash, err := HashPassword(password)
 	if err != nil {
 		t.Fatalf("hash password: %v", err)
 	}
 	if err := store.SetPasswordHash(ctx, u.ID, hash); err != nil {
 		t.Fatalf("set password: %v", err)
 	}
 	return u
 }
 func TestLoginService_SuccessAndWrongPassword(t *testing.T) {
 	pool := setupTenantDB(t, "test_iam02_login")
 	store := user.NewTenantUserStore(pool)
 	createUserWithPassword(t, store, "alice@example.com", "korrektes-passwort")
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	login := NewLoginService(store, issuer, "acme")
 	token, err := login.Login(context.Background(), "alice@example.com", "korrektes-passwort")
 	if err != nil {
 		t.Fatalf("login: %v", err)
 	}
 	if token == "" {
 		t.Fatal("erwartet nicht-leeres token")
 	}
 	if _, err := login.Login(context.Background(), "alice@example.com", "falsches-passwort"); !errors.Is(err, ErrInvalidCredentials) {
 		t.Fatalf("erwartet ErrInvalidCredentials, habe %v", err)
 	}
 	if _, err := login.Login(context.Background(), "unbekannt@example.com", "irgendwas"); !errors.Is(err, ErrInvalidCredentials) {
 		t.Fatalf("erwartet ErrInvalidCredentials bei unbekannter email, habe %v", err)
 	}
 }
 // Pruefung 1: kein Cross-Tenant-Login moeglich, obwohl dieselbe E-Mail in
 // zwei unterschiedlichen Tenant-Datenbanken mit unterschiedlichen Passwoertern
 // existiert.
 func TestLoginService_NoCrossTenantLogin(t *testing.T) {
 	poolA := setupTenantDB(t, "test_iam02_tenant_a")
 	poolB := setupTenantDB(t, "test_iam02_tenant_b")
 	storeA := user.NewTenantUserStore(poolA)
 	storeB := user.NewTenantUserStore(poolB)
 	createUserWithPassword(t, storeA, "shared@example.com", "passwort-tenant-a")
 	createUserWithPassword(t, storeB, "shared@example.com", "passwort-tenant-b")
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	loginA := NewLoginService(storeA, issuer, "tenant-a")
 	// Login gegen Tenant A mit dem Passwort von Tenant B darf nicht klappen,
 	// obwohl die E-Mail-Adresse identisch ist — die Store-Instanz kennt
 	// strukturell nur die Zeilen ihrer eigenen Datenbank.
 	if _, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-b"); !errors.Is(err, ErrInvalidCredentials) {
 		t.Fatalf("erwartet ErrInvalidCredentials fuer fremdes tenant-passwort, habe %v", err)
 	}
 	token, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-a")
 	if err != nil {
 		t.Fatalf("login gegen eigenen tenant sollte klappen: %v", err)
 	}
 	claims, err := issuer.Verify(token)
 	if err != nil {
 		t.Fatalf("verify: %v", err)
 	}
 	if claims.TenantSlug != "tenant-a" {
 		t.Fatalf("token tenant = %q, want tenant-a", claims.TenantSlug)
 	}
 }
 // Akzeptanzkriterium 3: geschuetzte Route ohne gueltige Session nicht erreichbar.
 func TestRequireAuth_BlocksWithoutValidCookie(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	protected := RequireAuth(issuer, func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 	// Kein Cookie.
 	req := httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
 	rec := httptest.NewRecorder()
 	protected(rec, req)
 	if rec.Code != http.StatusUnauthorized {
 		t.Fatalf("ohne cookie: status = %d, want 401", rec.Code)
 	}
 	// Manipuliertes Cookie.
 	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
 	req.AddCookie(&http.Cookie{Name: CookieName, Value: "kaputt.token.hier"})
 	rec = httptest.NewRecorder()
 	protected(rec, req)
 	if rec.Code != http.StatusUnauthorized {
 		t.Fatalf("mit kaputtem cookie: status = %d, want 401", rec.Code)
 	}
 	// Gueltiges Token.
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
 	req.AddCookie(&http.Cookie{Name: CookieName, Value: token})
 	rec = httptest.NewRecorder()
 	protected(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("mit gueltigem cookie: status = %d, want 200", rec.Code)
 	}
 }
@@ -0,0 +1,41 @@
 package auth
 import (
 	"context"
 	"net/http"
 )
 const CookieName = "nexarch_session"
 type contextKey int
 const claimsContextKey contextKey = iota
 // RequireAuth schuetzt eine Route: ohne gueltiges, nicht abgelaufenes Token
 // im Session-Cookie wird 401 zurueckgegeben und der Handler nicht aufgerufen
 // (IAM-02 Akzeptanzkriterium 3).
 func RequireAuth(issuer *TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		cookie, err := r.Cookie(CookieName)
 		if err != nil {
 			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
 			return
 		}
 		claims, err := issuer.Verify(cookie.Value)
 		if err != nil {
 			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
 			return
 		}
 		ctx := context.WithValue(r.Context(), claimsContextKey, claims)
 		next(w, r.WithContext(ctx))
 	}
 }
 // ClaimsFromContext liest die Claims, die RequireAuth in den Request-Context
 // gelegt hat.
 func ClaimsFromContext(ctx context.Context) (*Claims, bool) {
 	c, ok := ctx.Value(claimsContextKey).(*Claims)
 	return c, ok
 }
@@ -0,0 +1,28 @@
 // Package auth implementiert Core IAM-02: Login/Logout, Passwort-Hashing und
 // die Middleware zum Schutz von Routen. Autorisierung (was ein Benutzer darf)
 // ist ausdruecklich NICHT Teil dieses Pakets, siehe RBAC-01 — auth prueft nur
 // "wer bin ich" (Casbin-Architekturprinzip, siehe IAM-02-Ticket).
 package auth
 import "golang.org/x/crypto/bcrypt"
 // BcryptCost ist bewusst explizit festgelegt statt bcrypt.DefaultCost (10)
 // unreflektiert zu uebernehmen (IAM-02 Akzeptanzkriterium 4). Kostenfaktor 12
 // wurde gegen die Ziel-Login-Latenz benchmarkt, siehe password_bench_test.go
 // und den Pruefungs-Eintrag in der Commit-Nachricht.
 const BcryptCost = 12
 func HashPassword(plain string) (string, error) {
 	hash, err := bcrypt.GenerateFromPassword([]byte(plain), BcryptCost)
 	if err != nil {
 		return "", err
 	}
 	return string(hash), nil
 }
 // VerifyPassword ist timing-safe: bcrypt.CompareHashAndPassword vergleicht
 // konstant in der Zeit bzgl. des Hash-Inhalts (Referenzimplementierung fuer
 // die projektweite Timing-safe-Vergleich-Konvention aus IAM-02).
 func VerifyPassword(hash, plain string) bool {
 	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
 }
@@ -0,0 +1,42 @@
 package auth
 import (
 	"testing"
 	"time"
 )
 // TargetLoginLatency ist der Zielwert aus IAM-02 Akzeptanzkriterium 4: der
 // bcrypt-Vergleich allein darf die Login-Latenz nicht dominieren. 400ms ist
 // grosszuegig genug, um auf unterschiedlicher Hardware stabil zu sein, aber
 // eng genug, um eine versehentliche Kostenfaktor-Explosion (z.B. 16 statt 12)
 // zuverlaessig aufzudecken.
 const TargetLoginLatency = 400 * time.Millisecond
 // TestBcryptCostAgainstLatencyTarget misst die tatsaechliche Dauer eines
 // Passwort-Vergleichs mit dem festgelegten BcryptCost und dokumentiert das
 // Ergebnis (IAM-02 Pruefung 4).
 func TestBcryptCostAgainstLatencyTarget(t *testing.T) {
 	hash, err := HashPassword("benchmark-passwort")
 	if err != nil {
 		t.Fatalf("hash: %v", err)
 	}
 	start := time.Now()
 	if !VerifyPassword(hash, "benchmark-passwort") {
 		t.Fatal("verifikation haette erfolgreich sein muessen")
 	}
 	elapsed := time.Since(start)
 	t.Logf("bcrypt-vergleich mit cost=%d dauerte %s (ziel: unter %s)", BcryptCost, elapsed, TargetLoginLatency)
 	if elapsed > TargetLoginLatency {
 		t.Fatalf("bcrypt-vergleich zu langsam: %s > ziel %s", elapsed, TargetLoginLatency)
 	}
 }
 func BenchmarkVerifyPassword(b *testing.B) {
 	hash, _ := HashPassword("benchmark-passwort")
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		VerifyPassword(hash, "benchmark-passwort")
 	}
 }
@@ -0,0 +1,28 @@
 package auth
 import "testing"
 func TestHashAndVerifyPassword(t *testing.T) {
 	hash, err := HashPassword("s3hr-geheim!")
 	if err != nil {
 		t.Fatalf("hash: %v", err)
 	}
 	if hash == "s3hr-geheim!" {
 		t.Fatal("passwort wurde nicht gehasht")
 	}
 	if !VerifyPassword(hash, "s3hr-geheim!") {
 		t.Fatal("erwartet erfolgreiche verifikation")
 	}
 	if VerifyPassword(hash, "falsches-passwort") {
 		t.Fatal("erwartet fehlgeschlagene verifikation")
 	}
 }
 func TestDummyHashIsValidBcryptHash(t *testing.T) {
 	// Stellt sicher, dass der Timing-Angleichs-Hash in login.go tatsaechlich
 	// ein gueltiges bcrypt-Format hat und den vollen Kostenfaktor durchlaeuft
 	// (siehe Kommentar dort) statt sofort mit einem Format-Fehler abzubrechen.
 	if VerifyPassword(dummyHash, "irgendein-text") {
 		t.Fatal("dummyHash sollte fuer beliebigen text nicht passen")
 	}
 }
@@ -0,0 +1,63 @@
 package auth
 import (
 	"errors"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 )
 // AccessTokenTTL ist bewusst kurz gehalten (Session-Ablauf statt langlebiger
 // Tokens), passend zur "so vertrauenswuerdig wie noetig"-Produkt-DNA.
 const AccessTokenTTL = 30 * time.Minute
 var ErrInvalidToken = errors.New("auth: ungueltiges oder abgelaufenes token")
 type Claims struct {
 	UserID     string `json:"uid"`
 	TenantSlug string `json:"tenant"`
 	jwt.RegisteredClaims
 }
 // TokenIssuer signiert/verifiziert JWTs mit einem HMAC-Secret. Das
 // asymmetrische Core-weite Signaturschema (API-05, kid-Rotation) ist
 // ausdruecklich nicht Teil dieser Kachel — hier geht es nur um das
 // Login-Grundgerüst innerhalb eines einzelnen Core-Prozesses.
 type TokenIssuer struct {
 	secret []byte
 }
 func NewTokenIssuer(secret string) *TokenIssuer {
 	return &TokenIssuer{secret: []byte(secret)}
 }
 func (i *TokenIssuer) Issue(userID, tenantSlug string) (string, error) {
 	now := time.Now()
 	claims := Claims{
 		UserID:     userID,
 		TenantSlug: tenantSlug,
 		RegisteredClaims: jwt.RegisteredClaims{
 			IssuedAt:  jwt.NewNumericDate(now),
 			ExpiresAt: jwt.NewNumericDate(now.Add(AccessTokenTTL)),
 		},
 	}
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	return token.SignedString(i.secret)
 }
 // Verify prueft Signatur UND Ablauf (jwt.ParseWithClaims lehnt abgelaufene
 // Tokens automatisch ab) — der Signaturvergleich in golang-jwt ist
 // timing-safe (hmac.Equal).
 func (i *TokenIssuer) Verify(tokenString string) (*Claims, error) {
 	claims := &Claims{}
 	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
 		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
 			return nil, ErrInvalidToken
 		}
 		return i.secret, nil
 	})
 	if err != nil || !token.Valid {
 		return nil, ErrInvalidToken
 	}
 	return claims, nil
 }
@@ -0,0 +1,82 @@
 package auth
 import (
 	"strings"
 	"testing"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 )
 func TestTokenIssueAndVerify(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	claims, err := issuer.Verify(token)
 	if err != nil {
 		t.Fatalf("verify: %v", err)
 	}
 	if claims.UserID != "user-1" || claims.TenantSlug != "acme" {
 		t.Fatalf("claims unerwartet: %+v", claims)
 	}
 }
 // Pruefung 2: Token-Manipulationstest.
 func TestTokenVerify_RejectsManipulatedPayload(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	parts := strings.Split(token, ".")
 	if len(parts) != 3 {
 		t.Fatalf("unerwartetes token-format: %d teile", len(parts))
 	}
 	// Payload-Segment leicht veraendern (Signatur passt danach nicht mehr).
 	tampered := parts[0] + "." + parts[1] + "x" + "." + parts[2]
 	if _, err := issuer.Verify(tampered); err == nil {
 		t.Fatal("erwartet fehler bei manipuliertem token, habe nil")
 	}
 }
 func TestTokenVerify_RejectsWrongSecret(t *testing.T) {
 	issuer := NewTokenIssuer("secret-a")
 	other := NewTokenIssuer("secret-b")
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	if _, err := other.Verify(token); err == nil {
 		t.Fatal("erwartet fehler bei falschem secret, habe nil")
 	}
 }
 // Pruefung 3: abgelaufenes Token erzwingt Neuanmeldung.
 func TestTokenVerify_RejectsExpiredToken(t *testing.T) {
 	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
 	claims := Claims{
 		UserID:     "user-1",
 		TenantSlug: "acme",
 		RegisteredClaims: jwt.RegisteredClaims{
 			IssuedAt:  jwt.NewNumericDate(time.Now().Add(-2 * AccessTokenTTL)),
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Minute)),
 		},
 	}
 	tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 	expired, err := tok.SignedString([]byte("test-secret-nur-fuer-tests"))
 	if err != nil {
 		t.Fatalf("signieren: %v", err)
 	}
 	if _, err := issuer.Verify(expired); err == nil {
 		t.Fatal("erwartet fehler bei abgelaufenem token, habe nil")
 	}
 }
@@ -0,0 +1,27 @@
 // Package ldapsync implementiert Core IAM-05: LDAP/Active-Directory-
 // Anbindung je Tenant fuer Benutzer-Synchronisation, Login-Delegation und
 // Rollenzuordnung aus Gruppen ueber eine explizite Erlaubnis-Matrix.
 //
 // WICHTIGER HINWEIS: In dieser Umgebung steht kein echter LDAP/AD-Server zur
 // Verfuegung (analog zur Archive-Engine bei AUD-05). Client ist deshalb eine
 // Schnittstelle — die Sync-/Rollenzuordnungs-Logik ist gegen einen Fake in
 // den Tests vollstaendig geprueft, eine echte Verbindungspruefung gegen
 // LDAP/AD steht noch aus.
 package ldapsync
 // Entry ist ein aus LDAP gelesener Benutzerdatensatz.
 type Entry struct {
 	Email    string
 	Name     string
 	Groups   []string
 	Disabled bool
 }
 // Client abstrahiert die eigentliche LDAP-Verbindung (Bind + Search).
 type Client interface {
 	// Search liefert alle Benutzer, die dem konfigurierten Filter
 	// entsprechen. Ein Fehler bedeutet "Quelle nicht erreichbar oder
 	// fehlerhaft" — Run() bricht dann komplett und folgenlos ab
 	// (Akzeptanzkriterium 2).
 	Search() ([]Entry, error)
 }
@@ -0,0 +1,204 @@
 package ldapsync
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 type fakeClient struct {
 	entries []Entry
 	err     error
 }
 func (f *fakeClient) Search() ([]Entry, error) {
 	if f.err != nil {
 		return nil, f.err
 	}
 	return f.entries, nil
 }
 func setupTest(t *testing.T) (*user.TenantUserStore, *rbac.Store, *RoleMappingStore, 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 role_assignments (
 			user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
 			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS role_assignment_history (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
 			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS ldap_group_role_mapping (
 			ldap_group TEXT PRIMARY KEY, role TEXT NOT NULL CHECK (role IN ('user','tenant_admin'))
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return user.NewTenantUserStore(pool), rbac.NewStore(pool), NewRoleMappingStore(pool), cleanup
 }
 func uniqueEmail() string {
 	return fmt.Sprintf("ldap-test-%d@example.com", time.Now().UnixNano())
 }
 // Akzeptanzkriterium 3 + Pruefung 1: Rollen-Erlaubnis-Matrix mit Positiv- und
 // Negativfaellen — keine Privilege-Escalation ueber Gruppenmitgliedschaft.
 func TestRoleMapping_PositiveAndNegativeCases(t *testing.T) {
 	_, _, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := mappings.SetMapping(ctx, "cn=IT-Admins,ou=groups,dc=example,dc=com", rbac.RoleTenantAdmin); err != nil {
 		t.Fatalf("set mapping: %v", err)
 	}
 	// Positivfall: gemappte Gruppe liefert die konfigurierte Rolle.
 	role, ok, err := mappings.HighestRoleFor(ctx, []string{"cn=IT-Admins,ou=groups,dc=example,dc=com"})
 	if err != nil {
 		t.Fatalf("highest role: %v", err)
 	}
 	if !ok || role != rbac.RoleTenantAdmin {
 		t.Fatalf("erwartet tenant_admin, habe ok=%v role=%q", ok, role)
 	}
 	// Negativfall 1: unbekannte Gruppe vergibt keine Rolle.
 	_, ok, err = mappings.HighestRoleFor(ctx, []string{"cn=Praktikanten,ou=groups,dc=example,dc=com"})
 	if err != nil {
 		t.Fatalf("highest role (unbekannt): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet KEINE rolle fuer nicht gemappte gruppe")
 	}
 	// Negativfall 2 (Privilege-Escalation-Versuch): eine Gruppe, die zufaellig
 	// wie eine interne Rolle heisst, aber NIE explizit gemappt wurde, darf
 	// keine Rolle vergeben.
 	_, ok, err = mappings.HighestRoleFor(ctx, []string{"tenant_admin", "superadmin"})
 	if err != nil {
 		t.Fatalf("highest role (namens-trick): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet KEINE privilege-escalation ueber gruppennamen, die wie rollen aussehen")
 	}
 }
 // Akzeptanzkriterium 1: Synchronisationslauf legt Benutzer an.
 func TestSyncer_CreatesUsers(t *testing.T) {
 	users, roles, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	email := uniqueEmail()
 	client := &fakeClient{entries: []Entry{{Email: email, Name: "LDAP Nutzer"}}}
 	syncer := NewSyncer(client, users, roles, mappings)
 	result, err := syncer.Run(ctx)
 	if err != nil {
 		t.Fatalf("run: %v", err)
 	}
 	if result.Created != 1 {
 		t.Fatalf("erwartet 1 angelegten benutzer, habe %d", result.Created)
 	}
 	if _, err := users.GetByEmailForAuth(ctx, email); err != nil {
 		t.Fatalf("benutzer sollte existieren: %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: fehlerhafte/nicht erreichbare LDAP-
 // Quelle bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen.
 func TestSyncer_AbortsCleanlyOnSourceError(t *testing.T) {
 	users, roles, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	// Ein bereits bestehendes Konto, das UNBERUEHRT bleiben muss.
 	existingEmail := uniqueEmail()
 	existing, err := users.Create(ctx, existingEmail, "Bestehender Nutzer")
 	if err != nil {
 		t.Fatalf("create existing: %v", err)
 	}
 	client := &fakeClient{err: errors.New("ldap-server nicht erreichbar (simuliert)")}
 	syncer := NewSyncer(client, users, roles, mappings)
 	if _, err := syncer.Run(ctx); err == nil {
 		t.Fatal("erwartet fehler bei nicht erreichbarer ldap-quelle")
 	}
 	// Bestehendes Konto unveraendert (noch aktiv, keine geloeschten/neuen Zeilen).
 	got, err := users.Get(ctx, existing.ID)
 	if err != nil {
 		t.Fatalf("bestehendes konto sollte weiterhin existieren: %v", err)
 	}
 	if got.Status != user.StatusActive {
 		t.Fatalf("bestehendes konto sollte unveraendert aktiv sein, ist %q", got.Status)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Deaktivierung in LDAP wird bei
 // naechster Synchronisation korrekt uebernommen.
 func TestSyncer_AppliesDeactivationOnNextRun(t *testing.T) {
 	users, roles, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	email := uniqueEmail()
 	client := &fakeClient{entries: []Entry{{Email: email, Name: "Wird Deaktiviert"}}}
 	syncer := NewSyncer(client, users, roles, mappings)
 	if _, err := syncer.Run(ctx); err != nil {
 		t.Fatalf("erster lauf: %v", err)
 	}
 	u, err := users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		t.Fatalf("benutzer nach erstem lauf: %v", err)
 	}
 	if u.User.Status != user.StatusActive {
 		t.Fatalf("erwartet aktiv nach erstem lauf, habe %q", u.User.Status)
 	}
 	// Zweiter Lauf: derselbe Benutzer ist jetzt in LDAP deaktiviert.
 	client.entries[0].Disabled = true
 	result, err := syncer.Run(ctx)
 	if err != nil {
 		t.Fatalf("zweiter lauf: %v", err)
 	}
 	if result.Deactivated != 1 {
 		t.Fatalf("erwartet 1 deaktivierung, habe %d", result.Deactivated)
 	}
 	u, err = users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		t.Fatalf("benutzer nach zweitem lauf: %v", err)
 	}
 	if u.User.Status != user.StatusInactive {
 		t.Fatalf("erwartet inaktiv nach deaktivierung in ldap, habe %q", u.User.Status)
 	}
 }
@@ -0,0 +1,79 @@
 package ldapsync
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 )
 // RoleMappingStore verwaltet die Erlaubnis-Matrix LDAP-Gruppe -> Rolle
 // (Akzeptanzkriterium 3). Nur explizit gemappte Gruppen vergeben eine Rolle
 // — der Schutz gegen Privilege-Escalation ist strukturell: es gibt keinen
 // Code-Pfad, der eine unbekannte Gruppe irgendeiner Rolle zuordnet.
 type RoleMappingStore struct {
 	pool *pgxpool.Pool
 }
 func NewRoleMappingStore(pool *pgxpool.Pool) *RoleMappingStore {
 	return &RoleMappingStore{pool: pool}
 }
 // SetMapping ordnet eine LDAP-Gruppe genau einer NEXARCH-Rolle zu. Nur
 // 'user'/'tenant_admin' sind zuweisbar (dieselbe Matrix wie RBAC-01/03) —
 // 'superadmin' bleibt mandantenuebergreifend und nie ueber LDAP erreichbar.
 func (s *RoleMappingStore) SetMapping(ctx context.Context, ldapGroup string, role rbac.Role) error {
 	if role != rbac.RoleUser && role != rbac.RoleTenantAdmin {
 		return fmt.Errorf("ldapsync: rolle %q ist ueber ldap nicht zuweisbar", role)
 	}
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO ldap_group_role_mapping (ldap_group, role) VALUES ($1, $2)
 		ON CONFLICT (ldap_group) DO UPDATE SET role = $2
 	`, ldapGroup, string(role))
 	if err != nil {
 		return fmt.Errorf("gruppenzuordnung speichern: %w", err)
 	}
 	return nil
 }
 // roleFor liefert die einer LDAP-Gruppe zugeordnete Rolle, sofern konfiguriert.
 func (s *RoleMappingStore) roleFor(ctx context.Context, ldapGroup string) (rbac.Role, bool, error) {
 	var role string
 	err := s.pool.QueryRow(ctx, `SELECT role FROM ldap_group_role_mapping WHERE ldap_group = $1`, ldapGroup).Scan(&role)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return "", false, nil
 		}
 		return "", false, fmt.Errorf("gruppenzuordnung lesen: %w", err)
 	}
 	return rbac.Role(role), true, nil
 }
 // HighestRoleFor bestimmt aus einer Liste von LDAP-Gruppen die hoechste
 // zugeordnete Rolle (tenant_admin > user). Gruppen ohne Eintrag in der
 // Matrix tragen NICHTS bei — auch nicht, wenn ihr Name zufaellig wie eine
 // interne Rolle aussieht (Akzeptanzkriterium 3 / Pruefung 1: keine
 // Privilege-Escalation ueber Gruppenmitgliedschaft).
 func (s *RoleMappingStore) HighestRoleFor(ctx context.Context, ldapGroups []string) (rbac.Role, bool, error) {
 	var best rbac.Role
 	found := false
 	for _, g := range ldapGroups {
 		role, ok, err := s.roleFor(ctx, g)
 		if err != nil {
 			return "", false, err
 		}
 		if !ok {
 			continue
 		}
 		if !found || role == rbac.RoleTenantAdmin {
 			best = role
 			found = true
 		}
 	}
 	return best, found, nil
 }
@@ -0,0 +1,93 @@
 package ldapsync
 import (
 	"context"
 	"errors"
 	"fmt"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 // SyncResult fasst das Ergebnis eines Synchronisationslaufs zusammen.
 type SyncResult struct {
 	Created     int
 	Updated     int
 	Deactivated int
 	Failed      []string // Email-Adressen, bei denen die Verarbeitung fehlschlug
 }
 // Syncer fuehrt die Benutzer-/Rollen-Synchronisation aus LDAP aus.
 type Syncer struct {
 	client   Client
 	users    *user.TenantUserStore
 	roles    *rbac.Store
 	mappings *RoleMappingStore
 }
 func NewSyncer(client Client, users *user.TenantUserStore, roles *rbac.Store, mappings *RoleMappingStore) *Syncer {
 	return &Syncer{client: client, users: users, roles: roles, mappings: mappings}
 }
 // Run synchronisiert Benutzer aus LDAP (Akzeptanzkriterium 1). Ist die
 // LDAP-Quelle nicht erreichbar/fehlerhaft, wird SOFORT und OHNE jede
 // Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2 /
 // Pruefung 2) — Search() wird als allererstes aufgerufen, bevor irgendein
 // Schreibzugriff stattfindet.
 func (s *Syncer) Run(ctx context.Context) (SyncResult, error) {
 	entries, err := s.client.Search()
 	if err != nil {
 		return SyncResult{}, fmt.Errorf("ldap-quelle nicht erreichbar, synchronisation abgebrochen: %w", err)
 	}
 	var result SyncResult
 	for _, entry := range entries {
 		if err := s.syncOne(ctx, entry, &result); err != nil {
 			// Ein fehlerhafter Einzeleintrag isoliert sich selbst — er
 			// beschaedigt weder bereits verarbeitete noch nachfolgende
 			// Konten (Akzeptanzkriterium 2).
 			result.Failed = append(result.Failed, entry.Email)
 		}
 	}
 	return result, nil
 }
 func (s *Syncer) syncOne(ctx context.Context, entry Entry, result *SyncResult) error {
 	existing, err := s.users.GetByEmailForAuth(ctx, entry.Email)
 	isNew := errors.Is(err, user.ErrNotFound)
 	if err != nil && !isNew {
 		return err
 	}
 	var userID string
 	if isNew {
 		created, err := s.users.Create(ctx, entry.Email, entry.Name)
 		if err != nil {
 			return err
 		}
 		userID = created.ID
 		result.Created++
 	} else {
 		userID = existing.User.ID
 		result.Updated++
 	}
 	// Deaktivierung in LDAP wird uebernommen (Akzeptanzkriterium 3 / Pruefung 3).
 	if entry.Disabled {
 		if _, err := s.users.Deactivate(ctx, userID); err != nil {
 			return err
 		}
 		result.Deactivated++
 	}
 	role, ok, err := s.mappings.HighestRoleFor(ctx, entry.Groups)
 	if err != nil {
 		return err
 	}
 	if ok {
 		if _, err := s.roles.Assign(ctx, userID, role, "ldap-sync"); err != nil {
 			return err
 		}
 	}
 	return nil
 }
@@ -0,0 +1,71 @@
 // Package rbac implementiert Core RBAC-01: das Rollenmodell mit
 // Grundrollen/-rechten, Hierarchie und Zuweisung. Die eigentliche
 // Durchsetzung (erlaubt/verboten je Request) ist RBAC-02, dieses Paket
 // liefert nur Modell + Zuweisung (Casbin-Prinzip: Policy-Modell getrennt
 // von der Entscheidungsfunktion).
 package rbac
 // Role ist eine der drei Grundrollen. Superadmin lebt mandantenuebergreifend
 // (siehe internal/user.SuperadminStore aus IAM-01) und wird deshalb NICHT
 // ueber Store (tenant-gescoped) zugewiesen — die Existenz eines Superadmin-
 // Kontos IST die Rollenzuweisung.
 type Role string
 const (
 	RoleSuperadmin  Role = "superadmin"
 	RoleTenantAdmin Role = "tenant_admin"
 	RoleUser        Role = "user"
 )
 type Permission string
 const (
 	PermSelfRead       Permission = "self.read"
 	PermSelfUpdate     Permission = "self.update"
 	PermManageUsers    Permission = "tenant.manage_users"
 	PermManageSettings Permission = "tenant.manage_settings"
 	PermManageTenants  Permission = "platform.manage_tenants"
 )
 // parent bildet die Rollenhierarchie ab (Akzeptanzkriterium 2): eine Rolle
 // erbt alle Rechte ihrer Elternrolle. tenant_admin erbt von user,
 // superadmin erbt von tenant_admin.
 var parent = map[Role]Role{
 	RoleTenantAdmin: RoleUser,
 	RoleSuperadmin:  RoleTenantAdmin,
 }
 // direct sind die einer Rolle direkt (ohne Vererbung) zugeordneten Rechte.
 var direct = map[Role][]Permission{
 	RoleUser:        {PermSelfRead, PermSelfUpdate},
 	RoleTenantAdmin: {PermManageUsers, PermManageSettings},
 	RoleSuperadmin:  {PermManageTenants},
 }
 // EffectivePermissions liefert die vollstaendige, ueber die Hierarchie
 // aufgeloeste Rechtemenge einer Rolle (Akzeptanzkriterium 2 / Pruefung 2).
 func EffectivePermissions(role Role) []Permission {
 	seen := make(map[Permission]bool)
 	var out []Permission
 	for r, ok := role, true; ok; r, ok = parent[r] {
 		for _, p := range direct[r] {
 			if !seen[p] {
 				seen[p] = true
 				out = append(out, p)
 			}
 		}
 	}
 	return out
 }
 // HasPermission prueft, ob eine Rolle (inklusive geerbter Rechte) ein
 // bestimmtes Recht besitzt.
 func HasPermission(role Role, perm Permission) bool {
 	for _, p := range EffectivePermissions(role) {
 		if p == perm {
 			return true
 		}
 	}
 	return false
 }
@@ -0,0 +1,124 @@
 package rbac
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	// ErrRoleNotAssignableInTenantScope wird geliefert, wenn versucht wird,
 	// eine mandantenuebergreifende Rolle (superadmin) ueber den tenant-
 	// gescopten Store zu vergeben — die erlaubte Matrix laesst hier nur
 	// user/tenant_admin zu (Akzeptanzkriterium 1 / Pruefung 1).
 	ErrRoleNotAssignableInTenantScope = errors.New("rbac: rolle ist in diesem geltungsbereich nicht zuweisbar")
 	ErrNotFound                       = errors.New("rbac: keine rollenzuweisung gefunden")
 )
 // assignableRoles ist die erlaubte Matrix fuer Store (tenant-gescoped).
 var assignableRoles = map[Role]bool{
 	RoleUser:        true,
 	RoleTenantAdmin: true,
 }
 type Assignment struct {
 	UserID    string
 	Role      Role
 	GrantedBy string
 }
 // Store verwaltet Rollenzuweisungen innerhalb GENAU EINER Tenant-Datenbank —
 // analog zu internal/user.TenantUserStore (Modell C: der Pool bestimmt den
 // Tenant, keine tenant_id-Spalte noetig).
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // Assign vergibt eine Rolle an einen Benutzer. grantedBy identifiziert den
 // Akteur, der die Zuweisung vorgenommen hat (Akzeptanzkriterium 3). Jede
 // Zuweisung wird zusaetzlich in role_assignment_history festgehalten, auch
 // wenn sie eine vorherige Rolle ersetzt.
 func (s *Store) Assign(ctx context.Context, userID string, role Role, grantedBy string) (Assignment, error) {
 	if !assignableRoles[role] {
 		return Assignment{}, ErrRoleNotAssignableInTenantScope
 	}
 	if grantedBy == "" {
 		return Assignment{}, errors.New("rbac: grantedBy darf nicht leer sein")
 	}
 	tx, err := s.pool.Begin(ctx)
 	if err != nil {
 		return Assignment{}, fmt.Errorf("transaktion starten: %w", err)
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	if _, err := tx.Exec(ctx, `
 		INSERT INTO role_assignments (user_id, role, granted_by, granted_at)
 		VALUES ($1, $2, $3, now())
 		ON CONFLICT (user_id) DO UPDATE SET role = $2, granted_by = $3, granted_at = now()
 	`, userID, string(role), grantedBy); err != nil {
 		return Assignment{}, fmt.Errorf("rolle zuweisen: %w", err)
 	}
 	if _, err := tx.Exec(ctx, `
 		INSERT INTO role_assignment_history (user_id, role, granted_by, granted_at)
 		VALUES ($1, $2, $3, now())
 	`, userID, string(role), grantedBy); err != nil {
 		return Assignment{}, fmt.Errorf("historie schreiben: %w", err)
 	}
 	if err := tx.Commit(ctx); err != nil {
 		return Assignment{}, fmt.Errorf("transaktion committen: %w", err)
 	}
 	return Assignment{UserID: userID, Role: role, GrantedBy: grantedBy}, nil
 }
 func (s *Store) Get(ctx context.Context, userID string) (Assignment, error) {
 	var a Assignment
 	var role string
 	a.UserID = userID
 	if err := s.pool.QueryRow(ctx, `
 		SELECT role, granted_by FROM role_assignments WHERE user_id = $1
 	`, userID).Scan(&role, &a.GrantedBy); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return Assignment{}, ErrNotFound
 		}
 		return Assignment{}, fmt.Errorf("rollenzuweisung lesen: %w", err)
 	}
 	a.Role = Role(role)
 	return a, nil
 }
 // History liefert jede Rollenzuweisung eines Benutzers in chronologischer
 // Reihenfolge — die Grundlage fuer "wer hat wann welche Rolle vergeben"
 // (Akzeptanzkriterium 3).
 func (s *Store) History(ctx context.Context, userID string) ([]Assignment, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT role, granted_by FROM role_assignment_history
 		WHERE user_id = $1 ORDER BY granted_at
 	`, userID)
 	if err != nil {
 		return nil, fmt.Errorf("historie abfragen: %w", err)
 	}
 	defer rows.Close()
 	var out []Assignment
 	for rows.Next() {
 		var role string
 		a := Assignment{UserID: userID}
 		if err := rows.Scan(&role, &a.GrantedBy); err != nil {
 			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
 		}
 		a.Role = Role(role)
 		out = append(out, a)
 	}
 	return out, rows.Err()
 }
@@ -0,0 +1,66 @@
 package user
 import (
 	"encoding/json"
 	"errors"
 	"net/http"
 )
 // Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
 // Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
 // dieser Kachel und daher hier noch nicht angebunden.
 type Handler struct {
 	users       *TenantUserStore
 	superadmins *SuperadminStore
 }
 func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
 	return &Handler{users: users, superadmins: superadmins}
 }
 type createUserRequest struct {
 	Email string `json:"email"`
 	Name  string `json:"name"`
 }
 func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
 	var req createUserRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	u, err := h.users.Create(r.Context(), req.Email, req.Name)
 	writeUserResult(w, u, err)
 }
 // CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
 // bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
 func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
 	var req createUserRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
 	writeUserResult(w, u, err)
 }
 func writeUserResult(w http.ResponseWriter, u User, err error) {
 	if err != nil {
 		switch {
 		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
 			http.Error(w, err.Error(), http.StatusBadRequest)
 		case errors.Is(err, ErrNotFound):
 			http.Error(w, err.Error(), http.StatusNotFound)
 		default:
 			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
 		}
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusCreated)
 	_ = json.NewEncoder(w).Encode(u)
 }
@@ -0,0 +1,173 @@
 package user
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
 // uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
 // TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
 // fuer dasselbe Muster.
 func setupTestDB(t *testing.T, dbName, schemaSQL string) *pgxpool.Pool {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	adminPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
 	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
 		t.Fatalf("testdatenbank anlegen: %v", err)
 	}
 	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("connect testdatenbank: %v", err)
 	}
 	if _, err := pool.Exec(ctx, schemaSQL); err != nil {
 		t.Fatalf("schema anwenden: %v", err)
 	}
 	t.Cleanup(func() {
 		pool.Close()
 		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 		adminPool.Close()
 	})
 	return pool
 }
 const usersSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 const superadminsSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE superadmins (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 // Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
 func TestTenantUserStore_CRUD(t *testing.T) {
 	pool := setupTestDB(t, "test_iam01_users", usersSchema)
 	store := NewTenantUserStore(pool)
 	ctx := context.Background()
 	created, err := store.Create(ctx, "alice@example.com", "Alice")
 	if err != nil {
 		t.Fatalf("create: %v", err)
 	}
 	if created.Status != StatusActive {
 		t.Fatalf("erwartet status active, hat %q", created.Status)
 	}
 	got, err := store.Get(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if got.Email != "alice@example.com" {
 		t.Fatalf("get email = %q", got.Email)
 	}
 	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
 	if err != nil {
 		t.Fatalf("update: %v", err)
 	}
 	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
 		t.Fatalf("update ergebnis unerwartet: %+v", updated)
 	}
 	list, err := store.List(ctx)
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 	if len(list) != 1 {
 		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
 	}
 	deactivated, err := store.Deactivate(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("deactivate: %v", err)
 	}
 	if deactivated.Status != StatusInactive {
 		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
 	}
 	// Negativfall: doppelte E-Mail-Adresse.
 	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
 		t.Fatalf("create second: %v", err)
 	}
 	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
 		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
 	}
 	// Negativfall: fehlender Benutzer.
 	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
 		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
 // SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
 // keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
 func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
 	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
 	store := NewSuperadminStore(pool)
 	ctx := context.Background()
 	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
 	if err != nil {
 		t.Fatalf("create superadmin: %v", err)
 	}
 	if created.Status != StatusActive {
 		t.Fatalf("erwartet status active, hat %q", created.Status)
 	}
 	got, err := store.Get(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if got.Email != "root@nexarch.internal" {
 		t.Fatalf("get email = %q", got.Email)
 	}
 	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
 		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
 	}
 	deactivated, err := store.Deactivate(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("deactivate: %v", err)
 	}
 	if deactivated.Status != StatusInactive {
 		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
 	}
 }
@@ -0,0 +1,77 @@
 package user
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
 // Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
 // Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
 // TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
 // koennte (IAM-01, "ohne Sonderbehandlung im Code").
 type SuperadminStore struct {
 	pool *pgxpool.Pool
 }
 func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
 	return &SuperadminStore{pool: pool}
 }
 func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
 	if err := ValidateEmail(email); err != nil {
 		return User{}, err
 	}
 	var u User
 	u.Email, u.Name, u.Status = email, name, StatusActive
 	row := s.pool.QueryRow(ctx, `
 		INSERT INTO superadmins (email, name, status)
 		VALUES ($1, $2, $3)
 		RETURNING id, created_at, updated_at
 	`, u.Email, u.Name, u.Status)
 	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
 		return User{}, mapWriteErr(err)
 	}
 	return u, nil
 }
 func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM superadmins WHERE id = $1
 	`, id))
 }
 func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM superadmins ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("superadmins auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []User
 	for rows.Next() {
 		var u User
 		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("superadmin lesen: %w", err)
 		}
 		out = append(out, u)
 	}
 	return out, rows.Err()
 }
 func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		UPDATE superadmins SET status = $2, updated_at = now()
 		WHERE id = $1
 		RETURNING id, email, name, status, created_at, updated_at
 	`, id, StatusInactive))
 }
@@ -0,0 +1,173 @@
 package user
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgconn"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
 // Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
 // uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
 type TenantUserStore struct {
 	pool *pgxpool.Pool
 }
 func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
 	return &TenantUserStore{pool: pool}
 }
 func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
 	if err := ValidateEmail(email); err != nil {
 		return User{}, err
 	}
 	var u User
 	u.Email, u.Name, u.Status = email, name, StatusActive
 	row := s.pool.QueryRow(ctx, `
 		INSERT INTO users (email, name, status)
 		VALUES ($1, $2, $3)
 		RETURNING id, created_at, updated_at
 	`, u.Email, u.Name, u.Status)
 	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
 		return User{}, mapWriteErr(err)
 	}
 	return u, nil
 }
 func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM users WHERE id = $1
 	`, id))
 }
 func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM users ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("benutzer auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []User
 	for rows.Next() {
 		var u User
 		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("benutzer lesen: %w", err)
 		}
 		out = append(out, u)
 	}
 	return out, rows.Err()
 }
 // Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
 // Feld unveraendert.
 func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
 	if email != "" {
 		if err := ValidateEmail(email); err != nil {
 			return User{}, err
 		}
 	}
 	row := s.pool.QueryRow(ctx, `
 		UPDATE users
 		SET email = COALESCE(NULLIF($2, ''), email),
 		    name = COALESCE(NULLIF($3, ''), name),
 		    updated_at = now()
 		WHERE id = $1
 		RETURNING id, email, name, status, created_at, updated_at
 	`, id, email, name)
 	u, err := scanUser(row)
 	if err != nil {
 		return User{}, mapWriteErr(err)
 	}
 	return u, nil
 }
 // Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
 func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		UPDATE users SET status = $2, updated_at = now()
 		WHERE id = $1
 		RETURNING id, email, name, status, created_at, updated_at
 	`, id, StatusInactive))
 }
 // SetPasswordHash schreibt einen bereits berechneten bcrypt-Hash (siehe
 // internal/auth, IAM-02). Der Store selbst kennt kein Klartext-Passwort.
 func (s *TenantUserStore) SetPasswordHash(ctx context.Context, id, hash string) error {
 	tag, err := s.pool.Exec(ctx, `
 		UPDATE users SET password_hash = $2, updated_at = now() WHERE id = $1
 	`, id, hash)
 	if err != nil {
 		return fmt.Errorf("passwort setzen: %w", err)
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrNotFound
 	}
 	return nil
 }
 // AuthCredentials wird ausschliesslich fuer den Login-Pfad (internal/auth)
 // verwendet und traegt bewusst den password_hash, damit er nicht ueber den
 // regulaeren User-Typ/JSON-Serialisierungspfad nach aussen dringen kann.
 type AuthCredentials struct {
 	User         User
 	PasswordHash string
 }
 // GetByEmailForAuth liefert Benutzer + Passwort-Hash zu einer E-Mail-Adresse
 // aus GENAU DIESER Tenant-Datenbank — der Tenant-Scope ergibt sich damit
 // zwingend aus dem verwendeten Pool, es gibt keine Moeglichkeit, versehentlich
 // ueber Tenant-Grenzen hinweg zu suchen (bekannter archivmail-Fehler, siehe
 // IAM-02 "Bekannte Fehler vermeiden").
 func (s *TenantUserStore) GetByEmailForAuth(ctx context.Context, email string) (AuthCredentials, error) {
 	var c AuthCredentials
 	row := s.pool.QueryRow(ctx, `
 		SELECT id, email, name, status, created_at, updated_at, password_hash
 		FROM users WHERE email = $1
 	`, email)
 	if err := row.Scan(&c.User.ID, &c.User.Email, &c.User.Name, &c.User.Status,
 		&c.User.CreatedAt, &c.User.UpdatedAt, &c.PasswordHash); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return AuthCredentials{}, ErrNotFound
 		}
 		return AuthCredentials{}, fmt.Errorf("anmeldedaten lesen: %w", err)
 	}
 	return c, nil
 }
 func scanUser(row pgx.Row) (User, error) {
 	var u User
 	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return User{}, ErrNotFound
 		}
 		return User{}, fmt.Errorf("benutzer lesen: %w", err)
 	}
 	return u, nil
 }
 // mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
 // einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
 func mapWriteErr(err error) error {
 	var pgErr *pgconn.PgError
 	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
 		return ErrEmailTaken
 	}
 	if errors.Is(err, pgx.ErrNoRows) {
 		return ErrNotFound
 	}
 	return fmt.Errorf("benutzer schreiben: %w", err)
 }
@@ -0,0 +1,42 @@
 // Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
 // CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
 // gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
 // dagegen mandantenuebergreifend in der Registry und sind ueber
 // SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
 // tenant_id-NULL-Sonderfall in User.
 package user
 import (
 	"errors"
 	"regexp"
 	"time"
 )
 type Status string
 const (
 	StatusActive   Status = "active"
 	StatusInactive Status = "inactive"
 )
 type User struct {
 	ID        string
 	Email     string
 	Name      string
 	Status    Status
 	CreatedAt time.Time
 	UpdatedAt time.Time
 }
 var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
 var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
 var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
 var ErrNotFound = errors.New("user: nicht gefunden")
 func ValidateEmail(email string) error {
 	if !emailPattern.MatchString(email) {
 		return ErrInvalidEmail
 	}
 	return nil
 }
@@ -0,0 +1,24 @@
 package user
 import "testing"
 func TestValidateEmail(t *testing.T) {
 	cases := []struct {
 		email   string
 		wantErr bool
 	}{
 		{"a@b.de", false},
 		{"a.b+c@sub.example.com", false},
 		{"", true},
 		{"keine-email", true},
 		{"a@b", true},
 		{"@b.de", true},
 	}
 	for _, c := range cases {
 		err := ValidateEmail(c.email)
 		if (err != nil) != c.wantErr {
 			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
 		}
 	}
 }
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS superadmins;
@@ -0,0 +1,14 @@
 -- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
 -- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
 -- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
 -- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
 -- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
 -- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
 CREATE TABLE superadmins (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email        TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -1 +0,0 @@
 DROP TABLE IF EXISTS audit_events;
@@ -1,17 +0,0 @@
 -- Zentrales Audit-Log-Modell (AUD-01, siehe core-kanban/tickets/AUD-01.md).
 -- Getrennt vom allgemeinen Anwendungs-Log (Akzeptanzkriterium 2): eigene
 -- Tabelle, eigenes Paket (internal/audit), kein Log-Framework.
 -- tenant_slug ist NOT NULL + darf nicht leer sein (Akzeptanzkriterium 2 /
 -- Pruefung 2) — mandantenuebergreifende Ereignisse nutzen den reservierten
 -- Wert 'system', niemals NULL oder leeren String.
 CREATE TABLE audit_events (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    occurred_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
    tenant_slug  TEXT NOT NULL CHECK (tenant_slug <> ''),
    actor        TEXT NOT NULL CHECK (actor <> ''),
    action       TEXT NOT NULL CHECK (action <> ''),
    target       TEXT NOT NULL,
    metadata     JSONB NOT NULL DEFAULT '{}'::jsonb
 );
 CREATE INDEX audit_events_tenant_slug_idx ON audit_events (tenant_slug, occurred_at);
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS users;
@@ -0,0 +1,16 @@
 -- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
 -- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
 -- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
 -- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
 -- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
 -- nur innerhalb dieser einen Tenant-Datenbank.
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email        TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -0,0 +1,2 @@
 DROP TABLE IF EXISTS role_assignment_history;
 DROP TABLE IF EXISTS role_assignments;
@@ -0,0 +1,23 @@
 -- Rollenzuweisung pro Benutzer (RBAC-01, siehe core-kanban/tickets/RBAC-01.md).
 -- Nur 'user' und 'tenant_admin' sind hier zuweisbar — 'superadmin' lebt
 -- mandantenuebergreifend in der Registry (IAM-01 SuperadminStore) und hat
 -- daher bewusst KEINE Zeile in dieser tenant-lokalen Tabelle (Akzeptanz-
 -- kriterium 1: nur Zuweisungen innerhalb der erlaubten Matrix).
 CREATE TABLE role_assignments (
    user_id     UUID PRIMARY KEY REFERENCES users(id),
    role        TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
    granted_by  TEXT NOT NULL,
    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Vollstaendige Historie jeder Rollenaenderung (Akzeptanzkriterium 3: wer
 -- hat wann welche Rolle vergeben).
 CREATE TABLE role_assignment_history (
    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id     UUID NOT NULL,
    role        TEXT NOT NULL,
    granted_by  TEXT NOT NULL,
    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 CREATE INDEX role_assignment_history_user_idx ON role_assignment_history (user_id, granted_at);
@@ -0,0 +1 @@
 ALTER TABLE users DROP COLUMN password_hash;
@@ -0,0 +1,3 @@
 -- Passwort-Hash-Spalte fuer Login (IAM-02, siehe core-kanban/tickets/IAM-02.md).
 -- Enthaelt AUSSCHLIESSLICH den bcrypt-Hash, niemals das Klartext-Passwort.
 ALTER TABLE users ADD COLUMN password_hash TEXT NOT NULL DEFAULT '';
@@ -0,0 +1,2 @@
 DROP TABLE IF EXISTS ldap_group_role_mapping;
 DROP TABLE IF EXISTS ldap_config;
@@ -0,0 +1,22 @@
 -- LDAP/Active-Directory-Anbindung (IAM-05, siehe core-kanban/tickets/IAM-05.md).
 -- Bind-Credentials liegen NIE in dieser Tabelle im Klartext — bind_password_env
 -- nennt nur den Namen einer Umgebungsvariable, aus der das Passwort zur
 -- Laufzeit gelesen wird (Projekt-Konvention: Secrets nur ueber Env-Vars).
 CREATE TABLE ldap_config (
    id                 BOOLEAN PRIMARY KEY DEFAULT true CHECK (id),
    url                TEXT NOT NULL,
    bind_dn            TEXT NOT NULL,
    bind_password_env  TEXT NOT NULL,
    base_dn            TEXT NOT NULL,
    user_filter        TEXT NOT NULL DEFAULT '(objectClass=person)',
    updated_at         TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Erlaubnis-Matrix LDAP-Gruppe -> NEXARCH-Rolle (Akzeptanzkriterium 3).
 -- Eine LDAP-Gruppe OHNE Eintrag hier vergibt KEINE Rolle — kein impliziter
 -- Zugriff durch Gruppennamen-Zufall (Privilege-Escalation-Schutz, siehe
 -- "Bekannte Fehler vermeiden" im Ticket).
 CREATE TABLE ldap_group_role_mapping (
    ldap_group TEXT PRIMARY KEY,
    role       TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin'))
 );
@@ -1,24 +1,11 @@
 #!/usr/bin/env bash
 # Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
 # Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
 # tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
 # unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
 # Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
 #
 # Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 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;"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events 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,24 +1,12 @@
 #!/usr/bin/env bash
 # Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
 # Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
 # -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
 # dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
 #
 # Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 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
		`@@ -0,0 +1,2 @@`
							`DROP TABLE IF EXISTS role_assignment_history;`
							`DROP TABLE IF EXISTS role_assignments;`
		`@@ -0,0 +1 @@`
							`ALTER TABLE users DROP COLUMN password_hash;`
		`@@ -0,0 +1,2 @@`
							`DROP TABLE IF EXISTS ldap_group_role_mapping;`
							`DROP TABLE IF EXISTS ldap_config;`