Files
nexarch/internal/user/superadmin_store.go
patrickandClaude Sonnet 5 4fc361b462
Supply-Chain-Scan (Go) / govulncheck (push) Failing after 41s
TEN-09: registry-h-rtung-zugriffsschutz
Haertet die Control-Plane-Registry als eigene Schutzzone:

- Dedizierte Postgres-Rolle nexarch_registry (ohne CREATEDB) fuer
  NEXARCH_REGISTRY_DSN, getrennt von der Provisioning-Rolle nexarch_core
  (deploy/install.sh). Neu angelegte Tenant-Datenbanken entziehen PUBLIC
  explizit das CONNECT-Recht (internal/tenant/provisioner.go), damit die
  Registry-Rolle unter keinen Umstaenden Zugriff auf eine Tenant-Datenbank
  erhaelt (Akzeptanzkriterium 1).
- Auditierte Zugriffsmethoden (*AsActor) fuer Superadmin-Konten
  (internal/user.SuperadminStore) und Verbindungsinformationen
  (internal/tenant.Registry) — jeder lesende/schreibende Zugriff erzeugt
  einen Audit-Event mit Akteur und Zeitstempel, verdrahtet in
  internal/tenantadmin (TEN-05-Konsole) und cmd/core (Akzeptanzkriterium 2).
- Betriebsanleitung docs/TEN-09-REGISTRY-BETRIEB.md dokumentiert
  Rollentrennung und den auf den Core-Dienst beschraenkten Netzwerkzugriff
  (pg_hba.conf, listen_addresses, Firewall-Default-Policy), abgesichert
  durch internal/opsdocs/registry_hardening_test.go (Akzeptanzkriterium 3).

Automatisierte Tests je Akzeptanzkriterium: internal/tenant/isolation_test.go
(negativer Zugriffstest), internal/audit/wiring_test.go
(TestWiring_SuperadminReadIsAudited, TestWiring_RegistryConnectionInfoReadIsAudited),
internal/opsdocs/registry_hardening_test.go.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QPsyieCYwvbUBsnN598SbP
2026-09-17 01:37:40 +02:00

152 lines
4.9 KiB
Go

package user
import (
"context"
"fmt"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.perlbach24.de/scripte/nexarch/internal/audit"
)
// SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
// Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
// Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
// TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
// koennte (IAM-01, "ohne Sonderbehandlung im Code").
type SuperadminStore struct {
pool *pgxpool.Pool
audit *audit.Log
}
func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
return &SuperadminStore{pool: pool}
}
// WithAudit liefert einen SuperadminStore, der jeden lesenden und
// schreibenden Zugriff auf Superadmin-Konten zusaetzlich im zentralen,
// unveraenderlichen Audit-Log protokolliert (TEN-09 Akzeptanzkriterium 2,
// Konvention aus AUD-06 uebernommen: additiv, audit == nil bleibt gueltig
// und aendert das Verhalten bestehender Aufrufer/Tests nicht).
func (s *SuperadminStore) WithAudit(log *audit.Log) *SuperadminStore {
return &SuperadminStore{pool: s.pool, audit: log}
}
// recordAccess protokolliert genau einen Zugriff auf ein Superadmin-Konto.
// Wird nur nach einer erfolgreichen Operation aufgerufen (siehe Aufrufer) —
// derselbe Grundsatz wie tenant.Registry.transition: ein Audit-Fehler
// blockiert die eigentliche Operation nicht.
func (s *SuperadminStore) recordAccess(ctx context.Context, actor, action, target string) {
if s.audit == nil {
return
}
_ = s.audit.Record(ctx, audit.Event{
TenantSlug: audit.SystemTenant,
Actor: actor,
Action: action,
Target: target,
})
}
func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
if err := ValidateEmail(email); err != nil {
return User{}, err
}
var u User
u.Email, u.Name, u.Status = email, name, StatusActive
row := s.pool.QueryRow(ctx, `
INSERT INTO superadmins (email, name, status)
VALUES ($1, $2, $3)
RETURNING id, created_at, updated_at
`, u.Email, u.Name, u.Status)
if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
return User{}, mapWriteErr(err)
}
return u, nil
}
func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
return scanUser(s.pool.QueryRow(ctx, `
SELECT id, email, name, status, created_at, updated_at
FROM superadmins WHERE id = $1
`, id))
}
func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
rows, err := s.pool.Query(ctx, `
SELECT id, email, name, status, created_at, updated_at
FROM superadmins ORDER BY created_at
`)
if err != nil {
return nil, fmt.Errorf("superadmins auflisten: %w", err)
}
defer rows.Close()
var out []User
for rows.Next() {
var u User
if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
return nil, fmt.Errorf("superadmin lesen: %w", err)
}
out = append(out, u)
}
return out, rows.Err()
}
func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
return scanUser(s.pool.QueryRow(ctx, `
UPDATE superadmins SET status = $2, updated_at = now()
WHERE id = $1
RETURNING id, email, name, status, created_at, updated_at
`, id, StatusInactive))
}
// --- Auditierte Varianten (TEN-09 Akzeptanzkriterium 2) ---
//
// Eigene "AsActor"-Methoden statt Aenderung der bestehenden Signaturen:
// Create/Get/List/Deactivate werden bereits an mehreren Stellen ohne
// bekannten Akteur aufgerufen (z.B. interne Berechtigungspruefungen) — die
// bestehenden Methoden bleiben deshalb unveraendert nutzbar, waehrend jeder
// Aufrufer, der einen echten Akteur kennt (z.B. die eingeloggte Person in
// der Tenant-Verwaltungsoberflaeche, TEN-05), die auditierte Variante nutzt.
// CreateAsActor protokolliert die Neuanlage eines Superadmin-Kontos.
func (s *SuperadminStore) CreateAsActor(ctx context.Context, actor, email, name string) (User, error) {
u, err := s.Create(ctx, email, name)
if err == nil {
s.recordAccess(ctx, actor, "superadmin.create", u.ID)
}
return u, err
}
// GetAsActor protokolliert den lesenden Zugriff auf genau ein Superadmin-Konto.
func (s *SuperadminStore) GetAsActor(ctx context.Context, actor, id string) (User, error) {
u, err := s.Get(ctx, id)
if err == nil {
s.recordAccess(ctx, actor, "superadmin.read", id)
}
return u, err
}
// ListAsActor protokolliert den lesenden Zugriff auf die vollstaendige
// Superadmin-Liste.
func (s *SuperadminStore) ListAsActor(ctx context.Context, actor string) ([]User, error) {
list, err := s.List(ctx)
if err == nil {
s.recordAccess(ctx, actor, "superadmin.list", "all")
}
return list, err
}
// DeactivateAsActor protokolliert die Deaktivierung eines Superadmin-Kontos.
func (s *SuperadminStore) DeactivateAsActor(ctx context.Context, actor, id string) (User, error) {
u, err := s.Deactivate(ctx, id)
if err == nil {
s.recordAccess(ctx, actor, "superadmin.deactivate", id)
}
return u, err
}