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

Za pomocą Firebase Authentication możesz logować użytkowników, wysyłając im SMS-y na ich telefony. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w SMS-ie.

Z tego dokumentu dowiesz się, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.

Zanim zaczniesz

  1. Dodaj Firebase do projektu C++.
  2. Jeśli nie masz jeszcze połączonej aplikacji z projektem w Firebase, zrób to w Firebase konsoli.
  3. Zapoznaj się z wymaganiami platformy dotyczącymi logowania za pomocą numeru telefonu:
    • Logowanie za pomocą numeru telefonu jest dostępne tylko na platformach mobilnych.
    • W systemie iOS logowanie za pomocą numeru telefonu wymaga urządzenia fizycznego i nie będzie działać na symulatorze.

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie tylko za pomocą numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenieść na innego użytkownika. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik, który może odbierać SMS-y, może zalogować się na konto za pomocą numeru telefonu urządzenia.

Jeśli używasz w aplikacji logowania za pomocą numeru telefonu, powinieneś oferować je razem z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach w zakresie bezpieczeństwa związanych z używaniem logowania za pomocą numeru telefonu.

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

Aby logować użytkowników za pomocą SMS-ów, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu w projekcie w Firebase:

  1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania Telefon.
  3. Ustaw zasady dotyczące regionów, w których chcesz zezwolić na wysyłanie SMS-ów lub je zablokować. Ustawienie zasad dotyczących regionów SMS-ów może pomóc w ochronie aplikacji przed nadużyciami związanymi z SMS-ami. W przypadku nowych projektów domyślne zasady nie zezwalają na żadne regiony.
    1. W konsoli Firebase otwórz kartę Zabezpieczenia > Uwierzytelnianie > Ustawienia.
    2. W sekcji Zasady dotyczące regionów SMS-ów skonfiguruj zasady dotyczące regionów SMS-ów.

Zacznij otrzymywać powiadomienia APNs (platformy Apple)

Aby korzystać z uwierzytelniania za pomocą numeru telefonu na platformach Apple, Twoja aplikacja musi mieć możliwość odbierania powiadomień APNs z Firebase. Gdy użytkownik po raz pierwszy zaloguje się na urządzeniu za pomocą numeru telefonu , Firebase Authentication wyśle na urządzenie ciche powiadomienie push , aby sprawdzić, czy prośba o logowanie za pomocą numeru telefonu pochodzi z Twojej aplikacji. (Z tego powodu logowanie za pomocą numeru telefonu nie może być używane na symulatorze).

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

  1. W Xcode włącz powiadomienia push w swoim 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 konsoli Firebase otwórz Ustawienia > Ogólne. Następnie kliknij kartę Komunikacja w chmurze.
    2. Kliknij Prześlij certyfikat w przypadku certyfikatu deweloperskiego, produkcyjnego lub obu. Wymagany jest co najmniej 1 certyfikat.
    3. W przypadku każdego certyfikatu wybierz plik .p12 i podaj hasło, jeśli jest wymagane. Upewnij się, że identyfikator pakietu tego certyfikatu jest zgodny z identyfikatorem pakietu Twojej aplikacji. Kliknij Zapisz.

Wysyłanie kodu weryfikacyjnego na telefon użytkownika

Aby rozpocząć logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs, w którym będzie mógł podać swój numer telefonu, a następnie wywołaj funkcję PhoneAuthProvider::VerifyPhoneNumber, aby poprosić Firebase o wysłanie kodu uwierzytelniającego na telefon użytkownika za pomocą SMS-a:

  1. Pobierz numer telefonu użytkownika.

    Wymagania prawne różnią się w zależności od kraju, ale w ramach najlepszych praktyk i aby spełnić oczekiwania użytkowników, poinformuj ich, że jeśli użyją logowania za pomocą telefonu, mogą otrzymać SMS-a z kodem weryfikacyjnym, a opłaty będą naliczane według standardowych stawek.

  2. Wywołaj funkcję PhoneAuthProvider::VerifyPhoneNumber, przekazując jej numer telefonu użytkownika. 
    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 wywołasz funkcję PhoneAuthProvider::VerifyPhoneNumber, Firebase
    • (w iOS) wyśle do Twojej aplikacji ciche powiadomienie push,
    • wyśle SMS-a z kodem uwierzytelniającym na podany numer telefonu i przekaże identyfikator weryfikacji do funkcji zakończenia. Aby zalogować użytkownika, potrzebujesz zarówno kodu weryfikacyjnego, jak i identyfikatora weryfikacji.

  3. Zapisz identyfikator weryfikacji i przywróć go, gdy aplikacja się załaduje. Dzięki temu możesz mieć pewność, że nadal masz prawidłowy identyfikator weryfikacji, jeśli aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (np. podczas przełączania się na aplikację do SMS-ów).

    Identyfikator weryfikacji możesz utrwalać w dowolny sposób. Jeśli piszesz w wieloplatformowym frameworku C++, powinien on zapewniać powiadomienia o zakończeniu i przywróceniu aplikacji. W przypadku tych zdarzeń możesz zapisać i przywrócić, odpowiednio, identyfikator weryfikacji.

Jeśli wywołanie funkcji VerifyPhoneNumber spowoduje wywołanie funkcji OnCodeSent w Twoim detektorze, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w SMS-ie.

Z drugiej strony, jeśli wywołanie funkcji VerifyPhoneNumber spowoduje wywołanie funkcji OnVerificationCompleted, automatyczna weryfikacja zakończy się powodzeniem i będziesz mieć teraz PhoneAuthCredential, którego możesz użyć w sposób opisany poniżej.

Logowanie użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik poda w aplikacji kod weryfikacyjny z SMS-a , zaloguj go, tworząc obiekt PhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacji, a następnie przekazując ten obiekt do Auth::SignInWithCredential.

  1. Pobierz kod weryfikacyjny od użytkownika.
  2. Utwórz obiekt Credential na podstawie kodu weryfikacyjnego i identyfikatora 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, zostanie utworzone nowe konto użytkownika i połączone z danymi logowania – nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania – za pomocą których użytkownik się zalogował. To nowe konto jest przechowywane jako część projektu w Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od sposobu logowania.

  • W aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu 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 regułach bezpieczeństwa Firebase Realtime Database i Cloud Storage Security Rules, możesz uzyskać unikalny identyfikator zalogowanego użytkownika z zmiennej auth, i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą wielu dostawców uwierzytelniania przez połączenie danych logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();