AUD-02: unveraenderliches-protokoll-append-only

Append-only per Trigger (nicht nur GRANT/REVOKE): audit_events_prevent_mutation()
wirft bei jedem UPDATE/DELETE auf audit_events eine Exception, unabhaengig
von der verbindenden Rolle (Akzeptanzkriterium 1).

internal/audit/four_eyes.go: Vier-Augen-Prinzip fuer sicherheitskritische
Entscheidungen (Loeschbestaetigung, Rechtevergabe), 1:1 nach archivdms-
Vorbild. Request erzeugt einen Klartext-Code (wird ausserhalb des Systems an
eine ZWEITE Person uebermittelt) und speichert nur dessen SHA-256-Hash.
Confirm sperrt die Zeile mit FOR UPDATE (Akzeptanzkriterium 2 — serialisiert
zwei gleichzeitige Bestaetigungsversuche, verhindert doppelte Ausfuehrung),
weist eine Bestaetigung durch dieselbe Person wie die anfordernde ab
(ErrSameActor, echtes Vier-Augen-Prinzip statt nur Code-Pruefung), und
vergleicht den Code timing-safe (Akzeptanzkriterium 3).

internal/audit/timingsafe.go: timingSafeEqual als projektweite Referenz-
implementierung (subtle.ConstantTimeCompare) fuer sicherheitsrelevante
Vergleiche — andere Module (z.B. Archive CMP-06 Freigabelinks) uebernehmen
dasselbe Muster laut IAM-02-Konvention.

Nebenbei behoben: AUD-01s eigener Test nutzte einen festen Tenant-Slug mit
DELETE-basiertem Cleanup — seit dem neuen Append-only-Trigger schlaegt dieses
Cleanup lautlos fehl, wodurch Zeilen sich ueber Testlaeufe hinweg summierten
und die Zaehl-Assertion brach. Auf eindeutigen Slug pro Lauf umgestellt
(direkte, notwendige Folge dieser Kachel, keine Umgestaltung von AUD-01
selbst).

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Direkter UPDATE/DELETE-Versuch von der Datenbank abgewiesen —
   TestAppendOnly_RejectsUpdateAndDelete: beide Operationen scheitern,
   Eintrag bleibt unveraendert erhalten. PASS.
2. Vier-Augen-Prinzip mit FOR-UPDATE-Lock race-frei unter parallelen
   Anfragen — TestFourEyes_ConcurrentConfirmIsRaceFree: zwei gleichzeitige
   Bestaetigungsversuche fuer denselben Vorgang, genau einer erfolgreich,
   der andere ErrAlreadyDecided. PASS.
3. Timing-safe Vergleich per Laufzeitmessung stichprobenartig verifiziert —
   TestTimingSafeEqual_NoEarlyExitTiming: Mismatch am Anfang (603µs) vs. am
   Ende (574µs) ueber 20000 Iterationen, kein Hinweis auf Short-Circuit-
   Vergleich (Ratio innerhalb Faktor 3 Toleranz). PASS.

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

cmd/core/main.go

