Vá direto para um resumo gerado por IA desta postagem do blog

  • Resuma esta postagem com o Perplexity
  • Resuma esta postagem com o Gemini

Atualização CVE-2026-114938 para usuários do OpenJDK

Atualizado em 18 de novembro de 2026. As compilações do OpenJDK 17 da TuxCare incluem a correção do Java4Shell na versão mais recente da TuxCare. O Java 7, 8 e 11 não contêm o decodificador vulnerável; portanto, os clientes que utilizam essas versões do OpenJDK não precisam aplicar nenhuma correção para este CVE.

Se um host não puder receber a atualização imediatamente, o -XX:-UseBASE64Intrinsics A opção de inicialização desativa o caminho de código vulnerável nas compilações afetadas do HotSpot 17.

Obtenha suporte contínuo ao longo do ciclo de vida do OpenJDK →

Principais conclusões

  • Java4Shell (CVE-2026-114938) é um estouro de pilha no decodificador Base64 do OpenJDK que o Calif aproveitou para executar código remotamente.
  • As compilações não atualizadas do Java 17.0.6+, 21, 25 e 27 estão em risco em servidores x86-64 com AVX-512 VBMI.
  • A Oracle, o OpenJDK, o Corretto e o Zulu lançaram correções em 17 de novembro de 2026, enquanto o Temurin, a Red Hat e o Ubuntu ficaram para trás.
  • Iniciando a JVM com -XX:-UseBASE64Intrinsics desativa o caminho de código vulnerável até que uma versão corrigida do programa seja instalada.

A versão resumida

Ir para a versão completa ↓

O que aconteceu. Calif divulgou a vulnerabilidade Java4Shell (CVE-2026-114938) em 17 de novembro de 2026, no mesmo dia em que a Oracle e o projeto OpenJDK lançaram as correções. Uma string Base64 malformada, terminando com um preenchimento incorreto com o caractere “=”, faz com que o decodificador AVX-512 do HotSpot grave 62 ou 63 bytes além do fim de um buffer de heap, e a Calif afirma que isso resultou em execução remota de código em aplicativos como Jira, Jenkins e Keycloak. Ir para esta seção →

Quem está afetado. Qualquer pessoa que esteja executando uma versão sem patch das linhas Java 17.0.6+, 21, 25 ou 27 em um processador Intel ou AMD x86-64 com AVX-512 VBMI. Isso inclui versões da Oracle, Corretto, Temurin, Zulu, Red Hat, Microsoft e outros fornecedores baseados no OpenJDK. Os hosts padrão do Java 8, Java 11 e ARM64 não são afetados. Ir para esta seção →

Qual é a gravidade da vulnerabilidade? A Oracle atribui a ela uma pontuação de 8,1 segundo o CVSS 3.1, a Calif atribui 9,2 segundo o CVSS 4.0, e a Red Hat classifica o impacto como “Crítico”. A exploração requer trabalho específico para cada alvo, mas causar uma falha em uma JVM vulnerável é muito mais simples, e nenhum ataque em ambiente real havia sido relatado até 18 de novembro de 2026. Ir para esta seção →

Situação atual. As versões corrigidas no upstream são 17.0.21.1, 21.0.13.1, 25.0.5.1 e 27.0.1.1, e as correções para o Amazon Corretto e o Azul Zulu já foram lançadas. As compilações do Temurin, Red Hat e Ubuntu ainda estavam pendentes em 18 de novembro de 2026, e o Debian tinha uma correção apenas na versão instável. Os usuários do OpenJDK 17 que contam com o Suporte de Ciclo de Vida Ilimitado da TuxCare recebem a correção na versão mais recente da TuxCare, dentro da linha do OpenJDK 17 que já executam. Ir para esta seção →

O que fazer hoje. Identifique todas as JVMs, incluindo aquelas integradas em produtos e incorporadas em imagens de contêiner. Instale versões corrigidas, quando disponíveis, e configure -XX:-UseBASE64Intrinsics nos hosts afetados que ainda aguardam uma correção do fornecedor e, de qualquer forma, reinicie o sistema. Ir para esta seção →

A versão completa

