diff --git a/CHANGELOG.md b/CHANGELOG.md index 073102c..9e62b61 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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. diff --git a/VERSION b/VERSION index 6b9ee5c..471890e 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.46.6 +0.46.7 diff --git a/app/main.py b/app/main.py index a7f957d..5eb4b7d 100644 --- a/app/main.py +++ b/app/main.py @@ -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") diff --git a/tests/test_coherence_identite.py b/tests/test_coherence_identite.py new file mode 100644 index 0000000..eb10c36 --- /dev/null +++ b/tests/test_coherence_identite.py @@ -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) + diff --git a/tests/test_draco_correspondance.py b/tests/test_draco_correspondance.py index f8b9eb5..7c8b7e4 100644 --- a/tests/test_draco_correspondance.py +++ b/tests/test_draco_correspondance.py @@ -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",