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

Możesz używać uwierzytelniania Firebase do logowania użytkownika, wysyłając SMS-a na jego telefon. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w wiadomości SMS.

Z tego dokumentu dowiesz się, jak za pomocą pakietu SDK Firebase wdrożyć proces logowania przez numer telefonu.

Zanim zaczniesz

  1. Dodaj Firebase do projektu C++.
  2. Jeśli Twoja aplikacja nie jest jeszcze połączona z projektem Firebase, możesz to zrobić z poziomu 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 przenieść między użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkownika każdy użytkownik, który może odbierać SMS-y, może zalogować się na konto przy użyciu numeru telefonu tego urządzenia.

Jeśli w swojej aplikacji korzystasz z logowania się na podstawie numeru telefonu, zaoferuj je wraz z bezpieczniejszymi metodami logowania i poinformuj użytkowników o problemach związanych z bezpieczeństwem logowania się przy użyciu numeru telefonu.

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

Aby logować użytkowników SMS-em, musisz najpierw włączyć w projekcie Firebase metodę logowania z numerem telefonu:

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

Limit próśb Firebase o zalogowanie się za pomocą numeru telefonu jest tak wysoki, że nie będzie to miało wpływu na większość aplikacji. Jeśli jednak musisz zalogować bardzo dużą liczbę użytkowników z wykorzystaniem uwierzytelniania przez telefon, konieczne może być przejście na wyższy abonament. Zobacz stronę z cenami.

Zacznij otrzymywać powiadomienia APNs (platformy Apple)

Aby korzystać z uwierzytelniania przez numer telefonu na platformach Apple, Twoja aplikacja musi mieć możliwość odbierania powiadomień o APN z Firebase. Gdy po raz pierwszy logujesz użytkownika na urządzeniu za pomocą jego numeru telefonu, Uwierzytelnianie Firebase wysyła do urządzenia ciche powiadomienie push, aby potwierdzić, że żądanie logowania pochodzi z aplikacji. (Z tego powodu w symulatorze nie można logować się numerem telefonu).

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

  1. W Xcode włącz powiadomienia push dla swojego projektu.

  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 kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie kartę Komunikacja w chmurze.

    2. Kliknij przycisk Prześlij certyfikat dotyczący certyfikatu programistycznego, certyfikatu produkcyjnego lub obu. Trzeba podać co najmniej 1.

    3. Wybierz plik .p12 dla każdego certyfikatu i podaj hasło, jeśli takie jest. 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 zainicjować logowanie z użyciem numeru telefonu, pokaż interfejs z prośbą o podanie numeru telefonu, a następnie zadzwoń pod numer PhoneAuthProvider::VerifyPhoneNumber, aby poprosić Firebase o wysłanie SMS-a z kodem uwierzytelniającym na telefon użytkownika:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale zgodnie ze sprawdzoną metodą oraz ustaleniem oczekiwań użytkowników należy poinformować ich, że jeśli logują się przez telefon, mogą otrzymać SMS-a w celu weryfikacji. Obowiązują opłaty standardowe.

  2. Zadzwoń pod numer PhoneAuthProvider::VerifyPhoneNumber i przekaż 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);
    Gdy zadzwonisz do: PhoneAuthProvider::VerifyPhoneNumber, Firebase:
    • (w iOS) wysyła do aplikacji ciche powiadomienie push,
    • wysyła na podany numer telefonu SMS-a z kodem uwierzytelniającym i przekazuje identyfikator weryfikacyjny do funkcji uzupełniania. Aby zalogować użytkownika, musisz podać zarówno kod weryfikacyjny, jak i identyfikator weryfikacyjny.

  3. Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. Dzięki temu będziesz mieć pewność, że nadal będziesz mieć ważny identyfikator weryfikacyjny, jeśli Twoja aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (na przykład podczas przełączania się do aplikacji do SMS-ów).

    Identyfikator weryfikacyjny możesz zachować w dowolny sposób. Jeśli używasz wieloplatformowej platformy C++, powinna ona wyświetlać powiadomienia o zamknięciu i przywróceniu aplikacji. W przypadku tych zdarzeń możesz zapisać i przywrócić identyfikator weryfikacji.

Jeśli połączenie z VerifyPhoneNumber spowoduje nawiązanie połączenia z odbiornikiem OnCodeSent, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w SMS-ie.

Jeśli natomiast wywołanie VerifyPhoneNumber prowadzi do OnVerificationCompleted, oznacza to, że automatyczna weryfikacja się powiodła i masz teraz identyfikator PhoneAuthCredential, którego możesz używać w sposób opisany poniżej.

Logowanie użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik poda Twojej aplikacji kod weryfikacyjny z SMS-a, zaloguj go, tworząc obiekt PhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacji, a następnie przekazując go 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

Gdy użytkownik loguje się po raz pierwszy, tworzone jest nowe konto użytkownika, które jest łączone z danymi logowania (nazwa użytkownika i hasło, numer telefonu lub informacje o dostawcy uwierzytelniania). Nowe konto jest przechowywane w ramach Twojego projektu Firebase i może być używane do identyfikowania użytkowników we wszystkich aplikacjach w Twoim projekcie niezależnie od tego, jak się on loguje.

  • W swoich 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 zabezpieczeń Bazy danych czasu rzeczywistego Firebase i Cloud Storage możesz pobrać ze zmiennej auth unikalny identyfikator użytkownika zalogowanego użytkownika 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 różnych dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();