From 530e24b529fbb9df33c31ae505401e74d8f87d4d Mon Sep 17 00:00:00 2001 From: Spark Date: Sun, 8 Nov 2026 19:57:00 +0000 Subject: [PATCH] =?UTF-8?q?Kanbante=200.46.9=20=E2=80=94=20retour=20SSO=20?= =?UTF-8?q?:=20l'h=C3=B4te=20de=20la=20requ=C3=AAte=20fait=20foi=20pour=20?= =?UTF-8?q?le=20retour=20navigateur?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit render() construit sso_authorize_url avec app.config.base_retour_navigateur : l'hôte public de la requête (motif fermé dracodev) prime sur toute la configuration — KANBANTE_PUBLIC_URL/AGENT_URL explicites sur les noms officiels faisaient atterrir le retour sur kanbante.dracodev.net alors que l'app est servie en -dev (constat Bruno du 2026-11-08). Hors motif : la chaîne de configuration s'applique, inchangée. --- CHANGELOG.md | 8 ++++++ VERSION | 2 +- app/config.py | 25 +++++++++++++++++ app/main.py | 13 +++++++-- tests/test_draco_barre.py | 24 ++++++++++++++++ tests/test_draco_sso.py | 59 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 128 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index aceb1f4..024a927 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,11 @@ +## 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://` 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 : diff --git a/VERSION b/VERSION index 25e3aa5..2c2e21d 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.46.8 \ No newline at end of file +0.46.9 \ No newline at end of file diff --git a/app/config.py b/app/config.py index 8d8fd1f..33ac840 100644 --- a/app/config.py +++ b/app/config.py @@ -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: diff --git a/app/main.py b/app/main.py index 2dda886..ec49713 100644 --- a/app/main.py +++ b/app/main.py @@ -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 @@ -2737,10 +2738,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: diff --git a/tests/test_draco_barre.py b/tests/test_draco_barre.py index c7758d9..8b3d50d 100644 --- a/tests/test_draco_barre.py +++ b/tests/test_draco_barre.py @@ -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 diff --git a/tests/test_draco_sso.py b/tests/test_draco_sso.py index 8b4c643..8b3d556 100644 --- a/tests/test_draco_sso.py +++ b/tests/test_draco_sso.py @@ -122,3 +122,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 -- 2.54.0