nexarch/cmd/account-api/main.go

// account-api ist der Aufrufpunkt fuer IAM-16: setzt die bereits fertigen
// IAM-08-Handler (internal/auth, internal/authtoken, internal/totp) zu
// einem laufenden Login/Account-HTTP-Dienst zusammen. REINES WIRING —
// keine Aenderung an den bestehenden Paketen. Tenant-gescoped (Modell C):
// ein Dienst pro Mandanten-Datenbank, wie internal/auth.LoginService es
// bereits vorsieht.
package main

import (
	"context"
	"flag"
	"log"
	"net/http"
	"os"
	"strconv"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"

	"gitea.perlbach24.de/scripte/nexarch/common/httpharden"
	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
	"gitea.perlbach24.de/scripte/nexarch/internal/authtoken"
	"gitea.perlbach24.de/scripte/nexarch/internal/lockout"
	"gitea.perlbach24.de/scripte/nexarch/internal/moduletoken"
	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
	"gitea.perlbach24.de/scripte/nexarch/internal/totp"
	"gitea.perlbach24.de/scripte/nexarch/internal/user"
)

func requireEnv(name string) string {
	v := os.Getenv(name)
	if v == "" {
		log.Fatalf("%s muss gesetzt sein", name)
	}
	return v
}

func envInt(name string, def, min, max int) int {
	v := os.Getenv(name)
	if v == "" {
		return def
	}
	n, err := strconv.Atoi(v)
	if err != nil || n < min || n > max {
		log.Fatalf("%s muss eine ganze Zahl zwischen %d und %d sein, war %q", name, min, max, v)
	}
	return n
}

