Dodawanie uwierzytelniania wielopoziomowego do aplikacji na iOS

Jeśli masz wersję Firebase Authentication with Identity Platform, możesz dodać do aplikacji na iOS uwierzytelnianie wielopoziomowe z użyciem SMS-ów.

Uwierzytelnianie wielopoziomowe zwiększa bezpieczeństwo aplikacji. Osoby przeprowadzające ataki często przejmują hasła i konta społecznościowe, ale przechwycenie SMS-a jest dużo trudniejsze.

Zanim zaczniesz

Uwaga: korzystanie z uwierzytelniania wielopoziomowego w przypadku wielu najemców nie jest obsługiwane w systemie iOS.

1. Włącz co najmniej jednego dostawcę obsługującego uwierzytelnianie wielopoziomowe. Każdy dostawca obsługuje uwierzytelnianie wieloskładnikowe z wyjątkiem uwierzytelniania przez telefon, uwierzytelniania anonimowego i Apple Game Center.

2. Sprawdź, czy aplikacja weryfikuje adresy e-mail użytkowników. MFA wymaga weryfikacji adresu e-mail. Zapobiega to rejestrowaniu się hakerów w usłudze za pomocą adresu e-mail, który nie należy do nich, a następnie blokowaniu dostępu do konta prawdziwemu właścicielowi przez dodanie drugiego etapu weryfikacji.

Włączanie uwierzytelniania wielopoziomowego

1. Otwórz stronę Uwierzytelnianie > Metoda logowania w konsoli Firebase.

2. W sekcji Zaawansowane włącz Uwierzytelnianie wielopoziomowe z użyciem SMS-ów.

   Podaj też numery telefonów, których użyjesz do testowania aplikacji. Chociaż rejestracja numerów telefonów do testów jest opcjonalna, zdecydowanie ją zalecamy, ponieważ pozwoli uniknąć ograniczeń podczas programowania.

3. Jeśli domena aplikacji nie została jeszcze autoryzowana, dodaj ją do listy dozwolonych na stronie Uwierzytelnianie > Ustawienia w konsoli Firebase.

Weryfikacja aplikacji

Firebase musi potwierdzić, że żądania SMS-ów pochodzą z Twojej aplikacji. Możesz to zrobić na 2 sposoby:

• Ciche powiadomienia APNs: gdy użytkownik loguje się po raz pierwszy, usługa Firebase może wysłać na jego urządzenie ciche powiadomienie push. Jeśli aplikacja otrzyma powiadomienie, uwierzytelnianie może zostać przeprowadzone. Pamiętaj, że od iOS 8.0 nie musisz prosić użytkownika o zezwolenie na powiadomienia push, aby korzystać z tej metody.

• Weryfikacja reCAPTCHA: jeśli nie możesz wysłać cichego powiadomienia (np. dlatego, że użytkownik wyłączył odświeżanie w tle lub testujesz aplikację w symulatorze iOS), możesz użyć reCAPTCHA. W wielu przypadkach reCAPTCHA rozwiąże się automatycznie bez udziału użytkownika.

Korzystanie z wyciszonych powiadomień

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

1. W Xcode włącz powiadomienia push w projekcie.

2. Prześlij klucz uwierzytelniania APNs za pomocą konsoli Firebase (zmiany zostaną automatycznie przeniesione do Google Cloud Firebase). Jeśli nie masz jeszcze klucza uwierzytelniania APNs, zapoznaj się z artykułem Konfigurowanie APNs za pomocą FCM, aby dowiedzieć się, jak go uzyskać.

   1. Otwórz konsolę Firebase.

   2. Kliknij Ustawienia projektu.

   3. Wybierz kartę Cloud Messaging.

   4. W sekcji Klucz uwierzytelniania APNs w sekcji Konfiguracja aplikacji na iOS kliknij Prześlij, aby przesłać klucz uwierzytelniania środowiska deweloperskiego lub klucz uwierzytelniania środowiska produkcyjnego albo oba te klucze. Wymagany jest co najmniej 1 element.

   5. Wybierz klucz.

   6. Dodaj identyfikator klucza. Identyfikator klucza znajdziesz w sekcji Certyfikaty, identyfikatory i profile w Apple Developer Member Center.

   7. Kliknij Prześlij.

Jeśli masz już certyfikat APNs, możesz go przesłać.

Korzystanie z weryfikacji reCAPTCHA

Aby włączyć korzystanie z reCAPTCHA w pakiecie SDK klienta:

