Anmeldung wahlweise ueber OpenID Connect (Authentik)

Neben dem Passwort-Login gibt es jetzt einen zweiten, gleichberechtigten Weg:
OpenID Connect gegen einen selbst gehosteten Anmeldedienst. Ohne Konfiguration
aendert sich nichts - keine SSO-Knoepfe, Passwort-Login wie bisher.

Der Anmeldedienst ist NUR fuer die Anmeldung zustaendig. Danach stellt Vorrania
sein eigenes Token aus wie beim Passwort-Login, deshalb bleiben deps.py, die
Rollenpruefung und die langlebigen API-Tokens unveraendert.

Backend
- Anbieter kommen aus der Umgebung (OIDC_PROVIDERS + OIDC_<KUERZEL>_*). Ein
  zweiter Anbieter ist damit reine Konfiguration, ohne Codeaenderung.
- Browser-Weg (vertraulicher Client) und App-Weg (oeffentlicher Client, PKCE)
  enden beide im selben Token-Schema.
- state/nonce/PKCE-Verifier liegen in einer kurzlebigen Tabelle statt in einem
  Cookie: Starlettes CORS-Schicht spiegelt bei allow_origins=["*"] zusammen mit
  allow_credentials die Herkunft zurueck, sobald ein Request ein Cookie traegt.
  Ohne Cookie entsteht diese Wechselwirkung erst gar nicht - und der Ablauf
  bleibt mit der db-Fixture pruefbar.
- Zuordnung ueber die sub des Anbieters; die Erstverknuepfung laeuft ueber die
  BESTAETIGTE E-Mail-Adresse. Rollen kommen nie aus dem Anbieter, und ein
  gleichlautender preferred_username uebernimmt nie ein bestehendes Konto.
- users.password_hash darf jetzt leer sein (reine SSO-Konten). verify_password
  faengt das ab, sonst antwortete der Login mit 500 statt 401.

Verknuepfen bestehender Konten
- Neue Seite "Mein Konto" (fuer alle Benutzer, nicht nur Admins): verknuepfen
  und wieder loesen. Die Berechtigung stammt aus der laufenden Sitzung, es
  braucht also weder eine hinterlegte Adresse noch Admin-Rechte.
- Der Start laeuft ueber POST, weil eine Seitennavigation das Bearer-Token
  nicht mitschicken kann.
- Die letzte Anmeldemoeglichkeit eines Kontos laesst sich nicht loesen.

iOS
- AppAuth (erste Paketabhaengigkeit) mit PKCE im System-Browser, nie in einem
  eingebetteten WebView, und ohne Client-Secret.
- offline_access nur im App-Weg: der Browser-Weg braucht kein Refresh-Token und
  bekaeme sonst einen ueberfluessigen Zustimmungsdialog.
- Anmeldezustand je Serverprofil im Keychain; abgelaufene Token erneuert die App
  still im Hintergrund. Gleichzeitige 401er teilen sich eine Erneuerung.

Deployment
- docker-compose reicht die ganze .env durch. Einzeln aufzuzaehlen ginge nur mit
  fest verdrahteten Kuerzeln - genau das soll ein weiterer Anbieter nicht
  erfordern.

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

backend/app/services/oidc_state.py

@@ -0,0 +1,83 @@
+"""Kurzlebige Merkzettel fuer den Browser-Anmeldevorgang.
+
+``state``, ``nonce`` und der PKCE-Verifier muessen den Ausflug zum Anmeldedienst
+ueberdauern. Sie liegen dafuer in der Datenbank statt in einem Cookie – warum,
+steht bei :class:`~app.models.OidcLoginState`.
+
+Reine Datenbank-Funktionen, damit sie sich mit der vorhandenen ``db``-Fixture
+pruefen lassen.
+"""
+
+from __future__ import annotations
+
+import secrets
+from datetime import datetime, timedelta, timezone
+
+from sqlalchemy.orm import Session
+
+from ..models import OidcLoginState
+
+# Genug fuer eine Anmeldung samt Zwei-Faktor-Eingabe, kurz genug, dass ein
+# liegengebliebener Zettel nicht ewig gilt.
+GUELTIG = timedelta(minutes=15)
+
+
+def _jetzt() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _mit_zeitzone(wert: datetime) -> datetime:
+    # SQLite gibt Zeitstempel ohne Zonenangabe zurueck; ein Vergleich mit einem
+    # bewussten Zeitpunkt wuerfe sonst einen TypeError.
+    return wert if wert.tzinfo is not None else wert.replace(tzinfo=timezone.utc)
+
+
+def anlegen(
+    db: Session, provider: str, link_user_id: int | None = None
+) -> OidcLoginState:
+    """Erzeugt state, nonce und PKCE-Verifier und merkt sie vor.
+
+    ``link_user_id`` macht daraus einen Verknuepfungs- statt Anmeldevorgang.
+    """
+    zettel = OidcLoginState(
+        state=secrets.token_urlsafe(32),
+        provider=provider,
+        nonce=secrets.token_urlsafe(24),
+        # RFC 7636 erlaubt 43-128 Zeichen; token_urlsafe(64) liefert 86.
+        code_verifier=secrets.token_urlsafe(64),
+        link_user_id=link_user_id,
+        created_at=_jetzt(),
+    )
+    db.add(zettel)
+    db.commit()
+    return zettel
+
+
+def einloesen(db: Session, state: str, jetzt: datetime | None = None) -> OidcLoginState | None:
+    """Holt den Zettel und entfernt ihn dabei – er gilt genau einmal.
+
+    Damit ist ein zweiter Rueckweg mit demselben ``state`` wirkungslos.
+    """
+    zettel = db.get(OidcLoginState, state)
+    if zettel is None:
+        return None
+
+    # Vor dem Ablauf-Vergleich loeschen: auch ein abgelaufener Zettel ist
+    # verbraucht und soll nicht liegenbleiben.
+    db.delete(zettel)
+    db.commit()
+
+    if _mit_zeitzone(zettel.created_at) + GUELTIG < (jetzt or _jetzt()):
+        return None
+    return zettel
+
+
+def aufraeumen(db: Session, jetzt: datetime | None = None) -> int:
+    """Entfernt abgelaufene Zettel (abgebrochene Anmeldungen)."""
+    grenze = (jetzt or _jetzt()) - GUELTIG
+    alte = [z for z in db.query(OidcLoginState).all() if _mit_zeitzone(z.created_at) < grenze]
+    for zettel in alte:
+        db.delete(zettel)
+    if alte:
+        db.commit()
+    return len(alte)