Detectar contraseñas filtradas y credenciales vulneradas

En esta página se describe cómo usar la función de protección de contraseñas de reCAPTCHA para detectar filtraciones de contraseñas y credenciales vulneradas, y así evitar las apropiaciones de cuentas (ATOs) y los ataques de relleno de credenciales. Con reCAPTCHA, puedes realizar auditorías periódicas de las credenciales de los usuarios (contraseñas) como parte de cualquier evaluación para asegurarte de que no se hayan filtrado ni vulnerado. Para llevar a cabo estas evaluaciones, Google usa la función Verificación de contraseñas.

Importante: La defensa de contraseñas usa la computación multipartita segura (MPC) para proteger los datos de los usuarios. Solicitar comprobaciones de contraseñas puede provocar una latencia adicional al crear una evaluación. Aunque el tiempo de respuesta es mucho más rápido, te recomendamos que utilices un 500ms tiempo de espera al crear una evaluación con Protección de contraseñas.

Antes de empezar

1. Prepara tu entorno para reCAPTCHA.

2. Configura reCAPTCHA.

3. Verify that billing is enabled for your Google Cloud project.

   Para usar la función de protección de contraseñas, reCAPTCHA requiere que la facturación esté vinculada y habilitada en el proyecto. Puedes habilitar la facturación con una tarjeta de crédito o con un ID de facturación de proyecto Google Cloud ya creado. Si necesitas ayuda con la facturación, ponte en contacto con el equipo de Asistencia de Facturación de Cloud.

Comprobar si hay credenciales vulneradas y filtradas

Puedes comprobar si un conjunto de credenciales se ha visto comprometido mediante funciones criptográficas o con el contenedor de Docker.

El contenedor de Docker es un cliente de código abierto que implementa la computación multiparte segura que se necesita para proteger la privacidad del usuario final y buscar filtraciones de contraseñas de forma segura. Para obtener más información, consulta el repositorio de GitHub. El contenedor Docker abstrae la complejidad de implementar los algoritmos criptográficos y simplifica el proceso de instalación. También te permite alojar la aplicación de contenedor en tu infraestructura.

Función criptográfica

Para comprobar si un conjunto de credenciales se ha visto comprometido, usa la defensa de contraseñas al crear evaluaciones para acciones como inicios de sesión, cambios de contraseña y restablecimientos de contraseña.

Para comprobar si hay contraseñas filtradas y credenciales vulneradas, sigue estos pasos:

1. Generar parámetros de solicitud.
2. Crea una evaluación para detectar filtraciones de contraseñas.
3. Verificar credenciales filtradas de una evaluación
4. Interpretar el veredicto y tomar medidas.

Generar parámetros de solicitud

1. Calcula los parámetros de solicitud necesarios mediante las funciones criptográficas que requiere el protocolo de alta privacidad. reCAPTCHA proporciona bibliotecas Java y TypeScript para ayudarte a generar estos campos:

   • java-recaptcha-password-check-helpers
   • typescript-recaptcha-password-check-helpers

2. Para crear verificaciones de comprobación de contraseñas, crea un objeto PasswordCheckVerifier.

   PasswordCheckVerifier verifier = new PasswordCheckVerifier();
   

3. Para iniciar una verificación, llama al PasswordCheckVerifier#createVerification. Este método usa el nombre de usuario y la contraseña para calcular los parámetros que se usarán en la comprobación de la contraseña.

   PasswordCheckVerification verification = verifier.createVerification("username", "password").get();
   

4. Crea una evaluación con los parámetros de verificación.

   byte[] lookupHashPrefix = verification.getLookupHashPrefix();
   byte[] encryptedUserCredentialsHash = verification.getEncryptedUserCredentialsHash();
   

   Las matrices de bytes lookupHashPrefix y encryptedUserCredentialsHash contienen los parámetros necesarios para iniciar una comprobación de contraseñas Assessment.

Crear una evaluación para detectar filtraciones de contraseñas

Usa el método projects.assessments.create.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

