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-2017-5638-Attack-and-Defense — Laboratório de segurança baseado em Docker que demonstra a exploração e defesa do Apache Struts2 S2-045 (CVE-2017-5638), apresentando aplicações vulneráveis e corrigidas com proteção WAF para treinamento prático. | Kitploit
Ferramentas/GitHubGitHub/acharaf06/cve-2017-5638-attack-and-defense
Ferramentas DefensivasAnálise de VulnerabilidadesExploração de Aplicações WebBypass de WAFTestes de PenetraçãoAprendizado e EducaçãoLabs e Prática
GitHubacharaf06/cve-2017-5638-attack-and-defense

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 →

CVE-2017-5638-Attack-and-Defense

Laboratório de segurança baseado em Docker que demonstra a exploração e defesa do Apache Struts2 S2-045 (CVE-2017-5638), apresentando aplicações vulneráveis e corrigidas com proteção WAF para treinamento prático.

Ver Repositório
15há 8 mesesAinda não revisado
Compartilhar

Laboratório de Defesa e Exploração do Apache Struts2 S2-045

Um laboratório de segurança baseado em Docker que demonstra tanto a exploração quanto a defesa contra a vulnerabilidade Apache Struts2 S2-045 (CVE-2017-5638). Este laboratório inclui:

  1. Aplicação Vulnerável: Struts 2.3.31 (vulnerável ao S2-045) para demonstração de exploração
  2. Laboratório de Defesa: Struts 6.3.x (corrigido) com proteção WAF para treinamento defensivo

⚠️ Aviso de Segurança: Este laboratório contém exploits funcionais e código vulnerável. Use apenas em ambientes isolados. NÃO exponha a redes públicas.

Visão Geral da Arquitetura

root@kitploit:~
┌─────────────────────────────────────────────────────────────┐
│                     Host (127.0.0.1 only)                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────────┐    ┌─────────────────┐              │
│  │   Simulator     │───▶│  Nginx Proxy    │              │
│  │  (curl-based)   │    │  + WAF Rules    │              │
│  └─────────────────┘    └────────┬────────┘              │
│                                  │                        │
│                          ┌───────┴────────┐              │
│                          │                │                │
│                  ┌───────▼──────┐ ┌───────▼──────┐        │
│                  │  Defense App │ │ Vulnerable   │        │
│                  │ (Struts 6.3) │ │ App (2.3.31) │        │
│                  │ Port: 8080  │ │ Port: 8081  │        │
│                  └──────────────┘ └──────────────┘        │
│                                                             │
│  ┌─────────────────┐                                      │
│  │  Exploit        │───▶ Vulnerable App (8081)            │
│  │  Container      │                                      │
│  └─────────────────┘                                      │
│                                                             │
│  Logs mounted to: ./logs/nginx/, ./logs/app/,             │
│                   ./logs/app-vulnerable/                  │
└─────────────────────────────────────────────────────────────┘

Componentes

ContainerFinalidadePorta
nginxProxy reverso com regras WAF, limitação de taxa127.0.0.1:8080
appTomcat 9 + Struts 6.3.x (corrigido, laboratório de defesa)Apenas interno
app-vulnerableTomcat 9 + Struts 2.3.31 (vulnerável, para exploração)127.0.0.1:8081
exploitContainer de demonstração de exploraçãoN/A
simulatorEnvia requisições de teste (padrões benignos + suspeitos)N/A

Primeiros Passos

Pré-requisitos

  • Docker (versão 20.10 ou superior)
  • Docker Compose (versão 2.0 ou superior)
  • Python 3 (opcional, para executar scripts de exploit diretamente)
  • curl (opcional, para testes manuais)

Instalação

1. Clone o Repositório

root@kitploit:~
# Clone the repository
git clone https://github.com/ACharaf06/cybersec.git
cd cybersec

2. Construir e Executar

root@kitploit:~
# Build all containers (this may take several minutes on first run)
docker compose build

# Start the defense lab (nginx + patched app)
docker compose up -d nginx app

# Start the vulnerable app (for exploitation demo)
docker compose up -d app-vulnerable

# Verify services are running
docker compose ps

# Wait for services to be healthy (about 60 seconds)
sleep 60

# Check health endpoints
curl http://127.0.0.1:8080/struts-lab/health  # Defense lab
curl http://127.0.0.1:8081/struts-lab/health   # Vulnerable app

Saída Esperada:

  • Laboratório de defesa: resposta JSON com "status":"healthy" e "strutsVersion":"6.3.0.2 (patched - not vulnerable to S2-045)"
  • Aplicação vulnerável: resposta JSON com "status":"healthy" e "strutsVersion":"2.3.31 (VULNERABLE to S2-045)"

