"""Fusion ACC-3.2 — pont SSO draco_session (carte kanbante#27). Le cookie émis par ObsiGate (ACC-3.1) est vérifié localement (secret partagé, HS256) et converti en session Kanbante native par GET /auth/draco. Depuis la 0.46.0 (HUB-16), la correspondance est par utilisateur (users.draco_sub, création JIT) — voir tests/test_draco_correspondance.py. Les cas couverts ici restent valides : dans ce module, le seul compte préexistant est l'admin d'amorçage ; depuis la 0.46.5 (fusion #145), le premier jeton valide ne s'y lie PLUS automatiquement (adoption conditionnée au 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 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 import hashlib import hmac import json import time import pytest from fastapi.testclient import TestClient import app.main as main from app import draco, hub_roles SECRET = "secret-partage-de-test" def _jeton(sub="admin-1", secret=SECRET, exp=None, jti="jti-test"): 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": "Bruno", "iat": int(time.time()), "exp": exp if exp is not None else int(time.time()) + 3600, "jti": jti, }).encode()) sig = hmac.new(secret.encode(), f"{header}.{payload}".encode(), hashlib.sha256).digest() return f"{header}.{payload}.{b64(sig)}" @pytest.fixture() def client_sso(monkeypatch, fake_gitea): monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno") monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse") monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET) monkeypatch.setattr(draco, "_refresh_revocations", lambda: None) draco._revoked_cache.clear() with TestClient(main.app) as client: yield client draco._revoked_cache.clear() def test_verify_token(monkeypatch): monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET) assert draco.verify_token(_jeton())["sub"] == "admin-1" assert draco.verify_token(_jeton(secret="mauvais")) is None assert draco.verify_token(_jeton(exp=int(time.time()) - 5)) is None assert draco.verify_token("pas.un.jeton") is None 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"].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): 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", "") # La session native créée par le pont donne accès à l'app. assert client_sso.get("/").status_code == 200 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"].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"].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.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): # Défauts = noms officiels (DRACO_SSO_URL / KANBANTE_PUBLIC_URL). r = client_sso.get("/login") assert r.status_code == 200 assert "og.dracodev.net/sso/authorize" in r.text assert "kanbante.dracodev.net%2Fauth%2Fdraco" in r.text def test_bouton_sso_par_configuration(client_sso, monkeypatch): # Dev : l'émettrice et le return_to suivent l'environnement. monkeypatch.setenv("DRACO_SSO_URL", "https://og-dev.dracodev.net") monkeypatch.setenv( "KANBANTE_PUBLIC_URL", "https://kanbante-dev.dracodev.net" ) r = client_sso.get("/login") 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