FlowDeck CI / lint (push) Failing after 0s
FlowDeck CI / test (push) Failing after 1s
FlowDeck CI / docker (push) Skipped
FlowDeck CI / lint (pull_request) Failing after 1s
FlowDeck CI / test (pull_request) Failing after 1s
FlowDeck CI / docker (pull_request) Skipped
111 lines
4.7 KiB
Python
111 lines
4.7 KiB
Python
"""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
|