Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Verifica dei token web JSON
I token web JSON (JWTs) possono essere decodificati, letti e modificati facilmente. Un token di accesso modificato crea un rischio di escalation dei privilegi. Un token ID modificato crea un rischio di impersonificazione. L'applicazione considera attendibile il pool di utenti come emittente di token, ma cosa succede se un utente intercetta il token in transito? Devi assicurarti che la tua applicazione riceva lo stesso token emesso da Amazon Cognito.
Amazon Cognito emette token che utilizzano alcune delle funzionalità di integrità e riservatezza della specifica OpenID Connect (OIDC). I token del pool di utenti indicano la validità con oggetti come l'ora di scadenza, l'emittente e la firma digitale. La firma, il terzo e ultimo segmento del JWT `.` delimitato, è il componente chiave della convalida dei token. Un utente malintenzionato può modificare un token, ma se l'applicazione recupera la chiave pubblica e confronta la firma, questa non corrisponderà. Qualsiasi applicazione che elabora JWTs l'autenticazione OIDC deve eseguire questa operazione di verifica a ogni accesso.
In questa pagina, forniamo alcuni consigli generali e specifici per la verifica di. JWTs Lo sviluppo di applicazioni abbraccia una varietà di linguaggi e piattaforme di programmazione. Poiché Amazon Cognito implementa OIDC in modo sufficientemente simile alle specifiche pubbliche, qualsiasi libreria JWT affidabile nel tuo ambiente di sviluppo preferito può gestire i tuoi requisiti di verifica.
Queste fasi descrivono la verifica del token JWT (JSON Web Token) di un bacino d'utenza.
**Topics**
+ [Prerequisiti](#amazon-cognito-user-pools-using-tokens-prerequisites)
+ [Convalida i token con aws-jwt-verify](#amazon-cognito-user-pools-using-tokens-aws-jwt-verify)
+ [Comprensione e ispezione dei token](#amazon-cognito-user-pools-using-tokens-manually-inspect)
## Prerequisiti
La tua libreria, il tuo SDK o il tuo framework software potrebbero già gestire le attività descritte in questa sezione. AWS SDKs fornisci strumenti per la gestione e la gestione dei token del pool di utenti di Amazon Cognito nella tua app. AWS Amplify include funzioni per recuperare e aggiornare i token Amazon Cognito.
Per ulteriori informazioni, consulta le pagine seguenti.
+ [Integrazione dell'autenticazione e dell'autorizzazione di Amazon Cognito con app web e mobili](cognito-integrate-apps.md)
+ [Esempi di codice per l'utilizzo di Amazon Cognito Identity Provider AWS SDKs](https://docs.aws.amazon.com/cognito/latest/developerguide/service_code_examples.html)
+ [Advanced workflows](https://docs.amplify.aws/lib/auth/advanced/q/platform/js/#retrieve-jwt-tokens) (Flussi di lavoro avanzati) in *Amplify Dev Center* (Centro per sviluppatori Amplify)
Per la decodifica e la verifica di un token Web JSON (JWT) sono disponibili numerose librerie. Queste librerie sono utili se vuoi gestire i token manualmente per l'elaborazione dell'API lato server oppure se stai usando altri linguaggi di programmazione. Consulta [l'elenco di librerie OpenID Foundation per l'operatività con i token JWT](http://openid.net/developers/jwt/).
## Convalida i token con aws-jwt-verify
In un'app Node.js, AWS consiglia alla [aws-jwt-verifylibreria](https://github.com/awslabs/aws-jwt-verify) di convalidare i parametri nel token che l'utente passa all'app. Con `aws-jwt-verify` puoi popolare `CognitoJwtVerifier` con i valori delle attestazioni che desideri verificare per uno o più pool di utenti. Di seguito sono riportati alcuni valori che possono essere verificati.
+ Verifica che i token di accesso o ID non siano malformati o scaduti e abbiano una firma valida.
+ Verifica che i token di accesso provengano dai [pool di utenti e dai client dell'app corretti](https://github.com/awslabs/aws-jwt-verify#verifying-jwts-from-amazon-cognito).
+ Le dichiarazioni relative al token di accesso contengono gli [ambiti OAuth 2.0 corretti](https://github.com/awslabs/aws-jwt-verify#checking-scope).
+ Verifica che le chiavi che hanno firmato i token ID e di accesso [corrispondano a una chiave di firma `kid` dell'*URI JWKS* dei pool di utenti](https://github.com/awslabs/aws-jwt-verify#the-jwks-cache).
L'URI JWKS contiene le informazioni pubbliche sulla chiave privata usata per la firma del token dell'utente. Puoi trovare l'URI JWKS del tuo pool di utenti all'indirizzo `https://cognito-idp..amazonaws.com//.well-known/jwks.json`.
Per ulteriori informazioni e codice di esempio che è possibile utilizzare in un'app Node.js o in un programma di AWS Lambda autorizzazione, vedere [https://github.com/awslabs/aws-jwt-verify](https://github.com/awslabs/aws-jwt-verify)su. GitHub
## Comprensione e ispezione dei token
Prima di integrare l'ispezione dei token con la tua app, considera come si assembla Amazon Cognito. JWTs Recupera i token di esempio dal pool di utenti, decodificali ed esaminali accuratamente per comprenderne le caratteristiche e determinare cosa vuoi verificare e quando. Ad esempio, potresti voler esaminare l'appartenenza al gruppo in uno scenario e gli ambiti in un altro.
Le seguenti sezioni descrivono un processo per ispezionare manualmente Amazon JWTs Cognito durante la preparazione dell'app.
### Conferma della struttura del JWT
Un token Web JSON (JWT) include tre sezioni separate con il delimitatore `.` (punto).
**Header**
L'ID della chiave (`kid`) e l'algoritmo RSA (`alg`) utilizzati da Amazon Cognito per firmare il token. Amazon Cognito firma i token con un `alg` di `RS256`. `kid`È un riferimento troncato a una chiave di firma privata RSA a 2048 bit detenuta dal tuo pool di utenti.
**Carico utile**
Le attestazioni del token. In un token ID, le attestazioni includono gli attributi dell'utente e le informazioni sul pool di utenti (`iss`) e sul client dell'app (`aud`). In un token di accesso, il payload include gli ambiti, l'appartenenza al gruppo, il pool di utenti come `iss` e il client dell'app come `client_id`.
**Firma**
La firma non è decodificabile in base64url come l'header e il payload. È un RSA256 identificatore derivato da una chiave di firma e da parametri che puoi osservare nel tuo URI JWKS.
L'header e il payload sono JSON con codifica base64url. Puoi identificarli tramite i caratteri di apertura `eyJ` che si decodificano nel carattere iniziale `{`. Se l'utente presenta alla tua app un JWT con codifica base64url e non è nel formato`[JSON Header].[JSON Payload].[Signature]`, non è un token Amazon Cognito valido e puoi eliminarlo.
L'applicazione di esempio seguente verifica i token del pool di utenti con. `aws-jwt-verify`
```
// cognito-verify.js
// Usage example: node cognito-verify.js eyJra789ghiEXAMPLE
const { CognitoJwtVerifier } = require('aws-jwt-verify');
// Replace with your Amazon Cognito user pool ID
const userPoolId = 'us-west-2_EXAMPLE';
async function verifyJWT(token) {
try {
const verifier = CognitoJwtVerifier.create({
userPoolId,
tokenUse: 'access', // or 'id' for ID tokens
clientId: '1example23456789', // Optional, only if you need to verify the token audience
});
const payload = await verifier.verify(token);
console.log('Decoded JWT:', payload);
} catch (err) {
console.error('Error verifying JWT:', err);
}
}
// Example usage
if (process.argv.length < 3) {
console.error('Please provide a JWT token as an argument.');
process.exit(1);
}
const MyToken = process.argv[2];
verifyJWT(MyToken);
```
### Convalida del JWT
La firma JWT è una combinazione con hash di intestazione e payload. Amazon Cognito genera due coppie di chiavi di crittografia RSA per ogni bacino d'utenza. Una chiave privata firma i token di accesso e l'altra i token ID.
**Per verificare la firma di un token JWT**
1. Decodifica il token ID.
Anche OpenID Foundation [mantiene un elenco di librerie per l'utilizzo di token JWT](http://openid.net/developers/jwt/).
È inoltre possibile utilizzarlo AWS Lambda per decodificare il pool di utenti. JWTs Per ulteriori informazioni, consulta [Decodificare e verificare utilizzando i token Amazon Cognito JWT](https://github.com/awslabs/aws-support-tools/tree/master/Cognito/decode-verify-jwt). AWS Lambda
1. Confronta l'ID della chiave (`kid`) locale con il `kid` pubblico.
1. Scarica e archivia la chiave JWK (JSON Web Key) pubblica corrispondente per il tuo bacino d'utenza. È disponibile come parte di un set JWKS (JSON Web Key Set). Puoi individuarlo creando il seguente URI `jwks_uri` per l'ambiente:
```
https://cognito-idp..amazonaws.com//.well-known/jwks.json
```
Per ulteriori informazioni su JWK e JWKS, consulta l'articolo su [JSON Web Key (JWK)](https://tools.ietf.org/html/rfc7517).
**Nota**
Amazon Cognito può alternare le chiavi di firma nel pool di utenti. Come procedura consigliata, memorizza nella cache le chiavi pubbliche dell'app utilizzando il `kid` come chiave di cache e aggiorna periodicamente la cache. Confronta il `kid` nei token che la tua app riceve nella cache.
Se ricevi un token con l'emittente corretto ma un diverso `kid`, è possibile che Amazon Cognito abbia alternato la chiave di firma. Aggiorna la cache dall'endpoint `jwks_uri` del pool di utenti.
Questo è un file `jwks.json` di esempio:
```
{
"keys": [{
"kid": "1234example=",
"alg": "RS256",
"kty": "RSA",
"e": "AQAB",
"n": "1234567890",
"use": "sig"
}, {
"kid": "5678example=",
"alg": "RS256",
"kty": "RSA",
"e": "AQAB",
"n": "987654321",
"use": "sig"
}]
}
```
**ID chiave (`kid`)**
Il `kid` è un suggerimento che indica quale chiave è stata utilizzata per proteggere la JSON Web Signature (JWS) del token.
**Algoritmo (`alg`)**
Il parametro di intestazione `alg` rappresenta l'algoritmo di crittografia utilizzato per proteggere il token ID. I pool di utenti utilizzano un algoritmo RS256 crittografico, che è una firma RSA con SHA-256. Per ulteriori informazioni su RSA, consulta [crittografia RSA](https://tools.ietf.org/html/rfc3447).
**Tipo di chiavi (`kty`)**
Il parametro `kty` identifica la famiglia di algoritmi di crittografia usata con la chiave, come "RSA" in questo esempio.
**Esponente RSA (`e`)**
Il parametro `e` contiene il valore dell'esponente per la chiave pubblica RSA. È rappresentato come valore codificato in Base64url. UInt
**Modulo RSA (`n`)**
Il parametro `n` contiene il valore del modulo per la chiave pubblica RSA. È rappresentato come valore con codifica Base64url. UInt
**Utilizza (`use`)**
Il parametro `use` descrive l'uso previsto della chiave pubblica. Per questo esempio, il valore `use` value `sig` rappresenta la firma.
1. Cerca la JSON Web Key pubblica per un `kid` che corrisponde al `kid` del JWT.
### Verifica delle attestazioni
**Per verificare le attestazioni JWT**
1. Con uno dei seguenti metodi, verifica che il token non sia scaduto.
1. Decodifica il token e confronta la richiesta `exp` con l'ora corrente.
1. Se il tuo token di accesso include un `aws.cognito.signin.user.admin` reclamo, invia una richiesta a un'API come. [GetUser](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_GetUser.html) Le richieste API di [autorizzazione con un token di accesso](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pools-API-operations.html#user-pool-apis-auth-unauth) restituiscono un errore se il token è scaduto.
1. Presenta il tuo token di accesso in una richiesta a [Endpoint UserInfo](userinfo-endpoint.md). La tua richiesta restituisce un errore se il token è scaduto.
1. L'attestazione `aud` in un token ID e l'attestazione `client_id` in un token di accesso deve corrispondere all'ID client di app creato nel bacino d'utenza di Amazon Cognito.
1. L'attestazione dell'approvatore (`iss`) deve corrispondere al bacino d'utenza. Ad esempio, un bacino d'utenza creato nella regione `us-east-1` avrà un valore `iss` di:
`https://cognito-idp.us-east-1.amazonaws.com/`.
1. Controlla l'attestazione `token_use`.
+ Se accetti il token di accesso solo nelle operazioni dell'API Web, il valore deve essere `access`.
+ Se utilizzi solo il token ID, il valore deve essere `id`.
+ Se si usano sia ID sia token di accesso, l'attestazione `token_use` deve essere `id` o `access`.
Ora è possibile considerare attendibili le attestazioni all'interno del token.