Second serveur sur la même base : 403 hors 127/8, 10/8, 192.168/16, ::1 (X-Forwarded-For ignoré), connexion Gastinel avec adresse de retour et session propres, jetons CSRF, utilisateurs et rôles (roles.peut_donner), demandes d'adhésion avec photos, sujets de station à valider, signalements. Sessions séparées par portée dans forum.py ; 11 tests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
373 lignes
20 KiB
Python
373 lignes
20 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, badge, 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
|
|
|
|
CSS_PANNEAU = """
|
|
.haut .nom::after{content:" · panneau";color:var(--gris)}
|
|
.nav{display:flex;flex-wrap:wrap;gap:4px 14px;margin:6px 0 4px;font-size:15px}
|
|
.nav a{font-weight:600}
|
|
.ligne{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end}.ligne>div{flex:1 1 140px;min-width:0}
|
|
.ligne select,.ligne input{width:100%}
|
|
.etat{display:inline-block;border:1px solid var(--roche);padding:0 6px;font-size:12px;font-weight:600}
|
|
"""
|
|
|
|
|
|
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.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'; 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=()):
|
|
if user is None:
|
|
qui = server.BOUTON_GASTINEL.replace("href='/connexion/gastinel'", "href='/connexion/gastinel'")
|
|
else:
|
|
qui = ("<span class='moi'><span>%s</span><form method='post' action='/deconnexion'>%s<button>Sortir</button></form></span>"
|
|
% (e(user["display_name"]), self.champ_csrf()))
|
|
nav = ("<nav class='nav' aria-label='Panneau'><a href='/utilisateurs'>Utilisateurs</a><a href='/adhesions'>Adhésions</a>"
|
|
"<a href='/stations'>Stations à valider</a><a href='/signalements'>Signalements</a></nav>") if user is not None else ""
|
|
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%s</style></head><body>"
|
|
"<div class='haut'><a class='nom' href='/'>Forum</a>%s</div><main>%s%s</main>"
|
|
"<footer class='pied'>Panneau de gestion · réseau local uniquement</footer></body></html>"
|
|
% (e(titre), CSS, CSS_PANNEAU, qui, nav, contenu))
|
|
self.envoyer(code, corps, extra=extra)
|
|
|
|
def erreur(self, user, code, msg, extra=()):
|
|
self.page("Erreur", "<h1>%s</h1><p><a href='/'>Retour au panneau</a></p>" % 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:
|
|
return self.page("Connexion", "<h1>Panneau du forum</h1><div class='boite'><p style='margin-top:0'>"
|
|
"Réservé au Propriétaire et au Propriétaire adjoint. Connecte-toi avec ton compte Gastinel.</p>"
|
|
"<p style='margin-bottom:0'>%s</p></div>" % server.BOUTON_GASTINEL, None)
|
|
f = self.app.forum
|
|
self.gestionnaire(user)
|
|
n_adh = len(f.demandes_adhesion(user))
|
|
n_st = len(f.en_attente(user))
|
|
n_sig = len(f.signalements(user))
|
|
self.page("Panneau", "<h1>Panneau du forum</h1><ul class='sujets'>"
|
|
"<li><a href='/adhesions'>Demandes d'adhésion</a><span class='meta'>%d en attente</span></li>"
|
|
"<li><a href='/stations'>Sujets de station à valider</a><span class='meta'>%d en attente</span></li>"
|
|
"<li><a href='/signalements'>Signalements</a><span class='meta'>%d</span></li>"
|
|
"<li><a href='/utilisateurs'>Utilisateurs et rôles</a><span class='meta'>%d comptes</span></li></ul>"
|
|
% (n_adh, n_st, n_sig, len(f.tous_les_utilisateurs(user))), user)
|
|
|
|
def utilisateurs(self, user):
|
|
f = self.app.forum
|
|
self.gestionnaire(user)
|
|
mes_roles = f.roles_de(user)
|
|
donnables = [r for r in roles.ATTRIBUABLES if roles.peut_donner(mes_roles, r)]
|
|
opts = "".join("<option value='%s'>%s</option>" % (r, e(roles.LIBELLES[r])) for r in donnables)
|
|
st = "".join("<option value='%s'>%s</option>" % (e(k), e(v)) for k, v in sorted(f.stations.items(), key=lambda x: x[1]))
|
|
blocs = []
|
|
for i, u in enumerate(f.tous_les_utilisateurs(user)):
|
|
blocs.append(
|
|
"<div class='boite'><b>%s</b> %s<br><span class='meta'>%s</span>"
|
|
"<form method='post' action='/role'>%s<input type='hidden' name='hub_id' value='%s'><div class='ligne'>"
|
|
"<div><label for='r%d'>Rôle</label><select id='r%d' name='role'>%s</select></div>"
|
|
"<div><label for='s%d'>Station (propriétaire de station)</label><select id='s%d' name='station'>"
|
|
"<option value=''>—</option>%s</select></div></div>"
|
|
"<p style='margin-bottom:0'><button name='action' value='donner'>Donner</button> "
|
|
"<button name='action' value='retirer'>Retirer</button></p></form></div>"
|
|
% (e(u["display_name"]), "".join(badge(r, lib) for r, lib in f.badges(u["id"])), e(u["hub_id"]),
|
|
self.champ_csrf(), e(u["hub_id"]), i, i, opts, i, i, st))
|
|
self.page("Utilisateurs", "<h1>Utilisateurs</h1><p class='chapeau'>Le rôle « Propriétaire » se fixe par la configuration "
|
|
"du serveur, jamais ici. Seul le Propriétaire nomme un Propriétaire adjoint.</p>%s"
|
|
% ("".join(blocs) or "<p>Aucun compte.</p>"), user)
|
|
|
|
def adhesions(self, user):
|
|
f = self.app.forum
|
|
self.gestionnaire(user)
|
|
blocs = []
|
|
for d in f.demandes_adhesion(user):
|
|
_, ph = f.demande_adhesion(user, d["id"])
|
|
gal = "".join("<a href='/adhesion-photo/%s'><img src='/adhesion-photo/%s' alt='%s' loading='lazy'></a>"
|
|
% (e(os.path.basename(p["stored_path"])), e(os.path.basename(p["stored_path"])), e(p["filename"]))
|
|
for p in ph)
|
|
form = ("<form class='inline' method='post' action='/adhesion/decider'>%s<input type='hidden' name='demande' value='%d'>"
|
|
"<input type='hidden' name='ok' value='%s'><button>%s</button></form>")
|
|
blocs.append("<div class='boite'><b>%s</b> %s<br><span class='meta'>%s · %s</span>"
|
|
"<div style='white-space:pre-wrap;overflow-wrap:anywhere;margin:8px 0'>%s</div>%s<p style='margin-bottom:0'>%s%s</p></div>"
|
|
% (e(d["pseudo"]), "".join(badge(r, lib) for r, lib in f.badges(d["user_id"])), e(d["hub_id"]),
|
|
e(d["created_at"][:10]), e(d["message"]), "<div class='galerie'>%s</div>" % gal if gal else "",
|
|
form % (self.champ_csrf(), d["id"], 1, "Accepter"), form % (self.champ_csrf(), d["id"], 0, "Refuser")))
|
|
self.page("Adhésions", "<h1>Demandes d'adhésion</h1>%s" % ("".join(blocs) or "<p>Aucune demande en attente.</p>"), user)
|
|
|
|
def stations(self, user):
|
|
f = self.app.forum
|
|
self.gestionnaire(user)
|
|
blocs = []
|
|
for t in f.en_attente(user):
|
|
_, msgs = f.sujet(user, t["id"])
|
|
form = ("<form class='inline' method='post' action='/valider'>%s<input type='hidden' name='sujet' value='%d'>"
|
|
"<input type='hidden' name='ok' value='%s'><button>%s</button></form>")
|
|
blocs.append("<div class='boite'><b>%s</b><br><span class='meta'>par %s</span>"
|
|
"<div style='white-space:pre-wrap;overflow-wrap:anywhere;margin:8px 0'>%s</div><p style='margin-bottom:0'>%s%s</p></div>"
|
|
% (e(t["title"]), e(t["auteur"]), e(msgs[0]["body"] if msgs else ""),
|
|
form % (self.champ_csrf(), t["id"], 1, "Publier"), form % (self.champ_csrf(), t["id"], 0, "Refuser")))
|
|
self.page("Stations à valider", "<h1>Sujets de station à valider</h1>%s" % ("".join(blocs) or "<p>Rien à valider.</p>"), user)
|
|
|
|
def signalements(self, user):
|
|
self.gestionnaire(user)
|
|
items = "".join("<li><div>Message %d · sujet %d · %s<br><span class='meta'>%s</span><br>%s</div></li>"
|
|
% (r["post_id"], r["topic_id"], e(r["created_at"][:10]) if "created_at" in r.keys() else "",
|
|
e(r["reason"]), e(r["body"][:300])) for r in self.app.forum.signalements(user))
|
|
self.page("Signalements", "<h1>Signalements</h1><ul class='sujets'>%s</ul>" % (items or "<li>Aucun signalement.</li>"), 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()
|
|
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 = f.donner_role if d.get("action") == "donner" else f.retirer_role
|
|
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"))
|
|
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()
|