diff --git a/CHANGELOG.md b/CHANGELOG.md index 3718aea..c766b3b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,10 @@ +## v7.85.8 (2026-11-08) — Entrée SSO automatique sans session locale (chantier « entrée SSO de bout en bout », empilée sur la 7.85.7) + +Écart constaté par Bruno en test réel le 2026-11-08 (compte « testeur » créé au Hub) : arrivé chez Flowdeck avec une session centrale valide mais aucune session locale, l'application servait sa page publique déconnectée (« Log in », « Créer un compte dans le Hub ») comme si le cookie draco n'existait pas. Chaîne prouvée en navigateur réel dans une pile locale aux noms publics. + +- **Entrée automatique par le pont à la racine** (`app/routers/dashboard/workspace.py`) : sans session locale, si l'instance est peuplée et qu'un cookie `draco_session` **valide** (`app.services.draco.claims_valides`) est présenté, la racine `/` renvoie au pont `/auth/draco?next=/workspaces` (JIT si besoin) au lieu de servir la page publique. **Gardes** : instance vierge (aucun compte) → page publique d'installation inchangée ; cookie absent ou invalide → page publique inchangée ; le pont tranche ensuite (rôle « aucun » → sa page 403 ; échec de résolution → retour au formulaire local `/auth/login?provider=local` — le chemin prévu, celui de tous les liens d'entrée internes — qui n'est jamais intercepté : pas de boucle). Symétrique du contrôle de cohérence de la 7.85.7 (middleware), qui couvre le cas inverse (session locale d'un AUTRE compte). +- **Tests** : nouveau `tests/test_entree_sso.py` (5) — racine renvoyée au pont, chaîne complète jusqu'à la session ouverte, page publique inchangée sans cookie et avec cookie invalide, formulaire local jamais intercepté. Suites entrée + cohérence : 12/12. + ## v7.85.7 (2026-11-07) — Cohérence d'identité au changement de compte Cas réel (capture) : connecté « fred » chez ObsiGate, l'utilisateur ouvre Flowdeck et y trouve son propre compte (BC) — la session locale préexistante gouvernait sans reconsulter l'identité centrale, le pont `/auth/draco` ne s'exécutant qu'à l'entrée SSO sans session locale. diff --git a/VERSION b/VERSION index 0146993..7152639 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -7.85.7 +7.85.8 \ No newline at end of file diff --git a/app/routers/dashboard/workspace.py b/app/routers/dashboard/workspace.py index 012d80f..8bab807 100644 --- a/app/routers/dashboard/workspace.py +++ b/app/routers/dashboard/workspace.py @@ -55,16 +55,38 @@ async def dashboard( # ── Not authenticated → show landing page ── if not user: # Allow through if DB is empty (fresh install) + _peuplee = False try: with get_conn() as conn: - count = conn.execute("SELECT COUNT(*) FROM users").fetchone()[0] - if count == 0: - from app.templating import ENV - env = ENV - template = env.get_template("landing.html") - return template.render(**_contexte_accueil()) + _peuplee = conn.execute( + "SELECT COUNT(*) FROM users").fetchone()[0] > 0 except Exception: logger.exception("dashboard") + if _peuplee: + # Entrée automatique par le pont (7.85.8, chantier + # « entrée SSO de bout en bout ») : un cookie draco + # VALIDE présenté sans session locale ne doit pas + # aboutir à la page publique comme si la session de + # la suite n'existait pas — le navigateur est renvoyé + # au pont /auth/draco (JIT si besoin), qui revient à + # /workspaces. Gardes : instance vierge (aucun compte) + # → page publique d'installation, inchangée ; cookie + # absent ou invalide → page publique, inchangée ; le + # pont tranche ensuite (rôle « aucun » → sa page 403 ; + # échec de résolution → retour au formulaire local + # /auth/login?provider=local, le chemin prévu, qui + # n'est jamais intercepté : pas de boucle). Symétrique + # du contrôle de cohérence de la 7.85.7 (middleware), + # qui couvre le cas inverse (session locale d'un + # AUTRE compte). + try: + from app.services import draco as _draco_entree + + if _draco_entree.claims_valides(request) is not None: + return RedirectResponse( + url="/auth/draco?next=/workspaces", status_code=302) + except Exception: + logger.exception("dashboard — entrée automatique par le pont") from app.templating import ENV env = ENV template = env.get_template("landing.html") diff --git a/tests/test_entree_sso.py b/tests/test_entree_sso.py new file mode 100644 index 0000000..466e420 --- /dev/null +++ b/tests/test_entree_sso.py @@ -0,0 +1,118 @@ +"""Entrée SSO automatique sans session locale (7.85.8). + +Chantier « entrée SSO de bout en bout » — écart constaté par +Bruno en test réel le 2026-11-08 : arrivé chez Flowdeck avec une +session centrale valide (cookie ``draco_session``) mais aucune +session locale, l'application servait sa page publique +déconnectée (« Log in », « Notion-style ») comme +si le cookie n'existait pas. Attendu : à l'arrivée sur la racine, +passage automatique par le pont ``/auth/draco`` et service de +l'application connectée au compte désigné par le cookie. + +Couvert : redirection de la racine vers le pont, chaîne complète +jusqu'à la session ouverte, page publique inchangée sans cookie +ou avec un cookie invalide, formulaire local jamais intercepté +(le chemin prévu ``?provider=local``), pont qui tranche en cas de +rôle « aucun » (403, pas de boucle). + +Montage repris de tests/test_coherence_identite.py. +""" + +import base64 +import hashlib +import hmac +import json +import time + +import pytest + +from app.db import get_conn +from app.password_utils import hash_password +from app.services import draco + +from tests.conftest import anon + +SECRET = "entree-secret" +SUB_TESTEUR = "ent-sub-testeur" +MDP = "mot-de-passe-ent" + + +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", "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)}" + + +@pytest.fixture(autouse=True) +def _env(monkeypatch): + monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET) + monkeypatch.setattr(draco, "_refresh_revocations", lambda: None) + draco._revoked_cache.clear() + yield + draco._revoked_cache.clear() + + +@pytest.fixture() +def compte_lie(client): + with get_conn() as conn: + cur = conn.execute( + "INSERT INTO users (login, email, password_hash, full_name, is_active) " + "VALUES (?, ?, ?, ?, 1)", + ("enttesteur", "enttesteur@ex.ca", hash_password(MDP), + "Testeur Test")) + uid = cur.lastrowid + conn.execute( + "INSERT INTO draco_links (sub, user_id) VALUES (?, ?)", + (SUB_TESTEUR, uid)) + conn.commit() + return uid + + +def test_racine_sans_session_cookie_valide_renvoyee_au_pont(client, compte_lie): + anon(client) + client.cookies.set("draco_session", _jeton(SUB_TESTEUR)) + r = client.get("/", follow_redirects=False) + assert r.status_code == 302 + assert r.headers["location"] == "/auth/draco?next=/workspaces" + + +def test_chaine_complete_session_ouverte(client, compte_lie): + anon(client) + client.cookies.set("draco_session", _jeton(SUB_TESTEUR)) + r = client.get("/auth/draco", follow_redirects=False) + assert r.status_code == 302 + assert r.headers["location"] == "/workspaces" + assert "flowdeck_session" in r.headers.get("set-cookie", "") + # La racine ne sert plus la page publique. + r2 = client.get("/", follow_redirects=False) + assert "Notion-style" not in r2.text + + +def test_racine_sans_cookie_page_publique_inchangee(client, compte_lie): + anon(client) + r = client.get("/", follow_redirects=False) + assert r.status_code == 200 + assert "Notion-style" in r.text + + +def test_racine_cookie_invalide_page_publique_inchangee(client, compte_lie): + anon(client) + client.cookies.set("draco_session", _jeton(SUB_TESTEUR, secret="mauvais")) + r = client.get("/", follow_redirects=False) + assert r.status_code == 200 + assert "Notion-style" in r.text + + +def test_formulaire_local_jamais_intercepte(client, compte_lie): + anon(client) + client.cookies.set("draco_session", _jeton(SUB_TESTEUR)) + r = client.get("/auth/login?provider=local", follow_redirects=False) + assert r.status_code == 200