Ajouter l'authentification multifacteur TOTP à votre application Android

Si vous êtes passé à Firebase Authentication with Identity Platform, vous pouvez ajouter l'authentification multifacteur (MFA) par mot de passe à usage unique basé sur le temps (TOTP) à votre application.

Firebase Authentication with Identity Platform vous permet d'utiliser un TOTP comme facteur supplémentaire pour l'authentification MFA. Lorsque vous activez cette fonctionnalité, les utilisateurs qui tentent de se connecter à votre application voient une demande de TOTP. Pour le générer, ils doivent utiliser une application d'authentification capable de générer des codes TOTP valides, comme Google Authenticator.

Avant de commencer

  1. Activez au moins un fournisseur compatible avec l'authentification multifacteur. Notez que tous les fournisseurs, à l'exception des suivants, sont compatibles avec l'authentification multifacteur :

    • Authentification par téléphone
    • Authentification anonyme
    • Jetons d'authentification personnalisés
    • Apple Game Center

  2. Assurez-vous que votre application valide les adresses e-mail des utilisateurs. La MFA nécessite la validation de l'adresse e-mail. Cela empêche les personnes malveillantes de s'inscrire à un service avec une adresse e-mail qui ne leur appartient pas, puis de bloquer le véritable propriétaire de l'adresse e-mail en ajoutant un deuxième facteur.

  3. Si vous ne l'avez pas déjà fait, installez le SDK Firebase pour Android.

    La validation en deux étapes par TOTP n'est compatible qu'avec le SDK Android version 22.1.0 et les versions ultérieures.

Activer la MFA TOTP

Pour activer le TOTP en tant que deuxième facteur, utilisez Admin SDK ou appelez le point de terminaison REST de configuration du projet.

Pour utiliser Admin SDK, procédez comme suit :

  1. Si vous ne l'avez pas déjà fait, installez le SDK Firebase Admin Node.js.

    La MFA TOTP n'est compatible qu'avec les versions 11.6.0 et ultérieures du SDK Firebase Admin pour Node.js.

  2. Exécutez la commande suivante :

    import { getAuth } from 'firebase-admin/auth';

getAuth().projectConfigManager().updateProjectConfig(
{
      multiFactorConfig: {
          providerConfigs: [{
              state: "ENABLED",
              totpProviderConfig: {
                  adjacentIntervals: NUM_ADJ_INTERVALS
              }
          }]
      }
})

    Remplacez les éléments suivants :

    • NUM_ADJ_INTERVALS : nombre d'intervalles de temps adjacents à partir desquels accepter les TOTP, de zéro à dix. La valeur par défaut est 5.

      Les TOTP fonctionnent en s'assurant que lorsque deux parties (le prouveur et le validateur) génèrent des OTP dans la même période (généralement 30 secondes), elles génèrent le même mot de passe. Toutefois, pour tenir compte de la dérive d'horloge entre les parties et du temps de réponse humain, vous pouvez configurer le service TOTP pour qu'il accepte également les TOTP des fenêtres adjacentes.

Pour activer la validation en deux étapes par TOTP à l'aide de l'API REST, exécutez la commande suivante :

curl -X PATCH "https://identitytoolkit.googleapis.com/admin/v2/projects/PROJECT_ID/config?updateMask=mfa" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -H "X-Goog-User-Project: PROJECT_ID" \
    -d \
    '{
        "mfa": {
          "providerConfigs": [{
            "state": "ENABLED",
            "totpProviderConfig": {
              "adjacentIntervals": NUM_ADJ_INTERVALS
            }
          }]
       }
    }'

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet.

  • NUM_ADJ_INTERVALS : nombre d'intervalles de temps, de zéro à dix. La valeur par défaut est 5.

    Les TOTP fonctionnent en s'assurant que lorsque deux parties (le prouveur et le validateur) génèrent des OTP dans la même période (généralement 30 secondes), elles génèrent le même mot de passe. Toutefois, pour tenir compte de la dérive d'horloge entre les parties et du temps de réponse humain, vous pouvez configurer le service TOTP pour qu'il accepte également les TOTP des fenêtres adjacentes.

Choisir un modèle d'enregistrement

Vous pouvez choisir si votre application nécessite l'authentification multifacteur, ainsi que comment et quand enregistrer vos utilisateurs. Voici quelques modèles courants :

  • Enregistrez le second facteur de l'utilisateur lors de l'inscription. Utilisez cette méthode si votre application nécessite une authentification multifacteur pour tous les utilisateurs.

  • Proposez une option désactivable pour inscrire un second facteur lors de l'enregistrement. Vous pouvez utiliser cette approche si vous souhaitez encourager l'authentification multifacteur dans votre application, sans l'imposer.

  • Offrez la possibilité d'ajouter un deuxième facteur à partir de la page de gestion du compte ou du profil de l'utilisateur, plutôt que de l'écran d'inscription. Cela minimise les frictions lors du processus d'enregistrement tout en rendant encore l'authentification multifacteur disponible pour les utilisateurs sensibles à la sécurité.

  • Exigez l'ajout incrémentiel d'un second facteur lorsque l'utilisateur souhaite accéder aux fonctionnalités présentant des exigences de sécurité accrues.

Activer la MFA TOTP pour des utilisateurs

