From ed67887385d706359bba0a7644ff076ce5b9ef35 Mon Sep 17 00:00:00 2001 From: sysops Date: Thu, 27 Aug 2026 19:45:16 +0200 Subject: [PATCH] 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