fix(sso): rattachement par homonymie, conflit explicite et re-liaison par double preuve au pont draco (0.46.10)
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:
@@ -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)
|
||||
|
||||
@@ -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
@@ -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):
|
||||
|
||||
Reference in New Issue
Block a user