Detecte e previna atividades fraudulentas relacionadas a contas em sites.

Neste documento, mostramos como usar o reCAPTCHA Account Defender para detectar e impedir atividades fraudulentas relacionadas a contas em sites.

O reCAPTCHA ajuda a proteger ações críticas, como login e finalização de compra. No entanto, há muitas formas sutis de abuso da conta que podem ser detectado pela observação do comportamento de um usuário específico em um site durante um período de tempo de resposta. O defensor de conta reCAPTCHA ajuda na identificação desses tipos de abuso sutil. Para isso, crie um modelo específico para seu site a fim de detectar um tendência de comportamento suspeito ou uma mudança na atividade. Ao usar a configuração o defensor de conta reCAPTCHA ajuda a detectar o seguinte:

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

Com base na análise do defensor da conta reCAPTCHA e do modelo específico do site, você pode realizar as seguintes ações:

  • Restringir ou desativar contas fraudulentas.
  • Evite tentativas de invasão de conta.
  • Reduzir as invasões de contas.
  • Conceda acesso apenas às solicitações provenientes de contas de usuários legítimas.
  • Reduza a fricção para os usuários que fazem login em um dos dispositivos confiáveis.

Antes de começar

  1. Prepare seu ambiente para o reCAPTCHA.
  2. Crie uma chave de site baseada em pontuação.

Configurar suas páginas da Web para o defensor de conta reCAPTCHA

O defensor da conta do reCAPTCHA exige um entendimento abrangente das atividades da conta para permitir uma detecção eficaz. Para iniciar a alimentação relacionadas à conta ao defensor da conta reCAPTCHA e criar e melhorar o modelo específico do site, faça o seguinte:

  1. Ative a coleta de dados de telemetria horizontal.
  2. Gere relatórios sobre ações críticas do usuário.
  3. Avalie eventos críticos do usuário.
  4. Faça anotações em eventos de usuário para ajustar o modelo específico do site.

Ativar a coleta de dados de telemetria horizontal

O defensor de conta reCAPTCHA exige uma visão completa do usuário como, por exemplo, se o usuário está ou não conectado. Para ativar coleta passiva de dados de telemetria horizontal pelo reCAPTCHA de defesa da conta, carregue o script JavaScript reCAPTCHA com a chave do site baseada em pontuação que você criou em segundo plano em todas as páginas da Web que fazem parte do fluxo de trabalho do usuário.

O exemplo a seguir mostra como carregar o script JavaScript reCAPTCHA em uma página da Web.

    <head>
    <script src="https://www.google.com/recaptcha/enterprise.js?render=KEY_ID"></script>
    ....
    </head>

Gerar relatórios sobre ações críticas do usuário

Detectar padrões de atividade suspeitos e entender melhor os padrões de atividade comuns no site, conta reCAPTCHA precisa de informações sobre ações críticas do usuário. Portanto, informe ações importantes do usuário nas páginas da Web chamando grecaptcha.enterprise.execute() nessas ações.

Recomendamos informar todas as ações críticas do usuário, porque isso ajuda na coleta de indicadores adicionais. Para cada ação do usuário que você quer informar, substitua o valor do parâmetro action de grecaptcha.enterprise.execute() por um nome de ação que descreva a ação do usuário.

A tabela a seguir lista os nomes de ações que podem ser usados para informar ações importantes do usuário.

Nome da ação Evento ou ação iniciada pelo usuário
LOGIN

Faça login no site.
REGISTRATION Cadastro no site.
SECURITY_QUESTION_CHANGE Solicitação para alterar a pergunta de segurança.
PASSWORD_RESET Solicite a redefinição da senha.
PHONE_NUMBER_UPDATE Solicitação para atualizar o número de telefone.
EMAIL_UPDATE Solicitação para atualizar o endereço de e-mail.
ACCOUNT_UPDATE Solicitação para atualizar informações relacionadas à conta, como detalhes de contato.
TRIGGER_MFA Uma ação que aciona um teste de MFA.
REDEEM_CODE Solicitação para resgatar o código.
LIST_PAYMENT_METHODS Busque a lista de formas de pagamento.

