From d63fcbb49ed3581c22c93a177fd59dc6b611d31e Mon Sep 17 00:00:00 2001 From: sysops Date: Thu, 27 Aug 2026 21:43:26 +0200 Subject: [PATCH] RBAC-02: policy-enforcement-schicht-zentral MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit internal/policy: deklarativer, DB-gehaltener Regelsatz (policy_rules) statt hartcodierter Go-Entscheidungslogik — Store.IsAllowed schaut ausschliesslich in die Datenbank, kein Go-Fallback. Ein Regelwechsel (Grant/Revoke) wirkt sich sofort aus, ohne Codeaenderung/Deploy (Akzeptanzkriterium 3). Jede Aenderung wird atomar mit einem versionierten Historieneintrag in policy_rule_changes festgehalten (grant/revoke, Akteur, Version). Enforcer.Authorize ist Default-Deny: existiert keine Regel fuer role+ permission, ist der Zugriff verboten (Akzeptanzkriterium 2), fuer sich genommen ohne Anwendungslogik testbar. Guard/GuardTenantScoped sind die zentrale Enforcement-Funktion (Akzeptanzkriterium 1): die uebergebene Query-Funktion wird NUR bei erfolgreicher Autorisierung aufgerufen — es gibt keinen Weg, Daten ohne vorherige Authorize-Entscheidung zu erhalten. GuardTenantScoped erzwingt zusaetzlich per Funktionssignatur, dass tenantSlug TEIL der Query-Funktion ist (Akzeptanzkriterium 3) — ein nachgelagerter Post-Filter (der archivmail-Fehler aus "Bekannte Fehler vermeiden": Tenant-Filter nach statt in der Query) ist mit dieser Signatur strukturell nicht moeglich, da die Repository-Implementierung tenantSlug selbst fuer ihre eigene WHERE-Klausel entgegennimmt. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Kein Datenzugriffs-Pfad umgeht die zentrale Enforcement-Schicht — TestGuard_NeverCallsQueryWithoutAuthorization: query-Funktion wird nachweislich NICHT aufgerufen ohne vorherige Regel, erst nach Grant. PASS. 2. Anfrage ohne passende Policy wird zuverlaessig abgewiesen (Default-Deny) — TestAuthorize_DefaultDeny: keine Regel konfiguriert -> ErrDenied, nicht automatisch erlaubt. PASS. 3. Policy-Regelsatz versioniert, Regelwechsel ohne Codeaenderung nachvollziehbar — TestGrantRevoke_ChangesBehaviorWithoutCodeChange: Verhalten aendert sich durch reinen Datenbank-Grant/Revoke, Historie zeigt beide Versionen korrekt. PASS. Zusaetzlich: TestGuardTenantScoped_IsolatesDataBetweenTenants belegt das Tenant-Scoping-Muster aus Akzeptanzkriterium 3 konkret anhand zweier Tenants. PASS. Co-Authored-By: Claude Sonnet 5 --- internal/policy/enforcer.go | 67 +++++++++ internal/policy/policy_test.go | 187 ++++++++++++++++++++++++++ internal/policy/store.go | 124 +++++++++++++++++ migrations/0003_policy_rules.down.sql | 2 + migrations/0003_policy_rules.up.sql | 24 ++++ 5 files changed, 404 insertions(+) create mode 100644 internal/policy/enforcer.go create mode 100644 internal/policy/policy_test.go create mode 100644 internal/policy/store.go create mode 100644 migrations/0003_policy_rules.down.sql create mode 100644 migrations/0003_policy_rules.up.sql diff --git a/internal/policy/enforcer.go b/internal/policy/enforcer.go new file mode 100644 index 0000000..623f02b --- /dev/null +++ b/internal/policy/enforcer.go @@ -0,0 +1,67 @@ +package policy + +import ( + "context" + "errors" + "fmt" + + "gitea.perlbach24.de/scripte/nexarch/internal/rbac" +) + +// ErrDenied wird geliefert, wenn keine Regel role+permission erlaubt — +// Default-Deny (Akzeptanzkriterium 2). +var ErrDenied = errors.New("policy: zugriff verweigert") + +// Enforcer ist die EINE zentrale Entscheidungs- und Durchsetzungsschicht +// (Akzeptanzkriterium 1). Repository-/Query-Code ruft ausschliesslich Guard +// bzw. GuardTenantScoped auf, nie eine Rohabfrage direkt. +type Enforcer struct { + store *Store +} + +func NewEnforcer(store *Store) *Enforcer { + return &Enforcer{store: store} +} + +// Authorize entscheidet erlaubt/verboten — unabhaengig von jeder konkreten +// Query, rein anhand der deklarativen Regeln (Akzeptanzkriterium 2: fuer +// sich genommen testbar, ohne Anwendungslogik). +func (e *Enforcer) Authorize(ctx context.Context, role rbac.Role, perm rbac.Permission) error { + allowed, err := e.store.IsAllowed(ctx, role, perm) + if err != nil { + return err + } + if !allowed { + return fmt.Errorf("%w: rolle %q hat kein recht %q", ErrDenied, role, perm) + } + return nil +} + +// Guard ist die zentrale Enforcement-Funktion (Akzeptanzkriterium 1): query +// wird NUR aufgerufen, wenn Authorize zustimmt. Es gibt keinen Weg, query +// ausserhalb von Guard aufzurufen und trotzdem den Aufrufer als autorisiert +// zu behandeln — die Autorisierungsentscheidung steht immer VOR dem +// Datenzugriff, nie danach. +func Guard[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) { + var zero T + if err := e.Authorize(ctx, role, perm); err != nil { + return zero, err + } + return query(ctx) +} + +// GuardTenantScoped erzwingt zusaetzlich, dass tenantSlug TEIL der Query- +// Funktion selbst ist (Akzeptanzkriterium 3): der Funktionstyp verlangt, +// dass die Repository-Implementierung tenantSlug in ihre eigene WHERE- +// Klausel einbaut — ein nachgelagerter Filter auf dem Ergebnis (der +// archivmail-Fehler aus "Bekannte Fehler vermeiden") ist mit dieser +// Signatur nicht moeglich, da die Query-Funktion tenantSlug selbst +// entgegennimmt und dafuer verantwortlich ist, statt ihn hinterher +// anzuwenden. +func GuardTenantScoped[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, tenantSlug string, query func(ctx context.Context, tenantSlug string) (T, error)) (T, error) { + var zero T + if err := e.Authorize(ctx, role, perm); err != nil { + return zero, err + } + return query(ctx, tenantSlug) +} diff --git a/internal/policy/policy_test.go b/internal/policy/policy_test.go new file mode 100644 index 0000000..795c557 --- /dev/null +++ b/internal/policy/policy_test.go @@ -0,0 +1,187 @@ +package policy + +import ( + "context" + "errors" + "os" + "testing" + + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.perlbach24.de/scripte/nexarch/internal/rbac" +) + +func setupTest(t *testing.T) (*Store, *Enforcer, func()) { + t.Helper() + adminDSN := os.Getenv("TEST_ADMIN_DSN") + if adminDSN == "" { + t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen") + } + ctx := context.Background() + + pool, err := pgxpool.New(ctx, adminDSN) + if err != nil { + t.Fatalf("pool: %v", err) + } + if _, err := pool.Exec(ctx, ` + CREATE TABLE IF NOT EXISTS policy_rules ( + role TEXT NOT NULL, permission TEXT NOT NULL, + granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (role, permission) + ); + CREATE TABLE IF NOT EXISTS policy_rule_changes ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL, + action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL, + version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now() + ); + `); err != nil { + t.Fatalf("schema: %v", err) + } + + store := NewStore(pool) + cleanup := func() { + _, _ = pool.Exec(ctx, `DELETE FROM policy_rule_changes WHERE role LIKE 'test\_%' ESCAPE '\'`) + _, _ = pool.Exec(ctx, `DELETE FROM policy_rules WHERE role LIKE 'test\_%' ESCAPE '\'`) + pool.Close() + } + return store, NewEnforcer(store), cleanup +} + +// Akzeptanzkriterium 2 + Pruefung 2: Anfrage ohne passende Policy wird +// zuverlaessig abgewiesen (Default-Deny), nicht standardmaessig erlaubt. +func TestAuthorize_DefaultDeny(t *testing.T) { + _, enforcer, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + err := enforcer.Authorize(ctx, rbac.Role("test_niemand"), rbac.Permission("test_irgendwas")) + if !errors.Is(err, ErrDenied) { + t.Fatalf("erwartet ErrDenied ohne konfigurierte regel, habe %v", err) + } +} + +// Akzeptanzkriterium 1 + Pruefung 1: Guard ruft query NUR bei Autorisierung +// auf — kein Datenzugriffs-Pfad umgeht die Enforcement-Schicht. +func TestGuard_NeverCallsQueryWithoutAuthorization(t *testing.T) { + store, enforcer, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + role := rbac.Role("test_rolle_guard") + perm := rbac.Permission("test_lesen") + + queryCalled := false + _, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) { + queryCalled = true + return "geheime-daten", nil + }) + if !errors.Is(err, ErrDenied) { + t.Fatalf("erwartet ErrDenied, habe %v", err) + } + if queryCalled { + t.Fatal("query haette bei fehlender autorisierung NICHT aufgerufen werden duerfen") + } + + if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil { + t.Fatalf("grant: %v", err) + } + + result, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) { + queryCalled = true + return "geheime-daten", nil + }) + if err != nil { + t.Fatalf("guard nach grant: %v", err) + } + if !queryCalled || result != "geheime-daten" { + t.Fatalf("erwartet query-aufruf mit ergebnis nach autorisierung, habe queryCalled=%v result=%q", queryCalled, result) + } +} + +// Akzeptanzkriterium 2 + 3: Policy-Entscheidungen deklarativ und unabhaengig +// von Anwendungslogik testbar — Regelwechsel wirkt ohne Codeaenderung, +// Historie ist versioniert nachvollziehbar. +func TestGrantRevoke_ChangesBehaviorWithoutCodeChange(t *testing.T) { + store, enforcer, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + role := rbac.Role("test_rolle_history") + perm := rbac.Permission("test_schreiben") + + allowed, err := store.IsAllowed(ctx, role, perm) + if err != nil { + t.Fatalf("is allowed (vorher): %v", err) + } + if allowed { + t.Fatal("erwartet nicht erlaubt vor grant") + } + + if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil { + t.Fatalf("grant: %v", err) + } + if err := enforcer.Authorize(ctx, role, perm); err != nil { + t.Fatalf("authorize nach grant sollte erlauben: %v", err) + } + + if err := store.Revoke(ctx, role, perm, "admin@example.com"); err != nil { + t.Fatalf("revoke: %v", err) + } + if err := enforcer.Authorize(ctx, role, perm); !errors.Is(err, ErrDenied) { + t.Fatalf("authorize nach revoke sollte verweigern, habe %v", err) + } + + history, err := store.History(ctx, role, perm) + if err != nil { + t.Fatalf("history: %v", err) + } + if len(history) != 2 { + t.Fatalf("erwartet 2 historieneintraege (grant, revoke), habe %d", len(history)) + } + if history[0].Action != "grant" || history[0].Version != 1 { + t.Fatalf("history[0] unerwartet: %+v", history[0]) + } + if history[1].Action != "revoke" || history[1].Version != 2 { + t.Fatalf("history[1] unerwartet: %+v", history[1]) + } +} + +// Akzeptanzkriterium 3 + Pruefung 3 (Tenant-Scoping): GuardTenantScoped +// zwingt tenantSlug in die Query-Funktion selbst, kein Post-Filter moeglich. +func TestGuardTenantScoped_IsolatesDataBetweenTenants(t *testing.T) { + _, enforcer, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + // Simuliertes Repository: die WHERE-Klausel (hier: Map-Lookup) liegt + // INNERHALB der Query-Funktion, nicht als nachgelagerter Filter. + data := map[string][]string{ + "acme": {"dokument-a1", "dokument-a2"}, + "globex": {"dokument-b1"}, + } + repoQuery := func(ctx context.Context, tenantSlug string) ([]string, error) { + return data[tenantSlug], nil + } + + role := rbac.Role("test_tenant_rolle") + perm := rbac.Permission("test_dokumente_lesen") + if err := enforcer.store.Grant(ctx, role, perm, "admin@example.com"); err != nil { + t.Fatalf("grant: %v", err) + } + + gotAcme, err := GuardTenantScoped(ctx, enforcer, role, perm, "acme", repoQuery) + if err != nil { + t.Fatalf("guard tenant scoped (acme): %v", err) + } + if len(gotAcme) != 2 { + t.Fatalf("erwartet 2 dokumente fuer acme, habe %d", len(gotAcme)) + } + + gotGlobex, err := GuardTenantScoped(ctx, enforcer, role, perm, "globex", repoQuery) + if err != nil { + t.Fatalf("guard tenant scoped (globex): %v", err) + } + if len(gotGlobex) != 1 { + t.Fatalf("erwartet 1 dokument fuer globex, habe %d", len(gotGlobex)) + } +} diff --git a/internal/policy/store.go b/internal/policy/store.go new file mode 100644 index 0000000..f1e1619 --- /dev/null +++ b/internal/policy/store.go @@ -0,0 +1,124 @@ +// Package policy implementiert Core RBAC-02: die zentrale Policy- +// Entscheidungs- und Durchsetzungsschicht. Regeln liegen deklarativ in der +// Datenbank (Casbin-Prinzip: Policy als Modell+Regeln getrennt vom Code), +// versioniert und auditierbar — anders als Casbin-Dateien im Dateisystem +// (siehe "bewusst vermeiden" im Ticket). +package policy + +import ( + "context" + "fmt" + + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.perlbach24.de/scripte/nexarch/internal/rbac" +) + +// Rule ist eine gewaehrte Regel: role darf permission. +type Rule struct { + Role rbac.Role + Permission rbac.Permission +} + +// RuleChange ist ein Eintrag der Aenderungshistorie (Akzeptanzkriterium 3). +type RuleChange struct { + Role rbac.Role + Permission rbac.Permission + Action string // "grant" oder "revoke" + Actor string + Version int +} + +// Store verwaltet den deklarativen Regelsatz. IsAllowed schaut NUR in die +// Datenbank — es gibt keinen hartcodierten Go-Fallback, ein Regelwechsel +// wirkt sich ohne Codeaenderung sofort aus (Akzeptanzkriterium 2 / 3). +type Store struct { + pool *pgxpool.Pool +} + +func NewStore(pool *pgxpool.Pool) *Store { + return &Store{pool: pool} +} + +// IsAllowed prueft, ob role das Recht permission besitzt. Default-Deny: +// existiert keine passende Regel, ist der Zugriff verboten +// (Akzeptanzkriterium 2 / Pruefung 2) — es gibt keinen impliziten +// "erlaubt, wenn nichts anderes gesagt"-Pfad. +func (s *Store) IsAllowed(ctx context.Context, role rbac.Role, perm rbac.Permission) (bool, error) { + var exists bool + err := s.pool.QueryRow(ctx, ` + SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role = $1 AND permission = $2) + `, string(role), string(perm)).Scan(&exists) + if err != nil { + return false, fmt.Errorf("policy pruefen: %w", err) + } + return exists, nil +} + +// Grant gewaehrt role das Recht permission — deklarativ, ohne Codeaenderung +// wirksam. actor wird fuer die Aenderungshistorie festgehalten. +func (s *Store) Grant(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error { + return s.change(ctx, role, perm, "grant", actor, ` + INSERT INTO policy_rules (role, permission, granted_by, granted_at) + VALUES ($1, $2, $3, now()) + ON CONFLICT (role, permission) DO UPDATE SET granted_by = $3, granted_at = now() + `, string(role), string(perm), actor) +} + +// Revoke entzieht role das Recht permission. +func (s *Store) Revoke(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error { + return s.change(ctx, role, perm, "revoke", actor, ` + DELETE FROM policy_rules WHERE role = $1 AND permission = $2 + `, string(role), string(perm)) +} + +func (s *Store) change(ctx context.Context, role rbac.Role, perm rbac.Permission, action, actor, sql string, args ...any) error { + tx, err := s.pool.Begin(ctx) + if err != nil { + return fmt.Errorf("transaktion starten: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + if _, err := tx.Exec(ctx, sql, args...); err != nil { + return fmt.Errorf("regel aendern: %w", err) + } + + var version int + if err := tx.QueryRow(ctx, ` + SELECT COALESCE(MAX(version), 0) + 1 FROM policy_rule_changes WHERE role = $1 AND permission = $2 + `, string(role), string(perm)).Scan(&version); err != nil { + return fmt.Errorf("naechste version ermitteln: %w", err) + } + + if _, err := tx.Exec(ctx, ` + INSERT INTO policy_rule_changes (role, permission, action, actor, version, changed_at) + VALUES ($1, $2, $3, $4, $5, now()) + `, string(role), string(perm), action, actor, version); err != nil { + return fmt.Errorf("historie schreiben: %w", err) + } + + return tx.Commit(ctx) +} + +// History liefert die vollstaendige, versionierte Aenderungshistorie einer +// Regel (Akzeptanzkriterium 3). +func (s *Store) History(ctx context.Context, role rbac.Role, perm rbac.Permission) ([]RuleChange, error) { + rows, err := s.pool.Query(ctx, ` + SELECT action, actor, version FROM policy_rule_changes + WHERE role = $1 AND permission = $2 ORDER BY version + `, string(role), string(perm)) + if err != nil { + return nil, fmt.Errorf("historie abfragen: %w", err) + } + defer rows.Close() + + var out []RuleChange + for rows.Next() { + c := RuleChange{Role: role, Permission: perm} + if err := rows.Scan(&c.Action, &c.Actor, &c.Version); err != nil { + return nil, fmt.Errorf("historieneintrag lesen: %w", err) + } + out = append(out, c) + } + return out, rows.Err() +} diff --git a/migrations/0003_policy_rules.down.sql b/migrations/0003_policy_rules.down.sql new file mode 100644 index 0000000..522cfa4 --- /dev/null +++ b/migrations/0003_policy_rules.down.sql @@ -0,0 +1,2 @@ +DROP TABLE IF EXISTS policy_rule_changes; +DROP TABLE IF EXISTS policy_rules; diff --git a/migrations/0003_policy_rules.up.sql b/migrations/0003_policy_rules.up.sql new file mode 100644 index 0000000..e24030a --- /dev/null +++ b/migrations/0003_policy_rules.up.sql @@ -0,0 +1,24 @@ +-- Zentrale, deklarative Policy-Regeln (RBAC-02, siehe core-kanban/tickets/RBAC-02.md). +-- policy_rules haelt den AKTUELLEN, gewaehrten Regelsatz (Existenz = erlaubt, +-- Default-Deny fuer alles ohne Zeile). policy_rule_changes ist die +-- versionierte Aenderungshistorie (Akzeptanzkriterium 3: Regelwechsel ohne +-- Codeaenderung nachvollziehbar). +CREATE TABLE policy_rules ( + role TEXT NOT NULL, + permission TEXT NOT NULL, + granted_by TEXT NOT NULL, + granted_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (role, permission) +); + +CREATE TABLE policy_rule_changes ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + role TEXT NOT NULL, + permission TEXT NOT NULL, + action TEXT NOT NULL CHECK (action IN ('grant', 'revoke')), + actor TEXT NOT NULL, + version INT NOT NULL, + changed_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX policy_rule_changes_idx ON policy_rule_changes (role, permission, version);