A grande promessa do Java há três décadas é que os desenvolvedores não precisam se preocupar com a memória. A JVM verifica cada acesso à matriz, de modo que os estouros de buffer deveriam ser um problema exclusivo do C e do C++. O Java4Shell nos lembra que a própria JVM ainda é construída em C++ e em assembly ajustado manualmente, e que a rede de segurança abrange apenas o código executado sobre ela.

A vulnerabilidade CVE-2026-114938 está presente em uma dessas rotinas ajustadas manualmente: o decodificador AVX-512 Base64 que o HotSpot utiliza nos chips de servidor mais recentes da Intel e da AMD. Ao fornecer a ele uma string malformada com preenchimento incorreto no final, ele grava além do fim do buffer de saída antes que a JVM rejeite a entrada. A Calif, empresa que identificou a vulnerabilidade, afirma ter usado essa gravação para criar cadeias funcionais de execução remota de código contra o Jira, o Jenkins, o Keycloak e outros aplicativos amplamente implantados em suas configurações padrão.

A correção é pequena, a solução alternativa consiste em um único parâmetro da JVM e, até 18 de novembro de 2026, nenhuma exploração havia sido relatada publicamente. O mais difícil é que muitos ambientes de execução do Java ainda não possuem uma versão corrigida, e muitas equipes não têm uma estimativa clara de quantas JVMs realmente executam.

Como funciona o bug do Base64

Quando um método é chamado com frequência suficiente, o compilador C2 do HotSpot o substitui por um código nativo mais rápido. Para alguns caminhos de execução mais frequentes, incluindo java.util.Base64 na decodificação, ela pode recorrer a uma função intrínseca, uma rotina escrita manualmente pelos engenheiros da JVM no nível de assembly para processadores x86-64 específicos. Em chips com AVX-512 VBMI, a função intrínseca Base64 decodifica 64 bytes por vez usando armazenamentos vetoriais mascarados, nos quais uma máscara de 64 bits determina quais bytes são efetivamente gravados na memória.

A falha está na forma como essa máscara é construída para o último bloco de entrada. Se a parte restante for uma sequência de preenchimento malformada, como “=”, “==” ou “X=”, a rotina calcula um comprimento de saída igual a zero e, em seguida, subtrai um para cada “=”. O comprimento entra em subfluxo para -1 ou -2. A instrução BZHI, responsável pela construção da máscara, lê sua contagem de bits a partir do byte inferior desse valor, que resulta em 255 ou 254. Ambos excedem a largura de operando de 64 bits, de modo que todos os 64 bits da máscara permanecem ativados e o comando de armazenamento grava 64 bytes completos. No exemplo de Calif, uma entrada de 65 caracteres composta por 64 caracteres “A” mais “=” resulta em uma matriz de 50 bytes, e o decodificador grava 62 bytes além do seu fim. No OpenJDK 17, Calif afirma que o gatilho é 128 caracteres “A” mais “=”, pois o limite de comprimento para o caminho rápido é maior nessa versão.

O Java realmente lança uma IllegalArgumentException devido à entrada inválida. Ele simplesmente descarta a entrada depois que a gravação já ocorreu e, a essa altura, qualquer objeto que estivesse ao lado do buffer na pilha já pode ter sido corrompido.

Os bytes de estouro são, em sua maioria, valores fixos, e não dados escolhidos pelo invasor, o que parece limitante. Calif contornou isso com um truque clássico de exploração de navegadores. Manipule a pilha (heap) de modo que o estouro atinja o campo de comprimento de outra matriz e, em seguida, use essa matriz ampliada para gravar os bytes escolhidos em suas vizinhas. Um segundo array com o campo de comprimento corrompido, cujo conteúdo é copiado de volta para uma resposta HTTP, torna-se um leitor de heap, ao qual Calif deu o apelido de JavaBleed. Essa etapa, por si só, tem o potencial de vazar chaves privadas e tokens de sessão antes mesmo que qualquer código seja executado.

