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>

backend/tests/conftest.py

@@ -8,12 +8,16 @@ import tempfile
 os.environ.setdefault("APP_DATA_DIR", tempfile.mkdtemp(prefix="cf-test-"))
 os.environ.setdefault("APP_ECB_FETCH_ON_START", "false")
 os.environ.setdefault("APP_ADMIN_USERNAME", "admin")
-os.environ.setdefault("APP_ADMIN_PASSWORD", "adminpass")
+# Muss die Standard-Passwortrichtlinie erfüllen (Länge 10, Gross/Klein/Ziffer),
+# sonst verlangt der erste Login sofort einen Wechsel und alle Tests scheitern.
+os.environ.setdefault("APP_ADMIN_PASSWORD", "AdminPass1")
 os.environ.setdefault("APP_SESSION_SECRET", "test-secret")
 
 import pytest
 from fastapi.testclient import TestClient
 
+ADMIN_PASSWORD = "AdminPass1"
+
 
 @pytest.fixture()
 def client():
@@ -25,15 +29,67 @@ def client():
 
 @pytest.fixture()
 def admin(client):
-    r = client.post("/api/auth/login", data={"username": "admin", "password": "adminpass"})
+    r = client.post("/api/auth/login", data={"username": "admin", "password": ADMIN_PASSWORD})
     assert r.status_code == 200
     return client
 
 
+def new_password() -> str:
+    """Zufälliges, richtlinienkonformes Testpasswort."""
+    return "Pw1_" + secrets.token_hex(4)
+
+
 def new_user(admin_client) -> tuple[str, str]:
     """Legt (als Admin) einen frischen Nutzer an und gibt (username, passwort) zurück."""
     username = "u_" + secrets.token_hex(4)
-    password = "pw_" + secrets.token_hex(4)
+    password = new_password()
     r = admin_client.post("/api/users", json={"username": username, "password": password, "role": "user"})
     assert r.status_code == 201, r.text
     return username, password
+
+
+@pytest.fixture()
+def policy_admin(admin):
+    """Admin-Client für Tests, die die Passwortrichtlinie verändern.
+
+    Die Testdatenbank lebt über den ganzen Testlauf und die Richtlinie ist
+    global – ohne Zurücksetzen würde eine Verschärfung alle folgenden Tests
+    kippen.
+
+    Zurückgesetzt wird bewusst direkt über die Dienstschicht, nicht über die
+    API: wer ``mfa_required`` einschaltet, sperrt sich damit selbst aus
+    ``PUT /policy`` aus, bis er einen zweiten Faktor eingerichtet hat. Über die
+    API bliebe die Verschärfung also stehen."""
+    from app.database import SessionLocal
+    from app.services import policy as policy_service
+
+    vorher = admin.get("/api/policy").json()
+    try:
+        yield admin
+    finally:
+        db = SessionLocal()
+        try:
+            policy_service.save(db, policy_service.Policy(**vorher))
+        finally:
+            db.close()
+
+
+def login_ready(username: str, password: str) -> tuple[TestClient, str]:
+    """Meldet einen frisch angelegten Nutzer an und erledigt den Pflichtwechsel.
+
+    Vom Admin angelegte Konten tragen ``must_change_password``; solange das
+    offen ist, sperrt der Server alle fachlichen Endpunkte. Für Tests, die den
+    Nutzer einfach benutzen wollen, wird der Wechsel hier gleich mit erledigt.
+    Gibt den angemeldeten Client und das nun gültige Passwort zurück."""
+    from app.main import app
+
+    c = TestClient(app)
+    r = c.post("/api/auth/login", data={"username": username, "password": password})
+    assert r.status_code == 200, r.text
+    neu = new_password()
+    r = c.post(
+        "/api/auth/change-password",
+        json={"current_password": password, "new_password": neu},
+    )
+    assert r.status_code == 200, r.text
+    return c, neu

backend/tests/test_auth.py

