Mit passwortbasierten Konten mit C++ bei Firebase authentifizieren

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Mit Firebase Authentication können Sie Ihre Nutzer über ihre E-Mail-Adressen und Passwörter bei Firebase authentifizieren und die passwortbasierten Konten Ihrer App verwalten.

Hinweis

1. Fügen Sie Ihrem C++-Projekt Firebase hinzu.
2. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verknüpft haben, tun Sie dies in der Firebase Console.
3. Anmeldung per E-Mail-Adresse/Passwort aktivieren:
   1. Öffnen Sie in der Firebase-Konsole den Abschnitt Auth.
   2. Aktivieren Sie auf dem Tab Anmeldemethode die Anmeldemethode E-Mail-Adresse/Passwort und klicken Sie auf Speichern.

Auf die Klasse firebase::auth::Auth zugreifen

1. Fügen Sie die Auth- und App-Headerdateien hinzu:

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

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

   #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__)

3. Rufen Sie die firebase::auth::Auth-Klasse für Ihre firebase::App ab. Es gibt eine eindeutige Zuordnung zwischen App und Auth.

   firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Passwortbasiertes Konto erstellen

Wenn Sie ein neues Nutzerkonto mit einem Passwort erstellen möchten, führen Sie die folgenden Schritte im Anmeldencode Ihrer App aus:

1. Wenn sich ein neuer Nutzer über das Anmeldeformular Ihrer App registriert, führen Sie alle neuen Schritte zur Kontobestätigung durch, die für Ihre App erforderlich sind. Dazu gehört beispielsweise die Überprüfung, ob das Passwort für das neue Konto korrekt eingegeben wurde und den Anforderungen an die Komplexität entspricht.
2. 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);

3. Wenn Ihr Programm eine Update-Schleife hat, die regelmäßig ausgeführt wird (z. B. 30- oder 60-mal pro Sekunde), können Sie die Ergebnisse einmal pro Update 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-Funktion 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:

1. Wenn sich ein Nutzer in deiner App anmeldet, gib seine E-Mail-Adresse und sein Passwort an firebase::auth::Auth::SignInWithEmailAndPassword weiter:

   firebase::Future<firebase::auth::AuthResult> result =
       auth->SignInWithEmailAndPassword(email, password);

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

   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-Funktion registrieren.

Callback für einen Future registrieren

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

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 auf der Seite „Authentifizierungseinstellungen“ den Tab Passwortrichtlinie:

Authentifizierungseinstellungen

Die Passwortrichtlinien von Firebase Authentication unterstützen die folgenden Passwortanforderungen:

• Kleinbuchstaben erforderlich

• Großbuchstaben erforderlich

• Numerisches Zeichen erforderlich

• Nicht alphanumerisches Zeichen erforderlich

  Die folgenden Zeichen erfüllen die Anforderung nicht alphanumerischer Zeichen: ^ $ * . [ ] { } ( ) ? " ! @ # % & / \ , > < ' : ; | _ ~

• Mindestlänge des Passworts (6 bis 30 Zeichen, standardmäßig 6)

• Maximale Passwortlänge (maximal 4.096 Zeichen)

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

• Erforderlich: Die Registrierungsversuche schlagen fehl, bis der Nutzer ein Passwort verwendet, das Ihrer Richtlinie entspricht.

• Benachrichtigen: Nutzer können sich mit einem nicht konformen Passwort registrieren. Wenn Sie diesen Modus verwenden, sollten Sie prüfen, ob das Passwort des Nutzers auf der Clientseite der Richtlinie entspricht, und ihn auffordern, sein Passwort zu aktualisieren, falls dies nicht der Fall ist.

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

Wenn Sie aktive Nutzer haben, empfehlen wir, die erzwungene Umstellung bei der Anmeldung nicht zu aktivieren, es sei denn, Sie möchten den Zugriff für Nutzer blockieren, deren Passwörter nicht Ihren Richtlinien entsprechen. Verwenden Sie stattdessen den Benachrichtigungsmodus, mit dem sich Nutzer mit ihrem aktuellen Passwort anmelden können und über die Anforderungen informiert werden, die 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, wenn sie registriert werden muss (z. B. bei der Anmeldung mit einer E-Mail-Adresse und einem Passwort) oder registriert werden muss, wenn sie nicht verwendet werden muss (z. B. beim Ändern der E-Mail-Adresse eines Nutzers). Das kann zwar hilfreich sein, um Nutzern bestimmte Maßnahmen vorzuschlagen, aber auch von böswilligen Akteuren missbraucht werden, um die von Ihren Nutzern registrierten E-Mail-Adressen zu ermitteln.

Um dieses Risiko zu minimieren, empfehlen wir Ihnen, den Schutz vor E-Mail-Aufzählung für Ihr Projekt mit dem Google Cloud-Tool gcloud zu aktivieren. Hinweis: Wenn Sie diese Funktion aktivieren, ändert sich das Verhalten der Fehlerberichte von Firebase Authentication: Ihre Anwendung sollte nicht auf die spezifischeren Fehler angewiesen sein.

Nächste Schritte

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, d. h. mit dem Nutzernamen und Passwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter, mit denen sich der Nutzer angemeldet hat. 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 er sich anmeldet.

• In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers über das Objekt firebase::auth::User 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 Variablen auth abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

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

Wenn Sie einen Nutzer abmelden möchten, rufen Sie SignOut() auf:

auth->SignOut();