Rileva le fughe di password e le credenziali violate

Questa pagina descrive come utilizzare la funzionalità di rilevamento delle fughe di password di reCAPTCHA per rilevare fughe di password e credenziali compromesse al fine di prevenire i takeover dell'account (ATO) e gli attacchi di credential stuffing. Con reCAPTHCA, puoi eseguire regolarmente controlli delle credenziali utente (password) nell'ambito di qualsiasi valutazione per assicurarti che non siano state divulgate o violate. Per eseguire queste valutazioni, Google utilizza la funzionalità Controllo password.

Importante: il rilevamento delle fughe di password utilizza il calcolo multipartito sicuro (MPC) per proteggere i dati utente. La richiesta di controlli della password potrebbe causare una latenza aggiuntiva prilikom kreiranja procjene. Anche se il tempo di risposta è molto più rapido, consigliamo di utilizzare un timeout di 500ms quando crei una valutazione con il rilevamento delle fughe di password.

Prima di iniziare

1. Prepara l'ambiente per reCAPTCHA.

2. Configura reCAPTCHA.

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

   Per utilizzare la funzionalità di rilevamento delle fughe di password, reCAPTCHA richiede che la fatturazione sia collegata e attivata nel progetto. Puoi attivare la fatturazione utilizzando una carta di credito o un ID fatturazione del progetto Google Cloud esistente. Se hai bisogno di assistenza per la fatturazione, contatta l'assistenza per la fatturazione Cloud.

Controlla le credenziali violate e divulgate

Puoi controllare se un set di credenziali è stato compromesso utilizzando con funzioni crittografiche o mediante il container Docker.

Il container Docker è un client open source che implementa computing multi-parti sicuro necessari per preservare la privacy dell'utente finale e cercare in sicurezza le fughe di password. Per maggiori informazioni, consulta il repository GitHub. Il container Docker astrae la complessità dell'implementazione algoritmi e semplifica il processo di installazione. Ti consente inoltre di ospitare un'app containerizzata nella tua infrastruttura.

Funzione di crittografia

Per verificare se un insieme di credenziali è stato compromesso, utilizza il rilevamento delle fughe di password quando crei valutazioni per azioni come accessi, modifiche e reimpostazione delle password.

Per verificare la presenza di fughe di password e credenziali compromesse:

1. Generare i parametri della richiesta.
2. Crea una valutazione per rilevare le fughe di password.
3. Verifica le credenziali divulgate da una valutazione.
4. Interpreta l'esito e intraprendi le azioni necessarie.

Genera i parametri di richiesta

1. Calcola i parametri di richiesta necessari utilizzando le funzioni crittografiche richieste dal protocollo High Privacy. reCAPTCHA fornisce le librerie Java e TypeScript per aiutarti con generando questi campi:

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

1. Per creare verifiche di controllo delle password, crea un PasswordCheckVerifier .

   PasswordCheckVerifier verifier = new PasswordCheckVerifier();
   

2. Per avviare una verifica, chiama il numero PasswordCheckVerifier#createVerification. Questo metodo utilizza il nome utente e la password per calcolare i parametri per eseguire il controllo delle password.

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

3. Crea una valutazione utilizzando i parametri di verifica.

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

   Gli array di byte lookupHashPrefix e encryptedUserCredentialsHash contengono i parametri necessari per avviare un controllo delle password Assessment.

Creare una valutazione per rilevare fughe di password

Utilizza la projects.assessments.create .

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto Google Cloud
• LOOKUP_HASH_PREFIX: prefisso dell'hash SHA-256 del nome utente
• ENCRYPTED_USER_CREDENTIALS_HASH: hash Scrypt delle credenziali utente criptate

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

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: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

$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

Dovresti ricevere una risposta JSON simile alla seguente:

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

Verificare le credenziali trapelate da una valutazione

Estrai i campi reEncryptedUserCredentials e encryptedLeakMatchPrefixes dalla risposta della valutazione e passali all'oggetto verifier per determinare se le credenziali sono state divulgate o meno.

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

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

Esempio di codice

