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 reCAPTCHA, é possível realizar verificações auditorias de credenciais de usuários (senhas) como parte de qualquer avaliação para garantir que elas não tenham vazado ou violados. Para realizar essas avaliações, o Google usa o recurso Check-up de senha.

Importante :a detecção de vazamento de senhas usa computação segura de várias partes (MPC, na sigla em inglês) para proteger os dados do usuário. Solicitar verificações de senha pode causar latência extra ao criar uma avaliação. Embora o tempo de resposta seja muito mais rápido, recomendamos usar um tempo limite de 500ms ao criar uma avaliação com detecção de vazamento de senhas.

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 esteja vinculado e ativado no projeto 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.

Verificar 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 saber mais, consulte o repositório do GitHub (link em inglês). O contêiner do Docker abstrai a complexidade da implementação da criptografia algoritmos e simplifica o processo de instalação. Ele também permite hospedar contêiner do aplicativo em sua infraestrutura.

Função criptográfica

Para verificar se um conjunto de credenciais foi comprometido, use a detecção de vazamento de senhas 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. Criar uma avaliação para detectar vazamentos de senhas.
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:

• java-recaptcha-password-check-helpers (link em inglês)
• typescript-recaptcha-password-check-helpers

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

   PasswordCheckVerifier verifier = new PasswordCheckVerifier();
   

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

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

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 da resposta da avaliação. reEncryptedUserCredentials e encryptedLeakMatchPrefixes e transmiti-las para o objeto 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

Os exemplos de código a seguir mostram como implementar a detecção de vazamento de senhas usando as bibliotecas Java e TypeScript:

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

Node.js (TypeScript)

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 {google} from '@google-cloud/recaptcha-enterprise/build/protos/protos';
import {RecaptchaEnterpriseServiceClient} from '@google-cloud/recaptcha-enterprise';
import {PasswordCheckVerification} from 'recaptcha-password-check-helpers';

// TODO(developer): Uncomment and set the following variables
// Google Cloud Project ID.
// const projectId: string = "PROJECT_ID"

// Username and password to be checked for credential breach.
// const username: string = "user123";
// const password: string = "1234@abcd";

// Create a client.
const client: RecaptchaEnterpriseServiceClient =
  new RecaptchaEnterpriseServiceClient();

/*
* 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 Typescript.
* See, https://github.com/GoogleCloudPlatform/typescript-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.
*/
async function checkPasswordLeak(
  projectId: string,
  username: string,
  password: string
) {
  // Instantiate the recaptcha-password-check-helpers library to perform the
  // cryptographic functions.
  // Create the request to obtain the hash prefix and encrypted credentials.
  const verification: PasswordCheckVerification =
    await PasswordCheckVerification.create(username, password);

  const lookupHashPrefix: string = Buffer.from(
    verification.getLookupHashPrefix()
  ).toString('base64');
  const encryptedUserCredentialsHash: string = Buffer.from(
    verification.getEncryptedUserCredentialsHash()
  ).toString('base64');
  console.log('Hashes created.');

  // Pass the credentials to the createPasswordLeakAssessment() to get back
  // the matching database entry for the hash prefix.
  const credentials: google.cloud.recaptchaenterprise.v1.IPrivatePasswordLeakVerification =
    await createPasswordLeakAssessment(
      projectId,
      lookupHashPrefix,
      encryptedUserCredentialsHash
    );

  // Convert to appropriate input format.
  const reencryptedUserCredentialsHash: Uint8Array = Buffer.from(
    credentials.reencryptedUserCredentialsHash!.toString(),
    'base64'
  );
  const encryptedLeakMatchPrefixes: Uint8Array[] =
    credentials.encryptedLeakMatchPrefixes!.map(prefix => {
      return Buffer.from(prefix.toString(), 'base64');
    });

  // Verify if the encrypted credentials are present in the obtained
  // match list to check if the credential is leaked.
  const isLeaked: boolean = verification
    .verify(reencryptedUserCredentialsHash, encryptedLeakMatchPrefixes)
    .areCredentialsLeaked();

  console.log(`Is Credential leaked: ${isLeaked}`);
}

// Create a reCAPTCHA Enterprise assessment.
// Returns: PrivatePasswordLeakVerification which contains
// reencryptedUserCredentialsHash and credential breach database whose prefix
// matches the lookupHashPrefix.
async function createPasswordLeakAssessment(
  projectId: string,
  lookupHashPrefix: string,
  encryptedUserCredentialsHash: string
): Promise<google.cloud.recaptchaenterprise.v1.IPrivatePasswordLeakVerification> {
  // Build the assessment request.
  const createAssessmentRequest: google.cloud.recaptchaenterprise.v1.ICreateAssessmentRequest =
    {
      parent: `projects/${projectId}`,
      assessment: {
        // Set the hashprefix and credentials hash.
        // Setting this will trigger the Password leak protection.
        privatePasswordLeakVerification: {
          lookupHashPrefix: lookupHashPrefix,
          encryptedUserCredentialsHash: encryptedUserCredentialsHash,
        },
      },
    };

  // Send the create assessment request.
  const [response] = await client.createAssessment(createAssessmentRequest);

  // Get the reCAPTCHA Enterprise score.
  console.log(`The reCAPTCHA score is: ${response.riskAnalysis?.score}`);
  // Get the assessment name (id). Use this to annotate the assessment.
  console.log(`Assessment name: ${response.name}`);

  if (!response?.privatePasswordLeakVerification) {
    throw `Error in obtaining response from Private Password Leak Verification ${response}`;
  }

  return response.privatePasswordLeakVerification;
}

checkPasswordLeak(projectId, username, password).catch(err => {
  console.error(err.message);
  process.exitCode = 1;
});

contêiner do Docker

Esse recurso está sujeito aos "Termos de ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos de serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

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.

Observação: as credenciais compartilhadas dessa forma nunca são lidas ou descriptografadas pelo Google, e a verificação é realizada pelo próprio contêiner.

Para enviar solicitações ao contêiner do Docker, siga estas etapas:

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. Interprete o veredito e tome medidas.

Preparar-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 PLD para ser executado com HTTPS ou em uma demonstração somente de localhost modo

   Como o contêiner aceita credenciais confidenciais de usuário final (nomes de usuário e senhas), ele precisa ser executado com HTTPS ou em uma demonstração somente de localhost modo 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 para 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

Importante: embora este exemplo mostre o contêiner em execução no HTTP, recomendamos o uso de certificados HTTPS ao executar o contêiner do Docker em um ambiente de produção. Para detalhes sobre como configurar o HTTPS e fornecer certificados para o contêiner, consulte README.

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 vazado.
• 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 realizar ações

A resposta da avaliação mostra se as credenciais foram vazadas e fornece informações que podem ser usadas para tomar as medidas adequadas e proteger seus usuários.

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

Senha vazada detectada	Ações para proteger seu usuário
Durante o login	Rejeitar e exigir que o cliente escolha uma senha diferente e acione um desafio de 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. Acionar um fluxo de autenticação multifator (MFA).

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

A seguir

• Saiba como usar a autenticação multifator (MFA)
• Saiba como proteger as contas dos usuários usando o Defensor da conta do reCAPTCHA