RBAC-02: policy-enforcement-schicht-zentral

internal/policy: deklarativer, DB-gehaltener Regelsatz (policy_rules) statt
hartcodierter Go-Entscheidungslogik — Store.IsAllowed schaut ausschliesslich
in die Datenbank, kein Go-Fallback. Ein Regelwechsel (Grant/Revoke) wirkt
sich sofort aus, ohne Codeaenderung/Deploy (Akzeptanzkriterium 3). Jede
Aenderung wird atomar mit einem versionierten Historieneintrag in
policy_rule_changes festgehalten (grant/revoke, Akteur, Version).

Enforcer.Authorize ist Default-Deny: existiert keine Regel fuer role+
permission, ist der Zugriff verboten (Akzeptanzkriterium 2), fuer sich
genommen ohne Anwendungslogik testbar.

Guard/GuardTenantScoped sind die zentrale Enforcement-Funktion
(Akzeptanzkriterium 1): die uebergebene Query-Funktion wird NUR bei
erfolgreicher Autorisierung aufgerufen — es gibt keinen Weg, Daten ohne
vorherige Authorize-Entscheidung zu erhalten. GuardTenantScoped erzwingt
zusaetzlich per Funktionssignatur, dass tenantSlug TEIL der Query-Funktion
ist (Akzeptanzkriterium 3) — ein nachgelagerter Post-Filter (der
archivmail-Fehler aus "Bekannte Fehler vermeiden": Tenant-Filter nach statt
in der Query) ist mit dieser Signatur strukturell nicht moeglich, da die
Repository-Implementierung tenantSlug selbst fuer ihre eigene WHERE-Klausel
entgegennimmt.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Kein Datenzugriffs-Pfad umgeht die zentrale Enforcement-Schicht —
   TestGuard_NeverCallsQueryWithoutAuthorization: query-Funktion wird
   nachweislich NICHT aufgerufen ohne vorherige Regel, erst nach Grant. PASS.
2. Anfrage ohne passende Policy wird zuverlaessig abgewiesen (Default-Deny) —
   TestAuthorize_DefaultDeny: keine Regel konfiguriert -> ErrDenied, nicht
   automatisch erlaubt. PASS.
3. Policy-Regelsatz versioniert, Regelwechsel ohne Codeaenderung
   nachvollziehbar — TestGrantRevoke_ChangesBehaviorWithoutCodeChange:
   Verhalten aendert sich durch reinen Datenbank-Grant/Revoke, Historie
   zeigt beide Versionen korrekt. PASS.

Zusaetzlich: TestGuardTenantScoped_IsolatesDataBetweenTenants belegt das
Tenant-Scoping-Muster aus Akzeptanzkriterium 3 konkret anhand zweier
Tenants. PASS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

internal/policy/enforcer.go

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

internal/policy/policy_test.go

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

internal/policy/store.go

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

internal/rbac/group.go

