Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Benutzerpool-Endpunkte und Referenz für verwaltete Logins
Amazon Cognito bietet zwei Modelle der Benutzerpool-Authentifizierung: mit der Benutzerpools-API und mit dem OAuth 2.0-Autorisierungsserver. Verwenden Sie die API, wenn Sie OpenID Connect (OIDC) -Tokens mit einem AWS SDK in Ihrem Anwendungs-Backend abrufen möchten. Verwenden Sie den Autorisierungsserver, wenn Sie Ihren Benutzerpool als OIDC-Anbieter implementieren möchten. [Der Autorisierungsserver fügt Funktionen wie [Verbundanmeldung](cognito-user-pools-identity-federation.md), [API- und M2M-Autorisierung mit Gültigkeitsbereichen für Zugriffstoken und](cognito-user-pools-define-resource-servers.md) verwaltete Anmeldung hinzu.](cognito-user-pools-managed-login.md) [Sie können die API- und OIDC-Modelle jeweils einzeln oder zusammen verwenden, die auf Benutzerpoolebene oder App-Client-Ebene konfiguriert sind.](user-pool-settings-client-apps.md) Dieser Abschnitt ist eine Referenz für die Implementierung des OIDC-Modells. Weitere Informationen zu den beiden Authentifizierungsmodellen finden Sie unter. [Grundlegendes zur Authentifizierung über API, OIDC und verwaltete Anmeldeseiten](authentication-flows-public-server-side.md#user-pools-API-operations)
Amazon Cognito aktiviert die hier aufgeführten öffentlichen Webseiten, wenn Sie Ihrem Benutzerpool eine Domain zuweisen. Ihre Domain dient als zentraler Zugangspunkt für alle Ihre App-Clients. Sie umfassen die verwaltete Anmeldung, bei der sich Ihre Benutzer registrieren und anmelden ([Login-Endpunkt](login-endpoint.md)) und abmelden können ([Logout-Endpunkt](logout-endpoint.md)). Weitere Informationen zu diesen Ressourcen finden Sie unter [Vom Benutzerpool verwaltete Anmeldung](cognito-user-pools-managed-login.md).
Diese Seiten enthalten auch die öffentlichen Webressourcen, die es Ihrem Benutzerpool ermöglichen, mit SAML-, OpenID Connect- (OIDC) und OAuth 2.0-Identitätsanbietern () von Drittanbietern zu kommunizieren. IdPs Um einen Benutzer mit einem Federated Identity Provider anzumelden, müssen Ihre Benutzer eine Anfrage an das interaktive verwaltete Login oder das OIDC senden. [Login-Endpunkt](login-endpoint.md) [Autorisieren des Endpunkts](authorization-endpoint.md) Der Authorize-Endpunkt leitet Ihre Benutzer entweder zu Ihren verwalteten Anmeldeseiten oder zu Ihrer IdP-Anmeldeseite weiter.
Ihre App kann auch *lokale Benutzer* mit der [Amazon-Cognito-Benutzerpool-API](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/Welcome.html) anmelden. Ein lokaler Benutzer existiert ausschließlich in Ihrem Benutzerpool-Verzeichnis ohne Verbund über einen externen IdP.
Zusätzlich zur verwalteten Anmeldung lässt sich Amazon Cognito auch SDKs für Android JavaScript, iOS und mehr integrieren. SDKs Sie bieten Tools zur Durchführung von Benutzerpool-API-Vorgängen mit Amazon Cognito API-Serviceendpunkten. Weitere Hinweise zu Service-Endpunkten finden Sie unter [Endpunkte und Kontingente von Amazon Cognito Identity](https://docs.aws.amazon.com/general/latest/gr/cognito_identity.html).
**Warnung**
Fixieren Sie die Endentitäts- oder Zwischenzertifikate für Transport Layer Security (TLS) nicht für Amazon Cognito Cognito-Domains. AWS verwaltet alle Zertifikate für all Ihre Benutzerpool-Endpunkte und Präfix-Domains. Die Zertifizierungsstellen (CAs) in der Vertrauenskette, die Amazon Cognito Cognito-Zertifikate unterstützt, rotieren und erneuern sich dynamisch. Wenn Sie Ihre App an ein Zwischen- oder Leaf-Zertifikat anheften, kann es sein, dass Ihre App bei wechselnden AWS Zertifikaten ohne Vorankündigung fehlschlägt.
Heften Sie Ihre Anwendung stattdessen an alle verfügbaren [Amazon-Stammzertifikate](https://www.amazontrust.com/repository/) an. Weitere Informationen finden Sie unter „Bewährte Verfahren und Empfehlungen“ unter [Zertifikat-Pinning](https://docs.aws.amazon.com/acm/latest/userguide/acm-bestpractices.html#best-practices-pinning) im *AWS Certificate Manager -Benutzerhandbuch*.
**Topics**
+ [Benutzerinteraktives verwaltetes Login und klassische Endpunkte für gehostete Benutzeroberflächen](managed-login-endpoints.md)
+ [Identitätsanbieter und Endpunkte der vertrauenden Partei](federation-endpoints.md)
+ [OAuth 2.0 Zuschüsse](federation-endpoints-oauth-grants.md)
+ [Verwendung von PKCE in Autorisierungscode-Zuschüssen](using-pkce-in-authorization-code.md)
+ [Antworten auf verwaltete Anmelde- und Verbundfehler](federation-endpoint-idp-responses.md)
# Benutzerinteraktives verwaltetes Login und klassische Endpunkte für gehostete Benutzeroberflächen
Amazon Cognito aktiviert die verwalteten Anmeldeendpunkte in diesem Abschnitt, wenn Sie Ihrem Benutzerpool eine Domain hinzufügen. Dies sind Webseiten, auf denen Ihre Benutzer die wichtigsten Authentifizierungsvorgänge eines Benutzerpools abschließen können. Sie enthalten Seiten für Passwortverwaltung, Multi-Faktor-Authentifizierung (MFA) und Attributüberprüfung.
Die Webseiten, aus denen sich die verwaltete Anmeldung zusammensetzt, sind Frontend-Webanwendungen für interaktive Benutzersitzungen mit Ihren Kunden. Ihre App muss die verwaltete Anmeldung in den Browsern Ihrer Benutzer aufrufen. Amazon Cognito unterstützt keinen programmatischen Zugriff auf die Webseiten in diesem Kapitel. Die Verbund-Endpunkte in der [Identitätsanbieter und Endpunkte der vertrauenden Partei](federation-endpoints.md), die eine JSON-Antwort zurückgeben, können direkt in Ihrem App-Code abgefragt werden. Die [Autorisieren des Endpunkts](authorization-endpoint.md) leitet entweder zur verwalteten Anmeldung oder zu einer IdP-Anmeldeseite weiter und muss auch in den Browsern der Benutzer geöffnet werden.
Alle Benutzerpool-Endpunkte akzeptieren Datenverkehr von IPv4 und IPv6 Quell-IP-Adressen.
In den Themen in diesem Handbuch werden häufig verwendete Endpunkte für verwaltete Anmeldung und klassische gehostete Benutzeroberflächen ausführlich beschrieben. Der Unterschied zwischen der verwalteten Anmeldung und der gehosteten Benutzeroberfläche ist sichtbar und funktioniert nicht. Mit Ausnahme `/passkeys/add` von: Alle Pfade werden von den beiden Versionen des Brandings für verwaltete Logins gemeinsam genutzt.
Amazon Cognito stellt die folgenden Webseiten bereit, wenn Sie Ihrem Benutzerpool eine Domain zuweisen.
**Verwaltete Anmelde-Endpunkte**
| Endpunkt-URL | Description | Zugriff darauf |
| --- | --- | --- |
| https://Your user pool domain/login | Meldet lokale Benutzer und Verbundbenutzer im Benutzerpool an. | Weiterleitung von Endpunkten wie [Autorisieren des Endpunkts](authorization-endpoint.md), `/logout` und `/confirmforgotPassword`. Siehe [Login-Endpunkt](login-endpoint.md). |
| https://Your user pool domain/logout | Meldet Benutzer des Benutzerpools ab. | Direkt-Link. Siehe [Logout-Endpunkt](logout-endpoint.md). |
| https:///ConfirmUser Your user pool domain | Bestätigt Benutzer, die einen E-Mail-Link ausgewählt haben, um ihr Benutzerkonto zu verifizieren. | Der Benutzer hat einen Link in einer E-Mail-Nachricht ausgewählt. |
| https:///signup Your user pool domain | Registriert einen neuen Benutzer. Die Seite /login leitet die Benutzer an /signup weiter, wenn sie Sign up (Registrieren) auswählen. | Direkter Link mit den gleichen Parametern wie `/oauth2/authorize`. |
| https:///confirm Your user pool domain | Nachdem Ihr Benutzerpool einen Bestätigungscode an einen Benutzer gesendet hat, der sich angemeldet hat, fordert er Ihren Benutzer auf, den Code einzugeben. | Nur Weiterleitung von `/signup`. |
| https://Your user pool domain/Passwort vergessen | Fordert die Benutzer zur Eingabe des Benutzernamens auf und sendet einen Code zum Zurücksetzen des Passworts. Die Seite /login leitet die Benutzer an /forgotPassword weiter, wenn sie Forgot your password? (Passwort vergessen?) auswählen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/managed-login-endpoints.html) |
| https:///ConfirmForgotPassword Your user pool domain | Fordert die Benutzer auf, den Code zum Zurücksetzen des Passworts und anschließend ein neues Passwort einzugeben. Die Seite /forgotPassword leitet die Benutzer an /confirmforgotPassword weiter, wenn sie Reset your password (Passwort zurücksetzen) auswählen. | Nur Weiterleitung von /forgotPassword. |
| https://Your user pool domain/resendcode | Sendet einen neuen Bestätigungscode an einen Benutzer, der sich in Ihrem Benutzerpool angemeldet hat. | Nur Weiterleitung von **Neuen Code senden** unter `/confirm`. |
| https:///passkeys/add Your user pool domain | [Registriert einen neuen Hauptschlüssel.](amazon-cognito-user-pools-authentication-flow-methods.md#amazon-cognito-user-pools-authentication-flow-methods-passkey) Nur bei verwalteter Anmeldung verfügbar. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/managed-login-endpoints.html) |
**Topics**
+ [Der Endpunkt für die verwaltete Anmeldung: `/login`](login-endpoint.md)
+ [Der Endpunkt für die verwaltete Anmeldung und Abmeldung: `/logout`](logout-endpoint.md)
# Der Endpunkt für die verwaltete Anmeldung: `/login`
Der Anmeldeendpunkt ist ein Authentifizierungsserver und ein Umleitungsziel von[Autorisieren des Endpunkts](authorization-endpoint.md). Er ist der Einstiegspunkt für die verwaltete Anmeldung, wenn Sie keinen Identitätsanbieter angeben. Wenn Sie eine Weiterleitung zum Anmeldeendpunkt generieren, wird die Anmeldeseite geladen und dem Benutzer werden die für den Client konfigurierten Authentifizierungsoptionen angezeigt.
**Anmerkung**
Der Anmeldeendpunkt ist eine Komponente der verwalteten Anmeldung. Rufen Sie in Ihrer App Verbundseiten und verwaltete Anmeldeseiten auf, die zum Anmeldeendpunkt weiterleiten. Der direkte Zugriff von Benutzern auf den Anmeldeendpunkt hat sich als Methode nicht bewährt.
## GET /login
Der `/login`-Endpunkt unterstützt `HTTPS GET` nur für die erste Anfrage Ihres Benutzers. Ihre App ruft die Seite in einem Browser wie Chrome oder Firefox auf. Wenn Sie zu `/login` von der weiterleiten[Autorisieren des Endpunkts](authorization-endpoint.md), werden alle Parameter weitergegeben, die Sie in Ihrer ersten Anfrage angegeben haben. Der Anmeldeendpunkt unterstützt alle Anforderungsparameter des Autorisierungsendpunkts. Sie können auch direkt auf den Anmeldeendpunkt zugreifen. Es hat sich als Methode bewährt, die Sitzungen aller Benutzer mit `/oauth2/authorize` zu starten.
**Beispiel — Fordere den Benutzer auf, sich anzumelden**
Dieses Beispiel zeigt einen Anmeldebildschirm an.
```
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
```
**Beispiel — Antwort**
Der Authentifikationsserver wird mit Autorisierungs-Code und -Status zurück an Ihre App geleitet. Der Server muss den Code und den Status an die Abfragezeichenfolge-Parameter zurücksenden und nicht an das Fragment.
```
HTTP/1.1 302 Found
Location: https://YOUR_APP/redirect_uri?code=AUTHORIZATION_CODE&state=STATE
```
## Vom Benutzer initiierte Anmeldeanfrage
Nachdem Ihr Benutzer den `/login`-Endpunkt geladen hat, kann er einen Benutzernamen und ein Passwort eingeben und **Anmelden** wählen. Wenn er dies tut, generiert er eine `HTTPS POST`-Anfrage mit denselben Header-Anforderungsparametern wie die `GET`-Anfrage und einem Anforderungstext mit seinem Benutzernamen, Passwort und einem Gerätefingerabdruck.
# Der Endpunkt für die verwaltete Anmeldung und Abmeldung: `/logout`
Der `/logout`-Endpunkt ist ein Umleitungsendpunkt. Es meldet den Benutzer ab und leitet entweder zu einer autorisierten Abmelde-URL für Ihren App-Client oder zum Endpunkt weiter. `/login` Die verfügbaren Parameter in einer GET-Anfrage an den `/logout` Endpunkt sind auf Anwendungsfälle der verwalteten Anmeldung mit Amazon Cognito zugeschnitten.
Der Abmelde-Endpunkt ist eine Front-End-Webanwendung für interaktive Benutzersitzungen mit Ihren Kunden. Ihre App muss diesen und andere verwaltete Anmeldeendpunkte in den Browsern Ihrer Benutzer aufrufen.
Um Ihren Benutzer zur verwalteten Anmeldung weiterzuleiten, um sich erneut anzumelden, fügen Sie Ihrer Anfrage einen `redirect_uri` Parameter hinzu. Eine `logout`-Anfrage mit einem `redirect_uri`-Parameter muss auch Parameter für Ihre nachfolgende Anfrage an den [Login-Endpunkt](login-endpoint.md) enthalten, wie `client_id`, `response_type` und `scope`.
Um Ihren Benutzer auf eine von Ihnen gewählte Seite weiterzuleiten, fügen Sie Ihrem App-Client die Option **Zulässige Abmeldung URLs** hinzu. Fügen Sie in den Anfragen Ihrer Benutzer an den `logout`-Endpunkt `logout_uri`- und `client_id`-Parameter hinzu. Wenn der Wert von `logout_uri` einer der **zulässigen Abmeldungen URLs** für Ihren App-Client entspricht, leitet Amazon Cognito Benutzer zu dieser URL weiter.
Mit Single Logout (SLO) für SAML 2.0 IdPs leitet Amazon Cognito Ihren Benutzer zunächst an den SLO-Endpunkt weiter, den Sie in Ihrer IdP-Konfiguration definiert haben. Nachdem Ihr IdP Ihren Benutzer zurück zu geleitet hat`saml2/logout`, antwortet Amazon Cognito mit einer weiteren Weiterleitung auf die `redirect_uri` oder `logout_uri` von Ihrer Anfrage. Weitere Informationen finden Sie unter [SAML-Benutzer mit Single Sign-Out abmelden](cognito-user-pools-saml-idp-sign-out.md).
Der Abmeldeendpunkt meldet Benutzer nicht von OIDC oder Anbietern sozialer Identitäten ab (). IdPs Um Benutzer von ihrer Sitzung mit einem externen IdP abzumelden, leiten Sie sie zur Abmeldeseite für diesen Anbieter weiter.
## GET/Abmeldung
Der `/logout` Endpunkt unterstützt ausschließlich `HTTPS GET`. Der Benutzerpool-Client übermittelt diese Anfrage in der Regel über den Systembrowser. Der Browser ist normalerweise ein Custom Chrome Tab bei Android oder Safari Control View bei iOS.
### Anforderungsparameter
*Client-ID*
Die App-Client-ID für Ihre Anwendung. Um eine Client-ID für Ihre App abzurufen, müssen Sie die App im Benutzerpool registrieren. Weitere Informationen finden Sie unter [Anwendungsspezifische Einstellungen mit App-Clients](user-pool-settings-client-apps.md).
Erforderlich.
*Abmelde-Uri*
Leiten Sie Ihren Benutzer mit einem Parameter *logout-uri* auf eine benutzerdefinierte Abmeldeseite um. Legen Sie seinen Wert auf die **sign-out URL** (Abmelde-URL) des App-Clients fest, an die Sie Ihren Benutzer umleiten möchten, nachdem er sich abgemeldet hat. Verwenden Sie *logout\$1uri* nur mit einem *client\$1id*-Parameter. Weitere Informationen finden Sie unter [Anwendungsspezifische Einstellungen mit App-Clients](user-pool-settings-client-apps.md).
Sie können auch den *logout\$1uri*-Parameter verwenden, um Ihren Benutzer auf die Anmeldeseite eines anderen App-Clients umzuleiten. Legen Sie die Anmeldeseite für den anderen App-Client als **Allowed callback URL** (Zulässige Rückruf-URL) in Ihrem App-Client fest. Legen Sie in Ihrer Anforderung an den `/logout`-Endpunkt den Wert des *logout\$1uri*-Parameters auf die URL-codierte Anmeldeseite fest.
Amazon Cognito benötigt entweder einen *logout\$1uri*- oder einen *redirect\$1uri*-Parameter in der Anforderung an den `/logout`-Endpunkt. Ein *logout\$1uri*-Parameter leitet Ihren Benutzer auf eine andere Website um. Wenn sowohl die Parameter *logout\$1uri* als auch *redirect\$1uri* in Ihrer Anfrage an den `/logout`-Endpunkt enthalten sind, verwendet Amazon Cognito ausschließlich den Parameter *logout\$1uri* und überschreibt damit den Parameter *redirect\$1uri*.
*`nonce`*
(Optional) Ein zufälliger Wert, den Sie der Anfrage hinzufügen können. Der von Ihnen bereitgestellte Nonce-Wert ist im ID-Token enthalten, das Amazon Cognito ausgibt. Zum Schutz vor Replay-Angriffen kann Ihre App den `nonce`-Anspruch im ID-Token untersuchen und mit dem vergleichen, den Sie generiert haben. Weitere Informationen zum `nonce`-Anspruch finden Sie unter [ID-Token-Validierung](https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation) im *OpenID Connect-Standard*.
**redirect\$1uri**
Leiten Sie Ihren Benutzer auf Ihre Anmeldeseite um, um sich mit einem Parameter *redirect\$1uri* zu authentifizieren. Legen Sie seinen Wert auf die **Allowed callback URL** (Zulässige Rückruf-URL) des App-Clients fest, an die Sie Ihren Benutzer umleiten möchten, nachdem er sich wieder angemeldet hat. Fügen Sie die Parameter *client\$1id*, *scope*, *state* und *response\$1type* hinzu, die Sie an Ihren `/login`-Endpunkt übergeben möchten.
Amazon Cognito benötigt entweder einen *logout\$1uri*- oder einen *redirect\$1uri*-Parameter in der Anforderung an den `/logout`-Endpunkt. Um Ihren Benutzer an Ihren `/login` Endpunkt weiterzuleiten, um sich erneut zu authentifizieren und Token an Ihre App zu übergeben, fügen Sie einen *redirect\$1uri-Parameter* hinzu. *Wenn sowohl die Parameter *logout\$1uri* als auch *redirect\$1uri* in Ihrer Anfrage an den `/logout` Endpunkt enthalten sind, überschreibt Amazon Cognito den Parameter *redirect\$1uri* und verarbeitet ausschließlich den Parameter logout\$1uri.*
*response\$1type*
Die OAuth 2.0-Antwort, die Sie von Amazon Cognito erhalten möchten, nachdem sich Ihr Benutzer angemeldet hat. `code`und `token` sind die gültigen Werte für den Parameter *response\$1type*.
Erforderlich, wenn Sie einen *redirect\$1uri*-Parameter verwenden.
*state*
Wenn Ihre Anwendung einer Anfrage einen *State-Parameter* hinzufügt, gibt Amazon Cognito seinen Wert an Ihre App zurück, wenn der `/oauth2/logout` Endpunkt Ihren Benutzer umleitet.
Fügen Sie diesen Wert Ihren Anfragen hinzu, um sich vor [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery)-Angriffen zu schützen.
Sie können den Wert eines Parameters `state` nicht auf eine URL-codierte JSON-Zeichenfolge festlegen. Um eine Zeichenfolge, die diesem Format entspricht, in einem `state` Parameter zu übergeben, kodieren Sie die Zeichenfolge auf Base64 und dekodieren Sie sie dann in Ihrer Anwendung.
Dringend empfohlen, wenn Sie einen *redirect\$1uri*-Parameter verwenden.
*scope*
Die OAuth 2.0-Bereiche, die Sie von Amazon Cognito anfordern möchten, nachdem Sie sie mit einem *redirect\$1uri-Parameter* abgemeldet haben. Amazon Cognito leitet Ihren Benutzer an den `/login`-Endpunkt mit dem *scope*-Parameter in Ihrer Anforderung an den `/logout`-Endpunkt um.
Optional, wenn Sie einen *redirect\$1uri*-Parameter verwenden. Wenn Sie keinen *scope*-Parameter angeben, leitet Amazon Cognito Ihren Benutzer an den `/login`-Endpunkt mit einem *scope*-Parameter um. Wenn Amazon Cognito Ihren Benutzer umleitet und automatisch `scope` ausfüllt, enthält der Parameter alle autorisierten Bereiche für Ihren App-Client.
### Beispielanfragen
**Beispiel — Abmelden und Benutzer zum Client weiterleiten**
Amazon Cognito leitet Benutzersitzungen an die URL im Wert von `logout_uri` weiter und ignoriert dabei alle anderen Anforderungsparameter, wenn Anfragen `logout_uri` und `client_id` enthalten. Bei dieser URL muss es sich um eine autorisierte Abmelde-URL für den App-Client handeln.
Im Folgenden finden Sie ein Beispiel für eine Anfrage zur Abmeldung und Weiterleitung zu `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
```
**Beispiel — Melden Sie sich ab und fordern Sie den Benutzer auf, sich als ein anderer Benutzer anzumelden**
Wenn Anfragen ausgelassen werden, `logout_uri` aber ansonsten die Parameter angeben, die eine wohlgeformte Anfrage an den Autorisierungsendpunkt ausmachen, leitet Amazon Cognito Benutzer zur verwalteten Anmeldung weiter. Der Abmelde-Endpunkt hängt die Parameter in Ihrer ursprünglichen Anfrage an das Weiterleitungsziel an.
Die zusätzlichen Parameter, die Sie der Abmeldeanforderung hinzufügen, müssen in der Liste unter enthalten sein. [Anforderungsparameter](#get-logout-request-parameters) Beispielsweise unterstützt der Abmeldeendpunkt keine automatische IdP-Umleitung mit `identity_provider` oder `idp_identifier` -Parametern. Der Parameter `redirect_uri` in einer Anfrage an den Abmeldeendpunkt ist keine Abmelde-URL, sondern eine post-sign-in URL, die Sie an den Autorisierungsendpunkt weiterleiten möchten.
Im Folgenden finden Sie eine Beispielanforderung, die einen Benutzer abmeldet, zur Anmeldeseite weiterleitet und nach der Anmeldung einen Autorisierungscode bereitstellt. `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
```
# Identitätsanbieter und Endpunkte der vertrauenden Partei
*Verbundendpunkte* sind Benutzerpool-Endpunkte, die einem der von Benutzerpools verwendeten Authentifizierungsstandards dienen. Dazu gehören SAML-ACS URLs, OIDC-Erkennungsendpunkte und Dienstendpunkte für Benutzerpools, die sowohl als Identitätsanbieter als auch als vertrauende Partei fungieren. Verbundendpunkte initiieren Authentifizierungsabläufe, erhalten Authentifizierungsnachweise von Clients und stellen Token an diese aus IdPs. Sie interagieren mit IdPs Anwendungen und Administratoren, aber nicht mit Benutzern.
Die ganzseitigen Themen nach dieser Seite enthalten Informationen zu den OAuth 2.0- und OIDC-Provider-Endpunkten, die verfügbar werden, wenn Sie Ihrem Benutzerpool eine Domain hinzufügen. Die folgende Tabelle enthält eine Liste aller Verbundendpunkte.
Beispiele für [Benutzerpool-Domänen sind:](cognito-user-pools-assign-domain.md)
1. Präfixdomäne: `mydomain.auth.us-east-1.amazoncognito.com`
1. Benutzerdefinierte Domain: `auth.example.com`
**Benutzerpool-Verbund-Endpunkte**
| Endpunkt-URL | Description | Zugriff darauf |
| --- | --- | --- |
| https://Your user pool domain/oauth2/authorize | Leitet einen Benutzer entweder zur verwalteten Anmeldung oder zur Anmeldung mit seinem IdP weiter. | Wird im Kundenbrowser aufgerufen, um mit der Benutzerauthentifizierung zu beginnen. Siehe [Autorisieren des Endpunkts](authorization-endpoint.md). |
| https://Your user pool domain/oauth2/token | Gibt Token auf der Grundlage eines Autorisierungscodes oder einer Anforderung von Kundenanmeldeinformationen zurück. | Von der App zum Abrufen von Token angefordert. Siehe [Token-Endpunkt](token-endpoint.md). |
| https://Your user pool domainOAuth2/UserInfo | Gibt Benutzerattribute basierend auf OAuth 2.0-Bereichen und Benutzeridentität in einem Zugriffstoken zurück. | Von der App zum Abrufen des Benutzerprofils angefordert. Siehe [UserInfo-Endpunkt](userinfo-endpoint.md). |
| https://Your user pool domain/oauth2/revoke | Widerruft ein Aktualisierungs-Token und die zugehörigen Zugriffs-Token. | Von der App aufgefordert, ein Token zu widerrufen. Siehe [Widerrufen des Endpunkts](revocation-endpoint.md). |
| https://cognito-idp. Region.amazonaws.com/ /.well-known/openid-configuration your user pool ID | Ein Verzeichnis der OIDC-Architektur Ihres Benutzerpools. [1](#cognito-federation-oidc-discovery-note) | Von der App angefordert, um Metadaten des Benutzerpool-Emittenten zu finden. |
| https://cognito-idp. Region.amazonaws.com/ /.well-known/jwks.json your user pool ID | Öffentliche Schlüssel, mit denen Sie Amazon Cognito Cognito-Token validieren können. [2](#cognito-federation-oidc-jwks-note) | Von der App zur Überprüfung angefordert JWTs. |
| https://Your user pool domain/oauth2/idpresponse | Social-Identitätsanbieter müssen Ihre Benutzer mit einem Autorisierungscode an diesen Endpunkt umleiten. Amazon Cognito löst den Code gegen ein Token ein, wenn es Ihren Verbundbenutzer authentifiziert. | Weitergeleitet von der OIDC-IdP-Anmeldung als IdP-Client-Callback-URL. |
| https://Your user pool domain/saml2/idpresponse | Die Assertion Consumer Response (ACS) -URL für die Integration mit SAML 2.0-Identitätsanbietern. | Umgeleitet von SAML 2.0-IdP als ACS-URL oder Ausgangspunkt für die vom IdP initiierte Anmeldung. [3](#cognito-federation-idp-init-note) |
| httpsYour user pool domain:///saml2/logout | Die [Single Logout](cognito-user-pools-saml-idp-sign-out.md#cognito-user-pools-saml-idp-sign-out.title) (SLO) -URL für die Integration mit SAML 2.0-Identitätsanbietern. | Umgeleitet von SAML 2.0 IdP als Single Logout (SLO) -URL. Akzeptiert nur POST-Bindung. |
1 Das `openid-configuration` Dokument kann jederzeit mit zusätzlichen Informationen aktualisiert werden, damit der Endpunkt dem OIDC und OAuth2 den Spezifikationen entspricht.
2 Die `jwks.json` JSON-Datei kann jederzeit mit neuen öffentlichen Token-Signaturschlüsseln aktualisiert werden.
3 Weitere Informationen zur IDP-initiierten SAML-Anmeldung finden Sie unter. [Implementieren Sie die IDP-initiierte SAML-Anmeldung](cognito-user-pools-SAML-session-initiation.md#cognito-user-pools-SAML-session-initiation-idp-initiation)
[Weitere Informationen zu OpenID Connect und den OAuth Standards finden Sie unter [OpenID Connect 1.0 und OAuth 2.0](http://openid.net/specs/openid-connect-core-1_0.html).](https://tools.ietf.org/html/rfc6749)
**Topics**
+ [Der Umleitungs- und Autorisierungsendpunkt](authorization-endpoint.md)
+ [Der Endpunkt des Token-Ausstellers](token-endpoint.md)
+ [Der Endpunkt der Benutzerattribute](userinfo-endpoint.md)
+ [Der Endpunkt für den Token-Widerruf](revocation-endpoint.md)
+ [Der IdP-SAML-Assertion-Endpunkt](saml2-idpresponse-endpoint.md)
# Der Umleitungs- und Autorisierungsendpunkt
Der `/oauth2/authorize`-Endpunkt ist ein Umleitungsendpunkt, der zwei Umleitungsziele unterstützt. Wenn Sie einen `identity_provider`- oder `idp_identifier`-Parameter in der URL angeben, werden Ihre Benutzer im Hintergrund auf die Anmeldeseite für diesen Identitätsanbieter (IDP) umgeleitet. Andernfalls erfolgt die Umleitung an [Login-Endpunkt](login-endpoint.md) mit denselben URL-Parametern, die Sie in Ihre Anfrage aufgenommen haben.
Der Autorisierungsendpunkt leitet entweder zur verwalteten Anmeldung oder zu einer IdP-Anmeldeseite weiter. Das Ziel einer Benutzersitzung an diesem Endpunkt ist eine Webseite, mit der Ihr Benutzer direkt in seinem Browser interagieren muss.
Wenn Sie den Autorisierungsendpunkt verwenden möchten, rufen Sie den Browser Ihres Benutzers unter `/oauth2/authorize` mit Parametern auf, die Ihrem Benutzerpool Informationen zu den folgenden Benutzerpool-Details liefern.
+ Der App-Client, bei dem Sie sich anmelden möchten.
+ Die Rückruf-URL, zu der Sie gelangen möchten.
+ Die OAuth 2.0-Bereiche, die Sie im Zugriffstoken Ihres Benutzers anfordern möchten.
+ Optionaler Drittanbieter-IDP, den Sie für die Anmeldung verwenden möchten.
Sie können auch `state`- und `nonce`-Parameter angeben, die Amazon Cognito verwendet, um eingehende Ansprüche zu validieren.
## GET `/oauth2/authorize`
Der `/oauth2/authorize` Endpunkt unterstützt ausschließlich `HTTPS GET`. Ihre App initiiert diese Anfrage normalerweise im Browser Ihres Benutzers. Sie können nur über HTTPS Anfragen an den `/oauth2/authorize`-Endpunkt stellen.
Weitere Informationen über die Definition des Autorisierungsendpunkts im OpenID Connect (OIDC)-Standard finden Sie unter [Authorisierungsendpunkt](http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthorizationEndpoint).
### Anforderungsparameter
**`response_type`**
Erforderlich
Die Art der Antwort. Es muss sich entweder um `code` oder `token` handeln.
Eine erfolgreiche Anfrage mit einem `response_type` von `code` gibt eine Autorisierungscode-Erteilung zurück. Eine Autorisierungscode-Erteilung ist ein `code`-Parameter, den Amazon Cognito an Ihre Umleitungs-URL anhängt. Ihre App kann den Code durch Zugriffs-, ID- und Aktualisierungstoken austauschen. Verwenden Sie als bewährte Sicherheitsmethode und zum Abrufen von Aktualisierungstoken für Ihre Benutzer eine Autorisierungscode-Erteilung in Ihrer App.
Eine erfolgreiche Anfrage mit dem `response_type` `token` gibt eine implizite Erteilung zurück. Eine implizite Erteilung besteht aus einer ID und einem Zugriffstoken, die Amazon Cognito an Ihre Umleitungs-URL anhängt. Eine implizite Erteilung ist weniger sicher, da sie Token und potenzielle identifizierende Informationen für Benutzer verfügbar macht. Sie können die Unterstützung für implizite Erteilungen in der Konfiguration Ihres App-Clients deaktivieren.
**`client_id`**
Erforderlich
Die App-Client-ID).
Der Wert `client_id` muss die ID eines App-Clients in dem Benutzerpool sein, in dem Sie die Anfrage stellen. Ihr App-Client muss die Anmeldung durch lokale Benutzer von Amazon Cognito oder mindestens eines externen IdPs unterstützen.
**`redirect_uri`**
Erforderlich
Die URL, an die der Authentifizierungsserver den Browser nach der Autorisierung des Benutzers durch Amazon Cognito weiterleitet.
Ein Umleitungs-URI (Uniform Resource Identifier) muss die folgenden Attribute aufweisen:
+ Es muss ein absoluter URI sein.
+ Sie müssen die URI im Vorfeld mit einem Client registriert haben.
+ Sie darf keine Fragmentkomponente enthalten.
Siehe [OAuth 2.0 — Endpunkt der Umleitung](https://tools.ietf.org/html/rfc6749#section-3.1.2).
Amazon Cognito erfordert, dass Ihr Umleitungs-URI HTTPS verwendet, mit Ausnahme von `http://localhost`, was Sie als Rückruf-URL für Testzwecke festlegen können.
Amazon Cognito unterstützt auch App-Callback URLs wie. `myapp://example`
**`state`**
Optional, empfohlen.
Wenn Ihre App einer Anfrage einen Parameter *state* hinzufügt, gibt Amazon Cognito seinen Wert an Ihre App zurück, wenn der Endpunkt `/oauth2/authorize` Ihren Benutzer umleitet.
Fügen Sie diesen Wert Ihren Anfragen hinzu, um sich vor [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery)-Angriffen zu schützen.
Sie können den Wert eines Parameters `state` nicht auf eine URL-codierte JSON-Zeichenfolge festlegen. Um eine Zeichenfolge, die diesem Format entspricht, in einem `state` Parameter zu übergeben, kodieren Sie die Zeichenfolge in Base64 und dekodieren Sie sie dann in Ihrer App.
**`identity_provider`**
Optional.
Fügen Sie diesen Parameter hinzu, um die verwaltete Anmeldung zu umgehen und Ihren Benutzer auf die Anmeldeseite eines Anbieters umzuleiten. Der Wert des *identity\$1provider*-Parameters ist der Name des Identitätsanbieters (IDP), wie er in Ihrem Benutzerpool angezeigt wird.
+ Für soziale Anbieter können Sie die *identity\$1provider-Werte*`Facebook`,, und `Google` verwenden. `LoginWithAmazon` `SignInWithApple`
+ Verwenden Sie für Amazon Cognito Cognito-Benutzerpools den Wert`COGNITO`.
+ Verwenden Sie für SAML 2.0- und OpenID Connect (OIDC-) Identitätsanbieter (IdPs) den Namen, den Sie dem IdP in Ihrem Benutzerpool zugewiesen haben.
**`idp_identifier`**
Optional.
Fügen Sie diesen Parameter für die Umleitung an einen Anbieter mit einem alternativen Namen für *identity\$1provider* hinzu. Sie können Identifikatoren für Ihre SAML 2.0 und OIDC IdPs im Menü **Soziale Netzwerke und externe Anbieter der Amazon Cognito** Cognito-Konsole eingeben.
**`scope`**
Optional.
Dabei kann es sich um eine Kombination aus für das System reservierten Bereichen oder benutzerdefinierten Bereichen, die einem Client zugeordnet sind, handeln. Bereiche müssen durch Leerzeichen getrennt werden. Für das System reservierte Bereiche sind `openid``email`, `phone`, `profile` und `aws.cognito.signin.user.admin`. Jeder Bereich muss dem Client zugeordnet werden, sonst wird der Client zur Laufzeit ignoriert.
Falls der Client keine Bereiche anfordert, verwendet der Authentifizierungsserver alle Bereiche im Zusammenhang mit dem Client.
Ein ID-Token wird nur zurückgegeben, wenn der `openid`-Bereich angefordert wird. Das Zugriffs-Token kann nur gegen Amazon-Cognito-Benutzerpools verwendet werden, wenn der Bereich `aws.cognito.signin.user.admin` angefordert wird. Die Bereiche `phone`, `email` und `profile` können nur angefordert werden, wenn der Bereich `openid` ebenfalls angefordert wird. Diese Bereiche bestimmen die Anträge, die im ID-Token eingesetzt werden.
**`code_challenge_method`**
Optional.
Das Hashing-Protokoll, das Sie zur Generierung der Herausforderung verwendet haben. Die [PKCE RFC](https://tools.ietf.org/html/rfc7636) definiert zwei Methoden, die S256-Methode und eine einfache. Der Amazon-Cognito-Authentifikationsserver unterstützt jedoch nur die S256-Methode.
**`code_challenge`**
Optional.
Die PKCE-Abfrage (Proof of Key Code Exchange), die Sie anhand der generiert haben. `code_verifier` Weitere Informationen finden Sie unter [Verwendung von PKCE in Autorisierungscode-Zuschüssen](using-pkce-in-authorization-code.md).
Nur erforderlich, wenn Sie einen `code_challenge_method`-Parameter angeben.
**`nonce`**
Optional.
Ein Zufallswert, den Sie der Anforderung hinzufügen können. Der von Ihnen bereitgestellte Nonce-Wert ist im ID-Token enthalten, das Amazon Cognito ausgibt. Zum Schutz vor Replay-Angriffen kann Ihre App den `nonce`-Anspruch im ID-Token untersuchen und mit dem vergleichen, den Sie generiert haben. Weitere Informationen zum `nonce`-Anspruch finden Sie unter [ID-Token-Validierung](https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation) im *OpenID Connect-Standard*.
**`lang`**
Optional.
Die Sprache, in der Sie benutzerinteraktive Seiten anzeigen möchten. Verwaltete Anmeldeseiten können lokalisiert werden, gehostete UI-Seiten (klassische Seiten) jedoch nicht. Weitere Informationen finden Sie unter [Lokalisierung bei verwalteter Anmeldung](cognito-user-pools-managed-login.md#managed-login-localization).
**`login_hint`**
Optional.
Eine Aufforderung zur Eingabe eines Benutzernamens, die Sie an den Autorisierungsserver weiterleiten möchten. Sie können einen Benutzernamen, eine E-Mail-Adresse oder eine Telefonnummer von Ihrem Benutzer erfassen und dem Zielanbieter erlauben, den Anmeldenamen des Benutzers vorab auszufüllen. Wenn Sie einen `login_hint` Parameter und keine `idp_identifier` oder `identity_provider` Parameter an den `oauth2/authorize` Endpunkt senden, füllt Managed Login das Feld für den Benutzernamen mit Ihrem Hinweiswert aus. Sie können diesen Parameter auch an den übergeben [Login-Endpunkt](login-endpoint.md) und den Wert für den Benutzernamen automatisch ausfüllen.
Wenn Ihre Autorisierungsanfrage eine Weiterleitung zu OIDC aufruft IdPs, fügt Amazon Cognito der Anfrage an diesen Drittanbieter-Autorisierer einen `login_hint` Parameter hinzu. Sie können Anmeldehinweise nicht an SAML, Apple, Login With Amazon, Google oder Facebook (Meta) IdPs weiterleiten.
**`prompt`**
Optional.
Ein OIDC-Parameter, der das Authentifizierungsverhalten für bestehende Sitzungen steuert. Nur in der Branding-Version für verwaltete Anmeldung verfügbar, nicht in der klassischen gehosteten Benutzeroberfläche. Weitere Informationen aus der OIDC-Spezifikation finden Sie unter [Authentifizierungsanfrage](https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest). Die Werte `none` und `login` wirken sich auf das Authentifizierungsverhalten des Benutzerpools aus.
Amazon Cognito leitet alle Werte von weiter`none`, `prompt` außer an Ihre, IdPs wenn Benutzer die Authentifizierung bei Drittanbietern auswählen. Dies ist der Fall, wenn die URL, auf die Benutzer zugreifen, einen `identity_provider` `idp_identifier` OR-Parameter enthält oder wenn der Autorisierungsserver sie an den weiterleitet [Login-Endpunkt](login-endpoint.md) und sie einen IdP aus den verfügbaren Schaltflächen auswählen.
**Parameterwerte abfragen**
`prompt=none`
Amazon Cognito setzt die Authentifizierung für Benutzer, die über eine gültige authentifizierte Sitzung verfügen, im Hintergrund fort. Mit dieser Aufforderung können sich Benutzer unbeaufsichtigt zwischen verschiedenen App-Clients in Ihrem Benutzerpool authentifizieren. Wenn der Benutzer noch nicht authentifiziert ist, gibt der Autorisierungsserver einen Fehler zurück. `login_required`
`prompt=login`
Amazon Cognito verlangt von Benutzern, sich erneut zu authentifizieren, auch wenn sie eine bestehende Sitzung haben. Senden Sie diesen Wert, wenn Sie die Identität des Benutzers erneut überprüfen möchten. Authentifizierte Benutzer, die über eine bestehende Sitzung verfügen, können zur Anmeldung zurückkehren, ohne dass diese Sitzung ungültig wird. Wenn sich ein Benutzer, der eine bestehende Sitzung hat, erneut anmeldet, weist Amazon Cognito ihm ein neues Sitzungscookie zu. Dieser Parameter kann auch an Ihren weitergeleitet werden. IdPs IdPsdie diesen Parameter akzeptieren, fordern auch einen neuen Authentifizierungsversuch vom Benutzer an.
`prompt=select_account`
Dieser Wert hat keine Auswirkung auf die lokale Anmeldung und muss in Anfragen eingereicht werden, die zu IdPs umleiten. Wenn dieser Parameter in Ihrer Autorisierungsanfrage enthalten ist, wird er `prompt=select_account` zum URL-Pfad für das IdP-Umleitungsziel hinzugefügt. Wenn dieser Parameter IdPs unterstützt wird, fordern sie die Benutzer auf, das Konto auszuwählen, mit dem sie sich anmelden möchten.
`prompt=consent`
Dieser Wert hat keine Auswirkung auf die lokale Anmeldung und muss in Anfragen eingereicht werden, die zu IdPs umleiten. Wenn dieser Parameter in Ihrer Autorisierungsanfrage enthalten ist, wird er `prompt=consent` zum URL-Pfad für das IdP-Umleitungsziel hinzugefügt. Wenn dieser Parameter IdPs unterstützt wird, fordern sie die Zustimmung des Benutzers an, bevor sie zurück zu Ihrem Benutzerpool weiterleiten.
Wenn Sie den `prompt` Parameter in Ihrer Anfrage weglassen, folgt die verwaltete Anmeldung dem Standardverhalten: Benutzer müssen sich anmelden, es sei denn, ihr Browser hat ein gültiges Sitzungscookie für die verwaltete Anmeldung. Sie können beispielsweise mehrere Werte für `prompt` mit einem Leerzeichen als Trennzeichen kombinieren. `prompt=login consent`
**`resource`**
Optional.
Der Bezeichner einer Ressource, die Sie an das Zugriffstoken im Anspruch binden möchten. `aud` Wenn Sie diesen Parameter angeben, überprüft Amazon Cognito, ob es sich bei dem Wert um eine URL handelt, und legt die Zielgruppe des resultierenden Zugriffstokens auf die angeforderte Ressource fest. Sie können einen [Benutzerpool-Ressourcenserver](cognito-user-pools-define-resource-servers.md) mit einer Kennung in einem URL-Format oder einer URL Ihrer Wahl anfordern. Die Werte für diesen Parameter müssen mit `https://``http://localhost`, oder einem benutzerdefinierten URL-Schema wie beginnen`myapp://`.
Die Ressourcenbindung ist in [RFC 8707](https://www.rfc-editor.org/rfc/rfc8707.html) definiert. [Weitere Informationen zu Ressourcenservern und Ressourcenbindung finden Sie unter Ressourcenbindung.](cognito-user-pools-define-resource-servers.md#cognito-user-pools-resource-binding)
## Beispiel: Erteilung eines Autorisierungscodes
Dies ist ein Beispiel für eine Anfrage zur Erteilung eines Autorisierungscodes.
Die folgende Anfrage initiiert eine Sitzung zum Abrufen eines Autorisierungscodes, den Ihr Benutzer an Ihre App am `redirect_uri` Ziel weitergibt. In dieser Sitzung werden Bereiche für Benutzerattribute und für den Zugriff auf Amazon Cognito-Self-Service-API-Operationen angefordert.
```
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
```
Der Amazon-Cognito-Authentifikationsserver leitet Autorisierungs-Code und -Status zurück an Ihre App. Der Autorisierungscode ist fünf Minuten gültig.
```
HTTP/1.1 302 Found
Location: https://www.example.com?code=a1b2c3d4-5678-90ab-cdef-EXAMPLE11111&state=abcdefg
```
## Beispiel: Erteilung eines Autorisierungscodes mit PKCE
In diesem Beispielablauf wird eine Autorisierungscode-Erteilung mit [PKCE](using-pkce-in-authorization-code.md#using-pkce-in-authorization-code.title) durchgeführt.
Diese Anfrage fügt einen `code_challenge` Parameter hinzu. Um den Austausch eines Codes gegen ein Token abzuschließen, müssen Sie den `code_verifier` Parameter in Ihre Anfrage an den `/oauth2/token` Endpunkt aufnehmen.
```
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...
```
Der Autorisierungsserver leitet mit dem Autorisierungscode und dem Status zurück zu Ihrer Anwendung. Ihre Anwendung verarbeitet den Autorisierungscode und tauscht ihn gegen Token ein.
```
HTTP/1.1 302 Found
Location: https://www.example.com?code=a1b2c3d4-5678-90ab-cdef-EXAMPLE11111&state=abcdefg
```
## Beispiel: erfordert eine erneute Authentifizierung mit `prompt=login`
Die folgende Anfrage fügt einen `prompt=login` Parameter hinzu, nach dem sich der Benutzer erneut authentifizieren muss, auch wenn er bereits eine Sitzung hat.
```
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
```
Der Autorisierungsserver leitet zum [Anmeldeendpunkt](login-endpoint.md) weiter und erfordert eine erneute Authentifizierung.
```
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
```
## Beispiel: unbeaufsichtigte Authentifizierung mit `prompt=none`
Die folgende Anfrage fügt einen `prompt=none` Parameter hinzu, der im Hintergrund überprüft, ob der Benutzer eine gültige Sitzung hat.
```
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
```
Wenn keine gültige Sitzung vorhanden ist, gibt der Autorisierungsserver einen Fehler an die Umleitungs-URI zurück
```
HTTP/1.1 302 Found Location: https://www.example.com?error=login_required&state=abcdefg
```
Wenn eine gültige Sitzung besteht, gibt der Autorisierungsserver einen Autorisierungscode zurück.
```
HTTP/1.1 302 Found Location: https://www.example.com?code=AUTHORIZATION_CODE&state=abcdefg
```
## Beispiel: Erteilung eines Autorisierungscodes mit Ressourcenbindung
Die folgende Anfrage fügt einen `resource` Parameter hinzu, um das Zugriffstoken an einen bestimmten Ressourcenserver zu binden. Das resultierende Zugriffstoken schafft die Voraussetzungen dafür, dass die Ziel-API überprüft, ob es sich um die Zielgruppe der Anfrage des authentifizierten Benutzers handelt.
```
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
```
Der Autorisierungsserver gibt einen Autorisierungscode zurück, der zu einem Zugriffstoken mit dem `aud` Anspruch von `https://solar-system-data-api.example.com` führt.
```
HTTP/1.1 302 Found Location: https://www.example.com?code=AUTHORIZATION_CODE&state=abcdefg
```
## Beispiel: Token-Erteilung (implizit) ohne Geltungsbereich `openid`
Dieser Beispielablauf generiert eine implizite Gewährung und kehrt JWTs direkt zur Sitzung des Benutzers zurück.
Die Anfrage bezieht sich auf eine implizite Erteilung von Ihrem Autorisierungsserver. Sie fordert Bereiche im Zugriffstoken an, die Self-Service-Vorgänge für Benutzerprofile autorisieren.
```
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
```
Der Autorisierungsserver leitet nur mit einem Zugriffstoken zurück zu Ihrer Anwendung. Da der `openid`-Bereich nicht angefordert wurde, gibt Amazon Cognito kein ID-Token aus. Außerdem gibt Amazon Cognito in diesem Flow kein Aktualisierungs-Token aus.
```
HTTP/1.1 302 Found
Location: https://example.com/callback#access_token=eyJra456defEXAMPLE&token_type=bearer&expires_in=3600&state=STATE
```
## Beispiel: Token-Erteilung (implizit) mit Gültigkeitsbereich `openid`
Dieser Beispielablauf generiert eine implizite Gewährung und gibt Token an den Browser des Benutzers zurück.
Die Anfrage bezieht sich auf eine implizite Erteilung durch Ihren Autorisierungsserver. Sie fordert Bereiche im Zugriffstoken an, die den Zugriff auf Benutzerattribute und Self-Service-Operationen autorisieren.
```
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
```
Der Autorisierungsserver leitet mit dem Zugriffstoken und dem ID-Token zurück zu Ihrer Anwendung (da der `openid` Bereich enthalten war):
```
HTTP/1.1 302 Found
Location: https://www.example.com#id_token=eyJra67890EXAMPLE&access_token=eyJra12345EXAMPLE&token_type=bearer&expires_in=3600&state=abcdefg
```
## Beispiele für negative Antworten
Amazon Cognito lehnt Ihre Anfrage möglicherweise ab. Negative Anfragen enthalten einen HTTP-Fehlercode und eine Beschreibung, anhand derer Sie Ihre Anforderungsparameter korrigieren können. Im Folgenden finden Sie Beispiele für negative Antworten.
+ Wenn `client_id` und gültig `redirect_uri` sind, die Anforderungsparameter jedoch nicht korrekt formatiert sind, leitet der Authentifizierungsserver den Fehler an den des Clients weiter `redirect_uri` und fügt eine Fehlermeldung an einen URL-Parameter an. Im Folgenden finden Sie Beispiele für eine falsche Formatierung.
+ Die Anfrage enthält keinen `response_type` Parameter.
+ Die Autorisierungsanfrage lieferte einen `code_challenge` Parameter, aber keinen `code_challenge_method` Parameter.
+ Der Wert des `code_challenge_method` Parameters ist nicht`S256`.
Im Folgenden finden Sie die Antwort auf eine Beispielanfrage mit falscher Formatierung.
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request
```
+ Wenn der Client eine Anfrage `code` oder `token` eingibt`response_type`, aber keine Genehmigung für diese Anfragen hat, kehrt der Amazon Cognito Cognito-Autorisierungsserver wie folgt `unauthorized_client` zum Client-Autorisierungsserver zurück: `redirect_uri`
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=unauthorized_client
```
+ Falls die Anforderung des Clients unbekannt, falsch formatiert oder ungültig ist, sollte der Amazon-Cognito-Autorisierungsserver `invalid_scope` folgendermaßen zur `redirect_uri` des Clients zurückgeben:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_scope
```
+ Wenn auf dem Server ein unerwarteter Fehler auftritt, kehrt der Authentifizierungsserver `server_error` zum Server des `redirect_uri` Clients zurück. Da der HTTP 500-Fehler nicht an den Client gesendet wird, wird der Fehler nicht im Browser des Benutzers angezeigt. Der Autorisierungsserver gibt den folgenden Fehler zurück.
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=server_error
```
+ Wenn Amazon Cognito sich über einen Verbund mit einem Drittanbieter authentifiziert IdPs, kann es bei Amazon Cognito zu Verbindungsproblemen kommen, wie z. B. die folgenden:
+ Wenn es bei der Token-Anforderung vom IdP zu einem Verbindungs-Timeout kommt, leitet der Authentifizierungsserver den Fehler wie folgt an den `redirect_uri` des Clients weiter:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Timeout+occurred+in+calling+IdP+token+endpoint
```
+ Wenn beim Aufrufen des `jwks_uri` Endpunkts zur Überprüfung des ID-Tokens ein Verbindungs-Timeout auftritt, leitet der Authentifizierungsserver mit einem Fehler wie folgt an den des Clients weiter: `redirect_uri`
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=error_description=Timeout+in+calling+jwks+uri
```
+ Bei der Authentifizierung über einen Verbund mit einem Drittanbieter IdPs geben die Anbieter möglicherweise Fehlerantworten zurück. Dies kann auf Konfigurationsfehler oder andere Gründe zurückzuführen sein, z. B. auf die folgenden:
+ Wenn eine Fehlermeldung von anderen Anbietern empfangen wird, leitet der Authentifizierungsserver den Fehler wie folgt an den `redirect_uri` des Clients weiter:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=[IdP name]+Error+-+[status code]+error getting token
```
+ Wenn eine Fehlerantwort von Google empfangen wird, leitet der Authentifizierungsserver den Fehler wie folgt an den `redirect_uri` des Clients weiter:
```
HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Google+Error+-+[status code]+[Google-provided error code]
```
+ Wenn Amazon Cognito bei der Verbindung zu einem externen IdP auf eine Kommunikationsausnahme stößt, leitet der Authentifizierungsserver mit einer der folgenden Meldungen `redirect_uri` mit einem Fehler an den des Kunden weiter:
+
```
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
```
# Der Endpunkt des Token-Ausstellers
Der OAuth [2.0-Token-Endpunkt unter `/oauth2/token` gibt JSON-Webtoken](https://www.rfc-editor.org/rfc/rfc6749#section-3.2) (JWTs) an Anwendungen aus, die die Gewährung von Autorisierungscode und Kundenanmeldedaten abschließen möchten. Diese Token sind das Endergebnis der Authentifizierung mit einem Benutzerpool. Sie enthalten Informationen über den Benutzer (ID-Token), die Zugriffsebene des Benutzers (Zugriffstoken) und die Berechtigung des Benutzers, seine angemeldete Sitzung beizubehalten (Aktualisierungstoken). Rely-Party-Bibliotheken von OpenID Connect (OIDC) verarbeiten Anfragen an und Antwortnutzlasten von diesem Endpunkt aus. Tokens bieten einen überprüfbaren Authentifizierungsnachweis, Profilinformationen und einen Mechanismus für den Zugriff auf Backend-Systeme.
Ihr Benutzerpool OAuth 2.0-Autorisierungsserver gibt JSON-Webtoken (JWTs) vom Token-Endpunkt für die folgenden Sitzungstypen aus:
1. Benutzer, die eine Anfrage für die Gewährung eines Autorisierungscodes abgeschlossen haben. Wenn ein Code erfolgreich eingelöst wurde, werden ID-, Zugriffs- und Aktualisierungstoken zurückgegeben.
1. Machine-to-machine (M2M) -Sitzungen, für die eine Erteilung von Kundenanmeldedaten abgeschlossen wurde. Bei erfolgreicher Autorisierung mit dem geheimen Client-Schlüssel wird ein Zugriffstoken zurückgegeben.
1. Benutzer, die sich zuvor angemeldet und Aktualisierungstoken erhalten haben. Bei der Aktualisierungstoken-Authentifizierung werden neue ID- und Zugriffstoken zurückgegeben.
**Anmerkung**
Benutzer, die sich mit einem Autorisierungscode anmelden, der bei der verwalteten Anmeldung oder über den Verbund gewährt wurde, können ihre Token jederzeit vom Token-Endpunkt aus aktualisieren. Benutzer, die sich mit den API-Vorgängen anmelden `InitiateAuth` und ihre Token mit dem Token-Endpunkt aktualisieren `AdminInitiateAuth` können, [wenn die gespeicherten Geräte](amazon-cognito-user-pools-device-tracking.md) in Ihrem Benutzerpool *nicht* aktiv sind. Wenn die gespeicherten Geräte aktiv sind, aktualisieren Sie die Token mit dem [entsprechenden API- oder SDK-Token-Aktualisierungsvorgang](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-api) für Ihren App-Client.
Der Token-Endpunkt wird öffentlich verfügbar, wenn Sie Ihrem Benutzerpool eine Domain hinzufügen. Er akzeptiert HTTP-POST-Anfragen. Verwenden Sie aus Gründen der Anwendungssicherheit PKCE mit Ihren Autorisierungscode-Anmeldeereignissen. PKCE überprüft, ob der Benutzer, der einen Autorisierungscode übergibt, derselbe Benutzer ist, der sich authentifiziert hat. Weitere Informationen zu PKCE finden Sie unter [IETF](https://datatracker.ietf.org/doc/html/rfc7636) RFC 7636.
Weitere Informationen zu den App-Clients im Benutzerpool und ihren Grant-Typen, Client-Geheimnissen, zulässigen Bereichen und Clients finden Sie unter. IDs [Anwendungsspezifische Einstellungen mit App-Clients](user-pool-settings-client-apps.md) Weitere Informationen zur M2M-Autorisierung, zur Erteilung von Kundenanmeldedaten und zur Autorisierung mit Zugriffstoken finden Sie unter. [Bereiche, M2M und Ressourcenserver](cognito-user-pools-define-resource-servers.md)
Um Informationen über einen Benutzer aus seinem Zugriffstoken abzurufen, geben Sie diese an Ihre Anfrage [UserInfo-Endpunkt](userinfo-endpoint.md) oder an eine [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)API-Anfrage weiter. Das Zugriffstoken muss die entsprechenden Bereiche für diese Anfragen enthalten,
## Formatieren Sie eine POST-Anforderung für den Token-Endpunkt
Der `/oauth2/token` Endpunkt unterstützt ausschließlich `HTTPS POST`. Dieser Endpunkt ist nicht benutzerinteraktiv. Behandeln Sie Token-Anfragen mit einer [OpenID Connect (OIDC) -Bibliothek in Ihrer Anwendung](https://openid.net/developers/certified-openid-connect-implementations/).
Der Token-Endpunkt unterstützt `client_secret_basic`- und `client_secret_post`-Authentifizierung. [Weitere Informationen zur OIDC-Spezifikation finden Sie unter Client-Authentifizierung.](https://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication) Weitere Informationen zum Token-Endpunkt aus der OpenID-Connect-Spezifikation finden Sie unter [Token-Endpunkt](http://openid.net/specs/openid-connect-core-1_0.html#TokenEndpoint).
### Anfrageparameter im Header
Sie können die folgenden Parameter im Header Ihrer Anfrage an den Token-Endpunkt übergeben.
**`Authorization`**
Falls dem Client ein Geheim-Schlüssel zugestellt wurde, kann der Client seine `client_id` und sein `client_secret` im Autorisierungs-Header als `client_secret_basic` HTTP-Autorisierung übergeben. Sie können auch die `client_id` und das `client_secret` im Anforderungstext als `client_secret_post`-Autorisierung aufnehmen.
Die Autorisierungs-Header-Stringl autet [Basic](https://en.wikipedia.org/wiki/Basic_access_authentication#Client_side) `Base64Encode(client_id:client_secret)`. Das folgende Beispiel ist ein Autorisierungsheader für den App-Client `djc98u3jiedmi283eu928` mit dem geheimen Clientschlüssel`abcdef01234567890`, der die Base64-kodierte Version der Zeichenfolge verwendet: `djc98u3jiedmi283eu928:abcdef01234567890`
```
Authorization: Basic ZGpjOTh1M2ppZWRtaTI4M2V1OTI4OmFiY2RlZjAxMjM0NTY3ODkw
```
**`Content-Type`**
Stellen Sie den Wert dieses Parameters auf `'application/x-www-form-urlencoded'` ein.
### Anfrageparameter im Fließtext
Die folgenden Parameter können Sie im `x-www-form-urlencoded` Format im Anforderungstext für den Token-Endpunkt anfordern.
**`grant_type`**
*Pflichtfeld*
Die Art des OIDC-Zuschusses, den Sie beantragen möchten.
Es muss sich entweder um `authorization_code` oder `refresh_token` oder `client_credentials` handeln. Unter den folgenden Bedingungen können Sie vom Token-Endpunkt aus ein Zugriffstoken für einen benutzerdefinierten Bereich anfordern:
+ Sie haben den angeforderten Bereich in Ihrer App-Client-Konfiguration aktiviert.
+ Sie haben Ihren App-Client mit einem geheimen Clientschlüssel konfiguriert.
+ Sie aktivieren die Gewährung von Kundenanmeldedaten in Ihrem App-Client.
Der Token-Endpunkt gibt nur dann ein Aktualisierungstoken zurück, wenn dies der `grant_type` Fall ist`authorization_code`.
**`client_id`**
*Optional. Nicht erforderlich, wenn Sie die App-Client-ID im `Authorization` Header angeben.*
Die ID eines App-Clients in Ihrem Benutzerpool. Geben Sie denselben App-Client an, der Ihren Benutzer authentifiziert hat.
Sie müssen diesen Parameter angeben, wenn der Client öffentlich ist und kein Geheimnis hat, oder wenn er `client_secret_post` autorisiert ist. `client_secret`
**`client_secret`**
*Optional. Nicht erforderlich, wenn Sie das geheime Client-Geheimnis im `Authorization` Header angeben und wenn der App-Client kein Geheimnis hat.*
Das geheime Geheimnis des App-Clients, falls der App-Client über eines verfügt, für die `client_secret_post` Autorisierung.
**`scope`**
*Optional*.
Kann eine Kombination aller Bereiche sein, die Ihrem App-Client zugeordnet sind. Amazon Cognito ignoriert Bereiche in der Anfrage, die für den angeforderten App-Client nicht zulässig sind. Wenn Sie diesen Anforderungsparameter nicht angeben, gibt der Autorisierungsserver einen `scope` Zugriffstoken-Anspruch mit allen Autorisierungsbereichen zurück, die Sie in Ihrer App-Client-Konfiguration aktiviert haben. Sie können alle Bereiche anfordern, die für den angeforderten App-Client zulässig sind: Standardbereiche, benutzerdefinierte Bereiche von Ressourcenservern und der `aws.cognito.signin.user.admin` Self-Service-Bereich für Benutzer.
**`redirect_uri`**
*Optional. Für die Gewährung von Kundenanmeldedaten nicht erforderlich.*
Es muss sich um dieselbe `redirect_uri` handeln, die verwendet wurde, um `authorization_code` in `/oauth2/authorize` zu bekommen.
Falls `grant_type` ja, müssen Sie diesen Parameter angeben. `authorization_code`
**`refresh_token`**
*Optional. Wird nur verwendet, wenn der Benutzer bereits über ein Aktualisierungstoken verfügt und neue ID- und Zugriffstoken erhalten möchte.*
Um neue Zugriffs- und ID-Tokens für die Sitzung eines Benutzers `refresh_token` zu generieren, setzen Sie den Wert auf ein gültiges Aktualisierungstoken, das der angeforderte App-Client ausgegeben hat.
Gibt ein neues Aktualisierungstoken mit neuer ID und Zugriffstoken zurück, wenn die [Aktualisierungstoken-Rotation](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-rotation) aktiv ist. Andernfalls werden nur ID- und Zugriffstoken zurückgegeben. Wenn das ursprüngliche Zugriffstoken [an eine API-Ressource gebunden](cognito-user-pools-define-resource-servers.md#cognito-user-pools-resource-binding) war, behält das neue Zugriffstoken die angeforderte API-URL im `aud` Anspruch bei.
**`code`**
*Optional. Nur bei Erteilung von Autorisierungscodes erforderlich.*
Der Autorisierungscode aus einer Autorisierungscode-Erteilung. Sie müssen diesen Parameter angeben, wenn Ihre Autorisierungsanfrage ein `grant_type` of enthielt`authorization_code`.
**`aws_client_metadata`**
*Optional*.
Informationen, die Sie an die [Lambda-Auslöser für die Vorab-Generierung von Token](user-pool-lambda-pre-token-generation.md) internen [machine-to-machine (M2M)](cognito-user-pools-define-resource-servers.md) -Autorisierungsabläufe weitergeben möchten. Ihre Anwendung kann Kontextinformationen über die Sitzung sammeln und sie in diesem Parameter übergeben. Wenn Sie das URL-kodierte JSON-Format übergeben`aws_client_metadata`, nimmt Amazon Cognito es in das Eingabeereignis für Ihre Trigger-Lambda-Funktion auf. Ihre Pre-Token-Trigger-Event-Version oder globale Lambda-Trigger-Version muss für Version drei oder höher konfiguriert sein. Amazon Cognito akzeptiert zwar Anfragen an diesen Endpunkt in M2M-Datenströmen für Autorisierungscode und Kundenanmeldedaten, Ihr Benutzerpool wird jedoch nur von Anfragen mit Kundenanmeldedaten `aws_client_metadata` an den Trigger vor der Token-Generierung weitergeleitet.
**`code_verifier`**
Optional. Nur erforderlich, wenn Sie in Ihrer ersten Autorisierungsanfrage `code_challenge` Parameter angegeben `code_challenge_method` haben.
Der generierte Codeverifizierer, anhand dessen Ihre Anwendung in einer Anfrage zur `code_challenge` Erteilung eines Autorisierungscodes bei [PKCE](using-pkce-in-authorization-code.md) den Wert berechnet hat.
## Austausch eines Autorisierungscodes für Token
Mit der folgenden Anfrage werden nach der Authentifizierung mit einem Autorisierungscode erfolgreich ID-, Zugriffs- und Aktualisierungstoken generiert. Die Anfrage übergibt das Client-Geheimnis im `client_secret_basic` Format im Header. `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
```
Die Antwort gibt dem Benutzer neue ID-, Zugriffs- und Aktualisierungstoken mit zusätzlichen Metadaten aus.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"refresh_token": "eyJj3example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Kundenanmeldedaten mit Basisautorisierung
Die folgende Anfrage einer M2M-Anwendung fordert die Gewährung von Kundenanmeldedaten an. Da für Client-Anmeldeinformationen ein Client-Geheimnis erforderlich ist, wird die Anfrage mit einem `Authorization` Header autorisiert, der aus der App-Client-ID und dem geheimen Schlüssel abgeleitet wird. Die Anfrage führt zu einem Zugriffstoken mit den beiden angeforderten Bereichen. Die Anfrage enthält auch Client-Metadaten, die IP-Adressinformationen und ein Token enthalten, das an den Benutzer ausgegeben wird, für den die Gewährung erfolgt. Amazon Cognito leitet die Client-Metadaten an den Lambda-Trigger vor der Token-Generierung weiter.
```
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 leitet das folgende Eingabeereignis an den Lambda-Trigger vor der Token-Generierung weiter.
```
{
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 }
}
```
Die Antwort gibt ein Zugriffstoken zurück. Die Erteilung von Kundenanmeldedaten dient der machine-to-machine (M2M-) Autorisierung und gibt nur Zugriffstoken zurück.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Kundenanmeldedaten mit POST-Body-Autorisierung
Die folgende Anfrage zur Gewährung von Kundenanmeldedaten enthält den `client_secret` Parameter im Hauptteil der Anfrage und keinen Header. `Authorization` Diese Anfrage verwendet die `client_secret_post` Autorisierungssyntax. Die Anfrage führt zu einem Zugriffstoken mit dem angeforderten Bereich. Die Anfrage enthält auch Client-Metadaten, die IP-Adressinformationen und ein Token enthalten, das an den Benutzer ausgegeben wird, für den diese Genehmigung erteilt wurde. Amazon Cognito leitet die Client-Metadaten an den Lambda-Trigger vor der Token-Generierung weiter.
```
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 leitet das folgende Eingabeereignis an den Lambda-Trigger vor der Token-Generierung weiter.
```
{
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 }
}
```
Die Antwort gibt ein Zugriffstoken zurück. Die Erteilung von Kundenanmeldedaten dient der machine-to-machine (M2M-) Autorisierung und gibt nur Zugriffstoken zurück.
```
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"
}
```
## Erteilung des Autorisierungscodes mit PKCE
Die folgende Beispielanforderung vervollständigt eine Autorisierungsanfrage, die `code_challenge` Parameter `code_challenge_method` und Parameter in einer Autorisierungscode-Erteilungsanfrage mit [PKCE](using-pkce-in-authorization-code.md) beinhaltet.
```
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
```
In der Antwort werden ID-, Zugriffs- und Aktualisierungstoken aus der erfolgreichen PKCE-Überprüfung durch die Anwendung zurückgegeben.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"refresh_token": "eyJj3example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Token-Aktualisierung ohne Token-Rotation
Die folgende Beispielanforderung stellt ein Aktualisierungstoken für einen App-Client bereit, bei dem die [Rotation des Aktualisierungstokens](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-rotation) inaktiv ist. Da der App-Client über ein geheimes Client-Geheimnis verfügt, stellt die Anfrage einen `Authorization` Header bereit.
```
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
```
Die Antwort gibt neue IDs und Zugriffstoken zurück.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Token-Aktualisierung mit Rotation des Aktualisierungstokens
Die folgende Beispielanforderung stellt ein Aktualisierungstoken für einen App-Client bereit, für den die [Rotation des Aktualisierungstokens](amazon-cognito-user-pools-using-the-refresh-token.md#using-the-refresh-token-rotation) aktiv ist. Da der App-Client über ein geheimes Client-Geheimnis verfügt, stellt die Anfrage einen `Authorization` Header bereit.
```
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
```
Die Antwort gibt neue ID-, Zugriffs- und Aktualisierungstoken zurück.
```
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "eyJra1example",
"id_token": "eyJra2example",
"refresh_token": "eyJj4example",
"token_type": "Bearer",
"expires_in": 3600
}
```
## Beispiele für negative Antworten
Fehlerhafte Anfragen erzeugen Fehler vom Token-Endpunkt aus. Im Folgenden finden Sie eine allgemeine Übersicht über den Antworttext, wenn Token-Anfragen einen Fehler generieren.
```
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`**
Der Anforderung fehlt ein erforderlicher Parameter, sie umfasst einen nicht unterstützten Parameter-Wert (außer `unsupported_grant_type`) oder sie ist aus anderen Gründen ungültig. Beispielsweise, `grant_type` ist `refresh_token` aber `refresh_token` ist nicht enthalten.
**`invalid_client`**
Client-Authentifizierung ist fehlgeschlagen. Wenn der Client zum Beispiel `client_id` und `client_secret` im Autorisierungs-Header enthält, aber kein Client mit dieser `client_id` und diesem `client_secret`existiert.
**`invalid_grant`**
Das Refresh-Token wurde widerrufen.
Der Autorisierungs-Code wurde bereits verwendet oder ist nicht vorhanden.
Der App-Client hat keinen Lesezugriff auf alle [Attribute](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-attributes.html) im angeforderten Bereich. Zum Beispiel fordert Ihre App den `email`-Bereich an und Ihr App-Client kann das Attribut `email`, aber nicht `email_verified` lesen.
**`unauthorized_client`**
Dem Client ist es nicht gestattet, einen Code zu gewähren oder Token zu aktualisieren.
**`unsupported_grant_type`**
Wird zurückgegeben, wenn `grant_type` ein anderer Wert ist als `authorization_code` oder `refresh_token` oder `client_credentials`.
# Der Endpunkt der Benutzerattribute
Wo OIDC ID-Token ausgibt, die Benutzerattribute enthalten, implementiert OAuth 2.0 den `/oauth2/userInfo` Endpunkt. Ein authentifizierter Benutzer oder Client erhält ein Zugriffstoken mit einem Anspruch. `scopes` Dieser Anspruch bestimmt die Attribute, die der Autorisierungsserver zurückgeben soll. Wenn eine Anwendung dem `userInfo` Endpunkt ein Zugriffstoken vorlegt, gibt der Autorisierungsserver einen Antworttext zurück, der die Benutzerattribute enthält, die innerhalb der durch die Gültigkeitsbereiche der Zugriffstoken festgelegten Grenzen liegen. Ihre Anwendung kann Informationen über einen Benutzer vom `userInfo` Endpunkt abrufen, sofern sie über ein gültiges Zugriffstoken mit mindestens einem `openid` Geltungsbereichsanspruch verfügt.
Der Endpunkt `userInfo` ist ein OIDC-[UserInfo-Endpunkt](https://openid.net/specs/openid-connect-core-1_0.html#UserInfo) (OpenID-Connect). Sie reagiert mit Benutzerattributen, wenn Dienstanbieter Zugriffstoken vorlegen, die Ihr [Token-Endpunkt](token-endpoint.md) ausgegeben hat. Die Bereiche im Zugriffstoken Ihres Benutzers definieren die Benutzerattribute, die der UserInfo-Endpunkt in seiner Antwort zurückgibt. Der `openid`-Gültigkeitsbereich muss einer der Zugriffstokenansprüche sein.
Amazon Cognito gibt Zugriffs-Token als Antwort auf Benutzerpool-API-Anfragen wie [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) aus. Da sie keine Bereiche enthalten, akzeptiert der userInfo-Endpunkt diese Zugriffstoken nicht. Stattdessen müssen Sie Zugriffstoken von Ihrem Token-Endpunkt vorlegen.
Ihr OAuth 2.0-Dritt-Identity-Provider (IdP) hostet auch einen userInfo Endpunkt. Wenn sich Ihr Benutzer bei diesem IdP authentifiziert, tauscht Amazon Cognito im Hintergrund einen Autorisierungscode mit dem IdP-Endpunkt aus. `token` Ihr Benutzerpool übergibt das IdP-Zugriffstoken, um den Abruf von Benutzerinformationen vom IdP-Endpunkt zu autorisieren. `userInfo`
Die Bereiche im Zugriffstoken eines Benutzers werden durch den `scopes` Anforderungsparameter in Authentifizierungsanforderungen oder durch die Bereiche bestimmt, die der [Lambda-Trigger vor der Token-Generierung hinzufügt](user-pool-lambda-pre-token-generation.md). Sie können Zugriffstoken dekodieren und `scope` Ansprüche untersuchen, um herauszufinden, welche Bereiche der Zugriffskontrolle sie enthalten. Im Folgenden sind einige Bereichskombinationen aufgeführt, die sich auf die vom Endpunkt zurückgegebenen Daten auswirken. `userInfo` Der reservierte Amazon Cognito Cognito-Bereich `aws.cognito.signin.user.admin` hat keine Auswirkung auf die von diesem Endpunkt zurückgegebenen Daten.Beispielbereiche im Zugriffstoken und ihre Auswirkung auf die Antwort `userInfo`
**`openid`**
Gibt eine Antwort mit allen Benutzerattributen zurück, die der App-Client lesen kann.
**`openid profile`**
Gibt die Benutzerattribute`name`,`family_name`,`given_name`,`middle_name`,`nickname`,`preferred_username`,`profile`,`picture`,`website`,`gender`,`birthdate`, `zoneinfo``locale`, und zurück`updated_at`. Gibt auch [benutzerdefinierte Attribute](user-pool-settings-attributes.md#user-pool-settings-custom-attributes) zurück. In App-Clients, die keinen Lesezugriff auf jedes Attribut haben, entspricht die Antwort auf diesen Bereich allen Attributen innerhalb der Spezifikation, auf die Ihr App-Client Lesezugriff hat.
**`openid email`**
Gibt grundlegende Profilinformationen und die `email_verified` Attribute `email` und zurück.
**`openid phone`**
Gibt grundlegende Profilinformationen und die `phone_number_verified` Attribute `phone_number` und zurück.
## GET /oauth2/userInfo
Ihre Anwendung generiert Anfragen an diesen Endpunkt direkt, nicht über einen Browser.
Weitere Informationen finden Sie unter [UserInfo-Endpunkt](http://openid.net/specs/openid-connect-core-1_0.html#UserInfo) in der Spezifikation zu OpenID Connect (OIDC).
**Topics**
+ [GET /oauth2/userInfo](#get-userinfo)
+ [Anfrageparameter im Header](#get-userinfo-request-header-parameters)
+ [Beispiel — Anfrage](#get-userinfo-positive-exchanging-authorization-code-for-userinfo-sample-request)
+ [Beispiel — positive Antwort](#get-userinfo-response-sample)
+ [Beispiel für negative Antworten](#get-userinfo-negative)
## Anfrageparameter im Header
**`Authorization: Bearer `**
Übergeben Sie das Zugriffstoken im Autorisierungsheader-Feld.
Erforderlich
## Beispiel — Anfrage
```
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
```
## Beispiel — positive Antwort
```
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"
}
```
Eine Liste der OIDC-Ansprüche finden Sie unter [Standardansprüche](http://openid.net/specs/openid-connect-core-1_0.html#StandardClaims). Derzeit gibt Amazon Cognito die Werte für `email_verified` und `phone_number_verified` als Zeichenfolgen zurück.
## Beispiel für negative Antworten
### Beispiel — schlechte Anfrage
```
HTTP/1.1 400 Bad Request
WWW-Authenticate: error="invalid_request",
error_description="Bad OAuth2 request at UserInfo Endpoint"
```
**`invalid_request`**
In der Anfrage fehlt ein erforderlicher Parameter, sie enthält einen nicht unterstützten Parameterwert oder sie ist anderweitig falsch formatiert.
### Beispiel — schlechtes Token
```
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`**
Das Zugriffstoken ist abgelaufen, gesperrt, falsch formatiert oder ungültig.
# Der Endpunkt für den Token-Widerruf
Benutzer, die in ihrer Sitzung über ein Aktualisierungstoken verfügen, haben etwas Ähnliches wie ein Browser-Cookie. Sie können ihre bestehende Sitzung verlängern, solange das Aktualisierungstoken gültig ist. Anstatt einen Benutzer aufzufordern, sich nach Ablauf seiner ID oder seines Zugriffstokens anzumelden, kann Ihre Anwendung das Aktualisierungstoken verwenden, um neue, gültige Token abzurufen. Sie können jedoch extern festlegen, dass die Sitzung eines Benutzers beendet werden soll, oder der Benutzer kann sich dafür entscheiden, seine aktuelle Sitzung zu vergessen. Zu diesem Zeitpunkt können Sie das Aktualisierungstoken widerrufen, sodass der Benutzer seine Sitzung nicht länger fortführen kann.
Der `/oauth2/revoke` Endpunkt widerruft das Zugriffstoken eines Benutzers, das Amazon Cognito ursprünglich mit dem von Ihnen bereitgestellten Aktualisierungstoken ausgestellt hat. Dieser Endpunkt widerruft auch das Aktualisierungstoken selbst und alle nachfolgenden Zugriffs- und Identitätstoken desselben Aktualisierungstoken. Nachdem der Endpunkt die Token gesperrt hat, können Sie die widerrufenen Zugriffstoken nicht mehr verwenden, um auf die Amazon Cognito Cognito-Token zuzugreifen APIs , die authentifiziert werden.
## POST /oauth2/revoke
Der `/oauth2/revoke` Endpunkt unterstützt ausschließlich `HTTPS POST`. Der Benutzer-Pool sendet Anforderungen direkt an diesen Endpunkt und nicht über den System-Browser.
### Anfrageparameter im Header
**`Authorization`**
Wenn Ihr App-Client über einen geheimen Client-Schlüssel verfügt, muss die Anwendung dessen `client_id` und `client_secret` im Autorisierungsheader über die Basic-HTTP-Autorisierung weitergeben. Der Geheim-Schlüssel ist [Basic](https://en.wikipedia.org/wiki/Basic_access_authentication#Client_side) `Base64Encode(client_id:client_secret)`.
**`Content-Type`**
Es muss sich immer um handeln `'application/x-www-form-urlencoded'`.
#### Anfrageparameter im Fließtext
**`token`**
(Erforderlich) Das Aktualisierungstoken, das der Client widerrufen möchte. Die Anforderung widerruft auch alle Zugriffstoken, die Amazon Cognito mit diesem Aktualisierungstoken ausgegeben hat.
Erforderlich
**`client_id`**
(Optional) Die App-Client-ID für das Token, das Sie widerrufen möchten.
Erforderlich, wenn der Client öffentlich ist und keinen Geheim-Schlüssel hat.
## Beispiel für einen Widerrufsanforderung
Diese Sperranforderung widerruft ein Aktualisierungstoken für einen App-Client, der keinen geheimen Clientschlüssel hat. Notieren Sie sich den `client_id` Parameter im Hauptteil der Anfrage.
```
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
```
Diese Sperranforderung widerruft ein Aktualisierungstoken für einen App-Client, der *über einen geheimen Clientschlüssel verfügt*. Notieren Sie sich den `Authorization` Header, der eine verschlüsselte Client-ID und einen geheimen Client-Schlüssel enthält, aber nicht `client_id` im Hauptteil der Anfrage.
```
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
```
## Antwort auf einen Fehler
Eine erfolgreiche Antwort enthält einen leeren Körper. Die Fehlerantwort ist ein JSON-Objekt mit einem `error`-Feld und in manchen Fällen ein `error_description`-Feld.
**Endpunktfehler**
+ Ihnen werden HTTP 400 und der Fehler `invalid_request` angezeigt, wenn das Token in der Anforderung nicht vorhanden ist oder wenn die Funktion für den App-Client deaktiviert ist.
+ Wenn das Token, das Amazon Cognito in der Widerrufsanfrage gesendet hat, kein Aktualisierungstoken ist, erhalten Sie ein HTTP 400 und den Fehler `unsupported_token_type`.
+ Wenn die Client-Anmeldeinformationen nicht gültig sind, wird Ihnen HTTP 401 und der Fehler `invalid_client` angezeigt.
+ Wenn das Token widerrufen wurde oder der Client ein ungültiges Token übermittelt hat, erhalten Sie ein HTTP 200-OK.
# Der IdP-SAML-Assertion-Endpunkt
Der `/saml2/idpresponse` empfängt SAML-Assertionen. Bei der service-provider-initiated (SP-initiierten) Anmeldung interagiert Ihre Anwendung nicht direkt mit diesem Endpunkt — Ihr SAML 2.0-Identitätsanbieter (IdP) leitet Ihren Benutzer mit seiner SAML-Antwort hierher weiter. Für die SP-initiierte Anmeldung konfigurieren Sie Ihren IdP mit dem Pfad zu Ihrer `saml2/idpresponse` als Assertion Consumer Service (ACS) -URL. Weitere Informationen zur Sitzungsinitiierung finden Sie unter. [Initiierung der SAML-Sitzung in Amazon-Cognito-Benutzerpools](cognito-user-pools-SAML-session-initiation.md)
Rufen Sie bei der IDP-initiierten Anmeldung Anfragen an diesen Endpunkt in Ihrer Anwendung auf, nachdem Sie sich bei Ihrem SAML 2.0-Anbieter als Benutzer angemeldet haben. Ihre Benutzer melden sich mit Ihrem IdP in ihrem Browser an, dann sammelt Ihre Anwendung die SAML-Assertion und sendet sie an diesen Endpunkt. Sie müssen SAML-Assertionen im Hauptteil einer Anfrage über HTTPS einreichen. `HTTP POST` Der Hauptteil Ihrer `POST` Anfrage muss aus einem `SAMLResponse` Parameter und einem `Relaystate` Parameter bestehen. Weitere Informationen finden Sie unter [Implementieren Sie die IDP-initiierte SAML-Anmeldung](cognito-user-pools-SAML-session-initiation.md#cognito-user-pools-SAML-session-initiation-idp-initiation).
Der `saml2/idpresponse` Endpunkt kann SAML-Assertionen mit einer Länge von bis zu 100.000 Zeichen akzeptieren.
## BEITRAG `/saml2/idpresponse`
Um den `/saml2/idpresponse` Endpunkt bei einer vom IDP initiierten Anmeldung zu verwenden, generieren Sie eine POST-Anforderung mit Parametern, die Ihrem Benutzerpool Informationen über die Sitzung Ihres Benutzers liefern.
+ Der App-Client, bei dem sie sich anmelden möchten.
+ Die Callback-URL, unter der sie landen möchten.
+ Die OAuth 2.0-Bereiche, die sie im Zugriffstoken Ihres Benutzers anfordern möchten.
+ Der IdP, der die Anmeldeanforderung initiiert hat.
### Vom IDP initiierte Anfragetextparameter
*SAMLResponse*
Eine Base64-kodierte SAML-Assertion von einem IdP, der einem gültigen App-Client und einer IdP-Konfiguration in Ihrem Benutzerpool zugeordnet ist.
*RelayState*
Ein `RelayState` Parameter enthält die Anforderungsparameter, die Sie andernfalls an den Endpunkt übergeben würden. `oauth2/authorize` Detaillierte Informationen zu diesen Parametern finden Sie unter [Autorisieren des Endpunkts](authorization-endpoint.md).
*response\$1type*
Der OAuth Zuschusstyp 2.0.
*Client-ID*
Die App-Client-ID).
*redirect\$1uri*
Die URL, an die der Authentifizierungsserver den Browser nach der Autorisierung des Benutzers durch Amazon Cognito weiterleitet.
*Identitätsanbieter*
Der Name des Identitätsanbieters, an den Sie Ihren Benutzer weiterleiten möchten.
*Idp-Identifier*
Die Kennung des Identitätsanbieters, zu dem Sie Ihren Benutzer weiterleiten möchten.
*scope*
Die OAuth 2.0-Bereiche, die Ihr Benutzer vom Autorisierungsserver anfordern soll.
### Beispielanfragen mit positiven Antworten
**Beispiel — POST-Anfrage**
Die folgende Anfrage bezieht sich auf die Gewährung eines Autorisierungscodes für einen Benutzer von IdP `MySAMLIdP` im App-Client`1example23456789`. Der Benutzer leitet `https://www.example.com` mit seinem Autorisierungscode weiter, der gegen Token eingetauscht werden kann, die ein Zugriffstoken mit den Bereichen OAuth 2.0 enthalten `openid``email`, und. `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
```
**Beispiel — Antwort**
Das Folgende ist die Antwort auf die vorherige Anfrage.
```
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 2.0 Zuschüsse
Der Amazon Cognito Cognito-Benutzerpool OAuth 2.0-Autorisierungsserver gibt Token als Antwort auf drei Arten von OAuth [2.0-Autorisierungsberechtigungen aus.](https://datatracker.ietf.org/doc/html/rfc6749#section-1.3) Sie können die unterstützten Erteilungstypen für jeden App-Client in Ihrem Benutzerpool festlegen. Sie können Erteilungen von *Client-Anmeldeinformationen* im selben App-Client nicht als *implizite* oder *Autorisierungscode*-Erteilungen aktivieren. Anforderungen für implizite und Autorisierungscode-Erteilungen beginnen bei Ihrem [Autorisieren des Endpunkts](authorization-endpoint.md) und Anforderungen für Erteilungen von Client-Anmeldeinformationen bei Ihrem [Token-Endpunkt](token-endpoint.md).
**Erteilung des Autorisierungscodes**
Als Antwort auf Ihre erfolgreiche Authentifizierungsanforderung fügt der Autorisierungsserver Ihrer Callback-URL einen Autorisierungscode in einem `code`-Parameter an. Sie müssen dann den Code für ID-, Zugriffs- und Aktualisierungstoken durch den [Token-Endpunkt](token-endpoint.md) ersetzen. Wenn Sie die Erteilung eines Autorisierungscodes anfordern möchten, legen Sie `response_type` in Ihrer Anforderung auf `code` fest. Eine Beispielanforderung finden Sie unter [Beispiel: Erteilung eines Autorisierungscodes](authorization-endpoint.md#sample-authorization-code-grant). Amazon Cognito unterstützt [Proof Key for Code Exchange (PKCE)](using-pkce-in-authorization-code.md) bei der Gewährung von Autorisierungscodes.
Die Erteilung des Autorisierungscodes ist die sicherste Form der Autorisierungserteilung. Dabei werden Ihren Benutzern die Inhalte der Token nicht direkt angezeigt. Stattdessen ist Ihre App dafür zuständig, die Token Ihrer Benutzer abzurufen und sicher zu speichern. In Amazon Cognito ist die Erteilung eines Autorisierungscodes die einzige Möglichkeit, alle drei Tokentypen – ID-, Zugriffs- und Aktualisierungstoken – vom Autorisierungsserver abzurufen. Sie können auch alle drei Tokentypen aus der Authentifizierung über die Amazon Cognito Cognito-Benutzerpools-API abrufen, aber die API gibt keine Zugriffstoken mit anderen Bereichen als aus. `aws.cognito.signin.user.admin`
**Implizite Erteilung**
Als Antwort auf Ihre erfolgreiche Authentifizierungsanforderung fügt der Autorisierungsserver Ihrer Callback-URL ein Zugriffstoken in einem `access_token`-Parameter und ein ID-Token in einem `id_token`-Parameter an. Eine implizite Erteilung erfordert keine zusätzliche Interaktion mit dem [Token-Endpunkt](token-endpoint.md). Wenn Sie eine implizite Erteilung anfordern möchten, legen Sie `response_type` in Ihrer Anforderung auf `token` fest. Die implizite Erteilung generiert nur eine ID und ein Zugriffstoken. Eine Beispielanforderung finden Sie unter [Beispiel: Token-Erteilung (implizit) ohne Geltungsbereich `openid`](authorization-endpoint.md#sample-token-grant-without-openid-scope).
Bei der impliziten Erteilung handelt es sich um eine ältere Autorisierungserteilung. Im Gegensatz zur Autorisierungscode-Erteilung können Benutzer Ihre Token abfangen und überprüfen. Wenn Sie die Tokenzustellung durch implizite Erteilung verhindern möchten, konfigurieren Sie Ihren App-Client so, dass er nur die Erteilung von Autorisierungscodes unterstützt.
**Client-Anmeldeinformationen**
Bei den Kundenanmeldedaten handelt es sich nur um eine Autorisierung für den Zugriff. machine-to-machine Wenn Sie eine Erteilung von Client-Anmeldeinformationen erhalten möchten, umgehen Sie den [Autorisieren des Endpunkts](authorization-endpoint.md) und generieren Sie eine Anforderung direkt an den [Token-Endpunkt](token-endpoint.md). Ihr App-Client muss über ein Client-Geheimnis verfügen und darf nur Erteilungen von Client-Anmeldeinformationen unterstützen. Als Antwort auf Ihre erfolgreiche Anforderung gibt der Autorisierungsserver ein Zugriffstoken zurück.
Das Zugriffstoken aus der Erteilung von Kundenanmeldedaten ist ein Autorisierungsmechanismus, der 2.0-Bereiche umfasst OAuth . In der Regel enthält das Token benutzerdefinierte Bereichsansprüche, die HTTP-Operationen zugriffsgeschützt autorisieren. APIs Weitere Informationen finden Sie unter [Bereiche, M2M und Ressourcenserver](cognito-user-pools-define-resource-servers.md).
Bei Zuschüssen mit Kundenanmeldedaten fallen zusätzliche Kosten auf Ihre Rechnung an. AWS Weitere Informationen finden Sie unter [Amazon Cognito – Preise](https://aws.amazon.com/cognito/pricing).
**Aktualisierungstoken**
Sie können einen Zuschuss für ein Aktualisierungstoken direkt bei der beantragen[Token-Endpunkt](token-endpoint.md). Diese Gewährung gibt neue ID- und Zugriffstoken im Austausch gegen ein gültiges Aktualisierungstoken zurück.
Weitere Informationen zu diesen Zuschüssen und ihrer Implementierung finden Sie unter So verwenden Sie [OAuth 2.0 in Amazon Cognito: Erfahren Sie mehr über die verschiedenen OAuth 2.0-Zuschüsse](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/) im *AWS Sicherheitsblog*.
# Verwendung von PKCE in Autorisierungscode-Zuschüssen
Amazon Cognito unterstützt die Proof Key for Code Exchange (PKCE) -Authentifizierung bei der Gewährung von Autorisierungscodes. PKCE ist eine Erweiterung der OAuth 2.0-Autorisierungscode-Gewährung für öffentliche Kunden. PKCE schützt vor der Rücknahme abgefangener Autorisierungscodes.
## So verwendet Amazon Cognito PKCE
Um die Authentifizierung mit PKCE zu starten, muss Ihre Anwendung einen eindeutigen Zeichenkettenwert generieren. Diese Zeichenfolge ist der Code Verifier, ein geheimer Wert, den Amazon Cognito verwendet, um den Client, der die ursprüngliche Autorisierung beantragt, mit dem Client zu vergleichen, der den Autorisierungscode gegen Token tauscht.
Ihre App muss einen SHA256 Hash auf die Codeverifizierer-Zeichenfolge anwenden und das Ergebnis mit Base64 codieren. Übergeben Sie die Hash-Zeichenfolge [Autorisieren des Endpunkts](authorization-endpoint.md) als `code_challenge` Parameter im Anforderungstext an. Wenn Ihre App den Autorisierungscode gegen Token eintauscht, muss sie die Codeverifizierer-Zeichenfolge im Klartext als `code_verifier` Parameter im Anfragetext an die enthalten. [Token-Endpunkt](token-endpoint.md) Amazon Cognito führt den gleichen hash-and-encode Vorgang mit dem Code-Verifier durch. Amazon Cognito gibt ID-, Zugriffs- und Aktualisierungstoken nur zurück, wenn es feststellt, dass der Codeverifier zu derselben Codeabfrage führt, die er in der Autorisierungsanfrage erhalten hat.
**Um Authorization Grant Flow mit PKCE zu implementieren**
1. Öffnen Sie die [Amazon-Cognito-Konsole](https://console.aws.amazon.com/cognito/home). Wenn Sie dazu aufgefordert werden, geben Sie Ihre AWS Anmeldeinformationen ein.
1. Wählen Sie **User Pools** (Benutzerpools) aus.
1. Wählen Sie einen vorhandenen Benutzerpool aus der Liste aus oder erstellen Sie einen neuen Benutzerpool. Wenn Sie einen Benutzerpool erstellen, werden Sie während des Assistenten aufgefordert, einen App-Client einzurichten und die verwaltete Anmeldung zu konfigurieren.
1. Wenn Sie einen neuen Benutzerpool erstellen, richten Sie während der geführten Einrichtung einen App-Client ein und konfigurieren Sie die verwaltete Anmeldung.
1. Wenn Sie einen vorhandenen Benutzerpool konfigurieren, fügen Sie eine [Domain](cognito-user-pools-assign-domain.md) und einen [öffentlichen App-Client](user-pool-settings-client-apps.md) hinzu, falls Sie dies noch nicht getan haben.
1. Generieren Sie eine zufällige alphanumerische Zeichenfolge, in der Regel einen Universally Unique Identifier ([UUID](cognito-terms.md#terms-uuid)), um eine Code-Challenge für die PKCE zu erstellen. Diese Zeichenfolge ist der Wert des `code_verifier` Parameters, den Sie in Ihrer Anfrage an die senden. [Token-Endpunkt](token-endpoint.md)
1. Hasht die `code_verifier` Zeichenfolge mit dem SHA256 Algorithmus. Kodieren Sie das Ergebnis des Hashing-Vorgangs auf Base64. Diese Zeichenfolge ist der Wert des `code_challenge` Parameters, den Sie in Ihrer Anfrage an die senden. [Autorisieren des Endpunkts](authorization-endpoint.md)
Das folgende Python Beispiel generiert einen `code_verifier` und berechnet den`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}")
```
Im Folgenden finden Sie ein Beispiel für die Ausgabe des Python Skripts:
```
code challenge: Eh0mg-OZv7BAyo-tdv_vYamx1boOYDulDklyXoMDtLg
code verifier: 9D-aW_iygXrgQcWJd0y0tNVMPSXSChIc2xceDhvYVdGLCBk-JWFTmBNjvKSdOrjTTYazOFbUmrFERrjWx6oKtK2b6z_x4_gHBDlr4K1mRFGyE8yA-05-_v7Dxf3EIYJH
```
1. Schließen Sie die verwaltete Anmeldung mit einer Anfrage zur Erteilung eines Autorisierungscodes bei PKCE ab. Im Folgenden finden Sie ein Beispiel für eine 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. Sammeln Sie die Autorisierung `code` und lösen Sie sie gegen Token mit dem Token-Endpunkt ein. Im Folgenden finden Sie ein Beispiel für eine Anfrage:
```
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. Überprüfen Sie die Antwort. Sie wird ID-, Zugriffs- und Aktualisierungstoken enthalten. Weitere Informationen zur Verwendung von Amazon Cognito Cognito-Benutzerpool-Token finden Sie unter[JSON-Webtoken (JWTs) für den Benutzerpool verstehen](amazon-cognito-user-pools-using-tokens-with-identity-providers.md).
# Antworten auf verwaltete Anmelde- und Verbundfehler
Ein Anmeldevorgang bei der verwalteten Anmeldung oder bei der föderierten Anmeldung kann zu einem Fehler führen. Im Folgenden sind einige Bedingungen aufgeführt, die dazu führen können, dass die Authentifizierung mit einem Fehler endet.
+ Ein Benutzer führt einen Vorgang aus, den Ihr Benutzerpool nicht ausführen kann.
+ Ein Lambda-Trigger reagiert nicht mit der erwarteten Syntax.
+ Ihr Identitätsanbieter (IdP) gibt einen Fehler zurück.
+ Amazon Cognito konnte die von Ihrem Benutzer bereitgestellten Attributinformationen nicht überprüfen.
+ Ihr IdP hat keine Anforderungen gesendet, die den erforderlichen Attributen zugeordnet sind.
Wenn Amazon Cognito auf einen Fehler stößt, teilt es ihn auf eine der folgenden Arten mit.
1. Amazon Cognito sendet eine Weiterleitungs-URL mit dem Fehler in den Anforderungsparametern.
1. Amazon Cognito zeigt einen Fehler bei der verwalteten Anmeldung an.
Fehler, die Amazon Cognito an Anforderungsparameter anfügt, haben das folgende Format.
```
https:///?error_description=error+description&error=error+name
```
Wenn Sie Ihren Benutzern helfen, Fehlerinformationen zu übermitteln, obwohl sie einen Vorgang nicht ausführen können, fordern Sie sie auf, die URL *und* den Text oder einen Screenshot der Seite zu erfassen.
**Anmerkung**
Amazon Cognito-Fehlerbeschreibungen sind keine festen Zeichenketten, und Sie sollten keine Logik verwenden, die auf einem festen Muster oder Format basiert.
**Fehlermeldungen von OIDC- und Social-Identity-Anbietern**
Ihr Identitätsanbieter gibt möglicherweise einen Fehler zurück. Wenn ein OIDC- oder OAuth 2.0-IdP einen standardkonformen Fehler zurückgibt, leitet Amazon Cognito Ihren Benutzer zur Callback-URL weiter und fügt die Fehlerantwort des Anbieters zu den Fehleranforderungsparametern hinzu. Amazon Cognito fügt den Namen des Anbieters und den HTTP-Fehlercode zu den vorhandenen Fehlerzeichenfolgen hinzu.
Die folgende URL ist ein Beispiel für eine Weiterleitung von einem IdP, der einen Fehler an Amazon Cognito zurückgegeben hat.
```
https://www.amazon.com/?error_description=LoginWithAmazon+Error+-+400+invalid_request+The+request+is+missing+a+required+parameter+%3A+client_secret&error=invalid_request
```
Da Amazon Cognito nur das zurückgibt, was es von einem Anbieter erhält, kann es sein, dass Ihr Benutzer nur einen Teil dieser Informationen sieht.
Wenn Ihr Benutzer bei der ersten Anmeldung über Ihren IdP auf ein Problem stößt, übermittelt der IdP alle Fehlermeldungen direkt an Ihren Benutzer. Amazon Cognito leitet eine Fehlermeldung an Ihren Benutzer weiter, wenn es eine Anfrage an Ihren IdP generiert, um die Sitzung Ihres Benutzers zu validieren. Amazon Cognito leitet IdP-Fehlermeldungen OAuth und OIDC-IdP-Fehlermeldungen von den folgenden Endpunkten weiter.
`/token`
Amazon Cognito tauscht den IdP-Autorisierungscode gegen ein Zugriffs-Token aus.
`/.well-known/openid-configuration`
Amazon Cognito ermittelt den Pfad zu Ihren Emittenten-Endpunkten.
`/.well-known/jwks.json`
Um die JSON-Web-Tokens (JWTs) Ihres Benutzers zu verifizieren, erkennt Amazon Cognito die JSON-Webschlüssel (JWKs), die Ihr IdP zum Signieren von Tokens verwendet.
Da Amazon Cognito keine ausgehenden Sitzungen an SAML-2.0-Anbieter initiiert, die möglicherweise HTTP-Fehler zurückgeben, enthalten die Fehler Ihrer Benutzer während einer Sitzung mit einem SAML-2.0-IdP diese Form von Anbieter-Fehlermeldungen nicht.