Skip to content

About

Java4Shell (CVE-2026-114938): kit de deteccao e prevencao defensiva, multi-engine. Seguranca Descomplicada.

Topics

Resources

Contributing

Security policy

Stars

6 stars

Watchers

0 watching

Forks

Repository files navigation

Detect4Shell — Segurança Descomplicada · CVE-2026-114938

Detect4Shell

Detecção e avaliação de exposição ao Java4Shell (CVE-2026-114938) — Segurança Descomplicada. Ferramenta defensiva para a comunidade: ajuda times a identificar se estão expostos, detectar tentativas e prevenir na borda — com instruções simples, passo a passo.

CI CVE Licença Escopo Engines Versão

🐣 Nunca ouviu falar? Comece aqui: docs/EXPLICACAO-SIMPLES.md — o ataque explicado como para alguém de 10 anos (o que é, como funciona, implicações, e onde achar na sua organização). 5 minutos. É hype ou é real? Estou vulnerável? → docs/FAQ.md.

Aviso de escopo. Projeto só defensivo: sem exploit e sem cadeia weaponizada (writer/reader/JavaBleed/RCE) — o primitivo de corrupção nunca vira leitura/escrita útil nem execução; onde o gatilho roda, a escrita OOB fica dentro de um array do próprio programa, que a ferramenta apenas mede. O gatilho de corrupção de memória roda em dois sítios confinados: (1) a reprodução de lab local e offline (laboratorio/Base64Trigger.java — java.util.Base64 num array do próprio programa), só para validar a detecção e verificar patch; e (2) o alvo de demo (demo/alvo/, um servidor Java deliberadamente vulnerável que mede a escrita OOB no seu próprio processo), exercitado pelo Console de Ataque (demo/console/) e por demo/atacar.sh — que por padrão só disparam contra loopback, exigindo opt-in explícito (--allow-remote / D4S_ALLOW_REMOTE=1) para qualquer outro host, e só em rede isolada e autorizada. Nunca exponha o alvo vulnerável na Internet. Use apenas em sistemas que você está autorizado a testar.

Baseado na divulgação pública e creditando ikow/java4shell-poc (MIT) + o writeup da Calif.io. Mecanismo fundamentado no commit de correção OpenJDK 5177a70b385c (JDK-8393212).


O que é o Java4Shell (em um parágrafo)

Uma string Base64 malformada terminada em = (ex.: 64 chars Base64 + =, ou 128 + = no JDK 17) provoca um underflow de inteiro no intrínseco de decodificação Base64 AVX-512 VBMI do HotSpot: output_size vira -1, o bzhiq com índice 255 não zera bits → máscara toda-em-uns → evmovdqub escreve 62 bytes além de um buffer de 50; a IllegalArgumentException é lançada depois da escrita. Pré-condições: OpenJDK 17.0.6+ / 21 / 25 / 27 (antes da correção .1), CPU x86-64 com AVX-512 VBMI (Intel Ice Lake+ / AMD Zen 4+; ARM é imune), o intrínseco compilado pelo JIT, e o decodificador Basic ou URL (MIME não é afetado).

O que as fontes realmente mostram (honestidade sobre impacto)

Cruzamos 11 fontes públicas (OpenJDK/Oracle, CISA, Calif.io, Amazon ALAS, Blackpoint, Chainguard, Talos, VulnCheck, Wiz, Aikido, The Hacker News) — que em geral ecoam o advisory original, não são 11 confirmações independentes. Consenso:

  • ✅ Reproduzido por nós (lab confinado): escrita OOB de 62 bytes (changed=62 first=50 last=111), consistente com o sintoma do descobridor. ⚠️ O disparo é heap-dependente (100% no padrão fixo do reprodutor, ~0% com arrays frescos — precisa de bytes Base64 válidos logo após o buffer de decode), por isso o crash é probabilístico e uma exploração confiável exige heap grooming. Demonstrado por terceiros (não por nós): crash (DoS) + leak local de heap ("JavaBleed").
  • ⚠️ RCE genérico: alegado, não reproduzido publicamente contra produtos stock. O descobridor publica que o padrão do overflow é fixo e que o caminho ingênuo falha (consistente com o disparo heap-dependente acima — por isso precisa de grooming); os labs independentes só chegaram a crash + leak. ❗ Um pesquisador (Maycon Vitali, cadeia assistida por GLM) demonstrou publicamente um ataque DATA-ONLY num alvo-demo próprio: R/W no heap → flip de admin/sessão → "root". Isso corrobora a exploitabilidade data-only num alvo controlado (com container rodando como root + feature admin de exec), não um RCE nativo não-autenticado genérico. A detecção aqui pega o mesmo gatilho (A×64+"="). Amazon/OpenJDK pontuam como difícil (CVSS 8.1, AC:H).
  • 🚫 Sem exploração in-the-wild; não está na CISA KEV (em 2026-11-18).

Resumo honesto: hoje o risco real é tirar o sistema do ar (e vazar dado — leak local já demonstrado em teste por terceiros). "Hacker assume tudo" (RCE genérico) é possibilidade teórica, não realidade demonstrada. ⚠️ Antes de entrar em pânico: o bug exige x86-64 com AVX-512 VBMI (Ice Lake+ / Zen 4+) — ARM/Graviton e Xeon Skylake/Cascade Lake são imunes, então boa parte das frotas nem está no caminho. E lembre: banner ≠ match de regra ≠ bug são três coisas diferentes (um WAF bloquear não prova que o host era explorável; não bloquear não prova que era seguro). Corrija assim mesmo — derrubar um sistema crítico já é grave.

Validação em laboratório (o que realmente foi executado)

Reproduzido com segurança em container isolado --network none (eclipse-temurin:21.0.13_9-jdk-noble = OpenJDK 21.0.13, sem patch em 2026-11-18) num host AVX-512 VBMI, usando só o gatilho confinado laboratorio/Base64Trigger.java (toda escrita fica dentro de um array de 4096 bytes do próprio programa):

Execução Resultado
build vulnerável + VBMI REPRODUZIDO — rejected=true changed=62 first=50 last=111 (bate com o descobridor, byte-por-byte)
-XX:-UseBASE64Intrinsics NÃO REPRODUZIDO (changed=0) — mitigação confirmada
-XX:UseAVX=2 NÃO REPRODUZIDO (changed=0) — mitigação confirmada

Também mapeamos o que dispara (ground truth em lab, padrão fixo do reprodutor, temurin 21.0.13.0.2): 64 chars Base64 alinhados a quad + 1 OU 2 = — ou seja A×64+"=" E A×64+"==" (128 no JDK 17). Sem-= (A×65/66/67/68) e comprimentos não-alinhados não disparam. ⚠️ Importante: o disparo da escrita é heap-dependente (100% no padrão do reprodutor, ~0% com arrays frescos) — por isso o crash é probabilístico e um exploit confiável faz heap grooming. Aceitar só um = era um bypass (== dispara igual) — corrigido para ={1,2}, validado em edge ao vivo. A regra usa {16,} de propósito (pega 64 e 128) e super-casa comprimentos que podem não disparar (ok para detecção). Outras builds/APIs não foram exaustivamente testadas.

A detecção generalizada (e a prova)

As regras upstream são centradas em Basic auth, em parte por string exata (AAAA…A=), só com o alfabeto padrão e sem cobertura de SAML — trivialmente evadíveis. A detecção do Detect4Shell casa a forma estrutural do gatilho, nos sinks pré-auth onde Keycloak/PingFederate/Jira/Confluence decodificam Base64 (Basic/Bearer/SAML/cookie/param), nos dois alfabetos:

(?<![A-Za-z0-9+/_-])(?:(?:[A-Za-z0-9+/]{4}){16,}+|(?:[A-Za-z0-9_-]{4}){16,}+)={1,2}(?![A-Za-z0-9+/_=-])

