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>

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/rbac/role.go

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

internal/rbac/store.go

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

internal/webauthn/login.go

@@ -1,19 +0,0 @@
-package webauthn
-
-import (
-	"context"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-)
-
-// CompleteLogin verifiziert die WebAuthn-Signatur und stellt bei Erfolg ein
-// normales IAM-02-Sitzungs-Token aus — komponiert auth.TokenIssuer, ohne
-// LoginService/IAM-02 selbst zu veraendern. Passwort+TOTP (IAM-02/IAM-04)
-// bleiben davon vollstaendig unberuehrt und weiterhin nutzbar
-// (Akzeptanzkriterium 3).
-func CompleteLogin(ctx context.Context, store *Store, issuer *auth.TokenIssuer, tenantSlug, userID, challenge, credentialID string, signature []byte) (token string, err error) {
-	if err := store.FinishLogin(ctx, userID, challenge, credentialID, signature); err != nil {
-		return "", err
-	}
-	return issuer.Issue(userID, tenantSlug)
-}

internal/webauthn/webauthn.go

@@ -1,184 +0,0 @@
-// Package webauthn implementiert Core IAM-10: passwortlose Anmeldung ueber
-// einen registrierten Authenticator (Plattform-Authenticator wie Windows
-// Hello/Touch ID oder externer Sicherheitsschluessel).
-//
-// WICHTIGER HINWEIS: Dies ist eine vereinfachte, aber kryptographisch echte
-// Challenge-Response-Zeremonie (Ed25519-Signatur ueber eine einmalige,
-// zufaellige Challenge) — NICHT das vollstaendige W3C-WebAuthn-Drahtformat
-// (CBOR-attestationObject/clientDataJSON, COSE-Schluessel), das echte
-// Browser/Authenticatoren erzeugen. Ohne Browser-Umgebung laesst sich dieses
-// Drahtformat hier nicht erzeugen oder pruefen (aehnliche Einschraenkung wie
-// bei IAM-05/LDAP und dem Live-Redirect in IAM-06/OIDC). Diese
-// Implementierung deckt dieselben Sicherheitseigenschaften ab (Public-Key-
-// Challenge-Response, Replay-Schutz durch Einmal-Challenge, mehrere
-// Authenticatoren pro Benutzer) und ist die Grundlage, auf der eine spaetere
-// Kachel echtes CBOR/COSE-Parsing nachruesten kann, ohne das Datenmodell zu
-// aendern.
-package webauthn
-
-import (
-	"context"
-	"crypto/ed25519"
-	"crypto/rand"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var (
-	ErrChallengeInvalid = errors.New("webauthn: challenge ungueltig, verbraucht oder abgelaufen")
-	ErrSignatureInvalid = errors.New("webauthn: signatur ungueltig")
-	ErrNoCredentials    = errors.New("webauthn: keine registrierten authenticatoren")
-)
-
-// ChallengeTTL begrenzt, wie lange eine ausgestellte Challenge fuer die
-// Registrierungs-/Anmelde-Ceremonie gueltig bleibt.
-const ChallengeTTL = 5 * time.Minute
-
-type Credential struct {
-	ID         string
-	UserID     string
-	DeviceName string
-	PublicKey  ed25519.PublicKey
-	SignCount  int
-}
-
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// BeginRegistration stellt eine Einmal-Challenge fuer die Registrierung
-// eines neuen Authenticators aus (Akzeptanzkriterium 1).
-func (s *Store) BeginRegistration(ctx context.Context, userID string) (challenge string, err error) {
-	return s.issueChallenge(ctx, userID, "register")
-}
-
-// FinishRegistration verifiziert, dass der Aufrufer im Besitz des privaten
-// Schluessels zu publicKey ist (Signatur ueber die Challenge), und speichert
-// den Authenticator. Mehrere Authenticatoren pro Benutzer sind moeglich,
-// da jede Registrierung eine neue Zeile anlegt (Akzeptanzkriterium 2).
-func (s *Store) FinishRegistration(ctx context.Context, userID, challenge, deviceName string, publicKey ed25519.PublicKey, signature []byte) (credentialID string, err error) {
-	if err := s.consumeChallenge(ctx, userID, challenge, "register"); err != nil {
-		return "", err
-	}
-	if !ed25519.Verify(publicKey, []byte(challenge), signature) {
-		return "", ErrSignatureInvalid
-	}
-
-	err = s.pool.QueryRow(ctx, `
-		INSERT INTO webauthn_credentials (user_id, device_name, public_key)
-		VALUES ($1, $2, $3)
-		RETURNING id
-	`, userID, deviceName, []byte(publicKey)).Scan(&credentialID)
-	if err != nil {
-		return "", fmt.Errorf("credential speichern: %w", err)
-	}
-	return credentialID, nil
-}
-
-// BeginLogin stellt eine Einmal-Challenge fuer eine bestehende Anmeldung
-// aus. Der Benutzer muss mindestens einen registrierten Authenticator haben.
-func (s *Store) BeginLogin(ctx context.Context, userID string) (challenge string, err error) {
-	var count int
-	if err := s.pool.QueryRow(ctx, `SELECT count(*) FROM webauthn_credentials WHERE user_id = $1`, userID).Scan(&count); err != nil {
-		return "", fmt.Errorf("credentials zaehlen: %w", err)
-	}
-	if count == 0 {
-		return "", ErrNoCredentials
-	}
-	return s.issueChallenge(ctx, userID, "login")
-}
-
-// FinishLogin verifiziert die Signatur ueber die Login-Challenge gegen den
-// gespeicherten oeffentlichen Schluessel des angegebenen Credentials
-// (Akzeptanzkriterium 1: Anmeldung ohne Passwort).
-func (s *Store) FinishLogin(ctx context.Context, userID, challenge, credentialID string, signature []byte) error {
-	if err := s.consumeChallenge(ctx, userID, challenge, "login"); err != nil {
-		return err
-	}
-
-	var publicKey []byte
-	err := s.pool.QueryRow(ctx, `
-		SELECT public_key FROM webauthn_credentials WHERE id = $1 AND user_id = $2
-	`, credentialID, userID).Scan(&publicKey)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return ErrSignatureInvalid
-		}
-		return fmt.Errorf("credential lesen: %w", err)
-	}
-
-	if !ed25519.Verify(ed25519.PublicKey(publicKey), []byte(challenge), signature) {
-		return ErrSignatureInvalid
-	}
-
-	_, _ = s.pool.Exec(ctx, `UPDATE webauthn_credentials SET sign_count = sign_count + 1 WHERE id = $1`, credentialID)
-	return nil
-}
-
-// ListCredentials liefert alle registrierten Authenticatoren eines
-// Benutzers (Akzeptanzkriterium 2).
-func (s *Store) ListCredentials(ctx context.Context, userID string) ([]Credential, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, device_name, public_key, sign_count FROM webauthn_credentials WHERE user_id = $1
-	`, userID)
-	if err != nil {
-		return nil, fmt.Errorf("credentials auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Credential
-	for rows.Next() {
-		c := Credential{UserID: userID}
-		var pub []byte
-		if err := rows.Scan(&c.ID, &c.DeviceName, &pub, &c.SignCount); err != nil {
-			return nil, fmt.Errorf("credential lesen: %w", err)
-		}
-		c.PublicKey = pub
-		out = append(out, c)
-	}
-	return out, rows.Err()
-}
-
-func (s *Store) issueChallenge(ctx context.Context, userID, purpose string) (string, error) {
-	buf := make([]byte, 32)
-	if _, err := rand.Read(buf); err != nil {
-		return "", fmt.Errorf("challenge erzeugen: %w", err)
-	}
-	challenge := hex.EncodeToString(buf)
-
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO webauthn_challenges (user_id, challenge, purpose, expires_at)
-		VALUES ($1, $2, $3, $4)
-	`, userID, challenge, purpose, time.Now().Add(ChallengeTTL))
-	if err != nil {
-		return "", fmt.Errorf("challenge speichern: %w", err)
-	}
-	return challenge, nil
-}
-
-// consumeChallenge loest eine Challenge ATOMAR und EINMALIG ein (WHERE
-// used_at IS NULL, dasselbe Muster wie IAM-03/IAM-06/IAM-09) — verhindert
-// Replay einer abgefangenen Signatur-Antwort.
-func (s *Store) consumeChallenge(ctx context.Context, userID, challenge, purpose string) error {
-	tag, err := s.pool.Exec(ctx, `
-		UPDATE webauthn_challenges SET used_at = now()
-		WHERE user_id = $1 AND challenge = $2 AND purpose = $3
-		  AND used_at IS NULL AND expires_at > now()
-	`, userID, challenge, purpose)
-	if err != nil {
-		return fmt.Errorf("challenge einloesen: %w", err)
-	}
-	if tag.RowsAffected() == 0 {
-		return ErrChallengeInvalid
-	}
-	return nil
-}

