Hunt: HTTP Request Smuggling (golden-image rework + 2026 research)
Turn an edge topology into evidence-carrying CANDIDATES for request smuggling / desync: parser discrepancies, 0.CL, Expect-header desyncs, H2 downgrade, CRLF-powered desync. This skill produces candidates, never verdicts - findings leave ONLY through the G1 proof gate (triage).
Current emphasis (update on wiki harvest): root-cause parser- discrepancy detection (Host-header mutation, V-H / H-V reads) and the Expect: 100-continue surface over classic TE-probe timing - 2025-26 research showed defenses only broke the DETECTION; the vulnerability class stayed intact ($350k+ earned on "secure- looking" sites). Zero-CL, dangling-byte, and HTTP Terminator vectors lead until superseded.
Assumes hunt-core for the scope gate, two-account rule,
confirmation gate, enumeration limits, stop conditions, wiki protocol,
FIND output, and Deadends. Do not re-derive any of that here.
Wiki
Hub: [[web-moc]] - Primary page: [[http-request-smuggling]] - Payload
arsenal: wiki/payloads/smuggling.md
Anchors: [[reverse-proxy-attacks]], [[web-cache-poisoning]]
REFS: [[http-request-smuggling]], wiki/payloads/smuggling.md
mcp__wiki-search__query (lex) "HTTP request smuggling desync CL.TE TE.CL TE.TE CL.0 0.CL Expect 100-continue HTTP/2 downgrade dangling byte" via wiki-search MCP - ONLY on a concrete hint the map above does not cover; not a blanket first step.
Shared bypass arsenal (blocked implies research, but walk this first): skills/exploit/hunt/hunt-smuggling/references/bypass-arsenal.md - H2.CL/H2.TE downgrade smuggling, CONTINUATION flood (verify-only DoS), browser-powered desync, detection ladder (timing -> differential -> victim capture).
Paths (binding - define once at the top of the run notes)
# seat side (wsl) - engagement tree is DOUBLE-NESTED in VMshare:
ENG_DIR=/mnt/c/Users/Lenovo/Desktop/VMshare/<eng>/<eng>
RUN=$ENG_DIR/hunt/smuggling/<host>
# VM side (WHERE tools run, same tree through the VMware share):
ENG_DIR=/mnt/VMshare/<eng>/<eng>
RUN=$ENG_DIR/hunt/smuggling/<host>
Corpus and probes live in the VMshare tree; the VM runs tools against the /mnt/VMshare spelling as user tz; the seat reads the same bytes at the /mnt/c/Users/Lenovo/Desktop/VMshare spelling. The repo tree targets/ is admin/ingest only - probe artifacts NEVER land there.
Transport
Every VM-native command block ships through ONE documented transport:
wsl.exe -d kali-linux -u root bash -c "cd /mnt/c/Users/Lenovo/Documents/ObisidianVaults/ZTorch/ZTorch && bash scripts/vm-ssh.sh '<command>'"
- vm-ssh lands as user tz (NOT root): no root-only paths, no sudo.
- vm-ssh.sh takes the command as ONE argument; quotes ship as base64
(
echo <b64> | base64 -d | bashinside the vm-ssh argument). - Non-login shells do NOT source profile.d: target-facing fetches MUST use /opt/scope-shim/bin/{curl,httpx} by absolute path.
- Shim verdict semantics (verified live): out-of-scope dies rc 126 (never work around); in-scope passes; UNKNOWN gets an ADVISORY - not approval; verify against scope.md and self-deny.
- Race exploitation runs SEAT-SIDE in Turbo Intruder (Burp); its MCP interface (enable in settings) makes it agent-drivable. Long VM sweeps run detached (vm-scan.sh) - the bridge drops at ~2min.
Entry gate
All four must pass; each is falsifiable:
Active engagement exists (repo tree targets//active.md) and is on targets//scope.md in-scope. Scope-guard is the deny. (targets/ is the repo admin tree; $ENG_DIR holds corpus and run artifacts only - see Paths.)
hunt-core loaded (skills/exploit/hunt/hunt-core/SKILL.md).
Producer verified - at least ONE of: (a) $ENG_DIR/state.md asset table has >= 1 edge-fronted endpoint row for (CDN/WAF/LB in front, keep-alive reuse);
(b) a caido/burp baseline capture shows the host's chain (server banners naming front-end and back-end tiers);
(c) kickoff seeded $RUN/raw/edge-map.md. None = dispatch the surface lane first; never probe blind.Toolchain preflight (fails LOUD; Burp-side tools probed from the seat, VM tools absolute):
for t in /usr/bin/jq /usr/bin/python3 \ /opt/scope-shim/bin/curl; do [ -x "$t" ] || { echo "MISSING TOOL: $t"; exit 1; } done # seat-side (falsifiable): Burp running with the BApps loaded - # Burp > Extensions tab must list: HTTP Request Smuggler (v3+), # HTTP Hacker, Turbo Intruder (hunt-burp owns install; a missing # row in the Extensions list fails this gate as loudly as a # MISSING TOOL line above)
Checklist (mandatory)
Copy checklist.md (this skill's dir) to
$ENG_DIR/hunt/smuggling/<host>/smuggling-checklist.md at run start.
Unchecked at stop = UNCHECKED lane, re-run from the first unchecked
step. The SKILL.md text and the checklist header agree byte-for-byte
on that copy target.
Nudge
Review-skill re-injection text (pinned; NOTE: completion-gate emits its own generic nudge - both mean: resume at the first unchecked box):
Your work was just reviewed by the review skill and it was found
that you either missed a step of analysis, or didn't generate an
artifact of sufficient proof. Look at the markdown based checklist
and the output for each step, find what you missed, and complete
that step.
Confirmation gate
NOT confirmation: a single slow response or timing noise; a back-end read timeout by itself; a malformed request the front-end rejects; a delay you have not reproduced; a "Mystery 400" alone (it is a 0.CL deadlock SIGNATURE - strong signal, still needs the differential).
IS confirmation: a reliable differential - a smuggled prefix changing the NEXT request's response, reproduced on a clean connection; OR a consistent timing delta reproduced across runs and matched to a specific variant; OR a DNS/HTTP hit to your unique Collaborator/interactsh subdomain from a Collaborator-pointed smuggled request; OR the nested-second-path reflection (victim request's prefix processed as a hidden request line - the 302 Location reflects it).
Blind / OOB desync. Plant Collaborator-pointed smuggled requests with oob.md rows (targets//oob.md: token | sink | smuggling | date | waiting | source). The recon-capture hook flips waiting -> HIT; a HIT row is the gate to scaffold the FIND. Do NOT claim a blind smuggling desync without the captured differential or a HIT row.
Methodology
Rank before probing. H2 edge downgrading to H1 origin (H2.CL/ H2.TE re-open what a hardened H1 front-end closes - highest yield on modern stacks); multiple hops (each added parser = another disagreement chance); mismatched server software front vs back; connection reuse to the back-end (pooled keep-alive across users is what delivers victims); endpoints behind edge auth/path filters. Permanently exploitable fingerprint: AWS ALB (Server: awselb/2.0) + IIS (Microsoft-HTTPAPI/2.0) H-V class - AWS refuses to fix.
Step 1 - Edge map
Front-end/back-end tiers from banners, headers, timing @ $RUN/raw/edge-map.md (rows: tier | product | evidence).
Step 2 - Root-cause discrepancy scan (REPLACES blind TE probing)
WAF regexes now block obfuscated Transfer-Encoding - stop attacking with TE probes. Probe parser discrepancies instead via HTTP Request Smuggler v3+ (free; works on Burp Community): Host mutations (leading space, "Xost", duplicate Host with invalid value), obfuscated CL, vanilla + obfuscated Expect, across multiple strategies with 3 baselines (normal Host / no Host / arbitrary masked header). Read results as:
- V-H (front-end sees a header the back-end does not) -> convert to CL.0: hide a Content-Length in the body-prefix; if the front-end rejects GET bodies switch to OPTIONS.
- H-V (back-end sees it, front-end does not) -> 0.CL or H2.TE. Identify the answering tier by server banner/status. A response unique to the mutated form proves the discrepancy.
Step 3 - Classic variants (carried)
CL.TE / TE.CL timing probes (POST + malformed TE/CL, watch for back-end read timeout), TE.TE obfuscation (xchunked, leading space, tab, double TE), CL.0, H2.CL / H2.TE, H2 request splitting via CRLF in header values.
Step 4 - Zero-CL (0.CL)
Front-end does not see a hidden CL (implicit zero), forwards headers only; back-end sees CL:N and deadlocks waiting for a body that never comes - the timeout kills the attack UNLESS an early-response gadget makes the back-end respond before the body arrives:
- IIS/Windows: request /con, /aux, /nul (reserved device names) inside any filesystem-mapped folder - OS exception, IIS responds immediately, connection stays open.
- Server-level 302 redirects (incomplete folder path /resources).
- nginx static files respond early.
- Apache: NO viable gadget (closes the connection on errors) - do not burn time there. Tell: the "Mystery 400" (next request's first bytes eaten as phantom body). Prove desync: victim request with a nested second path - the correct CL slices its prefix and the back-end processes the hidden request line (302 Location reflects it).
Double-desync weaponization (0.CL -> attacker-controlled CL.0): request A poisons via 0.CL (hidden CL sized to request B's header block, aimed at the gadget); the poisoned socket decapitates request B into a CL.0 desync that repoisons with YOUR prefix; the prefix then poisons the next victim. Position the smuggled request BEFORE front-end-appended injected headers - measure the block size with 0cl-find-offset.py (Turbo Intruder examples; reflection of an input like zwrt reveals the injection offset) so the exploit works for any victim, not just your own connection. HEAD technique for XSS delivery: smuggle HEAD to a text/html resource (its CL header makes the front-end read following bytes as body), then the XSS request - victim gets attacker response headers + reflected JS.
Step 5 - Expect: 100-continue (highest-yield single header)
Virtually all servers support it; no browser sends it. Probe vanilla and obfuscated ("Expect: y 100-continue", "Expect:\t100-continue"):
- 0.CL desyncs by itself (front-end forgets it has not forwarded the client body when processing the back-end response).
- CL.0 via obfuscation + OPTIONS + obsolete line folding (Akamai CDN-wide, CVE-2025-32094; 65 days to fully fix).
- Memory/secret-key leakage into 100-continue interim responses.
- DUAL response header blocks: the second block bypasses front-end header stripping - internal header disclosure (Netlify X-Nf-/ X-Bb-; masked server banners).
- Expect + HEAD deadlocks (HEAD has no body; server over-reads).
Step 6 - HTTP Terminator vectors (2026)
In Smuggler v3+: multipart/byteranges Content-Type CL.0 trigger (Content-Type: multipart/byteranges; boundary=BOUND with CL fires as a standard CL.0; payload in body after Content-Range sections - worked on 200+ sites incl. a US bank); dual-matching CL headers; dangling-byte technique (smuggle a partial request missing exactly ONE byte - the back-end cannot finish response #2 until the victim's request arrives, eliminating the RQP race on method-agnostic back-ends); response forking (novel class, unproven in the wild); Shared-Parser Confusion (two products sharing one parser - a bug in one exploits the other).
Step 7 - H2 downgrade + cache-buster paradox
CDNs advertising H2 to clients but downgrading to H1 upstream add a 4th length interpretation. The Cloudflare lesson: a smuggled request BLOCKED by the front-end cache, with the cache-buster ADDED, fails - but WITHOUT the buster it desynced the CDN's internal hop (24M sites, CVE-2025-4366). When a probe is cache-blocked, test BOTH ways before moving on; the block may be the bug.
Step 8 - CRLF entry points
nginx proxy_pass with $uri and return 302 ...$uri reflect %0d%0a upstream: escalate "low" CRLF/header injection to CL.TE / 0.CL desync, Response Queue Poisoning (two complete smuggled requests = random users get each other's responses), blind tunnelling, auth bypass. Self-propagating desync worm (2026): desync delivers XSS whose payload re-fires the same desync via fetch; HEAD + stacked payload steals HttpOnly Set-Cookie (session refresh lands in a readable body). CRLF-Powered Desync Scanner BApp automates entry detection.
Step 9 - Differential confirmation + OOB
Confirm per the gate (differential on a clean connection / HIT row). Drive groups through Burp Repeater "Send group in sequence (single connection)"; HTTP Hacker for raw stream-level inspection where Burp's parsing hides the truth (unparsed response queues, multi-hop proxy modeling).
Step 10 - Exit artifact (candidates)
Merge probe JSONLs; candidates.md every class section present; pointer $ENG_DIR/hunt-smuggling-.md:
SMUGGLING-HUNT-DONE discrepancy=<n> zero-cl=<n> expect=<n>
h2=<n> crlf=<n> terminator=<n>
Plus _requests.md rows (lane = hunt-smuggling), state.md asset rows, Deadends rows with the WHY (which variants swept, which gadgets absent).
Every probe JSONL row: {class, host, endpoint, method, evidence (absolute probes/raw/ path), observed, confidence}. Request/response pairs under $RUN/probes/raw/ (sha256 filenames).
Chaining
A confirmed desync is a delivery primitive, not the endpoint:
- Smuggled response -> cache poisoning (persistent site takeover; always test whether the desync's output gets cached) -> hunt-cache.
- Request hijack: capture the next user's request (cookie, auth header, CSRF token).
- Front-end control bypass -> internal endpoints; reflected escalated to stored via poisoned response.
- Per hunt-core stop conditions: a traffic-affecting desync primitive IS the finding - stop and report at the primitive; do not fire at live user traffic.
Evasion
If direct CL/TE probes are normalized clean, the desync is often still there: TE.TE variants, H2 downgrade, Expect obfuscation, 0.CL via gadgets, Terminator vectors. Header casing, line folding, bare-CR/LF: wiki/payloads/smuggling.md.
Validation
- Proof = the smuggled SECOND request's effect: response prefix/suffix swap across a poisoned connection, the victim's request in backend-side evidence, nested-path reflection, or cache poison another visitor receives. Pair every timing claim with a content pair; timing alone wobbles with jitter.
False Positives
- Backend 400 for malformed input read as desync (re-send well-formed smuggle).
- Scanner-induced pipelining artifacts (your own client coalescing).
- TE-CL/CL-TE confusion flipping the conclusion; verify which parser is front.
- CDN normalizing/stripping the header so nothing reaches the backend parser.
- The proxy-error-page tell: an edge error page NAMES the second parser; it confirms topology, not a desync; still needs the pair test.
Cross-routing
- hunt-cache once poison persists across victims.
- hunt-ssrf when desync targets internal routing/fetches.
- hunt-xss when the victim-side render is the impact leg.
- Not this skill: plain reverse-proxy misconfig headers (ops note).
Severity
| Impact | Typical |
|---|---|
| Captured victim requests (session cookie / auth header) at scale | critical |
| Admin session theft | critical |
| Front-end auth / path-control bypass | high |
| Cache poisoning via smuggled response | high |
| Reflected escalated to stored via poisoning | high |
Rated on demonstrated impact per hunt-core. A desync you can trigger but cannot yet show capturing a victim request or poisoning a response is a mechanism, not the severity ceiling.
Deadends
Append: - [ ] smuggling on <host> -- discrepancy scan clean,
CL.TE/TE.CL/TE.TE/CL.0/0.CL/Expect/H2/Terminator swept (single
normalising front-end, no differential after full sweep; Apache
gadget-absent noted)
Record which variants you swept, not just that it failed.
N/A escapes
- "N/A: no front-end/back-end split (single origin)"
- "N/A: Apache back-end, no early-response gadget"
- "N/A per host: no CRLF-reflecting pattern found" An N/A tick is a claim with a reason, never a silent pass. Identical strings in SKILL.md and checklist.md.
Bitter-pill variant
Freehand run: skip checklist + numbered steps, one freehand pass over the edge map, output ONLY $RUN/analysis/bitter-pill.md (tried/found/ dismissed, every claim carries evidence). The differential/OOB gate survives freehand. Declare with a _requests.md row (lane = hunt-smuggling-bitterpill).
Depth walk (mandatory)
Walk EVERY applicable row of the payload arsenal page cited above.
Record each row in $RUN/coverage-depth.md as a table
| row | state | evidence | where state is probed, blocked, or
N/A, and evidence is a probe-pair path or a Deadends.md line. A bare
probed with no evidence reference fails the completion gate
(NEEDS-REVIEW). N/A rows cite why (surface shape forbids it).
Blocked implies research: before any Deadend is claimable on a blocked
row, (a) walk the arsenal page's bypass-ladder rows for that control
class, and (b) run one wiki query AND one mcp__wigolo__search for the
specific tech-plus-control bypass. Results, or a genuine null, land in
coverage-depth.md. "No research tried" is not a claimable state.
Exit artifact + handoff
ONE exit artifact set: $RUN/candidates.jsonl + candidates.md +
$ENG_DIR/hunt-smuggling-.md (pointer with SMUGGLING-HUNT-DONE +
counts). Consumer (triage) finds at $RUN: raw/edge-map.md,
probes/.jsonl, probes/raw/, candidates.{jsonl,md}. Findings leave
ONLY through G1. Distill: python3 scripts/wiki-stage.py --kind technique --slug <slug> --target-page techniques/web/http-request-smuggling.md.
Stop conditions
Terminal states complete (probed | N/A with reason | deadend row); nothing written into skill dirs; no unchecked boxes above REVIEW; hunt-core stop conditions fire unchanged (a traffic-affecting primitive is itself the finding - report, do not exploit live users).
Attack surface
APPROACH: Look for a front-end/back-end parser mismatch (CDN/WAF/LB -> origin, or an H2 edge downgrading to H1); detect with a timing-safe TE/CL probe, then confirm with a differential (a smuggled prefix that changes the NEXT request), driving the group through Burp on a single connection. AVOID: A single slow response, a back-end read timeout, or a malformed request the front-end simply rejects is NOT confirmation - you need a reproducible differential (or an OOB HIT), never timing alone.