Dodawanie uwierzytelniania wielopoziomowego do aplikacji na iOS

Jeśli masz już Firebase Authentication with Identity Platform, możesz dodać do swojej aplikacji na iOS uwierzytelnianie wielopoziomowe za pomocą 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 z wieloma najemcami nie jest obsługiwane w iOS.

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

2. Upewnij się, że Twoja aplikacja weryfikuje adresy e-mail użytkowników. MFA wymaga potwierdzania adresu e-mail. Uniemożliwia to złośliwym podmiotom rejestrowanie się w usłudze za pomocą adresu e-mail, którego nie są właścicielami, a następnie blokowanie dostępu prawdziwemu właścicielowi przez dodanie drugiego składnika.

Włączanie uwierzytelniania wielopoziomowego

1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.

2. Na karcie Metoda logowania w sekcji Zaawansowane włącz Uwierzytelnianie wielopoziomowe za pomocą SMS-ów.

   Wpisz też numery telefonów, za pomocą których będziesz testować aplikację. Chociaż rejestracja numerów telefonów do testów jest opcjonalna, zdecydowanie ją zalecamy, ponieważ pozwoli uniknąć ograniczeń podczas programowania.

3. Jeśli jeszcze tego nie zrobisz, autoryzuj domenę swojej aplikacji:

   1. W konsoli Firebase otwórz kartę Zabezpieczenia > Uwierzytelnianie > Ustawienia.

   2. W sekcji Autoryzowane domeny kliknij Dodaj domenę i dodaj swoją domenę.

Weryfikowanie aplikacji

Authentication musi sprawdzić, czy żą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, Authentication może wysłać ciche powiadomienie push na jego urządzenie. Jeśli aplikacja otrzyma powiadomienie, uwierzytelnianie może się zakończyć. Pamiętaj, że począwszy od iOS 8.0, aby korzystać z tej metody, nie musisz prosić użytkownika o zezwolenie na powiadomienia push.

• 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 interakcji użytkownika.

Korzystanie z cichych powiadomień

Aby włączyć powiadomienia APNs do użytku z Authentication:

1. W Xcode, włącz powiadomienia push dla swojego projektu.

2. Prześlij klucz uwierzytelniania APNs za pomocą konsoli Firebase (Twoje zmiany zostaną automatycznie przeniesione do Google Cloud Authentication). Jeśli nie masz jeszcze klucza uwierzytelniania APNs, dowiedz się, jak go uzyskać, w artykule Konfigurowanie APNs za pomocą FCM.

   1. W konsoli Firebase otwórz Ustawienia > Ogólne. Następnie kliknij kartę Komunikacja w chmurze.

   2. W sekcji Klucz uwierzytelniania APNs w sekcji Konfiguracja aplikacji na iOS kliknij Prześlij, aby przesłać klucz uwierzytelniania do programowania lub klucz uwierzytelniania do produkcji albo oba te klucze. Wymagany jest co najmniej 1 klucz.

   3. Wybierz klucz.

   4. Dodaj identyfikator klucza. Identyfikator klucza znajdziesz w Apple Developer Member Center w sekcji Certificates, Identifiers & Profiles (Certyfikaty, identyfikatory i profile).

   5. Kliknij Prześlij.

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

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. Kliknij kartę Informacje.

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

6. Kliknij przycisk +.

7. W polu Schematy adresów 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:

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

Wybieranie wzorca rejestracji

Możesz wybrać, czy Twoja aplikacja wymaga uwierzytelniania wielopoziomowego oraz 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 dla wszystkich użytkowników. Pamiętaj, że aby zarejestrować drugi składnik, konto musi mieć zweryfikowany adres e-mail, więc proces rejestracji musi to uwzględniać.

• Podczas rejestracji zaproponuj opcję zarejestrowania drugiego składnika, którą można pominąć. Aplikacje, które chcą zachęcać do korzystania z uwierzytelniania wielopoziomowego, ale nie wymagają go, mogą preferować to podejście.

• Zamiast ekranu rejestracji udostępnij możliwość dodania drugiego składnika na stronie zarządzania kontem lub profilem użytkownika. Minimalizuje to trudności podczas procesu rejestracji, a jednocześnie udostępnia uwierzytelnianie wielopoziomowe użytkownikom, którzy dbają o bezpieczeństwo.

• Wymagaj dodania drugiego składnika stopniowo, gdy użytkownik chce uzyskać dostęp do funkcji o zwiększonych wymaganiach dotyczących bezpieczeństwa.

Rejestrowanie drugiego składnika

Aby zarejestrować nowy składnik dodatkowy dla użytkownika:

1. Ponownie uwierzytelnij użytkownika.

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

   Uwaga: Google przechowuje i wykorzystuje numery telefonów, aby zwiększyć ochronę przed spamem i nadużyciami we wszystkich usługach Google. Zanim wyślesz numery telefonów użytkowników do Authenticationuwierzytelniania,
   upewnij się, że masz na to odpowiednią zgodę .

3. Uzyskaj sesję 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. Wyślij wiadomość weryfikacyjną na telefon użytkownika. Upewnij się, że numer telefonu jest sformatowany z początkowym znakiem + i bez innych znaków interpunkcyjnych ani białych znaków (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 poinformować użytkowników z wyprzedzeniem, ż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świetla się zadanie reCAPTCHA.

5. Gdy kod SMS zostanie wysłany, poproś użytkownika o jego weryfikację. Następnie użyj jego odpowiedzi, aby utworzyć 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 potwierdzenia:

   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 składnika. Jest to przydatne dla użytkowników, którzy mają kilka drugich składników, 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 przedstawia pełny przykład rejestracji drugiego składnika:

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 zarejestrowania więcej niż 1 drugiego składnika na potrzeby odzyskiwania konta. Jeśli użytkownik zarejestruje tylko 1 drugi składnik, a później utraci do niego dostęp, zostanie zablokowany na swoim koncie.

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

Aby zalogować użytkownika za pomocą weryfikacji dwuetapowej przez SMS-a:

1. Zaloguj użytkownika za pomocą pierwszego składnika, a następnie przechwyć błąd wskazujący, że wymagane jest uwierzytelnianie wielopoziomowe. Ten błąd zawiera resolver, wskazówki dotyczące zarejestrowanych drugich składników oraz sesję podstawową potwierdzającą, że użytkownik został pomyślnie uwierzytelniony za pomocą 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 składnikiem użytkownika jest dostawca federacyjny, np. OAuth, przechwyć błąd po wywołaniu getCredentialWith().

2. Jeśli użytkownik ma zarejestrowanych kilka składników dodatkowych, zapytaj go, którego z nich chce użyć. Zamaskowany numer telefonu możesz uzyskać za pomocą resolver.hints[selectedIndex].phoneNumber, a wyświetlaną nazwę za pomocą 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żyj go 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 potwierdzenia 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 przedstawia pełny przykład logowania użytkownika z uwierzytelnianiem wielopoziomowym:

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 z uwierzytelnianiem wielopoziomowym programowo za pomocą Admin SDK.