fix(auth): new passwords need at least 8 characters (FLAW-09)

auth.ValidatePassword checks every way a password is set: setup,
registration, profile, admin create and reset, reset by mail. Same rule
in the browser before sending (lib/password.ts), with our own German
message instead of the browser popup. Existing shorter passwords still
log in. Profile and admin reset no longer trim the password, which made
passwords with surrounding spaces unusable for login.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Doku/api/rest.md

@@ -13,7 +13,7 @@ Basis: `/api/v1`. Antworten sind JSON; Fehler haben die Form `{"error": "Text"}`
 | POST | `/auth/register` | Registrierung (`email`, `password`, `displayName`, `inviteCode`); nur mit Code oder wenn freigegeben |
 | POST | `/auth/login` | Anmeldung (`login`/`email`/`username`, `password`) → `{token, user}` |
 | POST | `/auth/forgot-password` | `{email}` → immer `{ok: true}`; Mail mit Link nur, wenn das Konto existiert. `503`, wenn SMTP oder `BASE_URL` fehlen |
-| POST | `/auth/reset-password` | `{token, password}` (mind. 4 Zeichen) → neues Passwort, alle Sitzungen beendet; `400` bei ungültigem oder abgelaufenem Link |
+| POST | `/auth/reset-password` | `{token, password}` (mind. 8 Zeichen) → neues Passwort, alle Sitzungen beendet; `400` bei ungültigem oder abgelaufenem Link |
 | POST | `/auth/quickstart` | Immer `403` (Gastzugang deaktiviert) |
 | POST | `/webhooks/ingest` | Aufgabe per Webhook anlegen, Token als `?token=`, `X-API-Key` oder Bearer. Body: `title`/`content`/`text`/`message`, `priority`, `source`, `tags`, `dueDate`; Klartext-Body wird als Inhalt genommen |
 | GET | `/ws`, `/ws/spaces/{id}`, `/ws/lists/{id}` | WebSocket, siehe [websocket.md](websocket.md); Token als `?token=` nötig |

Doku/architecture.md

@@ -74,7 +74,7 @@ Hinweis: `DATABASE_URL` mit `postgres…` führt dazu, dass der Standardpfad in
 ## Authentifizierung
 
 - **Login** mit E-Mail, Benutzername (aus dem E-Mail-Präfix) oder `login`. Passwörter: bcrypt (`DefaultCost`).
-- **JWT:** HS256, Laufzeit 30 Tage, Claims `userId`, `email`, `displayName`, `tokenVersion`, `jti`. Gültig nur, wenn Token nicht in `revoked_tokens` steht, das Konto aktiv ist und `tokenVersion` mit `users.token_version` übereinstimmt. `token_version` wird bei Passwortänderung, Rollenwechsel, Deaktivierung und „Alle Sitzungen beenden“ erhöht.
+- **JWT:** HS256, Laufzeit 30 Tage, Claims `userId`, `email`, `displayName`, `tokenVersion`, `jti`. Gültig nur, wenn Token nicht in `revoked_tokens` steht, das Konto aktiv ist und `tokenVersion` mit `users.token_version` übereinstimmt. Neue Passwörter brauchen mindestens 8 Zeichen (`auth.ValidatePassword`). `token_version` wird bei Passwortänderung, Rollenwechsel, Deaktivierung und „Alle Sitzungen beenden“ erhöht.
 - **Logout** schreibt den Token-Hash in `revoked_tokens`.
 - **API-Keys:** `mindsift_sec_<hex>`, gespeichert als SHA-256, nur das Präfix bleibt sichtbar. Der Key gilt als Bearer-Token oder in `X-API-Key` und darf nur Daten anliefern (`POST /inbox`, `POST /webhooks/ingest`); alle anderen Endpunkte antworten mit `403` ([FLAW-07](flaws.md)).
 - **Passwort vergessen:** nur wenn SMTP und `BASE_URL` gesetzt sind (nicht im Demo-Modus; `passwordReset` in `/auth/status`). `POST /auth/forgot-password` antwortet immer gleich und verschickt die Mail im Hintergrund, höchstens alle 2 Minuten pro Konto. Der Link `BASE_URL/?resetToken=…` gilt eine Stunde und einmal; gespeichert wird nur der SHA-256-Hash (`password_reset_tokens`). `POST /auth/reset-password` setzt das Passwort, entwertet alle offenen Links des Kontos und erhöht `token_version` (alle Sitzungen enden). Die App entfernt den Token sofort aus der Adresszeile.

Doku/flaws.md

