"""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)