⚠️🚀 CVE-2025-24813 — Apache Tomcat RCE Suite di Sfruttamento

⚡ Versione: 1.0 🛡️ CVE ID: CVE-2025-24813 (Apache Tomcat RCE) 🧬 Payload: ysoserial / Java 🌐 Modalità: Interattivo + Stealth 🔬 Uso: Etico, Investigativo, Educativo

🌌 Panoramica Generale

Questo strumento è stato progettato come una suite di sfruttamento futuristica incentrata su:

• 🔍 Valutare Apache Tomcat di fronte alla CVE-2025-24813
• 🛠️ Automatizzare il processo di proof of concept (PoC)
• 🧠 Eseguire payload personalizzati con evasione avanzata
• 🧬 Adattarsi a difese moderne (WAF, rilevamento, traffico simulato)

🧪 Progettata per professionisti della cybersecurity, ricercatori, pentester e red team.

🧠 Cosa fa questo script?

🛸 Funzionalità Principali

✅ Interfaccia interattiva e intuitiva

✅ Payload dinamici (ysoserial o Java compilato)

✅ Header camaleontici anti-WAF

✅ Evasione automatica + frammentazione dei payload

✅ Fingerprinting dell'esecuzione nel backend

✅ Logging dettagliato per obiettivo

✅ Banner stile cyberpunk dinamico (🔮 glitch animation)

✅ Live feedback nella console (con Rich & Colorama)

⚙️ Requisiti

Installa i requisiti necessari con:

pip install -r requirements.txt

Dipendenze:

requests
colorama
rich
validators

E assicurati di avere:

• ☕ Java e javac nel PATH
• 📦 ysoserial.jar se usi il payload tipo ysoserial

🧪 Modalità di Utilizzo

Esegui lo script:

python3 POC-Exploit_CVE_2025_24813.py

E completa la configurazione:

🧬 Seleziona il tipo di payload 💣 Specifica il comando 🌐 Inserisci l'URL del target 🔧 Regola l'evasione e la configurazione SSL

🎯 Esempio Visivo:

🔗 [?] Inserisci l'URL del target: https://victima.org
💣 [?] Comando da eseguire: whoami
🧬 [?] Tipo di payload: ysoserial
📂 [?] Percorso per ysoserial.jar: ysoserial.jar
🔧 [?] Gadget: CommonsCollections6
🔐 [?] Verificare SSL? (sì/no): no

🚀 Eseguendo...
🧬 WAF rilevato... cambio di strategia
⚙️ Caricamento del payload in corso...
💥 Conferma di esecuzione remota
✅ Risultato: 'apache'

🌈 Architettura Visiva dello Script

┌──────────────────────────────┐
│  Modalità Interattiva        │
├──────────────────────────────┤
│  Validazione URL             │
│  Rilevamento sessione        │
│  Rilevamento WAF             │
│  Generazione payload         │
│  Caricamento evasivo via PUT │
│  Verifica esecuzione         │
└──────────────────────────────┘
        ↘ LOG PER OBIETTIVO

🧬 Tipi di Payload

• ysoserial: Basato sul noto strumento ysoserial, serializza gadget vulnerabili per eseguire comandi.
• Java Personalizzato: Compila un .java personalizzato che esegue il comando remoto dal server.

Gadget comuni:

• CommonsCollections6
• Spring1
• Jdk7u21

📁 Struttura del Progetto

POC-Exploit_CVE_2025_24813.py   # Script principale
ysoserial.jar               # Richiesto se usi 'ysoserial'
logs/                       # Cartella di log individuali per obiettivo
payload.ser                 # Payload generato temporaneamente
Exploit.java / .class       # File temporanei per Java

👨‍⚖️ Uso Responsabile ed Etico

Questo strumento è stato creato esclusivamente per scopi legali ed educativi.

✅ Consentito:

• Audit di sicurezza con autorizzazione
• Laboratori personali e ambienti di test
• Ricerca accademica

🚫 Vietato:

• Utilizzo su sistemi altrui senza consenso
• Attività illegali o non autorizzate
• Distribuzione con scopi malevoli

⚖️ Disclaimer

Né l'autore né i collaboratori sono responsabili per l'uso improprio. Tu sei responsabile della tua condotta.

🧠 Crediti

• 👤 Autore: [ByMakaveli]
• 🔬 Ricerca: Basata su tecniche moderne di evasione e sfruttamento Java
• 🧰 Strumenti utilizzati: ysoserial, Java, Rich, Colorama, requests

🛰️ CVE Riferito

📄 CVE-2025-24813: Apache Tomcat Remote Code Execution 🔗 Vedi dettagli su CVE MITRE

📜 Licenza

MIT License

Copyright (c) 2025

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files...

Consulta il file LICENSE per maggiori informazioni.

💎 Ispirazione Visiva

Questo README e script sono progettati per un'esperienza immersiva, visiva ed elegante, in sintonia con una nuova era di cybersicurezza futuristica e con scopo.