@@ -8,7 +8,6 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 
 func main() {
@@ -35,20 +34,12 @@ func main() {
 	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
 	tenantHandler := tenant.NewHandler(provisioner)
 
-	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
-	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
-	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
-	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
-	superadmins := user.NewSuperadminStore(registryPool)
-	userHandler := user.NewHandler(nil, superadmins)
-
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
-	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
+	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
-	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)
 
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {

internal/audit/append_only_test.go

@@ -0,0 +1,97 @@
+package audit
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupAppendOnlyTest(t *testing.T) (*Log, *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 audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		);
+		CREATE OR REPLACE FUNCTION audit_events_prevent_mutation() RETURNS TRIGGER AS $$
+		BEGIN
+			RAISE EXCEPTION 'audit_events ist append-only: % ist nicht erlaubt', TG_OP;
+		END;
+		$$ LANGUAGE plpgsql;
+		DROP TRIGGER IF EXISTS audit_events_no_update ON audit_events;
+		CREATE TRIGGER audit_events_no_update
+			BEFORE UPDATE ON audit_events
+			FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();
+		DROP TRIGGER IF EXISTS audit_events_no_delete ON audit_events;
+		CREATE TRIGGER audit_events_no_delete
+			BEFORE DELETE ON audit_events
+			FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		pool.Close()
+	}
+	return NewLog(pool), pool, cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: direkter UPDATE/DELETE-Versuch wird von
+// der Datenbank abgewiesen.
+func TestAppendOnly_RejectsUpdateAndDelete(t *testing.T) {
+	log, pool, cleanup := setupAppendOnlyTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Append-only bedeutet: dieser Testeintrag kann NIE wieder geloescht
+	// werden, auch nicht vom Test selbst. Eindeutiger Tenant-Slug pro Lauf,
+	// damit wiederholte Testlaeufe sich nicht gegenseitig die Zaehlung
+	// verfaelschen.
+	tenantSlug := fmt.Sprintf("test_appendonly_%d", time.Now().UnixNano())
+
+	if err := log.Record(ctx, Event{
+		TenantSlug: tenantSlug,
+		Actor:      "alice",
+		Action:     "test.event",
+		Target:     "x",
+	}); err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	_, err := pool.Exec(ctx, `UPDATE audit_events SET actor = 'mallory' WHERE tenant_slug = $1`, tenantSlug)
+	if err == nil {
+		t.Fatal("erwartet fehler bei UPDATE auf audit_events, habe nil")
+	}
+
+	_, err = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug = $1`, tenantSlug)
+	if err == nil {
+		t.Fatal("erwartet fehler bei DELETE auf audit_events, habe nil")
+	}
+
+	count, err := log.CountByTenant(ctx, tenantSlug)
+	if err != nil {
+		t.Fatalf("count: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("eintrag haette trotz fehlgeschlagener update/delete-versuche erhalten bleiben muessen, count=%d", count)
+	}
+}

internal/audit/audit.go

@@ -0,0 +1,96 @@
+// Package audit implementiert Core AUD-01: das zentrale, vom allgemeinen
+// Anwendungs-Log getrennte Audit-Datenmodell fuer sicherheits- und
+// compliancerelevante Ereignisse (wer, was, wann, an welchem Tenant).
+// Unveraenderlichkeit (Append-only) ist AUD-02, Export/Filter-API ist AUD-03
+// — dieses Paket liefert nur das Datenmodell und den EINEN zentralen
+// Schreibpfad (Akzeptanzkriterium 3).
+package audit
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SystemTenant ist der reservierte Tenant-Bezug fuer mandantenuebergreifende
+// Ereignisse (z.B. Superadmin-Aktionen) — es gibt bewusst KEINEN Weg, ein
+// Ereignis ganz ohne Tenant-Bezug zu schreiben (Akzeptanzkriterium 2).
+const SystemTenant = "system"
+
+var ErrMissingTenant = errors.New("audit: tenant_slug darf nicht leer sein")
+var ErrMissingActor = errors.New("audit: actor darf nicht leer sein")
+var ErrMissingAction = errors.New("audit: action darf nicht leer sein")
+
+// Event ist ein strukturiertes Audit-Ereignis (Akzeptanzkriterium 1: Akteur,
+// Aktion, Zielobjekt, Zeitpunkt, Tenant).
+type Event struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	Target     string
+	Metadata   map[string]any
+	OccurredAt time.Time
+}
+
+// Log ist der EINE zentrale Schreibpfad fuer Audit-Ereignisse — es gibt
+// bewusst keine zweite Schreibmoeglichkeit, damit kein Handler versehentlich
+// direkt in audit_events schreibt und dabei die Validierung umgeht
+// (Akzeptanzkriterium 3).
+type Log struct {
+	pool *pgxpool.Pool
+}
+
+func NewLog(pool *pgxpool.Pool) *Log {
+	return &Log{pool: pool}
+}
+
+// Record persistiert genau einen Audit-Eintrag. Fehlender Tenant-Bezug wird
+// bereits hier abgewiesen (klarer Fehler statt Constraint-Verletzung im
+// Normalfall) — die Datenbank-CHECK-Constraint aus der Migration ist die
+// zweite, unumgehbare Verteidigungslinie (Akzeptanzkriterium 2 / Pruefung 2).
+func (l *Log) Record(ctx context.Context, e Event) error {
+	if e.TenantSlug == "" {
+		return ErrMissingTenant
+	}
+	if e.Actor == "" {
+		return ErrMissingActor
+	}
+	if e.Action == "" {
+		return ErrMissingAction
+	}
+	if e.Metadata == nil {
+		e.Metadata = map[string]any{}
+	}
+	metadataJSON, err := json.Marshal(e.Metadata)
+	if err != nil {
+		return fmt.Errorf("metadaten serialisieren: %w", err)
+	}
+	if e.OccurredAt.IsZero() {
+		e.OccurredAt = time.Now()
+	}
+
+	_, err = l.pool.Exec(ctx, `
+		INSERT INTO audit_events (occurred_at, tenant_slug, actor, action, target, metadata)
+		VALUES ($1, $2, $3, $4, $5, $6)
+	`, e.OccurredAt, e.TenantSlug, e.Actor, e.Action, e.Target, metadataJSON)
+	if err != nil {
+		return fmt.Errorf("audit-ereignis schreiben: %w", err)
+	}
+	return nil
+}
+
+// CountByTenant ist eine schlanke Lesehilfe fuer Tests/Diagnose — die
+// eigentliche Filter-/Export-API ist AUD-03, hier bewusst nicht vorgezogen.
+func (l *Log) CountByTenant(ctx context.Context, tenantSlug string) (int, error) {
+	var n int
+	if err := l.pool.QueryRow(ctx, `
+		SELECT count(*) FROM audit_events WHERE tenant_slug = $1
+	`, tenantSlug).Scan(&n); err != nil {
+		return 0, fmt.Errorf("audit-ereignisse zaehlen: %w", err)
+	}
+	return n, nil
+}

internal/audit/audit_test.go

@@ -0,0 +1,139 @@
+package audit
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupAuditTest(t *testing.T) (*Log, *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 audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug LIKE 'test\_%' ESCAPE '\' OR tenant_slug = $1`, SystemTenant)
+		pool.Close()
+	}
+	return NewLog(pool), pool, cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: ein sicherheitsrelevanter Vorgang
+// (hier: fehlgeschlagener Login) erzeugt zuverlaessig genau einen Eintrag.
+func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
+	log, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Seit AUD-02 ist audit_events append-only — Zeilen koennen nie wieder
+	// geloescht werden (auch nicht vom Test-Cleanup). Eindeutiger Slug pro
+	// Lauf, damit wiederholte Testlaeufe die Zaehlung nicht verfaelschen.
+	tenantSlug := "test_acme_" + fmt.Sprint(time.Now().UnixNano())
+
+	err := log.Record(ctx, Event{
+		TenantSlug: tenantSlug,
+		Actor:      "alice@example.com",
+		Action:     "iam.login_failed",
+		Target:     "user:alice@example.com",
+		Metadata:   map[string]any{"reason": "falsches passwort"},
+	})
+	if err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	count, err := log.CountByTenant(ctx, tenantSlug)
+	if err != nil {
+		t.Fatalf("count: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("erwartet genau 1 audit-eintrag, habe %d", count)
+	}
+
+	var actor, action, target string
+	if err := pool.QueryRow(ctx, `
+		SELECT actor, action, target FROM audit_events WHERE tenant_slug = $1
+	`, tenantSlug).Scan(&actor, &action, &target); err != nil {
+		t.Fatalf("eintrag lesen: %v", err)
+	}
+	if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
+		t.Fatalf("eintrag unerwartet: actor=%q action=%q target=%q", actor, action, target)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (App-Ebene): fehlender Tenant-Bezug wird
+// bereits vom zentralen Schreibpfad abgewiesen.
+func TestRecord_RejectsMissingTenant(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := log.Record(ctx, Event{TenantSlug: "", Actor: "alice", Action: "irgendwas"})
+	if !errors.Is(err, ErrMissingTenant) {
+		t.Fatalf("erwartet ErrMissingTenant, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (DB-Ebene): selbst ein direkter INSERT,
+// der Log.Record umgeht, wird durch die CHECK-Constraint verhindert — der
+// Schutz haengt nicht allein von der Go-Validierung ab.
+func TestConstraint_RejectsMissingTenantAtDatabaseLevel(t *testing.T) {
+	_, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	_, err := pool.Exec(ctx, `
+		INSERT INTO audit_events (tenant_slug, actor, action, target)
+		VALUES ('', 'alice', 'irgendwas', 'ziel')
+	`)
+	if err == nil {
+		t.Fatal("erwartet fehler durch CHECK-constraint bei leerem tenant_slug, habe nil")
+	}
+}
+
+func TestRecord_RejectsMissingActorAndAction(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "", Action: "x"}); !errors.Is(err, ErrMissingActor) {
+		t.Fatalf("erwartet ErrMissingActor, habe %v", err)
+	}
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "alice", Action: ""}); !errors.Is(err, ErrMissingAction) {
+		t.Fatalf("erwartet ErrMissingAction, habe %v", err)
+	}
+}
+
+func TestRecord_SystemTenantForCrossTenantEvents(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: SystemTenant, Actor: "superadmin", Action: "tenant.provisioned", Target: "tenant:acme"}); err != nil {
+		t.Fatalf("record mit SystemTenant: %v", err)
+	}
+}

