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.
This commit is contained in:
Spark
2026-11-16 19:50:25 +00:00
parent eac6156d47
commit 365a724e6e
9 changed files with 768 additions and 48 deletions
+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
+204 -1
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:
@@ -723,6 +733,34 @@ async def login_page(request: Request, next: str = "/", draco: str = ""):
"pour ce compte. Utilisez le formulaire ci-dessous, ou "
"réessayez le bouton de connexion ObsiGate."
)
elif draco == "conflit":
# Conflit de nom (0.46.10) : le compte local homonyme de
# l'identité présentée est lié à un AUTRE sub — aucun
# rattachement silencieux, aucun clone. La sortie est la
# double preuve : connexion locale par mot de passe,
# puis proposition de re-liaison (voir draco_relier).
erreur = (
"Un compte Kanbante porte le même nom que votre "
"compte de la suite, mais il est relié à une autre "
"identité : la connexion automatique est refusée "
"pour protéger ce compte. Connectez-vous ci-dessous "
"avec le mot de passe local de ce compte — la "
"re-liaison à votre identité actuelle vous sera "
"proposée."
)
elif draco == "invalide":
# Jeton présent mais illisible pour CE service
# (0.46.10) : signature, expiration ou révocation — à
# distinguer d'une absence de session centrale, qui
# arrive ici sans paramètre et sans message.
erreur = (
"Le jeton de la suite présenté à Kanbante n'a pas "
"pu être validé (expiré, révoqué ou illisible pour "
"ce service). Reconnectez-vous chez ObsiGate, puis "
"réessayez. Si ce message persiste, l'administrateur "
"doit vérifier la configuration du service (secret "
"partagé de la suite)."
)
return render(
request, "login.html", next=_safe_next(next), error=erreur,
porte_centrale=bool(get_settings().porte_centrale),
@@ -827,6 +865,20 @@ async def login_submit(
sub = claims.get("sub")
if sub and models.get_user_by_draco(sub) is None:
models.update_user(user["id"], draco_sub=sub)
# Double preuve (0.46.10) : le mot de passe local vient
# d'être prouvé, et un cookie draco valide est présent
# dont l'identité ne désigne pas ce compte (ce compte
# est lié à un autre sub, ou ce sub est détenu par un
# autre compte) — au lieu de laisser les deux identités
# se contredire en silence, la session s'ouvre sur la
# proposition de re-liaison (voir draco_relier).
if _draco_desalignement(request, models.get_user(user["id"])) \
is not None:
return _ouvrir_session(
username,
"/auth/draco/relier?next="
+ quote(_safe_next(next), safe=""),
)
return _ouvrir_session(username, next)
@@ -920,6 +972,104 @@ async def logout():
return response
def _draco_desalignement(request: Request, current: dict | None):
"""Désalignement entre session native et identité draco.
Retourne ``(claims, détenteur)`` quand le navigateur porte
À LA FOIS une session native (compte ``current``, authentifié
par mot de passe) et un cookie draco **valide** dont le
``sub`` ne désigne pas ce compte : soit ce compte est lié à
un autre sub, soit ce sub est détenu par un autre compte
(``détenteur``, éventuellement None dans le premier cas).
Retourne None si les deux identités concordent, si le sub
est libre et ce compte sans lien (la liaison silencieuse
historique s'en charge), ou si l'une des deux preuves est
absente. C'est l'état que la re-liaison par double preuve
(``/auth/draco/relier``) propose de résoudre.
"""
if current is None or current.get("id") is None:
return None
from app import draco
claims = draco.claims_for(request)
if claims is None:
return None
sub = str(claims.get("sub") or "")
if not sub or current.get("draco_sub") == sub:
return None
detenteur = models.get_user_by_draco(sub)
if current.get("draco_sub") or detenteur is not None:
return claims, detenteur
return None
@app.get("/auth/draco/relier")
async def draco_relier_page(request: Request, next: str = "/"):
"""Proposition de re-liaison par double preuve (0.46.10).
Cas réel : le compte local « bruno » (mot de passe connu de
son propriétaire) est lié à un ancien sub, pendant que le
navigateur présente le sub actuel du même propriétaire —
le pont refuse le rattachement silencieux (le nom seul ne
prouve pas la propriété du compte local) et le JIT ne doit
pas créer un clone. La double preuve tranche : la session
native prouve le mot de passe local, le cookie draco valide
prouve l'identité centrale ; réunies dans le même navigateur,
elles autorisent la réécriture du lien, proposée ici de
façon explicite — jamais appliquée sans ce geste.
"""
current = _current_user(request)
if current is None or current.get("id") is None:
return RedirectResponse("/login", status_code=303)
desalign = _draco_desalignement(request, current)
if desalign is None:
return RedirectResponse(_safe_next(next), status_code=303)
claims, detenteur = desalign
return render(
request, "draco_relier.html", next=_safe_next(next),
compte_local=current["username"],
nom_draco=str(claims.get("name") or ""),
detenteur=(detenteur or {}).get("username"),
)
@app.post("/auth/draco/relier")
async def draco_relier_submit(
request: Request,
next: str = Form("/"),
csrf_token: str = Form(""),
):
"""Re-liaison effective : réécrit users.draco_sub.
Les deux preuves sont revérifiées à l'instant du geste
(session native + cookie draco valide + CSRF) : le sub est
retiré à son détenteur actuel, s'il y en a un, et posé sur
le compte de la session. Les deux gestes sont journalisés
(draco.relink.retrait / draco.relink). Le compte délié
garde son mot de passe local : il reste accessible par le
formulaire, simplement plus désigné par la suite.
"""
current = _current_user(request)
if current is None or current.get("id") is None:
return RedirectResponse("/login", status_code=303)
if not _csrf_valid(request, csrf_token):
return render(
request, "error.html", status_code=403,
message="Session expirée — réessaie.",
)
desalign = _draco_desalignement(request, current)
if desalign is None:
return RedirectResponse(_safe_next(next), status_code=303)
claims, detenteur = desalign
sub = str(claims.get("sub") or "")
if detenteur is not None and detenteur["id"] != current["id"]:
models.update_user(detenteur["id"], draco_sub=None)
models.log_admin(detenteur["id"], "draco.relink.retrait", sub)
models.update_user(current["id"], draco_sub=sub)
models.log_admin(current["id"], "draco.relink", sub)
return RedirectResponse(_safe_next(next), status_code=303)
@app.get("/auth/draco")
def draco_bridge(request: Request, next: str = "/"):
"""Fusion ACC-3.2 — pont SSO : cookie ``draco_session`` → session.
@@ -932,7 +1082,18 @@ def draco_bridge(request: Request, next: str = "/"):
- session native déjà ouverte : le ``sub`` libre est lié à
ce compte (première visite doublement connectée, inchangé) —
c'est la voie (b) de la liaison explicite de l'amorçage ;
si les deux identités se contredisent (ce compte lié à un
autre sub, ou ce sub détenu par un autre compte), la
re-liaison par double preuve est proposée
(``/auth/draco/relier``, 0.46.10) ;
- ``sub`` lié à un compte : sa session est ouverte ;
- ``sub`` inconnu mais compte local HOMONYME sans lien :
rattachement et session de CE compte (0.46.10, voir
app.accounts) ; homonyme lié à un autre sub : refus
explicite ``/login?draco=conflit``, aucun clone créé ;
- jeton présent mais illisible pour ce service : refus
explicite ``/login?draco=invalide`` (0.46.10) — le
formulaire nu ne subsiste que pour un jeton absent ;
- compte d'amorçage (unique compte, admin, sans liaison) :
adoption CONDITIONNÉE (fusion #145, 0.46.5) — seulement si
le registre du Hub donne « administrateur » pour kanbante
@@ -964,7 +1125,25 @@ def draco_bridge(request: Request, next: str = "/"):
settings = get_settings()
claims = draco.claims_for(request)
if not settings.auth_enabled or claims is None:
if not settings.auth_enabled:
return RedirectResponse("/login", status_code=303)
if claims is None:
# Jeton ABSENT : visiteur sans session centrale — le
# formulaire nu historique, sans message (rien à
# signaler). Service draco INERTE (aucun secret
# configuré) : même formulaire nu, la fonction est
# éteinte. Jeton PRÉSENT mais illisible pour ce service
# (signature, expiration, révocation — 0.46.10) : échec
# explicite draco=invalide, jamais silencieux — c'est
# le symptôme « le bouton SSO me ramène au formulaire »
# du propriétaire légitime quand le secret partagé du
# conteneur diverge de l'émettrice.
if draco.enabled() and request.cookies.get(draco.COOKIE_NAME):
return RedirectResponse(
f"/login?next={quote(_safe_next(next), safe='')}"
"&draco=invalide",
status_code=303,
)
return RedirectResponse("/login", status_code=303)
sub = str(claims.get("sub") or "")
if not sub:
@@ -1004,6 +1183,19 @@ def draco_bridge(request: Request, next: str = "/"):
if models.get_user_by_draco(sub) is None:
models.update_user(current["id"], draco_sub=sub)
models.log_admin(current["id"], "draco.link", sub)
# Désalignement restant (0.46.10) : ce compte est lié à
# un autre sub, ou ce sub est détenu par un autre compte
# — la session native (mot de passe prouvé) + le cookie
# (identité prouvée) réunissent la double preuve : la
# re-liaison est proposée, jamais appliquée ici.
if _draco_desalignement(
request, models.get_user(current["id"])
) is not None:
return RedirectResponse(
"/auth/draco/relier?next="
+ quote(_safe_next(next), safe=""),
status_code=303,
)
return RedirectResponse(_safe_next(next), status_code=303)
# Correspondance, amorçage conditionné ou création JIT :
# ouvrir la session du compte que ce sub désigne — et
@@ -1027,6 +1219,17 @@ def draco_bridge(request: Request, next: str = "/"):
samesite="lax",
)
return response
# Conflit de nom (0.46.10) : l'homonyme local de cette
# identité est lié à un autre sub — la résolution a refusé
# tout rattachement et tout clone ; le formulaire explique
# et la sortie est la double preuve (connexion locale puis
# proposition de re-liaison).
if accounts_service.draco_conflit_nom(claims) is not None:
return RedirectResponse(
f"/login?next={quote(_safe_next(next), safe='')}"
"&draco=conflit",
status_code=303,
)
# Échec de résolution (0.46.8) : retour au formulaire AVEC la
# raison (paramètre draco=echec, traduit en message par
# login_page) — jamais un échec silencieux, et le formulaire
+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>