"""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()