internal/audit/four_eyes.go

@@ -0,0 +1,120 @@
+package audit
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	ErrConfirmationNotFound = errors.New("audit: bestaetigungsvorgang nicht gefunden")
+	ErrAlreadyDecided       = errors.New("audit: bestaetigungsvorgang wurde bereits entschieden")
+	ErrSameActor            = errors.New("audit: bestaetigung muss von einer anderen person als der anfordernden erfolgen")
+	ErrInvalidCode          = errors.New("audit: bestaetigungscode ungueltig")
+)
+
+type ConfirmationStatus string
+
+const (
+	StatusPending   ConfirmationStatus = "pending"
+	StatusConfirmed ConfirmationStatus = "confirmed"
+)
+
+// FourEyes implementiert das Vier-Augen-Prinzip fuer sicherheitskritische
+// Entscheidungen (Akzeptanzkriterium 2) nach dem archivdms-Vorbild:
+// FOR-UPDATE-Lock gegen Race-Bedingungen bei paralleler Bestaetigung,
+// Timing-safe Vergleich des Bestaetigungscodes (Akzeptanzkriterium 3).
+type FourEyes struct {
+	pool *pgxpool.Pool
+}
+
+func NewFourEyes(pool *pgxpool.Pool) *FourEyes {
+	return &FourEyes{pool: pool}
+}
+
+// Request legt einen neuen, zu bestaetigenden Vorgang an (z.B. Loeschbestaetigung,
+// Rechtevergabe) und liefert einen einmaligen Klartext-Code, der ausserhalb
+// dieses Systems (z.B. per E-Mail) an eine ZWEITE Person uebermittelt wird —
+// niemals der anfordernden Person selbst.
+func (f *FourEyes) Request(ctx context.Context, action, target, requestedBy string) (id, code string, err error) {
+	code, err = generateCode()
+	if err != nil {
+		return "", "", fmt.Errorf("bestaetigungscode erzeugen: %w", err)
+	}
+	hash := hashCode(code)
+
+	err = f.pool.QueryRow(ctx, `
+		INSERT INTO security_confirmations (action, target, requested_by, code_hash, status)
+		VALUES ($1, $2, $3, $4, 'pending')
+		RETURNING id
+	`, action, target, requestedBy, hash).Scan(&id)
+	if err != nil {
+		return "", "", fmt.Errorf("bestaetigungsvorgang anlegen: %w", err)
+	}
+	return id, code, nil
+}
+
+// Confirm bestaetigt einen Vorgang. confirmedBy MUSS sich von der
+// anfordernden Person unterscheiden (echtes Vier-Augen-Prinzip). Der Zugriff
+// auf die Zeile erfolgt mit FOR UPDATE, damit zwei gleichzeitige
+// Bestaetigungsversuche serialisiert werden und niemals beide durchgehen
+// (Akzeptanzkriterium 2 / Pruefung 2).
+func (f *FourEyes) Confirm(ctx context.Context, id, confirmedBy, code string) error {
+	tx, err := f.pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	var requestedBy, status string
+	var codeHash []byte
+	err = tx.QueryRow(ctx, `
+		SELECT requested_by, status, code_hash FROM security_confirmations
+		WHERE id = $1 FOR UPDATE
+	`, id).Scan(&requestedBy, &status, &codeHash)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrConfirmationNotFound
+		}
+		return fmt.Errorf("bestaetigungsvorgang lesen: %w", err)
+	}
+
+	if status != string(StatusPending) {
+		return ErrAlreadyDecided
+	}
+	if confirmedBy == requestedBy {
+		return ErrSameActor
+	}
+	if !timingSafeEqual(hashCode(code), codeHash) {
+		return ErrInvalidCode
+	}
+
+	if _, err := tx.Exec(ctx, `
+		UPDATE security_confirmations
+		SET status = 'confirmed', confirmed_by = $2, confirmed_at = now()
+		WHERE id = $1
+	`, id, confirmedBy); err != nil {
+		return fmt.Errorf("bestaetigung speichern: %w", err)
+	}
+
+	return tx.Commit(ctx)
+}
+
+func generateCode() (string, error) {
+	buf := make([]byte, 16)
+	if _, err := rand.Read(buf); err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(buf), nil
+}
+
+func hashCode(code string) []byte {
+	sum := sha256.Sum256([]byte(code))
+	return sum[:]
+}

