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

Ce document explique comment utiliser reCAPTCHA Account Defender pour détecter et prévenir les activités frauduleuses liées au compte 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'utilisation abusive de compte peuvent être détectées en observant le comportement d'un utilisateur spécifique sur une application mobile sur une période donnée. reCAPTCHA Account Defender permet d'identifier ces types d'abus subtils en créant un modèle spécifique au site pour que votre application mobile détecte une tendance de comportement suspect ou un changement d'activité. Grâce au modèle spécifique au site, reCAPTCHA Account Defender vous aide à détecter les éléments suivants:

• Activités suspectes
• Comptes avec des comportements similaires
• Demandes provenant d'appareils marqués comme fiables pour des utilisateurs spécifiques

Sur la base de l'analyse de reCAPTCHA Account Defender et du modèle spécifique au site, vous pouvez prendre les mesures suivantes:

• Limitez ou désactivez les comptes frauduleux.
• Empêchez les tentatives de piratage de compte.
• Limiter les piratages de compte
• N'accordez l'accès qu'aux demandes provenant de comptes utilisateur légitimes.
• Simplifiez la connexion des utilisateurs depuis l'un de leurs appareils vérifiés.

Avant de commencer

1. reCAPTCHA Account Defender pour les applications mobiles est accessible après un examen de sécurité. Contactez notre équipe commerciale 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 nécessite une compréhension complète des activités des comptes pour permettre une détection efficace. Pour commencer à alimenter les activités liées au compte dans reCAPTCHA Account Defender, ainsi que pour créer et améliorer le modèle spécifique à votre site, procédez comme suit:

1. Intégrez reCAPTCHA à votre application mobile.

   • Pour les applications Android, consultez Intégrer reCAPTCHA Enterprise aux applications Android.
   • Pour les applications iOS, consultez Intégrer reCAPTCHA Enterprise aux applications iOS.
2. Générez des rapports sur les actions critiques des utilisateurs.
3. Évaluez les événements utilisateur critiques.
4. Annotez les é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 modèles d'activité suspects et mieux comprendre les modèles d'activité typiques sur votre site, le défenseur de compte reCAPTCHA a besoin des 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:

• Android: execute() et RecaptchaAction
• iOS: execute() et RecaptchaAction

reCAPTCHA fournit un ensemble d'actions intégré et, 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 créer des rapports sur les actions critiques des utilisateurs.

Évaluer les événements utilisateur critiques

Lorsque vous appelez la méthode execute() pour une action de l'utilisateur, elle génère un jeton. Pour les événements utilisateur critiques, tels que les connexions réussies et échouées, les enregistrements et les actions des utilisateurs connectés, créez une évaluation pour évaluer les résultats de l'appel execute(). Cette évaluation vous fournit un verdict des risques, qui vous permet de prendre une décision sur la manière de gérer les activités potentiellement frauduleuses. Vous pouvez par exemple bloquer les demandes suspectes, contester les connexions risquées ou examiner les comptes qui vous intéressent.

reCAPTCHA Account Defender exige que vous fournissiez un identifiant de compte stable pour attribuer l'activité des utilisateurs à un compte spécifique, comme les requêtes de connexion, de connexion et d'inscription. Cela permet à reCAPTCHA Account Defender de comprendre les modèles 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 stable accountId 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 avoir la même valeur pour tous les événements liés au même utilisateur. Vous pouvez fournir les éléments suivants comme identifiant de compte:

En plus de fournir un identifiant de compte stable pour toutes les demandes liées au compte, vous pouvez fournir des identifiants de compte supplémentaires, potentiellement instables, pour certaines requêtes spécifiques. Les identifiants de compte spécifiques au contexte fournis en plus du accountId permettent à reCAPTCHA Account Defender de mieux comprendre l'activité des utilisateurs et de détecter les tentatives de piratage 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 sur la base de modèles intersites. Il signale les identifiants de compte abusifs et exploite les informations sur les schémas d'utilisation abusive sur plusieurs sites liés à ces identifiants. Par exemple, vous pouvez fournir les éléments suivants:

• Nom d'utilisateur, adresse e-mail ou numéro de téléphone utilisés comme identifiant pour les demandes de connexion