Em Testes do Datadog no OpenJDK 17.0.6, apenas os decodificadores básico e de URL retornados por Base64.getDecoder() e Base64.getUrlDecoder() chegou à rota vulnerável. O decodificador MIME não chega, e as bibliotecas Base64 que nunca chamam java.util.Base64 Não mexa de jeito nenhum no intrinsic. Isso ajuda na triagem, mas não dependa demais disso. Calif aponta recursos comuns, como autenticação e envio de arquivos, como formas pelas quais as entradas do invasor podem chegar ao decodificador.

Quais versões e servidores Java são afetados

É preciso que três condições se alinhem.

O ambiente de execução. O Java4Shell afeta compilações do OpenJDK 17 sem patch a partir da versão 17.0.6, além das linhas de lançamento posteriores, incluindo as versões 21, 25 e 27, antes das correções de 17 de novembro de 2026. O OpenJDK 17.0.6 foi lançado em janeiro de 2023; portanto, o decodificador vulnerável faz parte do OpenJDK 17 há quase quatro anos. O Java 8 e o Java 11 padrão não são afetados, pois nenhum deles possui o stub de decodificação x86, e o Java 17.0.0 até 17.0.5 também não são afetados. A única exceção no Java 8 é o Java SE 8 Enterprise Performance Pack da Oracle, que a Oracle lista como afetado na versão 8u511b33-perf.

Versões sem correção de outros fornecedores do OpenJDK também apresentam o bug. A lista da Calif inclui o Amazon Corretto, o Eclipse Temurin, a versão do OpenJDK da Microsoft, o Azul Zulu, o BellSoft Liberica, o SAP SapMachine, o OpenJDK da Red Hat, o Oracle OpenJDK, o Oracle Java SE e o Oracle GraalVM para JDK.

A CPU. O código vulnerável só é executado em chips x86-64 com AVX-512 VBMI. A lista da Calif’s cita os processadores Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids e Granite Rapids, além dos AMD EPYC e Ryzen com arquitetura Zen 4 ou mais recente. Skylake-SP, Cascade Lake e hardware AMD anterior ao Zen 4 geralmente não possuem VBMI e não seguem o caminho vulnerável, e o ARM64, incluindo o AWS Graviton e o Apple Silicon, não é afetado de forma alguma. Portanto, os hosts em risco são, em sua maioria, servidores e instâncias em nuvem mais recentes, o que inverte a suposição comum de que o risco está no hardware antigo. No entanto, ser mais novo não significa automaticamente que haja VBMI; portanto, a verificação do sinalizador da CPU abaixo é o verdadeiro teste.

O caminho dos dados. O aplicativo precisa passar uma entrada controlada pelo invasor para o decodificador básico padrão ou de URL, e esse método precisa ser executado com frequência suficiente para que o C2 o compile com a função intrínseca. Em um serviço web com alto volume de tráfego, ambas as condições podem ser atendidas. A Calif afirma ter demonstrado RCE pré-autenticação em configurações padrão do Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins e PingFederate, e RCE pós-autenticação no Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit e Spinnaker. A Calif afirma também ter conseguido RCE em aplicativos de exemplo desenvolvidos com Spring Boot e Apache Struts.

Depois, há o lado do cliente. A Calif relata que uma vulnerabilidade compartilhada com ela comprometeu um programa Java que simplesmente abria uma conexão TLS com um servidor malicioso, sem expor nenhum serviço próprio. Tarefas em lote, rastreadores e serviços de integração que realizam apenas chamadas de saída também estão incluídos nesse escopo.

Por que as verificações de dependências podem deixar o Java4Shell de fora

O Log4Shell treinou muitas equipes a procurar por JARs vulneráveis. Esse reflexo não ajuda neste caso. O Java4Shell não é uma dependência que você encontrará em um pom.xml ou build.gradle, e ele não aparecerá em um relatório de análise de composição de software que analise apenas as dependências do aplicativo. O código vulnerável vem incluído no JDK, que geralmente é obtido a partir de uma imagem base de contêiner, um pacote do sistema operacional, um instalador incluído em um produto de fornecedor ou um JAVA_HOME alguém criou em 2023 e nunca mais mexeu nisso.

É por isso que o alerta da CISA destaca especificamente os JDKs incluídos em pacotes de aplicativos de terceiros, imagens de contêineres e dispositivos. Um JDK do sistema atualizado não adiantará nada para um produto que seja executado a partir de sua própria cópia incluída no pacote, e um host atualizado não adiantará nada para um JDK integrado a uma imagem que não tenha sido recompilada.

