Flowdeck 7.85.7 — cohérence d'identité au changement de compte : la session locale s'aligne sur le cookie draco (middleware pages, marqueurs de session draco_sub/secours)
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
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
This commit is contained in:
+43
-5
@@ -36,16 +36,28 @@ class SessionManager:
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def create_session(user_data: dict, request=None) -> str:
|
||||
def create_session(user_data: dict, request=None, draco_sub: str | None = None,
|
||||
secours: bool = False) -> str:
|
||||
"""Create a signed session cookie value.
|
||||
|
||||
``request`` is optional — when provided the session is recorded in the
|
||||
``user_sessions`` table (ip + user agent) and becomes revocable.
|
||||
|
||||
Cohérence d'identité (7.85.7) : ``draco_sub`` inscrit dans le
|
||||
payload signé le sub draco que la session sert (posé par le
|
||||
pont) — c'est la base de comparaison du contrôle de
|
||||
cohérence, insensible au repli mono-utilisateur de la
|
||||
résolution ; ``secours=True`` marque une session de la porte
|
||||
de secours, exemptée de ce contrôle.
|
||||
"""
|
||||
payload = {
|
||||
"user": public_user(user_data),
|
||||
"created_at": datetime.now(UTC).replace(tzinfo=None).isoformat(),
|
||||
}
|
||||
if draco_sub:
|
||||
payload["draco_sub"] = str(draco_sub)
|
||||
if secours:
|
||||
payload["secours"] = True
|
||||
user_id = user_data.get("id")
|
||||
if user_id:
|
||||
sid = str(uuid4())
|
||||
@@ -54,17 +66,31 @@ class SessionManager:
|
||||
return _serializer.dumps(payload)
|
||||
|
||||
@staticmethod
|
||||
def decode_session(cookie: str) -> dict | None:
|
||||
"""Decode and validate a session cookie. Returns user data or None."""
|
||||
def decode_payload(cookie: str) -> dict | None:
|
||||
"""Decode the full session payload (user, sid, markers), or None.
|
||||
|
||||
Same validity checks as ``decode_session`` (signature,
|
||||
expiration, server-side revocation) but no ``last_seen``
|
||||
touch and no unwrapping — the coherence middleware reads
|
||||
the identity markers from here.
|
||||
"""
|
||||
try:
|
||||
payload = _serializer.loads(cookie, max_age=86400 * 7) # 7 days
|
||||
except (BadSignature, SignatureExpired):
|
||||
return None
|
||||
|
||||
sid = payload.get("sid") or ""
|
||||
if sid and not _session_active(sid):
|
||||
# Revoked or deleted session → treat as logged out.
|
||||
return None
|
||||
return payload
|
||||
|
||||
@staticmethod
|
||||
def decode_session(cookie: str) -> dict | None:
|
||||
"""Decode and validate a session cookie. Returns user data or None."""
|
||||
payload = SessionManager.decode_payload(cookie)
|
||||
if payload is None:
|
||||
return None
|
||||
sid = payload.get("sid") or ""
|
||||
if sid:
|
||||
_touch_session(sid)
|
||||
return payload.get("user")
|
||||
@@ -103,12 +129,24 @@ class SessionManager:
|
||||
|
||||
@staticmethod
|
||||
def refresh_session(cookie: str, user_data: dict, request=None) -> str:
|
||||
"""Re-sign a cookie keeping its session id (used after profile edits)."""
|
||||
"""Re-sign a cookie keeping its session id (used after profile edits).
|
||||
|
||||
Les marqueurs de cohérence (``draco_sub``, ``secours`` —
|
||||
7.85.7) de l'ancien payload sont préservés : un rafraîchi
|
||||
de profil ne doit ni perdre l'identité servie ni l'exemption
|
||||
de secours.
|
||||
"""
|
||||
sid = SessionManager.session_id(cookie) if cookie else None
|
||||
payload = {
|
||||
"user": public_user(user_data),
|
||||
"created_at": datetime.now(UTC).replace(tzinfo=None).isoformat(),
|
||||
}
|
||||
if cookie:
|
||||
ancien = SessionManager.decode_payload(cookie)
|
||||
if ancien:
|
||||
for marqueur in ("draco_sub", "secours"):
|
||||
if ancien.get(marqueur):
|
||||
payload[marqueur] = ancien[marqueur]
|
||||
user_id = user_data.get("id")
|
||||
if user_id:
|
||||
if sid is None:
|
||||
|
||||
@@ -280,6 +280,14 @@ app.add_middleware(
|
||||
from app.middleware.recherche_cors import RechercheCorsMiddleware
|
||||
|
||||
app.add_middleware(RechercheCorsMiddleware)
|
||||
|
||||
# Cohérence d'identité (7.85.7) : ajoutée en dernier, donc la plus
|
||||
# externe — une page dont la session locale contredit le cookie
|
||||
# draco valide présenté est renvoyée au pont avant tout service.
|
||||
# Le middleware ne traverse que les GET de pages (voir son module).
|
||||
from app.middleware.coherence_draco import CoherenceDracoMiddleware
|
||||
|
||||
app.add_middleware(CoherenceDracoMiddleware)
|
||||
app.include_router(auth.router)
|
||||
app.include_router(sso_router)
|
||||
app.include_router(dashboard.router)
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
"""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
|
||||
+13
-2
@@ -484,7 +484,11 @@ def local_login(request: Request, body: dict = Body(default={})):
|
||||
{"error": "Porte de secours : identifiants invalides."},
|
||||
status_code=401,
|
||||
)
|
||||
session = SessionManager.create_session(compte_secours, request)
|
||||
# Session marquée « secours » (7.85.7) : exemptée du
|
||||
# contrôle de cohérence d'identité — elle vit hors circuit
|
||||
# central par construction.
|
||||
session = SessionManager.create_session(
|
||||
compte_secours, request, secours=True)
|
||||
_log_login(compte_secours["id"], request)
|
||||
response = JSONResponse({"status": "ok", "user": {
|
||||
"login": compte_secours["login"],
|
||||
@@ -701,7 +705,14 @@ de l'instance reste possible par la page de connexion.</p>
|
||||
)
|
||||
if user is None:
|
||||
return RedirectResponse(url="/auth/login?provider=local", status_code=302)
|
||||
session = SessionManager.create_session(user, request)
|
||||
# Cohérence d'identité (7.85.7) : la session créée par le pont
|
||||
# inscrit le sub qu'elle sert dans son payload signé — base de
|
||||
# comparaison du contrôle de cohérence, insensible au repli
|
||||
# mono-utilisateur de la résolution.
|
||||
_claims = draco.claims_valides(request)
|
||||
session = SessionManager.create_session(
|
||||
user, request,
|
||||
draco_sub=str(_claims.get("sub", "")) if _claims else None)
|
||||
_log_login(user["id"], request)
|
||||
cible = next if next.startswith("/") and not next.startswith("//") else "/workspaces"
|
||||
response = RedirectResponse(url=cible, status_code=302)
|
||||
|
||||
@@ -149,6 +149,30 @@ def is_revoked(jti: str) -> bool:
|
||||
return jti in _revoked_cache
|
||||
|
||||
|
||||
def claims_valides(request) -> dict | None:
|
||||
"""Claims du cookie draco de la requête, validité complète, ou None.
|
||||
|
||||
Signature et expiration (``verify_token``), révocation du
|
||||
``jti`` selon le cache alimenté par l'émettrice, ``sub``
|
||||
présent — la même validité que celle qu'exige
|
||||
``user_for_draco`` avant de résoudre. Consommé par le contrôle
|
||||
de cohérence d'identité (7.85.7) : un cookie absent, invalide,
|
||||
expiré ou révoqué vaut « aucune identité centrale présentée »
|
||||
et ne doit rien déclencher.
|
||||
"""
|
||||
if not enabled():
|
||||
return None
|
||||
claims = verify_token(request.cookies.get(COOKIE_NAME, ""))
|
||||
if not claims:
|
||||
return None
|
||||
jti = str(claims.get("jti", ""))
|
||||
if jti and is_revoked(jti):
|
||||
return None
|
||||
if not str(claims.get("sub", "")):
|
||||
return None
|
||||
return claims
|
||||
|
||||
|
||||
# ── Résolution sub → utilisateur local ──────────────────────────────────
|
||||
|
||||
def _linked_user(conn, sub: str) -> dict | None:
|
||||
|
||||
Reference in New Issue
Block a user