214 lines
7.7 KiB
Python
214 lines
7.7 KiB
Python
"""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)
|
|
|