Kanbante 0.46.7 — cohérence d'identité au changement de compte : la session signée s'aligne sur le cookie draco (AuthMiddleware, sessions de secours marquées)
CI / test (push) Failing after 1s
CI / test (pull_request) Failing after 2s

This commit is contained in:
Spark
2026-11-08 04:06:55 +00:00
parent b7145e398d
commit f05a872caa
5 changed files with 366 additions and 11 deletions
+138 -10
View File
@@ -263,7 +263,8 @@ def _session_secret() -> bytes:
def _make_session(user: str, via_draco: bool = False) -> str:
def _make_session(user: str, via_draco: bool = False,
via_secours: bool = False) -> str:
"""Signed session cookie (0.22.0): user.expiry.hmac.
HUB-19 (0.46.2) : une session **établie par le pont draco**
@@ -272,9 +273,20 @@ def _make_session(user: str, via_draco: bool = False) -> str:
qui soumet ensuite ``/admin`` au registre des rôles du Hub
(voir ``_require_admin``). Les sessions natives gardent le
format historique, et les deux formats restent lisibles.
Cohérence d'identité (0.46.7) : une session **établie par la
porte de secours** porte de même un segment ``secours``
(``user.expiry.secours.hmac``) — c'est lui qui l'exempte du
contrôle de cohérence (voir ``_coherence_draco``) : elle vit
hors circuit central par construction.
"""
exp = int(time.time()) + SESSION_DAYS * 86400
charge = f"{user}.{exp}.draco" if via_draco else f"{user}.{exp}"
if via_draco:
charge = f"{user}.{exp}.draco"
elif via_secours:
charge = f"{user}.{exp}.secours"
else:
charge = f"{user}.{exp}"
sig = hmac.new(
_session_secret(), charge.encode("utf-8"), hashlib.sha256
).hexdigest()
@@ -287,16 +299,31 @@ def _session_info(request: Request) -> tuple[str, bool] | None:
Vérifie signature et expiration, dans les deux formats
(natif historique et marqué draco de la 0.46.2).
"""
info = _session_info_complet(request)
if info is None:
return None
return info[0], info[1]
def _session_info_complet(request: Request) -> tuple[str, bool, bool] | None:
"""(utilisateur, établie par draco, établie par secours), ou None.
Les segments marqueurs (``draco`` 0.46.2, ``secours`` 0.46.7)
sont couverts par la signature ; la position est relative à la
fin (l'expiration, numérique, ne peut pas les imiter).
"""
raw = request.cookies.get(SESSION_COOKIE, "")
morceaux = raw.split(".")
if len(morceaux) < 3:
return None
sig = morceaux[-1]
via_draco = len(morceaux) >= 4 and morceaux[-2] == "draco"
if via_draco:
marqueur = morceaux[-2] if len(morceaux) >= 4 else ""
via_draco = marqueur == "draco"
via_secours = marqueur == "secours"
if via_draco or via_secours:
exp = morceaux[-3]
user = ".".join(morceaux[:-3])
charge = f"{user}.{exp}.draco"
charge = f"{user}.{exp}.{marqueur}"
else:
exp = morceaux[-2]
user = ".".join(morceaux[:-2])
@@ -313,7 +340,7 @@ def _session_info(request: Request) -> tuple[str, bool] | None:
return None
except ValueError:
return None
return user, via_draco
return user, via_draco, via_secours
def _session_user(request: Request) -> str | None:
@@ -338,6 +365,12 @@ def _session_via_draco(request: Request) -> bool:
return bool(info and info[1] and _session_user(request) is not None)
def _session_via_secours(request: Request) -> bool:
"""Vrai si la session présentée a été établie par la porte de secours."""
info = _session_info_complet(request)
return bool(info and info[2] and _session_user(request) is not None)
def _basic_ok(request: Request) -> bool:
settings = get_settings()
header = request.headers.get("authorization", "")
@@ -393,6 +426,85 @@ def _current_user(request: Request) -> dict | None:
return None
def _coherence_draco(request: Request, session_user: str) -> Response | None:
"""Cohérence d'identité au changement de compte (0.46.7).
Cas réel : connecté « fred » chez ObsiGate, l'utilisateur ouvre
Kanbante et y trouve son propre compte — la session locale
préexistante gouvernait sans reconsulter l'identité centrale.
Quand la requête porte AUSSI un cookie ``draco_session``
**valide** (``app.draco.claims_for`` : signature, expiration,
révocation) dont le ``sub`` diffère du sub lié au compte de la
session, la session locale est invalidée — Kanbante n'a pas de
session serveur : supprimer le cookie de la réponse suffit —
et le navigateur repasse par le pont ``/auth/draco`` (JIT si
besoin) ; les appels API reçoivent un 401 avec le même
effacement, aucune écriture n'est attribuée au mauvais compte.
Gardes : aucun cookie ou cookie invalide/expiré/révoqué → None
(on ne touche à rien) ; session de la porte de secours
(marqueur signé ``secours``) → exemptée ; compte local sans
aucun lien draco → l'identité centrale présente gagne (le pont
s'applique, choix documenté) ; cookie que le pont ne peut pas
servir (rôle « aucun » au registre, compte désactivé, aucune
résolution) → session gardée : la détruire exclurait son
titulaire en boucle, le cookie refusé restant présent. Les
contrats navigateur inter-apps ``/api/search`` et
``/api/events`` gardent leurs sémantiques propres et sont
exemptés. Après alignement, le compte servi est celui du
cookie : pas de boucle.
"""
path = request.url.path
if path in ("/api/search", "/api/events"):
return None
if _session_via_secours(request):
return None
try:
from app import accounts as accounts_service
from app import draco
from app import hub_roles
claims = draco.claims_for(request)
if claims is None:
return None
sub = str(claims.get("sub") or "")
row = models.get_user_by_username(session_user)
sub_lie = row["draco_sub"] if row is not None else None
if sub_lie and sub_lie == sub:
return None
role = hub_roles.role_pour(
request.headers.get("cookie", ""), sub,
hote=request.headers.get("host"),
)
if role == "aucun":
return None
candidat = accounts_service.resolve_draco_user(
claims, provisionner=True, role_hub=role)
if candidat is None:
return None
if row is not None and candidat["id"] == row["id"]:
return None # le pont résout déjà vers ce compte
if row is None and candidat["username"] == session_user:
return None # opérateur d'environnement résolu tel quel
except Exception:
return None
if path.startswith("/api/") or path.startswith("/mcp"):
response: Response = JSONResponse(
{"ok": False,
"error": "Session alignée sur l'identité de la suite — "
"reconnectez-vous."},
status_code=401,
)
else:
target = path
if request.url.query:
target = f"{path}?{request.url.query}"
response = RedirectResponse(
f"/auth/draco?next={quote(target, safe='')}", status_code=303)
response.delete_cookie(SESSION_COOKIE)
return response
class AuthMiddleware(BaseHTTPMiddleware):
"""Session cookie (browser) or Basic header (scripts)."""
@@ -422,6 +534,14 @@ class AuthMiddleware(BaseHTTPMiddleware):
row = models.get_user_by_username(session_user)
if row is not None and not row["active"]:
session_user = None # disabled account: session is dead
# Cohérence d'identité (0.46.7) : une session locale qui
# contredit un cookie draco valide est alignée sur le
# cookie avant de servir quoi que ce soit. L'authentification
# Basic (scripts) n'est pas une session : hors contrôle.
if session_user is not None and not _basic_ok(request):
reponse = _coherence_draco(request, session_user)
if reponse is not None:
return reponse
if session_user is not None or _basic_ok(request):
return await call_next(request)
# Jetons d'API (0.25.0) : surfaces machine seulement — un jeton
@@ -536,12 +656,18 @@ def _safe_next(raw: str) -> str:
return "/"
def _ouvrir_session(username: str, next: str) -> RedirectResponse:
"""Réponse de connexion native : session signée posée, redirection."""
def _ouvrir_session(username: str, next: str,
secours: bool = False) -> RedirectResponse:
"""Réponse de connexion native : session signée posée, redirection.
``secours=True`` (0.46.7) marque la session de la porte de
secours : elle est exemptée du contrôle de cohérence
d'identité (voir ``_coherence_draco``).
"""
response = RedirectResponse(_safe_next(next), status_code=303)
response.set_cookie(
SESSION_COOKIE,
_make_session(username),
_make_session(username, via_secours=secours),
max_age=SESSION_DAYS * 86400,
httponly=True,
samesite="lax",
@@ -741,7 +867,9 @@ async def login_secours_submit(
),
)
models.log_admin(compte["id"], "login.porte_secours", username)
return _ouvrir_session(settings.porte_secours_user, next)
# Session marquée « secours » (0.46.7) : exemptée du contrôle
# de cohérence d'identité, elle vit hors circuit central.
return _ouvrir_session(settings.porte_secours_user, next, secours=True)
@app.get("/logout")