≥16 "quads" Base64 (≥64 chars), ancorado ao início do token (lookbehind), + 1 ou 2 = numa fronteira não-Base64 (= e == disparam — aceitar só um era bypassável). O {16,}+ é possessivo (anti-ReDoS). Precisões honestas: o run casado é de alfabeto PURO (padrão +/ ou url-safe _-, nunca misto — o intrínseco usa um só), então não casa strings de alfabeto misturado (menos FP em paths REST); a classe-união [A-Za-z0-9+/_-] fica só nos anchors de fronteira (lookbehind/lookahead). A regra casa a forma contígua no buffer que o sensor inspeciona — veja a nota de evasão abaixo.

Prova (testes/validar.py, só vetores benignos — python -I testes/validar.py):

corretos falsos-positivos
Detect4Shell (referência py) 16/16 0
Detect4Shell (PCRE das regras) 16/16 0
abordagem exata-A/Basic-only 11/16 0

5 FORMAS de gatilho representativas que a abordagem antiga perde e o Detect4Shell pega: SAML no corpo, SAML na query, alfabeto url-safe, valor de cookie, parâmetro de query genérico — os 5 que faltam para a baseline chegar de 11/16 a 16/16. São casamentos de forma representativos de uso real — não crashes executados em cada JDK. (Ambos, a baseline e o Detect4Shell, dão 0 falso-positivo neste conjunto curado; a diferença é só de cobertura de sink/alfabeto.)

Honestidade (pedida pelos revisores cross-vendor): o "16/16" é 9 TP / 7 TN num conjunto curado de 16 vetores — um teste unitário. Medimos também 0 FP em 107.752 strings benignas reais (base64/JWT/data-URI/presigned/paths/SecLists) num corpus de estresse — ver testes/fp-replay/ (limite ~95% ≈ 0,003% pela "regra de 3"; não é amostra de produção). A baseline é a NOSSA reconstrução de uma regra exata-A/Basic (um PoC estreito), não o upstream como enviado — por isso rotulamos "exata-A/Basic-only". A forma pode aparecer em tráfego legítimo malformado (data-URI, URLs pré-assinadas S3, slugs/tokens longos com -_ terminando em =), então um hit de rede único é confiança baixa/média — escale por correlação (veja abaixo).

Engines — detectar e prevenir (11)

Todas as regras partem da mesma forma validada. Índice e padrões canônicos: regras/README.md.

Engine Detecta Previne Arquivo
Suricata / Snort ✅ (drop) regras/suricata/
Sigma → SIEM ✅ — regras/sigma/
ModSecurity v3 ✅ ✅ regras/modsecurity/
nginx (borda) ✅ ✅ regras/nginx/
FortiWeb (WAF) ✅ ✅ regras/fortiweb/ · walkthrough
FortiGate IPS ✅ ✅ regras/fortigate-ips/ · walkthrough
AWS WAFv2 ✅ ✅ regras/cloud-waf/ · walkthrough
Cloudflare WAF ✅ ✅ regras/cloud-waf/
YARA (arquivos/forense) ✅ — regras/yara/
Splunk / Elastic ✅ — regras/siem/
FortiSIEM / FortiAnalyzer ✅ — regras/siem/

Usa Fortinet? Veja o mapa do Fabric: docs/FORTINET-FABRIC.md.

É o controle que a CISA recomenda

A CISA (alerta de 2026-11-17) recomenda, para quem não pode corrigir já: "restricting and validating Base64 input at the application boundary, enforcing input-size limits, and limiting unauthenticated access." As regras WAF/proxy do Detect4Shell (ModSecurity, nginx, FortiWeb, AWS/Cloudflare) são uma implementação aberta desse controle — mas no boundary de REDE, que pode ser evadido por encoding (veja a nota abaixo). O boundary de aplicação de fato exige normalizar/decodificar antes do match (ex.: transforms t:urlDecodeUni/t:jsDecode no ModSec) ou desligar o intrínseco na própria JVM (-XX:-UseBASE64Intrinsics). Nada disso substitui corrigir o JDK.

