fix(sso): rattachement par homonymie, conflit explicite et re-liaison par double preuve au pont draco (0.46.10)
CI / test (pull_request) Failing after 1s
CI / test (push) Failing after 3m13s

Cas réel Bruno (2026-11-16) : le bouton SSO ne connectait pas son
compte « bruno » — résolution par sub seul : clone JIT « bruno-2 »
servi à la place de son admin (compte sans lien ou lié à un ancien
sub), et formulaire nu sans message quand le jeton était illisible
pour le service.

- resolve_draco_user : étape 3, rattachement par homonymie (compte
  local homonyme sans lien rattaché au sub vérifié) ; homonyme lié
  à un autre sub = conflit (aucun rattachement, aucun clone).
- Pont : /login?draco=conflit et /login?draco=invalide explicites ;
  le formulaire nu ne subsiste que pour un jeton absent ou inerte.
- Re-liaison par double preuve : /auth/draco/relier (page + POST),
  exemption de cohérence limitée à ce chemin, réécriture journalisée.
- Tests : tests/test_draco_rattachement.py (9, cas réel) ; contrat
  homonyme de test_draco_correspondance.py inversé ; refus signalés
  dans test_draco_sso.py. Doc : docs/correspondance-draco.md.
This commit is contained in:
Spark
2026-11-16 19:50:25 +00:00
parent eac6156d47
commit 365a724e6e
9 changed files with 768 additions and 48 deletions
+22 -11
View File
@@ -11,8 +11,12 @@ users.draco_sub. Couvert ici :
cas historique est couvert ici avec ce rôle simulé ;
- JIT : deux identités distinctes → deux comptes distincts,
rôle membre, mot de passe local non divulgué/inutilisable ;
- le JIT n'adopte jamais un compte préexistant non lié, même
homonyme : il crée un compte nouveau, suffixé ;
- rattachement par homonymie (0.46.10, chantier SSO
« bruno ») : un compte préexistant non lié portant le nom de
l'identité présentée est rattaché et servi — le JIT ne crée
plus de clone suffixé dans ce cas (matrice complète :
tests/test_draco_rattachement.py) ; un compte d'un nom
DIFFÉRENT n'est toujours jamais absorbé ;
- liaison / déliaison par l'administrateur depuis /admin,
conflit de sub refusé ;
- compte désactivé : correspondance refusée, aucun contournement ;
@@ -200,7 +204,16 @@ def test_jit_deux_identites_deux_comptes_distincts(client_hub16):
models.update_user(admin["id"], draco_sub=None)
def test_jit_n_adopte_pas_un_compte_homonyme_non_lie(client_hub16):
def test_homonyme_non_lie_rattache_depuis_04610(client_hub16):
# Contrat inversé en 0.46.10 (chantier SSO « bruno ») :
# avant, ce cas créait un clone JIT suffixé et le compte
# préexistant n'était ni lié ni servi — le propriétaire
# légitime n'atteignait jamais son compte. Désormais, le
# compte homonyme SANS lien est rattaché au sub vérifié
# (les noms centraux font foi : comptes créés par
# l'administrateur au Hub, aucune inscription publique).
# La matrice complète (conflit, double preuve, gardes) vit
# dans tests/test_draco_rattachement.py.
admin, pur = _unique_admin_sans_liaison()
if pur:
models.update_user(admin["id"], draco_sub="hub16-temoin-amorce")
@@ -209,16 +222,14 @@ def test_jit_n_adopte_pas_un_compte_homonyme_non_lie(client_hub16):
"carole-exemple", accounts.hash_password("local-carole"),
role="member", display_name="Carole Exemple",
)
avant = models.count_users()
r = _pont(client_hub16, "hub16-carole", "Carole Exemple")
assert r.status_code == 303 and r.headers["location"] == "/"
# Le compte préexistant n'a PAS été lié ni utilisé…
local = models.get_user(local_id)
assert local["draco_sub"] is None
# …un compte nouveau, suffixé, porte la correspondance.
cree = models.get_user_by_draco("hub16-carole")
assert cree is not None and cree["id"] != local_id
assert cree["username"] == "carole-exemple-2"
assert _profil_username(client_hub16) == "carole-exemple-2"
# Le compte préexistant est lié et servi ; aucun clone.
assert models.count_users() == avant
lie = models.get_user_by_draco("hub16-carole")
assert lie is not None and lie["id"] == local_id
assert _profil_username(client_hub16) == "carole-exemple"
finally:
if pur:
models.update_user(admin["id"], draco_sub=None)
+317
View File
@@ -0,0 +1,317 @@
"""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é ;
- 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):
client, _bruno, _marie = instance_bruno
r = client.get("/auth/draco", follow_redirects=False)
assert r.status_code == 303
assert r.headers["location"] == "/login"
# ── 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"]
+10 -2
View File
@@ -82,16 +82,24 @@ def test_pont_cookie_valide_ouvre_la_session(client_sso):
def test_pont_cookie_falsifie_vers_login(client_sso):
# Depuis la 0.46.10 : un jeton PRÉSENT mais illisible n'est
# plus ramené au formulaire nu — l'échec est explicite
# (draco=invalide, message affiché par la page de connexion).
# Le formulaire nu ne subsiste que pour un jeton absent ou
# un service draco inerte (test_pont_inerte_sans_secret).
client_sso.cookies.set("draco_session", _jeton(secret="mauvais"))
r = client_sso.get("/auth/draco", follow_redirects=False)
assert r.headers["location"] == "/login"
assert r.headers["location"].startswith("/login?")
assert "draco=invalide" in r.headers["location"]
def test_pont_jeton_revoque_refuse(client_sso):
# Même contrat 0.46.10 : refusé, et signalé comme invalide.
draco._revoked_cache["jti-revoque"] = int(time.time()) + 3600
client_sso.cookies.set("draco_session", _jeton(jti="jti-revoque"))
r = client_sso.get("/auth/draco", follow_redirects=False)
assert r.headers["location"] == "/login"
assert r.headers["location"].startswith("/login?")
assert "draco=invalide" in r.headers["location"]
def test_pont_inerte_sans_secret(monkeypatch, fake_gitea):