diff --git a/beta/README.md b/beta/README.md index e04d299..5586199 100644 --- a/beta/README.md +++ b/beta/README.md @@ -15,4 +15,5 @@ tentatives par IP (6 par 15 min), journal, révocation immédiate, CSP `connect- vers un prestataire de paiement), données de démo dans des tables `demo_*` séparées. Droits POSIX (dossier 0700, fichiers 0600) vérifiés par `test_droits.py` sous Linux uniquement ; sous Windows ils n'ont pas d'effet : s'appuyer sur le profil utilisateur. +Ne jamais exposer ce serveur directement : écoute 127.0.0.1, derrière Caddy seulement. Déploiement : `beta/deploiement/PLAN.md` (non appliqué). diff --git a/beta/deploiement/Caddyfile.beta.exemple b/beta/deploiement/Caddyfile.beta.exemple index 692abcd..193521f 100644 --- a/beta/deploiement/Caddyfile.beta.exemple +++ b/beta/deploiement/Caddyfile.beta.exemple @@ -1,6 +1,19 @@ # EXEMPLE — NON APPLIQUÉ. À adapter puis à appliquer par Théo (sudo) après accord de Nils. # Bloc à ajouter au Caddyfile du VPS, À CÔTÉ du bloc jobrunner.fr existant (qui reste protégé # par basic_auth, inchangé). +# Options globales (bloc en tête du Caddyfile : à FUSIONNER avec l'existant, pas à dupliquer) +{ + servers { + timeouts { + read_header 10s + read_body 15s + write 20s + idle 15s + } + max_header_size 16KB + } +} + beta.jobrunner.fr { encode zstd gzip header { @@ -9,7 +22,7 @@ beta.jobrunner.fr { Referrer-Policy no-referrer X-Robots-Tag "noindex, nofollow" } - # Le serveur de la bêta (cornafserver) n'écoute que sur l'interface WireGuard. + # Chaîne : ce Caddy (VPS) -> wg -> Caddy de cornafserver -> Python sur 127.0.0.1:8830 (jamais exposé). # : à lire sur le serveur (ip a show wg1), ne pas deviner. reverse_proxy :8830 { header_up X-Forwarded-For {remote_host} diff --git a/beta/deploiement/PLAN.md b/beta/deploiement/PLAN.md index 9b9edec..2bc4f57 100644 --- a/beta/deploiement/PLAN.md +++ b/beta/deploiement/PLAN.md @@ -18,6 +18,14 @@ Rien de ce dossier n'a été exécuté sur un serveur. Tout est à valider avec 5. Vérifications : `/` redirige vers `/__beta/gate`, un mauvais code est refusé puis limité, un bon code entre, `/beta/db.py` et `/.git/config` donnent 404, aucun appel sortant (CSP `connect-src 'self'`). 6. Pré-requis : page 404 commune (note du 27/10) non appliquée sur jobrunner.fr : à voir avec Nils. +## Exposition : UNIQUEMENT derrière Caddy (obligatoire) +Le serveur Python (`http.server`) n'est pas fait pour Internet. Règles : +- il écoute sur `127.0.0.1` uniquement (`BETA_HOST=127.0.0.1`), jamais sur 0.0.0.0 ni sur une IP publique ; +- seul un Caddy le joint. Le VPS et cornafserver étant deux machines : VPS Caddy (public, TLS) -> WireGuard -> **second Caddy sur cornafserver** (écoute sur l'IP wg1) -> `127.0.0.1:8830`. Les limites ci-dessous se posent dans le Caddy qui est le plus proche du client (VPS) ET dans celui de cornafserver ; +- `BETA_TRUST_PROXY=1` seulement dans cette chaîne (le serveur lit le DERNIER `X-Forwarded-For`, ajouté par Caddy) ; +- limites Caddy explicites (voir `Caddyfile.beta.exemple`) : `timeouts { read_header 10s, read_body 15s, write 20s, idle 15s }`, `request_body max_size 3MB` (le serveur borne en plus : 2 ko /enter, 8 ko /tester, 2,6 Mo /feedback après session), `max_header_size`. Limite de connexions par IP : pas dans Caddy de base ; soit plugin `caddy-ratelimit`, soit règle `nftables ct count` (sudo Théo) : à choisir, non faite ; +- défenses déjà dans le serveur : délai total 20 s (ligne + en-têtes + corps, socket fermée), pas de keep-alive, 64 connexions max, 2 requêtes /enter simultanées par IP, délais d'échec hors de tout verrou. + ## Retour arrière Retirer le bloc Caddy, `systemctl --user stop jobrunner-beta jobrunner-beta-bots`, supprimer l'enregistrement DNS, supprimer `~/jobrunner-beta-data` (retours, testeurs : données personnelles). diff --git a/beta/deploiement/jobrunner-beta.service.exemple b/beta/deploiement/jobrunner-beta.service.exemple index dc681d3..7d70973 100644 --- a/beta/deploiement/jobrunner-beta.service.exemple +++ b/beta/deploiement/jobrunner-beta.service.exemple @@ -4,7 +4,7 @@ Description=JobRunner bêta (serveur Python, porte d'entrée par code) [Service] WorkingDirectory=%h/jobrunner-beta -Environment=BETA_HOST= +Environment=BETA_HOST=127.0.0.1 Environment=BETA_PORT=8830 Environment=BETA_TRUST_PROXY=1 Environment=BETA_DATA=%h/jobrunner-beta-data diff --git a/beta/server.py b/beta/server.py index 6f45519..78464a8 100644 --- a/beta/server.py +++ b/beta/server.py @@ -33,6 +33,9 @@ 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"} @@ -92,6 +95,7 @@ class ConnVerrouillee: 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 = "" @@ -100,6 +104,24 @@ class Handler(BaseHTTPRequestHandler): 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): @@ -121,6 +143,7 @@ class Handler(BaseHTTPRequestHandler): 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") @@ -307,16 +330,25 @@ class Handler(BaseHTTPRequestHandler): # --- entrée par code --------------------------------------------- def entrer(self): - sem = self.server.sem_entree # concurrence bornée, tenue aussi pendant les délais - if not sem.acquire(timeout=2): - return self.json(429, {"erreur": "Serveur occupé, réessayez."}, [("Retry-After", "5")]) + 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: - return self._entrer() + st, obj, extra, delai = self._entrer(iph) finally: - sem.release() + 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 = db.hacher_ip(self.ip()) + def _entrer(self, iph): with self.server.verrou_entree: # vérification de la limite + enregistrement : atomiques bloque = self.bloque(iph) tentative = None @@ -326,8 +358,7 @@ class Handler(BaseHTTPRequestHandler): self.c.commit() if bloque: 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))]) + 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 @@ -336,10 +367,7 @@ class Handler(BaseHTTPRequestHandler): 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é") - time.sleep(max(self._delai, 0.4)) # dans le sémaphore, hors verrou base - return self.json(401, {"erreur": "Code invalide, révoqué ou expiré."}) - if self._delai: - time.sleep(self._delai) # saturation globale : simple délai, le code valide passe + 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) @@ -355,7 +383,7 @@ class Handler(BaseHTTPRequestHandler): 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)]) + 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"],)) @@ -479,7 +507,7 @@ class Serveur(ThreadingHTTPServer): def __init__(self, addr, conn): super().__init__(addr, Handler) self.conn = ConnVerrouillee(conn) - self.sem_entree = threading.BoundedSemaphore(4) + self.conc, self.verrou_ip = {}, threading.Lock() self.verrou_entree = threading.RLock() self.connexions = threading.BoundedSemaphore(64) # plafond de connexions simultanées diff --git a/beta/tests/test_http.py b/beta/tests/test_http.py index 4e7f57d..87f1bc5 100644 --- a/beta/tests/test_http.py +++ b/beta/tests/test_http.py @@ -23,6 +23,7 @@ class T(unittest.TestCase): def setUpClass(cls): cls.conn = db.connect(check_same_thread=False) server.Handler.timeout = 3 + server.Handler.protocol_version = "HTTP/1.0" 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() @@ -168,6 +169,42 @@ class T(unittest.TestCase): self.assertGreaterEqual(res.count(429), 20 - server.MAX_ECHECS_IP - 4) self.conn.execute("DELETE FROM attempts"); self.conn.commit() + def test_8f_delai_total_goutte_a_goutte(self): + import socket + server.DELAI_TOTAL = 2 + try: + sk = socket.create_connection(("127.0.0.1", self.port)); sk.settimeout(8) + sk.sendall(b"GET /__beta/healthz HTTP/1.1" + CRLF + b"Host: x") # en-têtes jamais terminés + t0 = time.time() + fin = False + for _ in range(6): + try: + sk.sendall(b"X"); time.sleep(0.5) + except OSError: + fin = True; break + self.assertTrue(fin or sk.recv(10) == b"") + self.assertLess(time.time() - t0, 6) + finally: + server.DELAI_TOTAL = 20 + + def test_8g_pas_de_keepalive(self): + s, r, _ = self.req("GET", "/__beta/healthz") + self.assertEqual(r.getheader("Connection"), "close") + + def test_8h_delai_hors_semaphore_et_concurrence_par_ip(self): + self.conn.execute("DELETE FROM attempts"); self.conn.commit() + old, oldd = server.MAX_CONC_IP, server.DELAI_ECHEC + server.MAX_CONC_IP, server.DELAI_ECHEC = 1, 1.5 + try: + th = threading.Thread(target=lambda: self.entrer("JRB-AAAA-AAAA-AAAA")); th.start() + time.sleep(0.4) # le raté dort (1,5 s) mais ne tient plus aucune place + t0 = time.time(); s, _, _ = self.entrer() + self.assertEqual(s, 200); self.assertLess(time.time() - t0, 1.0) + th.join() + finally: + server.MAX_CONC_IP, server.DELAI_ECHEC = old, oldd + self.assertEqual(self.srv.conc, {}) # compteurs nettoyés + def test_9_limite_tentatives_en_dernier(self): self.conn.execute("DELETE FROM attempts"); self.conn.commit() for _ in range(server.MAX_ECHECS_IP):