Detección y prevención de actividades fraudulentas relacionadas con la cuenta

En este documento, se muestra cómo usar el defensor de la cuenta de reCAPTCHA Enterprise para detectar y evitar actividades fraudulentas relacionadas con la cuenta.

reCAPTCHA Enterprise te ayuda a proteger acciones críticas, como el acceso y la confirmación de la compra. Sin embargo, existen muchas formas sutiles de abuso en las cuentas que se pueden detectar si se observa el comportamiento de un usuario específico en el sitio durante un período. El defensor de cuentas de reCAPTCHA Enterprise permite identificar estos tipos de abusos sutiles mediante la creación de un modelo específico del sitio para que tu sitio web detecte una tendencia de comportamiento sospechoso o un cambio de actividad. Si usas el modelo específico del sitio, el defensor de la cuenta de reCAPTCHA Enterprise te ayudará a detectar lo siguiente:

  • Actividades sospechosas
  • Cuentas con comportamientos similares
  • Solicitudes provenientes de dispositivos marcados como de confianza para usuarios específicos

Según el análisis del defensor de la cuenta de reCAPTCHA Enterprise y el modelo específico del sitio, puedes hacer lo siguiente:

  • Restringe o inhabilita cuentas fraudulentas.
  • Evite los intentos de apropiación de cuentas.
  • Mitigue las apropiaciones de cuentas exitosas.
  • Otorgue acceso solo a las solicitudes provenientes de cuentas de usuario legítimas.
  • Reduce la fricción para los usuarios que acceden desde uno de sus dispositivos de confianza.

Antes de comenzar

Elige el mejor método para configurar reCAPTCHA Enterprise en tu entorno y completa la configuración.

Habilitar el defensor de la cuenta de reCAPTCHA Enterprise

  1. En Google Cloud Console, ve a la página reCAPTCHA Enterprise.

    Ir a reCAPTCHA Enterprise

  2. Verifica que el nombre de tu proyecto aparezca en el selector de recursos en la parte superior de la página.

    Si no ves el nombre de tu proyecto, haz clic en el selector de recursos y, luego, selecciona tu proyecto.

  3. Haz clic en Configuración.

  4. En el panel Defensor de la cuenta, haz clic en Habilitar.

  5. En el diálogo Configure account defender, haz clic en Enable.

Es posible que la habilitación del defensor de cuentas de reCAPTCHA Enterprise tarde unas horas en propagarse a nuestros sistemas. Después de que la habilitación de funciones se propague a nuestros sistemas, debes comenzar a recibir respuestas relacionadas con el defensor de la cuenta como parte de las evaluaciones.

Comprende el flujo de trabajo

Para usar el defensor de la cuenta de reCAPTCHA Enterprise, sigue estos pasos:

  1. Instala claves de sitios basadas en puntuaciones en los clientes (páginas web o aplicaciones para dispositivos móviles).
  2. Crea evaluaciones con hashedAccountId.
  3. Interpreta los detalles de la evaluación.
  4. Anota las evaluaciones con metadatos relacionados con la cuenta.

Después de completar estos pasos, tiene la opción de identificar las cuentas con comportamientos similares.

Instala claves de sitios basadas en puntuaciones en los clientes

Para usar el defensor de la cuenta de reCAPTCHA Enterprise, instala claves de sitio basadas en la puntuación en las páginas de acceso y de registro. Para ello, sigue las instrucciones específicas de la plataforma:

Para obtener resultados precisos, te recomendamos que instales claves de sitios basadas en la puntuación en las páginas que aparecen antes y después de acciones importantes, como las de acceso y confirmación de compras. Por ejemplo, considera un flujo de trabajo de cliente que incluye visitar la página principal, la página de acceso y la página de bienvenida en un sitio web. En este flujo de trabajo, debes proteger la página de acceso mediante la instalación de una clave de sitio basada en puntuaciones. Te recomendamos que instales claves de sitio basadas en puntuaciones en la página principal y en la de bienvenida para obtener resultados precisos.

Cuando instalas claves de sitios basadas en puntuaciones con acciones únicas en varias páginas de tu sitio web o aplicación para dispositivos móviles, el defensor de cuentas de reCAPTCHA Enterprise crea un modelo personalizado específico del sitio basado en los comportamientos de las cuentas legítimas y fraudulentas. Para aprender a instalar claves de sitio basadas en puntuaciones con acciones únicas, consulta cómo instalar claves de sitios basadas en puntuaciones para acciones de usuarios.

Crear evaluaciones con hashedAccountId

Crea evaluaciones para las acciones críticas. Entre las acciones críticas, se incluyen los accesos exitosos y fallidos, los registros y las acciones adicionales de los usuarios que accedieron.

Para crear una evaluación con hashedAccountId, haz lo siguiente:

  1. Genera un identificador de usuario con hash estable único mediante el método SHA256-HMAC para una cuenta de usuario en tu sitio web. Puedes generar este identificador desde un ID de usuario, un nombre de usuario o una dirección de correo electrónico.

  2. Agrega el identificador de usuario con hash al parámetro hashedAccountId en el método projects.assessments.create. hashedAccountId permite que el defensor de la cuenta de reCAPTCHA Enterprise detecte cuentas fraudulentas y usurpadas.

    Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

    • PROJECT_ID: El ID del proyecto de Google Cloud.
    • TOKEN: Token que se muestra a partir de la llamada grecaptcha.enterprise.execute()
    • KEY: Clave reCAPTCHA asociada con el sitio/aplicación
    • HASHED_ACCOUNT_ID: un identificador de usuario con hash estable generado mediante el método SHA256-HMAC para una cuenta de usuario en tu sitio web

    HTTP method and URL: 

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

    Cuerpo JSON de la solicitud: 

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

    Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

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

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

