Détecter et empêcher les activités frauduleuses liées aux comptes sur les applications mobiles

Ce document explique comment utiliser reCAPTCHA Account Defender pour détecter et empêcher les activités frauduleuses liées aux comptes dans les applications mobiles.

reCAPTCHA vous aide à protéger les actions critiques, telles que la connexion et le règlement. Cependant, de nombreuses formes subtiles d'abus de compte peuvent être détecté en observant le comportement d'un utilisateur spécifique sur une application mobile sur une période de en temps réel. Le service reCAPTCHA Account Defender permet d'identifier ces types d'abus subtils en créant un modèle spécifique au site pour votre application mobile afin de détecter d'un comportement suspect ou d'un changement d'activité. En utilisant la balise reCAPTCHA Account Defender vous aide à détecter les éléments suivants:

  • Activités suspectes
  • Comptes avec des comportements similaires
  • Requêtes provenant d'appareils marqués comme approuvés pour des utilisateurs spécifiques

En fonction de l'analyse de l'outil Account Defender de reCAPTCHA et du modèle spécifique au site, vous pouvez effectuer les actions suivantes :

  • Limitez ou désactivez les comptes frauduleux.
  • éviter les tentatives de piratage de compte ;
  • Limiter les piratages de compte réussis
  • Accordez l'accès uniquement aux requêtes provenant de comptes utilisateur légitimes.
  • Réduisez les frictions pour les utilisateurs qui se connectent à partir de l'un de leurs appareils approuvés.

Avant de commencer

  1. Pour bénéficier de Account Defender reCAPTCHA pour les applications mobiles, vous devez déclencher un examen de sécurité automatique en ajoutant un compte de facturation à votre projet. Ajouter un compte de facturation à votre projet pour intégrer cette fonctionnalité à votre site.
  2. Préparez votre environnement pour reCAPTCHA.
  3. Créez une clé basée sur des scores.

Configurer votre application mobile pour reCAPTCHA Account Defender

reCAPTCHA Account Defender requiert une compréhension approfondie les activités du compte afin d'assurer une détection efficace. Pour commencer à transmettre des activités liées au compte à l'outil Account Defender de reCAPTCHA, et pour créer et améliorer votre modèle spécifique à votre site, procédez comme suit :

  1. Intégrez reCAPTCHA à votre application mobile.

  2. Créez des rapports sur les actions critiques des utilisateurs.
  3. Évaluez les événements utilisateur critiques.
  4. Annotez des événements utilisateur pour ajuster le modèle spécifique à votre site.

Créer des rapports sur les actions critiques des utilisateurs

Pour détecter les activités suspectes et mieux comprendre tendances d'activité types sur votre site, compte reCAPTCHA défenseur a besoin d'informations sur les actions critiques des utilisateurs. Pour chaque action de votre application protégée par reCAPTCHA, appelez la méthode execute() avec RecaptchaAction. Pour en savoir plus sur execute() et RecaptchaAction, consultez les pages suivantes:

reCAPTCHA fournit un ensemble d'actions intégrées. Si nécessaire, vous pouvez créer des actions personnalisées.

Le tableau suivant répertorie les noms d'action que vous pouvez utiliser pour signaler les actions utilisateur critiques.

Nom de l'action Événement ou action déclenchés par l'utilisateur
LOGIN

Connectez-vous à l'application mobile.
SIGNUP

Inscrivez-vous sur l'application mobile.

Évaluer les événements utilisateur critiques

Lorsque vous appelez execute() sur une action utilisateur, un jeton est généré. Pour les plus critiques les événements utilisateur, tels que les connexions réussies et échouées, les inscriptions et les actions des utilisateurs connectés ; utilisateurs, créez une évaluation pour évaluer les résultats de l'appel execute(). L'évaluation vous fournit un avis sur le risque, que vous pouvez utiliser pour décider de la manière de gérer les activités potentiellement frauduleuses. Vous pouvez par exemple bloquer les requêtes suspectes, contester les connexions à risque et examiner les comptes qui vous intéressent.

