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-2017-5638-Attack-and-Defense — Laboratorio di sicurezza basato su Docker che dimostra lo sfruttamento e la difesa di Apache Struts2 S2-045 (CVE-2017-5638) con un'app vulnerabile, un'app corretta, Nginx WAF e script di exploit per una formazione pratica. | Kitploit
Strumenti/GitHubGitHub/acharaf06
/cve-2017-5638-attack-and-defense
Strumenti DifensiviAnalisi delle VulnerabilitàSfruttamento di Applicazioni WebBypass WAFPenetration TestingApprendimento e FormazioneLab e Pratica
GitHubacharaf06/cve-2017-5638-attack-and-defense

CVE-2017-5638-Attack-and-Defense

Laboratorio di sicurezza basato su Docker che dimostra lo sfruttamento e la difesa di Apache Struts2 S2-045 (CVE-2017-5638) con un'app vulnerabile, un'app corretta, Nginx WAF e script di exploit per una formazione pratica.

Vedi Repository
18 mesi 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

Laboratorio di Difesa e Sfruttamento di Apache Struts2 S2-045

Un laboratorio di sicurezza basato su Docker che dimostra sia lo sfruttamento che la difesa contro la vulnerabilità Apache Struts2 S2-045 (CVE-2017-5638). Questo laboratorio include:

  1. Applicazione Vulnerabile: Struts 2.3.31 (vulnerabile a S2-045) per dimostrazione dello sfruttamento
  2. Laboratorio di Difesa: Struts 6.3.x (corretto) con protezione WAF per formazione difensiva

⚠️ Avviso di Sicurezza: Questo laboratorio contiene exploit funzionanti e codice vulnerabile. Da usare solo in ambienti isolati. NON esporre a reti pubbliche.

Panoramica dell'Architettura

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

Componenti

ContenitoreScopoPorta
nginxProxy inverso con regole WAF, limitazione della velocità127.0.0.1:8080
appTomcat 9 + Struts 6.3.x (corretto, laboratorio di difesa)Solo interno
app-vulnerableTomcat 9 + Struts 2.3.31 (vulnerabile, per sfruttamento)127.0.0.1:8081
exploitContenitore dimostrativo di sfruttamentoN/D
simulatorInvia richieste di test (pattern benigni + sospetti)N/D

Per Iniziare

Prerequisiti

  • Docker (versione 20.10 o successiva)
  • Docker Compose (versione 2.0 o successiva)
  • Python 3 (opzionale, per eseguire script di exploit direttamente)
  • curl (opzionale, per test manuali)

Installazione

1. Clona il Repository

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

2. Costruisci ed Esegui

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

Output Previsto:

  • Laboratorio di difesa: risposta JSON con "status":"healthy" e "strutsVersion":"6.3.0.2 (patched - not vulnerable to S2-045)"
  • App vulnerabile: risposta JSON con "status":"healthy" e "strutsVersion":"2.3.31 (VULNERABLE to S2-045)"

2. Test del Laboratorio di Difesa

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. Dimostrazione di Sfruttamento

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

⚠️ Avviso: L'applicazione vulnerabile è intenzionalmente sfruttabile. Eseguire solo in ambienti isolati.

4. Osserva i Log

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

Cosa Osservare

Laboratorio di Difesa (Porta 8080)

Richiesta Legittima:

  • Log di accesso Nginx: risposta 200
  • Log dell'app: messaggio di elaborazione upload a livello INFO
  • Richiesta completata con successo

Richiesta Sospetta/Malformata:

  • Log di accesso Nginx: 403 Forbidden o 400 Bad Request
  • Log errori Nginx: messaggio di regola WAF attivata
  • Log dell'app: potrebbe mostrare errore di parsing se la richiesta raggiunge l'app
  • Richiesta bloccata o sanificata

App Vulnerabile (Porta 8081)

Sfruttamento Riuscito:

  • Risposta HTTP 200 o 500
  • Output del comando visibile nel corpo della risposta
  • Espressioni OGNL valutate
  • Comandi di sistema eseguiti

Esempi di Log:

Nginx blocca Content-Type sospetto (Laboratorio di Difesa):

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

Log dei metadati della richiesta nell'app (Laboratorio di Difesa):

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

Sfruttamento riuscito (App Vulnerabile):

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

Confronto: Vulnerabile vs Difesa

CaratteristicaApp Vulnerabile (Porta 8081)Laboratorio di Difesa (Porta 8080)
Versione Struts2.3.31 (vulnerabile)6.3.0.2 (corretto)
Protezione WAF❌ Nessuna✅ Regole WAF Nginx
Limitazione di Velocità❌ Nessuna✅ 10 richieste/s
Limiti Dimensione Richiesta❌ Nessuno✅ 10MB corpo, 8KB intestazioni
Registrazione di Sicurezza⚠️ Minima✅ Completa
Iniezione OGNL✅ Sfruttabile❌ Bloccata/Corretta
RCE Possibile✅ Sì❌ No
Caso d'UsoDimostrazione sfruttamentoFormazione difensiva

Note di Sicurezza

