Merge pull request 'SSO : aucune sortie nue au pont, « aucun » seulement si décidé, pont inerte signalé (0.46.11)' (#96) from sso-bruno-signalisation into main
CI / test (push) Failing after 3m33s
CI / test (push) Failing after 3m33s
This commit was merged in pull request #96.
This commit is contained in:
@@ -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.
|
||||
|
||||
+52
-7
@@ -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
|
||||
|
||||
+112
-26
@@ -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=(
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 ─────────────────────────────
|
||||
|
||||
+89
-6
@@ -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):
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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():
|
||||
|
||||
Reference in New Issue
Block a user