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.
# Erfassung von Daten zum Schutz vor Bedrohungen in Anwendungen
Die [ adaptive Authentifizierung von Amazon Cognito ](cognito-user-pool-settings-adaptive-authentication.md) bewertet die Risikostufen für den Versuch einer Kontoübernahme anhand der kontextbezogenen Details der Anmeldeversuche der Benutzer. Ihre Anwendung muss den API-Anfragen * Kontextdaten hinzufügen*, damit der Bedrohungsschutz von Amazon Cognito das Risiko genauer einschätzen kann. Kontextdaten sind Informationen wie IP-Adresse, Browser-Agent, Geräteinformationen und Anforderungsheader, die kontextbezogene Informationen darüber liefern, wie ein Benutzer mit Ihrem Benutzerpool verbunden ist.
Die zentrale Verantwortung einer Anwendung, die diesen Kontext an Amazon Cognito übermittelt, ist ein `EncodedData` Parameter bei Authentifizierungsanfragen an Benutzerpools. Um diese Daten zu Ihren Anfragen hinzuzufügen, können Sie Amazon Cognito mit einem SDK implementieren, das diese Informationen automatisch für Sie generiert, oder Sie können ein Modul für JavaScript iOS oder Android implementieren, das diese Daten erfasst. *Client-only*Anwendungen, die direkte Anfragen an Amazon Cognito stellen, müssen SDKs implementieren AWS Amplify . *Client-server*Anwendungen, die über einen Zwischenserver oder eine API-Komponente verfügen, müssen ein separates SDK-Modul implementieren.
In den folgenden Szenarien verwaltet Ihr Authentifizierungs-Frontend die Erfassung von Benutzerkontextdaten ohne zusätzliche Konfiguration:
+ Bei der verwalteten Anmeldung werden automatisch Kontextdaten erfasst und an den Bedrohungsschutz weitergeleitet.
+ Alle AWS Amplify Bibliotheken haben die Erfassung von Kontextdaten in ihre Authentifizierungsmethoden integriert.
## Senden von Benutzerkontextdaten in Anwendungen, die nur für Kunden bestimmt sind, mit Amplify
Amplify SDKs unterstützen mobile Clients, die sich direkt bei Amazon Cognito authentifizieren. Kunden dieser Art stellen direkte API-Anfragen an die öffentlichen API-Operationen von Amazon Cognito. Amplify-Kunden sammeln standardmäßig automatisch Kontextdaten zum Schutz vor Bedrohungen.
Amplify-Anwendungen mit stellen eine JavaScript Ausnahme dar. Sie erfordern das Hinzufügen eines [ JavaScript Moduls](#user-pool-settings-viewing-threat-protection-app-additional-resources-js), das Benutzerkontextdaten sammelt.
In der Regel verwendet eine Anwendung in dieser Konfiguration nicht authentifizierte API-Operationen wie [ InitiateAuth ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html) und. [ RespondToAuthChallenge ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html) Das [ UserContextData ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_UserContextDataType.html) Objekt hilft dabei, die Risiken für diese Operationen genauer zu bewerten. Die Amplify SDKs fügen Geräte- und Sitzungsinformationen zu einem `EncodedData` Parameter von hinzu. `UserContextData`
## Erfassung von Kontextdaten in Client-Server-Anwendungen
Einige Anwendungen haben eine Front-End-Ebene, die Benutzerauthentifizierungsdaten sammelt, und eine Anwendungs-Back-End-Ebene, die Authentifizierungsanfragen an Amazon Cognito sendet. Dies ist eine gängige Architektur in Webservern und Anwendungen, die von Microservices unterstützt werden. In diesen Anwendungen müssen Sie eine öffentliche Bibliothek für die Sammlung von Kontextdaten importieren.
In der Regel verwendet ein Anwendungsserver in dieser Konfiguration authentifizierte API-Operationen wie [ AdminInitiateAuth ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html) und. [ AdminRespondToAuthChallenge ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html) Das [ ContextData ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html#CognitoUserPools-AdminInitiateAuth-request-ContextData) Objekt hilft Amazon Cognito dabei, die Risiken für diese Operationen genauer zu bewerten. Der Inhalt von besteht aus `ContextData` den verschlüsselten Daten, die Ihr Frontend an Ihren Server weitergegeben hat, sowie zusätzliche Details aus der HTTP-Anfrage des Benutzers an Ihren Server. Diese zusätzlichen Kontextdetails, wie die HTTP-Header und die IP-Adresse, geben Ihrem Anwendungsserver die Eigenschaften der Benutzerumgebung an.
Ihr Anwendungsserver meldet sich möglicherweise auch mit nicht authentifizierten API-Vorgängen wie und an. [ InitiateAuth ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html) [ RespondToAuthChallenge ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html) Das [ UserContextData ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html#CognitoUserPools-InitiateAuth-request-UserContextData) Objekt dient als Grundlage für die Risikoanalyse des Bedrohungsschutzes bei diesen Vorgängen. Die Operationen in den verfügbaren Datenerfassungsbibliotheken für den öffentlichen Kontext fügen dem `EncodedData` Parameter in Authentifizierungsanforderungen Sicherheitsinformationen hinzu. Konfigurieren Sie Ihren Benutzerpool zusätzlich so, dass er zusätzliche Kontextdaten akzeptiert, und fügen Sie die Quell-IP des Benutzers zum `IpAddress` Parameter von hinzu`UserContextData`.
**Um Kontextdaten zu Client-Server-Anwendungen hinzuzufügen**
1. Erfassen Sie in Ihrer Frontend-Anwendung kodierte Kontextdaten vom Client mit einem [ iOS-, Android- oder Modul. JavaScript ](#user-pool-settings-viewing-threat-protection-app-additional-resources)
1. Übergeben Sie die verschlüsselten Daten und die Details der Authentifizierungsanfrage an Ihren Anwendungsserver.
1. Extrahieren Sie auf Ihrem Anwendungsserver die IP-Adresse des Benutzers, die relevanten HTTP-Header, den angeforderten Servernamen und den angeforderten Pfad aus der HTTP-Anfrage. Füllen Sie diese Werte in den [ ContextData ](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html#CognitoUserPools-AdminInitiateAuth-request-ContextData) Parameter Ihrer API-Anfrage an Amazon Cognito ein.
1. Füllen Sie den `EncodedData` Parameter von `ContextData` in Ihrer API-Anfrage mit den codierten Gerätedaten, die Ihr SDK-Modul erfasst hat. Fügen Sie diese Kontextdaten zur Authentifizierungsanfrage hinzu.
## Kontextdatenbibliotheken für Client-Server-Anwendungen
### JavaScript
Das `amazon-cognito-advanced-security-data.min.js` Modul sammelt`EncodedData`, die Sie an Ihren Anwendungsserver weitergeben können.
Fügen Sie das `amazon-cognito-advanced-security-data.min.js` Modul zu Ihrer JavaScript Konfiguration hinzu. ``Ersetzen Sie es durch eines AWS-Region aus der folgenden Liste: `us-east-1``us-east-2`,`us-west-2`,`eu-west-1`,`eu-west-2`, oder`eu-central-1`.
```
```
Um ein `encodedContextData` Objekt zu generieren, das Sie in dem `EncodedData` Parameter verwenden können, fügen Sie Ihrer JavaScript Anwendungsquelle Folgendes hinzu:
```
var encodedContextData = AmazonCognitoAdvancedSecurityData.getData(_username, _userpoolId, _userPoolClientId);
```
### iOS/Swift
Um Kontextdaten zu generieren, können iOS-Anwendungen das [ Modul ](https://github.com/aws-amplify/aws-sdk-ios/tree/main) Mobile SDK für iOS integrieren [ AWSCognitoIdentityProviderASF](https://github.com/aws-amplify/aws-sdk-ios/tree/main/AWSCognitoIdentityProviderASF).
Um kodierte Kontextdaten zum Schutz vor Bedrohungen zu sammeln, fügen Sie Ihrer Anwendung den folgenden Ausschnitt hinzu:
```
import AWSCognitoIdentityProviderASF
let deviceId = getDeviceId()
let encodedContextData = AWSCognitoIdentityProviderASF.userContextData(
userPoolId,
username: username,
deviceId: deviceId,
userPoolClientId: userPoolClientId)
/**
* Reuse DeviceId from keychain or generate one for the first time.
*/
func getDeviceId() -> String {
let deviceIdKey = getKeyChainKey(namespace: userPoolId, key: "AWSCognitoAuthAsfDeviceId")
if let existingDeviceId = self.keychain.string(forKey: deviceIdKey) {
return existingDeviceId
}
let newDeviceId = UUID().uuidString
self.keychain.setString(newDeviceId, forKey: deviceIdKey)
return newDeviceId
}
/**
* Get a namespaced keychain key given a namespace and key
*/
func getKeyChainKey(namespace: String, key: String) -> String {
return "\(namespace).\(key)"
}
```
### Android
Um Kontextdaten zu generieren, können Android-Anwendungen das Modul [ aws-android-sdk-cognitoidentityprovider-asf für Android ](https://github.com/aws-amplify/aws-sdk-android/tree/main) integrieren. [https://github.com/aws-amplify/aws-sdk-android/tree/main/aws-android-sdk-cognitoidentityprovider-asf](https://github.com/aws-amplify/aws-sdk-android/tree/main/aws-android-sdk-cognitoidentityprovider-asf)
Um verschlüsselte Kontextdaten für den Bedrohungsschutz zu sammeln, fügen Sie Ihrer Anwendung den folgenden Codeausschnitt hinzu:
```
UserContextDataProvider provider = UserContextDataProvider.getInstance();
// context here is android application context.
String encodedContextData = provider.getEncodedContextData(context, username, userPoolId, userPoolClientId);
```