internal/audit/four_eyes_test.go

@@ -0,0 +1,128 @@
+package audit
+
+import (
+	"context"
+	"errors"
+	"os"
+	"sync"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupFourEyesTest(t *testing.T) (*FourEyes, 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 security_confirmations (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			action TEXT NOT NULL,
+			target TEXT NOT NULL,
+			requested_by TEXT NOT NULL,
+			code_hash BYTEA NOT NULL,
+			status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'confirmed', 'rejected')),
+			confirmed_by TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			confirmed_at TIMESTAMPTZ
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM security_confirmations WHERE action LIKE 'test.%'`)
+		pool.Close()
+	}
+	return NewFourEyes(pool), cleanup
+}
+
+func TestFourEyes_RequestAndConfirm(t *testing.T) {
+	fe, cleanup := setupFourEyesTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	id, code, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
+	if err != nil {
+		t.Fatalf("request: %v", err)
+	}
+
+	if err := fe.Confirm(ctx, id, "bob@example.com", code); err != nil {
+		t.Fatalf("confirm: %v", err)
+	}
+}
+
+func TestFourEyes_RejectsSameActor(t *testing.T) {
+	fe, cleanup := setupFourEyesTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	id, code, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
+	if err != nil {
+		t.Fatalf("request: %v", err)
+	}
+
+	if err := fe.Confirm(ctx, id, "alice@example.com", code); !errors.Is(err, ErrSameActor) {
+		t.Fatalf("erwartet ErrSameActor, habe %v", err)
+	}
+}
+
+func TestFourEyes_RejectsWrongCode(t *testing.T) {
+	fe, cleanup := setupFourEyesTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	id, _, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
+	if err != nil {
+		t.Fatalf("request: %v", err)
+	}
+
+	if err := fe.Confirm(ctx, id, "bob@example.com", "falscher-code"); !errors.Is(err, ErrInvalidCode) {
+		t.Fatalf("erwartet ErrInvalidCode, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: FOR-UPDATE-Lock unter parallelen
+// Anfragen race-frei — von zwei gleichzeitigen Bestaetigungsversuchen fuer
+// denselben Vorgang darf genau einer durchgehen.
+func TestFourEyes_ConcurrentConfirmIsRaceFree(t *testing.T) {
+	fe, cleanup := setupFourEyesTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	id, code, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
+	if err != nil {
+		t.Fatalf("request: %v", err)
+	}
+
+	var wg sync.WaitGroup
+	results := make([]error, 2)
+	confirmers := []string{"bob@example.com", "carol@example.com"}
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			results[i] = fe.Confirm(ctx, id, confirmers[i], code)
+		}(i)
+	}
+	wg.Wait()
+
+	successCount := 0
+	for _, err := range results {
+		if err == nil {
+			successCount++
+		} else if !errors.Is(err, ErrAlreadyDecided) {
+			t.Fatalf("unerwarteter fehler: %v", err)
+		}
+	}
+	if successCount != 1 {
+		t.Fatalf("erwartet genau eine erfolgreiche bestaetigung, habe %d", successCount)
+	}
+}

internal/audit/timingsafe.go

@@ -0,0 +1,15 @@
+package audit
+
+import "crypto/subtle"
+
+// timingSafeEqual ist die projektweite Referenzimplementierung fuer
+// Timing-safe-Vergleiche sicherheitsrelevanter Geheimnisse (Bestaetigungs-
+// codes hier, spaeter Freigabelinks in Archive CMP-06 — siehe IAM-02-Ticket-
+// Konvention). subtle.ConstantTimeCompare vergleicht in konstanter Zeit
+// bezogen auf die Laenge von a, unabhaengig vom Inhalt.
+func timingSafeEqual(a, b []byte) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	return subtle.ConstantTimeCompare(a, b) == 1
+}

internal/audit/timingsafe_test.go

@@ -0,0 +1,62 @@
+package audit
+
+import (
+	"testing"
+	"time"
+)
+
+func TestTimingSafeEqual_Correctness(t *testing.T) {
+	a := hashCode("geheimnis-a")
+	b := hashCode("geheimnis-a")
+	c := hashCode("geheimnis-b")
+
+	if !timingSafeEqual(a, b) {
+		t.Fatal("identische hashes sollten gleich sein")
+	}
+	if timingSafeEqual(a, c) {
+		t.Fatal("unterschiedliche hashes sollten ungleich sein")
+	}
+	if timingSafeEqual(a, []byte("kuerzer")) {
+		t.Fatal("unterschiedliche laenge sollte ungleich sein")
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Timing-safe Vergleich stichprobenartig
+// per Laufzeitmessung verifiziert — ein Mismatch am Anfang darf nicht
+// messbar schneller sein als ein Mismatch am Ende (klassisches Merkmal
+// eines NICHT timing-safen Vergleichs wie bytes.Equal mit Short-Circuit).
+func TestTimingSafeEqual_NoEarlyExitTiming(t *testing.T) {
+	reference := hashCode("referenzwert-fuer-timing-test")
+
+	mismatchAtStart := make([]byte, len(reference))
+	copy(mismatchAtStart, reference)
+	mismatchAtStart[0] ^= 0xFF
+
+	mismatchAtEnd := make([]byte, len(reference))
+	copy(mismatchAtEnd, reference)
+	mismatchAtEnd[len(mismatchAtEnd)-1] ^= 0xFF
+
+	const iterations = 20000
+	startDur := measure(iterations, func() { timingSafeEqual(reference, mismatchAtStart) })
+	endDur := measure(iterations, func() { timingSafeEqual(reference, mismatchAtEnd) })
+
+	t.Logf("mismatch am anfang: %s, mismatch am ende: %s (%d iterationen)", startDur, endDur, iterations)
+
+	ratio := float64(startDur) / float64(endDur)
+	// Grosszuegige Toleranz (Faktor 3), da es ein Stichprobentest auf einer
+	// geteilten Testmaschine ist, kein isolierter Benchmark — es geht darum,
+	// eine grobe Short-Circuit-Implementierung zuverlaessig aufzudecken
+	// (die haette typischerweise eine Groessenordnung Unterschied), nicht um
+	// kryptographisch praezise Constant-Time-Beweise.
+	if ratio > 3.0 || ratio < 1.0/3.0 {
+		t.Fatalf("timing-unterschied zu gross (verdacht auf short-circuit-vergleich): ratio=%.2f", ratio)
+	}
+}
+
+func measure(iterations int, fn func()) time.Duration {
+	start := time.Now()
+	for i := 0; i < iterations; i++ {
+		fn()
+	}
+	return time.Since(start)
+}

internal/flag/flag.go

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

internal/flag/service.go

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

internal/policy/enforcer.go

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

internal/policy/module_scope.go

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

internal/policy/module_scope_test.go

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

internal/policy/policy_test.go

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

internal/policy/store.go

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

internal/rbac/role.go

@@ -1,71 +0,0 @@
-// 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/role_test.go

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

internal/rbac/store.go

@@ -1,124 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var (
-	// ErrRoleNotAssignableInTenantScope wird geliefert, wenn versucht wird,
-	// eine mandantenuebergreifende Rolle (superadmin) ueber den tenant-
-	// gescopten Store zu vergeben — die erlaubte Matrix laesst hier nur
-	// user/tenant_admin zu (Akzeptanzkriterium 1 / Pruefung 1).
-	ErrRoleNotAssignableInTenantScope = errors.New("rbac: rolle ist in diesem geltungsbereich nicht zuweisbar")
-	ErrNotFound                       = errors.New("rbac: keine rollenzuweisung gefunden")
-)
-
-// assignableRoles ist die erlaubte Matrix fuer Store (tenant-gescoped).
-var assignableRoles = map[Role]bool{
-	RoleUser:        true,
-	RoleTenantAdmin: true,
-}
-
-type Assignment struct {
-	UserID    string
-	Role      Role
-	GrantedBy string
-}
-
-// Store verwaltet Rollenzuweisungen innerhalb GENAU EINER Tenant-Datenbank —
-// analog zu internal/user.TenantUserStore (Modell C: der Pool bestimmt den
-// Tenant, keine tenant_id-Spalte noetig).
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// Assign vergibt eine Rolle an einen Benutzer. grantedBy identifiziert den
-// Akteur, der die Zuweisung vorgenommen hat (Akzeptanzkriterium 3). Jede
-// Zuweisung wird zusaetzlich in role_assignment_history festgehalten, auch
-// wenn sie eine vorherige Rolle ersetzt.
-func (s *Store) Assign(ctx context.Context, userID string, role Role, grantedBy string) (Assignment, error) {
-	if !assignableRoles[role] {
-		return Assignment{}, ErrRoleNotAssignableInTenantScope
-	}
-	if grantedBy == "" {
-		return Assignment{}, errors.New("rbac: grantedBy darf nicht leer sein")
-	}
-
-	tx, err := s.pool.Begin(ctx)
-	if err != nil {
-		return Assignment{}, fmt.Errorf("transaktion starten: %w", err)
-	}
-	defer func() { _ = tx.Rollback(ctx) }()
-
-	if _, err := tx.Exec(ctx, `
-		INSERT INTO role_assignments (user_id, role, granted_by, granted_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (user_id) DO UPDATE SET role = $2, granted_by = $3, granted_at = now()
-	`, userID, string(role), grantedBy); err != nil {
-		return Assignment{}, fmt.Errorf("rolle zuweisen: %w", err)
-	}
-
-	if _, err := tx.Exec(ctx, `
-		INSERT INTO role_assignment_history (user_id, role, granted_by, granted_at)
-		VALUES ($1, $2, $3, now())
-	`, userID, string(role), grantedBy); err != nil {
-		return Assignment{}, fmt.Errorf("historie schreiben: %w", err)
-	}
-
-	if err := tx.Commit(ctx); err != nil {
-		return Assignment{}, fmt.Errorf("transaktion committen: %w", err)
-	}
-
-	return Assignment{UserID: userID, Role: role, GrantedBy: grantedBy}, nil
-}
-
-func (s *Store) Get(ctx context.Context, userID string) (Assignment, error) {
-	var a Assignment
-	var role string
-	a.UserID = userID
-	if err := s.pool.QueryRow(ctx, `
-		SELECT role, granted_by FROM role_assignments WHERE user_id = $1
-	`, userID).Scan(&role, &a.GrantedBy); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Assignment{}, ErrNotFound
-		}
-		return Assignment{}, fmt.Errorf("rollenzuweisung lesen: %w", err)
-	}
-	a.Role = Role(role)
-	return a, nil
-}
-
-// History liefert jede Rollenzuweisung eines Benutzers in chronologischer
-// Reihenfolge — die Grundlage fuer "wer hat wann welche Rolle vergeben"
-// (Akzeptanzkriterium 3).
-func (s *Store) History(ctx context.Context, userID string) ([]Assignment, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT role, granted_by FROM role_assignment_history
-		WHERE user_id = $1 ORDER BY granted_at
-	`, userID)
-	if err != nil {
-		return nil, fmt.Errorf("historie abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Assignment
-	for rows.Next() {
-		var role string
-		a := Assignment{UserID: userID}
-		if err := rows.Scan(&role, &a.GrantedBy); err != nil {
-			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
-		}
-		a.Role = Role(role)
-		out = append(out, a)
-	}
-	return out, rows.Err()
-}

internal/rbac/store_test.go

@@ -1,144 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-func setupStoreTest(t *testing.T) (*Store, string, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS users (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			email TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignments (
-			user_id UUID PRIMARY KEY REFERENCES users(id),
-			role TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
-			granted_by TEXT NOT NULL,
-			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignment_history (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			user_id UUID NOT NULL,
-			role TEXT NOT NULL,
-			granted_by TEXT NOT NULL,
-			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	userStore := user.NewTenantUserStore(pool)
-	u, err := userStore.Create(ctx, "rbac_test@example.com", "RBAC Test")
-	if err != nil {
-		t.Fatalf("testuser anlegen: %v", err)
-	}
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM role_assignment_history WHERE user_id = $1`, u.ID)
-		_, _ = pool.Exec(ctx, `DELETE FROM role_assignments WHERE user_id = $1`, u.ID)
-		_, _ = pool.Exec(ctx, `DELETE FROM users WHERE id = $1`, u.ID)
-		pool.Close()
-	}
-	return NewStore(pool), u.ID, cleanup
-}
-
-// Akzeptanzkriterium 1: Grundrollen sind einem Benutzer je Tenant zuweisbar.
-func TestStore_AssignAndGet(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	assigned, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example")
-	if err != nil {
-		t.Fatalf("assign: %v", err)
-	}
-	if assigned.Role != RoleTenantAdmin {
-		t.Fatalf("erwartet tenant_admin, habe %q", assigned.Role)
-	}
-
-	got, err := store.Get(ctx, userID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Role != RoleTenantAdmin || got.GrantedBy != "admin@acme.example" {
-		t.Fatalf("zuweisung unerwartet: %+v", got)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: Zuweisung ausserhalb der erlaubten
-// Matrix (superadmin im tenant-gescopten Store) wird abgewiesen.
-func TestStore_RejectsSuperadminOutsideAllowedMatrix(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	_, err := store.Assign(ctx, userID, RoleSuperadmin, "admin@acme.example")
-	if !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
-		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope, habe %v", err)
-	}
-
-	// Sicherstellen, dass der abgewiesene Versuch keine Zeile hinterlassen hat.
-	if _, err := store.Get(ctx, userID); !errors.Is(err, ErrNotFound) {
-		t.Fatalf("erwartet ErrNotFound nach abgewiesener zuweisung, habe %v", err)
-	}
-}
-
-func TestStore_RejectsUnknownRole(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.Assign(ctx, userID, Role("erfunden"), "admin@acme.example"); !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
-		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope fuer unbekannte rolle, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 3: Rollenzuweisung vollstaendig auditierbar.
-func TestStore_HistoryTracksWhoAndWhen(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.Assign(ctx, userID, RoleUser, "system"); err != nil {
-		t.Fatalf("assign 1: %v", err)
-	}
-	if _, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example"); err != nil {
-		t.Fatalf("assign 2: %v", err)
-	}
-
-	history, err := store.History(ctx, userID)
-	if err != nil {
-		t.Fatalf("history: %v", err)
-	}
-	if len(history) != 2 {
-		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
-	}
-	if history[0].Role != RoleUser || history[0].GrantedBy != "system" {
-		t.Fatalf("history[0] unerwartet: %+v", history[0])
-	}
-	if history[1].Role != RoleTenantAdmin || history[1].GrantedBy != "admin@acme.example" {
-		t.Fatalf("history[1] unerwartet: %+v", history[1])
-	}
-}

internal/user/handler.go

@@ -1,66 +0,0 @@
-package user
-
-import (
-	"encoding/json"
-	"errors"
-	"net/http"
-)
-
-// Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
-// Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
-// dieser Kachel und daher hier noch nicht angebunden.
-type Handler struct {
-	users       *TenantUserStore
-	superadmins *SuperadminStore
-}
-
-func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
-	return &Handler{users: users, superadmins: superadmins}
-}
-
-type createUserRequest struct {
-	Email string `json:"email"`
-	Name  string `json:"name"`
-}
-
-func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
-	var req createUserRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	u, err := h.users.Create(r.Context(), req.Email, req.Name)
-	writeUserResult(w, u, err)
-}
-
-// CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
-// bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
-func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
-	var req createUserRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
-	writeUserResult(w, u, err)
-}
-
-func writeUserResult(w http.ResponseWriter, u User, err error) {
-	if err != nil {
-		switch {
-		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
-			http.Error(w, err.Error(), http.StatusBadRequest)
-		case errors.Is(err, ErrNotFound):
-			http.Error(w, err.Error(), http.StatusNotFound)
-		default:
-			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
-		}
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusCreated)
-	_ = json.NewEncoder(w).Encode(u)
-}

internal/user/store_test.go

@@ -1,173 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
-// uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
-// TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
-// fuer dasselbe Muster.
-func setupTestDB(t *testing.T, dbName, schemaSQL 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, schemaSQL); 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
-}
-
-const usersSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE users (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-	email TEXT NOT NULL UNIQUE,
-	name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active',
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);`
-
-const superadminsSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE superadmins (
-	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()
-);`
-
-// Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
-func TestTenantUserStore_CRUD(t *testing.T) {
-	pool := setupTestDB(t, "test_iam01_users", usersSchema)
-	store := NewTenantUserStore(pool)
-	ctx := context.Background()
-
-	created, err := store.Create(ctx, "alice@example.com", "Alice")
-	if err != nil {
-		t.Fatalf("create: %v", err)
-	}
-	if created.Status != StatusActive {
-		t.Fatalf("erwartet status active, hat %q", created.Status)
-	}
-
-	got, err := store.Get(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Email != "alice@example.com" {
-		t.Fatalf("get email = %q", got.Email)
-	}
-
-	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
-	if err != nil {
-		t.Fatalf("update: %v", err)
-	}
-	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
-		t.Fatalf("update ergebnis unerwartet: %+v", updated)
-	}
-
-	list, err := store.List(ctx)
-	if err != nil {
-		t.Fatalf("list: %v", err)
-	}
-	if len(list) != 1 {
-		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
-	}
-
-	deactivated, err := store.Deactivate(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("deactivate: %v", err)
-	}
-	if deactivated.Status != StatusInactive {
-		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
-	}
-
-	// Negativfall: doppelte E-Mail-Adresse.
-	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
-		t.Fatalf("create second: %v", err)
-	}
-	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
-		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
-	}
-
-	// Negativfall: fehlender Benutzer.
-	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
-		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
-// SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
-// keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
-func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
-	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
-	store := NewSuperadminStore(pool)
-	ctx := context.Background()
-
-	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
-	if err != nil {
-		t.Fatalf("create superadmin: %v", err)
-	}
-	if created.Status != StatusActive {
-		t.Fatalf("erwartet status active, hat %q", created.Status)
-	}
-
-	got, err := store.Get(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Email != "root@nexarch.internal" {
-		t.Fatalf("get email = %q", got.Email)
-	}
-
-	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
-		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
-	}
-
-	deactivated, err := store.Deactivate(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("deactivate: %v", err)
-	}
-	if deactivated.Status != StatusInactive {
-		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
-	}
-}

internal/user/superadmin_store.go

@@ -1,77 +0,0 @@
-package user
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
-// Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
-// Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
-// TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
-// koennte (IAM-01, "ohne Sonderbehandlung im Code").
-type SuperadminStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
-	return &SuperadminStore{pool: pool}
-}
-
-func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
-	if err := ValidateEmail(email); err != nil {
-		return User{}, err
-	}
-
-	var u User
-	u.Email, u.Name, u.Status = email, name, StatusActive
-
-	row := s.pool.QueryRow(ctx, `
-		INSERT INTO superadmins (email, name, status)
-		VALUES ($1, $2, $3)
-		RETURNING id, created_at, updated_at
-	`, u.Email, u.Name, u.Status)
-
-	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM superadmins WHERE id = $1
-	`, id))
-}
-
-func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM superadmins ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("superadmins auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []User
-	for rows.Next() {
-		var u User
-		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-			return nil, fmt.Errorf("superadmin lesen: %w", err)
-		}
-		out = append(out, u)
-	}
-	return out, rows.Err()
-}
-
-func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		UPDATE superadmins SET status = $2, updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, StatusInactive))
-}