A higiene das bibliotecas continua sendo importante, e o SecureChain para Java cuida da parte relacionada ao Maven. Nesse caso, porém, o alvo da correção é o ambiente de execução. Trate cada JVM como um ativo próprio a ser incluído no inventário.

Quão ruim o Java4Shell realmente é

Depende de quem está avaliando. A Oracle classifica o CVE-2026-114938 com nota 8,1 segundo o CVSS 3.1 e o descreve como difícil de ser explorado, exigindo acesso à rede, sem necessidade de privilégios nem interação do usuário, mas com alta complexidade de ataque. A Calif o classifica com nota 9,2 segundo o CVSS 4.0. O boletim da Red Hat, RHSB-2026-018, classifica o impacto como Crítico.

O Calif afirma que não existe uma exploração universal. Cada alvo precisa de seu próprio perfil de “heap grooming”; as cadeias do Calif são sensíveis ao jitter de rede e ao tempo de ida e volta, e uma tentativa fracassada de “grooming” pode travar a JVM. O Calif também descobriu que um proxy reverso que armazena em buffer o corpo completo das solicitações — o que o nginx faz por padrão — interrompe alguns de seus caminhos de “grooming”. Alguns, mas não todos. Calif afirma que sua cadeia do Elasticsearch funciona a partir de uma solicitação completa, portanto, o armazenamento em buffer não a impede.

Há dois fatores que apontam na direção contrária. Primeiro, é muito mais fácil provocar uma falha do que a execução de código. A Blackpoint Cyber identificou a vulnerabilidade por meio de um aplicativo Spring Boot local que utilizava o Spring Security, e cerca de 28.000 solicitações não autenticadas contendo um valor de autenticação Base64 malformado causaram a falha da JVM após aproximadamente 20 segundos. A Blackpoint também relatou alterações nos dados da aplicação em produção sem que ocorresse uma falha imediata, o que é muito mais difícil de detectar. Em segundo lugar, a Calif afirma ter encontrado a falha em uma hora com a ajuda da IA e ter desenvolvido uma primeira exploração funcional duas horas depois, utilizando menos de US$ 200 em tokens de IA. A Calif está mantendo em sigilo, por enquanto, as cadeias específicas de seus produtos.

Até 18 de novembro de 2026, não havia relatos de exploração em ambiente real. O GreyNoise não havia registrado nenhuma solicitação do tipo Java4Shell até a atualização das 00h48 UTC daquele dia, e o CVE não constava no catálogo de Vulnerabilidades Exploradas da CISA. A CISA ainda assim emitiu um alerta em 17 de novembro recomendando a aplicação imediata de patches, um bom sinal de quão a sério a agência está levando o caso.

A vulnerabilidade também já está exposta há mais tempo do que a maioria das pessoas imagina. De acordo com o The Hacker News, uma correção proposta, publicada no repositório do OpenJDK em 9 de setembro, incluía uma entrada que provocava o estouro de memória e foi encerrada sem ter sido incorporada no início de novembro, após ficar inativa. Calif afirmou que o bug vazou antes do lançamento do patch. Não há nada público que indique que o Java4Shell tenha sido explorado antes do lançamento da correção, e nenhum ataque foi relatado desde então, mas os defensores não devem presumir que são os primeiros a ler os detalhes.

Como o Java4Shell se compara ao Log4Shell

O Log4Shell (CVE-2021-44228) recebeu uma pontuação de 10,0 no CVSS 3.1, funcionava em qualquer CPU e podia ser acionado sempre que uma versão vulnerável do Log4j 2 registrasse uma sequência de caracteres controlada pelo invasor. Exploits públicos surgiram rapidamente e varreduras em massa se seguiram quase imediatamente.