@@ -0,0 +1,162 @@
+"""Anmeldung, Passwortrichtlinie und die serverseitige Sperre offener Pflichten."""
+
+from fastapi.testclient import TestClient
+
+from conftest import ADMIN_PASSWORD, login_ready, new_password, new_user
+
+
+def _client() -> TestClient:
+    from app.main import app
+
+    return TestClient(app)
+
+
+def test_login_wrong_password(client):
+    r = client.post("/api/auth/login", data={"username": "admin", "password": "falsch"})
+    assert r.status_code == 401
+
+
+def test_login_unknown_user(client):
+    r = client.post("/api/auth/login", data={"username": "gibtsnicht", "password": "egal"})
+    assert r.status_code == 401
+
+
+def test_login_returns_status_ok(client):
+    r = client.post("/api/auth/login", data={"username": "admin", "password": ADMIN_PASSWORD})
+    assert r.status_code == 200
+    body = r.json()
+    assert body["status"] == "ok"
+    assert body["user"]["username"] == "admin"
+
+
+def test_inactive_account_cannot_log_in(admin):
+    username, password = new_user(admin)
+    liste = admin.get("/api/users").json()
+    u = next(x for x in liste if x["username"] == username)
+    assert admin.patch(f"/api/users/{u['id']}", json={"is_active": False}).status_code == 200
+
+    r = _client().post("/api/auth/login", data={"username": username, "password": password})
+    assert r.status_code == 403
+
+
+def test_fresh_user_is_blocked_until_password_changed(admin):
+    """Vom Admin angelegte Konten kommen nur an die Wechsel-Endpunkte."""
+    username, password = new_user(admin)
+    c = _client()
+    assert c.post("/api/auth/login", data={"username": username, "password": password}).status_code == 200
+
+    # Eigene Daten und der Wechsel selbst bleiben erreichbar …
+    me = c.get("/api/auth/me").json()
+    assert me["must_change_password"] is True
+    assert me["must_change_password_reason"] == "temp"
+    assert c.get("/api/policy").status_code == 200
+
+    # … alles Fachliche nicht.
+    r = c.get("/api/accounts")
+    assert r.status_code == 403
+    assert r.json()["detail"] == "password_change_required"
+
+    neu = new_password()
+    assert c.post(
+        "/api/auth/change-password",
+        json={"current_password": password, "new_password": neu},
+    ).status_code == 200
+    assert c.get("/api/accounts").status_code == 200
+
+
+def test_change_password_checks_current(admin):
+    username, password = new_user(admin)
+    c, _gueltig = login_ready(username, password)
+    r = c.post(
+        "/api/auth/change-password",
+        json={"current_password": "stimmt-nicht", "new_password": new_password()},
+    )
+    assert r.status_code == 400
+
+
+def test_change_password_rejects_same_password(admin):
+    username, password = new_user(admin)
+    c, gueltig = login_ready(username, password)
+    r = c.post(
+        "/api/auth/change-password",
+        json={"current_password": gueltig, "new_password": gueltig},
+    )
+    assert r.status_code == 400
+
+
+def test_change_password_enforces_policy(admin):
+    username, password = new_user(admin)
+    c, gueltig = login_ready(username, password)
+    # Zu kurz, keine Grossbuchstaben, keine Ziffer.
+    r = c.post(
+        "/api/auth/change-password",
+        json={"current_password": gueltig, "new_password": "kurz"},
+    )
+    assert r.status_code == 400
+    assert "Richtlinie" in r.json()["detail"]
+
+
+def test_create_user_enforces_policy(admin):
+    r = admin.post("/api/users", json={"username": "schwach_x", "password": "abc", "role": "user"})
+    assert r.status_code == 400
+
+
+def test_policy_is_admin_only(admin):
+    other, _ = login_ready(*new_user(admin))
+    assert other.get("/api/policy").status_code == 200
+    assert other.put("/api/policy", json={"min_length": 8}).status_code == 403
+
+
+def test_tightened_policy_forces_change_on_next_login(policy_admin):
+    """Kernpunkt: der Hash gibt nichts her, aber beim Anmelden liegt das
+    Passwort im Klartext vor – dort wird die Richtlinie geprüft."""
+    username, password = new_user(policy_admin)
+    c, gueltig = login_ready(username, password)
+    assert c.get("/api/auth/me").json()["must_change_password"] is False
+
+    # Richtlinie verschärfen: das bisherige Passwort ist nun zu kurz.
+    assert policy_admin.put("/api/policy", json={
+        "min_length": 40, "require_upper": True, "require_lower": True,
+        "require_digit": True, "require_special": False, "mfa_required": False,
+    }).status_code == 200
+
+    zweiter = _client()
+    assert zweiter.post(
+        "/api/auth/login", data={"username": username, "password": gueltig}
+    ).status_code == 200
+    me = zweiter.get("/api/auth/me").json()
+    assert me["must_change_password"] is True
+    assert me["must_change_password_reason"] == "policy"
+    assert zweiter.get("/api/accounts").status_code == 403
+
+
+def test_policy_min_length_unter_untergrenze_wird_abgelehnt(policy_admin):
+    vorher = policy_admin.get("/api/policy").json()
+    assert policy_admin.put("/api/policy", json={"min_length": 4}).status_code == 422
+    # Die gespeicherte Richtlinie bleibt unverändert.
+    assert policy_admin.get("/api/policy").json() == vorher
+
+
+def test_change_password_revokes_other_sessions(admin):
+    username, password = new_user(admin)
+    erste, gueltig = login_ready(username, password)
+    zweite = _client()
+    assert zweite.post(
+        "/api/auth/login", data={"username": username, "password": gueltig}
+    ).status_code == 200
+
+    neu = new_password()
+    assert erste.post(
+        "/api/auth/change-password",
+        json={"current_password": gueltig, "new_password": neu},
+    ).status_code == 200
+
+    # Die andere Sitzung ist beendet, die eigene läuft weiter.
+    assert zweite.get("/api/auth/me").status_code == 401
+    assert erste.get("/api/auth/me").status_code == 200
+
+
+def test_logout_ends_session(admin):
+    c, _ = login_ready(*new_user(admin))
+    assert c.post("/api/auth/logout").status_code == 204
+    assert c.get("/api/auth/me").status_code == 401

