fix(beta): limite de tentatives atomique, corps borne par route, plafond de connexions
Tentative en attente enregistree avant verification, semaphore sur /enter, limites 2000/8000 o avant authentification, feedback apres session, delai total de lecture 10 s, 64 connexions max. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
13910d8cfb
révision
914f422893
2 fichiers modifiés
+98
-13
Aucun fichier ne correspond à votre recherche
+79
-13
@@ -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():
|
||||
|
||||
@@ -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):
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur