fix(beta): deni de service, concurrence par IP, delai total, pas de keep-alive, exposition derriere Caddy
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
15da7e1385
révision
7e23443f1b
6 fichiers modifiés
+104
-17
Aucun fichier ne correspond à votre recherche
@@ -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é).
|
||||
@@ -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é).
|
||||
# <IP_WG_CORNAFSERVER> : à lire sur le serveur (ip a show wg1), ne pas deviner.
|
||||
reverse_proxy <IP_WG_CORNAFSERVER>:8830 {
|
||||
header_up X-Forwarded-For {remote_host}
|
||||
|
||||
@@ -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).
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@ Description=JobRunner bêta (serveur Python, porte d'entrée par code)
|
||||
|
||||
[Service]
|
||||
WorkingDirectory=%h/jobrunner-beta
|
||||
Environment=BETA_HOST=<IP_WG_CORNAFSERVER>
|
||||
Environment=BETA_HOST=127.0.0.1
|
||||
Environment=BETA_PORT=8830
|
||||
Environment=BETA_TRUST_PROXY=1
|
||||
Environment=BETA_DATA=%h/jobrunner-beta-data
|
||||
|
||||
+43
-15
@@ -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
|
||||
|
||||
|
||||
@@ -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):
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur