Kontobezogene betrügerische Aktivitäten in mobilen Apps erkennen und verhindern

In diesem Dokument erfahren Sie, wie Sie mit reCAPTCHA Account Defender betrügerische Aktivitäten im Zusammenhang mit Konten in mobilen Anwendungen erkennen und verhindern.

Mit reCAPTCHA können Sie wichtige Aktionen wie die Anmeldung und den Bezahlvorgang schützen. Es gibt jedoch viele subtile Formen von Kontomissbrauch, die durch die Beobachtung des Verhaltens eines bestimmten Nutzers in einer mobilen Anwendung über einen bestimmten Zeitraum hinweg erkannt werden können. reCAPTCHA Account Defender hilft dabei, diese Arten von subtilem Missbrauch zu erkennen, indem ein websitespezifisches Modell für Ihre mobile Anwendung erstellt wird, um einen Trend zu verdächtigem Verhalten oder eine Änderung der Aktivität zu erkennen. Mithilfe des websitespezifischen Modells hilft Ihnen reCAPTCHA Account Defender, Folgendes zu erkennen:

• Verdächtige Aktivitäten
• Konten mit ähnlichen Verhaltensmustern
• Anfragen von Geräten, die für bestimmte Nutzer als vertrauenswürdig gekennzeichnet wurden

Auf Grundlage der Analyse von reCAPTCHA Account Defender und des Website-spezifischen Modells können Sie die folgenden Maßnahmen ergreifen:

• Betrügerische Konten einschränken oder deaktivieren
• Versuche zur Kontoübernahme verhindern
• Erfolgreiche Kontoübernahmen eindämmen
• Gewähren Sie nur Zugriff auf Anfragen, die von legitimen Nutzerkonten stammen.
• Die Anmeldung für Nutzer, die sich über eines ihrer vertrauenswürdigen Geräte anmelden, wird vereinfacht.

Hinweise

1. reCAPTCHA Account Defender für mobile Anwendungen ist verfügbar, nachdem Sie eine automatische Sicherheitsüberprüfung ausgelöst haben, indem Sie Ihrem Projekt ein Rechnungskonto hinzugefügt haben. Fügen Sie Ihrem Projekt ein Rechnungskonto hinzu, um Ihre Website auf dieses Feature umzustellen.
2. Umgebung für reCAPTCHA vorbereiten
3. Punktebasierten Schlüssel erstellen

Mobile Anwendung für reCAPTCHA Account Defender konfigurieren

Für reCAPTCHA Account Defender ist ein umfassendes Verständnis der Kontoaktivitäten erforderlich, um eine effektive Erkennung zu ermöglichen. So können Sie reCAPTCHA Account Defender mit kontobezogenen Aktivitäten füttern und Ihr Website-spezifisches Modell erstellen und verbessern:

1. Binden Sie reCAPTCHA in Ihre mobile Anwendung ein.

   • Informationen zu Android-Apps finden Sie unter reCAPTCHA in Android-Apps einbinden.
   • Informationen zu iOS-Apps finden Sie unter reCAPTCHA in iOS-Apps einbinden.
2. Berichte zu wichtigen Nutzeraktionen:
3. Wichtige Nutzerereignisse bewerten
4. Nutzerereignisse annotieren, um Ihr websitespezifisches Modell zu optimieren:

Berichte zu wichtigen Nutzeraktionen

Um verdächtige Aktivitätsmuster zu erkennen und ein besseres Verständnis der typischen Aktivitätsmuster auf Ihrer Website zu entwickeln, benötigt reCAPTCHA Account Defender Informationen zu wichtigen Nutzeraktionen. Rufen Sie für jede Aktion Ihrer App, die mit reCAPTCHA geschützt ist, die Methode execute() mit RecaptchaAction auf. Weitere Informationen zu execute() und RecaptchaAction finden Sie hier:

• Android: execute() und RecaptchaAction.
• iOS: execute() und RecaptchaAction.

reCAPTCHA bietet eine integrierte Reihe von Aktionen. Bei Bedarf können Sie benutzerdefinierte Aktionen erstellen.

