forum : connexion « Se connecter avec Gastinel », mode essai restreint, badges SVG, demandes d'adhésion

- connexion.py : client OAuth 2 code + PKCE S256 (state lié au navigateur, usage unique, 10 min),
  échange via urllib vers /oauth/jeton, profil via /oauth/moi ; réglages par variables d'environnement.
- Sessions par cookie HttpOnly Secure SameSite=Lax, identifiant aléatoire haché en base ; déconnexion en POST.
  L'ancien cookie forum_test n'authentifie plus rien.
- FORUM_PROPRIETAIRE_ID : l'id Gastinel de Théo reçoit le rôle Propriétaire à sa connexion.
- /test-login et --seed : seulement avec FORUM_MODE_TEST=1 et depuis le LAN ou la machine ;
  X-Forwarded-For cru seulement depuis 127.0.0.1 (ou FORUM_RELAIS).
- Badges en SVG en ligne avec texte alternatif ; épinglage réservé au propriétaire et à l'adjoint ;
  modérateur non adhérent : modère et répond, ne crée pas de sujet.
- Demandes d'adhésion : message + 10 photos (métadonnées retirées, hors dossier public),
  validation par propriétaire ou adjoint ; méthodes prêtes pour le panneau LAN.
- 37 tests (Hub simulé par un faux serveur local).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Opus 5.5 a révisé 2026-11-04 16:51:19 +01:00
1 Parent e914a4942d
révision ebc01aac03
7 fichiers modifiés
+978 -105

Aucun fichier ne correspond à votre recherche