O Java4Shell tem um escopo mais restrito. Ele requer um recurso específico da CPU, um JIT aquecido, um caminho de decodificação exposto e uma exploração específica para o alvo; portanto, ataques do tipo “spray-everything” são muito menos prováveis. Onde ele se mostra mais perigoso é no alcance e na limpeza. O Log4Shell residia em uma biblioteca que era possível localizar e substituir. O Java4Shell reside no ambiente de execução Java por baixo do aplicativo, abrangendo uma longa lista de compilações de fornecedores, cada uma com correções lançadas em seus próprios prazos, e cada JVM corrigida precisa ser reiniciada.

Status das atualizações por fornecedor de Java

A Oracle e o projeto OpenJDK lançaram correções às 13h, horário do Pacífico, em 17 de novembro de 2026. As versões originais corrigidas são 17.0.21.1, 21.0.13.1, 25.0.5.1 e 27.0.1.1. Os fornecedores derivados compilam a partir desse código-fonte seguindo seus próprios cronogramas e com suas próprias sequências de versão; portanto, o número da compilação em um determinado host é mais importante do que a data do aviso.

Compilação em Java Afetados Status da correção (18 de novembro de 2026)
Oracle Java SE 17, 21, 25, 27 17.0.6 a 17.0.21.0.3, além de 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3 e versões anteriores Corrigido nas versões 17.0.21.1, 21.0.13.1, 25.0.5.1 e 27.0.1.1 (build +4)
Pacote de Desempenho Empresarial do Oracle Java SE 8 8u511b33-perf Corrigido na versão 8u513-perf
Projeto original do OpenJDK Versões do Java 17 a partir da 17.0.6, além das versões 21, 25 e 27, anteriores à correção Corrigido nas versões 17.0.21.1+4, 21.0.13.1+4, 25.0.5.1+4 e 27.0.1.1+4
Amazon Corretto e Amazon Linux 17, 21, 25, 27 Corrigido nas versões 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 e 27.0.1.1.4 do Corretto, com os pacotes correspondentes para o Amazon Linux
Azul Zulu 17, 21, 25, 27 Corrigido nas versões 17.0.21.1+2, 21.0.13.1+2, 25.0.5.1+2 e 27.0.1.1+4, conforme a tabela de CVEs da Azul
Eclipse Temurin 17.0.6 e versões posteriores, incluindo 17.0.21+9 e 21.0.13+9 Ainda não foi publicada nenhuma versão fixa
Versão do OpenJDK compilada pela Red Hat (RHEL 8, 9, 10) 17, 21, 25 Corrigir pendências conforme RHSB-2026-018
Debian openjdk-17, 21, 25, 27 O openjdk-21 21.0.13.1+2-1 foi aceito no repositório “unstable” em 18 de novembro. Os repositórios “stable” e “testing” ainda apresentam vulnerabilidades
Ubuntu openjdk-17, openjdk-21 e pacotes OpenJDK mais recentes Ainda não foi confirmado nenhum pacote específico nem aviso de segurança
Microsoft, SapMachine, Liberica 17.0.6 e versões posteriores Afetado, segundo a Califórnia; ainda não foram confirmadas versões estáveis
Java 8 padrão, Java 11, Java 17.0.0 a 17.0.5 Não afetado Não é necessária nenhuma ação específica do Java4Shell

As imagens de contêiner constituem um item de linha à parte. As imagens base atualizadas precisam ser enviadas primeiro; em seguida, todas as imagens criadas a partir delas precisam ser recompiladas e reimplantadas. Um pacote corrigido no host não chega ao interior de um contêiner que trouxe seu próprio JDK.

Como mitigar o Java4Shell hoje

A correção do ambiente de execução é a solução definitiva. Instale a versão corrigida fornecida pelo fabricante para cada JVM afetada e, em seguida, reinicie o processo. A reinicialização não é opcional, pois uma JVM em execução continua utilizando o código que já foi carregado.

Nos casos em que ainda não existe uma versão compilada, tanto a Calif quanto a Red Hat indicam um parâmetro da JVM.

-XX:-UseBASE64Intrinsics

Isso desativa as rotinas Base64 aceleradas por hardware do HotSpot e recorre à implementação simples em Java, que não utiliza o caminho do decodificador nativo vulnerável. A alternativa mais abrangente, -XX:UseAVX=2, limita o HotSpot ao AVX2, de modo que ele deixa de usar o AVX-512. Isso funciona, mas também descarta todos os demais caminhos de código AVX-512 na JVM, o que pode acarretar alguma perda de velocidade; além disso, Calif observa que, em ARM, a JVM não reconhece o sinalizador e não inicia. Isso faz com que seja uma configuração padrão inadequada para frotas mistas.

