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>

go.mod

@@ -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
 )

go.sum

@@ -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=

internal/auth/handler.go

@@ -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)
+}

internal/auth/login.go

@@ -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"

internal/auth/login_test.go

@@ -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)
+	}
+}

internal/auth/middleware.go

@@ -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
+}

internal/auth/password.go

@@ -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
+}

internal/auth/password_bench_test.go

@@ -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")
+	}
+}

internal/auth/password_test.go

@@ -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")
+	}
+}

internal/auth/token.go

@@ -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
+}

internal/auth/token_test.go

@@ -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")
+	}
+}

internal/flag/flag.go

@@ -1,87 +0,0 @@
-// Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
-// Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
-// des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
-// + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
-package flag
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"hash/fnv"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrNotFound = errors.New("flag: nicht gefunden")
-
-// Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
-// getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
-type Flag struct {
-	Key               string
-	Enabled           bool
-	RolloutPercentage int
-	TargetTenantSlugs []string
-}
-
-// Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-func (s *Store) Set(ctx context.Context, f Flag) error {
-	if f.TargetTenantSlugs == nil {
-		f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
-	}
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
-		VALUES ($1, $2, $3, $4, now())
-		ON CONFLICT (key) DO UPDATE SET
-			enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
-	`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
-	if err != nil {
-		return fmt.Errorf("flag speichern: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
-	var f Flag
-	row := s.pool.QueryRow(ctx, `
-		SELECT key, enabled, rollout_percentage, target_tenant_slugs
-		FROM feature_flags WHERE key = $1
-	`, key)
-	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Flag{}, ErrNotFound
-		}
-		return Flag{}, fmt.Errorf("flag lesen: %w", err)
-	}
-	return f, nil
-}
-
-// evaluate wendet die Strategien in fester Reihenfolge an: globaler
-// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
-// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
-// kein Feature wird versehentlich aktiv.
-func evaluate(f Flag, tenantSlug string) bool {
-	if f.Enabled {
-		return true
-	}
-	for _, target := range f.TargetTenantSlugs {
-		if target == tenantSlug {
-			return true
-		}
-	}
-	if f.RolloutPercentage > 0 {
-		h := fnv.New32a()
-		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
-		return int(h.Sum32()%100) < f.RolloutPercentage
-	}
-	return false
-}

internal/flag/service.go

@@ -1,87 +0,0 @@
-package flag
-
-import (
-	"context"
-	"log/slog"
-	"sync"
-	"time"
-)
-
-// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
-// (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
-// Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
-// muss (Akzeptanzkriterium 3).
-const DefaultCacheTTL = 5 * time.Second
-
-type cacheEntry struct {
-	flag      Flag
-	expiresAt time.Time
-}
-
-// Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
-// lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
-type Service struct {
-	store *Store
-	ttl   time.Duration
-
-	mu    sync.RWMutex
-	cache map[string]cacheEntry
-}
-
-func NewService(store *Store, ttl time.Duration) *Service {
-	if ttl <= 0 {
-		ttl = DefaultCacheTTL
-	}
-	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
-}
-
-// IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
-// bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
-// Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
-// der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
-// Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
-func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
-	f, ok := s.resolve(ctx, key)
-	if !ok {
-		return false
-	}
-	return evaluate(f, tenantSlug)
-}
-
-func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
-	s.mu.RLock()
-	entry, exists := s.cache[key]
-	fresh := exists && time.Now().Before(entry.expiresAt)
-	s.mu.RUnlock()
-	if fresh {
-		return entry.flag, true
-	}
-
-	f, err := s.store.Get(ctx, key)
-	if err != nil {
-		if exists {
-			slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
-				"flag_key", key, "error", err)
-			return entry.flag, true
-		}
-		slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
-			"flag_key", key, "error", err)
-		return Flag{}, false
-	}
-
-	s.mu.Lock()
-	s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
-	s.mu.Unlock()
-	return f, true
-}
-
-// Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
-// aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
-// auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
-// ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
-// DefaultCacheTTL (siehe Akzeptanzkriterium 3).
-func (s *Service) Invalidate(key string) {
-	s.mu.Lock()
-	delete(s.cache, key)
-	s.mu.Unlock()
-}

internal/ldapsync/client.go

@@ -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)
+}

internal/ldapsync/ldapsync_test.go

@@ -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)
+	}
+}

internal/ldapsync/role_mapping.go

@@ -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
+}

internal/ldapsync/sync.go

@@ -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
+}

internal/policy/enforcer.go

@@ -1,67 +0,0 @@
-package policy
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-// ErrDenied wird geliefert, wenn keine Regel role+permission erlaubt —
-// Default-Deny (Akzeptanzkriterium 2).
-var ErrDenied = errors.New("policy: zugriff verweigert")
-
-// Enforcer ist die EINE zentrale Entscheidungs- und Durchsetzungsschicht
-// (Akzeptanzkriterium 1). Repository-/Query-Code ruft ausschliesslich Guard
-// bzw. GuardTenantScoped auf, nie eine Rohabfrage direkt.
-type Enforcer struct {
-	store *Store
-}
-
-func NewEnforcer(store *Store) *Enforcer {
-	return &Enforcer{store: store}
-}
-
-// Authorize entscheidet erlaubt/verboten — unabhaengig von jeder konkreten
-// Query, rein anhand der deklarativen Regeln (Akzeptanzkriterium 2: fuer
-// sich genommen testbar, ohne Anwendungslogik).
-func (e *Enforcer) Authorize(ctx context.Context, role rbac.Role, perm rbac.Permission) error {
-	allowed, err := e.store.IsAllowed(ctx, role, perm)
-	if err != nil {
-		return err
-	}
-	if !allowed {
-		return fmt.Errorf("%w: rolle %q hat kein recht %q", ErrDenied, role, perm)
-	}
-	return nil
-}
-
-// Guard ist die zentrale Enforcement-Funktion (Akzeptanzkriterium 1): query
-// wird NUR aufgerufen, wenn Authorize zustimmt. Es gibt keinen Weg, query
-// ausserhalb von Guard aufzurufen und trotzdem den Aufrufer als autorisiert
-// zu behandeln — die Autorisierungsentscheidung steht immer VOR dem
-// Datenzugriff, nie danach.
-func Guard[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) {
-	var zero T
-	if err := e.Authorize(ctx, role, perm); err != nil {
-		return zero, err
-	}
-	return query(ctx)
-}
-
-// GuardTenantScoped erzwingt zusaetzlich, dass tenantSlug TEIL der Query-
-// Funktion selbst ist (Akzeptanzkriterium 3): der Funktionstyp verlangt,
-// dass die Repository-Implementierung tenantSlug in ihre eigene WHERE-
-// Klausel einbaut — ein nachgelagerter Filter auf dem Ergebnis (der
-// archivmail-Fehler aus "Bekannte Fehler vermeiden") ist mit dieser
-// Signatur nicht moeglich, da die Query-Funktion tenantSlug selbst
-// entgegennimmt und dafuer verantwortlich ist, statt ihn hinterher
-// anzuwenden.
-func GuardTenantScoped[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, tenantSlug string, query func(ctx context.Context, tenantSlug string) (T, error)) (T, error) {
-	var zero T
-	if err := e.Authorize(ctx, role, perm); err != nil {
-		return zero, err
-	}
-	return query(ctx, tenantSlug)
-}

internal/policy/module_scope.go

@@ -1,90 +0,0 @@
-package policy
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-// ModuleScope verknuepft eine Policy-Regel mit einem Feature-Flag: existiert
-// ein ModuleScope fuer (role, permission), gilt die Regel nur zusaetzlich zur
-// Grundberechtigung, wenn FlagKey fuer den jeweiligen Tenant aktiv ist
-// (Akzeptanzkriterium 1: Rechte folgen der Lizenz).
-type ModuleScope struct {
-	Role       rbac.Role
-	Permission rbac.Permission
-	Module     string
-	FlagKey    string
-}
-
-// SetModuleScope verknuepft eine bestehende Policy-Regel mit einem Modul/
-// Feature-Flag. Die Regel selbst (Store.Grant) muss unabhaengig davon
-// existieren — ModuleScope schraenkt sie nur zusaetzlich ein.
-func (s *Store) SetModuleScope(ctx context.Context, role rbac.Role, perm rbac.Permission, module, flagKey string) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO policy_module_scopes (role, permission, module, flag_key)
-		VALUES ($1, $2, $3, $4)
-		ON CONFLICT (role, permission) DO UPDATE SET module = $3, flag_key = $4
-	`, string(role), string(perm), module, flagKey)
-	if err != nil {
-		return fmt.Errorf("modul-scope setzen: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) GetModuleScope(ctx context.Context, role rbac.Role, perm rbac.Permission) (ModuleScope, bool, error) {
-	var ms ModuleScope
-	ms.Role, ms.Permission = role, perm
-	err := s.pool.QueryRow(ctx, `
-		SELECT module, flag_key FROM policy_module_scopes WHERE role = $1 AND permission = $2
-	`, string(role), string(perm)).Scan(&ms.Module, &ms.FlagKey)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return ModuleScope{}, false, nil
-		}
-		return ModuleScope{}, false, fmt.Errorf("modul-scope lesen: %w", err)
-	}
-	return ms, true, nil
-}
-
-// AuthorizeForTenant ist dieselbe zentrale Entscheidungsfunktion wie
-// Authorize (Akzeptanzkriterium 3: keine zweite Enforcement-Schicht),
-// erweitert um die Modul-Scoping-Pruefung: eine sonst passende Regel greift
-// NICHT, wenn das zugehoerige Modul fuer den Tenant nicht aktiviert ist
-// (Akzeptanzkriterium 1). Feature-Flag-Aenderungen wirken ohne Neustart
-// (Akzeptanzkriterium 2), da flag.Service dieselbe TTL-Cache-Instanz der
-// aufrufenden Core-Instanz nutzt.
-func (e *Enforcer) AuthorizeForTenant(ctx context.Context, flags *flag.Service, tenantSlug string, role rbac.Role, perm rbac.Permission) error {
-	if err := e.Authorize(ctx, role, perm); err != nil {
-		return err
-	}
-
-	scope, found, err := e.store.GetModuleScope(ctx, role, perm)
-	if err != nil {
-		return err
-	}
-	if !found {
-		return nil // keine Modul-Bindung fuer diese Regel — Grundberechtigung reicht.
-	}
-
-	if !flags.IsEnabled(ctx, tenantSlug, scope.FlagKey) {
-		return fmt.Errorf("%w: modul %q ist fuer diesen mandanten nicht aktiviert", ErrDenied, scope.Module)
-	}
-	return nil
-}
-
-// GuardModuleScoped ist Guard mit zusaetzlicher Modul-Scoping-Pruefung —
-// dieselbe zentrale Enforcement-Funktion, kein paralleler Mechanismus
-// (Akzeptanzkriterium 3).
-func GuardModuleScoped[T any](ctx context.Context, e *Enforcer, flags *flag.Service, tenantSlug string, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) {
-	var zero T
-	if err := e.AuthorizeForTenant(ctx, flags, tenantSlug, role, perm); err != nil {
-		return zero, err
-	}
-	return query(ctx)
-}

