Join us in person and online for Firebase Summit on October 18, 2022. Learn how Firebase can help you accelerate app development, release your app with confidence, and scale with ease. Register now

Dodaj uwierzytelnianie wieloskładnikowe do swojej aplikacji na iOS

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Po przejściu na Uwierzytelnianie Firebase z Identity Platform możesz dodać uwierzytelnianie wielopoziomowe SMS do swojej aplikacji na iOS.

Uwierzytelnianie wieloskładnikowe zwiększa bezpieczeństwo Twojej aplikacji. Podczas gdy osoby atakujące często naruszają hasła i konta społecznościowe, przechwycenie wiadomości tekstowej jest trudniejsze.

Zanim zaczniesz

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

  2. Upewnij się, że Twoja aplikacja weryfikuje e-maile użytkowników. MFA wymaga weryfikacji poczty e-mail. Zapobiega to rejestrowaniu się złośliwych graczy w usłudze za pomocą wiadomości e-mail, których nie są właścicielami, a następnie blokowaniu rzeczywistego właściciela przez dodanie drugiego czynnika.

Włączanie uwierzytelniania wieloskładnikowego

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

  2. W sekcji Zaawansowane włącz uwierzytelnianie wieloskładnikowe SMS .

    Powinieneś też podać numery telefonów, z którymi będziesz testować swoją aplikację. Chociaż jest to opcjonalne, zdecydowanie zaleca się rejestrowanie testowych numerów telefonów, aby uniknąć ograniczania przepustowości podczas opracowywania.

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

Weryfikowanie Twojej aplikacji

Firebase musi sprawdzić, czy żądania SMS pochodzą z Twojej aplikacji. Możesz to zrobić na dwa sposoby:

  • Ciche powiadomienia APN : po pierwszym zalogowaniu użytkownika Firebase może wysłać ciche powiadomienie push na urządzenie użytkownika. Uwierzytelnianie może być kontynuowane, jeśli aplikacja otrzyma powiadomienie. Zwróć uwagę, że począwszy od iOS 8.0, nie musisz prosić użytkownika o zezwolenie na korzystanie z powiadomień wypychanych tą metodą.

  • Weryfikacja reCAPTCHA : jeśli nie możesz wysłać cichego powiadomienia (na przykład dlatego, że użytkownik wyłączył odświeżanie w tle lub testujesz swoją 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 Firebase:

  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 Firebase). Jeśli nie masz jeszcze klucza uwierzytelniania APNs, zobacz Konfigurowanie APNs za pomocą FCM , aby dowiedzieć się, jak go uzyskać.

    1. Otwórz konsolę Firebase .

    2. Przejdź do ustawień projektu .

    3. Wybierz kartę Wiadomości w chmurze .

    4. W sekcji Klucz uwierzytelniania APNs w sekcji Konfiguracja aplikacji na iOS kliknij Prześlij .

    5. Wybierz swój klucz.

    6. Dodaj identyfikator klucza dla klucza. Identyfikator klucza można znaleźć 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 umożliwić klientowi SDK korzystanie z reCAPTCHA:

  1. Otwórz konfigurację projektu w Xcode.

  2. Kliknij dwukrotnie nazwę projektu w lewym widoku drzewa.

  3. Wybierz swoją aplikację z sekcji Cele .

  4. Wybierz kartę Informacje .

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

  6. Kliknij przycisk + .

  7. Wprowadź swój odwrócony identyfikator klienta w polu Schematy adresów URL . Tę wartość można znaleźć w pliku konfiguracyjnym GoogleService-Info.plist jako REVERSED_CLIENT_ID .

Po zakończeniu konfiguracja powinna wyglądać podobnie do następującej:

Schematy niestandardowe

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

Wybór wzoru rejestracji

Możesz wybrać, czy Twoja aplikacja wymaga uwierzytelniania wieloskładnikowego oraz jak i kiedy rejestrować użytkowników. Niektóre typowe wzorce obejmują:

  • Zarejestruj drugi czynnik użytkownika w ramach rejestracji. Użyj tej metody, jeśli Twoja aplikacja wymaga uwierzytelniania wieloskładnikowego dla wszystkich użytkowników. Pamiętaj, że konto musi mieć zweryfikowany adres e-mail, aby zarejestrować drugi czynnik, więc proces rejestracji będzie musiał to uwzględnić.

  • Zaoferuj możliwość pominięcia opcji rejestracji drugiego czynnika podczas rejestracji. Aplikacje, które chcą zachęcić, ale nie wymagają uwierzytelniania wieloskładnikowego, mogą preferować to podejście.

  • Zapewnij możliwość dodania drugiego czynnika ze strony zarządzania kontem lub profilem użytkownika zamiast ekranu rejestracji. Minimalizuje to tarcia podczas procesu rejestracji, jednocześnie udostępniając uwierzytelnianie wieloskładnikowe użytkownikom wrażliwym na bezpieczeństwo.

  • Wymagaj stopniowego dodawania drugiego czynnika, gdy użytkownik chce uzyskać dostęp do funkcji o podwyższonych wymaganiach bezpieczeństwa.

