IAM-12: aktive-sitzungen-verwaltung

internal/session: Selbstbedienungs-Sitzungsuebersicht mit widerrufbarem,
SERVERSEITIGEM Zustand — bewusst ein separater Mechanismus neben IAM-02s
zustandslosem JWT (das fuer schnelle Modul-zu-Modul-Verifikation ohne
Core-Rueckfrage gewaehlt wurde, siehe API-05). Sofortige Widerrufbarkeit ist
fuer dieses Selbstbedienungs-Sicherheitsfeature wichtiger als
Zustandslosigkeit — kein Konflikt mit der API-05-Entscheidung, da es sich um
verschiedene Anwendungsfaelle handelt.

Store.Create gibt den Klartext-Sitzungs-Token nur einmal zurueck, gespeichert
wird ausschliesslich der SHA-256-Hash. Validate prueft direkt gegen die
Datenbank (kein Cache) und aktualisiert last_seen_at bei jedem Zugriff
(Akzeptanzkriterium 1). Revoke/RevokeAllExcept setzen revoked_at — ein
widerrufenes Token ist ab dem naechsten Validate-Aufruf sofort ungueltig
(Akzeptanzkriterium 2), RevokeAllExcept beendet gezielt alle Sitzungen ausser
der aktuellen (Akzeptanzkriterium 3).

LoginAndCreateSession verwendet auth.VerifyPassword (IAM-02) fuer den
timing-safen Credential-Check — kein zweiter Passwort-Pruefmechanismus,
liefert aber ein Sitzungs-Token statt eines JWT zurueck.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Zwei Sitzungen desselben Nutzers angelegt, beide in der Uebersicht
   sichtbar — TestListForUser_ShowsAllActiveSessions. PASS.
2. Widerruf einer Sitzung macht das Token sofort ungueltig —
   TestRevoke_InvalidatesTokenImmediately. PASS.
3. "Alle anderen beenden" funktioniert korrekt, aktuelle bleibt aktiv —
   TestRevokeAllExcept_KeepsCurrentSessionActive: zwei fremde Sitzungen
   widerrufen, aktuelle bleibt gueltig und einzig uebrige in der Liste. PASS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

internal/pwpolicy/blocklist.go

@@ -1,33 +0,0 @@
-package pwpolicy
-
-// commonPasswords ist eine kleine, eingebettete Sperrliste bekannt
-// haeufig verwendeter/kompromittierter Passwoerter (Akzeptanzkriterium 2).
-// Vergleich erfolgt case-insensitive (siehe Validate).
-var commonPasswords = map[string]bool{
-	"123456":     true,
-	"password":   true,
-	"12345678":   true,
-	"qwerty":     true,
-	"123456789":  true,
-	"12345":      true,
-	"1234":       true,
-	"111111":     true,
-	"1234567":    true,
-	"dragon":     true,
-	"123123":     true,
-	"baseball":   true,
-	"iloveyou":   true,
-	"trustno1":   true,
-	"1234567890": true,
-	"sunshine":   true,
-	"master":     true,
-	"welcome":    true,
-	"admin":      true,
-	"letmein":    true,
-	"login":      true,
-	"passw0rd":   true,
-	"starwars":   true,
-	"abc123":     true,
-	"password1":  true,
-	"qwerty123":  true,
-}

internal/pwpolicy/login_check.go

@@ -1,30 +0,0 @@
-package pwpolicy
-
-import (
-	"context"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-)
-
-// LoginAndCheckPolicy komponiert IAM-02s LoginService mit der Passwort-
-// Richtlinienpruefung, OHNE LoginService selbst zu veraendern. Ein
-// bestehender Benutzer mit einem alten, nicht mehr konformen Passwort kann
-// sich weiterhin einloggen (Login schlaegt NICHT fehl) — er wird lediglich
-// zur Aenderung aufgefordert (Akzeptanzkriterium 3: kein rueckwirkendes
-// Aussperren). Die Pruefung ist nur HIER moeglich, da nur beim Login das
-// Klartext-Passwort kurzzeitig vorliegt — der gespeicherte bcrypt-Hash laesst
-// sich nicht rueckwirkend gegen eine neue Richtlinie pruefen.
-func LoginAndCheckPolicy(ctx context.Context, policies *Store, login *auth.LoginService, email, password string) (token string, mustChangePassword bool, err error) {
-	token, err = login.Login(ctx, email, password)
-	if err != nil {
-		return "", false, err
-	}
-
-	policy, err := policies.Get(ctx)
-	if err != nil {
-		return "", false, err
-	}
-
-	mustChangePassword = Validate(policy, password) != nil
-	return token, mustChangePassword, nil
-}

