Ataque de Directory Traversal

Cómo Funciona Ataque de Directory Traversal

Cada aplicación web confina sus operaciones de archivos a un directorio raíz designado — la raíz del documento para archivos estáticos, una carpeta de subidas para contenido de usuarios, o un directorio de plantillas para vistas. El directory traversal rompe este confinamiento. Cuando la aplicación construye una ruta del sistema de archivos usando entrada del usuario no saneada, el atacante inyecta secuencias que ascienden por el árbol de directorios hasta alcanzar la raíz del sistema, y luego desciende hacia cualquier directorio objetivo. La superficie de ataque es enorme: cualquier parámetro, cabecera, cookie o campo multipart que alimente una API del sistema de archivos es un punto de entrada potencial.

Ejemplos Reales

Impacto y Evaluación de Riesgo

El directory traversal se clasifica como Crítico porque colapsa la frontera de seguridad más fundamental en las aplicaciones web: el aislamiento del sistema de archivos. Un ataque exitoso proporciona acceso inmediato a archivos de configuración que contienen credenciales de bases de datos, secretos API y claves de cifrado. En cargas de trabajo alojadas en la nube, expone endpoints de metadatos de instancia y tokens de cuentas de servicio, habilitando la toma completa de la cuenta en la nube. Cuando el acceso de escritura es alcanzable, el camino hacia la ejecución remota de código es directo. Datos históricos de programas de divulgación de vulnerabilidades muestran que el directory traversal se clasifica consistentemente entre las 5 clases de vulnerabilidad más frecuentemente reportadas en programas de bug bounty. El ataque no requiere autenticación, no requiere herramientas especiales y frecuentemente evade las defensas perimetrales — haciéndolo accesible a atacantes de baja habilidad mientras sigue siendo devastador en impacto.

Cómo Detectar Ataque de Directory Traversal

Desplegar detección multicapa: (1) Reglas del WAF que coincidan con ../ y sus variantes codificadas (%2e%2e, %252e%252e, %c0%ae%c0%ae, ....//), bytes nulos (%00) y referencias a rutas sensibles conocidas (/etc/passwd, /etc/shadow, /proc/self, win.ini, web.config); (2) Registro a nivel de aplicación de todas las operaciones del sistema de archivos con la ruta canónica resuelta, alertando cuando cualquier ruta resuelta cae fuera del directorio base esperado; (3) Autoprotección de Aplicaciones en Tiempo de Ejecución (RASP) interceptando llamadas al sistema de E/S de archivos y bloqueando accesos fuera de límites en tiempo real; (4) Firmas de IDS/IPS a nivel de red para patrones de traversal en tráfico HTTP; (5) Monitoreo de integridad de archivos (AIDE, OSSEC) en archivos críticos del sistema para detectar lecturas no autorizadas mediante cambios en el tiempo de acceso. Correlacionar los intentos de traversal con la puntuación de inteligencia de amenazas de la IP solicitante para priorizar la respuesta a incidentes.

Cómo Prevenir Ataque de Directory Traversal

Adoptar una estrategia de defensa en profundidad: (1) Nunca construir rutas de archivos desde entrada del usuario — usar una lista de permitidos o un mapa de referencia indirecta (el usuario envía un ID, el servidor lo mapea a una ruta predefinida); (2) Si las rutas dinámicas son inevitables, resolver la ruta canónica (realpath() en C/PHP, Path.GetFullPath() en .NET, os.path.realpath() en Python, path.resolve() en Node.js) y verificar que comience con el directorio base esperado usando una verificación estricta de prefijo; (3) Rechazar cualquier entrada que contenga separadores de ruta (/, \), secuencias de traversal, bytes nulos o variantes codificadas en URL — hacer esto después de decodificar; (4) Usar aislamiento a nivel del sistema operativo: jaulas chroot, namespaces de Linux, contenedores Docker con sistemas de archivos raíz de solo lectura, o perfiles AppArmor/SELinux que restrinjan el acceso a archivos del proceso; (5) Aplicar el principio de mínimo privilegio — el proceso del servidor web solo debería poseer y acceder a su raíz del documento; (6) Desplegar un WAF con firmas de traversal completas, incluyendo variantes codificadas y Unicode; (7) En Windows IIS, deshabilitar la generación de nombres cortos (8.3) para prevenir traversal estilo PROGRA~1.

Ejemplos de Código

const express = require('express');
const path = require('path');
const fs = require('fs');

const app = express();

// VULNERABLE: user input directly concatenated into file path
app.get('/files/:name', (req, res) => {
  const filePath = path.join(__dirname, 'uploads', req.params.name);
  // No validation — attacker uses: /files/..%2f..%2f..%2fetc%2fpasswd
  fs.readFile(filePath, (err, data) => {
    if (err) return res.status(404).send('Not found');
    res.send(data);
  });
});

// Attacker requests:
// GET /files/....//....//....//etc/passwd
// GET /files/%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd
// GET /files/..%252f..%252f..%252fetc%252fpasswd  (double encoding)

const express = require('express');
const path = require('path');
const fs = require('fs');

const app = express();
const UPLOAD_DIR = path.resolve(__dirname, 'uploads');

app.get('/files/:name', (req, res) => {
  const fileName = req.params.name;

  // 1. Reject any path separators or traversal sequences
  if (/[\/\\]/.test(fileName) || fileName.includes('..')) {
    return res.status(400).json({ error: 'Invalid filename' });
  }

  // 2. Resolve the canonical (real) path
  const resolved = path.resolve(UPLOAD_DIR, fileName);

  // 3. Strict prefix check — must be inside UPLOAD_DIR
  if (!resolved.startsWith(UPLOAD_DIR + path.sep)) {
    return res.status(403).json({ error: 'Access denied' });
  }

  // 4. Verify file exists and is a regular file (not symlink to outside)
  fs.lstat(resolved, (err, stats) => {
    if (err || !stats.isFile()) {
      return res.status(404).json({ error: 'Not found' });
    }
    // 5. Check the real path of symlinks too
    const real = fs.realpathSync(resolved);
    if (!real.startsWith(UPLOAD_DIR + path.sep)) {
      return res.status(403).json({ error: 'Access denied' });
    }
    res.sendFile(real);
  });
});

package main

import (
	"net/http"
	"os"
	"path/filepath"
	"strings"
)

func safeFileHandler(baseDir string) http.HandlerFunc {
	absBase, _ := filepath.Abs(baseDir)

	return func(w http.ResponseWriter, r *http.Request) {
		// Clean the requested path
		reqPath := filepath.Clean(r.URL.Path)

		// Resolve the full path
		fullPath := filepath.Join(absBase, reqPath)
		absPath, err := filepath.Abs(fullPath)
		if err != nil {
			http.Error(w, "Invalid path", http.StatusBadRequest)
			return
		}

		// Verify the resolved path is within the base directory
		if !strings.HasPrefix(absPath, absBase+string(os.PathSeparator)) {
			http.Error(w, "Forbidden", http.StatusForbidden)
			return
		}

		// Resolve symlinks and re-check
		realPath, err := filepath.EvalSymlinks(absPath)
		if err != nil {
			http.Error(w, "Not found", http.StatusNotFound)
			return
		}
		if !strings.HasPrefix(realPath, absBase+string(os.PathSeparator)) {
			http.Error(w, "Forbidden", http.StatusForbidden)
			return
		}

		http.ServeFile(w, r, realPath)
	}
}

func main() {
	http.HandleFunc("/files/", safeFileHandler("./uploads"))
	http.ListenAndServe(":8080", nil)
}

Preguntas Frecuentes

Ataques Relacionados