O exemplo abaixo mostra como chamar grecaptcha.enterprise.execute() em uma Atualização do número de telefone:

    <script>
    function onClick(e) {
      e.preventDefault();
      grecaptcha.enterprise.ready(async () => {
        const token = await grecaptcha.enterprise.execute('KEY_ID', {action: 'PHONE_NUMBER_UPDATE'});
      });
    }
    </script>

Avaliar eventos críticos do usuário

Quando você chama grecaptcha.enterprise.execute() em uma ação do usuário, ele gera um token. Para os eventos críticos do usuário, como logins bem-sucedidos e com falha, registros e ações dos usuários conectados, crie uma avaliação para avaliar os resultados da chamada grecaptcha.enterprise.execute(). O avaliação fornece um veredito de risco, que pode ser usado para tomar uma decisão sobre como lidar atividades potencialmente fraudulentas. O que você pode fazer é bloquear atividades a solicitações de dados, o desafio de logins arriscados e a investigação de contas de interesse.

O defensor da conta reCAPTCHA exige que você forneça um identificador de conta estável para atribui atividades do usuário, como solicitações de login, de login e de inscrição, a um conta específica. Isso ajuda o defensor da conta reCAPTCHA a entender a atividade do usuário padrões de atividade e criar um modelo de atividade para cada conta para detectar melhor problemas anômalos e abusivos do tráfego de entrada.

Escolha um identificador de conta estável accountId que não seja alterado com frequência pelo usuário e enviá-lo para a avaliação projects.assessments.create. Esse identificador de conta estável deve ter a o mesmo valor para todos os eventos relacionados ao mesmo usuário. Você pode fornecer o seguinte como identificador da conta:

Identificadores de usuários

Se cada conta puder ser associada exclusivamente a um nome de usuário, endereço de e-mail ou número de telefone estável, você poderá usá-lo como o accountId. Quando você fornece esse tipo de identificadores (identificadores que podem ser reutilizados entre sites), o reCAPTCHA utiliza esse para melhorar a proteção de suas contas de usuário com base em modelos entre sites ao sinalizar identificadores de conta abusivos e usar conhecimento de padrões de abuso entre sites relacionados a esses identificadores.

Como alternativa, se você tiver um ID de usuário interno associado exclusivamente a cada conta, poderá fornecê-lo como accountId.

Com hash ou criptografado

Se você não tiver um ID de usuário interno associado exclusivamente a cada conta, poderá transformar qualquer identificador estável em um identificador de conta opaco e específico do site. Esse identificador é ainda é necessário para que o defensor da conta reCAPTCHA entenda a atividade do usuário padrões e detectam comportamentos anômalos, mas eles não são compartilhados com outros sites.

Escolha qualquer identificador de conta estável e torne-o opaco antes de enviar ao reCAPTCHA. usando criptografia ou hash:

  • criptografia (recomendado): criptografe o identificador de conta usando uma expressão determinística. que produz um texto criptografado estável. Para instruções detalhadas, consulte Como criptografar dados de forma determinística. Quando você escolhe a criptografia simétrica em vez do hash, não precisa manter um mapeamento entre os identificadores de usuário e os identificadores opacos correspondentes. Descriptografar os identificadores opacos retornados pelo reCAPTCHA para transformá-los em identificador do usuário.

  • Geração de hash: recomendamos gerar hash do identificador da conta usando o método SHA256-HMAC com uma opção de sal personalizada. Como os hashes são unidirecionais, você precisa manter um mapeamento entre os hashes gerados e seus identificadores de usuário para que você possa mapear o hash identificador de conta retornado às contas originais.