A maneira mais simples de aplicar o sinalizador “narrow” de forma ampla é JAVA_TOOL_OPTIONS, que as JVMs do HotSpot leem na inicialização. Lembre-se de que isso se aplica a todas as JVMs iniciadas nesse ambiente, incluindo as ferramentas de compilação; portanto, teste antes de implementar em toda a frota.

export JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"

Para um serviço do systemd, abra um arquivo drop-in com sudo systemctl edit <service>, adicione essas duas linhas, salve e reinicie o serviço. Verifique a unidade primeiro, no entanto. Se ela já estiver configurada JAVA_TOOL_OPTIONS, adicione o sinalizador a esse valor; caso contrário, o plug-in substituirá o que quer que estivesse lá.

[Service]
Environment="JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics"

Para contêineres, defina-o como um ENV na fase de execução. Em seguida, reinicie e confirme se a alteração foi aplicada. Produtos com seus próprios scripts de inicialização podem substituir ou ignorar variáveis de ambiente; portanto, verifique os parâmetros do processo em execução, em vez de confiar no arquivo de configuração.

E quanto ao desempenho? O argumento da Calif é que o decodificador acelerado ajuda principalmente aplicativos que processam volumes enormes de Base64. É improvável que um endpoint de login ou uma API que decodifique algumas centenas de bytes por solicitação perceba uma diferença significativa.

Se houver uma versão corrigida disponível junto ao seu fornecedor de Java, instale-a, reinicie o sistema e verifique a versão. Se ainda não estiver disponível e o host tiver AVX-512 VBMI, defina o sinalizador hoje mesmo e agende a atualização do runtime para o dia em que o fornecedor disponibilizar a correção. Se o host for ARM64 ou um chip x86 mais antigo sem VBMI, ele não será afetado por esse bug, mas aplique o patch em seu ciclo normal de qualquer maneira, já que as cargas de trabalho mudam entre tipos de instância com mais frequência do que se imagina.

Os controles de borda ajudam um pouco. A CISA sugere validar e limitar o tamanho das entradas em Base64 no limite do aplicativo, além de restringir o acesso não autenticado. Uma regra de WAF voltada para valores Base64 com preenchimento irregular nos cabeçalhos de autenticação pode criar alguma barreira, mas é de se esperar que haja falsos positivos, e isso não deve ser considerado uma solução definitiva.

Verificação rápida do servidor

Comece pela CPU. No Linux, a verificação do Calif procura os quatro sinalizadores da CPU necessários para o caminho vulnerável.

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

Se todos os quatro estiverem presentes, o hardware atende ao pré-requisito. Se avx512vbmi se estiver ausente, o caminho do decodificador vulnerável não será utilizado nesse host.

Em seguida, liste os processos em execução com o nome java em todas as contas de serviço, não apenas na JVM do seu PATH. Execute-o como root, pois um usuário sem privilégios não pode resolver os processos de outros usuários.

sudo sh -c 'for p in (pgrepjava);doreadlink-f/proc/p/exe; done' | sort -u

Considere isso como um ponto de partida, e não como um inventário completo. As JVMs iniciadas com outros nomes, os pacotes instalados que não estão em execução no momento, os ambientes de execução incluídos em produtos de fornecedores e as imagens de contêineres — todos precisam ser verificados separadamente.

Em seguida, verifique a versão de cada runtime e se a função intrínseca está habilitada, substituindo pelo caminho da etapa anterior.

/path/to/bin/java -version
/path/to/bin/java -XX:+PrintFlagsFinal -version | grep -E ' (UseAVX|UseBASE64Intrinsics) '

Se a versão estiver dentro de um intervalo afetado, a verificação da CPU foi aprovada, UseAVX é maior que 2 e UseBASE64Intrinsics É verdade que a JVM pode utilizar o caminho vulnerável. Para um processo que já esteja em execução, jcmd mostra seus parâmetros efetivos. Execute-o com o mesmo usuário que é o proprietário do processo.

