From 7b0fee43d24b1e7f2da4b3690a38bb43eab16006 Mon Sep 17 00:00:00 2001 From: Spark Date: Mon, 16 Nov 2026 21:15:04 +0000 Subject: [PATCH] =?UTF-8?q?fix(sso):=20aucune=20sortie=20nue=20au=20pont,?= =?UTF-8?q?=20=C2=AB=20aucun=20=C2=BB=20seulement=20si=20d=C3=A9cid=C3=A9,?= =?UTF-8?q?=20pont=20inerte=20signal=C3=A9=20(0.46.11)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ronde 2 du cas « bruno » : la 0.46.10 déployée, le bouton SSO ramenait toujours au formulaire nu. Reproduction en pile de chaque état candidat : la seule variante au symptôme identique est DRACO_SESSION_SECRET absent du conteneur — draco inerte, claims toujours None, sortie « jeton absent » vers /login nu, bouton SSO rendu quand même. - Pont : jeton absent → draco=absent ; cookie présent + service inerte → draco=inactif ; sub vide → draco=invalide. Le middleware signale de même une page demandée avec un cookie présent mais inutilisable. Relier sans session → draco=echec. - Registre des rôles : hub_roles transporte le drapeau « explicite » (explicite_pour, cache partagé) ; le pont ne refuse un « aucun » que s'il est explicite ou d'origine inconnue — un défaut du registre ne verrouille plus l'entrée. - Tests : contrats des sorties nues mis à jour (le cas réel du conteneur sans secret est test_pont_inerte_sans_secret), rôle aucun dans ses trois états, drapeau transporté. Suite complète : échecs identiques à l'arbre vierge (23). --- CHANGELOG.md | 9 ++ VERSION | 2 +- app/hub_roles.py | 59 +++++++++++-- app/main.py | 138 +++++++++++++++++++++++++------ docs/correspondance-draco.md | 53 +++++++++--- tests/test_draco_rattachement.py | 13 ++- tests/test_draco_sso.py | 95 +++++++++++++++++++-- tests/test_entree_sso.py | 16 ++++ tests/test_hub_roles.py | 34 ++++++++ 9 files changed, 365 insertions(+), 54 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b19c07a..53fc8f8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,12 @@ +## 0.46.11 — 2026-11-16 — SSO : plus aucune sortie nue, « aucun » seulement si décidé, pont inerte signalé + +Ronde 2 du cas réel (dev de Bruno) : la 0.46.10 déployée, le bouton SSO ramenait toujours le compte « bruno » au formulaire **nu** — URL `/login` sans paramètre, aucun message — alors que son cookie draco était valide (lu par ShaarIt et TikTak dans le même navigateur). Énumération complète des sorties de la chaîne d'entrée draco (pont, middleware de cohérence #150, entrée automatique 0.46.8, registre des rôles, révocations, rattachement/conflit, re-liaison) et reproduction en pile fidèle de chaque état candidat : la seule variante qui reproduit le symptôme à l'identique est **`DRACO_SESSION_SECRET` absent du conteneur Kanbante** — draco inerte, `claims_for` toujours None, le pont prenait la sortie « jeton absent » vers `/login` nu, pendant que le bouton SSO continuait d'être rendu. Les autres candidates sont signalées ou servent un compte (rôle explicite → 403 lu ; conflit → message dans la page finale ; jeton révoqué → `draco=invalide` ; session du clone « bruno-2 » → le clone est servi). La cause racine est donc un état du conteneur, mais le code taisait l'échec : c'est ce silence qui est corrigé ici, pour que le prochain écart de configuration se lise à l'écran au lieu de se deviner. + +- **Aucune sortie nue (pont, middleware, re-liaison)** : jeton absent → `/login?draco=absent` (« Aucune session de la suite n'a été présentée ») ; cookie présent mais service draco inerte → `/login?draco=inactif` (« la connexion par la suite n'est pas active sur ce service — configuration incomplète ») ; les sorties `invalide` (0.46.10), `conflit` (0.46.10) et `echec` (0.46.8) sont inchangées. L'entrée automatique du middleware signale de même une page demandée avec un cookie présent mais inutilisable (`invalide` / `inactif`) au lieu du formulaire muet. Les sorties de `/auth/draco/relier` sans session native portent `draco=echec`. Le propriétaire légitime dont le conteneur perd le secret verra donc le nom du défaut — et le geste de réparation est côté hébergement (remettre le secret partagé dans l'environnement du conteneur, même valeur que l'émettrice). +- **« Aucun » seulement si décidé** (`app/hub_roles.py`) : la consultation du registre transporte désormais le drapeau `explicite` de la réponse (nouveau `explicite_pour`, même cache que `role_pour`). Le pont ne refuse un rôle « aucun » que s'il est explicite ou d'origine inconnue (réponse sans le drapeau : comportement historique conservé). Un « aucun » que le registre présente comme son défaut (`explicite: false`) n'est pas une décision de l'administrateur : il ne verrouille plus l'entrée — conformément à l'esprit du pilote (« le registre ne crée jamais un verrouillage nouveau »). Vérifié en pile : avec le Hub actuel, un compte sans ligne reçoit `utilisateur` (défaut), donc un « aucun » réel reste toujours une ligne explicite de la matrice. +- **Documentation** : `docs/correspondance-draco.md` (sorties d'échec toutes signalées ; précision `explicite` à la section des rôles). +- **Tests** : `test_draco_sso.py` (les deux tests qui figeaient les sorties nues — `test_pont_sans_cookie_vers_login`, `test_pont_inerte_sans_secret`, le cas réel du conteneur sans secret — portent le nouveau contrat ; ajoutés : entrée par page avec service inerte, rôle « aucun » non explicite / explicite / d'origine inconnue), `test_entree_sso.py` (cookie invalide signalé au formulaire), `test_hub_roles.py` (transport du drapeau `explicite`, cache partagé), `test_draco_rattachement.py` (contrat du jeton absent mis à jour). Suite complète : listes d'échecs strictement identiques à l'arbre vierge (23, fonds préexistant instable), 7 tests nouveaux tous verts. + ## 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. diff --git a/VERSION b/VERSION index 38dc606..3724114 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.46.10 \ No newline at end of file +0.46.11 diff --git a/app/hub_roles.py b/app/hub_roles.py index 8a60760..78cd1ce 100644 --- a/app/hub_roles.py +++ b/app/hub_roles.py @@ -23,6 +23,16 @@ jamais d'URL dev figée. illisible → ``None`` (rôle **inconnu**), et l'appelant garde son comportement actuel. Le registre ne crée jamais un verrouillage nouveau. + +Depuis la 0.46.11, la consultation transporte aussi le drapeau +``explicite`` de la réponse : le niveau vient-il d'une ligne +posée par l'administrateur (``True``), du défaut du registre +(``False``), ou la réponse ne le dit-elle pas (``None``) ? Le +pont s'en sert pour ne traiter un « aucun » comme un +verrouillage que lorsqu'il est explicite ou d'origine inconnue : +un « aucun » que le registre présente lui-même comme un défaut +n'est pas une décision de l'administrateur et ne doit fermer +aucune porte. """ from __future__ import annotations @@ -47,7 +57,7 @@ CACHE_TTL = 60.0 # secondes ROLES_CONNUS = ("aucun", "utilisateur", "administrateur") _verrou = threading.Lock() -_cache: dict[str, str] = {} +_cache: dict[str, tuple[str, bool | None]] = {} _cache_fetched_at: float = 0.0 @@ -59,8 +69,16 @@ def _reset_cache() -> None: _cache_fetched_at = 0.0 -def _consulter(hub_url: str, cookie: str) -> str | None: - """Un appel au registre ; rôle connu ou ``None`` (inconnu).""" +def _consulter( + hub_url: str, cookie: str +) -> tuple[str, bool | None] | None: + """Un appel au registre ; ``(rôle, explicite)`` ou ``None``. + + ``explicite`` vaut ``True`` si le niveau vient d'une ligne + posée par l'administrateur, ``False`` s'il vient du défaut + du registre, ``None`` si la réponse ne le dit pas (le Hub + actuel l'émet toujours). + """ url = f"{hub_url.rstrip('/')}/api/roles/{APP}" try: reponse = httpx.get( @@ -84,15 +102,22 @@ def _consulter(hub_url: str, cookie: str) -> str | None: if not isinstance(donnees, dict): return None role = donnees.get("role") - return role if role in ROLES_CONNUS else None + if role not in ROLES_CONNUS: + return None + explicite = donnees.get("explicite") + return role, explicite if isinstance(explicite, bool) else None -def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None: - """Niveau connu pour ce ``sub`` : un rôle ou ``None`` (inconnu). +def _detail_pour( + cookie: str, sub: str, hote: str | None = None +) -> tuple[str, bool | None] | None: + """``(rôle, explicite)`` connus pour ce ``sub``, ou ``None``. ``cookie`` est l'en-tête Cookie complet de la requête, relayé tel quel au Hub ; ``hote`` est l'hôte public de la requête, - pour résoudre l'URL du Hub comme la barre commune. + pour résoudre l'URL du Hub comme la barre commune. Cache + partagé par ``role_pour`` et ``explicite_pour`` : une seule + consultation par ``sub`` et par TTL. """ global _cache_fetched_at sub = str(sub or "") @@ -118,3 +143,23 @@ def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None: hub_url, APP, ) return resultat + + +def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None: + """Niveau connu pour ce ``sub`` : un rôle ou ``None`` (inconnu).""" + detail = _detail_pour(cookie, sub, hote) + return detail[0] if detail is not None else None + + +def explicite_pour( + cookie: str, sub: str, hote: str | None = None +) -> bool | None: + """Le niveau de ce ``sub`` est-il une décision explicite ? + + ``True`` : ligne posée par l'administrateur dans la matrice + du Hub. ``False`` : le registre applique son défaut, aucune + décision n'existe pour ce compte. ``None`` : inconnu (Hub + injoignable ou réponse sans le drapeau). + """ + detail = _detail_pour(cookie, sub, hote) + return detail[1] if detail is not None else None diff --git a/app/main.py b/app/main.py index 047f142..f2df891 100644 --- a/app/main.py +++ b/app/main.py @@ -597,6 +597,11 @@ class AuthMiddleware(BaseHTTPMiddleware): # historique est inchangé (formulaire, pages publiques). # Symétrique du contrôle de cohérence de la 0.46.7, qui # couvre le cas inverse (session locale d'un AUTRE compte). + # 0.46.11 : un cookie draco PRÉSENT mais inutilisable + # (illisible, ou service inerte) n'aboutit plus au + # formulaire muet — la redirection finale ci-dessous + # porte draco=invalide / draco=inactif, comme le pont. + draco_echec = None if not path.startswith("/api/") and not path.startswith("/mcp") \ and "text/html" in request.headers.get("accept", ""): try: @@ -610,6 +615,9 @@ class AuthMiddleware(BaseHTTPMiddleware): f"/auth/draco?next={quote(target, safe='')}", status_code=303, ) + if request.cookies.get(_draco.COOKIE_NAME): + draco_echec = ( + "invalide" if _draco.enabled() else "inactif") except Exception: pass # API consumers get a plain 401 (no browser prompt, no @@ -624,6 +632,12 @@ class AuthMiddleware(BaseHTTPMiddleware): target = path if request.url.query: target = f"{path}?{request.url.query}" + if draco_echec: + return RedirectResponse( + f"/login?next={quote(target, safe='')}" + f"&draco={draco_echec}", + status_code=303, + ) return RedirectResponse(f"/login?next={quote(target, safe='')}", status_code=303) @@ -725,7 +739,9 @@ async def login_page(request: Request, next: str = "/", draco: str = ""): # local (voir app/templates/login.html et docs/porte-centrale.md). # Échec du pont (0.46.8) : draco=echec posé par /auth/draco # quand la résolution du compte a échoué — le formulaire - # l'explique au lieu d'un retour muet. + # l'explique au lieu d'un retour muet. Depuis la 0.46.11, + # chaque sortie d'échec de la chaîne est nommée : conflit, + # invalide, absent, inactif (voir les branches ci-dessous). erreur = "" if draco == "echec": erreur = ( @@ -751,8 +767,9 @@ async def login_page(request: Request, next: str = "/", draco: str = ""): 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. + # distinguer d'une absence de session centrale + # (draco=absent) et d'un pont non configuré + # (draco=inactif), distingués depuis la 0.46.11. erreur = ( "Le jeton de la suite présenté à Kanbante n'a pas " "pu être validé (expiré, révoqué ou illisible pour " @@ -761,6 +778,31 @@ async def login_page(request: Request, next: str = "/", draco: str = ""): "doit vérifier la configuration du service (secret " "partagé de la suite)." ) + elif draco == "absent": + # Aucune session centrale présentée au pont (0.46.11) : + # le parcours SSO est arrivé sans cookie draco — session + # de la suite absente ou cookie non transmis. + erreur = ( + "Aucune session de la suite n'a été présentée à " + "Kanbante : la connexion par ObsiGate n'a reçu " + "aucune identité à valider. Connectez-vous d'abord " + "chez ObsiGate, puis réessayez le bouton — ou " + "utilisez le formulaire ci-dessous." + ) + elif draco == "inactif": + # Pont draco non configuré sur CE service (0.46.11) : + # aucun secret partagé dans la configuration du + # conteneur — le pont ne peut valider aucune session + # centrale, quel que soit le compte. Défaut de + # configuration, pas une faute de l'utilisateur. + erreur = ( + "La connexion par la suite (ObsiGate) n'est pas " + "active sur ce service : Kanbante ne peut valider " + "aucune session centrale (configuration du service " + "incomplète). Utilisez le formulaire ci-dessous ; " + "l'administrateur doit vérifier le secret partagé " + "de la suite dans la configuration du service." + ) return render( request, "login.html", next=_safe_next(next), error=erreur, porte_centrale=bool(get_settings().porte_centrale), @@ -1020,7 +1062,10 @@ async def draco_relier_page(request: Request, next: str = "/"): """ current = _current_user(request) if current is None or current.get("id") is None: - return RedirectResponse("/login", status_code=303) + # Sans la session native (une des deux preuves), rien à + # proposer : retour au formulaire AVEC la raison + # (0.46.11 — aucune redirection nue dans la chaîne). + return RedirectResponse("/login?draco=echec", status_code=303) desalign = _draco_desalignement(request, current) if desalign is None: return RedirectResponse(_safe_next(next), status_code=303) @@ -1051,7 +1096,7 @@ async def draco_relier_submit( """ current = _current_user(request) if current is None or current.get("id") is None: - return RedirectResponse("/login", status_code=303) + return RedirectResponse("/login?draco=echec", status_code=303) if not _csrf_valid(request, csrf_token): return render( request, "error.html", status_code=403, @@ -1092,8 +1137,18 @@ def draco_bridge(request: Request, next: str = "/"): 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 ; + explicite ``/login?draco=invalide`` (0.46.10) ; + - depuis la 0.46.11, AUCUNE sortie du pont n'est nue : + jeton absent → ``/login?draco=absent`` (le parcours SSO + n'a présenté aucune identité à valider) et service draco + inerte (aucun secret configuré) avec un cookie présenté + → ``/login?draco=inactif`` (le pont ne peut rien valider + sur ce service : défaut de configuration, pas de + l'utilisateur). Cas réel : le conteneur kanbante-dev + avait perdu ``DRACO_SESSION_SECRET`` — le bouton SSO, + rendu quand même, ramenait le propriétaire légitime au + formulaire nu, sans session ni message, pendant que + ShaarIt et TikTak lisaient son cookie ; - 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 @@ -1118,6 +1173,15 @@ def draco_bridge(request: Request, next: str = "/"): accès ne passent pas par ce pont et ne sont pas touchés : session native préexistante, connexion native (mot de passe), Basic d'environnement, jetons ``kbt_``. + + 0.46.11 : le refus sur « aucun » n'a lieu que si ce niveau + est une décision — ``explicite`` vrai dans la réponse du + registre, ou d'origine inconnue (réponse sans le drapeau : + comportement historique conservé). Un « aucun » que le + registre présente lui-même comme son défaut + (``explicite: false``) n'a jamais été décidé par + l'administrateur : il ne verrouille pas l'entrée (le + registre ne crée jamais un verrouillage nouveau). """ from app import accounts as accounts_service from app import draco @@ -1126,36 +1190,58 @@ def draco_bridge(request: Request, next: str = "/"): settings = get_settings() claims = draco.claims_for(request) if not settings.auth_enabled: - return RedirectResponse("/login", status_code=303) + # Aucune authentification sur cette instance : il n'y a + # pas d'échec SSO à signaler — la cible directement (la + # page /login redirigerait elle-même vers elle). + return RedirectResponse(_safe_next(next), 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 + # Aucune sortie nue (0.46.11) : chaque échec du parcours + # central est nommé au formulaire, qui l'explique. + # — Jeton PRÉSENT mais illisible pour ce service + # (signature, expiration, révocation — 0.46.10) : + # 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): + # — Cookie PRÉSENT mais service draco INERTE (aucun + # secret configuré dans CE conteneur) : draco=inactif — + # le pont ne peut valider aucune identité, c'est un + # défaut de configuration du service, pas de + # l'utilisateur (cas réel kanbante-dev, 2026-11-16). + # — Jeton ABSENT : draco=absent — le parcours SSO n'a + # présenté aucune session de la suite à valider. + cible = f"/login?next={quote(_safe_next(next), safe='')}" + if request.cookies.get(draco.COOKIE_NAME): + if draco.enabled(): + return RedirectResponse( + cible + "&draco=invalide", status_code=303) return RedirectResponse( - f"/login?next={quote(_safe_next(next), safe='')}" - "&draco=invalide", - status_code=303, - ) - return RedirectResponse("/login", status_code=303) + cible + "&draco=inactif", status_code=303) + return RedirectResponse(cible + "&draco=absent", status_code=303) sub = str(claims.get("sub") or "") if not sub: - return RedirectResponse("/login", status_code=303) + return RedirectResponse( + f"/login?next={quote(_safe_next(next), safe='')}" + "&draco=invalide", + status_code=303, + ) # HUB-19 : consultation du registre AVANT toute résolution # ou création (resolve_draco_user peut créer le compte JIT : - # un sub refusé ne doit jamais en recevoir un). + # un sub refusé ne doit jamais en recevoir un). Le refus sur + # « aucun » exige une décision : niveau explicite dans la + # matrice, ou drapeau inconnu (réponse sans « explicite » — + # comportement historique). Un « aucun » que le registre + # donne comme son défaut (explicite faux) ne verrouille pas + # (0.46.11) : l'administrateur n'a rien décidé pour ce + # compte, l'entrée ordinaire suit. role_hub = hub_roles.role_pour( request.headers.get("cookie", ""), sub, hote=request.headers.get("host"), ) - if role_hub == "aucun": + if role_hub == "aucun" and hub_roles.explicite_pour( + request.headers.get("cookie", ""), sub, + hote=request.headers.get("host"), + ) is not False: return render( request, "error.html", status_code=403, message=( diff --git a/docs/correspondance-draco.md b/docs/correspondance-draco.md index bbdefda..df62edd 100644 --- a/docs/correspondance-draco.md +++ b/docs/correspondance-draco.md @@ -105,16 +105,37 @@ 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) +## Sorties d'échec du pont — toutes signalées (0.46.10, complété en 0.46.11) -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. +Depuis la 0.46.11, **aucune** sortie d'échec de la chaîne +d'entrée draco (pont, entrée automatique du middleware, +re-liaison) ne ramène au formulaire sans message : chacune +porte un paramètre `draco=` que la page de connexion traduit +en explication. + +- **Jeton présent mais illisible** (0.46.10) : signature — + secret partagé du conteneur divergent —, expiration ou + révocation → `/login?draco=invalide`, message explicite. +- **Jeton absent** (0.46.11) : le parcours SSO est arrivé au + pont sans aucun cookie `draco_session` (session de la suite + absente ou cookie non transmis) → `/login?draco=absent`. + Avant, c'était le formulaire nu historique. +- **Service draco inerte** (0.46.11) : le conteneur Kanbante + n'a **aucun** `DRACO_SESSION_SECRET` — le pont ne peut + valider aucune identité, alors que le bouton SSO est rendu + quand même. Un cookie présenté dans cet état → + `/login?draco=inactif`, qui nomme un défaut de configuration + du service. Cas réel (2026-11-16) : c'était l'état du + conteneur kanbante-dev — le propriétaire légitime, cookie + valide lu par ShaarIt et TikTak, revenait au formulaire nu + sans aucun moyen de savoir que la faute était dans le + conteneur. La même signalisation s'applique quand une page + protégée est demandée avec un cookie présent mais + inutilisable (entrée automatique du middleware). +- **Échec de résolution** (0.46.8) : compte désigné + désactivé, etc. → `/login?draco=echec`. +- **Conflit de nom** (0.46.10) : homonyme lié à un autre + `sub` → `/login?draco=conflit` (voir plus haut). ## Création JIT (juste-à-temps) @@ -182,9 +203,17 @@ draco** : liaison, la résolution de la correspondance et la création JIT. Rôle connu `aucun` → refus explicite (403, en français) : aucune session ouverte par draco pour ce - `sub`, aucun compte créé. La session que le pont ouvre - porte un marqueur « draco » couvert par la signature du - cookie (`user.expiry.draco.hmac`). + `sub`, aucun compte créé. **Précision 0.46.11** : la + consultation transporte le drapeau `explicite` de la + réponse (`app.hub_roles.explicite_pour`) et le refus + n'a lieu que si le niveau est une décision — explicite, + ou d'origine inconnue (réponse sans le drapeau : + comportement historique). Un `aucun` que le registre + présente comme son **défaut** (`explicite: false`) n'a + été décidé par personne : il ne verrouille pas l'entrée. + La session que le pont ouvre porte un marqueur « draco » + couvert par la signature du cookie + (`user.expiry.draco.hmac`). 2. **`/admin`** (et ses actions, même garde `_require_admin`) : session établie par draco + rôle du registre connu ⇒ il faut `administrateur` dans le diff --git a/tests/test_draco_rattachement.py b/tests/test_draco_rattachement.py index 9280653..198eb07 100644 --- a/tests/test_draco_rattachement.py +++ b/tests/test_draco_rattachement.py @@ -29,7 +29,9 @@ Correctifs couverts ici : 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é ; + 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 @@ -213,10 +215,17 @@ def test_jeton_present_illisible_signale_invalide(instance_bruno): 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"] == "/login" + assert r.headers["location"].startswith("/login?") + assert "draco=absent" in r.headers["location"] # ── Re-liaison par double preuve ───────────────────────────── diff --git a/tests/test_draco_sso.py b/tests/test_draco_sso.py index 7effa76..98761f4 100644 --- a/tests/test_draco_sso.py +++ b/tests/test_draco_sso.py @@ -12,7 +12,13 @@ rôle « administrateur » du registre du Hub ou à une session native) — le pont ouvre alors la session d'un compte JIT propre à l'identité, ce que ces cas vérifient (session ouverte, accès à l'app) sans présumer du compte résolu. -Sans DRACO_SESSION_SECRET, le pont renvoie simplement au login. +Sans DRACO_SESSION_SECRET, le pont est inerte : depuis la +0.46.11, un cookie présenté dans cet état est signalé +(draco=inactif) au lieu du retour nu historique — c'était le +cas réel du conteneur kanbante-dev de Bruno (ronde 2 du +chantier SSO « bruno ») : cookie valide lu par les autres +applications, bouton SSO rendu, et retour au formulaire sans +session ni message. """ import base64 @@ -25,7 +31,7 @@ import pytest from fastapi.testclient import TestClient import app.main as main -from app import draco +from app import draco, hub_roles SECRET = "secret-partage-de-test" @@ -66,9 +72,16 @@ def test_verify_token(monkeypatch): def test_pont_sans_cookie_vers_login(client_sso): + # Depuis la 0.46.11 : même destination (le formulaire), + # mais l'échec du parcours est NOMMÉ (draco=absent) — le + # pont ne produit plus aucune redirection nue. r = client_sso.get("/auth/draco", follow_redirects=False) assert r.status_code == 303 - assert r.headers["location"] == "/login" + assert r.headers["location"].startswith("/login?") + assert "draco=absent" in r.headers["location"] + r2 = client_sso.get(r.headers["location"], follow_redirects=False) + assert r2.status_code == 200 + assert "Aucune session de la suite" in r2.text def test_pont_cookie_valide_ouvre_la_session(client_sso): @@ -85,8 +98,9 @@ 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). + # La 0.46.11 a fermé les deux sorties nues restantes : + # jeton absent (draco=absent) et service draco inerte + # (draco=inactif, 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"].startswith("/login?") @@ -103,13 +117,82 @@ def test_pont_jeton_revoque_refuse(client_sso): def test_pont_inerte_sans_secret(monkeypatch, fake_gitea): + # LE cas réel de la ronde 2 (conteneur kanbante-dev sans + # DRACO_SESSION_SECRET) : avant la 0.46.11, cette réponse + # était « /login » NU — aucune session, aucun message, + # pendant que le navigateur présentait un cookie valide. + # Désormais : draco=inactif, et le formulaire nomme le + # défaut de configuration du service. monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno") monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse") monkeypatch.delenv("DRACO_SESSION_SECRET", raising=False) with TestClient(main.app) as client: client.cookies.set("draco_session", _jeton()) r = client.get("/auth/draco", follow_redirects=False) - assert r.headers["location"] == "/login" + assert r.status_code == 303 + assert "draco=inactif" in r.headers["location"] + r2 = client.get(r.headers["location"], follow_redirects=False) + assert r2.status_code == 200 + assert "n'est pas active sur ce service" in \ + r2.text.replace("'", "'") + + +def test_entree_page_cookie_present_mais_service_inerte( + monkeypatch, fake_gitea): + # Même état, autre entrée : une PAGE protégée demandée avec + # le cookie — le middleware signale draco=inactif au lieu du + # formulaire muet (0.46.11). + monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno") + monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse") + monkeypatch.delenv("DRACO_SESSION_SECRET", raising=False) + with TestClient(main.app) as client: + client.headers["Accept"] = "text/html" + client.cookies.set("draco_session", _jeton()) + r = client.get("/", follow_redirects=False) + assert r.status_code == 303 + assert "draco=inactif" in r.headers["location"] + + +# ── Registre des rôles : « aucun » ne verrouille que décidé ── + +def test_role_aucun_non_explicite_ne_verrouille_pas( + client_sso, monkeypatch): + # Le registre répond « aucun » mais dit lui-même que ce + # n'est PAS une décision de l'administrateur (défaut) : + # l'entrée ordinaire suit — session ouverte (0.46.11). + monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun") + monkeypatch.setattr( + hub_roles, "explicite_pour", lambda *a, **k: False) + client_sso.cookies.set("draco_session", _jeton()) + r = client_sso.get("/auth/draco", follow_redirects=False) + assert r.status_code == 303 + assert r.headers["location"] == "/" + assert "kanbante_session" in r.headers.get("set-cookie", "") + + +def test_role_aucun_explicite_verrouille_403(client_sso, monkeypatch): + # Décision explicite de l'administrateur : le refus 403 + # historique s'applique, avec son message. + monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun") + monkeypatch.setattr( + hub_roles, "explicite_pour", lambda *a, **k: True) + client_sso.cookies.set("draco_session", _jeton()) + r = client_sso.get("/auth/draco", follow_redirects=False) + assert r.status_code == 403 + assert "registre des rôles" in r.text + assert "kanbante_session" not in r.headers.get("set-cookie", "") + + +def test_role_aucun_origine_inconnue_verrouille_403( + client_sso, monkeypatch): + # Réponse sans le drapeau « explicite » (registre ancien) : + # comportement historique conservé — le refus s'applique. + monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun") + monkeypatch.setattr( + hub_roles, "explicite_pour", lambda *a, **k: None) + client_sso.cookies.set("draco_session", _jeton()) + r = client_sso.get("/auth/draco", follow_redirects=False) + assert r.status_code == 403 def test_bouton_sso_sur_la_page_login(client_sso): diff --git a/tests/test_entree_sso.py b/tests/test_entree_sso.py index a6108a6..5e8f2b3 100644 --- a/tests/test_entree_sso.py +++ b/tests/test_entree_sso.py @@ -147,6 +147,22 @@ def test_cookie_invalide_formulaire_comme_avant(client_ent): assert r.headers["location"].startswith("/login?next=") +def test_cookie_invalide_signale_au_formulaire(client_ent): + # 0.46.11 : la destination reste le formulaire (contrat du + # test précédent inchangé), mais l'échec du parcours central + # est NOMMÉ — draco=invalide, traduit en message par la page + # de connexion. Avant : retour muet, indistinguable d'une + # absence de session centrale. + client_ent.cookies.set( + "draco_session", _jeton(SUB_LIE, secret="mauvais")) + r = client_ent.get("/", follow_redirects=False) + assert r.status_code == 303 + assert "draco=invalide" in r.headers["location"] + r2 = client_ent.get(r.headers["location"], follow_redirects=False) + assert r2.status_code == 200 + assert "n'a pas pu être validé" in r2.text.replace("'", "'") + + def test_page_login_jamais_interceptee(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_LIE)) r = client_ent.get("/login", follow_redirects=False) diff --git a/tests/test_hub_roles.py b/tests/test_hub_roles.py index 0db4a53..89618e0 100644 --- a/tests/test_hub_roles.py +++ b/tests/test_hub_roles.py @@ -186,6 +186,40 @@ def test_client_reponses_illisibles_inconnues(monkeypatch): assert hub_roles.role_pour("c=1", "sub-f") is None +# ── Drapeau « explicite » (0.46.11) ──────────────────────────── + +def test_explicite_transporte_depuis_la_reponse(monkeypatch): + # Le drapeau voyage avec le rôle, servi par le même cache : + # une seule consultation pour les deux lectures. + appels = [] + + def faux_get(url, headers=None, timeout=None): + appels.append(url) + return _Reponse(200, { + "app": "kanbante", "sub": "sub-g", "role": "aucun", + "explicite": False, "ttl_secondes": 60, + }) + + monkeypatch.setattr(httpx, "get", faux_get) + cookie = f"draco_session={_jeton('sub-g')}" + assert hub_roles.role_pour(cookie, "sub-g") == "aucun" + assert hub_roles.explicite_pour(cookie, "sub-g") is False + assert len(appels) == 1 + + +def test_explicite_absent_de_la_reponse_vaut_inconnu(monkeypatch): + # Un registre qui ne dit pas le drapeau : rôle lu, + # explicite inconnu (None) — le pont conserve alors son + # comportement historique pour un « aucun ». + def faux_get(url, headers=None, timeout=None): + return _Reponse(200, {"role": "utilisateur"}) + + monkeypatch.setattr(httpx, "get", faux_get) + cookie = f"draco_session={_jeton('sub-h')}" + assert hub_roles.role_pour(cookie, "sub-h") == "utilisateur" + assert hub_roles.explicite_pour(cookie, "sub-h") is None + + # ── Intégration : pont draco et garde /admin ───────────────── def _nettoyer():