Além de fornecer um identificador de conta estável para todas as solicitações relacionadas à conta, você pode fornecer outros identificadores de conta, potencialmente não estáveis, para algumas solicitações específicas. Os identificadores de conta específicos de contexto fornecidos além do accountId ajudam o defensor da conta do reCAPTCHA a entender melhor a atividade do usuário e detectar tentativas de invasão para manter as contas de usuário seguras. Quando você fornece identificadores adicionais, o reCAPTCHA usa essas informações para melhorar a proteção das suas contas de usuário com base em modelos entre sites, sinalizando identificadores de contas abusivas e usando o conhecimento de padrões de abuso entre sites relacionados a esses identificadores. Por exemplo, você pode fornecer o seguinte:

  • O nome de usuário, endereço de e-mail ou número de telefone usado como identificador de login para solicitações de login

  • O endereço de e-mail ou número de telefone verificado para uma solicitação de autenticação multifator

  • Um endereço de e-mail ou número de telefone (principal ou secundário) fornecido pelo usuário durante uma solicitação de atualização da conta

  • Os endereços de e-mail e números de telefone fornecidos pelo usuário durante uma solicitação de registro

Anexe o identificador de conta estável escolhido ao parâmetro accountId no projects.assessments.create para todas as solicitações relacionadas à conta. Opcionalmente, fornecer identificadores de conta adicionais para as solicitações relevantes usando o userIds; na avaliação.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: é o ID do projeto do Google Cloud.
  • TOKEN: token retornado da chamada grecaptcha.enterprise.execute()
  • KEY_ID: chave reCAPTCHA associada ao site
  • ACCOUNT_ID: o identificador associado exclusivamente à conta de usuário de um usuário no seu site
  • EMAIL_ADDRESS: opcional. Um endereço de e-mail associado a essa solicitação, se houver
  • PHONE_NUMBER: opcional. Um número de telefone associado a essa solicitação, se nenhum
  • USERNAME: opcional. Um nome de usuário associado a essa solicitação, se houver

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_ID",
    "userInfo": {
      "accountId": "ACCOUNT_ID",
      "userIds": [
        {
          "email": "EMAIL_ADDRESS"
        },
        {
          "phoneNumber": "PHONE_NUMBER"
        },
        {
          "username": "USERNAME"
        }
      ]
    }
  }
}

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

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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

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",
    "userInfo": {
      "accountId": "ACCOUNT_ID"
    }
  },
  "name": "projects/PROJECT_NUMBER/assessments/b6ac310000000000",
  "accountDefenderAssessment": {
    "labels": ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

Exemplo de código

Java

Para autenticar no reCAPTCHA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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;
  }
}

Interpretar o veredito de risco dos eventos críticos do usuário

Quando você cria uma avaliação com o defensor da conta ativado, retorna accountDefenderAssessment como parte da resposta da avaliação. O valor de accountDefenderAssessment ajuda você avalia se a atividade do usuário é legítima ou fraudulenta. Ele também retorna um ID de avaliação que você precisa usar ao anotar eventos do usuário.

Confira a seguir um exemplo de resposta JSON:

{
  "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_ID",
    "expectedAction": "USER_ACTION"
  },
  "name": "projects/PROJECT_ID/assessments/b6ac310000000000X",
  "accountDefenderAssessment": {
    labels: ["SUSPICIOUS_LOGIN_ACTIVITY"]
  }
}

O campo accountDefenderAssessment pode ter qualquer um destes valores:

Valor Descrição
SUSPICIOUS_LOGIN_ACTIVITY Indica que a solicitação representa um alto risco de preenchimento de credenciais ou de invasão de conta.
SUSPICIOUS_ACCOUNT_CREATION Indica que a solicitação representa uma alta o risco de criação de contas abusivas.
PROFILE_MATCH

Indica que os atributos do usuário correspondem aos atributos que foram vistos anteriormente para esse usuário. Esse valor é um indicador de que o usuário está em um dispositivo de confiança que foi usado antes para acessar seu site.

PROFILE_MATCH é retornado apenas nos seguintes cenários:

  • Você usa autenticação multifator (MFA) ou de dois fatores (2FA) e o reCAPTCHA Account Defender marca os perfis de usuário como confiáveis depois que os usuários passam no desafio de MFA ou 2FA.
  • Você anota as avaliações como LEGITIMATE ou PASSED_TWO_FACTOR e O defensor da conta reCAPTCHA marca o usuário correspondente como confiável.
