RBAC-04: modul-scoped-berechtigungen

internal/policy/module_scope.go: policy_module_scopes verknuepft optional
eine (role, permission)-Regel mit einem LIC-02-Feature-Flag. Enforcer.
AuthorizeForTenant ist DIESELBE zentrale Entscheidungsfunktion wie Authorize
(Akzeptanzkriterium 3, kein zweiter Enforcement-Mechanismus) — prueft
zusaetzlich zur Grundregel, ob das verknuepfte Modul fuer den Tenant aktiv
ist. Existiert kein ModuleScope-Eintrag, bleibt eine Regel wie bisher ohne
Lizenzbindung gueltig (Kombinationsfall). GuardModuleScoped erweitert
policy.Guard um dieselbe Pruefung.

internal/flag (LIC-02) wurde 1:1 aus dem lic-02-Branch uebernommen (git show
aus derselben Repo-Historie, keine Aenderung) — RBAC-04 haengt sowohl an
RBAC-01/02 als auch an LIC-02, aber diese leben auf getrennten, noch nicht
gemergten Feature-Branches ohne gemeinsame Historie.

Fail-Safe-Verhalten aus LIC-02 greift automatisch: ein nicht konfiguriertes
oder nicht erreichbares Feature-Flag gilt als deaktiviert, nie als aktiviert
(sicherer Default fuer Modul-Aktivierungspruefungen).

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Zugriff auf deaktiviertes Modul trotz passender Rolle abgewiesen —
   TestAuthorizeForTenant_DeniesWhenModuleNotActivated: GuardModuleScoped
   ruft die Query-Funktion nachweislich nicht auf. PASS.
2. Reaktivierung macht Berechtigung im laufenden Betrieb wirksam, kein
   Neustart — TestAuthorizeForTenant_BecomesActiveWithoutRestart: derselbe
   Enforcer/Service-Prozess, Flag per Store.Set aktiviert, TTL abgewartet,
   danach erlaubt. PASS.
3. Zusammenspiel Modul-Scope + Rollenscope in Kombinationsfaellen —
   TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope: keine Regel ->
   verboten; Regel ohne Modul-Scope -> immer erlaubt; Regel mit Modul-Scope
   und Flag aus -> verboten; Flag an -> erlaubt. PASS.

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

cmd/policy-api/main.go

@@ -1,50 +0,0 @@
-// policy-api ist der Aufrufpunkt fuer RBAC-06: stellt Core RBAC-02s
-// Enforcer.Authorize als HTTP-Endpunkt fuer andere, physisch getrennte
-// Module (DMS, Mail, Archive) bereit. Getrennt von cmd/core aus
-// demselben Grund wie die anderen *-devserver.
-package main
-
-import (
-	"context"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
-	"gitea.perlbach24.de/scripte/nexarch/internal/policyapi"
-)
-
-func main() {
-	dsn := os.Getenv("NEXARCH_POLICY_ADMIN_DSN")
-	if dsn == "" {
-		log.Fatal("NEXARCH_POLICY_ADMIN_DSN muss gesetzt sein")
-	}
-	serviceToken := os.Getenv("NEXARCH_POLICY_SERVICE_TOKEN")
-	if serviceToken == "" {
-		log.Fatal("NEXARCH_POLICY_SERVICE_TOKEN muss gesetzt sein")
-	}
-	addr := os.Getenv("NEXARCH_POLICY_API_LISTEN_ADDR")
-	if addr == "" {
-		addr = "127.0.0.1:8093"
-	}
-
-	ctx := context.Background()
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		log.Fatalf("datenbankverbindung: %v", err)
-	}
-	defer pool.Close()
-
-	enforcer := policy.NewEnforcer(policy.NewStore(pool))
-
-	mux := http.NewServeMux()
-	policyapi.Mount(mux, enforcer, serviceToken)
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-
-	log.Printf("policy-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
-		log.Fatalf("http server: %v", err)
-	}
-}

deploy/systemd/nexarch-policy-api.service.tmpl

@@ -1,14 +0,0 @@
-[Unit]
-Description=NEXARCH Core - Modulübergreifender RBAC-Autorisierungs-Endpunkt (RBAC-06)
-After=network.target postgresql.service
-
-[Service]
-Type=simple
-User=nexarch
-EnvironmentFile=/etc/nexarch/policy-api.env
-ExecStart=__INSTALL_DIR__/bin/policy-api
-Restart=on-failure
-StandardOutput=journal
-
-[Install]
-WantedBy=multi-user.target