internal/user/tenant_store.go

@@ -1,128 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgconn"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
-// Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
-// uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
-type TenantUserStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
-	return &TenantUserStore{pool: pool}
-}
-
-func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
-	if err := ValidateEmail(email); err != nil {
-		return User{}, err
-	}
-
-	var u User
-	u.Email, u.Name, u.Status = email, name, StatusActive
-
-	row := s.pool.QueryRow(ctx, `
-		INSERT INTO users (email, name, status)
-		VALUES ($1, $2, $3)
-		RETURNING id, created_at, updated_at
-	`, u.Email, u.Name, u.Status)
-
-	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM users WHERE id = $1
-	`, id))
-}
-
-func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM users ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("benutzer auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []User
-	for rows.Next() {
-		var u User
-		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-			return nil, fmt.Errorf("benutzer lesen: %w", err)
-		}
-		out = append(out, u)
-	}
-	return out, rows.Err()
-}
-
-// Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
-// Feld unveraendert.
-func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
-	if email != "" {
-		if err := ValidateEmail(email); err != nil {
-			return User{}, err
-		}
-	}
-
-	row := s.pool.QueryRow(ctx, `
-		UPDATE users
-		SET email = COALESCE(NULLIF($2, ''), email),
-		    name = COALESCE(NULLIF($3, ''), name),
-		    updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, email, name)
-
-	u, err := scanUser(row)
-	if err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-// Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
-func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		UPDATE users SET status = $2, updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, StatusInactive))
-}
-
-func scanUser(row pgx.Row) (User, error) {
-	var u User
-	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return User{}, ErrNotFound
-		}
-		return User{}, fmt.Errorf("benutzer lesen: %w", err)
-	}
-	return u, nil
-}
-
-// mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
-// einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
-func mapWriteErr(err error) error {
-	var pgErr *pgconn.PgError
-	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
-		return ErrEmailTaken
-	}
-	if errors.Is(err, pgx.ErrNoRows) {
-		return ErrNotFound
-	}
-	return fmt.Errorf("benutzer schreiben: %w", err)
-}

