Ronde 2 du cas « bruno » : la 0.46.10 déployée, le bouton SSO ramenait toujours au formulaire nu. Reproduction en pile de chaque état candidat : la seule variante au symptôme identique est DRACO_SESSION_SECRET absent du conteneur — draco inerte, claims toujours None, sortie « jeton absent » vers /login nu, bouton SSO rendu quand même. - Pont : jeton absent → draco=absent ; cookie présent + service inerte → draco=inactif ; sub vide → draco=invalide. Le middleware signale de même une page demandée avec un cookie présent mais inutilisable. Relier sans session → draco=echec. - Registre des rôles : hub_roles transporte le drapeau « explicite » (explicite_pour, cache partagé) ; le pont ne refuse un « aucun » que s'il est explicite ou d'origine inconnue — un défaut du registre ne verrouille plus l'entrée. - Tests : contrats des sorties nues mis à jour (le cas réel du conteneur sans secret est test_pont_inerte_sans_secret), rôle aucun dans ses trois états, drapeau transporté. Suite complète : échecs identiques à l'arbre vierge (23).
327 lines
13 KiB
Python
327 lines
13 KiB
Python
"""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"]
|