Come descritto nelle specifiche OAuth 2.0, possiamo autenticare un client che presenta un ID client e un client secret validi al nostro Identity Provider. 

Come si può vedere nello schema, un client generico può chiamare le API di AWS Cognito con il client ID e il segreto condivisi con lo stesso. Se i due parametri sono validi, AWS Cognito restituisce un token di accesso. Da questo momento, l’applicazione di terze parti può effettuare chiamate autenticate mediante l’access token rilasciato da Cognito.

Ciò che va implementato lato servizi è la convalida del token JWT come descritto dalla specifica OAuth 2.0. Occorre.

1. Convalidare che il JWT ricevuto abbia un formato valido.
2. Convalidare la firma JWT.
3. Verifica tutti i claim.

Passiamo ora a configurare il flusso descritto all'interno del nostro account AWS.

Hands-on!

Ora che abbiamo descritto le principali funzioni di Amazon Cognito possiamo iniziare con il progetto. Prima di tutto, creiamo una User Pool dalla console AWS. Scegliamo un nome esplicativo e manteniamo tutte le impostazioni predefinite facendo clic sul pulsante "Review defaults".

A questo punto possiamo iniziare ad esplorare le numerose opzioni fornite dal nostro nuovo pool di utenti, modificando quelle necessarie per il nostro progetto.

Il server o servizio che erogherà le API da autenticare può essere specificato nella pagina “resource server” nelle opzioni della User Pool.

Qui sarai in grado di determinare l'URL univoco del server che espone le API che devi proteggere. Inoltre, in questa pagina è possibile elencare una serie di scopes per discriminare, ad esempio, vari livelli di accesso al servizio.

Ora che il server di risorse è stato configurato, possiamo occuparci delle impostazioni dei client dell'app.

In questa pagina è possibile definire un nuovo client, ad esempio una nuova web-app, che deve consumare il set di API che si desidera proteggere.

Specifichiamo il nome del nuovo client e la scadenza dei token di sicurezza utilizzati nel processo di autorizzazione. A causa delle specifiche OAuth2 non esiste un meccanismo di refresh del token, per cui è possibile solamente indicarne la scadenza. Quando il token non sarà più valido, occorrerà ripetere il flusso di autenticazione per ottenerne uno nuovo. 

Salvando questi dettagli, Cognito ci chiederà un client app ID e un segreto. Sebbene l'ID sia inteso come identificativo pubblico delle app, è importante non condividere mai né l'ID né il segreto per motivi di sicurezza.

Questi due token devono essere crittografati e archiviati da ciascuna delle applicazioni registrate per richiedere i token di accesso al pool di utenti Cognito. Sono essenzialmente il nome utente e la password dell'autorizzazione da sistema a sistema.

La tua app è ora registrata correttamente ed è possibile modificare le opzioni di autorizzazione che desideri abilitare per i suoi utenti dalla pagina di impostazioni.

Da questa pagina, puoi anche definire quali scope possono essere utilizzati da ogni client dell'app.

Come passaggio finale sulla console Cognito, è necessario scegliere un nome di dominio. In questa pagina, infatti, sceglieremo (se disponibile) dove le applicazioni invieranno le richieste di token di accesso.

Cognito è ora correttamente configurato.

import requests
 
TOKEN_ENDPOINT = 'https://system-to-system.auth.eu-west-1.amazoncognito.com/oauth2/token'
 
body = {
    'grant_type': 'client_credentials',
    'client_id': CLIENT_ID,
    'client_secret': CLIENT_SECRET,
    'scope': 'https://my-api-server.org/api.readwrite'
}
 
response = requests.post(TOKEN_ENDPOINT, data=body)
print(response.text)
 

Come si evince dallo snippet sopra, il recupero del token di accesso è una richiesta HTTP POST abbastanza semplice che necessita nel suo corpo dei pochi semplici parametri visti prima. L’endpoint è composto usando il dominio specificato nelle impostazioni di Cognito.

Il token di accesso che abbiamo appena ricevuto è pronto per essere spedito all'interno di una chiamata API al server che eroga le API autenticate. Quest'ultimo, quindi, deve essere in grado di decodificarlo e convalidarlo.

import functools
import json
import jwt
import urllib.request
def is_valid_token(scope) -> bool:
    def wrapped(func):
        @functools.wraps(func)
        def wrapper(access_token):
            public_keys = get_well_known_jwk(REGION, USER_POOL_ID)
            kid = jwt.get_unverified_header(access_token)['kid']
            key = public_keys[kid]
            payload = jwt.decode(access_token, key=key, algorithms=['RS256'])
            if payload['client_id'] != CLIENT_ID:
                print('Wrong client_id')
                raise Exception('Wrong client id')
            if payload['scope'] != scope:
                print('Wrong scope')
                raise Exception('Wrong scope')
            return func(access_token)
        return wrapper
    return wrapped
def get_well_known_jwk(region: str, user_pool_id: str) -> dict:
    jwk_url = f"https://cognito-idp.{region}.amazonaws.com/{user_pool_id}/.well-known/jwks.json"
    with urllib.request.urlopen(jwk_url) as url:
        jwks = json.loads(url.read().decode())
    public_keys = {}
    for jwk in jwks['keys']:
        kid = jwk['kid']
        public_keys[kid] = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(jwk))
    return public_keys
@is_valid_token(scope = 'https://my-api-server.org/api.write')
def api(access_token):
    resp = {
        "status_code": 200,
        "body": "This is your body."
    }
    print(json.dumps(resp))

È ora possibile testare la soluzione e autenticare altri servizi della propria applicazione.

È tutto per oggi! In questo articolo, abbiamo spiegato come creare un sistema di autenticazione di tipo macchina-macchina sicuro, affidabile e completamente gestito sfruttando Amazon Cognito e gli User Pool.

Contattateci o lasciateci un commento qui sotto per farci domande o semplicemente per aggiungere considerazioni sull’argomento.

Ci vediamo tra 14 giorni per il prossimo articolo sul blog #Proud2beCloud!