Bug Bounty 2026-05-15 @reeshasx

WAF_EVASION_LOGS: Bypassing Enterprise Filters on High-Value Targets

[ 0x00 ] O MITO DA CAIXA INVIOLÁVEL

Todo mundo acha que empresas grandes têm defesas perfeitas. Quando você esbarra num WAF (Web Application Firewall) da Akamai, Cloudflare Enterprise ou Imperva num alvo gigante (como foi o caso da Coinbase que eu reportei), a tela de 403 Forbidden parece uma parede de concreto.

Mas o lance é o seguinte: WAFs não são mágicos. Eles são gigantescas coleções de Regex (expressões regulares) tentando entender tráfego web na força bruta. E se tem uma coisa que aprendi caçando bugs, é que onde tem parsing complexo, tem confusão.

[ 0x01 ] DESYNC: QUEM ESTÁ LENDO O QUÊ?

A chave para o bypass é causar uma dessincronização entre o que o WAF entende e o que o servidor Backend (a aplicação real) entende. O WAF bloqueia a palavra UNION SELECT. Mas e se você mandar U%6eION S%45LECT? - Se o WAF decodificar a URL apenas uma vez antes de validar, ele vê o texto com porcentagem e deixa passar. - Se a aplicação no backend decodificar uma segunda vez antes de executar no banco, o payload vira UNION SELECT novamente. - Boom. Bypass clássico de double-encoding.

[ 0x02 ] POLUIÇÃO DE PARÂMETROS (HPP)

Um dos meus favoritos. O que acontece se você enviar dois parâmetros com o mesmo nome na URL? GET /api/user?id=1&id=UNION SELECT...

A tecnologia A (ex: PHP) pega apenas o último valor.
A tecnologia B (ex: JSP/Tomcat) pega o primeiro valor.
A tecnologia C (ex: ASP.NET) concatena os dois.

Se o WAF for configurado para validar apenas o primeiro parâmetro, mas a aplicação em Node.js ler o último, o WAF vai validar o id=1 (que é seguro) e ignorar o payload venenoso no final. O backend, inocente, vai engolir o SQLi. É como passar com o contrabando por trás das costas do segurança.

[ 0x03 ] O CASO OPENRESTY

Num dos meus achados de recompensa (Bug Bounty), eu esbarrei num WAF bem parrudo. Toda tentativa direta de LFI ou XSS era sumariamente assassinada.

Comecei a fuzilar headers exóticos HTTP na requisição. X-Forwarded-Host, X-Rewrite-URL, Client-IP. A maioria dos WAFs são configurados para processar a URI original, mas os proxies reversos no meio do caminho podem alterar a requisição com base nesses headers se estiverem mal configurados.

Ao injetar um payload ofuscado num cabeçalho de proxy mal normalizado, consegui fazer o load balancer interno me cuspir não a página padrão de erro do WAF, mas sim uma página de debug do OpenResty. Eu expus a versão exata do proxy deles e as regras de roteamento internas simplesmente porque o filtro não cobria a combinação exata de caracteres unicode num header não-padrão.

[ 0x04 ] MINDSET DE CAÇADOR

Bypass de WAF raramente é usar ferramentas automatizadas como o sqlmap --tamper. Isso faz barulho e te dá um block de IP rápido.

Bypass é arte analítica. É bater na porta com uma letra minúscula, depois maiúscula, depois com espaço, depois com %00 (null byte), e ver como a resposta muda. É fazer o parser do WAF desistir por timeout ou confusão e deixar o pacote passar pro backend.

[ 0x05 ] TRANSFER-ENCODING: CHUNKED

Se você quer confundir WAFs antigos, essa é clássica. Quando enviamos dados HTTP via POST, geralmente dizemos o tamanho total no Content-Length. Mas o HTTP/1.1 permite enviar em "pedaços" usando o cabeçalho Transfer-Encoding: chunked. A mágica aqui é que muitos WAFs têm um limite de quantos "chunks" eles vão analisar antes de desistir (para economizar CPU).

Se você enviar:

POST /api/upload HTTP/1.1
Transfer-Encoding: chunked

1
<
1
s
1
c
1
r
...

O backend vai montar a string <script>... pedaço por pedaço e executar o XSS no banco, enquanto o WAF corporativo talvez não tenha re-montado o payload corretamente, olhando para blocos isolados inofensivos.

[ 0x06 ] NORMALIZAÇÃO UNICODE

Outro vetor assustador são os caracteres unicode que "se parecem" visualmente com letras, mas têm códigos hexadecimais diferentes. No padrão Unicode, a letra K (Kelvin) K não é a letra K maiúscula normal K.

O WAF olha para SELECKT e diz: "Isso não é um comando SQL, bloqueio não necessário." Mas quando isso entra no backend (um banco MySQL com charset utf8mb4 mal configurado, por exemplo), a engine do banco realiza a "normalização". Ela converte K para o clássico K maiúsculo. De repente, seu pacote inofensivo vira um SELECT monstruoso extraindo senhas.

