Fichiers
jobrunner-html/beta/tests/test_http.py
T
Théo GastineletClaude Opus 5.5 1228bf47aa fix(beta): API admin limitee a admin.jobrunner.fr, effacement et purge des testeurs, plafonds des captures, deconnexion en POST
- X-Admin seul ne suffit plus : Host doit etre admin.jobrunner.fr (le vhost public transmet les en-tetes du visiteur)
- feedback.tester_id : retours lies au testeur, effaces avec lui (captures comprises)
- codes.py effacer-testeur / purger (simulation par defaut)
- captures : 30/jour/auteur, 500 Mo au total, 5 Go libres minimum
- /__beta/logout en POST avec X-Beta (F5)
- 5 tests ajoutes (30 au total)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 11:45:45 +01:00

385 lignes
20 KiB
Python

"""Tests HTTP de la porte d'entrée, des retours et du formulaire (serveur réel, port libre)."""
import base64
import http.client
import json
import os
import sys
import tempfile
import threading
import time
import unittest
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
os.environ["BETA_DATA"] = str(Path(tempfile.mkdtemp()) / "data")
import db, server # noqa: E402
ADMIN = {"X-Admin": "1", "Host": "admin.jobrunner.fr"}
CRLF = bytes([13, 10])
PNG = "data:image/png;base64," + base64.b64encode(b"\x89PNG\r\n\x1a\n" + b"0" * 50).decode()
class T(unittest.TestCase):
@classmethod
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()
cls.id, cls.code = db.creer_code(cls.conn, "Testeur", 7)
@classmethod
def tearDownClass(cls):
cls.srv.shutdown()
def req(self, method, path, body=None, cookie=None, headers=None):
c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10)
h = {"X-Beta": "1", "Content-Type": "application/json"}
h.update(headers or {})
if cookie:
h["Cookie"] = cookie
c.request(method, path, json.dumps(body) if body is not None else None, h)
r = c.getresponse()
data = r.read()
return r.status, r, data
def entrer(self, code=None):
s, r, d = self.req("POST", "/__beta/api/enter", {"code": code or self.code})
ck = (r.getheader("Set-Cookie") or "").split(";")[0]
return s, ck, r
def test_1_sans_code(self):
s, r, _ = self.req("GET", "/app.html")
self.assertEqual((s, r.getheader("Location")), (302, "/__beta/formulaire"))
self.assertEqual(self.req("GET", "/assets/css/app.css")[0], 401)
self.assertEqual(self.req("GET", "/__beta/api/demo")[0], 401)
# La gate redirige vers le formulaire
s_g, r_g, _ = self.req("GET", "/__beta/gate")
self.assertEqual((s_g, r_g.getheader("Location")), (302, "/__beta/formulaire"))
self.assertEqual(self.req("GET", "/__beta/formulaire")[0], 200)
self.assertEqual(self.req("GET", "/assets/fonts/chillax-latin-400-normal.woff2")[0], 200)
def test_1b_traversee_sans_code(self):
chemins = ["/assets/fonts/../../beta/db.py", "/assets/fonts/%2e%2e/%2e%2e/beta/db.py", "/assets/fonts/..%2f..%2fbeta/db.py",
"/assets/fonts/%252e%252e/%252e%252e/beta/db.py", "/assets/img/logo.png/../../../beta/db.py",
"/assets/css/../../beta/server.py", "/assets/fonts/./chillax-latin-400-normal.woff2",
"/assets/fonts/..%5c..%5cbeta%5cdb.py", "/__beta/static/../../db.py", "/__beta/static/%2e%2e/db.py",
"/assets/img/logo-x.png", "/assets/fonts/chillax-latin-400-normal.woff2/../../css/app.css"]
for ch in chemins:
c = http.client.HTTPConnection("127.0.0.1", self.port)
c.putrequest("GET", ch, skip_accept_encoding=True); c.endheaders()
r = c.getresponse(); r.read()
self.assertIn(r.status, (404, 401), ch)
def test_2_csrf(self):
c = http.client.HTTPConnection("127.0.0.1", self.port)
c.request("POST", "/__beta/api/enter", "{}", {"Content-Type": "application/json"})
self.assertEqual(c.getresponse().status, 403)
def test_3_entree_et_acces(self):
s, ck, r = self.entrer(self.code.lower().replace("-", " "))
self.assertEqual(s, 200)
self.assertIn("HttpOnly", r.getheader("Set-Cookie"))
self.assertIn("SameSite=Lax", r.getheader("Set-Cookie"))
s, r, d = self.req("GET", "/app.html", cookie=ck)
self.assertEqual(s, 200)
self.assertIn(b"/__beta/static/beta.js", d)
self.assertIn("connect-src 'self'", r.getheader("Content-Security-Policy"))
for interdit in ("/beta/db.py", "/.git/config", "/docs/conv.nils.md", "/DOCUMENTATION.md", "/package.json",
"/../beta/db.py", "/%2e%2e/beta/db.py", "/beta/data/beta.sqlite"):
self.assertIn(self.req("GET", interdit, cookie=ck)[0], (404, 401), interdit)
s, _, d = self.req("GET", "/__beta/api/demo", cookie=ck)
self.assertEqual(s, 200)
self.assertIn("profiles", json.loads(d))
def test_4_retour(self):
_, ck, _ = self.entrer()
s, _, d = self.req("POST", "/__beta/api/feedback", {"text": "Le bouton est trop petit", "kind": "changer", "page": "/app.html\x1b", "viewport": "375x812", "screenshot": PNG}, ck)
self.assertEqual(s, 200, d)
self.assertTrue(list((db.DATA / "retours").glob("*.png")))
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "x"}, ck)[0], 400)
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "abc", "screenshot": "data:image/png;base64,AAAA"}, ck)[0], 400)
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "abc"})[0], 401)
row = self.conn.execute("SELECT page FROM feedback ORDER BY id DESC").fetchone()
self.assertNotIn("\x1b", row[0])
def test_5_revocation_immediate(self):
i, code = db.creer_code(self.conn, "Jetable", 7)
_, ck, _ = self.entrer(code)
self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 200)
self.conn.execute("UPDATE codes SET revoked_at=? WHERE id=?", (time.time(), i)); self.conn.commit()
self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 401)
self.assertEqual(self.entrer(code)[0], 401)
def test_6_expiration(self):
i, code = db.creer_code(self.conn, "Court", 7)
self.conn.execute("UPDATE codes SET expires_at=? WHERE id=?", (time.time() - 5, i)); self.conn.commit()
self.assertEqual(self.entrer(code)[0], 401)
def test_7_journal(self):
ev = {r[0] for r in self.conn.execute("SELECT event FROM audit")}
self.assertTrue({"code_cree", "entree_ok"} <= ev)
def test_8_formulaire(self):
base = {"nom": "Durand", "prenom": "Zoé", "email": "zoe@example.org", "tel": "06 12 34 56 78", "naissance": "1990-04-02",
"accord_participation": True, "rgpd": True, "confidentialite": True}
s, r, d = self.req("POST", "/__beta/api/tester", base)
self.assertEqual(s, 200)
res = json.loads(d.decode())
self.assertTrue(res.get("ok"))
self.assertEqual(res.get("suite"), "/app.html")
cookie = r.getheader("Set-Cookie")
self.assertTrue(cookie and "jrb_s=" in cookie)
# Accès direct avec le cookie délivré à l'inscription
self.assertEqual(self.req("GET", "/app.html", cookie=cookie)[0], 200)
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, naissance="2016-01-01"))[0], 400) # < 15 ans
mineur = dict(base, naissance=f"{time.localtime().tm_year - 16}-01-01", email="mineur@example.org")
self.assertEqual(self.req("POST", "/__beta/api/tester", mineur)[0], 400) # sans accord parental
ok = dict(mineur, parent_nom="Parent Durand", parent_email="p@example.org", accord_parental=True)
self.assertEqual(self.req("POST", "/__beta/api/tester", ok)[0], 200)
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, rgpd=False))[0], 400)
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)
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_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_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):
self.assertEqual(self.entrer("JRB-AAAA-AAAA-AAAA")[0], 401)
s, _, r = self.entrer() # même le bon code est refusé pendant le blocage
self.assertEqual(s, 429)
self.assertTrue(r.getheader("Retry-After"))
def test_admin_api(self):
# 1. Sans header X-Admin : refus 403
s, _, _ = self.req("POST", "/_admin/api/codes/creer", {"label": "Test 1"})
self.assertEqual(s, 403)
s, _, _ = self.req("GET", "/_admin/api/codes/liste")
self.assertEqual(s, 403)
# 2. Avec header X-Admin : succès 200
s, _, d = self.req("POST", "/_admin/api/codes/creer", {"label": "Testeur Admin", "jours": 14}, headers=ADMIN)
self.assertEqual(s, 200)
res = json.loads(d.decode())
self.assertTrue(res.get("ok"))
code = res.get("code")
self.assertTrue(code and code.startswith("JRB-"))
self.assertEqual(res.get("label"), "Testeur Admin")
# 3. Liste des codes
s, _, d = self.req("GET", "/_admin/api/codes/liste", headers=ADMIN)
self.assertEqual(s, 200)
res = json.loads(d.decode())
self.assertTrue(res.get("ok"))
labels = [c["label"] for c in res.get("codes", [])]
self.assertIn("Testeur Admin", labels)
code_id = res["codes"][0]["id"]
# 4. Supprimer le code
s, _, d = self.req("POST", "/_admin/api/codes/supprimer", {"id": code_id}, headers=ADMIN)
self.assertEqual(s, 200)
res = json.loads(d.decode())
self.assertTrue(res.get("ok"))
self.assertEqual(res.get("id"), code_id)
# Vérification qu'il n'est plus dans la liste
s, _, d = self.req("GET", "/_admin/api/codes/liste", headers=ADMIN)
self.assertEqual(s, 200)
res = json.loads(d.decode())
labels_after = [c["label"] for c in res.get("codes", [])]
self.assertNotIn("Testeur Admin", labels_after)
# 5. Liste des testeurs (inscriptions)
s, _, d = self.req("GET", "/_admin/api/candidatures/liste", headers=ADMIN)
self.assertEqual(s, 200)
res = json.loads(d.decode())
self.assertTrue(res.get("ok"))
cands = res.get("candidatures", [])
self.assertIsInstance(cands, list)
self.assertTrue(len(cands) >= 1)
testeur = cands[0]
self.assertTrue(testeur.get("ip"))
self.assertTrue(testeur.get("expire_ip_at") > 0)
# 6. Suspendre le testeur
tid = testeur["id"]
s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 0}, headers=ADMIN)
self.assertEqual(s, 200)
res = json.loads(d.decode())
self.assertEqual(res.get("actif"), 0)
# 7. Réactiver le testeur
s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 1}, headers=ADMIN)
self.assertEqual(s, 200)
res = json.loads(d.decode())
self.assertEqual(res.get("actif"), 1)
# 8. Supprimer le testeur
s, _, d = self.req("POST", "/_admin/api/testeurs/supprimer", {"id": tid}, headers=ADMIN)
self.assertEqual(s, 200)
def test_admin_refuse_depuis_le_site_public(self):
# Le vhost public de Caddy transmet tout en-tête du visiteur : X-Admin seul ne doit rien ouvrir.
for host in ("jobrunner.fr", "beta.jobrunner.fr", "www.jobrunner.fr", "127.0.0.1", "admin.jobrunner.fr.evil.com", "[::1]"):
h = {"X-Admin": "1", "Host": host}
self.assertEqual(self.req("GET", "/_admin/api/candidatures/liste", headers=h)[0], 403, host)
self.assertEqual(self.req("GET", "/_admin/api/codes/liste", headers=h)[0], 403, host)
self.assertEqual(self.req("POST", "/_admin/api/codes/creer", {"label": "Pirate"}, headers=h)[0], 403, host)
self.assertEqual(self.req("POST", "/_admin/api/testeurs/supprimer", {"id": 1}, headers=h)[0], 403, host)
self.assertEqual(self.req("GET", "/_admin/api/codes/liste", headers={"X-Admin": "1", "Host": "ADMIN.jobrunner.fr:443"})[0], 200)
self.assertEqual(self.req("GET", "/_admin/api/codes/liste", headers={"Host": "admin.jobrunner.fr"})[0], 403)
def test_8i_logout_post_seulement(self):
_, ck, _ = self.entrer()
self.assertEqual(self.req("GET", "/__beta/logout", cookie=ck)[0], 405)
self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 200) # GET n'a rien coupé
self.assertEqual(self.req("POST", "/__beta/logout", cookie=ck, headers={"X-Beta": "0"})[0], 403) # sans X-Beta
s, r, _ = self.req("POST", "/__beta/logout", cookie=ck)
self.assertEqual(s, 200)
self.assertIn("Max-Age=0", r.getheader("Set-Cookie"))
self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 401)
def test_effacement_testeur_avec_retours_et_captures(self):
base = {"nom": "Efface", "prenom": "Moi", "email": "efface@example.org", "tel": "06 00 00 00 00", "naissance": "1991-01-01",
"accord_participation": True, "rgpd": True, "confidentialite": True}
s, r, _ = self.req("POST", "/__beta/api/tester", base)
self.assertEqual(s, 200)
ck = r.getheader("Set-Cookie").split(";")[0]
s, _, d = self.req("POST", "/__beta/api/feedback", {"text": "retour a effacer", "screenshot": PNG}, ck)
self.assertEqual(s, 200, d)
fid = json.loads(d)["id"]
row = self.conn.execute("SELECT code_id, tester_id, shot FROM feedback WHERE id=?", (fid,)).fetchone()
self.assertIsNone(row[0]) # plus d'id de testeur rangé dans code_id
tid = row[1]
capture = db.DATA / "retours" / row[2]
self.assertTrue(capture.exists())
s, _, _ = self.req("POST", "/_admin/api/testeurs/supprimer", {"id": tid}, headers=ADMIN)
self.assertEqual(s, 200)
self.assertFalse(capture.exists())
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM feedback WHERE id=?", (fid,)).fetchone()[0], 0)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM testers WHERE id=?", (tid,)).fetchone()[0], 0)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM sessions WHERE tester_id=?", (tid,)).fetchone()[0], 0)
def test_purge_simulation_puis_application(self):
now = time.time()
vieux = now - 400 * 86400
cur = self.conn.execute("INSERT INTO testers(ts,nom,prenom,email,actif) VALUES(?,?,?,?,1)", (vieux, "Vieux", "T", "v@example.org"))
tid = cur.lastrowid
self.conn.execute("INSERT INTO feedback(ts,code_id,tester_id,text) VALUES(?,?,?,?)", (vieux, None, tid, "ancien"))
self.conn.execute("INSERT INTO attempts(ts,ip_hash,ok) VALUES(?,?,0)", (vieux, "x"))
self.conn.execute("INSERT INTO audit(ts,event) VALUES(?,?)", (vieux, "ancien"))
self.conn.commit()
avant = now - 200 * 86400
b = db.purger(self.conn, avant) # simulation par défaut
self.assertGreaterEqual(b["testeurs"], 1)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM testers WHERE id=?", (tid,)).fetchone()[0], 1)
db.purger(self.conn, avant, simulation=False)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM testers WHERE id=?", (tid,)).fetchone()[0], 0)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM feedback WHERE tester_id=?", (tid,)).fetchone()[0], 0)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM attempts WHERE ts<?", (avant,)).fetchone()[0], 0)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM audit WHERE event='ancien'").fetchone()[0], 0)
self.assertGreater(self.conn.execute("SELECT COUNT(*) FROM testers").fetchone()[0], 0) # les récents restent
def test_8j_plafond_captures(self):
i, code = db.creer_code(self.conn, "Captures", 7)
_, ck, _ = self.entrer(code)
ancien = server.MAX_CAPTURES_JOUR
server.MAX_CAPTURES_JOUR = 2
try:
for _ in range(2):
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "capture ok", "screenshot": PNG}, ck)[0], 200)
s, _, d = self.req("POST", "/__beta/api/feedback", {"text": "capture de trop", "screenshot": PNG}, ck)
self.assertEqual(s, 429, d)
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "texte seul toujours accepte"}, ck)[0], 200)
finally:
server.MAX_CAPTURES_JOUR = ancien
ancien = server.MIN_LIBRE_OCTETS
server.MIN_LIBRE_OCTETS = 10 ** 18 # disque « plein »
try:
_, ck2, _ = self.entrer(db.creer_code(self.conn, "Disque", 7)[1])
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "disque plein", "screenshot": PNG}, ck2)[0], 507)
finally:
server.MIN_LIBRE_OCTETS = ancien
if __name__ == "__main__":
unittest.main(verbosity=2)