hunt-http-smuggling — Claude Code skill: what it does, how to install
hunt-http-smuggling identifies HTTP request desynchronization across front-end proxies and back-end origins. Useful for auditing CDN and load balancer setups.
MIT ★ 16,193 updated 2026-10-29
/plugin marketplace add elementalsouls/Claude-BugHunter
/plugin install claude-bughunter@elementalsoulsWhat hunt-http-smuggling does
This skill outlines assessment procedures for header parsing discrepancies involving Content-Length and Transfer-Encoding (covering CL.TE, TE.CL, H2.CL, and H2.TE). It references dedicated audit utilities such as Burp's HTTP Request Smuggler extension, smuggler.py, and h2csmuggler. Detection procedures rely on timing probes with 30-second delays, alongside checks for cache poisoning and internal route access through authorization bypass.
The skill incorporates a proxy suitability matrix detailing real-world behavior. Proxies enforcing RFC 9112, including Nginx versions 1.21 and newer or Caddy 2.x, return HTTP 400 when encountering conflicting headers, meaning classic CL.TE payloads fail against them. Testing shifts toward HTTP/2 to HTTP/1.1 downgrade discrepancies across CDN-to-origin hops, alongside legacy deployments like older HAProxy or Citrix ADC appliances.
What it helps with
- audit reverse proxy configurations for HTTP/2 downgrade desync
- verify CDN and upstream origin parsing consistency
- identify internal route exposure caused by front-end WAF bypasses
- evaluate edge server compliance with RFC 9112 header rules
Example prompts for the agent
- Audit our reverse proxy setup against the H2.CL desynchronization checklist
- Review whether our current Nginx version blocks conflicting CL and TE headers
- Outline a timing probe strategy for inspecting CDN-to-origin request boundaries
How to install hunt-http-smuggling
1Plugin marketplace
/plugin marketplace add elementalsouls/Claude-BugHunter/plugin install claude-bughunter@elementalsoulsThis installs the whole claude-bughunter plugin with all its skills
2Skills CLI (Vercel)
npx skills add elementalsouls/Claude-BugHunter --skill hunt-http-smuggling -a claude-code3Manually: put the files in place
~/.claude/skills/hunt-http-smuggling/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/hunt-http-smuggling/
1Skills CLI (Vercel)
npx skills add elementalsouls/Claude-BugHunter --skill hunt-http-smuggling -a codex2Manually: put the files in place
.agents/skills/hunt-http-smuggling/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add elementalsouls/Claude-BugHunter --skill hunt-http-smuggling -a cursor2Manually: put the files in place
.cursor/skills/hunt-http-smuggling/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install elementalsouls/Claude-BugHunter skills/hunt-http-smuggling2Manually: put the files in place
.github/skills/hunt-http-smuggling/SKILL.md1Skills CLI (Vercel)
npx skills add elementalsouls/Claude-BugHunter --skill hunt-http-smuggling -a gemini-cli2Platform CLI
gemini skills install https://github.com/elementalsouls/Claude-BugHunter --path skills/hunt-http-smugglingManually: put the files in place
.devin/skills/hunt-http-smuggling/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about hunt-http-smuggling
How to install hunt-http-smuggling in Claude Code?
Run /plugin marketplace add elementalsouls/Claude-BugHunter followed by /plugin install claude-bughunter@elementalsouls.
What does hunt-http-smuggling do?
It guides the review of HTTP parsing discrepancies between front-end reverse proxies and origin back-ends.
Are modern Nginx instances vulnerable to standard CL.TE attacks?
Nginx release 1.21 and newer strictly adheres to RFC 9112, rejecting requests carrying both Content-Length and Transfer-Encoding with an HTTP 400 error.
Source text
SKILL.md · MIT
--- name: hunt-http-smuggling description: "Hunt HTTP request smuggling (CL.TE, TE.CL, H2.CL, H2.TE). Cause: front-end proxy and back-end server disagree on where one request ends and the next begins (Content-Length vs Transfer-Encoding header parsing inconsistency). CL.TE: front-end uses CL, back uses TE → smuggle by sending TE: chunked but with body that fits CL count. TE.CL: opposite. H2.CL: HTTP/2 downgrade, smuggle CL into HTTP/1.1 back-end. Detection tools: Burp HTTP Request Smuggler extension, smuggler.py, h2csmuggler. Confirm: time-delay technique (smuggled GET with 30s timeout) — if front-end returns slow on next victim request, smuggling works. Validate: cache poisoning chain (smuggle request that gets cached for victim), credential theft (smuggle X-Forwarded-For override that captures next user's cookies), bypass auth (smuggled internal-path request). Real paid examples from major CDN deployments. Use when hunting H1 paid programs running CDN+origin stacks, when targeting load balancer / WAF bypass." sources: hackerone_public, cve_database, portswigger_research, public_research report_count: 12 --- ## 17. HTTP REQUEST SMUGGLING > Lowest dup rate. $5K–$30K. PortSwigger research by James Kettle. ### CL.TE (Content-Length front, Transfer-Encoding back) ```http POST / HTTP/1.1 Content-Length: 13 Transfer-Encoding: chunked 0 SMUGGLED ``` ### Detection ``` 1. Burp extension: HTTP Request Smuggler 2. Right-click request → Extensions → HTTP Request Smuggler → Smuggle probe 3. Manual timing: CL.TE probe + ~10s delay = backend waiting for rest of body ``` ### Impact Chain ``` Poison next request → access admin as victim Steal credentials → capture victim's session Cache poisoning → stored XSS at scale ``` --- ## Target-Suitability Matrix (2026 reality check) The classic CL.TE / TE.CL payloads are NOT universally exploitable in 2026. Modern proxies are RFC 9112 strict by default. Fingerprint the front-end BEFORE investing time. | Front-end | CL.TE | TE.CL | H2.CL | H2.TE | Notes | |---|---|---|---|---|---| | **Nginx ≥ 1.21** | NO | NO | partial (H2 ingress) | partial | RFC-strict; rejects CL+TE with HTTP 400. Verified locally on Nginx 1.27 — all 9 documented variants killed by front-end ([docs/verification/phase2h-smuggling-cachepoison.md](../../docs/verification/phase2h-smuggling-cachepoison.md)). | | **Caddy 2.x** | NO | NO | — | — | Hardened by default | | **Envoy ≥ 1.20** | NO | NO | partial | partial | Hardened in most paths | | **HAProxy ≤ 2.4** | ✓ | ✓ | — | — | **Vulnerable**, see CVE-2021-40346 | | **AWS ALB + specific upstream** | partial | partial | ✓ | ✓ | Several disclosed-paid reports 2022-2024 | | **Cloudflare → S3 / Lambda chains** | — | — | ✓ | ✓ | H2-downgrade attacks remain viable | | **Older F5 BIG-IP (TMM < 16)** | ✓ | — | — | — | Vendor advisories | | **Citrix ADC / NetScaler (older firmware)** | ✓ | ✓ | — | — | Disclosed in 2020-2022 | | **Squid 3.x** | ✓ | — | — | — | Older deployments | | **Apache Traffic Server (older)** | ✓ | ✓ | ✓ | ✓ | PortSwigger research | | **Apache mod_proxy_ajp → Tomcat** | — | — | — | — | Cross-protocol HTTP→AJP desync (CVE-2022-26377); smuggled request is opaque to the WAF and reaches internal AJP admin/status paths that lack the external auth controls | | **Custom Python / Go proxies** | ✓ | ✓ | — | — | Frequently miss RFC enforcement | ### Operator fingerprint quick-check ```bash curl -sI https://target/ | grep -i "Server:" ``` - `nginx/1.21+`, `Caddy`, `envoy` → CL/TE classic is dead — pivot to H2.CL/H2.TE if the front-end speaks HTTP/2, or look for legacy proxies upstream - `HAProxy`, header points to AWS/CDN → run the full payload matrix - No Server header → assume hardened, but run a single quick `space-before-colon` probe; if it doesn't 400, dig deeper ### H2.CL / H2.TE (the modern dominant vector) H2-downgrade smuggling attacks rely on the front-end speaking HTTP/2 to the client and HTTP/1.1 to origin. The downgrade introduces CL/TE confusion because HTTP/2's frame-length headers don't survive the conversion cleanly. Most CDN+origin chains in 2024-2026 use this exact topology. Tools that send HTTP/2 raw frames (Burp Pro's HTTP Request Smuggler extension, `h2csmuggler`, `smuggler.py`) are the right starting point against CDN-fronted targets. Avoid HTTP/1.1-only test clients (curl, raw sockets) against H2-front-ended targets — you'll send the wrong protocol entirely. ### Mass credential harvesting — the "collector gadget" The highest-impact smuggling outcome needs no per-victim interaction. Instead of blindly poisoning the queue, smuggle a request aimed at a **back-end handler that echoes the full request** — a search endpoint that reflects headers, or a redirect that mirrors the request line. The next victim's headers (`Cookie`, `Authorization`, `X-Access-Token`) get attributed to your smuggled request, and the reflecting handler returns them **in a response you read**. Repeated on a busy keep-alive socket, this harvests live credentials from arbitrary users at scale — and it works even through a CDN (Akamai/Cloudflare) when the CDN↔origin hop desyncs. Chains to `hunt-ato`. --- ## Related Skills & Chains - **`hunt-cache-poison`** — Smuggling + cache is the canonical critical chain; one smuggled request becomes the cached response for every subsequent victim. Chain primitive: CL.TE smuggle a request whose response body contains attacker HTML/JS → front-end cache stores it under a popular URL (`/`, `/login`) → de-sync poisoning where the smuggled request becomes the cached response for the next N victims, persisting for the cache TTL. - **`hunt-auth-bypass`** — Smuggling reaches internal-only routes that the front-end WAF/auth-proxy filters out. Chain primitive: smuggle `GET /admin/users HTTP/1.1` past the front-end ACL that blocks external `/admin/*` → backend processes the smuggled request as if from a trusted internal source → bypass front-end auth by smuggling internal-routed request → admin data in the response queue. - **`hunt-idor`** — Smuggling attaches the NEXT user's session cookies to an attacker-controlled request path. Chain primitive: smuggle `GET /api/me HTTP/1.1` with no cookies → backend pairs it with the next legitimate user's incoming connection cookies → victim's session cookie attached to attacker's smuggled request → attacker reads the response containing victim's PII/tokens. - **`hunt-xss`** — Smuggling injects XSS payloads into the response stream of the next victim without ever appearing in a URL parameter. Chain primitive: smuggled request body contains reflected payload that the backend renders into the next response in the queue → next visitor to `/` receives attacker HTML inline → reflected XSS at every visitor without any URL parameter visible to them or to logs. - **`security-arsenal`** — Reach for the smuggling payload bank (CL.TE / TE.CL / TE.TE obfuscations, H2.CL downgrade probes, h2csmuggler one-liners, Burp HTTP Request Smuggler extension config) and the time-delay confirmation template before manual hex-editing. - **`triage-validation`** — Run the Pre-Severity Gate before claiming Critical: the smuggled-request effect MUST land on a request issued by a different client/session, not your own follow-up. A timing delta in your own browser alone is parser disagreement, not exploitable smuggling.
© Sachin Sharma · MIT · elementalsouls/Claude-BugHunter