Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Aggiungi l'autenticazione a più fattori alla tua app iOS

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Se hai eseguito l'upgrade a Firebase Authentication con Identity Platform, puoi aggiungere l'autenticazione a più fattori SMS alla tua app iOS.

L'autenticazione a più fattori aumenta la sicurezza della tua app. Mentre gli aggressori spesso compromettono password e account social, intercettare un messaggio di testo è più difficile.

Prima di iniziare

  1. Abilita almeno un provider che supporti l'autenticazione a più fattori. Tutti i provider supportano MFA, ad eccezione dell'autenticazione telefonica, dell'autenticazione anonima e di Apple Game Center.

  2. Assicurati che la tua app stia verificando le email degli utenti. MFA richiede la verifica dell'e-mail. Ciò impedisce agli attori malintenzionati di registrarsi a un servizio con un'e-mail che non possiedono e quindi bloccare il vero proprietario aggiungendo un secondo fattore.

Abilitazione dell'autenticazione a più fattori

  1. Apri la pagina Metodo di accesso > Autenticazione della console Firebase.

  2. Nella sezione Avanzate , abilita SMS Multi-factor Authentication .

    Dovresti anche inserire i numeri di telefono con cui testerai la tua app. Anche se facoltativo, la registrazione dei numeri di telefono di prova è fortemente consigliata per evitare limitazioni durante lo sviluppo.

  3. Se non hai già autorizzato il dominio della tua app, aggiungilo all'elenco Consenti nella pagina Autenticazione > Impostazioni della console Firebase.

Verifica della tua app

Firebase deve verificare che le richieste SMS provengano dalla tua app. Puoi farlo in due modi:

  • Notifiche APN silenziose : quando accedi per la prima volta a un utente, Firebase può inviare una notifica push silenziosa al dispositivo dell'utente. L'autenticazione può procedere se l'app riceve la notifica. Tieni presente che a partire da iOS 8.0, non è necessario chiedere all'utente di consentire le notifiche push per utilizzare questo metodo.

  • Verifica reCAPTCHA : se non puoi inviare una notifica silenziosa (ad esempio, perché l'utente ha disabilitato l'aggiornamento in background o stai testando la tua app nel simulatore iOS), puoi utilizzare reCAPTCHA. In molti casi, reCAPTCHA si risolverà automaticamente senza alcuna interazione da parte dell'utente.

Utilizzo delle notifiche silenziose

Per abilitare le notifiche APN per l'utilizzo con Firebase:

  1. In Xcode, abilita le notifiche push per il tuo progetto.

  2. Carica la tua chiave di autenticazione APN utilizzando la console di Firebase (le tue modifiche verranno trasferite automaticamente a Google Cloud Firebase). Se non disponi già della chiave di autenticazione APNs, consulta Configurazione di APNs con FCM per informazioni su come ottenerla.

    1. Apri la console di Firebase .

    2. Passare a Impostazioni progetto .

    3. Seleziona la scheda Messaggistica cloud .

    4. In Chiave di autenticazione APNs , nella sezione Configurazione app iOS , fai clic su Carica .

    5. Seleziona la tua chiave.

    6. Aggiungere l'ID chiave per la chiave. Puoi trovare l'ID chiave in Certificati, identificatori e profili nell'Apple Developer Member Center .

    7. Fai clic su Carica .

Se disponi già di un certificato APNs, puoi invece caricare il certificato.

Utilizzo della verifica reCAPTCHA

Per consentire all'SDK del client di utilizzare reCAPTCHA:

  1. Apri la configurazione del tuo progetto in Xcode.

  2. Fare doppio clic sul nome del progetto nella vista ad albero a sinistra.

  3. Seleziona la tua app dalla sezione Obiettivi .

  4. Seleziona la scheda Informazioni .

  5. Espandi la sezione Tipi di URL .

  6. Fare clic sul pulsante + .

  7. Inserisci il tuo ID cliente invertito nel campo Schemi URL . Puoi trovare questo valore elencato nel file di configurazione GoogleService-Info.plist come REVERSED_CLIENT_ID .

Al termine, la configurazione dovrebbe essere simile alla seguente:

Schemi personalizzati

Facoltativamente, puoi personalizzare il modo in cui la tua app presenta SFSafariViewController o UIWebView durante la visualizzazione di reCAPTCHA. Per fare ciò, crea una classe personalizzata conforme al protocollo FIRAuthUIDelegate e passala a verifyPhoneNumber:UIDelegate:completion: .

Scelta di un modello di iscrizione