internal/webauthn/webauthn_test.go

@@ -1,233 +0,0 @@
-package webauthn
-
-import (
-	"context"
-	"crypto/ed25519"
-	"errors"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-func setupTest(t *testing.T) (*Store, *user.TenantUserStore, string, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS users (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS webauthn_credentials (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL REFERENCES users(id),
-			device_name TEXT NOT NULL, public_key BYTEA NOT NULL, sign_count INT NOT NULL DEFAULT 0,
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS webauthn_challenges (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL REFERENCES users(id),
-			challenge TEXT NOT NULL UNIQUE, purpose TEXT NOT NULL CHECK (purpose IN ('register','login')),
-			expires_at TIMESTAMPTZ NOT NULL, used_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	userStore := user.NewTenantUserStore(pool)
-	email := fmt.Sprintf("webauthn-test-%d@example.com", time.Now().UnixNano())
-	u, err := userStore.Create(ctx, email, "WebAuthn Test")
-	if err != nil {
-		t.Fatalf("create user: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return NewStore(pool), userStore, u.ID, cleanup
-}
-
-// simulateAuthenticator erzeugt ein neues Schluesselpaar und "unterschreibt"
-// eine Challenge — steht fuer einen echten Hardware-/Plattform-Authenticator
-// im Test (siehe Paket-Dokumentation zur vereinfachten Zeremonie).
-func simulateAuthenticator(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
-	t.Helper()
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar erzeugen: %v", err)
-	}
-	return pub, priv
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: Registrierung und Anmeldung mit
-// simuliertem Authenticator erfolgreich, ganz ohne Passworteingabe.
-func TestRegisterAndLogin_WithoutPassword(t *testing.T) {
-	store, _, userID, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	pub, priv := simulateAuthenticator(t)
-
-	regChallenge, err := store.BeginRegistration(ctx, userID)
-	if err != nil {
-		t.Fatalf("begin registration: %v", err)
-	}
-	sig := ed25519.Sign(priv, []byte(regChallenge))
-	credentialID, err := store.FinishRegistration(ctx, userID, regChallenge, "Yubikey 1", pub, sig)
-	if err != nil {
-		t.Fatalf("finish registration: %v", err)
-	}
-
-	loginChallenge, err := store.BeginLogin(ctx, userID)
-	if err != nil {
-		t.Fatalf("begin login: %v", err)
-	}
-	loginSig := ed25519.Sign(priv, []byte(loginChallenge))
-
-	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
-	token, err := CompleteLogin(ctx, store, issuer, "acme", userID, loginChallenge, credentialID, loginSig)
-	if err != nil {
-		t.Fatalf("complete login: %v", err)
-	}
-	if token == "" {
-		t.Fatal("erwartet nicht-leeres sitzungs-token")
-	}
-}
-
-func TestFinishRegistration_RejectsWrongSignature(t *testing.T) {
-	store, _, userID, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	pub, _ := simulateAuthenticator(t)
-	_, otherPriv := simulateAuthenticator(t) // falscher privater schluessel
-
-	challenge, err := store.BeginRegistration(ctx, userID)
-	if err != nil {
-		t.Fatalf("begin registration: %v", err)
-	}
-	wrongSig := ed25519.Sign(otherPriv, []byte(challenge))
-
-	if _, err := store.FinishRegistration(ctx, userID, challenge, "Faelscher", pub, wrongSig); !errors.Is(err, ErrSignatureInvalid) {
-		t.Fatalf("erwartet ErrSignatureInvalid, habe %v", err)
-	}
-}
-
-func TestChallenge_CannotBeReplayed(t *testing.T) {
-	store, _, userID, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	pub, priv := simulateAuthenticator(t)
-	challenge, err := store.BeginRegistration(ctx, userID)
-	if err != nil {
-		t.Fatalf("begin registration: %v", err)
-	}
-	sig := ed25519.Sign(priv, []byte(challenge))
-
-	if _, err := store.FinishRegistration(ctx, userID, challenge, "Geraet 1", pub, sig); err != nil {
-		t.Fatalf("erste registrierung: %v", err)
-	}
-	if _, err := store.FinishRegistration(ctx, userID, challenge, "Geraet 2 (replay)", pub, sig); !errors.Is(err, ErrChallengeInvalid) {
-		t.Fatalf("erwartet ErrChallengeInvalid bei wiederverwendeter challenge, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: mehrere Authenticatoren pro Benutzer,
-// beide funktionsfaehig (Geraetewechsel/-verlust).
-func TestMultipleCredentials_BothWork(t *testing.T) {
-	store, _, userID, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	pub1, priv1 := simulateAuthenticator(t)
-	pub2, priv2 := simulateAuthenticator(t)
-
-	reg1, _ := store.BeginRegistration(ctx, userID)
-	cred1, err := store.FinishRegistration(ctx, userID, reg1, "Laptop", pub1, ed25519.Sign(priv1, []byte(reg1)))
-	if err != nil {
-		t.Fatalf("register cred1: %v", err)
-	}
-	reg2, _ := store.BeginRegistration(ctx, userID)
-	cred2, err := store.FinishRegistration(ctx, userID, reg2, "Handy", pub2, ed25519.Sign(priv2, []byte(reg2)))
-	if err != nil {
-		t.Fatalf("register cred2: %v", err)
-	}
-
-	creds, err := store.ListCredentials(ctx, userID)
-	if err != nil {
-		t.Fatalf("list: %v", err)
-	}
-	if len(creds) != 2 {
-		t.Fatalf("erwartet 2 credentials, habe %d", len(creds))
-	}
-
-	// Beide Authenticatoren koennen sich unabhaengig voneinander anmelden.
-	login1, _ := store.BeginLogin(ctx, userID)
-	if err := store.FinishLogin(ctx, userID, login1, cred1, ed25519.Sign(priv1, []byte(login1))); err != nil {
-		t.Fatalf("login mit cred1: %v", err)
-	}
-	login2, _ := store.BeginLogin(ctx, userID)
-	if err := store.FinishLogin(ctx, userID, login2, cred2, ed25519.Sign(priv2, []byte(login2))); err != nil {
-		t.Fatalf("login mit cred2: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Login mit Passwort+TOTP funktioniert
-// weiterhin unveraendert, kein Zwang auf WebAuthn.
-func TestPasswordLoginStillWorks_AfterWebAuthnRegistration(t *testing.T) {
-	store, userStore, userID, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	u, err := userStore.Get(ctx, userID)
-	if err != nil {
-		t.Fatalf("get user: %v", err)
-	}
-	hash, err := auth.HashPassword("korrektes-passwort")
-	if err != nil {
-		t.Fatalf("hash: %v", err)
-	}
-	if err := userStore.SetPasswordHash(ctx, userID, hash); err != nil {
-		t.Fatalf("set password: %v", err)
-	}
-
-	// WebAuthn zusaetzlich registrieren.
-	pub, priv := simulateAuthenticator(t)
-	reg, _ := store.BeginRegistration(ctx, userID)
-	if _, err := store.FinishRegistration(ctx, userID, reg, "Geraet", pub, ed25519.Sign(priv, []byte(reg))); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-
-	// Passwort-Login (IAM-02) bleibt unveraendert funktionsfaehig.
-	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
-	loginService := auth.NewLoginService(userStore, issuer, "acme")
-	token, err := loginService.Login(ctx, u.Email, "korrektes-passwort")
-	if err != nil {
-		t.Fatalf("passwort-login sollte trotz registriertem webauthn weiterhin funktionieren: %v", err)
-	}
-	if token == "" {
-		t.Fatal("erwartet gueltiges token")
-	}
-}
-
-func TestBeginLogin_RejectsUserWithoutCredentials(t *testing.T) {
-	store, _, userID, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.BeginLogin(ctx, userID); !errors.Is(err, ErrNoCredentials) {
-		t.Fatalf("erwartet ErrNoCredentials, habe %v", err)
-	}
-}

migrations/tenant/0002_role_assignments.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS role_assignment_history;
+DROP TABLE IF EXISTS role_assignments;

migrations/tenant/0002_role_assignments.up.sql

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

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

migrations/tenant/0003_webauthn.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS webauthn_challenges;
-DROP TABLE IF EXISTS webauthn_credentials;

migrations/tenant/0003_webauthn.up.sql

@@ -1,23 +0,0 @@
--- Passwortlose Anmeldung via WebAuthn/Passkey (IAM-10, siehe
--- core-kanban/tickets/IAM-10.md).
-CREATE TABLE webauthn_credentials (
-    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    user_id     UUID NOT NULL REFERENCES users(id),
-    device_name TEXT NOT NULL,
-    public_key  BYTEA NOT NULL,
-    sign_count  INT NOT NULL DEFAULT 0,
-    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
-CREATE INDEX webauthn_credentials_user_idx ON webauthn_credentials (user_id);
-
--- Einmal-Challenges fuer Registrierung/Anmeldung (Replay-Schutz).
-CREATE TABLE webauthn_challenges (
-    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    user_id    UUID NOT NULL REFERENCES users(id),
-    challenge  TEXT NOT NULL UNIQUE,
-    purpose    TEXT NOT NULL CHECK (purpose IN ('register', 'login')),
-    expires_at TIMESTAMPTZ NOT NULL,
-    used_at    TIMESTAMPTZ,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);