OAuth 2.0: implementazione in un'applicazione

Dopo aver esaminato i fondamenti di OAuth 2.0 ora ci concentriamo sulla sua implementazione pratica in un’applicazione web. OAuth 2.0 è uno standard di autorizzazione che consente a un’app di ottenere accesso alle risorse di un utente senza dover gestire direttamente le sue credenziali. In questa lezione, esploreremo i principali flussi di OAuth 2.0, vedremo come integrarli in un’applicazione web e discuteremo le sfide e le best practices.

Flussi di OAuth 2.0

Come abbiamo già visto nella lezione precedente OAuth 2.0 definisce diversi flussi (grant types) che si adattano a vari scenari. I più rilevanti per un’applicazione web sono:

1. Authorization Code Flow (Flusso del codice di autorizzazione).

2. Implicit Flow (Flusso implicito, ormai deprecato per motivi di sicurezza).

3. Client Credentials Flow (Flusso delle credenziali client, usato per applicazioni server-to-server).

4. Resource Owner Password Credentials Flow (Flusso delle credenziali del proprietario della risorsa, non consigliato per applicazioni moderne).

Per la nostra implementazione, useremo l’Authorization Code Flow, che è il più sicuro e adatto per applicazioni web che interagiscono con un Identity Provider (IdP).

Configurazione di un Identity Provider (IdP)

Per integrare OAuth 2.0 in un’app web, abbiamo bisogno di un Identity Provider che gestisca l’autenticazione degli utenti e rilasci i token di accesso. Possiamo scegliere tra diversi IdP noti, come:

• Google OAuth 2.0: facile da integrare, ampiamente supportato, utile per applicazioni che richiedono autenticazione tramite account Google.

• Auth0: fornisce un’ampia gamma di funzionalità di autenticazione e autorizzazione con un’interfaccia intuitiva.

• Okta: simile ad Auth0, ma più focalizzato su aziende con esigenze di gestione delle identità più complesse.

• Microsoft Entra ID (ex Azure AD): ideale per ambienti aziendali e integrazione con le applicazioni Microsoft.

• Keycloak: soluzione open source che permette un controllo completo sulla gestione delle identità e può essere ospitata in locale.

Supponiamo di usare Auth0 per la nostra implementazione. I passi iniziali sono:

1. Creiamo un account su Auth0 e registriamo una nuova applicazione.

2. Configuriamo i redirect URI, ovvero gli URL ai quali Auth0 invierà il codice di autorizzazione dopo l’autenticazione.

3. Otteniamo le credenziali client: Client ID e Client Secret.

Implementazione di OAuth 2.0 con l’Authorization Code Flow

Di saguito tutti i passaggi del nostro workflow.

Passo 1: Iniziare la richiesta di autorizzazione

Il primo passo consiste nel reindirizzare l’utente alla pagina di login dell’IdP. Supponiamo che la nostra applicazione sia sviluppata con PHP.

Nel frontend, possiamo creare un link per avviare il processo di autenticazione:

$auth_url = "https://YOUR_AUTH0_DOMAIN/authorize?" . http_build_query([
    'client_id' => 'YOUR_CLIENT_ID',
    'response_type' => 'code',
    'redirect_uri' => 'https://your-app.com/callback',
    'scope' => 'openid profile email',
    'state' => bin2hex(random_bytes(16))
]);
?>
<a href="<?php echo $auth_url; ?>">Login con Auth0</a>

Passo 2: Ricevere il codice di autorizzazione

Dopo l’autenticazione, Auth0 reindirizza l’utente all’URL specificato in redirect_uri con un parametro code. Questo codice serve per ottenere il token di accesso.

Nel backend (PHP), creiamo un endpoint per gestire questa richiesta:

if (isset($_GET['code'])) {
    $code = $_GET['code'];
    $response = file_get_contents('https://YOUR_AUTH0_DOMAIN/oauth/token', false, stream_context_create([
        'http' => [
            'method' => 'POST',
            'header' => "Content-Type: application/x-www-form-urlencoded\r\n",
            'content' => http_build_query([
                'grant_type' => 'authorization_code',
                'client_id' => 'YOUR_CLIENT_ID',
                'client_secret' => 'YOUR_CLIENT_SECRET',
                'code' => $code,
                'redirect_uri' => 'https://your-app.com/callback'
            ]),
        ]
    ]));
    $data = json_decode($response, true);
    setcookie("access_token", $data['access_token'], time() + 3600, "/", "", true, true);
    header("Location: /dashboard");
    exit;
}