1. Otwórz konfigurację projektu w Xcode.

2. W widoku drzewa po lewej stronie kliknij dwukrotnie nazwę projektu.

3. W sekcji Cele wybierz swoją aplikację.

4. Wybierz kartę Informacje.

5. Rozwiń sekcję Typy adresów URL.

6. Kliknij przycisk +.

7. W polu Schematy URL wpisz odwrócony identyfikator klienta. Tę wartość znajdziesz w pliku konfiguracyjnym GoogleService-Info.plist jako REVERSED_CLIENT_ID.

Po zakończeniu konfiguracja powinna wyglądać podobnie do tej poniżej:

Opcjonalnie możesz dostosować sposób, w jaki aplikacja prezentuje SFSafariViewController lub UIWebView podczas wyświetlania reCAPTCHA. Aby to zrobić, utwórz klasę niestandardową zgodną z protokołem FIRAuthUIDelegate i przekaż ją do verifyPhoneNumber:UIDelegate:completion:.

Wybieranie wzorca rejestracji

Możesz określić, czy aplikacja wymaga uwierzytelniania wielopoziomowego, a także jak i kiedy rejestrować użytkowników. Oto kilka typowych wzorców:

• Zarejestruj drugi składnik użytkownika w ramach rejestracji. Użyj tej metody, jeśli Twoja aplikacja wymaga uwierzytelniania wielopoziomowego od wszystkich użytkowników. Pamiętaj, że aby zarejestrować drugi czynnik, konto musi mieć zweryfikowany adres e-mail, więc proces rejestracji musi to uwzględniać.

• Podczas rejestracji oferuj opcję pominięcia rejestracji drugiego składnika. Aplikacje, które chcą zachęcać do uwierzytelniania wielopoziomowego, ale nie wymagają go, mogą preferować to podejście.

• Umożliwienie dodania drugiego czynnika na stronie zarządzania kontem lub profilem użytkownika, a nie na ekranie rejestracji. Minimalizuje to trudności podczas procesu rejestracji, a jednocześnie udostępnia uwierzytelnianie wielopoziomowe użytkownikom, którzy dbają o bezpieczeństwo.

• Wymagaj stopniowego dodawania drugiego etapu weryfikacji, gdy użytkownik chce uzyskać dostęp do funkcji o zwiększonych wymaganiach dotyczących bezpieczeństwa.

Rejestrowanie drugiego składnika

Aby zarejestrować nowy czynnik dodatkowy dla użytkownika:

1. Ponownie uwierzytelnij użytkownika.

2. Poproś użytkownika o wpisanie numeru telefonu.

   Uwaga: Google przechowuje i wykorzystuje numery telefonów, aby ulepszać zapobieganie spamowi i nadużyciom we wszystkich usługach Google. Zanim wyślesz numery telefonów użytkowników do Firebase,
   musisz uzyskać ich odpowiednią zgodę.

3. Uzyskiwanie sesji uwierzytelniania wielopoziomowego dla użytkownika:

   Swift

   authResult.user.multiFactor.getSessionWithCompletion() { (session, error) in
     // ...
   }
   

   Objective-C

   [authResult.user.multiFactor
     getSessionWithCompletion:^(FIRMultiFactorSession * _Nullable session,
                               NSError * _Nullable error) {
       // ...
   }];
   

4. Wysyłanie wiadomości weryfikacyjnej na telefon użytkownika. Upewnij się, że numer telefonu jest sformatowany ze znakiem + na początku i bez innych znaków interpunkcyjnych ani spacji (np. +).[phone]

   Swift

   // Send SMS verification code.
   PhoneAuthProvider.provider().verifyPhoneNumber(
     phoneNumber,
     uiDelegate: nil,
     multiFactorSession: session) { (verificationId, error) in
       // verificationId will be needed for enrollment completion.
   }
   

   Objective-C

   // Send SMS verification code.
   [FIRPhoneAuthProvider.provider verifyPhoneNumber:phoneNumber
                                         UIDelegate:nil
                                 multiFactorSession:session
                                         completion:^(NSString * _Nullable verificationID,
                                                       NSError * _Nullable error) {
       // verificationId will be needed for enrollment completion.
   }];
   

   Chociaż nie jest to wymagane, warto wcześniej poinformować użytkowników, że otrzymają SMS-a, i że obowiązują standardowe stawki.

   Metoda verifyPhoneNumber() rozpoczyna proces weryfikacji aplikacji w tle za pomocą cichego powiadomienia push. Jeśli ciche powiadomienie push jest niedostępne,zamiast niego wyświetlane jest zadanie reCAPTCHA.

