"""FlowDeck — cohérence d'identité au changement de compte (7.85.7). Cas réel : connecté « fred » chez ObsiGate, l'utilisateur ouvre Flowdeck et y trouve son propre compte (BC) — la session locale préexistante gouvernait sans jamais reconsulter l'identité centrale, le pont ``/auth/draco`` ne s'exécutant qu'à l'entrée SSO sans session locale. Ce middleware aligne la session sur l'identité centrale **présentée** : quand une requête de page (GET hors ``/api/``, ``/auth/``, ``/static/``, ``/s/``, ``/f/``, ``/scim/``) porte à la fois une session locale valide et un cookie ``draco_session`` **valide** (``app.services.draco.claims_valides`` : signature, expiration, révocation) dont le ``sub`` diffère de celui que la session sert, la session locale est révoquée (ligne ``user_sessions``), le cookie est supprimé de la réponse, et le navigateur est renvoyé au pont ``/auth/draco?next=…`` (JIT si besoin). Base de comparaison : le ``draco_sub`` inscrit dans le payload signé de la session à sa création par le pont — sinon le lien actif du compte (``draco.current_link``). Le sub inscrit neutralise le repli mono-utilisateur de la résolution : en mono-utilisateur, un sub étranger résout vers l'unique compte et ne doit pas détruire sa session en boucle. Gardes : - aucun cookie draco, ou cookie invalide/expiré/révoqué → rien : une panne ou une absence de l'émettrice ne déconnecte personne ; - session de la **porte de secours** (marqueur ``secours`` du payload) → exemptée : elle vit hors circuit central ; - cookie que le pont ne peut pas servir (rôle « aucun » au registre — ``user_for_draco`` lève ``RoleAucunRefuse`` —, dissociation, compte inactif) ou qui résout vers le **même** compte → session gardée : la détruire exclurait son titulaire en boucle, le cookie refusé restant présent ; - compte local **sans aucun lien** draco → l'identité centrale présente gagne (le pont s'applique ; choix documenté). En mode porte centrale, ce cas n'existe pas hors secours. Périmètre : les **pages**. L'API n'est pas traversée par ce middleware : un appel en vol n'est ni interrompu ni rejoué sous une autre identité ; dès la navigation suivante, la page sert l'identité du cookie et la session alignée gouverne l'API. Après alignement, le ``draco_sub`` de la nouvelle session égale celui du cookie : pas de boucle. """ from __future__ import annotations import logging from urllib.parse import quote from starlette.middleware.base import BaseHTTPMiddleware from starlette.requests import Request from starlette.responses import RedirectResponse from app.auth.session import SessionManager logger = logging.getLogger(__name__) _EXEMPT_PREFIXES = ("/api/", "/auth/", "/static/", "/s/", "/f/", "/scim/") class CoherenceDracoMiddleware(BaseHTTPMiddleware): """Aligne la session locale sur le cookie draco valide présenté.""" async def dispatch(self, request: Request, call_next): if request.method != "GET": return await call_next(request) path = request.url.path if any(path.startswith(p) for p in _EXEMPT_PREFIXES): return await call_next(request) cookie = request.cookies.get("flowdeck_session", "") if not cookie: return await call_next(request) payload = SessionManager.decode_payload(cookie) if payload is None: return await call_next(request) if payload.get("secours"): return await call_next(request) user = payload.get("user") or {} user_id = user.get("id") if not user_id: return await call_next(request) from app.services import draco claims = draco.claims_valides(request) if claims is None: return await call_next(request) sub_cookie = str(claims.get("sub", "")) base = payload.get("draco_sub") or draco.current_link(user_id) if base == sub_cookie: return await call_next(request) # Servabilité : le pont doit pouvoir servir un AUTRE compte, # sinon la session est gardée (pas d'exclusion en boucle). try: candidat = draco.user_for_draco(request) except Exception: candidat = None if candidat is None or candidat.get("id") == user_id: return await call_next(request) sid = payload.get("sid") if sid: SessionManager.revoke_session(sid) cible = path if request.url.query: cible = f"{path}?{request.url.query}" response = RedirectResponse( url=f"/auth/draco?next={quote(cible, safe='')}", status_code=302) response.delete_cookie("flowdeck_session", path="/") return response