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>
Cette révision appartient à :
Théo GastineletClaude Opus 5.5 a révisé 2026-10-31 11:45:45 +01:00
1 Parent 7148f3d04b
révision 1228bf47aa
5 fichiers modifiés
+233 -28

Aucun fichier ne correspond à votre recherche

+22
Voir le fichier
@@ -7,6 +7,8 @@
python beta/codes.py journal [--n 30] python beta/codes.py journal [--n 30]
python beta/codes.py retours [--n 30] python beta/codes.py retours [--n 30]
python beta/codes.py testeurs python beta/codes.py testeurs
python beta/codes.py effacer-testeur <id> [--oui]
python beta/codes.py purger --avant AAAA-MM-JJ [--appliquer]
Le code en clair n'est affiché qu'une seule fois, à la génération. Le code en clair n'est affiché qu'une seule fois, à la génération.
""" """
@@ -56,6 +58,9 @@ def main(argv=None):
j = sp.add_parser("journal"); j.add_argument("--n", type=int, default=30) j = sp.add_parser("journal"); j.add_argument("--n", type=int, default=30)
f = sp.add_parser("retours"); f.add_argument("--n", type=int, default=30) f = sp.add_parser("retours"); f.add_argument("--n", type=int, default=30)
sp.add_parser("testeurs") sp.add_parser("testeurs")
e = sp.add_parser("effacer-testeur"); e.add_argument("id", type=int); e.add_argument("--oui", action="store_true")
pu = sp.add_parser("purger"); pu.add_argument("--avant", required=True, help="AAAA-MM-JJ")
pu.add_argument("--appliquer", action="store_true", help="sans cette option : simulation seulement")
a = ap.parse_args(argv) a = ap.parse_args(argv)
c = db.connect() c = db.connect()
@@ -102,6 +107,23 @@ def main(argv=None):
for r_ in c.execute("SELECT f.*, c.label FROM feedback f LEFT JOIN codes c ON c.id=f.code_id ORDER BY f.id DESC LIMIT ?", (a.n,)): for r_ in c.execute("SELECT f.*, c.label FROM feedback f LEFT JOIN codes c ON c.id=f.code_id ORDER BY f.id DESC LIMIT ?", (a.n,)):
print(f"#{r_['id']} {fmt(r_['ts'])} [{propre(r_['kind'])}] {propre(r_['label'])} sur {propre(r_['page'])} ({propre(r_['viewport'])})" print(f"#{r_['id']} {fmt(r_['ts'])} [{propre(r_['kind'])}] {propre(r_['label'])} sur {propre(r_['page'])} ({propre(r_['viewport'])})"
f"{' capture: ' + propre(r_['shot']) if r_['shot'] else ''}\n {propre(r_['text'])}") f"{' capture: ' + propre(r_['shot']) if r_['shot'] else ''}\n {propre(r_['text'])}")
elif a.cmd == "effacer-testeur":
row = c.execute("SELECT * FROM testers WHERE id=?", (a.id,)).fetchone()
if not row:
sys.exit("Testeur introuvable.")
if not a.oui:
sys.exit(f"Effacerait #{a.id} {propre(row['prenom'])} {propre(row['nom'])}, ses sessions, retours et captures. Relancer avec --oui.")
n = db.effacer_testeur(c, a.id)
db.journal(c, "testeur_supprime", None, None, f"id={a.id} retours={n} (cli)")
print(f"Testeur #{a.id} effacé ({n} retours).")
elif a.cmd == "purger":
try:
avant = datetime.strptime(a.avant, "%Y-%m-%d").timestamp()
except ValueError:
sys.exit("Date attendue : AAAA-MM-JJ")
bilan = db.purger(c, avant, simulation=not a.appliquer)
print(("PURGE APPLIQUÉE : " if a.appliquer else "Simulation (rien supprimé) : ") +
", ".join(f"{k} {v}" for k, v in bilan.items()))
elif a.cmd == "testeurs": elif a.cmd == "testeurs":
for r_ in c.execute("SELECT * FROM testers ORDER BY id"): for r_ in c.execute("SELECT * FROM testers ORDER BY id"):
st = "ACTIF" if r_["actif"] else "SUSPENDU" st = "ACTIF" if r_["actif"] else "SUSPENDU"
+54 -1
Voir le fichier
@@ -63,7 +63,7 @@ CREATE TABLE IF NOT EXISTS attempts(
CREATE TABLE IF NOT EXISTS audit( CREATE TABLE IF NOT EXISTS audit(
id INTEGER PRIMARY KEY, ts REAL NOT NULL, event TEXT NOT NULL, code_id INTEGER, ip_hash TEXT, detail TEXT); id INTEGER PRIMARY KEY, ts REAL NOT NULL, event TEXT NOT NULL, code_id INTEGER, ip_hash TEXT, detail TEXT);
CREATE TABLE IF NOT EXISTS feedback( CREATE TABLE IF NOT EXISTS feedback(
id INTEGER PRIMARY KEY, ts REAL NOT NULL, code_id INTEGER, page TEXT, text TEXT NOT NULL, id INTEGER PRIMARY KEY, ts REAL NOT NULL, code_id INTEGER, tester_id INTEGER, page TEXT, text TEXT NOT NULL,
shot TEXT, viewport TEXT, ua TEXT, kind TEXT); shot TEXT, viewport TEXT, ua TEXT, kind TEXT);
CREATE TABLE IF NOT EXISTS testers( CREATE TABLE IF NOT EXISTS testers(
id INTEGER PRIMARY KEY, ts REAL NOT NULL, nom TEXT, prenom TEXT, email TEXT, tel TEXT, id INTEGER PRIMARY KEY, ts REAL NOT NULL, nom TEXT, prenom TEXT, email TEXT, tel TEXT,
@@ -109,6 +109,11 @@ def _migrer(c):
if "last_seen" not in cols_t: if "last_seen" not in cols_t:
c.execute("ALTER TABLE testers ADD COLUMN last_seen REAL") c.execute("ALTER TABLE testers ADD COLUMN last_seen REAL")
cols_f = [r[1] for r in c.execute("PRAGMA table_info(feedback)").fetchall()]
if "tester_id" not in cols_f:
c.execute("ALTER TABLE feedback ADD COLUMN tester_id INTEGER")
# Avant ce correctif, un testeur libre était rangé dans code_id avec son id de testeur :
# impossible de les distinguer à coup sûr, ces lignes anciennes sont laissées telles quelles.
cols_s = [r[1] for r in c.execute("PRAGMA table_info(sessions)").fetchall()] cols_s = [r[1] for r in c.execute("PRAGMA table_info(sessions)").fetchall()]
if "tester_id" not in cols_s: if "tester_id" not in cols_s:
c.execute("ALTER TABLE sessions ADD COLUMN tester_id INTEGER") c.execute("ALTER TABLE sessions ADD COLUMN tester_id INTEGER")
@@ -130,6 +135,54 @@ def purger_anciennes_ip(c):
pass pass
def _supprimer_captures(c, where, args):
n = 0
for r in c.execute(f"SELECT shot FROM feedback WHERE shot IS NOT NULL AND ({where})", args).fetchall():
f = Path(str(DATA)) / "retours" / Path(str(r[0])).name # nom de fichier seul, jamais de chemin
try:
f.unlink()
n += 1
except FileNotFoundError:
pass
return n
def effacer_testeur(c, tester_id):
"""Effacement individuel (droit RGPD) : testeur, sessions, retours et captures liés. Renvoie le nb de retours."""
_supprimer_captures(c, "tester_id=?", (tester_id,))
n = c.execute("DELETE FROM feedback WHERE tester_id=?", (tester_id,)).rowcount
c.execute("DELETE FROM sessions WHERE tester_id=?", (tester_id,))
c.execute("DELETE FROM testers WHERE id=?", (tester_id,))
c.commit()
return n
def purger(c, avant_ts, journaux_jours=30, audit_jours=183, simulation=True):
"""Purge des testeurs inscrits avant `avant_ts` (avec leurs retours et captures), des retours par code
antérieurs, des tentatives de plus de `journaux_jours` et du journal de plus de `audit_jours`.
Simulation par défaut : renvoie seulement le bilan."""
now = time.time()
ids = [r[0] for r in c.execute("SELECT id FROM testers WHERE ts < ?", (avant_ts,)).fetchall()]
bilan = {
"testeurs": len(ids),
"retours_testeurs": sum(c.execute("SELECT COUNT(*) FROM feedback WHERE tester_id=?", (i,)).fetchone()[0] for i in ids),
"retours_codes": c.execute("SELECT COUNT(*) FROM feedback WHERE tester_id IS NULL AND ts < ?", (avant_ts,)).fetchone()[0],
"tentatives": c.execute("SELECT COUNT(*) FROM attempts WHERE ts < ?", (now - journaux_jours * 86400,)).fetchone()[0],
"audit": c.execute("SELECT COUNT(*) FROM audit WHERE ts < ?", (now - audit_jours * 86400,)).fetchone()[0],
}
if simulation:
return bilan
for i in ids:
effacer_testeur(c, i)
_supprimer_captures(c, "tester_id IS NULL AND ts < ?", (avant_ts,))
c.execute("DELETE FROM feedback WHERE tester_id IS NULL AND ts < ?", (avant_ts,))
c.execute("DELETE FROM attempts WHERE ts < ?", (now - journaux_jours * 86400,))
c.execute("DELETE FROM audit WHERE ts < ?", (now - audit_jours * 86400,))
c.commit()
journal(c, "purge", None, None, " ".join(f"{k}={v}" for k, v in bilan.items()))
return bilan
def _ouvrir(path, check_same_thread): def _ouvrir(path, check_same_thread):
c = sqlite3.connect(str(path or dossier_prive() / "beta.sqlite"), timeout=10, check_same_thread=check_same_thread) c = sqlite3.connect(str(path or dossier_prive() / "beta.sqlite"), timeout=10, check_same_thread=check_same_thread)
c.row_factory = sqlite3.Row c.row_factory = sqlite3.Row
+58 -18
Voir le fichier
@@ -17,6 +17,7 @@ import secrets
import sys import sys
import threading import threading
import time import time
import shutil
import unicodedata import unicodedata
from datetime import date from datetime import date
from http import cookies from http import cookies
@@ -38,6 +39,12 @@ DELAI_ECHEC = 0.4
DELAI_TOTAL = 20 # secondes : ligne de requête + en-têtes + corps, puis la socket est fermée 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")) MAX_ECHECS_GLOBAL = int(os.environ.get("BETA_MAX_ECHECS_GLOBAL", "60"))
FAIT_CONFIANCE_PROXY = os.environ.get("BETA_TRUST_PROXY") == "1" FAIT_CONFIANCE_PROXY = os.environ.get("BETA_TRUST_PROXY") == "1"
# Hôte de l'espace projet. Le vhost public de Caddy ne transmet comme Host que jobrunner.fr / www / beta :
# un en-tête X-Admin envoyé par un visiteur du site public ne suffit donc plus.
ADMIN_HOST = os.environ.get("BETA_ADMIN_HOST", "admin.jobrunner.fr").lower()
MAX_CAPTURES_JOUR = int(os.environ.get("BETA_MAX_CAPTURES_JOUR", "30")) # par testeur ou par code
MAX_CAPTURES_OCTETS = int(os.environ.get("BETA_MAX_CAPTURES_MO", "500")) * 1_000_000 # total du dossier
MIN_LIBRE_OCTETS = int(os.environ.get("BETA_MIN_LIBRE_GO", "5")) * 1_000_000_000
EXT_OK = {".html", ".css", ".js", ".woff2", ".png", ".jpg", ".jpeg", ".svg", ".webp", ".ico", ".mp4", ".webm", ".gif", ".pdf"} EXT_OK = {".html", ".css", ".js", ".woff2", ".png", ".jpg", ".jpeg", ".svg", ".webp", ".ico", ".mp4", ".webm", ".gif", ".pdf"}
DOSSIERS_INTERDITS = {"beta", ".git", "docs", "node_modules", "design"} DOSSIERS_INTERDITS = {"beta", ".git", "docs", "node_modules", "design"}
CSP_APP = ("default-src 'self'; img-src 'self' https: data: blob:; media-src 'self' https: blob:; " CSP_APP = ("default-src 'self'; img-src 'self' https: data: blob:; media-src 'self' https: blob:; "
@@ -74,6 +81,7 @@ LIMITES_POST = {
"/_admin/api/codes/supprimer": 1000, "/_admin/api/codes/supprimer": 1000,
"/_admin/api/testeurs/statut": 1000, "/_admin/api/testeurs/statut": 1000,
"/_admin/api/testeurs/supprimer": 1000, "/_admin/api/testeurs/supprimer": 1000,
"/__beta/logout": 100,
} }
@@ -142,6 +150,14 @@ class Handler(BaseHTTPRequestHandler):
return xf.split(",")[-1].strip() # dernier saut = ajouté par Caddy return xf.split(",")[-1].strip() # dernier saut = ajouté par Caddy
return self.client_address[0] return self.client_address[0]
def est_admin(self):
if self.headers.get("X-Admin") != "1":
return False
hote = (self.headers.get("Host") or "").strip().lower()
if ":" in hote and not hote.startswith("["):
hote = hote.rsplit(":", 1)[0] # port éventuel ; une IPv6 entre crochets ne vaut jamais ADMIN_HOST
return hote == ADMIN_HOST
def https(self): def https(self):
return FAIT_CONFIANCE_PROXY and self.headers.get("X-Forwarded-Proto") == "https" return FAIT_CONFIANCE_PROXY and self.headers.get("X-Forwarded-Proto") == "https"
@@ -207,7 +223,7 @@ class Handler(BaseHTTPRequestHandler):
return None return None
def csrf_ok(self): def csrf_ok(self):
if self.headers.get("X-Admin") == "1": if self.est_admin():
return True return True
if self.headers.get("X-Beta") != "1": if self.headers.get("X-Beta") != "1":
return False return False
@@ -311,8 +327,8 @@ class Handler(BaseHTTPRequestHandler):
return self.json(200, self.flux_demo()) return self.json(200, self.flux_demo())
if p == "/__beta/api/me": if p == "/__beta/api/me":
return self.json(200, {"label": s["code"]["label"]}) return self.json(200, {"label": s["code"]["label"]})
if p == "/__beta/logout": if p == "/__beta/logout": # F5 : un GET ne change plus l'état, déconnexion par POST seulement
return self.deconnecter(s) return self.envoyer(405, "Utiliser le bouton Quitter.", "text/plain; charset=utf-8", extra=[("Allow", "POST")])
if p.startswith("/__beta/"): if p.startswith("/__beta/"):
return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8") return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8")
self.fichier(RACINE, p.lstrip("/") or "index.html", app=True) self.fichier(RACINE, p.lstrip("/") or "index.html", app=True)
@@ -340,6 +356,8 @@ class Handler(BaseHTTPRequestHandler):
return self.json(401, {"erreur": "session expirée, ressaisir le code"}) return self.json(401, {"erreur": "session expirée, ressaisir le code"})
if p == "/__beta/api/feedback": if p == "/__beta/api/feedback":
return self.retour(s) return self.retour(s)
if p == "/__beta/logout":
return self.deconnecter(s)
self.json(404, {"erreur": "inconnu"}) self.json(404, {"erreur": "inconnu"})
# --- fichiers ---------------------------------------------------- # --- fichiers ----------------------------------------------------
@@ -430,8 +448,8 @@ class Handler(BaseHTTPRequestHandler):
self.c.execute("DELETE FROM sessions WHERE token_hash=?", (s["hash"],)) self.c.execute("DELETE FROM sessions WHERE token_hash=?", (s["hash"],))
self.c.commit() self.c.commit()
db.journal(self.c, "sortie", s["code"]["id"], db.hacher_ip(self.ip())) db.journal(self.c, "sortie", s["code"]["id"], db.hacher_ip(self.ip()))
self.envoyer(302, b"", extra=[("Location", "/__beta/gate"), self.json(200, {"ok": True, "suite": "/__beta/gate"},
("Set-Cookie", f"{COOKIE}=; Path=/; Max-Age=0; HttpOnly; SameSite=Lax")]) [("Set-Cookie", f"{COOKIE}=; Path=/; Max-Age=0; HttpOnly; SameSite=Lax")])
# --- retours ----------------------------------------------------- # --- retours -----------------------------------------------------
def retour(self, s): def retour(self, s):
@@ -442,7 +460,7 @@ class Handler(BaseHTTPRequestHandler):
if len(texte) < 3: if len(texte) < 3:
return self.json(400, {"erreur": "Écrivez au moins quelques mots."}) return self.json(400, {"erreur": "Écrivez au moins quelques mots."})
now = time.time() now = time.time()
n = self.c.execute("SELECT COUNT(*) FROM feedback WHERE code_id=? AND ts>?", (s["code"]["id"], now - 60)).fetchone()[0] n = self.c.execute(*self._filtre_auteur(s, "SELECT COUNT(*) FROM feedback WHERE ts>?", (now - 60,))).fetchone()[0]
if n >= 10: if n >= 10:
return self.json(429, {"erreur": "Un peu de calme : 10 retours par minute maximum."}) return self.json(429, {"erreur": "Un peu de calme : 10 retours par minute maximum."})
kind = d.get("kind") if d.get("kind") in ("garder", "changer", "bug", "autre") else "autre" kind = d.get("kind") if d.get("kind") in ("garder", "changer", "bug", "autre") else "autre"
@@ -460,15 +478,39 @@ class Handler(BaseHTTPRequestHandler):
return self.json(400, {"erreur": "capture invalide"}) return self.json(400, {"erreur": "capture invalide"})
dossier = db.DATA / "retours" dossier = db.DATA / "retours"
dossier.mkdir(parents=True, exist_ok=True) dossier.mkdir(parents=True, exist_ok=True)
refus = self.capture_refusee(s, dossier, len(brut), now)
if refus:
return self.json(507 if "espace" in refus else 429, {"erreur": refus})
shot = f"{int(now)}-{secrets.token_hex(4)}.{'jpg' if m.group(1) == 'jpeg' else m.group(1)}" shot = f"{int(now)}-{secrets.token_hex(4)}.{'jpg' if m.group(1) == 'jpeg' else m.group(1)}"
(dossier / shot).write_bytes(brut) (dossier / shot).write_bytes(brut)
tid = s["tester"]["id"] if s.get("tester") else None
cid = None if tid else s["code"]["id"] # testeur libre : pas de code, on ne mélange plus les deux identifiants
cur = self.c.execute( cur = self.c.execute(
"INSERT INTO feedback(ts,code_id,page,text,shot,viewport,ua,kind) VALUES(?,?,?,?,?,?,?,?)", "INSERT INTO feedback(ts,code_id,tester_id,page,text,shot,viewport,ua,kind) VALUES(?,?,?,?,?,?,?,?,?)",
(now, s["code"]["id"], "".join(ch for ch in str(d.get("page", "")) if unicodedata.category(ch)[0] != "C")[:200], texte, shot, (now, cid, tid, "".join(ch for ch in str(d.get("page", "")) if unicodedata.category(ch)[0] != "C")[:200], texte, shot,
"".join(ch for ch in str(d.get("viewport", "")) if unicodedata.category(ch)[0] != "C")[:30], self.headers.get("User-Agent", "")[:200], kind)) "".join(ch for ch in str(d.get("viewport", "")) if unicodedata.category(ch)[0] != "C")[:30], self.headers.get("User-Agent", "")[:200], kind))
self.c.commit() self.c.commit()
self.json(200, {"ok": True, "id": cur.lastrowid}) self.json(200, {"ok": True, "id": cur.lastrowid})
@staticmethod
def _filtre_auteur(s, sql, args):
if s.get("tester"):
return sql + " AND tester_id=?", args + (s["tester"]["id"],)
return sql + " AND code_id=? AND tester_id IS NULL", args + (s["code"]["id"],)
def capture_refusee(self, s, dossier, taille, now):
"""Plafonds de stockage des captures (M4) : par jour et par auteur, total du dossier, espace libre."""
n = self.c.execute(*self._filtre_auteur(s, "SELECT COUNT(*) FROM feedback WHERE shot IS NOT NULL AND ts>?",
(now - 86400,))).fetchone()[0]
if n >= MAX_CAPTURES_JOUR:
return f"{MAX_CAPTURES_JOUR} captures par jour maximum : envoyez le texte seul."
total = sum(f.stat().st_size for f in dossier.iterdir() if f.is_file())
if total + taille > MAX_CAPTURES_OCTETS:
return "Stockage des captures plein : envoyez le texte seul."
if shutil.disk_usage(dossier).free - taille < MIN_LIBRE_OCTETS:
return "Plus assez d'espace disque pour les captures : envoyez le texte seul."
return None
# --- formulaire testeur (version web du PDF) --------------------- # --- formulaire testeur (version web du PDF) ---------------------
def formulaire_testeur(self): def formulaire_testeur(self):
raw_ip = self.ip() raw_ip = self.ip()
@@ -551,7 +593,7 @@ class Handler(BaseHTTPRequestHandler):
# --- administration (depuis admin.jobrunner.fr) ------------------- # --- administration (depuis admin.jobrunner.fr) -------------------
def admin_creer_code(self): def admin_creer_code(self):
if self.headers.get("X-Admin") != "1": if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"}) return self.json(403, {"erreur": "accès réservé à l'administration"})
try: try:
d = json.loads(self._corps.decode("utf-8")) d = json.loads(self._corps.decode("utf-8"))
@@ -596,7 +638,7 @@ class Handler(BaseHTTPRequestHandler):
}) })
def admin_supprimer_code(self): def admin_supprimer_code(self):
if self.headers.get("X-Admin") != "1": if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"}) return self.json(403, {"erreur": "accès réservé à l'administration"})
try: try:
d = json.loads(self._corps.decode("utf-8")) d = json.loads(self._corps.decode("utf-8"))
@@ -612,7 +654,7 @@ class Handler(BaseHTTPRequestHandler):
return self.json(200, {"ok": True, "id": code_id}) return self.json(200, {"ok": True, "id": code_id})
def admin_liste_candidatures(self): def admin_liste_candidatures(self):
if self.headers.get("X-Admin") != "1": if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"}) return self.json(403, {"erreur": "accès réservé à l'administration"})
now = time.time() now = time.time()
@@ -640,7 +682,7 @@ class Handler(BaseHTTPRequestHandler):
return self.json(200, {"ok": True, "candidatures": lignes}) return self.json(200, {"ok": True, "candidatures": lignes})
def admin_statut_testeur(self): def admin_statut_testeur(self):
if self.headers.get("X-Admin") != "1": if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"}) return self.json(403, {"erreur": "accès réservé à l'administration"})
try: try:
d = json.loads(self._corps.decode("utf-8")) d = json.loads(self._corps.decode("utf-8"))
@@ -657,7 +699,7 @@ class Handler(BaseHTTPRequestHandler):
return self.json(200, {"ok": True, "id": tester_id, "actif": actif}) return self.json(200, {"ok": True, "id": tester_id, "actif": actif})
def admin_supprimer_testeur(self): def admin_supprimer_testeur(self):
if self.headers.get("X-Admin") != "1": if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"}) return self.json(403, {"erreur": "accès réservé à l'administration"})
try: try:
d = json.loads(self._corps.decode("utf-8")) d = json.loads(self._corps.decode("utf-8"))
@@ -665,14 +707,12 @@ class Handler(BaseHTTPRequestHandler):
except Exception: except Exception:
return self.json(400, {"erreur": "ID invalide"}) return self.json(400, {"erreur": "ID invalide"})
self.c.execute("DELETE FROM sessions WHERE tester_id=?", (tester_id,)) n = db.effacer_testeur(self.c, tester_id)
self.c.execute("DELETE FROM testers WHERE id=?", (tester_id,)) db.journal(self.c, "testeur_supprime", None, None, f"id={tester_id} retours={n}")
self.c.commit()
db.journal(self.c, "testeur_supprime", None, None, f"id={tester_id}")
return self.json(200, {"ok": True, "id": tester_id}) return self.json(200, {"ok": True, "id": tester_id})
def admin_liste_codes(self): def admin_liste_codes(self):
if self.headers.get("X-Admin") != "1": if not self.est_admin():
return self.json(403, {"erreur": "accès réservé à l'administration"}) return self.json(403, {"erreur": "accès réservé à l'administration"})
now = time.time() now = time.time()
+6 -1
Voir le fichier
@@ -9,7 +9,12 @@
var b = el('div', { id: 'jrb-bandeau', role: 'status' }); var b = el('div', { id: 'jrb-bandeau', role: 'status' });
var badge = el('b', {}, 'BÊTA'); b.appendChild(badge); var badge = el('b', {}, 'BÊTA'); b.appendChild(badge);
b.appendChild(document.createTextNode('Données fictives · paiement SIMULÉ')); b.appendChild(document.createTextNode('Données fictives · paiement SIMULÉ'));
var out = el('a', { href: '/__beta/logout' }, 'Quitter'); b.appendChild(out); var out = el('a', { href: '#' }, 'Quitter'); b.appendChild(out);
out.addEventListener('click', function (ev) {
ev.preventDefault();
fetch('/__beta/logout', { method: 'POST', headers: { 'X-Beta': '1' }, credentials: 'same-origin' })
.then(function () { location.href = '/__beta/gate'; }, function () { location.href = '/__beta/gate'; });
});
document.body.insertBefore(b, document.body.firstChild); document.body.insertBefore(b, document.body.firstChild);
// --- Garde-fou paiement : aucun appel vers un prestataire de paiement --- // --- Garde-fou paiement : aucun appel vers un prestataire de paiement ---
+93 -8
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
ADMIN = {"X-Admin": "1", "Host": "admin.jobrunner.fr"}
CRLF = bytes([13, 10]) 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()
@@ -234,7 +235,7 @@ class T(unittest.TestCase):
self.assertEqual(s, 403) self.assertEqual(s, 403)
# 2. Avec header X-Admin : succès 200 # 2. Avec header X-Admin : succès 200
s, _, d = self.req("POST", "/_admin/api/codes/creer", {"label": "Testeur Admin", "jours": 14}, headers={"X-Admin": "1"}) s, _, d = self.req("POST", "/_admin/api/codes/creer", {"label": "Testeur Admin", "jours": 14}, headers=ADMIN)
self.assertEqual(s, 200) self.assertEqual(s, 200)
res = json.loads(d.decode()) res = json.loads(d.decode())
self.assertTrue(res.get("ok")) self.assertTrue(res.get("ok"))
@@ -243,7 +244,7 @@ class T(unittest.TestCase):
self.assertEqual(res.get("label"), "Testeur Admin") self.assertEqual(res.get("label"), "Testeur Admin")
# 3. Liste des codes # 3. Liste des codes
s, _, d = self.req("GET", "/_admin/api/codes/liste", headers={"X-Admin": "1"}) s, _, d = self.req("GET", "/_admin/api/codes/liste", headers=ADMIN)
self.assertEqual(s, 200) self.assertEqual(s, 200)
res = json.loads(d.decode()) res = json.loads(d.decode())
self.assertTrue(res.get("ok")) self.assertTrue(res.get("ok"))
@@ -252,21 +253,21 @@ class T(unittest.TestCase):
code_id = res["codes"][0]["id"] code_id = res["codes"][0]["id"]
# 4. Supprimer le code # 4. Supprimer le code
s, _, d = self.req("POST", "/_admin/api/codes/supprimer", {"id": code_id}, headers={"X-Admin": "1"}) s, _, d = self.req("POST", "/_admin/api/codes/supprimer", {"id": code_id}, headers=ADMIN)
self.assertEqual(s, 200) self.assertEqual(s, 200)
res = json.loads(d.decode()) res = json.loads(d.decode())
self.assertTrue(res.get("ok")) self.assertTrue(res.get("ok"))
self.assertEqual(res.get("id"), code_id) self.assertEqual(res.get("id"), code_id)
# Vérification qu'il n'est plus dans la liste # Vérification qu'il n'est plus dans la liste
s, _, d = self.req("GET", "/_admin/api/codes/liste", headers={"X-Admin": "1"}) s, _, d = self.req("GET", "/_admin/api/codes/liste", headers=ADMIN)
self.assertEqual(s, 200) self.assertEqual(s, 200)
res = json.loads(d.decode()) res = json.loads(d.decode())
labels_after = [c["label"] for c in res.get("codes", [])] labels_after = [c["label"] for c in res.get("codes", [])]
self.assertNotIn("Testeur Admin", labels_after) self.assertNotIn("Testeur Admin", labels_after)
# 5. Liste des testeurs (inscriptions) # 5. Liste des testeurs (inscriptions)
s, _, d = self.req("GET", "/_admin/api/candidatures/liste", headers={"X-Admin": "1"}) s, _, d = self.req("GET", "/_admin/api/candidatures/liste", headers=ADMIN)
self.assertEqual(s, 200) self.assertEqual(s, 200)
res = json.loads(d.decode()) res = json.loads(d.decode())
self.assertTrue(res.get("ok")) self.assertTrue(res.get("ok"))
@@ -279,21 +280,105 @@ class T(unittest.TestCase):
# 6. Suspendre le testeur # 6. Suspendre le testeur
tid = testeur["id"] tid = testeur["id"]
s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 0}, headers={"X-Admin": "1"}) s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 0}, headers=ADMIN)
self.assertEqual(s, 200) self.assertEqual(s, 200)
res = json.loads(d.decode()) res = json.loads(d.decode())
self.assertEqual(res.get("actif"), 0) self.assertEqual(res.get("actif"), 0)
# 7. Réactiver le testeur # 7. Réactiver le testeur
s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 1}, headers={"X-Admin": "1"}) s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 1}, headers=ADMIN)
self.assertEqual(s, 200) self.assertEqual(s, 200)
res = json.loads(d.decode()) res = json.loads(d.decode())
self.assertEqual(res.get("actif"), 1) self.assertEqual(res.get("actif"), 1)
# 8. Supprimer le testeur # 8. Supprimer le testeur
s, _, d = self.req("POST", "/_admin/api/testeurs/supprimer", {"id": tid}, headers={"X-Admin": "1"}) s, _, d = self.req("POST", "/_admin/api/testeurs/supprimer", {"id": tid}, headers=ADMIN)
self.assertEqual(s, 200) 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__": if __name__ == "__main__":
unittest.main(verbosity=2) unittest.main(verbosity=2)