5. Gdy kod SMS zostanie wysłany, poproś użytkownika o jego weryfikację. Następnie wykorzystaj ich odpowiedź do utworzenia PhoneAuthCredential:

   Swift

   // Ask user for the verification code. Then:
   let credential = PhoneAuthProvider.provider().credential(
     withVerificationID: verificationId,
     verificationCode: verificationCode)
   

   Objective-C

   // Ask user for the SMS verification code. Then:
   FIRPhoneAuthCredential *credential = [FIRPhoneAuthProvider.provider
                                          credentialWithVerificationID:verificationID
                                          verificationCode:kPhoneSecondFactorVerificationCode];
   

6. Zainicjuj obiekt asercji:

   Swift

   let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
   

   Objective-C

   FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
   

7. Dokończ rejestrację. Opcjonalnie możesz podać wyświetlaną nazwę drugiego czynnika. Jest to przydatne dla użytkowników, którzy mają kilka metod uwierzytelniania dwuskładnikowego, ponieważ numer telefonu jest maskowany podczas procesu uwierzytelniania (np. +1******1234).

   Swift

   // Complete enrollment. This will update the underlying tokens
   // and trigger ID token change listener.
   user.multiFactor.enroll(with: assertion, displayName: displayName) { (error) in
     // ...
   }
   

   Objective-C

   // Complete enrollment. This will update the underlying tokens
   // and trigger ID token change listener.
   [authResult.user.multiFactor enrollWithAssertion:assertion
                                        displayName:nil
                                         completion:^(NSError * _Nullable error) {
       // ...
   }];
   

Poniższy kod pokazuje kompletny przykład rejestracji drugiego czynnika:

Swift

let user = Auth.auth().currentUser
user?.multiFactor.getSessionWithCompletion({ (session, error) in
  // Send SMS verification code.
  PhoneAuthProvider.provider().verifyPhoneNumber(
    phoneNumber,
    uiDelegate: nil,
    multiFactorSession: session
  ) { (verificationId, error) in
    // verificationId will be needed for enrollment completion.
    // Ask user for the verification code.
    let credential = PhoneAuthProvider.provider().credential(
      withVerificationID: verificationId!,
      verificationCode: phoneSecondFactorVerificationCode)
    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
    // Complete enrollment. This will update the underlying tokens
    // and trigger ID token change listener.
    user?.multiFactor.enroll(with: assertion, displayName: displayName) { (error) in
      // ...
    }
  }
})

Objective-C

FIRUser *user = FIRAuth.auth.currentUser;
[user.multiFactor getSessionWithCompletion:^(FIRMultiFactorSession * _Nullable session,
                                              NSError * _Nullable error) {
    // Send SMS verification code.
    [FIRPhoneAuthProvider.provider
      verifyPhoneNumber:phoneNumber
      UIDelegate:nil
      multiFactorSession:session
      completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
        // verificationId will be needed for enrollment completion.

        // Ask user for the verification code.
        // ...

        // Then:
        FIRPhoneAuthCredential *credential =
            [FIRPhoneAuthProvider.provider credentialWithVerificationID:verificationID
                                                        verificationCode:kPhoneSecondFactorVerificationCode];
        FIRMultiFactorAssertion *assertion =
            [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];

        // Complete enrollment. This will update the underlying tokens
        // and trigger ID token change listener.
        [user.multiFactor enrollWithAssertion:assertion
                                  displayName:displayName
                                    completion:^(NSError * _Nullable error) {
            // ...
        }];
    }];
}];

Gratulacje! Udało Ci się zarejestrować drugi składnik uwierzytelniania dla użytkownika.

Ważne: zdecydowanie zachęcaj użytkowników do rejestrowania więcej niż jednego drugiego czynnika na potrzeby odzyskiwania konta. Jeśli użytkownik zarejestruje tylko jeden drugi czynnik i później utraci do niego dostęp, zostanie zablokowany na koncie.

Logowanie użytkowników za pomocą drugiego składnika

Aby zalogować użytkownika za pomocą weryfikacji dwuskładnikowej przez SMS:

