Detecte vazamentos de senhas e credenciais violadas

Nesta página, descrevemos como usar o recurso de detecção de vazamento de senhas do reCAPTCHA. para detectar vazamentos de senhas e credenciais violadas, evitando invasões de contas (ATOs) e ataques de preenchimento de credenciais. Com o reCAPTCHA, é possível fazer auditorias regulares das credenciais do usuário (senhas) como parte de qualquer avaliação para garantir que elas não tenham sido vazadas ou violadas. Para realizar essas avaliações, o Google usa o recurso Check-up de senha.

Antes de começar

  1. Prepare seu ambiente para o reCAPTCHA.

  2. Configure o reCAPTCHA.

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

    O reCAPTCHA exige que o faturamento seja vinculado e ativado no projeto para usar o recurso de detecção de vazamento de senhas. Você pode ativar o faturamento usando um cartão de crédito ou ID do faturamento do projeto atual do Google Cloud. Se você precisar de ajuda com o faturamento, entre em contato com o suporte do Cloud Billing.

Verifique se há credenciais violadas e vazadas

É possível verificar se um conjunto de credenciais foi comprometido usando funções criptográficas ou usando o contêiner do Docker.

O contêiner do Docker é um cliente de código aberto que implementa a computação segura multilateral necessária para preservar a privacidade do usuário final e procurar vazamentos de senha com segurança. Para mais informações, consulte o repositório do GitHub. O contêiner do Docker abstrai a complexidade da implementação dos algoritmos criptográficos e simplifica o processo de instalação. Ele também permite hospedar o app de contêiner na sua infraestrutura.

Função criptográfica

Para verificar se um conjunto de credenciais foi comprometido, use a detecção de vazamento de senha ao criar avaliações para ações, como logins, alterações de senha e redefinições de senha.

Para verificar se há vazamentos de senhas e credenciais violadas, siga estas etapas:

  1. Gerar parâmetros de solicitação.
  2. Crie uma avaliação para detectar vazamentos de senha.
  3. Verificar as credenciais vazadas de uma avaliação.
  4. Interpretar o veredito e realizar ações.

Gerar parâmetros de solicitação

  1. Calcule os parâmetros de solicitação necessários usando o as funções criptográficas exigidas pelo protocolo de alta privacidade. O reCAPTCHA fornece bibliotecas Java e TypeScript para ajudar na para gerar esses campos:

  2. Para criar verificações de verificação de senha, crie um objeto PasswordCheckVerifier.

    PasswordCheckVerifier verifier = new PasswordCheckVerifier();

  3. Para iniciar uma verificação, chame PasswordCheckVerifier#createVerification. Esse método usa o nome de usuário e a senha para calcular os parâmetros e realizar a verificação de senha.

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

  4. Crie um avaliação usando os parâmetros de verificação.

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

    As matrizes de bytes lookupHashPrefix e encryptedUserCredentialsHash contêm os parâmetros necessários para iniciar uma verificação de senha Assessment.

Criar uma avaliação para detectar vazamentos de senhas

Use o método projects.assessments.create.

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
  • LOOKUP_HASH_PREFIX: prefixo do prefixo de hash SHA-256 do nome de usuário
  • ENCRYPTED_USER_CREDENTIALS_HASH: hash Scrypt das credenciais de usuário criptografado

Método HTTP e URL: 

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

Corpo JSON da solicitação:

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

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:

{
  "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 credenciais vazadas de uma avaliação

Extraia os campos reEncryptedUserCredentials e encryptedLeakMatchPrefixes da resposta da avaliação e os transmita ao objeto de verificador para determinar se as credenciais vazaram ou não.

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

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

Exemplo de código

Para saber como implementar a detecção de vazamento de senhas usando TypeScript, consulte a amostra exemplo de código no GitHub (em inglês).

O exemplo de código a seguir mostra como implementar a detecção de vazamento de senhas usando Java:

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.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();
    }
  }
}

Contêiner do Docker

Para verificar se as credenciais foram vazadas, envie com segurança o par de credenciais de nome de usuário e senha para o contêiner usando uma conexão localhost ou configurando o HTTPS no contêiner. O contêiner, em seguida, criptografa essas credenciais antes de fazer uma solicitação de API para o reCAPTCHA e verifica o resultado recriptografado localmente.

Para enviar solicitações ao contêiner do Docker, conclua as etapas a seguir:

  1. Configure o Docker.
  2. Prepare um ambiente para o contêiner do Docker.
  3. Crie e execute o contêiner.
  4. Envie solicitações HTTP para o contêiner.
  5. Interpretar o veredito e realizar ações.

prepare-se para executar o contêiner do Docker

  1. Escolha uma estratégia de autenticação.

    O contêiner oferece suporte à configuração de credenciais padrão do aplicativo ou pode aceitar uma chave de API para autenticação.

  2. Configure o contêiner do PLD para ser executado com HTTPS ou em um modo de demonstração somente para localhost.

    Como o contêiner aceita credenciais sensíveis do usuário final (nomes de usuário e senhas), ele precisa ser executado com HTTPS ou no modo de demonstração somente para localhost. Para orientações sobre a configuração de HTTPS, consulte README no GitHub (em inglês).

As etapas a seguir usam a autenticação de chave de API e executam o cliente no modo de demonstração somente localhost.

Criar e executar o contêiner do Docker

  1. Clone o repositório:

    git clone github.com/GoogleCloudPlatform/reCAPTCHA-PLD

  2. Criar o contêiner:

    docker build . -t pld-local

  3. Inicie o contêiner:

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

O contêiner é iniciado e começa a exibir solicitações na porta 8080 do localhost.

Enviar solicitações de host local

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

  • LEAKED_USERNAME: nome de usuário do par de credenciais vazadas.
  • LEAKED_PASSWORD: senha do par de credenciais vazado.

Método HTTP e URL: 

POST http://localhost:8080/createAssessment/

Corpo JSON da solicitação:

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

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

PowerShell

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

$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

Você receberá uma resposta JSON semelhante a esta:


  { "leakedStatus":"LEAKED" }


 OR


  { "leakedStatus":"NO_STATUS" }

Interpretar o veredito e tomar medidas

A resposta da avaliação mostra se as credenciais vazaram e fornece informações que você pode usar para tomar as medidas apropriadas a fim de proteger seus usuários.

A tabela a seguir lista as ações recomendadas que você pode realizar quando uma senha vazada é detectada:

Senha vazada detectada Ações para proteger seu usuário
Durante o login
  • Recusar e exigir que o cliente escolha uma senha diferente acionar um desafio de autenticação multifator (MFA) se possível.
  • Lembrar o usuário de usar senhas exclusivas em todas as contas.
  • Exija senhas fortes no seu site.
  • Peça ao usuário para ativar a autenticação multifator (MFA) se ele não estiver usando.
Durante a criação da conta ou redefinição de senha
  • Exija que o usuário mude a senha.
  • Acione um fluxo de autenticação multifator (MFA).

Se você ainda não usa um provedor de MFA no seu site, use o recurso de MFA do reCAPTCHA.

A seguir