Como adicionar a autenticação multifator ao seu app iOS

Se você fez upgrade para o Firebase Authentication com o Identity Platform, poderá adicionar a autenticação multifator por SMS ao seu app iOS.

A autenticação multifator aumenta a segurança do app. Os invasores costumam comprometer as senhas e contas de redes sociais, mas é mais difícil interceptar uma mensagem de texto.

Antes de começar

Observação: o uso da autenticação multifator com vários locatários não é suportado no iOS.

1. Ative pelo menos um provedor compatível com a autenticação multifator. Todos os provedores são compatíveis com a autenticação multifator (MFA), exceto as autenticações por smartphone e a anônima e o Apple Game Center.

2. Confirme se o app está verificando os e-mails do usuário. A autenticação multifator (MFA) requer verificação de e-mail. Isso impede que agentes mal-intencionados se registrem em um serviço com um e-mail que não tenham e bloqueiem o proprietário real adicionando um segundo fator.

Como ativar a autenticação multifator

1. Abra a página Autenticação > Método de login do Console do Firebase.

2. Na seção Avançado, ative Autenticação multifator por SMS.

   Insira também os números de telefone usados para testar o app. Embora opcional, é recomendável registrar números de telefone de teste para evitar a limitação durante o desenvolvimento.

3. Se você ainda não autorizou o domínio do seu app, adicione-o à lista de permissões na página Autenticação > Configurações do Console do Firebase.

Como verificar seu app

O Firebase precisa verificar se as solicitações de SMS vêm do app. É possível fazer isso de duas maneiras:

• Notificações de APNs silenciosas: quando você faz login em um usuário pela primeira vez, o Firebase pode enviar uma notificação push silenciosa para o dispositivo do usuário. A autenticação poderá continuar se o app receber a notificação. No iOS 8.0 e versões mais recentes, não é necessário solicitar ao usuário que permita notificações push para usar esse método.

• Verificação reCAPTCHA: se não for possível enviar uma notificação silenciosa (por exemplo, porque o usuário desativou a atualização em segundo plano ou você está testando seu app no simulador do iOS), use o reCAPTCHA. Em muitos casos, o reCAPTCHA será resolvido automaticamente sem interação do usuário.

Como usar notificações silenciosas

Para ativar notificações de APNs para uso com o Firebase Authentication, faça o seguinte:

1. No Xcode, ative as notificações push para seu projeto.

2. Faça upload da chave de autenticação de APNs usando o Console do Firebase. Suas alterações serão automaticamente transferidas para o Google Cloud Firebase. Se você ainda não tem a chave de autenticação de APNs, consulte Como configurar APNs com o FCM para saber mais.

   1. Abra o Console do Firebase.

   2. Navegue até Configurações do projeto.

   3. Selecione a guia Cloud Messaging.

   4. Em Chave de autenticação de APNs, na seção Configuração do app para iOS, clique em Fazer upload.

   5. Selecione a chave.

   6. Adicione o ID da chave. Encontre o ID da chave em Certificates, Identifiers & Profiles no Apple Developer Member Center.

   7. Clique em Upload.

Se você já tiver um certificado APN, faça upload dele.

Como usar a verificação reCAPTCHA

Para ativar o SDK do cliente e usar o reCAPTCHA. faça o seguinte:

1. Abra a configuração do seu projeto no Xcode.

2. Clique duas vezes no nome do projeto na visualização em árvore à esquerda.

3. Selecione seu app na seção Destinos.

4. Selecione a guia Informações.

5. Expanda a seção Tipos de URL.

6. Clique no botão +.

7. Insira o ID do cliente revertido no campo Esquemas de URL. Esse valor está listado no arquivo de configuração GoogleService-Info.plist como REVERSED_CLIENT_ID.

Quando concluída, a configuração será semelhante a esta:

Também é possível personalizar a forma como o app apresenta o SFSafariViewController ou UIWebView ao exibir o reCAPTCHA. Para fazer isso, crie uma classe personalizada que esteja em conformidade com o protocolo FIRAuthUIDelegate e transmita para verifyPhoneNumber:UIDelegate:completion:.

Como escolher um padrão de registro

É possível escolher se o app requer autenticação multifator e como e quando registrar os usuários. Alguns padrões comuns incluem:

• Registrar o segundo fator do usuário como parte do processo. Use esse método se o app exigir autenticação multifator para todos os usuários. Observe que uma conta precisa ter um endereço de e-mail verificado para registrar um segundo fator. Portanto, seu fluxo de registro terá que acomodar isso.

• Oferecer uma opção pulável para registrar um segundo fator durante o processo. Os apps que quiserem incentivar, mas não exigirem, a autenticação multifator terão essa abordagem.

• Permitir a adição de um segundo fator na página de gerenciamento da conta ou no perfil do usuário, em vez da tela de inscrição. Isso minimiza o atrito durante o processo de registro, ao mesmo tempo que disponibiliza a autenticação multifator para usuários que se preocupam com a segurança.

• Exigir a adição de um segundo fator de maneira incremental quando o usuário quiser acessar recursos com requisitos de segurança aprimorados.

Como registrar um segundo fator

Para registrar um novo fator secundário para um usuário:

1. Reautentique o usuário.

2. Peça ao usuário para inserir o número de telefone.

   Observação: o Google armazena e usa números de telefone para melhorar a prevenção contra spam e abuso em todos os nossos serviços. Verifique se você recebeu o consentimento adequado dos usuários antes de enviar os números de telefone deles para o Firebase.

3. Disponibilize uma sessão de vários fatores para o usuário:

   Swift

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

   Objective-C

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

4. Envie uma mensagem de verificação ao smartphone do usuário. Verifique se o número de telefone está formatado com + no começo e sem outros sinais de pontuação ou espaços em branco (por exemplo: [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.
   }];
   

   Não é obrigatório, mas recomendamos informar aos usuários antecipadamente que eles receberão uma mensagem SMS e quais taxas padrão serão aplicadas.

   O método verifyPhoneNumber() inicia o processo de verificação do app em segundo plano usando a notificação push silenciosa. Se a notificação push silenciosa não estiver disponível, um desafio reCAPTCHA será emitido.

5. Após o envio do código SMS, peça ao usuário para fazer a verificação. Em seguida, use a resposta dele para criar um 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. Inicialize um objeto de declaração:

   Swift

   let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
   

   Objective-C

   FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
   

7. Conclua o registro. Se quiser, especifique um nome de exibição para o segundo fator. Isso é útil para usuários com vários fatores, já que o número de telefone é mascarado durante o fluxo de autenticação (por exemplo, +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) {
       // ...
   }];
   

O código abaixo mostra um exemplo completo de registro de um segundo fator:

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

Parabéns! Você registrou um segundo fator de autenticação para um usuário.

Importante: você precisa incentivar seus usuários a registrar mais de um segundo fator para fins de recuperação de conta. Se um usuário registrar só mais um fator e perder o acesso a ele, a conta será bloqueada.

Como fazer login dos usuários com um segundo fator

Para fazer login de um usuário com verificação por SMS de dois fatores:

1. Faça o login do usuário com o primeiro fator e, em seguida, capture um erro indicando que a autenticação multifator é necessária. Esse erro contém um resolvedor, dicas sobre os dois fatores registrados e uma sessão que mostra que o usuário foi autenticado com o primeiro fator.

   Por exemplo, se o primeiro fator do usuário for um e-mail e uma senha:

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

   Se o primeiro fator do usuário for um provedor federado, como o OAuth, capture o erro depois de chamar getCredentialWith().

2. Se o usuário tiver vários fatores secundários registrados, pergunte a ele qual usar. É possível conseguir o número de telefone mascarado com resolver.hints[selectedIndex].phoneNumber e o nome de exibição com 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. Envie um código de verificação ao smartphone do usuário:

   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. Depois que o código SMS for enviado, peça ao usuário para verificar o código e usá-lo para criar um 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. Inicialize um objeto de declaração com a credencial:

   Swift

   let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
   

   Objective-C

   FIRMultiFactorAssertion *assertion =
       [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
   

6. Resolva o login. Em seguida, você pode acessar o resultado do login original, que inclui os dados padrão do provedor e as credenciais de autenticação:

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

O código abaixo mostra um exemplo completo de login em um usuário de vários fatores:

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

Parabéns! Você fez login com sucesso usando uma autenticação multifator.

A seguir

• Gerencie usuários de vários fatores programaticamente com o SDK Admin.