Nota de evasão — regras de rede operam PRÉ-normalização

As regras casam a forma contígua e literal no buffer. A vuln dispara no sink Base64.decode da JVM, depois do parsing de protocolo/framework. Então há evasões que o WAF/IDS não vê, mas que entregam a forma ao JVM (divulgado abertamente — pedido pelos revisores):

  • = percent-encoded (%3D): engines que decodificam URL (Suricata http.uri, ModSec ARGS, AWS/Cloudflare com URL_DECODE) pegam; buffers brutos usam a variante (?:=…|%3[dD]) — que é mais ampla, não equivalente (não exige pad único). Dupla codificação (%253D) é caso de borda.
  • Escape JSON/XML: \u003d (JSON) e &#61;/&#x3d; (XML/SAML) passam no WAF e chegam decodificados ao parser → Base64.decode. Mitigação: aplique normalização antes do match (ModSec: t:urlDecodeUni,t:jsDecode,t:htmlEntityDecode).
  • Precisão (contra um erro comum): o decoder MIME (getMimeDecoder) NÃO é vulnerável — toma o caminho escalar, não o intrínseco AVX-512. Então "MIME line-wrap" não é evasão contra este bug. Os sinks vulneráveis são getDecoder (Basic) e getUrlDecoder (confirmado em lab).
  • Nenhuma regra de rede substitui corrigir o JDK.

Confiança e falsos-positivos

  • Hit de rede único = confiança baixa/média. Escale por correlação: rajada de aquecimento (dezenas–centenas de milhares de requisições Base64 de uma origem — ~200k p/ o JIT compilar o intrínseco) ou indicador de crash (hs_err_pid / SIGSEGV / StubRoutines / _base64_decodeBlock).
  • Maior confiança de rede: SAML com a cauda malformada (IdP decodifica pré-auth; SAML legítimo é bem-formado).
  • Sinal mais confiável no geral é host: IllegalArgumentException repetida do Base64$Decoder + logs fatais da JVM. Crash não é o único sinal e a ausência de crash não prova segurança (em JDK 21.0.13+G1 houve corrupção sem crash). Endpoints de versão remotos são só CANDIDATO — confirme host-local.

Mitigação (para reportar a donos de ativos)

  1. Atualize para os builds .1 (17.0.21.1 / 21.0.13.1 / 25.0.5.1 / 27.0.1.1; Corretto .1.2; Zulu *.201), reinicie as JVMs, reconstrua containers. (Red Hat / Temurin / Microsoft / Liberica estavam sem fix em 2026-11-18.)
  2. Interino: -XX:-UseBASE64Intrinsics (desliga só o intrínseco) ou -XX:UseAVX=2 (só x86-64; quebra a JVM em ARM). Ambos verificados acima.
  3. Não use -XX:DisableIntrinsic=_base64_decodeBlock sozinho (a JVM não inicia).
  4. Defense-in-depth na borda/aplicação (enquanto não corrige): regra de WAF/proxy em regras/ e o Servlet Filter em mitigacao/ — este último roda dentro da JVM: fecha a evasão %3D (o container URL-decodifica query/form), mas não decodifica &#61;/\u003d de corpos XML/JSON — esses chegam ao parser downstream (use a flag de JVM p/ eles).

