Uwierzytelnianie w Firebase za pomocą linku e-mail na platformach Apple

Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając mu e-maila z linkiem, który może kliknąć, aby się zalogować. Podczas procesu weryfikacji zweryfikowany jest też adres e-mail użytkownika.

Logowanie się przez e-maila ma wiele zalet:

  • Rejestracja i logowanie przebiegają sprawnie.
  • Mniejsze ryzyko ponownego użycia tego samego hasła w różnych aplikacjach, co może zagrażać bezpieczeństwu nawet dobrze dobranych haseł.
  • Możliwość uwierzytelnienia użytkownika, a jednocześnie potwierdzanie, że jest on prawowitym właścicielem adresu e-mail.
  • Aby się zalogować, użytkownik potrzebuje tylko dostępnego konta e-mail. Nie jest wymagane posiadanie numeru telefonu ani konta w mediach społecznościowych.
  • Użytkownik może logować się bezpiecznie bez konieczności podawania (lub zapamiętywania) hasła, co może być uciążliwe na urządzeniu mobilnym.
  • Istniejące konto użytkownika, które wcześniej logowało się przy użyciu identyfikatora e-mail (hasła lub konta sfederowanego), można przejść na wyższą wersję, aby logować się przy użyciu samego adresu e-mail. Na przykład użytkownik, który nie pamięta hasła, może się zalogować bez konieczności resetowania hasła.

Zanim zaczniesz

Użyj menedżera pakietów Swift, aby zainstalować zależności Firebase i nimi zarządzać.

  1. Po otwarciu projektu aplikacji przejdź w Xcode do File > Add Packages (Plik > Dodaj pakiety).
  2. Gdy pojawi się prośba, dodaj repozytorium SDK platform Apple Platform SDK Firebase:
    3.   https://github.com/firebase/firebase-ios-sdk.git
  3. Wybierz bibliotekę uwierzytelniania Firebase.
  4. Dodaj flagę -ObjC do sekcji Inne flagi łączące w ustawieniach kompilacji celu.
  5. Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie zależności w tle.

Aby logować użytkowników za pomocą linku w e-mailu, musisz najpierw włączyć w projekcie Firebase metodę logowania Dostawca poczty e-mail i metodę logowania się za pomocą linku w e-mailu:

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę E-mail/hasła. Pamiętaj, że aby korzystać z logowania za pomocą linku e-mail, musisz włączyć logowanie za pomocą adresu e-mail i hasła.
  3. W tej samej sekcji włącz metodę logowania Link w e-mailu (logowanie bez hasła).
  4. Kliknij Zapisz.

Aby zainicjować proces uwierzytelniania, udostępnij użytkownikowi interfejs, który prosi o podanie adresu e-mail, a następnie wywołaj sendSignInLink z prośbą o wysłanie przez Firebase linku uwierzytelniającego na jego adres e-mail.

  1. Utwórz obiekt ActionCodeSettings, który dostarcza Firebase z instrukcjami, jak utworzyć link do e-maila. Ustaw wartości w tych polach:

    • url: precyzyjny link do umieszczenia i wszystkie dodatkowe stany do przekazania. Domena linku musi znajdować się na białej liście na liście autoryzowanych domen w konsoli Firebase. Aby ją znaleźć, przejdź na kartę Metoda logowania (Uwierzytelnianie -> Metoda logowania).
    • iOSBundleID i androidPackageName : aplikacje używane po otwarciu linku logowania na urządzeniu z Androidem lub firmy Apple. Dowiedz się więcej o tym, jak skonfigurować Linki dynamiczne Firebase, aby otwierać linki do działań w e-mailach w aplikacjach mobilnych.
    • handleCodeInApp: ustaw wartość true (prawda). Operacja logowania musi być zawsze wykonywana w aplikacji, w przeciwieństwie do innych pozapasmowych działań związanych z e-mailami (resetowania hasła i potwierdzania adresu e-mail). Wynika to z faktu, że pod koniec procesu użytkownik musi być zalogowany, a jego stan uwierzytelniania musi pozostać w aplikacji.
    • DynamicLinkDomain: jeśli w projekcie zdefiniowanych jest wiele niestandardowych domen linków dynamicznych, określ, która z nich ma być używana, gdy link ma być otwierany przez określoną aplikację mobilną (np. example.page.link). W przeciwnym razie automatycznie zostanie wybrana pierwsza domena.

    Swift

    let actionCodeSettings = ActionCodeSettings()
actionCodeSettings.url = URL(string: "https://www.example.com")
// The sign-in operation has to always be completed in the app.
actionCodeSettings.handleCodeInApp = true
actionCodeSettings.setIOSBundleID(Bundle.main.bundleIdentifier!)
actionCodeSettings.setAndroidPackageName("com.example.android",
                                         installIfNotAvailable: false, minimumVersion: "12")
    PasswordlessViewController.swift

    Objective-C

    FIRActionCodeSettings *actionCodeSettings = [[FIRActionCodeSettings alloc] init];
