"""Cohérence d'identité au changement de compte (7.85.7). Cas réel (capture de Bruno) : connecté « fred » chez ObsiGate, il ouvre Flowdeck et y trouve son propre compte — la session locale préexistante gouvernait sans reconsulter l'identité centrale, le pont ne s'exécutant qu'à l'entrée SSO sans session locale. Le middleware ``CoherenceDracoMiddleware`` aligne la session sur le cookie draco valide présenté : révocation de la session locale + renvoi des pages au pont. Gardes couvertes ici : même sub (inchangée), aucun cookie / cookie invalide (intacte), session de secours marquée (exemptée), compte local sans aucun lien (l'identité centrale présente gagne), marqueur ``draco_sub`` inscrit par le pont dans le payload de session. """ import base64 import hashlib import hmac import json import time import pytest from app.auth.session import SessionManager from app.db import get_conn from app.password_utils import hash_password from app.services import draco from tests.conftest import anon SECRET = "coherence-secret" SUB_PROPRIO = "coh-sub-proprio" SUB_FRED = "coh-sub-fred" MDP = "mot-de-passe-coh" 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)}" @pytest.fixture(autouse=True) def _env(monkeypatch): monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET) monkeypatch.setattr(draco, "_refresh_revocations", lambda: None) draco._revoked_cache.clear() yield draco._revoked_cache.clear() def _creer(login, sub=None): with get_conn() as conn: cur = conn.execute( "INSERT INTO users (login, email, password_hash, full_name, is_active) " "VALUES (?, ?, ?, ?, 1)", (login, f"{login}@ex.ca", hash_password(MDP), login.title())) uid = cur.lastrowid if sub: conn.execute( "INSERT INTO draco_links (sub, user_id) VALUES (?, ?)", (sub, uid)) conn.commit() return uid def _connecter(client, login): r = client.post("/auth/local-login", json={"email": login, "password": MDP}) assert r.status_code == 200, r.text @pytest.fixture() def deux_comptes(client): proprio_id = _creer("cohproprio", SUB_PROPRIO) fred_id = _creer("cohfred", SUB_FRED) return proprio_id, fred_id # ── (iii) le cas de Bruno : session d'un autre compte ──────────── def test_session_autre_compte_alignee_sur_le_cookie(client, deux_comptes): proprio_id, _ = deux_comptes anon(client) _connecter(client, "cohproprio") client.cookies.set("draco_session", _jeton(SUB_FRED)) r = client.get("/workspaces", follow_redirects=False) assert r.status_code == 302 assert r.headers["location"].startswith("/auth/draco") assert "Max-Age=0" in r.headers.get("set-cookie", "") # La session locale du proprio est révoquée côté serveur. with get_conn() as conn: rows = conn.execute( "SELECT revoked FROM user_sessions WHERE user_id = ?", (proprio_id,)).fetchall() assert rows and all(row["revoked"] == 1 for row in rows) # Le pont sert ensuite le compte du cookie. r = client.get("/auth/draco", follow_redirects=False) assert r.status_code == 302 assert r.headers["location"] == "/workspaces" me = client.get("/auth/user") assert me.json()["authenticated"] is True assert me.json()["user"]["login"] == "cohfred" # ── (ii) même sub, (iv) pas de cookie, cookie invalide ─────────── def test_meme_sub_session_inchangee(client, deux_comptes): anon(client) _connecter(client, "cohproprio") client.cookies.set("draco_session", _jeton(SUB_PROPRIO)) r = client.get("/workspaces", follow_redirects=False) assert r.status_code == 200 me = client.get("/auth/user") assert me.json()["user"]["login"] == "cohproprio" def test_sans_cookie_session_intacte(client, deux_comptes): anon(client) _connecter(client, "cohproprio") r = client.get("/workspaces", follow_redirects=False) assert r.status_code == 200 def test_cookie_invalide_session_intacte(client, deux_comptes): anon(client) _connecter(client, "cohproprio") client.cookies.set( "draco_session", _jeton(SUB_FRED, secret="mauvais-secret")) r = client.get("/workspaces", follow_redirects=False) assert r.status_code == 200 me = client.get("/auth/user") assert me.json()["user"]["login"] == "cohproprio" # ── (v) session de secours exemptée ────────────────────────────── def test_session_secours_exemptee(client, deux_comptes): proprio_id, _ = deux_comptes anon(client) session = SessionManager.create_session( {"id": proprio_id, "login": "cohproprio", "full_name": "Cohproprio", "is_admin": 0}, None, secours=True) client.cookies.set("flowdeck_session", session) client.cookies.set("draco_session", _jeton(SUB_FRED)) r = client.get("/workspaces", follow_redirects=False) assert r.status_code == 200 # ── Garde 4 : compte sans lien, l'identité centrale gagne ──────── def test_compte_sans_lien_aligne(client): _creer("cohproprio") # aucun lien draco _creer("cohfred", SUB_FRED) anon(client) _connecter(client, "cohproprio") client.cookies.set("draco_session", _jeton(SUB_FRED)) r = client.get("/workspaces", follow_redirects=False) assert r.status_code == 302 assert r.headers["location"].startswith("/auth/draco") # ── Marqueur du pont ───────────────────────────────────────────── def test_pont_inscrit_le_sub_servi_dans_la_session(client, deux_comptes): anon(client) client.cookies.set("draco_session", _jeton(SUB_FRED)) r = client.get("/auth/draco", follow_redirects=False) assert r.status_code == 302 brut = client.cookies.get("flowdeck_session") payload = SessionManager.decode_payload(brut) assert payload is not None assert payload.get("draco_sub") == SUB_FRED # Changement de compte central : le cookie du proprio aligne # la session (base = sub inscrit, pas le lien courant). client.cookies.set("draco_session", _jeton(SUB_PROPRIO)) r = client.get("/workspaces", follow_redirects=False) assert r.status_code == 302 assert r.headers["location"].startswith("/auth/draco")