Uwierzytelniaj w Firebase przy użyciu numeru telefonu i języka C++

Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając SMS-a do telefonu użytkownika. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w SMS.

W tym dokumencie opisujemy, jak wdrożyć proces logowania się przy użyciu numeru telefonu za pomocą pakiet SDK Firebase.

Zanim zaczniesz

  1. Dodaj Firebase do swojego C++ projekt.
  2. Jeśli Twoja aplikacja nie jest jeszcze połączona z projektem Firebase, zrób to na stronie w konsoli Firebase.
  3. Zapoznaj się z wymaganiami platformy dotyczącymi logowania się za pomocą numeru telefonu:
    • Logowanie się za pomocą numeru telefonu jest możliwe tylko na platformach mobilnych.
    • W systemie iOS logowanie się za pomocą numeru telefonu wymaga fizycznego urządzenia i nie działa na symulatorze.

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie przy użyciu numeru telefonu, choć jest wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenosić między użytkownikami. Także na urządzeniach z wieloma użytkownikami profili, każdy użytkownik, który może odbierać wiadomości SMS, może zalogować się na konto przy użyciu z numerem telefonu urządzenia.

Jeśli w aplikacji korzystasz z logowania się na podstawie numeru telefonu, z bezpieczniejszymi metodami logowania oraz informować użytkowników logowanie się przy użyciu numeru telefonu.

Włączanie logowania się za pomocą numeru telefonu w projekcie Firebase

Aby logować użytkowników za pomocą SMS-ów, musisz najpierw włączyć logowanie się przy użyciu numeru telefonu do swojego projektu Firebase:

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  2. Na stronie Sign-in Method (Metoda logowania) włącz Phone Number. metody logowania się.

Limit próśb o zalogowanie się za pomocą numeru telefonu w Firebase jest tak wysoki, że większość aplikacji nie będzie mieć wpływu na dane. Jeśli jednak musisz logować się bardzo dużo użytkowników uwierzytelnianie przez telefon może wymagać przejścia na wyższy abonament. Zobacz cennik.

Zacznij otrzymywać powiadomienia APNs (platformy Apple)

Aby korzystać z uwierzytelniania przez numer telefonu na platformach Apple, aplikacja musi mieć możliwość odbierania Powiadomienia APNs z Firebase. Gdy logujesz użytkownika za pomocą telefonu po raz pierwszy na danym urządzeniu, Uwierzytelnianie Firebase wysyła dyskretne powiadomienie push powiadomienie na urządzenie, by potwierdzić, że prośba o zalogowanie się numer telefonu pochodzi z aplikacji. (Z tego powodu nie można zalogować się za pomocą numeru telefonu w symulatorze).

Aby włączyć powiadomienia APNs do użytku z Uwierzytelnianiem Firebase:

  1. W Xcode włączyć powiadomienia push w projekcie.

  2. Prześlij certyfikat APNs do Firebase. Jeśli nie masz jeszcze certyfikatu APNs, utwórz go w Apple Developer Member Center

    1. W projekcie w konsoli Firebase wybierz ikona koła zębatego, wybierz Ustawienia projektu, a potem wybierz Karta Komunikacja w chmurze.

    2. Wybierz Prześlij certyfikat. certyfikatu programistycznego, certyfikatu produkcji lub obu tych rodzajów danych. Co najmniej 1

    3. Dla każdego certyfikatu wybierz plik .p12 i wskaż i hasło. Sprawdź, czy identyfikator pakietu tego certyfikatu pasuje do identyfikatora pakietu Twojej aplikacji. Wybierz Zapisz.

Wysyłanie kodu weryfikacyjnego na telefon użytkownika

Aby rozpocząć logowanie za pomocą numeru telefonu, użyj interfejsu z prośbą o wyświetlenie prośby podać swój numer telefonu, a następnie zadzwonić PhoneAuthProvider::VerifyPhoneNumber, aby poprosić Firebase o wysłanie przy użyciu SMS-a z kodem uwierzytelniającym:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale jest to sprawdzona metoda i określać oczekiwania użytkowników, należy ich poinformować, przez telefon, mogą otrzymać SMS-a w celu weryfikacji i standardowego obowiązują opłaty.

  2. Wywołaj PhoneAuthProvider::VerifyPhoneNumber, przekazując do niego numeru telefonu. 
    class PhoneListener : public PhoneAuthProvider::Listener {
 public:
  ~PhoneListener() override {}

  void OnVerificationCompleted(PhoneAuthCredential credential) override {
    // Auto-sms-retrieval or instant validation has succeeded (Android only).
    // No need for the user to input the verification code manually.
    // `credential` can be used instead of calling GetCredential().
  }

  void OnVerificationFailed(const std::string& error) override {
    // Verification code not sent.
  }

  void OnCodeSent(const std::string& verification_id,
                  const PhoneAuthProvider::ForceResendingToken&
                      force_resending_token) override {
    // Verification code successfully sent via SMS.
    // Show the Screen to enter the Code.
    // Developer may want to save that verification_id along with other app states in case
    // the app is terminated before the user gets the SMS verification code.
  }
};

