Phase 3: Anmeldung, Rate-Limits und Sicherheits-Header

Lesen darf jeder, schreiben nur der Betreiber - mit der bewussten Ausnahme
des Reservierens. Dazu Dockerfile und Compose-Datei, damit sich das lokal
ausprobieren lässt.

Beim Bauen sind zwei Fehler aufgefallen, die ohne Test nicht aufgefallen
wären:

1. slowapi zählt pro URL-Pfad. Weil jedes Kleidungsstück eine eigene URL
   hat, bekam jedes seinen eigenen Zähler - ein Skript hätte also den
   gesamten Bestand reservieren können, ohne je an ein Limit zu stossen.
   Genau der Missbrauch, gegen den das Limit gedacht ist. Behoben mit
   shared_limit und festem scope.
2. Der erste Anlauf des Tests machte fünf Anfragen gegen ein Limit von
   fünf und konnte damit gar nichts zeigen. Geprüft wird jetzt der
   tatsächlich ausgelieferte Standardwert, mit mehr Anfragen als erlaubt.

Weiter umgesetzt:

- Passwort als bcrypt-Hash aus der Umgebung, einmal beim Start gebildet
  und gemerkt. Bei jeder Anfrage neu gehasht liesse sich die Anwendung
  sonst ohne Anmeldung lahmlegen - bcrypt ist absichtlich langsam.
- Ohne hinterlegtes Passwort bleibt der Erfassungsbereich gesperrt (503)
  statt offen zu stehen. Kein mitgeliefertes Standardpasswort.
- Sitzung als signiertes Cookie, HttpOnly, SameSite=Lax (blockt
  seitenfremde POSTs), Secure abschaltbar nur fürs lokale Testen,
  Abmeldung nach zwei Stunden Ruhe.
- CSP mit script-src 'self', nosniff, frame-ancestors none, dazu noindex
  und robots.txt: die Galerie ist frei zugänglich, soll aber nicht
  dauerhaft im Suchindex stehen.
- Der Betreiber darf Reservierungen ohne Token aufheben, damit sich eine
  Missbrauchswelle aufräumen lässt.
- uvicorn mit --proxy-headers: hinter einem Reverse-Proxy zählte sonst
  alles auf dessen IP, und ein einzelner Besucher sperrte alle aus.
- Container läuft nicht als root; Code gehört root, nur Daten und Bilder
  dem Dienstbenutzer.

Umgebungsvariablen heissen jetzt ausdrücklich englisch (ADMIN_PASSWORD,
SECRET_KEY, ...), passend zur Anleitung und zur Kantone-App.

59 Tests, alle grün. Zusätzlich gegen den laufenden Container geprüft.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GR4bNaj9GtRu57J4Niii8o

app/routers/auth.py

@@ -0,0 +1,58 @@
+"""Anmeldung des Betreibers."""
+
+from fastapi import APIRouter, HTTPException, Request, status
+from pydantic import BaseModel, Field
+
+from app import security
+from app.config import einstellungen
+
+router = APIRouter(prefix="/api/v1/auth", tags=["Anmeldung"])
+
+
+class AnmeldenRein(BaseModel):
+    passwort: str = Field(min_length=1)
+
+
+class ZustandAus(BaseModel):
+    angemeldet: bool
+    admin_eingerichtet: bool
+
+
+@router.get("/me", response_model=ZustandAus)
+def zustand(request: Request):
+    return ZustandAus(
+        angemeldet=security.ist_betreiber(request),
+        admin_eingerichtet=einstellungen().admin_aktiv,
+    )
+
+
+@router.post("/login", response_model=ZustandAus)
+@security.limiter.limit(lambda: einstellungen().limit_anmelden)
+def login(request: Request, daten: AnmeldenRein):
+    """Meldet den Betreiber an.
+
+    Das Rate-Limit ist hier wichtiger als es aussieht: die Anwendung ist aus
+    dem Internet erreichbar, es gibt genau ein Konto, und ohne Bremse liesse
+    sich das Passwort in Ruhe durchprobieren.
+    """
+    hash_wert = security.hinterlegter_hash()
+    if hash_wert is None:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail=(
+                "Der Erfassungsbereich ist nicht eingerichtet: "
+                "ADMIN_PASSWORD oder ADMIN_PASSWORD_HASH setzen."
+            ),
+        )
+
+    if not security.passwort_stimmt(daten.passwort, hash_wert):
+        raise HTTPException(status_code=401, detail="Passwort stimmt nicht.")
+
+    security.anmelden(request)
+    return ZustandAus(angemeldet=True, admin_eingerichtet=True)
+
+
+@router.post("/logout", response_model=ZustandAus)
+def logout(request: Request):
+    security.abmelden(request)
+    return ZustandAus(angemeldet=False, admin_eingerichtet=einstellungen().admin_aktiv)