internal/user/user.go

@@ -1,42 +0,0 @@
-// Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
-// CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
-// gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
-// dagegen mandantenuebergreifend in der Registry und sind ueber
-// SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
-// tenant_id-NULL-Sonderfall in User.
-package user
-
-import (
-	"errors"
-	"regexp"
-	"time"
-)
-
-type Status string
-
-const (
-	StatusActive   Status = "active"
-	StatusInactive Status = "inactive"
-)
-
-type User struct {
-	ID        string
-	Email     string
-	Name      string
-	Status    Status
-	CreatedAt time.Time
-	UpdatedAt time.Time
-}
-
-var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
-
-var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
-var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
-var ErrNotFound = errors.New("user: nicht gefunden")
-
-func ValidateEmail(email string) error {
-	if !emailPattern.MatchString(email) {
-		return ErrInvalidEmail
-	}
-	return nil
-}

internal/user/user_test.go

@@ -1,24 +0,0 @@
-package user
-
-import "testing"
-
-func TestValidateEmail(t *testing.T) {
-	cases := []struct {
-		email   string
-		wantErr bool
-	}{
-		{"a@b.de", false},
-		{"a.b+c@sub.example.com", false},
-		{"", true},
-		{"keine-email", true},
-		{"a@b", true},
-		{"@b.de", true},
-	}
-
-	for _, c := range cases {
-		err := ValidateEmail(c.email)
-		if (err != nil) != c.wantErr {
-			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
-		}
-	}
-}

