Fichiers
jobrunner-html/beta/server.py
T

803 lignes
37 KiB
Python

"""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 shutil
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_CONC_IP = int(os.environ.get("BETA_MAX_CONC_IP", "2"))
DELAI_ECHEC = 0.4
DELAI_TOTAL = 20 # secondes : ligne de requête + en-têtes + corps, puis la socket est fermée
MAX_ECHECS_GLOBAL = int(os.environ.get("BETA_MAX_ECHECS_GLOBAL", "60"))
FAIT_CONFIANCE_PROXY = os.environ.get("BETA_TRUST_PROXY") == "1"
# Hôte de l'espace projet. Le vhost public de Caddy ne transmet comme Host que jobrunner.fr / www / beta :
# un en-tête X-Admin envoyé par un visiteur du site public ne suffit donc plus.
ADMIN_HOST = os.environ.get("BETA_ADMIN_HOST", "admin.jobrunner.fr").lower()
MAX_CAPTURES_JOUR = int(os.environ.get("BETA_MAX_CAPTURES_JOUR", "30")) # par testeur ou par code
MAX_CAPTURES_OCTETS = int(os.environ.get("BETA_MAX_CAPTURES_MO", "500")) * 1_000_000 # total du dossier
MIN_LIBRE_OCTETS = int(os.environ.get("BETA_MIN_LIBRE_GO", "5")) * 1_000_000_000
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("/"))
LIMITES_POST = {
"/__beta/api/enter": 2000,
"/__beta/api/tester": 8000,
"/__beta/api/feedback": 2_600_000,
"/_admin/api/codes/creer": 4000,
"/_admin/api/codes/supprimer": 1000,
"/_admin/api/testeurs/statut": 1000,
"/_admin/api/testeurs/supprimer": 1000,
"/__beta/logout": 100,
}
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 ConnVerrouillee:
"""Verrou autour des seuls appels à la base (jamais autour des lectures/écritures réseau)."""
def __init__(self, conn):
self._c, self._v = conn, threading.RLock()
def execute(self, *a):
with self._v:
return self._c.execute(*a)
def commit(self):
with self._v:
self._c.commit()
class Handler(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.0" # pas de keep-alive : une requête par connexion
timeout = 10 # client lent : la connexion est coupée, le serveur n'est jamais bloqué
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")
def setup(self):
super().setup()
# minuterie globale : un client qui goutte-à-goutte (ligne, en-têtes ou corps) est coupé
self._minuterie = threading.Timer(DELAI_TOTAL, self._couper)
self._minuterie.daemon = True
self._minuterie.start()
def _couper(self):
try:
self.request.shutdown(2)
self.request.close()
except OSError:
pass
def finish(self):
self._minuterie.cancel()
super().finish()
# --- 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 est_admin(self):
if self.headers.get("X-Admin") != "1":
return False
hote = (self.headers.get("Host") or "").strip().lower()
if ":" in hote and not hote.startswith("["):
hote = hote.rsplit(":", 1)[0] # port éventuel ; une IPv6 entre crochets ne vaut jamais ADMIN_HOST
return hote == ADMIN_HOST
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("Connection", "close")
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):
brut = getattr(self, "_corps", b"")
if not brut or len(brut) > limite:
return None
try:
return json.loads(brut)
except Exception:
return None
def session(self):
brut = self.headers.get("Cookie", "")
# Le navigateur peut envoyer plusieurs jrb_s (ancien cookie resté sur un autre chemin ou domaine) :
# SimpleCookie n'en garde qu'un, on les essaie donc tous.
jetons = [m.strip()[len(COOKIE) + 1:] for m in brut.split(";") if m.strip().startswith(COOKIE + "=")]
now = time.time()
s = None
for tok in jetons[:5]:
h = hashlib.sha256(tok.encode()).hexdigest()
s = self.c.execute("SELECT * FROM sessions WHERE token_hash=? AND expires_at>?", (h, now)).fetchone()
if s:
break
if not s:
return None
# Cas 1 : session testeur direct (inscription libre)
if s["tester_id"]:
tester = self.c.execute("SELECT * FROM testers WHERE id=?", (s["tester_id"],)).fetchone()
if not tester or not tester["actif"]:
return None
return {
"hash": h,
"tester": tester,
"code": {"id": s["code_id"] or s["tester_id"], "label": f"{tester['prenom']} {tester['nom']}"}
}
# Cas 2 : session code classique
if s["code_id"]:
code = self.c.execute("SELECT * FROM codes WHERE id=?", (s["code_id"],)).fetchone()
if not code or not db.code_actif(code, now):
return None
return {"hash": h, "code": code}
return None
def csrf_ok(self):
if self.est_admin():
return True
if self.headers.get("X-Beta") != "1":
return False
o = self.headers.get("Origin")
return not o or urlsplit(o).netloc in (self.headers.get("Host"), "admin.jobrunner.fr", "jobrunner.fr", "beta.jobrunner.fr")
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]
if n_all >= MAX_ECHECS_GLOBAL:
self._delai = 1.0 # le compteur global n'ajoute qu'un délai : un code valide passe toujours
return n_ip >= MAX_ECHECS_IP
# --- routage -----------------------------------------------------
def do_HEAD(self):
self.do_GET()
def do_GET(self):
self._get()
def lire_corps(self, limite):
"""Lit le corps avec plafond de taille ET délai total (10 s) ; None si refusé."""
try:
n = int(self.headers.get("Content-Length") or 0)
except ValueError:
return None
if n < 0 or n > limite:
return None
fin, buf = time.time() + 10, b""
while len(buf) < n:
reste = fin - time.time()
if reste <= 0:
return None
try:
self.connection.settimeout(reste)
ch = self.rfile.read1(min(65536, n - len(buf)))
except OSError:
return None
if not ch:
return None
buf += ch
return buf
def do_POST(self):
p = urlsplit(self.path).path
self._corps, self._delai = b"", 0
self.close_connection = True # on ne réutilise pas la connexion après un refus
if not chemin_sur(p) or p not in LIMITES_POST:
return self.json(404, {"erreur": "inconnu"})
if not self.csrf_ok():
return self.json(403, {"erreur": "requête refusée"})
if p == "/__beta/api/feedback":
if not self.session(): # authentification AVANT de lire un gros corps
return self.json(401, {"erreur": "session expirée, ressaisir le code"})
corps = self.lire_corps(LIMITES_POST[p])
if corps is None:
return self.json(413, {"erreur": "corps trop gros, trop lent ou invalide"})
self._corps = corps
self.close_connection = False
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})
s = self.session()
if p == "/__beta/gate":
# La gate redirige désormais vers le formulaire libre (ou direct sur l'app si connecté)
loc = "/app.html" if s else "/__beta/formulaire"
return self.envoyer(302, b"", extra=[("Location", loc)])
if p == "/__beta/formulaire":
if s:
return self.envoyer(302, b"", extra=[("Location", "/app.html")])
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/"):])
if p == "/_admin/api/codes/liste":
return self.admin_liste_codes()
if p == "/_admin/api/candidatures/liste":
return self.admin_liste_candidatures()
if not s:
if p.endswith(".html") or p == "/":
return self.envoyer(302, b"", extra=[("Location", "/__beta/formulaire")])
return self.envoyer(401, "Accès réservé aux testeurs inscrits.", "text/plain; charset=utf-8")
if p == "/":
return self.envoyer(302, b"", extra=[("Location", "/app.html")])
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": # F5 : un GET ne change plus l'état, déconnexion par POST seulement
return self.envoyer(405, "Utiliser le bouton Quitter.", "text/plain; charset=utf-8", extra=[("Allow", "POST")])
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()
if p == "/_admin/api/codes/creer":
return self.admin_creer_code()
if p == "/_admin/api/codes/supprimer":
return self.admin_supprimer_code()
if p == "/_admin/api/testeurs/statut":
return self.admin_statut_testeur()
if p == "/_admin/api/testeurs/supprimer":
return self.admin_supprimer_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)
if p == "/__beta/logout":
return self.deconnecter(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:
i = txt.lower().rfind("</body>") # le DERNIER : un </body> peut apparaître dans une chaîne JS
txt = txt[:i] + INJECTION + txt[i:] if i >= 0 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, srv = db.hacher_ip(self.ip()), self.server
with srv.verrou_ip: # concurrence bornée PAR IP (pas globale)
occupe = srv.conc.get(iph, 0) >= MAX_CONC_IP
if not occupe:
srv.conc[iph] = srv.conc.get(iph, 0) + 1
if occupe:
return self.json(429, {"erreur": "Trop de requêtes simultanées, réessayez."}, [("Retry-After", "5")])
try:
st, obj, extra, delai = self._entrer(iph)
finally:
with srv.verrou_ip:
srv.conc[iph] -= 1
if srv.conc[iph] <= 0:
del srv.conc[iph]
if delai:
time.sleep(delai) # AUCUN verrou ni sémaphore tenu pendant le délai
self.json(st, obj, extra)
def _entrer(self, iph):
with self.server.verrou_entree: # vérification de la limite + enregistrement : atomiques
bloque = self.bloque(iph)
tentative = None
if not bloque: # tentative « en attente » comptée comme échec tant qu'elle n'a pas réussi
tentative = self.c.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,0,?)",
(time.time(), iph, "en attente")).lastrowid
self.c.commit()
if bloque:
db.journal(self.c, "entree_bloquee", None, iph, "trop d'échecs")
return (429, {"erreur": "Trop de tentatives. Réessayez dans 15 minutes."}, [("Retry-After", str(FENETRE_S))], 0)
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("UPDATE attempts SET reason=? WHERE id=?", ("code invalide", tentative))
self.c.commit()
db.journal(self.c, "entree_refusee", None, iph, "code invalide, révoqué ou expiré")
return (401, {"erreur": "Code invalide, révoqué ou expiré."}, None, max(self._delai, DELAI_ECHEC))
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(token_hash,code_id,created_at,expires_at,last_seen) 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("UPDATE attempts SET ok=1, reason=? WHERE id=?", ("ok", tentative))
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"
return (200, {"ok": True, "suite": "/app.html"}, [("Set-Cookie", attrs)], self._delai) # saturation globale : délai seul
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.json(200, {"ok": True, "suite": "/__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(*self._filtre_auteur(s, "SELECT COUNT(*) FROM feedback WHERE ts>?", (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)
refus = self.capture_refusee(s, dossier, len(brut), now)
if refus:
return self.json(507 if "espace" in refus else 429, {"erreur": refus})
shot = f"{int(now)}-{secrets.token_hex(4)}.{'jpg' if m.group(1) == 'jpeg' else m.group(1)}"
(dossier / shot).write_bytes(brut)
tid = s["tester"]["id"] if s.get("tester") else None
cid = None if tid else s["code"]["id"] # testeur libre : pas de code, on ne mélange plus les deux identifiants
cur = self.c.execute(
"INSERT INTO feedback(ts,code_id,tester_id,page,text,shot,viewport,ua,kind) VALUES(?,?,?,?,?,?,?,?,?)",
(now, cid, tid, "".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})
@staticmethod
def _filtre_auteur(s, sql, args):
if s.get("tester"):
return sql + " AND tester_id=?", args + (s["tester"]["id"],)
return sql + " AND code_id=? AND tester_id IS NULL", args + (s["code"]["id"],)
def capture_refusee(self, s, dossier, taille, now):
"""Plafonds de stockage des captures (M4) : par jour et par auteur, total du dossier, espace libre."""
n = self.c.execute(*self._filtre_auteur(s, "SELECT COUNT(*) FROM feedback WHERE shot IS NOT NULL AND ts>?",
(now - 86400,))).fetchone()[0]
if n >= MAX_CAPTURES_JOUR:
return f"{MAX_CAPTURES_JOUR} captures par jour maximum : envoyez le texte seul."
total = sum(f.stat().st_size for f in dossier.iterdir() if f.is_file())
if total + taille > MAX_CAPTURES_OCTETS:
return "Stockage des captures plein : envoyez le texte seul."
if shutil.disk_usage(dossier).free - taille < MIN_LIBRE_OCTETS:
return "Plus assez d'espace disque pour les captures : envoyez le texte seul."
return None
# --- formulaire testeur (version web du PDF) ---------------------
def formulaire_testeur(self):
raw_ip = self.ip()
iph = db.hacher_ip(raw_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 >= 10:
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, "suite": "/app.html"})
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 & conservation IP"),
("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)})
# Conservation légale LCEN de l'adresse IP pour 13 mois
expire_ip_at = now + db.RETENTION_IP_S
existant = self.c.execute("SELECT * FROM testers WHERE email=? ORDER BY id DESC LIMIT 1", (email,)).fetchone()
if existant:
if not existant["actif"]:
return self.json(403, {"erreur": "Votre accès a été désactivé par l'administration."})
tester_id = existant["id"]
self.c.execute(
"UPDATE testers SET nom=?, prenom=?, tel=?, naissance=?, mineur=?, parent_nom=?, parent_email=?, "
"ip=?, expire_ip_at=?, last_seen=?, source=? WHERE id=?",
(nom, prenom, tel, nais, mineur, pn if mineur else None, pe if mineur else None,
raw_ip, expire_ip_at, now, "web", tester_id)
)
else:
cur = 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,ip,expire_ip_at,actif,last_seen) "
"VALUES(?,?,?,?,?,?,?,?,?,1,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", raw_ip, expire_ip_at, now)
)
tester_id = cur.lastrowid
# Création immédiate de la session : inscription libre donne accès direct à la bêta
tok = secrets.token_urlsafe(32)
h = hashlib.sha256(tok.encode()).hexdigest()
exp = now + SESSION_S
self.c.execute("INSERT INTO sessions(token_hash,tester_id,code_id,ip,created_at,expires_at,last_seen) VALUES(?,?,?,?,?,?,?)",
(h, tester_id, None, raw_ip, now, exp, now))
self.c.commit()
db.journal(self.c, "inscription_libre", None, iph, f"tester_id={tester_id}")
attrs = f"{COOKIE}={tok}; Path=/; HttpOnly; SameSite=Lax; Max-Age={SESSION_S}"
if self.https():
attrs += "; Secure"
return self.json(200, {"ok": True, "suite": "/app.html"}, [("Set-Cookie", attrs)])
# --- administration (depuis admin.jobrunner.fr) -------------------
def admin_creer_code(self):
if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"})
try:
d = json.loads(self._corps.decode("utf-8"))
except Exception:
return self.json(400, {"erreur": "JSON invalide"})
label = str(d.get("label", "")).strip()
if not label:
return self.json(400, {"erreur": "Le nom ou référence du testeur est obligatoire."})
if a_controle(label):
return self.json(400, {"erreur": "Caractères non autorisés."})
if len(label) > 100:
return self.json(400, {"erreur": "Label trop long (max 100 car.)."})
jours = d.get("jours", 30)
try:
jours = int(jours)
if jours < 0 or jours > 365:
jours = 30
except (TypeError, ValueError):
jours = 30
sessions = d.get("sessions", 3)
try:
sessions = int(sessions)
if sessions < 1 or sessions > 10:
sessions = 3
except (TypeError, ValueError):
sessions = 3
cid, code = db.creer_code(self.c, label, jours, sessions)
exp = time.time() + jours * 86400 if jours else None
return self.json(200, {
"ok": True,
"id": cid,
"code": code,
"label": label,
"jours": jours,
"expires_at": exp,
"created_at": time.time()
})
def admin_supprimer_code(self):
if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"})
try:
d = json.loads(self._corps.decode("utf-8"))
code_id = int(d.get("id"))
except Exception:
return self.json(400, {"erreur": "ID de code invalide"})
self.c.execute("DELETE FROM sessions WHERE code_id=?", (code_id,))
self.c.execute("DELETE FROM codes WHERE id=?", (code_id,))
self.c.execute("UPDATE audit SET code_id=NULL WHERE code_id=?", (code_id,))
self.c.commit()
db.journal(self.c, "code_supprime", None, None, f"id={code_id}")
return self.json(200, {"ok": True, "id": code_id})
def admin_liste_candidatures(self):
if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"})
now = time.time()
lignes = []
for r in self.c.execute("SELECT id, ts, nom, prenom, email, tel, naissance, mineur, parent_nom, parent_email, suivi_reseaux, ip, expire_ip_at, actif, last_seen FROM testers ORDER BY id DESC LIMIT 100"):
nb_sessions = self.c.execute("SELECT COUNT(*) FROM sessions WHERE tester_id=? AND expires_at>?", (r["id"], now)).fetchone()[0]
lignes.append({
"id": r["id"],
"ts": r["ts"],
"nom": r["nom"],
"prenom": r["prenom"],
"email": r["email"],
"tel": r["tel"],
"naissance": r["naissance"],
"mineur": bool(r["mineur"]),
"parent_nom": r["parent_nom"],
"parent_email": r["parent_email"],
"suivi_reseaux": bool(r["suivi_reseaux"]),
"ip": r["ip"] or "",
"expire_ip_at": r["expire_ip_at"] or 0,
"actif": bool(r["actif"]),
"last_seen": r["last_seen"],
"sessions_actives": nb_sessions
})
return self.json(200, {"ok": True, "candidatures": lignes})
def admin_statut_testeur(self):
if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"})
try:
d = json.loads(self._corps.decode("utf-8"))
tester_id = int(d.get("id"))
actif = 1 if d.get("actif") else 0
except Exception:
return self.json(400, {"erreur": "Paramètres invalides"})
self.c.execute("UPDATE testers SET actif=? WHERE id=?", (actif, tester_id))
if not actif:
self.c.execute("DELETE FROM sessions WHERE tester_id=?", (tester_id,))
self.c.commit()
db.journal(self.c, "testeur_statut", None, None, f"id={tester_id} actif={actif}")
return self.json(200, {"ok": True, "id": tester_id, "actif": actif})
def admin_supprimer_testeur(self):
if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"})
try:
d = json.loads(self._corps.decode("utf-8"))
tester_id = int(d.get("id"))
except Exception:
return self.json(400, {"erreur": "ID invalide"})
n = db.effacer_testeur(self.c, tester_id)
db.journal(self.c, "testeur_supprime", None, None, f"id={tester_id} retours={n}")
return self.json(200, {"ok": True, "id": tester_id})
def admin_liste_codes(self):
if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"})
now = time.time()
lignes = []
for r in self.c.execute("SELECT id, label, created_at, expires_at, uses, last_used_at, revoked_at FROM codes ORDER BY id DESC LIMIT 50"):
st = "actif"
if r["revoked_at"]:
st = "révoqué"
elif r["expires_at"] and r["expires_at"] <= now:
st = "expiré"
lignes.append({
"id": r["id"],
"label": r["label"],
"created_at": r["created_at"],
"expires_at": r["expires_at"],
"uses": r["uses"],
"last_used_at": r["last_used_at"],
"status": st
})
return self.json(200, {"ok": True, "codes": lignes})
# --- 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 = ConnVerrouillee(conn)
self.conc, self.verrou_ip = {}, threading.Lock()
self.verrou_entree = threading.RLock()
self.connexions = threading.BoundedSemaphore(64) # plafond de connexions simultanées
def process_request(self, request, client_address):
if not self.connexions.acquire(blocking=False):
try:
request.close()
finally:
return
super().process_request(request, client_address)
def process_request_thread(self, request, client_address):
try:
super().process_request_thread(request, client_address)
finally:
self.connexions.release()
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()