Detectar filtraciones de contraseñas y credenciales vulneradas

En esta página, se describe cómo usar la función de defensa de contraseñas de reCAPTCHA para detectar filtraciones de contraseñas y credenciales vulneradas para evitar las apropiaciones de cuentas (ATO) 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 realizar estas evaluaciones, Google usa la función Password Checkup.

Antes de comenzar

  1. Prepara tu entorno para reCAPTCHA.

  2. Configura reCAPTCHA.

  3. Verifica que la facturación esté habilitada para tu Google Cloud proyecto.

    reCAPTCHA requiere que la facturación esté vinculada y habilitada en el proyecto para usar la función de defensa de contraseñas. Puedes habilitar la facturación con una tarjeta de crédito o un ID de facturación de proyecto Google Cloud existente. Si necesitas ayuda con la facturación, comunícate con el equipo de asistencia de Facturación de Cloud.

Verifica si hay credenciales vulneradas y filtradas

Puedes verificar si un conjunto de credenciales se vulneró con funciones criptográficas o con el contenedor de Docker.

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

Función criptográfica

Para verificar si un conjunto de credenciales se vulneró, usa la defensa de contraseñas cuando crees evaluaciones para acciones como accesos, cambios de contraseñas y restablecimientos de contraseñas.

Para verificar si hay filtraciones de contraseñas y credenciales vulneradas, completa los siguientes pasos:

  1. Genera parámetros de solicitud.
  2. Crea una evaluación para detectar filtraciones de contraseñas.
  3. Verifica las credenciales filtradas de una evaluación.
  4. Interpreta el veredicto y toma medidas.

Genera parámetros de solicitud

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

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

    PasswordCheckVerifier verifier = new PasswordCheckVerifier();

  3. Para iniciar una verificación, llama a PasswordCheckVerifier#createVerification. Este método usa el nombre de usuario y la contraseña para calcular los parámetros para realizar la verificació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();

    Los arrays de bytes lookupHashPrefix y encryptedUserCredentialsHash contienen los parámetros que se requieren para iniciar una Assessment de verificación de contraseñas.

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

Usa el projects.assessments.create método.

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

  • PROJECT_ID: El ID de tu Google Cloud proyecto
  • LOOKUP_HASH_PREFIX: Es el prefijo del prefijo de hash SHA-256 del nombre de usuario.
  • ENCRYPTED_USER_CREDENTIALS_HASH: Es el hash Scrypt de las credenciales de usuario encriptadas.

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

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

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 que se muestra a continuación:

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

Verifica las credenciales filtradas de una evaluación

En la respuesta de la evaluación, extrae los campos reEncryptedUserCredentials y encryptedLeakMatchPrefixes, y pásalos al objeto de verificación para determinar si las credenciales se filtraron o no.

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

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

Muestra de código

Node.js (TypeScript)

Para obtener información sobre cómo implementar la detección de filtración de contraseñas con Node.js (TypeScript), consulta la muestra de código de TypeScript en GitHub.

Java

Para autenticarte en reCAPTCHA, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para 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;

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 = verification.getLookupHashPrefix();
    byte[] encryptedUserCredentialsHash = 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 -> x.toByteArray())
            .collect(Collectors.toList());

    // Verify if the encrypted credentials are present in the obtained match list.
    PasswordCheckResult result =
        passwordLeak
            .verify(
                verification,
                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 de Docker

Para verificar si se filtraron las credenciales, envía de forma segura el par de credenciales de nombre de usuario y contraseña al contenedor con una conexión de localhost o configurando HTTPS en el contenedor. Luego, el contenedor encripta estas credenciales antes de realizar una solicitud a la API de reCAPTCHA y verifica el resultado encriptado nuevamente de forma local.

Para enviar solicitudes al contenedor de Docker, completa los siguientes pasos:

  1. Configura Docker.
  2. Prepara un entorno para el contenedor de Docker.
  3. Compila y ejecuta el contenedor.
  4. Envía solicitudes HTTP al contenedor.
  5. Interpreta el veredicto y toma medidas.

Prepárate para ejecutar el contenedor de Docker

  1. Elige una estrategia de autenticación.

    El contenedor admite la configuración de las 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 de localhost.

    Como el contenedor acepta credenciales sensibles del usuario final (nombres de usuario y contraseñas), se debe ejecutar con HTTPS o en un modo de demostración solo de localhost. Para obtener instrucciones sobre la configuración de HTTPS, consulta README en GitHub.

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

Compila y ejecuta el contenedor de 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 comienza a entregar solicitudes en el puerto 8080 de localhost.

Envía solicitudes de localhost

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

  • LEAKED_USERNAME: Es el nombre de usuario del par de credenciales filtradas.
  • LEAKED_PASSWORD: Es la 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 que se muestra a continuación:


  { "leakedStatus":"LEAKED" }


 OR


  { "leakedStatus":"NO_STATUS" }

Interpreta el veredicto y toma medidas

La respuesta de la evaluación muestra si se filtraron 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 realizar cuando se detecta una contraseña filtrada:

Se detectó una contraseña filtrada Acciones para proteger a tu usuario
Durante el acceso
  • Rechaza la solicitud y exige que el cliente elija una contraseña diferente y activa un desafío de MFA, si es posible.
  • Recuérdale al usuario que use contraseñas únicas en todas las cuentas.
  • Exige contraseñas seguras en tu sitio.
  • Pídele al usuario que habilite la autenticación de varios factores (MFA) si no la usa.
Durante la creación de la cuenta o el restablecimiento de la contraseña
  • Exige que el usuario cambie su contraseña.
  • Activa un flujo de autenticación de varios factores (MFA).

Si aún no usas un proveedor de MFA en tu sitio, puedes usar la capacidad de MFA de reCAPTCHA.

¿Qué sigue?