reCAPTCHA Account Defender exige que vous fournissiez un identifiant de compte stable à attribuer l'activité des utilisateurs (demandes de connexion, de connexion et d'inscription, par exemple) à un un compte spécifique. Cela permet au défenseur de compte reCAPTCHA de comprendre les tendances d'activité des utilisateurs et de créer un modèle d'activité pour chaque compte afin de mieux détecter le trafic anormal et abusif.

Choisissez un identifiant de compte accountId stable qui n'est pas souvent modifié par l'utilisateur et fournissez-le à l'évaluation dans la méthode projects.assessments.create. Cet identifiant de compte stable doit être associé au la même valeur pour tous les événements liés au même utilisateur. Vous pouvez indiquer les éléments suivants comme compte identifiant:

Identifiants utilisateur

Si chaque compte peut être associé de manière unique à un nom d'utilisateur, une adresse e-mail ou un numéro de téléphone stables vous pouvez l'utiliser comme accountId. Lorsque vous fournissez de tels identifiants intersites (identifiants pouvant être réutilisés sur plusieurs sites), reCAPTCHA utilise ces informations pour améliorer la protection de vos comptes utilisateur en fonction de modèles intersites en signalant les identifiants de compte abusifs et en utilisant les connaissances sur les modèles d'abus intersites associés à ces identifiants.

Si vous disposez d'un ID utilisateur interne associé de manière unique à chaque compte, vous pouvez indiquez-le comme accountId.

Hachées ou chiffrées

Si aucun ID utilisateur interne n'est associé de manière unique à chaque compte, vous pouvez activer tout identifiant stable en un identifiant de compte opaque, spécifique au site. Cet identifiant est encore nécessaire pour permettre à reCAPTCHA Account Defender de comprendre l'activité des utilisateurs et de détecter les comportements anormaux. En revanche, ces données ne sont pas partagées avec les autres sites.

Choisissez un identifiant de compte stable et rendez-le opaque avant de l'envoyer à reCAPTCHA à l'aide du chiffrement ou du hachage :

  • Chiffrement (recommandé) : chiffrez l'identifiant de compte à l'aide d'une méthode de chiffrement déterministe qui produit un texte chiffré stable. Pour obtenir des instructions détaillées, consultez la section Chiffrer les données de manière déterministe. Lorsque vous choisissez le chiffrement symétrique plutôt que le hachage, vous n'avez pas besoin de conserver une mise en correspondance entre vos identifiants utilisateur et les identifiants utilisateur opaques correspondants. Déchiffrez les identifiants opaques renvoyés par reCAPTCHA pour les transformer en identifiant utilisateur.

  • Hachage : nous vous recommandons de hacher l'identifiant du compte à l'aide de la méthode SHA256-HMAC avec un sel personnalisé de votre choix. Étant donné que les hachages ne sont à sens unique que, vous devez conserver un mappage entre les hachages générés et vos identifiants utilisateur afin de pouvoir mapper l'identifiant de compte haché renvoyé aux comptes d'origine.

En plus de fournir un identifiant de compte stable pour toutes les requêtes liées au compte, vous pouvez fournir des identifiants de compte supplémentaires, potentiellement non stables, pour certaines requêtes spécifiques. Les identifiants de compte spécifiques au contexte fournis en plus de accountId aident l'outil Account Defender de reCAPTCHA à mieux comprendre l'activité des utilisateurs et à détecter les tentatives de prise de contrôle de compte afin de protéger vos comptes utilisateur. Lorsque vous fournissez des identifiants supplémentaires, reCAPTCHA utilise ces informations pour améliorer la protection de vos comptes utilisateur en fonction de des modèles intersites en signalant les identifiants de compte abusifs et en exploitant les connaissances sur les abus intersites. des schémas liés à ces identifiants. Par exemple, vous pouvez fournir les informations suivantes :

  • Nom d'utilisateur, adresse e-mail ou numéro de téléphone utilisés comme identifiant de connexion requêtes

  • L'adresse e-mail ou le numéro de téléphone validés pour une demande d'authentification multifacteur

  • Une adresse e-mail ou un numéro de téléphone (principal ou secondaire) fourni par l'utilisateur lors d'une demande de modification de compte

  • Adresses e-mail et numéros de téléphone fournis par l'utilisateur lors de l'inscription demander

