From ed67887385d706359bba0a7644ff076ce5b9ef35 Mon Sep 17 00:00:00 2001 From: sysops Date: Thu, 27 Aug 2026 19:45:16 +0200 Subject: [PATCH 1/2] RBAC-01: rollenmodell-grundrechte MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit internal/rbac: drei Grundrollen (superadmin, tenant_admin, user) mit Hierarchie ueber eine einfache Eltern-Map (tenant_admin erbt von user, superadmin erbt von tenant_admin) — EffectivePermissions loest die volle vererbte Rechtemenge auf (Akzeptanzkriterium 2). Policy-Modell bewusst als reine Go-Datenstruktur getrennt von der Durchsetzung (RBAC-02), nach Casbin-Prinzip. Store verwaltet Rollenzuweisungen innerhalb EINER Tenant-Datenbank (Modell C, analog internal/user.TenantUserStore) — nur 'user' und 'tenant_admin' sind hier zuweisbar (assignableRoles-Matrix). Ein Zuweisungsversuch fuer 'superadmin' wird abgewiesen, da diese Rolle mandantenuebergreifend ist und bereits durch die Existenz eines Kontos in IAM-01s SuperadminStore repraesentiert wird — keine doppelte Modellierung. Jede Zuweisung schreibt zusaetzlich einen Historieneintrag (role_assignment_history) mit grantedBy/grantedAt, atomar in derselben Transaktion (Akzeptanzkriterium 3). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Zuweisung ausserhalb der erlaubten Matrix abgewiesen — TestStore_RejectsSuperadminOutsideAllowedMatrix und TestStore_RejectsUnknownRole: beide ErrRoleNotAssignableInTenantScope, kein Datensatz hinterlassen. PASS. 2. Rollenhierarchie liefert erwartete effektive Rechtemenge — TestEffectivePermissions_Inheritance: tenant_admin hat geerbte user-Rechte + eigene, aber nicht platform.manage_tenants; superadmin hat die volle Kette. PASS. 3. Datenmodell von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Zusaetzlich automatisiert getestet (Akzeptanzkriterium 3): TestStore_HistoryTracksWhoAndWhen — zwei aufeinanderfolgende Zuweisungen, Historie liefert beide mit korrektem grantedBy in chronologischer Reihenfolge. PASS. Co-Authored-By: Claude Sonnet 5 --- internal/rbac/role.go | 71 +++++++++ internal/rbac/role_test.go | 48 ++++++ internal/rbac/store.go | 124 +++++++++++++++ internal/rbac/store_test.go | 144 ++++++++++++++++++ .../tenant/0002_role_assignments.down.sql | 2 + .../tenant/0002_role_assignments.up.sql | 23 +++ scripts/reset-test-env.sh | 23 +++ scripts/run-checks.sh | 24 +++ 8 files changed, 459 insertions(+) create mode 100644 internal/rbac/role.go create mode 100644 internal/rbac/role_test.go create mode 100644 internal/rbac/store.go create mode 100644 internal/rbac/store_test.go create mode 100644 migrations/tenant/0002_role_assignments.down.sql create mode 100644 migrations/tenant/0002_role_assignments.up.sql create mode 100755 scripts/reset-test-env.sh create mode 100755 scripts/run-checks.sh diff --git a/internal/rbac/role.go b/internal/rbac/role.go new file mode 100644 index 0000000..cf2cdda --- /dev/null +++ b/internal/rbac/role.go @@ -0,0 +1,71 @@ +// Package rbac implementiert Core RBAC-01: das Rollenmodell mit +// Grundrollen/-rechten, Hierarchie und Zuweisung. Die eigentliche +// Durchsetzung (erlaubt/verboten je Request) ist RBAC-02, dieses Paket +// liefert nur Modell + Zuweisung (Casbin-Prinzip: Policy-Modell getrennt +// von der Entscheidungsfunktion). +package rbac + +// Role ist eine der drei Grundrollen. Superadmin lebt mandantenuebergreifend +// (siehe internal/user.SuperadminStore aus IAM-01) und wird deshalb NICHT +// ueber Store (tenant-gescoped) zugewiesen — die Existenz eines Superadmin- +// Kontos IST die Rollenzuweisung. +type Role string + +const ( + RoleSuperadmin Role = "superadmin" + RoleTenantAdmin Role = "tenant_admin" + RoleUser Role = "user" +) + +type Permission string + +const ( + PermSelfRead Permission = "self.read" + PermSelfUpdate Permission = "self.update" + PermManageUsers Permission = "tenant.manage_users" + PermManageSettings Permission = "tenant.manage_settings" + PermManageTenants Permission = "platform.manage_tenants" +) + +// parent bildet die Rollenhierarchie ab (Akzeptanzkriterium 2): eine Rolle +// erbt alle Rechte ihrer Elternrolle. tenant_admin erbt von user, +// superadmin erbt von tenant_admin. +var parent = map[Role]Role{ + RoleTenantAdmin: RoleUser, + RoleSuperadmin: RoleTenantAdmin, +} + +// direct sind die einer Rolle direkt (ohne Vererbung) zugeordneten Rechte. +var direct = map[Role][]Permission{ + RoleUser: {PermSelfRead, PermSelfUpdate}, + RoleTenantAdmin: {PermManageUsers, PermManageSettings}, + RoleSuperadmin: {PermManageTenants}, +} + +// EffectivePermissions liefert die vollstaendige, ueber die Hierarchie +// aufgeloeste Rechtemenge einer Rolle (Akzeptanzkriterium 2 / Pruefung 2). +func EffectivePermissions(role Role) []Permission { + seen := make(map[Permission]bool) + var out []Permission + + for r, ok := role, true; ok; r, ok = parent[r] { + for _, p := range direct[r] { + if !seen[p] { + seen[p] = true + out = append(out, p) + } + } + } + return out +} + +// HasPermission prueft, ob eine Rolle (inklusive geerbter Rechte) ein +// bestimmtes Recht besitzt. +func HasPermission(role Role, perm Permission) bool { + for _, p := range EffectivePermissions(role) { + if p == perm { + return true + } + } + return false +} diff --git a/internal/rbac/role_test.go b/internal/rbac/role_test.go new file mode 100644 index 0000000..ba047f9 --- /dev/null +++ b/internal/rbac/role_test.go @@ -0,0 +1,48 @@ +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") + } +} diff --git a/internal/rbac/store.go b/internal/rbac/store.go new file mode 100644 index 0000000..86f7f55 --- /dev/null +++ b/internal/rbac/store.go @@ -0,0 +1,124 @@ +package rbac + +import ( + "context" + "errors" + "fmt" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +var ( + // ErrRoleNotAssignableInTenantScope wird geliefert, wenn versucht wird, + // eine mandantenuebergreifende Rolle (superadmin) ueber den tenant- + // gescopten Store zu vergeben — die erlaubte Matrix laesst hier nur + // user/tenant_admin zu (Akzeptanzkriterium 1 / Pruefung 1). + ErrRoleNotAssignableInTenantScope = errors.New("rbac: rolle ist in diesem geltungsbereich nicht zuweisbar") + ErrNotFound = errors.New("rbac: keine rollenzuweisung gefunden") +) + +// assignableRoles ist die erlaubte Matrix fuer Store (tenant-gescoped). +var assignableRoles = map[Role]bool{ + RoleUser: true, + RoleTenantAdmin: true, +} + +type Assignment struct { + UserID string + Role Role + GrantedBy string +} + +// Store verwaltet Rollenzuweisungen innerhalb GENAU EINER Tenant-Datenbank — +// analog zu internal/user.TenantUserStore (Modell C: der Pool bestimmt den +// Tenant, keine tenant_id-Spalte noetig). +type Store struct { + pool *pgxpool.Pool +} + +func NewStore(pool *pgxpool.Pool) *Store { + return &Store{pool: pool} +} + +// Assign vergibt eine Rolle an einen Benutzer. grantedBy identifiziert den +// Akteur, der die Zuweisung vorgenommen hat (Akzeptanzkriterium 3). Jede +// Zuweisung wird zusaetzlich in role_assignment_history festgehalten, auch +// wenn sie eine vorherige Rolle ersetzt. +func (s *Store) Assign(ctx context.Context, userID string, role Role, grantedBy string) (Assignment, error) { + if !assignableRoles[role] { + return Assignment{}, ErrRoleNotAssignableInTenantScope + } + if grantedBy == "" { + return Assignment{}, errors.New("rbac: grantedBy darf nicht leer sein") + } + + tx, err := s.pool.Begin(ctx) + if err != nil { + return Assignment{}, fmt.Errorf("transaktion starten: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + if _, err := tx.Exec(ctx, ` + INSERT INTO role_assignments (user_id, role, granted_by, granted_at) + VALUES ($1, $2, $3, now()) + ON CONFLICT (user_id) DO UPDATE SET role = $2, granted_by = $3, granted_at = now() + `, userID, string(role), grantedBy); err != nil { + return Assignment{}, fmt.Errorf("rolle zuweisen: %w", err) + } + + if _, err := tx.Exec(ctx, ` + INSERT INTO role_assignment_history (user_id, role, granted_by, granted_at) + VALUES ($1, $2, $3, now()) + `, userID, string(role), grantedBy); err != nil { + return Assignment{}, fmt.Errorf("historie schreiben: %w", err) + } + + if err := tx.Commit(ctx); err != nil { + return Assignment{}, fmt.Errorf("transaktion committen: %w", err) + } + + return Assignment{UserID: userID, Role: role, GrantedBy: grantedBy}, nil +} + +func (s *Store) Get(ctx context.Context, userID string) (Assignment, error) { + var a Assignment + var role string + a.UserID = userID + if err := s.pool.QueryRow(ctx, ` + SELECT role, granted_by FROM role_assignments WHERE user_id = $1 + `, userID).Scan(&role, &a.GrantedBy); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return Assignment{}, ErrNotFound + } + return Assignment{}, fmt.Errorf("rollenzuweisung lesen: %w", err) + } + a.Role = Role(role) + return a, nil +} + +// History liefert jede Rollenzuweisung eines Benutzers in chronologischer +// Reihenfolge — die Grundlage fuer "wer hat wann welche Rolle vergeben" +// (Akzeptanzkriterium 3). +func (s *Store) History(ctx context.Context, userID string) ([]Assignment, error) { + rows, err := s.pool.Query(ctx, ` + SELECT role, granted_by FROM role_assignment_history + WHERE user_id = $1 ORDER BY granted_at + `, userID) + if err != nil { + return nil, fmt.Errorf("historie abfragen: %w", err) + } + defer rows.Close() + + var out []Assignment + for rows.Next() { + var role string + a := Assignment{UserID: userID} + if err := rows.Scan(&role, &a.GrantedBy); err != nil { + return nil, fmt.Errorf("historieneintrag lesen: %w", err) + } + a.Role = Role(role) + out = append(out, a) + } + return out, rows.Err() +} diff --git a/internal/rbac/store_test.go b/internal/rbac/store_test.go new file mode 100644 index 0000000..0469798 --- /dev/null +++ b/internal/rbac/store_test.go @@ -0,0 +1,144 @@ +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]) + } +} diff --git a/migrations/tenant/0002_role_assignments.down.sql b/migrations/tenant/0002_role_assignments.down.sql new file mode 100644 index 0000000..85852c8 --- /dev/null +++ b/migrations/tenant/0002_role_assignments.down.sql @@ -0,0 +1,2 @@ +DROP TABLE IF EXISTS role_assignment_history; +DROP TABLE IF EXISTS role_assignments; diff --git a/migrations/tenant/0002_role_assignments.up.sql b/migrations/tenant/0002_role_assignments.up.sql new file mode 100644 index 0000000..8fd0e54 --- /dev/null +++ b/migrations/tenant/0002_role_assignments.up.sql @@ -0,0 +1,23 @@ +-- Rollenzuweisung pro Benutzer (RBAC-01, siehe core-kanban/tickets/RBAC-01.md). +-- Nur 'user' und 'tenant_admin' sind hier zuweisbar — 'superadmin' lebt +-- mandantenuebergreifend in der Registry (IAM-01 SuperadminStore) und hat +-- daher bewusst KEINE Zeile in dieser tenant-lokalen Tabelle (Akzeptanz- +-- kriterium 1: nur Zuweisungen innerhalb der erlaubten Matrix). +CREATE TABLE role_assignments ( + user_id UUID PRIMARY KEY REFERENCES users(id), + role TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')), + granted_by TEXT NOT NULL, + granted_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Vollstaendige Historie jeder Rollenaenderung (Akzeptanzkriterium 3: wer +-- hat wann welche Rolle vergeben). +CREATE TABLE role_assignment_history ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + user_id UUID NOT NULL, + role TEXT NOT NULL, + granted_by TEXT NOT NULL, + granted_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX role_assignment_history_user_idx ON role_assignment_history (user_id, granted_at); diff --git a/scripts/reset-test-env.sh b/scripts/reset-test-env.sh new file mode 100755 index 0000000..5bc2bc5 --- /dev/null +++ b/scripts/reset-test-env.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash +# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte +# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle +# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches +# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische +# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]). +# +# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh +set -euo pipefail + +PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}" +ROLE="nexarch_test" + +export PGPASSWORD="$PASS" + +psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;" + +dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'") +for db in $dbs; do + psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";" +done + +echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt." diff --git a/scripts/run-checks.sh b/scripts/run-checks.sh new file mode 100755 index 0000000..83f26b6 --- /dev/null +++ b/scripts/run-checks.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost: +# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch. +# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf +# dem Testhost teilen (siehe [[project-nexarch-test-infra]]). +# +# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh +set -euo pipefail + +PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}" +cd "$(dirname "$0")/.." + +NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh + +export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable" + +echo "== go build ==" +go build ./... + +echo "== go vet ==" +go vet ./... + +echo "== go test (-p 1) ==" +go test ./... -p 1 -count=1 From d63fcbb49ed3581c22c93a177fd59dc6b611d31e Mon Sep 17 00:00:00 2001 From: sysops Date: Thu, 27 Aug 2026 21:43:26 +0200 Subject: [PATCH 2/2] 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);