Artigos aprofundados sobre a tecnologia que molda o que vem a seguir.

Java4Shell: 65 bytes no Base64 do OpenJDK levam a RCE

Java4Shell é uma falha de corrupção de memória no decodificador Base64 com AVX-512 do OpenJDK. Veja como 65 bytes geram RCE e como mitigar agora.

Ilustração de um defeito minúsculo e brilhante numa esteira corrompendo uma enorme máquina industrial
O menor componente da pilha, um caminho rápido para Base64, acabou sendo o que atravessa tudo.

Sessenta e quatro letras A e um único sinal de igual. Essa é a entrada inteira necessária para corromper o heap de um servidor OpenJDK sem patch: uma string Base64 de 65 caracteres que atravessa a proteção de memória famosa do Java e escreve 62 bytes além do fim de um array. A vulnerabilidade, divulgada pela empresa de segurança Calif como Java4Shell (CVE-2026-114938, CVSS 9.2), não está no código da aplicação, mas no assembly feito à mão, escondido no decodificador Base64 da JVM. Foi demonstrado RCE pré-autenticação contra Keycloak, Jenkins, Jira, Confluence, Artifactory e PingFederate. Se sua organização roda Java em servidores x86-64 (e estatisticamente, roda), esse problema é seu.

Eu cubro vulnerabilidades profissionalmente, e a maioria delas se mistura: mais uma desserialização, mais um bypass de autenticação, mais um path traversal. O Java4Shell é diferente, e não por causa da nota. É diferente por causa de onde ele mora. O bug está numa otimização, um atalho para decodificar Base64 usando instruções vetoriais AVX-512, que quase nenhuma aplicação no planeta realmente precisa. A história de como ele foi encontrado, como foi explorado e por que seus proxies talvez já estejam te protegendo diz muito sobre para onde a segurança de software está caminhando.

O problema: um intrínseco JIT com máscara quebrada

Para entender o bug, você precisa saber como o OpenJDK torna o Base64 rápido. A JVM HotSpot monitora quais métodos rodam com mais frequência e deixa o compilador C2 transformá-los em código nativo. Para certas operações, ela vai além e troca essas partes por rotinas de assembly ajustadas à mão, chamadas intrínsecos, que usam instruções especializadas da CPU. Em chips x86-64 com suporte a AVX-512 VBMI, a decodificação Base64 recebe exatamente esse tratamento: o intrínseco processa a entrada em blocos de 256 ou 64 bytes, usando a instrução VMOVDQU8 com uma máscara de 64 bits que decide quais bytes serão escritos no buffer de destino.

O erro está em como essa máscara é calculada para o final preenchido da entrada. O Base64 completa a saída com caracteres =, e o assembly reduz o tamanho da saída para cada byte de preenchimento que encontra. Para certas entradas malformadas, como um = isolado no fim de um bloco, o tamanho calculado sofre underflow e vira -1 ou -2. Esse valor negativo entra numa instrução de manipulação de bits (bzhiq) que, para entradas de 64 ou mais, deixa a máscara intacta: todos os 64 bits ligados. Todos os bits ligados significam que todos os bytes são escritos.

Vamos ao gatilho concreto. Você envia 64 letras A seguidas de =, 65 caracteres no total. A JVM calcula o tamanho decodificado como 50 bytes e aloca um array de 50 bytes. O intrínseco decodifica bem os primeiros 64 caracteres, depois esbarra no sinal de igual sobrando, sofre o underflow no tamanho, liga a máscara inteira e dispara uma escrita vetorizada de 64 bytes começando perto do fim do buffer de 50 bytes. Sessenta e dois bytes de objetos vizinhos no heap são sobrescritos com dados constantes influenciados pelo atacante. A validação do próprio Java eventualmente percebe que a entrada é inválida e lança IllegalArgumentException, mas aí o estrago já foi feito. O tratamento de exceção está limpando o chão enquanto a casa já está pegando fogo.

// Pseudocode of the mask calculation (after Calif's write-up)
input_mask := bzhiq(-1, input_length)
output_len := (input_length / 4) * 3
// handle padding
if input[input_length - 1] == '=':
output_len -= 1
input_mask >>= 1
if input[input_length - 2] == '=':
output_len -= 1
input_mask >>= 1
// For a lone '=' tail, output_len was already 0
// -> now it's -1, and bzhiq(-1, 255) leaves all bits set
output_mask := bzhiq(-1, output_len)   // == -1u64, all 64 bits 1
// evmovdqub then writes all 64 bytes where ~50 were allocated