Dica de Ouro: Caçar falhas em filtros não é sobre encontrar o payload mais complexo do Github. É entender perfeitamente a cadeia de tecnologias (Load Balancer -> WAF -> Proxy -> Backend -> Database) e achar onde a conversão de dados difere. A defesa corporativa é focada em padrões conhecidos. Seja o padrão desconhecido e o WAF se tornará cego.

[ 0x00 ] THE MYTH OF THE IMPENETRABLE BOX

Everyone thinks big companies have perfect defenses. When you bump into a WAF (Web Application Firewall) from Akamai, Cloudflare Enterprise, or Imperva on a giant target (like in the Coinbase case I reported), that 403 Forbidden screen feels like a concrete wall.

But here's the thing: WAFs aren't magical. They are massive collections of Regex (regular expressions) brute-forcing their way into understanding web traffic. And if there's one thing I've learned hunting bugs, it's that where there is complex parsing, there is confusion.

[ 0x01 ] DESYNC: WHO IS READING WHAT?

The key to bypassing is causing a desynchronization between what the WAF understands and what the Backend server (the actual application) understands. The WAF blocks the word UNION SELECT. But what if you send U%6eION S%45LECT? - If the WAF decodes the URL only once before validating, it sees the percent-encoded text and lets it pass. - If the backend application decodes it a second time before executing it on the database, the payload turns back into UNION SELECT. - Boom. Classic double-encoding bypass.

[ 0x02 ] HTTP PARAMETER POLLUTION (HPP)

One of my favorites. What happens if you send two parameters with the same name in the URL? GET /api/user?id=1&id=UNION SELECT...

Technology A (e.g., PHP) takes only the last value.
Technology B (e.g., JSP/Tomcat) takes the first value.
Technology C (e.g., ASP.NET) concatenates them.

If the WAF is configured to only validate the first parameter, but the Node.js application reads the last one, the WAF will validate id=1 (which is safe) and ignore the poisonous payload at the end. The innocent backend will swallow the SQLi. It's like sneaking contraband right behind the security guard's back.

[ 0x03 ] THE OPENRESTY CASE

During one of my bounty hunts, I hit a really tough WAF. Every direct attempt at LFI or XSS was summarily assassinated.

I started shotgunning exotic HTTP headers into the request. X-Forwarded-Host, X-Rewrite-URL, Client-IP. Most WAFs are configured to process the original URI, but reverse proxies along the way might alter the request based on these headers if they are misconfigured.

By injecting an obfuscated payload into a poorly normalized proxy header, I managed to make the internal load balancer spit out not the standard WAF error page, but a debug page from OpenResty. I exposed their exact proxy version and internal routing rules simply because the filter didn't cover the exact combination of unicode characters in a non-standard header.

[ 0x04 ] HUNTER MINDSET

WAF bypassing is rarely about using automated tools like sqlmap --tamper. That just makes noise and gets your IP blocked fast.

Bypassing is an analytical art. It's knocking on the door with a lowercase letter, then uppercase, then with a space, then with a %00 (null byte), and watching how the response changes. It's about making the WAF parser give up due to timeout or confusion and letting the packet slip through to the backend.

[ 0x05 ] TRANSFER-ENCODING: CHUNKED

If you want to confuse older WAFs, this is a classic. When sending HTTP POST data, we usually state the total size in Content-Length. But HTTP/1.1 allows sending it in "pieces" using the Transfer-Encoding: chunked header. The magic here is that many WAFs have a limit on how many "chunks" they will analyze before giving up (to save CPU).

If you send:

POST /api/upload HTTP/1.1
Transfer-Encoding: chunked

1
<
1
s
1
c
1
r
...

The backend will reassemble the string <script>... piece by piece and execute the XSS, while the corporate WAF might not have reassembled the payload correctly, looking at isolated, harmless blocks.

[ 0x06 ] UNICODE NORMALIZATION

Another scary vector is unicode characters that visually "look like" letters but have different hex codes. In the Unicode standard, the letter K (Kelvin Sign) K is not the standard uppercase K K.

The WAF looks at SELECKT and says: "This is not an SQL command, blocking unnecessary." But when this hits the backend (a MySQL database with poorly configured utf8mb4 charset, for example), the database engine performs "normalization". It converts K to the classic uppercase K. Suddenly, your harmless packet becomes a monstrous SELECT extracting passwords.

Golden Tip: Hunting flaws in filters isn't about finding the most complex payload on Github. It's about perfectly understanding the technology chain (Load Balancer -> WAF -> Proxy -> Backend -> Database) and finding where the data conversion differs. Corporate defense is focused on known patterns. Be the unknown pattern, and the WAF will become blind.