Kontobezogene betrügerische Aktivitäten erkennen und verhindern

In diesem Dokument erfahren Sie, wie Sie mit reCAPTCHA Enterprise-Account Defender kontobezogene betrügerische Aktivitäten erkennen und verhindern.

Mit reCAPTCHA Enterprise können Sie wichtige Aktionen wie Anmeldung und Bezahlvorgang schützen. Es gibt jedoch viele kleine Arten von Kontomissbrauch, die durch das Beobachten eines bestimmten Nutzerverhaltens auf der Website über einen bestimmten Zeitraum erkannt werden können. Der reCAPTCHA Enterprise-Account Defender hilft, diese Art von leichtem Missbrauch zu erkennen, indem ein websitespezifisches Modell für Ihre Website erstellt wird, um einen Trend zu verdächtigem Verhalten oder einer Änderung der Aktivität zu erkennen. Mit dem websitespezifischen Modell können Sie mit reCAPTCHA-Account Defender Folgendes erkennen:

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

Basierend auf der Analyse von reCAPTCHA Enterprise-Account Defender und dem websitespezifischen Modell können Sie Folgendes tun:

  • Betrügerische Konten einschränken oder deaktivieren
  • Versuche zur Kontoübernahme verhindern.
  • Vermeiden Sie Kontoübernahmen.
  • Gewähren Sie nur Zugriff auf die Anfragen von berechtigten Nutzerkonten.
  • Nutzer können sich einfacher von einem vertrauenswürdigen Gerät aus anmelden.

Hinweis

Wählen Sie die beste Methode zum Einrichten von reCAPTCHA Enterprise in Ihrer Umgebung aus und schließen Sie die Einrichtung ab.

reCAPTCHA Enterprise-Konto-Defender aktivieren

  1. Gehen Sie in der Konsole zur Seite reCAPTCHA Enterprise.

    Zur Seite „reCAPTCHA Enterprise“

  2. Überprüfe, ob der Name deines Projekts in der Ressourcenauswahl oben auf der Seite erscheint.

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

  3. Klicken Sie auf Einstellungen.

  4. Klicken Sie im Bereich Account Defender auf Enable.

  5. Klicken Sie im Dialogfeld Account Defender konfigurieren auf Enable.

Es kann einige Stunden dauern, bis das Aktivieren des reCAPTCHA Enterprise-Konto-Defenders in unseren Systemen wirksam wird. Nachdem die Funktionsaktivierung an unsere Systeme weitergegeben wurde, sollten Sie im Rahmen der Prüfungen Antworten auf die Kontosicherheit erhalten.

Informationen zum Workflow

So verwenden Sie reCAPTCHA Enterprise Account Defender:

  1. Score-basierte Websiteschlüssel auf Clients (Webseiten oder mobile Apps) installieren
  2. Prüfungen mit hashedAccountId erstellen.
  3. Bewerten Sie die Prüfungsdetails.
  4. Bewertungen mit kontobezogenen Metadaten annotieren

Wenn Sie die folgenden Schritte ausgeführt haben, können Sie Konten mit ähnlichen Verhaltensweisen identifizieren.

Auf Punktzahlen basierende Websiteschlüssel auf Clients installieren

Wenn Sie reCAPTCHA Enterprise-Konto-Defender verwenden möchten, installieren Sie auf der Anmeldeseite und der Registrierungsseite wertbezogene Websiteschlüssel, indem Sie der plattformspezifischen Anleitung folgen:

Wenn Sie genaue Ergebnisse erhalten möchten, sollten Sie auf allen Seiten vor und nach wichtigen Aktionen wie Anmeldung und Bezahlvorgang auf Punktzahlen basierende Erweiterungen installieren. Stellen Sie sich beispielsweise einen Kunden-Workflow vor, der die Startseite, die Anmeldeseite und die Begrüßungsseite auf einer Website umfasst. In diesem Workflow schützen Sie die Anmeldeseite, indem Sie einen auf Punktzahlen basierenden Websiteschlüssel auf der Anmeldeseite installieren. Wir empfehlen dir, auf der Startseite und der Begrüßungsseite ebenfalls auf Punktzahlen basierende Websiteschlüssel zu installieren, um genaue Ergebnisse zu erhalten.

