This article is Day 19 of a 60-day bug bounty mastery course focused on identifying and exploiting Cross-Site Request Forgery (CSRF) vulnerabilities in web applications. It explains how CSRF works by leveraging automatic browser cookie inclusion, demonstrates six common CSRF token bypass techniques, covers SameSite cookie protections and their gaps, and shows how to chain CSRF vulnerabilities into account takeover scenarios that earn high-severity bug bounty payouts. The article matters because CSRF remains prevalent in production applications due to inconsistent or incomplete protection implementations, making it a high-value attack surface for bug bounty hunters.
- CSRF exploits automatic cookie inclusionWhen a user is authenticated to a target domain, their browser automatically includes session cookies in every request to that domain regardless of origin. The application cannot distinguish between requests the user intentionally made and requests an attacker's page caused the browser to make. Without additional verification mechanisms like CSRF tokens or SameSite cookie restrictions, both types of requests are processed identically.
- Six token validation bypasses work in practiceThe article identifies six techniques that bypass CSRF token protection: deleting the token entirely, submitting an empty token value, using another user's valid token, submitting a wrong-length token, reusing previously used expired tokens, and changing request method from POST to GET. The method-switch bypass (POST to GET) is noted as the most common successful technique in real bug bounty reports, with many applications validating tokens on POST but not GET requests.
- Token presence does not guarantee validationApplications frequently generate and include CSRF tokens in forms but fail to implement server-side validation that actually rejects missing or invalid tokens. This pattern passes cursory security reviews because the token appears in the form, creating a false sense of protection. Testing shows the server accepts requests when the token parameter is deleted entirely, returning 200 OK and processing the action despite the token's presence in normal requests.
- SameSite cookies have documented limitationsSameSite=Strict prevents cross-origin cookie sending; SameSite=Lax (Chrome's default) sends cookies on top-level GET navigation but not cross-origin POST; SameSite=None sends cookies on all cross-origin requests if Secure flag is set. Gaps include applications using SameSite=None for CORS scenarios, GET-based state changes vulnerable under Lax mode, subdomains bypassing restrictions via XSS, and older browsers ignoring SameSite entirely.
- Account takeover chains determine severityStandalone CSRF against low-impact actions like notification preferences is typically rated Low severity. CSRF gains High to Critical ratings when chained to account takeover: CSRF on email change enables the attacker to receive verification emails and reset passwords; CSRF on 2FA disabling removes authentication factors; CSRF on OAuth linking connects attacker identities to victim accounts. The email-change-to-account-takeover chain is highlighted as the highest-value target.
- Endpoint inconsistency reveals CSRF gapsMost applications protect some endpoints with CSRF tokens while leaving others unprotected, with inconsistent SameSite cookie configuration across endpoints. This inconsistency typically results from CSRF protection being added over time without systematic audit. Highest-priority targets for CSRF testing are account settings endpoints—email change, password change without current password validation, and OAuth linking—where protection is most often missing or inadequate.
- PoC documentation requires before/after evidenceA compelling CSRF report includes: a before screenshot showing original account state, the HTML PoC file (generated by Burp Suite or manually written), and an after screenshot showing the change. Serving the PoC via localhost HTTP server (not file://) is critical because browsers block file:// CSRF, but localhost:8080 is treated as a proper cross-origin request that proves attackability from an external domain.
- GET-based endpoints pose distinct CSRF riskThe article provides CSRF payload examples for GET requests using image tags (e.g., ``) and JSON endpoints using form POST with text/plain encoding that bypass Content-Type restrictions. These techniques are necessary for endpoints that perform state-changing actions via GET or require JSON bodies, expanding the attack surface beyond simple form-based POST CSRF.
Bottom line: CSRF remains a high-value bug bounty vulnerability because applications frequently generate CSRF tokens without implementing proper server-side validation, and inconsistent protection across endpoints leaves exploitable gaps. Test every endpoint with all six token bypass techniques, always check for email-change-to-account-takeover chains, and document exploitation with before/after screenshots and PoC served from localhost to prove cross-origin attackability.
FREE
Part of the 60-Day Bug Bounty Mastery Course
🎯 What You’ll Master in Day 19
⏱️ 50 min read · 3 exercises
📋 CSRF Bug Bounty 2026 — Complete Guide
In Day 18 you found CSRF in OAuth flows via missing state parameters. Day 19 covers CSRF as a vulnerability class in its own right — the broader technique that OAuth CSRF is a specific instance of. Understanding CSRF deeply unlocks a finding category that appears in nearly every web application in the 60-Day Bug Bounty Mastery Course.
How CSRF Works and Why It Still Exists in 2026
CSRF exploits the browser’s automatic cookie inclusion behaviour. When a user is authenticated to target.com, every request their browser makes to target.com includes the session cookie — regardless of whether the request originates from target.com or from an attacker-controlled page. The application cannot distinguish between a request the user intentionally made and a request that an attacker’s page caused their browser to make. Without an additional verification mechanism (a CSRF token, or SameSite cookie restriction), the application processes both identically.
⏱️ Time: 12 minutes · Browser DevTools · in-scope target
Open DevTools → Network tab → check Preserve log
Step 2: Perform every state-changing action you can find:
– Update profile (name, email, phone)
– Change notification settings
– Update password (if current password not required)
– Add/remove 2FA
– Connect/disconnect third-party apps
– Change privacy settings
Step 3: For each request in the Network tab:
□ Is it GET or POST?
□ Does it include a CSRF token parameter?
□ What are the Cookie headers? Do they have SameSite set?
□ Does it accept JSON? Or form-encoded data?
Step 4: Create a shortlist of endpoints with:
– No visible CSRF token → high priority test
– CSRF token present → still test for validation bypass
– SameSite not set → no cookie-level protection
Step 5: For your highest-priority finding, write:
The endpoint URL, HTTP method, parameters,
and why it appears CSRF-vulnerable.
📸 Save your shortlist of potential CSRF endpoints in your notes.
CSRF Token Bypass — 6 Techniques That Work
SameSite Cookies — Understanding the Gaps
SameSite cookie attributes are the modern browser-level CSRF defence. SameSite=Strict never sends cookies on cross-origin requests. SameSite=Lax (now Chrome’s default) sends cookies on top-level GET navigation but not on cross-origin POST. SameSite=None sends cookies on all cross-origin requests (requires Secure flag). The gaps: applications using SameSite=None (often for CORS or embed scenarios), GET-based state changes vulnerable under Lax, subdomains bypassing SameSite restrictions via XSS, and older browsers ignoring SameSite entirely.
⏱️ Time: 20 minutes · Free PortSwigger account
Step 2: Complete: “CSRF vulnerability with no defenses”
This confirms the baseline — no token, simple PoC works
Step 3: Complete: “CSRF where token validation depends on request method”
This demonstrates the method-switch bypass (#6 above)
Step 4: Complete: “CSRF where token is tied to non-session cookie”
This shows cookie-based CSRF token weaknesses
Step 5: For each completed lab, note:
– The specific bypass technique used
– The exact PoC HTML you submitted
– What the vulnerability enabled (email change, etc.)
Advanced (if time): “CSRF with broken token validation”
These labs cover every token bypass from the command block above
in an interactive environment with confirmed impact.
📸 Screenshot completed CSRF labs and save it in your notes.
Chaining CSRF to Account Takeover
Standalone CSRF against a low-impact action (changing notification preferences) is typically Low severity. CSRF against an account settings endpoint that enables account takeover is Critical. The highest-value chains: CSRF on email change → attacker receives verification email → resets password → account takeover. CSRF on disabling 2FA → removes authentication factor from victim’s account. CSRF on OAuth account linking → links attacker’s OAuth identity to victim’s account (the Day 18 attack applied without OAuth-specific bypass).
⏱️ Time: 12 minutes · Burp Suite · own test account only
📸 Screenshot your Burp-generated CSRF PoC and the before/after account state and keep them in your notes.
🧠 QUICK CHECK — Day 19
Writing the CSRF Report — Proving Real Impact
CSRF reports get downgraded or rejected when they prove only that a request can be forged, not that forging it matters. Lead with the state-changing action and the account it affects.
- Title: name the action and endpoint, for example “CSRF on /account/email lets an attacker change a victim’s email and take over the account”.
- Proof of concept: include a self-submitting form (or fetch) that performs the action from a page you control, and show it succeeding against your own test account.
- Why the protection fails: explain the root cause — no token, token not validated, token tied to the wrong thing, or a SameSite gap you relied on.
- Impact: describe the end state — email or password change, funds moved, MFA disabled — and whether it leads to account takeover.
- Fix: recommend a per-session, per-form anti-CSRF token validated server-side, plus SameSite=Lax or Strict cookies as defence in depth.
Severity tracks the action: a CSRF that changes a display name is low, one that changes the recovery email is a takeover. Always chain to the highest-impact action the endpoint allows.
❓ Frequently Asked Questions
Is CSRF still worth reporting in 2026?
Does SameSite=Lax kill CSRF?
What makes a CSRF report high severity?
How do I prove CSRF safely?
📚 Further Reading
- OAuth 2.0 Bug Bounty 2026 — Day 18 covers OAuth CSRF via missing state parameter — the specific CSRF variant in OAuth flows that chains to account takeover via account linking.
- Authentication Bypass Hub — The complete authentication bypass category covering CSRF, OAuth, JWT, and session management attacks with chaining examples.
- 60-Day Bug Bounty Mastery Course — The complete course hub — Day 19 CSRF is part of the authentication vulnerability phase covering Days 16-22.
- PortSwigger CSRF Labs — Six interactive CSRF labs covering all bypass techniques — the most effective hands-on practice for mastering CSRF exploitation and understanding every token validation weakness.
- OWASP CSRF Prevention Cheat Sheet — The definitive CSRF defence reference — understanding what correct implementation looks like helps identify exactly where implementations fall short during bug bounty testing.

