Uwierzytelnij się w Firebase za pomocą łącza e-mail na platformach Apple

Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając mu wiadomość e-mail zawierającą link, który może kliknąć, aby się zalogować. W tym procesie weryfikowany jest również adres e-mail użytkownika.

Logowanie się przez e-mail ma wiele zalet:

  • Rejestracja i logowanie o niskim współczynniku tarcia.
  • Mniejsze ryzyko ponownego użycia hasła w różnych aplikacjach, co może podważyć bezpieczeństwo nawet dobrze wybranych haseł.
  • Możliwość uwierzytelnienia użytkownika przy jednoczesnej weryfikacji, czy użytkownik jest prawowitym właścicielem adresu e-mail.
  • Aby się zalogować, użytkownik potrzebuje jedynie dostępnego konta e-mail. Nie jest wymagane posiadanie numeru telefonu ani konta w mediach społecznościowych.
  • Użytkownik może zalogować się bezpiecznie, bez konieczności podawania (lub zapamiętywania) hasła, co na urządzeniu mobilnym może być uciążliwe.
  • Istniejącego użytkownika, który wcześniej logował się przy użyciu identyfikatora e-mail (hasła lub konta federacyjnego), można uaktualnić tak, aby logował się wyłącznie przy użyciu adresu e-mail. Na przykład użytkownik, który zapomniał hasła, nadal 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 zarządzać nimi.

  1. W Xcode, przy otwartym projekcie aplikacji, przejdź do File > Add Packages .
  2. Po wyświetleniu monitu dodaj repozytorium SDK platform Firebase Apple:
    3.   https://github.com/firebase/firebase-ios-sdk.git
  3. Wybierz bibliotekę uwierzytelniania Firebase.
  4. Dodaj flagę -ObjC do sekcji Inne flagi linkera w ustawieniach kompilacji celu.
  5. Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.

Aby logować użytkowników za pomocą łącza e-mail, musisz najpierw włączyć dostawcę poczty e-mail i metodę logowania za pomocą łącza e-mail dla swojego projektu Firebase:

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie .
  2. Na karcie Metoda logowania włącz dostawcę adresu e-mail/hasła . Pamiętaj, że aby móc logować się za pomocą łącza e-mail, musi być włączone logowanie za pomocą adresu e-mail/hasła.
  3. W tej samej sekcji włącz metodę logowania za pomocą łącza e-mail (logowanie bez hasła) .
  4. Kliknij Zapisz .

Aby zainicjować proces uwierzytelniania, wyświetl użytkownikowi interfejs, który poprosi go o podanie adresu e-mail, a następnie wywołaj sendSignInLink , aby poprosić Firebase o przesłanie linku uwierzytelniającego na adres e-mail użytkownika.

  1. Skonstruuj obiekt ActionCodeSettings , który udostępnia Firebase instrukcje dotyczące tworzenia łącza e-mail. Ustaw następujące pola:

    • url: Głęboki link do osadzenia i wszelki dodatkowy stan, który należy przekazać. Domena linku musi znajdować się na białej liście w konsoli Firebase Console, na liście autoryzowanych domen, którą można znaleźć przechodząc do zakładki Metoda logowania (Uwierzytelnianie -> Metoda logowania).
    • iOSBundleID i androidPackageName: aplikacje, które mają być używane po otwarciu łącza logowania na urządzeniu z systemem Android lub Apple. Dowiedz się więcej o konfigurowaniu łączy dynamicznych Firebase w celu otwierania linków do działań w wiadomościach e-mail za pośrednictwem aplikacji mobilnych.
    • handleCodeInApp: Ustaw na true. Operację logowania należy zawsze przeprowadzić w aplikacji, w przeciwieństwie do innych pozapasmowych działań e-mailowych (reset hasła i weryfikacja adresu e-mail). Dzieje się tak, ponieważ na końcu przepływu oczekuje się, że użytkownik będzie zalogowany, a jego stan uwierzytelnienia zostanie utrwalony w aplikacji.
    • dynamicLinkDomain: Jeśli dla projektu zdefiniowano wiele niestandardowych domen łączy dynamicznych, określ, która z nich ma być używana, gdy łącze ma być otwierane za pośrednictwem określonej aplikacji mobilnej (na przykład example.page.link ). W przeciwnym wypadku automatycznie wybierana jest pierwsza domena.

    Szybki

    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

    Cel 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

    Aby dowiedzieć się więcej na temat ActionCodeSettings, zapoznaj się z sekcją Przekazywanie stanu w akcjach e-mailowych .

  2. Poproś użytkownika o adres e-mail.

  3. Wyślij link uwierzytelniający na adres e-mail użytkownika i zapisz adres e-mail użytkownika na wypadek, gdyby użytkownik ukończył logowanie e-mailem na tym samym urządzeniu.

    Szybki

    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

    Cel 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

Obawy dotyczące bezpieczeństwa

