Ataque de Subida de Archivos Maliciosos

Cómo Funciona Ataque de Subida de Archivos Maliciosos

La funcionalidad de subida de archivos es una característica central de las aplicaciones web modernas: avatares de perfil, archivos adjuntos de documentos, importaciones CSV, actualizaciones de firmware. Cada endpoint de subida es una oportunidad para que un atacante coloque contenido arbitrario en el servidor. El ataque tiene éxito cuando la aplicación confía en el archivo subido sin verificar que su contenido real coincida con el tipo esperado, que su nombre no contenga secuencias de path traversal, y que la ubicación de almacenamiento prevenga la ejecución. La brecha entre lo que la aplicación asume ("esto es un JPEG inofensivo") y lo que el archivo realmente es (una web shell PHP con extensión .jpg.php) es donde vive el ataque.

Ejemplos Reales

Impacto y Evaluación de Riesgo

La subida de archivos maliciosos se clasifica como Alta porque proporciona un camino directo desde el acceso externo no autenticado hasta la ejecución de código en el servidor. El impacto inmediato depende de la carga: las web shells otorgan control interactivo completo sobre el servidor, los criptomineros consumen recursos de cómputo, el ransomware cifra datos para extorsión, y las cargas XSS (vía SVG/HTML) comprometen a los usuarios finales. El radio de explosión se extiende mucho más allá del endpoint de subida — una vez lograda la ejecución de código, el atacante hereda el acceso del proceso del servidor web a bases de datos, servicios internos, endpoints de metadatos de la nube y sistemas de archivos montados. En entornos cloud, esto frecuentemente habilita el movimiento lateral a otros servicios vía credenciales de metadatos de instancia. La vulnerabilidad es particularmente insidiosa porque la subida de archivos es una funcionalidad legítima y esperada — los usuarios y administradores no la perciben como una superficie de ataque hasta que es explotada.

Cómo Detectar Ataque de Subida de Archivos Maliciosos

