Gehackte Passwörter und Anmeldedaten erkennen

Auf dieser Seite wird beschrieben, wie Sie mit der Funktion „Password Defense“ von reCAPTCHA Passwortlecks und gehackte Anmeldedaten erkennen können, um Kontoübernahmen (Account Takeovers, ATOs) und Credential Stuffing-Angriffe zu verhindern. Mit reCAPTCHA können Sie im Rahmen jeder Bewertung regelmäßig Audits von Nutzeranmeldedaten (Passwörtern) ausführen, um sicherzustellen, dass sie nicht manipuliert oder gehackt wurden. Zur Durchführung dieser Bewertungen verwendet Google die Passwortcheck-Funktion.

Hinweis

  1. Bereiten Sie Ihre Umgebung für reCAPTCHA vor.

  2. Richten Sie reCAPTCHA ein.

  3. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

    Für reCAPTCHA muss die Abrechnung mit dem Projekt verknüpft und für dieses aktiviert sein, damit die Funktion „Password Defense“ verwendet werden kann. Sie können die Abrechnung entweder mithilfe einer Kreditkarte oder anhand einer vorhandenen Google Cloud Abrechnungs-ID für das Projekt aktivieren. Wenn Sie Hilfe bei der Abrechnung benötigen, wenden Sie sich an den Cloud Billing-Support.

Auf gehackte und durchgesickerte Anmeldedaten prüfen

Sie können prüfen, ob ein Satz Anmeldedaten manipuliert wurde, indem Sie kryptografische Funktionen oder den Docker-Container verwenden.

Der Docker-Container ist ein Open-Source-Client, der die Multi-Party Computation implementiert, die erforderlich ist, um die Privatsphäre von Endnutzern zu schützen und sicher nach Passwortlecks zu suchen. Weitere Informationen finden Sie im GitHub-Repository. Der Docker-Container abstrahiert die Komplexität der Implementierung der kryptografischen Algorithmen und vereinfacht den Installationsprozess. Außerdem können Sie die Container-App in Ihrer Infrastruktur hosten.

Kryptografische Funktion

Wenn Sie prüfen möchten, ob ein Satz Anmeldedaten manipuliert wurde, verwenden Sie Password Defense, wenn Sie Bewertungen für Aktionen wie Anmeldungen, Passwortänderungen und Passwortzurücksetzungen erstellen.

So prüfen Sie auf Passwortlecks und gehackte Anmeldedaten:

  1. Generieren Sie Anfrageparameter.
  2. Erstellen Sie eine Bewertung zum Erkennen von gehackten Passwörtern.
  3. Überprüfen Sie in der Bewertung erkannte gehackte Anmeldedaten.
  4. Interpretieren Sie das Urteil und ergreifen Sie Maßnahmen.

Anfrageparameter generieren

  1. Berechnen Sie die erforderlichen Anfrageparameter mit den kryptografischen Funktionen, die für das Protokoll mit hohem Datenschutz erforderlich sind. reCAPTCHA bietet Java- und TypeScript-Bibliotheken, die Sie beim Generieren dieser Felder unterstützen:

  2. Erstellen Sie ein PasswordCheckVerifier-Objekt, um Passwortprüfungen zu erstellen.

    PasswordCheckVerifier verifier = new PasswordCheckVerifier();

  3. Rufen Sie PasswordCheckVerifier#createVerification auf, um eine Überprüfung zu starten. Mit dieser Methode werden der Nutzername und das Passwort verwendet, um die Parameter für die Passwortprüfung zu berechnen.

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

  4. Erstellen Sie mit den Überprüfungsparametern eine Bewertung.

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

    Die Byte-Arrays lookupHashPrefix und encryptedUserCredentialsHash enthalten die Parameter, die zum Starten einer Passwortprüfung Assessment erforderlich sind.

Bewertung zum Erkennen von gehackten Passwörtern erstellen

Verwenden Sie die projects.assessments.create Methode.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Google Cloud Projekt-ID.
  • LOOKUP_HASH_PREFIX: Präfix des SHA-256-Hash-Präfixes des Nutzernamens.
  • ENCRYPTED_USER_CREDENTIALS_HASH: Mit Scrypt verschlüsselter Hash der Anmeldedaten des Nutzers.

HTTP-Methode und URL: 

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

JSON-Text der Anfrage: 

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

In Bewertung erkannte gehackte Anmeldedaten überprüfen

