Aggiunta dell'autenticazione a più fattori alla tua app per iOS

Questo documento mostra come aggiungere l'autenticazione a più fattori tramite SMS alla tua app iOS.

L'autenticazione a più fattori aumenta la sicurezza della tua app. Anche se gli utenti malintenzionati spesso compromettono password e account social, intercettare un messaggio è più difficile.

Prima di iniziare

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

  2. Assicurati che la tua app stia verificando le email degli utenti. L'autenticazione MFA richiede la verifica email. In questo modo è possibile impedire a malintenzionati di registrarsi a un servizio con un indirizzo email che non possiede e quindi bloccare il reale proprietario aggiungendo un secondo fattore.

Attivazione dell'autenticazione a più fattori

  1. Vai alla pagina Identity Platform MFA nella console Google Cloud.
    Vai alla pagina dell'MFA

  2. Nella casella Autenticazione a più fattori basata su SMS, fai clic su Attiva.

  3. Inserisci i numeri di telefono con cui testerai l'app. Sebbene sia facoltativa, la registrazione dei numeri di telefono di prova è vivamente consigliata per evitare limitazioni durante lo sviluppo.

  4. Se non hai già autorizzato il dominio della tua app, aggiungilo alla lista consentita facendo clic su Aggiungi dominio sulla destra.

  5. Fai clic su Salva.

Verifica dell'app

Identity Platform 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, Identity Platform può inviare una notifica push silenziosa al suo dispositivo. 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 l'utilizzo di questo metodo alle notifiche push.

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

Utilizzo delle notifiche silenziose

Per abilitare le notifiche del servizio APN per l'utilizzo con Identity Platform:

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

  2. Carica la chiave di autenticazione del servizio APN utilizzando la console Firebase (le modifiche verranno trasferite automaticamente alla piattaforma Google Cloud Identity). Se non hai ancora la chiave di autenticazione del servizio APN, consulta Configurazione del servizio APN con FCM per scoprire come ottenerla.

    1. Apri la Console Firebase.

    2. Vai a Impostazioni progetto.

    3. Seleziona la scheda Cloud Messaging.

    4. In Chiave di autenticazione del servizio APN, nella sezione Configurazione app per iOS, fai clic su Carica.

    5. Seleziona il token.

    6. Aggiungi l'ID della chiave. Puoi trovare l'ID della chiave in Certificati, identificatori e profili nel Centro membri di Apple Developer.

    7. Fai clic su Carica.

Se hai già un certificato del servizio APN, puoi caricarlo.

Utilizzo della verifica reCAPTCHA

Per abilitare l'SDK del client all'utilizzo di reCAPTCHA:

  1. Apri la configurazione del progetto in Xcode.

  2. Fai doppio clic sul nome del progetto nella visualizzazione ad albero a sinistra.

  3. Seleziona l'app dalla sezione Target.

  4. Seleziona la scheda Informazioni.

  5. Espandi la sezione Tipi di URL.

  6. Fai clic sul pulsante +.

  7. Inserisci l'ID client invertito nel campo Schemi URL. Questo valore viene elencato nel file di configurazione GoogleService-Info.plist come REVERSED_CLIENT_ID.

Una volta completata, la configurazione dovrebbe essere simile alla seguente:

Schemi personalizzati

Se vuoi, puoi personalizzare il modo in cui l'app presenta SFSafariViewController o UIWebView quando visualizzi il reCAPTCHA. A questo scopo, crea una classe personalizzata conforme al protocollo FIRAuthUIDelegate e trasmettila a verifyPhoneNumber:UIDelegate:completion:.

Scelta di un pattern di registrazione

Puoi scegliere se la tua app richiede l'autenticazione a più fattori e come e quando registrare gli utenti. Alcuni schemi comuni includono:

  • Registra il secondo fattore dell'utente come parte della registrazione. Utilizza 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à accettarlo.

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

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

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

Registrazione di un secondo fattore

Per registrare un nuovo fattore secondario per un utente:

  1. Esegui nuovamente l'autenticazione dell'utente.

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

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

    Swift

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

    Objective-C

    [authResult.user.multiFactor
      getSessionWithCompletion:^(FIRMultiFactorSession * _Nullable session,
                                NSError * _Nullable error) {
        // ...
    }];
    
  4. Invia un messaggio di verifica al telefono dell'utente. Assicurati che il formato del numero di telefono includa un carattere + iniziale e non altri segni di punteggiatura o spazi vuoti (ad esempio: +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.
    }];
    

    Sebbene non sia obbligatorio, la best practice consiglia di informare in anticipo gli utenti che riceveranno un SMS e che verranno applicate le tariffe standard.

    Il metodo verifyPhoneNumber() avvia la procedura di verifica app in background utilizzando una notifica push silenziosa. Se la notifica push silenziosa non è disponibile,viene generata una verifica reCAPTCHA.

  5. Una volta inviato il codice SMS, chiedi all'utente di verificarlo. Quindi, utilizza la sua risposta per creare un 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. Inizializza un oggetto asserzione:

    Swift

    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
    

    Objective-C

    FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
    
  7. Completa la registrazione. Se vuoi, puoi specificare un nome visualizzato per il secondo fattore. Questo è utile per gli utenti con più fattori secondari, poiché il numero di telefono viene mascherato durante il flusso di autenticazione (ad esempio, +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) {
        // ...
    }];
    

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

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

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

Fare in modo che gli utenti accedano con un secondo fattore

Per eseguire l'accesso di un utente con la verifica tramite SMS a due fattori:

  1. Fai accedere l'utente con il 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 prova che l'utente ha eseguito correttamente l'autenticazione con il primo fattore.

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

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

  2. Se l'utente ha più fattori secondari registrati, chiedi quale usare. Puoi ottenere il numero di telefono mascherato con resolver.hints[selectedIndex].phoneNumber e il nome visualizzato con 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. Invia un messaggio di verifica al telefono dell'utente:

    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. Dopo aver inviato il codice SMS, chiedi all'utente di verificarlo e utilizzarlo per creare un 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. Inizializza un oggetto asserzione con la credenziale:

    Swift

    let assertion = PhoneMultiFactorGenerator.assertion(with: credential)
    

    Objective-C

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

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

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

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

Complimenti! Hai eseguito correttamente l'accesso a un utente utilizzando l'autenticazione basata su più fattori.

Passaggi successivi