Shopping cart

Subtotal $0.00

View cartCheckout

Building better devs

TnewsTnews
Segurança

Java4Shell: 65 Caracteres Dão RCE no Seu Servidor Java

Email : 10

Um sinal de igual. 62 bytes corrompidos. Game over.

Você provavelmente já usou java.util.Base64.getDecoder().decode() umas mil vezes na vida. Eu também. É daquelas APIs que você nunca questiona, tipo String.length() ou respirar. Só que ontem, 17 de novembro de 2026, um pesquisador publicou uma das vulnerabilidades mais brutais que eu já vi no ecossistema Java: a Java4Shell (CVE-2026-114938), com score CVSS 4.0 de 9.2 (crítico).

A ideia é simples de explicar e assustadora de entender: uma string Base64 malformada com 65 caracteres causa um out-of-bounds heap write no decoder otimizado do OpenJDK. Isso significa corrupção de memória, leitura arbitrária de heap (tipo um Heartbleed do Java) e, no fim da cadeia, execução remota de código sem autenticação.

Jira, Confluence, Jenkins, Keycloak, Kafka, Elasticsearch. Se você roda qualquer um desses em produção num Intel Xeon ou AMD EPYC recente, seu servidor está vulnerável agora. Não amanhã, não “quando o atacante descobrir”. Agora.

O que é a Java4Shell, tecnicamente?

O nome é uma referência direta à Log4Shell de 2021, e por bons motivos. Assim como a Log4Shell explorava um componente ubíquo (logging), a Java4Shell ataca algo que todo sistema Java usa: decodificação Base64.

O CVE-2026-114938 é uma falha de corrupção de memória no intrinsic de Base64 do HotSpot JVM, especificamente no código assembly otimizado que usa instruções AVX-512 VBMI. Esse código existe desde o OpenJDK 17.0.6 e foi introduzido como uma otimização de performance para CPUs modernas.

O problema está na forma como o decoder calcula o tamanho do output quando encontra caracteres de padding (=) no final da string. Para uma entrada específica, como 64 caracteres ‘A’ seguidos de um =, o cálculo de comprimento sofre um underflow para valor negativo. Isso transforma o que deveria ser uma escrita pequena e controlada numa escrita completa de 64 bytes, corrompendo 62 bytes além do buffer alocado.

Em termos práticos: o JVM aloca um array de, digamos, 48 bytes para o output. Mas a instrução VMOVDQU8 com a máscara errada escreve 64 bytes. Os 62 bytes extras vão parar em cima de qualquer objeto que estiver adjacente no heap.

Quem está vulnerável (e quem não está)

Aqui vem a parte que complica. A vulnerabilidade não afeta todo mundo que roda Java. Ela depende de dois fatores:

RequisitoDetalhes
Versão do OpenJDK17.0.6 ou superior (incluindo Java 21, 25 e 27)
CPUx86-64 com suporte a AVX-512 VBMI

CPUs vulneráveis

Na Intel: Xeon a partir de Ice Lake (3a geração Xeon Scalable), Sapphire Rapids, Emerald Rapids, Granite Rapids. Na AMD: EPYC e Ryzen a partir do Zen 4.

Se você roda Java em ARM64 (como instâncias AWS Graviton), pode respirar. O código vulnerável simplesmente não existe nessa arquitetura.

Como verificar se seu servidor está vulnerável

# Verifica se a CPU tem as flags necessárias para o código vulnerável
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

Se as quatro flags aparecerem (avx512f, avx512bw, avx512vbmi, bmi2), seu hardware executa o caminho de código vulnerável. Combine isso com um java -version mostrando 17.0.6+ e você tem um problema.

Distribuições afetadas

Não é só o OpenJDK “vanilla”. Todas as distribuições baseadas no mesmo código estão vulneráveis:

  • Oracle Java SE
  • Amazon Corretto
  • Eclipse Temurin
  • Microsoft Build of OpenJDK
  • Azul Zulu
  • BellSoft Liberica
  • SAP SapMachine
  • Red Hat OpenJDK
  • Oracle GraalVM

Basicamente, se é Java e roda em x86-64 moderno: está vulnerável.

A anatomia do exploit: Heap Feng Shui em Java

Corromper 62 bytes no heap parece caótico e incontrolável, certo? É o que todo mundo pensou inicialmente. Mas os pesquisadores mostraram que é possível transformar essa escrita “cega” num exploit confiável usando uma técnica chamada Heap Feng Shui.

A ideia é manipular o layout de alocação do heap para garantir que objetos específicos fiquem adjacentes ao buffer de Base64. O ataque funciona em três estágios:

Estágio 1: Writer (escrita controlada)

O atacante aloca um grande número de arrays de bytes com tamanhos cuidadosamente escolhidos. Depois libera alguns deles de forma estratégica, criando “buracos” no heap. Quando o decoder de Base64 é chamado, o JVM aloca o buffer de output num desses buracos, e a escrita corrompida atinge o header do array adjacente, especificamente o campo de length.

Resultado: um array que o JVM acha que tem, digamos, 2 bilhões de elementos, quando na verdade tem 64 bytes. Isso dá ao atacante uma primitiva de escrita arbitrária limitada.

Estágio 2: Reader (JavaBleed)

Com o array corrompido, o atacante lê além dos limites reais do objeto, vazando o conteúdo do heap. Os pesquisadores batizaram essa primitiva de JavaBleed, numa referência ao Heartbleed. Isso permite descobrir endereços de memória, ponteiros de objetos e metadados internos do JVM.

Estágio 3: Code Cache RCE

Combinando escrita arbitrária com vazamento de informações, o atacante localiza e modifica o Code Cache do JIT compiler. Essa região contém código nativo compilado pelo JVM. Sobrescrever instruções nessa área equivale a injetar shellcode. Na próxima vez que o método compilado for chamado, o código do atacante executa.

Tudo isso sem autenticação. Sem credenciais. Só uma string Base64 malformada chegando no lugar certo.

Aplicações afetadas: a lista dá medo

Os pesquisadores categorizaram as aplicações vulneráveis em dois grupos:

RCE pré-autenticação (sem credenciais)

Essas aplicações processam Base64 de fontes externas antes de qualquer login:

  • Keycloak: tokens JWT, certificados X.509, SAML assertions
  • Atlassian Jira: headers de autenticação, anexos
  • Atlassian Confluence: mesmos vetores do Jira
  • JFrog Artifactory: uploads de artefatos, headers de API
  • Jenkins: autenticação via API, uploads de plugins
  • PingFederate: tokens SAML e OAuth
  • Apache Tomcat: qualquer servlet que processe Base64 de input externo
  • Spring Boot: aplicações que decodificam Base64 em endpoints públicos
  • Apache Struts: processamento de formulários e headers

RCE pós-autenticação

Requerem credenciais válidas, mas ainda assim perigosas em ambientes com múltiplos usuários:

  • Apache Kafka: mensagens com payload Base64
  • Apache Solr: indexação de documentos
  • Elasticsearch: ingestão de dados
  • Gerrit: code review com uploads
  • Netflix Spinnaker: pipelines de deploy

Se você roda um stack Java empresarial, a probabilidade de pelo menos uma dessas estar no seu ambiente é praticamente 100%.

Por que WAFs não vão te salvar

Primeira reação de muita gente: “beleza, vou colocar uma regra no WAF pra bloquear Base64 malformado”. Boa sorte com isso.

O problema fundamental é que a vulnerabilidade está no OpenJDK em si, não numa biblioteca ou framework específico. Qualquer caminho de código que eventualmente chame java.util.Base64.getDecoder().decode() com input externo pode ser um vetor de ataque.

Pense em quantos lugares uma aplicação Java processa Base64:

  • Headers HTTP (Authorization: Basic ...)
  • Cookies
  • Tokens JWT
  • Certificados TLS
  • Uploads de arquivos
  • Payloads de API (JSON com campos binários)
  • Mensagens de filas (Kafka, RabbitMQ)
  • Configurações (Spring Cloud Config)

Criar regras de WAF para todos esses vetores é inviável. E o pior: a string maliciosa tem apenas 65 caracteres. É pequena demais para heurísticas de tamanho, e parece Base64 legítimo para qualquer validação de formato.

Como se proteger agora

Opção 1: Atualizar o JDK (ideal)

A Oracle e as distribuições lançaram patches em 17 de novembro de 2026. Atualize para as versões corrigidas:

# Verifica sua versão atual
java -version

# Para ambientes com SDKMAN
sdk install java 17.0.22-tem
sdk install java 21.0.14-tem

# Para containers Docker
# Atualize a base image no Dockerfile
FROM eclipse-temurin:17.0.22_7-jre-jammy

Opção 2: Desabilitar o intrinsic (workaround imediato)

Se você não consegue atualizar agora, adicione uma flag na JVM:

# Desabilita o código assembly vulnerável do Base64
java -XX:-UseBASE64Intrinsics -jar sua-aplicacao.jar

