Java4Shell em 2026: Como Saber se Seu Servidor Java Está Vulnerável à CVE-2026-114938
Olá HaWkers, no dia 17/11/2026 a empresa de segurança Calif publicou o Java4Shell, registrado como CVE-2026-114938. É uma corrupção de memória dentro do decodificador Base64 do próprio OpenJDK, e a Calif mostrou execução remota de código sem login em configurações padrão de Keycloak, Jira, Confluence, Jenkins, JFrog Artifactory e PingFederate. A nota é 9.2 no CVSS 4.0 pela Calif e 8.1 no CVSS 3.1 pela Oracle.
O nome não é por acaso. Ele lembra o Log4Shell de 2021, quando uma biblioteca de log virou porta de entrada para meio mundo. A diferença é que desta vez o problema não está numa dependência que você escolheu: está no runtime, em java.util.Base64, uma classe que praticamente toda aplicação Java usa sem perceber. A pergunta que importa hoje é: o seu servidor está exposto? Neste artigo você vai entender o bug sem jargão desnecessário, aprender a checar em poucos minutos se uma máquina roda o caminho vulnerável e aplicar a mitigação certa enquanto o patch não chega em todo lugar.
O Que É o Java4Shell
O Java4Shell é uma escrita fora dos limites de memória (out-of-bounds write) no heap da JVM. Ela acontece num atalho de performance: quando o código que decodifica Base64 fica "quente", o compilador JIT C2 do HotSpot troca a implementação em Java por uma versão escrita direto em instruções da CPU, chamada de intrinsic. Em processadores x86-64 com a extensão AVX-512 VBMI, esse intrinsic usa instruções vetoriais que processam 64 bytes de uma vez.
O defeito está no cálculo de quantos bytes de saída cabem no buffer quando a entrada termina com o caractere de padding =. Em algumas combinações de padding, o tamanho calculado fica negativo, -1 ou -2. Um tamanho negativo vira uma máscara de escrita com todos os bits ligados, e a instrução vetorial grava 64 bytes inteiros, passando do fim do buffer.
O detalhe mais traiçoeiro: depois da escrita, o decodificador percebe que a entrada é inválida e lança IllegalArgumentException. Do ponto de vista da sua aplicação, parece que tudo deu certo, porque a entrada ruim foi rejeitada. Só que a memória ao lado já foi sobrescrita.
Por que isso vira execução remota de código
Sobrescrever memória do heap por si só não dá shell para ninguém. Segundo a Calif, o primeiro byte gravado é totalmente controlado pelo atacante, o segundo tem 4 bits controlados e o restante não é controlado. Com isso, eles combinaram técnicas de arrumação do heap (heap grooming) e medição de tempo para transformar a corrupção em leitura de memória, no estilo do Heartbleed, e depois em execução de código.
A própria Calif deixa claro que não existe exploit universal. Cada alvo exige uma cadeia própria: o atacante precisa achar um caminho na aplicação em que dados dele cheguem até Base64.getDecoder().decode(...). O problema é que esse caminho é comum demais. Tokens JWT, cabeçalhos Authorization: Basic, SAML, payloads de webhook e certificados em PEM passam por Base64 o tempo todo.
Quem Está Afetado (e Quem Não Está)
Três condições precisam ser verdadeiras ao mesmo tempo para uma máquina rodar o caminho vulnerável:
- Versão do Java: OpenJDK 17.0.6 ou mais novo, incluindo as linhas 21, 25 e 27. A Calif também lista o build Oracle 8u511b33-perf. A Red Hat, segundo relatos publicados no dia da divulgação, afirma que OpenJDK 8 e 11 não têm o caminho vulnerável.
- Arquitetura: x86-64. ARM64 não é afetado, então Graviton na AWS, Ampere e Macs com Apple Silicon ficam de fora.
- CPU com AVX-512 VBMI: Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids e Granite Rapids, e AMD EPYC e Ryzen a partir do Zen 4.
As distribuições derivadas do OpenJDK herdam o problema: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle Java SE e Oracle GraalVM for JDK.
Repare na terceira condição. Ela é o motivo pelo qual o mesmo container pode ser vulnerável numa instância e seguro em outra. Se o seu cluster mistura tipos de máquina, o resultado muda por nó, e não por imagem.
Passo 1: Checar se a CPU Roda o Caminho Vulnerável
A Calif e a Wiz publicaram a mesma checagem para Linux: o host só executa o intrinsic vulnerável se as quatro flags avx512f, avx512bw, avx512vbmi e bmi2 aparecerem em /proc/cpuinfo. O script abaixo faz essa conta e devolve uma resposta direta:
#!/usr/bin/env bash
# check-java4shell-cpu.sh
# Verifica se a CPU expõe as 4 flags que ativam o intrinsic vulnerável
set -euo pipefail
# Arquitetura diferente de x86-64 não executa o caminho vulnerável
if [ "$(uname -m)" != "x86_64" ]; then
echo "Arquitetura $(uname -m): fora do escopo do Java4Shell"
exit 0
fi
# Lê a linha de flags da primeira CPU
flags=$(grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n')
faltando=()
for f in avx512f avx512bw avx512vbmi bmi2; do
# grep -qx exige que a linha inteira seja igual à flag
if ! echo "$flags" | grep -qx "$f"; then
faltando+=("$f")
fi
done
if [ ${#faltando[@]} -eq 0 ]; then
echo "ATENÇÃO: CPU executa o caminho AVX-512 vulnerável"
exit 1
else
echo "CPU sem: ${faltando[*]} -> caminho vulnerável não é usado"
fiO exit 1 no caso vulnerável é proposital: dá para rodar o script num pipeline ou num agente de inventário e tratar o código de saída como alerta.
Dentro de um container, /proc/cpuinfo mostra a CPU do host, então o resultado vale para o nó onde o pod está rodando agora. Se o pod for reagendado em outro tipo de instância, a resposta pode mudar.
Passo 2: Descobrir Qual Java Está Rodando de Verdade
A versão que você acha que está rodando e a versão que está rodando costumam ser diferentes. Imagem base antiga, JRE embutido no instalador do Jira, Jenkins com Java próprio. Por isso vale perguntar diretamente para os processos vivos:
#!/usr/bin/env bash
# java-inventory.sh
# Lista todo processo Java em execução e a versão do runtime de cada um
for pid in $(pgrep -f java); do
# Caminho real do binário usado pelo processo
bin=$(readlink -f "/proc/$pid/exe" 2>/dev/null) || continue
# "java -version" escreve em stderr, por isso o 2>&1
versao=$("$bin" -version 2>&1 | head -n 1)
# Mostra a linha de comando resumida para identificar a aplicação
cmd=$(tr '\0' ' ' < "/proc/$pid/cmdline" | cut -c1-80)
echo "PID $pid | $versao | $cmd"
doneCom isso em mãos, cruze cada linha com as condições da seção anterior. Um Jenkins rodando em OpenJDK 21 num Xeon Sapphire Rapids é prioridade máxima. Um serviço em OpenJDK 11 num Graviton pode esperar.
Para quem roda Kubernetes, a mesma ideia funciona em escala com kubectl:
# Roda "java -version" em cada pod que tenha java no PATH
# e mostra junto o nó em que o pod está, para cruzar com o tipo de CPU
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{" "}{.metadata.name}{" "}{.spec.nodeName}{"\n"}{end}' |
while read -r ns pod node; do
v=$(kubectl exec -n "$ns" "$pod" -- java -version 2>&1 | head -n 1) || continue
echo "$ns/$pod | nó $node | $v"
doneEsse loop é lento em cluster grande, mas responde a pergunta certa em vez de confiar no que está escrito no Dockerfile.
Passo 3: Mitigar Agora com Uma Flag da JVM
Enquanto o patch não chega em todas as imagens, a Calif e a Wiz recomendam desligar o intrinsic vulnerável com uma flag de inicialização da JVM:
-XX:-UseBASE64Intrinsics: desliga só a versão acelerada do Base64. É a opção recomendada.-XX:UseAVX=2: desliga o AVX-512 inteiro na JVM. Só use em x86-64, porque segundo a Calif o OpenJDK para ARM não sobe com essa flag.
A primeira é cirúrgica. O Base64 volta a rodar no código Java comum, um pouco mais lento, e o resto da JVM continua usando as instruções vetoriais. A segunda é mais ampla e pode custar performance em outras rotinas que se beneficiam do AVX-512.
A BleepingComputer registrou que nem a Oracle nem o OpenJDK confirmaram oficialmente essa mitigação, então trate como medida temporária e teste antes de levar para produção.
O jeito mais simples de aplicar em todo processo Java de uma vez é a variável JAVA_TOOL_OPTIONS, que a JVM lê na inicialização:
# Dockerfile: mitigação temporária do Java4Shell
FROM eclipse-temurin:21-jre
# A JVM lê JAVA_TOOL_OPTIONS ao iniciar e aplica a flag
# sem precisar mexer no comando de start da aplicação
ENV JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"
COPY app.jar /app/app.jar
CMD ["java", "-jar", "/app/app.jar"]Ao subir, a JVM imprime Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics no stderr. Se essa linha não aparecer nos logs, a flag não foi aplicada.
Confirmando a flag de dentro da aplicação
Log de inicialização some, e variável de ambiente pode ser sobrescrita por um script de entrypoint. A forma mais confiável de saber se a mitigação está ativa é perguntar para a própria JVM em tempo de execução, usando o HotSpotDiagnosticMXBean:
import com.sun.management.HotSpotDiagnosticMXBean;
import java.lang.management.ManagementFactory;
// Expõe o estado da mitigação do Java4Shell, por exemplo num health check
public class Java4ShellCheck {
public static boolean intrinsicLigado() {
HotSpotDiagnosticMXBean hs =
ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
// "true" significa que o Base64 acelerado (caminho vulnerável) está ativo
return Boolean.parseBoolean(
hs.getVMOption("UseBASE64Intrinsics").getValue());
}
public static void main(String[] args) {
String arch = System.getProperty("os.arch");
String versao = Runtime.version().toString();
System.out.printf("Java %s em %s%n", versao, arch);
System.out.printf("UseBASE64Intrinsics = %s%n", intrinsicLigado());
if (intrinsicLigado() && arch.contains("64") && !arch.contains("aarch")) {
System.out.println("Atualize o JDK ou aplique -XX:-UseBASE64Intrinsics");
}
}
}Colocar esse valor num endpoint de health check ou numa métrica deixa a mitigação visível no seu painel. Se alguém trocar a imagem base e esquecer a flag, você descobre pelo alerta e não pelo incidente.
Passo 4: Atualizar o JDK (a Correção de Verdade)
A flag compra tempo. A correção é atualizar. A Oracle publicou a correção da CVE-2026-114938 em 17/11/2026, dentro do Critical Patch Update de novembro, que reúne 655 vulnerabilidades no total. O OpenJDK também publicou o seu aviso de segurança no mesmo dia.
Como cada distribuição empacota a correção no próprio ritmo, não confie num número de versão copiado de um post, inclusive deste. Confira a nota de segurança do seu fornecedor (Temurin, Corretto, Zulu, Red Hat, Oracle) e procure explicitamente pelo identificador CVE-2026-114938 antes de marcar o item como resolvido.
Uma ordem prática de prioridade:
- Sistemas expostos na internet que a Calif já explorou sem autenticação: Keycloak, Jira, Confluence, Jenkins, Artifactory e PingFederate. Se algum deles está aberto para fora, atualize hoje ou tire do ar.
- Serviços que recebem Base64 de terceiros: APIs com autenticação Basic, provedores SAML, receptores de webhook.
- Serviços onde a Calif mostrou RCE após login: Kafka, Solr, Elasticsearch, Gerrit e Spinnaker.
- Clientes Java que abrem conexão TLS com servidores externos. A Calif cita esse cenário: um programa Java que se conecta a um servidor malicioso também pode ser comprometido.
Enquanto isso, restringir o acesso externo a portais de administração reduz a superfície. WAF ajuda a barrar parte das tentativas, mas a Wiz lembra que ele não cobre todos os caminhos. A Calif acrescenta que até o buffer de requisição em proxies como o nginx não para a cadeia que eles montaram contra o Elasticsearch, e que frames de WebSocket passam por fora desse buffer.
A IA Encontrou o Bug em Uma Hora
Tem um dado nessa história que vai além do Java. Segundo a BleepingComputer, o pesquisador Quang Luong encontrou a falha usando o Codex, da OpenAI, durante uma auditoria do código interno do OpenJDK. Foi cerca de uma hora para achar o bug e mais duas para ter um exploit funcionando, com custo total de IA abaixo de 200 dólares. A Wiz, por sua vez, diz que montou uma prova de conceito própria em 2 horas depois da divulgação.
Isso muda a conta de quem cuida de segurança. Durante anos, o tempo entre a divulgação de uma falha e o primeiro exploit funcional dava alguns dias de folga para aplicar patch. Quando pesquisador e atacante têm acesso às mesmas ferramentas e conseguem reproduzir um exploit em horas, essa folga encolhe. A Calif não liberou os exploits completos contra as aplicações corporativas justamente para dar tempo de atualização, mas ninguém deveria contar com isso como proteção.
Se você acompanhou o React2Shell, a falha crítica nos React Server Components, vai reconhecer o padrão: um componente que todo mundo usa, um caminho de entrada que ninguém olhava e um apelido que pega rápido porque o impacto é amplo.
Java4Shell vs Log4Shell: O Que Muda
A comparação é inevitável, então vale ser preciso:
| Ponto | Log4Shell (2021) | Java4Shell (2026) |
|---|---|---|
| Onde está | Biblioteca Log4j | Runtime do OpenJDK |
| Tipo de falha | Lookup JNDI em string de log | Escrita fora dos limites no heap |
| Depende da CPU | Não | Sim, x86-64 com AVX-512 VBMI |
| Exploit genérico | Sim, uma string servia para quase tudo | Não, cada alvo exige cadeia própria |
| Correção | Atualizar a dependência | Atualizar o JDK ou desligar o intrinsic |
Na prática, o Java4Shell é mais difícil de explorar em massa do que o Log4Shell, porque não existe uma string mágica que funcione em qualquer aplicação. Por outro lado, ele é mais difícil de enxergar: não aparece no pom.xml, não aparece num scanner de dependências e varia conforme o hardware. Ferramentas de SCA que olham só para bibliotecas não vão te avisar.
O Que Fazer Esta Semana
Resumindo em uma lista curta que cabe num ticket:
- Rodar a checagem de CPU em todos os nós x86-64.
- Inventariar os processos Java vivos e as versões reais do runtime.
- Aplicar
-XX:-UseBASE64Intrinsicsonde CPU e versão batem, com teste antes. - Atualizar o JDK pelas notas do fornecedor, começando por Keycloak, Jira, Confluence, Jenkins, Artifactory e PingFederate.
- Expor o valor de
UseBASE64Intrinsicscomo métrica para não perder a mitigação numa troca de imagem.
Se você quer revisar o resto da superfície da sua aplicação aproveitando o embalo, o guia do OWASP Top 10 2025 é um bom ponto de partida.
Perspectivas
O Java4Shell mostra um tipo de risco que vai ficar mais comum: otimizações de baixo nível dentro do runtime, escritas para extrair cada ciclo da CPU, viram superfície de ataque quando um caso de borda escapa dos testes. E com a IA reduzindo o tempo de pesquisa de dias para horas, falhas assim vão aparecer mais rápido, tanto para quem defende quanto para quem ataca.
A boa notícia é que a defesa aqui é concreta e barata: saber qual Java roda em qual hardware, ter uma flag de mitigação pronta e um processo de atualização de JDK que não dependa de alguém lembrar. Quem já tem esse inventário vai resolver o Java4Shell numa tarde.
Bora pra cima! 🦅
📚 Quer Acompanhar o Que Vem Por Aí?
Este artigo cobriu o Java4Shell e como proteger servidores Java contra a CVE-2026-114938, mas o ecossistema muda toda semana e nem tudo vira artigo aqui.
No X eu compartilho o que estou testando, os bastidores dos projetos e as novidades que aparecem antes de virarem post.
Me Segue Lá
💡 Conteúdo diário sobre desenvolvimento, carreira e as ferramentas que eu realmente uso