I seguenti esempi di codice mostrano come implementare il rilevamento della divulgazione di password utilizzando le librerie Java e TypeScript:

Java

Per eseguire l'autenticazione in reCAPTCHA, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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)

Per eseguire l'autenticazione a reCAPTCHA, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Container Docker

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Per controllare se le credenziali sono trapelate, invia in modo sicuro il nome utente e la coppia di credenziali della password al container utilizzando una connessione localhost o per configurare HTTPS sul container. Il contenitore cripta quindi queste credenziali prima di effettuare una richiesta API a reCAPTCHA e verifica il risultato nuovamente criptato localmente.

Nota: le credenziali condivise in questo modo non vengono mai lette o decriptate da Google e la verifica viene eseguita dal container stesso.

Per inviare richieste al container Docker, completa i seguenti passaggi:

1. Configura Docker.
2. Prepara un ambiente per il container Docker.
3. Crea ed esegui il container.
4. Invia richieste HTTP al container.
5. Interpreta il verdetto e intervieni.

Preparati a eseguire il container Docker

1. Scegli una strategia di autenticazione.

   Il contenitore supporta l'impostazione delle credenziali predefinite dell'applicazione o può accettare una chiave API per l'autenticazione.

2. Configura il container PLD in modo che venga eseguito con HTTPS o in una demo solo localhost .

   Poiché il contenitore accetta credenziali utente sensibili (nomi utente e password), deve essere eseguito con HTTPS o in modalità demo solo localhost. Per indicazioni sulla configurazione HTTPS, consulta README su GitHub.

I passaggi che seguono utilizzano l'autenticazione con chiave API ed eseguono il client in modalità demo solo localhost.

Crea ed esegui il container Docker

1. Clona il repository:

   git clone github.com/GoogleCloudPlatform/reCAPTCHA-PLD
   

2. Crea il container:

   docker build . -t pld-local
   

3. Avvia il contenitore:

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

Il contenitore si avvia e inizia a gestire le richieste sulla porta 8080 di localhost.

Inviare richieste a localhost

Importante: anche se questo esempio mostra il contenitore in esecuzione in HTTP, ti consigliamo di utilizzare i certificati HTTPS quando esegui il contenitore Docker in un ambiente di produzione. Per maggiori dettagli sulla configurazione di HTTPS e per fornire al container, consulta README.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• LEAKED_USERNAME: nome utente della coppia di credenziali divulgate.
• LEAKED_PASSWORD: la password della coppia di credenziali divulgate.

Metodo HTTP e URL:

POST http://localhost:8080/createAssessment/

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

curl -X POST \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "http://localhost:8080/createAssessment/"

PowerShell

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

$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

Dovresti ricevere una risposta JSON simile alla seguente:

  { "leakedStatus":"LEAKED" }


 OR


  { "leakedStatus":"NO_STATUS" }

Interpreta il verdetto e intraprendi azioni

La risposta della valutazione mostra se le credenziali sono trapelate e ti fornisce informazioni che puoi utilizzare per intraprendere azioni appropriate per proteggere i tuoi utenti.

Nella tabella seguente sono elencate le azioni consigliate che puoi intraprendere quando viene rilevata una password compromessa:

Password divulgata rilevata	Azioni per proteggere gli utenti
Durante l'accesso	Rifiutare e richiedere al cliente di scegliere una password diversa. attivare una verifica MFA, se possibile. Ricorda all'utente di utilizzare password univoche da un account all'altro. Richiedere password efficaci sul tuo sito. Chiedi all'utente di abilitare l'autenticazione a più fattori (MFA) se non la utilizza.
Durante la creazione dell'account o la reimpostazione della password	Richiedi all'utente di cambiare la password. Attivare un flusso di autenticazione a più fattori (MFA).

Se non utilizzi già un provider di autenticazione a due fattori sul tuo sito, puoi utilizzare la funzionalità di autenticazione a due fattori di reCAPTCHA.

Passaggi successivi

• Scopri come utilizzare l'autenticazione a più fattori (MFA).
• Scopri come proteggere gli account utente utilizzando Account Defender reCAPTCHA di reCAPTCHA.