# Alternativa: limita AVX para versão 2 (sem AVX-512)
java -XX:UseAVX=2 -jar sua-aplicacao.jar

Essas flags fazem o JVM usar o decoder de Base64 em Java puro, que é mais lento mas não tem o bug. O impacto de performance é pequeno para a maioria das aplicações. Base64 decoding raramente é o gargalo.

Para Kubernetes e containers

# No deployment, adicione a flag como variável de ambiente
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
      - name: app
        env:
        - name: JAVA_OPTS
          value: "-XX:-UseBASE64Intrinsics"

Opção 3: Isolar aplicações expostas

Se patches e flags não são viáveis imediatamente, tire do ar as interfaces públicas das aplicações mais críticas (Jenkins, Jira, Keycloak) ou coloque-as atrás de VPN.

Java4Shell vs Log4Shell: comparação inevitável

Todo mundo está comparando, então vamos ser honestos sobre as diferenças:

AspectoLog4Shell (2021)Java4Shell (2026)
CVECVE-2021-44228CVE-2026-114938
CVSS10.09.2
Componentelog4j (biblioteca)OpenJDK (runtime)
Requisito de hardwareNenhumAVX-512 VBMI (x86-64)
ExploraçãoTrivial (uma string)Complexa (Heap Feng Shui)
UniversalidadeQualquer app com log4jApenas JDK 17.0.6+ em CPUs modernas
Mitigação rápidaRemover/atualizar libFlag da JVM

A Java4Shell é menos universal (precisa de hardware específico) e mais difícil de explorar (requer manipulação precisa do heap). Por outro lado, está num nível mais baixo do stack: não é uma biblioteca que você pode trocar, é o próprio runtime.

A boa notícia é que a mitigação é simples: uma flag e pronto. A Log4Shell exigia caçar todas as instâncias de log4j em todas as dependências transitivas, o que era um pesadelo.

O elefante na sala: IA acelerando exploits

Um detalhe que os pesquisadores mencionaram de passagem, mas que merece destaque: a técnica de Heap Feng Shui usada no exploit pode ser assistida por modelos de IA para adaptar o ataque a diferentes aplicações.

Tradicionalmente, exploits de corrupção de memória em Java eram considerados impraticáveis porque o layout do heap é não-determinístico. Mas com IA analisando padrões de alocação e sugerindo sequências de operações para posicionar objetos no heap, a barreira de entrada caiu.

Isso é preocupante porque muda a equação de risco. Uma vulnerabilidade que “ninguém conseguiria explorar na prática” em 2021 pode ter exploit funcional em semanas em 2026, com assistência de modelos de linguagem.

O que fazer nas próximas 24 horas

Se você é SRE, DevOps ou qualquer pessoa responsável por infraestrutura Java:

  1. Inventário: liste todas as aplicações Java em produção e suas versões de JDK
  2. Hardware check: rode o comando de verificação de CPU em todos os servidores
  3. Flag imediata: adicione -XX:-UseBASE64Intrinsics em toda JVM vulnerável
  4. Plano de patch: agende atualização do JDK para a versão corrigida
  5. Monitore: fique de olho nos logs de acesso para padrões suspeitos de Base64

A Oracle e todas as distribuições já liberaram patches. O fix é pequeno e focado. Não tem desculpa para não aplicar.

O problema real não é o bug, é a confiança cega

Eu fico pensando em quantas vezes eu usei Base64.getDecoder().decode() sem nem cogitar que aquilo poderia ser um vetor de ataque. Era código “seguro por definição”, parte do runtime, testado por milhões de desenvolvedores.

Só que otimizações em assembly são escritas por humanos, e humanos erram cálculos de máscara. A ironia é que o bug existe justamente por causa de uma otimização de performance: se o decoder usasse Java puro, a vulnerabilidade não existiria. Fizemos o código mais rápido e, sem querer, abrimos uma porta para RCE.

Isso levanta uma questão que não tem resposta fácil: até que ponto devemos confiar em otimizações de baixo nível em runtimes gerenciados? O Java foi projetado exatamente para evitar esse tipo de problema. Garbage collector, bounds checking, type safety. Tudo isso deveria proteger contra corrupção de memória. Mas quando você desce para assembly com AVX-512 pra ganhar uns nanossegundos, você abre mão exatamente dessas garantias.

A próxima vez que alguém falar que “Java é seguro contra buffer overflow”, mostra a CVE-2026-114938. E depois aplica o patch, porque o seu Jenkins provavelmente está esperando.


Fonte de inspiração: Java4Shell: Write once, RCE everywhere

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts