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/apiserver/context.go

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

internal/apiserver/errors.go

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

internal/apiserver/middleware.go

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

internal/apiserver/server.go

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

internal/apiserver/server_test.go

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

internal/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/ratelimit/middleware.go

@@ -1,64 +0,0 @@
-package ratelimit
-
-import (
-	"fmt"
-	"math"
-	"net/http"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
-)
-
-// KeyFunc bestimmt den Rate-Limit-Schluessel fuer eine Anfrage — typischerweise
-// der Tenant-Slug aus apiserver.RequestContext, siehe KeyByTenant. Als
-// eigenstaendiger Typ austauschbar (z.B. spaeter API-Token-basiert), ohne
-// internal/apiserver aendern zu muessen (Kein Umbau angrenzender Bereiche).
-type KeyFunc func(r *http.Request) (string, bool)
-
-// KeyByTenant liest den Tenant aus dem von internal/apiserver.authAndTenantContext
-// gesetzten RequestContext (IAM-02/API-01) — dieselbe Middleware-Kette,
-// keine zweite Authentifizierung.
-func KeyByTenant(r *http.Request) (string, bool) {
-	rc, ok := apiserver.FromContext(r.Context())
-	if !ok || rc.TenantSlug == "" {
-		return "", false
-	}
-	return rc.TenantSlug, true
-}
-
-// Middleware setzt sich VOR den eigentlichen Handler (nach Auth+Tenant-
-// Kontext, siehe KeyByTenant) und lehnt Anfragen ueber dem konfigurierten
-// Limit mit 429 + Retry-After ab (Akzeptanzkriterium 3).
-func Middleware(store *Store, keyFn KeyFunc, next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		key, ok := keyFn(r)
-		if !ok {
-			// Kein Schluessel ermittelbar (z.B. kein Tenant-Kontext) — die
-			// Auth-Pruefung selbst ist Sache von authAndTenantContext, hier
-			// wird nur nicht limitiert, wenn schon kein Kontext vorliegt.
-			next(w, r)
-			return
-		}
-
-		result, err := store.Allow(r.Context(), key)
-		if err != nil {
-			apiserver.WriteError(w, http.StatusInternalServerError, "rate_limit_error", "rate-limit-pruefung fehlgeschlagen")
-			return
-		}
-
-		w.Header().Set("X-RateLimit-Limit", fmt.Sprintf("%d", result.Limit))
-		w.Header().Set("X-RateLimit-Remaining", fmt.Sprintf("%d", result.Remaining))
-
-		if !result.Allowed {
-			retryAfterSeconds := int(math.Ceil(result.RetryAfter.Seconds()))
-			if retryAfterSeconds < 1 {
-				retryAfterSeconds = 1
-			}
-			w.Header().Set("Retry-After", fmt.Sprintf("%d", retryAfterSeconds))
-			apiserver.WriteError(w, http.StatusTooManyRequests, "rate_limit_exceeded",
-				"zu viele anfragen, bitte spaeter erneut versuchen")
-			return
-		}
-
-		next(w, r)
-	}
-}

internal/ratelimit/middleware_test.go

