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).
204 lines
8.1 KiB
Python
204 lines
8.1 KiB
Python
"""Entrée SSO automatique sans session locale (0.46.8).
|
|
|
|
Chantier « entrée SSO de bout en bout » — écart constaté par
|
|
Bruno en test réel le 2026-11-08 : arrivé chez Kanbante avec une
|
|
session centrale valide (cookie ``draco_session``) mais aucune
|
|
session locale, l'application servait son formulaire de connexion
|
|
comme si le cookie n'existait pas. Attendu : à l'arrivée sur une
|
|
page, passage automatique par le pont ``/auth/draco`` et service
|
|
de l'application connectée au compte désigné par le cookie.
|
|
|
|
Couvert : redirection du middleware vers le pont (compte lié et
|
|
création JIT), chaîne complète jusqu'à la session ouverte, API
|
|
jamais redirigées, absence de cookie et cookie invalide
|
|
inchangés, rôle « aucun » (le pont tranche : 403, pas de boucle),
|
|
échec de résolution signalé au formulaire (``draco=echec``, pas
|
|
d'échec silencieux), et identité de SESSION dans la barre
|
|
commune (le nom du compte connecté, pas l'opérateur).
|
|
|
|
Montage repris de tests/test_coherence_identite.py.
|
|
"""
|
|
|
|
import base64
|
|
import hashlib
|
|
import hmac
|
|
import json
|
|
import time
|
|
|
|
import pytest
|
|
from fastapi.testclient import TestClient
|
|
|
|
import app.main as main
|
|
from app import accounts, draco, hub_roles, models
|
|
|
|
SECRET = "entree-test"
|
|
|
|
SUB_LIE = "ent-sub-lie"
|
|
SUB_INCONNU = "ent-sub-inconnu"
|
|
SUB_INACTIF = "ent-sub-inactif"
|
|
NOMS = ("ent-lie", "ent-inactif", "ent-inconnu-test")
|
|
|
|
|
|
def _jeton(sub, 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": "Testeur Test", "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 _nettoyer():
|
|
with models.get_db() as conn:
|
|
ids = [r[0] for r in conn.execute(
|
|
"SELECT id FROM users WHERE username IN ({})".format(
|
|
",".join("?" * len(NOMS))), NOMS).fetchall()]
|
|
ids += [r[0] for r in conn.execute(
|
|
"SELECT id FROM users WHERE draco_sub IN (?, ?, ?)",
|
|
(SUB_LIE, SUB_INCONNU, SUB_INACTIF)).fetchall()]
|
|
for uid in ids:
|
|
conn.execute("DELETE FROM users WHERE id = ?", (uid,))
|
|
|
|
|
|
@pytest.fixture()
|
|
def client_ent(monkeypatch, fake_gitea):
|
|
monkeypatch.setenv("KANBANTE_AUTH_USER", "operateur")
|
|
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse")
|
|
monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET)
|
|
monkeypatch.setattr(draco, "_refresh_revocations", lambda: None)
|
|
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: None)
|
|
draco._revoked_cache.clear()
|
|
_nettoyer()
|
|
models.create_user(
|
|
"ent-lie", accounts.hash_password("local-lie"),
|
|
role="member", draco_sub=SUB_LIE)
|
|
with models.get_db() as conn:
|
|
conn.execute(
|
|
"UPDATE users SET display_name = 'Testeur Test' "
|
|
"WHERE username = 'ent-lie'")
|
|
inactif_id = models.create_user(
|
|
"ent-inactif", accounts.hash_password("local-inactif"),
|
|
role="member", draco_sub=SUB_INACTIF)
|
|
models.update_user(inactif_id, active=False)
|
|
with TestClient(main.app) as client:
|
|
# Le TestClient doit parler comme un navigateur : sans
|
|
# Accept text/html, le middleware classe la requête en
|
|
# cliente d'API (401) — c'est l'en-tête, pas le correctif,
|
|
# qui décide de la famille de la requête.
|
|
client.headers["Accept"] = (
|
|
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
|
|
yield client
|
|
_nettoyer()
|
|
draco._revoked_cache.clear()
|
|
|
|
|
|
# ── Entrée automatique par le pont ───────────────────────────────
|
|
|
|
def test_page_sans_session_cookie_valide_renvoyee_au_pont(client_ent):
|
|
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
|
r = client_ent.get("/", follow_redirects=False)
|
|
assert r.status_code == 303
|
|
assert r.headers["location"].startswith("/auth/draco")
|
|
|
|
|
|
def test_chaine_complete_session_ouverte_pour_le_compte_du_cookie(client_ent):
|
|
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
|
r = client_ent.get("/", follow_redirects=False)
|
|
pont = r.headers["location"]
|
|
r2 = client_ent.get(pont, follow_redirects=False)
|
|
assert r2.status_code == 303
|
|
assert "kanbante_session" in r2.headers.get("set-cookie", "")
|
|
r3 = client_ent.get("/", follow_redirects=False)
|
|
assert r3.status_code == 200
|
|
|
|
|
|
def test_page_sans_session_sub_inconnu_jit_par_le_pont(client_ent):
|
|
client_ent.cookies.set("draco_session", _jeton(SUB_INCONNU))
|
|
r = client_ent.get("/", follow_redirects=False)
|
|
assert r.headers["location"].startswith("/auth/draco")
|
|
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
|
assert r2.status_code == 303
|
|
assert models.get_user_by_draco(SUB_INCONNU) is not None
|
|
|
|
|
|
def test_api_sans_session_cookie_valide_reste_401(client_ent):
|
|
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
|
r = client_ent.get("/api/projects", follow_redirects=False)
|
|
assert r.status_code == 401
|
|
|
|
|
|
# ── Régressions : sans session centrale, rien ne change ─────────
|
|
|
|
def test_sans_cookie_formulaire_comme_avant(client_ent):
|
|
r = client_ent.get("/", follow_redirects=False)
|
|
assert r.status_code == 303
|
|
assert r.headers["location"].startswith("/login?next=")
|
|
|
|
|
|
def test_cookie_invalide_formulaire_comme_avant(client_ent):
|
|
client_ent.cookies.set("draco_session", _jeton(SUB_LIE, secret="mauvais"))
|
|
r = client_ent.get("/", follow_redirects=False)
|
|
assert r.status_code == 303
|
|
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)
|
|
assert r.status_code == 200
|
|
|
|
|
|
# ── Gardes du pont : refus explicite, échec signalé ─────────────
|
|
|
|
def test_role_aucun_le_pont_tranche_403_sans_boucle(client_ent, monkeypatch):
|
|
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun")
|
|
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
|
r = client_ent.get("/", follow_redirects=False)
|
|
assert r.headers["location"].startswith("/auth/draco")
|
|
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
|
assert r2.status_code == 403
|
|
|
|
|
|
def test_echec_de_resolution_signale_au_formulaire(client_ent):
|
|
client_ent.cookies.set("draco_session", _jeton(SUB_INACTIF))
|
|
r = client_ent.get("/auth/draco", follow_redirects=False)
|
|
assert r.status_code == 303
|
|
assert "draco=echec" in r.headers["location"]
|
|
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
|
assert r2.status_code == 200
|
|
# L'apostrophe du message est échappée par Jinja (n') :
|
|
# on cherche le fragment invariant.
|
|
assert "pas abouti pour ce compte" in r2.text
|
|
|
|
|
|
# ── Barre commune : l'identité de session, pas l'opérateur ──────
|
|
|
|
def test_barre_affiche_le_nom_du_compte_de_session(client_ent):
|
|
client_ent.cookies.set(
|
|
"kanbante_session", main._make_session("ent-lie"))
|
|
r = client_ent.get("/", follow_redirects=False)
|
|
assert r.status_code == 200
|
|
assert 'user: "Testeur Test"' in r.text
|
|
assert 'user: "O"' not in r.text # initiale de l'opérateur
|