Ajoutez l'identifiant de compte stable choisi au paramètre accountId dans projects.assessments.create pour toutes les demandes liées au compte. Éventuellement, fournir des identifiants de compte supplémentaires pour les demandes pertinentes à l'aide de l'userIds. lors de l'évaluation.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud
  • TOKEN : jeton renvoyé par l'appel execute()
  • KEY_ID : clé reCAPTCHA associée à l'application
  • ACCOUNT_ID: l'identifiant associé de manière unique au compte utilisateur pour un compte utilisateur à votre application
  • EMAIL_ADDRESS : facultatif. L'adresse e-mail associée à cette demande, si tout
  • PHONE_NUMBER : facultatif. Un numéro de téléphone associé à cette demande, si tout
  • USERNAME : facultatif. Un nom d'utilisateur associé à cette demande, le cas échéant

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

{
  "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"]
  }
}

Exemple de code

Java

Pour vous authentifier auprès de reCAPTCHA, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


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

Interpréter le résultat du risque des événements utilisateur critiques

Lorsque vous créez une évaluation avec le Défenseur de compte activé, il renvoie accountDefenderAssessment dans la réponse de l'évaluation. La valeur de accountDefenderAssessment aide vous déterminez si l’activité de l’utilisateur est légitime ou frauduleuse. Elle renvoie également un ID d'évaluation que vous devez utiliser pour annoter des événements utilisateur.

Voici un exemple de réponse JSON :

{
  "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"]
  }
}

Le champ accountDefenderAssessment peut avoir l'une des valeurs suivantes:

Valeur Description
SUSPICIOUS_LOGIN_ACTIVITY Indique que la requête représente un risque élevé du credential stuffing ou du piratage de compte.
SUSPICIOUS_ACCOUNT_CREATION Indique que la demande présente un risque élevé de création de compte abusif.
PROFILE_MATCH

Indique que les attributs de l'utilisateur correspondent aux attributs précédemment détectés pour cet utilisateur. Cette valeur indique que cet utilisateur se trouve sur un appareil approuvé qui a déjà été utilisé pour accéder à votre application mobile.

PROFILE_MATCH n'est renvoyé que dans les cas suivants:

  • Vous utilisez une authentification multifacteur(MFA) ou à deux facteurs(2FA). et reCAPTCHA Account Defender marque les profils utilisateur comme fiables après les utilisateurs réussissent l’authentification MFA ou 2FA.
  • Vous annotez les évaluations en tant que LEGITIMATE ou PASSED_TWO_FACTOR. Le service reCAPTCHA Account Defender marque l'utilisateur correspondant votre profil comme digne de confiance.

Annoter des événements pour ajuster votre modèle spécifique au site

Pour fournir plus d'informations à l'outil Account Defender de reCAPTCHA et améliorer votre modèle de détection spécifique à votre site, vous devez annoter les événements que vous avez évalués en créant des évaluations.

Pour annoter une évaluation, envoyez une requête à la méthode projects.assessments.annotate avec l'ID de l'évaluation. Dans le corps de cette requête, vous incluez des étiquettes en fournissant des informations supplémentaires sur un événement décrit dans l'évaluation.