Aby zapobiec używaniu linku do logowania do logowania się jako niezamierzony użytkownik lub na niezamierzonym urządzeniu, Firebase Auth wymaga podania adresu e-mail użytkownika podczas kończenia procesu logowania. Aby logowanie się powiodło, ten adres e-mail musi być zgodny z adresem, na który pierwotnie został wysłany link do logowania.

Możesz usprawnić ten przepływ dla użytkowników, którzy otwierają link do logowania na tym samym urządzeniu, na którym proszą o łącze, przechowując ich adresy e-mail lokalnie, gdy wysyłasz wiadomość e-mail do logowania. Następnie użyj tego adresu, aby zakończyć przepływ.

Po zakończeniu logowania wszelkie dotychczasowe niezweryfikowane mechanizmy logowania zostaną usunięte z użytkownika, a wszelkie istniejące sesje zostaną unieważnione. Na przykład, jeśli ktoś wcześniej utworzył niezweryfikowane konto przy użyciu tego samego adresu e-mail i hasła, hasło użytkownika zostanie usunięte, aby uniemożliwić osobie podszywającej się, która rościła sobie prawo własności i utworzyła to niezweryfikowane konto, ponowne zalogowanie się na to samo konto.

Kończenie logowania w aplikacji mobilnej Apple

Uwierzytelnianie Firebase wykorzystuje łącza dynamiczne Firebase do wysyłania linku e-mail na urządzenie mobilne. Aby móc logować się za pomocą aplikacji mobilnej, należy ją skonfigurować tak, aby wykrywała przychodzące łącze do aplikacji, analizowała głęboki link, a następnie dokończyła logowanie.

Firebase Auth korzysta z Firebase Dynamic Links podczas wysyłania linku, który ma zostać otwarty w aplikacji mobilnej. Aby móc korzystać z tej funkcji, należy skonfigurować łącza dynamiczne w konsoli Firebase.

  1. Włącz łącza dynamiczne Firebase:

    1. W konsoli Firebase otwórz sekcję Linki dynamiczne .

    2. Jeśli jeszcze nie zaakceptowałeś warunków Linków Dynamicznych i nie utworzyłeś domeny Dynamic Links, zrób to teraz.

      Jeśli masz już domenę Dynamic Links, zanotuj to. Domena Linków Dynamicznych zazwyczaj wygląda jak w poniższym przykładzie:

      example.page.link

      Ta wartość będzie Ci potrzebna podczas konfigurowania aplikacji na urządzenia Apple lub Android w celu przechwytywania łącza przychodzącego.

  2. Konfigurowanie aplikacji Apple:

    1. Jeśli planujesz obsługiwać te łącza ze swojej aplikacji, identyfikator pakietu musi zostać określony w ustawieniach projektu konsoli Firebase. Ponadto należy podać identyfikator App Store i identyfikator zespołu programistów Apple.
    2. Będziesz także musiał skonfigurować domenę obsługi akcji e-mail jako domenę skojarzoną w możliwościach aplikacji. Domyślnie moduł obsługi akcji e-mail jest hostowany w domenie, jak w poniższym przykładzie:
      APP_ID.firebaseapp.com
    3. Jeśli planujesz rozpowszechniać swoją aplikację na iOS w wersji 8 i starszej, musisz ustawić identyfikator pakietu jako niestandardowy schemat dla przychodzących adresów URL.
    4. Więcej informacji na ten temat można znaleźć w instrukcji odbierania łączy dynamicznych platformy Apple .

Po otrzymaniu linku w sposób opisany powyżej sprawdź, czy służy on do uwierzytelniania łącza e-mail i dokończ logowanie.

Szybki

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

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

}

Cel 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 za pomocą łącza e-mail w aplikacji na Androida, zapoznaj się z przewodnikiem po Androidzie .

Aby dowiedzieć się, jak obsługiwać logowanie za pomocą łącza e-mail w aplikacji internetowej, zapoznaj się z przewodnikiem internetowym .

Możesz także powiązać tę metodę uwierzytelniania z istniejącym użytkownikiem. Na przykład użytkownik uwierzytelniony wcześniej u innego dostawcy, na przykład za pomocą numeru telefonu, może dodać tę metodę logowania do swojego istniejącego konta.

Różnica będzie dotyczyć drugiej połowy operacji:

Szybki

  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.
  }

Cel 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.
  }];

Można to również wykorzystać do ponownego uwierzytelnienia użytkownika łącza e-mail przed wykonaniem poufnej operacji.

Szybki

  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.
  }

Cel 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.
  }];

Ponieważ jednak przepływ może zakończyć się na innym urządzeniu, na którym pierwotny użytkownik nie był zalogowany, przepływ ten może nie zostać ukończony. W takim przypadku użytkownikowi może zostać wyświetlony błąd mający na celu wymuszenie otwarcia łącza na tym samym urządzeniu. W łączu można przekazać pewien stan, aby dostarczyć informacji o typie operacji i identyfikatorze użytkownika.

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

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

Więcej szczegółów można znaleźć w dokumentacji dotyczącej ochrony wyliczeń adresów e-mail .

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

  • 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 funkcję signOut: .

Szybki

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

Cel C

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

Możesz także dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Zobacz Błędy obsługi .