CloudSec

Na terça-feira, 17 de novembro de 2026, a empresa de pesquisa Calif divulgou a Java4Shell (CVE-2026-114938), uma falha de corrupção de memória no decodificador Base64 do OpenJDK. O nome lembra a Log4Shell de 2021 — e não por acaso: a vulnerabilidade está na base de praticamente todo ecossistema Java e, segundo os pesquisadores, permite execução remota de código sem autenticação em aplicações muito usadas, incluindo o Keycloak.

A boa notícia é que o problema só se manifesta em uma combinação específica de hardware e software, e existe uma mitigação simples que pode ser aplicada hoje, sem esperar por novas imagens. Neste artigo explicamos o que aconteceu, como descobrir se o seu ambiente está exposto e o que fazer agora.

Resumo rápido

  • O que é: escrita fora dos limites do heap no decodificador Base64 acelerado por hardware (AVX-512) da JVM HotSpot.
  • Gravidade: 9.2 (Crítica) em CVSS 4.0 segundo a Calif; 8.1 em CVSS 3.1 segundo a Oracle, que considera a exploração de alta complexidade.
  • Quem é afetado: OpenJDK 17.0.6 ou superior (incluindo 21, 25 e 27) rodando em processadores x86-64 com a extensão AVX-512 VBMI (Intel Xeon Ice Lake em diante, AMD Zen 4 em diante).
  • Quem não é afetado: Java 8 e 11, OpenJDK 17.0.0 a 17.0.5, CPUs ARM64 (AWS Graviton, Apple Silicon) e CPUs x86 sem AVX-512 VBMI.
  • Correção: Oracle e o projeto OpenJDK publicaram correções em 17/11; as demais distribuições (Temurin, Corretto, Zulu, Red Hat etc.) estão liberando builds corrigidos.
  • Mitigação imediata: iniciar a JVM com -XX:-UseBASE64Intrinsics.
  • Exploração ativa: até a data desta publicação, não há relatos de exploração em larga escala e a falha não consta no catálogo KEV da CISA.

O que é a Java4Shell

Para decodificar Base64 mais rápido, o OpenJDK usa uma rotina escrita diretamente em instruções AVX-512 do processador, que o compilador C2 passa a usar quando o método Base64.Decoder fica “quente” (é chamado com frequência). O defeito está no tratamento do final da entrada: quando o texto termina em um fragmento curto com padding (= ou ==), o cálculo do tamanho da saída resulta em um número negativo. A máscara de escrita passa então a cobrir um bloco inteiro de 64 bytes, e a JVM grava 62 ou 63 bytes além do fim do array de destino.

O detalhe mais traiçoeiro: o Java até rejeita a entrada inválida com IllegalArgumentException — mas só depois que a escrita indevida já aconteceu e os objetos vizinhos no heap já foram corrompidos.

Na prática, isso tem duas consequências:

  1. Negação de serviço é fácil. Uma única mensagem malformada costuma derrubar a JVM (normalmente com SIGSEGV durante a coleta de lixo), e requisições repetidas mantêm o serviço fora do ar.
  2. Execução remota de código é possível, mas trabalhosa. A Calif afirma ter construído cadeias de exploração específicas para cada produto, combinando corrupção de tamanhos de array, vazamento de memória do heap (no estilo Heartbleed) e preparação do heap. Não existe um exploit universal, e os pesquisadores estão retendo as cadeias específicas para dar tempo de atualização.

O tamanho mínimo da entrada maliciosa também varia: cerca de 129 caracteres no Java 17 e 65 caracteres no Java 21 em diante.

Por que o Keycloak está na lista

Base64 está em toda parte no fluxo de autenticação: cabeçalhos Authorization: Basic, tokens JWT e asserções SAML são decodificados antes de o usuário estar autenticado. Por isso, qualquer endpoint público do Keycloak pode receber a carga maliciosa.

A Calif relata ter demonstrado RCE pré-autenticação em instalações padrão de Keycloak, Atlassian Jira, Confluence, JFrog Artifactory, Jenkins e PingFederate, além de RCE pós-autenticação em Kafka, Solr, Elasticsearch, Gerrit e Spinnaker. Essas demonstrações ainda não foram reproduzidas publicamente por terceiros, mas o comunicado oficial do Keycloak trata o risco como real e recomenda ação imediata.

Ponto de atenção: segundo o próprio projeto, as imagens de container Keycloak 26.8.2-1 e 26.8.2-2 (x86-64) trazem um build afetado do OpenJDK 21.0.13, e a imagem do Keycloak Operator 26.8.2 usa OpenJDK 25. A versão do Keycloak, sozinha, não diz se você está vulnerável — o que importa é o JDK que roda o processo e a CPU onde ele roda.