migrations/0002_superadmins.down.sql

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

migrations/0002_superadmins.up.sql

@@ -1,14 +0,0 @@
--- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
--- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
--- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
--- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
--- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
--- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
-CREATE TABLE superadmins (
-    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()
-);

migrations/0003_policy_rules.down.sql

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

migrations/0003_policy_rules.up.sql

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

migrations/0004_audit_events.down.sql

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

migrations/0004_audit_events.up.sql

@@ -0,0 +1,17 @@
+-- Zentrales Audit-Log-Modell (AUD-01, siehe core-kanban/tickets/AUD-01.md).
+-- Getrennt vom allgemeinen Anwendungs-Log (Akzeptanzkriterium 2): eigene
+-- Tabelle, eigenes Paket (internal/audit), kein Log-Framework.
+-- tenant_slug ist NOT NULL + darf nicht leer sein (Akzeptanzkriterium 2 /
+-- Pruefung 2) — mandantenuebergreifende Ereignisse nutzen den reservierten
+-- Wert 'system', niemals NULL oder leeren String.
+CREATE TABLE audit_events (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    occurred_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    tenant_slug  TEXT NOT NULL CHECK (tenant_slug <> ''),
+    actor        TEXT NOT NULL CHECK (actor <> ''),
+    action       TEXT NOT NULL CHECK (action <> ''),
+    target       TEXT NOT NULL,
+    metadata     JSONB NOT NULL DEFAULT '{}'::jsonb
+);
+
+CREATE INDEX audit_events_tenant_slug_idx ON audit_events (tenant_slug, occurred_at);

