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 à :
1 Parent
1fffd39e5c
révision
3649917f23
2 fichiers modifiés
+563
Aucun fichier ne correspond à votre recherche
@@ -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()
|
||||
@@ -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)
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur