Dodawanie uwierzytelniania wielopoziomowego do aplikacji na iOS

Po przejściu na Uwierzytelnianie Firebase z Identity Platform możesz dodać uwierzytelnianie wielopoziomowe z użyciem SMS-ów w swojej aplikacji na iOS.

Uwierzytelnianie wielopoziomowe zwiększa bezpieczeństwo aplikacji. Hakerzy często przejmują hasła i konta społecznościowe, ale przechwycenie SMS-a jest trudniejsze.

Zanim zaczniesz

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

  2. Upewnij się, że Twoja aplikacja weryfikuje adresy e-mail użytkowników. MFA wymaga weryfikacji adresu e-mail. Dzięki temu hakerzy nie będą mogli zarejestrować się w usłudze przy użyciu adresu e-mail, który nie należą do nich, i zablokować prawdziwego właściciela przez dodanie drugiego składnika.

Włączanie uwierzytelniania wielopoziomowego

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

  2. W sekcji Zaawansowane włącz Uwierzytelnianie wielopoziomowe przez SMS-y.

    Wpisz też numery telefonów, które będą używane podczas testowania aplikacji. Choć jest to opcjonalne, zdecydowanie zalecamy zarejestrowanie testowych numerów telefonów, aby uniknąć ograniczenia przepustowości na etapie programowania.

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

Weryfikowanie aplikacji

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

  • Ciche powiadomienia APNs: gdy logujesz się użytkownika po raz pierwszy, Firebase może wysłać ciche powiadomienie push na jego urządzenie. Uwierzytelnianie będzie kontynuowane, gdy aplikacja otrzyma powiadomienie. Pamiętaj, że od wersji iOS 8.0 nie trzeba prosić użytkownika o zgodę na korzystanie z tej metody w przypadku powiadomień push.

  • Weryfikacja za pomocą 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 aplikację w symulatorze iOS), możesz użyć reCAPTCHA. W wielu przypadkach reCAPTCHA rozwiązuje się automatycznie, bez udziału użytkownika.

Używanie cichych powiadomień

Aby włączyć powiadomienia APNs na potrzeby Firebase:

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

  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 informacjami o konfigurowaniu APNs w FCM, aby dowiedzieć się, jak go uzyskać.

    1. Otwórz konsolę Firebase.

    2. Otwórz Ustawienia projektu.

    3. Wybierz kartę Komunikacja w chmurze.

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

    5. Wybierz klucz.

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

    7. Kliknij Prześlij.

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

Używanie weryfikacji reCAPTCHA

Aby umożliwić pakietowi SDK klienta korzystanie z reCAPTCHA:

  1. Otwórz konfigurację projektu w Xcode.

  2. Kliknij dwukrotnie nazwę projektu w widoku drzewa po lewej stronie.

  3. Wybierz aplikację w sekcji Cele.

  4. Wybierz kartę Informacje.

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

  6. Kliknij przycisk +.

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

Gdy skończysz, Twoja konfiguracja powinna wyglądać mniej więcej tak:

Schematy niestandardowe

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

Wybór wzorca rejestracji

Możesz określić, czy Twoja aplikacja wymaga uwierzytelniania wielopoziomowego oraz jak i kiedy rejestrować użytkowników. Oto kilka często spotykanych wzorców:

  • Zarejestruj drugi składnik logowania użytkownika w ramach rejestracji. Użyj tej metody, jeśli Twoja aplikacja wymaga uwierzytelniania wielopoziomowego u wszystkich użytkowników. Pamiętaj, że aby można było zarejestrować drugi składnik, konto musi mieć zweryfikowany adres e-mail. Musisz to uwzględnić w procesie rejestracji.

  • Zaoferować możliwą do pominięcia opcję rejestracji drugiego składnika podczas rejestracji. Mogą preferować aplikacje, które chcą zachęcać do uwierzytelniania wielopoziomowego, ale nie wymagają ich.

  • Umożliwienie dodawania drugiego składnika na stronie konta użytkownika lub na stronie zarządzania profilem użytkownika zamiast na ekranie rejestracji. Pozwala to zminimalizować utrudnienia podczas procesu rejestracji, a jednocześnie umożliwić korzystanie z uwierzytelniania wielopoziomowego użytkownikom, którym zależy na bezpieczeństwie.

  • Wymagaj stopniowego dodawania drugiego składnika, gdy użytkownik chce uzyskać dostęp do funkcji o wyższych wymaganiach w zakresie bezpieczeństwa.

Rejestrowanie drugiego składnika

Aby zarejestrować nowy czynnik dodatkowy dla użytkownika:

  1. Ponownie uwierzytelnij użytkownika.

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

  3. Pobierz sesję wielopoziomową 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. Sprawdź, czy numer telefonu zaczyna się od +, bez innych znaków interpunkcyjnych ani spacji (np. +15105551234).

    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 zostaną naliczone standardowe opłaty.

    Metoda verifyPhoneNumber() rozpoczyna proces weryfikacji aplikacji w tle za pomocą cichych powiadomień push. Jeśli dyskretne powiadomienie push nie jest dostępne,zamiast niego uruchamiany jest test reCAPTCHA.

  5. Gdy otrzymasz SMS-a, poproś użytkownika o jego potwierdzenie. Następnie na podstawie odpowiedzi klienta utwórz 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 określić wyświetlaną nazwę drugiego składnika. Jest to przydatne w przypadku użytkowników z wieloma drugimi czynnikami, ponieważ numer telefonu jest maskowany podczas procesu uwierzytelniania (na przykład +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żej znajdziesz pełny przykład rejestrowania 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 etap uwierzytelniania dla użytkownika.

Logowanie użytkowników przy użyciu drugiego składnika

Aby zalogować użytkownika przy użyciu weryfikacji dwuetapowej przez SMS:

  1. Zaloguj użytkownika przy użyciu pierwszego składnika, a potem wychwytuj błąd informujący o tym, że wymagane jest uwierzytelnianie wielopoziomowe. Ten błąd zawiera resolver, wskazówki dotyczące zarejestrowanych drugich czynników i bazową sesję potwierdzającą, że użytkownik uwierzytelnił się przy użyciu pierwszego składnika.

    Jeśli np. pierwszym czynnikiem były adres e-mail i hasło użytkownika:

    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 sfederowany dostawca, np. OAuth, błąd zostanie wykryty po wywołaniu funkcji getCredentialWith().

  2. Jeśli użytkownik ma zarejestrowanych kilka czynników dodatkowych, zapytaj go, którego z nich użyje. Zamaskowany numer telefonu możesz uzyskać za pomocą parametru resolver.hints[selectedIndex].phoneNumber, a wyświetlaną nazwę – w polu 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 zostanie wysłany kod SMS, poproś użytkownika o zweryfikowanie kodu i użycie 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 asercji za pomocą danych logowania:

    Swift 

    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)

    Objective-C 

    FIRMultiFactorAssertion *assertion =
    [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];

  6. Zakończ proces logowania. Następnie możesz uzyskać dostęp do pierwotnych wyników logowania, które zawierają standardowe dane uwierzytelniające dostawcy i dane uwierzytelniające:

    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żej znajdziesz pełny przykład logowania użytkownika wielopoziomowego:

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?