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

Możesz użyć Firebase Authentication, aby zalogować użytkownika, wysyłając SMS-a na jego telefon. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w SMS-ie.

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

Zanim zaczniesz

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

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie przy użyciu samego numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ numer telefonu można łatwo przenieść między użytkownikami. 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, używając numeru telefonu urządzenia.

Jeśli w aplikacji używasz logowania za pomocą numeru telefonu, udostępnij tę opcję obok bezpieczniejszych metod logowania i poinformuj użytkowników o kompromisach związanych z bezpieczeństwem, które wiążą się z używaniem numeru telefonu do logowania.

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

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

  1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania przez telefon.
  3. Skonfiguruj zasadę dotyczącą regionów, do których chcesz zezwolić na wysyłanie SMS-ów lub zabronić ich wysyłania. Ustawienie zasad dotyczących regionu SMS-ów może pomóc chronić aplikacje przed nadużyciami związanymi z SMS-ami. W przypadku nowych projektów domyślna zasada nie zezwala na żadne regiony.
    1. W konsoli Firebase otwórz kartę Zabezpieczenia > Uwierzytelnianie > Ustawienia.
    2. W sekcji Zasady dotyczące regionów SMS skonfiguruj zasady dotyczące regionów SMS.

Zacznij otrzymywać powiadomienia APNs (platformy Apple)

Aby korzystać z uwierzytelniania za pomocą numeru telefonu na platformach Apple, aplikacja musi mieć możliwość odbierania powiadomień APN z Firebase. Gdy po raz pierwszy logujesz użytkownika za pomocą jego numeru telefonu na urządzeniu, Firebase Authentication wysyła na urządzenie ciche powiadomienie push, aby sprawdzić, czy prośba o zalogowanie się za pomocą numeru telefonu pochodzi z Twojej aplikacji. (Z tego powodu logowania za pomocą numeru telefonu nie można używać w symulatorze).

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

  1. W Xcode włącz 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 konsoli Firebase otwórz Ustawienia > Ogólne. Następnie kliknij kartę Komunikacja w chmurze.
    2. Kliknij Prześlij certyfikat, aby przesłać certyfikat programistyczny, certyfikat produkcyjny lub oba te certyfikaty. Trzeba podać co najmniej 1 formę kontaktu.
    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 aplikacji. Kliknij Zapisz.

wysłać kod weryfikacyjny na telefon użytkownika,

Aby rozpocząć logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs, który prosi o podanie numeru telefonu, a następnie wywołaj PhoneAuthProvider::VerifyPhoneNumber, aby poprosić Firebase o wysłanie kodu uwierzytelniającego na telefon użytkownika SMS-em:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne różnią się, ale zgodnie ze sprawdzonymi metodami i aby spełnić oczekiwania użytkowników, poinformuj ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać SMS-a z prośbą o weryfikację i że obowiązują standardowe opłaty.

  2. Wywołaj PhoneAuthProvider::VerifyPhoneNumber, przekazując 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).
    // There's no need for the end user to input the verification code manually.
    // `credential` can't 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łujesz PhoneAuthProvider::VerifyPhoneNumber, Firebase,
    • (na iOS) wysyła do aplikacji ciche powiadomienie push,
    • wysyła SMS-a z kodem uwierzytelniającym na podany numer telefonu i przekazuje identyfikator weryfikacyjny do funkcji zakończenia. Do zalogowania użytkownika potrzebny będzie zarówno kod weryfikacyjny, jak i identyfikator weryfikacji.

  3. Zapisz identyfikator weryfikacji i przywróć go po załadowaniu aplikacji. Dzięki temu będziesz mieć pewność, że nadal masz ważny 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 zachować w dowolny sposób. Jeśli piszesz kod w środowisku C++ na wiele platform, powinno ono udostępniać powiadomienia o zakończeniu i przywróceniu aplikacji. W tych zdarzeniach możesz odpowiednio zapisać i przywrócić identyfikator weryfikacji.

Jeśli wywołanie VerifyPhoneNumber spowoduje wywołanie OnCodeSent w obiekcie nasłuchującym, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w SMS-ie.

Jeśli jednak wywołanie VerifyPhoneNumber zwróci OnVerificationCompleted, oznacza to, że automatyczna weryfikacja się powiodła i masz 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. Uzyskaj 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

Po pierwszym zalogowaniu się użytkownika tworzone jest nowe konto użytkownika i łączone z danymi logowania, czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania, których użytkownik użył do zalogowania się. To nowe konto jest przechowywane w projekcie w Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach w projekcie, niezależnie od tego, jak się loguje.

  • 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 Firebase Realtime Database i Cloud Storageregułach zabezpieczeń możesz pobrać unikalny identyfikator zalogowanego użytkownika ze 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 przy użyciu wielu dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();