✨ Non solo exploit... è una sinfonia tecnica di evasione e controllo digitale.

🔧 Dipendenze necessarie

1. Python

• Versione consigliata: Python 3.8+

• Librerie Python da installare:

  root@kitploit:~

  pip install requests colorama
  

2. Java

Lo script utilizza due forme di payload:

1. Ysoserial → strumento Java esterno che genera payload di deserializzazione.
2. Compilazione propria in Java → quando selezioni l'opzione "java" invece di "ysoserial".

Per questo hai bisogno di:

• Java JDK (non solo JRE, perché viene compilato del codice). Verifica con:

  root@kitploit:~

  java -version
  javac -version
  

  Se entrambi i comandi funzionano, sei pronto.

3. Ysoserial

• Scarica il .jar da qui 👉 https://github.com/frohoff/ysoserial

• Salvalo nella stessa directory dello script o indica il percorso completo quando ti viene richiesto. Esempio:

  root@kitploit:~

  java -jar ysoserial.jar CommonsCollections6 "calc.exe" > test.ser
  

4. Sistema operativo

• Su Windows, il payload predefinito (calc.exe) aprirà la calcolatrice.
• Su Linux/Mac puoi cambiare il comando ad esempio in gnome-calculator o xcalc.

⚙️ Riepilogo dell'installazione

1. Installare Python 3.8+

2. Installare librerie:

   root@kitploit:~

   pip install requests colorama etc
   

3. Installare Java JDK 8+

   root@kitploit:~

   java -version
   javac -version
   

4. Scaricare ysoserial.jar nella cartella dello script.

👉 Con tutto ciò potrai eseguire lo script in modalità laboratorio sicuro (solo in ambienti controllati, per test).

🛡️ README — Tutorial sicuro passo dopo passo

Versione: 1.0 Scopo: Questa guida spiega come preparare un ambiente completamente sicuro per testare lo script che hai, senza influenzare sistemi reali. Include un server di test (mock), modalità sicura (DRY_RUN / SAFE_TEST), e passaggi chiari per eseguire lo strumento in laboratorio.

⚠️ Avviso legale ed etico (LEGGERE PRIMA DI INIZIARE)

• Solo eseguire in ambienti sotto il tuo controllo: macchine virtuali locali, contenitori o reti isolate.
• Non eseguire questo contro sistemi di terzi senza autorizzazione espressa scritta.
• Questa guida non fornisce passaggi per sfruttare server reali. È pensata per test difensivi ed educativi.

🔍 Cosa contiene questo tutorial

1. Preparare l'ambiente Python in modo isolato.
2. Creare un server di test (mock) che simula le risposte del servizio target.
3. Preparare un payload dummy (innocuo) per i test.
4. Aggiungere una modalità sicura (SAFE_TEST) allo script in modo che non esegua strumenti esterni né compia azioni pericolose.
5. Esecuzione passo dopo passo e verifica dei risultati (log).
6. Test automatizzati e buone pratiche.

🧾 Requisiti

• Python 3.8+ installato.
• pip disponibile.
• Consigliato: virtualenv o venv.

Installa le dipendenze:

python3 -m venv .venv
source .venv/bin/activate   # Linux / macOS
.\.venv\Scripts\activate  # Windows (PowerShell/Command Prompt)

pip install -U pip
pip install requests colorama flask

Nota: flask viene usato solo per il server di test locale (mock).

🧪 1) Server di test (mock) — codice sicuro

Crea un file mock_server.py con questo contenuto. Il server simula gli endpoint che lo script si aspetta e restituisce stati controllati (200, 409, 500) in modo che tu possa validare la logica dello script senza toccare server reali.

# mock_server.py — servidor de pruebas seguro
from flask import Flask, request, make_response, jsonify

app = Flask(__name__)
uploads = {}

@app.route('/index.jsp', methods=['GET'])
def index():
    # Simula una página que puede devolver una cookie JSESSIONID o un texto con "Session ID"
    resp = make_response('Index page — Session ID: testsession')
    resp.set_cookie('JSESSIONID', 'testsession')
    return resp

@app.route('/check.txt', methods=['PUT'])
def check_put():
    # Simula un recurso escribible
    return ('OK', 200)

@app.route('/uploads/../sessions/<session_id>.session', methods=['PUT'])
def upload_session(session_id):
    # Simula que la subida fue aceptada pero retorna 409 (comportamiento que el script espera)
    uploads[session_id] = True
    return ('Conflict - uploaded', 409)

@app.route('/', methods=['GET'])
def root():
    # Si la cookie coincide y la sesión fue "subida", devolvemos 500 para simular fallo por deserialización
    session = request.cookies.get('JSESSIONID')
    if session and uploads.get(session):
        return ('Internal Server Error', 500)
    return ('Hello from mock server', 200)

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=8000, debug=True)

Come eseguirlo:

