fix(beta): lecture du corps hors verrou, delai global sans blocage

Corps lu avant la base, verrou limite aux appels SQL, timeout 10 s ; le compteur global d echecs n ajoute qu un delai (un code valide passe toujours) ; injection avant le DERNIER body.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Sonnet 5.5 a révisé 2026-10-29 10:27:40 +01:00
1 Parent 3649917f23
révision 13910d8cfb
2 fichiers modifiés
+59 -12

Aucun fichier ne correspond à votre recherche

+38 -12
Voir le fichier
@@ -73,7 +73,23 @@ def age(naissance, ref=None):
return ref.year - y - ((ref.month, ref.day) < (m, d)) 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): class Handler(BaseHTTPRequestHandler):
timeout = 10 # client lent : la connexion est coupée, le serveur n'est jamais bloqué
server_version = "JobRunnerBeta" server_version = "JobRunnerBeta"
sys_version = "" sys_version = ""
@@ -119,11 +135,11 @@ class Handler(BaseHTTPRequestHandler):
self.envoyer(code, json.dumps(obj, ensure_ascii=False), "application/json; charset=utf-8", extra) self.envoyer(code, json.dumps(obj, ensure_ascii=False), "application/json; charset=utf-8", extra)
def corps_json(self, limite=32_000): def corps_json(self, limite=32_000):
n = int(self.headers.get("Content-Length") or 0) brut = getattr(self, "_corps", b"")
if n <= 0 or n > limite: if not brut or len(brut) > limite:
return None return None
try: try:
return json.loads(self.rfile.read(n)) return json.loads(brut)
except Exception: except Exception:
return None return None
@@ -153,19 +169,29 @@ class Handler(BaseHTTPRequestHandler):
now = time.time() 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_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] n_all = self.c.execute("SELECT COUNT(*) FROM attempts WHERE ok=0 AND ts>?", (now - 3600,)).fetchone()[0]
return n_ip >= MAX_ECHECS_IP or n_all >= MAX_ECHECS_GLOBAL 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 ----------------------------------------------------- # --- routage -----------------------------------------------------
def do_HEAD(self): def do_HEAD(self):
self.do_GET() self.do_GET()
def do_GET(self): def do_GET(self):
with self.server.verrou: self._get()
self._get()
def do_POST(self): def do_POST(self):
with self.server.verrou: # le corps est lu AVANT toute opération sur la base (un client lent ne bloque personne)
self._post() 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
self._post()
if self._delai:
time.sleep(self._delai) # hors de tout verrou (la réponse est déjà écrite)
def _get(self): def _get(self):
p = urlsplit(self.path).path p = urlsplit(self.path).path
@@ -240,7 +266,8 @@ class Handler(BaseHTTPRequestHandler):
if suf == ".html": if suf == ".html":
txt = data.decode("utf-8", "replace") txt = data.decode("utf-8", "replace")
if app: if app:
txt = txt.replace("</body>", INJECTION + "</body>", 1) if "</body>" in txt else txt + INJECTION i = txt.lower().rfind("</body>") # le DERNIER : un </body> peut apparaître dans une chaîne JS
txt = txt[:i] + INJECTION + txt[i:] if i >= 0 else txt + INJECTION
return self.envoyer(200, txt, "text/html; charset=utf-8", csp=CSP_APP if app else CSP_PAGE) return self.envoyer(200, txt, "text/html; charset=utf-8", csp=CSP_APP if app else CSP_PAGE)
if suf == ".js": if suf == ".js":
ctype = "text/javascript; charset=utf-8" ctype = "text/javascript; charset=utf-8"
@@ -262,7 +289,7 @@ class Handler(BaseHTTPRequestHandler):
self.c.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,0,?)", (now, iph, "code invalide")) self.c.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,0,?)", (now, iph, "code invalide"))
self.c.commit() self.c.commit()
db.journal(self.c, "entree_refusee", None, iph, "code invalide, révoqué ou expiré") db.journal(self.c, "entree_refusee", None, iph, "code invalide, révoqué ou expiré")
time.sleep(0.4) self._delai = max(self._delai, 0.4)
return self.json(401, {"erreur": "Code invalide, révoqué ou expiré."}) return self.json(401, {"erreur": "Code invalide, révoqué ou expiré."})
tok = secrets.token_urlsafe(32) tok = secrets.token_urlsafe(32)
h = hashlib.sha256(tok.encode()).hexdigest() h = hashlib.sha256(tok.encode()).hexdigest()
@@ -402,8 +429,7 @@ class Serveur(ThreadingHTTPServer):
def __init__(self, addr, conn): def __init__(self, addr, conn):
super().__init__(addr, Handler) super().__init__(addr, Handler)
self.conn = conn self.conn = ConnVerrouillee(conn)
self.verrou = threading.RLock()
def main(): def main():
+21
Voir le fichier
@@ -14,6 +14,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
os.environ["BETA_DATA"] = str(Path(tempfile.mkdtemp()) / "data") os.environ["BETA_DATA"] = str(Path(tempfile.mkdtemp()) / "data")
import db, server # noqa: E402 import db, server # noqa: E402
CRLF = bytes([13, 10])
PNG = "data:image/png;base64," + base64.b64encode(b"\x89PNG\r\n\x1a\n" + b"0" * 50).decode() PNG = "data:image/png;base64," + base64.b64encode(b"\x89PNG\r\n\x1a\n" + b"0" * 50).decode()
@@ -21,6 +22,7 @@ class T(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.conn = db.connect(check_same_thread=False) cls.conn = db.connect(check_same_thread=False)
server.Handler.timeout = 3
cls.srv = server.Serveur(("127.0.0.1", 0), cls.conn) cls.srv = server.Serveur(("127.0.0.1", 0), cls.conn)
cls.port = cls.srv.server_address[1] cls.port = cls.srv.server_address[1]
threading.Thread(target=cls.srv.serve_forever, daemon=True).start() threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
@@ -128,6 +130,25 @@ class T(unittest.TestCase):
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, nom="A\x1b[2J"))[0], 400) # contrôle self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, nom="A\x1b[2J"))[0], 400) # contrôle
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, email="pas-un-mail"))[0], 400) self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, email="pas-un-mail"))[0], 400)
def test_8b_client_lent_ne_bloque_pas(self):
import socket
lent = socket.create_connection(("127.0.0.1", self.port))
lent.sendall(b"POST /__beta/api/enter HTTP/1.1"+CRLF+b"Host: x"+CRLF+b"X-Beta: 1"+CRLF+b"Content-Length: 100"+CRLF+CRLF+b"{")
t0 = time.time()
s, _, _ = self.req("GET", "/__beta/healthz")
s2, ck, _ = self.entrer()
self.assertEqual((s, s2), (200, 200))
self.assertLess(time.time() - t0, 2)
lent.close()
def test_8c_saturation_globale_laisse_passer_code_valide(self):
self.conn.execute("DELETE FROM attempts")
for i in range(server.MAX_ECHECS_GLOBAL + 5):
self.conn.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,0,'x')", (time.time(), f"autre{i}"))
self.conn.commit()
s, ck, _ = self.entrer()
self.assertEqual(s, 200)
def test_9_limite_tentatives_en_dernier(self): def test_9_limite_tentatives_en_dernier(self):
self.conn.execute("DELETE FROM attempts"); self.conn.commit() self.conn.execute("DELETE FROM attempts"); self.conn.commit()
for _ in range(server.MAX_ECHECS_IP): for _ in range(server.MAX_ECHECS_IP):