app/routers/images.py

@@ -6,7 +6,7 @@ from fastapi import APIRouter, Depends, File, HTTPException, Response, UploadFil
 from fastapi.responses import FileResponse
 from sqlalchemy.orm import Session
 
-from app import crud, images
+from app import crud, images, security
 from app.config import einstellungen
 from app.database import get_db
 from app.models import Item, ItemBild
@@ -63,6 +63,7 @@ def bild_ausliefern(dateiname: str):
     response_model=list[BildAus],
     status_code=status.HTTP_201_CREATED,
     tags=["Bilder"],
+    dependencies=[security.BetreiberNoetig],
 )
 def bilder_hochladen(
     item_id: int,
@@ -86,6 +87,7 @@ def bilder_hochladen(
     response_model=list[ItemAus],
     status_code=status.HTTP_201_CREATED,
     tags=["Bilder"],
+    dependencies=[security.BetreiberNoetig],
 )
 def stapel_import(
     dateien: list[UploadFile] = File(...),
@@ -119,7 +121,8 @@ def stapel_import(
 
 # ----------------------------------------------------------------- Ändern ---
 
-@router.post("/api/v1/images/{bild_id}/primary", response_model=BildAus, tags=["Bilder"])
+@router.post("/api/v1/images/{bild_id}/primary", response_model=BildAus,
+             tags=["Bilder"], dependencies=[security.BetreiberNoetig])
 def hauptbild_setzen(bild_id: int, db: Session = Depends(get_db)):
     bild = db.get(ItemBild, bild_id)
     if bild is None:
@@ -131,6 +134,7 @@ def hauptbild_setzen(bild_id: int, db: Session = Depends(get_db)):
     "/api/v1/images/{bild_id}",
     status_code=status.HTTP_204_NO_CONTENT,
     tags=["Bilder"],
+    dependencies=[security.BetreiberNoetig],
 )
 def bild_loeschen(bild_id: int, db: Session = Depends(get_db)):
     bild = db.get(ItemBild, bild_id)

app/routers/items.py

@@ -5,11 +5,11 @@ Berechtigungslogik der Reservierung steckt aber schon hier, weil sie den
 Datenfluss bestimmt.
 """
 
-from fastapi import APIRouter, Depends, HTTPException, Query, Response, status
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response, status
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
-from app import crud, images
+from app import crud, images, security
 from app.config import einstellungen
 from app.database import get_db
 from app.models import Geschlecht, Item, Saison, Status
@@ -77,7 +77,8 @@ def item_anzeigen(item_id: int, db: Session = Depends(get_db)):
     return _als_antwort(_item_oder_404(db, item_id))
 
 
-@router.post("", response_model=ItemAus, status_code=status.HTTP_201_CREATED)
+@router.post("", response_model=ItemAus, status_code=status.HTTP_201_CREATED,
+             dependencies=[security.BetreiberNoetig])
 def item_anlegen(daten: ItemAnlegen, db: Session = Depends(get_db)):
     if daten.category_id is not None and crud.kategorie_holen(db, daten.category_id) is None:
         raise HTTPException(status_code=422, detail="Kategorie gibt es nicht.")
@@ -94,7 +95,8 @@ def item_anlegen(daten: ItemAnlegen, db: Session = Depends(get_db)):
     return _als_antwort(item)
 
 
-@router.patch("/{item_id}", response_model=ItemAus)
+@router.patch("/{item_id}", response_model=ItemAus,
+              dependencies=[security.BetreiberNoetig])
 def item_aendern(item_id: int, daten: ItemAendern, db: Session = Depends(get_db)):
     item = _item_oder_404(db, item_id)
     if daten.category_id is not None and crud.kategorie_holen(db, daten.category_id) is None:
@@ -110,7 +112,8 @@ def item_aendern(item_id: int, daten: ItemAendern, db: Session = Depends(get_db)
     return _als_antwort(geaendert)
 
 
-@router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
+@router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT,
+               dependencies=[security.BetreiberNoetig])
 def item_loeschen(item_id: int, db: Session = Depends(get_db)):
     item = _item_oder_404(db, item_id)
     # ON DELETE CASCADE räumt nur die Zeilen in item_images weg. Die Dateien
@@ -124,7 +127,25 @@ def item_loeschen(item_id: int, db: Session = Depends(get_db)):
 # --------------------------------------------------------- Reservierung ---
 
 @router.post("/{item_id}/reserve", response_model=ReservierenAus)
-def item_reservieren(item_id: int, daten: ReservierenRein, db: Session = Depends(get_db)):
+# shared_limit statt limit: slowapi zählt sonst pro URL-Pfad, und weil jedes
+# Kleidungsstück eine eigene URL hat, bekäme jedes seinen eigenen Zähler -
+# ein Skript könnte also den gesamten Bestand reservieren, ohne je an ein
+# Limit zu stossen. Der feste scope fasst alle Reservierungen zusammen.
+@security.limiter.shared_limit(
+    lambda: einstellungen().limit_reservieren, scope="reservieren"
+)
+def item_reservieren(
+    request: Request,
+    item_id: int,
+    daten: ReservierenRein,
+    db: Session = Depends(get_db),
+):
+    """Reserviert ein Kleidungsstück - bewusst ohne Anmeldung.
+
+    Die Galerie ist frei zugänglich, es gibt also keine vorgelagerte Hürde.
+    Das Rate-Limit ist damit das Einzige, was zwischen einem Skript und dem
+    gesamten Bestand steht.
+    """
     item = _item_oder_404(db, item_id)
     if item.status == Status.draft.value:
         raise HTTPException(status_code=404, detail="Kleidungsstück nicht gefunden.")
@@ -138,10 +159,10 @@ def item_reservieren(item_id: int, daten: ReservierenRein, db: Session = Depends
 
 @router.post("/{item_id}/release", response_model=ItemAus)
 def item_freigeben(
+    request: Request,
     item_id: int,
     token: str | None = Query(default=None),
     db: Session = Depends(get_db),
-    ist_betreiber: bool = False,  # wird in Phase 3 durch die Anmeldung ersetzt
 ):
     """Hebt eine Reservierung auf.
 
@@ -153,7 +174,7 @@ def item_freigeben(
     item = _item_oder_404(db, item_id)
     if item.status != Status.reserved.value:
         raise HTTPException(status_code=409, detail="Dieses Kleidungsstück ist nicht reserviert.")
-    if not ist_betreiber and not crud.token_gueltig(item, token):
+    if not security.betreiber_optional(request) and not crud.token_gueltig(item, token):
         raise HTTPException(
             status_code=403,
             detail="Zum Aufheben braucht es den Link aus der Reservierung.",
@@ -161,7 +182,8 @@ def item_freigeben(
     return _als_antwort(crud.freigeben(db, item))
 
 
-@router.post("/{item_id}/mark-given", response_model=ItemAus)
+@router.post("/{item_id}/mark-given", response_model=ItemAus,
+             dependencies=[security.BetreiberNoetig])
 def item_abgegeben(item_id: int, db: Session = Depends(get_db)):
     item = _item_oder_404(db, item_id)
     return _als_antwort(crud.als_abgegeben_markieren(db, item))