Zapisanie drugiego czynnika

Aby zarejestrować nowy czynnik dodatkowy dla użytkownika:

  1. Ponownie uwierzytelnij użytkownika.

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

  3. Uzyskaj sesję wieloczynnikową dla użytkownika:

    Szybki

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

    Cel 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 + i bez innych znaków interpunkcyjnych lub spacji (na przykład: +15105551234 )

    Szybki

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

    Cel 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, najlepiej jest wcześniej poinformować użytkowników, że otrzymają wiadomość SMS i że obowiązują standardowe stawki.

    Metoda verifyPhoneNumber() uruchamia proces weryfikacji aplikacji w tle przy użyciu cichego powiadomienia push. Jeśli ciche powiadomienie push nie jest dostępne, zamiast tego wysyłane jest wyzwanie reCAPTCHA.

  5. Po wysłaniu kodu SMS poproś użytkownika o weryfikację kodu. Następnie użyj ich odpowiedzi, aby zbudować PhoneAuthCredential :

    Szybki

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

    Cel C

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

    Szybki

    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
    

    Cel C

    FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
    
  7. Dokończ rejestrację. Opcjonalnie można określić nazwę wyświetlaną dla drugiego czynnika. Jest to przydatne dla użytkowników z wieloma czynnikami sekundowymi, ponieważ numer telefonu jest maskowany podczas przepływu uwierzytelniania (na przykład +1******1234).

    Szybki

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

    Cel 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 kompletny przykład rejestracji drugiego czynnika:

Szybki

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

Cel 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! Pomyślnie zarejestrowałeś drugi czynnik uwierzytelniania dla użytkownika.

Logowanie użytkowników za pomocą drugiego czynnika

Aby zalogować użytkownika za pomocą dwustopniowej weryfikacji SMS:

  1. Zaloguj się użytkownika za pomocą pierwszego czynnika, a następnie przechwyć błąd wskazujący, że wymagane jest uwierzytelnianie wieloskładnikowe. Ten błąd zawiera przelicznik, wskazówki dotyczące zarejestrowanych drugich czynników oraz podstawową sesję potwierdzającą pomyślne uwierzytelnienie użytkownika za pomocą pierwszego czynnika.

    Na przykład, jeśli pierwszym czynnikiem użytkownika był adres e-mail i hasło:

    Szybki

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

    Cel 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, taki jak OAuth, przechwyć błąd po wywołaniu getCredentialWith() .

  2. Jeśli użytkownik ma zarejestrowanych wiele czynników drugorzędnych, zapytaj, którego z nich użyć. Zamaskowany numer telefonu można uzyskać za pomocą resolver.hints[selectedIndex].phoneNumber i nazwę wyświetlaną za pomocą resolver.hints[selectedIndex].displayName .

    Szybki

    // Ask user which second factor to use. Then:
    if resolver.hints[selectedIndex].factorID == PhoneMultiFactorID {
      // User selected a phone second factor.
      // ...
    } else {
      // Unsupported second factor.
      // Note that only phone second factors are currently supported.
    }
    

    Cel 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 {
      // Unsupported second factor.
      // Note that only phone second factors are currently supported.
    }
    
  3. Wyślij wiadomość weryfikacyjną na telefon użytkownika:

    Szybki

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

    Cel 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. Po wysłaniu kodu SMS poproś użytkownika o zweryfikowanie kodu i użycie go do zbudowania PhoneAuthCredential :

    Szybki

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

    Cel C

    // Ask user for the SMS verification code. Then:
    FIRPhoneAuthCredential *credential =
        [FIRPhoneAuthProvider.provider
          credentialWithVerificationID:verificationID
                      verificationCode:verificationCodeFromUser];
    
  5. Zainicjuj obiekt asercji z poświadczeniem:

    Szybki

    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
    

    Cel C

    FIRMultiFactorAssertion *assertion =
        [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
    
  6. Rozwiąż logowanie. Następnie możesz uzyskać dostęp do oryginalnego wyniku logowania, który obejmuje standardowe dane specyficzne dla dostawcy i poświadczenia uwierzytelniania:

    Szybki

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

    Cel 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 kompletny przykład podpisywania użytkownika wieloskładnikowego:

Szybki

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

Cel 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! Pomyślnie zalogowałeś użytkownika przy użyciu uwierzytelniania wieloskładnikowego.

Co dalej