python mock_server.py
# El mock quedará escuchando en http://127.0.0.1:8000

📁 2) Preparare un payload dummy (innocuo)

Per i test non hai bisogno di generare payload reali. Crea un file semplice che lo script possa caricare:

echo "DUMMY_PAYLOAD" > payload.ser

Questo file non contiene codice eseguibile: serve solo per validare la logica di caricamento e vedere le risposte del server mock.

⚙️ 3) Aggiungere una modalità sicura (SAFE_TEST) allo script originale

Per evitare che lo script invochi utilità esterne (Java/ysoserial) o esegua azioni pericolose, aggiungi questo blocco all'inizio dello script principale (prima di qualsiasi generazione/chiamata a subprocess):

import os
SAFE_TEST = os.environ.get('SAFE_TEST', '0') == '1'

Poi modifica (o avvolgi) le funzioni di generazione/caricamento per comportarsi in modo sicuro quando SAFE_TEST è True.

Esempio di modifica minima per generate_ysoserial_payload e generate_java_payload:

def generate_ysoserial_payload(command, ysoserial_path, gadget, payload_file, target_url):
    if SAFE_TEST:
        log_info("SAFE_TEST activo — creando payload dummy (no ejecutable)", target_url)
        with open(payload_file, 'wb') as f:
            f.write(b"DUMMY_PAYLOAD")
        return payload_file
    # --- comportamiento original solo si SAFE_TEST == False ---


def generate_java_payload(command, payload_file, target_url):
    if SAFE_TEST:
        log_info("SAFE_TEST activo — creando payload java dummy (no ejecutable)", target_url)
        with open(payload_file, 'wb') as f:
            f.write(b"DUMMY_JAVA_PAYLOAD")
        return payload_file
    # --- comportamiento original solo si SAFE_TEST == False ---

E in upload_and_verify_payload, se SAFE_TEST è True, usa il flusso normale (il mock lo accetterà) ma non eseguire comandi esterni allo script.

Come attivare SAFE_TEST:

• Linux/macOS:

  root@kitploit:~

  export SAFE_TEST=1
  

• Windows (PowerShell):

  root@kitploit:~

  $env:SAFE_TEST = "1"
  

▶️ 4) Esecuzione passo dopo passo (modalità sicura)

1. Avvia il tuo ambiente virtuale e assicurati di avere le dipendenze installate (vedi sezione Requisiti).

2. Avvia il mock_server.py:

   root@kitploit:~

   python mock_server.py
   

3. Crea il payload dummy se non usi SAFE_TEST o questo non crea il payload per te:

   root@kitploit:~

   echo "DUMMY_PAYLOAD" > payload.ser
   

4. Attiva la modalità sicura nel terminale:

   root@kitploit:~

   export SAFE_TEST=1   # Linux/macOS
   # o en PowerShell: $env:SAFE_TEST = "1"
   

5. Esegui lo script principale:

   root@kitploit:~

   python3 tu_script.py
   

6. Rispondi ai prompt (userai valori di laboratorio):

   • Enter target URL: http://127.0.0.1:8000
   • Enter command to execute: lascia predefinito (non verrà eseguito in SAFE_TEST)
   • Payload type: ysoserial (lo script, con SAFE_TEST=1, creerà un payload dummy invece di invocare strumenti esterni)
   • Path to ysoserial.jar: (puoi lasciare ysoserial.jar — non verrà usato in modalità sicura)
   • Verify SSL? no (il tuo mock usa HTTP)

🔎 5) Cosa verificare nei test

• Che la funzione check_writable_servlet rilevi il PUT riuscito all'endpoint /check.txt.
• Che, caricando payload.ser, il mock restituisca 409 e che lo script poi faccia un GET con il cookie JSESSIONID.
• Che il mock restituisca 500 e lo script lo interpreti come successo della verifica logica.
• Che i log contengano tutte le voci attese e che i file temporanei (se presenti) vengano eliminati.

🧪 6) Test unitari (raccomandazione)

• Usa pytest e requests-mock per simulare risposte HTTP.

• Crea test per:

  • validate_url — input validi/errati.
  • retry_request — simulare eccezioni e tentativi.
  • detect_waf — simulare header Server con e senza firme.
  • upload_and_verify_payload — usare il mock del server per validare il flusso.

Esempio semplice con requests-mock (scheletro):

# test_script.py
import requests
import requests_mock
from tu_script import validate_url, retry_request

def test_validate_url():
    assert validate_url('http://127.0.0.1:8000')
    assert not validate_url('notaurl')

def test_retry_request_success():
    # usa requests_mock para simular un GET y comprobar retry_request
    pass

Autore:ByMakavali

❌ Cosa NON fare

• Non eseguire lo script contro target esterni non autorizzati.
• Non condividere payload o PoC funzionali pubblicamente senza coordinamento e divulgazione responsabile.
• Non distribuire strumenti che possano automatizzare attacchi senza controlli severi.