Passo 3: Usare il token per autenticare le richieste API

Ora che abbiamo ottenuto il token di accesso, possiamo usarlo per richieste autenticate alle API. Ad esempio, se abbiamo un’API protetta che restituisce i dati dell’utente:

if (!isset($_COOKIE['access_token'])) {
    http_response_code(401);
    echo 'Non autorizzato';
    exit;
}
$token = $_COOKIE['access_token'];
$userInfo = file_get_contents('https://YOUR_AUTH0_DOMAIN/userinfo', false, stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => "Authorization: Bearer $token\r\n"
    ]
]));
echo $userInfo;

Nel flusso OAuth 2.0 con PHP, il processo si svolge in questi passi:

1. L’utente clicca sul pulsante di login, che reindirizza all’Identity Provider con i parametri necessari.

2. L’utente si autentica presso l’IdP, che dopo il login reindirizza l’utente al nostro callback URL con un code di autorizzazione.

3. Il nostro server PHP riceve il code e lo scambia con un token di accesso facendo una richiesta HTTP POST all’IdP.

4. Riceviamo il token di accesso che viene salvato in un cookie sicuro per le richieste future.

5. L’utente viene reindirizzato alla dashboard e può ora accedere a risorse protette con il token.

6. Quando il client effettua richieste API, il token viene incluso nell’header Authorization: Bearer consentendo l’accesso ai dati protetti.

Questa sequenza garantisce sicurezza ed efficienza nella gestione delle autenticazioni.

Considerazioni sulla sicurezza con OAuth 2.0

Durante l’implementazione di OAuth 2.0 in un’applicazione web, è essenziale seguire una serie di best practices per garantire che il processo di autenticazione e autorizzazione avvenga in modo sicuro e protetto contro le vulnerabilità. Ecco alcune raccomandazioni fondamentali:

1. Non memorizzare il token di accesso nel localStorage o sessionStorage: questi meccanismi di archiviazione client-side non sono sicuri, in quanto sono vulnerabili a attacchi di tipo Cross-Site Scripting (XSS) che potrebbero consentire ad un attaccante di accedere ai dati sensibili come i token di autenticazione. Per minimizzare il rischio di esposizione, è preferibile evitare di memorizzare i token in queste aree.

2. Utilizzare Secure Cookies: è altamente consigliato conservare i token di accesso in cookie protetti con gli attributi httpOnly e Secure. Il flag httpOnly impedisce l'accesso al cookie tramite JavaScript, riducendo il rischio di furto attraverso attacchi XSS. Il flag Secure, invece, garantisce che il cookie venga trasmesso solo su connessioni HTTPS, proteggendo i dati durante il loro invio in rete.

3. Verificare sempre il token prima di accedere a risorse protette: è fondamentale validare il token di accesso ogni volta che si tenta di accedere a risorse protette. Questo passaggio è cruciale per garantire che il token non sia stato manomesso o che non sia scaduto, impedendo così accessi non autorizzati alle informazioni riservate.

4. Implementare il refresh token: per migliorare l'esperienza utente è consigliabile utilizzare un meccanismo di refresh token. Questo consente di ottenere nuovi token di accesso senza richiedere all'utente di autenticarsi nuovamente, riducendo il numero di volte in cui egli è costretto a fornire le proprie credenziali. I refresh token devono essere conservati in modo sicuro ed essere gestiti in modo da evitare che vengano rubati o abusati.

5. Utilizzare PKCE (Proof Key for Code Exchange): l'adozione di PKCE è fondamentale per proteggere il codice di autorizzazione, specialmente quando l’applicazione è mobile o in scenari di client pubblico. PKCE aggiunge un ulteriore strato di sicurezza durante il processo di scambio del codice di autorizzazione, evitando che un attaccante possa intercettare e utilizzare un codice di autorizzazione per ottenere un token di accesso.

Conclusioni

Adottando queste best practices, è possibile migliorare significativamente la sicurezza nell'implementazione di OAuth 2.0, proteggendo sia gli utenti che i sistemi da attacchi informatici e potenziali vulnerabilità.

Abbiamo visto come implementare OAuth 2.0 in un’applicazione web utilizzando il Authorization Code Flow con Auth0 in PHP. Questo flusso è la scelta migliore per garantire sicurezza e scalabilità. Nei prossimi passi possiamo approfondire l’integrazione con JSON Web Tokens (JWT) per gestire la sessione dell’utente e proteggere le API. Argomento che tratteremo nella prossima lezione.