backend/tests/test_backup.py

@@ -1,7 +1,8 @@
 import json
-import secrets
 from datetime import date
 
+from conftest import login_ready, new_user
+
 
 def _setup(admin):
     acc = admin.post("/api/accounts", json={"name": "Exp", "currency": "EUR"}).json()
@@ -41,19 +42,13 @@ def test_export_all_json(admin):
 
 
 def test_db_backup_admin_only(admin):
-    from fastapi.testclient import TestClient
-    from app.main import app
-
     # Admin darf.
     r = admin.get("/api/backup/db")
     assert r.status_code == 200
     assert r.content[:16].startswith(b"SQLite format 3")
 
     # Normaler Nutzer darf nicht.
-    u, p = "u_" + secrets.token_hex(4), "pw"
-    admin.post("/api/users", json={"username": u, "password": p, "role": "user"})
-    other = TestClient(app)
-    other.post("/api/auth/login", data={"username": u, "password": p})
+    other, _ = login_ready(*new_user(admin))
     assert other.get("/api/backup/db").status_code == 403
     # ...aber seinen eigenen Export schon (leer).
     assert other.get("/api/export/all.json").status_code == 200

backend/tests/test_isolation.py

@@ -1,21 +1,15 @@
-import secrets
 from datetime import date
 
+from conftest import login_ready, new_user
+
 
 def test_users_are_isolated(admin):
-    from fastapi.testclient import TestClient
-    from app.main import app
-
     # Admin legt ein Konto an.
     acc = admin.post("/api/accounts", json={"name": "AdminKonto", "currency": "EUR"}).json()
 
     # Frischen Nutzer anlegen und getrennt einloggen.
-    username = "iso_" + secrets.token_hex(4)
-    password = "pw_" + secrets.token_hex(4)
-    assert admin.post("/api/users", json={"username": username, "password": password, "role": "user"}).status_code == 201
-
-    other = TestClient(app)
-    assert other.post("/api/auth/login", data={"username": username, "password": password}).status_code == 200
+    username, password = new_user(admin)
+    other, _ = login_ready(username, password)
 
     # Sieht keine fremden Konten/Buchungen.
     assert other.get("/api/accounts").json() == []

backend/tests/test_restore.py

