feat: 2FA, Passwortrichtlinie und wiederherstellbares JSON-Backup

Zwei-Faktor per TOTP mit zehn Einmal-Wiederherstellungscodes. Der
Zwischenzustand "Passwort stimmt, Code fehlt" haengt an der vorhandenen
Sitzungstabelle (pending_2fa, zehn Minuten Laufzeit) und gilt nirgends als
angemeldet; nach dem Code wird das Cookie getauscht statt weiterverwendet.
Der Wiederverwendungsschutz merkt sich das tatsaechlich getroffene
Zeitfenster, nicht die aktuelle Uhrzeit - sonst liesse sich ein Code aus dem
naechsten Fenster gleich darauf nochmal einloesen.

Passwortrichtlinie (Laenge, Zeichenklassen, MFA-Pflicht) in der neuen
globalen Tabelle app_settings, durchgesetzt beim Anlegen, Zuruecksetzen und
Aendern von Passwoertern. Bestehende Passwoerter lassen sich nicht gegen eine
neue Richtlinie pruefen - der Hash gibt nichts her. Beim Anmelden liegt das
Passwort aber kurz im Klartext vor: dort wird geprueft und bei Verstoss ein
Wechsel verlangt, mit passendem Grund fuer den Hinweistext.

Nebenbei geschlossen: must_change_password war bisher nur im Frontend
erzwungen, wer die API direkt ansprach kam vorbei. enforce_account_state
haengt jetzt am /api-Sammelrouter und laesst nur noch durch, was man zum
Erfuellen der Pflicht braucht.

Das JSON-Backup liess sich bisher grundsaetzlich nicht zurueckladen: keine
Version, Kategorien nur ueber mehrdeutige Namen, sieben Tabellen fehlten.
Daneben steht nun ein Format v2, das Beziehungen ueber lokale IDs abbildet,
je Benutzer oder systemweit. Zurueckgeladen wird nach einer Pruefansicht,
wahlweise ersetzend oder ergaenzend; vor dem Ersetzen legt der Server einen
Schnappschuss der Datenbank an. Der alte Ansichts-Export bleibt fuer
Tabellenkalkulationen bestehen und wird beim Hochladen ausdruecklich
abgewiesen, statt halb zu raten.

Frontend: wiederverwendbares Passwortfeld mit Augensymbol, animierte
Anforderungsliste, 2FA-Seite, Admin-Karte fuer die Richtlinie und Karte zum
Zurueckladen. Neue Bewegung ist in prefers-reduced-motion hinterlegt; Secret
und Codes sind markierbar, sonst verhinderte das globale user-select das
Kopieren.

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

web/src/passwordPolicy.js

@@ -0,0 +1,90 @@
+/* Auswertung der Passwortrichtlinie im Browser – nur für die Anzeige.
+ *
+ * Verbindlich prüft der Server (backend/app/services/policy.py); hier geht es
+ * allein darum, beim Tippen sofort zu zeigen, was noch fehlt. Die Regeln müssen
+ * deshalb mit der Backend-Fassung übereinstimmen:
+ *   Grossbuchstabe = \p{Lu}, Kleinbuchstabe = \p{Ll}, Ziffer = \p{Nd},
+ *   Sonderzeichen  = weder Buchstabe noch Ziffer noch Leerraum.
+ */
+
+export const DEFAULT_POLICY = {
+  min_length: 10,
+  require_upper: true,
+  require_lower: true,
+  require_digit: true,
+  require_special: false,
+  mfa_required: false,
+};
+
+const PRUEFUNGEN = {
+  upper: (pw) => /\p{Lu}/u.test(pw),
+  lower: (pw) => /\p{Ll}/u.test(pw),
+  digit: (pw) => /\p{Nd}/u.test(pw),
+  special: (pw) => /[^\p{L}\p{N}\s]/u.test(pw),
+};
+
+/**
+ * Liefert die aktiven Regeln als Liste – jeweils mit Kennung und Erfüllt-Zustand.
+ * `t` ist die i18n-Funktion; die Texte liegen unter `password.rule*`.
+ */
+export function ruleList(policy, password, t) {
+  const p = policy || DEFAULT_POLICY;
+  const pw = password || "";
+  const regeln = [
+    { id: "length", text: t("password.ruleLength", { n: p.min_length }), ok: pw.length >= p.min_length },
+  ];
+  for (const id of ["upper", "lower", "digit", "special"]) {
+    if (p[`require_${id}`]) {
+      regeln.push({
+        id,
+        text: t(`password.rule${id[0].toUpperCase()}${id.slice(1)}`),
+        ok: PRUEFUNGEN[id](pw),
+      });
+    }
+  }
+  return regeln;
+}
+
+/** True, wenn das Passwort alle aktiven Regeln erfüllt. */
+export function meetsPolicy(policy, password, t) {
+  return ruleList(policy, password, t).every((r) => r.ok);
+}
+
+const GROSS = "ABCDEFGHJKMNPQRSTUVWXYZ"; // ohne I, O, L
+const KLEIN = "abcdefghijkmnpqrstuvwxyz";
+const ZIFFERN = "23456789";
+const SONDER = "!?%+*#$";
+
+function ziehen(alphabet, anzahl) {
+  const werte = new Uint32Array(anzahl);
+  crypto.getRandomValues(werte);
+  return Array.from(werte, (v) => alphabet[v % alphabet.length]);
+}
+
+/**
+ * Erzeugt ein zufälliges Passwort, das die Richtlinie garantiert erfüllt.
+ * Zeichen, die man leicht verwechselt (0/O, 1/I/l), bleiben draussen – solche
+ * Passwörter werden vom Admin abgetippt oder weitergegeben.
+ */
+export function randomPassword(policy) {
+  const p = policy || DEFAULT_POLICY;
+  const laenge = Math.max(p.min_length, 12);
+  const pflicht = [];
+  if (p.require_upper) pflicht.push(...ziehen(GROSS, 1));
+  if (p.require_lower) pflicht.push(...ziehen(KLEIN, 1));
+  if (p.require_digit) pflicht.push(...ziehen(ZIFFERN, 1));
+  if (p.require_special) pflicht.push(...ziehen(SONDER, 1));
+
+  const rest = GROSS + KLEIN + ZIFFERN + (p.require_special ? SONDER : "");
+  const zeichen = [...pflicht, ...ziehen(rest, Math.max(0, laenge - pflicht.length))];
+
+  // Mischen, damit die Pflichtzeichen nicht immer vorne stehen (Fisher-Yates
+  // mit kryptografischer Quelle).
+  const misch = new Uint32Array(zeichen.length);
+  crypto.getRandomValues(misch);
+  for (let i = zeichen.length - 1; i > 0; i--) {
+    const j = misch[i] % (i + 1);
+    [zeichen[i], zeichen[j]] = [zeichen[j], zeichen[i]];
+  }
+  return zeichen.join("");
+}