Isolamento

  • Tutti i servizi vincolati solo a 127.0.0.1 (nessun accesso esterno)
  • Rete Docker interna per comunicazione tra container
  • Nessuna esposizione di porta a 0.0.0.0
  • L'app vulnerabile NON deve MAI essere esposta a reti pubbliche

Strati Difensivi (Laboratorio di Difesa)

  1. Regole WAF Nginx: Blocca pattern sospetti di Content-Type prima che raggiungano l'app
  2. Limitazione di Velocità: 10 richieste/secondo per IP
  3. Limiti Dimensione Richiesta: massimo 10MB corpo, 8KB intestazioni
  4. Struts Corretto: Utilizza Struts 6.3.x (non vulnerabile a S2-045)
  5. Registrazione Completa: Tutte le attività sospette vengono registrate

Cos'era S2-045

S2-045 (CVE-2017-5638) era una vulnerabilità critica in Apache Struts2 versioni 2.3.5 - 2.3.31 e 2.5 - 2.5.10 in cui:

  • Intestazioni Content-Type malevole potevano iniettare espressioni OGNL
  • Il parser Jakarta Multipart valutava queste espressioni
  • Ciò portava all'esecuzione di codice in remoto (RCE)

L'app vulnerabile (porta 8081) dimostra questa vulnerabilità. Il laboratorio di difesa (porta 8080) mostra come proteggersi.

Struttura dei File

root@kitploit:~
.
├── docker-compose.yml          # Orchestrazione dei container
├── README.md                   # Questo file
├── EXPLOITATION_GUIDE.md      # Guida dettagliata allo sfruttamento
├── TECHNICAL_DETAILS.md        # Dettagli di implementazione tecnica
├── GLOSSARY.md                 # Glossario dei termini di sicurezza
├── nginx/
│   ├── nginx.conf              # Configurazione principale di nginx
│   └── waf-rules.conf          # Regole WAF per pattern S2-045
├── app/                        # Laboratorio di difesa (corretto)
│   ├── Dockerfile              # Build Tomcat + Maven
│   └── struts-app/
│       ├── pom.xml             # Progetto Maven (Struts 6.3.x)
│       └── src/main/
│           ├── java/           # Classi Action
│           ├── resources/      # Configurazione Struts + Log4j
│           └── webapp/         # Viste JSP + web.xml
├── app-vulnerable/             # App vulnerabile (per sfruttamento)
│   ├── Dockerfile              # Build Tomcat + Maven
│   └── struts-app/
│       ├── pom.xml             # Progetto Maven (Struts 2.3.31)
│       └── src/main/
│           ├── java/           # Classi Action
│           ├── resources/      # Configurazione Struts + Log4j
│           └── webapp/         # Viste JSP + web.xml
├── exploit/                    # Strumenti di sfruttamento
│   ├── Dockerfile              # Contenitore exploit
│   ├── demo_exploit.sh         # Script bash di exploit
│   └── exploit.py              # Script Python di exploit
├── simulator/
│   ├── Dockerfile              # Alpine + curl
│   └── simulate.sh             # Script di test
└── logs/                       # Directory log montata
    ├── nginx/
    ├── app/                    # Log del laboratorio di difesa
    └── app-vulnerable/         # Log dell'app vulnerabile

Pulizia

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

Configurazione di Sviluppo

Struttura del Progetto

Il progetto è organizzato come segue:

  • app/ - Applicazione del laboratorio di difesa (Struts 6.3.x, corretto)
  • app-vulnerable/ - Applicazione vulnerabile (Struts 2.3.31)
  • exploit/ - Strumenti e script di sfruttamento
  • nginx/ - Configurazione del proxy inverso Nginx con regole WAF
  • simulator/ - Simulatore di pattern di attacco
  • logs/ - Log dell'applicazione (gitignorati)

Costruzione di Componenti Individuali

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

Documentazione

  • EXPLOITATION_GUIDE.md: Guida dettagliata sul meccanismo della vulnerabilità S2-045 e sulla procedura di sfruttamento
  • TECHNICAL_DETAILS.md: Dettagli di implementazione tecnica del laboratorio
  • GLOSSARY.md: Glossario dei termini di sicurezza utilizzati in questo laboratorio

Risorse Educative

  • Bollettini di sicurezza di Apache Struts
  • Dettagli CVE-2017-5638
  • Prevenzione delle Iniezioni OWASP
  • Modulo Metasploit S2-045

⚠️ Avvertenze Importanti

  1. Applicazione Vulnerabile: L'app sulla porta 8081 è intenzionalmente vulnerabile. NON esporla a reti pubbliche.
  2. Exploit Funzionanti: Questo laboratorio contiene codice di exploit funzionante. Da usare solo in ambienti isolati.
  3. Scopo Educativo: Questo laboratorio è solo per educazione alla sicurezza, ricerca e test di penetrazione autorizzati.
  4. Conformità Legale: Usare solo su sistemi di tua proprietà o per i quali hai esplicita autorizzazione scritta al test.

Disclaimer: Questo laboratorio è solo a scopo educativo. Usalo responsabilmente e solo in ambienti controllati.

Scarica lo strumento