
Vulnerabilidade Java4Shell (CVE-2026-114938) Permite RCE Pré-Autenticação em Aplicações Chave
Uma falha crítica, batizada de Java4Shell (CVE-2026-114938), permite a execução remota de código sem autenticação em diversas aplicações Java populares, como Jira e Jenkins, em servidores com processadores AVX-512 VBMI.
Uma falha crítica no Java, batizada de Java4Shell e rastreada como CVE-2026-114938, permite que atacantes sem autenticação executem código arbitrário em aplicações amplamente utilizadas como Jira, Jenkins e Keycloak. A vulnerabilidade, divulgada esta semana pela empresa de pesquisa em segurança Calif, afeta versões do Java 17.0.6 e posteriores, mas apenas em processadores x86-64 Intel e AMD que suportam o recurso AVX-512 VBMI.
A Oracle e o projeto OpenJDK lançaram correções para a falha, que reside em uma versão otimizada do decodificador Base64 do Java. Embora pesquisadores da Calif afirmem ter alcançado a execução remota de código (RCE) em seis aplicações, outros laboratórios conseguiram reproduzir apenas falhas e vazamentos de memória. O Centro Canadense de Cibersegurança declarou não ter conhecimento de ataques explorando ativamente a falha até o momento.
O Mecanismo da Falha
A vulnerabilidade Java4Shell explora a forma como servidores frequentemente decodificam dados codificados em Base64, como cabeçalhos de login HTTP Basic, artefatos SAML e tokens CSRF, antes mesmo de verificar a autenticação do usuário. Isso permite que um atacante não autenticado manipule o processo.
A falha está especificamente em uma versão mais rápida do decodificador Base64 do Java, que é ativada em chips com AVX-512 VBMI. O Java alterna para este decodificador de alta performance quando o código é executado frequentemente. Uma string malformada que termina com um caractere '=' extra faz com que este decodificador escreva 62 ou 63 bytes além do final de sua saída. Embora o Java rejeite a string, a escrita indevida já ocorre.
Os bytes escritos além do limite são fixos, o que significa que um atacante controla apenas o local onde esses bytes são gravados na memória. Inicialmente, isso sugeria apenas falhas no sistema, mas os pesquisadores da Calif desenvolveram uma técnica chamada "JavaBleed". Eles manipulam o layout da memória do servidor para que o estouro expanda um array vizinho, permitindo então a escrita de bytes arbitrários e a leitura de volta da memória. A partir daí, a equipe afirma que o ataque pode atingir as partes do Java responsáveis pela execução de código.
Impacto e Exploração
A Calif reporta que os ataques funcionam sem necessidade de login nas configurações padrão de Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins e PingFederate. Com autenticação, a falha pode ser explorada em Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit e Spinnaker. É importante notar que não existe um único exploit universal; cada alvo requer um layout de memória e tempo específicos, e alguns ataques são sensíveis a atrasos de rede.
Empresas de segurança como Upwind e Blackpoint Cyber reproduziram a corrupção de memória e falhas em ambientes de laboratório. A Upwind observou danos a objetos adjacentes na memória e falhas no Java em um servidor AWS com chip Intel Ice Lake. A Blackpoint Cyber conseguiu causar a falha em uma aplicação Spring Boot de teste enviando cerca de 28.300 requisições de login malformadas em 20 segundos, e também usou a etapa JavaBleed para ler um segredo armazenado próximo ao estouro em testes locais, embora não tenha reproduzido a execução remota de código.
As pontuações CVSS para a CVE-2026-114938 variam: a Calif a classifica em 9.2 (CVSS 4.0), a Oracle em 8.1 (CVSS 3.1), a Red Hat preliminarmente em 9.8 e a Amazon em 8.8. A descrição da Oracle em seu registro CVE indica que "ataques bem-sucedidos desta vulnerabilidade podem resultar na tomada do Oracle Java SE".
Versões Afetadas e Correções
O código vulnerável está presente no Java 17.0.6 e versões posteriores da linha Java 17, bem como no Java 21, 25 e 27. As versões padrão Java 8 e Java 11 não são afetadas, mas o Java SE 8 Performance Pack build 8u511b33-perf está vulnerável. GraalVM para JDK 17.0.21.0.3, GraalVM para JDK 21.0.13.0.3 e GraalVM Enterprise Edition 21.3.20.0.3 também são afetados.
A vulnerabilidade só é explorável em chips x86-64 que suportam AVX-512 VBMI, incluindo Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids e chips AMD Zen 4 ou mais recentes. Chips ARM64 não são afetados. Isso significa que a mesma imagem de contêiner pode ser vulnerável em um servidor e não em outro, dependendo do hardware subjacente.
Para verificar se um servidor Linux possui os recursos de CPU necessários, o comando a seguir pode ser usado:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
Todas as quatro flags devem aparecer na saída para que o servidor seja potencialmente vulnerável.
As correções foram lançadas pelo projeto OpenJDK e pela Oracle. A Amazon já corrigiu suas compilações Corretto Java, e a Azul também atualizou suas versões Zulu. No entanto, a Red Hat ainda está preparando correções para suas compilações OpenJDK e Red Hat Enterprise Linux. SAP, Eclipse Temurin, Microsoft Build of OpenJDK e BellSoft Liberica não haviam listado compilações corrigidas até a verificação da notícia original.
| Compilação Java | Versões Afetadas | Versão Corrigida |
|---|---|---|
| Oracle Java SE 17 | 17.0.6 a 17.0.21.0.3 | 17.0.21.1 |
| Oracle Java SE 21 | 21.0.13.0.3 e anteriores | 21.0.13.1 |
| Oracle Java SE 25 | 25.0.5.0.3 e anteriores | 25.0.5.1 |
| Oracle Java SE 27 | 27.0.1.0.3 e anteriores | 27.0.1.1 |
| Amazon Corretto 17, 21, 25 e 27 | Compilações anteriores, de 17.0.6 em diante para Corretto 17 | 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 e 27.0.1.1.4 |
| Azul Zulu 17, 21, 25 e 27 | Compilações anteriores, de 17.0.6 em diante para Zulu 17 | 17.70.201, 21.54.201, 25.38.201 e 27.30.201 (compilações gratuitas) |
| Red Hat Enterprise Linux 8, 9 e 10, e Red Hat build of OpenJDK 17, 21 e 25 | 17.0.6 e posteriores, incluindo 21 e 25 | Nenhuma ainda |
Produtos que empacotam seu próprio tempo de execução Java exigem uma atualização do fabricante do produto. Após a atualização, é crucial reiniciar os serviços Java e reconstruir e reimplantar imagens de contêiner para garantir que o processo em execução utilize a nova compilação.
Medidas de Mitigação e Detecção
Para sistemas que não podem ser atualizados imediatamente, é possível iniciar a JVM com uma das seguintes flags, que devem ser removidas após a instalação da versão corrigida:
-XX:-UseBASE64Intrinsics: Desativa apenas o código Base64 mais rápido, removendo o caminho vulnerável e mantendo outras otimizações AVX-512.-XX:UseAVX=2: Desativa completamente o AVX-512. Esta flag deve ser usada apenas em servidores x86-64, pois o Java em ARM64 não a reconhece e falhará ao iniciar.
Testes de laboratório da Upwind confirmaram que ambas as flags impediram o estouro em todas as versões afetadas testadas.
Para identificar tentativas de exploração, a Upwind sugere verificar os seguintes sinais, com a ressalva de que nenhum deles prova um comprometimento e sua ausência não garante a segurança do servidor:
- Tokens Base64 de 32 caracteres ou mais que terminam em '=' e cujo comprimento não é múltiplo de 4, especialmente em cabeçalhos de Autorização.
- Surtos de erros
IllegalArgumentExceptiondejava.util.Base64$Decoder. - Logs de falha
hs_err_pidinexplicáveis ou surtos de reinicializações.
Curiosamente, uma entrada malformada que desencadeia o estouro foi postada publicamente em 9 de setembro, em uma proposta de correção submetida ao repositório de código do OpenJDK como um pull request. A proposta descrevia um estouro no mesmo código do decodificador Base64 AVX-512. Seu autor a fechou sem mesclá-la no início de novembro, após um aviso automatizado de inatividade.
Análise Técnica CyberX
A vulnerabilidade Java4Shell (CVE-2026-114938) representa um risco significativo devido à sua capacidade de permitir a execução remota de código (RCE) sem autenticação prévia em um conjunto específico de condições. A análise técnica revela que a exploração não é trivial e depende de uma combinação de fatores de software e hardware.
Mecanismo de Exploração e Dependência de Hardware
O cerne da falha reside na implementação otimizada do decodificador Base64 do Java, que é ativada exclusivamente em processadores x86-64 com suporte à extensão AVX-512 VBMI. Essa dependência de hardware é crucial, pois servidores sem essa capacidade de CPU não são suscetíveis à vulnerabilidade, mesmo que executem as versões de Java afetadas. A exploração ocorre quando uma string Base64 malformada, terminando com um caractere '=', é processada por esse decodificador otimizado, resultando em um estouro de buffer de 62 ou 63 bytes além do limite alocado.
Embora os bytes escritos sejam fixos, a técnica "JavaBleed" desenvolvida pelos pesquisadores da Calif demonstra como esse estouro pode ser encadeado para manipular o layout da memória do processo Java. Ao expandir um array vizinho na memória, os atacantes podem então escrever bytes arbitrários e ler da memória, pavimentando o caminho para a execução de código. Este processo exige um conhecimento aprofundado da alocação de memória da JVM e do aplicativo alvo, tornando a exploração mais complexa e específica para cada ambiente.
Superfície de Ataque e Condições
A superfície de ataque é ampla, abrangendo aplicações que decodificam dados Base64 antes da autenticação, como cabeçalhos HTTP Basic, tokens SAML ou CSRF. A capacidade de um proxy como o Nginx de bloquear algumas, mas não todas as tentativas, sugere que a exploração pode ser sensível a atrasos de rede e ao comportamento de processamento de requisições. A ausência de um exploit universal e a necessidade de adaptar o ataque para cada alvo indicam que a exploração em larga escala pode ser mais desafiadora do que vulnerabilidades mais genéricas.
Recomendações CyberX
- Priorização de Patching: A medida mais eficaz é a aplicação imediata das atualizações de segurança fornecidas pela Oracle, OpenJDK e distribuidores de Java (Amazon Corretto, Azul Zulu). Para produtos que empacotam seu próprio Java, aguardar e aplicar as atualizações dos respectivos fabricantes.
- Uso de Flags de Mitigação: Para sistemas onde o patching imediato não é possível, a aplicação das flags JVM
-XX:-UseBASE64Intrinsicsou-XX:UseAVX=2é uma mitigação temporária validada. A primeira é preferível por desativar apenas o componente vulnerável, mantendo outras otimizações AVX-512. A segunda desativa todo o AVX-512 e não deve ser usada em ARM64. - Verificação de Hardware: Identificar proativamente servidores que utilizam processadores com AVX-512 VBMI é crucial para determinar a real exposição. O comando
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'em Linux pode auxiliar nesta identificação. - Monitoramento Aprimorado: Implementar monitoramento para os sinais de detecção sugeridos, como erros
IllegalArgumentExceptiondo decodificador Base64 e logs de falhahs_err_pid, pode ajudar a identificar tentativas de exploração. - Reconstrução de Imagens de Contêiner: Após a aplicação de patches, é imperativo reconstruir e reimplantar todas as imagens de contêiner que utilizam as versões de Java afetadas para garantir que os novos binários sejam carregados.
A complexidade da exploração e a dependência de hardware podem limitar o número de ataques bem-sucedidos em ambientes reais, mas a natureza pré-autenticação e o impacto de RCE justificam uma resposta rápida e priorizada.
CyberX SOC Intelligence Bulletin
A vulnerabilidade Java4Shell (CVE-2026-114938) permite a execução remota de código (RCE) sem autenticação em sistemas Java específicos. A ameaça é crítica para ambientes que executam versões vulneráveis do Java em hardware compatível com AVX-512 VBMI, expondo aplicações como Jira, Jenkins e Keycloak a comprometimento total.
Ativos e Condições de Exposição
- Versões Java Afetadas: Java 17.0.6+, Java 21, 25, 27. Também Java SE 8 Performance Pack build 8u511b33-perf e certas versões de GraalVM.
- Hardware Requerido: Processadores x86-64 Intel (Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids) ou AMD (Zen 4 ou mais recentes) que suportam AVX-512 VBMI. Chips ARM64 não são afetados.
- Aplicações de Alto Risco: Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, PingFederate (RCE pré-autenticação). Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, Spinnaker (RCE com autenticação).
- Verificação de CPU (Linux): Executar
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'. A presença de todas as quatro flags indica potencial vulnerabilidade de hardware.
Sinais de Investigação e Detecção
- Logs de Aplicação/Web Server: Procurar por requisições HTTP contendo tokens Base64 de 32 caracteres ou mais, que terminam em '=' e cujo comprimento não é múltiplo de 4, especialmente em cabeçalhos de Autorização.
- Logs da JVM: Monitorar por surtos de erros
IllegalArgumentExceptionoriginados dejava.util.Base64$Decoder. - Logs de Sistema/Crash: Investigar logs de falha
hs_err_pidinexplicáveis ou padrões de reinicializações inesperadas de serviços Java. - Monitoramento de Rede: Análise de tráfego para padrões incomuns de requisições Base64 malformadas para endpoints sensíveis.
MITRE ATT&CK
- TA0001 - Initial Access:
- T1190 - Exploit Public-Facing Application: A exploração da Java4Shell permite que um atacante não autenticado obtenha acesso inicial a sistemas vulneráveis através de aplicações expostas à internet.
- TA0002 - Execution:
- T1059 - Command and Scripting Interpreter: Após a exploração bem-sucedida, o atacante pode executar código arbitrário no contexto da aplicação Java comprometida.
Correções e Mitigação
- Patching Urgente: Atualizar todas as instalações Java afetadas para as versões corrigidas (ex: Oracle Java SE 17.0.21.1, Amazon Corretto 17.0.21.1.2, Azul Zulu 17.70.201).
- Flags da JVM: Como medida temporária, aplicar
-XX:-UseBASE64Intrinsicsou-XX:UseAVX=2(apenas em x86-64) ao iniciar a JVM. - Reconstrução de Contêineres: Reconstruir e reimplantar imagens de contêiner após a aplicação de patches para garantir que as novas compilações Java sejam utilizadas.
- WAF/IPS: Configurar Web Application Firewalls (WAF) ou Intrusion Prevention Systems (IPS) para detectar e bloquear requisições HTTP com padrões de Base64 malformados que possam indicar tentativas de exploração.
Resposta e Preservação de Evidências
- Contenção: Isolar sistemas comprometidos ou potencialmente vulneráveis. Aplicar patches ou mitigações imediatamente.
- Erradicação: Remover quaisquer artefatos maliciosos ou backdoors instalados após a exploração.
- Recuperação: Restaurar sistemas a um estado seguro a partir de backups confiáveis, garantindo que as vulnerabilidades tenham sido corrigidas.
- Análise Forense: Em caso de comprometimento, coletar logs de aplicação, sistema, rede e despejos de memória para análise forense, buscando identificar a extensão do ataque e os dados acessados.
Indicadores de Comprometimento (IoCs)
Não foram identificados indicadores de comprometimento verificáveis (hashes, IPs, domínios maliciosos) nas fontes consultadas para esta vulnerabilidade específica. A detecção deve focar nos sinais de investigação e telemetria descritos acima.
Perguntas frequentes
O que é a vulnerabilidade Java4Shell (CVE-2026-114938)?
É uma falha crítica no Java que permite a execução remota de código (RCE) sem autenticação prévia em aplicações amplamente utilizadas como Jira, Jenkins e Keycloak. A vulnerabilidade foi divulgada pela empresa de pesquisa em segurança Calif.
Quais versões do Java e processadores são afetados pela Java4Shell?
A vulnerabilidade afeta o Java 17.0.6 e versões posteriores da linha Java 17, bem como o Java 21, 25 e 27. Ela só é explorável em processadores x86-64 Intel e AMD que suportam AVX-512 VBMI, como Intel Xeon Ice Lake e chips AMD Zen 4 ou mais recentes.
Como posso mitigar a Java4Shell se não puder atualizar imediatamente?
Para sistemas que não podem ser atualizados de imediato, é possível iniciar a JVM com uma das seguintes flags: `-XX:-UseAVX512ByteBase64` ou `-XX:-UseAVX512VBMIForBase64`. Testes de laboratório confirmaram que ambas as flags impedem o estouro em todas as versões afetadas testadas.
Quais aplicações são vulneráveis à Java4Shell sem autenticação?
A Calif reporta que os ataques funcionam sem necessidade de login nas configurações padrão de Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins e PingFederate.
Como saber se um servidor é suscetível à Java4Shell?
Um servidor é potencialmente vulnerável se executar versões afetadas do Java em um processador x86-64 com suporte a AVX-512 VBMI. Para servidores Linux, é necessário verificar a presença das flags `avx512f`, `avx512dq`, `avx512bw` e `avx512vbmi` na saída de um comando de CPU.


