ScarriffleandClaude Opus 5
7fc8763d57
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>
118 lines
4.3 KiB
Python
118 lines
4.3 KiB
Python
"""Gemeinsame FastAPI-Abhängigkeiten: aktueller Benutzer (Cookie), Admin-Pflicht.
|
||
|
||
Die Anmeldung läuft über eine server-seitige Sitzung im Cookie (siehe
|
||
``services/sessions``). ``get_current_user`` liest das Cookie, prüft die Sitzung
|
||
und liefert den Benutzer – oder 401.
|
||
|
||
``enforce_account_state`` hängt am zentralen ``/api``-Router und sperrt Benutzer
|
||
aus, die erst noch etwas erledigen müssen (Passwort wechseln, zweiten Faktor
|
||
einrichten). Bisher wurde das nur im Frontend umgeleitet – wer die API direkt
|
||
ansprach, kam daran vorbei.
|
||
"""
|
||
|
||
from fastapi import Depends, HTTPException, Request, status
|
||
from sqlalchemy.orm import Session
|
||
|
||
from .config import get_settings
|
||
from .database import get_db
|
||
from .models import Role, User
|
||
from .schemas import UserOut
|
||
from .services import policy as policy_service
|
||
from .services import sessions
|
||
|
||
_credentials_exc = HTTPException(
|
||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||
detail="Nicht angemeldet oder Sitzung abgelaufen",
|
||
)
|
||
|
||
# Pfade, die trotz offener Pflicht erreichbar bleiben müssen – sonst könnte
|
||
# niemand die Pflicht je erfüllen. Präfix-Vergleich, ohne führendes /api.
|
||
_ALWAYS_ALLOWED = (
|
||
"/health",
|
||
"/version",
|
||
"/auth/me",
|
||
"/auth/logout",
|
||
"/auth/login",
|
||
"/auth/change-password",
|
||
"/auth/2fa",
|
||
)
|
||
# Die Richtlinie darf gelesen werden (die Checkliste braucht sie), aber ein
|
||
# Admin mit offener Pflicht soll sie nicht erst einmal entschärfen können.
|
||
_READ_ONLY_ALLOWED = ("/policy",)
|
||
|
||
|
||
def _session_user(request: Request, db: Session) -> User | None:
|
||
"""Validiert die Sitzung genau einmal pro Anfrage und merkt sie sich.
|
||
|
||
``enforce_account_state`` läuft vor den Endpunkt-Abhängigkeiten; ohne diesen
|
||
Zwischenspeicher würde ``sessions.validate`` (und damit der Schreibzugriff
|
||
auf ``last_seen_at``) pro Anfrage zweimal laufen."""
|
||
if hasattr(request.state, "session_user"):
|
||
return request.state.session_user
|
||
token = request.cookies.get(get_settings().cookie_name, "")
|
||
user = sessions.validate(db, token)
|
||
request.state.session_user = user
|
||
return user
|
||
|
||
|
||
def get_current_user(request: Request, db: Session = Depends(get_db)) -> User:
|
||
user = _session_user(request, db)
|
||
if user is None:
|
||
raise _credentials_exc
|
||
return user
|
||
|
||
|
||
def pending_reason(db: Session, user: User) -> str | None:
|
||
"""Was der Benutzer erledigen muss, bevor er die App benutzen darf."""
|
||
if user.must_change_password:
|
||
return "password_change_required"
|
||
if policy_service.load(db).mfa_required and not user.totp_enabled:
|
||
return "mfa_setup_required"
|
||
return None
|
||
|
||
|
||
def enforce_account_state(request: Request, db: Session = Depends(get_db)) -> None:
|
||
"""Router-weite Sperre für Konten mit offener Pflicht (403, sonst Durchlass).
|
||
|
||
Nicht angemeldete Anfragen laufen hier ungehindert durch – um die kümmert
|
||
sich ``get_current_user`` am jeweiligen Endpunkt."""
|
||
pfad = request.url.path
|
||
rest = pfad[4:] if pfad.startswith("/api") else pfad
|
||
if rest.startswith(_ALWAYS_ALLOWED):
|
||
return
|
||
if request.method == "GET" and rest.startswith(_READ_ONLY_ALLOWED):
|
||
return
|
||
user = _session_user(request, db)
|
||
if user is None:
|
||
return
|
||
grund = pending_reason(db, user)
|
||
if grund is not None:
|
||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=grund)
|
||
|
||
|
||
def require_admin(current_user: User = Depends(get_current_user)) -> User:
|
||
if current_user.role != Role.admin:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_403_FORBIDDEN,
|
||
detail="Nur Administratoren dürfen diese Aktion ausführen",
|
||
)
|
||
return current_user
|
||
|
||
|
||
def user_out(db: Session, user: User) -> UserOut:
|
||
"""``UserOut`` inklusive des berechneten ``mfa_setup_required``."""
|
||
out = UserOut.model_validate(user)
|
||
out.mfa_setup_required = policy_service.load(db).mfa_required and not user.totp_enabled
|
||
return out
|
||
|
||
|
||
def get_owned(db: Session, model, obj_id: int, user: User):
|
||
"""Holt eine Zeile und stellt sicher, dass sie dem Nutzer gehört – sonst 404.
|
||
|
||
Bewusst 404 (nicht 403): fremde IDs sollen nicht einmal als existent gelten.
|
||
Zentrale Stelle für die Mandanten-Isolation."""
|
||
obj = db.get(model, obj_id)
|
||
if obj is None or getattr(obj, "owner_id", None) != user.id:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Nicht gefunden")
|
||
return obj
|