Après avoir activé l'authentification MFA TOTP en tant que deuxième facteur pour votre application, implémentez la logique côté client pour enregistrer les utilisateurs dans l'authentification MFA TOTP :

  1. Réauthentifiez l'utilisateur.

  2. Générez un secret TOTP pour l'utilisateur authentifié :

    // Generate a TOTP secret.
Firebase.auth.currentUser.multiFactor.session
    .addOnSuccessListener { multiFactorSession ->
        TotpMultiFactorGenerator.generateSecret(multiFactorSession)
            .addOnSuccessListener { totpSecret ->
                // Display the secret to the user and prompt them to
                // enter it into their authenticator app. (See the next
                // step.)
            }
    }

  3. Affichez le secret à l'utilisateur et invitez-le à le saisir dans son application d'authentification :

    // Display this key:
val secret = totpSecret.sharedSecretKey

    En plus d'afficher la clé secrète, vous pouvez essayer de l'ajouter automatiquement à l'application d'authentification par défaut de l'appareil. Pour ce faire, générez un URI de clé compatible avec Google Authenticator et transmettez-le à openInOtpApp() :

    val qrCodeUri = totpSecret.generateQrCodeUrl(
    currentUser.email ?: "default account",
    "Your App Name")
totpSecret.openInOtpApp(qrCodeUri)

    Une fois que l'utilisateur a ajouté son secret à son application d'authentification, celle-ci commence à générer des TOTP.

  4. Invitez l'utilisateur à saisir le TOTP affiché par son application d'authentification et utilisez-le pour finaliser l'enregistrement MFA :

    // Ask the user for a verification code from the authenticator app.
val verificationCode = // Code from user input.

// Finalize the enrollment.
val multiFactorAssertion = TotpMultiFactorGenerator
    .getAssertionForEnrollment(totpSecret, verificationCode)
Firebase.auth.currentUser.multiFactor.enroll(multiFactorAssertion, "TOTP")
    .addOnSuccessListener {
        // Enrollment complete.
    }

Connecter les utilisateurs avec un deuxième facteur

Pour connecter des utilisateurs avec la MFA TOTP, utilisez le code suivant :

  1. Appelez l'une des méthodes signInWith- comme vous le feriez si vous n'utilisiez pas la MFA. (par exemple, signInWithEmailAndPassword()). Si la méthode génère une exception FirebaseAuthMultiFactorException, démarrez le flux MFA de votre application.

    Firebase.auth.signInWithEmailAndPassword(email, password)
    .addOnSuccessListener { result ->
        // If the user is not enrolled with a second factor and provided valid
        // credentials, sign-in succeeds.

        // (If your app requires MFA, this could be considered an error
        // condition, which you would resolve by forcing the user to enroll a
        // second factor.)

        // ...
    }
    .addOnFailureListener { exception ->
        when (exception) {
            is FirebaseAuthMultiFactorException -> {
                // Initiate your second factor sign-in flow. (See next step.)
                // ...
            }
        }
    }

  2. Le flux MFA de votre application doit d'abord inviter l'utilisateur à choisir le deuxième facteur qu'il souhaite utiliser. Vous pouvez obtenir la liste des deuxièmes facteurs compatibles en examinant la propriété hints d'une instance MultiFactorResolver :

    val enrolledFactors = exception.resolver.hints.map { it.displayName }

  3. Si l'utilisateur choisit d'utiliser le TOTP, invitez-le à saisir le TOTP affiché dans son application d'authentification et à l'utiliser pour se connecter :

    when (exception.resolver.hints[selectedIndex].factorId) {
    TotpMultiFactorGenerator.FACTOR_ID -> {
        val otpFromAuthenticator = // OTP typed by the user.
        val assertion = TotpMultiFactorGenerator.getAssertionForSignIn(
            exception.resolver.hints[selectedIndex].uid,
            otpFromAuthenticator
        )
        exception.resolver.resolveSignIn(assertion)
            .addOnSuccessListener { result ->
                // Successfully signed in!
            }
            .addOnFailureListener { resolveError ->
                // Invalid or expired OTP.
            }
    }
    PhoneMultiFactorGenerator.FACTOR_ID -> {
        // Handle SMS second factor.
    }
}

Se désinscrire de la MFA par TOTP

Cette section explique comment gérer la désinscription d'un utilisateur de la MFA TOTP.

Si un utilisateur s'est inscrit à plusieurs options de MFA et qu'il se désinscrit de l'option activée le plus récemment, il reçoit un auth/user-token-expired et est déconnecté. L'utilisateur doit se reconnecter et valider ses identifiants existants (par exemple, une adresse e-mail et un mot de passe).

Pour désinscrire l'utilisateur, gérer l'erreur et déclencher une nouvelle authentification, utilisez le code suivant :

Firebase.auth.currentUser.multiFactor.unenroll(mfaEnrollmentId)
    .addOnSuccessListener {
        // Second factor unenrolled.
    }
    .addOnFailureListener { exception ->
        when (exception) {
            is FirebaseAuthInvalidUserException -> {
                // Second factor unenrolled. If the user was signed out, re-authenticate
                // them.

                // For example, if they signed in with a password, prompt them to
                // provide it again, then call `reauthenticateWithCredential()` as shown
                // below.
                val credential = EmailAuthProvider.getCredential(email, password)
                currentUser.reauthenticate(credential)
                    .addOnSuccessListener { 
                        // Success!
                    }
                    .addOnFailureListener { 
                        // Bad email address and password combination.
                    }
            }
        }
    }

Étape suivante