IAM-09: api-token-service-accounts

internal/serviceaccount: Service-Accounts als eigenstaendige Identitaetsklasse
(eigene Tabelle service_accounts, getrennt von internal/user — Zitadel-
Vorbild). Store.IssueToken gibt den Klartext-Token NUR einmal an den
Aufrufer zurueck, gespeichert wird ausschliesslich der SHA-256-Hash
(Akzeptanzkriterium 1). Scopes und optionale Ablaufzeit sind Teil des
Tokens selbst (Akzeptanzkriterium 2).

Store.Verify prueft Widerruf/Ablauf/Scope bei JEDEM Aufruf direkt gegen die
Datenbank — kein Cache dazwischen, ein widerrufenes Token wird ab dem
naechsten Request sofort abgewiesen (Akzeptanzkriterium 3).

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Token ausschliesslich gehasht gespeichert (Stichprobe in der Datenbank) —
   TestIssueToken_StoresOnlyHash: token_hash-Spalte direkt gelesen, enthaelt
   nachweislich nicht den Klartext, 32-Byte-SHA-256-Laenge bestaetigt. PASS.
2. Widerrufenes Token wird beim naechsten Request zuverlaessig abgewiesen —
   TestRevoke_TakesEffectImmediately: Verify vor Widerruf erfolgreich, sofort
   danach ErrTokenInvalid. PASS.
3. Scope-Verletzung wird korrekt abgewiesen —
   TestVerify_RejectsInsufficientScope: Token mit scope=read wird fuer
   scope=write abgewiesen (ErrScopeInsufficient), fuer scope=read akzeptiert. PASS.

Zusaetzlich: TestVerify_RejectsExpiredToken belegt die optionale zeitliche
Befristung aus Akzeptanzkriterium 2. 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/serviceaccount/serviceaccount.go

