From ac070c160a7b7ea177597d16342b81f5e1acb499 Mon Sep 17 00:00:00 2001 From: sysops Date: Thu, 27 Aug 2026 22:15:25 +0200 Subject: [PATCH] IAM-07: account-lockout-login-rate-limiting MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit internal/lockout: Store.RecordFailure erhoeht failed_count ATOMAR ueber ein einziges Postgres-UPSERT und setzt locked_until, sobald die konfigurierte Schwelle erreicht ist — Zustand lebt ausschliesslich in Postgres, mehrere Core-Instanzen teilen sich denselben Zaehler (Akzeptanzkriterium 2, bekannter Fehler aus archivdms internal/auth/ratelimit.go vermieden: kein In-Process-Zaehler). IsLocked vergleicht nur locked_until gegen die aktuelle Zeit — eine abgelaufene Sperre gilt automatisch als aufgehoben, ohne explizite Entsperr-Aktion (Akzeptanzkriterium 3). Unlock erlaubt zusaetzlich sofortige Entsperrung durch Administratoreingriff. GuardedLogin komponiert IAM-02s LoginService mit dem Lockout-Zustand, ohne LoginService selbst zu veraendern: prueft die Sperre vor jedem Versuch, vermerkt Erfolg/Fehlschlag danach. Bugfix waehrend Tests: die Sperrzeit wurde als Ganzzahl-Sekunden in die Postgres-INTERVAL-Berechnung eingesetzt (int(duration.Seconds())), wodurch Sperrzeiten unter 1 Sekunde (z.B. in Tests) auf 0 abgerundet wurden und die Sperre sofort wieder als abgelaufen galt — auf Fliesskomma-Sekunden umgestellt. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Zwei parallel laufende Dienstinstanzen teilen sich denselben Zaehler — TestRecordFailure_SharedAcrossInstances: zwei unabhaengige pgxpool.Pool- Verbindungen, Fehlversuche abwechselnd ueber beide, gemeinsame Schwelle wird erreicht. PASS. 2. Brute-Force-Sperre greift nach definierten Fehlversuchen zuverlaessig — TestRecordFailure_LocksAfterThreshold. PASS. 3. Zeitversatz zwischen Sperre und Entsperrung automatisiert getestet — TestIsLocked_AutoUnlocksAfterExpiry: gesperrt vor Ablauf, automatisch entsperrt nach Ablauf der Sperrzeit. PASS. Zusaetzlich: TestGuardedLogin_LocksAfterRepeatedFailures belegt das Zusammenspiel mit dem echten IAM-02-LoginService End-to-End — selbst das korrekte Passwort wird nach Sperrung abgewiesen. PASS. Co-Authored-By: Claude Sonnet 5 --- internal/lockout/guarded_login.go | 37 +++ internal/lockout/lockout.go | 103 ++++++++ internal/lockout/lockout_test.go | 233 ++++++++++++++++++ .../tenant/0003_login_attempts.down.sql | 1 + migrations/tenant/0003_login_attempts.up.sql | 10 + scripts/reset-test-env.sh | 11 + scripts/run-checks.sh | 12 + 7 files changed, 407 insertions(+) create mode 100644 internal/lockout/guarded_login.go create mode 100644 internal/lockout/lockout.go create mode 100644 internal/lockout/lockout_test.go create mode 100644 migrations/tenant/0003_login_attempts.down.sql create mode 100644 migrations/tenant/0003_login_attempts.up.sql create mode 100755 scripts/reset-test-env.sh create mode 100755 scripts/run-checks.sh diff --git a/internal/lockout/guarded_login.go b/internal/lockout/guarded_login.go new file mode 100644 index 0000000..0ddccaf --- /dev/null +++ b/internal/lockout/guarded_login.go @@ -0,0 +1,37 @@ +package lockout + +import ( + "context" + "errors" + + "gitea.perlbach24.de/scripte/nexarch/internal/auth" +) + +var ErrAccountLocked = errors.New("lockout: konto ist vorübergehend gesperrt") + +// GuardedLogin komponiert IAM-02s LoginService mit dem Lockout-Zustand, +// OHNE LoginService selbst zu veraendern (kein Umbau der Vorbedingung): +// vor jedem Login-Versuch wird die Sperre geprueft, nach jedem Versuch wird +// Erfolg/Fehlschlag im geteilten Postgres-Zustand vermerkt. +func GuardedLogin(ctx context.Context, store *Store, login *auth.LoginService, email, password string) (string, error) { + locked, _, err := store.IsLocked(ctx, email) + if err != nil { + return "", err + } + if locked { + return "", ErrAccountLocked + } + + token, err := login.Login(ctx, email, password) + if err != nil { + if _, _, lockErr := store.RecordFailure(ctx, email); lockErr != nil { + return "", lockErr + } + return "", err + } + + if err := store.RecordSuccess(ctx, email); err != nil { + return "", err + } + return token, nil +} diff --git a/internal/lockout/lockout.go b/internal/lockout/lockout.go new file mode 100644 index 0000000..438d2f1 --- /dev/null +++ b/internal/lockout/lockout.go @@ -0,0 +1,103 @@ +// Package lockout implementiert Core IAM-07: Account-Lockout nach +// Fehlversuchen und Login-Rate-Limiting mit geteiltem, externem +// (Postgres-basiertem) Zustand — kein In-Process-Zaehler, der bei +// Mehrinstanzbetrieb aushebelbar waere (bekannter Fehler aus archivdms +// internal/auth/ratelimit.go). +package lockout + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +// DefaultMaxFailedAttempts/DefaultLockoutDuration sind explizit benannte +// Defaults, ueberschreibbar via WithPolicy. +const ( + DefaultMaxFailedAttempts = 5 + DefaultLockoutDuration = 15 * time.Minute +) + +type Store struct { + pool *pgxpool.Pool + maxFailed int + lockoutDuration time.Duration +} + +func NewStore(pool *pgxpool.Pool) *Store { + return &Store{pool: pool, maxFailed: DefaultMaxFailedAttempts, lockoutDuration: DefaultLockoutDuration} +} + +func (s *Store) WithPolicy(maxFailed int, lockoutDuration time.Duration) *Store { + return &Store{pool: s.pool, maxFailed: maxFailed, lockoutDuration: lockoutDuration} +} + +// IsLocked prueft, ob ein Konto aktuell gesperrt ist. Eine abgelaufene +// Sperre gilt automatisch als nicht mehr gesperrt (Akzeptanzkriterium 3) — +// es ist keine explizite Entsperr-Aktion noetig, der Zeitvergleich reicht. +func (s *Store) IsLocked(ctx context.Context, email string) (locked bool, lockedUntil time.Time, err error) { + err = s.pool.QueryRow(ctx, ` + SELECT locked_until FROM login_attempts WHERE email = $1 AND locked_until IS NOT NULL + `, email).Scan(&lockedUntil) + if err != nil { + return false, time.Time{}, nil // kein Datensatz oder kein Lock -> nicht gesperrt + } + return time.Now().Before(lockedUntil), lockedUntil, nil +} + +// RecordFailure erhoeht den Fehlversuchszaehler ATOMAR (UPSERT) und sperrt +// das Konto, sobald die Schwelle erreicht ist (Akzeptanzkriterium 1 / 2). +// Der Zustand liegt ausschliesslich in Postgres, mehrere Core-Instanzen +// teilen sich denselben Zaehler (Akzeptanzkriterium 2). +func (s *Store) RecordFailure(ctx context.Context, email string) (locked bool, lockedUntil time.Time, err error) { + var failedCount int + var lockedUntilPtr *time.Time + + err = s.pool.QueryRow(ctx, ` + INSERT INTO login_attempts (email, failed_count, locked_until, last_attempt_at) + VALUES ($1, 1, CASE WHEN 1 >= $2 THEN now() + $3::interval ELSE NULL END, now()) + ON CONFLICT (email) DO UPDATE SET + failed_count = login_attempts.failed_count + 1, + last_attempt_at = now(), + locked_until = CASE + WHEN login_attempts.failed_count + 1 >= $2 THEN now() + $3::interval + ELSE login_attempts.locked_until + END + RETURNING failed_count, locked_until + `, email, s.maxFailed, fmt.Sprintf("%f seconds", s.lockoutDuration.Seconds())).Scan(&failedCount, &lockedUntilPtr) + if err != nil { + return false, time.Time{}, fmt.Errorf("fehlversuch erfassen: %w", err) + } + + if lockedUntilPtr != nil { + return time.Now().Before(*lockedUntilPtr), *lockedUntilPtr, nil + } + return false, time.Time{}, nil +} + +// RecordSuccess setzt den Fehlversuchszaehler nach erfolgreichem Login zurueck. +func (s *Store) RecordSuccess(ctx context.Context, email string) error { + _, err := s.pool.Exec(ctx, ` + INSERT INTO login_attempts (email, failed_count, locked_until, last_attempt_at) + VALUES ($1, 0, NULL, now()) + ON CONFLICT (email) DO UPDATE SET failed_count = 0, locked_until = NULL, last_attempt_at = now() + `, email) + if err != nil { + return fmt.Errorf("erfolgreichen login erfassen: %w", err) + } + return nil +} + +// Unlock entsperrt ein Konto durch Administratoreingriff, unabhaengig von +// der Sperrzeit (Akzeptanzkriterium 3). +func (s *Store) Unlock(ctx context.Context, email string) error { + _, err := s.pool.Exec(ctx, ` + UPDATE login_attempts SET failed_count = 0, locked_until = NULL WHERE email = $1 + `, email) + if err != nil { + return fmt.Errorf("konto entsperren: %w", err) + } + return nil +} diff --git a/internal/lockout/lockout_test.go b/internal/lockout/lockout_test.go new file mode 100644 index 0000000..5fde51e --- /dev/null +++ b/internal/lockout/lockout_test.go @@ -0,0 +1,233 @@ +package lockout + +import ( + "context" + "errors" + "fmt" + "os" + "testing" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.perlbach24.de/scripte/nexarch/internal/auth" + "gitea.perlbach24.de/scripte/nexarch/internal/user" +) + +const schema = ` +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 login_attempts ( + email TEXT PRIMARY KEY, failed_count INT NOT NULL DEFAULT 0, + locked_until TIMESTAMPTZ, last_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now() +);` + +func setupTest(t *testing.T) (*pgxpool.Pool, 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, schema); err != nil { + t.Fatalf("schema: %v", err) + } + cleanup := func() { pool.Close() } + return pool, cleanup +} + +func uniqueEmail() string { + return fmt.Sprintf("lockout-test-%d@example.com", time.Now().UnixNano()) +} + +// Akzeptanzkriterium 1 + Pruefung 2: Sperre greift nach definierten +// Fehlversuchen zuverlaessig. +func TestRecordFailure_LocksAfterThreshold(t *testing.T) { + pool, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + store := NewStore(pool).WithPolicy(3, time.Hour) + email := uniqueEmail() + + for i := 0; i < 2; i++ { + locked, _, err := store.RecordFailure(ctx, email) + if err != nil { + t.Fatalf("record failure %d: %v", i, err) + } + if locked { + t.Fatalf("sollte nach %d fehlversuchen noch nicht gesperrt sein", i+1) + } + } + + locked, lockedUntil, err := store.RecordFailure(ctx, email) + if err != nil { + t.Fatalf("record failure 3: %v", err) + } + if !locked { + t.Fatal("erwartet gesperrt nach 3 fehlversuchen (schwelle=3)") + } + if !lockedUntil.After(time.Now()) { + t.Fatal("lockedUntil sollte in der zukunft liegen") + } + + isLocked, _, err := store.IsLocked(ctx, email) + if err != nil { + t.Fatalf("is locked: %v", err) + } + if !isLocked { + t.Fatal("IsLocked sollte true liefern") + } +} + +// Akzeptanzkriterium 2 + Pruefung 1: zwei Dienstinstanzen teilen sich +// denselben Zaehler (Mehrinstanz-Test) — hier durch zwei unabhaengige +// pgxpool.Pool-Verbindungen zur selben Datenbank simuliert. +func TestRecordFailure_SharedAcrossInstances(t *testing.T) { + _, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + email := uniqueEmail() + + adminDSN := os.Getenv("TEST_ADMIN_DSN") + instanceA, err := pgxpool.New(ctx, adminDSN) + if err != nil { + t.Fatalf("instance a: %v", err) + } + defer instanceA.Close() + instanceB, err := pgxpool.New(ctx, adminDSN) + if err != nil { + t.Fatalf("instance b: %v", err) + } + defer instanceB.Close() + + storeA := NewStore(instanceA).WithPolicy(4, time.Hour) + storeB := NewStore(instanceB).WithPolicy(4, time.Hour) + + // Zwei fehlversuche ueber "instanz A", zwei ueber "instanz B" — beide + // muessen sich denselben Zaehler teilen und gemeinsam die Schwelle erreichen. + if _, _, err := storeA.RecordFailure(ctx, email); err != nil { + t.Fatalf("a1: %v", err) + } + if _, _, err := storeB.RecordFailure(ctx, email); err != nil { + t.Fatalf("b1: %v", err) + } + if _, _, err := storeA.RecordFailure(ctx, email); err != nil { + t.Fatalf("a2: %v", err) + } + locked, _, err := storeB.RecordFailure(ctx, email) + if err != nil { + t.Fatalf("b2: %v", err) + } + if !locked { + t.Fatal("erwartet gesperrt nach insgesamt 4 fehlversuchen ueber beide instanzen hinweg") + } +} + +// Akzeptanzkriterium 3 + Pruefung 3: automatische Entsperrung nach Ablauf +// der Sperrzeit, Zeitversatz automatisiert getestet. +func TestIsLocked_AutoUnlocksAfterExpiry(t *testing.T) { + pool, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + store := NewStore(pool).WithPolicy(1, 50*time.Millisecond) + email := uniqueEmail() + + locked, _, err := store.RecordFailure(ctx, email) + if err != nil { + t.Fatalf("record failure: %v", err) + } + if !locked { + t.Fatal("erwartet sofort gesperrt bei schwelle=1") + } + + isLocked, _, err := store.IsLocked(ctx, email) + if err != nil { + t.Fatalf("is locked (vor ablauf): %v", err) + } + if !isLocked { + t.Fatal("erwartet gesperrt vor ablauf der sperrzeit") + } + + time.Sleep(70 * time.Millisecond) + + isLocked, _, err = store.IsLocked(ctx, email) + if err != nil { + t.Fatalf("is locked (nach ablauf): %v", err) + } + if isLocked { + t.Fatal("erwartet automatisch entsperrt nach ablauf der sperrzeit") + } +} + +// Akzeptanzkriterium 3: Entsperrung durch Administratoreingriff. +func TestUnlock_ClearsLockImmediately(t *testing.T) { + pool, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + store := NewStore(pool).WithPolicy(1, time.Hour) + email := uniqueEmail() + + if _, _, err := store.RecordFailure(ctx, email); err != nil { + t.Fatalf("record failure: %v", err) + } + locked, _, _ := store.IsLocked(ctx, email) + if !locked { + t.Fatal("erwartet gesperrt vor admin-eingriff") + } + + if err := store.Unlock(ctx, email); err != nil { + t.Fatalf("unlock: %v", err) + } + locked, _, err := store.IsLocked(ctx, email) + if err != nil { + t.Fatalf("is locked nach unlock: %v", err) + } + if locked { + t.Fatal("erwartet sofort entsperrt nach admin-eingriff, unabhaengig von der sperrzeit") + } +} + +// Integrationstest: GuardedLogin komponiert IAM-02 LoginService mit dem +// Lockout-Zustand, ohne LoginService selbst zu veraendern. +func TestGuardedLogin_LocksAfterRepeatedFailures(t *testing.T) { + pool, cleanup := setupTest(t) + defer cleanup() + ctx := context.Background() + + email := uniqueEmail() + userStore := user.NewTenantUserStore(pool) + u, err := userStore.Create(ctx, email, "Lockout Test") + if err != nil { + t.Fatalf("create user: %v", err) + } + hash, err := auth.HashPassword("korrektes-passwort") + if err != nil { + t.Fatalf("hash: %v", err) + } + if err := userStore.SetPasswordHash(ctx, u.ID, hash); err != nil { + t.Fatalf("set password: %v", err) + } + + issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests") + loginService := auth.NewLoginService(userStore, issuer, "acme") + lockoutStore := NewStore(pool).WithPolicy(3, time.Hour) + + for i := 0; i < 3; i++ { + if _, err := GuardedLogin(ctx, lockoutStore, loginService, email, "falsches-passwort"); !errors.Is(err, auth.ErrInvalidCredentials) { + t.Fatalf("versuch %d: erwartet ErrInvalidCredentials, habe %v", i, err) + } + } + + // Selbst das RICHTIGE Passwort wird jetzt abgewiesen, weil das Konto gesperrt ist. + if _, err := GuardedLogin(ctx, lockoutStore, loginService, email, "korrektes-passwort"); !errors.Is(err, ErrAccountLocked) { + t.Fatalf("erwartet ErrAccountLocked trotz korrektem passwort, habe %v", err) + } +} diff --git a/migrations/tenant/0003_login_attempts.down.sql b/migrations/tenant/0003_login_attempts.down.sql new file mode 100644 index 0000000..732a956 --- /dev/null +++ b/migrations/tenant/0003_login_attempts.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS login_attempts; diff --git a/migrations/tenant/0003_login_attempts.up.sql b/migrations/tenant/0003_login_attempts.up.sql new file mode 100644 index 0000000..bb2f215 --- /dev/null +++ b/migrations/tenant/0003_login_attempts.up.sql @@ -0,0 +1,10 @@ +-- Account-Lockout & Login-Rate-Limiting (IAM-07, siehe +-- core-kanban/tickets/IAM-07.md). Geteilter, externer Zustand in Postgres — +-- kein In-Process-Zaehler (bekannter Fehler aus archivdms +-- internal/auth/ratelimit.go), gilt korrekt ueber mehrere Core-Instanzen. +CREATE TABLE login_attempts ( + email TEXT PRIMARY KEY, + failed_count INT NOT NULL DEFAULT 0, + locked_until TIMESTAMPTZ, + last_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now() +); diff --git a/scripts/reset-test-env.sh b/scripts/reset-test-env.sh new file mode 100755 index 0000000..fab5903 --- /dev/null +++ b/scripts/reset-test-env.sh @@ -0,0 +1,11 @@ +#!/usr/bin/env bash +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..1c28c3c --- /dev/null +++ b/scripts/run-checks.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +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