Interprete los detalles de la evaluación

Después de crear una evaluación, recibirás una respuesta como la del siguiente ejemplo de JSON. El defensor de la cuenta de reCAPTCHA Enterprise muestra accountDefenderAssessment como parte de la respuesta de la evaluación. El valor de accountDefenderAssessment te ayuda a evaluar si la actividad del usuario es legítima o 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"]
  }
}

El campo accountDefenderAssessment puede tener cualquiera de los siguientes valores:

  • PROFILE_MATCH: Indica que los atributos del usuario coinciden con los atributos que se vieron anteriormente para este usuario en particular. Este valor indica que este usuario está en un dispositivo de confianza que se usó antes para acceder a tu sitio web.

    PROFILE_MATCH solo se muestra en las siguientes situaciones:

    • Usas la autenticación de dos factores(MFA) o la autenticación de dos factores(2FA), y el defensor de cuentas de reCAPTCHA Enterprise marca los perfiles de usuario como de confianza después de que los usuarios pasan el desafío de MFA o 2FA.

    • Las anotaciones se pueden evaluar como LEGITIMATE, y el defensor de la cuenta reCAPTCHA Enterprise marca el perfil de usuario correspondiente como de confianza.

  • SUSPICIOUS_LOGIN_ACTIVITY: Indica que la solicitud coincidió con un perfil que antes tenía una actividad de acceso sospechosa. Este valor podría indicar que hubo ataques de uso excesivo de credenciales similares a esta solicitud.

  • SUSPICIOUS_ACCOUNT_CREATION: Indica que la solicitud coincidió con un perfil que antes tenía un comportamiento de creación de cuenta sospechoso. Este valor podría indicar que esta cuenta es falsa o fraudulenta.

Anotar evaluaciones con metadatos relacionados con la cuenta

Anota tus evaluaciones para permitir que el defensor de la cuenta de reCAPTCHA Enterprise realice las siguientes acciones:

  • Analiza todas las interacciones con un identificador específico y muestra puntuaciones precisas y códigos de motivo.
  • Crea un modelo específico para los atacantes.

Cuando anotes una evaluación, confirma las anotaciones de verdaderos positivos y negativos verdaderos agregando etiquetas a los eventos conocidos. Lo mejor es anotar el evento que evalúa si la solicitud es legítima o fraudulenta y, luego, incluir el motivo de la evaluación. Sin embargo, también puedes aplicar anotaciones a cualquier evaluación anterior sin una razón.

Cuando anotas una evaluación, envías una solicitud al método projects.assessments.annotate con el ID de evaluación. En el cuerpo de la solicitud, incluye etiquetas con información adicional sobre un evento que se describe en la evaluación.

Para anotar una evaluación, haz lo siguiente:

  1. Determina las etiquetas que deseas agregar al cuerpo de JSON de la solicitud según tu caso de uso.

    La siguiente tabla te ayudará a comprender las etiquetas que puedes usar para anotar las evaluaciones:

    Etiqueta Descripción Caso práctico de muestra
    annotation

    Una etiqueta que indica la legitimidad de las evaluaciones. Los valores posibles son LEGITIMATE o FRAUDULENT.

    Úsala cuando quieras indicar la legitimidad de acciones críticas, como el acceso.

    Para indicar que un evento de acceso fue legítimo, usa el siguiente cuerpo de solicitud JSON de JSON:

    
{
"annotation": "LEGITIMATE"
}
    reasons

    Una etiqueta que respalda tus evaluaciones. Para obtener una lista de valores posibles, consulta valores de motivos.

    Usa esta etiqueta para proporcionar motivos que admitan tus anotaciones de acciones críticas. Recomendamos usar INCORRECT_PASSWORD en las solicitudes que se realizan para cuentas que no existen.

    • Para diferenciar un intento de acceso fallido, usa el siguiente cuerpo de solicitud JSON de JSON:

      
{
"reasons": ["INCORRECT_PASSWORD"]
}

    • Para indicar que un usuario aprobó correctamente un desafío de dos factores, usa el siguiente cuerpo de solicitud JSON:

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

    Una etiqueta para asociar un ID de cuenta con hash a un evento. Un ID de cuenta con hash es un identificador de usuario con hash estable que se genera mediante el método SHA256-HMAC para una cuenta de usuario en tu sitio web.

    Si creaste una evaluación sin un ID de cuenta con hash, usa esta etiqueta para proporcionar el ID de cuenta con hash de un evento.

    Para indicar que un evento está asociado con un ID de cuenta con hash determinado, usa el siguiente cuerpo de solicitud JSON:

    
{
"hashedAccountId": "HASHED_ACCOUNT_ID"
}

  2. Crea una solicitud de anotación con las etiquetas apropiadas.

    Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

    • ASSESSMENT_ID: El valor del campo name que se muestra en la llamada projects.assessments.create.
    • ANNOTATION: Opcional. Una etiqueta que indica si la evaluación es legítima o fraudulenta.
    • REASONS: Opcional. Motivos que admiten tu anotación. Para obtener una lista de valores posibles, consulta valores de motivos.
    • HASHED_ACCOUNT_ID: Opcional. Identificador de usuario con hash estable que se genera con el método SHA256-HMAC para una cuenta de usuario en tu sitio web

    Para obtener más información, consulta Etiquetas para anotaciones.

    HTTP method and URL: 

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

    Cuerpo JSON de la solicitud: 

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

    Deberías recibir un código de estado exitoso (2xx) y una respuesta vacía.

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

¿Qué sigue?