2. Testes do Laboratório de Defesa

root@kitploit:~
# Run the simulator container (tests defense mechanisms)
docker-compose run --rm simulator

# Or run individual tests manually:
# Legitimate upload
curl -X POST -F "[email protected]" http://127.0.0.1:8080/struts-lab/upload

# Suspicious Content-Type (will be blocked by WAF)
curl -v -X POST \
  -H "Content-Type: multipart/form-data; boundary=----SUSPICIOUS" \
  http://127.0.0.1:8080/struts-lab/upload

3. Demonstração de Exploração

root@kitploit:~
# Run the exploit container (demonstrates S2-045 exploitation)
docker-compose --profile exploit run --rm exploit

# Or use the Python exploit script directly
python3 exploit/exploit.py http://127.0.0.1:8081/struts-lab 'whoami'

# Or use the bash script
./exploit/demo_exploit.sh

⚠️ Aviso: A aplicação vulnerável é intencionalmente explorável. Execute apenas em ambientes isolados.

4. Observar Logs

root@kitploit:~
# Defense lab logs
tail -f logs/nginx/access.log      # Nginx access logs
tail -f logs/nginx/error.log       # WAF blocks
tail -f logs/app/struts-lab.log    # Defense app logs

# Vulnerable app logs
tail -f logs/app-vulnerable/struts-lab.log  # Vulnerable app logs

# All logs combined
docker-compose logs -f

O que Observar

Laboratório de Defesa (Porta 8080)

Requisição Legítima:

  • Log de acesso do Nginx: resposta 200
  • Log da aplicação: mensagem de processamento de upload em nível INFO
  • Requisição concluída com sucesso

Requisição Suspeita/ Malformada:

  • Log de acesso do Nginx: 403 Forbidden ou 400 Bad Request
  • Log de erro do Nginx: mensagem de regra WAF acionada
  • Log da aplicação: pode mostrar erro de parsing se a requisição chegar à aplicação
  • Requisição bloqueada ou sanitizada

Aplicação Vulnerável (Porta 8081)

Exploração Bem-sucedida:

  • Resposta HTTP 200 ou 500
  • Saída do comando visível no corpo da resposta
  • Expressões OGNL avaliadas
  • Comandos do sistema executados

Exemplos de Logs:

Nginx bloqueando Content-Type suspeito (Laboratório de Defesa):

root@kitploit:~
[WAF] Blocked suspicious Content-Type pattern - Request ID: abc123

Registro de metadados da requisição pela aplicação (Laboratório de Defesa):

root@kitploit:~
[REQUEST] ID=abc123 Content-Type=multipart/form-data Method=POST URI=/upload
[UPLOAD] Processing file upload for request abc123

Exploração bem-sucedida (Aplicação Vulnerável):

root@kitploit:~
HTTP/1.1 200 OK
...
root
(Command output appears in response body)

Comparação: Vulnerável vs Defesa

CaracterísticaAplicação Vulnerável (Porta 8081)Laboratório de Defesa (Porta 8080)
Versão do Struts2.3.31 (vulnerável)6.3.0.2 (corrigido)
Proteção WAF❌ Nenhuma✅ Regras WAF do Nginx
Limitação de Taxa❌ Nenhuma✅ 10 req/s
Limites de Tamanho de Requisição❌ Nenhum✅ 10MB corpo, 8KB cabeçalhos
Registro de Segurança⚠️ Mínimo✅ Abrangente
Injeção OGNL✅ Explorável❌ Bloqueada/Corrigida
RCE Possível✅ Sim❌ Não
Caso de UsoDemonstração de exploraçãoTreinamento de defesa

Notas de Segurança

Isolamento

  • Todos os serviços vinculados apenas a 127.0.0.1 (sem acesso externo)
  • Rede Docker interna para comunicação entre contêineres
  • Nenhuma porta exposta para 0.0.0.0
  • A aplicação vulnerável NUNCA deve ser exposta a redes públicas

Camadas de Defesa (Laboratório de Defesa)

  1. Regras WAF do Nginx: Bloqueia padrões suspeitos de Content-Type antes de chegar à aplicação
  2. Limitação de Taxa: 10 requisições/segundo por IP
  3. Limites de Tamanho de Requisição: Máximo de 10MB corpo, 8KB cabeçalhos
  4. Struts Corrigido: Usa Struts 6.3.x (não vulnerável ao S2-045)
  5. Registro Abrangente: Toda atividade suspeita é registrada

O que foi o S2-045