Implementar detección multicapa: (1) Reglas del WAF inspeccionando solicitudes de subida en busca de extensiones de archivo peligrosas (.php, .jsp, .asp, .aspx, .phtml, .phar, .py, .cgi, .pl, .sh, .htaccess, .config, .shtml), extensiones dobles (.php.jpg) y secuencias de bytes nulos en nombres de archivo; (2) Análisis de contenido: escanear el contenido de archivos subidos en busca de firmas de scripts (<?php, <%, <%@, <script, #!/bin, eval(, system(, exec() independientemente del tipo de archivo declarado — un JPEG que contiene <?php es un ataque políglota; (3) Monitoreo de integridad de archivos en directorios de subida para detectar web shells depositados vía otros vectores de ataque; (4) Monitoreo de comportamiento: alertar cuando el proceso del servidor web genera procesos hijo inesperados (sh, cmd.exe, powershell) después de una subida de archivo, indicando ejecución de web shell; (5) Escaneo antivirus/antimalware de todos los archivos subidos antes del almacenamiento; (6) Monitorear patrones de acceso a directorios de subida — los archivos legítimos se acceden infrecuentemente comparados con las web shells que reciben solicitudes parametrizadas repetidas.

Cómo Prevenir Ataque de Subida de Archivos Maliciosos

Aplicar defensa en profundidad para cada endpoint de subida: (1) Validar el contenido del archivo, no solo la extensión o tipo MIME — usar validación de bytes mágicos, bibliotecas de reprocesamiento de imágenes (ImageMagick, GD, Sharp) que eliminan datos no-imagen, y bibliotecas dedicadas de detección de tipo de archivo (Apache Tika, python-magic, file-type para Node.js); (2) Renombrar archivos subidos con nombres aleatorios e imposibles de adivinar con una extensión impuesta por el servidor — nunca preservar el nombre de archivo original; (3) Almacenar subidas fuera de la raíz del documento web para que no puedan ser accedidas directamente vía URL — servirlas a través de un controlador que establezca Content-Disposition: attachment y un Content-Type seguro; (4) Configurar el servidor web para nunca ejecutar scripts en el directorio de subidas (eliminar handlers PHP/CGI, denegar ejecución de scripts en IIS); (5) Imponer límites estrictos de tamaño de archivo y limitación de tasa en endpoints de subida; (6) Usar Content Security Policy (CSP) para mitigar XSS desde archivos SVG/HTML subidos; (7) En despliegues cloud, almacenar subidas en almacenamiento de objetos (S3, GCS, Azure Blob) con ACLs privadas y servir vía URLs firmadas o CDN — esto elimina completamente el riesgo de ejecución del lado del servidor.

Ejemplos de Código

<?php
// VULNERABLE: Multiple validation failures
$target_dir = '/var/www/html/uploads/';
$target_file = $target_dir . basename($_FILES['file']['name']);

// FLAW 1: Trusting client-sent MIME type
$mime = $_FILES['file']['type'];  // Attacker controls this!
if ($mime == 'image/jpeg' || $mime == 'image/png') {

    // FLAW 2: Only checking extension (shell.php.jpg bypasses this)
    $ext = pathinfo($target_file, PATHINFO_EXTENSION);
    if (in_array($ext, ['jpg', 'png', 'gif'])) {

        // FLAW 3: Preserving original filename (allows path traversal)
        move_uploaded_file($_FILES['file']['tmp_name'], $target_file);
        echo "Upload successful: /uploads/" . basename($target_file);
    }
}

// Attacker uploads: shell.php with Content-Type: image/jpeg
// Or: shell.php.jpg on misconfigured Apache with AddHandler php-script .php
// Or: ../../../var/www/html/shell.php as the filename
?>

<?php
class SecureUploader {
    private string $storageDir;  // OUTSIDE document root
    private array $allowedTypes = ['image/jpeg', 'image/png', 'image/gif'];
    private int $maxSize = 5 * 1024 * 1024;  // 5 MB

    public function __construct(string $storageDir) {
        $this->storageDir = rtrim($storageDir, '/');
    }

    public function upload(array $file): array {
        // 1. Check for upload errors
        if ($file['error'] !== UPLOAD_ERR_OK) {
            throw new RuntimeException('Upload failed');
        }

        // 2. Enforce file size limit
        if ($file['size'] > $this->maxSize) {
            throw new RuntimeException('File too large');
        }

        // 3. Detect real MIME type from file content (NOT client header)
        $finfo = new finfo(FILEINFO_MIME_TYPE);
        $realMime = $finfo->file($file['tmp_name']);
        if (!in_array($realMime, $this->allowedTypes, true)) {
            throw new RuntimeException('Invalid file type: ' . $realMime);
        }

        // 4. Re-process image to strip any embedded code
        $image = @imagecreatefromstring(file_get_contents($file['tmp_name']));
        if ($image === false) {
            throw new RuntimeException('Invalid image data');
        }

        // 5. Generate random filename with server-enforced extension
        $ext = match($realMime) {
            'image/jpeg' => 'jpg',
            'image/png'  => 'png',
            'image/gif'  => 'gif',
        };
        $newName = bin2hex(random_bytes(16)) . '.' . $ext;
        $destPath = $this->storageDir . '/' . $newName;

        // 6. Save the re-processed image (strips any non-image data)
        match($realMime) {
            'image/jpeg' => imagejpeg($image, $destPath, 85),
            'image/png'  => imagepng($image, $destPath, 9),
            'image/gif'  => imagegif($image, $destPath),
        };
        imagedestroy($image);

        return ['id' => pathinfo($newName, PATHINFO_FILENAME), 'name' => $newName];
    }
}

// Serve files through a controller — never expose the storage directory
// GET /files/{id} → reads from storage dir, sets Content-Disposition: attachment
?>

Preguntas Frecuentes

Ataques Relacionados