Programação Por Equipe DevBras

Capa do artigo: Seu Java está exposto ao Java4Shell? Teste a CPU e a versão

Seu Java está exposto ao Java4Shell? Teste a CPU e a versão

A CVE-2026-114938 atinge Java 17, 21, 25 e 27 em CPUs com AVX-512. Testei a CPU, a versão e o paliativo no Temurin e no Corretto; veja o que fazer.

O servidor onde eu preparo os posts deste blog roda num Intel Xeon. Antes de escrever qualquer linha sobre a Java4Shell, rodei nele o comando que os pesquisadores da Calif indicam para saber se a CPU entra no alcance da falha. Os quatro flags apareceram. Em seguida baixei o Java 17 mais recente da Eclipse Temurin e o da Amazon Corretto e conferi, na prática, o que a JVM faz por padrão nessa máquina e o que o paliativo muda.

Se você roda Jenkins, Keycloak, Jira, Confluence, Artifactory ou qualquer serviço em Java 17, 21, 25 ou 27 num servidor x86-64 recente, este texto mostra como checar a sua situação em poucos minutos e o que fazer até o pacote corrigido do seu fornecedor chegar.

O que saiu em 17 de novembro

A Oracle publicou o Critical Security Patch Update de novembro com 11 correções para o Java SE. Segundo o boletim, todas podem ser exploradas pela rede sem credenciais, e a maior nota CVSS 3.1 entre elas é 8.1. No mesmo dia, o OpenJDK Vulnerability Group publicou o aviso equivalente para o OpenJDK.

A falha que ganhou apelido é a CVE-2026-114938, a "Java4Shell". Pelo aviso do OpenJDK, ela fica no componente hotspot/compiler, tem CVSS 3.1 de 8.1 e afeta as linhas 17, 21, 25 e 27. O Java 8 e o 11 não entram nessa CVE.

A Calif, empresa que descobriu e reportou o problema, publicou os detalhes técnicos: é uma corrupção de memória no decodificador Base64 que a JVM acelera com instruções AVX-512 VBMI. Por isso o alcance depende de três coisas ao mesmo tempo:

  • Versão: OpenJDK 17.0.6 ou mais novo, e as linhas 21, 25 e 27.
  • Distribuição: qualquer uma derivada do OpenJDK. A Calif cita Corretto, Temurin, Microsoft Build of OpenJDK, Zulu, Liberica, SapMachine, Red Hat e Oracle.
  • Processador: só x86-64 com AVX-512 VBMI, como Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids e Granite Rapids, e AMD Zen 4 em diante. Máquinas ARM64 (Graviton, Ampere, Apple Silicon) não são afetadas.

A Calif demonstrou execução remota de código sem login, na configuração padrão, em Keycloak, Jira, Confluence, Artifactory, Jenkins e PingFederate. Com login, em Kafka, Solr, Elasticsearch, Gerrit e Spinnaker. O BleepingComputer acrescenta que a Calif conseguiu explorar a falha também em aplicações de exemplo feitas com Apache Struts e Spring Boot, e que não existe um exploit universal: o atacante precisa achar, em cada aplicação, um caminho para entregar o Base64 malicioso ao decodificador. A Calif também mostrou o ataque contra um cliente Java que abre conexão TLS com um servidor malicioso, o que coloca na lista até aplicações que só fazem chamadas para fora.

Segundo o BleepingComputer, existe prova de conceito pública apenas da corrupção de memória, sem exploit pronto para execução de código. Até a noite de 17/11 não havia relato de exploração ativa, e a CVE não estava no catálogo de falhas exploradas (KEV) da CISA.

As outras 10 falhas do pacote também são exploráveis pela rede sem login e atingem o Java 8 e o 11. O aviso do OpenJDK lista como afetadas, para o pacote inteiro, as versões 27.0.1.0.3, 25.0.5.0.3, 21.0.13.0.3, 17.0.21.0.3, 11.0.33, 8u512 e anteriores. Quem está no Java 8 ou 11 escapa da Java4Shell, mas não escapa da atualização.

Passo 1: a CPU entra no alcance?

No Linux, o comando da Calif filtra os flags do processador. Só há risco de Java4Shell se aparecerem os quatro: avx512f, avx512bw, avx512vbmi e bmi2. No meu servidor (kernel 6.12, Intel Xeon), a saída foi esta:

$ grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
bmi2
avx512f
avx512bw
avx512vbmi