PhoneListener phone_listener;
PhoneAuhtOptions options;
options.timeout_milliseconds = kAutoVerifyTimeOut;
options.phone_number = phone_number;
PhoneAuthProvider& phone_provider = PhoneAuthProvider::GetInstance(auth);
phone_provider->VerifyPhoneNumber(options, &phone_listener);
    Gdy zadzwonisz do aplikacji PhoneAuthProvider::VerifyPhoneNumber, Firebase,
    • (w iOS) wysyła do aplikacji ciche powiadomienie push,
    • wysyła do podanego numeru SMS-a z kodem uwierzytelniającym numeru telefonu i przekazuje identyfikator weryfikacyjny do funkcji uzupełniania. Musisz podać zarówno kod weryfikacyjny, jak i identyfikator weryfikacyjny, aby zaloguj się na swoje konto użytkownika.

  3. Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. Dzięki temu możesz sprawdzić, czy Twoja aplikacja jest nadal ważnym identyfikatorem weryfikacyjnym. kończy się, zanim użytkownik zakończy proces logowania (na przykład na aplikację do SMS-ów).

    Identyfikator weryfikacyjny możesz zachować w dowolny sposób. Jeśli piszesz wykorzystujący wieloplatformową platformę C++, powinien dostarczać powiadomienia zakończenia i przywracania danych. Możesz je zapisywać i przywracać, identyfikator weryfikacji.

Jeśli wywołanie VerifyPhoneNumber kończy się OnCodeSent na swoim detektorze, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego po otrzymaniu go w wiadomości SMS.

Jeśli natomiast wywołanie VerifyPhoneNumber spowoduje OnVerificationCompleted, automatyczna weryfikacja się powiodła i będziesz teraz mieć PhoneAuthCredential, którego możesz używać zgodnie z opisem. poniżej.

Logowanie użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik poda aplikacji kod weryfikacyjny z SMS-a zaloguj użytkownika, tworząc PhoneAuthCredential z kodu weryfikacyjnego i identyfikatora weryfikacji i przekazując ten obiekt, do: Auth::SignInWithCredential.

  1. Uzyskaj kod weryfikacyjny od użytkownika.
  2. Utwórz obiekt Credential z kodu weryfikacyjnego i identyfikator weryfikacji. 
    PhoneAuthCredential credential = phone_auth_provider->GetCredential(
    verification_id_.c_str(), verification_code.c_str());
  3. Zaloguj użytkownika za pomocą obiektu Credential: 
    Future<User> future = auth_->SignInWithCredential(credential);
future.OnCompletion(
    [](const Future<User*>& result, void*) {
      if (result.error() == kAuthErrorNone) {
        // Successful.
        // User is signed in.
        User user = *result.result();

        // This should display the phone number.
        printf("Phone number: %s", user.phone_number().c_str());

        // The phone number provider UID is the phone number itself.
        printf("Phone provider uid: %s", user.uid().c_str());

        // The phone number providerID is 'phone'
        printf("Phone provider ID: %s", user.provider_id().c_str());
      } else {
        // Error.
        printf("Sign in error: %s", result.error_message().c_str());
      }
    },
    nullptr);

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, tworzone jest nowe konto użytkownika. powiązane z danymi logowania, czyli z nazwą użytkownika, hasłem i numerem telefonu, numer telefonu lub informacje o dostawcy uwierzytelniania – użytkownik zalogowany. Ten nowy jest przechowywane w ramach projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się loguje.

  • W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z Obiekt firebase::auth::User:

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

  • W Bazie danych czasu rzeczywistego Firebase i Cloud Storage reguł zabezpieczeń, możesz pobierz ze zmiennej auth unikalny identyfikator zalogowanego użytkownika, i używać ich do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji przy użyciu wielokrotnego uwierzytelniania. dostawców, łącząc dane logowania dostawcy uwierzytelniania z istniejącego konta użytkownika.

Aby wylogować użytkownika, wywołaj SignOut():

auth->SignOut();