Java4Shell: falha crítica no OpenJDK permite RCE sem login

Falha de corrupção de memória no decodificador Base64 acelerado do OpenJDK atinge versões a partir da 17.0.6 em processadores com AVX-512. A Oracle corrigiu em 17 de novembro e não há relato de exploração ativa até agora.

Ilustração abstrata de estouro de buffer: blocos de memória ultrapassando o limite de uma área delimitada

Arte editorial: escrita além do limite do buffer de destino.

Em 17 de novembro de 2026, a empresa de segurança Calif divulgou o Java4Shell, uma falha de corrupção de memória no OpenJDK que, em aplicações específicas, permite execução remota de código sem autenticação. A vulnerabilidade recebeu o identificador CVE-2026-114938, e a Oracle liberou correções no mesmo dia, às 13h (horário do Pacífico), dentro do seu Critical Patch Update de novembro.

O problema não está em uma biblioteca de terceiros, e sim no coração da plataforma: a rotina de decodificação Base64 acelerada por hardware da HotSpot, a máquina virtual do OpenJDK. Qualquer aplicação Java que decodifique Base64 recebido de fora — algo corriqueiro em tokens, cabeçalhos, cookies e payloads de API — pode servir de caminho para o ataque, desde que rode em um processador x86-64 com suporte às instruções AVX-512 VBMI.

Há duas leituras de gravidade em circulação, e elas não coincidem. A Calif classificou a falha como crítica, com CVSS 4.0 de 9,2. A Oracle atribuiu severidade alta, com CVSS 3.1 de 8,1, e descreve a vulnerabilidade como “difícil de explorar”. A diferença não é cosmética: ela reflete justamente a distância entre provar a corrupção de memória e transformá-la em execução de código em um alvo real.

Como o Java4Shell funciona por dentro

Um intrinsic é uma rotina que a JVM substitui por código de máquina otimizado, escrito à mão, em vez de compilar o Java correspondente. O decodificador Base64 do OpenJDK tem um desses atalhos para processadores x86-64 com AVX-512, instruções vetoriais que processam blocos grandes de dados de uma vez.

O erro está no tratamento do preenchimento final — o sinal de igual que fecha uma string Base64. Nas palavras da análise da Calif, o intrinsic “calculou de forma incorreta a máscara de escrita da cauda com preenchimento, causando uma escrita fora dos limites”. Na prática, um contador de tamanho é decrementado sem qualquer piso, chega a valores negativos como -1 ou -2 e, por ser interpretado sem sinal, vira uma máscara com todos os bits ligados. A instrução de escrita vetorial então grava 64 bytes onde deveria gravar poucos. A VulnCheck, que reproduziu o problema em um Xeon Ice Lake, descreve o efeito como um estouro de cerca de 62 bytes além do buffer de destino, no heap.

O gatilho é embaraçosamente simples: 64 caracteres “A” seguidos de um sinal de igual. Em versões mais antigas do OpenJDK 17, são necessários 128 caracteres.

Quem é afetado

Três condições precisam se somar.

  • Versão: OpenJDK a partir da 17.0.6. Linhas 17, 21, 25 e 27 estão na lista.
  • Processador: apenas x86-64 com AVX-512 VBMI. Isso inclui Intel Xeon de Ice Lake em diante (e Sapphire Rapids) e AMD Zen 4 ou mais novo, como EPYC Genoa e Turin e Ryzen das séries 7000 e 9000. CPUs ARM64 não são afetadas, assim como chips Intel de servidor mais antigos.
  • Caminho de entrada: a aplicação precisa levar dados controlados pelo atacante até o decodificador Base64 vulnerável.

Como a falha está no OpenJDK, ela desce para praticamente todas as distribuições construídas a partir dele: Oracle Java SE e Oracle OpenJDK, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK e Oracle GraalVM.

A Calif afirma ter obtido execução remota de código em configuração padrão, sem autenticação, nas seguintes aplicações: Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins e PingFederate. Com autenticação, a lista inclui Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit e Spinnaker. Aplicações de exemplo em Apache Struts e Spring Boot também foram exploradas. A própria empresa classifica a relação como não exaustiva.

Há ainda um ângulo que costuma passar despercebido: o risco não é só de servidor. A Calif cita um exploit do lado cliente compartilhado pelo pesquisador samczsun, em que um programa Java que abre uma conexão TLS com um servidor malicioso pode ser comprometido. Isso coloca clientes, agentes e ferramentas de linha de comando no escopo.

Exploração: o que é demonstração e o que é risco real

Esta é a parte em que vale separar os fatos das projeções.

O que está confirmado: a Calif publicou um gatilho autocontido e limitado, chamado Base64Trigger, que reproduz a sobrescrita de memória dentro de um array de 4.096 bytes. As cadeias de exploração específicas por produto não foram liberadas — nas palavras da empresa, “as cadeias armadas para produtos individuais permanecem privadas até que todos tenham tido a chance de atualizar”. A Calif também descreve uma técnica de leitura do heap, apelidada de JavaBleed, capaz de expor dados pessoais, chaves e tokens.

