"""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 = (''
'')
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,
}
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
# 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.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})
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":
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()
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)
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("