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

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

Z tego dokumentu dowiesz się, jak wdrożyć 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łączenia aplikacji z projektem 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.
    • Na iOS logowanie za pomocą numeru telefonu wymaga fizycznego urządzenia i nie działa na symulatorze.

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie za pomocą samego numeru telefonu jest wygodne, ale mniej bezpieczne niż inne dostępne metody, ponieważ własność numeru telefonu można łatwo przenieść między użytkownikami. 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, powinieneś/powinnaś oferować je wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach w zakresie bezpieczeństwa związanych z logowaniem za pomocą numeru telefonu.

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

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

  1. W Firebasekonsoli otwórz sekcję Uwierzytelnianie.
  2. Na stronie Metoda logowania włącz metodę logowania Numer telefonu.
  3. Opcjonalnie: na stronie Ustawienia ustaw zasadę dotyczącą regionów, do których chcesz zezwolić na wysyłanie wiadomości SMS lub im tego zabronić. Ustawienie zasad dotyczących regionu SMS-ów może pomóc chronić aplikacje przed nadużyciami związanymi z SMS-ami.

Zacznij otrzymywać powiadomienia APNs (platformy Apple)

Aby korzystać z uwierzytelniania za pomocą numeru telefonu na platformach Apple, aplikacja musi mieć możliwość odbierania powiadomień APNs z Firebase. Gdy użytkownik loguje się na urządzeniu po raz pierwszy za pomocą numeru telefonu, Firebase Authentication wysyła na to 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ć na symulatorze).

Aby włączyć powiadomienia APNs do użytku z usługą 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 Centrum dla deweloperów Apple.

    1. W projekcie w Firebase konsoli kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie kliknij kartę Cloud Messaging.

    2. Kliknij przycisk Prześlij certyfikat w przypadku certyfikatu deweloperskiego, certyfikatu produkcyjnego lub obu tych certyfikatów. Wymagany jest co najmniej 1 element.

    3. W przypadku każdego certyfikatu wybierz plik .p12 i podaj hasło (jeśli jest wymagane). Upewnij się, że identyfikator pakietu dla tego certyfikatu jest zgodny z identyfikatorem pakietu aplikacji. Kliknij Zapisz.

Wysyłanie kodu weryfikacyjnego na telefon użytkownika

Aby rozpocząć logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs z prośbą o podanie numeru telefonu, a następnie wywołaj funkcję 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 są różne, ale zgodnie ze sprawdzonymi metodami i aby spełnić oczekiwania użytkowników, należy poinformować ich, że jeśli użyją logowania za pomocą telefonu, mogą otrzymać SMS-a z prośbą o weryfikację, a w takim przypadku obowiązują standardowe stawki.

  2. Wywołaj funkcję PhoneAuthProvider::VerifyPhoneNumber, przekazując do niej 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 PhoneAuthProvider::VerifyPhoneNumber, Firebase:
    • (na iOS) wysyła ciche powiadomienie push do Twojej aplikacji,
    • wysyła SMS-a z kodem uwierzytelniania na podany numer telefonu i przekazuje 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 po wczytaniu aplikacji. Dzięki temu możesz mieć pewność, że nadal masz prawidłowy identyfikator weryfikacji, jeśli aplikacja zostanie zamknięta, zanim użytkownik dokończy proces logowania (np. podczas przełączania się na aplikację SMS).

    Identyfikator weryfikacji możesz przechowywać w dowolny sposób. Jeśli piszesz za pomocą wieloplatformowego frameworka C++, powinien on wysyłać powiadomienia o zakończeniu i przywróceniu działania aplikacji. W przypadku tych zdarzeń możesz odpowiednio zapisywać i przywracać identyfikator weryfikacji.

Jeśli połączenie z VerifyPhoneNumber spowoduje, że na urządzeniu nasłuchującym zostanie wywołany numer OnCodeSent, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w SMS-ie.

Z drugiej strony, jeśli wywołanie funkcji VerifyPhoneNumber zwróci wartość OnVerificationCompleted, oznacza to, że weryfikacja automatyczna się powiodła i masz teraz obiekt PhoneAuthCredential, którego możesz używać 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 przekaż ten obiekt do funkcji Auth::SignInWithCredential.

  1. Poproś użytkownika o kod weryfikacyjny.
  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 powiązane z danymi logowania, czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania, za pomocą których użytkownik się zalogował. Nowe konto jest przechowywane w projekcie Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach 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 Firebase Realtime Database i Cloud Storage regułach bezpieczeństwa 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 za pomocą wielu dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();