[actionCodeSettings setURL:[NSURL URLWithString:@"https://www.example.com"]];
// The sign-in operation has to always be completed in the app.
actionCodeSettings.handleCodeInApp = YES;
[actionCodeSettings setIOSBundleID:[[NSBundle mainBundle] bundleIdentifier]];
[actionCodeSettings setAndroidPackageName:@"com.example.android"
                    installIfNotAvailable:NO
                           minimumVersion:@"12"];
    PasswordlessViewController.m

    Więcej informacji o ActionCodeSettings znajdziesz w sekcji Stan przekazywania w czynnościach poczty e-mail.

  2. Poproś użytkownika o podanie adresu e-mail.

  3. Wyślij link uwierzytelniania na adres e-mail użytkownika i zapisz adres e-mail użytkownika, na wypadek gdyby użytkownik logował się za pomocą adresu e-mail na tym samym urządzeniu.

    Swift

    Auth.auth().sendSignInLink(toEmail: email,
                           actionCodeSettings: actionCodeSettings) { error in
  // ...
    if let error = error {
      self.showMessagePrompt(error.localizedDescription)
      return
    }
    // The link was successfully sent. Inform the user.
    // Save the email locally so you don't need to ask the user for it again
    // if they open the link on the same device.
    UserDefaults.standard.set(email, forKey: "Email")
    self.showMessagePrompt("Check your email for link")
    // ...
}
    PasswordlessViewController.swift

    Objective-C

    [[FIRAuth auth] sendSignInLinkToEmail:email
                   actionCodeSettings:actionCodeSettings
                           completion:^(NSError *_Nullable error) {
  // ...
    if (error) {
      [self showMessagePrompt:error.localizedDescription];
       return;
    }
    // The link was successfully sent. Inform the user.
    // Save the email locally so you don't need to ask the user for it again
    // if they open the link on the same device.
    [NSUserDefaults.standardUserDefaults setObject:email forKey:@"Email"];
    [self showMessagePrompt:@"Check your email for link"];
    // ...
}];
    PasswordlessViewController.m

Potencjalne problemy z bezpieczeństwem

Aby zapobiec użyciu linku logowania do zalogowania się jako niezamierzony użytkownik lub na niewłaściwym urządzeniu, Uwierzytelnianie Firebase wymaga podania adresu e-mail użytkownika podczas logowania się. Aby logowanie się powiodło, ten adres e-mail musi być zgodny z adresem, na który pierwotnie przesłano link.

Jeśli chcesz uprościć ten proces dla użytkowników klikających link logowania na tym samym urządzeniu, o który go proszą, możesz zapisać swój adres e-mail lokalnie podczas wysyłania e-maila logowania. Użyj tego adresu, aby dokończyć proces.

Po zakończeniu logowania wszystkie wcześniejsze niezweryfikowane mechanizmy logowania zostaną usunięte z konta użytkownika, a wszystkie istniejące sesje zostaną unieważnione. Jeśli na przykład ktoś wcześniej utworzył niezweryfikowane konto z tym samym adresem e-mail i tym samym hasłem, jego hasło zostanie usunięte, aby uniemożliwić osobie podszywającej się pod inną osobę, która zgłosiła prawo własności do niezweryfikowanego konta, i mogła zalogować się na nie ponownie za pomocą tego samego konta.

Logowanie się w aplikacji mobilnej Apple

Uwierzytelnianie Firebase używa Linków dynamicznych Firebase do wysyłania linku e-mail na urządzenie mobilne. Aby zalogować się za pomocą aplikacji mobilnej, należy skonfigurować aplikację tak, aby wykrywała przychodzący link do aplikacji, przeanalizowała precyzyjny link i ukończyła logowanie.

Uwierzytelnianie Firebase używa Linków dynamicznych Firebase do wysyłania linku, który ma być otwierany w aplikacji mobilnej. Aby korzystać z tej funkcji, musisz skonfigurować Linki dynamiczne w konsoli Firebase.

  1. Włącz Linki dynamiczne Firebase:

    1. W konsoli Firebase otwórz sekcję Połączenia dynamiczne.

    2. Jeśli Warunki Linków dynamicznych nie zostały jeszcze zaakceptowane i masz utworzoną domenę Linków dynamicznych, zrób to teraz.

      Jeśli masz już utworzoną domenę Linki dynamiczne, zanotuj ją. Domena linków dynamicznych zwykle wygląda tak jak w przykładzie poniżej:

      example.page.link

      Będzie ona potrzebna podczas konfigurowania aplikacji na Apple lub Androida w taki sposób, aby przechwytywała link przychodzący.

  2. Konfigurowanie aplikacji Apple:

    1. Jeśli planujesz obsługę tych linków z poziomu aplikacji, należy określić identyfikator pakietu w ustawieniach projektu w Konsoli Firebase. Musisz też podać identyfikator App Store i identyfikator zespołu Apple Developer Team.
    2. Musisz też skonfigurować domenę modułu obsługi działań poczty e-mail jako domenę powiązaną z funkcjami aplikacji. Domyślnie moduł obsługi działań na poczcie e-mail jest hostowany w domenie, jak w tym przykładzie:
      APP_ID.firebaseapp.com
    3. Jeśli planujesz dystrybuować swoją aplikację na iOS w wersji 8 i starszych, musisz ustawić identyfikator pakietu jako schemat niestandardowy dla przychodzących adresów URL.
    4. Więcej informacji na ten temat znajdziesz w instrukcjach dotyczących odbierania linków dynamicznych platformy Apple.

