Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Mit passwortbasierten Konten mit C++ bei Firebase authentifizieren

Mit Firebase Authentication können Sie Nutzer mit ihren E‑Mail-Adressen und Passwörtern bei Firebase authentifizieren und die passwortbasierten Konten Ihrer App verwalten.

Hinweis

Fügen Sie Firebase zu Ihrem C++-Projekt hinzu.
Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verknüpft haben, tun Sie dies in der Firebase Console.
Aktivieren Sie die E‑Mail-Adresse/das Passwort als Anmeldedienst für Ihr Firebase-Projekt:
1. Wechseln Sie in der Firebase-Konsole zu Sicherheit > Authentifizierung.
2. Aktivieren Sie auf dem Tab Anmeldemethode den E-Mail-Adresse/Passwort-Anmeldeanbieter.
3. Klicken Sie auf Speichern.
Tipp:Wenn Sie lieber die Firebase-Befehlszeile verwenden möchten, führen Sie firebase init auth aus, um Authentifizierungsanbieter zu konfigurieren, und dann firebase deploy --only auth, um die Änderungen in Ihrem Projekt bereitzustellen.

Auf die `firebase::auth::Auth`-Klasse zugreifen

Die Auth-Klasse ist das Gateway für alle API-Aufrufe.

Fügen Sie die Headerdateien für die Authentifizierung und die App hinzu:

#include <cassert>
#include <cstdint>

#include "firebase/app.h"
#include "firebase/auth.h"

Erstellen Sie in Ihrem Initialisierungscode eine Klasse firebase::App.

#if defined(__ANDROID__)
  firebase::App* app =
      firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);
#else
  firebase::App* app = firebase::App::Create(firebase::AppOptions());
#endif  // defined(__ANDROID__)

Rufen Sie die firebase::auth::Auth-Klasse für Ihr firebase::App ab. Es gibt eine 1:1-Beziehung zwischen App und Auth.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Passwortbasiertes Konto erstellen

So erstellen Sie ein neues Nutzerkonto mit einem Passwort:

Wenn sich ein neuer Nutzer über das Registrierungsformular Ihrer App registriert, führen Sie alle neuen Schritte zur Kontobestätigung aus, die für Ihre App erforderlich sind, z. B. die Bestätigung, dass das Passwort des neuen Kontos korrekt eingegeben wurde und die Komplexitätsanforderungen erfüllt.
Erstellen Sie ein neues Konto, indem Sie die E-Mail-Adresse und das Passwort des neuen Nutzers an Auth::CreateUserWithEmailAndPassword übergeben:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
```

Wenn Ihr Programm eine Aktualisierungsschleife hat, die regelmäßig ausgeführt wird (z. B. 30- oder 60-mal pro Sekunde), können Sie die Ergebnisse einmal pro Aktualisierung mit Auth::CreateUserWithEmailAndPasswordLastResult prüfen:

firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const firebase::auth::AuthResult auth_result = *result.result();
    printf("Create user succeeded for email %s\n",
           auth_result.user.email().c_str());
  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

Wenn Ihr Programm ereignisgesteuert ist, können Sie auch einen Callback für die Future registrieren.

Nutzer mit E‑Mail-Adresse und Passwort anmelden

Die Schritte zum Anmelden eines Nutzers mit einem Passwort ähneln denen zum Erstellen eines neuen Kontos. Gehen Sie in der Anmeldefunktion Ihrer App so vor:

Wenn sich ein Nutzer in Ihrer App anmeldet, übergeben Sie die E‑Mail-Adresse und das Passwort des Nutzers an firebase::auth::Auth::SignInWithEmailAndPassword:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);
```

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for email %s\n",
           auth_result.user.email().c_str());
  } else {
    printf("Sign in failed with error '%s'\n", result.error_message());
  }
}

Wenn Ihr Programm ereignisgesteuert ist, können Sie auch einen Callback für die Future registrieren.

Callback für ein Future registrieren

Einige Programme haben Update-Funktionen, die 30- oder 60-mal pro Sekunde aufgerufen werden. Viele Spiele folgen diesem Modell. Diese Programme können die LastResult-Funktionen aufrufen, um asynchrone Aufrufe abzufragen. Wenn Ihr Programm jedoch ereignisgesteuert ist, sollten Sie Callback-Funktionen registrieren. Nach Abschluss des Future wird eine Callback-Funktion aufgerufen.

void OnCreateCallback(const firebase::Future<firebase::auth::User*>& result,
                      void* user_data) {
  // The callback is called when the Future enters the `complete` state.
  assert(result.status() == firebase::kFutureStatusComplete);

  // Use `user_data` to pass-in program context, if you like.
  MyProgramContext* program_context = static_cast<MyProgramContext*>(user_data);

  // Important to handle both success and failure situations.
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());

    // Perform other actions on User, if you like.
    firebase::auth::User::UserProfile profile;
    profile.display_name = program_context->display_name;
    user->UpdateUserProfile(profile);

  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

void CreateUser(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}

Die Callback-Funktion kann auch ein Lambda sein.