1. Zaloguj użytkownika przy użyciu pierwszego poziomu uwierzytelniania, a następnie przechwyć błąd wskazujący, że wymagane jest uwierzytelnianie wieloskładnikowe. Ten błąd zawiera moduł rozpoznawania, wskazówki dotyczące zarejestrowanych drugich składników oraz sesję bazową potwierdzającą, że użytkownik został uwierzytelniony przy użyciu pierwszego składnika.

   Jeśli na przykład pierwszym składnikiem użytkownika był adres e-mail i hasło:

   Swift

   Auth.auth().signIn(
     withEmail: email,
     password: password
   ) { (result, error) in
     let authError = error as NSError
     if authError?.code == AuthErrorCode.secondFactorRequired.rawValue {
       // The user is a multi-factor user. Second factor challenge is required.
       let resolver =
         authError!.userInfo[AuthErrorUserInfoMultiFactorResolverKey] as! MultiFactorResolver
       // ...
     } else {
       // Handle other errors such as wrong password.
     }
   }
   

   Objective-C

   [FIRAuth.auth signInWithEmail:email
                        password:password
                      completion:^(FIRAuthDataResult * _Nullable authResult,
                                   NSError * _Nullable error) {
       if (error == nil || error.code != FIRAuthErrorCodeSecondFactorRequired) {
           // User is not enrolled with a second factor and is successfully signed in.
           // ...
       } else {
           // The user is a multi-factor user. Second factor challenge is required.
       }
   }];
   

   Jeśli pierwszym czynnikiem użytkownika jest dostawca federacyjny, np. OAuth, przechwyć błąd po wywołaniu funkcji getCredentialWith().

2. Jeśli użytkownik ma zarejestrowanych kilka czynników dodatkowych, zapytaj go, którego z nich chce użyć. Zamaskowany numer telefonu możesz uzyskać za pomocą funkcji resolver.hints[selectedIndex].phoneNumber, a wyświetlaną nazwę za pomocą funkcji resolver.hints[selectedIndex].displayName.

   Swift

   // Ask user which second factor to use. Then:
   if resolver.hints[selectedIndex].factorID == PhoneMultiFactorID {
     // User selected a phone second factor.
     // ...
   } else if resolver.hints[selectedIndex].factorID == TotpMultiFactorID {
     // User selected a TOTP second factor.
     // ...
   } else {
     // Unsupported second factor.
   }
   

   Objective-C

   FIRMultiFactorResolver *resolver =
       (FIRMultiFactorResolver *) error.userInfo[FIRAuthErrorUserInfoMultiFactorResolverKey];
   
   // Ask user which second factor to use. Then:
   FIRPhoneMultiFactorInfo *hint = (FIRPhoneMultiFactorInfo *) resolver.hints[selectedIndex];
   if (hint.factorID == FIRPhoneMultiFactorID) {
     // User selected a phone second factor.
     // ...
   } else if (hint.factorID == FIRTOTPMultiFactorID) {
     // User selected a TOTP second factor.
     // ...
   } else {
     // Unsupported second factor.
   }
   

3. Wyślij wiadomość weryfikacyjną na telefon użytkownika:

   Swift

   // Send SMS verification code.
   let hint = resolver.hints[selectedIndex] as! PhoneMultiFactorInfo
   PhoneAuthProvider.provider().verifyPhoneNumber(
     with: hint,
     uiDelegate: nil,
     multiFactorSession: resolver.session
   ) { (verificationId, error) in
     // verificationId will be needed for sign-in completion.
   }
   

   Objective-C

   // Send SMS verification code
   [FIRPhoneAuthProvider.provider
     verifyPhoneNumberWithMultiFactorInfo:hint
     UIDelegate:nil
     multiFactorSession:resolver.session
     completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
       if (error != nil) {
           // Failed to verify phone number.
       }
   }];
   

4. Gdy kod SMS zostanie wysłany, poproś użytkownika o jego weryfikację i użycie do utworzenia PhoneAuthCredential:

   Swift

   // Ask user for the verification code. Then:
   let credential = PhoneAuthProvider.provider().credential(
     withVerificationID: verificationId!,
     verificationCode: verificationCodeFromUser)
   

   Objective-C

   // Ask user for the SMS verification code. Then:
   FIRPhoneAuthCredential *credential =
       [FIRPhoneAuthProvider.provider
         credentialWithVerificationID:verificationID
                     verificationCode:verificationCodeFromUser];
   