In der folgenden Tabelle sind die Aktionsnamen aufgeführt, die Sie beim Melden der kritischen Nutzeraktionen verwenden können.

Wichtige Nutzerereignisse bewerten

Wenn Sie execute() für eine Nutzeraktion aufrufen, wird ein Token generiert. Erstellen Sie für die kritischen Nutzerereignisse wie erfolgreiche und fehlgeschlagene Anmeldungen, Registrierungen und Aktionen der angemeldeten Nutzer eine Bewertung, um die Ergebnisse des execute()-Aufrufs zu analysieren. Die Bewertung liefert Ihnen ein Risikourteil, das Sie als Grundlage für Ihre Entscheidung nutzen können, wie Sie mit potenziell betrügerischen Aktivitäten umgehen. Sie können beispielsweise verdächtige Anfragen blockieren, riskante Anmeldungen überprüfen und Konten untersuchen, die für Sie von Interesse sind.

Für reCAPTCHA Account Defender müssen Sie eine stabile Konto-ID angeben, um Nutzeraktivitäten wie Anmelde-, angemeldete und Registrierungsanfragen einem bestimmten Konto zuzuordnen. So kann reCAPTCHA Account Defender Muster der Nutzeraktivität erkennen und für jedes Konto ein Aktivitätsmodell erstellen, um anomale und missbräuchliche Zugriffe besser zu erkennen.

Wählen Sie eine stabile Konto-ID accountId aus, die vom Nutzer nicht oft geändert wird, und geben Sie sie in der Methode projects.assessments.create für die Bewertung an. Diese stabile Konto-ID sollte für alle Ereignisse, die sich auf denselben Nutzer beziehen, denselben Wert haben. Sie können Folgendes als Konto-ID angeben:

Zusätzlich zur Angabe einer stabilen Konto-ID für alle kontobezogenen Anfragen können Sie für einige bestimmte Anfragen zusätzliche Konto-IDs angeben, die möglicherweise nicht stabil sind. Kontextspezifische Konto-IDs, die zusätzlich zu accountId bereitgestellt werden, helfen reCAPTCHA Account Defender, Nutzeraktivitäten besser zu verstehen und Versuche zur Kontoübernahme zu erkennen, um Ihre Nutzerkonten zu schützen. Wenn Sie zusätzliche Kennungen angeben, verwendet reCAPTCHA diese Informationen, um den Schutz Ihrer Nutzerkonten auf Grundlage von websiteübergreifenden Modellen zu verbessern. Dazu werden missbräuchliche Konto-IDs gekennzeichnet und websiteübergreifende Missbrauchsmuster im Zusammenhang mit diesen Kennungen verwendet. Sie können beispielsweise Folgendes angeben:

• Der Nutzername, die E‑Mail-Adresse oder die Telefonnummer, die als Anmelde-Handle für Anmeldeanfragen verwendet wurde

• Die E-Mail-Adresse oder Telefonnummer, die für eine Anfrage zur Multi-Faktor-Authentifizierung bestätigt wurde

• Eine E-Mail-Adresse oder Telefonnummer (primär oder sekundär), die vom Nutzer bei einer Anfrage zur Kontoaktualisierung angegeben wurde

• Die E‑Mail-Adressen und Telefonnummern, die vom Nutzer während einer Registrierungsanfrage angegeben werden

Hängen Sie die ausgewählte stabile Konto-ID an den Parameter accountId in der Methode projects.assessments.create für alle kontobezogenen Anfragen an. Optional können Sie zusätzliche Konto-IDs für die entsprechenden Anfragen angeben, indem Sie das Feld userIds in der Überprüfung verwenden.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

• PROJECT_ID: Ihre Google Cloud -Projekt-ID
• TOKEN: vom Aufruf execute() zurückgegebenes Token
• KEY_ID: reCAPTCHA-Schlüssel, der der App zugeordnet ist
• ACCOUNT_ID: die eindeutige Kennung, die dem Nutzerkonto für ein Nutzerkonto in Ihrer App zugeordnet ist
• EMAIL_ADDRESS: Optional. Eine E‑Mail-Adresse, die mit diesem Antrag verknüpft ist, falls vorhanden
• PHONE_NUMBER: Optional. Eine Telefonnummer, die mit dieser Anfrage verknüpft ist, falls vorhanden
• USERNAME: Optional. Ein Nutzername, der mit dieser Anfrage verknüpft ist (falls vorhanden)

