Jeśli dokonałeś aktualizacji do uwierzytelniania Firebase z platformą tożsamości, możesz dodać wielopoziomowe uwierzytelnianie SMS do swojej aplikacji na iOS.
Uwierzytelnianie wieloskładnikowe zwiększa bezpieczeństwo Twojej aplikacji. Chociaż napastnicy często naruszają hasła i konta społecznościowe, przechwycenie wiadomości tekstowej jest trudniejsze.
Zanim zaczniesz
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.
Upewnij się, że Twoja aplikacja weryfikuje adresy e-mail użytkowników. MFA wymaga weryfikacji e-mailowej. Zapobiega to rejestrowaniu się złośliwych aktorów w usłudze przy użyciu adresu e-mail, którego nie należą, a następnie blokowaniu prawdziwego właściciela poprzez dodanie drugiego czynnika.
Włączanie uwierzytelniania wieloskładnikowego
Otwórz stronę Uwierzytelnianie > Metoda logowania w konsoli Firebase.
W sekcji Zaawansowane włącz uwierzytelnianie wieloskładnikowe SMS .
Powinieneś także wpisać numery telefonów, z którymi będziesz testować aplikację. Chociaż jest to opcjonalne, zdecydowanie zaleca się rejestrowanie testowych numerów telefonów, aby uniknąć ograniczania przepustowości podczas programowania.
Jeśli nie autoryzowałeś jeszcze domeny swojej aplikacji, 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 dwa sposoby:
Ciche powiadomienia APN : gdy logujesz się użytkownika po raz pierwszy, Firebase może wysłać ciche powiadomienie push na urządzenie użytkownika. Uwierzytelnianie może być kontynuowane, jeśli aplikacja otrzyma powiadomienie. Pamiętaj, że począwszy od wersji iOS 8.0 nie musisz prosić użytkownika o zezwolenie na korzystanie z tej metody przez powiadomienia wypychane.
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 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 APN do użytku z Firebase:
W Xcode włącz powiadomienia push dla swojego projektu.
Prześlij swój klucz uwierzytelniający APNs za pomocą konsoli Firebase (Twoje zmiany zostaną automatycznie przeniesione do Google Cloud Firebase). Jeśli nie masz jeszcze klucza uwierzytelniania APN, zobacz Konfigurowanie APN za pomocą FCM, aby dowiedzieć się, jak go uzyskać.
Otwórz konsolę Firebase .
Przejdź do Ustawień projektu .
Wybierz kartę Wiadomości w chmurze .
W obszarze Klucz uwierzytelniania APNs w sekcji konfiguracji aplikacji na iOS kliknij Prześlij .
Wybierz swój klucz.
Dodaj identyfikator klucza dla klucza. Identyfikator klucza można znaleźć w sekcji Certyfikaty, identyfikatory i profile w Centrum członkowskim programistów Apple .
Kliknij Prześlij .
Jeśli masz już certyfikat APNs, możesz zamiast tego przesłać go.
Korzystanie z weryfikacji reCAPTCHA
Aby umożliwić klientowi SDK korzystanie z reCAPTCHA:
Otwórz konfigurację projektu w Xcode.
Kliknij dwukrotnie nazwę projektu w lewym widoku drzewa.
Wybierz aplikację w sekcji Cele .
Wybierz zakładkę Informacje .
Rozwiń sekcję Typy adresów URL .
Kliknij przycisk + .
Wprowadź swój odwrócony identyfikator klienta w polu Schematy adresów URL . Tę wartość można znaleźć w pliku konfiguracyjnym
GoogleService-Info.plist
jakoREVERSED_CLIENT_ID
.
Po zakończeniu konfiguracja powinna wyglądać podobnie do poniższej:
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 zapisu
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 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 zapisania drugiego czynnika podczas rejestracji. Aplikacje, które chcą zachęcać do uwierzytelniania wieloskładnikowego, ale go nie wymagają, mogą preferować to podejście.
Zapewnij możliwość dodania drugiego elementu ze strony zarządzania kontem lub profilem użytkownika zamiast ekranu rejestracji. Minimalizuje to problemy 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.
Rejestracja drugiego czynnika
Aby zapisać nowy dodatkowy czynnik dla użytkownika:
Ponownie uwierzytelnij użytkownika.
Poproś użytkownika o podanie numeru telefonu.
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) { // ... }];
Wyślij wiadomość weryfikacyjną na telefon użytkownika. Upewnij się, że numer telefonu jest sformatowany z wiodącym
+
i bez innych znaków interpunkcyjnych lub białych znaków (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, najlepszą praktyką jest wcześniejsze poinformowanie użytkowników, że otrzymają wiadomość SMS i że obowiązują standardowe stawki.
Metoda
verifyPhoneNumber()
uruchamia proces weryfikacji aplikacji w tle za pomocą cichego powiadomienia push. Jeśli ciche powiadomienie push nie jest dostępne, zamiast tego zostanie wysłane wezwanie reCAPTCHA.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];
Zainicjuj obiekt asercji:
Szybki
let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
Cel C
FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
Dokończ rejestrację. Opcjonalnie można określić nazwę wyświetlaną dla drugiego czynnika. Jest to przydatne dla użytkowników korzystających z wielu sekund, ponieważ numer telefonu jest maskowany podczas 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 pełny 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 uwierzytelniający dla użytkownika.
Logowanie użytkowników przy użyciu drugiego czynnika
Aby zalogować użytkownika za pomocą dwuskładnikowej weryfikacji SMS:
Zaloguj użytkownika przy użyciu pierwszego czynnika, a następnie wyłap błąd wskazujący, że wymagane jest uwierzytelnianie wieloskładnikowe. Ten błąd zawiera moduł rozpoznawania nazw, wskazówki dotyczące zarejestrowanych drugich czynników i podstawową sesję potwierdzającą, że użytkownik pomyślnie uwierzytelnił się przy użyciu 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, wyłap błąd po wywołaniu
getCredentialWith()
.Jeśli użytkownik ma zarejestrowanych wiele dodatkowych czynników, zapytaj, którego z nich użyć. Zamaskowany numer telefonu można uzyskać za pomocą
resolver.hints[selectedIndex].phoneNumber
, a 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 if resolver.hints[selectedIndex].factorID == TotpMultiFactorID { // User selected a TOTP second factor. // ... } else { // Unsupported second factor. }
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 if (hint.factorID == FIRTOTPMultiFactorID) { // User selected a TOTP second factor. // ... } else { // Unsupported second factor. }
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. } }];
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];
Zainicjuj obiekt potwierdzenia za pomocą poświadczeń:
Szybki
let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
Cel C
FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
Rozwiąż problem z logowaniem. Następnie możesz uzyskać dostęp do pierwotnego wyniku logowania, który obejmuje standardowe dane specyficzne dla dostawcy i poświadczenia uwierzytelniające:
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 pełny przykład logowania 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
- Programowo zarządzaj użytkownikami wieloskładnikowymi za pomocą pakietu Admin SDK.