Cross-Site Request Forgery (CSRF) è un attacco che inganna il browser della vittima per inviare richieste HTTP indesiderate a un'applicazione in cui l'utente è autenticato. La vittima non nota nulla. Il server non è in grado di distinguere la richiesta legittima da quella "falsificata".

Nonostante sia una vulnerabilità vecchia e ben documentata, continua a comparire nella OWASP Top 10 e nei report di bug bounty. È facile sottovalutarla perché non richiede il furto di credenziali, non necessita di XSS e non lascia tracce evidenti nei log dell'applicazione.

Indice


Il nome è simile a quello della Server-Side Request Forgery (SSRF), ma il meccanismo è diverso: nel CSRF si sfrutta il browser autenticato della vittima, mentre nella SSRF è il server a effettuare richieste verso destinazioni non previste.

Come funziona il CSRF

Il browser allega automaticamente i cookie di sessione a ogni richiesta verso un dominio, indipendentemente dall'origine della richiesta. Questo comportamento, progettato per rendere la navigazione più fluida, è esattamente ciò che il CSRF sfrutta.

In uno scenario classico, l'utente accede a vulnerablesite.com e il browser salva il cookie di sessione. Senza effettuare il logout, l'utente visita una pagina malevola su un altro dominio. Quella pagina contiene del codice che invia una richiesta a vulnerablesite.com. Il browser allega il cookie di sessione, vulnerablesite.com riceve una richiesta autenticata ed esegue l'operazione.

Dal punto di vista del server, tutto sembra normale. Non ha modo di distinguere questa richiesta da una proveniente dall'interfaccia legittima.

Affinché l'attacco funzioni, devono essere soddisfatte alcune condizioni: la vittima deve essere autenticata al momento dell'attacco, l'applicazione deve utilizzare i cookie di sessione, l'operazione target deve essere eseguibile con una singola richiesta prevedibile e non devono essere attivi meccanismi di difesa.


Un esempio pratico di attacco

Supponiamo che vulnerablesite.com abbia un endpoint per i bonifici:

POST /transfer HTTP/1.1
Host: vulnerablesite.com
Cookie: session=abc123

amount=500&iban=IT60X0542811101000000123456&reason=Rent

Un attaccante che conosce questa struttura crea un file HTML:

<html>
<body onload="document.forms[0].submit()">
  <form action="https://vulnerablesite.com/transfer" method="POST" style="display:none">
    <input type="hidden" name="amount" value="500">
    <input type="hidden" name="iban" value="IT60X0542811101000000654321">
    <input type="hidden" name="reason" value="Gift">
  </form>
</body>
</html>

Quando la vittima apre questo link (tramite email, un messaggio o un redirect da un sito legittimo compromesso), il modulo viene inviato automaticamente con il cookie di sessione allegato. Il bonifico viene eseguito senza che la vittima clicchi esplicitamente su nulla.

Variante tramite tag img

Per le richieste GET su applicazioni progettate male, basta un tag immagine invisibile:

<img src="https://target.com/admin/delete-user?id=42" width="0" height="0">

Il browser tenta di caricare l'immagine, eseguendo la richiesta GET con i cookie allegati.


Tipi di CSRF

Il CSRF basato su form classico è il più comune. I form HTML possono inviare richieste cross-origin senza restrizioni CORS, poiché il CORS si applica alle risposte JavaScript e non alle submission dei form. Questo apre la porta in qualsiasi applicazione che non implementi i token CSRF.

Login CSRF: l'attaccante contraffatta una richiesta di login utilizzando le proprie credenziali, in modo che la vittima finisca per autenticarsi nell'account dell'attaccante. Qualsiasi dato inserito dall'utente in seguito (indirizzi, numeri di carta, dati personali) finirà nelle mani dell'attaccante.

Stored CSRF: il payload malevolo viene salvato all'interno dell'applicazione stessa, ad esempio in un campo del profilo o in un commento, e si attiva quando un altro utente visualizza quella pagina. Se il visualizzatore è un amministratore, le conseguenze sono molto più gravi rispetto a un attacco "one-shot".


Come difendersi

CSRF token (Synchronizer Token Pattern)

Il server genera un token casuale per ogni sessione, lo include nel form come campo nascosto e verifica che sia presente e corretto quando arriva la richiesta. Se non corrisponde, la richiesta viene rifiutata con un errore 403.

L'attaccante non può leggere il token dalla pagina legittima a causa della Same-Origin Policy, quindi non può includerlo nella richiesta "contraffatta".

Requisiti minimi affinché questo meccanismo funzioni: il token deve essere generato con un CSPRNG, avere almeno 128 bit di entropia (32 caratteri esadecimali), essere legato alla sessione e essere invalidato al logout. Un token debole o prevedibile rende inutile l'intero meccanismo.

Un attributo dei cookie che istruisce il browser a non allegarli alle richieste cross-site. Supportato da tutti i browser moderni.

Set-Cookie: session=abc123; SameSite=Strict; Secure; HttpOnly

SameSite=Strict blocca il cookie su qualsiasi richiesta cross-site, incluse le navigazioni da link esterni. SameSite=Lax (il default di Chrome dal 2020) lo invia solo per navigazioni GET di primo livello. SameSite=None rimuove ogni protezione e dovrebbe essere usato solo quando strettamente necessario (ad esempio, widget di terze parti che richiedono autenticazione).

