Détection et prévention des activités frauduleuses liées au compte

Ce document explique comment utiliser reCAPTCHA Enterprise Account Defender pour détecter et empêcher les activités frauduleuses liées à un compte.

reCAPTCHA Enterprise vous aide à protéger les actions critiques, telles que la connexion et le règlement. Toutefois, de nombreuses formes subtiles d'utilisation abusive des comptes peuvent être détectées en observant un comportement spécifique des utilisateurs sur un site dans le temps. L'outil reCAPTCHA Enterprise aide à identifier ces types d'abus subtils en créant un modèle spécifique à votre site Web afin de détecter une tendance de comportement suspect ou une modification de l'activité. À l'aide du modèle spécifique au site, reCAPTCHA Enterprise Account Defender vous permet de 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

D'après l'analyse du responsable de compte reCAPTCHA Enterprise et du modèle spécifique à un site, vous pouvez effectuer les opérations suivantes:

  • Limitez ou désactivez les comptes frauduleux.
  • Empêcher les tentatives de piratage de compte.
  • Limitez les piratages de comptes.
  • Accordez l'accès uniquement aux requêtes provenant de comptes utilisateur légitimes.
  • Proposez une expérience plus fluide aux utilisateurs se connectant depuis l'un de leurs appareils vérifiés.

Avant de commencer

Choisissez la meilleure méthode pour configurer reCAPTCHA Enterprise dans votre environnement et terminez la configuration.

Activer reCAPTCHA Enterprise Account Defender

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

    Accéder à la page reCAPTCHA Enterprise

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

    Si vous ne voyez pas le nom de votre projet, cliquez sur le sélecteur de ressources, puis sélectionnez votre projet.

  3. Cliquez sur Paramètres.

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

  5. Dans la boîte de dialogue Configurer votre compte Defender, cliquez sur Activer.

La propagation des modifications dans nos systèmes peut prendre quelques heures. Une fois la fonctionnalité activée dans nos systèmes, vous devriez commencer à recevoir des réponses liées au responsable de compte lors des évaluations.

Comprendre le workflow

Pour utiliser reCAPTCHA Enterprise Account Defender, procédez comme suit:

  1. Installez des clés de site basées sur des scores pour les clients (pages Web ou applications mobiles).
  2. Créez des évaluations à l'aide de hashedAccountId.
  3. Interprétez les détails de l'évaluation.
  4. Annotez les évaluations avec les métadonnées liées au compte.

Après avoir suivi cette procédure, vous pouvez éventuellement identifier les comptes ayant des comportements similaires.

Installer des clés de site basées sur des scores pour les clients

Pour utiliser reCAPTCHA Enterprise Account Defender, installez les clés de site basées sur des scores sur les pages de connexion et d'inscription en suivant les instructions spécifiques à la plate-forme:

Pour obtenir des résultats précis, nous vous recommandons d'installer des clés de site basées sur les scores sur les pages qui s'affichent avant et après les actions critiques telles que la connexion et le règlement. Prenons l'exemple d'un workflow de client qui comprend la page d'accueil, la page de connexion et la page d'accueil d'un site Web. Dans ce workflow, vous protégez la page de connexion en installant une clé de site basée sur le score sur la page de connexion. Nous vous recommandons d'installer également des clés de site basées sur les scores sur la page d'accueil et d'accueil afin d'obtenir des résultats précis.

Lorsque vous installez des clés de site basées sur des scores avec des actions uniques sur différentes pages de votre site Web ou de votre application mobile, reCAPTCHA Enterprise Account Defender crée un modèle personnalisé spécifique à un site en fonction des comportements des comptes légitimes et frauduleux. Pour savoir comment installer des clés de site basées sur les scores avec des actions uniques, consultez la section Installer des clés de site basées sur les scores pour les actions des utilisateurs.

Créer des évaluations à l'aide de hashedAccountId

Évaluez les actions critiques. Les actions critiques incluent les échecs de connexion, les enregistrements et les actions supplémentaires des utilisateurs connectés.

Pour créer une évaluation à l'aide de hashedAccountId, procédez comme suit:

  1. Générez un identifiant utilisateur stable et haché à l'aide de la méthode SHA256-HMAC pour un compte utilisateur sur votre site Web. Vous pouvez générer cet identifiant à partir d'un ID utilisateur, d'un nom d'utilisateur ou d'une adresse e-mail.

  2. Ajoutez l'identifiant utilisateur haché au paramètre hashedAccountId dans la méthode projects.assessments.create. hashedAccountId permet à reCAPTCHA Enterprise Account Defender de détecter les comptes frauduleux et les comptes piratés.

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

    • PROJECT_ID : ID de votre projet Google Cloud
    • TOKEN : jeton renvoyé par l'appel grecaptcha.enterprise.execute()
    • KEY : clé reCAPTCHA associée au site ou à l'application
    • HASHED_ACCOUNT_ID: identifiant utilisateur stable et haché, généré à l'aide de la méthode SHA256-HMAC pour un compte utilisateur sur votre site Web

    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",
    "hashedAccountId": "HASHED_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 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

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

    $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

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

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

