Les failles les plus fréquentes sont toujours les mêmes. Les connaître, c'est déjà éviter la plupart.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Chasseur de failles (côté défense)
🎬 L'histoire
HashBox reçoit son premier audit externe. Le rapport tient en une phrase par catégorie : « Injection SQL sur la recherche de cours. Traversée de répertoire sur le téléchargement de supports. Désérialisation non sûre dans l'import. Contrôle d'accès cassé sur les profils. »
« Quatre failles, quatre catégories du Top 10 de l'OWASP, dit Sam. Rien d'exotique. La bonne nouvelle : le Top 10 est aussi une liste de choses à vérifier avant de livrer. »
Tu apprends à reconnaître les grandes familles de failles, à les reproduire sur du code jouet que tu écris, puis à les corriger avec des contrôles solides.
🎯 Ta mission
À la fin, je serai capable de :
- énumérer les catégories de l'OWASP Top 10 et leurs défenses
- reconnaître et corriger injection SQL, injection de commande, traversée de chemin, désérialisation dangereuse
- appliquer la validation par liste blanche et l'encodage à la sortie
- éviter l'assignation en masse et les erreurs de configuration
- écrire des tests de sécurité automatisés
🧩 Défi d'échauffement (5 XP)
Un guichet accepte des formulaires. Un client remplit « Nom : Dupont ». Un autre remplit « Nom : Dupont' ; efface tous les dossiers ; ». Si l'employé recopie telle quelle la phrase dans le tampon qui déclenche les actions de l'ordinateur, que risque-t-il d'arriver ? Quelle différence y a-t-il entre donnée et instruction, et comment un guichet bien conçu s'assure-t-il que l'une ne devienne jamais l'autre ?
💡 Le concept
L'OWASP Top 10 (édition 2021)
L'OWASP (Open Worldwide Application Security Project) publie une liste de référence des risques applicatifs les plus critiques.
| # | Catégorie | En une phrase | Défense principale |
|---|---|---|---|
| A01 | Contrôle d'accès défaillant | un utilisateur agit hors de ses droits (IDOR, élévation) | autorisation côté serveur, refus par défaut |
| A02 | Défaillances cryptographiques | données sensibles mal protégées | TLS, chiffrement au repos, algorithmes sûrs, gestion des clés |
| A03 | Injection | des données interprétées comme des instructions (SQL, shell, LDAP, XSS) | requêtes paramétrées, encodage, validation |
| A04 | Conception non sécurisée | l'architecture elle-même est fragile | modélisation des menaces, schémas sûrs |
| A05 | Mauvaise configuration de sécurité | valeurs par défaut, services inutiles, erreurs verbeuses | durcissement, configuration reproductible |
Le principe commun de l'injection
Une injection survient quand des données non fiables sont mélangées à une instruction qui est ensuite interprétée.
La défense est toujours la même : séparer les données du code.
| Contexte | Mauvaise pratique | Bonne pratique |
|---|---|---|
| SQL | concaténer dans la requête | requêtes paramétrées |
| Shell | shell=True avec du texte utilisateur | subprocess.run([...]) avec liste d'arguments |
| HTML | insérer dans la page | encodage de sortie |
| Chemins de fichiers | concaténer base + nom | normaliser et vérifier que le résultat reste dans base |
| Évaluation de code | eval, exec | ne jamais évaluer une entrée externe |
| Désérialisation | pickle.loads sur des données externes |
Valider les entrées
La validation vérifie que l'entrée correspond à ce qu'on attend :
- liste blanche (allowlist) plutôt que liste noire : on définit ce qui est permis, on refuse tout le reste ;
- vérifier type, longueur, plage, format, ensemble de valeurs ;
- valider côté serveur (la validation côté client n'est qu'un confort) ;
- normaliser avant de valider (encodage, casse, chemins) pour éviter les contournements ;
- les messages d'erreur ne révèlent pas les détails internes.
Valider ne remplace pas l'encodage à la sortie ni les requêtes paramétrées : ce sont des défenses complémentaires.
Le principe de défense en profondeur appliqué
Pour la recherche de cours : (1) valider la longueur et les caractères ; (2) requête paramétrée ; (3) compte de base de données en lecture seule ; (4) journaliser les motifs suspects ; (5) limiter le débit. Si une couche échoue, les autres limitent les dégâts.
Assignation en masse
Un objet est rempli directement avec tous les champs reçus (utilisateur.update(**json)) : l'attaquant ajoute "role": "admin". Défense : liste blanche des champs acceptés.
Erreurs de configuration
Mode débogage activé en production, pages d'erreur avec traces, comptes par défaut, listes de répertoires, ports inutiles, services de test exposés, droits trop larges. La parade : une configuration versionnée, revue et automatisée, avec contrôle de conformité.
Tester la sécurité
Chaque faille corrigée doit devenir un test de régression : on rejoue l'attaque et on vérifie qu'elle échoue.
🧠 Astuce : devant toute entrée externe, demande-toi : qu'est-ce qui interprète cette donnée ensuite ? La réponse (base, shell, navigateur, système de fichiers, sérialiseur) te dit quelle défense appliquer.
🔍 Exemple pas à pas
Problème : reproduire quatre failles sur du code jouet, puis les corriger et prouver la correction par des tests.
import json, pickle, sqlite3, subprocess, tempfile
from pathlib import Path
# ======= 1. Injection SQL =======
bd = sqlite3.connect(":memory:")
bd.executescript('''
CREATE TABLE cours (code TEXT, titre TEXT, prive INTEGER);
INSERT INTO cours VALUES ('HEF-000', 'Mentalité', 0), ('HEF-010', 'Algorithmes', 0), ('SECRET-1', 'Plan de licenciement', 1);
''')
def rechercher_vulnerable(terme):
return bd.execute("SELECT code, titre FROM cours WHERE prive = 0 AND titre LIKE '%" + terme + "%'").fetchall()
def rechercher(terme):
if len(terme) > 50:
raise ValueError("terme trop long")
return bd.execute("SELECT code, titre FROM cours WHERE prive = 0 AND titre LIKE ?", (f"%{terme}%",)).fetchall()
attaque = "x%' OR prive = 1 --"
assert ("SECRET-1", "Plan de licenciement") in rechercher_vulnerable(attaque) # faille : le privé fuit
assert rechercher(attaque) == [] # corrigé : traité comme du texte
# ======= 2. Injection de commande =======
def saluer_vulnerable(nom):
return subprocess.run(f"echo Bonjour {nom}", shell=True, capture_output=, text=).stdout.splitlines()
():
subprocess.run([, , nom], capture_output=, text=).stdout.splitlines()
charge =
saluer_vulnerable(charge) == [, ]
saluer(charge) == []
tempfile.TemporaryDirectory() dossier:
base = Path(dossier, ).resolve()
base.mkdir()
(base / ).write_text()
Path(dossier, ).write_text()
():
(base / nom).read_text()
():
chemin = (base / nom).resolve()
chemin.is_relative_to(base):
PermissionError()
chemin.read_text()
lire_vulnerable() ==
lire() ==
mauvais (, , , ):
:
lire(mauvais)
AssertionError(mauvais)
(PermissionError, FileNotFoundError):
:
():
(, (,))
pickle.loads(pickle.dumps(Piege()))
():
donnees = json.loads(texte)
(donnees, ) (donnees) - {, }:
ValueError()
donnees
charger_json() == {: , : }
:
charger_json()
AssertionError
ValueError:
()
Lecture :
- SQL : la charge
x%' OR prive = 1 --transforme la requête en « tout, y compris le privé ». Le paramètre?envoie la valeur séparément de la requête : elle ne peut plus changer sa structure. - Commande : avec
shell=True, le;est interprété par le shell. Avec une liste d'arguments, il n'y a pas de shell : la chaîne reste un argument. - Chemin :
resolve()normalise (.., liens symboliques), puisis_relative_tovérifie le confinement. - Désérialisation :
picklepeut exécuter du code au chargement (ici un simpleprint, mais cela pourrait être n'importe quoi). Pour des données externes : JSON + validation de schéma.
Chaque correction repose sur la même idée : séparer la donnée de l'instruction, puis valider ce qui est attendu.
✍️ À toi, avec aide (10 XP)
Écris valider_inscription(donnees) qui valide un dictionnaire reçu d'un formulaire par liste blanche :
- champs autorisés :
nom(1 à 60 caractères, lettres, espaces, apostrophes, tirets),email(format simple, ≤ 120 caractères),age(entier 13 à 120),cours(parmi{"HEF-000", "HEF-010", "HEF-020"}) ; - tout autre champ (par exemple
role) provoque une erreur ; - renvoie
(donnees_nettoyees, erreurs): les erreurs sont une liste de messages par champ, sans révéler de détails internes.
Teste avec 10 entrées (valides, invalides, charges d'attaque).
💡 Indice 1
Convertis age avec int dans un try.
💡 Indice 2
Utilise re.fullmatch avec des motifs stricts.
💡 Indice 3
Compare set(donnees) aux champs autorisés pour détecter les champs en trop.
✅ Réponse
import re
AUTORISES = {"nom", "email", "age", "cours"}
COURS = {"HEF-000", "HEF-010", "HEF-020"}
NOM = re.compile(r"[A-Za-zÀ-ÖØ-öø-ÿ][A-Za-zÀ-ÖØ-öø-ÿ '\-]{0,59}")
EMAIL = re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}")
def valider_inscription(donnees):
erreurs, propre = [], {}
if not isinstance(donnees, dict):
return {}, ["format invalide"]
for champ in sorted(set(donnees) - AUTORISES):
erreurs.append(f"champ non autorisé : {champ}")
nom = donnees.get("nom")
if not isinstance(nom, str) or not NOM.fullmatch(nom.strip()):
erreurs.append("nom invalide")
else:
propre["nom"] = nom.strip()
email = donnees.get("email")
if not isinstance(email, str) or len(email) > EMAIL.fullmatch(email):
erreurs.append()
:
propre[] = email.lower()
:
age = (donnees.get())
<= age <= :
ValueError
propre[] = age
(TypeError, ValueError):
erreurs.append()
donnees.get() COURS:
propre[] = donnees[]
:
erreurs.append()
propre, erreurs
bon = {: , : , : , : }
valider_inscription(bon) == ({: , : , : , : }, [])
mauvais = [
(bon, role=),
(bon, nom=),
(bon, nom=),
(bon, email=),
(bon, email=),
(bon, age=),
(bon, age=),
(bon, cours=),
(bon, nom=),
]
entree mauvais:
_, erreurs = valider_inscription(entree)
erreurs, entree
()
🚀 À toi, en solo (20 XP)
Un téléchargeur de fichiers sûr. Écris servir_fichier(base, nom_demande) qui sert des fichiers d'un dossier de supports, avec :
- confinement strict dans
base(y compris contre les liens symboliques qui sortent du dossier) ; - liste blanche d'extensions (
.pdf,.txt,.md) ; - limite de taille (5 Mo) ;
- refus des noms contenant des octets nuls, des séparateurs Windows (
\), ou commençant par un point ; - un message d'erreur unique et vague (« introuvable ») pour tous les refus, afin de ne pas révéler l'existence de fichiers ;
- 15 tests d'attaque :
../, chemin absolu, lien symbolique sortant,%2e%2e/déjà décodé, octet nul, nom très long, extension interdite, fichier trop gros.
✅ Pistes de correction
import os, tempfile
from pathlib import Path
EXTENSIONS = {".pdf", ".txt", ".md"}
TAILLE_MAX = 5 * 1024 * 1024
class Introuvable(Exception):
pass
def servir_fichier(base, nom_demande):
base = Path(base).resolve()
try:
if not isinstance(nom_demande, str) or not nom_demande or len(nom_demande) > 200:
raise Introuvable
if "\x00" in nom_demande or "\\" in nom_demande or Path(nom_demande).name.startswith("."):
raise Introuvable
chemin = (base / nom_demande).resolve() # suit les liens symboliques
if not chemin.is_relative_to(base) or chemin == base:
raise Introuvable
if chemin.suffix.lower() not in EXTENSIONS chemin.is_file():
Introuvable
chemin.stat().st_size > TAILLE_MAX:
Introuvable
chemin.read_bytes()
(Introuvable, OSError, ValueError):
Introuvable()
tempfile.TemporaryDirectory() d:
racine = Path(d)
base = racine /
base.mkdir()
(base / ).write_text()
(base / ).write_text()
(base / ).write_text()
(base / ).write_bytes( * (TAILLE_MAX + ))
(racine / ).write_text()
os.symlink(racine / , base / )
servir_fichier(base, ) ==
attaques = [, , (racine / ), , , * + ,
, , , , , , , , ]
a attaques:
:
servir_fichier(base, a)
AssertionError()
Introuvable e:
(e) ==
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Concaténer des données dans une requête ou une commande | Injection | Paramètres, listes d'arguments, encodage |
| Liste noire de caractères dangereux | Contournements (encodages, variantes) | Liste blanche de ce qui est permis |
| Valider côté client uniquement | Contournement immédiat | Toujours valider côté serveur |
Désérialiser des données externes avec pickle | Exécution de code arbitraire | JSON + validation de schéma |
🐉 Mini-boss (40 XP)
Audit défensif d'une petite application « jouet ». Écris en 150 lignes une petite application (module de fonctions, sans framework) qui contient volontairement huit failles correspondant à huit catégories de l'OWASP : injection SQL, injection de commande, traversée de chemin, désérialisation dangereuse, contrôle d'accès cassé (IDOR), assignation en masse, secret en dur, message d'erreur trop bavard.
- Pour chaque faille, écris le test d'attaque qui la démontre (il doit réussir sur la version vulnérable).
- Corrige chaque faille ; le même test doit maintenant échouer à attaquer (l'attaque ne marche plus).
- Ajoute un test de non-régression par faille.
- Rédige un tableau : faille → catégorie OWASP → cause → correction → test.
- Explique en 10 lignes quelle défense a le meilleur rapport efficacité/effort, et pourquoi la validation seule ne suffit pas.
✅ Pistes de correction
Un bon travail : une fonction app_vulnerable regroupant rechercher, exporter, lire_support, charger_profil_pickle, lire_profil(id) sans contrôle de propriétaire, mettre_a_jour_profil(**champs) sans liste blanche, CLE_API = "sk_live_...", et repondre_erreur(e) qui renvoie la trace complète. La version corrigée utilise requêtes paramétrées, subprocess.run([...]), confinement par resolve()/is_relative_to, JSON + schéma, vérification proprietaire == utilisateur, liste blanche {"nom", "email"}, variable d'environnement, message générique + identifiant d'incident journalisé. Le tableau relie A03, A03, A01 (traversée), A08, A01, A04/A01, A02/A05, A05. Le meilleur rapport efficacité/effort est la séparation donnée/instruction (paramètres, listes d'arguments) : elle neutralise toute une famille de failles à faible coût, alors que la validation seule dépend d'une liste exhaustive de cas.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. L'injection consiste à :
- A. mélanger des données non fiables à une instruction interprétée
- B. chiffrer deux fois
- C. saturer un serveur
2. Pour éviter l'injection SQL, on utilise :
- A. des guillemets doubles
- B. des requêtes paramétrées
- C. des majuscules
3. La validation d'entrées doit privilégier :
- A. la liste noire des caractères dangereux
- B. l'absence de contrôle
- C. la liste blanche de ce qui est permis
4. 🔁 Révision mission 06 : Le XSS est évité principalement par :
- A. l'encodage des données à la sortie selon le contexte
- B. un pare-feu réseau
- C. un mot de passe plus long
5. 🔁 Révision mission 06 : Un jeton anti-CSRF prouve :
- A. que l'utilisateur est majeur
- B. que la requête vient bien du site légitime avec l'accord de l'utilisateur
- C. que le mot de passe est fort
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Dans quelles situations de ton travail passes-tu une donnée externe à un interpréteur (shell, base, navigateur, fichier) sans t'en rendre compte ?
- Pourquoi est-ce plus durable de corriger la cause (séparer donnée et code) que de bloquer une charge précise ?
🎒 À retenir
- Top 10 OWASP : contrôle d'accès, crypto, injection, conception, configuration, composants, authentification, intégrité, journalisation, SSRF.
- Injection = donnée interprétée comme instruction : la séparer.
- Liste blanche, validation côté serveur, normalisation avant contrôle.
- Pas de
pickleni d'evalsur des données externes. - Chaque faille corrigée devient un test de régression.
flowchart LR
T(["OWASP Top 10 et validation des entrées"])
T --> R1["1. Top 10 OWASP : contrôle d'accès, crypto, injection, conception,…"]
T --> R2["2. Injection = donnée interprétée comme instruction : la séparer."]
T --> R3["3. Liste blanche, validation côté serveur, normalisation avant contrôle."]
T --> R4["4. Pas de pickle ni d'eval sur des données externes."]
T --> R5["5. Chaque faille corrigée devient un test de régression."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Chasseur de failles (côté défense)
← Mission 06 — Sécurité web et API · Mission 08 — Sécurité réseau et système →
HEF-100 — Sécurité

