Detectar filtraciones de contraseñas y credenciales vulneradas

En esta página, se describe cómo usar la función de detección de filtraciones de contraseñas de reCAPTCHA para detectar filtraciones de contraseñas y credenciales vulneradas y evitar apropiaciones de cuentas (ATO) y ataques de uso excesivo 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 Verificación de contraseñas.

Importante: La detección de filtraciones de contraseñas usa computación segura multipartita (MPC) para proteger los datos del usuario. Solicitar verificaciones de contraseñas puede causar latencia adicional cuando se crea una evaluación. Aunque el tiempo de respuesta es mucho más rápido, te recomendamos que uses un tiempo de espera de 500ms cuando crees una evaluación con detección de filtración de contraseñas.

Antes de comenzar

1. Prepara tu entorno para reCAPTCHA.

2. Configura reCAPTCHA.

3. Make sure that billing is enabled for your Google Cloud project.

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

Cómo verificar si hay credenciales vulneradas o filtradas

Puedes verificar si se vulneró un conjunto de credenciales con funciones de criptografía o con el contenedor de Docker.

El contenedor de Docker es un cliente de código abierto que implementa el cálculo seguro de múltiples partes necesario para preservar 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 de Docker abstrae la complejidad de implementar los algoritmos de criptografía 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 se vulneró un conjunto de credenciales, usa la detección de filtración 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 de criptografía que requiere el protocolo de alta privacidad. reCAPTCHA proporciona bibliotecas de Java y TypeScript para ayudar a generar estos campos:

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

2. Para crear verificaciones de verificación 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 que se usarán en la verificación de 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 arreglos de bytes lookupHashPrefix y encryptedUserCredentialsHash contienen los parámetros necesarios para iniciar una verificación de contraseña Assessment.

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

Usa el método projects.assessments.create.

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.
• LOOKUP_HASH_PREFIX: Prefijo del hash SHA-256 del nombre de usuario
• ENCRYPTED_USER_CREDENTIALS_HASH: Hash de Scrypt de las credenciales del 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

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, 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: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, 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 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

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

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

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

Muestra de código

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

En la siguiente muestra de código, se muestra cómo implementar la detección de filtraciones de contraseñas con Java:

Java

Para autenticarte en reCAPTCHA, configura las credenciales predeterminadas de la aplicación. Si deseas 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;
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 de Docker

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

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 mediante una conexión a localhost o configura HTTPS en el contenedor. Luego, el contenedor encripta estas credenciales antes de hacer una solicitud a la API a reCAPTCHA y verifica el resultado vuelto a encriptar de forma local.

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

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 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.

   Debido a que 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 para localhost. Para obtener orientación sobre la configuración de HTTPS, consulta README en GitHub.

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

Compila y ejecuta el contenedor de Docker

1. Clone 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.

Cómo enviar solicitudes a localhost

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

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 filtrado.
• LEAKED_PASSWORD: La contraseña del par de credenciales filtrado

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 y 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 contraseña y solicita que el cliente elija una diferente. Si es posible, activa una verificación de MFA. Recuérdale al usuario que use contraseñas únicas en todas las cuentas. Solicita contraseñas seguras en tu sitio. Pídele al usuario que habilite la autenticación de varios factores (MFA) si no la está usando.
Durante la creación de la cuenta o el restablecimiento de la contraseña	Solicitar 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 función de MFA de reCAPTCHA.

¿Qué sigue?

• Obtén información para usar la autenticación de varios factores (MFA)
• Obtén información para proteger las cuentas de los usuarios con el Defensor de cuentas de reCAPTCHA