Exemple de code

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

Interpréter les détails de l'évaluation

Après avoir créé une évaluation, vous recevez une réponse semblable à l'exemple de code JSON suivant. Le reCAPTCHA Enterprise Account Defender renvoie accountDefenderAssessment dans le cadre de la réponse d'évaluation. La valeur de l'attribut accountDefenderAssessment vous aide à déterminer si l'activité de l'utilisateur est légitime ou frauduleuse.

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

Le champ accountDefenderAssessment peut présenter l'une des valeurs suivantes:

  • PROFILE_MATCH: indique que les attributs de l'utilisateur correspondent aux attributs précédemment affichés pour cet utilisateur. Cette valeur indique que l'utilisateur se trouve sur un appareil vérifié qui a été utilisé avant d'accéder à votre site Web.

    PROFILE_MATCH n'est renvoyé que dans les scénarios suivants:

    • Vous utilisez Multifacteur(MFA) ou authentification à deux facteurs(2FA), et reCAPTCHA Enterprise Account Defender marque les profils utilisateur comme étant approuvés après que les utilisateurs ont réussi le test MFA ou 2FA.

    • Vous annotez les évaluations en tant que LEGITIMATE, et le titulaire du compte reCAPTCHA Enterprise marque le profil utilisateur correspondant comme étant de confiance.

  • SUSPICIOUS_LOGIN_ACTIVITY : indique que la requête correspond à un profil dont l'activité de connexion était auparavant suspecte. Cette valeur peut indiquer que des attaques de credential stuffing ont été similaires à cette requête.

  • SUSPICIOUS_ACCOUNT_CREATION: indique que la requête correspond à un profil dont le comportement de création de compte était auparavant suspect. Cette valeur peut indiquer que ce compte est fictif ou frauduleux.

Annoter les évaluations avec les métadonnées associées au compte

Annotez vos évaluations pour permettre à reCAPTCHA Enterprise Account Defender d'effectuer les actions suivantes:

  • Analysez toutes les interactions avec un identifiant spécifique, et renvoyez des scores et des codes de justification exacts.
  • Créez un modèle spécifique aux pirates informatiques sur votre site.

Lorsque vous annotez une évaluation, confirmez les annotations pour les vrais positifs et les vrais négatifs en ajoutant des libellés aux événements connus. Il est préférable d'annoter l'événement qui évalue si la requête est légitime ou frauduleuse, et d'inclure le motif de l'évaluation. Toutefois, vous pouvez également appliquer des annotations à toutes les évaluations précédentes, sans aucune raison.

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

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

  1. Déterminez les étiquettes à ajouter dans le corps de la requête JSON, en fonction de votre cas d'utilisation.

    Le tableau suivant vous aide à comprendre les étiquettes que vous pouvez utiliser pour annoter des évaluations:

    Étiquette Description Exemple de cas d'utilisation
    annotation

    Libellé indiquant la légitimité des évaluations. Les valeurs possibles sont LEGITIMATE et FRAUDULENT.

    Utilisez ce libellé lorsque vous souhaitez spécifier la légitimité d'actions critiques telles que la connexion.

    Pour indiquer qu'un événement de connexion est légitime, utilisez le corps JSON de la requête suivante:

    
{
"annotation": "LEGITIMATE"
}
    reasons

    Libellé pour appuyer vos évaluations. Pour obtenir la liste des valeurs possibles, consultez la section Valeurs des motifs.

    Ce libellé permet de justifier les actions critiques. Nous vous recommandons d'utiliser INCORRECT_PASSWORD pour les requêtes effectuées pour des comptes qui n'existent pas.

    • Pour différencier une tentative de connexion ayant échoué, utilisez le corps JSON de la requête suivant:

      
{
"reasons": ["INCORRECT_PASSWORD"]
}

    • Pour indiquer qu'un utilisateur a réussi une question à deux facteurs, utilisez le corps JSON de la requête suivante:

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

    Libellé permettant d'associer un ID de compte haché à un événement. Un ID de compte haché est un identifiant utilisateur stable généré à l'aide de la méthode SHA256-HMAC pour un compte utilisateur sur votre site Web.

    Si vous avez créé une évaluation sans ID de compte haché, utilisez ce libellé pour fournir le numéro de compte haché d'un événement.

    Pour indiquer qu'un événement est associé à un identifiant de compte haché donné, utilisez le corps de requête JSON suivant:

    
{
"hashedAccountId": "HASHED_ACCOUNT_ID"
}

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

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

    • ASSESSMENT_ID: valeur du champ name renvoyée 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 acceptée. Pour obtenir la liste des valeurs possibles, consultez la section Valeurs des motifs.
    • HASHED_ACCOUNT_ID : facultatif. Un identifiant utilisateur haché et stable, généré à l'aide de la méthode SHA256-HMAC pour un compte utilisateur sur votre site Web

    Pour en savoir plus, consultez la section 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,
  "hashedAccountId": HASHED_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 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

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

    $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

    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


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

Étapes suivantes