fix(beta): serveur a porte d entree, traversee de chemin refusee

Segments . et .. (bruts ou encodes) refuses avant routage ; polices depuis un dossier fixe, logos en liste blanche ; tests de traversee.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Sonnet 5.5 a révisé 2026-10-29 10:25:51 +01:00
1 Parent 1fffd39e5c
révision 3649917f23
2 fichiers modifiés
+563

Aucun fichier ne correspond à votre recherche

+422
Voir le fichier
@@ -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 = ('<link rel="stylesheet" href="/__beta/static/beta.css">'
'<script src="/__beta/static/beta.js" defer></script>')
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("</body>", INJECTION + "</body>", 1) if "</body>" 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'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><rect width="100" height="100" fill="{fonds[h % 5]}"/>'
f'<circle cx="50" cy="38" r="18" fill="#F2F0E6"/><path d="M14 100c4-26 20-36 36-36s32 10 36 36z" fill="#F2F0E6"/>'
f'<text x="50" y="96" text-anchor="middle" font-size="14" fill="#2D2D2D" font-family="sans-serif">{ini}</text></svg>')
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()
+141
Voir le fichier
@@ -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)