@@ -1,159 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrGroupNotFound = errors.New("rbac: gruppe nicht gefunden")
-
-type Group struct {
-	ID   string
-	Name string
-	Role Role // leer, wenn der Gruppe noch keine Rolle zugewiesen wurde
-}
-
-// GroupStore verwaltet Gruppen/Abteilungen innerhalb GENAU EINER Tenant-
-// Datenbank (Modell C, wie Store fuer direkte Rollenzuweisungen) —
-// Akzeptanzkriterium 3 (tenant-isoliert) ist damit strukturell erfuellt.
-type GroupStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewGroupStore(pool *pgxpool.Pool) *GroupStore {
-	return &GroupStore{pool: pool}
-}
-
-// CreateGroup legt eine neue, noch rollenlose Gruppe an (Akzeptanzkriterium 1).
-func (s *GroupStore) CreateGroup(ctx context.Context, name string) (Group, error) {
-	if name == "" {
-		return Group{}, errors.New("rbac: gruppenname darf nicht leer sein")
-	}
-	var g Group
-	g.Name = name
-	if err := s.pool.QueryRow(ctx, `
-		INSERT INTO groups (name) VALUES ($1) RETURNING id
-	`, name).Scan(&g.ID); err != nil {
-		return Group{}, fmt.Errorf("gruppe anlegen: %w", err)
-	}
-	return g, nil
-}
-
-// SetGroupRole weist der Gruppe eine Rolle zu (Akzeptanzkriterium 2) — nur
-// 'user'/'tenant_admin' sind auf Gruppenebene zuweisbar, dieselbe erlaubte
-// Matrix wie in Store.Assign (superadmin bleibt mandantenuebergreifend und
-// ausserhalb jeder Gruppenlogik).
-func (s *GroupStore) SetGroupRole(ctx context.Context, groupID string, role Role) error {
-	if !assignableRoles[role] {
-		return ErrRoleNotAssignableInTenantScope
-	}
-	tag, err := s.pool.Exec(ctx, `UPDATE groups SET role = $2 WHERE id = $1`, groupID, string(role))
-	if err != nil {
-		return fmt.Errorf("gruppenrolle setzen: %w", err)
-	}
-	if tag.RowsAffected() == 0 {
-		return ErrGroupNotFound
-	}
-	return nil
-}
-
-// AddMember nimmt einen Benutzer in die Gruppe auf.
-func (s *GroupStore) AddMember(ctx context.Context, groupID, userID string) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
-		ON CONFLICT (group_id, user_id) DO NOTHING
-	`, groupID, userID)
-	if err != nil {
-		return fmt.Errorf("mitglied hinzufuegen: %w", err)
-	}
-	return nil
-}
-
-// RemoveMember entfernt einen Benutzer aus der Gruppe — die gruppenbasierten
-// Rechte entfallen fuer ihn sofort (Akzeptanzkriterium 3 / Pruefung 2), da
-// EffectivePermissionsForUser bei jedem Aufruf neu berechnet wird, nicht
-// zwischengespeichert.
-func (s *GroupStore) RemoveMember(ctx context.Context, groupID, userID string) error {
-	_, err := s.pool.Exec(ctx, `DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`, groupID, userID)
-	if err != nil {
-		return fmt.Errorf("mitglied entfernen: %w", err)
-	}
-	return nil
-}
-
-// DeleteGroup loescht die Gruppe — ON DELETE CASCADE entfernt die
-// Mitgliedschaften mit, Benutzerkonten selbst bleiben unberuehrt
-// (Akzeptanzkriterium 3).
-func (s *GroupStore) DeleteGroup(ctx context.Context, groupID string) error {
-	_, err := s.pool.Exec(ctx, `DELETE FROM groups WHERE id = $1`, groupID)
-	if err != nil {
-		return fmt.Errorf("gruppe loeschen: %w", err)
-	}
-	return nil
-}
-
-// RolesForUser liefert alle Rollen, die einem Benutzer ueber seine
-// Gruppenmitgliedschaften zufallen (Akzeptanzkriterium 2: wirkt auf alle
-// Mitglieder). Eine Gruppe ohne zugewiesene Rolle traegt nichts bei.
-func (s *GroupStore) RolesForUser(ctx context.Context, userID string) ([]Role, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT g.role FROM groups g
-		JOIN group_members gm ON gm.group_id = g.id
-		WHERE gm.user_id = $1 AND g.role IS NOT NULL
-	`, userID)
-	if err != nil {
-		return nil, fmt.Errorf("gruppenrollen abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Role
-	for rows.Next() {
-		var r string
-		if err := rows.Scan(&r); err != nil {
-			return nil, fmt.Errorf("gruppenrolle lesen: %w", err)
-		}
-		out = append(out, Role(r))
-	}
-	return out, rows.Err()
-}
-
-// EffectivePermissionsForUser vereinigt die Rechte aus der direkten
-// Rollenzuweisung (Store, RBAC-01) mit allen Rechten aus Gruppenrollen —
-// jede einzelne Rolle wird ueber die bestehende Hierarchie (EffectivePermissions)
-// aufgeloest, das Ergebnis dedupliziert.
-func (s *GroupStore) EffectivePermissionsForUser(ctx context.Context, directStore *Store, userID string) ([]Permission, error) {
-	seen := make(map[Permission]bool)
-	var out []Permission
-
-	add := func(role Role) {
-		for _, p := range EffectivePermissions(role) {
-			if !seen[p] {
-				seen[p] = true
-				out = append(out, p)
-			}
-		}
-	}
-
-	if directStore != nil {
-		assignment, err := directStore.Get(ctx, userID)
-		if err != nil && !errors.Is(err, ErrNotFound) {
-			return nil, err
-		}
-		if err == nil {
-			add(assignment.Role)
-		}
-	}
-
-	groupRoles, err := s.RolesForUser(ctx, userID)
-	if err != nil {
-		return nil, err
-	}
-	for _, r := range groupRoles {
-		add(r)
-	}
-
-	return out, nil
-}

internal/rbac/group_test.go

@@ -1,209 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-const groupSchema = `
-CREATE TABLE IF NOT EXISTS users (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE IF NOT EXISTS role_assignments (
-	user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
-	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE IF NOT EXISTS groups (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, role TEXT CHECK (role IN ('user','tenant_admin')),
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE IF NOT EXISTS group_members (
-	group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, user_id UUID NOT NULL REFERENCES users(id),
-	added_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (group_id, user_id)
-);`
-
-func setupGroupTestDB(t *testing.T, dbName string) *pgxpool.Pool {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	adminPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("admin pool: %v", err)
-	}
-	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
-		t.Fatalf("testdatenbank anlegen: %v", err)
-	}
-
-	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("connect testdatenbank: %v", err)
-	}
-	if _, err := pool.Exec(ctx, groupSchema); err != nil {
-		t.Fatalf("schema anwenden: %v", err)
-	}
-
-	t.Cleanup(func() {
-		pool.Close()
-		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-		adminPool.Close()
-	})
-	return pool
-}
-
-func createTestUser(t *testing.T, pool *pgxpool.Pool, email string) string {
-	t.Helper()
-	u, err := user.NewTenantUserStore(pool).Create(context.Background(), email, "Test")
-	if err != nil {
-		t.Fatalf("testuser anlegen: %v", err)
-	}
-	return u.ID
-}
-
-// Akzeptanzkriterium 1: Gruppen anlegen und Benutzer zuordnen.
-func TestGroup_CreateAndAddMember(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_create")
-	gs := NewGroupStore(pool)
-	ctx := context.Background()
-
-	g, err := gs.CreateGroup(ctx, "Buchhaltung")
-	if err != nil {
-		t.Fatalf("create group: %v", err)
-	}
-	userID := createTestUser(t, pool, "alice@example.com")
-
-	if err := gs.AddMember(ctx, g.ID, userID); err != nil {
-		t.Fatalf("add member: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Gruppenrolle wirkt auf ALLE aktuellen
-// Mitglieder.
-func TestGroup_RoleAffectsAllCurrentMembers(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_roleall")
-	gs := NewGroupStore(pool)
-	ctx := context.Background()
-
-	g, err := gs.CreateGroup(ctx, "Admins")
-	if err != nil {
-		t.Fatalf("create group: %v", err)
-	}
-	if err := gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin); err != nil {
-		t.Fatalf("set group role: %v", err)
-	}
-
-	alice := createTestUser(t, pool, "alice@example.com")
-	bob := createTestUser(t, pool, "bob@example.com")
-	if err := gs.AddMember(ctx, g.ID, alice); err != nil {
-		t.Fatalf("add alice: %v", err)
-	}
-	if err := gs.AddMember(ctx, g.ID, bob); err != nil {
-		t.Fatalf("add bob: %v", err)
-	}
-
-	for _, uid := range []string{alice, bob} {
-		perms, err := gs.EffectivePermissionsForUser(ctx, nil, uid)
-		if err != nil {
-			t.Fatalf("effective permissions fuer %s: %v", uid, err)
-		}
-		if !contains(perms, PermManageUsers) {
-			t.Fatalf("mitglied %s sollte tenant_admin-rechte ueber die gruppe haben, habe %v", uid, perms)
-		}
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Entfernen aus der Gruppe entzieht die
-// gruppenbasierten Rechte sofort.
-func TestGroup_RemoveMemberRevokesRightsImmediately(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_remove")
-	gs := NewGroupStore(pool)
-	ctx := context.Background()
-
-	g, _ := gs.CreateGroup(ctx, "Admins")
-	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
-	userID := createTestUser(t, pool, "alice@example.com")
-	_ = gs.AddMember(ctx, g.ID, userID)
-
-	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
-	if err != nil {
-		t.Fatalf("effective permissions (mitglied): %v", err)
-	}
-	if !contains(perms, PermManageUsers) {
-		t.Fatal("erwartet tenant_admin-rechte als mitglied")
-	}
-
-	if err := gs.RemoveMember(ctx, g.ID, userID); err != nil {
-		t.Fatalf("remove member: %v", err)
-	}
-
-	perms, err = gs.EffectivePermissionsForUser(ctx, nil, userID)
-	if err != nil {
-		t.Fatalf("effective permissions (entfernt): %v", err)
-	}
-	if contains(perms, PermManageUsers) {
-		t.Fatal("erwartet KEINE tenant_admin-rechte nach entfernen aus der gruppe")
-	}
-}
-
-// Akzeptanzkriterium 3: Loeschen einer Gruppe entzieht Rechte sauber, ohne
-// das Benutzerkonto zu loeschen.
-func TestGroup_DeleteGroupRevokesRightsWithoutDeletingUser(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_delete")
-	gs := NewGroupStore(pool)
-	us := user.NewTenantUserStore(pool)
-	ctx := context.Background()
-
-	g, _ := gs.CreateGroup(ctx, "Temp")
-	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
-	userID := createTestUser(t, pool, "alice@example.com")
-	_ = gs.AddMember(ctx, g.ID, userID)
-
-	if err := gs.DeleteGroup(ctx, g.ID); err != nil {
-		t.Fatalf("delete group: %v", err)
-	}
-
-	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
-	if err != nil {
-		t.Fatalf("effective permissions: %v", err)
-	}
-	if contains(perms, PermManageUsers) {
-		t.Fatal("erwartet keine rechte mehr nach loeschen der gruppe")
-	}
-
-	if _, err := us.Get(ctx, userID); err != nil {
-		t.Fatalf("benutzerkonto haette erhalten bleiben muessen: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Gruppen sind sauber tenant-isoliert.
-func TestGroup_TenantIsolation(t *testing.T) {
-	poolA := setupGroupTestDB(t, "test_rbac03_tenanta")
-	poolB := setupGroupTestDB(t, "test_rbac03_tenantb")
-	gsA := NewGroupStore(poolA)
-	ctx := context.Background()
-
-	if _, err := gsA.CreateGroup(ctx, "Nur-Tenant-A"); err != nil {
-		t.Fatalf("create group a: %v", err)
-	}
-
-	var countB int
-	if err := poolB.QueryRow(ctx, `SELECT count(*) FROM groups`).Scan(&countB); err != nil {
-		t.Fatalf("count tenant b: %v", err)
-	}
-	if countB != 0 {
-		t.Fatalf("tenant b sollte keine gruppen aus tenant a sehen, habe %d", countB)
-	}
-}

migrations/0003_policy_rules.down.sql

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

migrations/0003_policy_rules.up.sql

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

migrations/tenant/0003_groups.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS group_members;
-DROP TABLE IF EXISTS groups;

migrations/tenant/0003_groups.up.sql

@@ -1,21 +0,0 @@
--- Gruppen/Abteilungen mit Rollenzuweisung auf Gruppenebene (RBAC-03, siehe
--- core-kanban/tickets/RBAC-03.md). Lebt in der Tenant-Datenbank (Modell C) —
--- Gruppen sind implizit tenant-isoliert, da jede Tenant-DB ihre eigenen hat.
-CREATE TABLE groups (
-    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    name       TEXT NOT NULL,
-    role       TEXT CHECK (role IN ('user', 'tenant_admin')),
-    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
--- ON DELETE CASCADE: Loeschen einer Gruppe entzieht die gruppenbasierten
--- Rechte automatisch, ohne Benutzerkonten selbst zu beruehren
--- (Akzeptanzkriterium 3).
-CREATE TABLE group_members (
-    group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
-    user_id  UUID NOT NULL REFERENCES users(id),
-    added_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (group_id, user_id)
-);
-
-CREATE INDEX group_members_user_idx ON group_members (user_id);