Dois cuidados. Primeiro, em nuvem o mesmo tipo de instância pode cair em gerações diferentes de processador, então rode o comando em cada máquina, e não só numa. Segundo, um container enxerga os flags do host, então rodar o comando dentro do container ou no host dá o mesmo resultado.

Passo 2: a JVM está usando a parte vulnerável?

Este foi o teste que mais me ajudou a entender o problema. A JVM tem um flag chamado UseBASE64Intrinsics, que liga o atalho em código de máquina para o Base64. Baixei o Temurin 17.0.21+9 (o mais recente da Adoptium às 23h57 de 17/11, ainda sem a correção) e perguntei à JVM o valor final dos flags:

$ java -version
openjdk version "17.0.21" 2026-10-20
OpenJDK Runtime Environment Temurin-17.0.21+9 (build 17.0.21+9)

$ java -XX:+PrintFlagsFinal -version | grep -E "UseBASE64Intrinsics|UseAVX "
     intx UseAVX                 = 3       {ARCH product} {default}
     bool UseBASE64Intrinsics    = true    {product} {default}

Ou seja: numa CPU com AVX-512, a JVM liga sozinha o nível 3 de AVX e o atalho de Base64. Ninguém precisa ter configurado nada para estar exposto. O Corretto 17.0.21.1.2, que já traz a correção, mostra os mesmos dois valores: a correção não desliga o atalho, ela conserta o código dele. Por isso esse comando serve para saber se a parte afetada está em uso, não para saber se você já está corrigido. Para isso, o que vale é o número da versão.

Passo 3: a versão já é a corrigida?

Rode java -version em cada host e em cada imagem de container. Na Corretto corrigida, a saída fica assim:

$ java -version
openjdk version "17.0.21.1" 2026-11-17 LTS
OpenJDK Runtime Environment Corretto-17.0.21.1.2 (build 17.0.21.1+2-LTS)

Até a noite de 17/11, estes eram os builds com a correção:

  • Oracle JDK, pelas notas de release do JDK 17 e do JDK 21: 8u513, 11.0.33.1, 17.0.21.1 (17.0.21.1+4), 21.0.13.1 (21.0.13.1+4), 25.0.5.1 e 27.0.1.1.
  • Amazon Corretto: 17.0.21.1.2, 21.0.13.1.2 e 25.0.5.1.2. O changelog do Corretto 17 lista a CVE-2026-114938 com nota 8.1 no componente hotspot/compiler, assim como os do Corretto 21 e do Corretto 25.
  • Ainda sem pacote: Eclipse Temurin até a manhã de 18/11 (à tarde saíram os builds corrigidos 17.0.21.1+2 e 21.0.13.1+2), Debian (no security tracker, bookworm e trixie seguiam vulneráveis na manhã de 18/11; o sid, versão instável, já tinha os pacotes corrigidos) e Ubuntu (sem dado na página da CVE).

Para achar Java "escondido" (JDK embutido em appliance, agente de build, servidor de aplicação, imagem base), estes três comandos cobrem a maior parte dos casos:

java -version
sudo find / -type f -path "*/bin/java" 2>/dev/null
docker ps --format '{{.Names}}' | xargs -I{} sh -c 'echo "== {}"; docker exec {} java -version 2>&1 | head -1'

Lembre que atualizar o Java do host não atualiza o Java dentro da imagem. Para container, é trocar a tag da imagem base por uma que traga o build corrigido, fazer o build de novo e o redeploy. E todo processo Java precisa ser reiniciado depois da atualização: a JVM que já está no ar continua com o código antigo carregado.

Sem pacote ainda? O paliativo, testado

Atualização de 19/11: o Temurin já tem os builds corrigidos 17.0.21.1+2 e 21.0.13.1+2, então atualize. Quem está no Debian estável ou no Ubuntu e ainda não tem pacote corrigido pode usar o paliativo. A Calif recomenda, como medida temporária, subir a JVM com -XX:-UseBASE64Intrinsics ou com -XX:UseAVX=2. Nenhum fornecedor tinha endossado o paliativo até a noite de 17/11, então trate como ponte até a atualização, não como solução.

Testei as duas opções no Temurin 17.0.21+9 e no Corretto 17.0.21.1.2. O resultado foi o mesmo nos dois:

$ java -XX:-UseBASE64Intrinsics -XX:+PrintFlagsFinal -version | grep UseBASE64Intrinsics
     bool UseBASE64Intrinsics    = false   {product} {command line}

