Cette page a été traduite par l'API Cloud Translation.

Ajouter l'authentification multifacteur TOTP à votre application iOS

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 code TOTP comme facteur supplémentaire pour l'authentification multifacteur. Lorsque vous activez cette fonctionnalité, les utilisateurs qui tentent de se connecter à votre application voient une demande de code 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

Activez au moins un fournisseur compatible avec l'authentification multifacteur. Notez que tous les fournisseurs sauf les suivants sont compatibles avec l'authentification multifactor :
- Authentification par téléphone
- Authentification anonyme
- Jetons d'authentification personnalisés
- Apple Game Center
Assurez-vous que votre application valide les adresses e-mail des utilisateurs. L'authentification multifacteur nécessite une validation de l'adresse e-mail. Cela empêche les utilisateurs malveillants de s'enregistrer à un service avec une adresse e-mail dont ils ne sont pas propriétaire, puis de bloquer le propriétaire réel de l'adresse e-mail en ajoutant un second facteur.
Si vous ne l'avez pas déjà fait, installez le SDK Firebase Apple.

L'authentification multifacteur TOTP n'est compatible qu'avec la version 10.12.0 du SDK Apple et les versions ultérieures, et uniquement sur iOS.

Activer l'authentification multifacteur TOTP

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

Pour utiliser le Admin SDK, procédez comme suit :

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

L'authentification multifacteur TOTP n'est compatible qu'avec les versions 11.6.0 et ultérieures du SDK Firebase Admin Node.js.
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 fenêtre temporelle adjacents à partir desquels accepter les TOTP, de zéro à dix. La valeur par défaut est de cinq.
  
  Les codes TOTP fonctionnent en s'assurant que lorsque deux parties (le demandeur et le validateur) génèrent des OTP dans la même fenêtre temporelle (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 l'authentification multifacteur 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 période, de zéro à dix. La valeur par défaut est de cinq.

Les codes TOTP fonctionnent en s'assurant que lorsque deux parties (le demandeur et le validateur) génèrent des OTP dans la même fenêtre temporelle (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'inscription

Vous pouvez décider si votre application nécessite une authentification multifacteur, et comment et quand inscrire vos utilisateurs. Voici quelques exemples de modèles courants :

Inscrivez le deuxième facteur de l'utilisateur dans le cadre 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. Si vous souhaitez encourager l'authentification multifacteur dans votre application, mais pas l'exiger, vous pouvez utiliser cette approche.
Offrez la possibilité d'ajouter un second facteur à partir de la page de gestion de compte ou de profil de l'utilisateur, au lieu 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

Une fois que vous avez activé l'authentification multifacteur TOTP comme second facteur pour votre application, implémentez une logique côté client pour inscrire les utilisateurs à l'authentification multifacteur TOTP :

Réauthentifiez l'utilisateur.

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

// Generate a TOTP secret.
guard let mfaSession = try? await currentUser.multiFactor.session() else { return }
guard let totpSecret = try? await TOTPMultiFactorGenerator.generateSecret(with: mfaSession) else { return }

// Display the secret to the user and prompt them to enter it into their
// authenticator app. (See the next step.)

Affichez le code secret à l'utilisateur et invitez-le à le saisir dans son application d'authentification :
```
// Display this key:
let 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(withQRCodeURL:) :
```
let otpAuthUri = totpSecret.generateQRCodeURL(
    withAccountName: currentUser.email ?? "default account",
    issuer: "Your App Name")
totpSecret.openInOTPApp(withQRCodeURL: otpAuthUri)
```
Une fois que l'utilisateur a ajouté son code secret à son application d'authentification, celle-ci commence à générer des codes TOTP.

Invitez l'utilisateur à saisir le code TOTP affiché par son application d'authentification et utilisez-le pour finaliser l'inscription à l'AMF :

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

// Finalize the enrollment.
let multiFactorAssertion = TOTPMultiFactorGenerator.assertionForEnrollment(
    with: totpSecret,
    oneTimePassword: verificationCode)
do {
    try await currentUser.multiFactor.enroll(
        with: multiFactorAssertion,
        displayName: "TOTP")
} catch {
    // Wrong or expired OTP. Re-prompt the user.
}

Connecter des utilisateurs avec un second facteur

Pour connecter les utilisateurs avec l'authentification multifacteur TOTP, utilisez le code suivant :

Appelez l'une des méthodes signIn(with...:) comme vous le feriez si vous n'utilisiez pas l'authentification multifactorielle (par exemple, signIn(withEmail:password:)). Si la méthode génère une erreur avec le code secondFactorRequired, démarrez le flux d'authentification multifactorielle de votre application.

do {
    let authResult = try await Auth.auth().signIn(withEmail: email, password: password)

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

    // ...
} catch let error as AuthErrorCode where error.code == .secondFactorRequired {
    // Initiate your second factor sign-in flow. (See next step.)
    // ...
} catch {
    // Other auth error.
    throw error
}

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 facteurs secondaires acceptés en examinant la propriété hints d'une instance MultiFactorResolver :
```
let mfaKey = AuthErrorUserInfoMultiFactorResolverKey
guard let resolver = error.userInfo[mfaKey] as? MultiFactorResolver else { return }
let enrolledFactors = resolver.hints.map(\.displayName)
```

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 :

let multiFactorInfo = resolver.hints[selectedIndex]
switch multiFactorInfo.factorID {
case TOTPMultiFactorID:
    let otpFromAuthenticator = // OTP typed by the user.
    let assertion = TOTPMultiFactorGenerator.assertionForSignIn(
        withEnrollmentID: multiFactorInfo.uid,
        oneTimePassword: otpFromAuthenticator)
    do {
        let authResult = try await resolver.resolveSignIn(with: assertion)
    } catch {
        // Wrong or expired OTP. Re-prompt the user.
    }
default:
    return
}

Se désinscrire de l'authentification multifacteur TOTP

Cette section explique comment gérer la désinscription d'un utilisateur à l'authentification multifacteur TOTP.

Si un utilisateur s'est inscrit à plusieurs options d'AMF et qu'il se désinscrit de l'option la plus récemment activée, 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 réauthentification, utilisez le code suivant :

guard let currentUser = Auth.auth().currentUser else { return }

// Prompt the user to select a factor to unenroll, from this array:
currentUser.multiFactor.enrolledFactors

// ...

// Unenroll the second factor.
let multiFactorInfo = currentUser.multiFactor.enrolledFactors[selectedIndex]
do {
    try await currentUser.multiFactor.unenroll(with: multiFactorInfo)
} catch let error as AuthErrorCode where error.code == .invalidUserToken {
    // Second factor unenrolled, but the user was signed out. Re-authenticate
    // them.
}

Étape suivante

Gérez les utilisateurs multifacteur par programmation à l'aide de Admin SDK.

Ajouter l'authentification multifacteur TOTP à votre application iOS Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.