Puoi scegliere se la tua app richiede l'autenticazione a più fattori e come e quando iscrivere i tuoi utenti. Alcuni modelli comuni includono:

  • Registrare il secondo fattore dell'utente come parte della registrazione. Usa questo metodo se la tua app richiede l'autenticazione a più fattori per tutti gli utenti. Tieni presente che un account deve avere un indirizzo email verificato per registrare un secondo fattore, quindi il tuo flusso di registrazione dovrà adattarsi a questo.

  • Offri un'opzione ignorabile per iscrivere un secondo fattore durante la registrazione. Le app che vogliono incoraggiare, ma non richiedere, l'autenticazione a più fattori potrebbero preferire questo approccio.

  • Fornire la possibilità di aggiungere un secondo fattore dall'account dell'utente o dalla pagina di gestione del profilo, anziché dalla schermata di registrazione. Ciò riduce al minimo l'attrito durante il processo di registrazione, pur rendendo disponibile l'autenticazione a più fattori per gli utenti sensibili alla sicurezza.

  • Richiede l'aggiunta di un secondo fattore in modo incrementale quando l'utente desidera accedere a funzionalità con requisiti di sicurezza maggiori.

Iscrizione di un secondo fattore

Per registrare un nuovo fattore secondario per un utente:

  1. Riautenticare l'utente.

  2. Chiedi all'utente di inserire il proprio numero di telefono.

  3. Ottieni una sessione a più fattori per l'utente:

    Rapido

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

    Obiettivo-C

    [authResult.user.multiFactor
      getSessionWithCompletion:^(FIRMultiFactorSession * _Nullable session,
                                NSError * _Nullable error) {
        // ...
    }];
    
  4. Invia un messaggio di verifica al telefono dell'utente. Assicurati che il numero di telefono sia formattato con un + iniziale e nessun altro segno di punteggiatura o spazio vuoto (ad esempio: +15105551234 )

    Rapido

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

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

    Sebbene non sia obbligatorio, è consigliabile informare in anticipo gli utenti che riceveranno un messaggio SMS e che si applicano le tariffe standard.

    Il metodo verifyPhoneNumber() avvia il processo di verifica dell'app in background utilizzando la notifica push silenziosa. Se la notifica push silenziosa non è disponibile, viene invece emessa una sfida reCAPTCHA.

  5. Una volta inviato il codice SMS, chiedere all'utente di verificare il codice. Quindi, usa la loro risposta per creare un PhoneAuthCredential :

    Rapido

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

    Obiettivo-C

    // Ask user for the SMS verification code. Then:
    FIRPhoneAuthCredential *credential = [FIRPhoneAuthProvider.provider
                                           credentialWithVerificationID:verificationID
                                           verificationCode:kPhoneSecondFactorVerificationCode];
    
  6. Inizializza un oggetto asserzione:

    Rapido

    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
    

    Obiettivo-C

    FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
    
  7. Completa l'iscrizione. Facoltativamente, è possibile specificare un nome visualizzato per il secondo fattore. Ciò è utile per gli utenti con più secondi fattori, poiché il numero di telefono viene mascherato durante il flusso di autenticazione (ad esempio, +1******1234).

    Rapido

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

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

Il codice seguente mostra un esempio completo di registrazione di un secondo fattore:

Rapido

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

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

Congratulazioni! Hai registrato correttamente un secondo fattore di autenticazione per un utente.

Accesso degli utenti con un secondo fattore

Per accedere a un utente con la verifica SMS a due fattori:

  1. Accedi all'utente con il suo primo fattore, quindi rileva un errore che indica che è richiesta l'autenticazione a più fattori. Questo errore contiene un resolver, suggerimenti sui secondi fattori registrati e una sessione sottostante che dimostra che l'utente è stato autenticato correttamente con il primo fattore.

    Ad esempio, se il primo fattore dell'utente era un'e-mail e una password:

    Rapido

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

    Obiettivo-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 il primo fattore dell'utente è un provider federato, ad esempio OAuth, rileva l'errore dopo aver chiamato getCredentialWith() .

  2. Se l'utente ha registrato più fattori secondari, chiedigli quale utilizzare. Puoi ottenere il numero di telefono mascherato con resolver.hints[selectedIndex].phoneNumber e il nome visualizzato con resolver.hints[selectedIndex].displayName .

    Rapido

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

    Obiettivo-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. Invia un messaggio di verifica al telefono dell'utente:

    Rapido

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

    Obiettivo-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. Una volta inviato il codice SMS, chiedi all'utente di verificare il codice e di utilizzarlo per creare un PhoneAuthCredential :

    Rapido

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

    Obiettivo-C

    // Ask user for the SMS verification code. Then:
    FIRPhoneAuthCredential *credential =
        [FIRPhoneAuthProvider.provider
          credentialWithVerificationID:verificationID
                      verificationCode:verificationCodeFromUser];
    
  5. Inizializza un oggetto asserzione con la credenziale:

    Rapido

    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
    

    Obiettivo-C

    FIRMultiFactorAssertion *assertion =
        [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
    
  6. Risolvi l'accesso. È quindi possibile accedere al risultato di accesso originale, che include i dati specifici del provider standard e le credenziali di autenticazione:

    Rapido

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

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

Il codice seguente mostra un esempio completo di accesso di un utente a più fattori:

Rapido

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

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

Congratulazioni! Hai eseguito correttamente l'accesso di un utente utilizzando l'autenticazione a più fattori.

Qual è il prossimo