Fichiers
meteo-vercors/forum/tests/test_forum.py
T

834 lignes
43 KiB
Python

"""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
ICI = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
sys.path.insert(0, ICI)
import connexion # noqa: E402
import panneau # 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"}
def png(meta=True):
def bloc(nom, data):
return struct.pack(">I", len(data)) + nom + data + struct.pack(">I", zlib.crc32(nom + data))
ihdr = struct.pack(">IIBBBBB", 1, 1, 8, 2, 0, 0, 0)
corps = bloc(b"IHDR", ihdr)
if meta:
corps += bloc(b"tEXt", b"GPS\x0045.1,5.5")
corps += bloc(b"IDAT", zlib.compress(b"\x00\x00\x00\x00")) + bloc(b"IEND", b"")
return b"\x89PNG\r\n\x1a\n" + corps
def jpeg():
app1 = b"\xff\xe1" + struct.pack(">H", 2 + 10) + b"Exif\x00\x00GPS!"
app0 = b"\xff\xe0" + struct.pack(">H", 2 + 5) + b"JFIF\x00"
sos = b"\xff\xda" + struct.pack(">H", 2 + 2) + b"\x00\x00" + b"\x12\x34" + b"\xff\xd9"
return b"\xff\xd8" + app0 + app1 + sos
class Base(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.mkdtemp()
self.f = Forum(stations=STATIONS, dossier_photos=os.path.join(self.tmp, "photos"))
self.theo = self.f.fixer_proprietaire("theo", "Théo")
self.pere = self.f.utilisateur("pere", "Richard")
self.f.donner_role(self.theo, "pere", roles.ADJOINT)
self.f.donner_role(self.theo, "pere", roles.MODERATEUR)
self.membre = self.f.utilisateur("m1", "Marie")
self.adh = self.f.utilisateur("a1", "Alex")
self.f.donner_role(self.pere, "a1", roles.ADHERENT)
self.modo = self.f.utilisateur("mo1", "Momo")
self.f.donner_role(self.theo, "mo1", roles.MODERATEUR)
self.prop = self.f.utilisateur("s1", "Sam")
self.f.donner_role(self.pere, "s1", roles.STATION, "geve")
def tearDown(self):
shutil.rmtree(self.tmp, ignore_errors=True)
def bulletin(self):
return [t for t in self.f.sujets(None) if t["fixed"]][0]
class TestRoles(Base):
def test_cumul_et_badges(self):
self.assertEqual(self.f.roles_de(self.pere), {roles.MEMBRE, roles.ADJOINT, roles.MODERATEUR})
self.assertEqual([lib for _, lib in self.f.badges(self.pere["id"])], ["Propriétaire adjoint", "Modérateur"])
self.assertEqual([lib for _, lib in self.f.badges(self.membre["id"])], ["Membre"])
self.assertEqual([lib for _, lib in self.f.badges(self.prop["id"])], ["Propriétaire de station · Gêve"])
def test_qui_donne_quoi(self):
with self.assertRaises(Refus): # l'adjoint ne nomme pas d'adjoint
self.f.donner_role(self.pere, "m1", roles.ADJOINT)
with self.assertRaises(Refus): # personne ne donne « propriétaire »
self.f.donner_role(self.theo, "m1", roles.PROPRIETAIRE)
with self.assertRaises(Refus): # un modérateur ne gère pas les rôles
self.f.donner_role(self.modo, "m1", roles.ADHERENT)
with self.assertRaises(Invalide):
self.f.donner_role(self.theo, "m1", roles.STATION, "inconnue")
self.f.retirer_role(self.theo, "a1", roles.ADHERENT)
self.assertEqual(self.f.roles_de(self.f.utilisateur("a1")), {roles.MEMBRE})
def test_compte_systeme_reserve(self):
with self.assertRaises(Invalide):
self.f.utilisateur("systeme")
class TestSujets(Base):
def test_bulletin_fixe_en_tete_et_ferme(self):
self.f.creer_sujet(self.adh, "Givre à Gêve", "Photo ce matin")
liste = self.f.sujets(None)
self.assertEqual(liste[0]["title"], "Bulletin de la semaine du Vercors")
b = self.bulletin()["id"]
with self.assertRaises(Refus):
self.f.repondre(self.membre, b, "coucou")
self.f.repondre(self.adh, b, "Bilan de la semaine…") # un adhérent publie le bulletin
self.f.repondre(self.pere, b, "Complément") # le propriétaire adjoint aussi
with self.assertRaises(Refus):
self.f.epingler(self.theo, b, False)
with self.assertRaises(Refus):
self.f.masquer_sujet(self.theo, b)
def test_membre_repond_seulement(self):
with self.assertRaises(Refus):
self.f.creer_sujet(self.membre, "Mon sujet", "texte")
t = self.f.creer_sujet(self.adh, "Neige", "Il neige")
self.f.repondre(self.membre, t, "Ici aussi")
with self.assertRaises(Refus):
self.f.repondre(None, t, "visiteur")
def test_moderateur_seul_ne_cree_pas(self):
if roles.MODERATEUR_CREE_SUJETS:
self.skipTest("réglage modifié")
with self.assertRaises(Refus):
self.f.creer_sujet(self.modo, "Sujet", "texte")
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.verrouiller(self.modo, t)
with self.assertRaises(Refus):
self.f.repondre(self.membre, t, "trop tard")
def test_epingles_maximum(self):
ids = [self.f.creer_sujet(self.adh, "S%d" % i, "x") for i in range(6)]
for t in ids[:EPINGLES_MAX - 1]:
self.f.epingler(self.theo, t)
with self.assertRaises(Refus):
self.f.epingler(self.pere, ids[-1])
with self.assertRaises(Refus):
self.f.epingler(self.adh, ids[-1])
tetes = [t["title"] for t in self.f.sujets(None)[:EPINGLES_MAX]]
self.assertEqual(tetes, ["Bulletin de la semaine du Vercors", "S0", "S1", "S2", "S3"])
class TestStation(Base):
def test_sujet_de_station_valide(self):
t = self.f.creer_sujet_station(self.prop, "geve", "Ma station à 1353 m")
self.assertNotIn(t, [s["id"] for s in self.f.sujets(None)]) # en attente : invisible
self.assertIn(t, [s["id"] for s in self.f.sujets(self.prop)]) # sauf pour son auteur
with self.assertRaises(Invalide): # en attente : introuvable pour un membre
self.f.repondre(self.membre, t, "x")
self.assertEqual([s["id"] for s in self.f.en_attente(self.pere)], [t])
self.f.valider_sujet(self.pere, t)
s = [x for x in self.f.sujets(None) if x["id"] == t][0]
self.assertEqual(s["title"], "Station · Gêve")
self.f.repondre(self.membre, t, "Belle station")
def test_une_seule_et_la_sienne(self):
self.f.creer_sujet_station(self.prop, "geve", "x")
with self.assertRaises(Invalide):
self.f.creer_sujet_station(self.prop, "geve", "encore")
with self.assertRaises(Refus):
self.f.creer_sujet_station(self.prop, "oscence", "pas à moi")
with self.assertRaises(Refus):
self.f.creer_sujet_station(self.membre, "geve", "x")
with self.assertRaises(Refus):
self.f.valider_sujet(self.modo, 1)
def test_refus_puis_nouvel_essai(self):
t = self.f.creer_sujet_station(self.prop, "geve", "x")
self.f.valider_sujet(self.theo, t, accepte=False)
self.f.creer_sujet_station(self.prop, "geve", "deuxième essai")
class TestPhotos(Base):
def test_metadonnees_retirees(self):
mime, propre = photos.nettoyer(png())
self.assertEqual(mime, "image/png")
self.assertNotIn(b"GPS", propre)
mime, propre = photos.nettoyer(jpeg())
self.assertEqual(mime, "image/jpeg")
self.assertNotIn(b"Exif", propre)
self.assertTrue(propre.startswith(b"\xff\xd8") and propre.endswith(b"\xff\xd9"))
with self.assertRaises(photos.PhotoInvalide):
photos.nettoyer(b"<svg onload=alert(1)>")
def test_limites(self):
t = self.f.creer_sujet(self.adh, "Photos", "x")
p = self.f.repondre(self.membre, t, "voici")
self.f.ajouter_photos(self.membre, p, [("a.png", png())] * 10)
with self.assertRaises(Refus):
self.f.ajouter_photos(self.membre, p, [("b.png", png())])
with self.assertRaises(Refus):
self.f.ajouter_photos(self.adh, p, [("c.png", png())]) # pas son message
gros = self.f.repondre(self.membre, t, "gros")
with self.assertRaises(Refus):
self.f.ajouter_photos(self.membre, gros, [("g.png", png() + b"\x00" * (26 * 1024 * 1024))])
def test_proprietaire_sans_limite(self):
t = self.f.creer_sujet(self.theo, "Album", "x")
p = self.f.repondre(self.theo, t, "beaucoup")
self.f.ajouter_photos(self.theo, p, [("a.png", png())] * 12)
self.assertEqual(len(self.f.photos_de(p)), 12)
class TestModeration(Base):
def test_signalement_et_masquage(self):
t = self.f.creer_sujet(self.adh, "Sujet", "x")
p = self.f.repondre(self.membre, t, "message limite")
self.f.signaler(self.adh, p, "hors sujet")
with self.assertRaises(Refus):
self.f.signalements(self.membre)
self.assertEqual(len(self.f.signalements(self.modo)), 1)
self.f.masquer_message(self.modo, p)
_, msgs = self.f.sujet(self.membre, t)
self.assertNotIn(p, [m["id"] for m in msgs])
_, msgs = self.f.sujet(self.pere, t)
self.assertIn(p, [m["id"] for m in msgs])
def test_purge_ip(self):
t = self.f.creer_sujet(self.adh, "S", "x", ip="192.0.2.1")
self.f.con.execute("UPDATE posts SET created_at=datetime('now','-13 months') WHERE topic_id=?", (t,))
self.assertEqual(self.f.purger_ips(), 1)
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()
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):
for s in (self.srv, self.hub):
s.shutdown()
s.server_close()
super().tearDown()
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 = dict(entetes or {})
if 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, r.headers, r.read()
class TestHTTP(BaseHTTP):
def test_liste_visiteur(self):
st, h, b = self.req("/")
self.assertEqual(st, 200)
self.assertIn("Bulletin de la semaine du Vercors", b.decode())
self.assertIn("default-src 'none'", h["Content-Security-Policy"])
def test_reponse_avec_photo(self):
t = self.f.creer_sujet(self.adh, "Photos", "x")
frontiere = "XyZ"
corps = ("--%s\r\nContent-Disposition: form-data; name=\"sujet\"\r\n\r\n%d\r\n"
"--%s\r\nContent-Disposition: form-data; name=\"corps\"\r\n\r\nVoici le givre\r\n"
"--%s\r\nContent-Disposition: form-data; name=\"photos\"; filename=\"givre.png\"\r\nContent-Type: image/png\r\n\r\n"
% (frontiere, t, frontiere, frontiere)).encode() + png() + ("\r\n--%s--\r\n" % frontiere).encode()
st, _, _ = self.req("/repondre", "m1", corps, "multipart/form-data; boundary=" + frontiere)
self.assertEqual(st, 303)
st, _, b = self.req("/t/%d" % t)
self.assertIn("/photo/", b.decode())
nom = b.decode().split("/photo/")[1].split("'")[0]
st, h, img = self.req("/photo/" + nom)
self.assertEqual((st, h["Content-Type"], h["X-Content-Type-Options"]), (200, "image/png", "nosniff"))
self.assertNotIn(b"GPS", img)
def test_origine_et_droits(self):
st, _, _ = self.req("/sujet", "a1", b"titre=x&corps=y", origine=False)
self.assertEqual(st, 403)
st, _, _ = self.req("/sujet", "m1", b"titre=x&corps=y")
self.assertEqual(st, 403)
st, _, _ = self.req("/sujet", "a1", b"titre=Neige&corps=Il+neige")
self.assertEqual(st, 303)
st, _, _ = self.req("/roles", "mo1")
self.assertEqual(st, 403)
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))
class TestPrefixe(BaseHTTP):
def setUp(self):
super().setUp()
self.reglages.prefixe = "/forum"
def test_liens_formulaires_et_cookies(self):
for chemin in ("/forum/", "/forum", "/"): # avec ou sans préfixe (Caddy le retire ou non)
st, _, b = self.req(chemin, "a1")
self.assertEqual(st, 200, chemin)
b = b.decode()
self.assertIn("action='/forum/deconnexion'", b)
self.assertIn("action='/forum/sujet'", b)
self.assertIn("href='/forum/'", b)
self.assertNotIn("href='/'", b)
self.assertNotIn("action='/sujet'", b)
b = self.req("/forum/")[2].decode()
self.assertIn("href='/forum/connexion/gastinel'", b)
def test_redirections_et_posts(self):
for chemin in ("/forum/sujet", "/sujet"):
st, h, _ = self.req(chemin, "a1", b"titre=Neige&corps=Il+neige")
self.assertEqual(st, 303)
self.assertTrue(h["Location"].startswith("/forum/t/"), h["Location"])
st, h, _ = self.req("/forum/deconnexion", "a1", b"")
self.assertEqual((st, h["Location"]), (303, "/forum/"))
self.assertIn("Path=/forum;", h["Set-Cookie"])
st, _, b = self.req("/forum/t/1")
self.assertEqual(st, 200)
self.assertIn("href='/forum/'", b.decode())
def test_connexion_cookies_et_retour(self):
st, h, _ = self.req("/forum/connexion/gastinel")
self.assertEqual(st, 303)
self.assertIn("Path=/forum;", [c for c in h.get_all("Set-Cookie") if c.startswith("forum_etat=")][0])
def test_defaut_et_validation(self):
self.assertEqual(connexion.Reglages(prefixe="forum/").prefixe, "/forum")
self.assertEqual(connexion.Reglages(prefixe="/forum", ).redirect_uri, "https://vercors.me/forum/connexion/retour")
self.assertEqual(connexion.Reglages().redirect_uri, "https://vercors.me/connexion/retour")
self.assertEqual(connexion.Reglages.depuis_env({"FORUM_PREFIXE": "/f"}).redirect_uri, "https://vercors.me/f/connexion/retour")
with self.assertRaises(ValueError):
connexion.Reglages(prefixe="/a'b")
class TestPanneau(BaseHTTP):
"""Panneau LAN : second serveur sur la même base, cookie panneau_session, CSRF, propriétaires seulement."""
def setUp(self):
super().setUp()
self.pan = panneau.creer_serveur(self.f, 0, reglages=connexion.Reglages(
hub_url=self.reglages.hub_url, redirect_uri="http://127.0.0.1:1/connexion/retour"))
self.pport = self.pan.server_address[1]
threading.Thread(target=self.pan.serve_forever, daemon=True).start()
self.psess = {}
def tearDown(self):
self.pan.shutdown()
self.pan.server_close()
super().tearDown()
def preq(self, chemin, qui=None, corps=None, csrf=True, entetes=None, cookie=None):
h = dict(entetes or {})
if qui:
if qui not in self.psess:
self.psess[qui] = self.f.ouvrir_session(self.f.utilisateur(qui), 1, panneau.PORTEE)
h["Cookie"] = "panneau_session=" + self.psess[qui]
if cookie:
h["Cookie"] = cookie
if corps is not None:
h["Content-Type"] = "application/x-www-form-urlencoded"
h["Origin"] = "http://127.0.0.1:%d" % self.pport
if csrf and qui:
corps = corps + "&csrf=" + self.csrf(qui)
corps = corps.encode()
c = http.client.HTTPConnection("127.0.0.1", self.pport, timeout=10)
c.request("POST" if corps is not None else "GET", chemin, body=corps, headers=h)
r = c.getresponse()
return r.status, r.headers, r.read()
def csrf(self, qui):
b = self.preq("/", qui)[2].decode()
return b.split("name='csrf' value='")[1].split("'")[0]
def test_refus_hors_lan(self):
for ip in ("8.8.8.8", "172.16.0.5", "2001:db8::1", "192.169.0.1", "11.0.0.1"):
self.assertFalse(connexion.est_locale(ip), ip)
for ip in ("127.0.0.1", "10.1.2.3", "192.168.1.20", "::1"):
self.assertTrue(connexion.est_locale(ip), ip)
h = self.pan.RequestHandlerClass
h.ip = lambda self: "203.0.113.9" # connexion venue d'Internet
try:
self.assertEqual(self.preq("/")[0], 403)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 403)
self.assertEqual(self.preq("/role", "theo", "hub_id=m1&role=adherent&action=donner", csrf=False)[0], 403)
finally:
del h.ip
self.assertEqual(self.preq("/")[0], 200)
def test_x_forwarded_for_ignore(self):
h = self.pan.RequestHandlerClass
h.ip = lambda self: "203.0.113.9"
try:
self.assertEqual(self.preq("/", entetes={"X-Forwarded-For": "192.168.1.5"})[0], 403) # pas cru
finally:
del h.ip
self.assertEqual(self.preq("/", entetes={"X-Forwarded-For": "8.8.8.8"})[0], 200) # ne retire pas l'accès LAN
def test_refus_non_proprietaire(self):
self.assertEqual(self.preq("/")[0], 200) # page de connexion
self.assertEqual(self.preq("/utilisateurs")[0], 403) # visiteur
for qui in ("m1", "a1", "mo1", "s1"):
for chemin in ("/utilisateurs", "/adhesions", "/stations", "/signalements"):
self.assertEqual(self.preq(chemin, qui)[0], 403, (qui, chemin))
self.assertEqual(self.preq("/role", "m1", "hub_id=m1&role=adherent&action=donner")[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
# le cookie du forum ne vaut rien dans le panneau
jeton = self.f.ouvrir_session(self.theo)
self.assertEqual(self.preq("/utilisateurs", cookie="panneau_session=" + jeton)[0], 403)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 200)
self.assertEqual(self.preq("/utilisateurs", "pere")[0], 200)
def test_csrf_obligatoire(self):
corps = "hub_id=m1&role=adherent&action=donner"
self.assertEqual(self.preq("/role", "theo", corps, csrf=False)[0], 403)
self.assertEqual(self.preq("/role", "theo", corps + "&csrf=faux", csrf=False)[0], 403)
autre = self.csrf("pere") # jeton d'une autre session
self.assertEqual(self.preq("/role", "theo", corps + "&csrf=" + autre, csrf=False)[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
st, h, _ = self.preq("/role", "theo", corps)
self.assertEqual((st, h["Location"]), (303, "/utilisateurs"))
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
def test_liste_utilisateurs_et_badges(self):
b = self.preq("/utilisateurs", "theo")[2].decode()
for nom in ("Marie", "Alex", "Richard", "Sam"):
self.assertIn(nom, b)
self.assertIn("aria-label='Propriétaire adjoint'", b)
self.assertIn("Propriétaire de station · Gêve", b)
self.assertNotIn("<script", b)
def test_don_de_role_respecte_peut_donner(self):
base = "hub_id=m1&station="
# l'adjoint donne adhérent, mais pas adjoint ; personne ne donne propriétaire
self.assertEqual(self.preq("/role", "pere", base + "&role=adherent&action=donner")[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "pere", base + "&role=proprietaire_adjoint&action=donner")[0], 403)
self.assertEqual(self.preq("/role", "theo", base + "&role=proprietaire&action=donner")[0], 403)
self.assertNotIn(roles.ADJOINT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", base + "&role=proprietaire_adjoint&action=donner")[0], 303)
self.assertIn(roles.ADJOINT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", base + "geve&role=proprietaire_station&action=donner")[0], 303)
self.assertEqual(self.f.stations_de(self.membre), {"geve"})
self.assertEqual(self.preq("/role", "theo", base + "&role=adherent&action=retirer")[0], 303)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", "hub_id=inconnu&role=adherent&action=donner")[0], 400)
# l'adjoint ne voit pas l'option « adjoint » dans son formulaire
self.assertNotIn("value='proprietaire_adjoint'", self.preq("/utilisateurs", "pere")[2].decode())
self.assertIn("value='proprietaire_adjoint'", self.preq("/utilisateurs", "theo")[2].decode())
def test_decision_adhesion(self):
d = self.f.demander_adhesion(self.membre, "Station à Lans", [("n.png", png())])
b = self.preq("/adhesions", "theo")[2].decode()
self.assertIn("Station à Lans", b)
nom = b.split("/adhesion-photo/")[1].split("'")[0]
st, h, img = self.preq("/adhesion-photo/" + nom, "pere")
self.assertEqual((st, h["Content-Type"]), (200, "image/png"))
self.assertNotIn(b"GPS", img)
self.assertEqual(self.preq("/adhesion-photo/" + nom, "m1")[0], 403)
self.assertEqual(self.preq("/adhesion-photo/" + nom)[0], 403)
self.assertEqual(self.preq("/adhesion/decider", "mo1", "demande=%d&ok=1" % d)[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/adhesion/decider", "pere", "demande=%d&ok=1" % d)[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertIn("Aucune demande", self.preq("/adhesions", "theo")[2].decode())
d2 = self.f.demander_adhesion(self.modo, "Je modère déjà")
self.assertEqual(self.preq("/adhesion/decider", "theo", "demande=%d&ok=0" % d2)[0], 303)
self.assertEqual(self.f.ma_demande_adhesion(self.modo)["status"], "refusee")
def test_stations_et_signalements(self):
t = self.f.creer_sujet_station(self.prop, "geve", "Ma station au col")
b = self.preq("/stations", "theo")[2].decode()
self.assertIn("Ma station au col", b)
self.assertEqual(self.preq("/valider", "theo", "sujet=%d&ok=1" % t)[0], 303)
self.assertEqual(self.f.sujet(None, t)[0]["status"], "publie")
p = self.f.repondre(self.adh, self.f.creer_sujet(self.adh, "Neige", "x"), "message douteux")
self.f.signaler(self.membre, p, "Insultes")
b = self.preq("/signalements", "pere")[2].decode()
self.assertIn("Insultes", b)
self.assertIn("message douteux", b)
def test_echappement_et_en_tetes(self):
self.f.utilisateur("x1", "<script>alert(1)</script>")
st, h, b = self.preq("/utilisateurs", "theo")
self.assertNotIn("<script>alert", b.decode())
self.assertIn("&lt;script&gt;", b.decode())
self.assertIn("default-src 'none'", h["Content-Security-Policy"])
self.assertEqual(h["Cache-Control"], "private, no-store")
def test_connexion_gastinel_propre_au_panneau(self):
redir = "http://127.0.0.1:1/connexion/retour"
st, h, _ = self.preq("/connexion/gastinel")
self.assertEqual(st, 303)
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
self.assertEqual(q["redirect_uri"], redir) # adresse de retour distincte
etat = [c for c in h.get_all("Set-Cookie") if c.startswith("panneau_etat=")][0]
self.assertNotIn("Secure", etat) # panneau en http sur le LAN
self.hub.RequestHandlerClass.codes["c1"] = (q["code_challenge"], "forum-vercors", redir, {"id": "pere", "pseudo": "Richard"})
st, h, _ = self.preq("/connexion/retour?code=c1&state=" + q["state"], cookie="panneau_etat=" + q["state"])
self.assertEqual(st, 303)
cookie = [c for c in h.get_all("Set-Cookie") if c.startswith("panneau_session=") and "Max-Age=0" not in c][0]
jeton = cookie.split(";")[0].split("=", 1)[1]
self.assertEqual(self.preq("/utilisateurs", cookie="panneau_session=" + jeton)[0], 200)
# un simple membre Gastinel (ou un inconnu) ne passe pas, et aucun compte n'est créé
for hub_id in ("m1", "inconnu"):
st, h, _ = self.preq("/connexion/gastinel")
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
self.hub.RequestHandlerClass.codes["c2"] = (q["code_challenge"], "forum-vercors", redir, {"id": hub_id, "pseudo": "X"})
st, h, _ = self.preq("/connexion/retour?code=c2&state=" + q["state"], cookie="panneau_etat=" + q["state"])
self.assertEqual(st, 403)
self.assertFalse([c for c in h.get_all("Set-Cookie") if c.startswith("panneau_session=") and "Max-Age=0" not in c])
self.assertIsNone(self.f.utilisateur_existant("inconnu"))
def test_deconnexion(self):
self.assertEqual(self.preq("/deconnexion", "theo", "")[0], 303)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 403)
if __name__ == "__main__":
unittest.main()