IAM-08: benutzerprofil-login-oberflaeche (login+2fa/passwort-reset/profil-backend-handler + web/account next.js-frontend auf shl-01)

2026-08-28 23:34:36 +02:00
parent f0139c889a
commit f627caaacb
19 changed files with 1407 additions and 0 deletions
@@ -0,0 +1,109 @@
+package authtoken
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+// ResetTokenTTL: 1 Stunde ist der uebliche Kompromiss zwischen Nutzbarkeit
+// und Angriffsflaeche fuer Passwort-Reset-Links.
+const ResetTokenTTL = time.Hour
+
+// Notifier verschickt das Reset-Token an den Benutzer. Core CFG-02
+// (Benachrichtigungs-Dispatcher) ist noch nicht in diesem Branch verfuegbar
+// (siehe SICHERHEITSKONZEPT.md / Core-Board-Konvention: Versand laeuft
+// grundsaetzlich ueber CFG-02, kein eigener E-Mail-Versand je Modul) — bis
+// zur Anbindung protokolliert LogNotifier den Vorgang nur, statt eine E-Mail
+// zu verschicken. Produktionsreif ist erst der Austausch gegen einen
+// CFG-02-Client, keine neue eigene Versandlogik hier.
+type Notifier interface {
+	NotifyPasswordReset(ctx context.Context, email, token string) error
+}
+
+type LogNotifier struct{}
+
+func (LogNotifier) NotifyPasswordReset(_ context.Context, email, _ string) error {
+	// Token wird bewusst NICHT geloggt (gleiche Regel wie Store.Create).
+	slog.Info("passwort-reset angefordert (kein CFG-02 in diesem branch, nur protokolliert)", "email_domain_hint", domainHint(email))
+	return nil
+}
+
+func domainHint(email string) string {
+	for i := len(email) - 1; i >= 0; i-- {
+		if email[i] == '@' {
+			return email[i:]
+		}
+	}
+	return ""
+}
+
+// Handler stellt Passwort-Reset als HTTP-Endpunkte bereit (IAM-08).
+type Handler struct {
+	tokens   *Store
+	users    *user.TenantUserStore
+	notifier Notifier
+}
+
+func NewHandler(tokens *Store, users *user.TenantUserStore, notifier Notifier) *Handler {
+	if notifier == nil {
+		notifier = LogNotifier{}
+	}
+	return &Handler{tokens: tokens, users: users, notifier: notifier}
+}
+
+type requestResetRequest struct {
+	Email string `json:"email"`
+}
+
+// RequestReset liefert IMMER dieselbe Erfolgsmeldung, unabhaengig davon, ob
+// die E-Mail-Adresse existiert (Akzeptanzkriterium 3 / Pruefung 1,
+// User-Enumeration-Schutz — gleiches Prinzip wie auth.LoginService.Login).
+func (h *Handler) RequestReset(w http.ResponseWriter, r *http.Request) {
+	var req requestResetRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	// Absichtlich: Fehler (unbekannte E-Mail) fuehrt NICHT zu einer anderen
+	// HTTP-Antwort als der Erfolgsfall — nur der interne Pfad unterscheidet sich.
+	creds, err := h.users.GetByEmailForAuth(r.Context(), req.Email)
+	if err == nil {
+		token, tokenErr := h.tokens.Create(r.Context(), creds.User.ID, PurposeReset, ResetTokenTTL)
+		if tokenErr == nil {
+			_ = h.notifier.NotifyPasswordReset(r.Context(), req.Email, token)
+		}
+	}
+
+	w.WriteHeader(http.StatusOK)
+	_ = json.NewEncoder(w).Encode(map[string]string{
+		"message": "Falls ein Konto mit dieser E-Mail-Adresse existiert, wurde eine Nachricht mit weiteren Schritten verschickt.",
+	})
+}
+
+type completeResetRequest struct {
+	Token       string `json:"token"`
+	NewPassword string `json:"new_password"`
+}
+
+// CompleteReset schliesst den Reset ab (Akzeptanzkriterium 3: generische
+// Fehlermeldung bei ungueltigem/abgelaufenem Token, siehe ErrInvalidToken).
+func (h *Handler) CompleteReset(w http.ResponseWriter, r *http.Request) {
+	var req completeResetRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	if err := CompletePasswordReset(r.Context(), h.tokens, h.users, req.Token, req.NewPassword); err != nil {
+		http.Error(w, "Link ungültig oder abgelaufen.", http.StatusBadRequest)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
@@ -0,0 +1,94 @@
+package authtoken
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// fakeNotifier zeichnet auf, ob/mit welchem Token benachrichtigt wurde —
+// ersetzt LogNotifier im Test, damit der Test pruefen kann, OB ein Token
+// erzeugt wurde, ohne die HTTP-Antwort danach zu unterscheiden
+// (Akzeptanzkriterium 3: die Antwort selbst bleibt in beiden Faellen gleich).
+type fakeNotifier struct {
+	calls []string // e-mail-adressen, fuer die notifiziert wurde
+}
+
+func (f *fakeNotifier) NotifyPasswordReset(_ context.Context, email, _ string) error {
+	f.calls = append(f.calls, email)
+	return nil
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Antwort ist IDENTISCH, egal ob die
+// E-Mail-Adresse existiert — nur intern (Notifier-Aufruf) unterscheidet sich.
+func TestRequestReset_SameResponseRegardlessOfExistence(t *testing.T) {
+	tokens, users, userID, cleanup := setupTest(t)
+	defer cleanup()
+	_ = userID
+
+	u, err := users.Get(context.Background(), userID)
+	if err != nil {
+		t.Fatalf("benutzer laden: %v", err)
+	}
+
+	notifier := &fakeNotifier{}
+	h := NewHandler(tokens, users, notifier)
+
+	// Fall 1: existierende E-Mail.
+	body1, _ := json.Marshal(requestResetRequest{Email: u.Email})
+	req1 := httptest.NewRequest(http.MethodPost, "/auth/password-reset/request", bytes.NewReader(body1))
+	rec1 := httptest.NewRecorder()
+	h.RequestReset(rec1, req1)
+
+	// Fall 2: nicht existierende E-Mail.
+	body2, _ := json.Marshal(requestResetRequest{Email: "gibt-es-nicht@example.com"})
+	req2 := httptest.NewRequest(http.MethodPost, "/auth/password-reset/request", bytes.NewReader(body2))
+	rec2 := httptest.NewRecorder()
+	h.RequestReset(rec2, req2)
+
+	if rec1.Code != rec2.Code {
+		t.Fatalf("status codes unterscheiden sich: %d vs %d — verraet Konto-Existenz", rec1.Code, rec2.Code)
+	}
+	if rec1.Body.String() != rec2.Body.String() {
+		t.Fatalf("antwort-body unterscheidet sich: %q vs %q — verraet Konto-Existenz", rec1.Body.String(), rec2.Body.String())
+	}
+
+	// Intern wurde aber nur fuer die existierende Adresse tatsaechlich benachrichtigt.
+	if len(notifier.calls) != 1 || notifier.calls[0] != u.Email {
+		t.Fatalf("erwartet genau 1 benachrichtigung fuer %q, habe %v", u.Email, notifier.calls)
+	}
+}
+
+// Akzeptanzkriterium 3: vollstaendiger Reset-Flow ueber HTTP.
+func TestCompleteReset_Works(t *testing.T) {
+	tokens, users, userID, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	token, err := tokens.Create(ctx, userID, PurposeReset, ResetTokenTTL)
+	if err != nil {
+		t.Fatalf("token erzeugen: %v", err)
+	}
+
+	h := NewHandler(tokens, users, &fakeNotifier{})
+	body, _ := json.Marshal(completeResetRequest{Token: token, NewPassword: "neues-sicheres-passwort"})
+	req := httptest.NewRequest(http.MethodPost, "/auth/password-reset/complete", bytes.NewReader(body))
+	rec := httptest.NewRecorder()
+	h.CompleteReset(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+
+	// Token ist jetzt verbraucht — zweiter Versuch schlaegt fehl.
+	body2, _ := json.Marshal(completeResetRequest{Token: token, NewPassword: "noch-ein-passwort"})
+	req2 := httptest.NewRequest(http.MethodPost, "/auth/password-reset/complete", bytes.NewReader(body2))
+	rec2 := httptest.NewRecorder()
+	h.CompleteReset(rec2, req2)
+	if rec2.Code != http.StatusBadRequest {
+		t.Fatalf("wiederverwendung: status = %d, want 400", rec2.Code)
+	}
+}