Seu ambiente está vulnerável?

Uma instância só está em risco quando as três condições abaixo são verdadeiras:

CondiçãoAfetadoNão afetado
Versão do JavaOpenJDK 17.0.6+, 21, 25, 27 sem correçãoJava 8, Java 11, OpenJDK 17.0.0–17.0.5
Processadorx86-64 com AVX-512 VBMI (Intel Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids; AMD Zen 4+)ARM64 (Graviton, Apple Silicon); Intel Skylake-SP/Cascade Lake; AMD anterior ao Zen 4
Flags da JVMIntrínsecos Base64 habilitados (padrão)JVM com -XX:-UseBASE64Intrinsics ou -XX:UseAVX=2

Para quem roda na nuvem: o que vale é a CPU que a VM expõe. Na AWS, por exemplo, instâncias Graviton estão fora do escopo, enquanto famílias baseadas em Intel de geração recente e em AMD EPYC Zen 4 podem estar dentro. Não presuma — verifique cada nó com os comandos abaixo, inclusive nós de failover e os usados em rolling updates.

1. Verifique a CPU

No host, na VM ou, em Kubernetes, no nó onde o pod do Keycloak roda:

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

A máquina só é potencialmente vulnerável se as quatro flags aparecerem. Sem avx512vbmi, o caminho de código defeituoso nunca é usado.

2. Verifique o Java que realmente executa o Keycloak

Um serviço systemd pode usar um JDK diferente do que aparece no seu shell. Cheque o binário do próprio processo:

java -version
docker exec <container-keycloak> java -version
kubectl exec <pod-keycloak> -c keycloak -- java -version

3. Verifique as flags da JVM em execução

jcmd -l                                   # descobre o PID
jcmd <pid> VM.flags -all | grep -F UseBASE64Intrinsics

Se o resultado for UseBASE64Intrinsics = true em um host com AVX-512 VBMI e um JDK afetado, a instância está exposta.

Mitigação imediata

A mitigação recomendada pela Red Hat e pelo projeto Keycloak é desligar o caminho acelerado de Base64 com a flag -XX:-UseBASE64Intrinsics. Ela mantém as demais otimizações AVX-512 e, nos testes do projeto, não afetou emissão de tokens OAuth2/OIDC, validação de JWT nem operações de realm. Sempre acrescente a flag ao valor existente de JAVA_OPTS_APPEND em vez de substituí-lo, e reinicie todas as instâncias.

Instalação ZIP/TAR.GZ

export JAVA_OPTS_APPEND="${JAVA_OPTS_APPEND:+$JAVA_OPTS_APPEND }-XX:-UseBASE64Intrinsics"
./bin/kc.sh start

systemd: defina JAVA_OPTS_APPEND no Environment= da unit (ou em um drop-in), rode systemctl daemon-reload e reinicie o serviço. Exportar a variável no shell não afeta um serviço já em execução.

Docker / Podman

docker run ... -e JAVA_OPTS_APPEND=-XX:-UseBASE64Intrinsics quay.io/keycloak/keycloak:<tag> start

Docker Compose

services:
  keycloak:
    environment:
      JAVA_OPTS_APPEND: "-XX:-UseBASE64Intrinsics"

Keycloak Operator (pods do Keycloak): adicione a variável no recurso Keycloak, via spec.env ou em spec.unsupported.podTemplate.spec.containers para o contêiner keycloak, mesclando com a configuração existente. Garanta que todos os pods sejam recriados.

O próprio Operator: ele não lê JAVA_OPTS_APPEND; use JDK_JAVA_OPTIONS:

kubectl -n <namespace-operator> set env deployment/keycloak-operator \
  JDK_JAVA_OPTIONS=-XX:-UseBASE64Intrinsics

Com OLM, configure em spec.config.env da Subscription. Configurar o Operator não protege os pods que ele gerencia — aplique as duas mudanças.

Alternativas: -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_base64_decodeBlock desliga apenas o intrínseco de decodificação (escopo mais estreito). Já -XX:UseAVX=2 desliga todo o AVX-512 e pode impactar desempenho; além disso, só deve ser usada em hosts x86-64, pois o OpenJDK para ARM não reconhece a flag e não inicia.

Depois de aplicar, confirme na JVM em execução (não apenas na variável de ambiente). O esperado é UseBASE64Intrinsics = false:

kubectl exec <pod-keycloak> -c keycloak -- \
  jcmd io.quarkus.bootstrap.runner.QuarkusEntryPoint VM.flags -all | grep -F UseBASE64Intrinsics