$ java -XX:UseAVX=2 -XX:+PrintFlagsFinal -version | grep -E "UseBASE64Intrinsics|UseAVX "
     intx UseAVX                 = 2       {ARCH product} {command line}
     bool UseBASE64Intrinsics    = false   {product} {default}

Três coisas que o teste mostrou e que não estão óbvias nos avisos:

  • O -XX:-UseBASE64Intrinsics é um flag de produto no Java 17. Ele funcionou sozinho, sem precisar de -XX:+UnlockDiagnosticVMOptions.
  • O -XX:UseAVX=2 também desligou o atalho de Base64 nesses dois builds, mas mexe em todo o uso de AVX da JVM, não só no Base64. Eu ficaria com a primeira opção, que é mais cirúrgica. E o UseAVX só existe na JVM para x86-64: numa máquina ARM a JVM recusa o flag e não sobe, então não ponha esse flag numa configuração compartilhada entre arquiteturas.
  • Dá para aplicar o flag a todas as JVMs de um host pela variável JAVA_TOOL_OPTIONS. A JVM avisa que pegou a variável, e o flag aparece com origem "environment":
$ JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics" java -XX:+PrintFlagsFinal -version | grep -E "Picked up|UseBASE64"
Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics
     bool UseBASE64Intrinsics    = false   {product} {environment}

Depois de reiniciar o serviço, confirme no processo que está rodando, e não só no arquivo de configuração. Com o jcmd, que vem no JDK (não no JRE), fica assim:

$ jcmd -l
2967829 Dorme
$ jcmd 2967829 VM.flags | tr ' ' '\n' | grep BASE64
-XX:-UseBASE64Intrinsics

E o custo de desempenho? Escrevi um programa pequeno que decodifica 1.000 vezes um bloco de 1,4 MB em Base64 com java.util.Base64 e rodei três vezes cada combinação, nos dois Java. Os tempos ficaram entre 838 e 1.073 ms em todas elas, com ou sem o paliativo, e a variação entre rodadas da mesma configuração foi maior que a diferença entre configurações. Num servidor compartilhado como o meu, isso quer dizer que não deu para medir perda nesse teste. Não é garantia para a sua aplicação: se ela decodifica muito Base64 (tokens, anexos, payloads), meça com a sua carga antes e depois.

O que eu priorizaria hoje

  1. Serviços expostos à internet primeiro: SSO (Keycloak, PingFederate), CI (Jenkins), wiki e tickets (Confluence, Jira) e repositório de artefatos. São justamente os alvos que a Calif demonstrou.
  2. Onde há pacote, atualizar e reiniciar. Oracle JDK e Corretto já tinham build corrigido em 17/11.
  3. Onde não há, aplicar o paliativo e restringir o acesso (VPN ou lista de IPs) até o fornecedor publicar.
  4. Não esquecer Java 8 e 11: eles não têm Java4Shell, mas têm as outras falhas do pacote.
  5. Conferir depois: java -version em cada host e container, varredura de imagens de novo e olho nos logs e crashes da JVM nas primeiras horas.

Antes de atualizar um servidor que importa, vale garantir um caminho de volta. Escrevi sobre isso em atualizar o sistema com backup. E se os seus serviços Java rodam em container como root, aproveite a janela de manutenção para revisar isso também: um RCE dentro de um container sem privilégios causa bem menos estrago, como explico em usuário não root no container.

Novembro está pesado para quem cuida de servidor. Na mesma semana houve as 7 falhas HIGH do Node.js e as 52 falhas do PostgreSQL. Se a sua stack tem os três, vale juntar tudo numa única janela de manutenção planejada, em vez de três correrias separadas.

Perguntas rápidas

Uso Java 11. Preciso fazer algo?

Precisa atualizar por causa das outras falhas do pacote de novembro, mas a Java4Shell não afeta a linha 11, segundo o aviso do OpenJDK.

Meus servidores são ARM (Graviton). Estou fora?

Da Java4Shell, sim: a Calif informa que ARM64 não é afetado. Das outras 10 falhas, não. Atualize do mesmo jeito.

O PrintFlagsFinal mostra UseBASE64Intrinsics = true. Estou vulnerável?

Mostra só que a parte afetada está em uso. No Corretto já corrigido o valor também é true. Quem diz se você está corrigido é a versão.

Posso deixar o paliativo para sempre?

Não é a ideia. Ele foi indicado pelos pesquisadores como medida temporária, sem endosso dos fornecedores até agora. Quando o pacote corrigido chegar, atualize e tire o flag.

Avalie este artigo