@@ -1,136 +0,0 @@
-package ratelimit
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-)
-
-func setupMiddlewareTest(t *testing.T) (*apiserver.Server, *auth.TokenIssuer, *Store, 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 rate_limit_configs (
-			key TEXT PRIMARY KEY, limit_value INT NOT NULL, window_seconds INT NOT NULL
-		);
-		CREATE TABLE IF NOT EXISTS rate_limit_counters (
-			key TEXT NOT NULL, window_start TIMESTAMPTZ NOT NULL, count INT NOT NULL DEFAULT 0,
-			PRIMARY KEY (key, window_start)
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
-	srv := apiserver.NewServer(issuer)
-	store := NewStore(pool)
-
-	cleanup := func() { pool.Close() }
-	return srv, issuer, store, cleanup
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Ueberschreitung liefert 429 mit
-// Retry-After-Header, ueber die vollstaendige Middleware-Kette (Auth ->
-// Tenant-Kontext -> Rate-Limit -> Handler) hinweg.
-func TestMiddleware_Returns429WithRetryAfterOnExceeded(t *testing.T) {
-	srv, issuer, store, cleanup := setupMiddlewareTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	tenantSlug := newTestKey()
-	if err := store.SetLimit(ctx, tenantSlug, 1, time.Minute); err != nil {
-		t.Fatalf("setlimit: %v", err)
-	}
-
-	called := 0
-	srv.HandleV1("/limited", Middleware(store, KeyByTenant, func(w http.ResponseWriter, r *http.Request) {
-		called++
-		w.WriteHeader(http.StatusOK)
-	}))
-
-	token, err := issuer.Issue("user-1", tenantSlug)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	req1 := httptest.NewRequest(http.MethodGet, "/api/v1/limited", nil)
-	req1.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
-	rec1 := httptest.NewRecorder()
-	srv.Handler().ServeHTTP(rec1, req1)
-	if rec1.Code != http.StatusOK {
-		t.Fatalf("1. anfrage: status = %d, want 200", rec1.Code)
-	}
-
-	req2 := httptest.NewRequest(http.MethodGet, "/api/v1/limited", nil)
-	req2.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
-	rec2 := httptest.NewRecorder()
-	srv.Handler().ServeHTTP(rec2, req2)
-	if rec2.Code != http.StatusTooManyRequests {
-		t.Fatalf("2. anfrage: status = %d, want 429", rec2.Code)
-	}
-	if rec2.Header().Get("Retry-After") == "" {
-		t.Fatal("erwartet gesetzten Retry-After-Header bei 429")
-	}
-	if called != 1 {
-		t.Fatalf("handler wurde %d mal aufgerufen, want genau 1 (2. anfrage haette nicht durchgereicht werden duerfen)", called)
-	}
-}
-
-// Akzeptanzkriterium 1: das Limit ist pro Tenant konfigurierbar — ein
-// anderer Tenant (anderer Key) bleibt von der Ausschoepfung unberuehrt.
-func TestMiddleware_DifferentTenantsHaveIndependentLimits(t *testing.T) {
-	srv, issuer, store, cleanup := setupMiddlewareTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	tenantA := newTestKey()
-	tenantB := newTestKey()
-	if err := store.SetLimit(ctx, tenantA, 1, time.Minute); err != nil {
-		t.Fatalf("setlimit a: %v", err)
-	}
-	if err := store.SetLimit(ctx, tenantB, 1, time.Minute); err != nil {
-		t.Fatalf("setlimit b: %v", err)
-	}
-
-	srv.HandleV1("/limited2", Middleware(store, KeyByTenant, func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	}))
-
-	tokenA, _ := issuer.Issue("user-a", tenantA)
-	tokenB, _ := issuer.Issue("user-b", tenantB)
-
-	// Tenant A schoepft sein Limit aus.
-	reqA := httptest.NewRequest(http.MethodGet, "/api/v1/limited2", nil)
-	reqA.AddCookie(&http.Cookie{Name: auth.CookieName, Value: tokenA})
-	recA := httptest.NewRecorder()
-	srv.Handler().ServeHTTP(recA, reqA)
-	if recA.Code != http.StatusOK {
-		t.Fatalf("tenant a, 1. anfrage: status = %d, want 200", recA.Code)
-	}
-
-	// Tenant B ist von der Ausschoepfung bei A unberuehrt.
-	reqB := httptest.NewRequest(http.MethodGet, "/api/v1/limited2", nil)
-	reqB.AddCookie(&http.Cookie{Name: auth.CookieName, Value: tokenB})
-	recB := httptest.NewRecorder()
-	srv.Handler().ServeHTTP(recB, reqB)
-	if recB.Code != http.StatusOK {
-		t.Fatalf("tenant b haette trotz ausgeschoepftem limit von tenant a erlaubt sein muessen, status = %d", recB.Code)
-	}
-}

internal/ratelimit/ratelimit.go

@@ -1,126 +0,0 @@
-// Package ratelimit implementiert Core API-03: eine zentrale Rate-Limiting-
-// Schicht fuer die gesamte Core-API mit GETEILTEM, EXTERNEM Zustand in
-// Postgres — kein In-Process-Zaehler (siehe "Bekannte Fehler vermeiden" im
-// Ticket: dasselbe Risiko wie bei IAM-07s In-Memory-Lockout). Fixed-Window-
-// Algorithmus: einfach, korrekt unter nebenlaeufigem Zugriff (atomares
-// UPSERT wie internal/usage.Store.Increment), und fuer ein API-Gateway
-// ausreichend praezise — kein Sliding-Window-Overhead noetig.
-package ratelimit
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// DefaultLimit/DefaultWindow gelten fuer jeden Schluessel (Tenant oder
-// API-Token), fuer den keine eigene Konfiguration existiert
-// (Akzeptanzkriterium 1: "konfigurierbar", nicht "verpflichtend konfiguriert").
-const (
-	DefaultLimit  = 100
-	DefaultWindow = time.Minute
-)
-
-// Config ist das je Schluessel konfigurierbare Limit.
-type Config struct {
-	Limit  int
-	Window time.Duration
-}
-
-// Store haelt Konfiguration UND Zaehlerstand in Postgres — beides ueber
-// dieselbe Verbindung erreichbar, damit mehrere Dienstinstanzen denselben
-// Zustand sehen (Akzeptanzkriterium 2).
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// SetLimit setzt die Konfiguration fuer EINEN Schluessel (z.B. einen
-// Tenant-Slug oder eine API-Token-ID) — wirkt sich nicht auf andere
-// Schluessel aus (Akzeptanzkriterium 1 / Pruefung 3).
-func (s *Store) SetLimit(ctx context.Context, key string, limit int, window time.Duration) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO rate_limit_configs (key, limit_value, window_seconds)
-		VALUES ($1, $2, $3)
-		ON CONFLICT (key) DO UPDATE SET limit_value = $2, window_seconds = $3
-	`, key, limit, int(window.Seconds()))
-	if err != nil {
-		return fmt.Errorf("rate-limit-konfiguration speichern: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) getConfig(ctx context.Context, key string) (Config, error) {
-	var limit, windowSeconds int
-	err := s.pool.QueryRow(ctx, `
-		SELECT limit_value, window_seconds FROM rate_limit_configs WHERE key = $1
-	`, key).Scan(&limit, &windowSeconds)
-	if err != nil {
-		if err == pgx.ErrNoRows {
-			return Config{Limit: DefaultLimit, Window: DefaultWindow}, nil
-		}
-		return Config{}, fmt.Errorf("rate-limit-konfiguration lesen: %w", err)
-	}
-	return Config{Limit: limit, Window: time.Duration(windowSeconds) * time.Second}, nil
-}
-
-// Result ist der Ausgang einer Allow-Pruefung (Akzeptanzkriterium 3).
-type Result struct {
-	Allowed    bool
-	Limit      int
-	Remaining  int
-	RetryAfter time.Duration
-}
-
-// Allow erhoeht den Zaehler fuer (key, aktuelles Zeitfenster) ATOMAR ueber
-// ein einziges UPSERT (dasselbe Muster wie internal/usage.Store.Increment)
-// und vergleicht das Ergebnis gegen die konfigurierte Grenze — kein
-// Lesen-Erhoehen-Schreiben in Go, damit zwei Dienstinstanzen, die
-// gleichzeitig gegen dieselbe Datenbank inkrementieren, sich niemals
-// gegenseitig ueberschreiben (Akzeptanzkriterium 2 / Pruefung 1).
-func (s *Store) Allow(ctx context.Context, key string) (Result, error) {
-	cfg, err := s.getConfig(ctx, key)
-	if err != nil {
-		return Result{}, err
-	}
-
-	windowSeconds := int64(cfg.Window.Seconds())
-	if windowSeconds <= 0 {
-		windowSeconds = int64(DefaultWindow.Seconds())
-	}
-	now := time.Now().UTC()
-	windowStart := time.Unix((now.Unix()/windowSeconds)*windowSeconds, 0).UTC()
-	windowEnd := windowStart.Add(time.Duration(windowSeconds) * time.Second)
-
-	var count int
-	err = s.pool.QueryRow(ctx, `
-		INSERT INTO rate_limit_counters (key, window_start, count)
-		VALUES ($1, $2, 1)
-		ON CONFLICT (key, window_start) DO UPDATE
-			SET count = rate_limit_counters.count + 1
-		RETURNING count
-	`, key, windowStart).Scan(&count)
-	if err != nil {
-		return Result{}, fmt.Errorf("rate-limit-zaehler erhoehen: %w", err)
-	}
-
-	remaining := cfg.Limit - count
-	if remaining < 0 {
-		remaining = 0
-	}
-	if count > cfg.Limit {
-		return Result{
-			Allowed:    false,
-			Limit:      cfg.Limit,
-			Remaining:  0,
-			RetryAfter: windowEnd.Sub(now),
-		}, nil
-	}
-	return Result{Allowed: true, Limit: cfg.Limit, Remaining: remaining}, nil
-}

internal/ratelimit/ratelimit_test.go

@@ -1,168 +0,0 @@
-package ratelimit
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupTest(t *testing.T) (*pgxpool.Pool, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS rate_limit_configs (
-			key TEXT PRIMARY KEY, limit_value INT NOT NULL, window_seconds INT NOT NULL
-		);
-		CREATE TABLE IF NOT EXISTS rate_limit_counters (
-			key TEXT NOT NULL, window_start TIMESTAMPTZ NOT NULL, count INT NOT NULL DEFAULT 0,
-			PRIMARY KEY (key, window_start)
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return pool, cleanup
-}
-
-func newTestKey() string {
-	return fmt.Sprintf("test-key-%d", time.Now().UnixNano())
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Ueberschreitung des Limits wird
-// nachweislich erkannt.
-func TestAllow_RejectsAfterLimitExceeded(t *testing.T) {
-	pool, cleanup := setupTest(t)
-	defer cleanup()
-	store := NewStore(pool)
-	ctx := context.Background()
-	key := newTestKey()
-
-	if err := store.SetLimit(ctx, key, 3, time.Minute); err != nil {
-		t.Fatalf("setlimit: %v", err)
-	}
-
-	for i := 0; i < 3; i++ {
-		res, err := store.Allow(ctx, key)
-		if err != nil {
-			t.Fatalf("allow %d: %v", i, err)
-		}
-		if !res.Allowed {
-			t.Fatalf("anfrage %d haette erlaubt sein muessen, limit=3", i)
-		}
-	}
-
-	res, err := store.Allow(ctx, key)
-	if err != nil {
-		t.Fatalf("allow (4.): %v", err)
-	}
-	if res.Allowed {
-		t.Fatal("4. anfrage haette abgelehnt werden muessen (limit=3)")
-	}
-	if res.RetryAfter <= 0 {
-		t.Fatalf("erwartet positive retry-after-dauer, habe %v", res.RetryAfter)
-	}
-}
-
-// Akzeptanzkriterium 1 / Pruefung 3: Konfigurationsaenderung wirkt sich
-// NICHT auf andere Schluessel (Tenants) aus.
-func TestSetLimit_DoesNotAffectOtherKeys(t *testing.T) {
-	pool, cleanup := setupTest(t)
-	defer cleanup()
-	store := NewStore(pool)
-	ctx := context.Background()
-	keyA := newTestKey()
-	keyB := newTestKey()
-
-	if err := store.SetLimit(ctx, keyA, 1, time.Minute); err != nil {
-		t.Fatalf("setlimit a: %v", err)
-	}
-
-	resA1, _ := store.Allow(ctx, keyA)
-	resA2, _ := store.Allow(ctx, keyA)
-	if !resA1.Allowed || resA2.Allowed {
-		t.Fatalf("key a: erwartet erlaubt,abgelehnt, habe %v,%v", resA1.Allowed, resA2.Allowed)
-	}
-
-	// keyB hat keine eigene Konfiguration -> DefaultLimit, unbeeinflusst von keyA.
-	resB, err := store.Allow(ctx, keyB)
-	if err != nil {
-		t.Fatalf("allow b: %v", err)
-	}
-	if !resB.Allowed {
-		t.Fatal("key b haette trotz limit-ueberschreitung bei key a erlaubt sein muessen")
-	}
-	if resB.Limit != DefaultLimit {
-		t.Fatalf("key b limit = %d, want default %d", resB.Limit, DefaultLimit)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: zwei "Dienstinstanzen" (zwei
-// unabhaengige Pools/Store-Objekte) gegen dieselbe Datenbank setzen
-// dasselbe Limit korrekt durch — kein In-Process-Zustand kann das leisten.
-func TestAllow_TwoInstancesShareStateCorrectly(t *testing.T) {
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	pool, cleanup := setupTest(t)
-	defer cleanup()
-
-	ctx := context.Background()
-	pool2, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("zweiter pool (simuliert zweite instanz): %v", err)
-	}
-	defer pool2.Close()
-
-	storeInstance1 := NewStore(pool)
-	storeInstance2 := NewStore(pool2)
-
-	key := newTestKey()
-	const limit = 20
-	if err := storeInstance1.SetLimit(ctx, key, limit, time.Minute); err != nil {
-		t.Fatalf("setlimit: %v", err)
-	}
-
-	const totalRequests = 50
-	var allowedCount int64
-	var wg sync.WaitGroup
-	for i := 0; i < totalRequests; i++ {
-		wg.Add(1)
-		store := storeInstance1
-		if i%2 == 0 {
-			store = storeInstance2 // Haelfte der Anfragen "kommt" von der zweiten Instanz
-		}
-		go func(s *Store) {
-			defer wg.Done()
-			res, err := s.Allow(ctx, key)
-			if err != nil {
-				t.Errorf("allow: %v", err)
-				return
-			}
-			if res.Allowed {
-				atomic.AddInt64(&allowedCount, 1)
-			}
-		}(store)
-	}
-	wg.Wait()
-
-	if allowedCount != limit {
-		t.Fatalf("erlaubte anfragen ueber beide instanzen = %d, want exakt %d (geteilter zustand)", allowedCount, limit)
-	}
-}

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

migrations/0003_rate_limits.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE rate_limit_counters;
-DROP TABLE rate_limit_configs;

migrations/0003_rate_limits.up.sql

@@ -1,15 +0,0 @@
--- Rate-Limiting mit geteiltem, externem Zustand (API-03, siehe
--- core-kanban/tickets/API-03.md) — bewusst NICHT In-Process, damit mehrere
--- Dienstinstanzen dasselbe Limit korrekt durchsetzen.
-CREATE TABLE rate_limit_configs (
-    key            TEXT PRIMARY KEY,
-    limit_value    INT NOT NULL,
-    window_seconds INT NOT NULL
-);
-
-CREATE TABLE rate_limit_counters (
-    key          TEXT NOT NULL,
-    window_start TIMESTAMPTZ NOT NULL,
-    count        INT NOT NULL DEFAULT 0,
-    PRIMARY KEY (key, window_start)
-);

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

scripts/reset-test-env.sh

@@ -1,16 +1,11 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
-
 export PGPASSWORD="$PASS"
-
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
-
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
-
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."

scripts/run-checks.sh

@@ -1,18 +1,12 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
-
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
-
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
-
 echo "== go build =="
 go build ./...
-
 echo "== go vet =="
 go vet ./...
-
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1