Wenn Sie auf Punktzahlen basierende Websiteschlüssel mit eindeutigen Aktionen auf verschiedenen Seiten Ihrer Website oder in Ihrer mobilen App installieren, erstellt reCAPTCHA Enterprise Account Defender ein benutzerdefiniertes Modell, das auf dem Verhalten von legitimen und betrügerischen Konten basiert. Weitere Informationen zum Installieren von Punktzahl-basierten Websiteschlüsseln mit eindeutigen Aktionen finden Sie unter Auf Punktzahlen basierte Websiteschlüssel für Nutzeraktionen installieren.

Bewertungen mithilfe von hashedAccountId erstellen

Bewertungen für kritische Aktionen erstellen Kritische Aktionen sind erfolgreiche und fehlgeschlagene Anmeldungen, Registrierungen und zusätzliche Aktionen der angemeldeten Nutzer.

So erstellen Sie eine Bewertung mit hashedAccountId:

  1. Erstellen Sie eine eindeutige stabile gehashte Nutzerkennung mit der SHA256-HMAC-Methode für ein Nutzerkonto auf Ihrer Website. Sie können diese Kennung aus einer Nutzer-ID, einem Nutzernamen oder einer E-Mail-Adresse generieren.

  2. Hänge die gehashte Nutzerkennung an den Parameter hashedAccountId in der Methode projects.assessments.create an. Mit hashedAccountId können reCAPTCHA Enterprise-Account Defender betrügerische Konten und gehackte Konten erkennen.

    Bevor Sie eine der Anfragedaten verwenden, nehmen Sie folgende Ersetzungen vor:

    • PROJECT_ID: Ihre Google Cloud-Projekt-ID
    • TOKEN: vom Aufruf grecaptcha.enterprise.execute() zurückgegebenes Token
    • KEY: reCAPTCHA Schlüssel, der der Website/App zugeordnet ist
    • HASHED_ACCOUNT_ID: eine stabile gehashte Nutzerkennung, die mit der SHA256-HMAC-Methode für ein Nutzerkonto auf Ihrer Website generiert wurde

    HTTP-Methode und URL: 

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

    JSON-Text der Anfrage: 

    {
  "event": {
    "token": "TOKEN",
    "siteKey": "KEY",
    "hashedAccountId": "HASHED_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 application-default print-access-token) \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments"

    PowerShell

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

    $cred = gcloud auth application-default 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 in etwa folgende JSON-Antwort erhalten:

    {
  "tokenProperties": {
    "valid": true,
    "hostname": "www.google.com",
    "action": "login",
    "createTime": "2019-03-28T12:24:17.894Z"
   },
  "riskAnalysis": {
    "score": 0.6,
  },
 "event": {
    "token": "TOKEN",
    "siteKey": "KEY",
    "expectedAction": "USER_ACTION"
  },
  "name": "projects/PROJECT_ID/assessments/b6ac310000000000",
  "accountDefenderAssessment": {
    labels: ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Codebeispiel

Java


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 java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.UUID;

public class AccountDefenderAssessment {

  public static void main(String[] args) throws IOException, NoSuchAlgorithmException {
    // 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 customer, such as email, customer ID, etc.
    String userIdentifier = "default" + UUID.randomUUID().toString().split("-")[0];

    // Hash the unique customer ID using HMAC SHA-256.
    MessageDigest digest = MessageDigest.getInstance("SHA-256");
    byte[] hashBytes = digest.digest(userIdentifier.getBytes(StandardCharsets.UTF_8));
    ByteString hashedAccountId = ByteString.copyFrom(hashBytes);

    accountDefenderAssessment(projectId, recaptchaSiteKey, token, recaptchaAction, hashedAccountId);
  }

  /**
   * 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,
      ByteString hashedAccountId)
      throws IOException {
    try (RecaptchaEnterpriseServiceClient client = RecaptchaEnterpriseServiceClient.create()) {

      // Set the properties of the event to be tracked.
      Event event =
          Event.newBuilder()
              .setSiteKey(recaptchaSiteKey)
              .setToken(token)
              // Set the hashed account id (of the user).
              // Recommended approach: HMAC SHA256 along with salt (or secret key).
              .setHashedAccountId(hashedAccountId)
              .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;
  }
}

Bewertungsdetails auswerten

Nachdem Sie eine Bewertung erstellt haben, erhalten Sie eine Antwort wie im folgenden JSON-Beispiel. Der reCAPTCHA Enterprise-Konto-Defender gibt accountDefenderAssessment als Teil der Bewertungsantwort zurück. Mit dem Wert accountDefenderAssessment kannst du prüfen, ob die Nutzeraktivität legitim oder betrügerisch ist.

{
  "tokenProperties": {
    "valid": true,
    "hostname": "www.google.com",
    "action": "login",
    "createTime": "2019-03-28T12:24:17.894Z"
   },
  "riskAnalysis": {
    "score": 0.6,
  },
 "event": {
    "token": "TOKEN",
    "siteKey": "KEY",
    "expectedAction": "USER_ACTION"
  },
  "name": "projects/PROJECT_ID/assessments/b6ac310000000000",
  "accountDefenderAssessment": {
    labels: ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Das Feld accountDefenderAssessment kann einen der folgenden Werte haben:

  • PROFILE_MATCH: Gibt an, dass die Attribute des Nutzers mit den Attributen übereinstimmen, die zuvor für diesen Nutzer angesehen wurden. Dieser Wert weist darauf hin, dass dieser Nutzer ein vertrauenswürdiges Gerät verwendet, das zuvor für den Zugriff auf Ihre Website verwendet wurde.

    PROFILE_MATCH wird nur in folgenden Fällen zurückgegeben:

    • Sie verwenden die Multi-Faktor-Authentifizierung(MFA) oder Zwei-Faktor-Authentifizierung(2FA) und reCAPTCHA Enterprise-Konto-Verteidiger markieren Nutzerprofile als vertrauenswürdig, nachdem Nutzer die MFA oder 2FA bestanden haben.

    • Sie kommentieren Prüfungen als LEGITIMATE und das reCAPTCHA Enterprise-Konto-Defender wird das entsprechende Nutzerprofil als vertrauenswürdig markiert.

  • SUSPICIOUS_LOGIN_ACTIVITY: Gibt an, dass die Anfrage mit einem Profil übereinstimmt, das zuvor eine verdächtige Anmeldeaktivität aufwies. Dieser Wert kann darauf hinweisen, dass es Angriffe auf Credential Stuffing gibt, die dieser Anfrage ähnlich sind.

  • SUSPICIOUS_ACCOUNT_CREATION: Gibt an, dass die Anfrage mit einem Profil übereinstimmt, das zuvor ein verdächtiges Kontoerstellungsverhalten aufwies. Dieser Wert kann darauf hindeuten, dass dieses Konto gefälscht oder betrügerisch ist.

Prüfungen mit kontobezogenen Metadaten versehen

Annotieren Sie Ihre Prüfungen, um reCAPTCHA Enterprise-Account Defender zu aktivieren. Folgende Aktionen werden ausgeführt:

  • Analysiere alle Interaktionen mit einer bestimmten Kennung und gib korrekte Werte und Ursachencodes zurück.
  • Erstellen Sie ein websitespezifisches Modell für Angreifer auf Ihrer Website.

Wenn Sie eine Bewertung annotieren, müssen Sie die Annotationen für richtig positive und echt negative Ergebnisse bestätigen. Fügen Sie dazu den bekannten Ereignissen Labels hinzu. Das Ereignis, das beurteilt, ob die Anfrage legitim oder betrügerisch ist, sollte am besten mit einem Grund für die Bewertung versehen werden. Sie können aber auch ohne Grund Anmerkungen auf vorherige Bewertungen anwenden.

Wenn Sie eine Bewertung annotieren, senden Sie eine Anfrage an die Methode projects.assessments.annotate mit der Bewertungs-ID. Der Text der Anfrage enthält Labels, die zusätzliche Informationen zu einem Ereignis enthalten, das in der Bewertung beschrieben wird.

So können Sie eine Bewertung mit Anmerkungen versehen:

  1. Ermitteln Sie die Labels, die je nach Anwendungsfall im JSON-Text der Anfrage hinzugefügt werden sollen.

    In der folgenden Tabelle finden Sie Informationen zu Labels, mit denen Sie Anmerkungen mit Anmerkungen versehen können:

    Label Beschreibung Beispielanwendungsfall
    annotation

    Ein Label, das die Legitimität der Bewertungen angibt. Mögliche Werte sind LEGITIMATE und FRAUDULENT.

    Verwenden Sie dieses Label, wenn Sie die Legitimität wichtiger Aktionen wie die Anmeldung angeben möchten.

    Geben Sie den folgenden Anfrage-JSON-Text an, um anzugeben, dass ein Anmeldeereignis legitim war:

    
{
"annotation": "LEGITIMATE"
}
    reasons

    Ein Label zur Unterstützung Ihrer Bewertungen. Eine Liste möglicher Werte findest du unter Gründe für Werte.

    Verwenden Sie dieses Label, um Gründe anzugeben, die Ihre Annotationen unterstützen. Wir empfehlen die Verwendung von INCORRECT_PASSWORD für Anfragen, die für nicht vorhandene Konten gestellt wurden.

    • Verwenden Sie den folgenden JSON-Text für die Anfrage, um einen fehlgeschlagenen Anmeldeversuch zu unterscheiden:

      
{
"reasons": ["INCORRECT_PASSWORD"]
}

    • Verwende den folgenden Anfrage-JSON-Text, um anzugeben, dass ein Nutzer eine Bestätigung in zwei Schritten erfolgreich bestanden hat:

      
{
"annotation": "LEGITIMATE",
"reasons": ["PASSED_TWO_FACTOR"]
}
    hashedAccountId

    Ein Label, das einer gehashten Konto-ID ein Ereignis zugeordnet werden soll. Eine gehashte Konto-ID ist eine stabile, gehashte Nutzerkennung, die mit der SHA256-HMAC-Methode für ein Nutzerkonto auf Ihrer Website generiert wird.

    Wenn Sie eine Bewertung ohne gehashte Konto-ID erstellt haben, verwenden Sie dieses Label, um die gehashte Konto-ID eines Ereignisses anzugeben.

    Wenn Sie angeben möchten, dass ein Ereignis mit einer bestimmten Hash-Konto-ID verknüpft ist, verwenden Sie den folgenden JSON-Text für die Anfrage:

    
{
"hashedAccountId": "HASHED_ACCOUNT_ID"
}

  2. Erstellen Sie eine Anmerkungsanfrage mit den entsprechenden Labels.

    Bevor Sie eine der Anfragedaten verwenden, nehmen Sie folgende Ersetzungen vor:

    • ASSESSMENT_ID: Wert des Feldes name, das vom projects.assessments.create-Aufruf zurückgegeben wurde.
    • ANNOTATION: optional. Ein Label, das angibt, ob die Bewertung legitim oder betrügerisch ist.
    • REASONS: optional. Begründung Eine Liste möglicher Werte findest du unter Gründe für Werte.
    • HASHED_ACCOUNT_ID: optional. Eine stabile gehashte Nutzerkennung, die mit der SHA256-HMAC-Methode für ein Nutzerkonto auf Ihrer Website generiert wurde

    Weitere Informationen findest du 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,
  "hashedAccountId": HASHED_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 application-default 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 application-default 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

Java


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;

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";

    // hashedAccountId: Set the hashedAccountId corresponding to the assessment id.
    ByteString hashedAccountId = ByteString.copyFrom(new byte[] {});

    annotateAssessment(projectID, assessmentId, hashedAccountId);
  }

  /**
   * 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, ByteString hashedAccountId) 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)
              .setHashedAccountId(hashedAccountId)
              .build();

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

Weitere Informationen