S2-045 (CVE-2017-5638) foi uma vulnerabilidade crítica no Apache Struts2 versões 2.3.5 - 2.3.31 e 2.5 - 2.5.10 onde:

  • Cabeçalhos Content-Type maliciosos podiam injetar expressões OGNL
  • O parser Jakarta Multipart avaliava essas expressões
  • Isso levava à Execução Remota de Código (RCE)

A aplicação vulnerável (porta 8081) demonstra essa vulnerabilidade. O laboratório de defesa (porta 8080) mostra como se proteger contra ela.

Estrutura de Arquivos

root@kitploit:~
.
├── docker-compose.yml          # Orquestração de contêineres
├── README.md                   # Este arquivo
├── EXPLOITATION_GUIDE.md      # Guia detalhado de exploração
├── TECHNICAL_DETAILS.md        # Detalhes técnicos de implementação
├── GLOSSARY.md                 # Glossário de termos de segurança
├── nginx/
│   ├── nginx.conf              # Configuração principal do Nginx
│   └── waf-rules.conf          # Regras WAF para padrões S2-045
├── app/                        # Laboratório de defesa (corrigido)
│   ├── Dockerfile              # Construção Tomcat + Maven
│   └── struts-app/
│       ├── pom.xml             # Projeto Maven (Struts 6.3.x)
│       └── src/main/
│           ├── java/           # Classes Action
│           ├── resources/      # Configuração Struts + Log4j
│           └── webapp/         # Visualizações JSP + web.xml
├── app-vulnerable/             # Aplicação vulnerável (para exploração)
│   ├── Dockerfile              # Construção Tomcat + Maven
│   └── struts-app/
│       ├── pom.xml             # Projeto Maven (Struts 2.3.31)
│       └── src/main/
│           ├── java/           # Classes Action
│           ├── resources/      # Configuração Struts + Log4j
│           └── webapp/         # Visualizações JSP + web.xml
├── exploit/                    # Ferramentas de exploração
│   ├── Dockerfile              # Container de exploit
│   ├── demo_exploit.sh         # Script Bash de exploit
│   └── exploit.py              # Script Python de exploit
├── simulator/
│   ├── Dockerfile              # Alpine + curl
│   └── simulate.sh             # Script de teste
└── logs/                       # Diretório de logs montado
    ├── nginx/
    ├── app/                    # Logs do laboratório de defesa
    └── app-vulnerable/         # Logs da aplicação vulnerável

Limpeza

root@kitploit:~
# Stop all containers
docker compose down

# Remove volumes and logs
docker compose down -v
rm -rf logs/

# Full cleanup (including images)
docker compose down --rmi all -v

Configuração de Desenvolvimento

Estrutura do Projeto

O projeto está organizado da seguinte forma:

  • app/ - Aplicação do laboratório de defesa (Struts 6.3.x, corrigido)
  • app-vulnerable/ - Aplicação vulnerável (Struts 2.3.31)
  • exploit/ - Ferramentas e scripts de exploração
  • nginx/ - Configuração do proxy reverso Nginx com regras WAF
  • simulator/ - Simulador de padrões de ataque
  • logs/ - Logs da aplicação (gitignored)

Construindo Componentes Individuais

root@kitploit:~
# Rebuild only the vulnerable app
docker compose build app-vulnerable
docker compose up -d app-vulnerable

# Rebuild only the defense app
docker compose build app
docker compose up -d app

# Rebuild exploit container
docker compose build exploit

Documentação

  • EXPLOITATION_GUIDE.md: Guia detalhado sobre o mecanismo da vulnerabilidade S2-045 e procedimento de exploração
  • TECHNICAL_DETAILS.md: Detalhes técnicos de implementação do laboratório
  • GLOSSARY.md: Glossário de termos de segurança usados neste laboratório

Recursos Educacionais

  • Boletins de Segurança do Apache Struts
  • Detalhes do CVE-2017-5638
  • Prevenção de Injeção OWASP
  • Módulo Metasploit S2-045

⚠️ Avisos Importantes

  1. Aplicação Vulnerável: A aplicação na porta 8081 é intencionalmente vulnerável. NÃO exponha a redes públicas.
  2. Exploits Funcionais: Este laboratório contém código de exploit funcional. Use apenas em ambientes isolados.
  3. Propósito Educacional: Este laboratório é apenas para educação em segurança, pesquisa e testes de penetração autorizados.
  4. Conformidade Legal: Use apenas em sistemas que você possui ou para os quais tenha autorização explícita por escrito para testar.

Aviso Legal: Este laboratório é apenas para fins educacionais. Use com responsabilidade e apenas em ambientes controlados.

Baixar ferramenta