diff --git a/internal/ldapsync/client.go b/internal/ldapsync/client.go new file mode 100644 index 0000000..549e00d --- /dev/null +++ b/internal/ldapsync/client.go @@ -0,0 +1,27 @@ +// Package ldapsync implementiert Core IAM-05: LDAP/Active-Directory- +// Anbindung je Tenant fuer Benutzer-Synchronisation, Login-Delegation und +// Rollenzuordnung aus Gruppen ueber eine explizite Erlaubnis-Matrix. +// +// WICHTIGER HINWEIS: In dieser Umgebung steht kein echter LDAP/AD-Server zur +// Verfuegung (analog zur Archive-Engine bei AUD-05). Client ist deshalb eine +// Schnittstelle — die Sync-/Rollenzuordnungs-Logik ist gegen einen Fake in +// den Tests vollstaendig geprueft, eine echte Verbindungspruefung gegen +// LDAP/AD steht noch aus. +package ldapsync + +// Entry ist ein aus LDAP gelesener Benutzerdatensatz. +type Entry struct { + Email string + Name string + Groups []string + Disabled bool +} + +// Client abstrahiert die eigentliche LDAP-Verbindung (Bind + Search). +type Client interface { + // Search liefert alle Benutzer, die dem konfigurierten Filter + // entsprechen. Ein Fehler bedeutet "Quelle nicht erreichbar oder + // fehlerhaft" — Run() bricht dann komplett und folgenlos ab + // (Akzeptanzkriterium 2). + Search() ([]Entry, error) +} diff --git a/internal/ldapsync/ldapsync_test.go b/internal/ldapsync/ldapsync_test.go new file mode 100644 index 0000000..f30ec96 --- /dev/null +++ b/internal/ldapsync/ldapsync_test.go @@ -0,0 +1,204 @@ +package ldapsync + +import ( + "context" + "errors" + "fmt" + "os" + "testing" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.perlbach24.de/scripte/nexarch/internal/rbac" + "gitea.perlbach24.de/scripte/nexarch/internal/user" +) + +type fakeClient struct { + entries []Entry + err error +} + +func (f *fakeClient) Search() ([]Entry, error) { + if f.err != nil { + return nil, f.err + } + return f.entries, nil +} + +func setupTest(t *testing.T) (*user.TenantUserStore, *rbac.Store, *RoleMappingStore, 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', password_hash TEXT NOT NULL DEFAULT '', + 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() + ); + CREATE TABLE IF NOT EXISTS ldap_group_role_mapping ( + ldap_group TEXT PRIMARY KEY, role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')) + ); + `); err != nil { + t.Fatalf("schema: %v", err) + } + + cleanup := func() { pool.Close() } + return user.NewTenantUserStore(pool), rbac.NewStore(pool), NewRoleMappingStore(pool), cleanup +} + +func uniqueEmail() string { + return fmt.Sprintf("ldap-test-%d@example.com", time.Now().UnixNano()) +} + +// Akzeptanzkriterium 3 + Pruefung 1: Rollen-Erlaubnis-Matrix mit Positiv- und +// Negativfaellen — keine Privilege-Escalation ueber Gruppenmitgliedschaft. +func TestRoleMapping_PositiveAndNegativeCases(t *testing.T) { + _, _, mappings, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + if err := mappings.SetMapping(ctx, "cn=IT-Admins,ou=groups,dc=example,dc=com", rbac.RoleTenantAdmin); err != nil { + t.Fatalf("set mapping: %v", err) + } + + // Positivfall: gemappte Gruppe liefert die konfigurierte Rolle. + role, ok, err := mappings.HighestRoleFor(ctx, []string{"cn=IT-Admins,ou=groups,dc=example,dc=com"}) + if err != nil { + t.Fatalf("highest role: %v", err) + } + if !ok || role != rbac.RoleTenantAdmin { + t.Fatalf("erwartet tenant_admin, habe ok=%v role=%q", ok, role) + } + + // Negativfall 1: unbekannte Gruppe vergibt keine Rolle. + _, ok, err = mappings.HighestRoleFor(ctx, []string{"cn=Praktikanten,ou=groups,dc=example,dc=com"}) + if err != nil { + t.Fatalf("highest role (unbekannt): %v", err) + } + if ok { + t.Fatal("erwartet KEINE rolle fuer nicht gemappte gruppe") + } + + // Negativfall 2 (Privilege-Escalation-Versuch): eine Gruppe, die zufaellig + // wie eine interne Rolle heisst, aber NIE explizit gemappt wurde, darf + // keine Rolle vergeben. + _, ok, err = mappings.HighestRoleFor(ctx, []string{"tenant_admin", "superadmin"}) + if err != nil { + t.Fatalf("highest role (namens-trick): %v", err) + } + if ok { + t.Fatal("erwartet KEINE privilege-escalation ueber gruppennamen, die wie rollen aussehen") + } +} + +// Akzeptanzkriterium 1: Synchronisationslauf legt Benutzer an. +func TestSyncer_CreatesUsers(t *testing.T) { + users, roles, mappings, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + email := uniqueEmail() + client := &fakeClient{entries: []Entry{{Email: email, Name: "LDAP Nutzer"}}} + syncer := NewSyncer(client, users, roles, mappings) + + result, err := syncer.Run(ctx) + if err != nil { + t.Fatalf("run: %v", err) + } + if result.Created != 1 { + t.Fatalf("erwartet 1 angelegten benutzer, habe %d", result.Created) + } + + if _, err := users.GetByEmailForAuth(ctx, email); err != nil { + t.Fatalf("benutzer sollte existieren: %v", err) + } +} + +// Akzeptanzkriterium 2 + Pruefung 2: fehlerhafte/nicht erreichbare LDAP- +// Quelle bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen. +func TestSyncer_AbortsCleanlyOnSourceError(t *testing.T) { + users, roles, mappings, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + // Ein bereits bestehendes Konto, das UNBERUEHRT bleiben muss. + existingEmail := uniqueEmail() + existing, err := users.Create(ctx, existingEmail, "Bestehender Nutzer") + if err != nil { + t.Fatalf("create existing: %v", err) + } + + client := &fakeClient{err: errors.New("ldap-server nicht erreichbar (simuliert)")} + syncer := NewSyncer(client, users, roles, mappings) + + if _, err := syncer.Run(ctx); err == nil { + t.Fatal("erwartet fehler bei nicht erreichbarer ldap-quelle") + } + + // Bestehendes Konto unveraendert (noch aktiv, keine geloeschten/neuen Zeilen). + got, err := users.Get(ctx, existing.ID) + if err != nil { + t.Fatalf("bestehendes konto sollte weiterhin existieren: %v", err) + } + if got.Status != user.StatusActive { + t.Fatalf("bestehendes konto sollte unveraendert aktiv sein, ist %q", got.Status) + } +} + +// Akzeptanzkriterium 3 + Pruefung 3: Deaktivierung in LDAP wird bei +// naechster Synchronisation korrekt uebernommen. +func TestSyncer_AppliesDeactivationOnNextRun(t *testing.T) { + users, roles, mappings, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + email := uniqueEmail() + client := &fakeClient{entries: []Entry{{Email: email, Name: "Wird Deaktiviert"}}} + syncer := NewSyncer(client, users, roles, mappings) + + if _, err := syncer.Run(ctx); err != nil { + t.Fatalf("erster lauf: %v", err) + } + u, err := users.GetByEmailForAuth(ctx, email) + if err != nil { + t.Fatalf("benutzer nach erstem lauf: %v", err) + } + if u.User.Status != user.StatusActive { + t.Fatalf("erwartet aktiv nach erstem lauf, habe %q", u.User.Status) + } + + // Zweiter Lauf: derselbe Benutzer ist jetzt in LDAP deaktiviert. + client.entries[0].Disabled = true + result, err := syncer.Run(ctx) + if err != nil { + t.Fatalf("zweiter lauf: %v", err) + } + if result.Deactivated != 1 { + t.Fatalf("erwartet 1 deaktivierung, habe %d", result.Deactivated) + } + + u, err = users.GetByEmailForAuth(ctx, email) + if err != nil { + t.Fatalf("benutzer nach zweitem lauf: %v", err) + } + if u.User.Status != user.StatusInactive { + t.Fatalf("erwartet inaktiv nach deaktivierung in ldap, habe %q", u.User.Status) + } +} diff --git a/internal/ldapsync/role_mapping.go b/internal/ldapsync/role_mapping.go new file mode 100644 index 0000000..963d6af --- /dev/null +++ b/internal/ldapsync/role_mapping.go @@ -0,0 +1,79 @@ +package ldapsync + +import ( + "context" + "errors" + "fmt" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.perlbach24.de/scripte/nexarch/internal/rbac" +) + +// RoleMappingStore verwaltet die Erlaubnis-Matrix LDAP-Gruppe -> Rolle +// (Akzeptanzkriterium 3). Nur explizit gemappte Gruppen vergeben eine Rolle +// — der Schutz gegen Privilege-Escalation ist strukturell: es gibt keinen +// Code-Pfad, der eine unbekannte Gruppe irgendeiner Rolle zuordnet. +type RoleMappingStore struct { + pool *pgxpool.Pool +} + +func NewRoleMappingStore(pool *pgxpool.Pool) *RoleMappingStore { + return &RoleMappingStore{pool: pool} +} + +// SetMapping ordnet eine LDAP-Gruppe genau einer NEXARCH-Rolle zu. Nur +// 'user'/'tenant_admin' sind zuweisbar (dieselbe Matrix wie RBAC-01/03) — +// 'superadmin' bleibt mandantenuebergreifend und nie ueber LDAP erreichbar. +func (s *RoleMappingStore) SetMapping(ctx context.Context, ldapGroup string, role rbac.Role) error { + if role != rbac.RoleUser && role != rbac.RoleTenantAdmin { + return fmt.Errorf("ldapsync: rolle %q ist ueber ldap nicht zuweisbar", role) + } + _, err := s.pool.Exec(ctx, ` + INSERT INTO ldap_group_role_mapping (ldap_group, role) VALUES ($1, $2) + ON CONFLICT (ldap_group) DO UPDATE SET role = $2 + `, ldapGroup, string(role)) + if err != nil { + return fmt.Errorf("gruppenzuordnung speichern: %w", err) + } + return nil +} + +// roleFor liefert die einer LDAP-Gruppe zugeordnete Rolle, sofern konfiguriert. +func (s *RoleMappingStore) roleFor(ctx context.Context, ldapGroup string) (rbac.Role, bool, error) { + var role string + err := s.pool.QueryRow(ctx, `SELECT role FROM ldap_group_role_mapping WHERE ldap_group = $1`, ldapGroup).Scan(&role) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return "", false, nil + } + return "", false, fmt.Errorf("gruppenzuordnung lesen: %w", err) + } + return rbac.Role(role), true, nil +} + +// HighestRoleFor bestimmt aus einer Liste von LDAP-Gruppen die hoechste +// zugeordnete Rolle (tenant_admin > user). Gruppen ohne Eintrag in der +// Matrix tragen NICHTS bei — auch nicht, wenn ihr Name zufaellig wie eine +// interne Rolle aussieht (Akzeptanzkriterium 3 / Pruefung 1: keine +// Privilege-Escalation ueber Gruppenmitgliedschaft). +func (s *RoleMappingStore) HighestRoleFor(ctx context.Context, ldapGroups []string) (rbac.Role, bool, error) { + var best rbac.Role + found := false + + for _, g := range ldapGroups { + role, ok, err := s.roleFor(ctx, g) + if err != nil { + return "", false, err + } + if !ok { + continue + } + if !found || role == rbac.RoleTenantAdmin { + best = role + found = true + } + } + return best, found, nil +} diff --git a/internal/ldapsync/sync.go b/internal/ldapsync/sync.go new file mode 100644 index 0000000..3ea1a17 --- /dev/null +++ b/internal/ldapsync/sync.go @@ -0,0 +1,93 @@ +package ldapsync + +import ( + "context" + "errors" + "fmt" + + "gitea.perlbach24.de/scripte/nexarch/internal/rbac" + "gitea.perlbach24.de/scripte/nexarch/internal/user" +) + +// SyncResult fasst das Ergebnis eines Synchronisationslaufs zusammen. +type SyncResult struct { + Created int + Updated int + Deactivated int + Failed []string // Email-Adressen, bei denen die Verarbeitung fehlschlug +} + +// Syncer fuehrt die Benutzer-/Rollen-Synchronisation aus LDAP aus. +type Syncer struct { + client Client + users *user.TenantUserStore + roles *rbac.Store + mappings *RoleMappingStore +} + +func NewSyncer(client Client, users *user.TenantUserStore, roles *rbac.Store, mappings *RoleMappingStore) *Syncer { + return &Syncer{client: client, users: users, roles: roles, mappings: mappings} +} + +// Run synchronisiert Benutzer aus LDAP (Akzeptanzkriterium 1). Ist die +// LDAP-Quelle nicht erreichbar/fehlerhaft, wird SOFORT und OHNE jede +// Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2 / +// Pruefung 2) — Search() wird als allererstes aufgerufen, bevor irgendein +// Schreibzugriff stattfindet. +func (s *Syncer) Run(ctx context.Context) (SyncResult, error) { + entries, err := s.client.Search() + if err != nil { + return SyncResult{}, fmt.Errorf("ldap-quelle nicht erreichbar, synchronisation abgebrochen: %w", err) + } + + var result SyncResult + for _, entry := range entries { + if err := s.syncOne(ctx, entry, &result); err != nil { + // Ein fehlerhafter Einzeleintrag isoliert sich selbst — er + // beschaedigt weder bereits verarbeitete noch nachfolgende + // Konten (Akzeptanzkriterium 2). + result.Failed = append(result.Failed, entry.Email) + } + } + return result, nil +} + +func (s *Syncer) syncOne(ctx context.Context, entry Entry, result *SyncResult) error { + existing, err := s.users.GetByEmailForAuth(ctx, entry.Email) + isNew := errors.Is(err, user.ErrNotFound) + if err != nil && !isNew { + return err + } + + var userID string + if isNew { + created, err := s.users.Create(ctx, entry.Email, entry.Name) + if err != nil { + return err + } + userID = created.ID + result.Created++ + } else { + userID = existing.User.ID + result.Updated++ + } + + // Deaktivierung in LDAP wird uebernommen (Akzeptanzkriterium 3 / Pruefung 3). + if entry.Disabled { + if _, err := s.users.Deactivate(ctx, userID); err != nil { + return err + } + result.Deactivated++ + } + + role, ok, err := s.mappings.HighestRoleFor(ctx, entry.Groups) + if err != nil { + return err + } + if ok { + if _, err := s.roles.Assign(ctx, userID, role, "ldap-sync"); err != nil { + return err + } + } + return nil +} 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/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/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/migrations/tenant/0003_ldap.down.sql b/migrations/tenant/0003_ldap.down.sql new file mode 100644 index 0000000..3905754 --- /dev/null +++ b/migrations/tenant/0003_ldap.down.sql @@ -0,0 +1,2 @@ +DROP TABLE IF EXISTS ldap_group_role_mapping; +DROP TABLE IF EXISTS ldap_config; diff --git a/migrations/tenant/0003_ldap.up.sql b/migrations/tenant/0003_ldap.up.sql new file mode 100644 index 0000000..8bf2165 --- /dev/null +++ b/migrations/tenant/0003_ldap.up.sql @@ -0,0 +1,22 @@ +-- LDAP/Active-Directory-Anbindung (IAM-05, siehe core-kanban/tickets/IAM-05.md). +-- Bind-Credentials liegen NIE in dieser Tabelle im Klartext — bind_password_env +-- nennt nur den Namen einer Umgebungsvariable, aus der das Passwort zur +-- Laufzeit gelesen wird (Projekt-Konvention: Secrets nur ueber Env-Vars). +CREATE TABLE ldap_config ( + id BOOLEAN PRIMARY KEY DEFAULT true CHECK (id), + url TEXT NOT NULL, + bind_dn TEXT NOT NULL, + bind_password_env TEXT NOT NULL, + base_dn TEXT NOT NULL, + user_filter TEXT NOT NULL DEFAULT '(objectClass=person)', + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Erlaubnis-Matrix LDAP-Gruppe -> NEXARCH-Rolle (Akzeptanzkriterium 3). +-- Eine LDAP-Gruppe OHNE Eintrag hier vergibt KEINE Rolle — kein impliziter +-- Zugriff durch Gruppennamen-Zufall (Privilege-Escalation-Schutz, siehe +-- "Bekannte Fehler vermeiden" im Ticket). +CREATE TABLE ldap_group_role_mapping ( + ldap_group TEXT PRIMARY KEY, + role TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')) +);