What Is Cross-Site Request Forgery (CSRF)?
Cross-Site Request Forgery Vulnerability — Architectural definition, operational mechanics, real-world examples, security posture, and client-side inspection utilities.
Web Protocols & Security Architecture Research
What Is Cross-Site Request Forgery (CSRF)?
Supporting Architectural Explanation
Because web browsers automatically attach stored session cookies and HTTP authentication credentials to all cross-origin HTTP requests destined for a domain, an attacker can embed a malicious form or script on an external site (`evil.com`) that silently triggers state-changing actions (e.g. money transfers, password resets) on `bank.com`.
Unlike XSS (which steals data and executes code inside the application), CSRF exploits the server’s blind trust in the browser’s automatic inclusion of session cookies. Modern defense relies on the `SameSite=Lax` or `Strict` cookie attribute and anti-CSRF synchronizer tokens.
Why does CSRF exist?
Understanding CSRF enables engineers to distinguish between intentional user submissions and forged third-party requests.
Early web architecture designed browsers to automatically attach cookies to every matching outbound request regardless of which website originated the request, enabling seamless embedding of images and cross-site form submissions.
Understanding CSRF enables engineers to distinguish between intentional user submissions and forged third-party requests.
How does CSRF work?
A user logs into their bank; while still logged in, they visit an attacker’s malicious site; the attacker’s site immediately fires a hidden POST request to the bank; the browser automatically attaches the user’s valid session cookie.
Victim Authenticates
User logs into `bank.com`; server sets session cookie.
Victim Visits Malicious Site
User clicks a link to `attacker.com` while session cookie remains valid in browser.
Hidden Form Auto-Submission
Attacker’s page contains `<form action="https://bank.com/transfer" method="POST">` and auto-submits via JavaScript.
Automatic Cookie Attachment
Browser attaches the legitimate `bank.com` cookie; bank executes transfer assuming user intended it.
How is CSRF implemented in code?
// Secure Anti-CSRF Synchronizer Token Pattern
import crypto from 'crypto';
// 1. Generate unpredictable token stored in user session
app.get('/transfer-form', (req, res) => {
const csrfToken = crypto.randomBytes(32).toString('hex');
req.session.csrfToken = csrfToken;
res.render('transfer', { csrfToken });
});
// 2. Validate token on state-changing POST requests
app.post('/transfer', (req, res) => {
const clientToken = req.body._csrf || req.headers['x-csrf-token'];
if (!clientToken || clientToken !== req.session.csrfToken) {
return res.status(403).json({ error: 'Invalid or missing CSRF token' });
}
// Token verified: Process transfer safely
processTransfer(req.body);
});Architectural Explanation: Because external attacker sites cannot read the secret token due to the Same-Origin Policy, forged requests fail validation.
Where is CSRF commonly used?
Securing financial transfers, email address changes, and administrative actions.
Built-in protection in Django, Ruby on Rails, Spring Security, and Laravel.
What are the advantages and limitations of CSRF?
Core Advantages
SameSite Cookie Modern Standard
Modern browsers default cookies to `SameSite=Lax`, mitigating the vast majority of legacy CSRF form attacks automatically.
Architectural Limitations
Stateless Token Management
APIs using stateless authentication must use Double-Submit Cookie or encrypted bearer tokens.
Can CSRF introduce security vulnerabilities?
CSRF via Unprotected GET Requests
If state-changing actions (like deleting an account) are triggered via GET, attackers can exploit CSRF simply with `<img src="bank.com/delete">`.
Never perform state changes on GET or HEAD requests; follow REST HTTP idempotency rules strictly.
What are common misconceptions about CSRF?
CORS does NOT block requests from executing! A simple HTML form submission (`<form action="...">`) executes and mutates data on the server regardless of CORS.
CSRF forges actions using valid cookies without reading responses. XSS executes arbitrary code inside the app and can completely bypass CSRF tokens.
Frequently Asked Questions About CSRF
Q:Does SameSite=Lax completely eliminate the need for CSRF tokens?
Additionally, if a website suffers from an XSS vulnerability, SameSite cookies will not prevent exploitation.
12. Related Interactive Tools
Inspect, test, and verify this protocol directly in your browser with 100% private client-side execution:
13. Related Comprehensive Guides
Zugehöriges technisches Ökosystem & nächste Schritte
Verwandte technische Fragen
Why Does CORS Allow Simple GET Requests Without a Preflight?
Answer: CORS allows simple GET requests without preflight for backwards compatibility with legacy HTML form and image behaviors that predate CORS.
Why Do Browsers Send OPTIONS Preflight Requests?
Answer: Browsers send preflights to verify that older servers not expecting cross-origin calls explicitly permit the method and custom headers before execution.
Praxis-Diagnoselabore
Entwickler-Spezifikationen & Referenzen
Weiterlernen
CORS Policy & Preflight Handshake Lab
Simulate preflight OPTIONS probes and adjust Access-Control-Allow-* headers inside the browser sandbox.