
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:
- 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.
- 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ção | Afetado | Não afetado |
|---|---|---|
| Versão do Java | OpenJDK 17.0.6+, 21, 25, 27 sem correção | Java 8, Java 11, OpenJDK 17.0.0–17.0.5 |
| Processador | x86-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 JVM | Intrí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 -version3. Verifique as flags da JVM em execução
jcmd -l # descobre o PID
jcmd <pid> VM.flags -all | grep -F UseBASE64IntrinsicsSe 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 startsystemd: 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> startDocker 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:-UseBASE64IntrinsicsCom 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 UseBASE64IntrinsicsRepita 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
IllegalArgumentExceptionvindos dejava.util.Base64no tratamento de requisições. - Quedas da JVM: arquivos
hs_err_pid*.logcom SIGSEGV em rotinas do GC e o frameBase64$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
- Inventarie todas as instâncias Java (Keycloak e demais aplicações) e o JDK que cada processo realmente usa.
- Verifique a CPU de cada nó, inclusive failover e nós de autoscaling.
- Aplique
-XX:-UseBASE64Intrinsicsnas instâncias expostas, incluindo o Keycloak Operator, e reinicie. - Confirme a flag na JVM em execução com
jcmd. - Ative o monitoramento dos sinais acima.
- 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