La inyección de comandos en el sistema operativo es una vulnerabilidad crítica que permite a un atacante ejecutar instrucciones arbitrarias en el servidor que aloja una aplicación web. Este fallo ocurre cuando la aplicación transfiere datos suministrados por el usuario (como formularios, cookies o encabezados HTTP) directamente a una shell del sistema sin la debida validación o filtrado.

Cuando se explota con éxito, el atacante opera con los mismos privilegios que el proceso de la aplicación web. Por ejemplo, si el servidor web se ejecuta bajo el usuario www-data, cualquier comando inyectado tendrá acceso a los archivos y recursos permitidos para ese usuario específico. Este tipo de vulnerabilidad se clasifica frecuentemente como Ejecución Remota de Código (RCE), representando uno de los riesgos más severos en la seguridad de aplicaciones web.

Identificación de puntos vulnerables

La raíz de este problema reside en el uso de funciones integradas en lenguajes de programación como PHP, Python o Node.js que están diseñadas para interactuar con el sistema operativo. Un desarrollador podría intentar automatizar tareas del sistema basándose en la entrada del usuario.

Considere el siguiente fragmento de código en PHP, diseñado para buscar registros de acceso de un usuario específico en un archivo de texto:

<?php
  $nombre_usuario = $_GET['user'];
  $resultado = shell_exec("grep " . $nombre_usuario . " accesos.log");
  echo "" . $resultado . "";
?>

En este escenario, la lógica es la siguiente:

1. La aplicación recibe un parámetro user a través de una petición GET.
2. Dicho parámetro se concatena directamente en una cadena de comando de Linux (grep).
3. El sistema ejecuta el comando y devuelve el resultado al navegador.

Un atacante podría manipular el parámetro user enviando algo como admin; cat /etc/passwd. El servidor ejecutaría entonces dos comandos: la búsqueda del usuario y la lectura del archivo de contraseñas del sistema.

Incluso en entornos modernos como Python, el uso incorrecto de bibliotecas de gestión de procesos puede derivar en el mismo riesgo. Observe este ejemplo con Flask:

from flask import Flask, request
import subprocess

app = Flask(__name__)

@app.route("/red/verificar")
def verificar_host():
    direccion_ip = request.args.get('ip')
    # Uso inseguro de shell=True
    salida = subprocess.check_output(f"ping -c 1 {direccion_ip}", shell=True)
    return salida

if __name__ == "__main__":
    app.run()

Aquí, el argumento shell=True permite que el sistema interprete caracteres especiales de la shell, facilitando la ejecución de comandos adicionales mediante operadores de encadenamiento.

Metodologías de explotación

La inyección de comandos suele clasificarse en dos categorías pricnipales según la retroalimentación que recibe el atacante:

1. Inyección Verbosa (Basada en resultados)

Es la más sencilla de detectar. El resultado del comando ejecutado se muestra directamente en la respuesta HTTP. Si el atacante introduce whoami y la página responde con el nombre del usuario del sistema, la vulnerabilidad es confirmada y fácilmente explotable.

2. Inyección Ciega (Blind)

En este caso, la aplicación no devuelve la salida del comando. El atacante debe inferir el éxito de la ejecución mediante otros métodos:

• Basada en tiempo: Utilizar comandos que generen un retraso, como sleep o ping con un conteo específico de paquetes. Si la respuesta del servidor tarda exactamente el tiempo solicitado, la inyección es efectiva.
• Exfiltración de datos: Redirigir la salida a un archivo accesible vía web (ej. > prueba.txt) o enviarla a un servidor externo controlado por el atacante mediante herramientas como curl o netcat.

Operadores útiles para el encadenamiento

Para inyectar múltiples comandos, se utilizan operadores lógicos y de control de flujo propios del sistema operativo:

Comandos de reconocimiento habituales

Dependiendo del sistema operativo del objetivo, los atacantes suelen utilizar los siguientes comandos para explorar el entorno:

En sistemas Linux:

• whoami: Identificar el usuario actual.
• id: Obtener identificadores de usuario y grupos.
• ls -la: Listar archivos, incluyendo ocultos y permisos.
• cat /etc/issue: Identificar la distribución del sistema operativo.

En sistemas Windows:

• whoami: Identificar el usuario actual.
• dir: Listar el contenido del directorio.
• type: Leer el contenido de un archivo.
• systeminfo: Obtener detalles del sistema operativo y parches instalados.

Estrategias de Prevención

La defensa contra la inyección de comandos debe ser multicapa, priorizando el diseño seguro sobre el filtrado:

1. Evitar funciones peligrosas: Siempre que sea posible, utilice funciones nativas del lenguaje de programación en lugar de llamar a binarios del sistema operativo. Por ejemplo, para renombrar un archivo en PHP, use rename() en lugar de exec("mv ...").
2. Validación mediante listas blancas: No intente filtrar caracteres "malos". En su lugar, defina un formato estricto de lo que es permitido. Si se espera una dirección IP, valide que la entrada coincida exactamente con el formato IPv4/IPv6.
3. Parametrización de argumentos: Al usar funciones de ejecución, pase los argumentos como una lista o arreglo si la biblioteca lo permite, lo que evita que la shell interprete los espacios y caracteres especiales como nuevos comandos.
4. Principio de menor privilegio: Ejecute los servicios web con cuentas de usuario con permisos mínimos, restringiendo su capacidad para acceder a binarios sensibles (como nc, perl o python) y directorios críticos del sistema.

Ejemplo de validación robusta en PHP:

<?php
  $id_producto = $_POST['id'];
  // Solo permitir caracteres alfanuméricos
  if (!ctype_alnum($id_producto)) {
      die("Entrada no válida");
  }
  // Ejecución más segura
  passthru("/usr/bin/check_stock " . escapeshellarg($id_producto));
?>

La función escapeshellarg() añade comillas alrededor de la cadena y escapa cualquier comilla existente, asegurando que la entrada sea tratada como un único argumento y no como parte del comando.