"""0.46.10 — rattachement par homonymie, conflit explicite et re-liaison par double preuve (chantier SSO « bruno »). Cas réel (dev de Bruno, 2026-11-16) : connecté chez ObsiGate avec son compte « bruno », le bouton SSO de Kanbante ne le connectait pas à SON compte. Reproduction en pile fidèle (secrets partagés identiques, instance multi-utilisateurs, admin local « bruno » issu de l'amorçage par l'environnement) : - bruno local SANS lien draco : le pont créait un clone JIT « bruno-2 » (membre) et ouvrait SA session — l'admin légitime restait sans lien, invisible ; - bruno local lié à un ANCIEN sub : même clone, aucun signal ; - jeton présent mais illisible pour Kanbante (secret du conteneur divergent) : retour au formulaire NU, sans session ni message — indiscernable d'une absence de session centrale. Correctifs couverts ici : - rattachement par homonymie : le compte local qui porte le nom de l'identité présentée et n'a aucun lien draco est rattaché au sub vérifié et servi (les noms centraux font foi : comptes créés par l'administrateur au Hub, aucune inscription publique) ; - homonyme lié à un autre sub : refus explicite ``/login?draco=conflit``, aucun rattachement, aucun clone ; - re-liaison par double preuve : connexion locale par mot de passe pendant qu'un cookie draco valide d'une identité désalignée est présent → proposition ``/auth/draco/relier`` → réécriture du lien (retrait à l'ancien détenteur compris) ; - jeton présent mais illisible : ``/login?draco=invalide`` explicite ; jeton absent : formulaire nu inchangé en 0.46.10, nommé ``draco=absent`` depuis la 0.46.11 (ronde 2 : plus aucune sortie nue dans la chaîne d'entrée) ; - gardes : un sub de nom DIFFÉRENT n'absorbe toujours aucun compte (#145 intact) ; le JIT ordinaire est inchangé quand aucun homonyme n'existe ; la re-liaison exige les deux preuves et le CSRF. """ import base64 import hashlib import hmac import json import time import httpx import pytest from fastapi.testclient import TestClient import app.main as main from app import accounts, draco, hub_roles, models SECRET = "secret-rattachement-04610" SECRET_FAUX = "secret-rattachement-DIVERGENT" SUB_ACTUEL = "rat-sub-actuel-bruno" SUB_ANCIEN = "rat-sub-ancien-bruno" SUB_INCONNU = "rat-sub-inconnu" def _jeton(sub, nom="bruno", secret=SECRET): 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": nom, "iat": int(time.time()), "exp": 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 _sub_depuis_cookie(cookie: str) -> str: for morceau in (cookie or "").split(";"): nom, _, valeur = morceau.strip().partition("=") if nom == "draco_session" and valeur.count(".") == 2: segment = valeur.split(".")[1] segment += "=" * (-len(segment) % 4) try: return json.loads(base64.urlsafe_b64decode(segment))["sub"] except Exception: return "" return "" class _Reponse: def __init__(self, status_code=200, donnees=None): self.status_code = status_code self._donnees = donnees def json(self): return self._donnees @pytest.fixture(autouse=True) def _cache_propre(): hub_roles._reset_cache() yield hub_roles._reset_cache() @pytest.fixture() def faux_hub(monkeypatch): """Faux registre du Hub : rôle « utilisateur » par défaut.""" def faux_get(url, headers=None, timeout=None): sub = _sub_depuis_cookie((headers or {}).get("Cookie", "")) return _Reponse(200, { "app": "kanbante", "sub": sub, "role": "utilisateur", "explicite": True, "ttl_secondes": 60, }) monkeypatch.setattr(httpx, "get", faux_get) return {} @pytest.fixture() def instance_bruno(monkeypatch, tmp_path, fake_gitea, faux_hub): """Instance comme celle de Bruno : amorçage « bruno » (admin, mot de passe local connu) + une membre « marie » — donc multi-utilisateurs : l'adoption d'amorçage (#145) ne peut pas jouer, seul le chemin testé décide.""" monkeypatch.setenv("KANBANTE_DB_PATH", str(tmp_path / "bruno.db")) monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno") monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "mdp-local-bruno") monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET) monkeypatch.setattr(draco, "_refresh_revocations", lambda: None) draco._revoked_cache.clear() with TestClient(main.app) as client: users = models.list_users() assert len(users) == 1 and users[0]["username"] == "bruno" bruno = users[0] marie_id = models.create_user( "marie", accounts.hash_password("mdp-marie"), role="member", display_name="Marie Test") yield client, bruno, models.get_user(marie_id) draco._revoked_cache.clear() def _pont(client, sub, nom="bruno", secret=SECRET): client.cookies.set("draco_session", _jeton(sub, nom, secret)) return client.get("/auth/draco", follow_redirects=False) def _profil_username(client) -> str: r = client.get("/profile") assert r.status_code == 200 return r.text.split("page-sub\">", 1)[1].split(" ·", 1)[0].strip() def _csrf_via_login(client) -> str: client.get("/login") return client.cookies.get("kanbante_csrf") or "" def _login_natif(client, username, password): token = _csrf_via_login(client) return client.post( "/login", data={"username": username, "password": password, "next": "/", "csrf_token": token}, follow_redirects=False, ) # ── Cas réel A : homonyme sans lien → rattachement ─────────── def test_homonyme_sans_lien_rattache_et_sert_son_compte(instance_bruno): client, bruno, _marie = instance_bruno r = _pont(client, SUB_ACTUEL, "bruno") assert r.status_code == 303 and r.headers["location"] == "/" # Aucun clone : toujours deux comptes, et le lien est sur # l'admin « bruno » lui-même. assert models.count_users() == 2 assert models.get_user_by_username("bruno-2") is None lie = models.get_user_by_draco(SUB_ACTUEL) assert lie is not None and lie["id"] == bruno["id"] assert lie["role"] == "admin" assert _profil_username(client) == "bruno" # ── Cas réel B : homonyme lié à un autre sub → conflit ─────── def test_homonyme_lie_autre_sub_conflit_explicite_sans_clone(instance_bruno): client, bruno, _marie = instance_bruno models.update_user(bruno["id"], draco_sub=SUB_ANCIEN) r = _pont(client, SUB_ACTUEL, "bruno") assert r.status_code == 303 assert "draco=conflit" in r.headers["location"] assert "kanbante_session" not in r.headers.get("set-cookie", "") # Ni rattachement ni clone : l'état est exactement l'initial. assert models.count_users() == 2 assert models.get_user(bruno["id"])["draco_sub"] == SUB_ANCIEN assert models.get_user_by_draco(SUB_ACTUEL) is None # Le formulaire explique la sortie (double preuve). r = client.get("/login?draco=conflit") assert r.status_code == 200 assert "relié à une autre" in r.text assert "re-liaison" in r.text # ── Cas réel D : jeton présent illisible → signalé ─────────── def test_jeton_present_illisible_signale_invalide(instance_bruno): client, _bruno, _marie = instance_bruno r = _pont(client, SUB_ACTUEL, "bruno", secret=SECRET_FAUX) assert r.status_code == 303 assert "draco=invalide" in r.headers["location"] assert "kanbante_session" not in r.headers.get("set-cookie", "") r = client.get("/login?draco=invalide") assert r.status_code == 200 assert "Le jeton de la suite" in r.text and "validé" in r.text def test_jeton_absent_formulaire_nu_inchange(instance_bruno): # Contrat 0.46.10 : jeton absent → formulaire, rien d'autre. # La 0.46.11 (ronde 2) nomme aussi CET échec : la # destination reste le formulaire, mais la redirection porte # draco=absent — le pont ne produit plus de sortie nue, # pour que « le bouton SSO me ramène au formulaire » soit # toujours explicable à l'écran. client, _bruno, _marie = instance_bruno r = client.get("/auth/draco", follow_redirects=False) assert r.status_code == 303 assert r.headers["location"].startswith("/login?") assert "draco=absent" in r.headers["location"] # ── Re-liaison par double preuve ───────────────────────────── def test_reliage_apres_login_local_compte_lie_ancien_sub(instance_bruno): client, bruno, _marie = instance_bruno models.update_user(bruno["id"], draco_sub=SUB_ANCIEN) # Cookie draco du sub ACTUEL présent pendant la connexion # locale par mot de passe : la proposition suit la session. client.cookies.set("draco_session", _jeton(SUB_ACTUEL, "bruno")) r = _login_natif(client, "bruno", "mdp-local-bruno") assert r.status_code == 303 assert r.headers["location"].startswith("/auth/draco/relier") # La page nomme les deux identités et le geste. r = client.get(r.headers["location"]) assert r.status_code == 200 assert "bruno" in r.text and "Relier mon compte" in r.text # Le geste réécrit le lien ; le pont sert ensuite CE compte. token = client.cookies.get("kanbante_csrf") or "" r = client.post( "/auth/draco/relier", data={"next": "/", "csrf_token": token}, follow_redirects=False, ) assert r.status_code == 303 and r.headers["location"] == "/" assert models.get_user(bruno["id"])["draco_sub"] == SUB_ACTUEL client.cookies.delete("kanbante_session") r = _pont(client, SUB_ACTUEL, "bruno") assert r.status_code == 303 and r.headers["location"] == "/" assert _profil_username(client) == "bruno" def test_reliage_retire_le_sub_a_son_detenteur(instance_bruno): client, bruno, marie = instance_bruno # Le sub actuel est détenu par marie ; bruno n'a aucun lien. models.update_user(marie["id"], draco_sub=SUB_ACTUEL) client.cookies.set("draco_session", _jeton(SUB_ACTUEL, "bruno")) r = _login_natif(client, "bruno", "mdp-local-bruno") assert r.status_code == 303 assert r.headers["location"].startswith("/auth/draco/relier") token = client.cookies.get("kanbante_csrf") or "" r = client.post( "/auth/draco/relier", data={"next": "/", "csrf_token": token}, follow_redirects=False, ) assert r.status_code == 303 assert models.get_user(marie["id"])["draco_sub"] is None assert models.get_user(bruno["id"])["draco_sub"] == SUB_ACTUEL def test_reliage_exige_les_deux_preuves_et_le_csrf(instance_bruno): client, bruno, _marie = instance_bruno models.update_user(bruno["id"], draco_sub=SUB_ANCIEN) # Sans session native : la page n'existe pas pour un visiteur # (le middleware renvoie un navigateur au formulaire). r = client.get("/auth/draco/relier", follow_redirects=False, headers={"Accept": "text/html"}) assert r.status_code == 303 assert r.headers["location"].startswith("/login") # Session native mais AUCUN cookie draco : pas de # désalignement, la page renvoie à la destination. r = _login_natif(client, "bruno", "mdp-local-bruno") assert r.status_code == 303 and r.headers["location"] == "/" r = client.get("/auth/draco/relier", follow_redirects=False) assert r.status_code == 303 and r.headers["location"] == "/" # Double preuve réunie mais CSRF absent : refus, lien intact. client.cookies.set("draco_session", _jeton(SUB_ACTUEL, "bruno")) r = client.post( "/auth/draco/relier", data={"next": "/", "csrf_token": "faux"}, follow_redirects=False, ) assert r.status_code == 403 assert models.get_user(bruno["id"])["draco_sub"] == SUB_ANCIEN # ── Gardes : JIT ordinaire et non-absorption ───────────────── def test_jit_inchange_quand_aucun_homonyme(instance_bruno): client, _bruno, _marie = instance_bruno r = _pont(client, SUB_INCONNU, "Alice Exemple") assert r.status_code == 303 and r.headers["location"] == "/" cree = models.get_user_by_draco(SUB_INCONNU) assert cree is not None and cree["username"] == "alice-exemple" assert cree["role"] == "member" assert _profil_username(client) == "alice-exemple" def test_nom_different_n_absorbe_aucun_compte(instance_bruno): client, bruno, _marie = instance_bruno r = _pont(client, SUB_INCONNU, "Mario Frère") assert r.status_code == 303 and r.headers["location"] == "/" # L'admin « bruno » n'est ni lié ni servi : un JIT propre. assert models.get_user(bruno["id"])["draco_sub"] is None cree = models.get_user_by_draco(SUB_INCONNU) assert cree is not None and cree["id"] != bruno["id"] assert _profil_username(client) == cree["username"]