HTTP Smuggling labs
HTTP Request Smuggling
What is HTTP Smuggling?
HTTP Request Smuggling exploits the desync between the front-end (proxy/CDN) and the back-end when interpreting where a request ends. By smuggling a prefix into the server's buffer, you poison the request queue, steal other users' requests, bypass front-end controls and poison the cache.
Why practice HTTP Smuggling?
Smuggling is one of the highest-impact, lowest-competition techniques: hardly anyone masters it because it requires understanding the byte-by-byte flow between proxies and origin. A well-built desyncer takes down the entire edge security (WAF, front-end auth) and steals sessions. Typical bounties: $5,000-$30,000.
What will you learn with the HTTP Smuggling labs?
You'll learn to detect the desync by behavior difference and by timing, tell CL.TE apart from TE.CL, build the prefix that poisons the queue, capture other people's requests with their cookie, chain smuggling with cache poisoning, and automate with Burp's HTTP Request Smuggler extension.
Types of HTTP Smuggling we cover
- CL.TE
The front-end uses Content-Length and the back-end Transfer-Encoding. The chunk the front-end considers 'extra' stays in the buffer and is prepended to the next request.
- TE.CL
The front-end uses Transfer-Encoding and the back-end Content-Length. The chunked part the back-end ignores poisons the request queue.
- TE.TE
Both ends support Transfer-Encoding, but the header is obfuscated (Transfer-Encoding: xchunked) so one ignores it and the desync reappears.
- HTTP/2 downgrade
An HTTP/2 front-end rewrites to HTTP/1.1 toward the origin; injecting CRLF in pseudo-headers or values (h2c smuggling) reintroduces classic smuggling over HTTP/2.
- Request tunnelling
Tunnel your own request inside another to read internal responses or bypass front-end controls, even without a full queue desync.
How do you find and exploit HTTP Smuggling?
A practical playbook — from recon to proof of concept.
- 1
Differential and timing detection
Send an ambiguous request with both Content-Length and Transfer-Encoding and an incomplete chunk. If the back-end hangs waiting for bytes that never come, there's a desync.
Transfer-Encoding: chunked\r\nContent-Length: 4\r\n\r\n1\r\nA\r\nX → timeout = smuggling likely - 2
Confirm the variant
Send a request that only poisons under one of the two interpretations to tell CL.TE from TE.CL without false positives.
CL.TE: body `0\r\n\r\nGET /404 HTTP/1.1\r\nX: ` → if the next request gets a 404, it's CL.TE - 3
Poison the request queue
Leave your malicious prefix in the back-end's buffer so it's prepended to the next user's request arriving over that connection.
smuggled prefix: GET /admin HTTP/1.1\r\nHost: target\r\nFoo: (waits for the rest of the victim's request) - 4
Steal other users' requests
Make the prefix capture the victim's full request (with their session cookie) and reflect it in a resource you can read.
Smuggle → POST /comment with the victim's request as the body → you read their Cookie in the comment - 5
Cache poisoning via smuggling
Combine the desync with a cacheable response so the cache stores your content and serves it to all users.
Desync so the /static/main.js response is a 302 to evil.com → cached for everyone - 6
Automate with HTTP Request Smuggler
Use Burp's extension (James Kettle, PortSwigger) to scan, confirm the variant and generate the PoC with Turbo Intruder without hand-crafting the CRLFs.
Burp → Extensions → HTTP Request Smuggler → 'Smuggle probe' / 'Launch smuggle attack'
Learn the theory
Academy: Advanced Techniques
Loading labs...
View in full catalog →Frequently asked questions
What is HTTP Request Smuggling?
It's a technique that exploits the fact that the front-end (proxy, CDN, load balancer) and the back-end interpret where an HTTP request ends differently. That discrepancy lets you smuggle a prefix into the server's buffer and poison the next user's request.
How is HTTP Request Smuggling exploited?
You send a request with contradictory Content-Length and Transfer-Encoding (or abusing an HTTP/2 downgrade) so one end processes more or fewer bytes than the other. The leftover stays in the queue and is prepended to the next user's request, letting you steal their data, bypass the WAF or poison the cache.
How do you find HTTP Request Smuggling in bug bounty?
Try requests with ambiguous CL/TE headers and measure timing: a back-end hang gives away the desync. Confirm the variant (CL.TE vs TE.CL) with a prefix that triggers a 404 on the next request and automate with Burp's HTTP Request Smuggler extension. There's a full guide at /blog/http-request-smuggling-espanol.
How do you prevent HTTP Request Smuggling?
Normalize and reject ambiguous requests (Content-Length + Transfer-Encoding together), use HTTP/2 end-to-end without downgrade to HTTP/1.1, configure the front-end to close connections on malformed headers, and keep front-end and back-end on the same parser.
Difference between CL.TE and TE.CL?
In CL.TE the front-end respects Content-Length and the back-end Transfer-Encoding, so the back-end 'sees' an extra chunk after the body. In TE.CL it's the reverse: the front-end uses chunked and the back-end Content-Length, leaving the chunked part the back-end ignores in the queue. It changes which end desyncs and, therefore, how the payload is built.
Other related categories
- hunters training
- 650
- labs from real reports
- 50
- completions
- 380
- in bounties practiced
- $200,000
hunters training
labs from real reports
completions
in bounties practiced
Practice HTTP Smuggling in real labs
Every HTTP Smuggling lab replicates a real bug bounty report that got paid. Create your free account, start with the Academy and move to the labs whenever you want.
No card · free Academy · cancel anytime