diff --git a/beta/server.py b/beta/server.py index ff46fb3..6f45519 100644 --- a/beta/server.py +++ b/beta/server.py @@ -63,6 +63,9 @@ def chemin_sur(p): 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} + + def a_controle(v): return any(unicodedata.category(ch)[0] == "C" for ch in str(v)) @@ -180,18 +183,46 @@ class Handler(BaseHTTPRequestHandler): def do_GET(self): self._get() - def do_POST(self): - # le corps est lu AVANT toute opération sur la base (un client lent ne bloque personne) + 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) - self._corps = self.rfile.read(n) if 0 < n <= 2_600_000 else b"" - except (OSError, ValueError): - self.close_connection = True - return - self._delai = 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() - if self._delai: - time.sleep(self._delai) # hors de tout verrou (la réponse est déjà écrite) def _get(self): p = urlsplit(self.path).path @@ -276,8 +307,24 @@ 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")]) + try: + return self._entrer() + finally: + sem.release() + + def _entrer(self): iph = db.hacher_ip(self.ip()) - if self.bloque(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 self.json(429, {"erreur": "Trop de tentatives. Réessayez dans 15 minutes."}, [("Retry-After", str(FENETRE_S))]) @@ -286,11 +333,13 @@ class Handler(BaseHTTPRequestHandler): row = db.verifier_code(self.c, saisi) if len(db.normaliser(saisi)) >= 8 else None now = time.time() if not row: - self.c.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,0,?)", (now, iph, "code invalide")) + 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é") - self._delai = max(self._delai, 0.4) + 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 tok = secrets.token_urlsafe(32) h = hashlib.sha256(tok.encode()).hexdigest() exp = min(now + SESSION_S, row["expires_at"] or now + SESSION_S) @@ -300,7 +349,7 @@ class Handler(BaseHTTPRequestHandler): 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("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,1,?)", (now, iph, "ok")) + 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)}" @@ -430,6 +479,23 @@ class Serveur(ThreadingHTTPServer): def __init__(self, addr, conn): super().__init__(addr, Handler) self.conn = ConnVerrouillee(conn) + self.sem_entree = threading.BoundedSemaphore(4) + 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(): diff --git a/beta/tests/test_http.py b/beta/tests/test_http.py index 638fc4a..4e7f57d 100644 --- a/beta/tests/test_http.py +++ b/beta/tests/test_http.py @@ -149,6 +149,25 @@ class T(unittest.TestCase): s, ck, _ = self.entrer() self.assertEqual(s, 200) + def test_8d_limites_de_corps_avant_authentification(self): + import socket + for chemin, taille, attendu in (("/__beta/api/enter", 5000, 413), ("/__beta/api/tester", 20000, 413), ("/__beta/api/feedback", 100000, 401), ("/__beta/api/inconnu", 10, 404)): + sk = socket.create_connection(("127.0.0.1", self.port)); sk.settimeout(5) + sk.sendall(("POST " + chemin + " HTTP/1.1").encode() + CRLF + b"Host: x" + CRLF + b"X-Beta: 1" + CRLF + ("Content-Length: %d" % taille).encode() + CRLF + CRLF) + self.assertEqual(sk.recv(100)[9:12], str(attendu).encode(), chemin) # refusé sans lire le corps + sk.close() + + def test_8e_limite_atomique_sous_concurrence(self): + self.conn.execute("DELETE FROM attempts"); self.conn.commit() + res = [] + def tente(): + res.append(self.entrer("JRB-ZZZZ-ZZZZ-ZZZZ")[0]) + th = [threading.Thread(target=tente) for _ in range(20)] + [x.start() for x in th]; [x.join() for x in th] + self.assertLessEqual(res.count(401), server.MAX_ECHECS_IP, res) # jamais plus de N essais effectifs + self.assertGreaterEqual(res.count(429), 20 - server.MAX_ECHECS_IP - 4) + self.conn.execute("DELETE FROM attempts"); self.conn.commit() + def test_9_limite_tentatives_en_dernier(self): self.conn.execute("DELETE FROM attempts"); self.conn.commit() for _ in range(server.MAX_ECHECS_IP):