From 365a724e6e1f1c553f12b284c47717df0a2afc38 Mon Sep 17 00:00:00 2001 From: Spark Date: Mon, 16 Nov 2026 19:50:25 +0000 Subject: [PATCH] fix(sso): rattachement par homonymie, conflit explicite et re-liaison par double preuve au pont draco (0.46.10) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- CHANGELOG.md | 11 + VERSION | 2 +- app/accounts.py | 115 +++++++++-- app/main.py | 205 ++++++++++++++++++- app/templates/draco_relier.html | 46 +++++ docs/correspondance-draco.md | 75 +++++-- tests/test_draco_correspondance.py | 33 ++- tests/test_draco_rattachement.py | 317 +++++++++++++++++++++++++++++ tests/test_draco_sso.py | 12 +- 9 files changed, 768 insertions(+), 48 deletions(-) create mode 100644 app/templates/draco_relier.html create mode 100644 tests/test_draco_rattachement.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 024a927..b19c07a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,14 @@ +## 0.46.10 — 2026-11-16 — SSO : rattachement par homonymie, conflit explicite, re-liaison par double preuve + +Cas réel (dev de Bruno) : connecté chez ObsiGate avec son compte « bruno », le bouton SSO de Kanbante ne le connectait pas à son compte. Diagnostic prouvé en pile fidèle à son état (secrets partagés identiques, épingles officielles, admin local « bruno » d'amorçage + instance multi-utilisateurs) : la résolution ne cherchait que par `sub` — à sub inconnu, le JIT créait un clone suffixé « bruno-2 » (membre) et ouvrait SA session, que le compte local « bruno » soit sans lien ou lié à un ancien sub ; et un jeton présent mais illisible pour Kanbante (secret du conteneur divergent, révocation) ramenait au formulaire **nu**, sans session ni message. + +- **Rattachement par homonymie** (`app.accounts.resolve_draco_user`, étape 3) : un compte local portant exactement le nom d'utilisateur de l'identité présentée (base dérivée des claims) et **sans lien draco** est rattaché au sub vérifié et servi — fini le clone « bruno-2 » pour le propriétaire légitime. Fondement : les noms centraux font foi (comptes créés par l'administrateur au Hub, aucune inscription publique). Un sub de nom **différent** n'absorbe toujours aucun compte (fusion #145 intacte) ; un homonyme désactivé n'est jamais contourné. +- **Conflit explicite** : homonyme déjà lié à un **autre** sub → aucun rattachement silencieux, aucun clone : le pont redirige vers `/login?draco=conflit` et le formulaire explique la sortie (nouveau `accounts.draco_conflit_nom`). +- **Re-liaison par double preuve** : connexion locale par mot de passe réussie pendant qu'un cookie draco valide désaligné est présent (ou passage du pont avec session native) → page **`/auth/draco/relier`** nommant les deux identités ; le geste, revérifié (session + cookie + CSRF), réécrit `users.draco_sub` — retrait à l'ancien détenteur compris, journalisé `draco.relink.retrait` / `draco.relink`. Le compte délié garde son mot de passe local. +- **Jeton illisible signalé** : jeton draco **présent** mais non validé par Kanbante (signature, expiration, révocation) → `/login?draco=invalide` avec message explicite ; jeton **absent** → formulaire nu inchangé. +- **Documentation** : `docs/correspondance-draco.md` (résolution en 5 étapes, re-liaison par double preuve, jeton illisible). +- **Tests** : nouveau `tests/test_draco_rattachement.py` (9) — cas réels A (rattachement), B (conflit), D (invalide), double preuve dans les deux sens, exigences de la re-liaison, JIT inchangé, non-absorption d'un nom différent. Le test historique `test_jit_n_adopte_pas_un_compte_homonyme_non_lie` est inversé en `test_homonyme_non_lie_rattache_depuis_04610` (le contrat qu'il figeait est précisément le défaut corrigé). Suite complète comparée à main vierge, environnement identique. + ## 0.46.9 — 2026-11-08 — Retour SSO : l'hôte de la requête fait foi pour le retour navigateur (empilée sur la 0.46.8) Cas réel (dev) : le bouton « Se connecter avec ObsiGate (SSO) » servi par kanbante-dev portait `return_to=https://kanbante.dracodev.net/auth/draco` — le retour atterrissait sur le nom officiel, où la prod n'est pas encore installée. Cause : l'adresse de retour venait de la chaîne de configuration (`resoudre_urls_draco` : variable explicite de l'app d'abord), et les adresses publiques explicites des conteneurs dev portent les noms officiels. diff --git a/VERSION b/VERSION index 2c2e21d..38dc606 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.46.9 \ No newline at end of file +0.46.10 \ No newline at end of file diff --git a/app/accounts.py b/app/accounts.py index f8bbf5f..59354c8 100644 --- a/app/accounts.py +++ b/app/accounts.py @@ -91,20 +91,29 @@ def ensure_bootstrap_admin() -> dict | None: # l'utilisateur connecté lie explicitement son compte) ; # tout autre sub inconnu suit le parcours ordinaire (JIT ou # refus selon la surface), JAMAIS l'amorçage ; -# 3. sinon, si provisionner=True : création JIT d'un compte +# 3. rattachement par HOMONYMIE (0.46.10, chantier SSO +# « bruno ») : si un compte local porte EXACTEMENT le nom +# d'utilisateur que cette identité porterait (base dérivée +# des claims, voir _base_nom_draco) et qu'il n'a AUCUN lien +# draco, le sub y est rattaché et c'est CE compte qui est +# servi — avant, le JIT créait un clone suffixé (« bruno-2 ») +# et le propriétaire légitime n'atteignait jamais son compte. +# Fondement : les noms centraux font foi — les comptes de la +# suite sont créés par l'administrateur au Hub, il n'existe +# aucune inscription publique ; un sub de nom DIFFÉRENT +# n'absorbe toujours aucun compte (le #145 reste entier). +# Si l'homonyme est déjà lié à un AUTRE sub : aucun +# rattachement silencieux, aucun clone — résolution à None, +# le pont signale le conflit (draco_conflit_nom) et la +# re-liaison exige la double preuve (voir +# app.main.draco_relier) ; +# 4. sinon, si provisionner=True : création JIT d'un compte # propre à cette identité (voir provision_draco_user). # # Avant la 0.46.5, l'étape 2 liait l'amorçage au PREMIER sub # valide de passage : sur une instance fraîche, un simple # utilisateur de la suite devenait l'administrateur local # (audit « compte partout » du 2026-11-06, carte fusion #145). -# -# Un sub inconnu ne désigne JAMAIS un compte existant non lié -# (ni l'opérateur d'environnement, ni un compte dont le nom -# ressemblerait au nom affiché draco) : la liaison d'un compte -# préexistant est un geste d'administrateur (/admin, voir -# docs/correspondance-draco.md) ou la première visite -# doublement connectée (session native + cookie draco). def _slug_draco(valeur: str) -> str: @@ -113,17 +122,28 @@ def _slug_draco(valeur: str) -> str: return re.sub(r"[^a-z0-9]+", "-", texte).strip("-")[:40].strip("-") +def _base_nom_draco(nom_affiche: str) -> str | None: + """Base du nom d'utilisateur d'une identité draco : le nom + affiché slugifié (« Alice Exemple » → « alice-exemple », + « bruno » → « bruno »). None si la base est inexploitable + (< 3 caractères) : aucune homonymie ne peut alors être + établie et le JIT retombe sur son nom de repli.""" + base = _slug_draco(nom_affiche) + return base if len(base) >= 3 else None + + def _nom_utilisateur_draco(nom_affiche: str, sub: str) -> str: """Nom d'utilisateur libre dérivé des claims (jamais réutilisé). Base : le nom affiché slugifié (« Alice Exemple » → « alice-exemple ») ; repli « draco- ». Si le nom - est déjà pris — y compris par un compte préexistant NON lié, - qui ne doit pas être adopté — un suffixe -2, -3… est ajouté : - le JIT crée toujours un compte nouveau, distinct. + est déjà pris, un suffixe -2, -3… est ajouté : hors le + rattachement par homonymie de resolve_draco_user (compte + homonyme SANS lien), le JIT crée toujours un compte nouveau, + distinct. """ - base = _slug_draco(nom_affiche) - if len(base) < 3: + base = _base_nom_draco(nom_affiche) + if base is None: base = _slug_draco(f"draco-{sub}") or "draco" candidat, n = base, 2 while models.get_user_by_username(candidat) is not None: @@ -132,6 +152,43 @@ def _nom_utilisateur_draco(nom_affiche: str, sub: str) -> str: return candidat +def _compte_homonyme(claims: dict | None, sub: str) -> dict | None: + """Compte local portant le nom d'utilisateur de l'identité + draco présentée (base dérivée des claims), ou None. + + C'est la clé du rattachement de l'étape 3 de + resolve_draco_user et du conflit signalé par + draco_conflit_nom : la comparaison porte sur le NOM + D'UTILISATEUR local contre le nom que l'émetteur fait porter + à l'identité — jamais sur un nom d'une autre forme. + """ + base = _base_nom_draco(str((claims or {}).get("name") or "")) + if base is None: + return None + return models.get_user_by_username(base) + + +def draco_conflit_nom(claims: dict | None) -> dict | None: + """Compte local homonyme de l'identité présentée mais lié à + un AUTRE sub, ou None. + + Distingue, pour le pont, l'échec « ce nom est déjà le compte + d'une autre identité de la suite » (conflit explicite, + re-liaison par double preuve) d'un échec ordinaire : la + résolution refuse alors tout rattachement et tout clone JIT. + """ + sub = str((claims or {}).get("sub") or "") + if not sub: + return None + homonyme = _compte_homonyme(claims, sub) + if homonyme is None: + return None + lie = homonyme.get("draco_sub") + if lie and lie != sub: + return homonyme + return None + + def provision_draco_user(sub: str, nom_affiche: str = "") -> dict | None: """Création JIT du compte Kanbante d'une identité draco (HUB-16). @@ -186,11 +243,14 @@ def resolve_draco_user( provisionner=False : correspondance et amorçage seulement (surfaces qui ne doivent pas créer de compte, p. ex. - /api/search). provisionner=True : création JIT si aucune - correspondance n'existe (pont /auth/draco — la « première - connexion draco » du critère « un compte fonctionne - partout »). Un compte désactivé résout à None et n'est - jamais contourné par un JIT (la correspondance existe). + /api/search — le rattachement par homonymie, qui ÉCRIT le + lien, n'y a pas lieu). provisionner=True : rattachement par + homonymie si un compte local sans lien porte le nom de + l'identité, sinon création JIT si aucune correspondance + n'existe (pont /auth/draco — la « première connexion + draco » du critère « un compte fonctionne partout »). Un + compte désactivé résout à None et n'est jamais contourné + par un JIT (la correspondance existe). Adoption de l'amorçage (fusion #145) : ``role_hub`` est le rôle du sub au registre du Hub pour kanbante, déjà consulté @@ -222,6 +282,25 @@ def resolve_draco_user( models.log_admin(seul["id"], "draco.link.amorcage", sub) return models.get_user(seul["id"]) if provisionner: + # Étape 3 — rattachement par homonymie (0.46.10) : le + # compte local qui porte le nom de cette identité et n'a + # aucun lien draco EST le compte de cette identité (les + # noms centraux sont émis par l'administrateur au Hub, + # sans inscription publique). Un homonyme désactivé + # résout à None, jamais contourné par un clone. Un + # homonyme lié à un autre sub arrête tout : ni + # rattachement silencieux, ni clone JIT — le pont + # signalera le conflit (draco_conflit_nom) et la + # re-liaison passera par la double preuve. + homonyme = _compte_homonyme(claims, sub) + if homonyme is not None: + if homonyme.get("draco_sub"): + return None + if not homonyme["active"]: + return None + models.update_user(homonyme["id"], draco_sub=sub) + models.log_admin(homonyme["id"], "draco.link.nom", sub) + return models.get_user(homonyme["id"]) cree = provision_draco_user(sub, str((claims or {}).get("name") or "")) if cree is not None and cree["active"]: return cree diff --git a/app/main.py b/app/main.py index ec49713..047f142 100644 --- a/app/main.py +++ b/app/main.py @@ -458,6 +458,16 @@ def _coherence_draco(request: Request, session_user: str) -> Response | None: path = request.url.path if path in ("/api/search", "/api/events"): return None + # Re-liaison par double preuve (0.46.10) : la page et son + # geste POST sont EXEMPTÉS de l'alignement — les aligner + # détruirait la session native (l'une des deux preuves) au + # profit du détenteur actuel du sub, précisément le compte + # que la re-liaison peut devoir délier. Les handlers de + # /auth/draco/relier revérifient eux-mêmes les deux preuves + # à l'instant du geste ; l'exemption ne sert aucune donnée + # et tout autre chemin reste aligné comme avant. + if path == "/auth/draco/relier": + return None if _session_via_secours(request): return None try: @@ -723,6 +733,34 @@ async def login_page(request: Request, next: str = "/", draco: str = ""): "pour ce compte. Utilisez le formulaire ci-dessous, ou " "réessayez le bouton de connexion ObsiGate." ) + elif draco == "conflit": + # Conflit de nom (0.46.10) : le compte local homonyme de + # l'identité présentée est lié à un AUTRE sub — aucun + # rattachement silencieux, aucun clone. La sortie est la + # double preuve : connexion locale par mot de passe, + # puis proposition de re-liaison (voir draco_relier). + erreur = ( + "Un compte Kanbante porte le même nom que votre " + "compte de la suite, mais il est relié à une autre " + "identité : la connexion automatique est refusée " + "pour protéger ce compte. Connectez-vous ci-dessous " + "avec le mot de passe local de ce compte — la " + "re-liaison à votre identité actuelle vous sera " + "proposée." + ) + elif draco == "invalide": + # Jeton présent mais illisible pour CE service + # (0.46.10) : signature, expiration ou révocation — à + # distinguer d'une absence de session centrale, qui + # arrive ici sans paramètre et sans message. + erreur = ( + "Le jeton de la suite présenté à Kanbante n'a pas " + "pu être validé (expiré, révoqué ou illisible pour " + "ce service). Reconnectez-vous chez ObsiGate, puis " + "réessayez. Si ce message persiste, l'administrateur " + "doit vérifier la configuration du service (secret " + "partagé de la suite)." + ) return render( request, "login.html", next=_safe_next(next), error=erreur, porte_centrale=bool(get_settings().porte_centrale), @@ -827,6 +865,20 @@ async def login_submit( sub = claims.get("sub") if sub and models.get_user_by_draco(sub) is None: models.update_user(user["id"], draco_sub=sub) + # Double preuve (0.46.10) : le mot de passe local vient + # d'être prouvé, et un cookie draco valide est présent + # dont l'identité ne désigne pas ce compte (ce compte + # est lié à un autre sub, ou ce sub est détenu par un + # autre compte) — au lieu de laisser les deux identités + # se contredire en silence, la session s'ouvre sur la + # proposition de re-liaison (voir draco_relier). + if _draco_desalignement(request, models.get_user(user["id"])) \ + is not None: + return _ouvrir_session( + username, + "/auth/draco/relier?next=" + + quote(_safe_next(next), safe=""), + ) return _ouvrir_session(username, next) @@ -920,6 +972,104 @@ async def logout(): return response +def _draco_desalignement(request: Request, current: dict | None): + """Désalignement entre session native et identité draco. + + Retourne ``(claims, détenteur)`` quand le navigateur porte + À LA FOIS une session native (compte ``current``, authentifié + par mot de passe) et un cookie draco **valide** dont le + ``sub`` ne désigne pas ce compte : soit ce compte est lié à + un autre sub, soit ce sub est détenu par un autre compte + (``détenteur``, éventuellement None dans le premier cas). + Retourne None si les deux identités concordent, si le sub + est libre et ce compte sans lien (la liaison silencieuse + historique s'en charge), ou si l'une des deux preuves est + absente. C'est l'état que la re-liaison par double preuve + (``/auth/draco/relier``) propose de résoudre. + """ + if current is None or current.get("id") is None: + return None + from app import draco + + claims = draco.claims_for(request) + if claims is None: + return None + sub = str(claims.get("sub") or "") + if not sub or current.get("draco_sub") == sub: + return None + detenteur = models.get_user_by_draco(sub) + if current.get("draco_sub") or detenteur is not None: + return claims, detenteur + return None + + +@app.get("/auth/draco/relier") +async def draco_relier_page(request: Request, next: str = "/"): + """Proposition de re-liaison par double preuve (0.46.10). + + Cas réel : le compte local « bruno » (mot de passe connu de + son propriétaire) est lié à un ancien sub, pendant que le + navigateur présente le sub actuel du même propriétaire — + le pont refuse le rattachement silencieux (le nom seul ne + prouve pas la propriété du compte local) et le JIT ne doit + pas créer un clone. La double preuve tranche : la session + native prouve le mot de passe local, le cookie draco valide + prouve l'identité centrale ; réunies dans le même navigateur, + elles autorisent la réécriture du lien, proposée ici de + façon explicite — jamais appliquée sans ce geste. + """ + current = _current_user(request) + if current is None or current.get("id") is None: + return RedirectResponse("/login", status_code=303) + desalign = _draco_desalignement(request, current) + if desalign is None: + return RedirectResponse(_safe_next(next), status_code=303) + claims, detenteur = desalign + return render( + request, "draco_relier.html", next=_safe_next(next), + compte_local=current["username"], + nom_draco=str(claims.get("name") or ""), + detenteur=(detenteur or {}).get("username"), + ) + + +@app.post("/auth/draco/relier") +async def draco_relier_submit( + request: Request, + next: str = Form("/"), + csrf_token: str = Form(""), +): + """Re-liaison effective : réécrit users.draco_sub. + + Les deux preuves sont revérifiées à l'instant du geste + (session native + cookie draco valide + CSRF) : le sub est + retiré à son détenteur actuel, s'il y en a un, et posé sur + le compte de la session. Les deux gestes sont journalisés + (draco.relink.retrait / draco.relink). Le compte délié + garde son mot de passe local : il reste accessible par le + formulaire, simplement plus désigné par la suite. + """ + current = _current_user(request) + if current is None or current.get("id") is None: + return RedirectResponse("/login", status_code=303) + if not _csrf_valid(request, csrf_token): + return render( + request, "error.html", status_code=403, + message="Session expirée — réessaie.", + ) + desalign = _draco_desalignement(request, current) + if desalign is None: + return RedirectResponse(_safe_next(next), status_code=303) + claims, detenteur = desalign + sub = str(claims.get("sub") or "") + if detenteur is not None and detenteur["id"] != current["id"]: + models.update_user(detenteur["id"], draco_sub=None) + models.log_admin(detenteur["id"], "draco.relink.retrait", sub) + models.update_user(current["id"], draco_sub=sub) + models.log_admin(current["id"], "draco.relink", sub) + return RedirectResponse(_safe_next(next), status_code=303) + + @app.get("/auth/draco") def draco_bridge(request: Request, next: str = "/"): """Fusion ACC-3.2 — pont SSO : cookie ``draco_session`` → session. @@ -932,7 +1082,18 @@ def draco_bridge(request: Request, next: str = "/"): - session native déjà ouverte : le ``sub`` libre est lié à ce compte (première visite doublement connectée, inchangé) — c'est la voie (b) de la liaison explicite de l'amorçage ; + si les deux identités se contredisent (ce compte lié à un + autre sub, ou ce sub détenu par un autre compte), la + re-liaison par double preuve est proposée + (``/auth/draco/relier``, 0.46.10) ; - ``sub`` lié à un compte : sa session est ouverte ; + - ``sub`` inconnu mais compte local HOMONYME sans lien : + rattachement et session de CE compte (0.46.10, voir + app.accounts) ; homonyme lié à un autre sub : refus + explicite ``/login?draco=conflit``, aucun clone créé ; + - jeton présent mais illisible pour ce service : refus + explicite ``/login?draco=invalide`` (0.46.10) — le + formulaire nu ne subsiste que pour un jeton absent ; - compte d'amorçage (unique compte, admin, sans liaison) : adoption CONDITIONNÉE (fusion #145, 0.46.5) — seulement si le registre du Hub donne « administrateur » pour kanbante @@ -964,7 +1125,25 @@ def draco_bridge(request: Request, next: str = "/"): settings = get_settings() claims = draco.claims_for(request) - if not settings.auth_enabled or claims is None: + if not settings.auth_enabled: + return RedirectResponse("/login", status_code=303) + if claims is None: + # Jeton ABSENT : visiteur sans session centrale — le + # formulaire nu historique, sans message (rien à + # signaler). Service draco INERTE (aucun secret + # configuré) : même formulaire nu, la fonction est + # éteinte. Jeton PRÉSENT mais illisible pour ce service + # (signature, expiration, révocation — 0.46.10) : échec + # explicite draco=invalide, jamais silencieux — c'est + # le symptôme « le bouton SSO me ramène au formulaire » + # du propriétaire légitime quand le secret partagé du + # conteneur diverge de l'émettrice. + if draco.enabled() and request.cookies.get(draco.COOKIE_NAME): + return RedirectResponse( + f"/login?next={quote(_safe_next(next), safe='')}" + "&draco=invalide", + status_code=303, + ) return RedirectResponse("/login", status_code=303) sub = str(claims.get("sub") or "") if not sub: @@ -1004,6 +1183,19 @@ def draco_bridge(request: Request, next: str = "/"): if models.get_user_by_draco(sub) is None: models.update_user(current["id"], draco_sub=sub) models.log_admin(current["id"], "draco.link", sub) + # Désalignement restant (0.46.10) : ce compte est lié à + # un autre sub, ou ce sub est détenu par un autre compte + # — la session native (mot de passe prouvé) + le cookie + # (identité prouvée) réunissent la double preuve : la + # re-liaison est proposée, jamais appliquée ici. + if _draco_desalignement( + request, models.get_user(current["id"]) + ) is not None: + return RedirectResponse( + "/auth/draco/relier?next=" + + quote(_safe_next(next), safe=""), + status_code=303, + ) return RedirectResponse(_safe_next(next), status_code=303) # Correspondance, amorçage conditionné ou création JIT : # ouvrir la session du compte que ce sub désigne — et @@ -1027,6 +1219,17 @@ def draco_bridge(request: Request, next: str = "/"): samesite="lax", ) return response + # Conflit de nom (0.46.10) : l'homonyme local de cette + # identité est lié à un autre sub — la résolution a refusé + # tout rattachement et tout clone ; le formulaire explique + # et la sortie est la double preuve (connexion locale puis + # proposition de re-liaison). + if accounts_service.draco_conflit_nom(claims) is not None: + return RedirectResponse( + f"/login?next={quote(_safe_next(next), safe='')}" + "&draco=conflit", + status_code=303, + ) # Échec de résolution (0.46.8) : retour au formulaire AVEC la # raison (paramètre draco=echec, traduit en message par # login_page) — jamais un échec silencieux, et le formulaire diff --git a/app/templates/draco_relier.html b/app/templates/draco_relier.html new file mode 100644 index 0000000..aa42c8c --- /dev/null +++ b/app/templates/draco_relier.html @@ -0,0 +1,46 @@ + + + + + + + + Relier le compte — Kanbante + + + +
+ +
+ + diff --git a/docs/correspondance-draco.md b/docs/correspondance-draco.md index c47a19d..bbdefda 100644 --- a/docs/correspondance-draco.md +++ b/docs/correspondance-draco.md @@ -52,24 +52,69 @@ Dans l'ordre : doublement connectée) : l'utilisateur connecté lie explicitement son propre compte. Tout autre `sub` inconnu reçoit le parcours ordinaire - (création JIT d'un compte **membre** propre, point 4) — - jamais l'amorçage. Avant la 0.46.5, le premier `sub` valide - de passage adoptait l'amorçage quel qu'il soit : sur une - instance fraîche, un simple utilisateur de la suite devenait - l'administrateur local (audit « compte partout » du - 2026-11-06). Les autres accès de l'amorçage restent inchangés - dans tous les cas : connexion native avec le mot de passe du - compte, et repli d'urgence par les identifiants - d'environnement (formulaire et Basic), qui ne dépendent pas - de draco. -4. **Création JIT** : sinon, un compte Kanbante est créé pour + (rattachement par homonymie, point 4, ou création JIT d'un + compte **membre** propre, point 5) — jamais l'amorçage. + Avant la 0.46.5, le premier `sub` valide de passage adoptait + l'amorçage quel qu'il soit : sur une instance fraîche, un + simple utilisateur de la suite devenait l'administrateur + local (audit « compte partout » du 2026-11-06). Les autres + accès de l'amorçage restent inchangés dans tous les cas : + connexion native avec le mot de passe du compte, et repli + d'urgence par les identifiants d'environnement (formulaire + et Basic), qui ne dépendent pas de draco. +4. **Rattachement par homonymie (0.46.10)** : si un compte local + porte **exactement le nom d'utilisateur** que l'identité + présentée porterait (nom des claims slugifié — `bruno` → + `bruno`) et qu'il n'a **aucun lien draco**, le `sub` y est + rattaché (journalisé `draco.link.nom`) et c'est la session de + **ce** compte qui est ouverte. Fondement : les noms centraux + font foi — les comptes de la suite sont créés par + l'administrateur au Hub et il n'existe aucune inscription + publique ; avant la 0.46.10, ce cas créait un clone JIT + suffixé (`bruno-2`) et le propriétaire légitime n'atteignait + jamais son compte. Si l'homonyme est déjà lié à un **autre** + `sub` : **conflit explicite** — le pont redirige vers + `/login?draco=conflit`, ne rattache rien et ne crée aucun + clone ; la sortie est la re-liaison par double preuve + (§ Re-liaison par double preuve). Un homonyme **désactivé** + résout à un échec ordinaire, jamais contourné. +5. **Création JIT** : sinon, un compte Kanbante est créé pour cette identité (détail ci-dessous) et sa session est ouverte. Un `sub` inconnu n'ouvre **jamais** la session de l'opérateur -d'environnement ni celle d'un compte existant non lié — y compris -si le nom affiché draco ressemble au nom d'un compte local : le -JIT crée toujours un compte **nouveau** (nom suffixé `-2`, `-3`… -en cas de collision), jamais une adoption. +d'environnement ni celle d'un compte existant d'un **autre nom** +que le sien : hors le rattachement par homonymie du point 4 +(compte homonyme **sans lien**), le JIT crée toujours un compte +**nouveau** (nom suffixé `-2`, `-3`… en cas de collision), +jamais une adoption. + +## Re-liaison par double preuve (0.46.10) + +Quand le compte local du propriétaire est lié à un **ancien** +`sub` (ou quand le `sub` actuel est détenu par un autre +compte), aucun geste automatique ne réécrit le lien : le nom +prouve l'identité centrale, pas la propriété du compte local. +La **double preuve** la tranche : la connexion locale par mot +de passe réussie **pendant qu'un cookie draco valide de +l'identité désalignée est présent** (ou le passage du pont avec +une session native déjà ouverte) ouvre la page +`/auth/draco/relier`, qui nomme les deux identités et propose +le geste. La validation réécrit `users.draco_sub` (retrait à +l'ancien détenteur journalisé `draco.relink.retrait`, pose +journalisée `draco.relink`) ; le compte délié garde son mot de +passe local. Sans les deux preuves réunies, la page est +inatteignable et aucun lien ne bouge. + +## Jeton présent mais illisible (0.46.10) + +Le pont distingue désormais le jeton **absent** (formulaire nu +historique : visiteur sans session centrale) du jeton +**présent mais illisible** pour Kanbante (signature — secret +partagé du conteneur divergent —, expiration ou révocation) : +ce dernier cas redirige vers `/login?draco=invalide` avec un +message explicite, au lieu du retour muet qui rendait le +symptôme « le bouton SSO me ramène au formulaire » +indistinguable d'une absence de session. ## Création JIT (juste-à-temps) diff --git a/tests/test_draco_correspondance.py b/tests/test_draco_correspondance.py index f8157f3..ebfc671 100644 --- a/tests/test_draco_correspondance.py +++ b/tests/test_draco_correspondance.py @@ -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) diff --git a/tests/test_draco_rattachement.py b/tests/test_draco_rattachement.py new file mode 100644 index 0000000..9280653 --- /dev/null +++ b/tests/test_draco_rattachement.py @@ -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"] diff --git a/tests/test_draco_sso.py b/tests/test_draco_sso.py index 8b3d556..7effa76 100644 --- a/tests/test_draco_sso.py +++ b/tests/test_draco_sso.py @@ -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):