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 zawierający link, który może kliknąć, aby się zalogować. W trakcie tego procesu użytkownik Adres e-mail również został zweryfikowany.

Logowanie się przez e-maila ma wiele zalet:

  • Rejestracja i logowanie przebiegają sprawnie.
  • Mniejsze ryzyko ponownego użycia hasła w różnych aplikacjach, co może zagrażać bezpieczeństwu nawet dobrze dobrane hasła.
  • Możliwość uwierzytelnienia użytkownika, a jednocześnie weryfikacja, czy użytkownik jest jest uprawnionym właścicielem adresu e-mail.
  • Aby się zalogować, użytkownik musi mieć tylko dostępne konto e-mail. Brak własności elementu Numer telefonu lub konto w mediach społecznościowych są wymagane.
  • Użytkownik może logować się bezpiecznie bez konieczności podawania (lub zapamiętania) co może być uciążliwe na urządzeniu mobilnym.
  • Istniejący użytkownik, który wcześniej zalogował się przy użyciu identyfikatora e-mail (hasła) lub sfederowanego) może przejść na wyższą wersję, aby logować się za pomocą samego adresu e-mail. Na przykład plik użytkownik, który nie pamięta hasła, może się zalogować bez konieczności resetować hasło.

Zanim zaczniesz

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

  1. W Xcode po otwarciu projektu aplikacji przejdź do File > 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 lub zależności w tle.

Aby zalogować użytkowników za pomocą linku w e-mailu, musisz najpierw włączyć dostawcę poczty e-mail Metoda logowania za pomocą linku wysłanego e-mailem do projektu Firebase:

  1. W konsoli Firebase otwórz Auth (Uwierzytelnianie).
  2. Na karcie Metoda logowania włącz dostawcę E-mail/hasła. Notatka że logowanie za pomocą adresu e-mail za pomocą linku wymaga włączenia logowania za pomocą adresu e-mail i hasła.
  3. W tej samej sekcji włącz logowanie się przy użyciu opcji Link w e-mailu (logowanie bez hasła). .
  4. Kliknij Zapisz.

Aby zainicjować proces uwierzytelniania, przekaż użytkownikowi interfejs, który prosi użytkownika o podanie adresu e-mail, a następnie sendSignInLink, aby poprosić Firebase o sprawdzenie, wyślij link uwierzytelniania na adres e-mail użytkownika.

  1. Utwórz obiekt ActionCodeSettings, który udostępnia Firebase instrukcje tworzenia linku 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 w konsoli Firebase autoryzowane domeny, które można znaleźć na karcie Metoda logowania. (Uwierzytelnianie -> Metoda logowania).
    • iOSBundleID i androidPackageName : aplikacje, które mają być używane w przypadku linku logowania. jest otwarty na urządzeniu z Androidem lub firmy Apple. Dowiedz się więcej o tym, Skonfiguruj Linki dynamiczne Firebase otwierać w aplikacjach mobilnych linki do działań w e-mailach.
    • handleCodeInApp: ustaw wartość true (prawda). Operacja logowania musi zawsze wykonane w aplikacji w przeciwieństwie do innych spoza zakresu działań związanych z e-mailami (hasło resetowanie urządzenia i potwierdzanie adresu e-mail). To dlatego, że na końcu cyklu użytkownik powinien być zalogowany, a jego stan uwierzytelniania utrzymywał się przez aplikację.
    • DynamicLinkDomain: gdy zdefiniowano wiele niestandardowych domen linków dynamicznych w projekcie, określ, który z nich ma być używany przy otwieraniu linku określoną aplikację mobilną (np. example.page.link). W przeciwnym razie Pierwsza domena jest wybierana automatycznie.

    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 tutaj Stan udanego działania e-maili .

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

  3. Wyślij link uwierzytelniania na adres e-mail użytkownika i zapisz jego adres e-mail. w sytuacji, gdy użytkownik zaloguje się przez e-maila 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

Zapobieganie używaniu linku logowania do logowania się jako niezamierzony użytkownik lub po jego włączeniu niezamierzonym urządzeniem, Uwierzytelnianie Firebase wymaga podania adresu e-mail użytkownika podany podczas logowania. Aby można było się zalogować, ten adres e-mail musi odpowiadać adresowi, na który został pierwotnie wysłany link umożliwiający zalogowanie się.

Możesz usprawnić ten proces w przypadku użytkowników, którzy po kliknięciu linku logowania z urządzenia, z którego użytkownik poprosi o link, zapisując swój adres e-mail lokalnie wyślij e-maila logowania. Użyj tego adresu, aby dokończyć proces.

Po zakończeniu logowania każdy wcześniej niezweryfikowany mechanizm logowania zostanie wyłączony. zostanie usunięte z konta użytkownika, a wszystkie istniejące sesje zostaną unieważnione. Na przykład jeśli ktoś wcześniej utworzył niezweryfikowane konto z tym samym i hasła, hasło zostanie usunięte, by zapobiec Użytkownik podszywający się pod Ciebie, który zgłosił prawo własności i utworzył niezweryfikowane konto z zaloguj się ponownie na to samo konto.

Logowanie się w aplikacji mobilnej Apple

Uwierzytelnianie Firebase używa Linków dynamicznych Firebase do wysyłania linku e-mail do urządzenia mobilnego. W celu zalogowania się za pomocą aplikacji mobilnej aplikacja należy skonfigurować, aby wykrywać przychodzący link aplikacji, przeanalizować użyj precyzyjnego linku, a potem zaloguj się.

Uwierzytelnianie Firebase używa Linków dynamicznych Firebase do wysyłania który powinien być otwierany w aplikacji mobilnej. Aby korzystać z Linki dynamiczne należy skonfigurować w konsoli Firebase.

  1. Włącz Linki dynamiczne Firebase:

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

    2. Jeśli nie zaakceptujesz jeszcze warunków korzystania z Linków dynamicznych ani nie masz utworzonych Linków dynamicznych domeny, zrób to teraz.

      Jeśli masz już utworzoną domenę Linki dynamiczne, zanotuj ją. Link dynamiczny domena zwykle wygląda tak:

      example.page.link

      Ta wartość będzie potrzebna podczas konfigurowania aplikacji na Apple lub Androida przechwytywać 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 konsoli Firebase ustawieniach projektu. Dodatkowo identyfikator App Store i identyfikator Apple Trzeba też podać identyfikator zespołu.
    2. Domenę modułu obsługi działań poczty e-mail musisz też skonfigurować jako Powiązana domena w możliwościach aplikacji. Domyślnie atrybut Moduł obsługi działań związanych z pocztą 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 lub starszej, musisz ustawić identyfikator pakietu jako schemat niestandardowy dla przychodzących Adresy URL.
    4. Więcej informacji: Instrukcje dotyczące linków dynamicznych platformy Apple.

Po otrzymaniu linku w sposób opisany powyżej sprawdź, czy jest on przeznaczony do e-maili. uwierzytelnienie połączenia i dokończenie logowania.

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ę za pomocą linku e-mail na urządzeniu z Androidem aplikacji znajdziesz w przewodniku po Androidzie.

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

Możesz też powiązać tę metodę uwierzytelniania z istniejącym użytkownikiem. Przykład: użytkownik został wcześniej uwierzytelniony u innego dostawcy, np. przy użyciu numeru telefonu; mogą 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żna też ponownie uwierzytelnić użytkownika korzystającego z linku e-mail przed uruchomieniem poufnej operacji.

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

Ponieważ przepływ może jednak skończyć się na innym urządzeniu, na którym pierwotny użytkownik Użytkownik nie jest zalogowany, ten proces mógł nie zostać ukończony. W takim przypadku błąd może ma być wyświetlana użytkownikowi, aby zmusić go do otwarcia linku na tym samym urządzeniu. Niektóre stan można przekazać w linku w celu podania informacji o typie operacji oraz identyfikator UID użytkownika.

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

Chociaż możesz wyłączyć ochronę wyliczania adresów e-mail w projekcie, takiego działania.

Zapoznaj się z dokumentacją dotyczącą ochrony przed wyliczeniem adresów e-mail .

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, tworzone jest nowe konto użytkownika. powiązane z danymi logowania, czyli z nazwą użytkownika, hasłem i numerem telefonu, numer telefonu lub informacje o dostawcy uwierzytelniania – użytkownik zalogowany. Ten nowy jest przechowywane w ramach projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się loguje.

  • W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z User . Zobacz Zarządzanie użytkownikami.

  • W Bazie danych czasu rzeczywistego Firebase i Cloud Storage reguł zabezpieczeń, możesz pobierz ze zmiennej auth unikalny identyfikator zalogowanego użytkownika, i używać ich do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji przy użyciu wielokrotnego uwierzytelniania. dostawców, łącząc dane logowania dostawcy uwierzytelniania z istniejącego konta 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żna także dodać kod obsługi błędów dla pełnego zakresu uwierzytelniania . Patrz sekcja Obsługa błędów.