jcmd <pid> VM.flags -all | grep -E 'UseAVX|UseBASE64Intrinsics'

Calif também publicou uma prova de conceito limitada que prepara o decodificador, fornece a ele a entrada malformada e exibe a mensagem “REPRODUCED” em um JDK afetado. Ela foi projetada para manter todas as gravações dentro de um array real de 4.096 bytes, mas ainda assim é executada em um ambiente de teste isolado contra uma cópia de cada ambiente de execução de produção. Uma ressalva para quem usa o Java 17: o PoC publicado usa o gatilho de 65 caracteres (64 caracteres “A” mais “=”), e a Calif afirma que o OpenJDK 17 precisa de 128 caracteres “A” mais “=”; portanto, um resultado “NOT REPRODUCED” em um ambiente de execução do Java 17 não prova grande coisa. O número de compilação corrigido pelo fornecedor é a verdadeira prova de que um ambiente de execução foi corrigido.

A situação atual do suporte contínuo ao ciclo de vida do OpenJDK

O TuxCare oferece suporte ao OpenJDK 7, 8, 11 e 17, continuando a fornecer correções de segurança mesmo após o término do período de suporte para uma determinada compilação. Três dessas quatro versões não são afetadas pelo Java4Shell. O Java 7, 8 e 11 não incluem o stub de decodificação x86 Base64; portanto, os clientes que utilizam essas versões não precisam aplicar nenhuma correção para essa vulnerabilidade (CVE).

O OpenJDK 17 é um caso à parte. As compilações do OpenJDK 17 sem correção, a partir da versão 17.0.6, contêm o decodificador vulnerável, e os pacotes do OpenJDK 17 da TuxCare se enquadram nesse intervalo. Os engenheiros da TuxCare confirmaram que a correção para o Java4Shell faz parte da versão mais recente; portanto, os clientes podem obtê-la pelos mesmos repositórios que já utilizam. A correção é incorporada à linha do OpenJDK 17 que os clientes já executam, sem a necessidade de um salto de versão principal nem do trabalho de compatibilidade que isso acarreta.

Versão do OpenJDK Afetado pelo Java4Shell Situação do TuxCare (18 de novembro de 2026)
OpenJDK 7 Não Não afetado
OpenJDK 8 Não Não afetado
OpenJDK 11 Não Não afetado
OpenJDK 17 Sim, em hosts VBMI com AVX-512 Corrigido na versão mais recente do TuxCare

Para servidores que não podem receber a atualização imediatamente, -XX:-UseBASE64Intrinsics funciona nas compilações do OpenJDK 17 da TuxCare da mesma forma que em outros ambientes de execução do HotSpot 17 afetados.

Mais uma observação para quem está avaliando suas opções. O Java4Shell é exatamente o tipo de notícia que leva as equipes a realizar atualizações precipitadas para versões principais, e saltar da 17 para a 21 ou 25 sob pressão só ajuda se a nova compilação já estiver corrigida, já que compilações não corrigidas dessas versões apresentam o mesmo bug. O caminho mais rápido e seguro é uma compilação corrigida da versão que já está em produção.

Mantenha sua versão atual do OpenJDK atualizada com os patches, sem precisar fazer uma atualização forçada. Conheça o suporte de ciclo de vida ilimitado para o OpenJDK →

Respostas rápidas sobre o Java4Shell

O Java 8 é afetado pelo Java4Shell? As compilações padrão do Java 8 não são afetadas, pois não contêm o stub de decodificação vulnerável. A única exceção no Java 8 é o Java SE 8 Enterprise Performance Pack da Oracle, que a Oracle lista como afetado na versão 8u511b33-perf.

O Java 11 é afetado? Não. O Java 11 também não possui o stub de decodificação x86.

Os servidores ARM são afetados? Não. Os hosts ARM64, incluindo o AWS Graviton e o Apple Silicon, nunca geram o stub x86.

O Java4Shell está sendo explorado? Não até 18 de novembro de 2026. Não foram relatados casos de exploração em ambiente real, e o CVE não consta no catálogo KEV da CISA.

