Ataque de Inyección de Comandos

Cómo Funciona Ataque de Inyección de Comandos

La inyección de comandos ocurre cuando los desarrolladores usan funciones que pasan la entrada del usuario directamente a comandos de shell (exec(), system(), subprocess, etc.) sin la validación o escape adecuados. El shell del sistema operativo interpreta los metacaracteres como separadores de comandos, permitiendo a los atacantes agregar comandos maliciosos. A diferencia de la inyección SQL, que apunta a consultas de bases de datos, la inyección de comandos ejecuta comandos con los privilegios del proceso de la aplicación vulnerable.

Ejemplos Reales

Impacto y Evaluación de Riesgo

La inyección de comandos permite el compromiso total del sistema, robo de datos, despliegue de malware y movimiento lateral a otros sistemas. Los atacantes pueden leer/escribir cualquier archivo accesible para el proceso de la aplicación, robar credenciales de bases de datos de archivos de configuración, instalar backdoors, lanzar ataques contra redes internas, o usar el servidor comprometido como nodo de botnet. En entornos multi-tenant, un inquilino puede comprometer a otros. El impacto incluye brechas de datos, interrupción del servicio, multas regulatorias y pérdida total de confianza. La inyección de comandos frecuentemente conduce al control completo de la infraestructura de alojamiento.

Cómo Detectar Ataque de Inyección de Comandos

Monitorear patrones sospechosos de ejecución de comandos: metacaracteres de shell en parámetros (;, |, &, $, `), funciones de comandos del sistema con entrada del usuario, operaciones de archivos inesperadas, conexiones de reverse shell o intentos de escalación de privilegios. Registrar todas las ejecuciones de comandos del sistema con argumentos completos e información del proceso. Usar pruebas de seguridad de aplicaciones (SAST/DAST) para identificar patrones de código vulnerables. Desplegar protección de aplicaciones en tiempo de ejecución (RASP) para detectar llamadas al sistema anómalas. Monitorear conexiones de red anómalas desde el servidor de la aplicación (shells salientes, exfiltración de datos).

Cómo Prevenir Ataque de Inyección de Comandos

Nunca ejecutar comandos de shell con entrada del usuario. Si es inevitable, usar APIs parametrizadas (subprocess de Python con argumentos en lista, ProcessBuilder de Java con argumentos separados, child_process.execFile de Node.js) en lugar de concatenación de cadenas. Validar la entrada con listas blancas estrictas (solo alfanuméricos, sin caracteres especiales). Escapar correctamente los metacaracteres de shell usando funciones de escape específicas del lenguaje. Implementar principios de mínimo privilegio: ejecutar los procesos de la aplicación con permisos mínimos, entornos chroot/sandbox. Usar bibliotecas de validación de entrada que rechacen metacaracteres de shell. Desactivar utilidades del sistema innecesarias. Usar APIs seguras (bibliotecas) en lugar de comandos del sistema cuando sea posible. Revisiones de código regulares enfocadas en patrones de ejecución de comandos del sistema.

Ejemplos de Código

import subprocess

# VULNERABLE: User input concatenated into command
def ping_host(ip_address):
    # Attacker can input: 8.8.8.8; cat /etc/passwd
    result = subprocess.run(
        f'ping -c 4 {ip_address}',
        shell=True,  # shell=True enables metacharacter interpretation
        capture_output=True,
        text=True
    )
    return result.stdout

import subprocess
import re

def validate_ip(ip):
    """Validate IP address with strict pattern"""
    pattern = r'^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
    return re.match(pattern, ip) is not None

def ping_host(ip_address):
    # SECURE: Input validation + parameterized execution
    if not validate_ip(ip_address):
        raise ValueError('Invalid IP address format')
    
    # Use list argument (no shell=True) - input can't inject commands
    result = subprocess.run(
        ['ping', '-c', '4', ip_address],
        capture_output=True,
        text=True,
        # No shell=True - each argument is separate
    )
    return result.stdout

const { exec } = require('child_process');

// VULNERABLE: Don't do this
function pingVulnerable(ip) {
  exec(`ping -c 4 ${ip}`, (error, stdout, stderr) => {
    // Attacker can inject: ; rm -rf /
    console.log(stdout);
  });
}

// SECURE: Option 1 - Use a library instead of shell commands
const ping = require('ping');

async function pingSecure(ip) {
  const res = await ping.promise.probe(ip, {
    timeout: 2,
    extra: ['-c', '4']
  });
  return res.output;
}

// SECURE: Option 2 - Strict validation + parameterized
const { spawn } = require('child_process');

function validateIP(ip) {
  // IPv4 regex pattern
  const pattern = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
  return pattern.test(ip);
}

function pingParameterized(ip) {
  if (!validateIP(ip)) {
    throw new Error('Invalid IP address');
  }

  // spawn() with array - no shell interpretation
  return spawn('ping', ['-c', '4', ip]);
}

Preguntas Frecuentes

Ataques Relacionados