5. Zainicjuj obiekt asercji za pomocą danych logowania:

   Swift

   let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
   

   Objective-C

   FIRMultiFactorAssertion *assertion =
       [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
   

6. Rozwiąż problem z logowaniem. Następnie możesz uzyskać dostęp do pierwotnego wyniku logowania, który zawiera standardowe dane specyficzne dla dostawcy i dane logowania:

   Swift

   // Complete sign-in. This will also trigger the Auth state listeners.
   resolver.resolveSignIn(with: assertion) { (authResult, error) in
     // authResult will also contain the user, additionalUserInfo, optional
     // credential (null for email/password) associated with the first factor sign-in.
   
     // For example, if the user signed in with Google as a first factor,
     // authResult.additionalUserInfo will contain data related to Google provider that
     // the user signed in with.
   
     // user.credential contains the Google OAuth credential.
     // user.credential.accessToken contains the Google OAuth access token.
     // user.credential.idToken contains the Google OAuth ID token.
   }
   

   Objective-C

   // Complete sign-in.
   [resolver resolveSignInWithAssertion:assertion
                             completion:^(FIRAuthDataResult * _Nullable authResult,
                                           NSError * _Nullable error) {
       if (error != nil) {
           // User successfully signed in with the second factor phone number.
       }
   }];
   

Poniższy kod zawiera pełny przykład logowania użytkownika z uwierzytelnianiem wieloskładnikowym:

Swift

Auth.auth().signIn(
  withEmail: email,
  password: password
) { (result, error) in
  let authError = error as NSError?
  if authError?.code == AuthErrorCode.secondFactorRequired.rawValue {
    let resolver =
      authError!.userInfo[AuthErrorUserInfoMultiFactorResolverKey] as! MultiFactorResolver

    // Ask user which second factor to use.
    // ...

    // Then:
    let hint = resolver.hints[selectedIndex] as! PhoneMultiFactorInfo

    // Send SMS verification code
    PhoneAuthProvider.provider().verifyPhoneNumber(
      with: hint,
      uiDelegate: nil,
      multiFactorSession: resolver.session
    ) { (verificationId, error) in
      if error != nil {
        // Failed to verify phone number.
      }
      // Ask user for the SMS verification code.
      // ...

      // Then:
      let credential = PhoneAuthProvider.provider().credential(
        withVerificationID: verificationId!,
        verificationCode: verificationCodeFromUser)
      let assertion = PhoneMultiFactorGenerator.assertion(with: credential)

      // Complete sign-in.
      resolver.resolveSignIn(with: assertion) { (authResult, error) in
        if error != nil {
          // User successfully signed in with the second factor phone number.
        }
      }
    }
  }
}

Objective-C

[FIRAuth.auth signInWithEmail:email
                     password:password
                   completion:^(FIRAuthDataResult * _Nullable authResult,
                               NSError * _Nullable error) {
    if (error == nil || error.code != FIRAuthErrorCodeSecondFactorRequired) {
        // User is not enrolled with a second factor and is successfully signed in.
        // ...
    } else {
        FIRMultiFactorResolver *resolver =
            (FIRMultiFactorResolver *) error.userInfo[FIRAuthErrorUserInfoMultiFactorResolverKey];

        // Ask user which second factor to use.
        // ...

        // Then:
        FIRPhoneMultiFactorInfo *hint = (FIRPhoneMultiFactorInfo *) resolver.hints[selectedIndex];

        // Send SMS verification code
        [FIRPhoneAuthProvider.provider
          verifyPhoneNumberWithMultiFactorInfo:hint
                                    UIDelegate:nil
                            multiFactorSession:resolver.session
                                    completion:^(NSString * _Nullable verificationID,
                                                NSError * _Nullable error) {
            if (error != nil) {
                // Failed to verify phone number.
            }

            // Ask user for the SMS verification code.
            // ...

            // Then:
            FIRPhoneAuthCredential *credential =
                [FIRPhoneAuthProvider.provider
                  credentialWithVerificationID:verificationID
                              verificationCode:kPhoneSecondFactorVerificationCode];
            FIRMultiFactorAssertion *assertion =
                [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];

            // Complete sign-in.
            [resolver resolveSignInWithAssertion:assertion
                                      completion:^(FIRAuthDataResult * _Nullable authResult,
                                                    NSError * _Nullable error) {
                if (error != nil) {
                    // User successfully signed in with the second factor phone number.
                }
            }];
        }];
    }
}];

Gratulacje! Udało Ci się zalogować użytkownika za pomocą uwierzytelniania wielopoziomowego.

Co dalej?

• Zarządzaj użytkownikami korzystającymi z uwierzytelniania wieloskładnikowego automatycznie za pomocą Admin SDK.