RELATED_ACCOUNTS_NUMBER_HIGH Indica que a solicitação tem um número alto de contas relacionadas. Não significa necessariamente que a conta seja ruim, mas pode exigir uma investigação mais aprofundada.

Anotar eventos para ajustar o modelo específico do site

Para fornecer mais informações ao defensor da conta reCAPTCHA e melhorar seu modelo de detecção específico do site, você precisa anotar os eventos que que você avaliou criando avaliações.

Para anotar uma avaliação, envie uma solicitação ao método projects.assessments.annotate com o ID da avaliação. No corpo da solicitação, você inclui rótulos com mais informações sobre um evento descrito na avaliação.

Para fazer anotações em uma avaliação, faça o seguinte:

  1. Determinar as informações e rótulos a serem adicionados no corpo JSON da solicitação dependendo do caso de uso.

    A tabela a seguir lista os rótulos e valores que você pode usar para fazer anotações eventos:

    Rótulo Descrição Exemplo de solicitação
    reasons Obrigatório. Um rótulo para apoiar avaliações.

    Forneça detalhes do evento em tempo real no rótulo reasons alguns segundos ou minutos após o evento, porque eles influenciam a detecção em tempo real.

    Para a lista de valores possíveis, consulte valores de motivos.

    Exemplo: para detectar invasões de conta, anote se o a senha estava correta com CORRECT_PASSWORD ou INCORRECT_PASSWORD. Se você implantou sua própria MFA, é possível adicionar os seguintes valores: INITIATED_TWO_FACTOR e PASSED_TWO_FACTOR ou FAILED_TWO_FACTOR. 

          {
      "reasons": ["INCORRECT_PASSWORD"]
      }
    annotation Opcional. Um rótulo para indicar a legitimidade das avaliações.

    Forneça fatos sobre eventos de login e registro para validar ou corrigir suas avaliações de risco no rótulo annotation.

    Valores possíveis: LEGITIMATE ou FRAUDULENT.

    É possível enviar essas informações a qualquer momento ou como parte de uma job em lote. No entanto, recomendamos enviar essas informações alguns segundos ou minutos após o evento, porque elas influenciam a detecção em tempo real.

    		 
          {
       "annotation": "LEGITIMATE"
      }
    accountId

    Opcional. Um rótulo para associar um ID da conta a um evento.

    Se você criou uma avaliação sem um ID da conta, use esse rótulo para fornecer o ID da conta de um evento sempre que ele estiver disponível.

    		 
      {
   "accountId": "ACCOUNT_ID"
  }

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

    Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

    • ASSESSMENT_ID: valor do campo name retornado pela chamada projects.assessments.create.
    • ANNOTATION: opcional. Um rótulo que indica se a avaliação é legítima ou fraudulenta.
    • REASONS: opcional. Motivos que apoiam sua anotação. Para a lista de valores possíveis, consulte valores de motivos.
    • ACCOUNT_ID: opcional. o identificador exclusivo associado à conta do 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,
  "accountId": ACCOUNT_ID
}

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

    curl

    Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

    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

    Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

    $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

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

Exemplo de código

Java

Para autenticar no reCAPTCHA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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);
    }
  }
}

Ativar o defensor da conta do reCAPTCHA

Depois de configurar suas páginas da Web para o defensor da conta reCAPTCHA, ative o defensor da conta reCAPTCHA.

  1. No console do Google Cloud, acesse a página reCAPTCHA.

    Acessar o reCAPTCHA

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

    Se você não encontrar o nome do projeto, clique no seletor de recursos para selecioná-lo.

  3. Clique em Configurações.

  4. No painel Defensor da conta, clique em Configurar.

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

O defensor da conta reCAPTCHA pode levar algumas horas se propagam para nossos sistemas. Após a ativação do recurso propagadas para nossos sistemas, você deverá começar a receber respostas relacionadas à conta de segurança como parte das avaliações.

A seguir