void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // The lambda has the same signature as the callback function.
  result.OnCompletion(
      [](const firebase::Future<firebase::auth::User*>& result,
         void* user_data) {
        // `user_data` is the same as &my_program_context, below.
        // Note that we can't capture this value in the [] because std::function
        // is not supported by our minimum compiler spec (which is pre C++11).
        MyProgramContext* program_context =
            static_cast<MyProgramContext*>(user_data);

        // Process create user result...
        (void)program_context;
      },
      &my_program_context);
}

Empfohlen: Passwortrichtlinie festlegen

Sie können die Kontosicherheit verbessern, indem Sie Anforderungen an die Komplexität von Passwörtern erzwingen.

Wenn Sie eine Passwortrichtlinie für Ihr Projekt konfigurieren möchten, öffnen Sie in der Firebase-Konsole den Bereich Passwortrichtlinie auf dem Tab Sicherheit > Authentifizierung > Einstellungen:

Authentifizierungseinstellungen

Firebase Authentication-Passwortrichtlinien unterstützen die folgenden Anforderungen an Passwörter:

Kleinbuchstaben erforderlich
Großbuchstaben erforderlich
Numerisches Zeichen erforderlich
Nicht alphanumerisches Zeichen erforderlich

Die folgenden Zeichen erfüllen die Anforderung für nicht alphanumerische Zeichen: ^ $ * . [ ] { } ( ) ? " ! @ # % & / \ , > < ' : ; | _ ~
Mindestlänge des Passworts (6 bis 30 Zeichen; Standardwert: 6)
Maximale Länge des Passworts (maximal 4.096 Zeichen)

Sie können die Erzwingung von Passwortrichtlinien in zwei Modi aktivieren:

Erforderlich: Anmeldeversuche schlagen fehl, wenn Nutzer ein Passwort verwenden, das nicht Ihrer Richtlinie entspricht.
Benachrichtigen: Nutzer dürfen sich mit einem nicht konformen Passwort registrieren. Wenn Sie diesen Modus verwenden, sollten Sie clientseitig prüfen, ob das Passwort des Nutzers der Richtlinie entspricht, und den Nutzer auf irgendeine Weise auffordern, sein Passwort zu aktualisieren, wenn dies nicht der Fall ist.

Neue Nutzer müssen immer ein Passwort auswählen, das Ihren Richtlinien entspricht.

Wenn Sie aktive Nutzer haben, empfehlen wir, die Erzwingung von Upgrades bei der Anmeldung nicht zu aktivieren, es sei denn, Sie möchten den Zugriff für Nutzer blockieren, deren Passwörter nicht Ihrer Richtlinie entsprechen. Verwenden Sie stattdessen den Benachrichtigungsmodus. So können sich Nutzer mit ihren aktuellen Passwörtern anmelden und werden darüber informiert, welche Anforderungen ihr Passwort nicht erfüllt.

Empfohlen: Schutz vor E-Mail-Enumeration aktivieren

Einige Firebase Authentication-Methoden, die E-Mail-Adressen als Parameter verwenden, geben bestimmte Fehler aus, wenn die E-Mail-Adresse nicht registriert ist, obwohl sie registriert sein muss (z. B. bei der Anmeldung mit einer E-Mail-Adresse und einem Passwort), oder registriert ist, obwohl sie nicht verwendet werden darf (z. B. beim Ändern der E-Mail-Adresse eines Nutzers). Das kann zwar hilfreich sein, um Nutzern bestimmte Abhilfemaßnahmen vorzuschlagen, aber auch von böswilligen Akteuren missbraucht werden, um die von Ihren Nutzern registrierten E‑Mail-Adressen herauszufinden.

Um dieses Risiko zu minimieren, empfehlen wir, dass Sie den Schutz vor E‑Mail-Enumeration für Ihr Projekt aktivieren. Sie können diese Einstellung in der Firebase-Konsole prüfen: Gehen Sie zum Tab Sicherheit > Authentifizierung > Einstellungen und klicken Sie dann auf Nutzeraktionen.

Wenn Sie diese Funktion aktivieren, ändert sich das Verhalten bei der Fehlerberichterstattung für Firebase Authentication. Achten Sie also darauf, dass Ihre App nicht auf den spezifischeren Fehlern basiert.

Nächste Schritte

Wenn sich ein Nutzer zum ersten Mal anmeldet, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, mit denen sich der Nutzer angemeldet hat, also mit dem Nutzernamen und Passwort, der Telefonnummer oder den Informationen des Authentifizierungsanbieters. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in allen Apps in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Nutzer anmeldet.

In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers aus dem firebase::auth::User-Objekt abrufen:

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string name = user.display_name();
  std::string email = user.email();
  std::string photo_url = user.photo_url();
  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

In Ihren Firebase Realtime Database- und Cloud Storage-Sicherheitsregeln können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der auth-Variablen abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

Sie können Nutzern erlauben, sich mit mehreren Authentifizierungsanbietern in Ihrer App anzumelden, indem Sie Anmeldedaten des Authentifizierungsanbieters mit einem vorhandenen Nutzerkonto verknüpfen.

Rufen Sie SignOut() auf, um einen Nutzer abzumelden:

auth->SignOut();