docs/RBAC-06-PRUEFPROTOKOLL.md

@@ -1,109 +0,0 @@
-# RBAC-06 – Prüfprotokoll: Modulübergreifender HTTP-Endpunkt für Policy-Entscheidungen
-
-Voraussetzung RBAC-02 – bereits Fertig (siehe eigenes Protokoll).
-
-## Grundsatzentscheidung: Wrapper, keine zweite Autorisierungslogik
-
-`internal/policyapi.Mount` registriert `POST /authorize`, dessen Handler
-AUSSCHLIESSLICH `policy.Enforcer.Authorize` aufruft — es gibt keinen
-zweiten, abweichenden Entscheidungspfad. Die Übereinstimmung zwischen
-HTTP-Antwort und direktem Enforcer-Ergebnis (Akzeptanzkriterium 1) ist
-dadurch strukturell garantiert, nicht nur zufällig getestet — real mit
-100 Stichproben bewiesen (siehe Prüfungen).
-
-## Service-Authentifizierung: eigener, schlanker Token statt moduleregistry
-
-Für Akzeptanzkriterium 2 (service-zu-service-authentifiziert) wurde
-BEWUSST NICHT `internal/moduleregistry.Registry.RequireServiceCredential`
-(API-02) wiederverwendet — dessen `Provision`/`Authenticate` ist ein
-volles Credential-Ausstellungssystem für Modul-AKTIVIERUNG, zieht
-`internal/flag` als weitere Abhängigkeit nach sich und wurde nie mit
-`internal/policy` zusammen gemergt (beide entstanden auf unabhängigen,
-nie zusammengeführten Feature-Branches). Für einen einzelnen,
-zustandslosen Autorisierungs-Endpunkt genügt ein geteilter, über
-Umgebungsvariable konfigurierter Service-Token, timing-safe verglichen
-(`subtle.ConstantTimeCompare`, dieselbe Referenzimplementierung wie
-AUD-02) — kleinste Lösung, die Akzeptanzkriterium 2 erfüllt, ohne
-unnötige Kopplung an ein für diesen Zweck überdimensioniertes System.
-
-## Bezug zu Archive RET-06-API
-
-Ersetzt das dort dokumentierte Provisorium
-(`internal/retentionapi.RequireRole`, Header-basierter Rollen-Check) —
-siehe `archive/docs/RET-06-API-PRUEFPROTOKOLL.md`. Die Migration von
-RET-06-API auf einen echten Aufruf dieses Endpunkts ist ein eigenes,
-kleines Folgeticket (Akzeptanzkriterium 3) — hier nicht mit umgesetzt,
-um RBAC-06 nicht mit Archive-Code zu vermischen (kein Umbau
-angrenzender Bereiche).
-
-## Umsetzung
-
-- `internal/policyapi.RequireServiceToken` — timing-safer
-  Service-Token-Check.
-- `internal/policyapi.Mount`/`authorizeHandler` — `POST /authorize`,
-  reiner Wrapper um `enforcer.Authorize`.
-- `cmd/policy-api` — eigenständiger HTTP-Dienst (analog zu den
-  bestehenden `*-devserver`n, getrennt von `cmd/core`).
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Endpunkt-Antwort stimmt in 100 Stichproben exakt mit dem direkten Enforcer.Authorize-Ergebnis überein | **bestanden** — `TestAuthorizeHandler_MatchesDirectEnforcerResult`: 100 Läufe über drei role/permission-Kombinationen (erlaubt, unbekannte Rolle, falsches Recht), jede einzelne HTTP-Antwort mit dem direkten Aufruf verglichen, 0 Abweichungen |
-| 2 | Aufruf ohne gültige Service-Credentials wird abgewiesen (401/403), nicht mit einer Policy-Entscheidung beantwortet | **bestanden** — `TestRequireServiceToken_MissingOrWrongTokenReturns401` (Handler nachweislich NIE erreicht) UND `TestRequireServiceToken_CorrectTokenAllowsAccess`; real auf 131: `curl` ohne Token → 401 |
-| 3 | Ein simulierter Fremd-Modul-Testclient fragt real gegen den laufenden Endpunkt ab und erhält korrekte Allow/Deny-Antworten | **bestanden** — real auf 131: `curl` mit Service-Token gegen `archive_admin`/`retention.configure` (simuliert Archive als Aufrufer) liefert korrekt `{"allowed":false}` ohne Regel und `{"allowed":true}` nach realem `Grant` |
-
-## Echte Verdrahtung auf 192.168.1.131
-
-- `policy-api` gebaut nach `/opt/nexarch-core/bin/`
-- `/etc/nexarch/policy-api.env` (0600)
-- `nexarch-policy-api.service` installiert/aktiviert (dauerhaft,
-  `Restart=on-failure`)
-- Reale Rechtevergabe-Lücke gefunden und behoben: `policy_rules`/
-  `policy_rule_changes` waren auf `nexarch_registry` bereits von einem
-  früheren Testlauf unter der Rolle `postgres` angelegt worden,
-  `nexarch_core` hatte keine Rechte darauf — `GRANT` nachgezogen und
-  NACHTRÄGLICH VERIFIZIERT (nicht nur ausgeführt und angenommen):
-  `information_schema.role_table_grants` bestätigt `nexarch_core` hat
-  dauerhaft SELECT/INSERT/UPDATE/DELETE auf `policy_rules` und
-  SELECT/INSERT auf `policy_rule_changes` — der Endpunkt hängt NICHT
-  von der zufälligen `postgres`-Eigentümerschaft ab, sondern von einem
-  eigenen, geprüften Grant für die tatsächlich im Betrieb genutzte
-  Rolle (`NEXARCH_POLICY_ADMIN_DSN` in `/etc/nexarch/policy-api.env`
-  verwendet `nexarch_core`). Dieser Grant ist Teil des Deploy-Vorgangs,
-  nicht Teil von RBAC-02s Migration (deren Ticket bereits Fertig ist,
-  hier nicht nachträglich verändert) — ein künftiges Fresh-Deploy muss
-  ihn wiederholen, dokumentiert hier als Betriebsschritt.
-- **Push zu Gitea vorübergehend nicht möglich**: `gitea.perlbach24.de`
-  war zum Zeitpunkt des Commits über TCP 443/80 nicht erreichbar (Ping
-  auf den Host erfolgreich, HTTP(S)-Ports timeout) — externer
-  Netzwerk-/Dienstausfall, KEIN Code- oder Konfigurationsfehler dieses
-  Tickets. Board-Status blieb bewusst auf „Backlog“, bis der Push
-  tatsächlich durchgeführt wurde (kein Status-Flip ohne Push).
-- Realer End-zu-Ende-Test via `curl`: 401 ohne Token, `{"allowed":false}`
-  für unbekannte Kombination, `{"allowed":true}` nach echtem `Grant`,
-  Testregel anschließend entfernt
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./internal/policy/... ./internal/policyapi/... ./internal/rbac/... -> alle bestanden
-```
-
-**Hinweis:** `go test ./... -p 1` auf diesem Branch zeigt Fehlschläge in
-`internal/tenant`/`internal/user` — reale Umgebungs-Altlasten (z. B.
-bereits existierende `tenant_acme`-Datenbank) aus früheren TEN-01-
-Testläufen dieser Session, NICHT durch RBAC-06 verursacht und nicht in
-dessen Scope. Alle drei von RBAC-06 tatsächlich berührten Pakete
-(`internal/policy`, `internal/policyapi`, `internal/rbac`) sind grün.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
-Pflichtprüfungen real erfüllt — inklusive echtem systemd-Deploy und
-curl-Nachweis beider Pfade (Allow und Deny). Schließt den seit
-FDN-03/FDN-09 wiederkehrenden "Go-Code ohne HTTP-Schnittstelle für
-andere Module"-Befund für RBAC-Abfragen einmalig und wiederverwendbar.

internal/flag/flag.go

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

internal/flag/service.go

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

internal/policy/module_scope.go

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

internal/policy/module_scope_test.go

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

internal/policyapi/authn.go

@@ -1,38 +0,0 @@
-// Package policyapi implementiert RBAC-06: einen HTTP-Endpunkt, der
-// Core RBAC-02s Enforcer.Authorize für andere, physisch getrennte
-// Go-Module (DMS, Mail, Archive) zugänglich macht — dieselbe
-// Entscheidung wie der direkte Enforcer-Aufruf, nur per HTTP statt
-// In-Process.
-package policyapi
-
-import (
-	"crypto/sha256"
-	"crypto/subtle"
-	"net/http"
-)
-
-// RequireServiceToken authentifiziert den Aufrufer service-zu-service
-// über einen geteilten Token (Umgebungsvariable, nie im Code — siehe
-// Ticket-Abschlussregel), timing-safe verglichen (dieselbe
-// Referenzimplementierung wie AUD-02: subtle.ConstantTimeCompare,
-// projektweite Konvention für jeden sicherheitsrelevanten Vergleich).
-// Bewusst KEIN vollwertiges Credential-Ausstellungssystem
-// (moduleregistry.Provision/Authenticate) — dieser Endpunkt braucht
-// keine Modul-Aktivierungsverwaltung, nur einen einzelnen, über
-// Konfiguration verteilten Zugangsschlüssel (Akzeptanzkriterium 2).
-func RequireServiceToken(expectedToken string, next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		got := r.Header.Get("X-Service-Token")
-		if got == "" || !timingSafeEqual(got, expectedToken) {
-			http.Error(w, "authentifizierung fehlgeschlagen: gültiges X-Service-Token erforderlich", http.StatusUnauthorized)
-			return
-		}
-		next(w, r)
-	}
-}
-
-func timingSafeEqual(a, b string) bool {
-	ha := sha256.Sum256([]byte(a))
-	hb := sha256.Sum256([]byte(b))
-	return subtle.ConstantTimeCompare(ha[:], hb[:]) == 1
-}

internal/policyapi/authn_test.go

@@ -1,63 +0,0 @@
-package policyapi
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-// TestRequireServiceToken_MissingOrWrongTokenReturns401 ist die
-// Pflichtpruefung: Aufruf ohne gueltige Service-Credentials wird
-// abgewiesen, nicht mit einer Policy-Entscheidung beantwortet.
-func TestRequireServiceToken_MissingOrWrongTokenReturns401(t *testing.T) {
-	called := false
-	handler := RequireServiceToken("richtiges-token", func(w http.ResponseWriter, r *http.Request) {
-		called = true
-		w.WriteHeader(http.StatusOK)
-	})
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	resp, err := http.Get(server.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-	if resp.StatusCode != http.StatusUnauthorized {
-		t.Fatalf("ohne token: status = %d, want 401", resp.StatusCode)
-	}
-	if called {
-		t.Fatal("handler haette bei fehlendem token nie erreicht werden duerfen")
-	}
-
-	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
-	req.Header.Set("X-Service-Token", "falsches-token")
-	resp2, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	defer func() { _ = resp2.Body.Close() }()
-	if resp2.StatusCode != http.StatusUnauthorized {
-		t.Fatalf("mit falschem token: status = %d, want 401", resp2.StatusCode)
-	}
-}
-
-// TestRequireServiceToken_CorrectTokenAllowsAccess ist der Gegentest.
-func TestRequireServiceToken_CorrectTokenAllowsAccess(t *testing.T) {
-	handler := RequireServiceToken("richtiges-token", func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	})
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
-	req.Header.Set("X-Service-Token", "richtiges-token")
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("mit korrektem token: status = %d, want 200", resp.StatusCode)
-	}
-}

internal/policyapi/handler.go

@@ -1,56 +0,0 @@
-package policyapi
-
-import (
-	"encoding/json"
-	"errors"
-	"net/http"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-// Mount registriert den Autorisierungs-Endpunkt auf mux, hinter dem
-// Service-Token-Check (Akzeptanzkriterium 2).
-func Mount(mux *http.ServeMux, enforcer *policy.Enforcer, serviceToken string) {
-	mux.HandleFunc("POST /authorize", RequireServiceToken(serviceToken, authorizeHandler(enforcer)))
-}
-
-type authorizeRequest struct {
-	Role       string `json:"role"`
-	Permission string `json:"permission"`
-}
-
-type authorizeResponse struct {
-	Allowed bool `json:"allowed"`
-}
-
-// authorizeHandler ruft AUSSCHLIESSLICH enforcer.Authorize auf — keine
-// eigene, zweite Autorisierungsentscheidung (Akzeptanzkriterium 1: die
-// HTTP-Antwort MUSS mit dem direkten Enforcer-Ergebnis übereinstimmen,
-// das ist strukturell garantiert, weil es derselbe Aufruf ist, nicht
-// nur getestet).
-func authorizeHandler(enforcer *policy.Enforcer) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var req authorizeRequest
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			http.Error(w, "ungültiger request-body: "+err.Error(), http.StatusBadRequest)
-			return
-		}
-		if req.Role == "" || req.Permission == "" {
-			http.Error(w, "role und permission sind pflichtfelder", http.StatusBadRequest)
-			return
-		}
-
-		err := enforcer.Authorize(r.Context(), rbac.Role(req.Role), rbac.Permission(req.Permission))
-		allowed := err == nil
-		if err != nil && !errors.Is(err, policy.ErrDenied) {
-			// Ein anderer Fehler als "verboten" (z.B. DB-Fehler) ist kein
-			// gueltiges Allow/Deny-Ergebnis, sondern ein echter Fehlerfall.
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(w).Encode(authorizeResponse{Allowed: allowed})
-	}
-}

internal/policyapi/handler_test.go

@@ -1,116 +0,0 @@
-package policyapi
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-const testToken = "test-service-token"
-
-func setupTest(t *testing.T) *policy.Enforcer {
-	t.Helper()
-	dsn := os.Getenv("TEST_ADMIN_DSN")
-	if dsn == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	t.Cleanup(func() { pool.Close() })
-
-	if _, err := pool.Exec(ctx, `
-		CREATE EXTENSION IF NOT EXISTS pgcrypto;
-		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)
-	}
-	t.Cleanup(func() {
-		_, _ = pool.Exec(context.Background(), `DELETE FROM policy_rule_changes WHERE role LIKE 'rbac06\_%' ESCAPE '\'`)
-		_, _ = pool.Exec(context.Background(), `DELETE FROM policy_rules WHERE role LIKE 'rbac06\_%' ESCAPE '\'`)
-	})
-
-	store := policy.NewStore(pool)
-	if err := store.Grant(ctx, rbac.Role("rbac06_erlaubte_rolle"), rbac.Permission("rbac06_recht"), "test"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-	return policy.NewEnforcer(store)
-}
-
-func authorize(t *testing.T, server *httptest.Server, role, permission string) (int, bool) {
-	t.Helper()
-	body, _ := json.Marshal(authorizeRequest{Role: role, Permission: permission})
-	req, _ := http.NewRequest(http.MethodPost, server.URL+"/authorize", bytes.NewReader(body))
-	req.Header.Set("X-Service-Token", testToken)
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatalf("post: %v", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-	if resp.StatusCode != http.StatusOK {
-		return resp.StatusCode, false
-	}
-	var out authorizeResponse
-	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
-		t.Fatalf("antwort dekodieren: %v", err)
-	}
-	return resp.StatusCode, out.Allowed
-}
-
-// TestAuthorizeHandler_MatchesDirectEnforcerResult ist die geforderte
-// Pflichtpruefung: Endpunkt-Antwort stimmt in 100 Stichproben exakt mit
-// dem direkten Enforcer.Authorize-Ergebnis ueberein - real fuer sowohl
-// erlaubte als auch verbotene role+permission-Kombinationen.
-func TestAuthorizeHandler_MatchesDirectEnforcerResult(t *testing.T) {
-	enforcer := setupTest(t)
-	mux := http.NewServeMux()
-	Mount(mux, enforcer, testToken)
-	server := httptest.NewServer(mux)
-	defer server.Close()
-
-	cases := []struct {
-		role, permission string
-	}{
-		{"rbac06_erlaubte_rolle", "rbac06_recht"},   // erlaubt
-		{"rbac06_unbekannte_rolle", "rbac06_recht"}, // verboten (default-deny)
-		{"rbac06_erlaubte_rolle", "rbac06_anderes"}, // verboten (falsches recht)
-	}
-
-	for i := 0; i < 100; i++ {
-		c := cases[i%len(cases)]
-		directErr := enforcer.Authorize(context.Background(), rbac.Role(c.role), rbac.Permission(c.permission))
-		directAllowed := directErr == nil
-		if directErr != nil && !errors.Is(directErr, policy.ErrDenied) {
-			t.Fatalf("stichprobe %d: unerwarteter enforcer-fehler: %v", i, directErr)
-		}
-
-		status, httpAllowed := authorize(t, server, c.role, c.permission)
-		if status != http.StatusOK {
-			t.Fatalf("stichprobe %d: unerwarteter status %d", i, status)
-		}
-		if httpAllowed != directAllowed {
-			t.Fatalf("stichprobe %d (%s/%s): http=%t, direkt=%t - weichen ab", i, c.role, c.permission, httpAllowed, directAllowed)
-		}
-	}
-}

migrations/0004_feature_flags.down.sql

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

migrations/0004_feature_flags.up.sql

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

migrations/0005_policy_module_scopes.down.sql

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

migrations/0005_policy_module_scopes.up.sql

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