O que não está confirmado: até a publicação das análises, não há relato de exploração ativa na natureza. A VulnCheck avalia que derrubar uma JVM (negação de serviço) é trivial para quem alcance um ponto de entrada vulnerável — em seus testes, uma rajada de requisições causou indisponibilidade de forma consistente —, mas que a execução de código exige manipulação não trivial do heap e um caminho adicional de vazamento de memória para contornar o ASLR. Não existe, portanto, um exploit universal: cada alvo exige um jeito próprio de entregar o Base64 malicioso.

Um detalhe digno de nota sobre o processo de descoberta: segundo a reportagem do BleepingComputer, o pesquisador Quang Luong encontrou a falha em cerca de uma hora e montou um exploit inicial em aproximadamente duas horas adicionais, usando um assistente de programação baseado em IA durante a auditoria dos internos do OpenJDK, a um custo total de uso inferior a US$ 200. É um indicador relevante sobre o custo decrescente de auditar código nativo complexo, ainda que seja um caso isolado e não uma medição sistemática.

Correção e mitigação

A atualização é a única solução real. A Oracle publicou o patch em 17 de novembro, dentro de um Critical Patch Update com 655 correções de segurança no total. Entre as versões corrigidas já confirmadas estão as do Amazon Corretto — 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 e 27.0.1.1.4 — e o Oracle JDK 17.0.21.1 (build 17.0.21.1+4). As versões listadas pela Oracle como afetadas são 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3 e 27.0.1.0.3; não confunda essa lista com builds corrigidos. Para as demais distribuições, confira o aviso de cada fornecedor.

Enquanto a atualização não chega, existem dois parâmetros de inicialização que desligam o caminho vulnerável. A VulnCheck relata que ambos impediram o estouro em seus testes com OpenJDK 17, 21 e 25:

-XX:-UseBASE64Intrinsics     # desativa os intrinsics de Base64
-XX:UseAVX=2                 # desativa o uso de AVX-512 (somente em x86-64)

Atenção ao segundo: o OpenJDK em ARM não reconhece essa opção e simplesmente não inicia. Os dois parâmetros têm custo de desempenho e são medidas temporárias, não substitutos do patch.

Checklist prático

  • Atualize todas as instalações Java afetadas, incluindo clientes que se conectam a servidores que você não controla.
  • Reinicie cada JVM depois de atualizar — sem isso, o processo continua rodando o build vulnerável.
  • Mapeie o hardware. Em Linux, verifique em /proc/cpuinfo a presença das flags avx512f, avx512bw, avx512vbmi e bmi2. Hosts sem elas não estão expostos a esta falha e podem sair da fila de prioridade.
  • Priorize o que está exposto: Keycloak, Jira, Confluence, Artifactory, Jenkins e PingFederate acessíveis pela internet merecem a primeira janela de manutenção.
  • Monitore picos de entradas Base64 grandes terminadas em preenchimento e quedas inesperadas de JVM, que podem indicar tentativas de disparo.
  • Avalie o período de exposição. Para instâncias que ficaram alcançáveis sem correção, procure sinais de uso e rotacione credenciais se não for possível descartar comprometimento.
  • Consulte os avisos oficiais antes de aceitar listas de versão de terceiros — elas divergem entre si neste caso.

Conclusão

O Java4Shell é menos explosivo do que o apelido sugere e mais incômodo do que a nota da Oracle indica. Não há exploração em massa à vista, não existe um exploit genérico e o hardware vulnerável, embora comum em servidores modernos, é um filtro real. Em compensação, a falha está na própria JVM, atinge versões em uso em praticamente todo parque Java corporativo e já tem prova de execução remota sem autenticação em produtos de identidade e automação que costumam ficar no perímetro.

O que observar nos próximos dias: a publicação prometida das cadeias de exploração por produto, a chegada de PoCs públicos que disparem a falha sem vencer o ASLR, uma eventual inclusão no catálogo KEV da CISA e os primeiros relatos de uso real. Até lá, o trabalho é de inventário e aplicação de patch — sem pressa desnecessária, mas sem adiar para a próxima janela trimestral.

Fontes e referências

  • Calif — “Java4Shell” (divulgação original): calif.io
  • Oracle — “Critical Patch Update Advisory – November 2026”: oracle.com
  • BleepingComputer — “Critical Java4Shell flaw allows RCE attacks on major Java applications”: bleepingcomputer.com
  • VulnCheck — “Java4Shell CVE-2026-114938: Fine, I Guess We’ll Do This Again”: vulncheck.com
  • Censys — “Nov 17 Advisory: OpenJDK Remote Code Execution (Java4Shell) [CVE-2026-114938]”: censys.com
  • Registro CVE: cve.org/CVERecord?id=CVE-2026-114938
PLUGGED NINJA
Informações de privacidade

Este site usa cookies para que possamos oferecer a melhor experiência de usuário possível. As informações dos cookies são armazenadas em seu navegador e executam funções como reconhecê-lo quando você retorna ao nosso site e ajudar nossa equipe a entender quais seções do site você considera mais interessantes e úteis.