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
+8
View File
@@ -1,3 +1,11 @@
## 0.46.7 — 2026-11-07 — Cohérence d'identité au changement de compte
Cas réel : connecté « fred » chez ObsiGate, l'utilisateur ouvre Kanbante et y trouve son propre compte — la session locale préexistante gouvernait sans jamais reconsulter l'identité centrale.
- **Contrôle de cohérence dans `AuthMiddleware`** (`_coherence_draco`) : quand une requête authentifiée par la session signée porte aussi un cookie `draco_session` **valide** (`app.draco.claims_for` : signature, expiration, révocation) dont le `sub` diffère du sub lié (`users.draco_sub`) au compte de la session, la session locale est invalidée — Kanbante n'a pas de session serveur : le cookie est supprimé de la réponse — et les **pages** sont renvoyées au pont `/auth/draco` (JIT si besoin) ; les **API** reçoivent un 401 avec le même effacement (aucune écriture attribuée au mauvais compte ; l'action en vol n'est pas rejouée sous une autre identité). **Gardes** : aucun cookie ou cookie invalide/expiré/révoqué → rien (une panne de l'émettrice ne déconnecte personne) ; authentification Basic (scripts) → hors contrôle ; contrats navigateur inter-apps `/api/search` et `/api/events` → exemptés (sémantiques propres) ; cookie que le pont ne peut pas servir (rôle « aucun » au registre, compte désactivé ou sans résolution) → session gardée, pas d'exclusion en boucle. **Compte local sans aucun lien** : l'identité centrale présente gagne, le pont s'applique (choix documenté). Après alignement, le compte servi est celui du cookie : pas de boucle.
- **Sessions de secours marquées** : segment signé `secours` dans le cookie de session (`user.expiry.secours.hmac`, même patron que le marqueur `draco` de la 0.46.2 ; `_session_info_complet` lit les trois formats, l'historique reste valide) — posée par `POST /login/secours`, elle exempte la session du contrôle de cohérence : elle vit hors circuit central par construction.
- **Tests** : nouveau `tests/test_coherence_identite.py` (10) — page et API alignées, pont servant ensuite le compte du cookie, même sub / sans cookie / cookie invalide intacts, secours exemptée, rôle « aucun » gardé, compte sans lien aligné, marqueurs lisibles et infalsifiables. Montage ajusté dans `tests/test_draco_correspondance.py` (la déliaison par l'administrateur se fait désormais sans cookie draco étranger dans le navigateur — c'est précisément le cas aligné par la 0.46.7). Suite complète comparée à main vierge : aucun échec nouveau (23 échecs préexistants identiques, environnement et dérive de gabarits).
## 0.46.6 — 2026-11-06 — Porte centrale unique (programme « compte partout », phase 2 — basée sur la 0.46.5)
Version **fonctionnelle** dans la série 0.46.x (base : branche 0.46.5, fusion #145/#144 ; la 0.47.0 de la PR #87 reste indépendante et non touchée). **Désactivée par défaut à la livraison** : sans activation explicite d'un administrateur, le comportement est exactement celui de la 0.46.5.
+1 -1
View File
@@ -1 +1 @@
0.46.6
0.46.7
+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")
+213
View File
@@ -0,0 +1,213 @@
"""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
dont le ``sub`` diffère du sub lié au compte de la session,
``AuthMiddleware`` invalide la session locale (suppression du
cookie signé — Kanbante n'a pas de session serveur) et renvoie
les pages au pont ``/auth/draco`` ; les API reçoivent un 401.
Gardes couvertes : même sub (inchangée), aucun cookie et cookie
invalide (intacte), session de secours marquée (exemptée), rôle
« aucun » au registre (session gardée — pas d'exclusion en
boucle), compte local sans aucun lien (l'identité centrale
présente gagne).
La base de test est partagée par toute la session (conftest) :
comptes « coh-… » créés ici et supprimés au teardown.
"""
import base64
import hashlib
import hmac
import json
import time
import pytest
from fastapi.testclient import TestClient
import app.main as main
from app import accounts, draco, hub_roles, models
SECRET = "coherence-test"
SUB_BRUNO = "coh-sub-bruno"
SUB_FRED = "coh-sub-fred"
NOMS = ("coh-bruno", "coh-fred", "coh-historique")
def _jeton(sub, secret=SECRET, exp=None):
def b64(d: bytes) -> str:
return base64.urlsafe_b64encode(d).rstrip(b"=").decode()
header = b64(json.dumps({"alg": "HS256", "typ": "JWT"}).encode())
payload = b64(json.dumps({
"sub": sub, "name": "Testeur", "iat": int(time.time()),
"exp": exp if exp is not None else int(time.time()) + 3600,
"jti": f"jti-{sub}",
}).encode())
sig = hmac.new(secret.encode(), f"{header}.{payload}".encode(),
hashlib.sha256).digest()
return f"{header}.{payload}.{b64(sig)}"
def _nettoyer():
with models.get_db() as conn:
ids = [r[0] for r in conn.execute(
"SELECT id FROM users WHERE username IN ({})".format(
",".join("?" * len(NOMS))), NOMS).fetchall()]
ids += [r[0] for r in conn.execute(
"SELECT id FROM users WHERE draco_sub IN (?, ?)",
(SUB_BRUNO, SUB_FRED)).fetchall()]
for uid in ids:
conn.execute("DELETE FROM users WHERE id = ?", (uid,))
@pytest.fixture()
def client_coh(monkeypatch, fake_gitea):
monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno")
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse")
monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET)
monkeypatch.setattr(draco, "_refresh_revocations", lambda: None)
# Registre des rôles muet (rôle inconnu), sauf test dédié.
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: None)
draco._revoked_cache.clear()
_nettoyer()
models.create_user(
"coh-bruno", accounts.hash_password("local-bruno"),
role="admin", draco_sub=SUB_BRUNO)
models.create_user(
"coh-fred", accounts.hash_password("local-fred"),
role="member", draco_sub=SUB_FRED)
models.create_user(
"coh-historique", accounts.hash_password("local-hist"),
role="member")
with TestClient(main.app) as client:
yield client
_nettoyer()
draco._revoked_cache.clear()
def _session(client, nom, **kwargs):
client.cookies.set(
"kanbante_session", main._make_session(nom, **kwargs))
def _cookie_detruit(reponse) -> bool:
brut = reponse.headers.get("set-cookie", "")
return "kanbante_session=" in brut and "Max-Age=0" in brut
# ── (iii) session d'un autre compte + cookie valide → alignement ──
def test_page_session_autre_compte_renvoyee_au_pont(client_coh):
_session(client_coh, "coh-fred")
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 303
assert r.headers["location"].startswith("/auth/draco")
assert _cookie_detruit(r)
def test_apres_alignement_le_pont_sert_le_compte_du_cookie(client_coh):
_session(client_coh, "coh-fred")
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
client_coh.get("/", follow_redirects=False)
# Le navigateur honore le Max-Age=0 de la réponse d'alignement
# (le jar du TestClient, lui, conserve le cookie périmé : on
# retire donc la session du jar pour simuler le navigateur).
client_coh.cookies.delete("kanbante_session")
# Sans session locale, le navigateur repasse par le pont.
r = client_coh.get("/auth/draco", follow_redirects=False)
assert r.status_code == 303
assert r.headers["location"] == "/"
# La session résultante (jar du client) est celle du compte du
# cookie, établie par le pont (segment marqueur « draco »).
session = client_coh.cookies.get("kanbante_session") or ""
assert session.startswith("coh-bruno.")
assert ".draco." in session
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 200
def test_api_session_autre_compte_401_et_cookie_detruit(client_coh):
_session(client_coh, "coh-fred")
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
r = client_coh.get("/api/standup")
assert r.status_code == 401
assert _cookie_detruit(r)
# ── (ii) même sub, (iv) pas de cookie, cookie invalide → intacte ──
def test_meme_sub_session_inchangee(client_coh):
_session(client_coh, "coh-fred")
client_coh.cookies.set("draco_session", _jeton(SUB_FRED))
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 200
assert not _cookie_detruit(r)
def test_sans_cookie_session_intacte(client_coh):
_session(client_coh, "coh-fred")
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 200
def test_cookie_invalide_session_intacte(client_coh):
_session(client_coh, "coh-fred")
client_coh.cookies.set(
"draco_session", _jeton(SUB_BRUNO, secret="mauvais-secret"))
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 200
# ── (v) session de secours exemptée ──────────────────────────────
def test_session_secours_exemptee(client_coh):
_session(client_coh, "coh-bruno", via_secours=True)
client_coh.cookies.set("draco_session", _jeton(SUB_FRED))
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 200
assert not _cookie_detruit(r)
# ── Gardes : rôle « aucun », compte sans lien ────────────────────
def test_role_aucun_session_gardee(client_coh, monkeypatch):
monkeypatch.setattr(
hub_roles, "role_pour", lambda *a, **k: "aucun")
_session(client_coh, "coh-fred")
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 200
assert not _cookie_detruit(r)
def test_compte_sans_lien_identite_centrale_gagne(client_coh):
_session(client_coh, "coh-historique")
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
r = client_coh.get("/", follow_redirects=False)
assert r.status_code == 303
assert r.headers["location"].startswith("/auth/draco")
assert _cookie_detruit(r)
def test_marqueur_secours_lisible_et_infalsifiable():
brut = main._make_session("coh-bruno", via_secours=True)
class Faux:
cookies = {"kanbante_session": brut}
info = main._session_info_complet(Faux())
assert info == ("coh-bruno", False, True)
# Les formats historique et draco restent lisibles.
natif = main._make_session("coh-bruno")
class Faux2:
cookies = {"kanbante_session": natif}
assert main._session_info_complet(Faux2()) == ("coh-bruno", False, False)
+6
View File
@@ -313,6 +313,12 @@ def test_liaison_par_administrateur(client_hub16):
assert _profil_username(client_hub16) == "hub16-dave"
# Déliaison par l'administrateur (champ vide).
# Le cookie draco de Dave encore présent dans le navigateur est
# retiré : depuis la cohérence d'identité (0.46.7), une session
# locale présentée avec le cookie valide d'un AUTRE sub est
# alignée sur ce sub avant tout service — l'administrateur agit
# ici dans un navigateur sans identité centrale étrangère.
client_hub16.cookies.delete("draco_session")
_connecter_admin(client_hub16)
r = client_hub16.post(
f"/admin/users/{dave_id}/draco",