IAM-14: passwort-richtlinien

internal/pwpolicy: Validate ist eine schmale Regelschicht VOR dem bcrypt-Hashing aus IAM-02, kein eigenes Policy-Framework. Prueft Mindestlaenge, Zeichenklassen (Gross-/Kleinbuchstaben, Ziffern, Sonderzeichen je nach Policy) und eine eingebettete Sperrliste haeufig verwendeter Passwoerter (case-insensitive) — Akzeptanzkriterium 1 + 2. Store haelt die Richtlinie als eine Zeile je Tenant-Datenbank (Singleton, Modell C), DefaultPolicy() greift, solange kein Tenant eine eigene gesetzt hat. LoginAndCheckPolicy komponiert IAM-02s LoginService, OHNE ihn zu veraendern: der Login selbst schlaegt bei einem alten, nicht mehr konformen Passwort NICHT fehl (Akzeptanzkriterium 3 — kein rueckwirkendes Aussperren), die Funktion liefert zusaetzlich mustChangePassword=true. Die Pruefung ist nur im Login-Moment moeglich, da dort kurzzeitig das Klartext-Passwort vorliegt — der gespeicherte bcrypt-Hash laesst sich nicht rueckwirkend gegen eine neue Richtlinie pruefen. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Zu kurzes/zu einfaches Passwort bei Registrierung/Aenderung abgelehnt — TestValidate_RejectsTooShortOrSimple. PASS. 2. Passwort aus Sperrliste abgelehnt — TestValidate_RejectsBlocklistedPassword (inkl. Gross-/Kleinschreibung). PASS. 3. Bestehender Nutzer mit altem, nicht-konformem Passwort kann sich noch einloggen, wird aber zur Aenderung aufgefordert — TestLoginAndCheckPolicy_FlagsNonConformantExistingPassword: Login mit schwachem Altpasswort gelingt, mustChangePassword=true; mit konformem Passwort mustChangePassword=false. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-27 22:26:23 +02:00
parent 3d20d86a4f
commit 3c4e9d45b8
8 changed files with 386 additions and 0 deletions
@@ -0,0 +1,176 @@
+package pwpolicy
+
+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"
+)
+
+// Akzeptanzkriterium 1 + Pruefung 1: zu kurzes/zu einfaches Passwort abgelehnt.
+func TestValidate_RejectsTooShortOrSimple(t *testing.T) {
+	policy := DefaultPolicy()
+
+	if err := Validate(policy, "kurz1A"); !errors.Is(err, ErrPasswordTooWeak) {
+		t.Fatalf("erwartet ErrPasswordTooWeak fuer zu kurzes passwort, habe %v", err)
+	}
+	if err := Validate(policy, "alleskleingeschriebenundlang123"); !errors.Is(err, ErrPasswordTooWeak) {
+		t.Fatalf("erwartet ErrPasswordTooWeak ohne grossbuchstaben, habe %v", err)
+	}
+	if err := Validate(policy, "GutesPasswort2026!"); err != nil {
+		t.Fatalf("erwartet gueltig, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Passwort aus Sperrliste abgelehnt.
+func TestValidate_RejectsBlocklistedPassword(t *testing.T) {
+	policy := Policy{MinLength: 4} // absichtlich schwach, damit NUR die sperrliste greift
+
+	if err := Validate(policy, "password"); !errors.Is(err, ErrPasswordTooWeak) {
+		t.Fatalf("erwartet ErrPasswordTooWeak fuer sperrlisten-passwort, habe %v", err)
+	}
+	if err := Validate(policy, "PASSWORD"); !errors.Is(err, ErrPasswordTooWeak) {
+		t.Fatalf("erwartet case-insensitive treffer auf der sperrliste, habe %v", err)
+	}
+	if err := Validate(policy, "ein-eher-unueblicher-satz"); err != nil {
+		t.Fatalf("nicht-sperrlisten-passwort sollte hier gueltig sein: %v", err)
+	}
+}
+
+func setupTest(t *testing.T) (*Store, *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, `
+		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 password_policy (
+			id BOOLEAN PRIMARY KEY DEFAULT true CHECK (id), min_length INT NOT NULL DEFAULT 12,
+			require_upper BOOLEAN NOT NULL DEFAULT true, require_lower BOOLEAN NOT NULL DEFAULT true,
+			require_digit BOOLEAN NOT NULL DEFAULT true, require_special BOOLEAN NOT NULL DEFAULT false,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	// Singleton-Tabelle: vor jedem Test leeren, falls ein vorheriger Lauf
+	// (in dieser geteilten Registry-Tabelle) eine Zeile hinterlassen hat.
+	if _, err := pool.Exec(ctx, `DELETE FROM password_policy`); err != nil {
+		t.Fatalf("vorab-bereinigung: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM password_policy`)
+		pool.Close()
+	}
+	return NewStore(pool), pool, cleanup
+}
+
+func TestStore_GetReturnsDefaultWhenUnset(t *testing.T) {
+	store, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	got, err := store.Get(ctx)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got != DefaultPolicy() {
+		t.Fatalf("erwartet default policy, habe %+v", got)
+	}
+}
+
+func TestStore_SetAndGetRoundTrip(t *testing.T) {
+	store, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	custom := Policy{MinLength: 16, RequireUpper: true, RequireLower: true, RequireDigit: true, RequireSpecial: true}
+	if err := store.Set(ctx, custom); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	got, err := store.Get(ctx)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got != custom {
+		t.Fatalf("erwartet %+v, habe %+v", custom, got)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: bestehender Nutzer mit altem,
+// nicht-konformem Passwort kann sich noch einloggen, wird aber zur
+// Aenderung aufgefordert — kein rueckwirkendes Aussperren.
+func TestLoginAndCheckPolicy_FlagsNonConformantExistingPassword(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	email := fmt.Sprintf("pwpolicy-test-%d@example.com", time.Now().UnixNano())
+	userStore := user.NewTenantUserStore(pool)
+	u, err := userStore.Create(ctx, email, "Legacy User")
+	if err != nil {
+		t.Fatalf("create user: %v", err)
+	}
+
+	// Altes Passwort, das VOR der heutigen Richtlinie gesetzt wurde — erfuellt
+	// die aktuelle DefaultPolicy() nicht (kein Grossbuchstabe, zu kurz).
+	oldPassword := "altespasswort"
+	hash, err := auth.HashPassword(oldPassword)
+	if err != nil {
+		t.Fatalf("hash: %v", err)
+	}
+	if err := userStore.SetPasswordHash(ctx, u.ID, hash); err != nil {
+		t.Fatalf("set password hash: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
+	loginService := auth.NewLoginService(userStore, issuer, "acme")
+
+	token, mustChange, err := LoginAndCheckPolicy(ctx, store, loginService, email, oldPassword)
+	if err != nil {
+		t.Fatalf("login sollte trotz schwachem altpasswort gelingen: %v", err)
+	}
+	if token == "" {
+		t.Fatal("erwartet gueltiges token")
+	}
+	if !mustChange {
+		t.Fatal("erwartet mustChangePassword=true fuer nicht-konformes altpasswort")
+	}
+
+	// Konformes Passwort -> kein Aenderungszwang.
+	strongPassword := "EinStarkesPasswort2026!"
+	hash2, err := auth.HashPassword(strongPassword)
+	if err != nil {
+		t.Fatalf("hash 2: %v", err)
+	}
+	if err := userStore.SetPasswordHash(ctx, u.ID, hash2); err != nil {
+		t.Fatalf("set password hash 2: %v", err)
+	}
+	_, mustChange, err = LoginAndCheckPolicy(ctx, store, loginService, email, strongPassword)
+	if err != nil {
+		t.Fatalf("login mit starkem passwort: %v", err)
+	}
+	if mustChange {
+		t.Fatal("erwartet mustChangePassword=false fuer konformes passwort")
+	}
+}