Detecção e prevenção de atividades fraudulentas relacionadas à conta

Este documento mostra como usar o defensor da conta do reCAPTCHA Enterprise para detectar e impedir atividades fraudulentas relacionadas à conta.

O reCAPTCHA Enterprise ajuda a proteger ações importantes, como login e finalização da compra. No entanto, há muitas formas sutis de abuso de contas que podem ser detectadas pela observação de um comportamento específico do usuário no site durante um período. O defensor da conta do reCAPTCHA Enterprise ajuda a identificar esses tipos de abuso simplificado criando um modelo específico para o site a fim de detectar uma tendência de comportamento suspeito ou uma mudança na atividade. Usando o modelo específico do site, o defensor da conta do reCAPTCHA Enterprise ajuda você a detectar o seguinte:

  • Atividades suspeitas
  • Contas com comportamentos parecidos
  • Solicitações provenientes de dispositivos marcados como confiáveis para usuários específicos

Com base na análise do defensor da conta do reCAPTCHA Enterprise e do modelo específico do site, é possível fazer o seguinte:

  • restringir ou desativar contas fraudulentas;
  • Evite tentativas de invasão de conta.
  • Diminua a invasão de contas.
  • Permitir acesso apenas às solicitações provenientes de contas de usuário legítimas.
  • Simplifique o login dos usuários em um dispositivo confiável.

Antes de começar

Escolha o melhor método para configurar o reCAPTCHA Enterprise no ambiente e conclua a configuração.

Ativar a defesa de conta do reCAPTCHA Enterprise

  1. No console, acesse a página reCAPTCHA Enterprise.

    Acessar o reCAPTCHA Enterprise

  2. Verifique se o nome do seu projeto aparece no seletor de recursos na parte superior da página.

    Se o nome do seu projeto não for exibido, clique no seletor de recursos e escolha seu projeto.

  3. Clique em Configurações.

  4. No painel Defesa da conta, clique em Ativar.

  5. Na caixa de diálogo Configurar o defensor da conta, clique em Ativar.

Pode levar algumas horas para que a ativação do defensor da conta do reCAPTCHA Enterprise seja propagada para nossos sistemas. Depois que a ativação do recurso for propagada para nossos sistemas, você começará a receber respostas relacionadas ao defensor da conta como parte das avaliações.

Entenda o fluxo de trabalho

Para usar a defensa de conta do reCAPTCHA Enterprise, siga as seguintes etapas:

  1. Instale chaves de site com base em pontuação em clientes (páginas da Web ou aplicativos para dispositivos móveis).
  2. Crie avaliações usando hashedAccountId.
  3. Interprete os detalhes da avaliação.
  4. Anotar avaliações com metadados relacionados à conta.

Depois de concluir essas etapas, será possível identificar contas com comportamentos semelhantes.

Instalar chaves de site com base em pontuação nos clientes

Para usar a defensa de conta do reCAPTCHA Enterprise, instale chaves de site com base em pontuação nas páginas de login e registro seguindo as instruções específicas da plataforma:

Para resultados precisos, recomendamos instalar chaves de site com base em pontuação nas páginas exibidas antes e depois de ações importantes, como login e finalização da compra. Por exemplo, considere um fluxo de trabalho do cliente que inclua visitar a página inicial, a página de login e a página de recepção em um site. Nesse fluxo de trabalho, você protege a página de login instalando uma chave baseada em pontuação da página de login. Recomendamos instalar também chaves de site com base em pontuação nas páginas inicial e de boas-vindas para alcançar resultados precisos.

Quando você instala chaves de site baseadas em pontuação com ações únicas em várias páginas do site ou aplicativo para dispositivos móveis, o defensor da conta do reCAPTCHA Enterprise cria um modelo específico para o site com base no comportamento de contas legítimas e fraudulentas. Para saber como instalar chaves de site com base em pontuação com ações únicas, consulte Instalar chaves de site baseadas em pontuação para ações do usuário.

Criar avaliações usando o hashedAccountId

Crie avaliações para ações críticas. As ações críticas incluem logins bem-sucedidos e com falha, registros e outras ações dos usuários conectados.

Para criar uma avaliação usando hashedAccountId, faça o seguinte:

  1. Gere um identificador de usuário com hash estável exclusivo usando o método SHA256-HMAC para uma conta de usuário no seu site. Você pode gerar esse identificador com base em um ID de usuário, um nome de usuário ou um endereço de e-mail.

  2. Anexe o identificador de usuário com hash ao parâmetro hashedAccountId no método projects.assessments.create. hashedAccountId permite que o defensor da conta do reCAPTCHA Enterprise detecte contas fraudulentas e contas invadidas.

    Antes de usar qualquer um dos dados da solicitação, faça as seguintes substituições:

    • PROJECT_ID: é o ID do projeto do Google Cloud.
    • TOKEN: token retornado da chamada grecaptcha.enterprise.execute()
    • KEY: chave reCAPTCHA associada ao site/app
    • HASHED_ACCOUNT_ID: um identificador de usuário com hash estável gerado usando o método SHA256-HMAC para uma conta de usuário em seu site.

    Método HTTP e URL:

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

    Corpo JSON da solicitação:

    {
      "event": {
        "token": "TOKEN",
        "siteKey": "KEY",
        "hashedAccountId": "HASHED_ACCOUNT_ID"
      }
    }
    

    Para enviar a solicitação, escolha uma destas opções:

    curl

    Salve o corpo da solicitação em um arquivo chamado request.json e execute o seguinte comando:

    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

    Salve o corpo da solicitação em um arquivo chamado request.json e execute o seguinte comando:

    $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

    Você receberá uma resposta JSON semelhante a esta:

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

Exemplo de código

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

Interpretar os detalhes da avaliação

Depois de criar uma avaliação, você receberá uma resposta como o exemplo JSON a seguir. O defensor da conta do reCAPTCHA Enterprise retorna accountDefenderAssessment como parte da resposta de avaliação. O valor de accountDefenderAssessment ajuda a avaliar se a atividade do usuário é legítima ou fraudulenta.

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

O campo accountDefenderAssessment pode ter qualquer um dos seguintes valores:

  • PROFILE_MATCH: indica que os atributos do usuário correspondem aos atributos vistos anteriormente desse usuário específico. Esse valor é um indicador de que esse usuário está em um dispositivo confiável usado antes para acessar seu site.

    PROFILE_MATCH é retornado apenas nos seguintes cenários:

    • Você usa a autenticação multifator(MFA) ou autenticação de dois fatores(2FA), e o defensor da conta do reCAPTCHA Enterprise marca os perfis de usuário como confiáveis depois que os usuários passam no desafio MFA ou 2FA.

    • As anotações são avaliadas como LEGITIMATE, e o defensor da conta do reCAPTCHA Enterprise marca o perfil de usuário correspondente como confiável.

  • SUSPICIOUS_LOGIN_ACTIVITY: indica que a solicitação correspondeu a um perfil que teve uma atividade de login suspeita anteriormente. Esse valor pode indicar que houve ataques de preenchimento de credenciais semelhantes a essa solicitação.

  • SUSPICIOUS_ACCOUNT_CREATION: indica que a solicitação correspondeu a um perfil que tinha um comportamento de criação de conta suspeito. Esse valor pode indicar que essa conta é falsa ou fraudulenta.

Anotar avaliações com metadados relacionados à conta

Anote as avaliações para permitir que o defensor da conta do reCAPTCHA Enterprise execute as seguintes ações:

  • Analise todas as interações com um identificador específico e retorne pontuações e códigos de motivo precisos.
  • Crie um modelo específico de invasor no seu site.

Ao inserir uma avaliação, confirme as anotações de verdadeiros positivos e negativos reais adicionando rótulos aos eventos conhecidos. É melhor anotar o evento que avalia se a solicitação é legítima ou fraudulenta e incluir o motivo da avaliação. No entanto, também é possível aplicar anotações a qualquer avaliação anterior sem um motivo.

Ao fazer anotações em uma avaliação, você envia uma solicitação para o método projects.assessments.annotate com o ID da avaliação. No corpo dessa solicitação, inclua rótulos que forneçam informações adicionais sobre um evento descrito na avaliação.

Para anotar uma avaliação, faça o seguinte:

  1. Determine os identificadores a serem adicionados ao corpo JSON da solicitação, dependendo do caso de uso.

    A tabela a seguir ajuda a entender os rótulos que podem ser usados para fazer anotações:

    Rótulo Descrição Amostra de caso de uso
    annotation

    Uma etiqueta para indicar a legitimidade das avaliações. Os valores possíveis são LEGITIMATE ou FRAUDULENT.

    Use esse rótulo quando quiser indicar a legitimidade das ações importantes, como o login.

    Para indicar que um evento de login foi legítimo, use o seguinte corpo JSON da solicitação:

    
    {
    "annotation": "LEGITIMATE"
    }
    
    reasons

    Uma etiqueta para apoiar suas avaliações Para ver a lista de valores possíveis, consulte Valores de motivo.

    Use esse rótulo para informar os motivos que dão suporte às anotações de ações críticas. Recomendamos o uso de INCORRECT_PASSWORD para solicitações feitas para contas que não existem.

    • Para diferenciar uma tentativa de login malsucedida, use o seguinte corpo JSON de solicitação:

      
      {
      "reasons": ["INCORRECT_PASSWORD"]
      }
      
    • Para indicar que um usuário foi aprovado em um desafio de dois fatores, use o seguinte corpo JSON de solicitação:

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

    Um rótulo para associar um ID de conta com hash a um evento. Um ID de conta com hash é um identificador de usuário estável com hash gerado usando o método SHA256-HMAC para uma conta de usuário no seu site.

    Se você criou uma avaliação sem um ID de conta com hash, use esse rótulo para fornecer o ID da conta com hash de um evento.

    Para indicar que um evento está associado a um determinado ID de conta com hash, use o seguinte corpo JSON da solicitação:

    
    {
    "hashedAccountId": "HASHED_ACCOUNT_ID"
    }
    

  2. Crie uma solicitação de anotação com os rótulos apropriados.

    Antes de usar qualquer um dos dados da solicitação, faça as seguintes substituições:

    • ASSESSMENT_ID: valor do campo name retornado da chamada projects.assessments.create.
    • ANNOTATION: opcional. Uma etiqueta para indicar se a avaliação é legítima ou fraudulenta.
    • REASONS: opcional. Motivos que dão suporte à anotação. Para ver a lista de valores possíveis, consulte Valores de motivo.
    • HASHED_ACCOUNT_ID: opcional. Um identificador de usuário com hash estável gerado usando o método SHA256-HMAC para uma conta de usuário no seu site.

    Para mais informações, consulte Rótulos para anotações.

    Método HTTP e URL:

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

    Corpo JSON da solicitação:

    {
      "annotation": ANNOTATION,
      "reasons": REASONS,
      "hashedAccountId": HASHED_ACCOUNT_ID
    }
    

    Para enviar a solicitação, escolha uma destas opções:

    curl

    Salve o corpo da solicitação em um arquivo chamado request.json e execute o seguinte comando:

    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

    Salve o corpo da solicitação em um arquivo chamado request.json e execute o seguinte comando:

    $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

    Você receberá um código de status bem-sucedido (2xx) e uma resposta vazia.

Exemplo de código

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

A seguir