Dix ans après la généralisation d'Eloquent, de Doctrine ou de Prisma, l'injection SQL figure toujours dans le classement OWASP et continue d'être exploitée en production. Ce n'est pas que les équipes ignorent le concept : c'est que les ORM protègent très bien le chemin balisé (CRUD classique via query builder) et laissent des trous béants dès qu'on en sort - recherche avancée, tri dynamique, rapports, procédures stockées, outils d'administration développés dans l'urgence. Ce billet détaille où se cachent réellement ces trous aujourd'hui, comment les repérer, et comment les corriger sans se contenter d'un pansement.
Le mécanisme qu'on oublie
Une injection SQL se produit quand une donnée non fiable est concaténée dans une chaîne de requête qui sera ensuite interprétée comme du code par le moteur de base de données, plutôt que transmise comme une simple valeur via un paramètre lié (bound parameter). Les ORM modernes résolvent ce problème par défaut pour les opérations standard : User::where('email', $email) génère systématiquement une requête préparée avec un placeholder. Le danger n'a pas disparu, il s'est déplacé vers les cas où le développeur doit sortir de l'abstraction.
Pourquoi les placeholders ne couvrent pas tout
Un paramètre lié remplace une valeur dans une requête (WHERE email = ?), jamais un identifiant - nom de colonne, nom de table, direction de tri (ASC/DESC). Le pilote SQL n'a tout simplement pas de syntaxe de placeholder pour ça. Dès qu'une fonctionnalité de tri dynamique, de filtre « par n'importe quel champ », ou de nom de table variable (multi-tenant avec schéma par client) apparaît, il faut une validation explicite côté application. C'est précisément l'angle mort que la plupart des développeurs découvrent trop tard, parce que l'ORM ne les protège plus et ne le signale pas non plus.
Où ça se niche encore en 2026
En pratique, l'injection survit dans des endroits très précis et récurrents :
- Les appels
whereRaw,DB::raw,selectRawsous Laravel, utilisés pour des agrégations ou des conditions complexes. - Les requêtes DQL de Doctrine construites par concaténation de chaînes plutôt que par
setParameter. - Le tri ou le filtrage dynamique par colonne, exposé directement depuis un paramètre de requête HTTP.
- Les procédures stockées appelées avec du SQL dynamique interne (
EXEC(@sql)côté SQL Server,EXECUTEcôté PostgreSQL), qui restent vulnérables même si l'application appelle la procédure de façon paramétrée. - Les outils de reporting ou d'administration développés rapidement, souvent avec un accès direct à la base et moins de rigueur que le code métier.
- Les API génériques « filtrer par n'importe quel champ », qui transforment un nom de champ fourni par le client en colonne SQL via réflexion.
// Vulnérable : concaténation directe dans une requête brute
$email = $request->input('email');
$users = DB::select("SELECT * FROM users WHERE email = '" . $email . "'");
// Sûr : liaison de paramètres, le pilote échappe et type la valeur
$users = DB::select('SELECT * FROM users WHERE email = ?', [$email]);
Le tri dynamique est l'exemple le plus trompeur, car le code "a l'air" d'utiliser le query builder en toute sécurité :
// Vulnérable : le nom de colonne vient directement du client
$sort = $request->query('sort', 'created_at');
$users = DB::table('users')->orderBy($sort)->get();
// Sûr : liste blanche explicite des colonnes autorisées
$allowedColumns = ['name', 'email', 'created_at'];
$sort = in_array($request->query('sort'), $allowedColumns, true)
? $request->query('sort')
: 'created_at';
$users = DB::table('users')->orderBy($sort)->get();
Côté Doctrine, le piège classique est de construire dynamiquement une clause WHERE en string plutôt que d'utiliser le QueryBuilder :
// Vulnérable
$dql = "SELECT u FROM App\Entity\User u WHERE u.email = '" . $email . "'";
$query = $em->createQuery($dql);
// Sûr
$qb = $em->createQueryBuilder();
$qb->select('u')
->from(User::class, 'u')
->andWhere('u.email = :email')
->setParameter('email', $email);
Diagnostiquer avant de corriger
La première étape n'est pas de patcher au hasard mais de cartographier la surface réelle. Trois leviers complémentaires :
# Recherche des patterns à risque dans le code
grep -rn "whereRaw\|DB::raw\|selectRaw\|->raw(" src/
grep -rn "createQuery(\"" src/
# Analyse statique ciblée avec des règles dédiées à l'injection
semgrep --config p/sql-injection src/
En complément, l'examen des logs de requêtes (activables temporairement en environnement de staging) permet de repérer des motifs suspects - guillemets non échappés, unions inattendues, commentaires SQL (--, /* */) dans des valeurs qui ne devraient jamais en contenir. Un test avec sqlmap contre un environnement de staging alimenté par un jeu de données jetable reste la méthode la plus directe pour valider qu'un point d'entrée est réellement exploitable, mais ne doit jamais être exécuté contre la production.
Le correctif, et ses compromis
La liaison de paramètres partout où une valeur est injectée dans une requête règle l'immense majorité des cas. Pour les identifiants (colonnes, tables, direction de tri), la seule réponse fiable est la liste blanche explicite - une structure de données qui énumère ce qui est autorisé, jamais une tentative d'échappement du nom de colonne lui-même. Échapper un identifiant est fragile et dépend du moteur ; le valider contre une liste connue ne l'est pas.
Un deuxième levier, souvent négligé parce qu'il ne se voit pas dans le code applicatif, est le principe du moindre privilège côté base de données : le compte utilisé par l'application ne devrait pas avoir de droits DDL (CREATE, DROP, ALTER), ni d'accès aux schémas d'autres tenants dans une architecture multi-locataire. Si une injection passe malgré tout, elle est alors contenue par les permissions de la base elle-même plutôt que par la seule couche applicative. Le compromis est opérationnel : des comptes de service plus fins à gérer, des migrations qui doivent utiliser un rôle distinct avec plus de droits, et une discipline supplémentaire sur les scripts d'administration.
Quand le correctif facile ne suffit pas
La liaison de paramètres protège le point d'entrée immédiat, mais pas nécessairement les usages ultérieurs de la donnée. C'est le principe de l'injection de second ordre : une valeur stockée en toute sécurité via une requête paramétrée (un terme de recherche sauvegardé pour un historique, par exemple) peut ensuite être réinjectée sans protection dans un générateur de rapport ou un export SQL ad hoc qui, lui, concatène directement. Le correctif doit donc couvrir tous les points où la donnée ressort, pas seulement celui où elle entre.
Les architectures multi-tenant avec schéma par client posent un problème structurellement différent : le nom du schéma est souvent construit dynamiquement à partir d'un identifiant de tenant, et aucun placeholder ne peut protéger un nom de schéma. La seule option solide est de valider cet identifiant contre la liste des tenants réellement provisionnés en base, avant toute construction de requête, jamais après.
Enfin, un pare-feu applicatif web (WAF) peut réduire l'exposition en bloquant des motifs d'attaque connus, mais il s'agit d'une mesure d'atténuation en profondeur, pas d'un correctif. Un WAF mal réglé laisse passer des variantes d'encodage, et sa présence ne dispense jamais de corriger la requête vulnérable à la source.
À retenir
L'injection SQL en 2026 n'est pas un problème de framework obsolète, c'est un problème de surface : chaque sortie du chemin balisé de l'ORM (raw query, identifiant dynamique, procédure stockée, outil interne) doit être traitée avec la même rigueur que le code métier principal. Liste blanche pour les identifiants, liaison de paramètres pour les valeurs, moindre privilège côté base : ces trois réflexes couvrent l'essentiel des cas réellement exploités.