@@ -0,0 +1,189 @@
+"""Voll-Backup: Export, Prüfansicht und Wiederherstellung."""
+
+import json
+from datetime import date
+
+from conftest import login_ready, new_user
+
+
+def _datensatz(c):
+    """Legt ein Konto mit zwei Buchungen an und gibt das Konto zurück."""
+    acc = c.post("/api/accounts", json={"name": "Restore-Konto", "currency": "EUR"}).json()
+    for betrag, wer in ((1234, "Laden A"), (5678, "Laden B")):
+        c.post("/api/transactions", json={
+            "type": "expense", "date": str(date.today()), "account_id": acc["id"],
+            "amount_cents": betrag, "payee": wer,
+        })
+    return acc
+
+
+def _backup(c) -> dict:
+    r = c.get("/api/export/backup.json")
+    assert r.status_code == 200, r.text
+    return json.loads(r.content)
+
+
+def _hochladen(c, daten: dict, pfad: str, mode: str | None = None):
+    dateien = {"file": ("backup.json", json.dumps(daten).encode("utf-8"), "application/json")}
+    if mode is None:
+        return c.post(pfad, files=dateien)
+    return c.post(pfad, files=dateien, data={"mode": mode})
+
+
+def test_backup_hat_umschlag_und_alle_tabellen(admin):
+    _datensatz(admin)
+    daten = _backup(admin)
+    assert daten["format"] == "certain-finance-backup"
+    assert daten["schema_version"] == 2
+    assert daten["scope"] == "user"
+    assert daten["username"] == "admin"
+    # Beziehungen laufen über lokale IDs, nicht über Namen.
+    konto = daten["data"]["accounts"][0]
+    assert "local_id" in konto
+    buchung = daten["data"]["transactions"][0]
+    assert buchung["account_id"] in {a["local_id"] for a in daten["data"]["accounts"]}
+    # Felder, die der alte Ansichts-Export verlor.
+    assert "import_hash" in buchung
+    assert "fx_rate" in buchung
+    assert "budget_treatment" in buchung
+
+
+def test_pruefansicht_schreibt_nichts(admin):
+    c, _ = login_ready(*new_user(admin))
+    _datensatz(c)
+    daten = _backup(c)
+    vorher = len(c.get("/api/accounts").json())
+
+    r = _hochladen(c, daten, "/api/backup/restore/preview")
+    assert r.status_code == 200, r.text
+    body = r.json()
+    assert body["scope"] == "user"
+    tabellen = {z["key"]: z["count"] for z in body["tables"]}
+    assert tabellen["accounts"] >= 1
+    assert tabellen["transactions"] == 2
+    assert len(c.get("/api/accounts").json()) == vorher
+
+
+def test_replace_stellt_geloeschte_daten_wieder_her(admin):
+    c, _ = login_ready(*new_user(admin))
+    acc = _datensatz(c)
+    daten = _backup(c)
+    konten_vorher = c.get("/api/accounts").json()
+    buchungen_vorher = c.get("/api/transactions").json()
+
+    # Alles wegwerfen …
+    assert c.delete(f"/api/accounts/{acc['id']}").status_code in (200, 204)
+    assert c.get("/api/accounts").json() == []
+
+    # … und aus dem Backup zurückholen.
+    r = _hochladen(c, daten, "/api/backup/restore", "replace")
+    assert r.status_code == 200, r.text
+    assert r.json()["mode"] == "replace"
+
+    konten = c.get("/api/accounts").json()
+    buchungen = c.get("/api/transactions").json()
+    assert len(konten) == len(konten_vorher)
+    assert konten[0]["name"] == "Restore-Konto"
+    assert len(buchungen) == len(buchungen_vorher)
+    assert {b["payee"] for b in buchungen} == {"Laden A", "Laden B"}
+    # Die Buchungen hängen wieder am wiederhergestellten Konto.
+    assert {b["account_id"] for b in buchungen} == {konten[0]["id"]}
+
+
+def test_replace_ersetzt_statt_zu_ergaenzen(admin):
+    c, _ = login_ready(*new_user(admin))
+    _datensatz(c)
+    daten = _backup(c)
+
+    # Zwischendurch etwas anlegen, das im Backup nicht vorkommt.
+    c.post("/api/accounts", json={"name": "Danach angelegt", "currency": "EUR"})
+    assert len(c.get("/api/accounts").json()) == 2
+
+    assert _hochladen(c, daten, "/api/backup/restore", "replace").status_code == 200
+    namen = [a["name"] for a in c.get("/api/accounts").json()]
+    assert namen == ["Restore-Konto"]
+
+
+def test_merge_erzeugt_keine_duplikate(admin):
+    c, _ = login_ready(*new_user(admin))
+    _datensatz(c)
+    daten = _backup(c)
+
+    assert _hochladen(c, daten, "/api/backup/restore", "merge").status_code == 200
+    assert len(c.get("/api/accounts").json()) == 1
+    assert len(c.get("/api/transactions").json()) == 2
+
+    # Zweiter Durchlauf ändert weiterhin nichts.
+    assert _hochladen(c, daten, "/api/backup/restore", "merge").status_code == 200
+    assert len(c.get("/api/accounts").json()) == 1
+    assert len(c.get("/api/transactions").json()) == 2
+
+
+def test_merge_ergaenzt_fehlendes(admin):
+    geber, _ = login_ready(*new_user(admin))
+    _datensatz(geber)
+    daten = _backup(geber)
+
+    nehmer, _ = login_ready(*new_user(admin))
+    nehmer.post("/api/accounts", json={"name": "Eigenes Konto", "currency": "EUR"})
+
+    assert _hochladen(nehmer, daten, "/api/backup/restore", "merge").status_code == 200
+    namen = sorted(a["name"] for a in nehmer.get("/api/accounts").json())
+    assert namen == ["Eigenes Konto", "Restore-Konto"]
+    assert len(nehmer.get("/api/transactions").json()) == 2
+
+
+def test_fremde_version_wird_abgelehnt(admin):
+    daten = _backup(admin)
+    daten["schema_version"] = 99
+    r = _hochladen(admin, daten, "/api/backup/restore/preview")
+    assert r.status_code == 400
+    assert "99" in r.json()["detail"]
+
+
+def test_ansichts_export_wird_erkannt(admin):
+    _datensatz(admin)
+    alt = json.loads(admin.get("/api/export/all.json").content)
+    r = _hochladen(admin, alt, "/api/backup/restore/preview")
+    assert r.status_code == 400
+    assert "all.json" in r.json()["detail"]
+
+
+def test_fremde_datei_wird_abgelehnt(admin):
+    r = _hochladen(admin, {"irgendwas": 1}, "/api/backup/restore/preview")
+    assert r.status_code == 400
+
+
+def test_systembackup_nur_fuer_admin(admin):
+    assert admin.get("/api/export/system-backup.json").status_code == 200
+    other, _ = login_ready(*new_user(admin))
+    assert other.get("/api/export/system-backup.json").status_code == 403
+
+
+def test_systembackup_enthaelt_alle_benutzer(admin):
+    daten = json.loads(admin.get("/api/export/system-backup.json").content)
+    assert daten["scope"] == "system"
+    namen = {u["username"] for u in daten["users"]}
+    assert "admin" in namen
+    admin_satz = next(u for u in daten["users"] if u["username"] == "admin")
+    # Für einen echten Wiederaufbau muss der Hash mit – deshalb der Hinweis
+    # in der Oberfläche, die Datei wie ein Passwort zu behandeln.
+    assert admin_satz["password_hash"].startswith("$argon2")
+    assert "data" in admin_satz
+
+
+def test_systembackup_darf_kein_normaler_nutzer_einspielen(admin):
+    daten = json.loads(admin.get("/api/export/system-backup.json").content)
+    other, _ = login_ready(*new_user(admin))
+    r = _hochladen(other, daten, "/api/backup/restore/preview")
+    assert r.status_code == 403
+
+
+def test_systembackup_ohne_admin_wird_abgelehnt(admin):
+    daten = json.loads(admin.get("/api/export/system-backup.json").content)
+    daten["users"] = [u for u in daten["users"] if u["role"] != "admin"]
+    r = _hochladen(admin, daten, "/api/backup/restore", "replace")
+    assert r.status_code == 400
+    assert "Administrator" in r.json()["detail"]
+    # Nichts halb eingespielt: der Admin ist noch da.
+    assert admin.get("/api/auth/me").status_code == 200