HTTP-Methode und URL:

POST https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments

JSON-Text der Anfrage:

{
  "event": {
    "token": "TOKEN",
    "siteKey": "KEY_ID",
    "userInfo": {
      "accountId": "ACCOUNT_ID",
      "userIds": [
        {
          "email": "EMAIL_ADDRESS"
        },
        {
          "phoneNumber": "PHONE_NUMBER"
        },
        {
          "username": "USERNAME"
        }
      ]
    }
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "tokenProperties": {
    "valid": true,
    "androidPackageName": "com.example.app" or "iosBundleId": "com.example.app",
    "action": "login",
    "createTime": "2019-03-28T12:24:17.894Z"
   },
  "riskAnalysis": {
    "score": 0.6,
  },
 "event": {
    "token": "TOKEN",
    "siteKey": "KEY",
    "userInfo": {
      "accountId": "ACCOUNT_ID"
    }
  },
  "name": "projects/PROJECT_NUMBER/assessments/b6ac310000000000",
  "accountDefenderAssessment": {
    "labels": ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Codebeispiel

import com.google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseServiceClient;
import com.google.protobuf.ByteString;
import com.google.recaptchaenterprise.v1.AccountDefenderAssessment.AccountDefenderLabel;
import com.google.recaptchaenterprise.v1.Assessment;
import com.google.recaptchaenterprise.v1.CreateAssessmentRequest;
import com.google.recaptchaenterprise.v1.Event;
import com.google.recaptchaenterprise.v1.ProjectName;
import com.google.recaptchaenterprise.v1.RiskAnalysis.ClassificationReason;
import com.google.recaptchaenterprise.v1.TokenProperties;
import com.google.recaptchaenterprise.v1.UserId;
import com.google.recaptchaenterprise.v1.UserInfo;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.UUID;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class AccountDefenderAssessment {

  public static void main(String[] args)
      throws IOException, NoSuchAlgorithmException, InvalidKeyException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: Google Cloud Project ID
    String projectId = "project-id";

    // recaptchaSiteKey: Site key obtained by registering a domain/app to use recaptcha
    // services.
    String recaptchaSiteKey = "recaptcha-site-key";

    // token: The token obtained from the client on passing the recaptchaSiteKey.
    // To get the token, integrate the recaptchaSiteKey with frontend. See,
    // https://cloud.google.com/recaptcha-enterprise/docs/instrument-web-pages#frontend_integration_score
    String token = "recaptcha-token";

    // recaptchaAction: The action name corresponding to the token.
    String recaptchaAction = "recaptcha-action";

    // Unique ID of the user, such as email, customer ID, etc.
    String accountId = "default" + UUID.randomUUID().toString().split("-")[0];

    // User phone number
    String phoneNumber = "555-987-XXXX";

    // User email address
    String emailAddress = "john.doe@example.com";

    accountDefenderAssessment(projectId, recaptchaSiteKey, token, recaptchaAction, accountId, phoneNumber, emailAddress);
  }

  /**
   * This assessment detects account takeovers. See,
   * https://cloud.google.com/recaptcha-enterprise/docs/account-takeovers The input is the hashed
   * account id. Result tells if the action represents an account takeover. You can optionally
   * trigger a Multi-Factor Authentication based on the result.
   */
  public static void accountDefenderAssessment(
      String projectId,
      String recaptchaSiteKey,
      String token,
      String recaptchaAction,
      String accountId,
      String phoneNumber,
      String emailAddress)
      throws IOException {
    try (RecaptchaEnterpriseServiceClient client = RecaptchaEnterpriseServiceClient.create()) {

      // Set the properties of the event to be tracked.
      Event.Builder eventBuilder =
          Event.newBuilder()
              .setSiteKey(recaptchaSiteKey)
              .setToken(token);

      // Set the account id, email address and phone number (of the user).
      eventBuilder.setUserInfo(
        UserInfo.newBuilder()
          .setAccountId(accountId)
          .addUserIds(UserId.newBuilder().setEmail(emailAddress))
          .addUserIds(UserId.newBuilder().setPhoneNumber(phoneNumber)));

      Event event = eventBuilder.build();

      // Build the assessment request.
      CreateAssessmentRequest createAssessmentRequest =
          CreateAssessmentRequest.newBuilder()
              .setParent(ProjectName.of(projectId).toString())
              .setAssessment(Assessment.newBuilder().setEvent(event).build())
              .build();

      Assessment response = client.createAssessment(createAssessmentRequest);

      // Check integrity of the response token.
      if (!checkTokenIntegrity(response.getTokenProperties(), recaptchaAction)) {
        return;
      }

      // Get the reason(s) and the reCAPTCHA risk score.
      // For more information on interpreting the assessment,
      // see: https://cloud.google.com/recaptcha-enterprise/docs/interpret-assessment
      for (ClassificationReason reason : response.getRiskAnalysis().getReasonsList()) {
        System.out.println(reason);
      }
      float recaptchaScore = response.getRiskAnalysis().getScore();
      System.out.println("The reCAPTCHA score is: " + recaptchaScore);
      String assessmentName = response.getName();
      System.out.println(
          "Assessment name: " + assessmentName.substring(assessmentName.lastIndexOf("/") + 1));

      // Get the Account Defender result.
      com.google.recaptchaenterprise.v1.AccountDefenderAssessment accountDefenderAssessment =
          response.getAccountDefenderAssessment();
      System.out.println(accountDefenderAssessment);

      // Get Account Defender label.
      List<AccountDefenderLabel> defenderResult =
          response.getAccountDefenderAssessment().getLabelsList();
      // Based on the result, can you choose next steps.
      // If the 'defenderResult' field is empty, it indicates that Account Defender did not have
      // anything to add to the score.
      // Few result labels: ACCOUNT_DEFENDER_LABEL_UNSPECIFIED, PROFILE_MATCH,
      // SUSPICIOUS_LOGIN_ACTIVITY, SUSPICIOUS_ACCOUNT_CREATION, RELATED_ACCOUNTS_NUMBER_HIGH.
      // For more information on interpreting the assessment, see:
      // https://cloud.google.com/recaptcha-enterprise/docs/account-defender#interpret-assessment-details
      System.out.println("Account Defender Assessment Result: " + defenderResult);
    }
  }

  private static boolean checkTokenIntegrity(
      TokenProperties tokenProperties, String recaptchaAction) {
    // Check if the token is valid.
    if (!tokenProperties.getValid()) {
      System.out.println(
          "The Account Defender Assessment call failed because the token was: "
              + tokenProperties.getInvalidReason().name());
      return false;
    }

    // Check if the expected action was executed.
    if (!tokenProperties.getAction().equals(recaptchaAction)) {
      System.out.printf(
          "The action attribute in the reCAPTCHA tag '%s' does not match "
              + "the action '%s' you are expecting to score",
          tokenProperties.getAction(), recaptchaAction);
      return false;
    }
    return true;
  }
}

Risikobewertung der kritischen Nutzerereignisse interpretieren

Wenn Sie eine Bewertung mit aktiviertem Account Defender erstellen, gibt Account Defender accountDefenderAssessment als Teil der Bewertungsantwort zurück. Anhand des Werts von accountDefenderAssessment können Sie beurteilen, ob die Nutzeraktivität legitim oder betrügerisch ist. Außerdem wird eine Bewertungs-ID zurückgegeben, die Sie beim Annotieren von Nutzerereignissen verwenden müssen.

Das folgende Beispiel zeigt eine JSON-Beispielantwort:

{
  "tokenProperties": {
    "valid": true,
    "androidPackageName": "com.example.app" or "iosBundleId": "com.example.app",
    "action": "login",
    "createTime": "2019-03-28T12:24:17.894Z"
   },
  "riskAnalysis": {
    "score": 0.6,
  },
 "event": {
    "token": "TOKEN",
    "siteKey": "KEY_ID",
    "expectedAction": "USER_ACTION"
  },
  "name": "projects/PROJECT_ID/assessments/b6ac310000000000X",
  "accountDefenderAssessment": {
    labels: ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Das Feld accountDefenderAssessment kann einen der folgenden Werte haben:

Ereignisse annotieren, um Ihr websitespezifisches Modell zu optimieren

Damit Sie reCAPTCHA Account Defender weitere Informationen zur Verfügung stellen und Ihr websitespezifisches Erkennungsmodell verbessern können, müssen Sie die Ereignisse, die Sie bewertet haben, durch Erstellen von Bewertungen annotieren.

Sie merken eine Bewertung an, indem Sie eine Anfrage mit der Bewertungs-ID an die Methode projects.assessments.annotate senden. Im Text dieser Anfrage fügen Sie Labels ein, die zusätzliche Informationen zu einem im Gutachten beschriebenen Ereignis enthalten.

So fügen Sie einer Bewertung eine Anmerkung hinzu:

1. Legen Sie die Informationen und Labels fest, die Sie je nach Anwendungsfall in den JSON-Text der Anfrage einfügen möchten.

   In der folgenden Tabelle sind die Labels und Werte aufgeführt, die Sie zum Annotieren von Ereignissen verwenden können:

   Label	Beschreibung	Beispielanfrage
   reasons	Erforderlich. Ein Label zur Unterstützung Ihrer Analysen. Stellen Sie innerhalb von Sekunden oder Minuten nach dem Ereignis Echtzeit-Ereignisdetails im reasons-Label bereit, da sie die Echtzeiterkennung beeinflussen. Eine Liste der möglichen Werte finden Sie unter Werte für „reasons“. Beispiel: Um Kontoübernahmen zu erkennen, geben Sie mit den Werten CORRECT_PASSWORD oder INCORRECT_PASSWORD an, ob das eingegebene Passwort korrekt war. Wenn Sie Ihre eigene MFA bereitgestellt haben, können Sie die folgenden Werte hinzufügen: INITIATED_TWO_FACTOR und PASSED_TWO_FACTOR oder FAILED_TWO_FACTOR.	{ "reasons": ["INCORRECT_PASSWORD"] }
   annotation	Optional. Ein Label, das die Rechtmäßigkeit von Bewertungen angibt. Geben Sie Fakten zu Anmelde- und Registrierungsereignissen an, um Ihre Risikobewertungen im Label annotation zu validieren oder zu korrigieren. Mögliche Werte: LEGITIMATE oder FRAUDULENT. Sie können diese Informationen jederzeit oder im Rahmen eines Batchjobs senden. Wir empfehlen jedoch, diese Informationen einige Sekunden oder Minuten nach dem Ereignis zu senden, da sie die Echtzeiterkennung beeinflussen.	{ "annotation": "LEGITIMATE" }
   accountId	Optional. Ein Label, mit dem eine Konto-ID einem Ereignis zugeordnet wird. Wenn Sie eine Bewertung ohne Konto-ID erstellt haben, verwenden Sie dieses Label, um die Konto-ID eines Ereignisses anzugeben, sofern sie verfügbar ist.	{ "accountId": "ACCOUNT_ID" }

2. Erstellen Sie eine Annotate-Anfrage mit den entsprechenden Labels.

   Ersetzen Sie diese Werte in den folgenden Anfragedaten:

   • ASSESSMENT_ID: Wert des Felds name, der vom projects.assessments.create-Aufruf zurückgegeben wurde.
   • ANNOTATION: Optional. Ein Label, das angibt, ob die Bewertung legitim oder betrügerisch ist.
   • REASONS: Optional. Gründe, die Ihre Anmerkung unterstützen. Eine Liste der möglichen Werte finden Sie unter Werte für „reasons“.
   • ACCOUNT_ID: Optional. Die Kennung, die eindeutig mit dem Nutzerkonto in Ihrer App verknüpft ist.

   Weitere Informationen finden Sie unter Labels für Annotationen.

   HTTP-Methode und URL:

   POST https://recaptchaenterprise.googleapis.com/v1/ASSESSMENT_ID:annotate

   JSON-Text der Anfrage:

   {
     "annotation": ANNOTATION,
     "reasons": REASONS,
     "accountId": ACCOUNT_ID
   }
   

   Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

   curl

   Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

   curl -X POST \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        -H "Content-Type: application/json; charset=utf-8" \
        -d @request.json \
        "https://recaptchaenterprise.googleapis.com/v1/ASSESSMENT_ID:annotate"

   PowerShell

   Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method POST `
       -Headers $headers `
       -ContentType: "application/json; charset=utf-8" `
       -InFile request.json `
       -Uri "https://recaptchaenterprise.googleapis.com/v1/ASSESSMENT_ID:annotate" | Select-Object -Expand Content

   Sie sollten einen erfolgreichen Statuscode (2xx) und eine leere Antwort als Ausgabe erhalten.

Codebeispiel

import com.google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseServiceClient;
import com.google.protobuf.ByteString;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentRequest;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentRequest.Annotation;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentRequest.Reason;
import com.google.recaptchaenterprise.v1.AnnotateAssessmentResponse;
import com.google.recaptchaenterprise.v1.AssessmentName;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.UUID;

public class AnnotateAccountDefenderAssessment {

  public static void main(String[] args) throws IOException, NoSuchAlgorithmException {
    // TODO(developer): Replace these variables before running the sample.
    // projectID: GCloud Project id.
    String projectID = "project-id";

    // assessmentId: Value of the 'name' field returned from the CreateAssessment call.
    String assessmentId = "account-defender-assessment-id";

    // accountId: Set the accountId corresponding to the assessment id.
    String accountId = "default" + UUID.randomUUID().toString().split("-")[0];

    annotateAssessment(projectID, assessmentId, accountId);
  }

  /**
   * Pre-requisite: Create an assessment before annotating. Annotate an assessment to provide
   * feedback on the correctness of recaptcha prediction.
   */
  public static void annotateAssessment(
      String projectID, String assessmentId, String accountId) throws IOException {

    try (RecaptchaEnterpriseServiceClient client = RecaptchaEnterpriseServiceClient.create()) {
      // Build the annotation request.
      // For more info on when/how to annotate, see:
      // https://cloud.google.com/recaptcha-enterprise/docs/annotate-assessment#when_to_annotate
      AnnotateAssessmentRequest annotateAssessmentRequest =
          AnnotateAssessmentRequest.newBuilder()
              .setName(AssessmentName.of(projectID, assessmentId).toString())
              .setAnnotation(Annotation.LEGITIMATE)
              .addReasons(Reason.PASSED_TWO_FACTOR)
              .setAccountId(accountId)
              .build();

      // Empty response is sent back.
      AnnotateAssessmentResponse response = client.annotateAssessment(annotateAssessmentRequest);
      System.out.println("Annotated response sent successfully ! " + response);
    }
  }
}

reCAPTCHA Account Defender aktivieren

Nachdem Sie Ihre mobile Anwendung für reCAPTCHA Account Defender konfiguriert haben, können Sie reCAPTCHA Account Defender aktivieren.

1. Rufen Sie in der Google Cloud Console die Seite reCAPTCHA auf.

   Zu reCAPTCHA

2. Prüfen Sie, ob der Name Ihres Projekts in der Ressourcenauswahl oben auf der Seite angezeigt wird.

   Wenn Sie den Namen Ihres Projekts nicht sehen, klicken Sie auf die Ressourcenauswahl und wählen Sie Ihr Projekt aus.

3. Klicken Sie auf settingsEinstellungen.

4. Klicken Sie im Bereich Account Defender auf Konfigurieren.

   

5. Klicken Sie im Dialogfeld Account Defender konfigurieren auf Aktivieren und dann auf Speichern.

   

Es kann einige Stunden dauern, bis die Aktivierung von reCAPTCHA Account Defender in unseren Systemen übernommen wird. Nachdem die Aktivierung der Funktion in unseren Systemen erfolgt ist, sollten Sie im Rahmen der Bewertungen Antworten zu Account Defender erhalten.

Nächste Schritte

• Weitere Informationen zu anderen Kontoschutzfunktionen