Mapa do repositório

  • docs/EXPLICACAO-SIMPLES.md — o ataque para leigos (comece aqui).
  • docs/FAQ.md — perguntas frequentes (é hype? estou vulnerável? o WAF bloqueou = era explorável?).
  • docs/ANALISE.md — análise técnica resumida (mecânica + versões).
  • docs/FORTINET-FABRIC.md — como o Fortinet Fabric cobre, por função.
  • docs/ARTE-PROMPTS.md — kit de prompts de arte + style guide da identidade visual (docs/banner.png é a social-preview exportada daí).
  • regras/ — todas as regras (11 engines) + índice/padrões canônicos.
  • deteccao/ + testes/ — a lógica e a prova.
  • scanner/ — verificador passivo de exposição (1 GET benigno por endpoint).
  • laboratorio/ — reprodução confinada + verificar_patch.sh + matrix/ (matriz CPU×JDK validada: 17/21/25 × VBMI/sem-VBMI × flags/patch).
  • demo/ — ataque vs. defesa ao vivo: alvo Java vulnerável + edge nginx (regra do repo) que bloqueia na borda; passo a passo com os resultados reais. Inclui o Console de Ataque (frontend web que dispara o gatilho e classifica cada rajada em 4 estados: OOB no alvo Java local, bloqueio do WAF na borda, chegou-sem-disparar, ou sem-resposta) e o walkthrough FortiWeb ao vivo (FortiWeb-VM 8.0.8, Custom Signature da forma em Alert→Alert & Deny: bloqueio 403 na borda demonstrado via curl; a escrita OOB verde foi no alvo Java local, não através do WAF).
  • mitigacao/ — mitigação na aplicação: Servlet Filter (dentro da JVM, fecha a evasão %3D) + wiring (web.xml / Spring Boot).
  • honeypot/ — sensor em modo-monitor (nginx detect-only → mock inerte 200 OK): forma implantável para observar scans reais na borda sem expor nada vulnerável. O JVM vulnerável nunca entra no stack (backend inerte por design — alvo vulnerável não vira seguro só em modo-alerta).

Testes & CI

bash test.sh roda o gate de regressão completo localmente (requer Docker + python3). O CI roda o mesmo em todo push/PR e bloqueia em caso de falha. 7 tiers, em ordem (para no primeiro que falhar):

  1. testes/validar.py — teste unitário canônico de FN + FP (Python puro, sem Docker).
  2. testes/canonical_sync.py — drift-guard: a regex canônica byte-idêntica entre a referência e as cópias fora-de-banda (Python puro, sem Docker).
  3. mitigacao/test/run.sh — compila o Servlet Filter contra stubs jakarta.servlet inline e roda 13 cenários (só JDK, sem Docker).
  4. testes/per-engine/run.sh — matriz por engine: as 43 regexes nos motores reais (re2/pcre2/yara; a regra Elastic é casada com fullmatch, fiel à semântica term-anchored do Lucene).
  5. testes/per-engine/load_check.sh — as regras enviadas carregam no engine real (YARA/nginx/Suricata).
  6. testes/fp-replay/run.sh — replay de ~108k strings benignas, 0 falsos positivos.
  7. testes/on-the-wire/run.sh — replay ao vivo: PCAP no Suricata + requisição HTTP no ModSecurity provam que a regra dispara no fio (não só que a regex casa e o arquivo carrega).

laboratorio/matrix/run_matrix.sh (imagens JDK externas que mudam com o tempo) é validação periódica, fora do gate bloqueante (RUN_MATRIX=1 bash test.sh roda só como aviso).

Créditos e licença

  • Pesquisa: Qi Deng / Quang Luong & Jenish Rakholiya (Calif.io). Aviso OpenJDK/Oracle 2026-11-17. Reprodução independente: Upwind, Blackpoint.
  • PoC e regras originais que este projeto aprimora: ikow/java4shell-poc (MIT, © Qi Deng).
  • MIT. Veja LICENSE e NOTICE. A lógica de detecção generalizada, a validação e os docs são contribuições originais; o reprodutor confinado preserva o aviso MIT do upstream.

About

Java4Shell (CVE-2026-114938): kit de deteccao e prevencao defensiva, multi-engine. Seguranca Descomplicada.

Topics

Resources

Contributing

Security policy

Stars

6 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages