Le navigateur et le réseau sont des terrains hostiles : tout ce qui arrive au serveur peut être forgé, tout ce qui part vers le navigateur peut être détourné.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Défenseur du web
🎬 L'histoire
Un formateur de HashBox poste un commentaire dans le forum : <script>…</script>. Le lendemain, tous les visiteurs de la page exécutent son script. Un autre jour, un message envoyé à un membre contient un lien discret qui, une fois cliqué alors que le membre est connecté, supprime son compte.
« Dans les deux cas, le serveur a fait confiance, dit Sam : la première fois à ce que contient une page, la seconde à qui envoie une requête. Le web a ses attaques classiques, et ses défenses classiques. »
Tu apprends XSS, CSRF, SSRF, CORS, les en-têtes de sécurité, les cookies, la limitation de débit — et comment chacun se défend.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer XSS et l'empêcher par échappement et politique de contenu
- expliquer CSRF et utiliser jetons et cookies
SameSite - expliquer SSRF et valider une URL sortante
- configurer des cookies et des en-têtes de sécurité
- implémenter une limitation de débit (token bucket)
🧩 Défi d'échauffement (5 XP)
Un restaurant accepte les commandes par bon papier. Un client écrit sur son bon : « Table 4 : une soupe. Et dites au cuisinier de me remettre la caisse. » Si le serveur recopie le bon tel quel au cuisinier, que se passe-t-il ? Deuxième scénario : un inconnu glisse dans la poche d'un habitué, qui est déjà au comptoir, un bon « Annulez la réservation de Mme Durand » ; l'habitué le dépose sans le lire. Qui est trompé dans chaque cas ?
💡 Le concept
Le modèle de menace du web
Le navigateur exécute du code reçu de multiples sites. La règle de base est la politique de même origine (same-origin policy) : une page ne peut lire que les ressources de sa propre origine (schéma + hôte + port). Presque toutes les attaques web consistent à contourner ou exploiter cette frontière ou la confiance du serveur.
XSS : exécuter du code dans la page d'un autre
Le XSS (Cross-Site Scripting) : une donnée contrôlée par l'attaquant est insérée dans une page sans être neutralisée, et le navigateur la prend pour du code.
| Variante | Origine | Exemple |
|---|---|---|
| Stocké | enregistré (commentaire, profil) puis servi à tous | script dans un forum |
| Réfléchi | dans l'URL, renvoyé dans la réponse | ?q=<script>… |
| Basé sur le DOM | le JavaScript de la page l'insère sans précaution | innerHTML = location.hash |
Impact : vol de session, actions au nom de la victime, hameçonnage dans une page légitime.
Défenses :
- Encoder à la sortie, selon le contexte (HTML, attribut, JavaScript, URL, CSS) :
html.escapepour le texte HTML. - Utiliser des gabarits qui échappent par défaut (Jinja2 avec autoescape, frameworks modernes) ; éviter
innerHTML, préférertextContent. - CSP (Content-Security-Policy) : le serveur déclare d'où peuvent venir scripts et ressources (
script-src 'self') : limite les dégâts. - Cookies
HttpOnly: un script ne peut pas lire le cookie de session.
CSRF : forcer un utilisateur connecté à agir
Le CSRF (Cross-Site Request Forgery) : un site malveillant déclenche, depuis le navigateur de la victime déjà connectée, une requête vers ton site ; le navigateur joint automatiquement le cookie de session, et ton serveur croit à une action volontaire.
Défenses :
- cookies
SameSite=LaxouStrict: le navigateur n'envoie pas le cookie dans la plupart des requêtes inter-sites ; - jeton anti-CSRF : une valeur imprévisible liée à la session, exigée dans les requêtes qui modifient l'état (formulaires, en-tête) ;
- ne pas modifier l'état avec des requêtes
GET; - vérifier l'en-tête
Origin.
SSRF : faire parler le serveur à sa place
Le SSRF (Server-Side Request Forgery) : l'application récupère une URL fournie par l'utilisateur (aperçu de lien, import, webhook) ; l'attaquant fournit une adresse interne (http://169.254.169.254/ — service de métadonnées du cloud —, http://localhost:6379, réseau privé) et le serveur la lit pour lui.
Défenses : liste blanche de domaines si possible ; n'accepter que http/https ; résoudre le nom, vérifier que l'IP est publique (pas privée, boucle locale, lien local), se connecter à cette IP (contre le DNS rebinding) ; refuser ou revalider les redirections ; pas de réponse brute renvoyée à l'utilisateur ; segmentation réseau.
Cookies et en-têtes
| Attribut / en-tête | Rôle |
|---|---|
HttpOnly | le cookie n'est pas lisible par JavaScript |
Secure | envoyé uniquement en HTTPS |
SameSite=Lax/Strict | limite l'envoi inter-sites |
Max-Age / Expires | durée de vie |
Strict-Transport-Security (HSTS) | impose HTTPS |
Content-Security-Policy | limite les sources de contenu |
X-Content-Type-Options: nosniff | empêche le navigateur de deviner un type de fichier |
X-Frame-Options / frame-ancestors |
CORS
Le CORS (Cross-Origin Resource Sharing) permet à un serveur d'autoriser certains sites à lire ses réponses. Erreurs fréquentes : refléter l'en-tête Origin sans contrôle, Access-Control-Allow-Origin: * avec des données privées, autoriser les identifiants à toutes les origines. CORS n'est pas une protection côté serveur : il restreint seulement ce que les navigateurs laissent lire.
Limiter le débit
Contre la force brute, le bourrage d'identifiants et les abus : la limitation de débit (rate limiting). L'algorithme du seau à jetons (token bucket) autorise des salves tout en plafonnant le rythme moyen.
Les API en plus
- Authentifier et autoriser chaque appel (jeton, portée) ;
- valider les entrées (types, tailles, formats) ;
- ne pas renvoyer plus de champs que nécessaire (excessive data exposure) ;
- versionner et documenter ; journaliser ;
- attention à l'assignation en masse (accepter tous les champs du JSON).
🧠 Astuce : trois réflexes web : encoder à la sortie, exiger une preuve d'intention pour modifier l'état, ne jamais appeler une URL fournie sans la vérifier.
🔍 Exemple pas à pas
Problème : implémenter les protections XSS, CSRF, cookies, SSRF et limitation de débit, avec des tests.
import hashlib, hmac, html, ipaddress, secrets, socket
from http.cookies import SimpleCookie
from urllib.parse import urlparse
# ---------- XSS : encodage à la sortie ----------
def afficher_commentaire_naif(texte):
return f"<p>{texte}</p>" # ❌ le texte est interprété comme du HTML
def afficher_commentaire(texte):
return f"<p>{html.escape(texte)}</p>" # ✅ encodage pour le contexte HTML
charge = "<script>alert('xss')</script>"
assert "<script>" in afficher_commentaire_naif(charge)
assert afficher_commentaire(charge) == "<p><script>alert('xss')</script></p>"
def champ_valeur(valeur): # contexte : valeur d'attribut → guillemets aussi
return f'<input value="{html.escape(valeur, quote=True)}">'
assert champ_valeur('x" onfocus="alert(1)') == '<input value="x" onfocus="alert(1)">'
# ---------- CSRF : jeton lié à la session ----------
CLE_SERVEUR = secrets.token_bytes(32)
def jeton_csrf(id_session):
hmac.new(CLE_SERVEUR, id_session.encode(), hashlib.sha256).hexdigest()
():
hmac.compare_digest(jeton_csrf(id_session), jeton_recu )
session = secrets.token_urlsafe()
jeton = jeton_csrf(session)
verifier_csrf(session, jeton)
verifier_csrf(session, )
verifier_csrf(secrets.token_urlsafe(), jeton)
():
c = SimpleCookie()
c[] = valeur
c[][] =
c[][] =
c[][] =
c[][] =
c[][] =
c.output(header=)
en_tete = cookie_session()
(m en_tete m (, , , ))
():
p = urlparse(url)
p.scheme (, ) p.hostname:
:
infos = socket.getaddrinfo(p.hostname, p.port ( p.scheme == ), proto=socket.IPPROTO_TCP)
socket.gaierror:
info infos:
ip = ipaddress.ip_address(info[][])
ip.is_private ip.is_loopback ip.is_link_local ip.is_reserved ip.is_multicast:
url, attendu ((, ), (, ),
(, ), (, ), (, ),
(, ), (, ), (, )):
url_sure(url) attendu, url
:
():
.capacite, .taux, .jetons, .dernier = capacite, par_seconde, (capacite), maintenant
():
.jetons = (.capacite, .jetons + (maintenant - .dernier) * .taux)
.dernier = maintenant
.jetons >= cout:
.jetons -= cout
seau = SeauAJetons(capacite=, par_seconde=)
salve = [seau.autoriser() _ ()]
salve == [] * + [] *
seau.autoriser() seau.autoriser() seau.autoriser()
()
Lecture :
- XSS : la version naïve laisse passer le
<script>;html.escapele transforme en texte inerte ; pour un attribut, il faut aussi échapper les guillemets (quote=True) — le contexte détermine l'encodage ; - CSRF : le jeton est dérivé de la session par HMAC ; une requête forgée par un autre site ne peut pas le connaître ;
- cookies :
HttpOnly,Secure,SameSiteet une durée limitée ; - SSRF : les schémas dangereux (
file:,ftp:,javascript:), les adresses privées, locales, de métadonnées etlocalhostsont refusés ; - débit : le seau accepte une salve de 5 puis un flux moyen d'une requête par seconde.
✍️ À toi, avec aide (10 XP)
Écris verifier_en_tetes(en_tetes) qui audite les en-têtes de réponse d'une page et renvoie la liste des problèmes :
- absence de
Strict-Transport-Security; - absence de
Content-Security-Policy, ou CSP qui contientunsafe-inline/unsafe-eval/*dansscript-src; - absence de
X-Content-Type-Options: nosniff; - cookie de session sans
HttpOnly,SecureouSameSite; Access-Control-Allow-Origin: *accompagné deAccess-Control-Allow-Credentials: true.
Teste sur trois réponses : une très mauvaise, une moyenne, une bonne.
💡 Indice 1
Mets les clés en minuscules avant de comparer (les en-têtes sont insensibles à la casse).
💡 Indice 2
Pour le cookie, analyse la chaîne Set-Cookie sans tenir compte de la casse.
💡 Indice 3
Renvoie une liste vide si tout est bon.
✅ Réponse
def verifier_en_tetes(en_tetes, cookies=()):
h = {k.lower(): v for k, v in en_tetes.items()}
problemes = []
if "strict-transport-security" not in h:
problemes.append("HSTS absent : le navigateur n'impose pas HTTPS")
csp = h.get("content-security-policy")
if csp is None:
problemes.append("Content-Security-Policy absente")
else:
script = next((d for d in csp.split(";") if d.strip().startswith("script-src")), "")
for mauvais in ("unsafe-inline", "unsafe-eval", "*"):
if mauvais in script.split():
problemes.append(f"CSP script-src contient {mauvais!r}")
if h.get("x-content-type-options", "").lower() != "nosniff":
problemes.append("X-Content-Type-Options: nosniff absent")
for cookie in cookies:
c = cookie.lower()
for attribut in (, , ):
attribut c:
problemes.append()
h.get() == h.get(, ).lower() == :
problemes.append()
problemes
mauvaise = ({: , : }, [])
moyenne = ({: , : }, [])
bonne = ({: , : ,
: }, [])
((verifier_en_tetes(*mauvaise)), (verifier_en_tetes(*moyenne)), (verifier_en_tetes(*bonne)))
verifier_en_tetes(*bonne) == []
(verifier_en_tetes(*mauvaise)) >= < (verifier_en_tetes(*moyenne)) < (verifier_en_tetes(*mauvaise))
🚀 À toi, en solo (20 XP)
Gabarit HTML sûr. Écris un mini moteur de gabarits rendre(gabarit, contexte) où {{ nom }} est échappé automatiquement pour le HTML, et {{ nom|brut }} insère sans échapper (réservé aux valeurs de confiance). Contraintes :
- un
{{ nom }}placé dans un attribut entre guillemets doit aussi échapper les guillemets ; - une variable inconnue lève une erreur claire ;
- teste avec des charges :
<script>," onmouseover="alert(1),&,', une chaîne vide ; - montre qu'un développeur qui oublie l'échappement manuel est protégé par défaut.
✅ Pistes de correction
import html, re
MOTIF = re.compile(r"\{\{\s*([A-Za-z_]\w*)(\|brut)?\s*\}\}")
def rendre(gabarit, contexte):
def remplacement(m):
nom, brut = m.group(1), m.group(2)
if nom not in contexte:
raise KeyError(f"variable de gabarit inconnue : {nom}")
valeur = str(contexte[nom])
return valeur if brut else html.escape(valeur, quote=True)
return MOTIF.sub(remplacement, gabarit)
g = '<div title="{{ titre }}">Bonjour {{ nom }} {{ signature|brut }}</div>'
sortie = rendre(g, {"titre": '" onmouseover="alert(1)', "nom": "<script>alert(1)</script>", "signature": "<em>HashBox</em>"})
print(sortie)
assert "<script>" not in sortie and 'onmouseover="alert' not in sortie
assert "<em>HashBox</em>" in sortie # brut volontaire
rendre(, {: }) ==
rendre(, {: }) ==
:
rendre(, {})
AssertionError()
KeyError e:
(e)
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Insérer des données dans du HTML sans échapper | XSS | Encoder à la sortie selon le contexte, gabarits sûrs par défaut |
| Modifier l'état avec un GET | CSRF trivial par une image ou un lien | POST/PUT/DELETE + jeton + SameSite |
| Appeler une URL fournie sans contrôle | SSRF vers le réseau interne ou les métadonnées du cloud | Liste blanche, validation d'IP, pas d'accès au réseau interne |
| CORS permissif « pour que ça marche » | Lecture des données privées par n'importe quel site | Liste d'origines autorisées, jamais * avec identifiants |
🐉 Mini-boss (40 XP)
Forum sécurisé de HashBox. Écris les fonctions serveur (sans framework, avec des dictionnaires comme « requêtes » et « réponses ») pour un forum :
poster_message(requete): exige session valide, jeton CSRF, méthodePOST,Originautorisée, longueur ≤ 2 000, limitation de débit par utilisateur (seau) ;afficher_forum(requete): rend les messages avec échappement systématique et ajoute les en-têtes de sécurité (CSP stricte, HSTS, nosniff, frame-ancestors) et un cookie de session sûr ;apercu_lien(requete): récupère le titre d'une URL fournie, protégée contre le SSRF (la récupération est simulée par une fonction injectée) ;api_message(requete): API JSON avec liste blanche de champs (pas d'assignation en masse) et CORS restreint ;- 25 tests d'attaque (XSS stocké et réfléchi, CSRF, SSRF vers 10 adresses dangereuses, abus de débit, champs interdits, CORS) et un test qui vérifie les en-têtes avec l'auditeur de la mission.
✅ Pistes de correction
Un bon travail : un décorateur @protege qui enchaîne les contrôles (session → méthode → Origin → CSRF → débit) et renvoie 401/403/405/429 avec des messages sobres; le rendu passe par rendre (échappement par défaut); l'aperçu de lien appelle url_sure puis une fonction recuperer(ip, host) injectée qui se connecte à l'IP validée (anti-rebinding) et limite la taille de la réponse; l'API ne copie que {"texte"} du JSON reçu et ignore auteur, role, id; CORS : Access-Control-Allow-Origin n'est renvoyé que si l'origine est dans {"https://hashbox.example"}. Les 25 tests attaquent avec : <script> dans le message, <img src=x onerror=…>, formulaire sans jeton, jeton d'une autre session, Origin étrangère, 10 URL internes, 100 messages en 1 s, JSON avec role: "admin".
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Le XSS est évité principalement par :
- A. un pare-feu réseau
- B. l'encodage des données à la sortie selon le contexte
- C. un mot de passe plus long
2. Un jeton anti-CSRF prouve :
- A. que l'utilisateur est majeur
- B. que le mot de passe est fort
- C. que la requête vient bien du site légitime avec l'accord de l'utilisateur
3. Le SSRF consiste à :
- A. faire effectuer une requête par le serveur vers une cible choisie par l'attaquant
- B. voler un cookie
- C. saturer le serveur
4. 🔁 Révision mission 05 : Pour stocker un secret d'application, on utilise :
- A. le code source
- B. un coffre ou des variables d'environnement, hors du dépôt
- C. le README
5. 🔁 Révision mission 05 : Un secret versionné dans un dépôt doit être considéré comme :
- A. protégé par l'historique
- B. inoffensif s'il est ancien
- C. compromis
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Dans quelles situations de ta vie des tiers pourraient-ils agir « en ton nom » à ton insu (CSRF) ?
- Pourquoi l'encodage à la sortie est-il plus fiable qu'un « nettoyage » des entrées ?
🎒 À retenir
- XSS : encoder à la sortie, gabarits sûrs, CSP, cookies HttpOnly.
- CSRF : SameSite, jeton, pas de GET qui modifie.
- SSRF : valider l'IP résolue, liste blanche, connexion à l'IP validée.
- En-têtes et cookies de sécurité.
- Limitation de débit par seau à jetons.
flowchart LR
T(["Sécurité web et API"])
T --> R1["1. XSS : encoder à la sortie, gabarits sûrs, CSP, cookies HttpOnly."]
T --> R2["2. CSRF : SameSite, jeton, pas de GET qui modifie."]
T --> R3["3. SSRF : valider l'IP résolue, liste blanche, connexion à l'IP validée."]
T --> R4["4. En-têtes et cookies de sécurité."]
T --> R5["5. Limitation de débit par seau à jetons."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Défenseur du web
← Mission 05 — Secrets et données sensibles · Mission 07 — OWASP Top 10 et validation des entrées →
HEF-100 — Sécurité