+177
Voir le fichier
@@ -0,0 +1,177 @@
"""« Se connecter avec Gastinel » : client OAuth 2 (code + PKCE S256) vers le Hub. Bibliothèque standard seulement.
Contrat du Hub (Plan-connexion-Gastinel.md) :
GET {hub}/oauth/autoriser?response_type=code&client_id&redirect_uri&state&code_challenge&code_challenge_method=S256
POST {hub}/oauth/jeton (formulaire) grant_type=authorization_code, code, redirect_uri, client_id, code_verifier[, client_secret]
-> {"access_token", "token_type": "Bearer", "expires_in": 3600} ; erreurs {"error"} en 400/401/429
GET {hub}/oauth/moi (Authorization: Bearer <jeton>) -> {"id": "<uuid>", "pseudo": "..."} ; sinon 401 {"error": "invalid_token"}
Le forum ne voit jamais le mot de passe ni l'e-mail : seulement l'identifiant et le pseudo.
"""
import base64
import hashlib
import ipaddress
import json
import os
import re
import secrets
import urllib.error
import urllib.parse
import urllib.request
REPONSE_MAX = 64 * 1024 # réponse du Hub lue au plus (octets)
DELAI = 10 # secondes
ID_HUB_OK = re.compile(r"^[A-Za-z0-9_.:@-]{1,64}$")
LOCALES = [ipaddress.ip_network(n) for n in ("127.0.0.0/8", "10.0.0.0/8", "192.168.0.0/16", "::1/128")]
class ErreurHub(Exception):
"""Le Hub a refusé ou n'a pas répondu correctement."""
def _bool(v):
return str(v or "").strip() == "1"
class Reglages:
"""Configuration de la connexion. En production : depuis les variables d'environnement (depuis_env)."""
def __init__(self, hub_url="", client_id="forum-vercors",
redirect_uri="https://vercors.me/forum/connexion/retour", client_secret="",
mode_test=False, relais=("127.0.0.1", "::1")):
self.hub_url = (hub_url or "").rstrip("/")
if self.hub_url:
u = urllib.parse.urlparse(self.hub_url)
local = u.hostname in ("127.0.0.1", "localhost", "::1")
if u.scheme != "https" and not (u.scheme == "http" and local):
raise ValueError("FORUM_HUB_URL doit être en https (http seulement en local)")
self.client_id = client_id
self.redirect_uri = redirect_uri
self.client_secret = client_secret
self.mode_test = bool(mode_test)
self.relais = frozenset(relais)
@property
def configuree(self):
return bool(self.hub_url and self.client_id and self.redirect_uri)
@classmethod
def depuis_env(cls, env=None):
env = os.environ if env is None else env
secret = ""
fichier = env.get("FORUM_OAUTH_SECRET_FILE")
if fichier:
with open(fichier, encoding="utf-8") as fh:
secret = fh.read().strip()
else:
secret = env.get("FORUM_OAUTH_SECRET", "")
relais = ("127.0.0.1", "::1") + tuple(x.strip() for x in env.get("FORUM_RELAIS", "").split(",") if x.strip())
return cls(hub_url=env.get("FORUM_HUB_URL", ""),
client_id=env.get("FORUM_CLIENT_ID", "forum-vercors"),
redirect_uri=env.get("FORUM_REDIRECT_URI", "https://vercors.me/forum/connexion/retour"),
client_secret=secret,
mode_test=_bool(env.get("FORUM_MODE_TEST")),
relais=relais)
# --- PKCE et adresse d'autorisation ------------------------------------------
def _b64(octets):
return base64.urlsafe_b64encode(octets).rstrip(b"=").decode("ascii")
def pkce():
"""Retourne (code_verifier, code_challenge S256)."""
verifier = secrets.token_urlsafe(48) # 64 caractères (RFC 7636 : 43 à 128)
return verifier, _b64(hashlib.sha256(verifier.encode("ascii")).digest())
def nouvel_etat():
return secrets.token_urlsafe(32)
def url_autorisation(r, etat, challenge):
q = urllib.parse.urlencode({"response_type": "code", "client_id": r.client_id, "redirect_uri": r.redirect_uri,
"state": etat, "code_challenge": challenge, "code_challenge_method": "S256"})
return "%s/oauth/autoriser?%s" % (r.hub_url, q)
# --- appels serveur à serveur ------------------------------------------------
class _SansRedirection(urllib.request.HTTPRedirectHandler):
def redirect_request(self, *a, **k): # un code ou un jeton ne suit jamais une redirection
return None
_OUVREUR = urllib.request.build_opener(urllib.request.ProxyHandler({}), _SansRedirection())
def _json(req):
try:
with _OUVREUR.open(req, timeout=DELAI) as rep:
brut = rep.read(REPONSE_MAX + 1)
except urllib.error.HTTPError as ex:
raise ErreurHub("le Hub a répondu %d" % ex.code)
except (urllib.error.URLError, OSError) as ex:
raise ErreurHub("Hub injoignable (%s)" % ex.__class__.__name__)
if len(brut) > REPONSE_MAX:
raise ErreurHub("réponse du Hub trop longue")
try:
d = json.loads(brut.decode("utf-8"))
except ValueError:
raise ErreurHub("réponse du Hub illisible")
if not isinstance(d, dict):
raise ErreurHub("réponse du Hub inattendue")
return d
def echanger_code(r, code, verifier):
"""Échange le code contre un jeton d'accès (POST /oauth/jeton)."""
champs = {"grant_type": "authorization_code", "code": code, "redirect_uri": r.redirect_uri,
"client_id": r.client_id, "code_verifier": verifier}
if r.client_secret:
champs["client_secret"] = r.client_secret
req = urllib.request.Request(r.hub_url + "/oauth/jeton", data=urllib.parse.urlencode(champs).encode("ascii"),
headers={"Content-Type": "application/x-www-form-urlencoded",
"Accept": "application/json"}, method="POST")
jeton = _json(req).get("access_token")
if not isinstance(jeton, str) or not jeton or len(jeton) > 4096:
raise ErreurHub("jeton absent")
return jeton
def lire_profil(r, jeton):
"""GET /oauth/moi -> (id Gastinel, pseudo)."""
req = urllib.request.Request(r.hub_url + "/oauth/moi",
headers={"Authorization": "Bearer " + jeton, "Accept": "application/json"})
d = _json(req)
ident = d.get("id", d.get("sub"))
if isinstance(ident, bool) or not isinstance(ident, (str, int)):
raise ErreurHub("identifiant absent")
ident = str(ident)
if not ID_HUB_OK.match(ident) or ident == "systeme":
raise ErreurHub("identifiant invalide")
pseudo = d.get("pseudo")
pseudo = "".join(c for c in pseudo if c.isprintable()).strip()[:60] if isinstance(pseudo, str) else ""
return ident, pseudo or "Membre"
# --- adresse du client --------------------------------------------------------
def ip_client(directe, xff, relais=("127.0.0.1", "::1")):
"""Adresse réelle du visiteur. X-Forwarded-For n'est cru que si la requête vient d'un relais de confiance
(Caddy en local) ; on prend alors la dernière adresse, celle que le relais a vue."""
if directe in relais and xff:
derniere = xff.split(",")[-1].strip()
try:
return str(ipaddress.ip_address(derniere))
except ValueError:
return directe
return directe
def est_locale(ip):
try:
a = ipaddress.ip_address(ip)
except ValueError:
return False
if getattr(a, "ipv4_mapped", None):
a = a.ipv4_mapped
return any(a.version == n.version and a in n for n in LOCALES)
+35 -1
Voir le fichier
@@ -1,4 +1,4 @@
"""Schéma SQLite et accès aux données (version 2 : rôles cumulables, sujets épinglés, photos)."""
"""Schéma SQLite et accès aux données (version 3 : + sessions Gastinel, demandes d'adhésion)."""
import sqlite3
SCHEMA = """
@@ -59,6 +59,40 @@ CREATE TABLE IF NOT EXISTS reports (
created_at TEXT NOT NULL DEFAULT (datetime('now')),
UNIQUE (post_id, reporter_id)
);
-- Sessions du forum (connexion Gastinel) : seul le haché SHA-256 de l'identifiant du cookie est gardé.
CREATE TABLE IF NOT EXISTS sessions (
id_hache TEXT PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
created_at TEXT NOT NULL DEFAULT (datetime('now')),
expires_at TEXT NOT NULL
);
-- Demandes de connexion en cours (state haché -> code_verifier PKCE), 10 minutes au plus.
CREATE TABLE IF NOT EXISTS oauth_etats (
etat_hache TEXT PRIMARY KEY,
verifier TEXT NOT NULL,
created_at TEXT NOT NULL DEFAULT (datetime('now'))
);
-- Demandes pour devenir adhérent météo (validées par le propriétaire ou l'adjoint).
CREATE TABLE IF NOT EXISTS adhesions (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
message TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'en_attente' CHECK (status IN ('en_attente','acceptee','refusee')),
created_at TEXT NOT NULL DEFAULT (datetime('now')),
decided_by INTEGER REFERENCES users(id),
decided_at TEXT
);
CREATE TABLE IF NOT EXISTS adhesion_photos (
id INTEGER PRIMARY KEY,
adhesion_id INTEGER NOT NULL REFERENCES adhesions(id),
filename TEXT NOT NULL,
mime TEXT NOT NULL,
size INTEGER NOT NULL,
sha256 TEXT NOT NULL,
stored_path TEXT NOT NULL
);
CREATE UNIQUE INDEX IF NOT EXISTS idx_une_demande_en_cours ON adhesions(user_id) WHERE status = 'en_attente';
CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id);
CREATE INDEX IF NOT EXISTS idx_topics_liste ON topics(pinned DESC, pin_pos, id DESC);
CREATE INDEX IF NOT EXISTS idx_posts_topic ON posts(topic_id, id);
CREATE INDEX IF NOT EXISTS idx_attach_post ON attachments(post_id);
+150 -17
Voir le fichier
@@ -5,6 +5,7 @@ Le sujet fixe « Bulletin de la semaine du Vercors » est toujours épinglé en
"""
import hashlib
import os
import secrets
import db
import photos
@@ -12,7 +13,9 @@ import roles
TITRE_MAX, CORPS_MAX = 150, 20000
EPINGLES_MAX = 5 # sujet fixe compris
PHOTOS_MAX, OCTETS_MAX = 10, 25 * 1024 * 1024 # par message, sauf propriétaires
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
class Refus(Exception):
@@ -24,10 +27,57 @@ class Invalide(Exception):
class Forum:
def __init__(self, chemin=":memory:", stations=None, dossier_photos=None):
def __init__(self, chemin=":memory:", stations=None, dossier_photos=None, proprietaire_id=None):
self.con = db.connecter(chemin)
self.stations = stations or {} # id -> nom affiché (pour le titre des sujets de station)
self.dossier_photos = dossier_photos
self.proprietaire_id = proprietaire_id or None # id Gastinel de Théo (FORUM_PROPRIETAIRE_ID)
# --- connexion Gastinel et sessions ----------------------------------
@staticmethod
def _hache(s):
return hashlib.sha256(s.encode("utf-8")).hexdigest()
def connexion_gastinel(self, hub_id, pseudo):
"""Après « Se connecter avec Gastinel » : crée ou met à jour le compte ; le propriétaire configuré reçoit son rôle."""
u = self.utilisateur(hub_id, pseudo)
if self.proprietaire_id and hub_id == self.proprietaire_id:
u = self.fixer_proprietaire(hub_id, pseudo)
return u
def ouvrir_session(self, user, jours=SESSION_JOURS):
"""Retourne l'identifiant aléatoire à mettre dans le cookie ; seul son haché est stocké."""
jeton = secrets.token_urlsafe(32)
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(jeton), user["id"], "+%d days" % jours))
self.con.commit()
return jeton
def utilisateur_de_session(self, jeton):
if not jeton:
return None
return self.con.execute("SELECT u.* FROM sessions s JOIN users u ON u.id=s.user_id"
" WHERE s.id_hache=? AND s.expires_at > datetime('now')", (self._hache(jeton),)).fetchone()
def fermer_session(self, jeton):
self.con.execute("DELETE FROM sessions WHERE id_hache=?", (self._hache(jeton or ""),))
self.con.commit()
def noter_etat(self, etat, verifier):
"""Mémorise une demande de connexion (state -> code_verifier PKCE)."""
self.con.execute("DELETE FROM oauth_etats WHERE created_at < datetime('now', ?)", ("-%d minutes" % ETAT_MINUTES,))
self.con.execute("INSERT INTO oauth_etats(etat_hache, verifier) VALUES (?, ?)", (self._hache(etat), verifier))
self.con.commit()
def prendre_etat(self, etat):
"""Usage unique : retourne le code_verifier si le state est connu et récent, sinon None."""
h = self._hache(etat or "")
r = self.con.execute("SELECT verifier FROM oauth_etats WHERE etat_hache=? AND created_at >= datetime('now', ?)",
(h, "-%d minutes" % ETAT_MINUTES)).fetchone()
self.con.execute("DELETE FROM oauth_etats WHERE etat_hache=?", (h,))
self.con.commit()
return r["verifier"] if r else None
# --- utilisateurs et rôles -----------------------------------------
def utilisateur(self, hub_id, nom=None):
@@ -233,10 +283,22 @@ class Forum:
p = self._post(post_id)
if p["author_id"] != user["id"]:
raise Refus("pas votre message")
deja = self.photos_de(post_id)
prets = self._preparer_photos(fichiers, deja, self._peut(user, "photos_illimitees"))
ids = []
for nom, mime, propre in prets:
empreinte, chemin = self._stocker(self.dossier_photos, mime, propre)
cur = self.con.execute("INSERT INTO attachments(post_id, filename, mime, size, sha256, stored_path)"
" VALUES (?, ?, ?, ?, ?, ?)", (post_id, nom, mime, len(propre), empreinte, chemin))
ids.append(cur.lastrowid)
self.con.commit()
return ids
def _preparer_photos(self, fichiers, deja=(), illimite=False):
"""Vérifie limites et formats, retire les métadonnées ; rien n'est écrit. -> [(nom, mime, octets)]"""
if not self.dossier_photos:
raise Invalide("photos non configurées")
deja = self.photos_de(post_id)
if not self._peut(user, "photos_illimitees"):
if not illimite:
if len(deja) + len(fichiers) > PHOTOS_MAX:
raise Refus("%d photos par message au maximum" % PHOTOS_MAX)
if sum(a["size"] for a in deja) + sum(len(d) for _, d in fichiers) > OCTETS_MAX:
@@ -248,20 +310,91 @@ class Forum:
except photos.PhotoInvalide as e:
raise Invalide(str(e))
prets.append((os.path.basename(nom or "photo")[:80], mime, propre))
os.makedirs(self.dossier_photos, exist_ok=True)
ids = []
for nom, mime, propre in prets:
empreinte = hashlib.sha256(propre).hexdigest()
chemin = os.path.join(self.dossier_photos, empreinte + photos.TYPES[mime])
if not os.path.exists(chemin):
with open(chemin + ".tmp", "wb") as f:
f.write(propre)
os.replace(chemin + ".tmp", chemin)
cur = self.con.execute("INSERT INTO attachments(post_id, filename, mime, size, sha256, stored_path)"
" VALUES (?, ?, ?, ?, ?, ?)", (post_id, nom, mime, len(propre), empreinte, chemin))
ids.append(cur.lastrowid)
return prets
@staticmethod
def _stocker(dossier, mime, propre):
os.makedirs(dossier, exist_ok=True)
empreinte = hashlib.sha256(propre).hexdigest()
chemin = os.path.join(dossier, empreinte + photos.TYPES[mime])
if not os.path.exists(chemin):
with open(chemin + ".tmp", "wb") as f:
f.write(propre)
os.replace(chemin + ".tmp", chemin)
return empreinte, chemin
# --- demandes d'adhésion ---------------------------------------------
# Méthodes prévues pour être reprises telles quelles par le panneau LAN.
@property
def dossier_demandes(self):
"""Photos des demandes : hors du dossier public, servies seulement au propriétaire et à l'adjoint."""
return os.path.join(self.dossier_photos, "demandes") if self.dossier_photos else None
def demander_adhesion(self, user, message, fichiers=()):
"""Un membre demande à devenir adhérent météo : message + jusqu'à 10 photos (25 Mo). Une demande en cours à la fois."""
self._exiger(user, "demander_adhesion")
if roles.ADHERENT in self.roles_de(user):
raise Invalide("tu es déjà adhérent")
if self.con.execute("SELECT 1 FROM adhesions WHERE user_id=? AND status='en_attente'", (user["id"],)).fetchone():
raise Invalide("une demande est déjà en cours")
message = self._texte(message, ADHESION_MAX, "message")
prets = self._preparer_photos(list(fichiers)) if fichiers else []
cur = self.con.execute("INSERT INTO adhesions(user_id, message) VALUES (?, ?)", (user["id"], message))
try:
for nom, mime, propre in prets:
empreinte, chemin = self._stocker(self.dossier_demandes, mime, propre)
self.con.execute("INSERT INTO adhesion_photos(adhesion_id, filename, mime, size, sha256, stored_path)"
" VALUES (?, ?, ?, ?, ?, ?)", (cur.lastrowid, nom, mime, len(propre), empreinte, chemin))
except OSError:
self.con.rollback()
raise
self.con.commit()
return ids
return cur.lastrowid
def ma_demande_adhesion(self, user):
"""Dernière demande de cet utilisateur (ou None), pour lui afficher où elle en est."""
if user is None:
return None
return self.con.execute("SELECT * FROM adhesions WHERE user_id=? ORDER BY id DESC LIMIT 1", (user["id"],)).fetchone()
def demandes_adhesion(self, acteur, statut="en_attente"):
"""Liste des demandes (propriétaire et adjoint). statut : en_attente, acceptee, refusee ou None (toutes)."""
self._exiger(acteur, "valider_adhesion")
return self.con.execute(
"SELECT a.*, u.display_name AS pseudo, u.hub_id,"
" (SELECT COUNT(*) FROM adhesion_photos p WHERE p.adhesion_id=a.id) AS n_photos"
" FROM adhesions a JOIN users u ON u.id=a.user_id WHERE (? IS NULL OR a.status=?) ORDER BY a.id",
(statut, statut)).fetchall()
def demande_adhesion(self, acteur, demande_id):
"""Retourne (demande, photos)."""
self._exiger(acteur, "valider_adhesion")
d = self.con.execute("SELECT a.*, u.display_name AS pseudo, u.hub_id FROM adhesions a"
" JOIN users u ON u.id=a.user_id WHERE a.id=?", (demande_id,)).fetchone()
if d is None:
raise Invalide("demande introuvable")
return d, self.con.execute("SELECT * FROM adhesion_photos WHERE adhesion_id=? ORDER BY id", (demande_id,)).fetchall()
def decider_adhesion(self, acteur, demande_id, accepte):
"""Accepter donne le rôle adhérent météo ; refuser clôt la demande (une nouvelle reste possible)."""
self._exiger(acteur, "valider_adhesion")
d, _ = self.demande_adhesion(acteur, demande_id)
if d["status"] != "en_attente":
raise Invalide("demande déjà traitée")
self.con.execute("UPDATE adhesions SET status=?, decided_by=?, decided_at=datetime('now') WHERE id=?",
("acceptee" if accepte else "refusee", acteur["id"], demande_id))
if accepte:
self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, given_by) VALUES (?, ?, ?)",
(d["user_id"], roles.ADHERENT, acteur["id"]))
self.con.commit()
def photo_adhesion(self, acteur, nom):
"""Chemin d'une photo de demande, si l'acteur a le droit de la voir et qu'elle appartient à une demande."""
self._exiger(acteur, "valider_adhesion")
for r in self.con.execute("SELECT stored_path FROM adhesion_photos WHERE sha256=?", (nom.split(".")[0],)):
if os.path.basename(r["stored_path"]) == nom and os.path.isfile(r["stored_path"]):
return r["stored_path"]
raise Invalide("photo introuvable")
def _post(self, post_id):
p = self.con.execute("SELECT * FROM posts WHERE id=?", (post_id,)).fetchone()
+4 -2
Voir le fichier
@@ -27,7 +27,7 @@ ORDRE_BADGES = [PROPRIETAIRE, ADJOINT, MODERATEUR, ADHERENT, STATION, MEMBRE]
# Rôles qu'on peut donner depuis le panneau (« propriétaire » est fixé par la configuration, jamais par l'interface)
ATTRIBUABLES = (ADHERENT, MODERATEUR, ADJOINT, STATION)
# Question ouverte (04/11) : un modérateur qui n'est pas adhérent peut-il créer des sujets ? Réponse provisoire : non.
# Décision de Théo : un modérateur non adhérent ne crée PAS de sujet ; il modère et répond.
MODERATEUR_CREE_SUJETS = False
PROPRIOS = {PROPRIETAIRE, ADJOINT}
@@ -43,7 +43,9 @@ DROITS = {
"publier_bulletin": _CREATEURS, # écrire dans un sujet fermé aux réponses (Bulletin de la semaine)
"creer_sujet_station": {STATION},
"valider_sujet": PROPRIOS,
"epingler": PROPRIOS,
"epingler": PROPRIOS, # décision de Théo : pas les modérateurs
"demander_adhesion": {MEMBRE},
"valider_adhesion": PROPRIOS,
"masquer": {MODERATEUR} | PROPRIOS,
"verrouiller": {MODERATEUR} | PROPRIOS,
"voir_masques": {MODERATEUR} | PROPRIOS,
+268 -73
Voir le fichier
@@ -1,14 +1,23 @@
"""Serveur HTTP du forum de vercors.me (http.server, aucune dépendance).
AUTHENTIFICATION SIMULÉE : le cookie `forum_test` contient un identifiant de compte fictif.
Elle sera remplacée par « Se connecter avec Gastinel » (voir Documents/Meteo-Vercors/09-Forum/Plan-connexion-Gastinel.md).
À ne jamais exposer sur Internet tant que c'est le cas : le serveur n'écoute que sur 127.0.0.1.
Connexion : « Se connecter avec Gastinel » (OAuth 2 code + PKCE vers le Hub, voir connexion.py).
Session du forum : cookie `forum_session` HttpOnly Secure SameSite=Lax ; seul son haché est en base.
Lancer : python forum/server.py --seed (puis http://127.0.0.1:8940/test-login?u=theo)
Variables d'environnement :
FORUM_HUB_URL adresse du Hub (https://…), sans elle la connexion est fermée
FORUM_CLIENT_ID identifiant client déclaré au Hub (défaut : forum-vercors)
FORUM_REDIRECT_URI adresse de retour exacte déclarée au Hub (défaut : https://vercors.me/forum/connexion/retour)
FORUM_OAUTH_SECRET secret client, facultatif (ou FORUM_OAUTH_SECRET_FILE : chemin d'un fichier)
FORUM_PROPRIETAIRE_ID id Gastinel de Théo : reçoit le rôle Propriétaire à sa connexion
FORUM_RELAIS adresses de relais en plus de 127.0.0.1 dont on croit X-Forwarded-For (vide par défaut)
FORUM_MODE_TEST=1 active /test-login et --seed, et seulement depuis le LAN ou la machine elle-même
Essai local : FORUM_MODE_TEST=1 python forum/server.py --seed puis http://127.0.0.1:8940/test-login?u=theo
"""
import argparse
import email.parser
import email.policy
import hmac
import html
import json
import os
@@ -19,22 +28,28 @@ 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
from forum import EPINGLES_MAX, OCTETS_MAX, PHOTOS_MAX, Forum, Invalide, Refus # noqa: E402
from forum import EPINGLES_MAX, OCTETS_MAX, PHOTOS_MAX, SESSION_JOURS, ETAT_MINUTES, Forum, Invalide, Refus # noqa: E402
COOKIE = "forum_test"
SESSION = "forum_session"
ETAT = "forum_etat"
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)$")
CORPS_MAX_REQUETE = 30 * 1024 * 1024 # au-delà, refus (sauf propriétaires : 300 Mo)
TYPES_IMG = {"jpg": "image/jpeg", "png": "image/png", "webp": "image/webp"}
CSS = """
:root{color-scheme:light;--sapin:#1f4d3a;--mousse:#6f8f5c;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--glacier:#6eb5bd;--gris:#5d635e}
*{box-sizing:border-box;border-radius:0}
body{margin:0;min-height:100vh;display:flex;flex-direction:column;background:var(--calcaire);color:var(--roche);font:16px/1.5 Outfit,system-ui,sans-serif}
a{color:var(--sapin)}
.haut{max-width:900px;width:100%;margin:0 auto;padding:16px 24px 0;display:flex;justify-content:space-between;gap:12px;flex-wrap:wrap;align-items:baseline;font-size:12px;font-weight:600;letter-spacing:.14em;text-transform:uppercase}
.haut{max-width:900px;width:100%;margin:0 auto;padding:16px 16px 0;display:flex;justify-content:space-between;gap:10px;flex-wrap:wrap;align-items:center;font-size:12px;font-weight:600;letter-spacing:.14em;text-transform:uppercase}
.haut a{color:var(--gris);text-decoration:none}.haut .nom{color:var(--sapin);font-size:15px;letter-spacing:.22em}
main{flex:1 0 auto;width:100%;max-width:900px;margin:0 auto;padding:16px 24px 48px}
.haut .moi{display:flex;flex-wrap:wrap;gap:4px 12px;align-items:center}
.haut form{margin:0}.haut form button{font-size:12px;padding:2px 8px;letter-spacing:.08em;text-transform:uppercase}
main{flex:1 0 auto;width:100%;max-width:900px;margin:0 auto;padding:16px 16px 48px}
h1{font-family:Bitter,Georgia,serif;color:var(--sapin);font-size:38px;line-height:1.05;margin:8px 0 8px}
h2{font-family:Bitter,Georgia,serif;color:var(--sapin);font-size:21px;margin:30px 0 10px}
.chapeau,.meta{color:var(--gris);font-size:14px}
@@ -44,12 +59,17 @@ h2{font-family:Bitter,Georgia,serif;color:var(--sapin);font-size:21px;margin:30p
.sujets a{font-family:Bitter,Georgia,serif;font-weight:600;font-size:17px;text-decoration:none}
.sujets .epingle a::before{content:"\\25A0 ";color:var(--sapin);font-size:12px}
.sujets .attente{opacity:.7}
.badge{display:inline-block;margin:0 4px 2px 0;padding:0 7px;font-size:10.5px;font-weight:600;letter-spacing:.07em;text-transform:uppercase;border:1px solid;vertical-align:1px;white-space:nowrap}
.b-proprietaire,.b-proprietaire_adjoint{background:var(--sapin);border-color:var(--sapin);color:#fff}
.b-moderateur{background:#000;border-color:#000;color:#fff}
.b-proprietaire_station{background:rgba(110,181,189,.18);border-color:var(--glacier);color:#2f6f78}
.b-adherent{background:rgba(111,143,92,.16);border-color:var(--mousse);color:var(--sapin)}
.badge{display:inline-flex;align-items:center;gap:4px;margin:0 4px 3px 0;padding:1px 6px;font-size:10.5px;font-weight:600;letter-spacing:.07em;text-transform:uppercase;border:1px solid;max-width:100%}
.badge svg{width:12px;height:12px;flex:none}
.b-proprietaire,.b-proprietaire_adjoint{background:#fff;border-color:var(--sapin);color:var(--sapin)}
.b-moderateur{background:#fff;border-color:var(--roche);color:var(--roche)}
.b-proprietaire_station{background:#fff;border-color:var(--glacier);color:#2f6f78}
.b-adherent{background:#fff;border-color:var(--mousse);color:#4d6a3e}
.b-membre{background:#fff;border-color:#b9b5aa;color:var(--gris)}
.gastinel{display:inline-flex;align-items:center;gap:10px;background:var(--sapin);color:#fff!important;text-decoration:none;font-weight:600;padding:8px 14px 8px 8px;border:1px solid var(--sapin);letter-spacing:.02em;text-transform:none;font-size:15px}
.gastinel .g{display:inline-flex;width:26px;height:26px;align-items:center;justify-content:center;background:#fff;color:var(--sapin);font-family:Bitter,Georgia,serif;font-weight:700}
.gastinel:hover,.gastinel:focus-visible{background:#163a2b}
.haut .gastinel{font-size:13px;padding:4px 10px 4px 4px;gap:8px;color:#fff}.haut .gastinel .g{width:20px;height:20px}
.msg{display:grid;grid-template-columns:170px 1fr;border-top:1px solid var(--roche)}
.msg:last-of-type{border-bottom:1px solid var(--roche)}
.msg aside{padding:14px 10px 14px 4px;font-size:13px}.msg aside b{display:block;font-family:Bitter,Georgia,serif;font-size:16px}
@@ -57,24 +77,54 @@ h2{font-family:Bitter,Georgia,serif;color:var(--sapin);font-size:21px;margin:30p
.msg.cache{opacity:.55}
.galerie{display:flex;flex-wrap:wrap;gap:6px;margin-top:10px}.galerie img{width:150px;height:110px;object-fit:cover;border:1px solid var(--pierre)}
form{margin:14px 0}label{display:block;margin:8px 0 3px;font-size:14px}
input,select,textarea,button{font:inherit;border:1px solid var(--roche);padding:7px 9px;background:#fff;color:var(--roche)}
input,select,textarea,button{font:inherit;border:1px solid var(--roche);padding:7px 9px;background:#fff;color:var(--roche);max-width:100%}
textarea{width:100%;min-height:120px}input[type=text]{width:100%}
button{cursor:pointer;border-color:var(--sapin);color:var(--sapin);font-weight:600}button:hover{background:var(--sapin);color:#fff}
.bouton{display:inline-block;border:1px solid var(--sapin);padding:7px 12px;font-weight:600;text-decoration:none;background:#fff}
.boite{padding:14px 16px;border:1px solid var(--roche);background:#faf9f5;margin:18px 0}
form.inline{display:inline;margin:0 6px 0 0}form.inline button{font-size:12px;padding:3px 8px}
table{border-collapse:collapse;width:100%;font-size:14px}td,th{border:1px solid var(--pierre);padding:6px 8px;text-align:left;vertical-align:top}
.pied{background:#303336;color:#d1d3d6;padding:20px 24px;font-size:13px}.pied a{color:#b9c2cc}
@media (max-width:640px){h1{font-size:30px}.msg{grid-template-columns:1fr}.msg .corps{border-left:0;border-top:1px solid var(--pierre);padding-left:4px}}
.pied{background:#303336;color:#d1d3d6;padding:20px 16px;font-size:13px}.pied a{color:#b9c2cc}
@media (max-width:640px){h1{font-size:30px}.msg{grid-template-columns:1fr}.msg .corps{border-left:0;border-top:1px solid var(--pierre);padding-left:4px}
.galerie img{width:calc(50% - 3px);height:100px}}
"""
# Badges : pictogrammes sobres (trait 1,5, angles vifs), couleur du texte du badge. Membre reste en texte seul.
_PICTOS = {
roles.PROPRIETAIRE: "<path d='M2 13h12V5l-3 3-3-5-3 5-3-3z' fill='currentColor'/>",
roles.ADJOINT: "<path d='M2.75 12.25h10.5V6.8L11 9 8 4.4 5 9 2.75 6.8z' fill='none' stroke='currentColor' stroke-width='1.5'/>",
roles.MODERATEUR: "<path d='M8 1.8l5.2 1.9v4.1c0 3.2-2.2 5.4-5.2 6.4-3-1-5.2-3.2-5.2-6.4V3.7z' fill='none' stroke='currentColor' stroke-width='1.5'/>",
roles.ADHERENT: "<path d='M8 1.5v13M2.4 4.75l11.2 6.5M2.4 11.25l11.2-6.5' stroke='currentColor' stroke-width='1.5'/>",
roles.STATION: "<path d='M8 14.5V4M3 4h10M5 14.5h6' stroke='currentColor' stroke-width='1.5'/>"
"<rect x='1' y='2' width='3.5' height='3.5' fill='currentColor'/><rect x='11.5' y='2' width='3.5' height='3.5' fill='currentColor'/>",
}
def e(s):
return html.escape(str(s), quote=True)
def badge(role, libelle):
"""Badge d'un rôle : pictogramme SVG en ligne avec texte alternatif + libellé visible (lu une seule fois)."""
picto = _PICTOS.get(role)
if not picto:
return "<span class='badge b-%s'>%s</span>" % (e(role), e(libelle))
return ("<span class='badge b-%s'><svg viewBox='0 0 16 16' role='img' aria-label='%s' focusable='false'>"
"<title>%s</title>%s</svg><span aria-hidden='true'>%s</span></span>"
% (e(role), e(libelle), e(libelle), picto, e(libelle)))
BOUTON_GASTINEL = "<a class='gastinel' href='/connexion/gastinel'><span class='g' aria-hidden='true'>G</span>Se connecter avec Gastinel</a>"
class App:
def __init__(self, forum):
def __init__(self, forum, reglages):
self.forum = forum
self.reglages = reglages
def _cookie(nom, valeur, age):
return ("Set-Cookie", "%s=%s; Path=/; Max-Age=%d; HttpOnly; Secure; SameSite=Lax" % (nom, valeur, age))
class Handler(BaseHTTPRequestHandler):
@@ -85,15 +135,26 @@ class Handler(BaseHTTPRequestHandler):
pass
# --- outils ---------------------------------------------------------
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 utilisateur(self):
c = cookies.SimpleCookie(self.headers.get("Cookie", ""))
if COOKIE in c and ID_OK.match(c[COOKIE].value):
try:
return self.app.forum.utilisateur(c[COOKIE].value)
except Invalide:
return None
jeton = self.cookie(SESSION)
if jeton and JETON_OK.match(jeton):
return self.app.forum.utilisateur_de_session(jeton)
return None
def ip(self):
return connexion.ip_client(self.client_address[0], self.headers.get("X-Forwarded-For"), self.app.reglages.relais)
def essai_permis(self):
"""/test-login : seulement si FORUM_MODE_TEST=1 ET depuis le LAN ou la machine elle-même."""
return self.app.reglages.mode_test and connexion.est_locale(self.ip())
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)
@@ -111,35 +172,43 @@ class Handler(BaseHTTPRequestHandler):
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 badges(self, user_id):
return "".join("<span class='badge b-%s'>%s</span>" % (r, e(lib)) for r, lib in self.app.forum.badges(user_id))
return "".join(badge(r, lib) for r, lib in self.app.forum.badges(user_id))
def page(self, titre, contenu, user, code=200):
def page(self, titre, contenu, user, code=200, extra=()):
f = self.app.forum
if user is None:
qui = "<a href='/test-login?u=theo'>Se connecter (essai)</a>"
qui = BOUTON_GASTINEL
if self.essai_permis():
qui += " <a href='/test-login?u=theo'>Essai</a>"
else:
rs = f.roles_de(user)
liens = ""
if roles.peut(f.roles_de(user), "valider_sujet"):
liens += " &nbsp; <a href='/validation'>À valider</a> &nbsp; <a href='/roles'>Rôles</a>"
if roles.peut(f.roles_de(user), "voir_signalements"):
liens += " &nbsp; <a href='/moderation'>Modération</a>"
qui = "%s%s &nbsp; <a href='/test-logout'>Sortir</a>" % (e(user["display_name"]), liens)
if roles.peut(rs, "valider_sujet"):
liens += "<a href='/validation'>À valider</a><a href='/roles'>Rôles</a>"
if roles.peut(rs, "valider_adhesion"):
liens += "<a href='/adhesions'>Adhésions</a>"
if roles.peut(rs, "voir_signalements"):
liens += "<a href='/moderation'>Modération</a>"
qui = ("<span class='moi'><span>%s</span>%s<form method='post' action='/deconnexion'><button>Sortir</button></form></span>"
% (e(user["display_name"]), liens))
essai = ("<p class='essai'>Mode essai : connexion simulée possible depuis le réseau local.</p>"
if self.app.reglages.mode_test else "")
corps = ("<!doctype html><html lang='fr'><head><meta charset='utf-8'>"
"<meta name='viewport' content='width=device-width,initial-scale=1'>"
"<title>%s · Forum Météo Vercors</title><style>%s</style></head><body>"
"<div class='haut'><a class='nom' href='/'>Forum</a><span>%s</span></div><main>"
"<p class='essai'>Essai local : connexion simulée, remplacée par le compte Gastinel avant l'ouverture.</p>%s</main>"
"<footer class='pied'>Forum Météo Vercors · vercors.me</footer></body></html>" % (e(titre), CSS, qui, contenu))
self.envoyer(code, corps)
"<div class='haut'><a class='nom' href='/'>Forum</a>%s</div><main>%s%s</main>"
"<footer class='pied'>Forum Météo Vercors · vercors.me</footer></body></html>" % (e(titre), CSS, qui, essai, contenu))
self.envoyer(code, corps, extra=extra)
def erreur(self, user, code, msg):
self.page("Erreur", "<h1>%s</h1><p><a href='/'>Retour au forum</a></p>" % e(msg), user, code)
def erreur(self, user, code, msg, extra=()):
self.page("Erreur", "<h1>%s</h1><p><a href='/'>Retour au forum</a></p>" % e(msg), user, code, extra)
def origine_ok(self):
o = self.headers.get("Origin") or self.headers.get("Referer") or ""
@@ -176,6 +245,42 @@ class Handler(BaseHTTPRequestHandler):
champs[nom] = data.decode("utf-8", "replace")
return champs, fichiers
# --- 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 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), [_cookie(ETAT, etat, ETAT_MINUTES * 60)])
def connexion_retour(self, q):
f, r = self.app.forum, self.app.reglages
efface = _cookie(ETAT, "", 0)
if not r.configuree:
return self.erreur(None, 503, "La connexion avec Gastinel n'est pas encore ouverte")
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) # usage unique, 10 minutes au plus
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])
user = f.connexion_gastinel(ident, pseudo)
ancien = self.cookie(SESSION)
if ancien:
f.fermer_session(ancien)
self.rediriger("/", [efface, _cookie(SESSION, f.ouvrir_session(user), SESSION_JOURS * 86400)])
# --- pages ------------------------------------------------------------
def liste(self, user):
f = self.app.forum
@@ -190,22 +295,27 @@ class Handler(BaseHTTPRequestHandler):
"<span class='meta'>%d message%s</span></li>"
% (cls, t["id"], e(t["title"]), e(t["auteur"]), etat, t["n"], "s" if t["n"] > 1 else ""))
out = ["<h1>Forum</h1><p class='chapeau'>Le coin des gens du Vercors. Les sujets épinglés sont en tête "
"(%d au plus), le Bulletin de la semaine toujours en premier.</p>" % EPINGLES_MAX,
"<ul class='sujets'>%s</ul>" % "".join(items)]
"(%d au plus), le Bulletin de la semaine toujours en premier.</p>" % EPINGLES_MAX]
if user is None:
out.append("<div class='boite'><p style='margin-top:0'>Pour répondre, connecte-toi avec ton compte Gastinel.</p>"
"<p>%s</p><p class='meta' style='margin-bottom:0'>Le forum reçoit seulement ton pseudo et un identifiant, "
"jamais ton mot de passe ni ton e-mail. Pas de publicité.</p></div>" % BOUTON_GASTINEL)
out.append("<ul class='sujets'>%s</ul>" % "".join(items))
if roles.peut(rs, "creer_sujet"):
out.append("<div class='boite'><h2 style='margin-top:0'>Nouveau sujet</h2><form method='post' action='/sujet'>"
"<label>Titre</label><input type='text' name='titre' maxlength='150' required>"
"<label>Message</label><textarea name='corps' required></textarea><button>Publier</button></form></div>")
"<label for='titre'>Titre</label><input type='text' id='titre' name='titre' maxlength='150' required>"
"<label for='corps'>Message</label><textarea id='corps' name='corps' required></textarea><button>Publier</button></form></div>")
stations = sorted(f.stations_de(user))
if roles.peut(rs, "creer_sujet_station") and stations:
opts = "".join("<option value='%s'>%s</option>" % (e(s), e(f.stations.get(s, s))) for s in stations)
out.append("<div class='boite'><h2 style='margin-top:0'>Sujet de ma station</h2>"
"<p class='meta'>Un sujet par station, titre préconfiguré, publié après validation.</p>"
"<form method='post' action='/station'><label>Station</label><select name='station'>%s</select>"
"<label>Présentation</label><textarea name='corps' required></textarea>"
"<form method='post' action='/station'><label for='station'>Station</label><select id='station' name='station'>%s</select>"
"<label for='pres'>Présentation</label><textarea id='pres' name='corps' required></textarea>"
"<button>Envoyer pour validation</button></form></div>" % opts)
if user is not None and not roles.peut(rs, "creer_sujet"):
out.append("<p class='meta'>En tant que membre, tu réponds dans les sujets existants.</p>")
out.append("<p class='meta'>En tant que membre, tu réponds dans les sujets existants. "
"Les adhérents météo ouvrent les sujets.</p><p><a class='bouton' href='/adhesion'>Demander à devenir adhérent</a></p>")
self.page("Forum", "".join(out), user)
def sujet(self, user, tid):
@@ -247,16 +357,60 @@ class Handler(BaseHTTPRequestHandler):
if peut_ecrire:
limite = "" if roles.peut(rs, "photos_illimitees") else " (%d photos et %d Mo au plus par message)" % (PHOTOS_MAX, OCTETS_MAX // 1048576)
out.append("<div class='boite'><h2 style='margin-top:0'>%s</h2><form method='post' action='/repondre' enctype='multipart/form-data'>"
"<input type='hidden' name='sujet' value='%d'><textarea name='corps' required></textarea>"
"<label>Photos%s</label><input type='file' name='photos' accept='image/jpeg,image/png,image/webp' multiple>"
"<input type='hidden' name='sujet' value='%d'><textarea name='corps' aria-label='Message' required></textarea>"
"<label for='photos'>Photos%s</label><input type='file' id='photos' name='photos' accept='image/jpeg,image/png,image/webp' multiple>"
"<p class='meta'>La position GPS et les infos de l'appareil sont retirées des photos.</p>"
"<button>Envoyer</button></form></div>" % ("Publier" if not t["replies_open"] else "Répondre", tid, limite))
elif not t["replies_open"] and t["fixed"]:
out.append("<p class='meta'>Le Bulletin de la semaine est publié par les adhérents météo ; pas de réponses ici. Les réactions arrivent bientôt.</p>")
elif user is None:
out.append("<p class='meta'>Connecte-toi avec ton compte Gastinel pour répondre.</p>")
out.append("<div class='boite'><p style='margin-top:0'>Connecte-toi pour répondre.</p>%s</div>" % BOUTON_GASTINEL)
self.page(t["title"], "".join(out), user)
def adhesion(self, user):
f = self.app.forum
if user is None:
return self.page("Devenir adhérent", "<h1>Devenir adhérent météo</h1><div class='boite'>"
"<p style='margin-top:0'>Connecte-toi d'abord avec ton compte Gastinel.</p>%s</div>" % BOUTON_GASTINEL, None)
out = ["<p class='meta'><a href='/'>Forum</a> › adhésion</p><h1>Devenir adhérent météo</h1>"
"<p class='chapeau'>Les adhérents ouvrent des sujets et publient le Bulletin de la semaine. "
"C'est gratuit : présente-toi, montre tes photos ou ce que tu observes, le propriétaire te répond.</p>"]
if roles.ADHERENT in f.roles_de(user):
out.append("<p>Tu es déjà adhérent météo.</p>")
return self.page("Devenir adhérent", "".join(out), user)
d = f.ma_demande_adhesion(user)
if d is not None and d["status"] == "en_attente":
out.append("<div class='boite'>Ta demande du %s est en attente de réponse.</div>" % e(d["created_at"][:10]))
return self.page("Devenir adhérent", "".join(out), user)
if d is not None and d["status"] == "refusee":
out.append("<p class='meta'>Ta demande précédente n'a pas été retenue ; tu peux en refaire une.</p>")
out.append("<div class='boite'><form method='post' action='/adhesion' enctype='multipart/form-data'>"
"<label for='message'>Ton message</label><textarea id='message' name='message' maxlength='4000' required></textarea>"
"<label for='photos'>Photos (%d au plus, %d Mo en tout)</label>"
"<input type='file' id='photos' name='photos' accept='image/jpeg,image/png,image/webp' multiple>"
"<p class='meta'>La position GPS et les infos de l'appareil sont retirées. Seuls le propriétaire et son adjoint voient ces photos.</p>"
"<button>Demander à devenir adhérent</button></form></div>" % (PHOTOS_MAX, OCTETS_MAX // 1048576))
self.page("Devenir adhérent", "".join(out), user)
def adhesions(self, user):
f = self.app.forum
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)
blocs.append("<div class='boite'><b>%s</b> %s<br><span class='meta'>%s · %s</span>"
"<div class='corps' style='white-space:pre-wrap;margin-top:8px'>%s</div>%s<p style='margin-bottom:0'>"
"<form class='inline' method='post' action='/adhesion/decider'><input type='hidden' name='demande' value='%d'>"
"<input type='hidden' name='ok' value='1'><button>Accepter</button></form>"
"<form class='inline' method='post' action='/adhesion/decider'><input type='hidden' name='demande' value='%d'>"
"<input type='hidden' name='ok' value='0'><button>Refuser</button></form></p></div>"
% (e(d["pseudo"]), self.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 "", d["id"], d["id"]))
self.page("Adhésions", "<h1>Demandes d'adhésion</h1><p class='chapeau'>Provisoire : reprise plus tard par le panneau LAN.</p>%s"
% ("".join(blocs) or "<p>Aucune demande en attente.</p>"), user)
def validation(self, user):
f = self.app.forum
lignes = "".join("<tr><td><a href='/t/%d'>%s</a></td><td>%s</td><td>"
@@ -277,9 +431,9 @@ class Handler(BaseHTTPRequestHandler):
% (e(u["display_name"]), e(u["hub_id"]), self.badges(u["id"])) for u in users)
opts = "".join("<option value='%s'>%s</option>" % (r, e(roles.LIBELLES[r])) for r in roles.ATTRIBUABLES)
st = "".join("<option value='%s'>%s</option>" % (e(k), e(v)) for k, v in sorted(f.stations.items(), key=lambda x: x[1]))
form = ("<div class='boite'><form method='post' action='/role'><label>Compte (identifiant)</label>"
"<input type='text' name='hub_id' required><label>Rôle</label><select name='role'>%s</select>"
"<label>Station (pour « propriétaire de station »)</label><select name='station'><option value=''>—</option>%s</select>"
form = ("<div class='boite'><form method='post' action='/role'><label for='hub_id'>Compte (identifiant)</label>"
"<input type='text' id='hub_id' name='hub_id' required><label for='role'>Rôle</label><select id='role' name='role'>%s</select>"
"<label for='st'>Station (pour « propriétaire de station »)</label><select id='st' name='station'><option value=''>—</option>%s</select>"
"<p><button name='action' value='donner'>Donner</button> <button name='action' value='retirer'>Retirer</button></p></form></div>"
% (opts, st))
self.page("Rôles", "<h1>Rôles</h1><p class='chapeau'>Provisoire : la gestion quotidienne se fera dans le panneau LAN.</p>"
@@ -291,14 +445,22 @@ class Handler(BaseHTTPRequestHandler):
% (r["post_id"], r["topic_id"], e(r["reason"]), e(r["body"][:200])) for r in s)
self.page("Modération", "<h1>Signalements</h1><ul class='sujets'>%s</ul>" % (items or "<li>Aucun signalement.</li>"), user)
def fichier_image(self, chemin, nom, public=True):
cache = "public, max-age=31536000, immutable" if public else "private, no-store"
with open(chemin, "rb") as fh:
self.envoyer(200, fh.read(), TYPES_IMG[nom.rsplit(".", 1)[1]], [("Cache-Control", cache)])
def photo(self, nom):
dossier = self.app.forum.dossier_photos
chemin = os.path.join(dossier or "", nom)
if not dossier or not PHOTO_OK.match(nom) or not os.path.isfile(chemin):
return self.envoyer(404, "introuvable", "text/plain; charset=utf-8")
types = {"jpg": "image/jpeg", "png": "image/png", "webp": "image/webp"}
with open(chemin, "rb") as fh:
self.envoyer(200, fh.read(), types[nom.rsplit(".", 1)[1]], [("Cache-Control", "public, max-age=31536000, immutable")])
self.fichier_image(chemin, nom)
def photo_adhesion(self, user, nom):
if not PHOTO_OK.match(nom):
return self.envoyer(404, "introuvable", "text/plain; charset=utf-8")
self.fichier_image(self.app.forum.photo_adhesion(user, nom), nom, public=False)
# --- GET --------------------------------------------------------------
def do_GET(self):
@@ -306,14 +468,18 @@ class Handler(BaseHTTPRequestHandler):
user = self.utilisateur()
f = self.app.forum
try:
if u.path == "/connexion/gastinel":
return self.connexion_depart(user)
if u.path == "/connexion/retour":
return self.connexion_retour(parse_qs(u.query))
if u.path == "/test-login":
if not self.essai_permis():
return self.erreur(user, 404, "Page introuvable")
qui = parse_qs(u.query).get("u", [""])[0]
if not ID_OK.match(qui) or qui == "systeme":
return self.erreur(user, 400, "Identifiant d'essai invalide")
f.utilisateur(qui)
return self.rediriger("/", [("Set-Cookie", "%s=%s; Path=/; HttpOnly; SameSite=Strict" % (COOKIE, qui))])
if u.path == "/test-logout":
return self.rediriger("/", [("Set-Cookie", COOKIE + "=; Path=/; Max-Age=0")])
jeton = f.ouvrir_session(f.utilisateur(qui))
return self.rediriger("/", [_cookie(SESSION, jeton, SESSION_JOURS * 86400)])
if u.path == "/":
return self.liste(user)
m = re.fullmatch(r"/t/(\d+)", u.path)
@@ -322,6 +488,13 @@ class Handler(BaseHTTPRequestHandler):
m = re.fullmatch(r"/photo/([^/]+)", u.path)
if m:
return self.photo(m.group(1))
m = re.fullmatch(r"/adhesion-photo/([^/]+)", u.path)
if m:
return self.photo_adhesion(user, m.group(1))
if u.path == "/adhesion":
return self.adhesion(user)
if u.path == "/adhesions":
return self.adhesions(user)
if u.path == "/validation":
return self.validation(user)
if u.path == "/roles":
@@ -340,8 +513,13 @@ class Handler(BaseHTTPRequestHandler):
f = self.app.forum
if not self.origine_ok():
return self.erreur(user, 403, "Origine refusée")
ip = self.client_address[0]
ip = self.ip()
try:
if self.path == "/deconnexion":
jeton = self.cookie(SESSION)
if jeton:
f.fermer_session(jeton)
return self.rediriger("/", [_cookie(SESSION, "", 0)])
if user is None:
raise Refus("connexion requise")
d, fichiers = self.lire_formulaire(user)
@@ -355,6 +533,12 @@ class Handler(BaseHTTPRequestHandler):
if fichiers:
f.ajouter_photos(user, pid, fichiers)
return self.rediriger("/t/%d" % tid)
if self.path == "/adhesion":
f.demander_adhesion(user, d.get("message"), fichiers)
return self.rediriger("/adhesion")
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("/validation")
@@ -383,8 +567,8 @@ class Handler(BaseHTTPRequestHandler):
self.erreur(user, 400, str(ex))
def creer_serveur(forum, port=0, hote="127.0.0.1"):
h = type("H", (Handler,), {"app": App(forum)})
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)
@@ -402,27 +586,38 @@ def charger_stations():
return {}
def semer(f):
"""Comptes d'essai (mode test seulement)."""
theo = f.fixer_proprietaire("theo", "Théo")
for hub_id, nom, rs in (("pere", "Richard", [(roles.ADJOINT, ""), (roles.MODERATEUR, "")]),
("adherent1", "Adhérent d'essai", [(roles.ADHERENT, "")]),
("modo1", "Modérateur d'essai", [(roles.MODERATEUR, "")]),
("station1", "Propriétaire d'essai", [(roles.STATION, sorted(f.stations)[0])]),
("membre1", "Membre d'essai", [])):
f.utilisateur(hub_id, nom)
for r, st in rs:
f.donner_role(theo, hub_id, r, st)
def main():
ici = os.path.dirname(os.path.abspath(__file__))
ap = argparse.ArgumentParser()
ap.add_argument("--db", default=os.path.join(ici, "forum-local.sqlite3"))
ap.add_argument("--photos", default=os.path.join(ici, "photos-local"))
ap.add_argument("--port", type=int, default=8940)
ap.add_argument("--seed", action="store_true", help="comptes d'essai : theo (propriétaire), pere, adherent1, modo1, station1, membre1")
ap.add_argument("--seed", action="store_true", help="comptes d'essai (FORUM_MODE_TEST=1 exigé) : theo, pere, adherent1, modo1, station1, membre1")
a = ap.parse_args()
f = Forum(a.db, stations=charger_stations() or {"geve": "Gêve"}, dossier_photos=a.photos)
reglages = connexion.Reglages.depuis_env()
if a.seed and not reglages.mode_test:
sys.exit("--seed refusé : comptes d'essai seulement avec FORUM_MODE_TEST=1")
f = Forum(a.db, stations=charger_stations() or {"geve": "Gêve"}, dossier_photos=a.photos,
proprietaire_id=os.environ.get("FORUM_PROPRIETAIRE_ID"))
if a.seed:
theo = f.fixer_proprietaire("theo", "Théo")
for hub_id, nom, rs in (("pere", "Richard", [(roles.ADJOINT, ""), (roles.MODERATEUR, "")]),
("adherent1", "Adhérent d'essai", [(roles.ADHERENT, "")]),
("modo1", "Modérateur d'essai", [(roles.MODERATEUR, "")]),
("station1", "Propriétaire d'essai", [(roles.STATION, sorted(f.stations)[0])]),
("membre1", "Membre d'essai", [])):
f.utilisateur(hub_id, nom)
for r, st in rs:
f.donner_role(theo, hub_id, r, st)
s = creer_serveur(f, a.port)
print("Forum local (connexion SIMULÉE) : http://127.0.0.1:%d/test-login?u=theo" % a.port)
semer(f)
s = creer_serveur(f, a.port, reglages=reglages)
print("Forum : http://127.0.0.1:%d (connexion Gastinel %s%s)" % (
a.port, "configurée" if reglages.configuree else "NON configurée : FORUM_HUB_URL manquant",
" ; mode essai : /test-login?u=theo" if reglages.mode_test else ""))
s.serve_forever()
Voir le fichier
Seulement les espaces.
+344 -12
Voir le fichier
@@ -1,15 +1,28 @@
"""Tests du forum (rôles cumulables, sujets, Bulletin, sujets de station, photos). python -I forum/tests/test_forum.py"""
"""Tests du forum (rôles, sujets, Bulletin, stations, photos, connexion Gastinel simulée, adhésions).
python -m unittest discover -s forum/tests (ou python -I forum/tests/test_forum.py)
"""
import hashlib
import http.client
import json
import os
import shutil
import struct
import subprocess
import sys
import tempfile
import threading
import unittest
import zlib
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, urlparse
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
ICI = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
sys.path.insert(0, ICI)
import connexion # noqa: E402
import photos # noqa: E402
import roles # noqa: E402
import server # noqa: E402
from forum import EPINGLES_MAX, Forum, Invalide, Refus # noqa: E402
STATIONS = {"geve": "Gêve", "oscence": "Combe de l'Oscence"}
@@ -206,34 +219,84 @@ class TestModeration(Base):
self.assertEqual(self.f.purger_ips(), 1)
class TestHTTP(Base):
class FauxHub(BaseHTTPRequestHandler):
"""Hub simulé : /oauth/jeton (vérifie PKCE S256, code à usage unique) et /oauth/moi."""
codes = {} # code -> (code_challenge, client_id, redirect_uri, profil)
jetons = {} # jeton -> profil
def log_message(self, *a):
pass
def repondre(self, code, d):
data = json.dumps(d).encode()
self.send_response(code)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
def do_POST(self):
if self.path != "/oauth/jeton":
return self.repondre(404, {})
f = {k: v[0] for k, v in parse_qs(self.rfile.read(int(self.headers["Content-Length"])).decode()).items()}
entree = self.codes.pop(f.get("code"), None) # usage unique
if (entree is None or f.get("grant_type") != "authorization_code"
or (f.get("client_id"), f.get("redirect_uri")) != entree[1:3]
or connexion._b64(hashlib.sha256(f.get("code_verifier", "").encode()).digest()) != entree[0]):
return self.repondre(400, {"error": "invalid_grant"})
jeton = "jeton-%d" % len(self.jetons)
self.jetons[jeton] = entree[3]
self.repondre(200, {"access_token": jeton, "token_type": "Bearer", "expires_in": 3600})
def do_GET(self):
jeton = self.headers.get("Authorization", "")[7:]
if self.path != "/oauth/moi" or jeton not in self.jetons:
return self.repondre(401, {})
self.repondre(200, self.jetons[jeton])
class BaseHTTP(Base):
def setUp(self):
super().setUp()
import threading
import server
self.hub = ThreadingHTTPServer(("127.0.0.1", 0), type("Hub", (FauxHub,), {"codes": {}, "jetons": {}}))
threading.Thread(target=self.hub.serve_forever, daemon=True).start()
self.srv = server.creer_serveur(self.f, 0)
self.port = self.srv.server_address[1]
self.reglages = connexion.Reglages(hub_url="http://127.0.0.1:%d" % self.hub.server_address[1],
redirect_uri="http://127.0.0.1:%d/connexion/retour" % self.port,
mode_test=True)
self.srv.RequestHandlerClass.app.reglages = self.reglages
threading.Thread(target=self.srv.serve_forever, daemon=True).start()
self.sessions = {}
def tearDown(self):
self.srv.shutdown()
self.srv.server_close()
for s in (self.srv, self.hub):
s.shutdown()
s.server_close()
super().tearDown()
def req(self, chemin, qui=None, corps=None, ct=None, origine=True):
import http.client
def session(self, qui):
if qui not in self.sessions:
self.sessions[qui] = self.f.ouvrir_session(self.f.utilisateur(qui))
return "forum_session=" + self.sessions[qui]
def req(self, chemin, qui=None, corps=None, ct=None, origine=True, cookie=None, entetes=None):
c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10)
h = {}
h = dict(entetes or {})
if qui:
h["Cookie"] = "forum_test=" + qui
h["Cookie"] = self.session(qui)
if cookie is not None:
h["Cookie"] = cookie
if corps is not None:
h["Content-Type"] = ct or "application/x-www-form-urlencoded"
if origine:
h["Origin"] = "http://127.0.0.1:%d" % self.port
c.request("POST" if corps is not None else "GET", chemin, body=corps, headers=h)
r = c.getresponse()
return r.status, dict(r.getheaders()), r.read()
return r.status, r.headers, r.read()
class TestHTTP(BaseHTTP):
def test_liste_visiteur(self):
st, h, b = self.req("/")
self.assertEqual(st, 200)
@@ -268,6 +331,275 @@ class TestHTTP(Base):
st, _, _ = self.req("/photo/../../etc/passwd")
self.assertEqual(st, 404)
def test_badges_svg_avec_texte_alternatif(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.repondre(self.pere, t, "réponse")
self.f.repondre(self.prop, t, "ma station")
b = self.req("/t/%d" % t)[2].decode()
for lib in ("Adhérent météo", "Propriétaire adjoint", "Modérateur", "Propriétaire de station · Gêve"):
self.assertIn("role='img' aria-label='%s'" % lib, b)
self.assertIn("<title>%s</title>" % lib, b)
self.assertIn("aria-label='Propriétaire'", server.badge(roles.PROPRIETAIRE, "Propriétaire"))
self.assertNotIn("<script", b)
def test_moderateur_sans_bouton_epingler(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.assertNotIn("action='/epingler'", self.req("/t/%d" % t, "mo1")[2].decode())
self.assertIn("action='/epingler'", self.req("/t/%d" % t, "pere")[2].decode())
st, _, _ = self.req("/epingler", "mo1", ("sujet=%d&etat=1" % t).encode())
self.assertEqual(st, 403)
class TestConnexionGastinel(BaseHTTP):
def depart(self):
st, h, _ = self.req("/connexion/gastinel")
self.assertEqual(st, 303)
loc = urlparse(h["Location"])
q = {k: v[0] for k, v in parse_qs(loc.query).items()}
self.assertEqual(loc.path, "/oauth/autoriser")
self.assertEqual((q["response_type"], q["client_id"], q["code_challenge_method"]), ("code", "forum-vercors", "S256"))
self.assertEqual(q["redirect_uri"], self.reglages.redirect_uri)
cookie = [c for c in h.get_all("Set-Cookie") if c.startswith("forum_etat=")][0]
for attr in ("HttpOnly", "Secure", "SameSite=Lax"):
self.assertIn(attr, cookie)
return q["state"], q["code_challenge"]
def hub_accepte(self, code, challenge, profil):
self.hub.RequestHandlerClass.codes[code] = (challenge, "forum-vercors", self.reglages.redirect_uri, profil)
def retour(self, etat, code="c1", cookie_etat=None):
cookie = "forum_etat=" + (etat if cookie_etat is None else cookie_etat)
return self.req("/connexion/retour?code=%s&state=%s" % (code, etat), cookie=cookie)
@staticmethod
def jeton_session(h):
for c in h.get_all("Set-Cookie") or []:
if c.startswith("forum_session=") and not c.startswith("forum_session=;"):
return c.split(";")[0].split("=", 1)[1], c
return None, None
def test_connexion_complete(self):
etat, ch = self.depart()
self.hub_accepte("c1", ch, {"id": "g-42", "pseudo": "Lucie"})
st, h, _ = self.retour(etat)
self.assertEqual(st, 303)
jeton, cookie = self.jeton_session(h)
self.assertIsNotNone(jeton)
for attr in ("HttpOnly", "Secure", "SameSite=Lax", "Path=/"):
self.assertIn(attr, cookie)
u = self.f.con.execute("SELECT * FROM users WHERE hub_id='g-42'").fetchone()
self.assertEqual(u["display_name"], "Lucie")
stocke = self.f.con.execute("SELECT id_hache FROM sessions WHERE user_id=?", (u["id"],)).fetchone()[0]
self.assertEqual(stocke, hashlib.sha256(jeton.encode()).hexdigest()) # seul le haché est en base
b = self.req("/", cookie="forum_session=" + jeton)[2].decode()
self.assertIn("Lucie", b)
self.assertIn("action='/deconnexion'", b)
# nouvelle connexion : le pseudo suit le compte Gastinel, le state précédent ne resert pas
st, _, _ = self.retour(etat)
self.assertEqual(st, 400)
etat2, ch2 = self.depart()
self.hub_accepte("c2", ch2, {"id": "g-42", "pseudo": "Lucie V."})
self.retour(etat2, "c2")
self.assertEqual(self.f.utilisateur("g-42")["display_name"], "Lucie V.")
def test_proprietaire_par_variable(self):
self.f.proprietaire_id = "g-theo"
for code, ident in (("c1", "g-theo"), ("c2", "g-autre")):
etat, ch = self.depart()
self.hub_accepte(code, ch, {"id": ident, "pseudo": ident})
self.assertEqual(self.retour(etat, code)[0], 303)
self.assertIn(roles.PROPRIETAIRE, self.f.roles_de(self.f.utilisateur("g-theo")))
self.assertNotIn(roles.PROPRIETAIRE, self.f.roles_de(self.f.utilisateur("g-autre")))
def test_state_invalide(self):
etat, ch = self.depart()
self.hub_accepte("c1", ch, {"id": "g-1", "pseudo": "X"})
for st, h, _ in (self.retour("faux-state", cookie_etat="faux-state"), # inconnu du serveur
self.retour(etat, cookie_etat="autre-navigateur"), # pas le navigateur qui a commencé
self.req("/connexion/retour?code=c1&state=" + etat)): # sans cookie
self.assertEqual(st, 400)
self.assertIsNone(self.jeton_session(h)[0])
self.assertIsNone(self.f.con.execute("SELECT 1 FROM users WHERE hub_id='g-1'").fetchone())
st, _, _ = self.req("/connexion/retour?error=access_denied&state=" + etat, cookie="forum_etat=" + etat)
self.assertEqual(st, 400)
def test_pkce_faux_ou_hub_en_panne(self):
etat, _ = self.depart()
self.hub_accepte("c1", "challenge-qui-ne-correspond-pas", {"id": "g-1", "pseudo": "X"})
st, h, _ = self.retour(etat)
self.assertEqual(st, 502)
self.assertIsNone(self.jeton_session(h)[0])
self.reglages.hub_url = "http://127.0.0.1:1" # Hub injoignable
etat, ch = self.depart()
self.assertEqual(self.retour(etat)[0], 502)
def test_deconnexion_en_post(self):
cookie = self.session("m1")
self.assertEqual(self.req("/deconnexion", cookie=cookie)[0], 404) # pas en GET
self.assertEqual(self.req("/deconnexion", corps=b"", cookie=cookie, origine=False)[0], 403)
st, h, _ = self.req("/deconnexion", corps=b"", cookie=cookie)
self.assertEqual(st, 303)
self.assertIn("Max-Age=0", h["Set-Cookie"])
self.assertIsNone(self.f.utilisateur_de_session(self.sessions["m1"]))
def test_cookies_forges_ignores(self):
for c in ("forum_test=theo", "forum_session=" + "A" * 43, "forum_session=theo"):
b = self.req("/", cookie=c)[2].decode()
self.assertIn("Se connecter avec Gastinel", b)
self.assertEqual(self.req("/roles", cookie="forum_test=theo")[0], 403)
def test_non_configuree(self):
self.reglages.hub_url = ""
self.assertEqual(self.req("/connexion/gastinel")[0], 503)
def test_reglages(self):
with self.assertRaises(ValueError):
connexion.Reglages(hub_url="http://hub.gastinel.me")
r = connexion.Reglages.depuis_env({"FORUM_HUB_URL": "https://hub.gastinel.me/", "FORUM_MODE_TEST": "1",
"FORUM_CLIENT_ID": "x", "FORUM_REDIRECT_URI": "https://v/retour"})
self.assertEqual((r.hub_url, r.client_id, r.redirect_uri, r.mode_test), ("https://hub.gastinel.me", "x", "https://v/retour", True))
self.assertFalse(connexion.Reglages.depuis_env({}).mode_test)
v, c = connexion.pkce()
self.assertTrue(43 <= len(v) <= 128)
self.assertEqual(c, connexion._b64(hashlib.sha256(v.encode()).digest()))
class TestModeEssai(BaseHTTP):
def test_test_login_lan_et_variable(self):
st, h, _ = self.req("/test-login?u=theo")
self.assertEqual(st, 303)
self.assertIn("forum_session=", h["Set-Cookie"])
# derrière Caddy local : l'adresse réelle (Internet) est refusée
st, h, _ = self.req("/test-login?u=theo", entetes={"X-Forwarded-For": "203.0.113.5"})
self.assertEqual(st, 404)
self.assertIsNone(h["Set-Cookie"])
st, _, _ = self.req("/test-login?u=theo", entetes={"X-Forwarded-For": "192.168.1.20"})
self.assertEqual(st, 303)
self.reglages.mode_test = False # sans FORUM_MODE_TEST=1 : jamais
self.assertEqual(self.req("/test-login?u=theo")[0], 404)
self.assertNotIn("/test-login", self.req("/")[2].decode())
def test_ip_client(self):
ip = connexion.ip_client
self.assertEqual(ip("203.0.113.9", "127.0.0.1"), "203.0.113.9") # X-Forwarded-For ignoré hors relais
self.assertEqual(ip("10.8.0.1", "192.168.1.2"), "10.8.0.1")
self.assertEqual(ip("127.0.0.1", "192.168.1.5, 203.0.113.7"), "203.0.113.7") # dernière adresse : celle vue par Caddy
self.assertEqual(ip("127.0.0.1", "pas-une-ip"), "127.0.0.1")
self.assertEqual(ip("10.8.0.1", "203.0.113.7", relais={"10.8.0.1"}), "203.0.113.7")
loc = connexion.est_locale
for a in ("127.0.0.1", "10.1.2.3", "192.168.0.10", "::1", "::ffff:127.0.0.1"):
self.assertTrue(loc(a), a)
for a in ("203.0.113.5", "172.16.0.1", "8.8.8.8", "2001:db8::1", "x"):
self.assertFalse(loc(a), a)
def test_seed_refuse_sans_mode_test(self):
env = {k: v for k, v in os.environ.items() if k != "FORUM_MODE_TEST"}
p = subprocess.run([sys.executable, "-I", os.path.join(ICI, "server.py"), "--seed",
"--db", os.path.join(self.tmp, "x.sqlite3"), "--port", "0"],
env=env, capture_output=True, text=True, timeout=30)
self.assertNotEqual(p.returncode, 0)
self.assertIn("FORUM_MODE_TEST", p.stderr)
self.assertFalse(os.path.exists(os.path.join(self.tmp, "x.sqlite3")))
class TestDecisions(Base):
def test_moderateur_non_adherent(self):
self.assertFalse(roles.MODERATEUR_CREE_SUJETS)
with self.assertRaises(Refus):
self.f.creer_sujet(self.modo, "Sujet", "texte")
t = self.f.creer_sujet(self.adh, "Neige", "x")
p = self.f.repondre(self.modo, t, "Je réponds") # il répond
self.f.masquer_message(self.modo, p) # et modère
self.f.verrouiller(self.modo, t)
with self.assertRaises(Refus): # pas de Bulletin pour lui
self.f.repondre(self.modo, self.bulletin()["id"], "bilan")
self.f.creer_sujet(self.pere, "Sujet du père", "x") # l'adjoint (aussi modérateur) crée, lui
def test_epinglage_reserve_aux_proprietaires(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
for qui in (self.modo, self.adh, self.membre, self.prop, None):
with self.assertRaises(Refus):
self.f.epingler(qui, t)
self.f.epingler(self.pere, t) # propriétaire adjoint
self.f.epingler(self.theo, t, False) # propriétaire
self.assertEqual(roles.DROITS["epingler"], {roles.PROPRIETAIRE, roles.ADJOINT})
class TestAdhesion(Base):
def test_demande_puis_acceptation(self):
d = self.f.demander_adhesion(self.membre, "Je photographie le givre", [("a.png", png()), ("b.jpg", jpeg())])
with self.assertRaises(Invalide): # une seule en cours
self.f.demander_adhesion(self.membre, "encore")
for qui in (self.modo, self.adh, self.membre):
with self.assertRaises(Refus):
self.f.demandes_adhesion(qui)
with self.assertRaises(Refus):
self.f.decider_adhesion(self.modo, d, True)
liste = self.f.demandes_adhesion(self.pere)
self.assertEqual([(x["id"], x["pseudo"], x["n_photos"]) for x in liste], [(d, "Marie", 2)])
_, ph = self.f.demande_adhesion(self.theo, d)
for p in ph:
self.assertEqual(os.path.dirname(p["stored_path"]), self.f.dossier_demandes)
with open(p["stored_path"], "rb") as fh:
contenu = fh.read()
self.assertNotIn(b"GPS", contenu)
self.assertEqual(self.f.photo_adhesion(self.pere, os.path.basename(p["stored_path"])), p["stored_path"])
self.f.decider_adhesion(self.pere, d, True)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
with self.assertRaises(Invalide):
self.f.decider_adhesion(self.theo, d, False) # déjà traitée
with self.assertRaises(Invalide):
self.f.demander_adhesion(self.membre, "re") # déjà adhérent
self.assertEqual(self.f.demandes_adhesion(self.theo), [])
self.assertEqual(len(self.f.demandes_adhesion(self.theo, None)), 1)
def test_refus_puis_nouvelle_demande(self):
d = self.f.demander_adhesion(self.modo, "Modérateur, j'aimerais publier")
self.f.decider_adhesion(self.theo, d, False)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.modo))
self.assertEqual(self.f.ma_demande_adhesion(self.modo)["status"], "refusee")
self.f.demander_adhesion(self.modo, "deuxième essai")
def test_limites(self):
with self.assertRaises(Refus):
self.f.demander_adhesion(None, "visiteur")
with self.assertRaises(Invalide):
self.f.demander_adhesion(self.membre, " ")
with self.assertRaises(Refus):
self.f.demander_adhesion(self.membre, "trop", [("a.png", png())] * 11)
with self.assertRaises(Refus):
self.f.demander_adhesion(self.membre, "lourd", [("g.png", png() + b"\x00" * (26 * 1024 * 1024))])
with self.assertRaises(Invalide):
self.f.demander_adhesion(self.membre, "pas une image", [("x.svg", b"<svg/>")])
self.assertIsNone(self.f.ma_demande_adhesion(self.membre)) # rien n'a été enregistré
class TestAdhesionHTTP(BaseHTTP):
def test_parcours(self):
b = self.req("/", "m1")[2].decode()
self.assertIn("Demander à devenir adhérent", b)
frontiere = "AbC"
corps = ("--%s\r\nContent-Disposition: form-data; name=\"message\"\r\n\r\nBonjour, je suis à Autrans\r\n"
"--%s\r\nContent-Disposition: form-data; name=\"photos\"; filename=\"neige.png\"\r\nContent-Type: image/png\r\n\r\n"
% (frontiere, frontiere)).encode() + png() + ("\r\n--%s--\r\n" % frontiere).encode()
self.assertEqual(self.req("/adhesion", "m1", corps, "multipart/form-data; boundary=" + frontiere)[0], 303)
self.assertIn("en attente", self.req("/adhesion", "m1")[2].decode())
self.assertEqual(self.req("/adhesions", "mo1")[0], 403)
st, _, b = self.req("/adhesions", "pere")
self.assertEqual(st, 200)
self.assertIn("Bonjour, je suis à Autrans", b.decode())
nom = b.decode().split("/adhesion-photo/")[1].split("'")[0]
st, h, img = self.req("/adhesion-photo/" + nom, "pere")
self.assertEqual((st, h["Content-Type"], h["Cache-Control"]), (200, "image/png", "private, no-store"))
self.assertNotIn(b"GPS", img)
self.assertEqual(self.req("/adhesion-photo/" + nom, "m1")[0], 403)
self.assertEqual(self.req("/adhesion-photo/" + nom)[0], 403)
self.assertEqual(self.req("/photo/" + nom)[0], 404) # pas dans les photos publiques
d = self.f.ma_demande_adhesion(self.membre)["id"]
self.assertEqual(self.req("/adhesion/decider", "mo1", ("demande=%d&ok=1" % d).encode())[0], 403)
self.assertEqual(self.req("/adhesion/decider", "pere", ("demande=%d&ok=1" % d).encode())[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
if __name__ == "__main__":
unittest.main()