Comprensione dei token Django CSRF: cosa sono e perché ne hai bisogno

Django è un framework Web Python che puoi utilizzare per creare applicazioni Web sicure. Offre molte funzionalità per aiutare gli sviluppatori con la sicurezza. Una di queste funzionalità sono i token CSRF, essenziali per proteggere i moduli dagli attacchi Cross-Site Request Forgery.

Cos'è un token CSRF?

Un token CSRF è una funzione di sicurezza che protegge le applicazioni Web da Attacchi Cross-Site Request Forgery (CSRF).. Consente al server delle applicazioni di verificare se l'invio di un modulo proviene da un browser autentico o se è stato falsificato da un hacker.

I token CSRF sono input di moduli che tengono traccia di una sessione utente. Un sito web framework per applicazioni web lato server in genere genera token CSRF per ogni sessione utente univoca. Il server controlla se il token è corretto ogni volta che un utente invia un modulo. I token CSRF generalmente sono costituiti da stringhe e numeri casuali, rendendo i loro valori imprevedibili.

Generazione di token CSRF in Django

Di Django get_token() La funzione genera in modo casuale token CSRF. Per trovare questa funzione, vai al file csrf.py file all'interno del tuo Ambiente virtuale Python. La struttura delle cartelle dovrebbe essere simile a questa:

avv/
└──Lib/
 └── pacchetti-sito/
 └── django/
 └── middleware/
 └── csrf.py

All'interno di questo file troverai il file get_token() funzione, che restituisce il token. Django usa mascheramento dei dati per proteggere il valore del token dagli hacker.

Per impostazione predefinita, Django abilita la protezione CSRF per il tuo sito aggiungendo django.middleware.csrf. CsrfViewMiddleware nel MIDDLEWARE elenco dei tuoi impostazioni.py file. Tutto quello che devi fare è aggiungere {% csrf_token %} alla tua INVIARE forme. Senza aggiungere {% csrf_token %}, otterrai un 403 (proibito) errore quando si invia un modulo.

Quando aggiungi {% csrf_token %} al modulo, crea automaticamente un campo di input nascosto con il nome csrfmiddlewaretoken, che contiene il valore del token CSRF mascherato. Il server utilizza questo valore per determinare se l'invio del modulo è autentico. Puoi verificare il valore di questo campo nascosto visualizzando il sorgente della pagina o utilizzando la funzione degli strumenti per sviluppatori del tuo browser.

Come funzionano i token CSRF in Django

Quando avvii il tuo sito con il modulo, Django crea automaticamente un file cookie del browser chiamato token. Questo cookie tiene traccia dell'attività dell'utente sul sito e identifica in modo univoco ciascun utente.

Quando l'utente invia il modulo, il server confronta il valore del cookie con il valore del file csrfmiddlewaretoken nel campo di input nascosto. Se questi valori corrispondono, il server elaborerà il modulo con successo, altrimenti produrrà un errore.

A prima vista, i valori del cookie e del file csrfmiddlewaretoken sembrano essere diversi. Questo è intenzionale e aggiunge un ulteriore livello di protezione al token CSRF. Il token CSRF viene confrontato con il cookie in questo modo:

• IL get_token() La funzione maschera il token CSRF prima di passarlo al campo di input.
• Quando il modulo viene inviato, il token CSRF viene smascherato con l'aiuto della chiave segreta nel file delle impostazioni.
• Il token non mascherato viene confrontato con il cookie di sessione.
• Se i valori sono gli stessi, il modulo viene elaborato. In caso contrario, il server restituisce un errore.

Per impedire agli hacker di rubare il tuo token CSRF, Django lo rinnova ogni volta che avvia una sessione utente.

Creazione di token CSRF personalizzati

Sebbene Django semplifichi la protezione dei moduli semplicemente aggiungendo il file {% csrf_token %}, è anche possibile generare token CSRF e aggiungerli manualmente ai moduli. Per fare ciò, importa il file get_token() funzione:

da django.middleware.csrf importare get_token

A tuo avviso, puoi generare il token CSRF in questo modo:

defnome_vista(richiesta):
 csrf_token = get_token (richiesta)
# esegue la logica di visualizzazione
 contesto = {
"csrf_token": csrf_token
 }
ritorno rendere (richiesta, 'nome_app/template.html', contesto=contesto)

Nel tuo modello HTML, puoi includere manualmente il tuo tag di input e aggiungere il file csrf_token ad esso in questo modo:

