Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7b0fee43d2 | ||
|
|
365a724e6e | ||
|
|
eac6156d47 | ||
|
|
530e24b529 |
@@ -1,3 +1,31 @@
|
||||
## 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.
|
||||
|
||||
- **Nouveau `app.config.base_retour_navigateur(hote, repli)`** : pour un aller-retour SSO **initié par un navigateur**, la base de retour est `https://<hôte public de la requête>` quand cet hôte suit le motif fermé dracodev — elle prime sur toute la configuration. Hors motif (LAN, IP, domaine propre) : le repli (la chaîne habituelle) s'applique, inchangé. Les contextes sans requête et les appels serveur-à-serveur gardent la résolution par configuration.
|
||||
- **`render()`** construit `sso_authorize_url` avec ce helper (repli = l'URL publique résolue comme avant) ; l'émettrice et les autres URL du contexte (barre, panneau, CSP) restent résolues par la chaîne habituelle.
|
||||
- **Tests** : `tests/test_draco_barre.py` (le helper : hôte -dev prime sur un repli officiel, hôte officiel inchangé, hors motif = repli) et `tests/test_draco_sso.py` (le bouton servi : configuration « conteneur dev réel » — AGENT_URL et KANBANTE_PUBLIC_URL explicites sur les noms officiels, émettrice en -dev → `return_to` en **-dev** ; régressions prod et LAN).
|
||||
|
||||
## 0.46.8 — 2026-11-08 — Entrée SSO automatique sans session locale (chantier « entrée SSO de bout en bout », empilée sur la 0.46.7)
|
||||
|
||||
Écarts constatés par Bruno en test réel le 2026-11-08 (compte « testeur » créé au Hub), chaînes prouvées en navigateur réel dans une pile locale aux noms publics :
|
||||
|
||||
+97
-18
@@ -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
|
||||
|
||||
@@ -335,6 +335,31 @@ class UrlsDraco:
|
||||
agent_url: str # base du service d'agents (panneau + CSP)
|
||||
|
||||
|
||||
def base_retour_navigateur(hote_requete: str | None, repli: str) -> str:
|
||||
"""Base de retour d'un aller-retour SSO **initié par un navigateur**.
|
||||
|
||||
L'hôte public de la requête fait foi quand il suit le motif fermé
|
||||
dracodev (``suffixe_environnement_requete``) : c'est l'origine
|
||||
que le navigateur utilise déjà, donc celle du retour — elle
|
||||
prime sur TOUTE la chaîne de configuration (variable explicite
|
||||
de l'app et dérivation par les adresses de l'agent comprises),
|
||||
qui peut décrire un autre environnement. Constat dev du
|
||||
2026-11-08 : avec les adresses publiques explicites sur les
|
||||
noms officiels, le retour SSO atterrissait sur le nom officiel
|
||||
(la prod n'est pas encore installée) alors que l'app est servie
|
||||
en « -dev ». Hors motif (LAN, IP, domaine propre) : ``repli`` —
|
||||
la chaîne de configuration habituelle, inchangée. Réservé aux
|
||||
retours navigateur ; les contextes sans requête et les appels
|
||||
serveur-à-serveur gardent la résolution par configuration.
|
||||
"""
|
||||
if suffixe_environnement_requete(hote_requete) is not None:
|
||||
hote = (hote_requete or "").strip().lower()
|
||||
if not hote.startswith("["):
|
||||
hote = hote.split(":", 1)[0]
|
||||
return f"https://{hote}"
|
||||
return repli
|
||||
|
||||
|
||||
def resoudre_urls_draco(
|
||||
hote_requete: str | None = None, base: "Settings | None" = None
|
||||
) -> UrlsDraco:
|
||||
|
||||
+52
-7
@@ -23,6 +23,16 @@ jamais d'URL dev figée.
|
||||
illisible → ``None`` (rôle **inconnu**), et l'appelant garde son
|
||||
comportement actuel. Le registre ne crée jamais un verrouillage
|
||||
nouveau.
|
||||
|
||||
Depuis la 0.46.11, la consultation transporte aussi le drapeau
|
||||
``explicite`` de la réponse : le niveau vient-il d'une ligne
|
||||
posée par l'administrateur (``True``), du défaut du registre
|
||||
(``False``), ou la réponse ne le dit-elle pas (``None``) ? Le
|
||||
pont s'en sert pour ne traiter un « aucun » comme un
|
||||
verrouillage que lorsqu'il est explicite ou d'origine inconnue :
|
||||
un « aucun » que le registre présente lui-même comme un défaut
|
||||
n'est pas une décision de l'administrateur et ne doit fermer
|
||||
aucune porte.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -47,7 +57,7 @@ CACHE_TTL = 60.0 # secondes
|
||||
ROLES_CONNUS = ("aucun", "utilisateur", "administrateur")
|
||||
|
||||
_verrou = threading.Lock()
|
||||
_cache: dict[str, str] = {}
|
||||
_cache: dict[str, tuple[str, bool | None]] = {}
|
||||
_cache_fetched_at: float = 0.0
|
||||
|
||||
|
||||
@@ -59,8 +69,16 @@ def _reset_cache() -> None:
|
||||
_cache_fetched_at = 0.0
|
||||
|
||||
|
||||
def _consulter(hub_url: str, cookie: str) -> str | None:
|
||||
"""Un appel au registre ; rôle connu ou ``None`` (inconnu)."""
|
||||
def _consulter(
|
||||
hub_url: str, cookie: str
|
||||
) -> tuple[str, bool | None] | None:
|
||||
"""Un appel au registre ; ``(rôle, explicite)`` ou ``None``.
|
||||
|
||||
``explicite`` vaut ``True`` si le niveau vient d'une ligne
|
||||
posée par l'administrateur, ``False`` s'il vient du défaut
|
||||
du registre, ``None`` si la réponse ne le dit pas (le Hub
|
||||
actuel l'émet toujours).
|
||||
"""
|
||||
url = f"{hub_url.rstrip('/')}/api/roles/{APP}"
|
||||
try:
|
||||
reponse = httpx.get(
|
||||
@@ -84,15 +102,22 @@ def _consulter(hub_url: str, cookie: str) -> str | None:
|
||||
if not isinstance(donnees, dict):
|
||||
return None
|
||||
role = donnees.get("role")
|
||||
return role if role in ROLES_CONNUS else None
|
||||
if role not in ROLES_CONNUS:
|
||||
return None
|
||||
explicite = donnees.get("explicite")
|
||||
return role, explicite if isinstance(explicite, bool) else None
|
||||
|
||||
|
||||
def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None:
|
||||
"""Niveau connu pour ce ``sub`` : un rôle ou ``None`` (inconnu).
|
||||
def _detail_pour(
|
||||
cookie: str, sub: str, hote: str | None = None
|
||||
) -> tuple[str, bool | None] | None:
|
||||
"""``(rôle, explicite)`` connus pour ce ``sub``, ou ``None``.
|
||||
|
||||
``cookie`` est l'en-tête Cookie complet de la requête, relayé
|
||||
tel quel au Hub ; ``hote`` est l'hôte public de la requête,
|
||||
pour résoudre l'URL du Hub comme la barre commune.
|
||||
pour résoudre l'URL du Hub comme la barre commune. Cache
|
||||
partagé par ``role_pour`` et ``explicite_pour`` : une seule
|
||||
consultation par ``sub`` et par TTL.
|
||||
"""
|
||||
global _cache_fetched_at
|
||||
sub = str(sub or "")
|
||||
@@ -118,3 +143,23 @@ def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None:
|
||||
hub_url, APP,
|
||||
)
|
||||
return resultat
|
||||
|
||||
|
||||
def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None:
|
||||
"""Niveau connu pour ce ``sub`` : un rôle ou ``None`` (inconnu)."""
|
||||
detail = _detail_pour(cookie, sub, hote)
|
||||
return detail[0] if detail is not None else None
|
||||
|
||||
|
||||
def explicite_pour(
|
||||
cookie: str, sub: str, hote: str | None = None
|
||||
) -> bool | None:
|
||||
"""Le niveau de ce ``sub`` est-il une décision explicite ?
|
||||
|
||||
``True`` : ligne posée par l'administrateur dans la matrice
|
||||
du Hub. ``False`` : le registre applique son défaut, aucune
|
||||
décision n'existe pour ce compte. ``None`` : inconnu (Hub
|
||||
injoignable ou réponse sans le drapeau).
|
||||
"""
|
||||
detail = _detail_pour(cookie, sub, hote)
|
||||
return detail[1] if detail is not None else None
|
||||
|
||||
+306
-8
@@ -42,7 +42,8 @@ from fastapi.staticfiles import StaticFiles
|
||||
from jinja2 import Environment, FileSystemLoader, select_autoescape
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
|
||||
from app.config import APP_VERSION, get_settings, resoudre_urls_draco
|
||||
from app.config import (APP_VERSION, base_retour_navigateur, get_settings,
|
||||
resoudre_urls_draco)
|
||||
from app.gitea_client import GiteaClient
|
||||
from app import code_links as code_links_service
|
||||
from app import digest as digest_service
|
||||
@@ -457,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:
|
||||
@@ -586,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:
|
||||
@@ -599,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
|
||||
@@ -613,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)
|
||||
|
||||
|
||||
@@ -714,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 = (
|
||||
@@ -722,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),
|
||||
@@ -826,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)
|
||||
|
||||
|
||||
@@ -919,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.
|
||||
@@ -931,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
|
||||
@@ -956,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
|
||||
@@ -963,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=(
|
||||
@@ -1003,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
|
||||
@@ -1026,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
|
||||
@@ -2737,10 +3027,18 @@ def render(
|
||||
},
|
||||
)
|
||||
context.setdefault("agent_url", _urls.agent_url)
|
||||
# Aller-retour SSO initié par un navigateur : l'adresse de
|
||||
# retour est l'hôte public de la requête quand il suit le motif
|
||||
# fermé dracodev (base_retour_navigateur) — jamais une adresse
|
||||
# de configuration, qui peut décrire un autre environnement
|
||||
# (constat dev du 2026-11-08 : retour sur le nom officiel alors
|
||||
# que l'app est servie en « -dev »). L'émettrice et les autres
|
||||
# URL du contexte restent résolues par la chaîne habituelle.
|
||||
_hote_requete = request.headers.get("host")
|
||||
context.setdefault(
|
||||
"sso_authorize_url",
|
||||
f"{_urls.sso_url}/sso/authorize?return_to="
|
||||
f"{quote(_urls.public_url + '/auth/draco', safe='')}",
|
||||
f"{quote(base_retour_navigateur(_hote_requete, _urls.public_url) + '/auth/draco', safe='')}",
|
||||
)
|
||||
# 0.24.0 (P2/P3) : utilisateur courant, espaces, sélecteur.
|
||||
try:
|
||||
|
||||
@@ -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
|
||||
« {{ compte_local }} » par son mot de passe,
|
||||
et votre navigateur présente aussi l'identité de la
|
||||
suite « {{ nom_draco }} » (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
|
||||
« {{ detenteur }} »{% endif %}.</p>
|
||||
<p>Relier déplacera la liaison vers le compte
|
||||
« {{ compte_local }} » : 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>
|
||||
@@ -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
|
||||
|
||||
@@ -420,3 +420,27 @@ def test_resolution_sans_requete_inchangee(monkeypatch):
|
||||
assert urls.public_url == "https://kanbante.dracodev.net"
|
||||
assert urls.agent_url == "https://agent.dracodev.net"
|
||||
assert _env_settings().agent_url == "https://agent.dracodev.net"
|
||||
|
||||
|
||||
# ── Retour SSO navigateur : l'hôte de la requête fait foi ──────────
|
||||
# Correctif du constat dev du 2026-11-08 : le bouton SSO servi en
|
||||
# « -dev » portait return_to sur le nom officiel parce que la chaîne
|
||||
# de configuration (KANBANTE_PUBLIC_URL / AGENT_URL explicites sur
|
||||
# les noms officiels) primait. Pour un aller-retour initié par un
|
||||
# navigateur, l'hôte public de la requête (motif fermé dracodev)
|
||||
# prime sur toute la configuration.
|
||||
|
||||
def test_base_retour_navigateur():
|
||||
from app.config import base_retour_navigateur
|
||||
|
||||
assert base_retour_navigateur(
|
||||
"kanbante-dev.dracodev.net", "https://kanbante.dracodev.net") == \
|
||||
"https://kanbante-dev.dracodev.net"
|
||||
assert base_retour_navigateur(
|
||||
"kanbante.dracodev.net", "https://kanbante.dracodev.net") == \
|
||||
"https://kanbante.dracodev.net"
|
||||
for hote in ("192.168.30.101:8082", "atelier.example.net",
|
||||
"nimporte-dev.dracodev.net", "testserver", "", None):
|
||||
assert base_retour_navigateur(
|
||||
hote, "https://kanbante.dracodev.net") == \
|
||||
"https://kanbante.dracodev.net", hote
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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"]
|
||||
+156
-6
@@ -12,7 +12,13 @@ rôle « administrateur » du registre du Hub ou à une session
|
||||
native) — le pont ouvre alors la session d'un compte JIT propre
|
||||
à l'identité, ce que ces cas vérifient (session ouverte, accès
|
||||
à l'app) sans présumer du compte résolu.
|
||||
Sans DRACO_SESSION_SECRET, le pont renvoie simplement au login.
|
||||
Sans DRACO_SESSION_SECRET, le pont est inerte : depuis la
|
||||
0.46.11, un cookie présenté dans cet état est signalé
|
||||
(draco=inactif) au lieu du retour nu historique — c'était le
|
||||
cas réel du conteneur kanbante-dev de Bruno (ronde 2 du
|
||||
chantier SSO « bruno ») : cookie valide lu par les autres
|
||||
applications, bouton SSO rendu, et retour au formulaire sans
|
||||
session ni message.
|
||||
"""
|
||||
|
||||
import base64
|
||||
@@ -25,7 +31,7 @@ import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import app.main as main
|
||||
from app import draco
|
||||
from app import draco, hub_roles
|
||||
|
||||
SECRET = "secret-partage-de-test"
|
||||
|
||||
@@ -66,9 +72,16 @@ def test_verify_token(monkeypatch):
|
||||
|
||||
|
||||
def test_pont_sans_cookie_vers_login(client_sso):
|
||||
# Depuis la 0.46.11 : même destination (le formulaire),
|
||||
# mais l'échec du parcours est NOMMÉ (draco=absent) — le
|
||||
# pont ne produit plus aucune redirection nue.
|
||||
r = client_sso.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"] == "/login"
|
||||
assert r.headers["location"].startswith("/login?")
|
||||
assert "draco=absent" in r.headers["location"]
|
||||
r2 = client_sso.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 200
|
||||
assert "Aucune session de la suite" in r2.text
|
||||
|
||||
|
||||
def test_pont_cookie_valide_ouvre_la_session(client_sso):
|
||||
@@ -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("'", "'")
|
||||
|
||||
|
||||
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):
|
||||
@@ -122,3 +213,62 @@ def test_bouton_sso_par_configuration(client_sso, monkeypatch):
|
||||
assert r.status_code == 200
|
||||
assert "og-dev.dracodev.net/sso/authorize" in r.text
|
||||
assert "kanbante-dev.dracodev.net%2Fauth%2Fdraco" in r.text
|
||||
|
||||
|
||||
# ── Retour SSO navigateur : l'hôte de la requête fait foi ──────────
|
||||
# Correctif du constat dev du 2026-11-08 : le bouton servi en « -dev »
|
||||
# portait return_to sur le nom officiel parce que la configuration
|
||||
# explicite primait sur l'hôte de la requête dans la construction
|
||||
# du lien. Pour un aller-retour initié par un navigateur, l'hôte
|
||||
# public de la requête (motif fermé dracodev) prime désormais sur
|
||||
# toute la configuration (app.config.base_retour_navigateur).
|
||||
|
||||
def _env_retour_sso(monkeypatch):
|
||||
for nom in ("AGENT_EVENEMENTS_URL", "DRACO_AGENT_URL"):
|
||||
monkeypatch.delenv(nom, raising=False)
|
||||
|
||||
|
||||
def test_bouton_sso_dev_malgre_configuration_officielle(client_sso, monkeypatch):
|
||||
# Configuration « conteneur dev réel » : les adresses publiques
|
||||
# explicites portent les noms OFFICIELS, seule l'émettrice est
|
||||
# épinglée en -dev — avant le correctif, le bouton retombait
|
||||
# sur le nom officiel (le constat de Bruno).
|
||||
_env_retour_sso(monkeypatch)
|
||||
monkeypatch.setenv("AGENT_URL", "https://agent.dracodev.net")
|
||||
monkeypatch.setenv("KANBANTE_PUBLIC_URL",
|
||||
"https://kanbante.dracodev.net")
|
||||
monkeypatch.setenv("DRACO_SSO_URL", "https://og-dev.dracodev.net")
|
||||
r = client_sso.get("/login", headers={"Host": "kanbante-dev.dracodev.net"})
|
||||
assert r.status_code == 200
|
||||
assert ("https://og-dev.dracodev.net/sso/authorize"
|
||||
"?return_to=https%3A%2F%2Fkanbante-dev.dracodev.net"
|
||||
"%2Fauth%2Fdraco") in r.text
|
||||
assert ("return_to=https%3A%2F%2Fkanbante.dracodev.net"
|
||||
"%2Fauth%2Fdraco") not in r.text
|
||||
|
||||
|
||||
def test_bouton_sso_prod_reste_officiel(client_sso, monkeypatch):
|
||||
# Régression prod : servi sur le nom officiel, le retour reste
|
||||
# le nom officiel.
|
||||
_env_retour_sso(monkeypatch)
|
||||
monkeypatch.setenv("AGENT_URL", "https://agent.dracodev.net")
|
||||
monkeypatch.setenv("DRACO_SSO_URL", "https://og.dracodev.net")
|
||||
r = client_sso.get("/login", headers={"Host": "kanbante.dracodev.net"})
|
||||
assert r.status_code == 200
|
||||
assert ("https://og.dracodev.net/sso/authorize"
|
||||
"?return_to=https%3A%2F%2Fkanbante.dracodev.net"
|
||||
"%2Fauth%2Fdraco") in r.text
|
||||
|
||||
|
||||
def test_bouton_sso_hors_motif_chaine_inchangee(client_sso, monkeypatch):
|
||||
# Hôte hors motif (LAN) : la chaîne de configuration décide,
|
||||
# comme avant le correctif.
|
||||
_env_retour_sso(monkeypatch)
|
||||
monkeypatch.setenv("KANBANTE_PUBLIC_URL",
|
||||
"https://kanbante.dracodev.net")
|
||||
monkeypatch.setenv("DRACO_SSO_URL", "https://og.dracodev.net")
|
||||
r = client_sso.get("/login", headers={"Host": "192.168.30.101:8081"})
|
||||
assert r.status_code == 200
|
||||
assert ("https://og.dracodev.net/sso/authorize"
|
||||
"?return_to=https%3A%2F%2Fkanbante.dracodev.net"
|
||||
"%2Fauth%2Fdraco") in r.text
|
||||
|
||||
@@ -147,6 +147,22 @@ def test_cookie_invalide_formulaire_comme_avant(client_ent):
|
||||
assert r.headers["location"].startswith("/login?next=")
|
||||
|
||||
|
||||
def test_cookie_invalide_signale_au_formulaire(client_ent):
|
||||
# 0.46.11 : la destination reste le formulaire (contrat du
|
||||
# test précédent inchangé), mais l'échec du parcours central
|
||||
# est NOMMÉ — draco=invalide, traduit en message par la page
|
||||
# de connexion. Avant : retour muet, indistinguable d'une
|
||||
# absence de session centrale.
|
||||
client_ent.cookies.set(
|
||||
"draco_session", _jeton(SUB_LIE, secret="mauvais"))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert "draco=invalide" in r.headers["location"]
|
||||
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 200
|
||||
assert "n'a pas pu être validé" in r2.text.replace("'", "'")
|
||||
|
||||
|
||||
def test_page_login_jamais_interceptee(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
||||
r = client_ent.get("/login", follow_redirects=False)
|
||||
|
||||
@@ -186,6 +186,40 @@ def test_client_reponses_illisibles_inconnues(monkeypatch):
|
||||
assert hub_roles.role_pour("c=1", "sub-f") is None
|
||||
|
||||
|
||||
# ── Drapeau « explicite » (0.46.11) ────────────────────────────
|
||||
|
||||
def test_explicite_transporte_depuis_la_reponse(monkeypatch):
|
||||
# Le drapeau voyage avec le rôle, servi par le même cache :
|
||||
# une seule consultation pour les deux lectures.
|
||||
appels = []
|
||||
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
appels.append(url)
|
||||
return _Reponse(200, {
|
||||
"app": "kanbante", "sub": "sub-g", "role": "aucun",
|
||||
"explicite": False, "ttl_secondes": 60,
|
||||
})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
cookie = f"draco_session={_jeton('sub-g')}"
|
||||
assert hub_roles.role_pour(cookie, "sub-g") == "aucun"
|
||||
assert hub_roles.explicite_pour(cookie, "sub-g") is False
|
||||
assert len(appels) == 1
|
||||
|
||||
|
||||
def test_explicite_absent_de_la_reponse_vaut_inconnu(monkeypatch):
|
||||
# Un registre qui ne dit pas le drapeau : rôle lu,
|
||||
# explicite inconnu (None) — le pont conserve alors son
|
||||
# comportement historique pour un « aucun ».
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
return _Reponse(200, {"role": "utilisateur"})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
cookie = f"draco_session={_jeton('sub-h')}"
|
||||
assert hub_roles.role_pour(cookie, "sub-h") == "utilisateur"
|
||||
assert hub_roles.explicite_pour(cookie, "sub-h") is None
|
||||
|
||||
|
||||
# ── Intégration : pont draco et garde /admin ─────────────────
|
||||
|
||||
def _nettoyer():
|
||||
|
||||
Reference in New Issue
Block a user