Compare commits

..
Author SHA1 Message Date
Spark 7b0fee43d2 fix(sso): aucune sortie nue au pont, « aucun » seulement si décidé, pont inerte signalé (0.46.11)
CI / test (pull_request) Failing after 1s
CI / test (push) Failing after 3m40s
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).
2026-11-16 21:15:04 +00:00
Spark 365a724e6e fix(sso): rattachement par homonymie, conflit explicite et re-liaison par double preuve au pont draco (0.46.10)
CI / test (pull_request) Failing after 1s
CI / test (push) Failing after 3m13s
Cas réel Bruno (2026-11-16) : le bouton SSO ne connectait pas son
compte « bruno » — résolution par sub seul : clone JIT « bruno-2 »
servi à la place de son admin (compte sans lien ou lié à un ancien
sub), et formulaire nu sans message quand le jeton était illisible
pour le service.

- resolve_draco_user : étape 3, rattachement par homonymie (compte
  local homonyme sans lien rattaché au sub vérifié) ; homonyme lié
  à un autre sub = conflit (aucun rattachement, aucun clone).
- Pont : /login?draco=conflit et /login?draco=invalide explicites ;
  le formulaire nu ne subsiste que pour un jeton absent ou inerte.
- Re-liaison par double preuve : /auth/draco/relier (page + POST),
  exemption de cohérence limitée à ce chemin, réécriture journalisée.
- Tests : tests/test_draco_rattachement.py (9, cas réel) ; contrat
  homonyme de test_draco_correspondance.py inversé ; refus signalés
  dans test_draco_sso.py. Doc : docs/correspondance-draco.md.
