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.
🐣 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.Base64num 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 pordemo/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).
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).
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 deadmin/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.
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. = 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.
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).
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.
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.
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 (Suricatahttp.uri, ModSecARGS, AWS/Cloudflare comURL_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=/=(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ãogetDecoder(Basic) egetUrlDecoder(confirmado em lab). - Nenhuma regra de rede substitui corrigir o JDK.
- 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:
IllegalArgumentExceptionrepetida doBase64$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.
- 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.) - Interino:
-XX:-UseBASE64Intrinsics(desliga só o intrínseco) ou-XX:UseAVX=2(só x86-64; quebra a JVM em ARM). Ambos verificados acima. - Não use
-XX:DisableIntrinsic=_base64_decodeBlocksozinho (a JVM não inicia). - Defense-in-depth na borda/aplicação (enquanto não corrige): regra de WAF/proxy em
regras/e o Servlet Filter emmitigacao/— este último roda dentro da JVM: fecha a evasão%3D(o container URL-decodifica query/form), mas não decodifica=/\u003dde corpos XML/JSON — esses chegam ao parser downstream (use a flag de JVM p/ eles).
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 emAlert→Alert & Deny: bloqueio 403 na borda demonstrado viacurl; 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 inerte200 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).
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):
testes/validar.py— teste unitário canônico de FN + FP (Python puro, sem Docker).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).mitigacao/test/run.sh— compila o Servlet Filter contra stubsjakarta.servletinline e roda 13 cenários (só JDK, sem Docker).testes/per-engine/run.sh— matriz por engine: as 43 regexes nos motores reais (re2/pcre2/yara; a regra Elastic é casada comfullmatch, fiel à semântica term-anchored do Lucene).testes/per-engine/load_check.sh— as regras enviadas carregam no engine real (YARA/nginx/Suricata).testes/fp-replay/run.sh— replay de ~108k strings benignas, 0 falsos positivos.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).
- 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.