fix(sso): rattachement par homonymie, conflit explicite et re-liaison par double preuve au pont draco (0.46.10)
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:
+204
-1
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user