Pour annoter une évaluation, procédez comme suit :

  1. Déterminer les informations et les étiquettes à ajouter dans le corps JSON de la requête selon votre cas d'utilisation.

    Le tableau suivant répertorie les étiquettes et les valeurs que vous pouvez utiliser pour annoter événements:

    Libellé Description Exemple de requête
    reasons Obligatoire. Un libellé pour étayer vos évaluations.

    Fournissez les détails des événements en temps réel dans la Libellé reasons quelques secondes ou minutes après l'événement car elles influencent la détection en temps réel.

    Pour la liste des valeurs possibles, voir reasons values.

    Exemple: Pour détecter les piratages de compte, annotez si les valeurs saisies le mot de passe était correct avec CORRECT_PASSWORD ou Valeurs INCORRECT_PASSWORD. Si vous avez déployé votre propre MFA, vous pouvez ajouter les valeurs suivantes : INITIATED_TWO_FACTOR, PASSED_TWO_FACTOR ou FAILED_TWO_FACTOR. 

          {
      "reasons": ["INCORRECT_PASSWORD"]
      }
    annotation Facultatif. Une étiquette indiquant la légitimité des évaluations.

    Fournissez des informations sur la connexion et d'inscription pour valider ou corriger vos évaluations des risques Libellé annotation.

    Valeurs possibles : LEGITIMATE ou FRAUDULENT.

    Vous pouvez envoyer ces informations à tout moment ou dans le cadre d'une tâche par lot. Toutefois, nous vous recommandons d'envoyer ces informations quelques secondes ou minutes après l'événement, car elles ont une incidence sur la détection en temps réel.

    		 
          {
       "annotation": "LEGITIMATE"
      }
    accountId

    Facultatif. Libellé permettant d'associer un ID de compte à un événement.

    Si vous avez créé une évaluation sans ID de compte, utilisez ce libellé pour indiquer le compte ID d'un événement, chaque fois qu'il est disponible.

    		 
      {
   "accountId": "ACCOUNT_ID"
  }

  2. Créez une requête d'annotation avec les libellés appropriés.

    Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

    • ASSESSMENT_ID: valeur du champ name renvoyé par l'appel projects.assessments.create.
    • ANNOTATION : facultatif. Libellé indiquant si l'évaluation est légitime ou frauduleuse
    • REASONS : facultatif. Raisons pour lesquelles votre annotation est justifiée. Pour obtenir la liste des valeurs possibles, consultez la section Valeurs de reasons.
    • ACCOUNT_ID : facultatif. Identifiant associé de manière unique au compte utilisateur de votre application.

    Pour en savoir plus, consultez des libellés pour les annotations.

    Méthode HTTP et URL : 

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

    Corps JSON de la requête : 

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

    Pour envoyer votre requête, choisissez l'une des options suivantes :

    curl

    Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

    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

    Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

    $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

    Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.

Exemple de code

Java

Pour vous authentifier auprès de reCAPTCHA, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


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);
    }
  }
}

Activer Account Defender pour reCAPTCHA

Après avoir configuré votre application mobile pour l'outil Account Defender de reCAPTCHA, vous pouvez l'activer.

  1. Dans la console Google Cloud, accédez à la page reCAPTCHA.

    Accéder à reCAPTCHA

  2. Vérifiez que le nom de votre projet apparaît dans le sélecteur de ressources en haut de la page.

    Si le nom de votre projet n'apparaît pas, cliquez sur le sélecteur de ressource, puis sélectionnez votre projet.

  3. Cliquez sur Paramètres.

  4. Dans le volet Account Defender, cliquez sur Configurer.

  5. Dans la boîte de dialogue Configure account Defender, cliquez sur Activer, puis cliquez sur Enregistrer.

La propagation de l'activation de Account Defender reCAPTCHA dans nos systèmes peut prendre quelques heures. Une fois l'activation de la fonctionnalité propagée dans nos systèmes, vous devriez commencer à recevoir des réponses liées au Défenseur de compte dans le cadre des évaluations.

Étape suivante