• PROJECT_ID: tu ID de proyecto Google Cloud
• LOOKUP_HASH_PREFIX: prefijo del prefijo del hash SHA-256 del nombre de usuario
• ENCRYPTED_USER_CREDENTIALS_HASH: hash Scrypt de las credenciales de usuario cifradas

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "private_password_leak_verification": {
    "lookup_hash_prefix": "LOOKUP_HASH_PREFIX",
    "encrypted_user_credentials_hash": "ENCRYPTED_USER_CREDENTIALS_HASH"
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

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 print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://recaptchaenterprise.googleapis.com/v1/projects/PROJECT_ID/assessments"

PowerShell

Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "name": "projects/698047609967/assessments/fb22000000000000",
  "score": 0,
  "reasons": [],
  "privatePasswordLeakVerification": {
    "lookupHashPrefix": "zoxZwA==",
    "encryptedUserCredentialsHash": "AyRihRcKaGLj/FA/r2uqQY/fzfTaDb/nEcIUMeD3Tygp",
    "reencryptedUserCredentialsHash": "Aw65yEbLM39ww1ridDEfx5VhkWo11tzn/R1B88Qqwr/+"
    "encryptedLeakMatchPrefixes": [
      "n/n5fvPD6rmQPFyb4xk=", "IVQqzXsbZenaibID6OI=", ..., "INeMMndrfnlf6osCVvs=",
      "MkIpxt2x4mtyBnRODu0=", "AqUyAUWzi+v7Kx03e6o="]
  }
}

Verificar credenciales filtradas de una evaluación

Extrae los campos reEncryptedUserCredentials y encryptedLeakMatchPrefixes de la respuesta de la evaluación y pásalos al objeto de verificación para determinar si las credenciales se han filtrado o no.

PasswordCheckResult result = verifier.verify(verification,
result.getReEncryptedUserCredentials(),
result.getEncryptedLeakMatchPrefixes()
).get();

System.out.println("Credentials leaked: " + result.areCredentialsLeaked());

Código de ejemplo

Node.js (TypeScript)

Para saber cómo implementar la detección de filtraciones de contraseñas con Node.js (TypeScript), consulta el código de ejemplo de TypeScript en GitHub.

Java

Para autenticarte en reCAPTCHA, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

import com.google.cloud.recaptcha.passwordcheck.PasswordCheckResult;
import com.google.cloud.recaptcha.passwordcheck.PasswordCheckVerification;
import com.google.cloud.recaptcha.passwordcheck.PasswordCheckVerifier;
import com.google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseServiceClient;
import com.google.protobuf.ByteString;
import com.google.recaptchaenterprise.v1.Assessment;
import com.google.recaptchaenterprise.v1.CreateAssessmentRequest;
import com.google.recaptchaenterprise.v1.PrivatePasswordLeakVerification;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.bouncycastle.util.encoders.Base64;

public class CreatePasswordLeakAssessment {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    // Google Cloud Project ID.
    String projectID = "project-id";

    // Username and password to be checked for credential breach.
    String username = "username";
    String password = "password";

