From ec4177087cef25599ad90487ee9e446e9ef6faf9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Fri, 6 Nov 2026 10:17:23 +0100 Subject: [PATCH] =?UTF-8?q?forum=20:=20session=20d'1=20h=20(jeton=20du=20H?= =?UTF-8?q?ub)=20et=20rafra=C3=AEchissement=20silencieux=20par=20le=20Hub?= =?UTF-8?q?=20(revue=20s=C3=A9cu=2006/11)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Le cookie garde 30 jours, mais la session en base n'en vaut plus qu'une heure ; au-delà, une page HTML repasse par /oauth/autoriser (sans clic si la session Gastinel vaut encore) et revient sur la page demandée. Un ban, un changement de mot de passe ou des jetons révoqués côté Hub coupent donc le forum en 1 h au plus. Page de retour limitée au site. Co-Authored-By: Claude Opus 5.5 --- forum/forum.py | 14 +++++++++---- forum/server.py | 35 +++++++++++++++++++++++++++---- forum/tests/test_forum.py | 44 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 84 insertions(+), 9 deletions(-) diff --git a/forum/forum.py b/forum/forum.py index 354c002..503422b 100644 --- a/forum/forum.py +++ b/forum/forum.py @@ -18,7 +18,11 @@ EPINGLES_MAX = 5 # sujet fixe compris FICHE_PHOTOS_MAX = 3 # photos épinglées sur la fiche publique d'une station PHOTOS_MAX, OCTETS_MAX = 10, 25 * 1024 * 1024 # par message, sauf propriétaires (et par demande d'adhésion) ADHESION_MAX = 4000 # longueur du message d'une demande d'adhésion -SESSION_JOURS, ETAT_MINUTES = 30, 10 +SESSION_JOURS, ETAT_MINUTES = 30, 10 # SESSION_JOURS : durée du cookie (« se souvenir »), pas de la session +# Session en base : 1 h au plus, comme le jeton du Hub. Au-delà, le forum repasse par le Hub (sans clic si la +# session Gastinel est toujours valable) : un ban, un changement de mot de passe ou des jetons révoqués côté Hub +# coupent donc le forum en 1 h au plus. +SESSION_MINUTES = 60 MODIF_JOURS = 7 # un message se modifie une fois, pendant une semaine @@ -61,13 +65,15 @@ class Forum: self._pousser_roles(hub_id) return u - def ouvrir_session(self, user, jours=SESSION_JOURS, portee=""): + def ouvrir_session(self, user, jours=None, portee=""): """Retourne l'identifiant aléatoire à mettre dans le cookie ; seul son haché est stocké. - `portee` (ex. « panneau ») sépare les sessions : un jeton du forum ne vaut rien dans le panneau, et inversement.""" + `portee` (ex. « panneau ») sépare les sessions : un jeton du forum ne vaut rien dans le panneau, et inversement. + Sans `jours` : SESSION_MINUTES (cf. plus haut).""" jeton = secrets.token_urlsafe(32) + duree = "+%d minutes" % SESSION_MINUTES if jours is None else "+%d days" % jours self.con.execute("DELETE FROM sessions WHERE expires_at < datetime('now')") self.con.execute("INSERT INTO sessions(id_hache, user_id, expires_at) VALUES (?, ?, datetime('now', ?))", - (self._hache(portee + ":" + jeton), user["id"], "+%d days" % jours)) + (self._hache(portee + ":" + jeton), user["id"], duree)) self.con.commit() return jeton diff --git a/forum/server.py b/forum/server.py index 8b0dbf9..0d4e8d0 100644 --- a/forum/server.py +++ b/forum/server.py @@ -28,7 +28,7 @@ import threading import time from http import cookies from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer -from urllib.parse import parse_qs, urlparse +from urllib.parse import parse_qs, quote, unquote, urlparse sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import connexion # noqa: E402 @@ -65,6 +65,7 @@ def date_fr(texte, heure=False): SESSION = "forum_session" ETAT = "forum_etat" +RETOUR = "forum_retour" # page à rouvrir après un rafraîchissement silencieux de la session JETON_OK = re.compile(r"^[A-Za-z0-9_-]{20,100}$") ID_OK = re.compile(r"^[A-Za-z0-9_.-]{1,40}$") PHOTO_OK = re.compile(r"^[0-9a-f]{64}\.(jpg|png|webp)$") @@ -693,14 +694,37 @@ class Handler(BaseHTTPRequestHandler): return champs, fichiers # --- connexion Gastinel ----------------------------------------------- - def connexion_depart(self, user): + def connexion_depart(self, user, extra=()): r = self.app.reglages if not r.configuree: return self.erreur(user, 503, "La connexion avec Gastinel n'est pas encore ouverte") verifier, challenge = connexion.pkce() etat = connexion.nouvel_etat() self.app.forum.noter_etat(etat, verifier) - self.rediriger(connexion.url_autorisation(r, etat, challenge), [self.ck(ETAT, etat, ETAT_MINUTES * 60)]) + self.rediriger(connexion.url_autorisation(r, etat, challenge), [self.ck(ETAT, etat, ETAT_MINUTES * 60), *extra]) + + def session_a_rafraichir(self, u): + """Cookie de session présent mais session échue (1 h, cf. forum.SESSION_MINUTES) sur une page HTML : + on repasse par le Hub, qui renvoie aussitôt si la session Gastinel vaut encore (sinon : connexion + demandée, ou refus si le compte est banni). Une seule tentative : le cookie est effacé au départ.""" + jeton = self.cookie(SESSION) + return (bool(jeton) and JETON_OK.match(jeton) is not None and self.app.reglages.configuree + and "text/html" in (self.headers.get("Accept") or "") + and not u.path.startswith(("/connexion", "/test-login", "/deconnexion", "/api/", "/photo/", "/polices/"))) + + def rafraichir_session(self, u): + chemin = u.path + ("?" + u.query if u.query else "") + if not chemin.startswith("/") or chemin.startswith("//") or "\\" in chemin or len(chemin) > 500: + chemin = "/" + return self.connexion_depart(None, [self.ck(SESSION, "", 0), self.ck(RETOUR, quote(chemin, safe="/"), ETAT_MINUTES * 60)]) + + def page_de_retour(self): + """Page gardée par rafraichir_session (même site seulement), sinon l'accueil.""" + chemin = unquote(self.cookie(RETOUR) or "") + if (not chemin.startswith("/") or chemin.startswith("//") or "\\" in chemin or len(chemin) > 500 + or any(ord(c) < 32 for c in chemin)): + return "/" + return chemin def connexion_retour(self, q): f, r = self.app.forum, self.app.reglages @@ -726,7 +750,8 @@ class Handler(BaseHTTPRequestHandler): ancien = self.cookie(SESSION) if ancien: f.fermer_session(ancien) - self.rediriger("/", [efface, self.ck(SESSION, f.ouvrir_session(user), SESSION_JOURS * 86400)]) + self.rediriger(self.page_de_retour(), [efface, self.ck(RETOUR, "", 0), + self.ck(SESSION, f.ouvrir_session(user), SESSION_JOURS * 86400)]) # --- pages ------------------------------------------------------------ def carte_sujet(self, user, t): @@ -1172,6 +1197,8 @@ class Handler(BaseHTTPRequestHandler): return self.a_la_une() filtre = parse_qs(u.query).get("q", [""])[0].strip()[:80] user = self.utilisateur() + if user is None and self.session_a_rafraichir(u): + return self.rafraichir_session(u) f = self.app.forum try: if u.path == "/connexion/gastinel": diff --git a/forum/tests/test_forum.py b/forum/tests/test_forum.py index 231b5c0..1f1d56e 100644 --- a/forum/tests/test_forum.py +++ b/forum/tests/test_forum.py @@ -15,11 +15,12 @@ import threading import unittest import zlib from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer -from urllib.parse import parse_qs, urlparse +from urllib.parse import parse_qs, quote, unquote, urlparse ICI = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") sys.path.insert(0, ICI) import connexion # noqa: E402 +import forum as forum_mod # noqa: E402 import panneau # noqa: E402 import photos # noqa: E402 import roles # noqa: E402 @@ -522,6 +523,47 @@ class TestConnexionGastinel(BaseHTTP): etat, ch = self.depart() self.assertEqual(self.retour(etat)[0], 502) + def test_session_courte_puis_rafraichie_par_le_hub(self): + """Revue sécu 06/11 : la session du forum ne dure qu'une heure (jeton du Hub). Au-delà, le forum repasse + par le Hub ; un compte banni ou déconnecté côté Hub n'est donc plus reconnu après au plus 1 h.""" + etat, ch = self.depart() + self.hub_accepte("c1", ch, {"id": "g-7", "pseudo": "Zoé"}) + jeton = self.jeton_session(self.retour(etat)[1])[0] + u = self.f.utilisateur("g-7") + reste = self.f.con.execute("SELECT (julianday(expires_at) - julianday('now')) * 1440 FROM sessions" + " WHERE user_id=?", (u["id"],)).fetchone()[0] + self.assertLessEqual(reste, forum_mod.SESSION_MINUTES + 1) + # Session échue : une page HTML repasse par le Hub, efface le cookie et garde la page demandée. + self.f.con.execute("UPDATE sessions SET expires_at=datetime('now', '-1 minute')") + self.f.con.commit() + cookie = "forum_session=" + jeton + st, h, _ = self.req("/t/1?page=2", cookie=cookie, entetes={"Accept": "text/html"}) + self.assertEqual(st, 303) + self.assertEqual(urlparse(h["Location"]).path, "/oauth/autoriser") + poses = h.get_all("Set-Cookie") + self.assertTrue(any(c.startswith("forum_session=;") and "Max-Age=0" in c for c in poses)) + retour = [c for c in poses if c.startswith("forum_retour=")][0].split(";")[0].split("=", 1)[1] + etat2 = [c for c in poses if c.startswith("forum_etat=")][0].split(";")[0].split("=", 1)[1] + q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()} + # Le Hub accepte (session Gastinel valable) : retour sur la page demandée, nouvelle session. + self.hub_accepte("c2", q["code_challenge"], {"id": "g-7", "pseudo": "Zoé"}) + st, h, _ = self.req("/connexion/retour?code=c2&state=" + etat2, cookie="forum_etat=%s; forum_retour=%s" % (etat2, retour)) + self.assertEqual((st, h["Location"]), (303, "/t/1?page=2")) + self.assertIsNotNone(self.jeton_session(h)[0]) + # Le Hub refuse (banni, jetons révoqués) : pas de nouvelle session, et le cookie est déjà effacé. + st, h, _ = self.req("/connexion/retour?code=inconnu&state=" + etat2, cookie="forum_etat=" + etat2) + self.assertIsNone(self.jeton_session(h)[0]) + # Sans page HTML demandée (ressource, POST) : pas de détour, simple visiteur. + self.assertEqual(self.req("/", cookie=cookie)[0], 200) + + def test_page_de_retour_reste_sur_le_site(self): + for mauvais in ("//evil.example/x", "https://evil.example/", "/%5Cevil", "/a%0d%0aSet-Cookie:x", "x"): + etat, ch = self.depart() + self.hub_accepte("c1", ch, {"id": "g-8", "pseudo": "Max"}) + st, h, _ = self.req("/connexion/retour?code=c1&state=" + etat, + cookie="forum_etat=%s; forum_retour=%s" % (etat, quote(unquote(mauvais), safe="/"))) + self.assertEqual((st, h["Location"]), (303, "/"), mauvais) + def test_deconnexion_en_post(self): cookie = self.session("m1") self.assertEqual(self.req("/deconnexion", cookie=cookie)[0], 404) # pas en GET