2026-11-16 19:50:25 +00:00
12 changed files with 1098 additions and 67 deletions
+20
View File
@@ -1,3 +1,23 @@
## 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.
- **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.
+1 -1
View File
@@ -1 +1 @@
0.46.9
0.46.11
+97 -18
View File
@@ -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-<sub slugifié> ». 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
+52 -7
View File
@@ -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
+295 -6
View File
@@ -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:
@@ -587,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:
@@ -600,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
@@ -614,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)
@@ -715,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 = (
@@ -723,6 +749,60 @@ 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
# (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 "
"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)."
)
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),
@@ -827,6 +907,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 +1014,107 @@ 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:
# 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)
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?draco=echec", 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 +1127,28 @@ 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) ;
- 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
@@ -957,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
@@ -964,19 +1189,59 @@ def draco_bridge(request: Request, next: str = "/"):
settings = get_settings()
claims = draco.claims_for(request)
if not settings.auth_enabled or claims is None:
return RedirectResponse("/login", status_code=303)
if not settings.auth_enabled:
# 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:
# 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.
# — 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(
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=(
@@ -1004,6 +1269,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 +1305,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
+46
View File
@@ -0,0 +1,46 @@
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<script>try{var t=localStorage.getItem("kanbante-theme");document.documentElement.setAttribute("data-theme",t==="light"?"light":"dark");}catch(e){document.documentElement.setAttribute("data-theme","dark");}</script>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="csrf-token" content="{{ csrf_token }}">
<title>Relier le compte — Kanbante</title>
<link rel="stylesheet" href="/static/css/style.css">
</head>
<body class="login-body">
<main class="login-wrap">
<section class="login-card">
<div class="login-brand">
<span class="login-mark" aria-hidden="true"><svg viewBox="0 0 24 24" fill="#fff" aria-hidden="true" style="width:20px;height:20px;display:block"><rect x="3" y="4" width="5" height="16" rx="1"/><rect x="9.5" y="4" width="5" height="10" rx="1"/><rect x="16" y="4" width="5" height="13" rx="1"/></svg></span>
<h1>Kanbante</h1>
<p class="login-sub">Relier ce compte à votre identité de la suite</p>
</div>
{# Re-liaison par double preuve (0.46.10) : la session
native prouve le mot de passe local, le cookie draco
valide prouve l'identité centrale — la page n'est
rendue que lorsque les deux sont présentes et se
contredisent (voir app.main.draco_relier_page). #}
<p>Vous êtes connecté ici au compte local
«&nbsp;{{ compte_local }}&nbsp;» par son mot de passe,
et votre navigateur présente aussi l'identité de la
suite «&nbsp;{{ nom_draco }}&nbsp;» (ObsiGate). Ces
deux identités ne désignent pas le même compte
Kanbante{% if detenteur %} : l'identité de la suite
est actuellement reliée au compte
«&nbsp;{{ detenteur }}&nbsp;»{% endif %}.</p>
<p>Relier déplacera la liaison vers le compte
«&nbsp;{{ compte_local }}&nbsp;» : la connexion par
ObsiGate ouvrira désormais ce compte-ci. Le compte
délié garde son mot de passe local et reste
accessible par le formulaire de connexion.</p>
<form method="post" action="/auth/draco/relier" class="login-form">
<input type="hidden" name="csrf_token" value="{{ csrf_token }}">
<input type="hidden" name="next" value="{{ next }}">
<button type="submit" class="login-submit">Relier mon compte</button>
</form>
<a class="login-sso" href="{{ next }}">Plus tard — continuer sans relier</a>
</section>
</main>
</body>
</html>
+92 -18
View File
@@ -52,24 +52,90 @@ 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.
## Sorties d'échec du pont — toutes signalées (0.46.10, complété en 0.46.11)
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)
@@ -137,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
+22 -11
View File
@@ -11,8 +11,12 @@ users.draco_sub. Couvert ici :
cas historique est couvert ici avec ce rôle simulé ;
- JIT : deux identités distinctes → deux comptes distincts,
rôle membre, mot de passe local non divulgué/inutilisable ;
- le JIT n'adopte jamais un compte préexistant non lié, même
homonyme : il crée un compte nouveau, suffixé ;
- rattachement par homonymie (0.46.10, chantier SSO
« bruno ») : un compte préexistant non lié portant le nom de
l'identité présentée est rattaché et servi — le JIT ne crée
plus de clone suffixé dans ce cas (matrice complète :
tests/test_draco_rattachement.py) ; un compte d'un nom
DIFFÉRENT n'est toujours jamais absorbé ;
- liaison / déliaison par l'administrateur depuis /admin,
conflit de sub refusé ;
- compte désactivé : correspondance refusée, aucun contournement ;
@@ -200,7 +204,16 @@ def test_jit_deux_identites_deux_comptes_distincts(client_hub16):
models.update_user(admin["id"], draco_sub=None)
def test_jit_n_adopte_pas_un_compte_homonyme_non_lie(client_hub16):
def test_homonyme_non_lie_rattache_depuis_04610(client_hub16):
# Contrat inversé en 0.46.10 (chantier SSO « bruno ») :
# avant, ce cas créait un clone JIT suffixé et le compte
# préexistant n'était ni lié ni servi — le propriétaire
# légitime n'atteignait jamais son compte. Désormais, le
# compte homonyme SANS lien est rattaché au sub vérifié
# (les noms centraux font foi : comptes créés par
# l'administrateur au Hub, aucune inscription publique).
# La matrice complète (conflit, double preuve, gardes) vit
# dans tests/test_draco_rattachement.py.
admin, pur = _unique_admin_sans_liaison()
if pur:
models.update_user(admin["id"], draco_sub="hub16-temoin-amorce")
@@ -209,16 +222,14 @@ def test_jit_n_adopte_pas_un_compte_homonyme_non_lie(client_hub16):
"carole-exemple", accounts.hash_password("local-carole"),
role="member", display_name="Carole Exemple",
)
avant = models.count_users()
r = _pont(client_hub16, "hub16-carole", "Carole Exemple")
assert r.status_code == 303 and r.headers["location"] == "/"
# Le compte préexistant n'a PAS été lié ni utilisé…
local = models.get_user(local_id)
assert local["draco_sub"] is None
# …un compte nouveau, suffixé, porte la correspondance.
cree = models.get_user_by_draco("hub16-carole")
assert cree is not None and cree["id"] != local_id
assert cree["username"] == "carole-exemple-2"
assert _profil_username(client_hub16) == "carole-exemple-2"
# Le compte préexistant est lié et servi ; aucun clone.
assert models.count_users() == avant
lie = models.get_user_by_draco("hub16-carole")
assert lie is not None and lie["id"] == local_id
assert _profil_username(client_hub16) == "carole-exemple"
finally:
if pur:
models.update_user(admin["id"], draco_sub=None)
+326
View File
@@ -0,0 +1,326 @@
"""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é 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
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):
# 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"].startswith("/login?")
assert "draco=absent" in r.headers["location"]
# ── 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"]
+97 -6
View File
@@ -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):
@@ -82,26 +95,104 @@ 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).
# 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"] == "/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):
# 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("&#39;", "'")
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):
+16
View File
@@ -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("&#39;", "'")
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)
+34
View File
@@ -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():