    checkPasswordLeak(projectID, username, password);
  }

  /*
   * Detect password leaks and breached credentials to prevent account takeovers
   * (ATOs) and credential stuffing attacks.
   * For more information, see:
   * https://cloud.google.com/recaptcha-enterprise/docs/check-passwords and
   * https://security.googleblog.com/2019/02/protect-your-accounts-from-data.html

   * Steps:
   * 1. Use the 'create' method to hash and Encrypt the hashed username and
   * password.
   * 2. Send the hash prefix (26-bit) and the encrypted credentials to create
   * the assessment.(Hash prefix is used to partition the database.)
   * 3. Password leak assessment returns a list of encrypted credential hashes to
   * be compared with the decryption of the returned re-encrypted credentials.
   * Create Assessment also sends back re-encrypted credentials.
   * 4. The re-encrypted credential is then locally verified to see if there is
   * a match in the database.
   *
   * To perform hashing, encryption and verification (steps 1, 2 and 4),
   * reCAPTCHA Enterprise provides a helper library in Java.
   * See, https://github.com/GoogleCloudPlatform/java-recaptcha-password-check-helpers

   * If you want to extend this behavior to your own implementation/ languages,
   * make sure to perform the following steps:
   * 1. Hash the credentials (First 26 bits of the result is the
   * 'lookupHashPrefix')
   * 2. Encrypt the hash (result = 'encryptedUserCredentialsHash')
   * 3. Get back the PasswordLeak information from
   * reCAPTCHA Enterprise Create Assessment.
   * 4. Decrypt the obtained 'credentials.getReencryptedUserCredentialsHash()'
   * with the same key you used for encryption.
   * 5. Check if the decrypted credentials are present in
   * 'credentials.getEncryptedLeakMatchPrefixesList()'.
   * 6. If there is a match, that indicates a credential breach.
   */
  public static void checkPasswordLeak(
      String projectID, String username, String password)
      throws ExecutionException, InterruptedException, IOException {

    // Instantiate the java-password-leak-helper library to perform the cryptographic functions.
    PasswordCheckVerifier passwordLeak = new PasswordCheckVerifier();

    // Create the request to obtain the hash prefix and encrypted credentials.
    PasswordCheckVerification verification =
        passwordLeak.createVerification(username, password).get();

    byte[] lookupHashPrefix = Base64.encode(verification.getLookupHashPrefix());
    byte[] encryptedUserCredentialsHash = Base64.encode(
        verification.getEncryptedUserCredentialsHash());

    // Pass the credentials to the createPasswordLeakAssessment() to get back
    // the matching database entry for the hash prefix.
    PrivatePasswordLeakVerification credentials =
        createPasswordLeakAssessment(
            projectID,
            lookupHashPrefix,
            encryptedUserCredentialsHash);

    // Convert to appropriate input format.
    List<byte[]> leakMatchPrefixes =
        credentials.getEncryptedLeakMatchPrefixesList().stream()
            .map(x -> Base64.decode(x.toByteArray()))
            .collect(Collectors.toList());

    // Verify if the encrypted credentials are present in the obtained match list.
    PasswordCheckResult result =
        passwordLeak
            .verify(
                verification,
                Base64.decode(credentials.getReencryptedUserCredentialsHash().toByteArray()),
                leakMatchPrefixes)
            .get();

    // Check if the credential is leaked.
    boolean isLeaked = result.areCredentialsLeaked();
    System.out.printf("Is Credential leaked: %s", isLeaked);
  }

  // Create a reCAPTCHA Enterprise assessment.
  // Returns:  PrivatePasswordLeakVerification which contains
  // reencryptedUserCredentialsHash and credential breach database
  // whose prefix matches the lookupHashPrefix.
  private static PrivatePasswordLeakVerification createPasswordLeakAssessment(
      String projectID,
      byte[] lookupHashPrefix,
      byte[] encryptedUserCredentialsHash)
      throws IOException {
    try (RecaptchaEnterpriseServiceClient client = RecaptchaEnterpriseServiceClient.create()) {

      // Set the hashprefix and credentials hash.
      // Setting this will trigger the Password leak protection.
      PrivatePasswordLeakVerification passwordLeakVerification =
          PrivatePasswordLeakVerification.newBuilder()
              .setLookupHashPrefix(ByteString.copyFrom(lookupHashPrefix))
              .setEncryptedUserCredentialsHash(ByteString.copyFrom(encryptedUserCredentialsHash))
              .build();

      // Build the assessment request.
      CreateAssessmentRequest createAssessmentRequest =
          CreateAssessmentRequest.newBuilder()
              .setParent(String.format("projects/%s", projectID))
              .setAssessment(
                  Assessment.newBuilder()
                      // Set request for Password leak verification.
                      .setPrivatePasswordLeakVerification(passwordLeakVerification)
                      .build())
              .build();

      // Send the create assessment request.
      Assessment response = client.createAssessment(createAssessmentRequest);

      // Get the reCAPTCHA Enterprise score.
      float recaptchaScore = response.getRiskAnalysis().getScore();
      System.out.println("The reCAPTCHA score is: " + recaptchaScore);

      // Get the assessment name (id). Use this to annotate the assessment.
      String assessmentName = response.getName();
      System.out.println(
          "Assessment name: " + assessmentName.substring(assessmentName.lastIndexOf("/") + 1));

      return response.getPrivatePasswordLeakVerification();
    }
  }
}

Contenedor Docker

Esta función está sujetas a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Las funciones previas a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.