Um detalhe importa para sua triagem: isso só executa em hosts x86-64 cujas CPUs suportam AVX-512 VBMI. Servidores ARM como o AWS Graviton nunca executam o stub vulnerável, e o mesmo vale para Xeons mais antigos. O caminho de código vulnerável também só aparece em JVMs baseadas no HotSpot: OpenJDK, Oracle JDK, GraalVM. OpenJ9 e Azul Prime, que usam arquiteturas JIT diferentes, não são afetados. No OpenJDK 17, aliás, o gatilho são 128 letras A mais =, e não 64, porque o limite para entrar no caminho rápido é maior. Diferenças pequenas, mas que importam se você estiver escrevendo regras de detecção.

Primeira tentativa fracassada: "Java é seguro em memória"

A primeira reação nos canais de Slack de engenharia quando isso veio à tona foi descrença. Corrupção de memória, em Java? A segurança de memória não é justamente o ponto? Esse instinto, de que o runtime é uma fortaleza e só o código da aplicação pode trair você, é o primeiro modelo falho, e vale examiná-lo porque ele molda a forma como as equipes auditam a própria stack.

A linguagem Java verifica todo acesso a array e gerencia toda alocação. Mas o runtime Java é um corpo enorme de C, C++ e assembly. Os compiladores JIT, os coletores de lixo, os intrínsecos, o código de imagens nativas: tudo isso executa com o poder total e sem mediação do processo, e nenhum deles goza das garantias que o Java oferece ao seu bytecode. Cada intrínseco é um pequeno buraco aberto na muralha de segurança em nome da velocidade, e esses buracos são mantidos por um punhado relativamente pequeno de engenheiros de VM. É a mesma lição estrutural do bug de asterisco no SSH do Alpine Linux, de uma década atrás: os defeitos mais assustadores vivem no código que todo mundo usa e quase ninguém lê.

Existe um ponto cego de auditoria de segurança que vejo o tempo todo. As equipes fazem fuzzing dos próprios parsers JSON, fazem pentest nos handlers REST e rodam análise estática em cada linha que escreveram, e depois tratam o JDK como caixa-preta porque ele é maduro, amplamente implantado e mantido por gente competente. Maturidade não é defesa. Muitas vezes é o contrário: décadas de otimizações acumuladas, cada uma sensata na época, cada uma adicionando superfície de ataque que é entregue a todos, quer se beneficiem ou não. O intrínseco AVX-512 do Base64 existe para acelerar aplicações que decodificam volumes enormes de dados. Sua API REST decodificando um header de autenticação de 200 bytes herda o risco e recebe praticamente nada da recompensa. A Calif chama isso de tragédia dos comuns, e tem razão: quem precisava do recurso ficou com o benefício, e todos os outros ficaram só com o bug.

Segunda tentativa fracassada: "A escrita é restrita demais para ser explorada"

O segundo modelo falho veio de pessoas que leram os detalhes técnicos e relaxaram. Uma sobrescrita de valor constante, em offset fixo, sem controle sobre os bytes escritos? Muitos bugs assim são classificados como "apenas crash" e despriorizados. Essa dispensa é compreensível e errada, e o motivo de estar errada é a parte mais instrutiva de todo esse episódio.

Exploração moderna não é sobre o que uma única primitiva consegue fazer; é sobre o que o sistema ao redor pode ser convencido a organizar em torno dela. A técnica da Calif foi o heap grooming: moldar remotamente o comportamento do alocador para que um objeto previsível e útil caia logo atrás do buffer estourado. Eles fizeram isso pela rede, usando o timing das requisições para controlar quando alocações e liberações acontecem no alvo. A escrita pode ter valor constante, mas se você controla qual objeto está no raio de explosão, controla o que será corrompido. A partir daí, construíram um vazamento de memória no estilo Heartbleed, vazaram o suficiente para derrotar o ASLR e encadearam tudo até uma execução remota de código completa.