<modulometodo="INVIARE" >
<ingressotipo="nascosto"nome="token csrfmiddleware"valore="{{ csrf_token }}">
 {{form.as_p}}
<pulsantetipo="invia"classe="btn btn-contorno-secondario">Aggiungi libropulsante>
modulo>

In alternativa, puoi generare il campo di input nascosto dalle tue visualizzazioni in questo modo:

defil tuo punto di vista(richiesta):
 csrf_token = get_token (richiesta)
 csrf_token_html = ''.format (csrf_token)
# esegue la logica di visualizzazione
 contesto = {
"csrf_token": csrf_token_html
 }
ritorno rendere (richiesta, 'nome_app/template.html', contesto=contesto)

Puoi quindi aggiungerlo al tuo modello HTML in questo modo:

<modulometodo="INVIARE" >
 {{ csrf_token_html|sicuro }}
 {{form.as_p}}
<pulsantetipo="invia"classe="btn btn-contorno-secondario">Aggiungi libropulsante>
modulo>

Se vuoi controllare completamente la protezione CSRF del tuo modulo, puoi farlo confrontando il tuo token CSRF con il cookie memorizzato nel browser. Sulla base dei risultati del confronto, puoi gestire l'invio del modulo come preferisci. Ecco un esempio:

da django.scorciatoie importare rendere
da django.middleware.csrf importare get_token, _unmask_cipher_token
da django.utils.crypto importare constant_time_compare
defil tuo punto di vista(richiesta):
# Genera un token CSRF personalizzato
 csrf_token = get_token (richiesta)
 csrf_cookie = richiesta. COOKIES.get('csrftoken')
# smaschera il token csrf
 unmasked_csrf_token = _unmask_cipher_token (csrf_token) 

# Confronta i token
Senon constant_time_compare (unmasked_csrf_token, csrf_cookie):
# Gestisce il caso in cui i token non corrispondono
passaggio
altro:
# Gestisce il caso in cui i token corrispondono
passaggio

# Renderizza il modello
 contesto = {
'csrf_token': csrf_token,
 }
ritorno rendere (richiesta, 'nome_app/template.html', contesto=contesto)

Questo frammento di codice recupera il file csrf_cookie dall'oggetto richiesta HTTP. Quindi utilizza il file _unmask_cipher_token() funzione per smascherare il csrf_token.

Un'istruzione condizionale confronta i valori dell'oggetto recuperato csrf_cookie e gli smascherati csrf_token. Questo confronto utilizza il constant_time_compare funzione per proteggere dagli exploit di temporizzazione. Puoi scrivere la tua logica in base al risultato del confronto.

Disabilitare la protezione CSRF in Django

Anche se Django fornisce una protezione CSRF predefinita, puoi disabilitarla nel tuo progetto se lo desideri. Ci sono due modi per farlo:

• Disabilitare la protezione CSRF su tutto il tuo sito web.
• Disattivazione della protezione CSRF su una vista specifica.

Disabilitare la protezione CSRF sull'intero sito web

Per disabilitare la protezione CSRF di Django sul tuo sito web, devi semplicemente rimuovere il middleware CSRF dal tuo file delle impostazioni. Nel file delle impostazioni, individua un elenco chiamato MIDDLEWARE. All'interno dell'elenco, cerca questo:

'django.middleware.csrf. CsrfViewMiddleware',

Una volta trovato, dovresti rimuoverlo dal tuo codice per la protezione CSRF predefinita di Django per disabilitarlo.

Disattivazione della protezione CSRF su una vista specifica

Se vuoi solo disabilitare la protezione CSRF su una vista Django specifica, usa il file @csrf_exempt decoratore. Ecco uno snippet di codice da dimostrare:

da django.views.decorators.csrf importare csrf_esente
@csrf_exempt
defnome_vista(richiesta):
# esegue la logica di visualizzazione
passaggio

IL @csrf_exempt decorator è solo uno dei tanti relativi alla protezione CSRF in Django. Puoi leggere il resto su Riferimento CSRF di Django.

Non disabilitare la protezione CSRF sul tuo sito web

Sebbene Django lo renda possibile, non è consigliabile disabilitare il meccanismo di protezione CSRF integrato di Django. Ciò renderà il tuo sito vulnerabile agli attacchi CSRF e alla fine influenzerà negativamente gli utenti della tua app.

A meno che tu non sia uno sviluppatore esperto che sappia come implementare un meccanismo di protezione CSRF personalizzato, dovresti lavorare con l'alternativa fornita da Django.