Detectar vazamentos de senha e credenciais violadas

A defesa de senha no Google Cloud Fraud Defense permite detectar credenciais vazadas e violadas para ajudar a proteger seus aplicativos contra ataques de sequestro de conta (ATO, na sigla em inglês) e ataques de preenchimento de credenciais. Como parte de qualquer avaliação, é possível auditar as credenciais do usuário em relação a violações de dados conhecidas usando a tecnologia Check-up de senha do Google.

Antes de começar

  1. Prepare seu ambiente para o Google Cloud Fraud Defense.

  2. Configurar o Fraud Defense.

  3. Verifique se o faturamento está ativado para o projeto do Google Cloud .

    O Fraud Defense exige que o faturamento esteja vinculado e ativado no projeto para usar o recurso de Defesa de senha. É possível ativar o faturamento usando um cartão de crédito ou um ID de faturamento de projeto do Google Cloud atual. Se 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 o contêiner do Docker.

O contêiner do Docker é um cliente de código aberto que implementa a computação multipartidária segura necessária para preservar a privacidade do usuário final e realizar pesquisa rápida de 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 Defesa 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 de geração.
  2. Crie uma avaliação para detectar vazamentos de senhas.
  3. Verificar credenciais vazadas de uma avaliação.
  4. Interpretar o veredicto e entrar em ação.

Gerar parâmetros de solicitação

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

  2. Para criar verificações 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 para realizar a verificação de senha.

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

  4. Crie uma 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.

Crie 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 de credenciais de usuário criptografadas

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 abaixo: 

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 abaixo: 

$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

Na resposta da avaliação, extraia os campos reEncryptedUserCredentials e encryptedLeakMatchPrefixes e transmita-os ao objeto verificador para determinar se as credenciais foram vazadas ou não.

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

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

Exemplo de código

Node.js (TypeScript)

Para saber como implementar a Defesa de senha usando o Node.js (TypeScript), consulte o exemplo de código TypeScript no GitHub.

Java

Para autenticar no Fraud Defense, 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;

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

Contêiner do Docker

Para verificar se as credenciais vazaram, 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. Em seguida, o contêiner criptografa essas credenciais antes de fazer uma solicitação de API e verifica o resultado criptografado novamente de forma local.

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. Enviar solicitações HTTP para o contêiner.
  5. Interpretar o veredicto e entrar em ação.

Preparar para executar o contêiner do Docker

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

    O contêiner é compatível com a configuração do Application Default Credentials 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 confidenciais do usuário final (nomes de usuário e senhas), ele precisa ser executado com HTTPS ou em um modo de demonstração somente para localhost. Para orientações sobre a configuração de HTTPS, consulte o README no GitHub.

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. Crie 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 atender solicitações na porta 8080 do localhost.

Enviar solicitações do Localhost

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

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 veredicto e entrar em ação

A resposta da avaliação mostra se as credenciais foram vazadas e fornece informações que você pode usar para tomar as medidas adequadas para 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 o usuário
Durante o processo de login
  • Rejeitar e exigir que o cliente escolha outra senha e acionar um desafio de MFA, se possível.
  • Lembre 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 a redefinição de senha
  • Exigir que o usuário mude a senha.
  • Acionar 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 Fraud Defense.

A seguir