backend/tests/test_twofactor.py

@@ -0,0 +1,213 @@
+"""Zwei-Faktor: Einrichtung, zweistufige Anmeldung, Wiederherstellungscodes."""
+
+import time
+
+import pyotp
+from fastapi.testclient import TestClient
+
+from conftest import login_ready, new_user
+
+
+def _client() -> TestClient:
+    from app.main import app
+
+    return TestClient(app)
+
+
+def _code(secret: str, versatz: int = 0) -> str:
+    """Code für das aktuelle (oder ein verschobenes) Zeitfenster.
+
+    Jeder Code verbraucht sein Fenster dauerhaft, deshalb muss ein Test, der
+    mehrfach anmeldet, jeweils ein späteres Fenster nehmen."""
+    schritt = int(time.time()) // 30 + versatz
+    return pyotp.TOTP(secret).at(schritt * 30)
+
+
+def _mit_2fa(admin) -> tuple[str, str, str]:
+    """Legt einen Nutzer an, richtet 2FA ein und gibt (name, passwort, secret) zurück.
+
+    Aktiviert wird mit dem Code des aktuellen Fensters – spätere Anmeldungen im
+    Test brauchen deshalb ``versatz >= 1``."""
+    username, password = new_user(admin)
+    c, gueltig = login_ready(username, password)
+    setup = c.post("/api/auth/2fa/setup").json()
+    r = c.post("/api/auth/2fa/activate", json={"code": _code(setup["secret"])})
+    assert r.status_code == 200, r.text
+    return username, gueltig, setup["secret"]
+
+
+def test_setup_liefert_qr_und_secret(admin):
+    c, _ = login_ready(*new_user(admin))
+    r = c.post("/api/auth/2fa/setup")
+    assert r.status_code == 200
+    body = r.json()
+    assert body["qr_png"].startswith("data:image/png;base64,")
+    assert body["otpauth_uri"].startswith("otpauth://totp/")
+    assert len(body["secret"]) >= 16
+    # Noch nicht aktiv, solange kein Code bestätigt wurde.
+    assert c.get("/api/auth/2fa/status").json()["enabled"] is False
+
+
+def test_activate_liefert_wiederherstellungscodes(admin):
+    c, _ = login_ready(*new_user(admin))
+    setup = c.post("/api/auth/2fa/setup").json()
+    r = c.post("/api/auth/2fa/activate", json={"code": _code(setup["secret"])})
+    assert r.status_code == 200
+    codes = r.json()["codes"]
+    assert len(codes) == 10
+    assert len(set(codes)) == 10
+    status = c.get("/api/auth/2fa/status").json()
+    assert status["enabled"] is True
+    assert status["recovery_codes_left"] == 10
+
+
+def test_activate_mit_falschem_code(admin):
+    c, _ = login_ready(*new_user(admin))
+    c.post("/api/auth/2fa/setup")
+    assert c.post("/api/auth/2fa/activate", json={"code": "000000"}).status_code == 400
+
+
+def test_zweistufige_anmeldung(admin):
+    username, password, secret = _mit_2fa(admin)
+
+    c = _client()
+    r = c.post("/api/auth/login", data={"username": username, "password": password})
+    assert r.status_code == 200
+    assert r.json()["status"] == "2fa_required"
+    assert r.json()["user"] is None
+
+    # Das Zwischen-Cookie ist kein Zugang.
+    assert c.get("/api/auth/me").status_code == 401
+    assert c.get("/api/accounts").status_code == 401
+
+    r = c.post("/api/auth/2fa/verify", json={"code": _code(secret, 1)})
+    assert r.status_code == 200, r.text
+    assert r.json()["status"] == "ok"
+    assert r.json()["user"]["username"] == username
+    assert c.get("/api/accounts").status_code == 200
+
+
+def test_code_gilt_nur_einmal(admin):
+    username, password, secret = _mit_2fa(admin)
+    code = _code(secret, 1)
+
+    c = _client()
+    c.post("/api/auth/login", data={"username": username, "password": password})
+    assert c.post("/api/auth/2fa/verify", json={"code": code}).status_code == 200
+
+    # Derselbe Code ein zweites Mal: das Fenster ist verbraucht.
+    zweiter = _client()
+    zweiter.post("/api/auth/login", data={"username": username, "password": password})
+    assert zweiter.post("/api/auth/2fa/verify", json={"code": code}).status_code == 401
+
+
+def test_bereits_verbrauchtes_fenster_wird_abgelehnt(admin):
+    """Der Code, mit dem aktiviert wurde, taugt nicht mehr zum Anmelden."""
+    username, password = new_user(admin)
+    c, gueltig = login_ready(username, password)
+    setup = c.post("/api/auth/2fa/setup").json()
+    aktivierungscode = _code(setup["secret"])
+    assert c.post("/api/auth/2fa/activate", json={"code": aktivierungscode}).status_code == 200
+
+    zweiter = _client()
+    zweiter.post("/api/auth/login", data={"username": username, "password": gueltig})
+    assert zweiter.post(
+        "/api/auth/2fa/verify", json={"code": aktivierungscode}
+    ).status_code == 401
+
+
+def test_falscher_code_wird_abgelehnt(admin):
+    username, password, _ = _mit_2fa(admin)
+    c = _client()
+    c.post("/api/auth/login", data={"username": username, "password": password})
+    assert c.post("/api/auth/2fa/verify", json={"code": "000000"}).status_code == 401
+    assert c.get("/api/auth/me").status_code == 401
+
+
+def test_zu_viele_fehlversuche_beenden_den_versuch(admin):
+    username, password, secret = _mit_2fa(admin)
+    c = _client()
+    c.post("/api/auth/login", data={"username": username, "password": password})
+    for _ in range(5):
+        c.post("/api/auth/2fa/verify", json={"code": "000000"})
+    # Die Pending-Sitzung ist verbraucht – auch ein richtiger Code hilft nicht mehr.
+    r = c.post("/api/auth/2fa/verify", json={"code": _code(secret, 1)})
+    assert r.status_code == 401
+
+
+def test_wiederherstellungscode_funktioniert_einmal(admin):
+    username, password = new_user(admin)
+    c, gueltig = login_ready(username, password)
+    setup = c.post("/api/auth/2fa/setup").json()
+    codes = c.post("/api/auth/2fa/activate", json={"code": _code(setup["secret"])}).json()["codes"]
+
+    erster = _client()
+    erster.post("/api/auth/login", data={"username": username, "password": gueltig})
+    r = erster.post("/api/auth/2fa/verify", json={"code": codes[0], "recovery": True})
+    assert r.status_code == 200, r.text
+    assert erster.get("/api/auth/2fa/status").json()["recovery_codes_left"] == 9
+
+    zweiter = _client()
+    zweiter.post("/api/auth/login", data={"username": username, "password": gueltig})
+    r = zweiter.post("/api/auth/2fa/verify", json={"code": codes[0], "recovery": True})
+    assert r.status_code == 401
+
+
+def test_abschalten_verlangt_das_richtige_passwort(admin):
+    username, password = new_user(admin)
+    c, gueltig = login_ready(username, password)
+    setup = c.post("/api/auth/2fa/setup").json()
+    assert c.post("/api/auth/2fa/activate", json={"code": _code(setup["secret"])}).status_code == 200
+
+    assert c.post("/api/auth/2fa/disable", json={"password": "falsch"}).status_code == 400
+    r = c.post("/api/auth/2fa/disable", json={"password": gueltig})
+    assert r.status_code == 200
+    assert r.json()["totp_enabled"] is False
+    assert c.get("/api/auth/2fa/status").json()["recovery_codes_left"] == 0
+
+
+def test_admin_kann_zwei_faktor_zuruecksetzen(admin):
+    username, password, secret = _mit_2fa(admin)
+    u = next(x for x in admin.get("/api/users").json() if x["username"] == username)
+    assert u["totp_enabled"] is True
+
+    r = admin.post(f"/api/users/{u['id']}/2fa/reset")
+    assert r.status_code == 200
+    assert r.json()["totp_enabled"] is False
+
+    # Danach genügt wieder das Passwort allein.
+    c = _client()
+    r = c.post("/api/auth/login", data={"username": username, "password": password})
+    assert r.json()["status"] == "ok"
+    assert secret  # das alte Secret ist damit wertlos
+
+
+def test_mfa_pflicht_sperrt_bis_zur_einrichtung(policy_admin):
+    username, password = new_user(policy_admin)
+    c, gueltig = login_ready(username, password)
+
+    assert policy_admin.put("/api/policy", json={
+        "min_length": 10, "require_upper": True, "require_lower": True,
+        "require_digit": True, "require_special": False, "mfa_required": True,
+    }).status_code == 200
+
+    zweiter = _client()
+    assert zweiter.post(
+        "/api/auth/login", data={"username": username, "password": gueltig}
+    ).status_code == 200
+    me = zweiter.get("/api/auth/me").json()
+    assert me["mfa_setup_required"] is True
+
+    r = zweiter.get("/api/accounts")
+    assert r.status_code == 403
+    assert r.json()["detail"] == "mfa_setup_required"
+
+    # Einrichten ist erlaubt und hebt die Sperre auf.
+    setup = zweiter.post("/api/auth/2fa/setup").json()
+    assert zweiter.post(
+        "/api/auth/2fa/activate", json={"code": _code(setup["secret"])}
+    ).status_code == 200
+    assert zweiter.get("/api/accounts").status_code == 200
+
+    # Abschalten bleibt verwehrt, solange die Pflicht gilt.
+    assert zweiter.post("/api/auth/2fa/disable", json={"password": gueltig}).status_code == 400