# Hunt Smuggling

> Turn an edge topology into evidence-carrying CANDIDATES for request

- Skill: `encod3d-sec/hunt-smuggling-2` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx get-skill add encod3d-sec/hunt-smuggling-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/encod3d-sec/hunt-smuggling-2/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: Encod3d-Sec (https://skillmd.com/u/encod3d-sec)
- Updated: 2026-11-16
- Page: https://skillmd.com/skills/encod3d-sec/hunt-smuggling-2

---


# 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/
<eng> 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 | bash` inside 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:

1. Active engagement exists (repo tree targets/<eng>/active.md) and
   <host> is on targets/<eng>/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.)
2. hunt-core loaded (skills/exploit/hunt/hunt-core/SKILL.md).
3. Producer verified - at least ONE of:
   (a) $ENG_DIR/state.md asset table has >= 1 edge-fronted endpoint
   row for <host> (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.
4. 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/<eng>/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-<host>.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-<host>.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.

