Fichiers
meteo-vercors/forum/panneau.py
T
Théo GastineletClaude Opus 5.5 72ab04d722 Forum : refonte visuelle (sujets en cartes, extraits, sections Bulletin/Sujets/Stations, nouveau sujet visible, polices locales)
Refonte de Codex (interrompue par son quota), reprise et finie par Claude :
dates en français à l'heure de Paris, « Aucune réponse » / « Aucune publication ».
69 tests OK. En essai sur le forum LAN :32, pas en ligne.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 23:05:35 +01:00

343 lignes
17 KiB
Python

"""Panneau de gestion du forum, réservé au réseau local et au Propriétaire / Propriétaire adjoint.
Second serveur, sur la même base que le forum (python forum/panneau.py --port 8790).
- Toute requête dont l'adresse n'est pas en 127/8, 10/8, 192.168/16 ou ::1 reçoit 403 : on regarde seulement
l'adresse de la connexion TCP, JAMAIS X-Forwarded-For (le panneau ne se place pas derrière un relais).
- Connexion avec le compte Gastinel (même client OAuth que le forum, connexion.py), mais adresse de retour propre
(FORUM_PANNEAU_REDIRECT_URI) et session propre (cookie panneau_session, jetons séparés de ceux du forum).
- Aucune inscription ici : seul un compte déjà connu du forum et ayant le droit « gerer_roles » entre.
- Tous les POST exigent un jeton CSRF lié à la session, en plus du contrôle d'origine.
Variables d'environnement : celles du forum (FORUM_HUB_URL, FORUM_CLIENT_ID, FORUM_OAUTH_SECRET[_FILE],
FORUM_PROPRIETAIRE_ID) + FORUM_PANNEAU_REDIRECT_URI (défaut : http://localhost:<port>/connexion/retour).
"""
import argparse
import hashlib
import hmac
import os
import re
import secrets
import sys
from http import cookies
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, urlparse
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import connexion # noqa: E402
import roles # noqa: E402
import server # noqa: E402
from forum import ETAT_MINUTES, Forum, Invalide, Refus # noqa: E402
from server import CSS, JETON_OK, PHOTO_OK, TYPES_IMG, e # noqa: E402
PORTEE = "panneau" # sépare les sessions du panneau de celles du forum
SESSION = "panneau_session"
ETAT = "panneau_etat"
SESSION_JOURS = 1
FORMULAIRE_MAX = 64 * 1024
SUJET_PUBLIC = "https://vercors.me/forum/t/"
class App:
def __init__(self, forum, reglages):
self.forum = forum
self.reglages = reglages
self.cle = secrets.token_bytes(32) # clé des jetons CSRF (propre à ce processus)
class Handler(BaseHTTPRequestHandler):
server_version = "PanneauForum"
app = None # défini dans creer_serveur
def log_message(self, *a):
pass
# --- outils ---------------------------------------------------------
def ip(self):
return self.client_address[0] # volontairement sans X-Forwarded-For
def cookie(self, nom):
try:
c = cookies.SimpleCookie(self.headers.get("Cookie", ""))
except cookies.CookieError:
return None
return c[nom].value if nom in c else None
def jeton_session(self):
j = self.cookie(SESSION)
return j if j and JETON_OK.match(j) else None
def utilisateur(self):
j = self.jeton_session()
return self.app.forum.utilisateur_de_session(j, PORTEE) if j else None
def csrf(self):
j = self.jeton_session() or ""
return hmac.new(self.app.cle, j.encode("ascii"), hashlib.sha256).hexdigest()
def champ_csrf(self):
return "<input type='hidden' name='csrf' value='%s'>" % self.csrf()
def ck(self, nom, valeur, age):
secure = self.app.reglages.redirect_uri.startswith("https://")
return server._cookie(nom, valeur, age, "/", secure)
def envoyer(self, code, corps, type_="text/html; charset=utf-8", extra=()):
data = corps if isinstance(corps, bytes) else corps.replace("__POLICES__", "/polices").encode("utf-8")
self.send_response(code)
self.send_header("Content-Type", type_)
self.send_header("Content-Length", str(len(data)))
self.send_header("Content-Security-Policy",
"default-src 'none'; style-src 'unsafe-inline'; img-src 'self'; font-src 'self'; form-action 'self'; frame-ancestors 'none'")
self.send_header("X-Content-Type-Options", "nosniff")
self.send_header("Referrer-Policy", "no-referrer")
self.send_header("Cache-Control", "private, no-store")
for k, v in extra:
self.send_header(k, v)
self.end_headers()
self.wfile.write(data)
def rediriger(self, url, extra=()):
self.send_response(303)
self.send_header("Location", url)
self.send_header("Referrer-Policy", "no-referrer")
for k, v in extra:
self.send_header(k, v)
self.send_header("Content-Length", "0")
self.end_headers()
def page(self, titre, contenu, user, code=200, extra=()):
qui = ""
nav = ""
if user is not None:
qui = ("<div class='moi'><span>%s</span><form method='post' action='/deconnexion'>"
"%s<button>Se déconnecter</button></form></div>"
% (e(user["display_name"]), self.champ_csrf()))
if roles.peut(self.app.forum.roles_de(user), "gerer_roles"):
liens = [("/", "Vue d’ensemble"), ("/utilisateurs", "Comptes et rôles"), ("/adhesions", "Adhésions"),
("/stations", "Stations à valider"), ("/signalements", "Signalements")]
nav = server.navigation(liens, urlparse(self.path).path, "Panneau du forum")
corps = ("<!doctype html><html lang='fr'><head><meta charset='utf-8'>"
"<meta name='viewport' content='width=device-width,initial-scale=1'><meta name='robots' content='noindex'>"
"<title>%s · Panneau du forum</title><style>%s</style></head><body>"
"<a class='saut' href='#contenu'>Aller au contenu</a>"
"<header class='haut'><a class='nom' href='/'>Météo Vercors · Gestion</a>%s</header>"
"<main id='contenu'>%s%s</main>"
"<footer class='pied'>Panneau de gestion · réseau local uniquement</footer></body></html>"
% (e(titre), CSS, qui, nav, contenu))
self.envoyer(code, corps, extra=extra)
def erreur(self, user, code, msg, extra=()):
titre = {400: "Demande à corriger", 403: "Accès refusé", 404: "Page introuvable"}.get(code, "Action indisponible")
self.page(titre, "<h1>%s</h1><p class='info'>%s</p><p><a class='bouton' href='/'>Retour au panneau</a></p>"
% (titre, e(msg)), user, code, extra)
def refuser_hors_lan(self):
if connexion.est_locale(self.ip()):
return False
self.envoyer(403, "Accès refusé", "text/plain; charset=utf-8")
return True
def origine_ok(self):
o = self.headers.get("Origin") or self.headers.get("Referer") or ""
return urlparse(o).netloc == self.headers.get("Host", "x")
def gestionnaire(self, user):
"""L'utilisateur s'il a le droit d'utiliser le panneau, sinon Refus (rôles revérifiés à chaque requête)."""
if user is None:
raise Refus("connexion requise")
if not roles.peut(self.app.forum.roles_de(user), "gerer_roles"):
raise Refus("réservé au Propriétaire et au Propriétaire adjoint")
return user
# --- connexion Gastinel ----------------------------------------------
def connexion_depart(self, user):
r = self.app.reglages
if not r.configuree:
return self.erreur(user, 503, "La connexion avec Gastinel n'est pas configurée")
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)])
def connexion_retour(self, q):
f, r = self.app.forum, self.app.reglages
efface = self.ck(ETAT, "", 0)
if not r.configuree:
return self.erreur(None, 503, "La connexion avec Gastinel n'est pas configurée")
if "error" in q:
return self.erreur(None, 400, "Connexion annulée", [efface])
etat, code = q.get("state", [""])[0], q.get("code", [""])[0]
du_navigateur = self.cookie(ETAT) or ""
if (not etat or not du_navigateur or len(etat) > 200
or not hmac.compare_digest(etat.encode("utf-8"), du_navigateur.encode("utf-8"))):
return self.erreur(None, 400, "Demande de connexion invalide ou expirée, recommence", [efface])
verifier = f.prendre_etat(etat)
if not verifier or not code or len(code) > 512:
return self.erreur(None, 400, "Demande de connexion invalide ou expirée, recommence", [efface])
try:
jeton = connexion.echanger_code(r, code, verifier)
ident, pseudo = connexion.lire_profil(r, jeton)
except connexion.ErreurHub:
return self.erreur(None, 502, "Le compte Gastinel n'a pas pu être vérifié, réessaie plus tard", [efface])
if f.proprietaire_id and ident == f.proprietaire_id:
user = f.connexion_gastinel(ident, pseudo)
else:
user = f.utilisateur_existant(ident) # pas d'inscription par le panneau
if user is None or not roles.peut(f.roles_de(user), "gerer_roles"):
return self.erreur(None, 403, "Ce compte n'a pas accès au panneau", [efface])
ancien = self.jeton_session()
if ancien:
f.fermer_session(ancien, PORTEE)
self.rediriger("/", [efface, self.ck(SESSION, f.ouvrir_session(user, SESSION_JOURS, PORTEE), SESSION_JOURS * 86400)])
# --- pages ------------------------------------------------------------
def accueil(self, user):
if user is None:
action = (server.BOUTON_GASTINEL if self.app.reglages.configuree
else "<p class='info'>La connexion Gastinel doit être configurée avant d’utiliser le panneau.</p>")
return self.page("Connexion", "<h1>Panneau du forum</h1><section class='boite'><h2>Accès de gestion</h2>"
"<p>Connecte-toi avec le compte Gastinel du Propriétaire ou du Propriétaire adjoint.</p>"
"%s</section>" % action, None)
f = self.app.forum
self.gestionnaire(user)
cartes = (
("/adhesions", "Demandes d’adhésion", len(f.demandes_adhesion(user)), "à examiner"),
("/stations", "Sujets de station", len(f.en_attente(user)), "à valider"),
("/signalements", "Signalements", len(f.signalements(user)), "reçus"),
("/utilisateurs", "Comptes et rôles", len(f.tous_les_utilisateurs(user)), "comptes"),
)
grille = "".join("<a class='fiche' href='%s'><h2>%s</h2><p class='meta'>%d %s</p></a>"
% (url, nom, nombre, libelle) for url, nom, nombre, libelle in cartes)
self.page("Vue d’ensemble", "<h1>Panneau du forum</h1><p class='chapeau'>Retrouve les demandes, les signalements "
"et les rôles des comptes Gastinel inscrits au forum.</p><div class='grille'>%s</div>" % grille, user)
def utilisateurs(self, user):
self.gestionnaire(user)
filtre = parse_qs(urlparse(self.path).query).get("q", [""])[0].strip()[:80]
self.page("Comptes et rôles", "<h1>Comptes et rôles</h1><p class='chapeau'>Retrouve un compte puis ouvre sa fiche. "
"Le rôle Propriétaire est défini dans la configuration. Seul le Propriétaire peut nommer son adjoint.</p>%s"
% server.gestion_roles(self.app.forum, user, filtre, self.champ_csrf()), user)
def adhesions(self, user):
self.gestionnaire(user)
self.page("Adhésions", "<h1>Demandes d’adhésion</h1><p class='chapeau'>Relis les présentations et leurs photos avant de décider.</p>%s"
% server.demandes_html(self.app.forum, user, self.champ_csrf()), user)
def stations(self, user):
self.gestionnaire(user)
self.page("Stations à valider", "<h1>Sujets de station à valider</h1>"
"<p class='chapeau'>Vérifie la présentation avant publication sur le forum.</p>%s"
% server.stations_html(self.app.forum, user, csrf=self.champ_csrf()), user)
def signalements(self, user):
self.gestionnaire(user)
self.page("Signalements", "<h1>Signalements</h1><p class='chapeau'>Retrouve le contexte du message sur le forum. "
"Les actions de modération s’effectuent depuis la discussion.</p>%s"
% server.signalements_html(self.app.forum, user, SUJET_PUBLIC), user)
def photo_adhesion(self, user, nom):
self.gestionnaire(user)
if not PHOTO_OK.match(nom):
return self.envoyer(404, "introuvable", "text/plain; charset=utf-8")
with open(self.app.forum.photo_adhesion(user, nom), "rb") as fh:
self.envoyer(200, fh.read(), TYPES_IMG[nom.rsplit(".", 1)[1]])
# --- GET / POST ---------------------------------------------------------
def do_GET(self):
if self.refuser_hors_lan():
return
u = urlparse(self.path)
user = self.utilisateur()
if u.path.startswith("/polices/"):
return server.servir_police(self, u.path)
try:
if u.path == "/connexion/gastinel":
return self.connexion_depart(user)
if u.path == "/connexion/retour":
return self.connexion_retour(parse_qs(u.query))
routes = {"/": self.accueil, "/utilisateurs": self.utilisateurs, "/adhesions": self.adhesions,
"/stations": self.stations, "/signalements": self.signalements}
if u.path in routes:
return routes[u.path](user)
m = re.fullmatch(r"/adhesion-photo/([^/]+)", u.path)
if m:
return self.photo_adhesion(user, m.group(1))
self.erreur(user, 404, "Page introuvable")
except Refus as ex:
self.erreur(user, 403, "Accès réservé : %s" % ex)
except Invalide as ex:
self.erreur(user, 404, str(ex))
def lire_formulaire(self):
try:
n = int(self.headers.get("Content-Length") or 0)
except ValueError:
raise Invalide("longueur de requête invalide")
if n < 0 or n > FORMULAIRE_MAX:
raise Invalide("requête invalide")
return {k: v[0] for k, v in parse_qs(self.rfile.read(n).decode("utf-8", "replace")).items()}
def do_POST(self):
if self.refuser_hors_lan():
return
user = self.utilisateur()
f = self.app.forum
if not self.origine_ok():
return self.erreur(user, 403, "Origine refusée")
try:
d = self.lire_formulaire()
if user is None:
raise Refus("connexion requise")
if not hmac.compare_digest(d.get("csrf", "").encode("utf-8"), self.csrf().encode("ascii")):
raise Refus("jeton CSRF invalide, recharge la page")
if self.path == "/deconnexion":
f.fermer_session(self.jeton_session(), PORTEE)
return self.rediriger("/", [self.ck(SESSION, "", 0)])
self.gestionnaire(user)
if self.path == "/role":
action = {"donner": f.donner_role, "retirer": f.retirer_role}.get(d.get("action"))
if action is None:
raise Invalide("Choisis une action pour le rôle.")
action(user, d.get("hub_id", ""), d.get("role", ""), d.get("station", ""))
return self.rediriger("/utilisateurs")
if self.path == "/adhesion/decider":
f.decider_adhesion(user, int(d.get("demande", "0")), d.get("ok") == "1")
return self.rediriger("/adhesions")
if self.path == "/valider":
f.valider_sujet(user, int(d.get("sujet", "0")), d.get("ok") == "1")
return self.rediriger("/stations")
self.erreur(user, 404, "Page introuvable")
except Refus as ex:
self.erreur(user, 403, "Non autorisé : %s" % ex)
except (Invalide, ValueError) as ex:
self.erreur(user, 400, str(ex))
def creer_serveur(forum, port=0, hote="127.0.0.1", reglages=None):
h = type("H", (Handler,), {"app": App(forum, reglages or connexion.Reglages())})
return ThreadingHTTPServer((hote, port), h)
def main():
ici = os.path.dirname(os.path.abspath(__file__))
ap = argparse.ArgumentParser(description="Panneau de gestion du forum (réseau local, Propriétaire et adjoint)")
ap.add_argument("--db", default=os.path.join(ici, "forum-local.sqlite3"), help="la même base que le forum")
ap.add_argument("--photos", default=os.path.join(ici, "photos-local"), help="le même dossier de photos que le forum")
ap.add_argument("--port", type=int, default=8790)
ap.add_argument("--hote", default="0.0.0.0", help="adresse d'écoute (défaut 0.0.0.0 ; les IP hors LAN reçoivent 403)")
a = ap.parse_args()
reglages = connexion.Reglages.depuis_env()
reglages.redirect_uri = os.environ.get("FORUM_PANNEAU_REDIRECT_URI") or "http://localhost:%d/connexion/retour" % a.port
f = Forum(a.db, stations=server.charger_stations() or {"geve": "Gêve"}, dossier_photos=a.photos,
proprietaire_id=os.environ.get("FORUM_PROPRIETAIRE_ID"))
f.apres_roles = lambda h, rs: connexion.pousser_roles(reglages, h, rs) # rôles affichés sur la page du compte Gastinel
s = creer_serveur(f, a.port, a.hote, reglages)
print("Panneau : http://%s:%d (réseau local seulement ; connexion Gastinel %s, retour %s)" % (
a.hote, a.port, "configurée" if reglages.configuree else "NON configurée : FORUM_HUB_URL manquant", reglages.redirect_uri))
s.serve_forever()
if __name__ == "__main__":
main()