Extrahieren Sie aus der Bewertungsantwort die Felder reEncryptedUserCredentials und encryptedLeakMatchPrefixes und übergeben Sie sie an das Verifiziererobjekt, um zu ermitteln, ob die Anmeldedaten durchgesickert sind.

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

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

Codebeispiel

Node.js (TypeScript)

Informationen zum Implementieren der Erkennung von Passwortlecks mit Node.js (TypeScript) finden Sie im TypeScript-Codebeispiel auf GitHub.

Java

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Fraud Defense zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


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

Docker-Container

Wenn Sie prüfen möchten, ob Anmeldedaten durchgesickert sind, senden Sie das Paar aus Nutzername und Passwort sicher über eine Localhost-Verbindung oder durch Einrichten von HTTPS im Container an den Container. Der Container verschlüsselt diese Anmeldedaten dann, bevor er eine API-Anfrage an reCAPTCHA sendet, und überprüft das neu verschlüsselte Ergebnis lokal.

So senden Sie Anfragen an den Docker-Container:

  1. Richten Sie Docker ein.
  2. Bereiten Sie eine Umgebung für den Docker-Container vor.
  3. Erstellen und führen Sie den Container aus.
  4. Senden Sie HTTP-Anfragen an den Container.
  5. Interpretieren Sie das Urteil und ergreifen Sie Maßnahmen.

Vorbereiten der Ausführung des Docker-Containers

  1. Wählen Sie eine Authentifizierungsstrategie aus.

    Der Container unterstützt das Festlegen von Standardanmeldedaten für Anwendungen oder kann einen API-Schlüssel zur Authentifizierung akzeptieren.

  2. Konfigurieren Sie den PLD-Container für die Ausführung mit HTTPS oder im Demo-Modus nur für Localhost.

    Da der Container vertrauliche Anmeldedaten von Endnutzern (Nutzernamen und Passwörter) akzeptiert, muss er entweder mit HTTPS oder im Demo-Modus nur für Localhost ausgeführt werden. Eine Anleitung zur HTTPS-Konfiguration finden Sie in der README-Datei auf GitHub.

In den folgenden Schritten wird die API-Schlüsselauthentifizierung verwendet und der Client wird im Demo-Modus nur für Localhost ausgeführt.

Docker-Container erstellen und ausführen

  1. Klonen Sie das Repository:

    git clone github.com/GoogleCloudPlatform/reCAPTCHA-PLD

  2. Erstellen Sie den Container:

    docker build . -t pld-local

  3. Starten Sie den Container:

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

Der Container wird gestartet und beginnt, Anfragen auf Port 8080 von Localhost zu verarbeiten.

Localhost-Anfragen senden

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LEAKED_USERNAME: Nutzername des durchgesickerten Anmeldedatenpaars.
  • LEAKED_PASSWORD: Passwort des durchgesickerten Anmeldedatenpaars.

HTTP-Methode und URL: 

POST http://localhost:8080/createAssessment/

JSON-Text der Anfrage: 

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:


  { "leakedStatus":"LEAKED" }


 OR


  { "leakedStatus":"NO_STATUS" }

Urteil interpretieren und Maßnahmen ergreifen

Die Bewertungsantwort zeigt, ob die Anmeldedaten durchgesickert sind, und liefert Ihnen Informationen, mit denen Sie geeignete Maßnahmen zum Schutz Ihrer Nutzer ergreifen können.

In der folgenden Tabelle sind die empfohlenen Maßnahmen aufgeführt, die Sie ergreifen können, wenn ein durchgesickertes Passwort erkannt wird:

Durchgesickertes Passwort erkannt Maßnahmen zum Schutz Ihres Nutzers
Bei der Anmeldung
  • Lehnen Sie die Anmeldung ab und fordern Sie den Kunden auf, ein anderes Passwort zu wählen. Lösen Sie nach Möglichkeit eine MFA-Abfrage aus.
  • Erinnern Sie den Nutzer daran, für verschiedene Konten unterschiedliche Passwörter zu verwenden.
  • Erzwingen Sie starke Passwörter auf Ihrer Website.
  • Fordern Sie den Nutzer auf, die Multi-Faktor-Authentifizierung (MFA) zu aktivieren, wenn er sie nicht verwendet.
Bei der Kontoerstellung oder Passwortzurücksetzung
  • Fordern Sie den Nutzer auf, sein Passwort zu ändern.
  • Lösen Sie einen Multi-Faktor-Authentifizierungsablauf (MFA) aus.

Wenn Sie auf Ihrer Website noch keinen MFA-Anbieter verwenden, können Sie die MFA-Funktion von reCAPTCHA nutzen.

Nächste Schritte