Voltar para o Blog

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:

  1. 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.
  2. Arquitetura: x86-64. ARM64 não é afetado, então Graviton na AWS, Ampere e Macs com Apple Silicon ficam de fora.
  3. 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"
fi

O 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"
done

Com 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"
done

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

  1. 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.
  2. Serviços que recebem Base64 de terceiros: APIs com autenticação Basic, provedores SAML, receptores de webhook.
  3. Serviços onde a Calif mostrou RCE após login: Kafka, Solr, Elasticsearch, Gerrit e Spinnaker.
  4. 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:-UseBASE64Intrinsics onde 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 UseBASE64Intrinsics como 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á

👉 Seguir @jeffbruchado no X

💡 Conteúdo diário sobre desenvolvimento, carreira e as ferramentas que eu realmente uso

Comentários (0)

Esse artigo ainda não possui comentários 😢. Seja o primeiro! 🚀🦅

Adicionar comentário