Po otrzymaniu linku (zgodnie z opisem powyżej) upewnij się, że służy on do uwierzytelniania za pomocą linku w e-mailu, i zaloguj się.

Swift

if Auth.auth().isSignIn(withEmailLink: link) {
AppDelegate.swift

        Auth.auth().signIn(withEmail: email, link: self.link) { user, error in
          // ...
        }
PasswordlessViewController.swift

}

Objective-C

if ([[FIRAuth auth] isSignInWithEmailLink:link]) {
AppDelegate.m

    [[FIRAuth auth] signInWithEmail:email
                               link:link
                         completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
      // ...
    }];
PasswordlessViewController.m

}

Aby dowiedzieć się, jak obsługiwać logowanie się w aplikacji na Androida za pomocą linku e-mail, zapoznaj się z przewodnikiem na temat Androida.

Aby dowiedzieć się, jak obsługiwać logowanie się w aplikacji internetowej za pomocą linku przez e-maila, zapoznaj się z Przewodnikiem po stronie internetowej.

Możesz też powiązać tę metodę uwierzytelniania z istniejącym użytkownikiem. Na przykład użytkownik, który wcześniej uwierzytelnił się u innego dostawcy (np. przy użyciu numeru telefonu), może dodać tę metodę logowania do swojego istniejącego konta.

Różnica będzie widoczna w drugiej połowie operacji:

Swift

  let credential = EmailAuthCredential.credential(withEmail:email
                                                       link:link)
  Auth.auth().currentUser?.link(with: credential) { authData, error in
    if (error) {
      // And error occurred during linking.
      return
    }
    // The provider was successfully linked.
    // The phone user can now sign in with their phone number or email.
  }

Objective-C

  FIRAuthCredential *credential =
      [FIREmailAuthProvider credentialWithEmail:email link:link];
  [FIRAuth auth].currentUser
      linkWithCredential:credential
              completion:^(FIRAuthDataResult *_Nullable result,
                           NSError *_Nullable error) {
    if (error) {
      // And error occurred during linking.
      return;
    }
    // The provider was successfully linked.
    // The phone user can now sign in with their phone number or email.
  }];

W ten sposób możesz też ponownie uwierzytelnić użytkownika powiązanego z linkiem e-mail przed uruchomieniem operacji poufnej.

Swift

  let credential = EmailAuthProvider.credential(withEmail:email
                                                       link:link)
  Auth.auth().currentUser?.reauthenticate(with: credential) { authData, error in
    if (error) {
      // And error occurred during re-authentication.
      return
    }
    // The user was successfully re-authenticated.
  }

Objective-C

  FIRAuthCredential *credential =
      [FIREmailAuthCredential credentialWithEmail:email link:link];
  [FIRAuth auth].currentUser
      reauthenticateWithCredential:credential
                        completion:^(FIRAuthDataResult *_Nullable result,
                                     NSError *_Nullable error) {
    if (error) {
      // And error occurred during re-authentication
      return;
    }
    // The user was successfully re-authenticated.
  }];

Proces ten może jednak nie zostać ukończony na innym urządzeniu, na którym pierwotny użytkownik nie był zalogowany. W takim przypadku może wyświetlić się komunikat o błędzie, który będzie wymuszał na nim otwarcie linku na tym samym urządzeniu. W linku można przekazać informacje o typie działania i identyfikatorze UID użytkownika.

Jeśli Twój projekt został utworzony 15 września 2023 r. lub później, ochrona przed wyliczeniem adresów e-mail jest domyślnie włączona. Ta funkcja zwiększa bezpieczeństwo kont użytkowników Twojego projektu, ale wyłącza metodę fetchSignInMethodsForEmail(), którą wcześniej rekomendowaliśmy w celu implementacji przepływów skoncentrowanych na identyfikatorze.

Chociaż możesz wyłączyć ochronę wyliczania adresów e-mail w projekcie, nie zalecamy tego.

Więcej informacji znajdziesz w dokumentacji dotyczącej ochrony przed wyliczeniem adresów e-mail.

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 User . Zobacz Zarządzanie użytkownikami.

  • 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:.

Swift

let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}

Objective-C

NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Możesz też dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Patrz sekcja Obsługa błędów.