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à.
# Endpoint del pool di utenti e riferimento all'accesso gestito
Amazon Cognito offre due modelli di autenticazione dei pool di utenti: con l'API dei pool di utenti e con il server di autorizzazione OAuth 2.0. Usa l'API quando desideri recuperare i token OpenID Connect (OIDC) AWS con un SDK nel backend dell'applicazione. Utilizza il server di autorizzazione quando desideri implementare il tuo pool di utenti come provider OIDC. [Il server di autorizzazione aggiunge funzionalità come [l'accesso federato, l'](cognito-user-pools-identity-federation.md)[autorizzazione API e M2M con ambiti dei token di accesso e l'accesso gestito](cognito-user-pools-define-resource-servers.md).](cognito-user-pools-managed-login.md) [È possibile utilizzare i modelli API e OIDC singolarmente o insieme, configurati a livello di pool di utenti o a livello di client dell'app.](user-pool-settings-client-apps.md) Questa sezione è un riferimento per l'implementazione del modello OIDC. Per ulteriori informazioni sui due modelli di autenticazione, vedere. [Comprendere l'API, l'OIDC e l'autenticazione delle pagine di accesso gestite](authentication-flows-public-server-side.md#user-pools-API-operations)
Amazon Cognito attiva le pagine Web pubbliche elencate qui quando si assegna un dominio al pool di utenti. Il dominio funge da punto di accesso centrale per tutti i client dell'app. Includono l'accesso gestito, in cui gli utenti possono registrarsi e accedere ([Endpoint Login](login-endpoint.md)) e disconnettersi ([Endpoint Logout](logout-endpoint.md)). Per ulteriori informazioni su queste risorse, vedere [Accesso gestito dal pool di utenti](cognito-user-pools-managed-login.md).
Queste pagine includono anche le risorse Web pubbliche che consentono al pool di utenti di comunicare con provider di identità SAML, OpenID Connect (OIDC OAuth ) e 2.0 di terze parti (). IdPs Per accedere a un utente con un provider di identità federato, gli utenti devono inviare una richiesta all'accesso gestito interattivo o all'OIDC. [Endpoint Login](login-endpoint.md) [Endpoint Authorize](authorization-endpoint.md) L'endpoint Authorize reindirizza gli utenti alle pagine di accesso gestite o alla pagina di accesso IdP.
L'app può anche effettuare l'accesso come *utenti locali* con l'[API dei pool di utenti Amazon Cognito](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/Welcome.html). Un utente locale esiste esclusivamente nella directory del pool di utenti senza federazione tramite un IdP esterno.
Oltre all'accesso gestito, Amazon Cognito si integra con SDKs Android JavaScript, iOS e altro. SDKs Forniscono strumenti per eseguire operazioni API con pool di utenti con gli endpoint del servizio API Amazon Cognito. Per ulteriori informazioni su questi endpoint del servizio, consulta [Endpoint e quote di Amazon Cognito Identity](https://docs.aws.amazon.com/general/latest/gr/cognito_identity.html).
**avvertimento**
Non aggiungere i certificati Transport Layer Security (TLS) di entità finale o intermedi per i domini Amazon Cognito. AWS gestisce tutti i certificati per tutti gli endpoint e i domini con prefisso del pool di utenti. Le autorità di certificazione (CAs) nella catena di fiducia che supporta i certificati Amazon Cognito ruotano e si rinnovano dinamicamente. Quando aggiungi l'app a un certificato intermedio o principale, l'app può fallire senza preavviso durante la rotazione dei certificati. AWS
Associa invece la tua applicazione a tutti i [certificati root Amazon](https://www.amazontrust.com/repository/) disponibili. Per ulteriori informazioni, consulta le best practice e i suggerimenti in [Associazione dei certificati](https://docs.aws.amazon.com/acm/latest/userguide/acm-bestpractices.html#best-practices-pinning) nella *Guida per l'utente di AWS Certificate Manager *.
**Topics**
+ [Accesso gestito interattivo dall'utente ed endpoint dell'interfaccia utente ospitati in versione classica](managed-login-endpoints.md)
+ [Endpoint del provider di identità e del relying party](federation-endpoints.md)
+ [OAuth Sovvenzioni 2.0](federation-endpoints-oauth-grants.md)
+ [Utilizzo di PKCE nelle concessioni di codici di autorizzazione](using-pkce-in-authorization-code.md)
+ [Risposte gestite agli errori di accesso e federazione](federation-endpoint-idp-responses.md)
# Accesso gestito interattivo dall'utente ed endpoint dell'interfaccia utente ospitati in versione classica
Amazon Cognito attiva gli endpoint di accesso gestiti in questa sezione quando aggiungi un dominio al tuo pool di utenti. Sono pagine Web in cui gli utenti possono completare le operazioni di autenticazione di base di un pool di utenti. Includono pagine per la gestione delle password, l'autenticazione a più fattori (MFA) e la verifica degli attributi.
Le pagine Web che costituiscono l'accesso gestito sono un'applicazione Web front-end per sessioni utente interattive con i clienti. L'app deve richiamare l'accesso gestito nei browser degli utenti. Amazon Cognito non supporta l'accesso programmatico alle pagine Web di questo capitolo. Gli endpoint di federazione in [Endpoint del provider di identità e del relying party](federation-endpoints.md) che restituiscono una risposta JSON possono essere interrogati direttamente nel codice dell'app. I [Endpoint Authorize](authorization-endpoint.md) reindirizzamenti all'accesso gestito o a una pagina di accesso IdP devono inoltre essere aperti nei browser degli utenti.
Tutti gli endpoint del pool di utenti accettano traffico da e indirizzi IP di origine. IPv4 IPv6
Gli argomenti di questa guida descrivono in dettaglio l'accesso gestito di uso frequente e gli endpoint dell'interfaccia utente ospitati classici. La differenza tra l'accesso gestito e l'interfaccia utente ospitata è visibile, non funzionale. Ad eccezione di`/passkeys/add`, tutti i percorsi sono condivisi tra le due versioni del branding di accesso gestito.
Amazon Cognito rende disponibili le pagine Web seguenti quando si assegna un dominio al pool di utenti.
**Endpoint di accesso gestiti**
| URL dell'endpoint | Description | Modalità di accesso |
| --- | --- | --- |
| https:///login Your user pool domain | Accede agli utenti locali e federati del pool di utenti. | Esegui il reindirizzamento da endpoint come [Endpoint Authorize](authorization-endpoint.md), `/logout` e `/confirmforgotPassword`. Per informazioni, consulta [Endpoint Login](login-endpoint.md). |
| https:///logout Your user pool domain | Disconnette gli utenti del pool di utenti. | Collegamento diretto. Per informazioni, consulta [Endpoint Logout](logout-endpoint.md). |
| https:///ConfirmUser Your user pool domain | Conferma gli utenti che hanno selezionato un collegamento e-mail per verificare il proprio account utente. | Collegamento selezionato dall'utente in un messaggio di posta elettronica. |
| https:///registrazione Your user pool domain | Registra un nuovo utente. La pagina /login indirizza l'utente a /signup quando si seleziona Sign up (Registrati). | Collegamento diretto con gli stessi parametri di `/oauth2/authorize`. |
| https:///conferma Your user pool domain | Dopo che il pool di utenti invia un codice di conferma a un utente che ha effettuato la registrazione, richiede il codice all'utente. | Solo reindirizzamento da `/signup`. |
| https://Your user pool domain/Password dimenticata | Richiede all'utente il nome utente e invia un codice di ripristino della password. La pagina /login indirizza l'utente a /forgotPassword quando si seleziona Forgot your password? (Hai dimenticato la password?). | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cognito/latest/developerguide/managed-login-endpoints.html) |
| https:///ConfirmPassword dimenticata Your user pool domain | Richiede all'utente il codice di ripristino della password e una nuova password. La pagina /forgotPassword indirizza l'utente a /confirmforgotPassword quando si seleziona Reset your password (Reimposta la password). | Solo reindirizzamento da /forgotPassword. |
| https:///resendcode Your user pool domain | Invia un nuovo codice di conferma a un utente che ha effettuato la registrazione nel pool di utenti. | Solo reindirizzamento dal collegamento **Invia un nuovo codice** a `/confirm`. |
| https://passkeys/add Your user pool domain | [Registra una nuova passkey.](amazon-cognito-user-pools-authentication-flow-methods.md#amazon-cognito-user-pools-authentication-flow-methods-passkey) Disponibile solo nell'accesso gestito. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cognito/latest/developerguide/managed-login-endpoints.html) |
**Topics**
+ [L'endpoint di accesso gestito: `/login`](login-endpoint.md)
+ [L'endpoint di disconnessione con accesso gestito: `/logout`](logout-endpoint.md)
# L'endpoint di accesso gestito: `/login`
L'endpoint di accesso è un server di autenticazione e una destinazione di reindirizzamento da. [Endpoint Authorize](authorization-endpoint.md) È il punto di accesso all'accesso gestito quando non si specifica un provider di identità. Quando generi un reindirizzamento all'endpoint di accesso, la pagina di accesso viene caricata e vengono presentate le opzioni di autenticazione configurate per il client all'utente.
**Nota**
L'endpoint di accesso è un componente dell'accesso gestito. Nell'app, richiama le pagine di federazione e di accesso gestito che reindirizzano all'endpoint di accesso. L'accesso diretto da parte degli utenti all'endpoint di accesso non è una best practice.
## GET /login
L'endpoint `/login` supporta solo `HTTPS GET` per la richiesta iniziale dell'utente. L'app richiama la pagina in un browser come Chrome o Firefox. Quando esegui il reindirizzamento `/login` da a[Endpoint Authorize](authorization-endpoint.md), vengono trasmessi tutti i parametri che hai fornito nella richiesta iniziale. L'endpoint di accesso supporta tutti i parametri di richiesta dell'endpoint Authorize. Puoi anche accedere direttamente all'endpoint di accesso. Come best practice, crea tutte le sessioni degli utenti in `/oauth2/authorize`.
**Esempio: richiedere all'utente di accedere**
In questo esempio viene visualizzata la schermata di accesso.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/login?
response_type=code&
client_id=ad398u21ijw3s9w3939&
redirect_uri=https://YOUR_APP/redirect_uri&
state=STATE&
scope=openid+profile+aws.cognito.signin.user.admin
```
**Esempio: risposta**
Il server di autenticazione reindirizza all'app con lo stato e il codice di autorizzazione. IL server deve restituire il codice e lo stato nei parametri della stringa di query e non nel frammento.
```
HTTP/1.1 302 Found
Location: https://YOUR_APP/redirect_uri?code=AUTHORIZATION_CODE&state=STATE
```
## Richiesta di accesso avviata dall'utente
Dopo aver caricato l'endpoint `/login`, l'utente può inserire un nome utente e una password e scegliere **Accedi**. Quando lo fanno, generano una richiesta `HTTPS POST` con gli stessi parametri di richiesta di intestazione come richiesta `GET` e un corpo della richiesta con il nome utente, la password e l'impronta digitale del dispositivo.
# L'endpoint di disconnessione con accesso gestito: `/logout`
L'endpoint `/logout` è un endpoint di reindirizzamento. Disconnette l'utente e lo reindirizza a un URL di disconnessione autorizzato per il client dell'app o all'endpoint. `/login` I parametri disponibili in una richiesta GET all'`/logout`endpoint sono personalizzati in base ai casi d'uso di accesso gestito di Amazon Cognito.
L'endpoint di logout è un'applicazione web front-end per sessioni utente interattive con i tuoi clienti. La tua app deve richiamare questo e altri endpoint di accesso gestito nei browser degli utenti.
Per reindirizzare l'utente all'accesso gestito per accedere nuovamente, aggiungi un `redirect_uri` parametro alla tua richiesta. Una richiesta `logout` con un parametro `redirect_uri` deve includere anche i parametri per la richiesta successiva a [Endpoint Login](login-endpoint.md), come `client_id`, `response_type` e `scope`.
Per reindirizzare l'utente a una pagina di tua scelta, aggiungi Disconnessione **consentita URLs al client** dell'app. Nelle richieste degli utenti all'endpoint `logout`, aggiungi i parametri `logout_uri` e `client_id`. Se il valore di `logout_uri` è una delle **uscite consentite URLs** per il client dell'app, Amazon Cognito reindirizza gli utenti a quell'URL.
Con il single logout (SLO) per SAML 2.0, Amazon IdPs Cognito reindirizza innanzitutto l'utente all'endpoint SLO definito nella configurazione IdP. Dopo che il tuo IdP ha reindirizzato l'utente a, Amazon `saml2/logout` Cognito risponde con un altro reindirizzamento alla o dalla tua richiesta. `redirect_uri` `logout_uri` Per ulteriori informazioni, consulta [Disconnessione degli utenti SAML con accesso singolo](cognito-user-pools-saml-idp-sign-out.md).
L'endpoint di logout non disconnette gli utenti dall'OIDC o dai provider di identità social (). IdPs Per disconnettere gli utenti dalla sessione con un IdP esterno, indirizzali alla pagina di disconnessione di quel provider.
## GET /logout
L'endpoint `/logout` supporta solo `HTTPS GET`. Il client del bacino d'utenza in genere invia questa richiesta tramite un browser di sistema. Il browser è in genere Custom Chrome Tab in Android o Safari View Control in iOS.
### Parametri della richiesta
*client\$1id*
L'ID client dell'app per l'app. Per ottenere l'ID del client di un'app, devi registrare l'app nel bacino d'utenza. Per ulteriori informazioni, consulta [Impostazioni specifiche dell'applicazione con client di app](user-pool-settings-client-apps.md).
Obbligatorio.
*logout\$1uri*
Reindirizza l'utente a una pagina di disconnessione personalizzata con un parametro *logout\$1uri*. Imposta il suo valore sull'**URL di disconnessione** del client dell'app a cui vuoi reindirizzare l'utente dopo la disconnessione. Utilizza *logout\$1uri* solo con il parametro *client\$1id*. Per ulteriori informazioni, consulta [Impostazioni specifiche dell'applicazione con client di app](user-pool-settings-client-apps.md).
Puoi utilizzare il parametro *logout\$1uri* anche per reindirizzare l'utente alla pagina di accesso di un altro client di app. Imposta la pagina di accesso per l'altro client di app come **Allowed callback URL** (URL di callback consentito) nel tuo client di app. Nella richiesta all'endpoint `/logout`, imposta il valore del parametro *logout\$1uri* sulla pagina di accesso con codifica URL.
Amazon Cognito richiede un parametro *logout\$1uri* o *redirect\$1uri* nella richiesta all'endpoint `/logout`. Il parametro *logout\$1uri* reindirizza l'utente a un altro sito Web. Se nella richiesta all'endpoint `/logout` sono inclusi entrambi i parametri *logout\$1uri* e *redirect\$1uri*, Amazon Cognito utilizzerà esclusivamente il parametro *logout\$1uri*, sovrascrivendo il parametro *redirect\$1uri*.
*`nonce`*
(Facoltativo) Un valore casuale che puoi aggiungere alla richiesta. Il valore nonce fornito è incluso nel token ID emesso da Amazon Cognito. Per proteggersi da attacchi di tipo replay, l'app può analizzare la richiesta `nonce` nel token dell'ID e confrontarlo con quello generato. Per ulteriori informazioni sulla richiesta `nonce`, consulta la sezione relativa alla [convalida del token dell'ID](https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation) nella *documentazione dello standard OpenID Connect*.
**redirect\$1uri**
Reindirizza l'utente alla pagina di accesso per l'autenticazione con il parametro *redirect\$1uri*. Imposta il suo valore sull'**URL di callback consentito** del client dell'app dove vuoi reindirizzare l'utente quando questo ha nuovamente effettuato l'accesso. Utilizza i parametri *client\$1id*, *scope*, *state* e *response\$1type* che vuoi passare all'endpoint `/login`.
Amazon Cognito richiede un parametro *logout\$1uri* o *redirect\$1uri* nella richiesta all'endpoint `/logout`. *Per reindirizzare l'utente all'`/login`endpoint per riautenticarsi e passare i token all'app, aggiungi un parametro redirect\$1uri.* **Se nella richiesta all'endpoint sono inclusi entrambi i parametri *logout\$1uri* *e redirect\$1uri*, `/logout` Amazon Cognito sovrascrive il parametro redirect\$1uri ed elabora esclusivamente il parametro logout\$1uri.**
*response\$1type*
La risposta OAuth 2.0 che desideri ricevere da Amazon Cognito dopo l'accesso dell'utente. `code`e `token` sono i valori validi per il parametro *response\$1type*.
Obbligatorio se si utilizza un parametro *redirect\$1uri*.
*stato*
Quando l'applicazione aggiunge un parametro di *stato* a una richiesta, Amazon Cognito ne restituisce il valore all'app quando l'`/oauth2/logout`endpoint reindirizza l'utente.
Aggiungi questo valore alle richieste di protezione contro attacchi [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery).
Non è possibile impostare il valore di un parametro `state` su una stringa JSON con codifica URL. Per passare una stringa che corrisponda a questo formato in un `state` parametro, codifica la stringa in base64, quindi decodificala nell'applicazione.
Vivamente consigliato quando si utilizza un parametro *redirect\$1uri*.
*scope*
Gli ambiti OAuth 2.0 che desideri richiedere ad Amazon Cognito dopo averli disconnessi con *un* parametro redirect\$1uri. Amazon Cognito reindirizza l'utente all'endpoint `/login` con il parametro *scope*nella richiesta all'endpoint `/logout`.
Facoltativo quando si utilizza un parametro *redirect\$1uri*. Se non includi un parametro *scope*, Amazon Cognito reindirizza l'utente all'endpoint `/login` con un parametro *scope*. Quando Amazon Cognito reindirizza l'utente e compila automaticamente `scope`, il parametro include tutti gli ambiti autorizzati per il client di app.
### Richieste di esempio
**Esempio: disconnettersi e reindirizzare l'utente al client**
Quando le richieste includono `logout_uri` e `client_id`, Amazon Cognito reindirizza le sessioni utente all'URL nel valore di `logout_uri`, ignorando tutti gli altri parametri di richiesta. Questo URL deve essere un URL di disconnessione autorizzato per il client dell'app.
Di seguito è riportato un esempio di richiesta di disconnessione e reindirizzamento a `https://www.example.com/welcome`.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/logout?
client_id=1example23456789&
logout_uri=https%3A%2F%2Fwww.example.com%2Fwelcome
```
**Esempio: disconnettersi e richiedere all'utente di accedere come altro utente**
Quando le richieste vengono omesse `logout_uri` ma forniscono in altro modo i parametri che costituiscono una richiesta ben formata all'endpoint di autorizzazione, Amazon Cognito reindirizza gli utenti all'accesso gestito. L'endpoint di disconnessione aggiunge i parametri della richiesta originale alla destinazione di reindirizzamento.
I parametri aggiuntivi che aggiungi alla richiesta di disconnessione devono essere presenti nell'elenco in. [Parametri della richiesta](#get-logout-request-parameters) Ad esempio, l'endpoint di logout non supporta il reindirizzamento IdP automatico con parametri o. `identity_provider` `idp_identifier` Il parametro `redirect_uri` in una richiesta all'endpoint di logout non è un URL di disconnessione, ma un post-sign-in URL che si desidera trasmettere all'endpoint di autorizzazione.
Di seguito è riportato un esempio di richiesta che disconnette un utente, reindirizza alla pagina di accesso e fornisce un codice di autorizzazione dopo l'accesso. `https://www.example.com`
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/logout?
response_type=code&
client_id=1example23456789&
redirect_uri=https%3A%2F%2Fwww.example.com&
state=example-state-value&
nonce=example-nonce-value&
scope=openid+profile+aws.cognito.signin.user.admin
```
# Endpoint del provider di identità e del relying party
Gli *endpoint federativi sono endpoint* di pool di utenti che servono a uno degli standard di autenticazione utilizzati dai pool di utenti. Includono SAML ACS URLs, gli endpoint di rilevamento OIDC e gli endpoint di servizio per i ruoli del pool di utenti sia come provider di identità che come relying party. Gli endpoint federativi avviano i flussi di autenticazione, ricevono la prova dell'autenticazione e rilasciano token ai client. IdPs Interagiscono con IdPs le applicazioni e gli amministratori, ma non con gli utenti.
Gli argomenti a pagina intera che seguono questa pagina contengono dettagli sugli endpoint dei provider OAuth 2.0 e OIDC che diventano disponibili quando si aggiunge un dominio al pool di utenti. La tabella seguente è un elenco di tutti gli endpoint della federazione.
Esempi di [domini di pool di utenti](cognito-user-pools-assign-domain.md) sono:
1. Dominio con prefisso: `mydomain.auth.us-east-1.amazoncognito.com`
1. Dominio personalizzato: `auth.example.com`
**Endpoint di federazione del pool di utenti**
| URL dell'endpoint | Description | Modalità di accesso |
| --- | --- | --- |
| https://Your user pool domain/oauth2/authorize | Reindirizza un utente all'accesso gestito o all'accesso con il proprio IdP. | Richiamato nel browser del cliente per iniziare l'autenticazione dell'utente. Per informazioni, consulta [Endpoint Authorize](authorization-endpoint.md). |
| https://oauth2/token Your user pool domain | Restituisce i token in base a un codice di autorizzazione o richiesta di credenziali del client. | Richiesto dall'app per recuperare i token. Per informazioni, consulta [Endpoint Token](token-endpoint.md). |
| Your user pool domainhttps://oAuth2/UserInfo | Restituisce gli attributi utente in base agli ambiti OAuth 2.0 e all'identità utente in un token di accesso. | Richiesto dall'app per recuperare il profilo utente. Per informazioni, consulta [Endpoint UserInfo](userinfo-endpoint.md). |
| Your user pool domainhttps://oauth2/revoke | Revoca un token di aggiornamento e i token di accesso associati. | Richiesta dall'app di revocare un token. Per informazioni, consulta [Endpoint Revoke](revocation-endpoint.md). |
| https://cognito-idp. Region.amazonaws.com/ your user pool ID /.well-known/openid-configuration | Una directory dell'architettura OIDC del tuo pool di utenti. [1](#cognito-federation-oidc-discovery-note) | Richiesto dall'app per individuare i metadati dell'emittente del pool di utenti. |
| https://cognito-idp. Region.amazonaws.com/ /.well-known/jwks.json your user pool ID | Chiavi pubbliche che puoi utilizzare per convalidare i token Amazon Cognito. [2](#cognito-federation-oidc-jwks-note) | Richiesto dall'app per la verifica JWTs. |
| Your user pool domainhttps://oauth2/idpresponse | I gestori dell'identità digitale devono reindirizzare gli utenti a questo endpoint con un codice di autorizzazione. Amazon Cognito riscatta il codice per un token quando autentica l'utente federato. | Reindirizzato dall'accesso IdP OIDC come URL di callback del client IdP. |
| Your user pool domainhttps://saml2/idpresponse | L'URL Assertion Consumer Response (ACS) per l'integrazione con i provider di identità SAML 2.0. | Reindirizzato da SAML 2.0 IdP come URL ACS o punto di origine per l'accesso avviato dall'IdP. [3](#cognito-federation-idp-init-note) |
| Your user pool domainhttps://saml2/logout | L'URL [Single Logout](cognito-user-pools-saml-idp-sign-out.md#cognito-user-pools-saml-idp-sign-out.title) (SLO) per l'integrazione con i provider di identità SAML 2.0. | Reindirizzato da SAML 2.0 IdP come URL di accesso singolo (SLO). Accetta solo l'associazione POST. |
1 Il `openid-configuration` documento può essere aggiornato in qualsiasi momento con informazioni aggiuntive che mantengano l'endpoint conforme all'OIDC e alle specifiche. OAuth2
2 Il file `jwks.json` JSON può essere aggiornato in qualsiasi momento con nuove chiavi pubbliche per la firma dei token.
3 Per ulteriori informazioni sull'accesso SAML avviato da IdP, consulta. [Implementazione dell'accesso SAML avviato da IdP](cognito-user-pools-SAML-session-initiation.md#cognito-user-pools-SAML-session-initiation-idp-initiation)
[Per ulteriori informazioni su OpenID Connect e sugli OAuth standard, vedere OpenID [Connect](http://openid.net/specs/openid-connect-core-1_0.html) 1.0 e 2.0. OAuth](https://tools.ietf.org/html/rfc6749)
**Topics**
+ [L'endpoint di reindirizzamento e autorizzazione](authorization-endpoint.md)
+ [L'endpoint che emette il token](token-endpoint.md)
+ [L'endpoint degli attributi utente](userinfo-endpoint.md)
+ [L'endpoint di revoca del token](revocation-endpoint.md)
+ [L'endpoint di asserzione SAML IdP](saml2-idpresponse-endpoint.md)
# L'endpoint di reindirizzamento e autorizzazione
L'endpoint `/oauth2/authorize` è un endpoint di reindirizzamento che supporta due destinazioni di reindirizzamento. Se si include un `identity_provider` o `idp_identifier` nell'URL, viene eseguito il reindirizzamento invisibile all'utente alla pagina di accesso del gestore dell'identità digitale (IdP) specificato. In caso contrario, viene eseguito il reindirizzamento all'[Endpoint Login](login-endpoint.md) con gli stessi parametri URL inclusi nella richiesta.
L'endpoint di autorizzazione reindirizza all'accesso gestito o a una pagina di accesso IdP. La destinazione di una sessione utente su questo endpoint è una pagina web con cui l'utente deve interagire direttamente nel proprio browser.
Per utilizzare l'endpoint di autorizzazione, richiama il browser dell'utente all'indirizzo `/oauth2/authorize` con parametri che forniscono al pool di utenti informazioni sui seguenti dettagli del pool stesso.
+ Il client dell'app a cui vuoi accedere.
+ L'URL di callback a cui si desidera essere reindirizzati.
+ Gli ambiti OAuth 2.0 che desideri richiedere nel token di accesso dell'utente.
+ Facoltativamente, il gestore dell'identità digitale (IdP) di terze parti che desideri utilizzare per accedere.
Puoi anche specificare i parametri `state` e `nonce` utilizzati da Amazon Cognito per convalidare le richieste in arrivo.
## GET `/oauth2/authorize`
L'endpoint `/oauth2/authorize` supporta solo `HTTPS GET`. L'app in genere avvia questa richiesta nel browser dell'utente. È possibile effettuare richieste solo all'endpoint `/oauth2/authorize` tramite HTTPS.
È possibile trovare ulteriori informazioni sulla definizione dell'endpoint di autorizzazione nello standard OpenID Connect (OIDC) nella pagina relativa all'[endpoint di autorizzazione](http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthorizationEndpoint).
### Parametri della richiesta
**`response_type`**
Obbligatorio.
Il tipo di risposta. Deve essere `code` o `token`.
Una richiesta riuscita con `response_type` impostato su `code` restituisce una concessione del codice di autorizzazione. Una concessione del codice di autorizzazione è un parametro `code` che Amazon Cognito aggiunge all'URL di reindirizzamento. L'app scambia il codice con l'[Endpoint Token](token-endpoint.md) per i token di accesso, ID e aggiornamento. Come best practice di sicurezza e per ricevere token di aggiornamento per gli utenti, usa una concessione del codice di autorizzazione nella tua app.
Una richiesta riuscita con `response_type` impostato su `token` restituisce una concessione implicita. Una concessione implicita è un token di ID e accesso che Amazon Cognito aggiunge all'URL di reindirizzamento. Una concessione implicita è meno sicura perché espone i token e le potenziali informazioni di identificazione agli utenti. Puoi disattivare il supporto per le concessioni implicite nella configurazione del client dell'app.
**`client_id`**
Obbligatorio.
L'ID del client dell'applicazione.
Il valore del parametro `client_id` deve essere l'ID di un client dell'app nel pool di utenti in cui si effettua la richiesta. Il client dell'app deve supportare l'accesso da parte degli utenti locali di Amazon Cognito o di almeno un gestore dell'identità digitale (IdP) di terze parti.
**`redirect_uri`**
Obbligatorio.
L'URL a cui il server di autenticazione reindirizza il browser una volta che Amazon Cognito concede l'autorizzazione all'utente.
L'URI (Uniform Resource Identifier) di reindirizzamento deve avere i seguenti attributi:
+ Deve essere un URI assoluto.
+ Deve essere preregistrato con un client.
+ Non può includere un componente frammento.
Vedi [OAuth 2.0 - Endpoint di reindirizzamento.](https://tools.ietf.org/html/rfc6749#section-3.1.2)
Amazon Cognito richiede che l'URI di reindirizzamento utilizzi HTTPS, ad eccezione di `http://localhost`, che è possibile impostare come URL di callback a scopo di test.
Amazon Cognito supporta anche il callback URLs di app come. `myapp://example`
**`state`**
Facoltativo, consigliato.
Quando l'app aggiunge un parametro *state* a una richiesta, Amazon Cognito restituisce il suo valore all'app quando l'endpoint `/oauth2/authorize` reindirizza l'utente.
Aggiungi questo valore alle richieste di protezione contro attacchi [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery).
Non è possibile impostare il valore di un parametro `state` su una stringa JSON con codifica URL. Per passare una stringa che corrisponda a questo formato in un `state` parametro, codifica la stringa in base64, quindi decodificala nell'app.
**`identity_provider`**
Opzionale.
Aggiungi questo parametro per ignorare l'accesso gestito e reindirizzare l'utente a una pagina di accesso del provider. Il valore del parametro *identity\$1provider* è il nome del provider di identità come appare nel bacino d'utenza.
+ Per i provider di servizi sociali, puoi utilizzare i valori *identity\$1provider*,, e. `Facebook` `Google` `LoginWithAmazon` `SignInWithApple`
+ Per i pool di utenti di Amazon Cognito, usa il valore. `COGNITO`
+ Per i provider di identità SAML 2.0 e OpenID Connect (OIDC) (IdPs), usa il nome che hai assegnato all'IdP nel tuo pool di utenti.
**`idp_identifier`**
Opzionale.
Aggiungi questo parametro per reindirizzare a un provider usando un nome alternativo per il parametro *identity\$1provider*. Puoi inserire gli identificatori per SAML 2.0 e OIDC IdPs dal menu **Social e provider esterni** della console Amazon Cognito.
**`scope`**
Opzionale.
Può essere una combinazione di qualsiasi ambito riservato al sistema o ambito personalizzato associato al client. Gli ambiti devono essere separati da spazi. Gli ambiti riservati al sistema sono `openid`, `email`, `phone`, `profile` e `aws.cognito.signin.user.admin`. Qualsiasi ambito utilizzato deve essere associato al client o verrà ignorato in fase di runtime.
Se il client non richiede alcun ambito, il server di autenticazione utilizza tutti gli ambiti associati al client.
Un token ID viene restituito solo viene richiesto l'ambito `openid`. Il token di accesso può essere utilizzato in relazione ai bacini d'utenza di Amazon Cognito solo se viene richiesto l'ambito `aws.cognito.signin.user.admin`. Gli ambiti `phone`, `email` e `profile` possono essere richiesti solo se viene richiesto anche l'ambito `openid`. Questi ambiti impongono le attestazioni da includere all'interno del token ID.
**`code_challenge_method`**
Opzionale.
Il protocollo di hashing che hai usato per generare la sfida. Il [PKCE RFC](https://tools.ietf.org/html/rfc7636) definisce due metodi, S256 e semplice; tuttavia, il server di autenticazione di Amazon Cognito supporta solo S256.
**`code_challenge`**
Opzionale.
La sfida Proof of Key Code Exchange (PKCE) che hai generato da. `code_verifier` Per ulteriori informazioni, consulta [Utilizzo di PKCE nelle concessioni di codici di autorizzazione](using-pkce-in-authorization-code.md).
Obbligatorio solo quando specifichi un parametro `code_challenge_method`.
**`nonce`**
Opzionale.
Un valore casuale che puoi aggiungere alla richiesta. Il valore nonce fornito è incluso nel token ID emesso da Amazon Cognito. Per proteggersi da attacchi di tipo replay, l'app può analizzare la richiesta `nonce` nel token dell'ID e confrontarlo con quello generato. Per ulteriori informazioni sulla richiesta `nonce`, consulta la sezione relativa alla [convalida del token dell'ID](https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation) nella *documentazione dello standard OpenID Connect*.
**`lang`**
Opzionale.
La lingua in cui desideri visualizzare le pagine interattive con l'utente. Le pagine di accesso gestite possono essere localizzate, ma le pagine dell'interfaccia utente ospitate (classiche) no. Per ulteriori informazioni, consulta [Managed login localization](cognito-user-pools-managed-login.md#managed-login-localization).
**`login_hint`**
Opzionale.
Una richiesta di nome utente da trasmettere al server di autorizzazione. Puoi raccogliere un nome utente, un indirizzo e-mail o un numero di telefono dall'utente e consentire al provider di destinazione di precompilare il nome di accesso dell'utente. Quando invii un `login_hint` parametro e `identity_provider` i parametri no `idp_identifier` or all'`oauth2/authorize`endpoint, l'accesso gestito compila il campo del nome utente con il valore del suggerimento. Puoi anche passare questo parametro a [Endpoint Login](login-endpoint.md) e inserire automaticamente il valore del nome utente.
Quando la tua richiesta di autorizzazione richiama un reindirizzamento a OIDC, IdPs Amazon Cognito aggiunge `login_hint` un parametro alla richiesta all'autorizzatore di terze parti. Non puoi inoltrare i suggerimenti di accesso a SAML, Apple, Login With Amazon, Google o Facebook (Meta). IdPs
**`prompt`**
Opzionale.
Un parametro OIDC che controlla il comportamento di autenticazione per le sessioni esistenti. Disponibile solo nella versione Managed Login Branding, non nella classica interfaccia utente ospitata. [Per ulteriori informazioni sulla specifica OIDC, consulta Richiesta di autenticazione.](https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest) I valori `none` `login` hanno un effetto sul comportamento di autenticazione del pool di utenti.
Amazon Cognito inoltra tutti i valori `prompt` tranne `none` IdPs quando gli utenti scelgono l'autenticazione con provider di terze parti. Ciò è vero quando l'URL a cui gli utenti accedono include un `idp_identifier` parametro `identity_provider` o o quando il server di autorizzazione li reindirizza a [Endpoint Login](login-endpoint.md) e selezionano un IdP dai pulsanti disponibili.
**Richiedi i valori dei parametri**
`prompt=none`
Amazon Cognito continua silenziosamente l'autenticazione per gli utenti che dispongono di una sessione autenticata valida. Con questa richiesta, gli utenti possono autenticarsi silenziosamente tra diversi client di app nel tuo pool di utenti. Se l'utente non è già autenticato, il server di autorizzazione restituisce un errore. `login_required`
`prompt=login`
Amazon Cognito richiede agli utenti di effettuare nuovamente l'autenticazione anche se hanno una sessione esistente. Invia questo valore quando desideri verificare nuovamente l'identità dell'utente. Gli utenti autenticati che hanno una sessione esistente possono tornare all'accesso senza invalidare quella sessione. Quando un utente con una sessione esistente accede nuovamente, Amazon Cognito gli assegna un nuovo cookie di sessione. Questo parametro può essere inoltrato anche al tuo. IdPs IdPsche accettano questo parametro richiedono anche un nuovo tentativo di autenticazione da parte dell'utente.
`prompt=select_account`
Questo valore non ha effetto sull'accesso locale e deve essere inviato nelle richieste che reindirizzano a. IdPs Se incluso nella richiesta di autorizzazione, questo parametro si aggiunge `prompt=select_account` al percorso URL per la destinazione di reindirizzamento IdP. Quando IdPs supportano questo parametro, richiedono agli utenti di selezionare l'account con cui desiderano accedere.
`prompt=consent`
Questo valore non ha effetto sull'accesso locale e deve essere inviato nelle richieste reindirizzate a. IdPs Se incluso nella richiesta di autorizzazione, questo parametro si aggiunge `prompt=consent` al percorso URL per la destinazione di reindirizzamento IdP. Quando IdPs supportano questo parametro, richiedono il consenso dell'utente prima di reindirizzare nuovamente al tuo pool di utenti.
Quando ometti il `prompt` parametro dalla tua richiesta, l'accesso gestito segue il comportamento predefinito: gli utenti devono accedere a meno che il loro browser non disponga di un cookie valido per la sessione di accesso gestito. Ad esempio, è possibile combinare più valori per `prompt` con un delimitatore di caratteri spaziali. `prompt=login consent`
**`resource`**
Opzionale.
L'identificatore di una risorsa che desideri associare al token di accesso nel claim. `aud` Quando includi questo parametro, Amazon Cognito verifica che il valore sia un URL e imposta il pubblico del token di accesso risultante sulla risorsa richiesta. Puoi richiedere un [server di risorse del](cognito-user-pools-define-resource-servers.md) pool di utenti con un identificatore in un formato URL o un URL a tua scelta. I valori di questo parametro devono iniziare con `https://``http://localhost`, o uno schema URL personalizzato come`myapp://`.
L'associazione delle risorse è definita nella [RFC 8707](https://www.rfc-editor.org/rfc/rfc8707.html). Per ulteriori informazioni sui server di risorse e sull'associazione delle risorse, vedere [Resource](cognito-user-pools-define-resource-servers.md#cognito-user-pools-resource-binding) binding.
## Esempio: concessione del codice di autorizzazione
Questo è un esempio di richiesta di concessione di un codice di autorizzazione.
La seguente richiesta avvia una sessione per recuperare un codice di autorizzazione che l'utente trasmette all'app nella `redirect_uri` destinazione. Questa sessione richiede gli ambiti per gli attributi utente e per l'accesso alle operazioni API self-service di Amazon Cognito.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?
response_type=code&
client_id=1example23456789&
redirect_uri=https://www.example.com&
state=abcdefg&
scope=openid+profile+aws.cognito.signin.user.admin
```
Il server di autenticazione di Amazon Cognito viene reindirizzato all'app con lo stato e il codice di autorizzazione. Il codice di autorizzazione è valido per cinque minuti.
```
HTTP/1.1 302 Found
Location: https://www.example.com?code=a1b2c3d4-5678-90ab-cdef-EXAMPLE11111&state=abcdefg
```
## Esempio: concessione del codice di autorizzazione con PKCE
Questo flusso di esempio esegue una concessione di codice di autorizzazione con [PKCE](using-pkce-in-authorization-code.md#using-pkce-in-authorization-code.title).
Questa richiesta aggiunge un `code_challenge` parametro. Per completare lo scambio di un codice con un token, è necessario includere il `code_verifier` parametro nella richiesta all'`/oauth2/token`endpoint.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?
response_type=code&
client_id=1example23456789&
redirect_uri=https://www.example.com&
state=abcdefg&
scope=aws.cognito.signin.user.admin&
code_challenge_method=S256&
code_challenge=a1b2c3d4...
```
Il server di autorizzazione reindirizza nuovamente all'applicazione con il codice e lo stato di autorizzazione. L'applicazione elabora il codice di autorizzazione e lo scambia con token.
```
HTTP/1.1 302 Found
Location: https://www.example.com?code=a1b2c3d4-5678-90ab-cdef-EXAMPLE11111&state=abcdefg
```
## Esempio: richiedi la riautenticazione con `prompt=login`
La richiesta seguente aggiunge un `prompt=login` parametro che richiede all'utente di autenticarsi nuovamente, anche se ha una sessione esistente.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?
response_type=code&
client_id=1example23456789&
redirect_uri=https://www.example.com&
state=abcdefg&
scope=openid+profile+aws.cognito.signin.user.admin&
prompt=login
```
Il server di autorizzazione reindirizza all'[endpoint di accesso](login-endpoint.md), richiedendo una nuova autenticazione.
```
HTTP/1.1 302 Found Location: https://mydomain.auth.us-east-1.amazoncognito.com/login?response_type=code&client_id=1example23456789&redirect_uri=https://www.example.com&state=abcdefg&scope=openid+profile+aws.cognito.signin.user.admin&prompt=login
```
## Esempio: autenticazione silenziosa con `prompt=none`
La seguente richiesta aggiunge un `prompt=none` parametro che verifica silenziosamente se l'utente ha una sessione valida.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?
response_type=code&
client_id=1example23456789&
redirect_uri=https://www.example.com&
state=abcdefg&
scope=openid+profile+aws.cognito.signin.user.admin&
prompt=none
```
Quando non esiste una sessione valida, il server di autorizzazione restituisce un errore all'URI di reindirizzamento
```
HTTP/1.1 302 Found Location: https://www.example.com?error=login_required&state=abcdefg
```
Quando esiste una sessione valida, il server di autorizzazione restituisce un codice di autorizzazione.
```
HTTP/1.1 302 Found Location: https://www.example.com?code=AUTHORIZATION_CODE&state=abcdefg
```
## Esempio: concessione del codice di autorizzazione con associazione di risorse
La seguente richiesta aggiunge un `resource` parametro per associare il token di accesso a un server di risorse specifico. Il token di accesso risultante crea le condizioni affinché l'API di destinazione confermi che si tratta del pubblico previsto della richiesta dell'utente autenticato.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?
response_type=code&
client_id=1example23456789&
redirect_uri=https://www.example.com&
state=abcdefg&
scope=solar-system-data-api.example.com/asteroids.add&
resource=https://solar-system-data-api.example.com
```
Il server di autorizzazione restituisce un codice di autorizzazione che genera un token di accesso con un'`aud`affermazione di. `https://solar-system-data-api.example.com`
```
HTTP/1.1 302 Found Location: https://www.example.com?code=AUTHORIZATION_CODE&state=abcdefg
```
## Esempio: concessione di token (implicita) senza ambito `openid`
Questo flusso di esempio genera una concessione implicita e ritorna JWTs direttamente alla sessione dell'utente.
La richiesta riguarda una concessione implicita dal server di autorizzazione. Richiede gli ambiti nel token di accesso che autorizzano le operazioni self-service del profilo utente.
```
GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?
response_type=token&
client_id=1example23456789&
redirect_uri=https://www.example.com&
state=abcdefg&
scope=aws.cognito.signin.user.admin
```
Il server di autorizzazione reindirizza all'applicazione solo con un token di accesso. Poiché non è stato richiesto l'ambito del `openid`, Amazon Cognito non restituisce un token ID. Inoltre, Amazon Cognito non restituisce un token di aggiornamento in questo flusso.
```
HTTP/1.1 302 Found
Location: https://example.com/callback#access_token=eyJra456defEXAMPLE&token_type=bearer&expires_in=3600&state=STATE
```
## Esempio: concessione di token (implicita) con ambito `openid`
Questo flusso di esempio genera una concessione implicita e restituisce token al browser dell'utente.
La richiesta riguarda una concessione implicita dal server di autorizzazione. Richiede degli ambiti nel token di accesso che autorizzano l'accesso agli attributi utente e alle operazioni self-service.
```
GET
https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?
response_type=token&
client_id=1example23456789&
redirect_uri=https://www.example.com&
state=abcdefg&
scope=aws.cognito.signin.user.admin+openid+profile
```
Il server di autorizzazione reindirizza all'applicazione con il token di accesso e il token ID (poiché `openid` l'ambito era incluso):
```
HTTP/1.1 302 Found
Location: https://www.example.com#id_token=eyJra67890EXAMPLE&access_token=eyJra12345EXAMPLE&token_type=bearer&expires_in=3600&state=abcdefg
```
## Esempi di risposte negative
Amazon Cognito potrebbe rifiutare la tua richiesta. Le richieste negative sono accompagnate da un codice di errore HTTP e da una descrizione che puoi utilizzare per correggere i parametri della richiesta. Di seguito sono riportati alcuni esempi di risposte negative.
+ Se `client_id` e `redirect_uri` sono validi, ma i parametri della richiesta non sono formattati correttamente, il server di autenticazione reindirizza l'errore al client `redirect_uri` e aggiunge un messaggio di errore in un parametro URL. Di seguito sono riportati alcuni esempi di formattazione errata.
+ La richiesta non include un `response_type` parametro.
+ La richiesta di autorizzazione ha fornito un `code_challenge` parametro, ma non un `code_challenge_method` parametro.
+ Il valore del `code_challenge_method` parametro non lo è`S256`.
Di seguito è riportata la risposta a una richiesta di esempio con una formattazione errata.
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request
```
+ Se il client richiede `code` o `token` accede`response_type`, ma non dispone dell'autorizzazione per queste richieste, il server di autorizzazione Amazon Cognito torna `unauthorized_client` a quello del client`redirect_uri`, come segue:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=unauthorized_client
```
+ Se il client richiede un ambito non valido, sconosciuto o non corretto, il server di autorizzazione di Amazon Cognito restituisce `invalid_scope` al `redirect_uri` del client, come riportato di seguito:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_scope
```
+ Se si verifica un errore imprevisto nel server, il server di autenticazione torna `server_error` a quello del `redirect_uri` client. Poiché l'errore HTTP 500 non viene inviato al client, l'errore non viene visualizzato nel browser dell'utente. Il server di autorizzazione restituisce il seguente errore.
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=server_error
```
+ Quando Amazon Cognito esegue l'autenticazione tramite federazione a terze parti, Amazon IdPs Cognito potrebbe riscontrare problemi di connessione, come i seguenti:
+ Se si verifica un timeout di connessione durante la richiesta del token dal provider di identità, il server di autenticazione reindirizza l'errore al `redirect_uri` del client come segue:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Timeout+occurred+in+calling+IdP+token+endpoint
```
+ Se si verifica un timeout di connessione durante la chiamata all'`jwks_uri`endpoint per la convalida del token ID, il server di autenticazione reindirizza con un errore al client nel modo seguente: `redirect_uri`
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=error_description=Timeout+in+calling+jwks+uri
```
+ Durante l'autenticazione mediante federazione a terze parti IdPs, i provider possono restituire risposte di errore. Ciò può essere dovuto a errori di configurazione o ad altri motivi, come i seguenti:
+ Se viene ricevuta una risposta di errore da altri provider, il server di autenticazione reindirizza l'errore al `redirect_uri` del client come segue:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=[IdP name]+Error+-+[status code]+error getting token
```
+ Se viene ricevuta una risposta di errore da Google, il server di autenticazione reindirizza l'errore al `redirect_uri` del client come segue:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Google+Error+-+[status code]+[Google-provided error code]
```
+ Quando Amazon Cognito rileva un'eccezione di comunicazione quando si connette a un IdP esterno, il server di autenticazione reindirizza con un errore al client con uno dei seguenti messaggi: `redirect_uri`
+
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Connection+reset
```
+
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Read+timed+out
```
# L'endpoint che emette il token
L'[endpoint OAuth 2.0 token at `/oauth2/token` emette token](https://www.rfc-editor.org/rfc/rfc6749#section-3.2) web JSON (JWTs) per le applicazioni che desiderano completare i flussi di concessione del codice di autorizzazione e delle credenziali client. Questi token sono il risultato finale dell'autenticazione con un pool di utenti. Contengono informazioni sull'utente (token ID), sul livello di accesso dell'utente (token di accesso) e sul diritto dell'utente a mantenere la sessione di accesso (token di aggiornamento). Le librerie relying-party OpenID Connect (OIDC) gestiscono le richieste e i payload di risposta da questo endpoint. I token forniscono una prova verificabile dell'autenticazione, informazioni sul profilo e un meccanismo per l'accesso ai sistemi di back-end.
Il server di autorizzazione del pool di utenti OAuth 2.0 emette token web JSON (JWTs) dall'endpoint del token ai seguenti tipi di sessioni:
1. Utenti che hanno completato una richiesta di concessione del codice di autorizzazione. Il riscatto riuscito di un codice restituisce i token ID, di accesso e di aggiornamento.
1. Machine-to-machine (M2M) sessioni che hanno completato una concessione di credenziali client. L'autorizzazione riuscita con il segreto del client restituisce un token di accesso.
1. Utenti che hanno precedentemente effettuato l'accesso e ricevuto token di aggiornamento. L'autenticazione con token di aggiornamento restituisce nuovi ID e token di accesso.
**Nota**
Gli utenti che accedono con un codice di autorizzazione concesso nell'accesso gestito o tramite la federazione possono sempre aggiornare i propri token dall'endpoint del token. Gli utenti che accedono con le operazioni API `InitiateAuth` e `AdminInitiateAuth` possono aggiornare i propri token con l'endpoint token quando i [dispositivi ricordati](amazon-cognito-user-pools-device-tracking.md) *non* sono attivi nel pool di utenti. Se i dispositivi ricordati sono attivi, aggiorna i token con l'[API o l'operazione di aggiornamento dei token SDK pertinenti](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-api) per il client dell'app.
L'endpoint token diventa disponibile pubblicamente quando si aggiunge un dominio al pool di utenti. Accetta le richieste POST HTTP. Per la sicurezza delle applicazioni, utilizzate PKCE con gli eventi di accesso con il codice di autorizzazione. PKCE verifica che l'utente che trasmette un codice di autorizzazione sia lo stesso utente che ha effettuato l'autenticazione. Per ulteriori informazioni su PKCE, vedere [IETF](https://datatracker.ietf.org/doc/html/rfc7636) RFC 7636.
Puoi saperne di più sui client dell'app del pool di utenti e sui relativi tipi di concessione, segreti dei client, ambiti consentiti e client all'indirizzo. IDs [Impostazioni specifiche dell'applicazione con client di app](user-pool-settings-client-apps.md) Puoi saperne di più sull'autorizzazione M2M, sulla concessione delle credenziali dei client e sull'autorizzazione con ambiti dei token di accesso all'indirizzo. [Ambiti, M2M e server di risorse](cognito-user-pools-define-resource-servers.md)
Per recuperare informazioni su un utente dal suo token di accesso, passale alla tua richiesta [Endpoint UserInfo](userinfo-endpoint.md) o a una richiesta API. [https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_GetUser.html](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_GetUser.html) Il token di accesso deve contenere gli ambiti appropriati per queste richieste,
## Formatta una richiesta POST sull'endpoint del token
L'endpoint `/oauth2/token` supporta solo `HTTPS POST`. Questo endpoint non è interattivo con l'utente. Gestisci le richieste di token con una [libreria OpenID Connect (OIDC) nella tua applicazione](https://openid.net/developers/certified-openid-connect-implementations/).
L'endpoint token supporta l'autenticazione `client_secret_basic` e `client_secret_post`. [Per ulteriori informazioni sulla specifica OIDC, vedere Client Authentication.](https://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication) Per ulteriori informazioni sull'endpoint Token della specifica OpenID Connect, consulta [Endpoint Token](http://openid.net/specs/openid-connect-core-1_0.html#TokenEndpoint).
### Parametri della richiesta nell'intestazione
È possibile passare i seguenti parametri nell'intestazione della richiesta all'endpoint del token.
**`Authorization`**
Se il client ha emesso un segreto, dovrà trasmettere i suoi `client_id` e `client_secret` nell'intestazione dell'autorizzazione come autorizzazione HTTP `client_secret_basic`. Puoi inoltre includere `client_id` e `client_secret` nel corpo della richiesta come autorizzazione `client_secret_post`.
La stringa di intestazione di autorizzazione è [Base](https://en.wikipedia.org/wiki/Basic_access_authentication#Client_side) `Base64Encode(client_id:client_secret)`. L'esempio seguente è un'intestazione di autorizzazione per il client dell'app `djc98u3jiedmi283eu928` con client secret`abcdef01234567890`, che utilizza la versione della stringa con codifica Base64: `djc98u3jiedmi283eu928:abcdef01234567890`
```
Authorization: Basic ZGpjOTh1M2ppZWRtaTI4M2V1OTI4OmFiY2RlZjAxMjM0NTY3ODkw
```
**`Content-Type`**
Imposta il valore di questo parametro su `'application/x-www-form-urlencoded'`.
### Parametri della richiesta nel corpo
Di seguito sono riportati i parametri che è possibile richiedere in `x-www-form-urlencoded` formato nel corpo della richiesta all'endpoint del token.
**`grant_type`**
*Campo obbligatorio*.
Il tipo di concessione OIDC che desideri richiedere.
Deve essere `authorization_code` o `refresh_token` o `client_credentials`. Puoi richiedere un token di accesso per un ambito personalizzato dall'endpoint del token alle seguenti condizioni:
+ Hai abilitato l'ambito richiesto nella configurazione del client dell'app.
+ Hai configurato il client dell'app con un client secret.
+ Abilita la concessione delle credenziali del cliente nel client dell'app.
L'endpoint del token restituisce un token di aggiornamento solo quando lo è. `grant_type` `authorization_code`
**`client_id`**
*Facoltativo. Non richiesto quando si fornisce l'ID client dell'app nell'`Authorization`intestazione.*
L'ID di un client app nel tuo pool di utenti. Specificate lo stesso client dell'app che ha autenticato l'utente.
È necessario fornire questo parametro se il client è pubblico e non dispone di un segreto o è `client_secret_post` autorizzato. `client_secret`
**`client_secret`**
*Facoltativo. Non richiesto quando si fornisce il segreto del client nell'`Authorization`intestazione e quando il client dell'app non dispone di un segreto.*
Il segreto del client dell'app, se il client dell'app ne ha uno, per `client_secret_post` l'autorizzazione.
**`scope`**
*Facoltativo*.
Può essere una combinazione di qualsiasi ambito associato al client dell'app. Amazon Cognito ignora gli ambiti della richiesta che non sono consentiti per il client dell'app richiesto. Se non fornisci questo parametro di richiesta, il server di autorizzazione restituisce una `scope` richiesta di token di accesso con tutti gli ambiti di autorizzazione abilitati nella configurazione del client dell'app. Puoi richiedere uno qualsiasi degli ambiti consentiti per il client dell'app richiesto: ambiti standard, ambiti personalizzati dai server di risorse e ambito self-service dell'`aws.cognito.signin.user.admin`utente.
**`redirect_uri`**
*Facoltativo. Non richiesto per la concessione delle credenziali del client.*
Deve essere lo stesso `redirect_uri` utilizzato per ottenere `authorization_code` in `/oauth2/authorize`.
È necessario fornire questo parametro se lo è. `grant_type` `authorization_code`
**`refresh_token`**
*Facoltativo. Utilizzato solo quando l'utente dispone già di un token di aggiornamento e desidera ottenere un nuovo ID e token di accesso.*
Per generare nuovi token di accesso e ID per la sessione di un utente, imposta il valore di su un token `refresh_token` di aggiornamento valido emesso dal client dell'app richiesto.
Restituisce un nuovo token di aggiornamento con un nuovo ID e token di accesso quando la [rotazione del token di aggiornamento](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-rotation) è attiva, altrimenti restituisce solo ID e token di accesso. Se il token di accesso originale era [associato a una risorsa API](cognito-user-pools-define-resource-servers.md#cognito-user-pools-resource-binding), il nuovo token di accesso mantiene l'URL dell'API richiesto nel claim. `aud`
**`code`**
*Facoltativo. Richiesto solo nelle concessioni di codici di autorizzazione.*
Il codice di autorizzazione derivante da una concessione di codice di autorizzazione. È necessario fornire questo parametro se la richiesta di autorizzazione includeva un `grant_type` di`authorization_code`.
**`aws_client_metadata`**
*Facoltativo*.
Informazioni che si desidera trasmettere ai flussi di autorizzazione [Trigger Lambda di pre-generazione del token](user-pool-lambda-pre-token-generation.md) in [machine-to-machine (M2M)](cognito-user-pools-define-resource-servers.md). L'applicazione può raccogliere informazioni contestuali sulla sessione e passarle in questo parametro. Quando passi `aws_client_metadata` il formato JSON con codifica URL, Amazon Cognito lo include nell'evento di input della funzione Lambda trigger. La versione dell'evento pre token trigger o la versione globale del trigger Lambda deve essere configurata per la versione tre o successiva. Sebbene Amazon Cognito accetti le richieste a questo endpoint nei flussi M2M del codice di autorizzazione e delle credenziali client, il tuo pool di utenti passa `aws_client_metadata` al trigger precedente alla generazione del token solo dalle richieste di credenziali del client.
**`code_verifier`**
Opzionale. Richiesto solo se hai fornito i `code_challenge` parametri nella richiesta `code_challenge_method` di autorizzazione iniziale.
[Il verificatore di codice generato `code_challenge` da cui l'applicazione ha calcolato in una richiesta di concessione del codice di autorizzazione con PKCE.](using-pkce-in-authorization-code.md)
## Sostituzione di un codice di autorizzazione per i token
La seguente richiesta genera correttamente ID, token di accesso e aggiornamento dopo l'autenticazione con una concessione del codice di autorizzazione. La richiesta trasmette il segreto del client nel formato dell'intestazione. `client_secret_basic` `Authorization`
```
POST https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/token&
Content-Type='application/x-www-form-urlencoded'&
Authorization=Basic ZGpjOTh1M2ppZWRtaTI4M2V1OTI4OmFiY2RlZjAxMjM0NTY3ODkw
grant_type=authorization_code&
client_id=1example23456789&
code=AUTHORIZATION_CODE&
redirect_uri=com.myclientapp://myclient/redirect
```
La risposta invia all'utente nuovi ID, token di accesso e aggiornamento, con metadati aggiuntivi.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"refresh_token": "eyJj3example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Credenziali del client con autorizzazione di base
La seguente richiesta proveniente da un'applicazione M2M richiede la concessione delle credenziali del client. Poiché le credenziali del client richiedono un client secret, la richiesta viene autorizzata con un'`Authorization`intestazione derivata dall'ID e dal segreto del client dell'app. La richiesta genera un token di accesso con i due ambiti richiesti. La richiesta include anche i metadati del client che forniscono informazioni sull'indirizzo IP e un token rilasciato all'utente per conto del quale questa concessione è concessa. Amazon Cognito passa i metadati del client al trigger Lambda prima della generazione di token.
```
POST https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/token >
Content-Type='application/x-www-form-urlencoded'&
Authorization=Basic ZGpjOTh1M2ppZWRtaTI4M2V1OTI4OmFiY2RlZjAxMjM0NTY3ODkw
grant_type=client_credentials&
client_id=1example23456789&
scope=resourceServerIdentifier1%2Fscope1%20resourceServerIdentifier2%2Fscope2&
&aws_client_metadata=%7B%22onBehalfOfToken%22%3A%22eyJra789ghiEXAMPLE%22,%20%22ClientIpAddress%22%3A%22192.0.2.252%22%7D
```
Amazon Cognito trasmette il seguente evento di input al trigger Lambda prima della generazione del token.
```
{
version: '3',
triggerSource: 'TokenGeneration_ClientCredentials',
region: 'us-east-1',
userPoolId: 'us-east-1_EXAMPLE',
userName: 'ClientCredentials',
callerContext: {
awsSdkVersion: 'aws-sdk-unknown-unknown',
clientId: '1example23456789'
},
request: {
userAttributes: {},
groupConfiguration: null,
scopes: [
'resourceServerIdentifier1/scope1',
'resourceServerIdentifier2/scope2'
],
clientMetadata: {
'onBehalfOfToken': 'eyJra789ghiEXAMPLE',
'ClientIpAddress': '192.0.2.252'
}
},
response: { claimsAndScopeOverrideDetails: null }
}
```
La risposta restituisce un token di accesso. Le credenziali concesse ai client servono per l'autorizzazione machine-to-machine (M2M) e restituiscono solo token di accesso.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Credenziali del cliente con autorizzazione dell'ente POST
La seguente richiesta di concessione di credenziali client include il `client_secret` parametro nel corpo della richiesta e non include un'intestazione. `Authorization` Questa richiesta utilizza la sintassi di autorizzazione. `client_secret_post` La richiesta genera un token di accesso con l'ambito richiesto. La richiesta include anche i metadati del client che forniscono informazioni sull'indirizzo IP e un token rilasciato all'utente per conto del quale questa concessione è concessa. Amazon Cognito passa i metadati del client al trigger Lambda prima della generazione di token.
```
POST /oauth2/token HTTP/1.1
Content-Type: application/x-www-form-urlencoded
X-Amz-Target: AWSCognitoIdentityProviderService.Client credentials request
User-Agent: USER_AGENT
Accept: /
Accept-Encoding: gzip, deflate, br
Content-Length: 177
Referer: http://auth.example.com/oauth2/token
Host: auth.example.com
Connection: keep-alive
grant_type=client_credentials&
client_id=1example23456789&
scope=my_resource_server_identifier%2Fmy_custom_scope&
client_secret=9example87654321&
aws_client_metadata=%7B%22onBehalfOfToken%22%3A%22eyJra789ghiEXAMPLE%22,%20%22ClientIpAddress%22%3A%22192.0.2.252%22%7D
```
Amazon Cognito trasmette il seguente evento di input al trigger Lambda prima della generazione del token.
```
{
version: '3',
triggerSource: 'TokenGeneration_ClientCredentials',
region: 'us-east-1',
userPoolId: 'us-east-1_EXAMPLE',
userName: 'ClientCredentials',
callerContext: {
awsSdkVersion: 'aws-sdk-unknown-unknown',
clientId: '1example23456789'
},
request: {
userAttributes: {},
groupConfiguration: null,
scopes: [
'resourceServerIdentifier1/my_custom_scope'
],
clientMetadata: {
'onBehalfOfToken': 'eyJra789ghiEXAMPLE',
'ClientIpAddress': '192.0.2.252'
}
},
response: { claimsAndScopeOverrideDetails: null }
}
```
La risposta restituisce un token di accesso. Le credenziali concesse ai client servono per l'autorizzazione machine-to-machine (M2M) e restituiscono solo token di accesso.
```
HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Date: Tue, 05 Dec 2023 16:11:11 GMT
x-amz-cognito-request-id: 829f4fe2-a1ee-476e-b834-5cd85c03373b
{
"access_token": "eyJra12345EXAMPLE",
"expires_in": 3600,
"token_type": "Bearer"
}
```
## Concessione del codice di autorizzazione con PKCE
[La seguente richiesta di esempio completa una richiesta di autorizzazione che includeva `code_challenge_method``code_challenge` parametri in una richiesta di concessione del codice di autorizzazione con PKCE.](using-pkce-in-authorization-code.md)
```
POST https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/token
Content-Type='application/x-www-form-urlencoded'&
Authorization=Basic ZGpjOTh1M2ppZWRtaTI4M2V1OTI4OmFiY2RlZjAxMjM0NTY3ODkw
grant_type=authorization_code&
client_id=1example23456789&
code=AUTHORIZATION_CODE&
code_verifier=CODE_VERIFIER&
redirect_uri=com.myclientapp://myclient/redirect
```
La risposta restituisce ID, accesso e token di aggiornamento derivanti dall'esito positivo della verifica PKCE da parte dell'applicazione.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"refresh_token": "eyJj3example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Aggiornamento del token senza aggiornamento (rotazione del token)
Le seguenti richieste di esempio forniscono un token di aggiornamento a un client di app in cui la [rotazione del token di aggiornamento](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-rotation) è inattiva. Poiché il client dell'app dispone di un client secret, la richiesta fornisce un'intestazione. `Authorization`
```
POST https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/token >
Content-Type='application/x-www-form-urlencoded'&
Authorization=Basic ZGpjOTh1M2ppZWRtaTI4M2V1OTI4OmFiY2RlZjAxMjM0NTY3ODkw
grant_type=refresh_token&
client_id=1example23456789&
refresh_token=eyJj3example
```
La risposta restituisce nuovi ID e token di accesso.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Aggiornamento dei token con rotazione dei token di aggiornamento
Le seguenti richieste di esempio forniscono un token di aggiornamento a un client di app in cui è attiva la [rotazione del token di aggiornamento](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-rotation). Poiché il client dell'app dispone di un client secret, la richiesta fornisce un'`Authorization`intestazione.
```
POST https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/token >
Content-Type='application/x-www-form-urlencoded'&
Authorization=Basic ZGpjOTh1M2ppZWRtaTI4M2V1OTI4OmFiY2RlZjAxMjM0NTY3ODkw
grant_type=refresh_token&
client_id=1example23456789&
refresh_token=eyJj3example
```
La risposta restituisce nuovi ID, token di accesso e aggiornamento.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"refresh_token": "eyJj4example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Esempi di risposte negative
Le richieste non valide generano errori dall'endpoint del token. Di seguito è riportata una mappa generale del corpo della risposta quando le richieste di token generano un errore.
```
HTTP/1.1 400 Bad Request
Content-Type: application/json;charset=UTF-8
{
"error":"invalid_request|invalid_client|invalid_grant|unauthorized_client|unsupported_grant_type"
}
```
**`invalid_request`**
Nella richiesta manca un parametro obbligatorio, include un valore di parametro non supportato (diverso da `unsupported_grant_type`) oppure è comunque non corretto. Ad esempio, `grant_type` è `refresh_token` ma `refresh_token` non è incluso.
**`invalid_client`**
L'autenticazione del client non è riuscita. Ad esempio, quando il client include `client_id` e `client_secret` nell'intestazione di autorizzazione, ma non esiste un client con valori `client_id` e `client_secret`.
**`invalid_grant`**
Il token di aggiornamento è stato revocato.
Il codice di autorizzazione è stato utilizzato già o non esiste.
Il client dell'app non ha accesso in lettura a tutti gli [attributi](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-attributes.html) nell'ambito richiesto. Ad esempio, l'app richiede l'ambito `email` e il client dell'app può leggere l'attributo `email`, ma non `email_verified`.
**`unauthorized_client`**
Il client non ha le autorizzazioni necessarie per il flusso di concessione del codice o per l'aggiornamento dei token.
**`unsupported_grant_type`**
Restituito se `grant_type` è diverso da `authorization_code`, `refresh_token` o `client_credentials`.
# L'endpoint degli attributi utente
Laddove OIDC emette token ID che contengono attributi utente, OAuth 2.0 implementa l'endpoint. `/oauth2/userInfo` Un utente o client autenticato riceve un token di accesso con un claim. `scopes` Questa affermazione determina gli attributi che il server di autorizzazione deve restituire. Quando un'applicazione presenta un token di accesso all'`userInfo`endpoint, il server di autorizzazione restituisce un corpo di risposta che contiene gli attributi utente che rientrano nei limiti stabiliti dagli ambiti del token di accesso. L'applicazione può recuperare informazioni su un utente dall'`userInfo`endpoint purché disponga di un token di accesso valido con almeno un requisito di ambito. `openid`
L'endpoint `userInfo` è un [endpoint userInfo](https://openid.net/specs/openid-connect-core-1_0.html#UserInfo) OpenID Connect (OIDC). [Risponde con gli attributi utente quando i provider di servizi presentano i token di accesso emessi dall'endpoint del token.](token-endpoint.md) Gli ambiti nel token di accesso dell'utente definiscono gli attributi utente restituiti dall'endpoint userInfo nella sua risposta. L'ambito `openid` deve essere una delle richieste del token di accesso.
Amazon Cognito emette token di accesso in risposta a richieste API dei pool di utenti come [https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html). Poiché non contengono alcun ambito, l'endpoint userInfo non accetta questi token di accesso. È invece necessario presentare i token di accesso dall'endpoint del token.
Il tuo provider di identità (IdP) OAuth 2.0 di terze parti ospita anche un userInfo endpoint. Quando l'utente si autentica con quell'IdP, Amazon Cognito scambia silenziosamente un codice di autorizzazione con l'endpoint IdP. `token` Il tuo pool di utenti passa il token di accesso IdP per autorizzare il recupero delle informazioni utente dall'endpoint IdP. `userInfo`
Gli ambiti nel token di accesso di un utente sono determinati dal parametro `scopes` request nelle richieste di autenticazione o dagli ambiti aggiunti dal trigger [Lambda prima della generazione del token](user-pool-lambda-pre-token-generation.md). È possibile decodificare i token di accesso ed esaminare le `scope` attestazioni per vedere gli ambiti di controllo degli accessi in essi contenuti. Di seguito sono riportate alcune combinazioni di ambiti che influiscono sui dati restituiti dall'endpoint. `userInfo` L'ambito riservato di Amazon Cognito non `aws.cognito.signin.user.admin` ha alcun effetto sui dati restituiti da questo endpoint.Esempi di ambiti nel token di accesso e loro effetto sulla risposta `userInfo`
**`openid`**
Restituisce una risposta con tutti gli attributi utente che il client dell'app è in grado di leggere.
**`openid profile`**
Restituisce gli attributi utente `name` `family_name``given_name`,`middle_name`,`nickname`,`preferred_username`,`profile`,`picture`,`website`,`gender`,`birthdate`,`zoneinfo`,`locale`, e`updated_at`. Restituisce anche [attributi personalizzati](user-pool-settings-attributes.md#user-pool-settings-custom-attributes). Nei client di app che non dispongono dell'accesso in lettura a ciascun attributo, la risposta a questo ambito è costituita da tutti gli attributi all'interno delle specifiche a cui il client dell'app ha accesso in lettura.
**`openid email`**
Restituisce le informazioni di base del profilo `email` e `email_verified` gli attributi and.
**`openid phone`**
Restituisce le informazioni di base del profilo `phone_number` e `phone_number_verified` gli attributi and.
## GET /oauth2/userInfo
L'applicazione genera le richieste a questo endpoint direttamente, non tramite un browser.
Per ulteriori informazioni, consulta [Endpoint UserInfo](http://openid.net/specs/openid-connect-core-1_0.html#UserInfo) nelle specifiche di OpenID Connect (OIDC).
**Topics**
+ [GET /oauth2/userInfo](#get-userinfo)
+ [Parametri della richiesta nell'intestazione](#get-userinfo-request-header-parameters)
+ [Esempio: richiesta](#get-userinfo-positive-exchanging-authorization-code-for-userinfo-sample-request)
+ [Esempio: risposta positiva](#get-userinfo-response-sample)
+ [Esempio di risposte negative](#get-userinfo-negative)
## Parametri della richiesta nell'intestazione
**`Authorization: Bearer `**
Passa il token di accesso nel campo dell'intestazione dell'autorizzazione.
Obbligatorio.
## Esempio: richiesta
```
GET /oauth2/userInfo HTTP/1.1
Content-Type: application/x-amz-json-1.1
Authorization: Bearer eyJra12345EXAMPLE
User-Agent: [User agent]
Accept: */*
Host: auth.example.com
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
```
## Esempio: risposta positiva
```
HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Content-Length: [Integer]
Date: [Timestamp]
x-amz-cognito-request-id: [UUID]
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
Strict-Transport-Security: max-age=31536000 ; includeSubDomains
X-Frame-Options: DENY
Server: Server
Connection: keep-alive
{
"sub": "[UUID]",
"email_verified": "true",
"custom:mycustom1": "CustomValue",
"phone_number_verified": "true",
"phone_number": "+12065551212",
"email": "bob@example.com",
"username": "bob"
}
```
Per un elenco di richieste OIDC, vedi la sezione relativa alle [richieste standard](http://openid.net/specs/openid-connect-core-1_0.html#StandardClaims). Attualmente, Amazon Cognito restituisce i valori per `email_verified` e `phone_number_verified` come stringhe.
## Esempio di risposte negative
### Esempio: richiesta errata
```
HTTP/1.1 400 Bad Request
WWW-Authenticate: error="invalid_request",
error_description="Bad OAuth2 request at UserInfo Endpoint"
```
**`invalid_request`**
Nella richiesta manca un parametro obbligatorio, include un valore di parametro non supportato oppure è in altro modo errata.
### Esempio: token errato
```
HTTP/1.1 401 Unauthorized
WWW-Authenticate: error="invalid_token",
error_description="Access token is expired, disabled, or deleted, or the user has globally signed out."
```
**`invalid_token`**
Il token di accesso è scaduto, revocato, non valido o non è valido.
# L'endpoint di revoca del token
Gli utenti che dispongono di un token di aggiornamento nella loro sessione hanno qualcosa di simile a un cookie del browser. Possono rinnovare la sessione esistente purché il token di aggiornamento sia valido. Invece di richiedere a un utente di accedere dopo la scadenza dell'ID o del token di accesso, l'applicazione può utilizzare il token di aggiornamento per ottenere nuovi token validi. Tuttavia, è possibile stabilire esternamente che la sessione di un utente debba essere terminata oppure l'utente potrebbe scegliere di dimenticare la sessione corrente. A quel punto, puoi revocare quel token di aggiornamento in modo che l'utente non possa più persistere nella sessione.
L'`/oauth2/revoke`endpoint revoca il token di accesso di un utente che Amazon Cognito aveva inizialmente emesso con il token di aggiornamento fornito. Questo endpoint revoca anche il token di aggiornamento stesso e tutti i token di accesso e di identità successivi dello stesso token di aggiornamento. Dopo che l'endpoint ha revocato i token, non puoi utilizzare i token di accesso revocati per accedere ai token di Amazon APIs Cognito autenticati.
## POST /oauth2/revoke
L'endpoint `/oauth2/revoke` supporta solo `HTTPS POST`. Il client del bacino d'utenza effettua direttamente le richieste a questo endpoint e non tramite il browser di sistema.
### Parametri della richiesta nell'intestazione
**`Authorization`**
Se il client dell'app dispone di un client secret, l'applicazione deve trasmetterlo `client_id` e `client_secret` inserirlo nell'intestazione di autorizzazione tramite l'autorizzazione HTTP di base. Il segreto è [Basic](https://en.wikipedia.org/wiki/Basic_access_authentication#Client_side) `Base64Encode(client_id:client_secret)`.
**`Content-Type`**
Deve sempre essere `'application/x-www-form-urlencoded'`.
#### Parametri della richiesta nel corpo
**`token`**
(Obbligatorio) Il token di aggiornamento che il client desidera revocare. La richiesta revoca anche tutti i token di accesso emessi da Amazon Cognito con questo token di aggiornamento.
Obbligatorio.
**`client_id`**
(Facoltativo) L'ID client dell'app per il token che desideri revocare.
Obbligatorio se il client è pubblico e non dispone di un segreto.
## Esempi di richiesta di revoca
Questa richiesta di revoca revoca un token di aggiornamento per un client di app che non ha alcun segreto client. Annotate il `client_id` parametro nel corpo della richiesta.
```
POST /oauth2/revoke HTTP/1.1
Host: mydomain.auth.us-east-1.amazoncognito.com
Accept: application/json
Content-Type: application/x-www-form-urlencoded
token=2YotnFZFEjr1zCsicMWpAA&
client_id=1example23456789
```
*Questa richiesta di revoca revoca un token di aggiornamento per un client di app con un client segreto.* Nota l'`Authorization`intestazione che contiene un ID client codificato e un client secret, ma non nel corpo della richiesta. `client_id`
```
POST /oauth2/revoke HTTP/1.1
Host: mydomain.auth.us-east-1.amazoncognito.com
Accept: application/json
Content-Type: application/x-www-form-urlencoded
Authorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW
token=2YotnFZFEjr1zCsicMWpAA
```
## Risposta di errore di revoca
Una risposta riuscita contiene un corpo vuoto. La risposta di errore è un oggetto JSON con un campo `error` e possibilmente un campo `error_description`.
**Errori di endpoint**
+ Se il token non è presente nella richiesta o se la funzionalità è disabilitata per il client dell'app, viene restituito un codice di errore HTTP 400 e `invalid_request`.
+ Se il token inviato da Amazon Cognito nella richiesta di revoca non è un token di aggiornamento, riceverai un codice di errore HTTP 400 e `unsupported_token_type`.
+ Se le credenziali client non sono valide, riceverai un codice di errore HTTP 401 e `invalid_client`.
+ Se il token è stato revocato o se il client ha inviato un token non valido, viene restituito un codice di errore HTTP 200 OK.
# L'endpoint di asserzione SAML IdP
`/saml2/idpresponse`riceve asserzioni SAML. Nell'accesso service-provider-initiated (avviato da SP), l'applicazione non interagisce direttamente con questo endpoint: il tuo provider di identità SAML 2.0 (IdP) reindirizza l'utente qui con la sua risposta SAML. Per l'accesso avviato da SP, configura il tuo IdP con il percorso del tuo URL As the Assertion Consumer Service (`saml2/idpresponse`ACS). Per ulteriori informazioni sull'avvio della sessione, consulta. [Avvio della sessione SAML nei bacini d'utenza di Amazon Cognito](cognito-user-pools-SAML-session-initiation.md)
Nell'accesso avviato da IdP, richiama le richieste a questo endpoint nell'applicazione dopo aver effettuato l'accesso come utente con il tuo provider SAML 2.0. I tuoi utenti accedono con il tuo IdP nel loro browser, quindi l'applicazione raccoglie l'asserzione SAML e la invia a questo endpoint. È necessario inviare le asserzioni SAML nel corpo di una richiesta tramite HTTPS. `HTTP POST` Il corpo della `POST` richiesta deve essere un `SAMLResponse` parametro e un `Relaystate` parametro. Per ulteriori informazioni, consulta [Implementazione dell'accesso SAML avviato da IdP](cognito-user-pools-SAML-session-initiation.md#cognito-user-pools-SAML-session-initiation-idp-initiation).
L'`saml2/idpresponse`endpoint può accettare asserzioni SAML lunghe fino a 100.000 caratteri.
## POSTA `/saml2/idpresponse`
Per utilizzare l'`/saml2/idpresponse`endpoint in un accesso avviato da IdP, genera una richiesta POST con parametri che forniscano al tuo pool di utenti informazioni sulla sessione dell'utente.
+ Il client dell'app a cui vogliono accedere.
+ L'URL di callback a cui vogliono finire.
+ Gli ambiti OAuth 2.0 che vogliono richiedere nel token di accesso dell'utente.
+ L'IdP che ha avviato la richiesta di accesso.
### Parametri del corpo della richiesta avviati da IDP
*SAMLResponse*
Un'asserzione SAML con codifica Base64 di un IdP associata a un client di app valido e a una configurazione IdP nel tuo pool di utenti.
*RelayState*
Un `RelayState` parametro contiene i parametri di richiesta che altrimenti passeresti all'endpoint. `oauth2/authorize` Per ulteriori informazioni su questi parametri, consulta [Endpoint Authorize](authorization-endpoint.md).
*response\$1type*
Il tipo di concessione OAuth 2.0.
*client\$1id*
L'ID del client dell'applicazione.
*redirect\$1uri*
L'URL a cui il server di autenticazione reindirizza il browser una volta che Amazon Cognito concede l'autorizzazione all'utente.
*identity\$1provider*
Il nome del provider di identità a cui desideri reindirizzare l'utente.
*idp\$1identifier*
L'identificatore del provider di identità a cui desideri reindirizzare l'utente.
*scope*
Gli ambiti OAuth 2.0 che desideri che l'utente richieda al server di autorizzazione.
### Richieste di esempio con risposte positive
**Esempio: richiesta POST**
La seguente richiesta riguarda la concessione di un codice di autorizzazione per un utente da IdP `MySAMLIdP` nel client dell'app. `1example23456789` L'utente reindirizza a `https://www.example.com` con il proprio codice di autorizzazione, che può essere scambiato con token che includono un token di accesso con ambiti OAuth 2.0, e. `openid` `email` `phone`
```
POST /saml2/idpresponse HTTP/1.1
User-Agent: USER_AGENT
Accept: */*
Host: example.auth.us-east-1.amazoncognito.com
Content-Type: application/x-www-form-urlencoded
SAMLResponse=[Base64-encoded SAML assertion]&RelayState=identity_provider%3DMySAMLIdP%26client_id%3D1example23456789%26redirect_uri%3Dhttps%3A%2F%2Fwww.example.com%26response_type%3Dcode%26scope%3Demail%2Bopenid%2Bphone
```
**Esempio: risposta**
Di seguito è riportata la risposta alla richiesta precedente.
```
HTTP/1.1 302 Found
Date: Wed, 06 Dec 2023 00:15:29 GMT
Content-Length: 0
x-amz-cognito-request-id: 8aba6eb5-fb54-4bc6-9368-c3878434f0fb
Location: https://www.example.com?code=[Authorization code]
```
# OAuth Sovvenzioni 2.0
[Il server di autorizzazione del pool di utenti di Amazon Cognito OAuth 2.0 emette token in risposta a tre tipi di concessioni di autorizzazione OAuth 2.0.](https://datatracker.ietf.org/doc/html/rfc6749#section-1.3) Puoi impostare i tipi di concessione supportati per ogni client dell'app nel pool di utenti. Non puoi abilitare concessioni delle *credenziali del client* nello stesso client dell'app come concessioni *implicite* o del *codice di autorizzazione*. Le richieste per concessioni implicite e del codice di autorizzazione iniziano in in [Endpoint Authorize](authorization-endpoint.md) e le richieste per concessioni delle credenziali dei clienti iniziano in [Endpoint Token](token-endpoint.md).
**Concessione codice autorizzazione**
In risposta alla richiesta di autenticazione riuscita, il server di autorizzazione aggiunge un codice di autorizzazione in un parametro `code` all'URL di callback. Occorre quindi scambiare il codice per token ID, di accesso e di aggiornamento con [Endpoint Token](token-endpoint.md). Per richiedere una concessione del codice di autorizzazione, imposta `response_type` su `code` nella richiesta. Per una richiesta di esempio, consulta [Esempio: concessione del codice di autorizzazione](authorization-endpoint.md#sample-authorization-code-grant). Amazon Cognito supporta [Proof Key for Code Exchange (PKCE)](using-pkce-in-authorization-code.md) nelle concessioni di codici di autorizzazione.
La concessione del codice di autorizzazione è la forma più sicura di concessione di autorizzazione. Non mostra il contenuto dei token direttamente agli utenti. L'app è invece responsabile del recupero e dell'archiviazione sicura dei token dell'utente. In Amazon Cognito, una concessione del codice di autorizzazione è l'unico modo per ottenere tutti e tre i tipi di token (ID, accesso e aggiornamento) dal server di autorizzazione. Puoi anche ottenere tutti e tre i tipi di token dall'autenticazione tramite l'API dei pool di utenti di Amazon Cognito, ma l'API non emette token di accesso con ambiti diversi da. `aws.cognito.signin.user.admin`
**Implicit grant (Concessione implicita)**
In risposta alla richiesta di autenticazione riuscita, il server di autorizzazione aggiunge un token di accesso in un parametro `access_token` e un token ID in un parametro `id_token`, all'URL di callback. Una concessione implicita non richiede alcuna interazione aggiuntiva con [Endpoint Token](token-endpoint.md). Per richiedere una concessione implicita, imposta `response_type` su `token` nella richiesta. La concessione implicita genera solo un ID e un token di accesso. Per una richiesta di esempio, consulta [Esempio: concessione di token (implicita) senza ambito `openid`](authorization-endpoint.md#sample-token-grant-without-openid-scope).
La concessione implicita è una concessione di autorizzazione legacy. A differenza della concessione del codice di autorizzazione, gli utenti possono intercettare e ispezionare i token. Per impedire la distribuzione dei token tramite concessione implicita, configura il client dell'app in modo che supporti solo la concessione del codice di autorizzazione.
**Client credentials (Credenziali del client)**
Le credenziali del client sono concesse solo per l'autorizzazione all'accesso. machine-to-machine Per ricevere una concessione delle credenziali del client, ignora il [Endpoint Authorize](authorization-endpoint.md) e genera una richiesta direttamente a [Endpoint Token](token-endpoint.md). Il client dell'app deve disporre di un segreto del client e supportare solo le concessioni delle credenziali del cliente. In risposta alla richiesta riuscita, il server di autorizzazione restituisce un token di accesso.
Il token di accesso derivante dalla concessione di credenziali client è un meccanismo di autorizzazione che contiene ambiti 2.0. OAuth In genere, il token contiene attestazioni di ambito personalizzate che autorizzano le operazioni HTTP a essere protette dall'accesso. APIs Per ulteriori informazioni, consulta [Ambiti, M2M e server di risorse](cognito-user-pools-define-resource-servers.md).
Le credenziali del cliente garantiscono costi aggiuntivi alla fattura. AWS Per ulteriori informazioni, consultare [Prezzi di Amazon Cognito](https://aws.amazon.com/cognito/pricing).
**Token di aggiornamento**
Puoi richiedere la concessione di un token di aggiornamento direttamente da. [Endpoint Token](token-endpoint.md) Questa concessione restituisce nuovi ID e token di accesso in cambio di un token di aggiornamento valido.
*Per ulteriori informazioni su queste sovvenzioni e sulla loro implementazione, consulta Come usare la [OAuth versione 2.0 in Amazon Cognito: scopri le OAuth diverse sovvenzioni 2.0 nel AWS blog sulla](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/) sicurezza.*
# Utilizzo di PKCE nelle concessioni di codici di autorizzazione
Amazon Cognito supporta l'autenticazione Proof Key for Code Exchange (PKCE) nelle concessioni di codici di autorizzazione. PKCE è un'estensione della concessione del codice di autorizzazione OAuth 2.0 per i clienti pubblici. PKCE protegge dal riscatto dei codici di autorizzazione intercettati.
## In che modo Amazon Cognito utilizza PKCE
Per avviare l'autenticazione con PKCE, l'applicazione deve generare un valore di stringa univoco. Questa stringa è il verificatore del codice, un valore segreto che Amazon Cognito utilizza per confrontare il client che richiede la concessione di autorizzazione iniziale con il client che scambia il codice di autorizzazione in token.
L'app deve applicare un SHA256 hash alla stringa del verificatore del codice e codificare il risultato in base64. Passa la stringa con hash a [Endpoint Authorize](authorization-endpoint.md) come parametro nel corpo della richiesta. `code_challenge` Quando l'app scambia il codice di autorizzazione in cambio di token, deve includere la stringa del verificatore del codice in testo semplice come `code_verifier` parametro nel corpo della richiesta a. [Endpoint Token](token-endpoint.md) Amazon Cognito esegue la stessa hash-and-encode operazione sul verificatore di codice. Amazon Cognito restituisce ID, accesso e token di aggiornamento solo se determina che il verificatore del codice genera la stessa richiesta di codice ricevuta nella richiesta di autorizzazione.
**Per implementare Authorization Grant Flow con PKCE**
1. Apri la [console Amazon Cognito](https://console.aws.amazon.com/cognito/home). Se richiesto, inserisci le tue AWS credenziali.
1. Scegli **User Pools** (Pool di utenti).
1. Scegli un bacino d'utenza esistente dall'elenco o creane uno nuovo. Se crei un pool di utenti, durante la procedura guidata ti verrà richiesto di configurare un client per l'app e configurare l'accesso gestito.
1. Se crei un nuovo pool di utenti, configura un client per l'app e configura l'accesso gestito durante la configurazione guidata.
1. Se configuri un pool di utenti esistente, aggiungi un [dominio](cognito-user-pools-assign-domain.md) e un [client di app pubblico](user-pool-settings-client-apps.md), se non l'hai già fatto.
1. Genera una stringa alfanumerica casuale, in genere un identificatore univoco universale ([UUID](cognito-terms.md#terms-uuid)), per creare una sfida di codice per il PKCE. Questa stringa è il valore del `code_verifier` parametro che verrà inviato nella richiesta a. [Endpoint Token](token-endpoint.md)
1. Effettua l'hash della `code_verifier` stringa con l' SHA256 algoritmo. Codifica il risultato dell'operazione di hashing in base64. Questa stringa è il valore del `code_challenge` parametro che verrà inviato nella richiesta a. [Endpoint Authorize](authorization-endpoint.md)
L'Pythonesempio seguente genera un `code_verifier` e calcola: `code_challenge`
```
#!/usr/bin/env python3
import secrets
from base64 import urlsafe_b64encode
from hashlib import sha256
from string import ascii_letters
from string import digits
# use the secrets module for cryptographically strong random values
alphabet = ascii_letters + digits
code_verifier = ''.join(secrets.choice(alphabet) for _ in range(128))
code_verifier_hash = sha256(code_verifier.encode()).digest()
code_challenge = urlsafe_b64encode(code_verifier_hash).decode().rstrip('=')
print(f"code challenge: {code_challenge}")
print(f"code verifier: {code_verifier}")
```
Di seguito è riportato un esempio di output dello Python script:
```
code challenge: Eh0mg-OZv7BAyo-tdv_vYamx1boOYDulDklyXoMDtLg
code verifier: 9D-aW_iygXrgQcWJd0y0tNVMPSXSChIc2xceDhvYVdGLCBk-JWFTmBNjvKSdOrjTTYazOFbUmrFERrjWx6oKtK2b6z_x4_gHBDlr4K1mRFGyE8yA-05-_v7Dxf3EIYJH
```
1. Completa l'accesso gestito con una richiesta di concessione del codice di autorizzazione con PKCE. Di seguito è riportato un esempio di URL:
```
https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?response_type=code&client_id=1example23456789&redirect_uri=https://www.example.com&code_challenge=Eh0mg-OZv7BAyo-tdv_vYamx1boOYDulDklyXoMDtLg&code_challenge_method=S256
```
1. Raccogli l'autorizzazione `code` e riscattala in token con l'endpoint del token. Di seguito è riportato un esempio di richiesta:
```
POST /oauth2/token HTTP/1.1
Host: mydomain.auth.us-east-1.amazoncognito.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 296
redirect_uri=https%3A%2F%2Fwww.example.com&
client_id=1example23456789&
code=7378f445-c87f-400c-855e-0297d072ff03&
grant_type=authorization_code&
code_verifier=9D-aW_iygXrgQcWJd0y0tNVMPSXSChIc2xceDhvYVdGLCBk-JWFTmBNjvKSdOrjTTYazOFbUmrFERrjWx6oKtK2b6z_x4_gHBDlr4K1mRFGyE8yA-05-_v7Dxf3EIYJH
```
1. Rivedi la risposta. Conterrà ID, accesso e token di aggiornamento. Per ulteriori informazioni sull'utilizzo dei token del pool di utenti di Amazon Cognito, consulta. [Comprensione dei token web JSON del pool di utenti () JWTs](amazon-cognito-user-pools-using-tokens-with-identity-providers.md)
# Risposte gestite agli errori di accesso e federazione
Una procedura di accesso in accesso gestito o accesso federato potrebbe restituire un errore. Di seguito sono riportate alcune condizioni che possono determinare un errore di autenticazione.
+ Un utente esegue un'operazione che il pool di utenti non è in grado di eseguire.
+ Un trigger Lambda non risponde con la sintassi prevista.
+ Il gestore dell'identità digitale restituisce un errore.
+ Amazon Cognito non è riuscito a convalidare le informazioni sugli attributi fornite dall'utente.
+ L'IdP non ha inviato richieste che corrispondono agli attributi richiesti.
Quando Amazon Cognito rileva un errore, lo comunica in uno dei seguenti modi.
1. Amazon Cognito invia un URL di reindirizzamento con l'errore nei parametri della richiesta.
1. Amazon Cognito mostra un errore nell'accesso gestito.
Gli errori aggiunti da Amazon Cognito ai parametri della richiesta hanno il seguente formato.
```
https:///?error_description=error+description&error=error+name
```
Quando fornisci assistenza agli utenti per inviare informazioni sugli errori quando non è possibile eseguire un'operazione, richiedi che acquisiscano l'URL *e* il testo o uno screenshot della pagina.
**Nota**
Le descrizioni degli errori di Amazon Cognito non sono stringhe fisse e non devi usare una logica basata su un modello o un formato fisso.
**Messaggi di errore del provider di identità OIDC e social**
Il provider di identità potrebbe restituire un errore. Quando un OAuth IdP OIDC o 2.0 restituisce un errore conforme agli standard, Amazon Cognito reindirizza l'utente all'URL di callback e aggiunge la risposta di errore del provider ai parametri della richiesta di errore. Amazon Cognito aggiunge il nome del provider e il codice di errore HTTP alle stringhe di errore esistenti.
L'URL seguente è un reindirizzamento di esempio da un IdP che ha restituito un errore ad Amazon Cognito.
```
https://www.amazon.com/?error_description=LoginWithAmazon+Error+-+400+invalid_request+The+request+is+missing+a+required+parameter+%3A+client_secret&error=invalid_request
```
Poiché Amazon Cognito restituisce solo ciò che riceve da un provider, l'utente potrebbe visualizzare un sottoinsieme di queste informazioni.
Quando l'utente rileva un problema con l'accesso iniziale tramite l'IdP, questo invia eventuali messaggi di errore direttamente all'utente. Amazon Cognito inoltra un messaggio di errore all'utente quando genera una richiesta all'IdP per convalidare la sessione dell'utente. Relay Amazon Cognito e messaggi di errore OAuth OIDC IdP dai seguenti endpoint.
`/token`
Amazon Cognito scambia un codice di autorizzazione IdP per un token di accesso.
`/.well-known/openid-configuration`
Amazon Cognito rileva il percorso agli endpoint dell'emittente.
`/.well-known/jwks.json`
Per verificare i token Web JSON (JWTs) dell'utente, Amazon Cognito rileva le chiavi Web JSON (JWKs) utilizzate dal tuo IdP per firmare i token.
Poiché Amazon Cognito non avvia sessioni in uscita verso i provider SAML 2.0 che potrebbero restituire errori HTTP, gli errori degli utenti durante una sessione con un IdP SAML 2.0 non includono questa forma di messaggio di errore del provider.