@@ -18,7 +18,7 @@ Schweregrade: **Hoch** (Datenabfluss oder Rechteumgehung möglich), **Mittel** (
 | FLAW-06 | Aufgaben | ~~Jeder Editor einer Aufgabenliste kann sie per `teamId` an weitere Gruppen freigeben~~ | **Behoben** |
 | FLAW-07 | Auth | ~~Ein API-Key ist ein Vollzugriff~~ – Keys dürfen nur noch einliefern; Scopes fehlen noch | Niedrig |
 | FLAW-08 | Auth | ~~Webhook-Ingest mit JWT prüft weder Sperrliste noch `token_version` noch `is_active`~~ | **Behoben** |
-| FLAW-09 | Auth | Kein Rate-Limit, keine Sperre bei Fehlversuchen, Mindestpasswort 4 Zeichen | Mittel |
+| FLAW-09 | Auth | Kein Rate-Limit, keine Sperre bei Fehlversuchen; ~~Mindestpasswort 4 Zeichen~~ | Mittel |
 | FLAW-10 | Freigaben | ~~`sharing_mode` wird bei Freigaben nicht durchgesetzt; Benutzerverzeichnis leakt alle Konten~~ | **Behoben** |
 | FLAW-11 | Workspace | ~~Block-Upsert (`ON CONFLICT(id)`) prüft das Dokument nicht~~ | **Behoben** |
 | FLAW-12 | Benachrichtigungen | ~~`notify_before_minutes` wirkungslos; Alarm feuert nach Umplanung nie wieder~~; kein Backoff bei Fehlern | **Teilweise behoben** |
@@ -90,6 +90,7 @@ Schweregrade: **Hoch** (Datenabfluss oder Rechteumgehung möglich), **Mittel** (
 - **Maßnahme:** Dieselbe Prüfkette wie in `authMiddleware` verwenden (gemeinsame Funktion statt Kopien; siehe auch `authenticateUserFromReq`).
 
 ### FLAW-09: Kein Schutz gegen Brute-Force
+- **Teilweise behoben:** Neue Passwörter brauchen überall mindestens 8 Zeichen (Setup, Registrierung, Profil, Admin-Anlage und -Reset, Reset per Mail), geprüft zentral in `auth.ValidatePassword` und vorab im Browser (`lib/password.ts`). Bestehende kürzere Passwörter funktionieren beim Anmelden weiter. Offen: Rate-Limit und Sperre.
 - **Fundstellen:** `handleLogin`, `handleRegister`, `handleFirstBootSetup`.
 - **Problem:** Weder Rate-Limit noch Sperre; `middleware.RealIP` vertraut `X-Forwarded-For` ungeprüft. Mindestpasswortlänge ist 4 Zeichen. Der Login-Pfad ist so über das Internet raten- und durchprobierbar.
 - **Maßnahme:** Rate-Limit je IP und Konto, längeres Mindestpasswort.

frontend/src/features/auth/SetupAndAuthView.tsx

@@ -15,6 +15,7 @@ import { AuthStatus, SharingMode, User } from '../../lib/types';
 import { api, triggerHaptic } from '../../lib/api';
 import { ToggleSwitch } from '../../components/ToggleSwitch';
 import { LegalLinks } from '../../components/LegalLinks';
+import { passwordProblem } from '../../lib/password';
 
 interface SetupAndAuthViewProps {
   authStatus: AuthStatus;
@@ -74,6 +75,12 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
   const handleResetPassword = async (e: React.FormEvent) => {
     e.preventDefault();
     setError(null);
+    const resetProblem = passwordProblem(newPassword);
+    if (resetProblem) {
+      setError(resetProblem);
+      triggerHaptic(25);
+      return;
+    }
     if (newPassword !== newPasswordConfirm) {
       setError('Die eingegebenen Passwörter stimmen nicht überein.');
       triggerHaptic(25);
@@ -99,6 +106,12 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
     e.preventDefault();
     setError(null);
 
+    const setupProblem = passwordProblem(setupPassword);
+    if (setupProblem) {
+      setError(setupProblem);
+      triggerHaptic(25);
+      return;
+    }
     if (setupPassword !== setupPasswordConfirm) {
       setError('Die eingegebenen Passwörter stimmen nicht überein.');
       triggerHaptic(25);
@@ -143,6 +156,12 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
   const handleRegisterOrInvite = async (e: React.FormEvent) => {
     e.preventDefault();
     setError(null);
+    const registerProblem = passwordProblem(password);
+    if (registerProblem) {
+      setError(registerProblem);
+      triggerHaptic(25);
+      return;
+    }
     setSubmitting(true);
     triggerHaptic(15);
     try {
@@ -235,8 +254,7 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
                     type="password"
                     value={setupPassword}
                     onChange={(e) => setSetupPassword(e.target.value)}
-                    placeholder="Mindestens 4 Zeichen"
+                    placeholder="Mindestens 8 Zeichen"
-                    minLength={4}
                     required
                     className="w-full h-8 px-2.5 input-field"
                   />
@@ -248,7 +266,6 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
                     value={setupPasswordConfirm}
                     onChange={(e) => setSetupPasswordConfirm(e.target.value)}
                     placeholder="Passwort erneut eingeben"
-                    minLength={4}
                     required
                     className={`w-full h-8 px-2.5 input-field ${
                       setupPasswordConfirm && setupPassword !== setupPasswordConfirm
@@ -529,7 +546,7 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
                   type="password"
                   value={newPassword}
                   onChange={(e) => setNewPassword(e.target.value)}
-                  minLength={4}
+                  placeholder="Mindestens 8 Zeichen"
                   required
                   autoFocus
                   autoComplete="new-password"
@@ -542,7 +559,6 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
                   type="password"
                   value={newPasswordConfirm}
                   onChange={(e) => setNewPasswordConfirm(e.target.value)}
-                  minLength={4}
                   required
                   autoComplete="new-password"
                   className="w-full h-11 sm:h-8 px-2.5 input-field text-base sm:text-xs"
@@ -716,8 +732,7 @@ export const SetupAndAuthView: React.FC<SetupAndAuthViewProps> = ({
                   type="password"
                   value={password}
                   onChange={(e) => setPassword(e.target.value)}
-                  placeholder="Mindestens 4 Zeichen"
+                  placeholder="Mindestens 8 Zeichen"
-                  minLength={4}
                   required
                   className="w-full h-8 px-2.5 input-field"
                 />

frontend/src/features/settings/AdminSettingsView.tsx

@@ -25,6 +25,7 @@ import {
   UserRole,
 } from '../../lib/types';
 import { api, setCurrentSharingMode, triggerHaptic } from '../../lib/api';
+import { passwordProblem } from '../../lib/password';
 import { UserAvatar } from '../../components/UserAvatar';
 import { ToggleSwitch } from '../../components/ToggleSwitch';
 import { CountBadge } from '../../components/CountBadge';
@@ -151,6 +152,11 @@ export const AdminSettingsView: React.FC<AdminSettingsViewProps> = ({
   const handleCreateUser = async (e: React.FormEvent) => {
     e.preventDefault();
     setStatusMsg(null);
+    const problem = passwordProblem(newUserPassword);
+    if (problem) {
+      setStatusMsg({ type: 'err', text: problem });
+      return;
+    }
     triggerHaptic(15);
     try {
       const created = await api.adminCreateUser({
@@ -235,8 +241,14 @@ export const AdminSettingsView: React.FC<AdminSettingsViewProps> = ({
   const handleConfirmResetPassword = async (userId: string) => {
     if (!resetPwdVal.trim()) return;
     setStatusMsg(null);
+    const problem = passwordProblem(resetPwdVal);
+    if (problem) {
+      setStatusMsg({ type: 'err', text: problem });
+      return;
+    }
     try {
-      await api.adminResetPassword(userId, resetPwdVal.trim());
+      // Not trimmed: login compares the password exactly as typed
+      await api.adminResetPassword(userId, resetPwdVal);
       setResetPwdUserId(null);
       setResetPwdVal('');
       setStatusMsg({ type: 'ok', text: 'Passwort erfolgreich zurückgesetzt.' });
@@ -555,8 +567,7 @@ export const AdminSettingsView: React.FC<AdminSettingsViewProps> = ({
                         type="password"
                         value={newUserPassword}
                         onChange={(e) => setNewUserPassword(e.target.value)}
-                        placeholder="Mind. 4 Zeichen"
+                        placeholder="Mind. 8 Zeichen"
-                        minLength={4}
                         required
                         className="w-full min-w-0 h-8 px-2.5 input-field"
                       />
@@ -843,7 +854,7 @@ export const AdminSettingsView: React.FC<AdminSettingsViewProps> = ({
                             type="password"
                             value={resetPwdVal}
                             onChange={(e) => setResetPwdVal(e.target.value)}
-                            placeholder="Neues Passwort eingeben…"
+                            placeholder="Neues Passwort (mind. 8 Zeichen)…"
                             className="flex-1 h-7 px-2 input-field"
                           />
                           <button

frontend/src/features/settings/UserSettingsView.tsx

@@ -22,6 +22,7 @@ import {
 } from 'lucide-react';
 import { APIKey, AuthStatus, User, UserTheme } from '../../lib/types';
 import { api, clearToken, triggerHaptic } from '../../lib/api';
+import { passwordProblem } from '../../lib/password';
 import { customThemeId, ThemeId, ThemeOption } from '../../lib/theme';
 import themeTemplateCss from '../../themes/theme-template.css?raw';
 import { UserAvatar, resizeImageToDataUrl } from '../../components/UserAvatar';
@@ -283,7 +284,13 @@ export const UserSettingsView: React.FC<UserSettingsViewProps> = ({
         avatarUrl: avatarUrl.trim(),
       };
       if (newPassword.trim()) {
-        patch.password = newPassword.trim();
+        const problem = passwordProblem(newPassword);
+        if (problem) {
+          setProfileMsg({ type: 'err', text: problem });
+          return;
+        }
+        // Not trimmed: login compares the password exactly as typed
+        patch.password = newPassword;
       }
       const updated = await api.updateSettings(patch);
       onUserUpdated(updated);
@@ -696,7 +703,7 @@ export const UserSettingsView: React.FC<UserSettingsViewProps> = ({
                     type="password"
                     value={newPassword}
                     onChange={(e) => setNewPassword(e.target.value)}
-                    placeholder="Mindestens 4 Zeichen"
+                    placeholder="Mindestens 8 Zeichen"
                     className="w-full h-9 px-3 input-field"
                   />
                 </div>

frontend/src/lib/password.ts

@@ -0,0 +1,8 @@
+// Same rule as the server (auth.ValidatePassword): at least 8 characters, not only spaces.
+// Only for setting a password; logging in with an older, shorter one keeps working.
+export const MIN_PASSWORD_LENGTH = 8;
+
+export const passwordProblem = (password: string): string | null =>
+  !password.trim() || Array.from(password).length < MIN_PASSWORD_LENGTH
+    ? `Das Passwort muss mindestens ${MIN_PASSWORD_LENGTH} Zeichen lang sein`
+    : null;

internal/api/handlers_admin.go

@@ -111,8 +111,12 @@ func (s *Server) handleAdminCreateUser(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, "Ungültiges JSON")
 		return
 	}
-	if req.Email == "" || req.Password == "" {
+	if req.Email == "" {
-		writeError(w, http.StatusBadRequest, "E-Mail und Passwort erforderlich")
+		writeError(w, http.StatusBadRequest, "E-Mail-Adresse erforderlich")
+		return
+	}
+	if err := auth.ValidatePassword(req.Password); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 	// Only full server admin can create another server admin
@@ -200,10 +204,14 @@ func (s *Server) handleAdminResetPassword(w http.ResponseWriter, r *http.Request
 	var req struct {
 		Password string `json:"password"`
 	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || strings.TrimSpace(req.Password) == "" {
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeError(w, http.StatusBadRequest, "Neues Passwort erforderlich")
 		return
 	}
+	if err := auth.ValidatePassword(req.Password); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
 	hash, err := auth.HashPassword(req.Password)
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, "Passwort-Hash fehlgeschlagen")

internal/api/handlers_auth.go

@@ -90,8 +90,12 @@ func (s *Server) handleFirstBootSetup(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, "Ungültige Anfrage")
 		return
 	}
-	if strings.TrimSpace(req.Email) == "" || len(req.Password) < 4 {
+	if strings.TrimSpace(req.Email) == "" {
-		writeError(w, http.StatusBadRequest, "E-Mail und Passwort (mind. 4 Zeichen) erforderlich")
+		writeError(w, http.StatusBadRequest, "E-Mail-Adresse erforderlich")
+		return
+	}
+	if err := auth.ValidatePassword(req.Password); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 	if strings.TrimSpace(req.DisplayName) == "" {
@@ -154,8 +158,12 @@ func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, "Ungültige Anfrage")
 		return
 	}
-	if strings.TrimSpace(req.Email) == "" || len(req.Password) < 4 {
+	if strings.TrimSpace(req.Email) == "" {
-		writeError(w, http.StatusBadRequest, "E-Mail und Passwort (mind. 4 Zeichen) erforderlich")
+		writeError(w, http.StatusBadRequest, "E-Mail-Adresse erforderlich")
+		return
+	}
+	if err := auth.ValidatePassword(req.Password); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 	if strings.TrimSpace(req.DisplayName) == "" {
@@ -415,6 +423,10 @@ func (s *Server) handleUpdateUserSettings(w http.ResponseWriter, r *http.Request
 		}
 	}
 	if req.Password != nil && strings.TrimSpace(*req.Password) != "" {
+		if err := auth.ValidatePassword(*req.Password); err != nil {
+			writeError(w, http.StatusBadRequest, err.Error())
+			return
+		}
 		hash, err := auth.HashPassword(*req.Password)
 		if err != nil {
 			writeError(w, http.StatusInternalServerError, "Fehler beim Hashen des Passworts")

internal/api/password_reset.go

@@ -68,8 +68,8 @@ func (s *Server) handleResetPassword(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, storage.ErrResetTokenInvalid.Error())
 		return
 	}
-	if len(req.Password) < 4 {
+	if err := auth.ValidatePassword(req.Password); err != nil {
-		writeError(w, http.StatusBadRequest, "Das Passwort braucht mindestens 4 Zeichen")
+		writeError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 	hash, err := auth.HashPassword(req.Password)

internal/api/server_test.go

@@ -1344,7 +1344,16 @@ func TestFirstBootSetupWithSampleData(t *testing.T) {
 	defer store.Close()
 	srv := NewServer(&config.Config{Port: "8080", DatabasePath: dbPath, JWTSecret: "test-jwt-secret-key"}, store, ws.NewHub(), nil)
 
-	body := []byte(`{"email":"me@example.com","password":"secret","displayName":"Ich","createSampleData":true}`)
+	// Too short passwords are refused (FLAW-09)
+	short := httptest.NewRequest(http.MethodPost, "/api/v1/auth/setup", strings.NewReader(`{"email":"me@example.com","password":"secret"}`))
+	short.Header.Set("Content-Type", "application/json")
+	shortRec := httptest.NewRecorder()
+	srv.Router().ServeHTTP(shortRec, short)
+	if shortRec.Code != http.StatusBadRequest || !strings.Contains(shortRec.Body.String(), "mindestens 8 Zeichen") {
+		t.Fatalf("setup with 6 characters: want 400, got %d %s", shortRec.Code, shortRec.Body.String())
+	}
+
+	body := []byte(`{"email":"me@example.com","password":"secret123","displayName":"Ich","createSampleData":true}`)
 	req := httptest.NewRequest(http.MethodPost, "/api/v1/auth/setup", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
 	rec := httptest.NewRecorder()

internal/auth/auth.go

@@ -7,7 +7,9 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"strings"
 	"time"
+	"unicode/utf8"
 
 	"github.com/golang-jwt/jwt/v5"
 	"golang.org/x/crypto/bcrypt"
@@ -25,6 +27,27 @@ type Claims struct {
 	jwt.RegisteredClaims
 }
 
+// MinPasswordLength applies wherever a password is set (setup, registration, profile, admin, reset).
+// Existing shorter passwords keep working for login.
+const MinPasswordLength = 8
+
+var (
+	ErrPasswordTooShort = fmt.Errorf("Das Passwort muss mindestens %d Zeichen lang sein", MinPasswordLength)
+	// bcrypt only uses the first 72 bytes and rejects longer input
+	ErrPasswordTooLong = errors.New("Das Passwort darf höchstens 72 Bytes lang sein")
+)
+
+// ValidatePassword checks a new password: at least MinPasswordLength characters, not only whitespace.
+func ValidatePassword(password string) error {
+	if strings.TrimSpace(password) == "" || utf8.RuneCountInString(password) < MinPasswordLength {
+		return ErrPasswordTooShort
+	}
+	if len(password) > 72 {
+		return ErrPasswordTooLong
+	}
+	return nil
+}
+
 func HashPassword(password string) (string, error) {
 	bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
 	return string(bytes), err

internal/auth/auth_test.go

@@ -0,0 +1,22 @@
+package auth
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidatePassword(t *testing.T) {
+	cases := map[string]error{
+		"geheim12":              nil,
+		"äöüßäöüß":              nil, // counts characters, not bytes
+		"kurz":                  ErrPasswordTooShort,
+		"        ":              ErrPasswordTooShort,
+		strings.Repeat("a", 73): ErrPasswordTooLong,
+		"leer zeichen sind ok":  nil,
+	}
+	for pw, want := range cases {
+		if got := ValidatePassword(pw); got != want {
+			t.Errorf("ValidatePassword(%q) = %v, want %v", pw, got, want)
+		}
+	}
+}