func main() {
	rotateModuleKey := flag.Bool("rotate-module-key", false, "neuen Modul-Signaturschluessel anlegen und beenden")
	rotateSessionKey := flag.Bool("rotate-session-key", false, "QA-15 F-10: neuen Sitzungs-Signaturschluessel anlegen und beenden")
	encryptTOTPSecrets := flag.Bool("encrypt-totp-secrets", false, "QA-15 F-06: bestehende Klartext-TOTP-Secrets nachverschluesseln und beenden")
	rewrapModuleKeys := flag.Bool("rewrap-module-keys", false, "QA-15 F-25: gespeicherte Modul-Signaturschluessel von "+envKeyEncryptionKeyOld+" auf "+envKeyEncryptionKey+" neu verpacken und beenden")
	flag.Parse()
	dsn := requireEnv("NEXARCH_ACCOUNT_TENANT_DSN")
	tenantSlug := requireEnv("NEXARCH_ACCOUNT_TENANT_SLUG")
	// QA-15 F-10: HS256 ist seit der Umstellung auf Ed25519-Sitzungsschluessel
	// nur noch der optionale Uebergangs-/Rueckfallpfad (Akzeptanzkriterium 3)
	// — ein gesetzter Wert muss weiterhin MinHS256SecretLen erfuellen, ein
	// leerer deaktiviert HS256 vollstaendig (reine Ed25519-Ausstellung).
	jwtSecret := os.Getenv("NEXARCH_ACCOUNT_JWT_SECRET")
	if jwtSecret != "" {
		if err := auth.ValidateHS256Secret(jwtSecret); err != nil {
			log.Fatalf("NEXARCH_ACCOUNT_JWT_SECRET: %v", err)
		}
	}
	totpIssuer := os.Getenv("NEXARCH_ACCOUNT_TOTP_ISSUER")
	if totpIssuer == "" {
		totpIssuer = "NEXARCH"
	}
	addr := os.Getenv("NEXARCH_ACCOUNT_API_LISTEN_ADDR")
	if addr == "" {
		addr = "127.0.0.1:8099"
	}

	ctx := context.Background()
	pool, err := pgxpool.New(ctx, dsn)
	if err != nil {
		log.Fatalf("datenbankverbindung: %v", err)
	}
	defer pool.Close()

	dbWait := time.Duration(envInt("NEXARCH_ACCOUNT_DB_STARTUP_TIMEOUT_SECONDS", 120, 0, 3600)) * time.Second
	if err := waitForDB(ctx, pool, dbWait, time.Sleep); err != nil {
		log.Printf("account-api: %v — DSN in NEXARCH_ACCOUNT_TENANT_DSN (Rolle, Passwort, Datenbank) pruefen", err)
		if isPermanentDBError(err) {
			pool.Close()
			os.Exit(exitPermanentDBError)
		}
		pool.Close()
		os.Exit(1)
	}

	totpCipher, err := newTOTPCipher()
	if err != nil {
		log.Fatalf("totp-verschluesselung: %v", err)
	}
	if totpCipher == nil {
		log.Printf("account-api: %s nicht gesetzt — bestehende Klartext-TOTP-Secrets bleiben lesbar, NEUE Einrichtungen schlagen fehl (fail closed, QA-15 F-06)", envTOTPEncryptionKey)
	}
	totpStore := totp.NewEncryptedStore(pool, totpCipher)

	if *encryptTOTPSecrets {
		if totpCipher == nil {
			log.Fatalf("-encrypt-totp-secrets: %s muss gesetzt sein", envTOTPEncryptionKey)
		}
		n, err := encryptExistingTOTPSecrets(ctx, pool, totpCipher)
		if err != nil {
			log.Fatalf("totp-secrets nachverschluesseln: %v", err)
		}
		log.Printf("account-api: %d totp-secret(s) nachverschluesselt", n)
		return
	}

	users := user.NewTenantUserStore(pool)
	// QA-15 F-10: eigener, persistenter Ed25519-Schluesselsatz fuer
	// Sitzungstokens (getrennt von den API-16-Modulschluesseln); account-api
	// ist die einzige Instanz, die damit auch SIGNIEREN kann.
	sessionKeys, err := newSessionKeyManager(ctx, pool, os.Getenv, auth.AccessTokenTTL)
	if err != nil {
		log.Fatalf("sitzungsschluessel: %v", err)
	}
	tokenIssuer, err := auth.NewAsymmetricTokenIssuer(sessionKeys, jwtSecret)
	if err != nil {
		log.Fatalf("sitzungs-token-aussteller: %v", err)
	}
	if *rotateSessionKey {
		kp, err := sessionKeys.RotateContext(ctx)
		if err != nil {
			log.Fatalf("sitzungsschluessel rotieren: %v", err)
		}
		log.Printf("account-api: neuer sitzungsschluessel %s angelegt (signiert nach der aktivierungsverzoegerung)", kp.KID)
		return
	}
	loginService := auth.NewLoginService(users, tokenIssuer, tenantSlug)

	revocationStore := auth.NewRevocationStore(pool)
	authHandler := auth.NewHandler(loginService, tokenIssuer, revocationStore, nil)
	// QA-15 F-04: Kontosperre (Postgres, geteilt) und Begrenzung je Quelladresse.
	lockStore := lockout.NewStore(pool).WithPolicy(
		envInt("NEXARCH_ACCOUNT_LOCKOUT_MAX_FAILED", lockout.DefaultMaxFailedAttempts, 1, 100),
		time.Duration(envInt("NEXARCH_ACCOUNT_LOCKOUT_MINUTES", int(lockout.DefaultLockoutDuration/time.Minute), 1, 1440))*time.Minute)
	if registryDSN := os.Getenv("NEXARCH_ACCOUNT_REGISTRY_DSN"); registryDSN != "" {
		registryPool, err := pgxpool.New(ctx, registryDSN)
		if err != nil {
			log.Fatalf("registry-datenbank (audit): %v", err)
		}
		defer registryPool.Close()
		lockStore = lockStore.WithAudit(audit.NewLog(registryPool), tenantSlug)
	} else {
		log.Printf("account-api: NEXARCH_ACCOUNT_REGISTRY_DSN nicht gesetzt, Sperr-Ereignisse gehen nicht ins zentrale Audit-Log")
	}
	trustForwarded := os.Getenv("NEXARCH_ACCOUNT_TRUST_FORWARDED_FOR") == "true"
	ipLimiter := lockout.NewIPLimiter(
		envInt("NEXARCH_ACCOUNT_LOGIN_MAX_PER_IP", 20, 1, 100000),
		time.Duration(envInt("NEXARCH_ACCOUNT_LOGIN_WINDOW_SECONDS", 60, 1, 3600))*time.Second)
	totpHandler := totp.NewHandler(users, totpStore, loginService, totpIssuer).WithLoginGuard(lockStore, ipLimiter, trustForwarded)
	profileHandler := auth.NewProfileHandler(users)
	// QA-15 F-06: alte Sitzungen nach einer Passwortaenderung widerrufen.
	changePasswordHandler := auth.NewChangePasswordHandler(users).WithSessionRotation(revocationStore, tokenIssuer)
	resetStore := authtoken.NewStore(pool)
	resetHandler := authtoken.NewHandler(resetStore, users, authtoken.LogNotifier{})

	moduleTokenTTL, err := moduletoken.ParseTTL(os.Getenv("NEXARCH_ACCOUNT_MODULE_TOKEN_TTL_SECONDS"))
	if err != nil {
		log.Fatalf("NEXARCH_ACCOUNT_MODULE_TOKEN_TTL_SECONDS: %v", err)
	}
	moduleAudiences, err := moduletoken.ParseAudiences(os.Getenv("NEXARCH_ACCOUNT_MODULE_AUDIENCES"), []string{"dms"})
	if err != nil {
		log.Fatalf("NEXARCH_ACCOUNT_MODULE_AUDIENCES: %v", err)
	}
	moduleIssuer := os.Getenv("NEXARCH_ACCOUNT_MODULE_TOKEN_ISSUER")
	if moduleIssuer == "" {
		moduleIssuer = "nexarch-core"
	}
	if *rewrapModuleKeys {
		n, err := rewrapModuleSigningKeys(ctx, pool)
		if err != nil {
			log.Fatalf("modul-schluessel neu verpacken: %v", err)
		}
		log.Printf("account-api: %d modul-schluessel neu verpackt", n)
		return
	}

	moduleKeys, err := newModuleKeyManager(ctx, pool, os.Getenv, moduleTokenTTL)
	if err != nil {
		log.Fatalf("modul-schluessel: %v", err)
	}
	if *rotateModuleKey {
		kp, err := moduleKeys.RotateContext(ctx)
		if err != nil {
			log.Fatalf("modul-schluessel rotieren: %v", err)
		}
		log.Printf("account-api: neuer modul-schluessel %s angelegt (signiert nach der aktivierungsverzoegerung)", kp.KID)
		return
	}

	mux := http.NewServeMux()
	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })

	// Login ist DER EINE Endpunkt, den das Frontend aufruft (deckt 2FA
	// optional mit ab) — siehe internal/totp/handler.go-Dokumentation.
	moduletoken.RegisterJWKS(mux, moduleKeys)
	// QA-15 F-10: eigener JWKS-Endpunkt fuer Sitzungsschluessel — getrennt
	// vom Modul-JWKS (RegisterJWKS oben), damit verifizierende Dienste
	// (rbac-admin-api, notifyprefs-api) NUR den fuer sie relevanten
	// oeffentlichen Schluesselsatz abrufen.
	mux.HandleFunc("GET /auth/session-jwks", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Cache-Control", "public, max-age=60")
		sessionKeys.ServeJWKS(w, r)
	})
	moduletoken.RegisterToken(mux, moduletoken.NewHandler(moduleKeys, users, rbac.NewStore(pool), tenantSlug, moduleTokenTTL).WithAudiences(moduleIssuer, moduleAudiences),
		tokenIssuer, auth.NewRevocationStore(pool))

	mux.HandleFunc("POST /auth/login", totpHandler.Login)
	mux.HandleFunc("POST /auth/mobile-login", totpHandler.MobileLogin)
	mux.HandleFunc("POST /auth/logout", authHandler.Logout)
	mux.HandleFunc("POST /auth/password-reset/request", ipLimiter.Wrap(trustForwarded, resetHandler.RequestReset))
	mux.HandleFunc("POST /auth/password-reset/complete", ipLimiter.Wrap(trustForwarded, resetHandler.CompleteReset))

	mux.HandleFunc("GET /account/me", auth.RequireAuth(tokenIssuer, profileHandler.Me))
	mux.HandleFunc("POST /account/change-password", auth.RequireAuth(tokenIssuer, changePasswordHandler.ChangePassword))

	mux.HandleFunc("GET /auth/totp/status", auth.RequireAuth(tokenIssuer, totpHandler.Status))
	mux.HandleFunc("POST /auth/totp/setup/begin", auth.RequireAuth(tokenIssuer, totpHandler.SetupBegin))
	mux.HandleFunc("POST /auth/totp/setup/confirm", auth.RequireAuth(tokenIssuer, totpHandler.SetupConfirm))

	log.Printf("account-api: listening on %s (tenant %s)", addr, tenantSlug)
	if err := httpharden.ListenAndServe(addr, mux); err != nil {
		log.Fatalf("http server: %v", err)
	}
}