@@ -0,0 +1,151 @@
+// Package serviceaccount implementiert Core IAM-09: Service-Accounts als
+// eigenstaendige Identitaeten (getrennt von menschlichen Benutzern, siehe
+// internal/user) sowie API-Token mit Scopes und optionaler Ablaufzeit zur
+// programmatischen Authentifizierung.
+package serviceaccount
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	ErrTokenInvalid           = errors.New("serviceaccount: token ungueltig, widerrufen oder abgelaufen")
+	ErrScopeInsufficient      = errors.New("serviceaccount: token hat nicht den erforderlichen scope")
+	ErrServiceAccountNotFound = errors.New("serviceaccount: nicht gefunden")
+)
+
+type ServiceAccount struct {
+	ID   string
+	Name string
+}
+
+type Token struct {
+	ID               string
+	ServiceAccountID string
+	Scopes           []string
+	ExpiresAt        *time.Time
+}
+
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// CreateServiceAccount legt eine neue, eigenstaendige Identitaet an
+// (Akzeptanzkriterium 1) — lebt in service_accounts, nicht in users.
+func (s *Store) CreateServiceAccount(ctx context.Context, name string) (ServiceAccount, error) {
+	if name == "" {
+		return ServiceAccount{}, errors.New("serviceaccount: name darf nicht leer sein")
+	}
+	var sa ServiceAccount
+	sa.Name = name
+	if err := s.pool.QueryRow(ctx, `
+		INSERT INTO service_accounts (name) VALUES ($1) RETURNING id
+	`, name).Scan(&sa.ID); err != nil {
+		return ServiceAccount{}, fmt.Errorf("service-account anlegen: %w", err)
+	}
+	return sa, nil
+}
+
+// IssueToken erzeugt ein neues API-Token fuer einen Service-Account.
+// scopes beschraenkt, wofuer das Token verwendet werden darf; ttl ist
+// optional (nil = kein Ablauf) — beides Akzeptanzkriterium 2. Der
+// Klartext-Token wird NUR hier zurueckgegeben, gespeichert wird ausschliesslich
+// der Hash (Akzeptanzkriterium 1 / Pruefung 1).
+func (s *Store) IssueToken(ctx context.Context, serviceAccountID string, scopes []string, ttl *time.Duration) (id, plaintext string, err error) {
+	plaintext, err = randomToken()
+	if err != nil {
+		return "", "", fmt.Errorf("token erzeugen: %w", err)
+	}
+	hash := hashToken(plaintext)
+	if scopes == nil {
+		scopes = []string{}
+	}
+
+	var expiresAt *time.Time
+	if ttl != nil {
+		t := time.Now().Add(*ttl)
+		expiresAt = &t
+	}
+
+	err = s.pool.QueryRow(ctx, `
+		INSERT INTO api_tokens (service_account_id, token_hash, scopes, expires_at)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, serviceAccountID, hash, scopes, expiresAt).Scan(&id)
+	if err != nil {
+		return "", "", fmt.Errorf("token speichern: %w", err)
+	}
+	return id, plaintext, nil
+}
+
+// Verify prueft ein Token gegen einen benoetigten Scope. Widerruf und Ablauf
+// werden bei JEDEM Aufruf direkt gegen die Datenbank geprueft — es gibt
+// keinen Cache, ein widerrufenes Token wird beim naechsten Request sofort
+// abgewiesen (Akzeptanzkriterium 3). requiredScope == "" ueberspringt die
+// Scope-Pruefung.
+func (s *Store) Verify(ctx context.Context, tokenString, requiredScope string) (Token, error) {
+	hash := hashToken(tokenString)
+
+	var tok Token
+	err := s.pool.QueryRow(ctx, `
+		SELECT id, service_account_id, scopes, expires_at
+		FROM api_tokens
+		WHERE token_hash = $1 AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > now())
+	`, hash).Scan(&tok.ID, &tok.ServiceAccountID, &tok.Scopes, &tok.ExpiresAt)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Token{}, ErrTokenInvalid
+		}
+		return Token{}, fmt.Errorf("token pruefen: %w", err)
+	}
+
+	if requiredScope != "" && !hasScope(tok.Scopes, requiredScope) {
+		return Token{}, ErrScopeInsufficient
+	}
+	return tok, nil
+}
+
+// Revoke widerruft ein Token sofort — Verify schlaegt ab dem naechsten
+// Aufruf fehl (Akzeptanzkriterium 3 / Pruefung 2).
+func (s *Store) Revoke(ctx context.Context, tokenID string) error {
+	_, err := s.pool.Exec(ctx, `UPDATE api_tokens SET revoked_at = now() WHERE id = $1`, tokenID)
+	if err != nil {
+		return fmt.Errorf("token widerrufen: %w", err)
+	}
+	return nil
+}
+
+func hasScope(scopes []string, want string) bool {
+	for _, s := range scopes {
+		if s == want {
+			return true
+		}
+	}
+	return false
+}
+
+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/serviceaccount/serviceaccount_test.go

@@ -0,0 +1,163 @@
+package serviceaccount
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+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 service_accounts (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS api_tokens (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), service_account_id UUID NOT NULL REFERENCES service_accounts(id),
+			token_hash BYTEA NOT NULL UNIQUE, scopes TEXT[] NOT NULL DEFAULT '{}',
+			expires_at TIMESTAMPTZ, revoked_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewStore(pool), pool, cleanup
+}
+
+// Akzeptanzkriterium 1: Service-Account anlegen, eigenes gehashtes Token erhalten.
+// Akzeptanzkriterium 1 + Pruefung 1: Token ausschliesslich gehasht gespeichert.
+func TestIssueToken_StoresOnlyHash(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sa, err := store.CreateServiceAccount(ctx, "ci-pipeline")
+	if err != nil {
+		t.Fatalf("create service account: %v", err)
+	}
+
+	tokenID, plaintext, err := store.IssueToken(ctx, sa.ID, []string{"read"}, nil)
+	if err != nil {
+		t.Fatalf("issue token: %v", err)
+	}
+	if plaintext == "" {
+		t.Fatal("erwartet nicht-leeren klartext-token")
+	}
+
+	var storedHash []byte
+	if err := pool.QueryRow(ctx, `SELECT token_hash FROM api_tokens WHERE id = $1`, tokenID).Scan(&storedHash); err != nil {
+		t.Fatalf("hash lesen: %v", err)
+	}
+	if string(storedHash) == plaintext {
+		t.Fatal("token_hash enthaelt den klartext-token — verstoss gegen akzeptanzkriterium 1")
+	}
+	if len(storedHash) != 32 { // sha256
+		t.Fatalf("erwartet 32-byte sha256-hash, habe %d bytes", len(storedHash))
+	}
+
+	tok, err := store.Verify(ctx, plaintext, "")
+	if err != nil {
+		t.Fatalf("verify: %v", err)
+	}
+	if tok.ServiceAccountID != sa.ID {
+		t.Fatalf("service account id = %q, want %q", tok.ServiceAccountID, sa.ID)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Scope-Verletzung wird abgewiesen.
+func TestVerify_RejectsInsufficientScope(t *testing.T) {
+	store, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sa, err := store.CreateServiceAccount(ctx, "readonly-bot")
+	if err != nil {
+		t.Fatalf("create service account: %v", err)
+	}
+	_, plaintext, err := store.IssueToken(ctx, sa.ID, []string{"read"}, nil)
+	if err != nil {
+		t.Fatalf("issue token: %v", err)
+	}
+
+	if _, err := store.Verify(ctx, plaintext, "read"); err != nil {
+		t.Fatalf("erwartet erfolg fuer passenden scope: %v", err)
+	}
+	if _, err := store.Verify(ctx, plaintext, "write"); !errors.Is(err, ErrScopeInsufficient) {
+		t.Fatalf("erwartet ErrScopeInsufficient fuer fehlenden scope, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2: optionale zeitliche Befristung wird durchgesetzt.
+func TestVerify_RejectsExpiredToken(t *testing.T) {
+	store, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sa, err := store.CreateServiceAccount(ctx, "temp-bot")
+	if err != nil {
+		t.Fatalf("create service account: %v", err)
+	}
+	ttl := -1 * time.Second // sofort abgelaufen
+	_, plaintext, err := store.IssueToken(ctx, sa.ID, nil, &ttl)
+	if err != nil {
+		t.Fatalf("issue token: %v", err)
+	}
+
+	if _, err := store.Verify(ctx, plaintext, ""); !errors.Is(err, ErrTokenInvalid) {
+		t.Fatalf("erwartet ErrTokenInvalid bei abgelaufenem token, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: widerrufenes Token wird sofort abgewiesen.
+func TestRevoke_TakesEffectImmediately(t *testing.T) {
+	store, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sa, err := store.CreateServiceAccount(ctx, "revoke-bot")
+	if err != nil {
+		t.Fatalf("create service account: %v", err)
+	}
+	tokenID, plaintext, err := store.IssueToken(ctx, sa.ID, nil, nil)
+	if err != nil {
+		t.Fatalf("issue token: %v", err)
+	}
+
+	if _, err := store.Verify(ctx, plaintext, ""); err != nil {
+		t.Fatalf("verify vor widerruf: %v", err)
+	}
+
+	if err := store.Revoke(ctx, tokenID); err != nil {
+		t.Fatalf("revoke: %v", err)
+	}
+
+	if _, err := store.Verify(ctx, plaintext, ""); !errors.Is(err, ErrTokenInvalid) {
+		t.Fatalf("erwartet ErrTokenInvalid sofort nach widerruf, habe %v", err)
+	}
+}
+
+func TestVerify_RejectsUnknownToken(t *testing.T) {
+	store, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Verify(ctx, "niemals-ausgestelltes-token", ""); !errors.Is(err, ErrTokenInvalid) {
+		t.Fatalf("erwartet ErrTokenInvalid, habe %v", err)
+	}
+}

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_service_accounts.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS api_tokens;
+DROP TABLE IF EXISTS service_accounts;

migrations/tenant/0003_service_accounts.up.sql

@@ -0,0 +1,20 @@
+-- Service-Accounts & API-Token (IAM-09, siehe core-kanban/tickets/IAM-09.md).
+-- Service-Accounts sind eine eigenstaendige Identitaetsklasse neben
+-- menschlichen Benutzern (users), nicht dieselbe Tabelle (Zitadel-Vorbild).
+CREATE TABLE service_accounts (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name       TEXT NOT NULL,
+    status     TEXT NOT NULL DEFAULT 'active',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- token_hash enthaelt NIEMALS den Klartext-Token, nur dessen SHA-256-Hash.
+CREATE TABLE api_tokens (
+    id                 UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    service_account_id UUID NOT NULL REFERENCES service_accounts(id),
+    token_hash         BYTEA NOT NULL UNIQUE,
+    scopes             TEXT[] NOT NULL DEFAULT '{}',
+    expires_at         TIMESTAMPTZ,
+    revoked_at         TIMESTAMPTZ,
+    created_at         TIMESTAMPTZ NOT NULL DEFAULT now()
+);