Para comprobar si se han filtrado credenciales, envía de forma segura el par de credenciales de nombre de usuario y contraseña al contenedor mediante una conexión localhost o configurando HTTPS en el contenedor. A continuación, el contenedor cifra estas credenciales antes de hacer una solicitud de API a reCAPTCHA y verifica el resultado recifrado de forma local.

Nota: Google nunca lee ni descifra las credenciales que se comparten de esta forma, y la verificación la realiza el propio contenedor.

Para enviar solicitudes al contenedor Docker, sigue estos pasos:

1. Configura Docker.
2. Prepara un entorno para el contenedor Docker.
3. Crea y ejecuta el contenedor.
4. Enviar solicitudes HTTP al contenedor.
5. Interpretar el veredicto y tomar medidas.

Preparar la ejecución del contenedor Docker

1. Elige una estrategia de autenticación.

   El contenedor admite la configuración de credenciales predeterminadas de la aplicación o puede aceptar una clave de API para la autenticación.

2. Configura el contenedor de PLD para que se ejecute con HTTPS o en un modo de demostración solo para localhost.

   Como el contenedor acepta credenciales sensibles de usuarios finales (nombres de usuario y contraseñas), debe ejecutarse con HTTPS o en un modo de demostración solo para localhost. Para obtener información sobre la configuración de HTTPS, consulta el archivo README en GitHub.

En los siguientes pasos se usa la autenticación con clave de API y se ejecuta el cliente en el modo de demostración solo para localhost.

Compilar y ejecutar el contenedor Docker

1. Clona el repositorio:

   git clone github.com/GoogleCloudPlatform/reCAPTCHA-PLD
   

2. Compila el contenedor:

   docker build . -t pld-local
   

3. Inicia el contenedor:

   docker run --network host \
   -e RECAPTCHA_PROJECT_ID=PROJECT_ID \
   -e GOOGLE_CLOUD_API_KEY=API_KEY \
   pld-local
   

El contenedor se inicia y empieza a atender solicitudes en el puerto 8080 de localhost.

Enviar solicitudes de localhost

Importante: Aunque en este ejemplo se muestra el contenedor ejecutándose en HTTP, te recomendamos que uses certificados HTTPS cuando ejecutes el contenedor Docker en un entorno de producción. Para obtener información sobre cómo configurar HTTPS y proporcionar certificados al contenedor, consulta el archivo README.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

• LEAKED_USERNAME: nombre de usuario del par de credenciales filtradas.
• LEAKED_PASSWORD: contraseña del par de credenciales filtradas.

Método HTTP y URL:

POST http://localhost:8080/createAssessment/

Cuerpo JSON de la solicitud:

{
    "username":"LEAKED_USERNAME",
    "password":"LEAKED_PASSWORD"
}

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 "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "http://localhost:8080/createAssessment/"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "http://localhost:8080/createAssessment/" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

  { "leakedStatus":"LEAKED" }


 OR


  { "leakedStatus":"NO_STATUS" }

Interpretar el veredicto y tomar medidas

La respuesta de la evaluación muestra si se han filtrado las credenciales y te proporciona información que puedes usar para tomar las medidas adecuadas para proteger a tus usuarios.

En la siguiente tabla se enumeran las acciones recomendadas que puedes llevar a cabo cuando se detecta una contraseña filtrada:

Contraseña filtrada detectada	Acciones para proteger a tus usuarios
Durante el inicio de sesión	Rechaza la contraseña y pide al cliente que elija otra. Además, activa la autenticación multifactor, si es posible. Recuerda al usuario que debe usar contraseñas únicas en todas sus cuentas. Exige contraseñas seguras en tu sitio. Pide al usuario que habilite la autenticación multifactor (MFA) si no la está usando.
Durante la creación de la cuenta o el cambio de contraseña	Exige al usuario que cambie su contraseña. Activa un flujo de autenticación multifactor (MFA).

Si aún no usas ningún proveedor de MFA en tu sitio, puedes usar la función de MFA de reCAPTCHA.

Siguientes pasos

• Consulta cómo usar la autenticación multifactor (MFA).
• Consulta cómo proteger las cuentas de los usuarios con Account Defender de reCAPTCHA.