internal/pwpolicy/policy.go

@@ -1,112 +0,0 @@
-// Package pwpolicy implementiert Core IAM-14: konfigurierbare Passwort-
-// Komplexitätsanforderungen pro Tenant — eine schmale Regelschicht VOR dem
-// bcrypt-Hashing aus IAM-02, kein eigenes Policy-Framework.
-package pwpolicy
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-	"unicode"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// Policy sind die Mindestanforderungen (Akzeptanzkriterium 1).
-type Policy struct {
-	MinLength      int
-	RequireUpper   bool
-	RequireLower   bool
-	RequireDigit   bool
-	RequireSpecial bool
-}
-
-// DefaultPolicy gilt, solange ein Tenant keine eigene Konfiguration gesetzt hat.
-func DefaultPolicy() Policy {
-	return Policy{MinLength: 12, RequireUpper: true, RequireLower: true, RequireDigit: true, RequireSpecial: false}
-}
-
-var ErrPasswordTooWeak = errors.New("pwpolicy: passwort erfuellt die richtlinie nicht")
-
-// Validate prueft ein Passwort gegen policy UND die Sperrliste
-// (Akzeptanzkriterium 2). Liefert bei Verstoss ErrPasswordTooWeak,
-// gewrappt mit einer fuer Menschen lesbaren Begruendung.
-func Validate(policy Policy, password string) error {
-	if commonPasswords[strings.ToLower(password)] {
-		return fmt.Errorf("%w: passwort steht auf der sperrliste haeufig verwendeter passwoerter", ErrPasswordTooWeak)
-	}
-	if len(password) < policy.MinLength {
-		return fmt.Errorf("%w: mindestens %d zeichen erforderlich", ErrPasswordTooWeak, policy.MinLength)
-	}
-
-	var hasUpper, hasLower, hasDigit, hasSpecial bool
-	for _, r := range password {
-		switch {
-		case unicode.IsUpper(r):
-			hasUpper = true
-		case unicode.IsLower(r):
-			hasLower = true
-		case unicode.IsDigit(r):
-			hasDigit = true
-		case unicode.IsPunct(r) || unicode.IsSymbol(r):
-			hasSpecial = true
-		}
-	}
-
-	if policy.RequireUpper && !hasUpper {
-		return fmt.Errorf("%w: mindestens ein grossbuchstabe erforderlich", ErrPasswordTooWeak)
-	}
-	if policy.RequireLower && !hasLower {
-		return fmt.Errorf("%w: mindestens ein kleinbuchstabe erforderlich", ErrPasswordTooWeak)
-	}
-	if policy.RequireDigit && !hasDigit {
-		return fmt.Errorf("%w: mindestens eine ziffer erforderlich", ErrPasswordTooWeak)
-	}
-	if policy.RequireSpecial && !hasSpecial {
-		return fmt.Errorf("%w: mindestens ein sonderzeichen erforderlich", ErrPasswordTooWeak)
-	}
-	return nil
-}
-
-// Store verwaltet die pro-Tenant konfigurierte Richtlinie (eine Zeile je
-// Tenant-Datenbank, Modell C).
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// Get liefert die konfigurierte Richtlinie, oder DefaultPolicy() wenn noch
-// keine gesetzt wurde.
-func (s *Store) Get(ctx context.Context) (Policy, error) {
-	var p Policy
-	err := s.pool.QueryRow(ctx, `
-		SELECT min_length, require_upper, require_lower, require_digit, require_special
-		FROM password_policy WHERE id = true
-	`).Scan(&p.MinLength, &p.RequireUpper, &p.RequireLower, &p.RequireDigit, &p.RequireSpecial)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return DefaultPolicy(), nil
-		}
-		return Policy{}, fmt.Errorf("richtlinie lesen: %w", err)
-	}
-	return p, nil
-}
-
-// Set legt die Richtlinie fuer diesen Tenant fest (Akzeptanzkriterium 1).
-func (s *Store) Set(ctx context.Context, p Policy) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO password_policy (id, min_length, require_upper, require_lower, require_digit, require_special, updated_at)
-		VALUES (true, $1, $2, $3, $4, $5, now())
-		ON CONFLICT (id) DO UPDATE SET
-			min_length = $1, require_upper = $2, require_lower = $3, require_digit = $4, require_special = $5, updated_at = now()
-	`, p.MinLength, p.RequireUpper, p.RequireLower, p.RequireDigit, p.RequireSpecial)
-	if err != nil {
-		return fmt.Errorf("richtlinie speichern: %w", err)
-	}
-	return nil
-}

internal/pwpolicy/policy_test.go

@@ -1,176 +0,0 @@
-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")
-	}
-}

internal/session/login.go

@@ -0,0 +1,35 @@
+package session
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+// LoginAndCreateSession prueft die Anmeldedaten mit demselben timing-safen
+// bcrypt-Vergleich wie IAM-02s LoginService (kein zweiter Credential-Check),
+// erzeugt bei Erfolg aber eine widerrufbare Sitzung statt eines
+// zustandslosen JWT — das ist der Bearer-Token fuer diese Selbstbedienungs-
+// Funktion.
+func LoginAndCreateSession(ctx context.Context, users *user.TenantUserStore, sessions *Store, email, password, deviceInfo, ip string) (sessionToken string, err error) {
+	creds, err := users.GetByEmailForAuth(ctx, email)
+	if err != nil {
+		return "", fmt.Errorf("anmeldedaten pruefen: %w", err)
+	}
+	if creds.User.Status != user.StatusActive {
+		return "", fmt.Errorf("konto nicht aktiv")
+	}
+	// Wiederverwendung von IAM-02s timing-safem bcrypt-Vergleich, kein
+	// zweiter Passwort-Pruefmechanismus.
+	if !auth.VerifyPassword(creds.PasswordHash, password) {
+		return "", fmt.Errorf("anmeldedaten ungueltig")
+	}
+
+	_, sessionToken, err = sessions.Create(ctx, creds.User.ID, deviceInfo, ip)
+	if err != nil {
+		return "", fmt.Errorf("sitzung anlegen: %w", err)
+	}
+	return sessionToken, nil
+}

internal/session/session.go

@@ -0,0 +1,142 @@
+// Package session implementiert Core IAM-12: Selbstbedienungs-Sitzungs-
+// uebersicht mit Geraete-/Zugriffsinformationen und gezieltem Widerruf.
+// Bewusst serverseitig und widerrufbar — ein separater Mechanismus neben
+// IAM-02s zustandslosem JWT (das fuer schnelle Modul-zu-Modul-Verifikation
+// ohne Core-Rueckfrage gewaehlt wurde, siehe API-05). Fuer den
+// Selbstbedienungs-Anwendungsfall hier ist sofortige Widerrufbarkeit
+// wichtiger als Zustandslosigkeit.
+package session
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrSessionInvalid = errors.New("session: sitzung ungueltig oder widerrufen")
+
+type Session struct {
+	ID         string
+	UserID     string
+	DeviceInfo string
+	IP         string
+	CreatedAt  time.Time
+	LastSeenAt time.Time
+}
+
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Create legt eine neue Sitzung an und liefert den Klartext-Token NUR an den
+// Aufrufer zurueck (als Cookie-Wert) — gespeichert wird ausschliesslich der Hash.
+func (s *Store) Create(ctx context.Context, userID, deviceInfo, ip string) (id, token string, err error) {
+	token, err = randomToken()
+	if err != nil {
+		return "", "", fmt.Errorf("token erzeugen: %w", err)
+	}
+	hash := hashToken(token)
+
+	err = s.pool.QueryRow(ctx, `
+		INSERT INTO sessions (user_id, token_hash, device_info, ip)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, userID, hash, deviceInfo, ip).Scan(&id)
+	if err != nil {
+		return "", "", fmt.Errorf("sitzung anlegen: %w", err)
+	}
+	return id, token, nil
+}
+
+// Validate prueft ein Sitzungs-Token direkt gegen die Datenbank — kein
+// Cache, ein widerrufenes Token ist beim naechsten Zugriffsversuch sofort
+// ungueltig (Akzeptanzkriterium 2). Erfolgreiche Validierung aktualisiert
+// last_seen_at (Akzeptanzkriterium 1: letzter Zugriff).
+func (s *Store) Validate(ctx context.Context, token string) (Session, error) {
+	hash := hashToken(token)
+
+	var sess Session
+	err := s.pool.QueryRow(ctx, `
+		UPDATE sessions SET last_seen_at = now()
+		WHERE token_hash = $1 AND revoked_at IS NULL
+		RETURNING id, user_id, device_info, ip, created_at, last_seen_at
+	`, hash).Scan(&sess.ID, &sess.UserID, &sess.DeviceInfo, &sess.IP, &sess.CreatedAt, &sess.LastSeenAt)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Session{}, ErrSessionInvalid
+		}
+		return Session{}, fmt.Errorf("sitzung pruefen: %w", err)
+	}
+	return sess, nil
+}
+
+// ListForUser liefert alle NICHT widerrufenen Sitzungen eines Benutzers
+// (Akzeptanzkriterium 1).
+func (s *Store) ListForUser(ctx context.Context, userID string) ([]Session, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, user_id, device_info, ip, created_at, last_seen_at
+		FROM sessions WHERE user_id = $1 AND revoked_at IS NULL
+		ORDER BY last_seen_at DESC
+	`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("sitzungen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Session
+	for rows.Next() {
+		var sess Session
+		if err := rows.Scan(&sess.ID, &sess.UserID, &sess.DeviceInfo, &sess.IP, &sess.CreatedAt, &sess.LastSeenAt); err != nil {
+			return nil, fmt.Errorf("sitzung lesen: %w", err)
+		}
+		out = append(out, sess)
+	}
+	return out, rows.Err()
+}
+
+// Revoke widerruft eine einzelne Sitzung sofort (Akzeptanzkriterium 2).
+func (s *Store) Revoke(ctx context.Context, sessionID string) error {
+	_, err := s.pool.Exec(ctx, `UPDATE sessions SET revoked_at = now() WHERE id = $1`, sessionID)
+	if err != nil {
+		return fmt.Errorf("sitzung widerrufen: %w", err)
+	}
+	return nil
+}
+
+// RevokeAllExcept beendet alle Sitzungen eines Benutzers ausser der
+// angegebenen (Akzeptanzkriterium 3: "alle anderen beenden", aktuelle
+// Sitzung bleibt bestehen).
+func (s *Store) RevokeAllExcept(ctx context.Context, userID, keepSessionID string) error {
+	_, err := s.pool.Exec(ctx, `
+		UPDATE sessions SET revoked_at = now()
+		WHERE user_id = $1 AND id <> $2 AND revoked_at IS NULL
+	`, userID, keepSessionID)
+	if err != nil {
+		return fmt.Errorf("andere sitzungen widerrufen: %w", err)
+	}
+	return nil
+}
+
+func randomToken() (string, error) {
+	buf := make([]byte, 32)
+	if _, err := rand.Read(buf); err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(buf), nil
+}
+
+func hashToken(token string) []byte {
+	sum := sha256.Sum256([]byte(token))
+	return sum[:]
+}

internal/session/session_test.go

@@ -0,0 +1,174 @@
+package session
+
+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"
+)
+
+func setupTest(t *testing.T) (*Store, *user.TenantUserStore, 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', 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 sessions (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL REFERENCES users(id),
+			token_hash BYTEA NOT NULL UNIQUE, device_info TEXT NOT NULL DEFAULT '', ip TEXT NOT NULL DEFAULT '',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_seen_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			revoked_at TIMESTAMPTZ
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	userStore := user.NewTenantUserStore(pool)
+	email := fmt.Sprintf("session-test-%d@example.com", time.Now().UnixNano())
+	u, err := userStore.Create(ctx, email, "Session Test")
+	if err != nil {
+		t.Fatalf("create user: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewStore(pool), userStore, u.ID, cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: zwei Sitzungen angelegt, beide in der
+// Uebersicht sichtbar.
+func TestListForUser_ShowsAllActiveSessions(t *testing.T) {
+	store, _, userID, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, _, err := store.Create(ctx, userID, "Chrome auf Windows", "10.0.0.1"); err != nil {
+		t.Fatalf("create session 1: %v", err)
+	}
+	if _, _, err := store.Create(ctx, userID, "Safari auf iPhone", "10.0.0.2"); err != nil {
+		t.Fatalf("create session 2: %v", err)
+	}
+
+	sessions, err := store.ListForUser(ctx, userID)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(sessions) != 2 {
+		t.Fatalf("erwartet 2 sitzungen, habe %d", len(sessions))
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Widerruf macht das Token sofort ungueltig.
+func TestRevoke_InvalidatesTokenImmediately(t *testing.T) {
+	store, _, userID, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sessionID, token, err := store.Create(ctx, userID, "Firefox", "10.0.0.3")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+
+	if _, err := store.Validate(ctx, token); err != nil {
+		t.Fatalf("validate vor widerruf: %v", err)
+	}
+
+	if err := store.Revoke(ctx, sessionID); err != nil {
+		t.Fatalf("revoke: %v", err)
+	}
+
+	if _, err := store.Validate(ctx, token); !errors.Is(err, ErrSessionInvalid) {
+		t.Fatalf("erwartet ErrSessionInvalid sofort nach widerruf, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: "alle anderen beenden" funktioniert,
+// aktuelle Sitzung bleibt aktiv.
+func TestRevokeAllExcept_KeepsCurrentSessionActive(t *testing.T) {
+	store, _, userID, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	currentID, currentToken, err := store.Create(ctx, userID, "aktuelles geraet", "10.0.0.4")
+	if err != nil {
+		t.Fatalf("create current: %v", err)
+	}
+	_, otherToken1, err := store.Create(ctx, userID, "anderes geraet 1", "10.0.0.5")
+	if err != nil {
+		t.Fatalf("create other 1: %v", err)
+	}
+	_, otherToken2, err := store.Create(ctx, userID, "anderes geraet 2", "10.0.0.6")
+	if err != nil {
+		t.Fatalf("create other 2: %v", err)
+	}
+
+	if err := store.RevokeAllExcept(ctx, userID, currentID); err != nil {
+		t.Fatalf("revoke all except: %v", err)
+	}
+
+	if _, err := store.Validate(ctx, currentToken); err != nil {
+		t.Fatalf("aktuelle sitzung sollte weiterhin gueltig sein: %v", err)
+	}
+	if _, err := store.Validate(ctx, otherToken1); !errors.Is(err, ErrSessionInvalid) {
+		t.Fatalf("andere sitzung 1 sollte widerrufen sein, habe %v", err)
+	}
+	if _, err := store.Validate(ctx, otherToken2); !errors.Is(err, ErrSessionInvalid) {
+		t.Fatalf("andere sitzung 2 sollte widerrufen sein, habe %v", err)
+	}
+
+	remaining, err := store.ListForUser(ctx, userID)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(remaining) != 1 || remaining[0].ID != currentID {
+		t.Fatalf("erwartet genau die aktuelle sitzung uebrig, habe %+v", remaining)
+	}
+}
+
+func TestLoginAndCreateSession(t *testing.T) {
+	store, userStore, userID, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	u, err := userStore.Get(ctx, userID)
+	if err != nil {
+		t.Fatalf("get user: %v", err)
+	}
+	hash, err := auth.HashPassword("korrektes-passwort")
+	if err != nil {
+		t.Fatalf("hash: %v", err)
+	}
+	if err := userStore.SetPasswordHash(ctx, userID, hash); err != nil {
+		t.Fatalf("set password: %v", err)
+	}
+
+	token, err := LoginAndCreateSession(ctx, userStore, store, u.Email, "korrektes-passwort", "Test-Client", "127.0.0.1")
+	if err != nil {
+		t.Fatalf("login and create session: %v", err)
+	}
+	if _, err := store.Validate(ctx, token); err != nil {
+		t.Fatalf("validate: %v", err)
+	}
+
+	if _, err := LoginAndCreateSession(ctx, userStore, store, u.Email, "falsches-passwort", "Test-Client", "127.0.0.1"); err == nil {
+		t.Fatal("erwartet fehler bei falschem passwort")
+	}
+}

migrations/tenant/0003_password_policy.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS password_policy;

migrations/tenant/0003_password_policy.up.sql

@@ -1,11 +0,0 @@
--- Passwort-Richtlinien je Tenant (IAM-14, siehe core-kanban/tickets/IAM-14.md).
--- Genau eine Zeile pro Tenant-Datenbank (Singleton-Muster, id fest auf true).
-CREATE TABLE 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()
-);

migrations/tenant/0003_sessions.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS sessions;

migrations/tenant/0003_sessions.up.sql

@@ -0,0 +1,18 @@
+-- Aktive-Sitzungen-Verwaltung (IAM-12, siehe core-kanban/tickets/IAM-12.md).
+-- Bewusst SERVERSEITIG mit widerrufbarem Zustand — anders als IAM-02s
+-- zustandsloses JWT (API-05-Entscheidung fuer Modul-zu-Modul-Vertrauen),
+-- braucht die Selbstbedienungs-Sitzungsuebersicht einen Ort, an dem eine
+-- einzelne Sitzung sofort und nachweislich ungueltig gemacht werden kann.
+-- token_hash enthaelt NIEMALS den Klartext-Token, nur dessen SHA-256-Hash.
+CREATE TABLE sessions (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id       UUID NOT NULL REFERENCES users(id),
+    token_hash    BYTEA NOT NULL UNIQUE,
+    device_info   TEXT NOT NULL DEFAULT '',
+    ip            TEXT NOT NULL DEFAULT '',
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    last_seen_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    revoked_at    TIMESTAMPTZ
+);
+
+CREATE INDEX sessions_user_idx ON sessions (user_id);