Datenlecks und gehackte Anmeldedaten erkennen

Auf dieser Seite wird beschrieben, wie Sie die Funktion zur Passwortleck-Erkennung von reCAPTCHA verwenden, um Passwortlecks und gehackte Anmeldedaten zu erkennen und so Kontoübernahmen (Account Takeovers, ATOs) und Credential Stuffing-Angriffe zu verhindern. Mit können Sie regelmäßig Audits der Nutzeranmeldedaten (Passwörter) im Rahmen einer Prüfung, um sicherzustellen, dass sie nicht gehackt wurden. Für diese Prüfungen verwendet Google die Funktion Passwortcheck verwenden.

Wichtig: Die Erkennung von Passwortlecks nutzt eine sichere Berechnung durch mehrere Parteien. (MPC) zum Schutz von Nutzerdaten. Wenn Sie eine Passwortprüfung anfordern, kann dies beim Erstellen einer Bewertung zusätzliche Latenz verursachen. Obwohl die Antwortzeit viel kürzer ist, empfehlen, beim Erstellen eines 500ms-Zeitlimits mit der Erkennung von Passwortlecks.

Hinweise

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

2. Richten Sie reCAPTCHA ein.

3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

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

Auf manipulierte und gehackte Anmeldedaten prüfen

Mit dem Befehl kryptografischer Funktionen oder den Docker-Container zu verwenden.

Der Docker-Container ist ein Open-Source-Client, der die sichere Berechnung durch mehrere Parteien die erforderlich ist, um die Privatsphäre der Endnutzer zu schützen und Passwortlecks sicher aufzuspüren. 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 verwenden.

Kryptografische Funktion

Mit der Funktion „Erkennung von Passwortlecks“ können Sie prüfen, ob bestimmte Anmeldedaten gehackt wurden. wenn Sie Prüfungen für Aktionen wie Anmeldungen, Passwortänderungen für die Passwortzurücksetzung.

So prüfen Sie, ob Ihre Passwörter und Anmeldedaten gehackt wurden:

1. Erstellen Sie Anfrageparameter.
2. Bewertung erstellen, um Passwortlecks zu erkennen
3. Gehackte Anmeldedaten aus einer Bewertung prüfen
4. Ergebnis interpretieren und Maßnahmen ergreifen:

Anfrageparameter generieren

1. Berechnen Sie die erforderlichen Anfrageparameter mithilfe der kryptografischen Funktionen, die für das datenschutzfreundliche Protokoll erforderlich sind. reCAPTCHA bietet Java- und TypeScript-Bibliotheken, die beim Generieren dieser Felder helfen:

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

1. Um Bestätigungen zur Passwortprüfung zu erstellen, erstelle eine PasswordCheckVerifier -Objekt enthält.

   PasswordCheckVerifier verifier = new PasswordCheckVerifier();
   

2. Rufen Sie PasswordCheckVerifier#createVerification an, um die Bestätigung einzuleiten. Bei dieser Methode werden der Nutzername und das Passwort verwendet, um die Parameter für führen Sie die Passwortprüfung durch.

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

3. Erstellen Sie mit den Bestätigungsparametern 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 zur Erkennung von Passwortlecks erstellen

Verwenden Sie die Methode projects.assessments.create.

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 für den Nutzernamen
• ENCRYPTED_USER_CREDENTIALS_HASH: Verschlüsselter Verschlüsselungs-Hash der Nutzeranmeldedaten

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

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch bei der gcloud CLI anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

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

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud CLI angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

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 in etwa folgende JSON-Antwort 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="]
  }
}

Gehackte Anmeldedaten aus einer Bewertung prüfen

Extrahieren Sie aus der Antwort der Prüfung die Felder reEncryptedUserCredentials und encryptedLeakMatchPrefixes und übergeben Sie sie an das Verifier-Objekt, um festzustellen, ob die Anmeldedaten gehackt wurden oder nicht.

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

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

Codebeispiel

Die folgenden Codebeispiele zeigen, wie Sie die Passwortleckerkennung mithilfe der Java- und TypeScript-Bibliotheken implementieren:

Java

Richten Sie zur Authentifizierung bei reCAPTCHA die Standardanmeldedaten für Anwendungen ein. 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;
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)

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

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

Docker-Container

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Um zu prüfen, ob Anmeldedaten gehackt wurden, senden Sie den Nutzernamen und Paar der Anmeldedaten für den Container über eine localhost-Verbindung oder durch HTTPS für den Container einrichten. Der Container verschlüsselt diese Anmeldedaten dann, bevor er eine API-Anfrage an reCAPTCHA sendet, und überprüft das neu verschlüsselte Ergebnis lokal.

Hinweis: Anmeldedaten, die auf diese Weise freigegeben werden, werden von Google nie gelesen oder entschlüsselt. Die Überprüfung erfolgt durch den Container selbst.

So senden Sie Anfragen an den Docker-Container:

1. Richten Sie Docker ein.
2. Umgebung für den Docker-Container vorbereiten
3. Erstellen Sie den Container und führen Sie ihn aus.
4. HTTP-Anfragen an den Container senden
5. Ergebnis interpretieren und Maßnahmen ergreifen:

Ausführung des Docker-Containers vorbereiten

1. Wählen Sie eine Authentifizierungsstrategie aus.

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

2. Konfigurieren Sie den PLD-Container so, dass er mit HTTPS oder im Demomodus nur für localhost ausgeführt wird.

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

In den folgenden Schritten wird die API-Schlüsselauthentifizierung verwendet und der Client wird im Demomodus 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 bedienen.

Localhost-Anfragen senden

Wichtig: In diesem Beispiel wird der Container über HTTP ausgeführt. Wir empfehlen jedoch, HTTPS-Zertifikate zu verwenden, wenn Sie den Docker-Container in einer Produktionsumgebung ausführen. Weitere Informationen zum Einrichten von HTTPS und zum Bereitstellen von Zertifikaten für den Container findest du in der README-Datei.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

• LEAKED_USERNAME: Nutzername des gehackten Anmeldedatenpaars.
• LEAKED_PASSWORD: Passwort des gehackten Anmeldedaten-Paares.

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 in etwa folgende JSON-Antwort erhalten:

  { "leakedStatus":"LEAKED" }


 OR


  { "leakedStatus":"NO_STATUS" }

Entscheidung auswerten und Maßnahmen ergreifen

Die Bewertungsantwort zeigt, ob die Anmeldedaten gehackt wurden, und bietet 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 gehacktes Passwort erkannt:

Gehacktes Passwort erkannt	Maßnahmen zum Schutz Ihrer Nutzer
Während der Anmeldung	Lehnen Sie das Passwort ab und fordern Sie den Kunden auf, ein anderes Passwort auszuwählen. Lösen Sie nach Möglichkeit eine MFA-Herausforderung aus. Erinnern Sie den Nutzer daran, für alle Konten eindeutige Passwörter zu verwenden. Legen Sie starke Passwörter für Ihre Website fest. Nutzer auffordern, die Multi-Faktor-Authentifizierung (MFA) zu aktivieren, wenn sie sie nicht verwendet
Bei der Kontoerstellung oder beim Zurücksetzen des Passworts	Nutzer auffordern, ihr Passwort zu ändern Lösen Sie einen Multi-Faktor-Authentifizierungsablauf (MFA) aus.

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

Nächste Schritte

• Multi-Faktor-Authentifizierung (MFA) verwenden
• Informationen zum Schutz von Nutzerkonten mit reCAPTCHA Account Defender