Isso é um problema do Log4j? Não. O bug está no próprio decodificador Base64 do JDK, e não em uma biblioteca de registro de logs ou em qualquer outra dependência do aplicativo.

Essa solução alternativa causa algum problema? O -XX:-UseBASE64Intrinsics O sinalizador apenas substitui o decodificador acelerado pelo normal. Muitos aplicativos não notarão uma diferença significativa, mas ainda assim é recomendável fazer um teste rápido antes de implementar a mudança em toda a frota.

Aplique o patch no Runtime no Everything

O Java4Shell é um problema de tempo de execução, e os problemas de tempo de execução costumam passar despercebidos. É necessário um servidor x86-64 com AVX-512 VBMI, uma compilação do OpenJDK sem patches a partir da versão 17.0.6 e um caminho de código que decodifique Base64 da rede — uma combinação comum no Java corporativo moderno. A medida prática a ser tomada hoje é breve. Faça um inventário de todas as JVMs, incluindo as integradas e as em contêineres; aplique patches onde houver compilações do fornecedor; defina -XX:-UseBASE64Intrinsics nos sistemas afetados que ainda aguardam uma correção e reinicie-os. Em seguida, fique de olho no Temurin, Red Hat, Debian e Ubuntu, já que essas correções ainda estavam a caminho ou haviam sido lançadas apenas parcialmente até 18 de novembro de 2026.

Para equipes que utilizam o OpenJDK além do prazo de suporte definido pelo fornecedor, o Suporte de Ciclo de Vida Ilimitado da TuxCare para o OpenJDK garante que as correções de segurança continuem sendo aplicadas à versão específica em produção, para que o próximo Java4Shell não se transforme em uma migração forçada.

Cronologia do Java4Shell

Data Evento
Janeiro de 2023 O OpenJDK 17.0.6 vem com a função intrínseca de decodificação AVX-512 Base64, sendo esta a primeira versão do Java 17 a conter o código vulnerável
9 de setembro de 2026 Uma proposta de correção para o OpenJDK contendo uma entrada que desencadeia o problema foi publicada, segundo o The Hacker News
Início de novembro de 2026 Essa correção proposta foi encerrada sem ter sido incorporada após ficar inativa
17 de novembro de 2026 A Oracle lança sua Atualização de Patches de Segurança Críticos de novembro, e o OpenJDK publica seu comunicado com versões corrigidas
17 de novembro de 2026 A Calif publica seu artigo sobre o Java4Shell e a prova de conceito, sem divulgar as cadeias de exploração específicas do produto
17 de novembro de 2026 A CISA recomenda a aplicação imediata de patches, a Red Hat publica o RHSB-2026-018, e o Amazon Corretto e o Azul Zulu lançam versões corrigidas
18 de novembro de 2026 O Debian aceitou uma versão fixa do openjdk-21 no repositório “unstable”. As correções do Temurin, da Red Hat e do Ubuntu ainda estão pendentes, e não foram relatados casos de exploração da vulnerabilidade

Fontes

Calif, artigo sobre o Java4Shell

Aviso sobre vulnerabilidade do OpenJDK, 17 de novembro de 2026

Aviso da Oracle sobre atualizações críticas de segurança, novembro de 2026

Alerta da CISA sobre a vulnerabilidade crítica do Java

Boletim de segurança da Red Hat RHSB-2026-018

Registro CVE-2026-114938

Tabela CVE da Azul Zulu, novembro de 2026

Página do Amazon Linux sobre o CVE-2026-114938

The Hacker News: a CISA recomenda a aplicação imediata da correção para o Java4Shell

The Hacker News: Java4Shell permite RCE antes da autenticação

Datadog Security Labs, análise do Java4Shell

Blackpoint Cyber, testes do Java4Shell

GreyNoise, rastreador de atividades do Java4Shell

Documentação do TuxCare OpenJDK

Junte-se a mais de 4.500 profissionais de Linux e código aberto!

2 vezes por mês. Sem spam.

Índice
Obtenha as respostas sobre segurança de código aberto de que você precisa

Junte-se a mais de 4.500 profissionais de Linux e código aberto!

2 vezes por mês. Sem spam.