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à. # 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 ```