Come funziona il sistema di autenticazione di Django?

Question

Accepted Answer

Django include un **sistema di autenticazione** completo e integrato (`django.contrib.auth`) che gestisce **utenti**, **password**, **sessioni/login** e **permessi** — un'altra funzionalità "batteries-included" che ti evita di costruire (e sbagliare) questa funzionalità critica per la sicurezza.

## Il modello User e la creazione di utenti

```python
from django.contrib.auth.models import User

# passwords are HASHED automatically — never store plaintext
user = User.objects.create_user(username="ann", email="a@x.com", password="secret")
user.set_password("newpassword")        # always use set_password (it hashes)
user.check_password("secret")            # verify a password (constant-time)
```

Il modello `User` integrato gestisce automaticamente l'**hashing sicuro delle password** (utilizzando algoritmi forti come PBKDF2) — non memorizzi mai o confronti password in testo semplice, eliminando un rischio di sicurezza importante.

## Autenticazione e login

```python
from django.contrib.auth import authenticate, login, logout

def login_view(request):
    user = authenticate(request, username=username, password=password)  # verify credentials
    if user is not None:
        login(request, user)             # establish a SESSION (sets request.user)
        return redirect("home")
    # else: invalid credentials

def logout_view(request):
    logout(request)                       # clear the session
```

`authenticate()` verifica le credenziali e `login()` stabilisce una sessione — dopodiché `request.user` è l'utente collegato su ogni richiesta (tramite il middleware di autenticazione).

## Proteggere le view (richiedere il login)

```python
from django.contrib.auth.decorators import login_required

@login_required                          # redirect to login if not authenticated
def dashboard(request):
    return render(request, "dashboard.html", {"user": request.user})

# for class-based views:
from django.contrib.auth.mixins import LoginRequiredMixin
class DashboardView(LoginRequiredMixin, ListView): ...
```

## Permessi e autorizzazione

```python
# checking permissions
request.user.is_authenticated            # is someone logged in?
request.user.is_staff / is_superuser     # role flags
request.user.has_perm("blog.add_article")# a specific permission
request.user.groups.all()                 # group membership (role-based access)

@permission_required("blog.add_article")
def create_article(request): ...
```

Django distingue **autenticazione** (chi sei — login) da **autorizzazione** (cosa puoi fare — permessi). Fornisce permessi per-modello (aggiungi/modifica/elimina/visualizza), gruppi per l'accesso basato su ruoli, e decorator/mixin per applicarli.

## View di autenticazione integrate e personalizzazione

```text
✓ Ready-made views/URLs for login, logout, password change/reset (django.contrib.auth.urls)
✓ Customizable: a CUSTOM USER MODEL (recommended from the start) to add fields,
  custom backends (e.g. authenticate via email or OAuth), password validators
```

## Perché è importante

Il sistema di autenticazione integrato di Django è una funzionalità importante e critica per la sicurezza che ti evita di costruire una delle parti più soggette a errori e pericolose di un'applicazione web.
": Comprenderlo è essenziale perché praticamente ogni applicazione reale ha bisogno di account utente, login e controllo degli accessi — e sbagliare l'autenticazione **crea vulnerabilità di sicurezza serie** (password in testo semplice, hashing debole, difetti di sessione).

Il sistema di Django gestisce questi aspetti correttamente da subito: **esegue l'hashing delle password in modo sicuro** (algoritmi forti, mai testo semplice — usi `create_user`/`set_password`/`check_password` invece di gestire le password manualmente), gestisce le sessioni e il login (`authenticate`/`login`, con `request.user` disponibile ovunque tramite middleware), e fornisce autorizzazione tramite un **sistema completo di permessi e gruppi**.

Sapere come creare e autenticare gli utenti, proteggere le view (`@login_required`, `LoginRequiredMixin`), e applicare **autorizzazione** tramite permessi e gruppi (distinguendo autenticazione — chi sei — da autorizzazione — cosa ti è permesso fare) è fondamentale per costruire applicazioni sicure.

L'estensibilità del sistema — in particolare l'uso di un **modello utente personalizzato** (fortemente consigliato dall'inizio del progetto) per aggiungere campi, e backend personalizzati per login via email/OAuth — è una conoscenza pratica importante.

Poiché l'autenticazione è sia ubiqua che critica per la sicurezza, e poiché Django fornisce una soluzione robusta, corretta e batteries-included, padroneggiare il suo sistema di autenticazione è una conoscenza fondamentale che ti permette di costruire applicazioni sicure rivolte agli utenti senza reinventare (e rischiare) questa funzionalità basilare.