Grade urbana abstrata de blocos de memória organizados em um padrão deliberado, com um bloco vermelho no centro
O heap grooming transforma uma escrita restrita e de valor constante em arma, controlando onde a escrita cai.

Há um detalhe deliciosamente pragmático enterrado no relatório sobre como fazer isso funcionar na internet real. O heap grooming remoto é sensível ao round-trip time e ao jitter: você precisa que as requisições cheguem num ritmo específico para que o alocador esteja no estado desejado. Em vez de fazer engenharia reversa da pilha TCP, os pesquisadores alugaram uma VM na mesma região de nuvem do alvo. Resolveram um problema de física com dinheiro. Vejo desenvolvedores de exploit de elite fazerem versões disso há anos, e é um bom lembrete de que as restrições do atacante são econômicas tanto quanto técnicas. Um adversário bem financiado trata o jitter da rede como uma linha no orçamento.

Vale notar também: não existe exploit universal. Cada aplicação (Jira, Jenkins, Keycloak) usa Base64 de um jeito diferente, aloca de forma diferente e expõe superfícies de grooming diferentes. Essa é a boa notícia. A má é a amplitude de pontos de entrada. Headers de autenticação, campos de upload de arquivo, tratamento de certificados de cliente, payloads de mensagens: qualquer lugar onde texto Base64 cruza para dentro da JVM é um gatilho potencial. Um contribuidor chegou a demonstrar uma variante do lado do cliente: uma aplicação Java que abre uma conexão TLS com um servidor malicioso pode ser comprometida sem expor nenhum serviço. Seus jobs em batch e ferramentas internas estão no escopo, não só seus gateways expostos à internet.

O centauro na sala: IA encontrou isso em uma hora

Agora a parte que deveria recalibrar o modelo de ameaças de toda equipe de segurança. O pesquisador Quang Luong encontrou a vulnerabilidade em cerca de uma hora e tinha um exploit funcionando aproximadamente duas horas depois. Custo total em tokens de IA: menos de US$ 200. O método dele foi apontar um agente de programação com IA para as áreas do HotSpot onde a complexidade cruza fronteiras (o JIT, os intrínsecos, APIs amplamente acessíveis, criptografia) e depois filtrar o ruído. A maior parte do que o agente apontou era lixo inalcançável. Ele continuou insistindo, e vinte minutos de persistência depois, apareceu o achado do Base64.

A Calif chama isso de "hacker centauro": o humano fornece a intuição sobre onde sistemas complexos falham, a IA fornece a resistência. Acho que é uma descrição precisa, e acho que as implicações vão nos dois sentidos. O mesmo ciclo que encontrou o Java4Shell está disponível para qualquer pessoa com uma chave de API, e a fase de desenvolvimento de exploit (construir pipelines de grooming reutilizáveis e depois deixar agentes gerarem cadeias específicas para cada aplicação) está cada vez mais automatizável. A economia de encontrar bugs em C e assembly maduros e amplamente implantados simplesmente desabou. Defensores devem presumir que a próxima dúzia de bugs da classe Java4Shell já está sendo procurada, por gente que não envia divulgações. Essa é a pressão por trás de debates como os prazos cada vez menores de divulgação do Project Zero: quando descobrir vulnerabilidades fica barato, a janela de correção é o jogo inteiro.

A contramedida proposta pela Calif é provocativa, e concordo em grande parte: usar a mesma alavancagem de IA para apagar código em vez de adicioná-lo. Eles chamam isso de "vibe-uncoding", ou seja, auditar uma base de código em busca de funcionalidades mortas, suporte a protocolos antigos e otimizações desnecessárias, e depois removê-las para reduzir a superfície de ataque. A objeção honesta é que remover é arriscado: funcionalidades aparentemente não usadas têm dependentes escondidos, e a remoção exige testes que as equipes sistematicamente subfinanciam. Mas a direção está certa. Se seu JDK traz um caminho rápido em assembly feito à mão para uma carga de trabalho que você nunca vai ter, a postura de segurança ideal é simplesmente não enviar esse caminho. Na falta disso, a JVM pelo menos oferece uma chave para desligá-lo. O que nos leva ao que realmente funciona.

O que realmente funciona: corrigir, desligar, usar proxy