migrations/0004_feature_flags.down.sql

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

migrations/0004_feature_flags.up.sql

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

migrations/0005_audit_append_only.down.sql

@@ -0,0 +1,3 @@
+DROP TRIGGER IF EXISTS audit_events_no_delete ON audit_events;
+DROP TRIGGER IF EXISTS audit_events_no_update ON audit_events;
+DROP FUNCTION IF EXISTS audit_events_prevent_mutation();

migrations/0005_audit_append_only.up.sql

@@ -0,0 +1,17 @@
+-- Audit-Log technisch gegen Aenderung/Loeschung absichern (AUD-02, siehe
+-- core-kanban/tickets/AUD-02.md). Ein Trigger statt nur GRANT/REVOKE, damit
+-- der Schutz unabhaengig davon greift, mit welcher Rolle verbunden wird
+-- (Akzeptanzkriterium 1: "auf Datenbankebene technisch unterbunden").
+CREATE FUNCTION audit_events_prevent_mutation() RETURNS TRIGGER AS $$
+BEGIN
+    RAISE EXCEPTION 'audit_events ist append-only: % ist nicht erlaubt', TG_OP;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER audit_events_no_update
+    BEFORE UPDATE ON audit_events
+    FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();
+
+CREATE TRIGGER audit_events_no_delete
+    BEFORE DELETE ON audit_events
+    FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();

migrations/0005_policy_module_scopes.down.sql

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

migrations/0005_policy_module_scopes.up.sql

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

migrations/0006_security_confirmations.down.sql

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

migrations/0006_security_confirmations.up.sql

@@ -0,0 +1,14 @@
+-- Vier-Augen-Prinzip fuer sicherheitskritische Entscheidungen (AUD-02
+-- Akzeptanzkriterium 2), Vorbild: archivdms FOR-UPDATE-Lock + Timing-safe
+-- Vergleich. code_hash speichert NIEMALS den Bestaetigungscode im Klartext.
+CREATE TABLE security_confirmations (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    action        TEXT NOT NULL,
+    target        TEXT NOT NULL,
+    requested_by  TEXT NOT NULL,
+    code_hash     BYTEA NOT NULL,
+    status        TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'confirmed', 'rejected')),
+    confirmed_by  TEXT,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    confirmed_at  TIMESTAMPTZ
+);

migrations/tenant/0001_users.down.sql

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

migrations/tenant/0001_users.up.sql

@@ -1,16 +0,0 @@
--- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
--- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
--- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
--- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
--- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
--- nur innerhalb dieser einen Tenant-Datenbank.
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-
-CREATE TABLE users (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    email        TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/tenant/0002_role_assignments.down.sql

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

migrations/tenant/0002_role_assignments.up.sql

@@ -1,23 +0,0 @@
--- 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);

scripts/reset-test-env.sh

@@ -14,6 +14,7 @@ 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;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events 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