Repita a verificação após cada restart ou rollout.

Correção definitiva

A mitigação é temporária. O caminho definitivo é rodar um JDK cujo fornecedor confirme a correção da CVE-2026-114938:

  • Oracle e OpenJDK liberaram correções em 17/11/2026, no Critical Security Patch Update de novembro.
  • Eclipse Temurin, Amazon Corretto, Azul Zulu, Red Hat build of OpenJDK, Microsoft, BellSoft Liberica e SAP SapMachine estão publicando builds corrigidos — consulte o boletim de cada fornecedor. Não deduza o status pela numeração de versão da Oracle: builds LTS de outros fornecedores com número parecido podem ainda conter o código vulnerável.
  • Keycloak: até o momento não há imagem corrigida recomendada. O projeto vai publicar novas imagens do Keycloak e do Operator assim que os builds corrigidos do OpenJDK estiverem disponíveis. Imagens customizadas precisam ser reconstruídas sobre uma base corrigida.

Mantenha a mitigação até que o runtime corrigido esteja implantado e verificado em todos os nós. Lembre também que aplicações que embarcam o próprio JDK (Jenkins, Jira, Keycloak, Elasticsearch) podem não usar o java do sistema — atualizar o pacote do SO não basta.

O que monitorar

Enquanto o ambiente não está totalmente corrigido, vale configurar alertas para os seguintes sinais:

  • Entradas suspeitas: campos Base64 terminando em = ou == cujo tamanho não é múltiplo de 4 — encoders legítimos não geram isso.
  • Rajadas de erros: picos de IllegalArgumentException vindos de java.util.Base64 no tratamento de requisições.
  • Quedas da JVM: arquivos hs_err_pid*.log com SIGSEGV em rotinas do GC e o frame Base64$Decoder.decode0, especialmente se agrupados por IP de origem.
  • Padrões de tráfego: alto volume de requisições com Base64 vindas de uma mesma origem, cadenciadas ou fragmentadas.
  • Respostas anômalas: respostas maiores que o normal ou com conteúdo binário em endpoints que ecoam dados decodificados, possível sinal de vazamento de heap.

Como defesa em profundidade, a CISA recomenda validar e limitar o tamanho de entradas Base64 na borda (WAF, proxy reverso) e restringir o acesso não autenticado sempre que possível — por exemplo, não expor o console administrativo do Keycloak à internet.

Checklist

  1. Inventarie todas as instâncias Java (Keycloak e demais aplicações) e o JDK que cada processo realmente usa.
  2. Verifique a CPU de cada nó, inclusive failover e nós de autoscaling.
  3. Aplique -XX:-UseBASE64Intrinsics nas instâncias expostas, incluindo o Keycloak Operator, e reinicie.
  4. Confirme a flag na JVM em execução com jcmd.
  5. Ative o monitoramento dos sinais acima.
  6. Acompanhe os boletins dos fornecedores e planeje a migração para um runtime corrigido; remova a mitigação só depois de validar.

Como a Neture pode ajudar

A Neture opera e monitora ambientes de clientes em nuvem e on-premises, incluindo implantações de Keycloak para SSO corporativo. Para os clientes dos nossos contratos de operação em nuvem e monitoramento NOC, já estamos levantando o inventário de runtimes Java e CPUs, aplicando a mitigação onde necessário e acompanhando a liberação dos builds corrigidos. Se você não é cliente e quer ajuda para avaliar seu ambiente, fale com a nossa equipe.

Referências

  • Keycloak — Java4Shell: What Keycloak admins need to do (CVE-2026-114938): https://www.keycloak.org/2026/11/java4shell-vulnerability-cve-2026-114938
  • Calif — Java4Shell: Write once, RCE everywhere: https://calif.io/java4shell/
  • Keycloak — Issue #55293: https://github.com/keycloak/keycloak/issues/55293
  • Red Hat — Boletim RHSB-2026-018: https://access.redhat.com/security/vulnerabilities/RHSB-2026-018
  • Endor Labs — Java4Shell: Pre-Auth Heap Overflow in OpenJDK: https://www.endorlabs.com/learn/java4shell-unauthenticated-rce-reported-in-openjdk-17-cve-2026-114938
  • Help Net Security — Java4Shell OpenJDK flaw: https://www.helpnetsecurity.com/2026/11/18/java4shell-openjdk-vulnerability-cve-2026-114938/
  • Qualys — How to Find, Mitigate, and Patch Java4Shell: https://blog.qualys.com/vulnerabilities-threat-research/2026/11/17/how-to-find-mitigate-and-patch-the-critical-java4shell-flaw-cve-2026-114938-now