• Adresse e-mail ou numéro de téléphone validés pour une requête d'authentification multifacteur

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

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

Ajoutez l'identifiant de compte stable choisi au paramètre accountId dans la méthode projects.assessments.create pour toutes les requêtes liées au compte. Si vous le souhaitez, fournissez des identifiants de compte supplémentaires pour les requêtes pertinentes en utilisant le champ userIds dans l'évaluation.

Avant d'utiliser les données de requête, 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: identifiant associé de manière unique au compte utilisateur d'un compte utilisateur de votre application.
• EMAIL_ADDRESS : facultatif. Une adresse e-mail associée à cette demande, le cas échéant
• PHONE_NUMBER : facultatif. Un numéro de téléphone associé à cette requête, le cas échéant
• USERNAME : facultatif. Un nom d'utilisateur associé à cette requête, 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 -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

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

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 = "[email protected]";

    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 verdict du risque lié aux événements utilisateur critiques

Lorsque vous créez une évaluation avec Account Defender activé, Account Defender renvoie accountDefenderAssessment dans sa réponse. La valeur de accountDefenderAssessment vous aide à évaluer si l'activité de l'utilisateur est légitime ou frauduleuse. Il renvoie également un ID d'évaluation que vous devez utiliser lorsque vous annotez 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:

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

Pour fournir plus d'informations à reCAPTCHA Account Defender 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 d'évaluation. Dans le corps de la 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 informations et les étiquettes à ajouter dans le corps JSON de la requête en fonction de votre cas d'utilisation.

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

   Étiquette	Description	Exemple de requête
   reasons	Obligatoire. Une étiquette pour étayer vos évaluations. Fournissez des détails sur les événements en temps réel dans le libellé reasons quelques secondes ou minutes après l'événement, car ils influencent la détection en temps réel. Pour obtenir la liste des valeurs possibles, consultez la section Valeurs des motifs. Exemple: Pour détecter les piratages de compte, annotez le mot de passe saisi avec les valeurs CORRECT_PASSWORD ou INCORRECT_PASSWORD. Si vous avez déployé votre propre MFA, vous pouvez ajouter les valeurs suivantes: INITIATED_TWO_FACTOR, et PASSED_TWO_FACTOR ou FAILED_TWO_FACTOR.	{ "reasons": ["INCORRECT_PASSWORD"] }
   annotation	Facultatif. Libellé indiquant la légitimité des évaluations. Dans le libellé annotation, fournissez des informations sur les événements de connexion et d'enregistrement pour valider ou corriger vos évaluations des risques. Valeurs possibles: LEGITIMATE ou FRAUDULENT. Vous pouvez envoyer ces informations à tout moment ou dans le cadre d'un job par lot. Toutefois, nous vous recommandons d'envoyer ces informations dans les quelques secondes ou minutes qui suivent l'événement, car elles influencent 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 fournir l'ID d'un événement lorsqu'il est disponible.	{ "accountId": "ACCOUNT_ID" }

2. Créez une requête d'annotation avec les étiquettes appropriées.

   Avant d'utiliser les données de requête, 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 justifiant votre annotation. Pour obtenir la liste des valeurs possibles, consultez la section Valeurs des motifs.
   • ACCOUNT_ID : (facultatif) identifiant associé de manière unique au compte utilisateur de votre application.

   Pour en savoir plus, consultez la section Libellés des 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 et 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 et 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

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 reCAPTCHA Account Defender

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

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 vous ne voyez pas le nom de votre projet, cliquez sur le sélecteur de ressources, puis sélectionnez votre projet.

3. Cliquez sur settingsParamètres.

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

   

5. Dans la boîte de dialogue Configure Account Defender (Configurer Account Defender), cliquez sur Enable (Activer).

   

La propagation de la fonctionnalité reCAPTCHA Account Defender à nos systèmes peut prendre quelques heures. Une fois la fonctionnalité activée dans nos systèmes, vous devriez commencer à recevoir des réponses concernant Account Defender dans le cadre des évaluations.

Étapes suivantes

• Pour en savoir plus sur les autres fonctionnalités de protection des comptes, consultez Fonctionnalités de protection des comptes utilisateur.