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

Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając wiadomość SMS na telefon użytkownika. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w wiadomości SMS.

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

Zanim zaczniesz

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

Obawy dotyczące bezpieczeństwa

Uwierzytelnianie przy użyciu samego numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenosić pomiędzy użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik mogący odbierać wiadomości SMS może zalogować się na konto przy użyciu numeru telefonu urządzenia.

Jeśli w swojej aplikacji używasz logowania przy użyciu numeru telefonu, powinieneś zaoferować tę opcję obok bezpieczniejszych metod logowania i poinformować użytkowników o kompromisach w zakresie bezpieczeństwa, jakie wiążą się z logowaniem się za pomocą numeru telefonu.

Włącz logowanie za pomocą numeru telefonu w swoim projekcie Firebase

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

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie .
  2. Na stronie Metoda logowania włącz metodę logowania za pomocą numeru telefonu .

Limit żądań logowania na numer telefonu w Firebase jest na tyle wysoki, że nie będzie to miało wpływu na większość aplikacji. Jeśli jednak chcesz zalogować bardzo dużą liczbę użytkowników przy użyciu uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz stronę z cenami .

Zacznij otrzymywać powiadomienia APN (platformy Apple)

Aby korzystać z uwierzytelniania za pomocą numeru telefonu na platformach Apple, Twoja aplikacja musi mieć możliwość odbierania powiadomień APN z Firebase. Gdy po raz pierwszy logujesz się na urządzeniu za pomocą numeru telefonu, funkcja uwierzytelniania Firebase wysyła do urządzenia ciche powiadomienie push w celu sprawdzenia, czy prośba o zalogowanie się na numer telefonu pochodzi z Twojej aplikacji. (Z tego powodu w symulatorze nie można logować się za pomocą numeru telefonu.)

Aby włączyć powiadomienia APN do użytku z uwierzytelnianiem Firebase:

  1. W Xcode włącz powiadomienia push dla swojego projektu.
  2. Prześlij swój certyfikat APNs do Firebase. Jeśli nie masz jeszcze certyfikatu APNs, pamiętaj o utworzeniu go w Apple Developer Member Center .

    1. Wewnątrz projektu w konsoli Firebase wybierz ikonę koła zębatego, wybierz Ustawienia projektu , a następnie wybierz kartę Cloud Messaging .

    2. Wybierz przycisk Prześlij certyfikat dla certyfikatu programistycznego, certyfikatu produkcyjnego lub obu. Wymagany jest co najmniej jeden.

    3. Dla każdego certyfikatu wybierz plik .p12 i podaj hasło, jeśli istnieje. Upewnij się, że identyfikator pakietu dla tego certyfikatu jest zgodny z identyfikatorem pakietu Twojej aplikacji. Wybierz opcję Zapisz .

Wyślij kod weryfikacyjny na telefon użytkownika

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

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale w ramach najlepszej praktyki i w celu ustalenia oczekiwań użytkowników należy poinformować ich, że w przypadku korzystania z logowania przez telefon mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązywać będą standardowe stawki.

  2. Wywołaj PhoneAuthProvider::VerifyPhoneNumber , przekazując mu 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);
    
    Kiedy dzwonisz do PhoneAuthProvider::VerifyPhoneNumber , Firebase,
    • (na iOS) wysyła ciche powiadomienie push do Twojej aplikacji,
    • wysyła wiadomość SMS zawierającą kod uwierzytelniający na podany numer telefonu i przekazuje identyfikator weryfikacyjny do Twojej funkcji zakończenia. Aby zalogować użytkownika, będziesz potrzebować zarówno kodu weryfikacyjnego, jak i identyfikatora weryfikacyjnego.
  3. Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. W ten sposób możesz mieć pewność, że nadal masz ważny identyfikator weryfikacyjny, jeśli aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (na przykład podczas przełączania się do aplikacji do obsługi SMS-ów).

    Możesz zachować identyfikator weryfikacyjny w dowolny sposób. Jeśli piszesz w wieloplatformowym środowisku C++, powinno ono wyświetlać powiadomienia o zamknięciu i przywróceniu aplikacji. W przypadku tych zdarzeń możesz odpowiednio zapisać i przywrócić identyfikator weryfikacyjny.

Jeśli wywołanie VerifyPhoneNumber spowoduje wywołanie OnCodeSent na Twoim odbiorniku, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego po otrzymaniu go w wiadomości SMS.

Z drugiej strony, jeśli wywołanie VerifyPhoneNumber skutkuje OnVerificationCompleted , oznacza to, że automatyczna weryfikacja zakończyła się pomyślnie i będziesz mieć teraz PhoneAuthCredential , którego możesz używać w sposób opisany poniżej.

Zaloguj użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik poda aplikacji kod weryfikacyjny z wiadomości SMS, zaloguj się, tworząc obiekt PhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacyjnego, 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 weryfikacyjnego.
    PhoneAuthCredential credential = phone_auth_provider->GetCredential(
        verification_id_.c_str(), verification_code.c_str());
        
  3. Zaloguj się 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);
    

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i powiązane z poświadczeniami — czyli 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ęść Twojego projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w Twoim projekcie, niezależnie od tego, w jaki sposób użytkownik się loguje.

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

    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 bazy danych Firebase Realtime i Cloud Storage możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik może uzyskać dostęp.

Możesz zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();