665 lignes
29 KiB
Python
665 lignes
29 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 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"
|
|
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,
|
|
}
|
|
|
|
|
|
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 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", "")
|
|
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-Admin") == "1":
|
|
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})
|
|
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/"):])
|
|
if p == "/_admin/api/codes/liste":
|
|
return self.admin_liste_codes()
|
|
if p == "/_admin/api/candidatures/liste":
|
|
return self.admin_liste_candidatures()
|
|
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()
|
|
if p == "/_admin/api/codes/creer":
|
|
return self.admin_creer_code()
|
|
if p == "/_admin/api/codes/supprimer":
|
|
return self.admin_supprimer_code()
|
|
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:
|
|
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 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.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})
|
|
|
|
# --- administration (depuis admin.jobrunner.fr) -------------------
|
|
def admin_creer_code(self):
|
|
if self.headers.get("X-Admin") != "1":
|
|
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 self.headers.get("X-Admin") != "1":
|
|
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 self.headers.get("X-Admin") != "1":
|
|
return self.json(403, {"erreur": "accès réservé à l'administration"})
|
|
|
|
lignes = []
|
|
for r in self.c.execute("SELECT id, ts, nom, prenom, email, tel, naissance, mineur, parent_nom, parent_email, suivi_reseaux FROM testers ORDER BY id DESC LIMIT 100"):
|
|
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"]),
|
|
})
|
|
return self.json(200, {"ok": True, "candidatures": lignes})
|
|
|
|
def admin_liste_codes(self):
|
|
if self.headers.get("X-Admin") != "1":
|
|
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()
|