SameSite dovrebbe essere usato insieme ai token CSRF, non al loro posto. Esistono casi limite (vecchi browser, particolari configurazioni di proxy) in cui SameSite da solo non è sufficiente.

Controllo dell'header Origin

Il server controlla l'header Origin della richiesta e la rifiuta se non proviene dal dominio previsto:

def verify_origin(request):
    origin = request.headers.get('Origin') or request.headers.get('Referer', '')
    if not origin.startswith('https://my-app.com'):
        raise PermissionError("Unauthorized origin")

Alcuni browser e proxy rimuovono l'header Referer, quindi questo controllo da solo non è sufficiente.

Utile per le API stateless. Il server genera un token casuale, lo invia sia come cookie che nel corpo/header della richiesta e verifica che i due corrispondano. L'attaccante non può leggere il valore del cookie da un altro dominio a causa della Same-Origin Policy, quindi non può costruire una richiesta valida.


Implementazione in PHP, Django e REST API

PHP Nativo

// Token generation
session_start();

if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

$csrf_token = $_SESSION['csrf_token'];
<form action="/transfer" method="POST">
    <input type="hidden" name="csrf_token" value="<?= htmlspecialchars($csrf_token) ?>">
    <!-- other fields -->
    <button type="submit">Confirm</button>
</form>
// Validation on receipt
session_start();

function validate_csrf(string $received_token): void {
    if (
        empty($_SESSION['csrf_token']) ||
        !hash_equals($_SESSION['csrf_token'], $received_token)
    ) {
        http_response_code(403);
        die('Invalid request');
    }
}

validate_csrf($_POST['csrf_token'] ?? '');

L'uso di hash_equals() invece di === previene gli timing attacks, in cui un attaccante potrebbe dedurre la lunghezza del token misurando i tempi di risposta del confronto.

Django

Django ha la protezione CSRF abilitata di default. Non disabilitarla.

# settings.py - middleware already included by default
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    # ...
]
<!-- In every POST form -->
<form method="post" action="/transfer/">
    {% csrf_token %}
    <!-- other fields -->
</form>

Per le chiamate fetch/axios dal frontend JavaScript:

function getCookie(name) {
    const value = `; ${document.cookie}`;
    const parts = value.split(`; ${name}=`);
    if (parts.length === 2) return parts.pop().split(';').shift();
}

fetch('/api/transfer/', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-CSRFToken': getCookie('csrftoken'),
    },
    body: JSON.stringify({ amount: 500, iban: '...' })
});

REST API con JWT

Le API stateless che utilizzano JWT nell'header Authorization non soffrono di CSRF classico: il browser non aggiunge automaticamente header personalizzati nel modo in cui aggiunge i cookie. Il problema sorge quando il JWT viene salvato in un cookie per comodità, un pattern piuttosto comune. In quel caso l'applicazione è nuovamente esposta e necessita di SameSite=Strict sul cookie o del pattern Double Submit Cookie.

// Safe pattern: JWT in the header, not in a cookie
fetch('/api/transfer', {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${localStorage.getItem('jwt')}`,
        'Content-Type': 'application/json',
    },
    body: JSON.stringify(payload)
});

Errori comuni

Utilizzare GET per operazioni con effetti collaterali. Le richieste GET devono essere idempotenti. Qualsiasi operazione che modifichi lo stato dell'applicazione (eliminazioni, aggiornamenti, trasferimenti) deve passare attraverso POST, PUT o DELETE.

// Bad
// /admin/delete-user?id=42
if (isset($_GET['id'])) {
    $db->deleteUser($_GET['id']);
}

Un token generato male. Un token derivato da dati prevedibili come l'ID della sessione vanifica l'intero meccanismo:

$token = md5(session_id()); // Bad, predictable
$token = bin2hex(random_bytes(32)); // Good, 256 bits of random entropy

Uso imprudente di @csrf_exempt. In Django (e gli equivalenti in altri framework), questo decoratore dovrebbe essere utilizzato solo su endpoint che ricevono richieste da sistemi esterni non basati su browser, come webhook o integrazioni server-to-server. Mai su endpoint raggiungibili da utenti autenticati tramite browser.


Per scegliere il proxy più adatto a queste verifiche, consulta anche il confronto operativo tra Burp Suite e OWASP ZAP.

Testing

Testing manuale con Burp Suite: intercetta una richiesta POST autenticata, rimuovi il token CSRF dal corpo e riesegui la richiesta. Se il server risponde con 200, l'endpoint è vulnerabile. Burp dispone anche di Engagement Tools > Generate CSRF PoC, che costruisce automaticamente un file HTML di test dalla richiesta intercettata.

Con OWASP ZAP: lo scanner attivo analizza i moduli dell'applicazione e segnala quelli privi di token. Utile per un controllo sistematico su applicazioni con molti endpoint.


Confronto dei meccanismi

Meccanismo Efficacia Quando usarlo
CSRF token (Synchronizer) Alta Applicazioni con sessioni lato server
SameSite=Strict/Lax Alta Sempre, come livello extra
Double Submit Cookie Media-Alta API stateless con cookie
Controllo Origin/Referer Media Come complemento
JWT nell'header Authorization Alta REST API senza cookie di sessione

Risorse