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>
343 lignes
17 KiB
Python
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()
|