diff --git a/beta/server.py b/beta/server.py new file mode 100644 index 0000000..0536b1b --- /dev/null +++ b/beta/server.py @@ -0,0 +1,422 @@ +"""Serveur de la bêta JobRunner (bibliothèque standard uniquement). + +Sert le site statique du dépôt derrière une porte d'entrée par code d'accès, +injecte le bandeau « Bêta » et le bouton « Donner mon avis », et expose une +petite API locale (entrée, retours, formulaire testeur, flux de démo). + +Lancement local : python beta/server.py (127.0.0.1:8830 par défaut) +Aucun appel sortant, aucun paiement, aucune clé. +""" +import base64 +import hashlib +import json +import mimetypes +import os +import re +import secrets +import sys +import threading +import time +import unicodedata +from datetime import date +from http import cookies +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path +from urllib.parse import unquote, urlsplit + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import db # noqa: E402 + +RACINE = Path(__file__).resolve().parent.parent +STATIC = Path(__file__).resolve().parent / "static" +COOKIE = "jrb_s" +SESSION_S = 7 * 86400 +FENETRE_S = 15 * 60 +MAX_ECHECS_IP = int(os.environ.get("BETA_MAX_ECHECS_IP", "6")) +MAX_ECHECS_GLOBAL = int(os.environ.get("BETA_MAX_ECHECS_GLOBAL", "60")) +FAIT_CONFIANCE_PROXY = os.environ.get("BETA_TRUST_PROXY") == "1" +EXT_OK = {".html", ".css", ".js", ".woff2", ".png", ".jpg", ".jpeg", ".svg", ".webp", ".ico", ".mp4", ".webm", ".gif", ".pdf"} +DOSSIERS_INTERDITS = {"beta", ".git", "docs", "node_modules", "design"} +CSP_APP = ("default-src 'self'; img-src 'self' https: data: blob:; media-src 'self' https: blob:; " + "style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; font-src 'self' data:; " + "connect-src 'self'; frame-src 'none'; object-src 'none'; base-uri 'self'; form-action 'self'") +CSP_PAGE = ("default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; " + "script-src 'self' 'unsafe-inline'; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; " + "base-uri 'none'; form-action 'self'") +INJECTION = ('' + '') +EMAIL = re.compile(r"^[^@\s]{1,64}@[^@\s]{1,190}\.[^@\s]{2,}$") +TEL = re.compile(r"^[0-9 +().-]{6,20}$") + + +LOGOS = {"logo.png", "logo-official.jpg", "logo-square.png", "logo-transparent.png", + "logo-dark.svg", "logo-j.svg", "logo-light.svg"} + + +def chemin_sur(p): + """Refuse tout segment '.' ou '..' (y compris encodé, même doublement), antislash, NUL, % résiduel.""" + q = p + for _ in range(3): + q = unquote(q) + if "%" in q or "\\" in q or "\x00" in q or any(ord(ch) < 32 for ch in q): + return False + return not any(seg in (".", "..") for seg in p.split("/") + q.split("/")) + + +def a_controle(v): + return any(unicodedata.category(ch)[0] == "C" for ch in str(v)) + + +def age(naissance, ref=None): + ref = ref or date.today() + y, m, d = (int(x) for x in naissance.split("-")) + return ref.year - y - ((ref.month, ref.day) < (m, d)) + + +class Handler(BaseHTTPRequestHandler): + server_version = "JobRunnerBeta" + sys_version = "" + + def log_message(self, fmt, *a): # pas de journal HTTP (ni IP ni cookie) sauf demande + if os.environ.get("BETA_VERBOSE"): + sys.stderr.write("[beta] " + fmt % a + "\n") + + # --- utilitaires ------------------------------------------------- + @property + def c(self): + return self.server.conn + + def ip(self): + if FAIT_CONFIANCE_PROXY: + xf = self.headers.get("X-Forwarded-For", "") + if xf: + return xf.split(",")[-1].strip() # dernier saut = ajouté par Caddy + return self.client_address[0] + + def https(self): + return FAIT_CONFIANCE_PROXY and self.headers.get("X-Forwarded-Proto") == "https" + + def envoyer(self, code, corps=b"", ctype="text/html; charset=utf-8", extra=None, csp=CSP_PAGE): + if isinstance(corps, str): + corps = corps.encode() + self.send_response(code) + self.send_header("Content-Type", ctype) + self.send_header("Content-Length", str(len(corps))) + self.send_header("X-Content-Type-Options", "nosniff") + self.send_header("Referrer-Policy", "no-referrer") + self.send_header("X-Robots-Tag", "noindex, nofollow") + if not any(k.lower() == "cache-control" for k, _ in (extra or [])): + self.send_header("Cache-Control", "no-store") + if csp: + self.send_header("Content-Security-Policy", csp) + for k, v in (extra or []): + self.send_header(k, v) + self.end_headers() + if self.command != "HEAD": + self.wfile.write(corps) + + def json(self, code, obj, extra=None): + self.envoyer(code, json.dumps(obj, ensure_ascii=False), "application/json; charset=utf-8", extra) + + def corps_json(self, limite=32_000): + n = int(self.headers.get("Content-Length") or 0) + if n <= 0 or n > limite: + return None + try: + return json.loads(self.rfile.read(n)) + except Exception: + return None + + def session(self): + brut = self.headers.get("Cookie", "") + try: + tok = cookies.SimpleCookie(brut)[COOKIE].value + except Exception: + return None + h = hashlib.sha256(tok.encode()).hexdigest() + now = time.time() + s = self.c.execute("SELECT * FROM sessions WHERE token_hash=? AND expires_at>?", (h, now)).fetchone() + if not s: + return None + code = self.c.execute("SELECT * FROM codes WHERE id=?", (s["code_id"],)).fetchone() + if not code or not db.code_actif(code, now): # révocation / expiration immédiates + return None + return {"hash": h, "code": code} + + def csrf_ok(self): + if self.headers.get("X-Beta") != "1": + return False + o = self.headers.get("Origin") + return not o or urlsplit(o).netloc == self.headers.get("Host") + + def bloque(self, iph): + now = time.time() + n_ip = self.c.execute("SELECT COUNT(*) FROM attempts WHERE ip_hash=? AND ok=0 AND ts>?", (iph, now - FENETRE_S)).fetchone()[0] + n_all = self.c.execute("SELECT COUNT(*) FROM attempts WHERE ok=0 AND ts>?", (now - 3600,)).fetchone()[0] + return n_ip >= MAX_ECHECS_IP or n_all >= MAX_ECHECS_GLOBAL + + # --- routage ----------------------------------------------------- + def do_HEAD(self): + self.do_GET() + + def do_GET(self): + with self.server.verrou: + self._get() + + def do_POST(self): + with self.server.verrou: + self._post() + + def _get(self): + p = urlsplit(self.path).path + if not chemin_sur(p): + return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8") + if p == "/robots.txt": + return self.envoyer(200, "User-agent: *\nDisallow: /\n", "text/plain") + if p == "/__beta/healthz": + return self.json(200, {"ok": True}) + if p == "/__beta/gate": + return self.envoyer(200, (STATIC / "gate.html").read_bytes()) + if p == "/__beta/formulaire": + return self.envoyer(200, (STATIC / "formulaire.html").read_bytes()) + if p.startswith("/__beta/static/"): + return self.fichier(STATIC, p[len("/__beta/static/"):], cache=True) + if p.startswith("/assets/fonts/"): # polices : dossier fixe, woff2 uniquement + return self.fichier(RACINE / "assets" / "fonts", p[len("/assets/fonts/"):], ext=".woff2") + if p == "/assets/css/fonts.css": + return self.fichier(RACINE / "assets" / "css", "fonts.css") + if p.startswith("/assets/img/") and p[len("/assets/img/"):] in LOGOS: # logos : liste blanche + return self.fichier(RACINE / "assets" / "img", p[len("/assets/img/"):]) + s = self.session() + if not s: + if p.endswith(".html") or p == "/": + return self.envoyer(302, b"", extra=[("Location", "/__beta/gate")]) + return self.envoyer(401, "Accès réservé aux testeurs.", "text/plain; charset=utf-8") + if p.startswith("/__beta/avatar/"): + return self.avatar(p[len("/__beta/avatar/"):]) + if p == "/__beta/api/demo": + return self.json(200, self.flux_demo()) + if p == "/__beta/api/me": + return self.json(200, {"label": s["code"]["label"]}) + if p == "/__beta/logout": + return self.deconnecter(s) + if p.startswith("/__beta/"): + return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8") + self.fichier(RACINE, p.lstrip("/") or "index.html", app=True) + + def _post(self): + p = urlsplit(self.path).path + if not chemin_sur(p): + return self.json(404, {"erreur": "inconnu"}) + if not self.csrf_ok(): + return self.json(403, {"erreur": "requête refusée"}) + if p == "/__beta/api/enter": + return self.entrer() + if p == "/__beta/api/tester": + return self.formulaire_testeur() + s = self.session() + if not s: + return self.json(401, {"erreur": "session expirée, ressaisir le code"}) + if p == "/__beta/api/feedback": + return self.retour(s) + self.json(404, {"erreur": "inconnu"}) + + # --- fichiers ---------------------------------------------------- + def fichier(self, base, rel, cache=False, app=False, ext=None): + try: + if "\x00" in rel or "\\" in rel: + raise ValueError + cible = (base / rel).resolve() + parties = cible.relative_to(base.resolve()).parts + except Exception: + return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8") + if app and (not parties or parties[0] in DOSSIERS_INTERDITS or any(x.startswith(".") for x in parties)): + return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8") + if not cible.is_file() or cible.suffix.lower() not in EXT_OK or (ext and cible.suffix.lower() != ext): + return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8") + data = cible.read_bytes() + suf = cible.suffix.lower() + ctype = mimetypes.guess_type(cible.name)[0] or "application/octet-stream" + if suf == ".html": + txt = data.decode("utf-8", "replace") + if app: + txt = txt.replace("", INJECTION + "", 1) if "" in txt else txt + INJECTION + return self.envoyer(200, txt, "text/html; charset=utf-8", csp=CSP_APP if app else CSP_PAGE) + if suf == ".js": + ctype = "text/javascript; charset=utf-8" + extra = [("Cache-Control", "no-cache")] + self.envoyer(200, data, ctype, extra=extra, csp=None) + + # --- entrée par code --------------------------------------------- + def entrer(self): + iph = db.hacher_ip(self.ip()) + if self.bloque(iph): + db.journal(self.c, "entree_bloquee", None, iph, "trop d'échecs") + return self.json(429, {"erreur": "Trop de tentatives. Réessayez dans 15 minutes."}, + [("Retry-After", str(FENETRE_S))]) + d = self.corps_json(2000) or {} + saisi = str(d.get("code", ""))[:64] + row = db.verifier_code(self.c, saisi) if len(db.normaliser(saisi)) >= 8 else None + now = time.time() + if not row: + self.c.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,0,?)", (now, iph, "code invalide")) + self.c.commit() + db.journal(self.c, "entree_refusee", None, iph, "code invalide, révoqué ou expiré") + time.sleep(0.4) + return self.json(401, {"erreur": "Code invalide, révoqué ou expiré."}) + tok = secrets.token_urlsafe(32) + h = hashlib.sha256(tok.encode()).hexdigest() + exp = min(now + SESSION_S, row["expires_at"] or now + SESSION_S) + self.c.execute("INSERT INTO sessions VALUES(?,?,?,?,?)", (h, row["id"], now, exp, now)) + vieux = self.c.execute("SELECT token_hash FROM sessions WHERE code_id=? ORDER BY created_at DESC LIMIT -1 OFFSET ?", + (row["id"], row["max_sessions"])).fetchall() + for v in vieux: # limite de sessions simultanées : on retire les plus anciennes + self.c.execute("DELETE FROM sessions WHERE token_hash=?", (v[0],)) + self.c.execute("UPDATE codes SET uses=uses+1,last_used_at=? WHERE id=?", (now, row["id"])) + self.c.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,1,?)", (now, iph, "ok")) + self.c.commit() + db.journal(self.c, "entree_ok", row["id"], iph, None) + attrs = f"{COOKIE}={tok}; Path=/; HttpOnly; SameSite=Lax; Max-Age={int(exp - now)}" + if self.https(): + attrs += "; Secure" + self.json(200, {"ok": True, "suite": "/app.html"}, [("Set-Cookie", attrs)]) + + def deconnecter(self, s): + self.c.execute("DELETE FROM sessions WHERE token_hash=?", (s["hash"],)) + self.c.commit() + db.journal(self.c, "sortie", s["code"]["id"], db.hacher_ip(self.ip())) + self.envoyer(302, b"", extra=[("Location", "/__beta/gate"), + ("Set-Cookie", f"{COOKIE}=; Path=/; Max-Age=0; HttpOnly; SameSite=Lax")]) + + # --- retours ----------------------------------------------------- + def retour(self, s): + d = self.corps_json(2_500_000) + if not d: + return self.json(400, {"erreur": "requête invalide"}) + texte = str(d.get("text", "")).strip()[:4000] + if len(texte) < 3: + return self.json(400, {"erreur": "Écrivez au moins quelques mots."}) + now = time.time() + n = self.c.execute("SELECT COUNT(*) FROM feedback WHERE code_id=? AND ts>?", (s["code"]["id"], now - 60)).fetchone()[0] + if n >= 10: + return self.json(429, {"erreur": "Un peu de calme : 10 retours par minute maximum."}) + kind = d.get("kind") if d.get("kind") in ("garder", "changer", "bug", "autre") else "autre" + shot = None + img = d.get("screenshot") + if img: + m = re.match(r"^data:image/(png|jpeg|webp);base64,([A-Za-z0-9+/=]+)$", str(img)) + if not m: + return self.json(400, {"erreur": "capture invalide"}) + brut = base64.b64decode(m.group(2)) + if len(brut) > 1_500_000: + return self.json(413, {"erreur": "capture trop lourde (1,5 Mo max)"}) + sig = {"png": b"\x89PNG", "jpeg": b"\xff\xd8\xff", "webp": b"RIFF"}[m.group(1)] + if not brut.startswith(sig): + return self.json(400, {"erreur": "capture invalide"}) + dossier = db.DATA / "retours" + dossier.mkdir(parents=True, exist_ok=True) + shot = f"{int(now)}-{secrets.token_hex(4)}.{'jpg' if m.group(1) == 'jpeg' else m.group(1)}" + (dossier / shot).write_bytes(brut) + cur = self.c.execute( + "INSERT INTO feedback(ts,code_id,page,text,shot,viewport,ua,kind) VALUES(?,?,?,?,?,?,?,?)", + (now, s["code"]["id"], "".join(ch for ch in str(d.get("page", "")) if unicodedata.category(ch)[0] != "C")[:200], texte, shot, + "".join(ch for ch in str(d.get("viewport", "")) if unicodedata.category(ch)[0] != "C")[:30], self.headers.get("User-Agent", "")[:200], kind)) + self.c.commit() + self.json(200, {"ok": True, "id": cur.lastrowid}) + + # --- formulaire testeur (version web du PDF) --------------------- + def formulaire_testeur(self): + iph = db.hacher_ip(self.ip()) + now = time.time() + n = self.c.execute("SELECT COUNT(*) FROM audit WHERE event='formulaire' AND ip_hash=? AND ts>?", (iph, now - 3600)).fetchone()[0] + if n >= 5: + return self.json(429, {"erreur": "Trop d'envois depuis ce réseau. Réessayez plus tard."}) + d = self.corps_json(8000) + if not d: + return self.json(400, {"erreur": "requête invalide"}) + if d.get("site_web"): # champ piège pour les robots + return self.json(200, {"ok": True}) + g = lambda k, n=120: str(d.get(k, "")).strip()[:n] + nom, prenom, email, tel, nais = g("nom"), g("prenom"), g("email", 254), g("tel", 20), g("naissance", 10) + err = [] + if any(a_controle(d.get(k, "")) for k in ("nom", "prenom", "parent_nom", "email", "parent_email", "tel", "naissance")): + return self.json(400, {"erreur": "caractères de contrôle interdits"}) + if not nom or not prenom: + err.append("nom et prénom requis") + if not EMAIL.match(email): + err.append("e-mail invalide") + if not TEL.match(tel): + err.append("téléphone invalide") + try: + a = age(nais) + if not 0 <= a < 120: + raise ValueError + except Exception: + return self.json(400, {"erreur": "date de naissance invalide (AAAA-MM-JJ)"}) + for k, lab in (("accord_participation", "accord de participation"), ("rgpd", "consentement RGPD"), + ("confidentialite", "engagement de confidentialité")): + if not d.get(k): + err.append(lab + " à cocher") + if a < 15: + err.append("la participation est réservée aux personnes de 15 ans ou plus") + mineur = 1 if a < 18 else 0 + pn, pe = g("parent_nom"), g("parent_email", 254) + if mineur and a >= 15 and (not pn or not EMAIL.match(pe) or not d.get("accord_parental")): + err.append("accord parental requis (nom, e-mail du responsable légal et case cochée)") + if err: + return self.json(400, {"erreur": "; ".join(err)}) + self.c.execute("INSERT INTO testers(ts,nom,prenom,email,tel,naissance,mineur,parent_nom,parent_email," + "accord_participation,rgpd,confidentialite,age_ok,suivi_reseaux,source) VALUES(?,?,?,?,?,?,?,?,?,1,1,1,1,?,?)", + (now, nom, prenom, email, tel, nais, mineur, pn if mineur else None, pe if mineur else None, + 1 if d.get("suivi_reseaux") else 0, "web")) + self.c.commit() + db.journal(self.c, "formulaire", None, iph, "mineur" if mineur else "majeur") + self.json(200, {"ok": True}) + + # --- démo -------------------------------------------------------- + def flux_demo(self): + q = self.c.execute + profils = [dict(r) for r in q("SELECT * FROM demo_profiles ORDER BY id")] + annonces = [dict(r) for r in q("SELECT * FROM demo_ads ORDER BY id")] + convs = [] + for r in q("SELECT * FROM demo_convs ORDER BY id").fetchall(): + c = dict(r) + c["messages"] = [dict(m) for m in q("SELECT id,sender,text,created_at FROM demo_msgs WHERE conv_id=? ORDER BY id", (r["id"],))] + convs.append(c) + act = [dict(r) for r in q("SELECT * FROM demo_activity ORDER BY id DESC LIMIT 15")] + return {"profiles": profils, "ads": annonces, "convs": convs, "activity": act, "ts": time.time()} + + def avatar(self, nom): + seed = re.sub(r"[^a-zA-Z0-9]", "", nom.replace(".svg", ""))[:40] or "x" + h = int(hashlib.sha256(seed.encode()).hexdigest()[:6], 16) + fonds = ["#8B9E90", "#E8D5C4", "#C9D3CB", "#D9C7B3", "#A9B8AD"] + ini = (seed[:1] or "?").upper() + svg = (f'' + f'' + f'{ini}') + self.envoyer(200, svg, "image/svg+xml", extra=[("Cache-Control", "public, max-age=3600")], csp=None) + + +class Serveur(ThreadingHTTPServer): + daemon_threads = True + + def __init__(self, addr, conn): + super().__init__(addr, Handler) + self.conn = conn + self.verrou = threading.RLock() + + +def main(): + host = os.environ.get("BETA_HOST", "127.0.0.1") + port = int(os.environ.get("BETA_PORT", "8830")) + conn = db.connect(check_same_thread=False) + srv = Serveur((host, port), conn) + print(f"Bêta JobRunner sur http://{host}:{port}/ (données : {db.DATA})", flush=True) + try: + srv.serve_forever() + except KeyboardInterrupt: + pass + + +if __name__ == "__main__": + main() diff --git a/beta/tests/test_http.py b/beta/tests/test_http.py new file mode 100644 index 0000000..bb75a71 --- /dev/null +++ b/beta/tests/test_http.py @@ -0,0 +1,141 @@ +"""Tests HTTP de la porte d'entrée, des retours et du formulaire (serveur réel, port libre).""" +import base64 +import http.client +import json +import os +import sys +import tempfile +import threading +import time +import unittest +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) +os.environ["BETA_DATA"] = str(Path(tempfile.mkdtemp()) / "data") +import db, server # noqa: E402 + +PNG = "data:image/png;base64," + base64.b64encode(b"\x89PNG\r\n\x1a\n" + b"0" * 50).decode() + + +class T(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.conn = db.connect(check_same_thread=False) + cls.srv = server.Serveur(("127.0.0.1", 0), cls.conn) + cls.port = cls.srv.server_address[1] + threading.Thread(target=cls.srv.serve_forever, daemon=True).start() + cls.id, cls.code = db.creer_code(cls.conn, "Testeur", 7) + + @classmethod + def tearDownClass(cls): + cls.srv.shutdown() + + def req(self, method, path, body=None, cookie=None, headers=None): + c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10) + h = {"X-Beta": "1", "Content-Type": "application/json"} + h.update(headers or {}) + if cookie: + h["Cookie"] = cookie + c.request(method, path, json.dumps(body) if body is not None else None, h) + r = c.getresponse() + data = r.read() + return r.status, r, data + + def entrer(self, code=None): + s, r, d = self.req("POST", "/__beta/api/enter", {"code": code or self.code}) + ck = (r.getheader("Set-Cookie") or "").split(";")[0] + return s, ck, r + + def test_1_sans_code(self): + s, r, _ = self.req("GET", "/app.html") + self.assertEqual((s, r.getheader("Location")), (302, "/__beta/gate")) + self.assertEqual(self.req("GET", "/assets/css/app.css")[0], 401) + self.assertEqual(self.req("GET", "/__beta/api/demo")[0], 401) + self.assertEqual(self.req("GET", "/__beta/gate")[0], 200) + self.assertEqual(self.req("GET", "/assets/fonts/chillax-latin-400-normal.woff2")[0], 200) + + def test_1b_traversee_sans_code(self): + chemins = ["/assets/fonts/../../beta/db.py", "/assets/fonts/%2e%2e/%2e%2e/beta/db.py", "/assets/fonts/..%2f..%2fbeta/db.py", + "/assets/fonts/%252e%252e/%252e%252e/beta/db.py", "/assets/img/logo.png/../../../beta/db.py", + "/assets/css/../../beta/server.py", "/assets/fonts/./chillax-latin-400-normal.woff2", + "/assets/fonts/..%5c..%5cbeta%5cdb.py", "/__beta/static/../../db.py", "/__beta/static/%2e%2e/db.py", + "/assets/img/logo-x.png", "/assets/fonts/chillax-latin-400-normal.woff2/../../css/app.css"] + for ch in chemins: + c = http.client.HTTPConnection("127.0.0.1", self.port) + c.putrequest("GET", ch, skip_accept_encoding=True); c.endheaders() + r = c.getresponse(); r.read() + self.assertIn(r.status, (404, 401), ch) + + def test_2_csrf(self): + c = http.client.HTTPConnection("127.0.0.1", self.port) + c.request("POST", "/__beta/api/enter", "{}", {"Content-Type": "application/json"}) + self.assertEqual(c.getresponse().status, 403) + + def test_3_entree_et_acces(self): + s, ck, r = self.entrer(self.code.lower().replace("-", " ")) + self.assertEqual(s, 200) + self.assertIn("HttpOnly", r.getheader("Set-Cookie")) + self.assertIn("SameSite=Lax", r.getheader("Set-Cookie")) + s, r, d = self.req("GET", "/app.html", cookie=ck) + self.assertEqual(s, 200) + self.assertIn(b"/__beta/static/beta.js", d) + self.assertIn("connect-src 'self'", r.getheader("Content-Security-Policy")) + for interdit in ("/beta/db.py", "/.git/config", "/docs/conv.nils.md", "/DOCUMENTATION.md", "/package.json", + "/../beta/db.py", "/%2e%2e/beta/db.py", "/beta/data/beta.sqlite"): + self.assertIn(self.req("GET", interdit, cookie=ck)[0], (404, 401), interdit) + s, _, d = self.req("GET", "/__beta/api/demo", cookie=ck) + self.assertEqual(s, 200) + self.assertIn("profiles", json.loads(d)) + + def test_4_retour(self): + _, ck, _ = self.entrer() + s, _, d = self.req("POST", "/__beta/api/feedback", {"text": "Le bouton est trop petit", "kind": "changer", "page": "/app.html\x1b", "viewport": "375x812", "screenshot": PNG}, ck) + self.assertEqual(s, 200, d) + self.assertTrue(list((db.DATA / "retours").glob("*.png"))) + self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "x"}, ck)[0], 400) + self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "abc", "screenshot": "data:image/png;base64,AAAA"}, ck)[0], 400) + self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "abc"})[0], 401) + row = self.conn.execute("SELECT page FROM feedback ORDER BY id DESC").fetchone() + self.assertNotIn("\x1b", row[0]) + + def test_5_revocation_immediate(self): + i, code = db.creer_code(self.conn, "Jetable", 7) + _, ck, _ = self.entrer(code) + self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 200) + self.conn.execute("UPDATE codes SET revoked_at=? WHERE id=?", (time.time(), i)); self.conn.commit() + self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 401) + self.assertEqual(self.entrer(code)[0], 401) + + def test_6_expiration(self): + i, code = db.creer_code(self.conn, "Court", 7) + self.conn.execute("UPDATE codes SET expires_at=? WHERE id=?", (time.time() - 5, i)); self.conn.commit() + self.assertEqual(self.entrer(code)[0], 401) + + def test_7_journal(self): + ev = {r[0] for r in self.conn.execute("SELECT event FROM audit")} + self.assertTrue({"code_cree", "entree_ok"} <= ev) + + def test_8_formulaire(self): + base = {"nom": "Durand", "prenom": "Zoé", "email": "zoe@example.org", "tel": "06 12 34 56 78", "naissance": "1990-04-02", + "accord_participation": True, "rgpd": True, "confidentialite": True} + self.assertEqual(self.req("POST", "/__beta/api/tester", base)[0], 200) + self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, naissance="2016-01-01"))[0], 400) # < 15 ans + mineur = dict(base, naissance=f"{time.localtime().tm_year - 16}-01-01") + self.assertEqual(self.req("POST", "/__beta/api/tester", mineur)[0], 400) # sans accord parental + ok = dict(mineur, parent_nom="Parent Durand", parent_email="p@example.org", accord_parental=True) + self.assertEqual(self.req("POST", "/__beta/api/tester", ok)[0], 200) + self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, rgpd=False))[0], 400) + self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, nom="A\x1b[2J"))[0], 400) # contrôle + self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, email="pas-un-mail"))[0], 400) + + def test_9_limite_tentatives_en_dernier(self): + self.conn.execute("DELETE FROM attempts"); self.conn.commit() + for _ in range(server.MAX_ECHECS_IP): + self.assertEqual(self.entrer("JRB-AAAA-AAAA-AAAA")[0], 401) + s, _, r = self.entrer() # même le bon code est refusé pendant le blocage + self.assertEqual(s, 429) + self.assertTrue(r.getheader("Retry-After")) + + +if __name__ == "__main__": + unittest.main(verbosity=2)