Aqui está a parte que interessa à sua escala de plantão. As correções se dividem em três níveis, e eu defenderia que você faça pelo menos duas delas hoje, e não depois da próxima janela de mudança.

  1. Atualize para uma build corrigida do OpenJDK. A correção upstream (commit 5177a70 do JDK) corrige o cálculo da máscara. Esta é a única correção completa. As versões afetadas começam na 17.0.6 na linha 17 e seguem até as versões atuais da 21 e posteriores; consulte a lista de versões corrigidas para sua linha específica e trate toda JVM HotSpot (OpenJDK, Oracle JDK, GraalVM) como em escopo até verificação em contrário.
  2. Desative o intrínseco como controle provisório. Inicie a JVM com -XX:-UseBASE64Intrinsics para desligar por completo a aceleração de Base64 por hardware. O custo de desempenho é insignificante, a menos que você decodifique gigabytes de Base64, o que quase ninguém faz. Alternativamente, -XX:UseAVX=2 desabilita o AVX-512 em x86-64, mas não defina essa flag em ARM, onde a JVM se recusará a iniciar. Essa é a mesma filosofia do playbook de CVEs do PHP: quando o componente vulnerável é um caminho rápido estreito e substituível, matar o caminho rápido vence esperar.
  3. Use seus proxies para quebrar o timing do exploit. A seção de limitações da própria Calif observa que os perfis atuais de grooming remoto dependem de corpos de requisição parciais chegando à aplicação com timing preciso. Um proxy reverso que armazena o corpo completo da requisição, o que o nginx faz por padrão, destrói esse timing. Não é uma correção de jeito nenhum, mas degrada significativamente o caminho de ataque mais prático enquanto você aplica o patch.

A detecção merece uma frase também. A Semgrep publicou scripts gratuitos que verificam a combinação de condições que tornam um host explorável: uma VM da família HotSpot, hardware x86-64 com o suporte às instruções relevantes e uma versão na faixa afetada. Rode isso na sua frota antes de presumir que está exposto. Seus contêineres baseados em ARM e os resquícios de OpenJ9 estão bem, e saber disso rapidamente economiza um fim de semana. Ao escanear, lembre-se de que as linhas de versão importam: a correção saiu em releases de patch específicas por linha, então "estamos na 21" não é uma resposta.

Três camadas defensivas concêntricas protegendo um núcleo brilhante, com uma mão acionando uma chave no anel mais interno
Monte camadas de defesa: corrija no núcleo, desligue o caminho rápido e deixe o proxy quebrar o timing do atacante.

A lição maior: otimizações são passivos que você não auditou

Afastando-se da resposta a incidentes, o Java4Shell deixa um resíduo desconfortável. O bug não estava em algum canto obscuro. Estava no Base64, provavelmente a operação mais entediante, mais onipresente e mais "com certeza isso já está ok" da computação. A vulnerabilidade existiu justamente porque alguém tornou a coisa entediante rápida, usando as instruções vetoriais mais novas, em assembly, com um caso de borda no tratamento do final da entrada que sobreviveu à revisão de código. Todo runtime maduro está cheio disso. E cada um desses casos está agora sendo caçado por agentes incansáveis que custam menos que um bom jantar.

Todo mundo pergunta o que a IA consegue construir. A pergunta de segurança melhor talvez seja o que ela pode nos ajudar a apagar.

Minha opinião: a indústria está prestes a aprender a diferença entre código auditado e código presumido seguro, e a lição vai custar caro. Bibliotecas padrão, intrínsecos de VM, codecs de compressão, decodificadores de imagem: as camadas fundamentais que nunca questionamos são exatamente onde a atenção humana é mais escassa e onde a caça assistida por IA paga as maiores recompensas. O modelo centauro não apenas encontra bugs mais rápido; ele os encontra em lugares que pesquisadores humanos pularam porque o valor esperado de auditar código "resolvido" parecia baixo demais.

Então atualize suas JVMs, ligue a flag do intrínseco onde não puder atualizar, e deixe o nginx te comprar tempo. Mas também vá olhar sua própria árvore de dependências e faça a pergunta do uncoding: quais dessas funcionalidades você herdou em vez de escolher? A string de 65 caracteres que vai queimar seu fim de semana provavelmente já foi escrita. A única questão é se quem a tem vai enviar uma divulgação ou não.