internal/policy/module_scope_test.go

@@ -1,170 +0,0 @@
-package policy
-
-import (
-	"context"
-	"errors"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-func setupModuleScopeTest(t *testing.T) (*Store, *Enforcer, *flag.Store, *flag.Service, 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 policy_rules (
-			role TEXT NOT NULL, permission TEXT NOT NULL,
-			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-			PRIMARY KEY (role, permission)
-		);
-		CREATE TABLE IF NOT EXISTS policy_rule_changes (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
-			action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL,
-			version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS policy_module_scopes (
-			role TEXT NOT NULL, permission TEXT NOT NULL, module TEXT NOT NULL, flag_key TEXT NOT NULL,
-			PRIMARY KEY (role, permission)
-		);
-		CREATE TABLE IF NOT EXISTS feature_flags (
-			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
-			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	store := NewStore(pool)
-	flagStore := flag.NewStore(pool)
-	flagService := flag.NewService(flagStore, 10*time.Millisecond) // kurze TTL fuer testbare invalidierung
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM policy_module_scopes WHERE role LIKE 'test\_%' ESCAPE '\'`)
-		_, _ = pool.Exec(ctx, `DELETE FROM policy_rule_changes WHERE role LIKE 'test\_%' ESCAPE '\'`)
-		_, _ = pool.Exec(ctx, `DELETE FROM policy_rules WHERE role LIKE 'test\_%' ESCAPE '\'`)
-		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
-		pool.Close()
-	}
-	return store, NewEnforcer(store), flagStore, flagService, cleanup
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: Berechtigung fuer nicht aktiviertes
-// Modul greift nicht, selbst bei sonst passender Rolle.
-func TestAuthorizeForTenant_DeniesWhenModuleNotActivated(t *testing.T) {
-	store, enforcer, _, flagService, cleanup := setupModuleScopeTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	role := rbac.Role("test_dms_nutzer")
-	perm := rbac.Permission("test_dokumente_lesen")
-	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-	if err := store.SetModuleScope(ctx, role, perm, "dms", "test_dms_enabled"); err != nil {
-		t.Fatalf("set module scope: %v", err)
-	}
-	// Flag existiert nicht/ist nicht gesetzt -> IsEnabled liefert false (Fail-Safe-Default).
-
-	queryCalled := false
-	_, err := GuardModuleScoped(ctx, enforcer, flagService, "acme", role, perm, func(ctx context.Context) (string, error) {
-		queryCalled = true
-		return "daten", nil
-	})
-	if !errors.Is(err, ErrDenied) {
-		t.Fatalf("erwartet ErrDenied bei deaktiviertem modul, habe %v", err)
-	}
-	if queryCalled {
-		t.Fatal("query haette bei deaktiviertem modul nicht aufgerufen werden duerfen")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Aktivierung des Moduls macht die
-// Berechtigung ohne Neustart wirksam.
-func TestAuthorizeForTenant_BecomesActiveWithoutRestart(t *testing.T) {
-	store, enforcer, flagStore, flagService, cleanup := setupModuleScopeTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	role := rbac.Role("test_dms_nutzer2")
-	perm := rbac.Permission("test_dokumente_schreiben")
-	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-	if err := store.SetModuleScope(ctx, role, perm, "dms", "test_dms_enabled2"); err != nil {
-		t.Fatalf("set module scope: %v", err)
-	}
-
-	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", role, perm); !errors.Is(err, ErrDenied) {
-		t.Fatalf("vor aktivierung: erwartet ErrDenied, habe %v", err)
-	}
-
-	// Modul "im laufenden Betrieb" aktivieren — derselbe Prozess, kein Neustart.
-	if err := flagStore.Set(ctx, flag.Flag{Key: "test_dms_enabled2", Enabled: true}); err != nil {
-		t.Fatalf("flag setzen: %v", err)
-	}
-	time.Sleep(20 * time.Millisecond) // TTL abwarten statt Neustart
-
-	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", role, perm); err != nil {
-		t.Fatalf("nach aktivierung sollte erlaubt sein: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Zusammenspiel Modul-Scope + Rollenscope
-// in Kombinationsfaellen.
-func TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope(t *testing.T) {
-	store, enforcer, flagStore, flagService, cleanup := setupModuleScopeTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	scopedRole := rbac.Role("test_scoped_rolle")
-	unscopedRole := rbac.Role("test_unscoped_rolle")
-	perm := rbac.Permission("test_kombiniert")
-
-	// Fall 1: Rolle ohne jegliche Regel -> verboten, unabhaengig vom Flag.
-	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", rbac.Role("test_unbekannt"), perm); !errors.Is(err, ErrDenied) {
-		t.Fatalf("fall 1: erwartet ErrDenied (keine regel), habe %v", err)
-	}
-
-	// Fall 2: Regel vorhanden, KEIN Modul-Scope -> immer erlaubt (Grundrecht ohne Lizenzbindung).
-	if err := store.Grant(ctx, unscopedRole, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant unscoped: %v", err)
-	}
-	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", unscopedRole, perm); err != nil {
-		t.Fatalf("fall 2: erwartet erlaubt ohne modul-scope, habe %v", err)
-	}
-
-	// Fall 3: Regel + Modul-Scope, Flag aus -> verboten.
-	if err := store.Grant(ctx, scopedRole, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant scoped: %v", err)
-	}
-	if err := store.SetModuleScope(ctx, scopedRole, perm, "mail", "test_mail_enabled"); err != nil {
-		t.Fatalf("set module scope: %v", err)
-	}
-	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", scopedRole, perm); !errors.Is(err, ErrDenied) {
-		t.Fatalf("fall 3: erwartet ErrDenied (modul aus), habe %v", err)
-	}
-
-	// Fall 4: Regel + Modul-Scope, Flag an -> erlaubt.
-	if err := flagStore.Set(ctx, flag.Flag{Key: "test_mail_enabled", Enabled: true}); err != nil {
-		t.Fatalf("flag setzen: %v", err)
-	}
-	time.Sleep(20 * time.Millisecond)
-	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", scopedRole, perm); err != nil {
-		t.Fatalf("fall 4: erwartet erlaubt (modul an), habe %v", err)
-	}
-}

internal/policy/policy_test.go

@@ -1,187 +0,0 @@
-package policy
-
-import (
-	"context"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-func setupTest(t *testing.T) (*Store, *Enforcer, 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 policy_rules (
-			role TEXT NOT NULL, permission TEXT NOT NULL,
-			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-			PRIMARY KEY (role, permission)
-		);
-		CREATE TABLE IF NOT EXISTS policy_rule_changes (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
-			action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL,
-			version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	store := NewStore(pool)
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM policy_rule_changes WHERE role LIKE 'test\_%' ESCAPE '\'`)
-		_, _ = pool.Exec(ctx, `DELETE FROM policy_rules WHERE role LIKE 'test\_%' ESCAPE '\'`)
-		pool.Close()
-	}
-	return store, NewEnforcer(store), cleanup
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Anfrage ohne passende Policy wird
-// zuverlaessig abgewiesen (Default-Deny), nicht standardmaessig erlaubt.
-func TestAuthorize_DefaultDeny(t *testing.T) {
-	_, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	err := enforcer.Authorize(ctx, rbac.Role("test_niemand"), rbac.Permission("test_irgendwas"))
-	if !errors.Is(err, ErrDenied) {
-		t.Fatalf("erwartet ErrDenied ohne konfigurierte regel, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: Guard ruft query NUR bei Autorisierung
-// auf — kein Datenzugriffs-Pfad umgeht die Enforcement-Schicht.
-func TestGuard_NeverCallsQueryWithoutAuthorization(t *testing.T) {
-	store, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	role := rbac.Role("test_rolle_guard")
-	perm := rbac.Permission("test_lesen")
-
-	queryCalled := false
-	_, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
-		queryCalled = true
-		return "geheime-daten", nil
-	})
-	if !errors.Is(err, ErrDenied) {
-		t.Fatalf("erwartet ErrDenied, habe %v", err)
-	}
-	if queryCalled {
-		t.Fatal("query haette bei fehlender autorisierung NICHT aufgerufen werden duerfen")
-	}
-
-	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-
-	result, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
-		queryCalled = true
-		return "geheime-daten", nil
-	})
-	if err != nil {
-		t.Fatalf("guard nach grant: %v", err)
-	}
-	if !queryCalled || result != "geheime-daten" {
-		t.Fatalf("erwartet query-aufruf mit ergebnis nach autorisierung, habe queryCalled=%v result=%q", queryCalled, result)
-	}
-}
-
-// Akzeptanzkriterium 2 + 3: Policy-Entscheidungen deklarativ und unabhaengig
-// von Anwendungslogik testbar — Regelwechsel wirkt ohne Codeaenderung,
-// Historie ist versioniert nachvollziehbar.
-func TestGrantRevoke_ChangesBehaviorWithoutCodeChange(t *testing.T) {
-	store, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	role := rbac.Role("test_rolle_history")
-	perm := rbac.Permission("test_schreiben")
-
-	allowed, err := store.IsAllowed(ctx, role, perm)
-	if err != nil {
-		t.Fatalf("is allowed (vorher): %v", err)
-	}
-	if allowed {
-		t.Fatal("erwartet nicht erlaubt vor grant")
-	}
-
-	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-	if err := enforcer.Authorize(ctx, role, perm); err != nil {
-		t.Fatalf("authorize nach grant sollte erlauben: %v", err)
-	}
-
-	if err := store.Revoke(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("revoke: %v", err)
-	}
-	if err := enforcer.Authorize(ctx, role, perm); !errors.Is(err, ErrDenied) {
-		t.Fatalf("authorize nach revoke sollte verweigern, habe %v", err)
-	}
-
-	history, err := store.History(ctx, role, perm)
-	if err != nil {
-		t.Fatalf("history: %v", err)
-	}
-	if len(history) != 2 {
-		t.Fatalf("erwartet 2 historieneintraege (grant, revoke), habe %d", len(history))
-	}
-	if history[0].Action != "grant" || history[0].Version != 1 {
-		t.Fatalf("history[0] unerwartet: %+v", history[0])
-	}
-	if history[1].Action != "revoke" || history[1].Version != 2 {
-		t.Fatalf("history[1] unerwartet: %+v", history[1])
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3 (Tenant-Scoping): GuardTenantScoped
-// zwingt tenantSlug in die Query-Funktion selbst, kein Post-Filter moeglich.
-func TestGuardTenantScoped_IsolatesDataBetweenTenants(t *testing.T) {
-	_, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	// Simuliertes Repository: die WHERE-Klausel (hier: Map-Lookup) liegt
-	// INNERHALB der Query-Funktion, nicht als nachgelagerter Filter.
-	data := map[string][]string{
-		"acme":   {"dokument-a1", "dokument-a2"},
-		"globex": {"dokument-b1"},
-	}
-	repoQuery := func(ctx context.Context, tenantSlug string) ([]string, error) {
-		return data[tenantSlug], nil
-	}
-
-	role := rbac.Role("test_tenant_rolle")
-	perm := rbac.Permission("test_dokumente_lesen")
-	if err := enforcer.store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-
-	gotAcme, err := GuardTenantScoped(ctx, enforcer, role, perm, "acme", repoQuery)
-	if err != nil {
-		t.Fatalf("guard tenant scoped (acme): %v", err)
-	}
-	if len(gotAcme) != 2 {
-		t.Fatalf("erwartet 2 dokumente fuer acme, habe %d", len(gotAcme))
-	}
-
-	gotGlobex, err := GuardTenantScoped(ctx, enforcer, role, perm, "globex", repoQuery)
-	if err != nil {
-		t.Fatalf("guard tenant scoped (globex): %v", err)
-	}
-	if len(gotGlobex) != 1 {
-		t.Fatalf("erwartet 1 dokument fuer globex, habe %d", len(gotGlobex))
-	}
-}

internal/policy/store.go

@@ -1,124 +0,0 @@
-// Package policy implementiert Core RBAC-02: die zentrale Policy-
-// Entscheidungs- und Durchsetzungsschicht. Regeln liegen deklarativ in der
-// Datenbank (Casbin-Prinzip: Policy als Modell+Regeln getrennt vom Code),
-// versioniert und auditierbar — anders als Casbin-Dateien im Dateisystem
-// (siehe "bewusst vermeiden" im Ticket).
-package policy
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-// Rule ist eine gewaehrte Regel: role darf permission.
-type Rule struct {
-	Role       rbac.Role
-	Permission rbac.Permission
-}
-
-// RuleChange ist ein Eintrag der Aenderungshistorie (Akzeptanzkriterium 3).
-type RuleChange struct {
-	Role       rbac.Role
-	Permission rbac.Permission
-	Action     string // "grant" oder "revoke"
-	Actor      string
-	Version    int
-}
-
-// Store verwaltet den deklarativen Regelsatz. IsAllowed schaut NUR in die
-// Datenbank — es gibt keinen hartcodierten Go-Fallback, ein Regelwechsel
-// wirkt sich ohne Codeaenderung sofort aus (Akzeptanzkriterium 2 / 3).
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// IsAllowed prueft, ob role das Recht permission besitzt. Default-Deny:
-// existiert keine passende Regel, ist der Zugriff verboten
-// (Akzeptanzkriterium 2 / Pruefung 2) — es gibt keinen impliziten
-// "erlaubt, wenn nichts anderes gesagt"-Pfad.
-func (s *Store) IsAllowed(ctx context.Context, role rbac.Role, perm rbac.Permission) (bool, error) {
-	var exists bool
-	err := s.pool.QueryRow(ctx, `
-		SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role = $1 AND permission = $2)
-	`, string(role), string(perm)).Scan(&exists)
-	if err != nil {
-		return false, fmt.Errorf("policy pruefen: %w", err)
-	}
-	return exists, nil
-}
-
-// Grant gewaehrt role das Recht permission — deklarativ, ohne Codeaenderung
-// wirksam. actor wird fuer die Aenderungshistorie festgehalten.
-func (s *Store) Grant(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
-	return s.change(ctx, role, perm, "grant", actor, `
-		INSERT INTO policy_rules (role, permission, granted_by, granted_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (role, permission) DO UPDATE SET granted_by = $3, granted_at = now()
-	`, string(role), string(perm), actor)
-}
-
-// Revoke entzieht role das Recht permission.
-func (s *Store) Revoke(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
-	return s.change(ctx, role, perm, "revoke", actor, `
-		DELETE FROM policy_rules WHERE role = $1 AND permission = $2
-	`, string(role), string(perm))
-}
-
-func (s *Store) change(ctx context.Context, role rbac.Role, perm rbac.Permission, action, actor, sql string, args ...any) error {
-	tx, err := s.pool.Begin(ctx)
-	if err != nil {
-		return fmt.Errorf("transaktion starten: %w", err)
-	}
-	defer func() { _ = tx.Rollback(ctx) }()
-
-	if _, err := tx.Exec(ctx, sql, args...); err != nil {
-		return fmt.Errorf("regel aendern: %w", err)
-	}
-
-	var version int
-	if err := tx.QueryRow(ctx, `
-		SELECT COALESCE(MAX(version), 0) + 1 FROM policy_rule_changes WHERE role = $1 AND permission = $2
-	`, string(role), string(perm)).Scan(&version); err != nil {
-		return fmt.Errorf("naechste version ermitteln: %w", err)
-	}
-
-	if _, err := tx.Exec(ctx, `
-		INSERT INTO policy_rule_changes (role, permission, action, actor, version, changed_at)
-		VALUES ($1, $2, $3, $4, $5, now())
-	`, string(role), string(perm), action, actor, version); err != nil {
-		return fmt.Errorf("historie schreiben: %w", err)
-	}
-
-	return tx.Commit(ctx)
-}
-
-// History liefert die vollstaendige, versionierte Aenderungshistorie einer
-// Regel (Akzeptanzkriterium 3).
-func (s *Store) History(ctx context.Context, role rbac.Role, perm rbac.Permission) ([]RuleChange, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT action, actor, version FROM policy_rule_changes
-		WHERE role = $1 AND permission = $2 ORDER BY version
-	`, string(role), string(perm))
-	if err != nil {
-		return nil, fmt.Errorf("historie abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []RuleChange
-	for rows.Next() {
-		c := RuleChange{Role: role, Permission: perm}
-		if err := rows.Scan(&c.Action, &c.Actor, &c.Version); err != nil {
-			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
-		}
-		out = append(out, c)
-	}
-	return out, rows.Err()
-}

internal/rbac/role_test.go

@@ -1,48 +0,0 @@
-package rbac
-
-import "testing"
-
-func contains(perms []Permission, p Permission) bool {
-	for _, x := range perms {
-		if x == p {
-			return true
-		}
-	}
-	return false
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Rollenhierarchie liefert die erwartete
-// effektive Rechtemenge.
-func TestEffectivePermissions_Inheritance(t *testing.T) {
-	userPerms := EffectivePermissions(RoleUser)
-	if !contains(userPerms, PermSelfRead) || !contains(userPerms, PermSelfUpdate) {
-		t.Fatalf("user sollte self.read/self.update haben, habe %v", userPerms)
-	}
-	if contains(userPerms, PermManageUsers) {
-		t.Fatal("user sollte KEIN tenant.manage_users haben")
-	}
-
-	adminPerms := EffectivePermissions(RoleTenantAdmin)
-	if !contains(adminPerms, PermSelfRead) || !contains(adminPerms, PermManageUsers) || !contains(adminPerms, PermManageSettings) {
-		t.Fatalf("tenant_admin sollte geerbte user-rechte + eigene rechte haben, habe %v", adminPerms)
-	}
-	if contains(adminPerms, PermManageTenants) {
-		t.Fatal("tenant_admin sollte KEIN platform.manage_tenants haben")
-	}
-
-	superPerms := EffectivePermissions(RoleSuperadmin)
-	for _, want := range []Permission{PermSelfRead, PermSelfUpdate, PermManageUsers, PermManageSettings, PermManageTenants} {
-		if !contains(superPerms, want) {
-			t.Fatalf("superadmin sollte %q haben (volle vererbte kette), habe %v", want, superPerms)
-		}
-	}
-}
-
-func TestHasPermission(t *testing.T) {
-	if !HasPermission(RoleTenantAdmin, PermSelfRead) {
-		t.Fatal("tenant_admin sollte geerbtes self.read haben")
-	}
-	if HasPermission(RoleUser, PermManageTenants) {
-		t.Fatal("user sollte platform.manage_tenants nicht haben")
-	}
-}

internal/rbac/store_test.go

@@ -1,144 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-func setupStoreTest(t *testing.T) (*Store, 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',
-			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()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	userStore := user.NewTenantUserStore(pool)
-	u, err := userStore.Create(ctx, "rbac_test@example.com", "RBAC Test")
-	if err != nil {
-		t.Fatalf("testuser anlegen: %v", err)
-	}
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM role_assignment_history WHERE user_id = $1`, u.ID)
-		_, _ = pool.Exec(ctx, `DELETE FROM role_assignments WHERE user_id = $1`, u.ID)
-		_, _ = pool.Exec(ctx, `DELETE FROM users WHERE id = $1`, u.ID)
-		pool.Close()
-	}
-	return NewStore(pool), u.ID, cleanup
-}
-
-// Akzeptanzkriterium 1: Grundrollen sind einem Benutzer je Tenant zuweisbar.
-func TestStore_AssignAndGet(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	assigned, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example")
-	if err != nil {
-		t.Fatalf("assign: %v", err)
-	}
-	if assigned.Role != RoleTenantAdmin {
-		t.Fatalf("erwartet tenant_admin, habe %q", assigned.Role)
-	}
-
-	got, err := store.Get(ctx, userID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Role != RoleTenantAdmin || got.GrantedBy != "admin@acme.example" {
-		t.Fatalf("zuweisung unerwartet: %+v", got)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: Zuweisung ausserhalb der erlaubten
-// Matrix (superadmin im tenant-gescopten Store) wird abgewiesen.
-func TestStore_RejectsSuperadminOutsideAllowedMatrix(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	_, err := store.Assign(ctx, userID, RoleSuperadmin, "admin@acme.example")
-	if !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
-		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope, habe %v", err)
-	}
-
-	// Sicherstellen, dass der abgewiesene Versuch keine Zeile hinterlassen hat.
-	if _, err := store.Get(ctx, userID); !errors.Is(err, ErrNotFound) {
-		t.Fatalf("erwartet ErrNotFound nach abgewiesener zuweisung, habe %v", err)
-	}
-}
-
-func TestStore_RejectsUnknownRole(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.Assign(ctx, userID, Role("erfunden"), "admin@acme.example"); !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
-		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope fuer unbekannte rolle, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 3: Rollenzuweisung vollstaendig auditierbar.
-func TestStore_HistoryTracksWhoAndWhen(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.Assign(ctx, userID, RoleUser, "system"); err != nil {
-		t.Fatalf("assign 1: %v", err)
-	}
-	if _, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example"); err != nil {
-		t.Fatalf("assign 2: %v", err)
-	}
-
-	history, err := store.History(ctx, userID)
-	if err != nil {
-		t.Fatalf("history: %v", err)
-	}
-	if len(history) != 2 {
-		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
-	}
-	if history[0].Role != RoleUser || history[0].GrantedBy != "system" {
-		t.Fatalf("history[0] unerwartet: %+v", history[0])
-	}
-	if history[1].Role != RoleTenantAdmin || history[1].GrantedBy != "admin@acme.example" {
-		t.Fatalf("history[1] unerwartet: %+v", history[1])
-	}
-}

internal/user/tenant_store.go

@@ -103,6 +103,51 @@ func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, erro
 	`, 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 {

migrations/0003_policy_rules.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS policy_rule_changes;
-DROP TABLE IF EXISTS policy_rules;

migrations/0003_policy_rules.up.sql

@@ -1,24 +0,0 @@
--- Zentrale, deklarative Policy-Regeln (RBAC-02, siehe core-kanban/tickets/RBAC-02.md).
--- policy_rules haelt den AKTUELLEN, gewaehrten Regelsatz (Existenz = erlaubt,
--- Default-Deny fuer alles ohne Zeile). policy_rule_changes ist die
--- versionierte Aenderungshistorie (Akzeptanzkriterium 3: Regelwechsel ohne
--- Codeaenderung nachvollziehbar).
-CREATE TABLE policy_rules (
-    role       TEXT NOT NULL,
-    permission TEXT NOT NULL,
-    granted_by TEXT NOT NULL,
-    granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (role, permission)
-);
-
-CREATE TABLE policy_rule_changes (
-    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    role       TEXT NOT NULL,
-    permission TEXT NOT NULL,
-    action     TEXT NOT NULL CHECK (action IN ('grant', 'revoke')),
-    actor      TEXT NOT NULL,
-    version    INT NOT NULL,
-    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
-CREATE INDEX policy_rule_changes_idx ON policy_rule_changes (role, permission, version);

migrations/0004_feature_flags.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS feature_flags;

migrations/0004_feature_flags.up.sql

@@ -1,10 +0,0 @@
--- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
--- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
--- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
-CREATE TABLE feature_flags (
-    key                 TEXT PRIMARY KEY,
-    enabled             BOOLEAN NOT NULL DEFAULT false,
-    rollout_percentage  INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
-    target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/0005_policy_module_scopes.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS policy_module_scopes;

migrations/0005_policy_module_scopes.up.sql

@@ -1,11 +0,0 @@
--- Modul-Scoping fuer Policy-Regeln (RBAC-04, siehe core-kanban/tickets/RBAC-04.md).
--- Existiert fuer eine (role, permission)-Regel ein Eintrag hier, gilt sie
--- NUR, wenn zusaetzlich das verknuepfte Feature-Flag (LIC-02) fuer den
--- Tenant aktiv ist — Rechte folgen der Lizenz, nicht umgekehrt.
-CREATE TABLE policy_module_scopes (
-    role       TEXT NOT NULL,
-    permission TEXT NOT NULL,
-    module     TEXT NOT NULL,
-    flag_key   TEXT NOT NULL,
-    PRIMARY KEY (role, permission)
-);

migrations/tenant/0002_users_password.down.sql

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

migrations/tenant/0002_users_password.up.sql

@@ -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 '';

migrations/tenant/0003_ldap.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS ldap_group_role_mapping;
+DROP TABLE IF EXISTS ldap_config;

migrations/tenant/0003_ldap.up.sql

@@ -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'))
+);

scripts/reset-test-env.sh

@@ -1,23 +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;"
-
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
-
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."

scripts/run-checks.sh

@@ -1,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