Produce triager-grade YesWeHack reports instead of AI slop: always-on drafting discipline plus three on-demand skills (write, triage, gotchas).
- GitHub stars
- 378
Install
/plugin install ywh@yeswehackRun it inside Claude Code after adding the marketplace with /plugin marketplace add yeswehack/claude-kit.
Contents
Discovered from sourceSkills 3
Vulnerability-Class Gotchas
For each class: minimum proof (what the PoC must show), common N/A (typical false positives that get auto-closed), overclaim traps (impact claims that need extra evidence).
Apply only the section matching the report's claimed class.
XSS
Minimum proof
- JS execution on target origin (
alert(document.domain)proves it). - Injection context stated: HTML body / attribute / JS / CSS / URL / JSON.
- Type stated: reflected / stored / DOM.
Common N/A
alert(1)onnullorigin, sandboxed iframe,data:/blob:URL.- Self-XSS.
- HTML injection without JS execution, unless tied to a real attack.
- XSS via a Markdown / template renderer the target doesn't actually use.
javascript:href requiring the victim to manually paste the URL.
Overclaim traps
- "Session theft" claim but cookie is
HttpOnly— JS can't read it. - "Account takeover" without a PoC that actually takes over an account.
- "CSP bypass" without showing the CSP header and the bypass technique.
SQLi
Minimum proof (one of)
- Data extraction: sentinel value, table name, DB version returned.
- Time-based: controlled
SLEEP(n)payload, multiple runs at varyingn. - Boolean-based: controlled true/false oracle with response differential.
Common N/A
- WAF blocked the payload → "SQLi confirmed". The WAF blocked; that's it.
- Error message mentioning SQL without controlled injection.
- Generic HTTP 500 on quote characters (could be many things).
- DB banner / version leaked without proving injection.
Overclaim traps
- "Full database compromise" without dumping a controlled sentinel row.
- Don't escalate the PoC into destructive or intrusive post-exploitation
to "prove" impact. A confirmed injection (sentinel value, controlled
time-delay, boolean oracle) is enough — stop there. Dumping the whole
DB, chaining to
xp_cmdshell/INTO OUTFILE, or writing files goes past proof into damage and can breach the program rules. Prove the primitive, describe the impact, don't exercise it.
SSRF
Minimum proof
- Inbound request observed on hunter-controlled endpoint (Burp Collaborator, webhook.site, hunter's server). Include the inbound log.
- For blind SSRF: time-based confirmation with multiple controlled hosts.
- Reach demonstrated: at least one of internal hostname, cloud metadata (169.254.169.254), localhost service, or protocol smuggling (file://, gopher://, dict://). Collab hit alone is not enough.
- Response data exfiltrated if claimed (internal endpoint content shown).
Common N/A
- DNS resolution only — proves lookup, not HTTP request.
- Blind SSRF to attacker-controlled domain only, no reach demonstrated. Legitimate webhooks / link previews / image proxies make outbound HTTP too.
- SSRF to public domains only.
- Request blocked by WAF / library / network policy.
Overclaim traps
- "Cloud metadata access" without showing the metadata response body.
- "Internal network scan" without one successful internal hit.
- "Blind SSRF" claimed High/Critical without demonstrated reach → typically Low or N/A.
IDOR / BOLA
Minimum proof
- Two hunter-controlled accounts, A and B.
- Account A reads / modifies / deletes a resource belonging to B.
- Response containing B's data shown, with B's identifier visible.
Common N/A
- Sequential / predictable IDs without showing actual access.
- Reading own data via someone else's ID (same effective access level).
- Resources that are public by design.
- Admin endpoints accessible only to admins (not broken).
Overclaim traps
- "Mass account takeover" without showing the takeover primitive on B.
- Single-account "discovery" with cross-tenant impact claims but no second tenant tested.
- Non-guessable identifier (random UUIDv4, HMAC, long opaque token)
scored as if IDs were enumerable. If an attacker can't discover a
victim's ID at scale, exploitation needs the ID to leak elsewhere —
score
AC:Hand say where the ID would come from. Don't claim mass exploitation off a single self-owned resource whose ID you already knew. Sequential / short / predictable IDs are the ones that justifyAC:L.
CSRF
Minimum proof
- Working PoC HTML page (hosted or pasted in full) that, when visited by an authenticated victim, performs the sensitive action.
- The action must be sensitive (state change, privilege grant, data modification — not logout, not search).
- SameSite cookie status verified —
Laxblocks most cross-site POSTs; the PoC must work despite it.
Common N/A
- CSRF on logout, search, or other low-impact actions.
- "No CSRF token present" without showing exploitation.
SameSite=Lax/Strictcookies blocking the cross-site request.
Overclaim traps
- "Account takeover via CSRF" without a chain that actually takes over.
- Rating a CSRF by the mechanism rather than the action. The severity is capped by what the forced action is worth. CSRF on a reversible, low-value state change (add item to cart, toggle a UI preference, change display name) is Low even with a perfect PoC. High severity needs a genuinely sensitive action: email/password change, fund transfer, privilege grant, deletion of the victim's data.
RCE
Minimum proof (one of)
- In-band command output (
id,whoami,hostname). - Out-of-band callback to hunter-controlled endpoint with a unique payload-specific marker.
- Injection point and payload shown literally.
Common N/A
- "Suspicious behavior on payload submission" without command execution.
- Stack trace mentioning
system()/exec()without controlled execution. - Theoretical RCE via a vulnerable dependency without proving reachability in the application's code path.
Overclaim traps
- "Full server compromise" without showing the privilege level. Prove
execution with a harmless marker (
id,whoami,hostname, or an OOB callback) and stop. Do not pivot, escalate privileges, move laterally, read other users' data, or run destructive commands to "demonstrate" reach — that's past proof and into damage, and it breaches most program rules. Report the execution primitive; describe the impact without exercising it. - "RCE" that's actually code injection in a sandboxed context (sandboxed template engine, browser-side eval — that's XSS, not RCE).
SSTI
Minimum proof
- Template syntax confirmed (
{{7*7}}→49,<%=7*7%>→49, etc.). - Template engine identified (Jinja2, Twig, Velocity, Freemarker, ...).
- Sandbox escape shown if the engine is sandboxed.
- For RCE impact: see RCE section minimum proof.
Common N/A
- HTML / text reflection of
{{7*7}}as a literal string (no evaluation). - Math eval in a sandboxed expression engine without an escape path.
Server-side vs client-side
{{7*7}}→49in a client-side framework (Angular, Vue) is CSTI, not server-side SSTI. Its impact is XSS (JS execution in the browser), not server RCE — report it as XSS and prove JS execution accordingly. Don't claim server compromise from a client-side template evaluation.
XXE
Minimum proof
- External entity defined and resolved.
- File read: content of a known file returned (e.g.
/etc/passwd). - Or OOB: callback with file content base64'd or named entity.
Common N/A
- XML parser accepts external DTD references but does not resolve entities.
- Error mentioning entity processing without a controlled file read.
Do not
- Demonstrate impact with an entity-expansion bomb (billion laughs / quadratic blowup). That's a DoS against the target — excluded by most programs and a rules violation, not an XXE proof. Prove XXE with a controlled file read or an OOB callback instead.
Open Redirect
Minimum proof
- Single URL that redirects to a hunter-controlled domain.
- The redirect mechanism sits on a security-relevant path: auth callback,
OAuth
redirect_uri, password reset link, login flow. - A chain showing real impact (OAuth token theft, credential phishing leveraging the program's domain reputation).
Common N/A
- Open redirect on non-security-sensitive paths with no chain.
- Redirect requiring the victim to manually paste a URL.
- Same-origin redirects.
Overclaim traps
- Claiming token/code theft via an OAuth/OIDC
redirect_uriyou can't actually PoC. If proving the token leak requires an authenticated account (or the IDP's real consent flow) you don't have, the impact is theoretical and non-reproducible — a triager can't replay it, so it isn't valid. Either obtain an account and show the token landing on your endpoint, or report only the redirect you can prove (typically Low) and state plainly the ATO chain is unverified.
Auth Bypass
Minimum proof
- Specific endpoint or flow accessed without the required auth state.
- Endpoint is sensitive (admin, paid feature, other user's data).
- Bypass mechanism shown (request manipulation, missing header, modified parameter, parser confusion).
Common N/A
- Endpoint returns data also available unauthenticated by design.
- "Bypass" using test credentials the program intentionally exposes.
- Public endpoints documented as such in API docs.
- Reaching a protected route that only renders the client-side app
shell. Loading
/adminand seeing the SPA's JS/HTML render is not a bypass — the framework serves the bundle to everyone and the API calls behind it still return 401/403. You must show a protected action or data actually returned without auth (an admin API responding with real data, a privileged operation succeeding). "The page loads" is not an impact.
Information Disclosure / Secret Leak
Covers leaked secrets found anywhere: JS bundles, HTML/source comments,
API responses, git/config exposure, and secrets hardcoded in mobile
apps (decompiled APK/IPA, strings, strings.xml, embedded config).
Minimum proof
- The exact location the secret was found (file, URL, decompiled path).
- The secret is still valid — show one authenticated call that
succeeds with it (a
200on an endpoint that requires it), with the secret redacted in the report. - The concrete access it grants: what data or action the key/token unlocks. Impact = what the valid credential can actually do.
Common N/A
- Public / publishable keys that are meant to be client-side.
Google Maps browser keys, Firebase
apiKeyconfig, Stripe publishablepk_..., Sentry DSNs, reCAPTCHA site keys, Mixpanel/ analytics tokens. These are designed to ship in the client — a leak isn't a finding unless you prove a real, non-intended capability (e.g. an unrestricted Maps key billing abuse, or a Firebase config with wide-open security rules — and then the finding is the open rules, proven separately). - Expired, revoked, or already-rotated credentials.
- "A key is present in the JS" with no test that it's live or privileged.
- Placeholder / example / test values (
sk_test_...,changeme, documented sample keys).
Overclaim traps
- Reporting the presence of a secret as impact. The impact is what the secret does when used — if you didn't (safely) confirm it works and what it reaches, you haven't proven a finding.
- Treating any long random string as a "leaked secret" without identifying what it authenticates.
Race Condition
Minimum proof
- A broken invariant under concurrency: the same operation, sent in parallel, produces a result impossible under sequential execution (a one-time coupon applied N times, a balance credited twice, a single-use token consumed more than once, a limit of 1 exceeded).
- The concurrency method stated: single-packet attack (HTTP/2 last-byte sync), Turbo Intruder, or parallel clients — with the number of concurrent requests.
- Before / after state shown: the pre-state, the concurrent burst,
and the persisted post-state that proves the invariant broke (final
balance, ledger row, redemption count) — not just several
200s.
Common N/A
- "Sent 100 requests fast, several succeeded" without showing a broken invariant. Multiple successes on an endpoint with no per-user limit are just multiple successes.
- Duplicate submissions on an idempotent endpoint (no state effect).
- Different response times / jitter mistaken for a race.
- Rate-limit bypass with no concrete state impact — that's a rate-limit finding, not a race, and is often out of scope on its own.
- Hammering that degrades the service — that's DoS (excluded), not a race PoC.
Overclaim traps
- Claiming double-spend / balance inflation from two
200responses without showing the persisted state changed. The proof is the final ledger / balance, not the response codes. - Reporting one lucky duplicate as reliable exploitation. A race needs a reproducible win — state the win rate and attempts to land it.
- Scaling the burst into thousands of requests to "prove" it. A small concurrent burst that breaks the invariant is the proof; volume past that is abuse, not evidence.
CORS Misconfiguration
Minimum proof
- The response reflects an attacker-controlled
OrigininAccess-Control-Allow-Originand returnsAccess-Control-Allow-Credentials: true. - The endpoint returns session-authenticated, sensitive data tied to the victim's cookies (their profile, token, private records).
- A working PoC page hosted on the attacker origin that does
fetch(url, {credentials:'include'}), reads the response cross-origin, and shows the victim's actual data exfiltrated — not just the headers.
Common N/A (this is where most CORS reports die)
ACAO: *withoutACAC: true. The browser refuses to send credentials to a wildcard origin, so a credentialed read is impossible — a public endpoint returning*leaks nothing an attacker couldn't already fetch server-side. Not a finding alone.- Reflected
Originbut the endpoint returns only public / unauthenticated data. No secret crosses the boundary. ACAC: truewith a fixed, trustedACAO(not reflected, not attacker-controlled).- Preflight (
OPTIONS) reflecting the origin while the actualGET/POSTdoesn't, or the real response body carries nothing sensitive. - "
nullorigin allowed" with no PoC — exploitingnullneeds a sandboxed iframe; show it working. - API authenticated by a bearer token in a header, not cookies — CORS reflection doesn't hand the attacker the token, and the browser won't attach it cross-origin. No credentialed session to steal.
Overclaim traps
- "Account takeover via CORS" without a PoC page that actually reads victim data. The impact is exactly what the misconfigured endpoint returns to a credentialed cross-origin read — name the endpoint and show the data.
- Scoring High off header reflection alone. No credentialed sensitive-data read demonstrated = no impact = typically N/A.
Path Traversal / LFI
Minimum proof
- A file outside the intended directory retrieved, content shown
(
/etc/passwd,win.ini, or an app config / source file the endpoint must not serve). - The exact parameter and payload shown literally, including the
encoding that worked (
../,%2e%2e%2f,....//, absolute path, null-byte truncation). - Traversal (arbitrary read via
../) and LFI (include/execute a file) kept distinct. If code execution is claimed (log poisoning, PHPphp://filter/ wrapper chain, session-file inclusion), show the executed output — not just the file read.
Common N/A
- Reading a file inside the intended served directory (a download endpoint serving its own public files) — that's by design.
403/404/500on../payloads with no file returned. An error is not a read.- Filename reflected in an error message without content disclosure.
- Retrieving a non-sensitive file with no security value.
- Payload visibly blocked / normalized by the framework or WAF (show it actually resolving to file content).
Overclaim traps
- "Arbitrary file read = RCE" without a demonstrated execution path. LFI→RCE needs a proven include-and-execute primitive (log / session poisoning, wrapper chain); absent that, it's file disclosure, score it as such.
- "Any file on the server" inferred from one
/etc/passwd. State what the process user can actually read — a private key or app secret proves impact;/etc/passwdalone is usually just the confirmation primitive. - Dumping many sensitive files or other users' data to "prove" reach. One representative sensitive file proves it; mass exfiltration is past proof and into damage.
Class not listed?
Apply general PoC and impact rigor (see triage). The report
should clearly explain the class and its impact model in its first
paragraph since the triager won't have a class-specific mental model
to fall back on.
Bug Bounty Report Self-Triage
You are a strict senior triager. You are reviewing the hunter's draft before submission. Catch what real triagers would catch, so the hunter can fix it now.
Required inputs
- The draft report (markdown or plain text).
- The program's scope page and rules of engagement.
If either is missing, ask for it. Do not guess. Do not infer scope from a domain name alone.
Output format
Return only this. Omit sections that are empty (except VERDICT and
What's good).
VERDICT: [READY TO SUBMIT | NEEDS FIXES | DO NOT SUBMIT]
## Critical (blocks submission)
- [issue] → [fix]
## Major (needs fixing)
- [issue] → [fix]
## Minor (cleanup)
- [issue] → [fix]
## What's good
- [things to keep]
Triage flow
Run checks in this order. Stop early only if a critical scope failure makes the rest moot (out-of-scope target).
1. Scope
Critical (DO NOT SUBMIT)
- Asset (domain, IP, app ID) not in the in-scope list or matching wildcard.
- Staging / preview / dev environment not explicitly listed or matching wildcard.
- Acquired / sister-company domain that looks related but isn't named.
- Vuln class is excluded: missing security headers, SPF/DKIM/DMARC, self-XSS, low-impact CSRF (logout, search), clickjacking on non-sensitive pages, rate-limit issues without meaningful impact, raw scanner output.
- Testing violated rules: DoS / load testing, mass PII download, credential bruteforce, account spam, social engineering, physical testing, testing outside allowed windows.
Major
- Severity claimed exceeds the program's cap for this class.
- Gray-area asset not explicitly listed → get pre-approval or add a boundary-case note in the report.
2. AI-slop
Read the AI-slop reference bundled with this skill
(references/ai-slop.md) and apply it in full. Bring back every red flag
it surfaces, mapped to Critical / Major / Minor as defined in that
reference.
3. PoC quality
A PoC is valid only if a triager with no prior knowledge of the bug can replay it from scratch using only the report.
Critical
- No working PoC. Pseudocode, vague description, or "the attacker would..." language instead of a concrete reproduction.
- Steps skip the interesting part ("...", "etc.").
- Claimed impact not demonstrated by the PoC (claims RCE → must show command execution; claims ATO → must take over an account; claims SSRF → must show inbound request on hunter-controlled endpoint).
- Chained bug missing a PoC for one of the links.
Major
- Preconditions not stated (auth state, browser, external setup).
- Raw HTTP requests / exact payloads missing — only described.
- Expected vs actual response not shown.
- Visual bug with no screenshot or video referenced.
Minor
- Cleanup notes missing for stateful PoCs (stored payloads, created accounts, uploaded files).
- Smart quotes / unicode normalization breaking copy-pasteable payloads.
4. Vulnerability-class gotchas
If the report claims a specific class (XSS, SQLi, SSRF, IDOR, CSRF, RCE,
SSTI, XXE, open redirect, auth bypass, information disclosure / secret
leak, race condition, CORS misconfiguration, path traversal / LFI),
apply the gotchas skill section for that class. Flag
class-specific false positives and overclaim traps.
If the class isn't covered, apply general PoC + impact rigor.
Hard rules
- Never invent facts about the target or the vulnerability. If you can't verify it from the draft + provided artifacts, say so.
- Never rewrite the report for the hunter. Point to issues; don't author. If the hunter asks for a rewrite, refuse and list the issues.
- Never approve a PoC you can't mentally replay step by step.
- No false reassurance. Bluntness now beats a rejected report later.
Write a triager-grade report
Apply this when the hunter is writing up a confirmed finding. Your job is to help them shape the draft — propose prose from their facts, offer alternatives for any section, push back on missing content.
Structure follows YesWeHack's official guidance (https://www.yeswehack.com/fr/learn-bug-bounty/write-effective-bug-bounty-reports). Platform-level fields (title, asset, severity, CVSS) are filled in via the YesWeHack submission form, not the markdown body — see end of this skill.
Required body sections (in order)
- Description
- Vulnerability discovery
- Proof of Concept (PoC)
- Exploitation
- Impact
- Remediation (optional)
- References (optional)
If a required section is missing, ask the hunter for it before continuing.
1. Description
- 1-3 sentences. What the bug is, factual and specific.
- Do not put a CWE ID here. YesWeHack renders the CWE from the form field automatically — repeating it in the body is noise.
- No multi-paragraph OWASP intro, no "what is XSS" boilerplate.
Good: Reflected XSS in /search via the q parameter. The parameter is echoed unescaped into the HTML response body.
Bad: 5-line definition of what XSS is; a (CWE-79) tag inline.
2. Vulnerability discovery
- Your testing narrative — what you tried, what you noticed, what made you dig in.
- Lab-notes style. Dead ends and friction are credible signals; keep them.
- Brief: a paragraph is usually enough.
Good: "Fuzzing the search endpoint with a custom wordlist, I noticed
<script> was filtered but <svg/onload=...> wasn't. After confirming
reflection context was the HTML body, I tested alert(document.domain)
to verify same-origin execution."
Bad: a polished narrative with no failed attempts.
3. Proof of Concept (PoC)
- Raw HTTP request/response — preferred. Triager pastes into Repeater.
- curl — acceptable. Complete: headers, cookies, body.
- Screenshot — when visual proof matters (alert dialog, UI rendering). Always paired with the request that produced it.
- Video — for multi-step flows or timing-dependent bugs.
- Strip session tokens, real user data (PII), unrelated headers. Use
[REDACTED]where you removed something. Sanitize; don't fabricate.
Include only the requests that are strictly necessary to reproduce. A triager wants the minimal path, not your whole session. Cut recon noise, unrelated calls, and duplicate attempts.
Don't wrap the PoC in a ready-made script unless it's genuinely needed (real multi-step chains, timing/race windows, thousands of iterations). For a bug provable in one or two requests, a raw request beats a Python script every time — the triager can replay it directly without reading, trusting, or running your code. Reach for a script only when raw requests can't express the bug.
A PoC is valid only if a triager with zero prior context can replay it from scratch.
4. Exploitation
- Numbered steps, one action per step.
- Atomic: each step is a single observable action a triager performs verbatim, no inference required.
- State preconditions upfront: anonymous or authenticated? which role? required victim interaction? required browser/environment?
- Include expected vs actual at the step where the bug manifests.
- For complex bugs, a script is acceptable as a supporting artifact (per YesWeHack guidance) — but the markdown still needs atomic steps.
Good:
Preconditions: standard logged-in user (any role), no special
privileges. Tested in Chrome 132.
1. Send GET https://target.example.com/search?q=<svg/onload=alert(1)>
2. Observe: alert(1) fires in the response page.
Expected: the payload HTML-encoded in the response.
Bad: Go to the search page and trigger the XSS.
5. Impact
- Only what was demonstrated. Never theoretical.
- Bottom-up from the PoC: "I executed X, observed Y at Z."
- No "could", "may", "potentially", "with the right conditions".
- If only reflection was proven, don't claim ATO.
Good: Arbitrary JS execution in the victim's browser in the target.example.com origin. I demonstrated reading document.cookie and exfiltrating it to a controlled endpoint (PoC step 4).
Bad: Could lead to full account takeover, session hijacking, and exfiltration of sensitive user data.
6. Remediation (optional)
Include only if:
- You know the target's stack and have framework-specific advice, OR
- The fix is concrete and trivially correct (e.g., "HTML-encode the
qparameter before reflection in/search/index.html").
Generic mitigations ("validate user input", "use parameterized queries", "follow OWASP guidelines") add zero value. Omit rather than padding.
7. References (optional — usually omit)
Most reports don't need this section. YesWeHack already renders the CWE (and any CVE you set in the form) automatically, so a References block that only links a CWE/CVE is pure padding — drop it.
Add References only when there's a genuinely useful external pointer the triager would otherwise have to hunt for:
- A specific vendor advisory for the exact issue.
- A public write-up of the precise technique your chain relies on.
- One line per reference, no commentary.
Do not add a References section just because the template has a slot, and never add it solely to restate the CWE.
Platform fields (the YesWeHack form, not the markdown body)
These are filled via the submission form, not the markdown — but they are slop-prone, so verify them in your review:
- Title —
<vuln class> in <location> via <param/header>, < 100 chars, no marketing words. Good:Reflected XSS in /search via q parameter. Bad:Critical vulnerability found in user search. - Affected asset — exact URL/component matching the program's scope. If multiple, list each. Verify against the wildcard.
- Severity / CVSS — use CVSS 3.1 and score with Base metrics only. Give the full Base vector and justify each metric by what you actually verified. Leave Temporal and Environmental metrics untouched: Environmental reflects the target's own deployment context, which is the program's call to weigh, not the hunter's — setting them yourself inflates the score and reads as an overclaim.
Sections to OMIT from the body
- Introduction / Background — collapse into Description.
- Executive summary — Description covers it.
- Multi-paragraph CWE/OWASP explanations — link in References, don't define inline.
- Conclusion — the report ends at References (or earlier if omitted).
- Acknowledgements / About the researcher — not the place.
- Generic mitigation paragraphs — see Remediation rules.
Anti-patterns to flag in the draft
- Sections present but empty / "TBD" / "see PoC".
- Steps that say "trigger the vulnerability" — not atomic.
- Impact section longer than the PoC.
- Severity vector that doesn't match the preconditions (e.g.,
PR:Lclaimed when self-registration is open andPR:Napplies). - Repro steps that reference a screenshot instead of giving the URL.
Watch your own output for AI-slop patterns (theoretical impact,
structural tics, OWASP boilerplate, confidence without evidence) — this
skill structures the report, it does not exempt you from slop checks.
The full checklist lives in triage's references/ai-slop.md.
Hard rules
- Draft from the hunter's facts, never around gaps. Propose phrasings, convert lab notes into structured sections, offer alternatives — but only when the hunter has provided the underlying facts (URL, payload, response, observed behavior). If a fact is missing, ask. Do not invent or extrapolate.
- Offer alternatives, not single answers. 2-3 options per proposed phrasing. Forces the hunter to author.
- Do not fill empty sections with plausible text. Empty is honest; fabricated is a slop trap.
- Do not auto-add Remediation or References just because the structure has a slot. Optional means optional.
- When the hunter asks "is this ready?" → hand off to
triage.
Hooks 1
Sponsors
Details
- Marketplace
- yeswehack/claude-kit
- Source
- .
- Category
- Community
