> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Découvrez comment vérifier si un utilisateur s’est connecté à votre application Web au moyen de l’authentification multifacteur (MFA) en examinant son ID Token.

# Configurer l’authentification renforcée pour les applications Web

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASKED*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Avec l’authentification renforcée, les applications qui donnent accès à différents types de ressources peuvent exiger que les utilisateurs s’authentifient au moyen d’un mécanisme plus robuste pour accéder à des renseignements sensibles ou effectuer certaines transactions.

Par exemple, un utilisateur peut être autorisé à accéder à des pages contenant des données sensibles ou à réinitialiser son mot de passe seulement après avoir confirmé son identité au moyen de l’<Tooltip tip="Authentification multifacteur (MFA) : processus d’authentification de l’utilisateur qui utilise un facteur en plus du nom d’utilisateur et du mot de passe, comme un code par SMS." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=multi-factor+authentication">authentification multifacteur</Tooltip> (MFA).

Pour mettre en œuvre l’authentification renforcée dans votre application web, vous allez créer une Action qui demande à l’utilisateur de s’authentifier avec MFA lorsque l’application web le requiert, vérifier les revendications du <Tooltip tip="ID Token : informations d’identification destinées à l’application cliente elle-même, et non à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=ID+Token">ID Token</Tooltip> pour MFA si l’utilisateur tente d’accéder à une page restreinte, puis demander à l’utilisateur de s’authentifier si MFA n’est pas inclus dans la revendication.

<div id="validate-id-tokens-for-mfa">
  ## Valider les jetons d’identité pour la MFA
</div>

Lorsqu’un utilisateur se connecte, vous obtenez un [jeton d’identité](/fr-CA/docs/secure/tokens/id-tokens/get-id-tokens) qui contient des informations pertinentes sur la session de l’utilisateur sous forme de revendications. La revendication pertinente est `amr` (référence des méthodes d’authentification), un tableau JSON de chaînes qui indique la méthode d’authentification utilisée lors de la connexion. Elle doit être présente dans le payload du jeton d’identité et doit contenir la valeur `mfa`.

Ses valeurs peuvent inclure n’importe laquelle des [Authentication Method Reference Values](https://tools.ietf.org/html/rfc8176) prédéfinies. Comme elle peut contenir des revendications autres que `mfa`, vous devez, lors de la validation, vérifier à la fois sa présence et si son contenu comprend la valeur `mfa`.

Si un utilisateur tente d’accéder à une page restreinte et que le jeton indique qu’il ne s’est pas authentifié avec la MFA, vous pouvez alors relancer l’authentification, que vous avez configurée pour déclencher la MFA à l’aide d’une Action. Une fois que l’utilisateur a fourni le deuxième facteur, un nouveau jeton d’identité contenant la revendication `amr` est généré et envoyé à l’application.

1. [Obtenez le jeton d’identité](/fr-CA/docs/secure/tokens/id-tokens/get-id-tokens).
2. Vérifiez la signature du jeton, pour confirmer que l’expéditeur du jeton est bien celui qu’il prétend être et pour vous assurer que le message n’a pas été modifié en cours de route.
3. Validez les revendications suivantes :

| Revendication | Description                                                                                                                                                                                                                                      |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `exp`         | Expiration du jeton                                                                                                                                                                                                                              |
| `iss`         | Émetteur du jeton                                                                                                                                                                                                                                |
| `aud`         | Destinataire prévu du jeton                                                                                                                                                                                                                      |
| `amr`         | Si `amr` n’est pas présent dans le payload ou ne contient pas la valeur `mfa`, l’utilisateur ne s’est pas connecté avec la MFA. Si `amr` est présent dans le payload et contient la valeur `mfa`, l’utilisateur s’est bien connecté avec la MFA. |

<div id="amr-claim-exceptions">
  #### Exceptions relatives à la revendication AMR
</div>

La revendication `amr` est requise, sauf dans les cas d’utilisation suivants :

1. Dans les flux de connexion hébergés, la revendication `amr` n’est injectée dans le jeton d’identité qu’après que l’utilisateur a réussi un défi MFA. Si l’application utilise l’authentification silencieuse ou des Jetons d’actualisation pour des jetons d’identité nouvellement émis, la revendication `amr` ne sera pas présente, puisque l’utilisateur a déjà effectué une connexion avec MFA.
2. Les jetons émis par l’API MFA ne contiennent pas la revendication `amr`. La revendication `amr` indique les méthodes d’authentification utilisées lorsque l’utilisateur reçoit l’ID Token. Dans le processus d’authentification de l’API MFA, l’application contrôle le flux d’authentification et peut imposer MFA au besoin.

Dans les exemples ci-dessous, vous pouvez comparer les valeurs possibles incluses dans le payload d’un jeton d’identité selon qu’un utilisateur s’est authentifié avec MFA ou non.

<div id="example-values-with-mfa">
  ### Exemple : valeurs avec MFA
</div>

export const codeExample1 = `{
    "iss": "https://{yourDomain}/",
    "sub": "auth0|1a2b3c4d5e6f7g8h9i",
    "aud": "{yourClientId}",
    "iat": 1522838054,
    "exp": 1522874054,
    "acr": "http://schemas.openid.net/pape/policies/2007/06/multi-factor",
    "amr": [
        "mfa"
    ]
}`;

<AuthCodeBlock children={codeExample1} language="json" />

<div id="example-values-without-mfa">
  ### Exemple : valeurs sans MFA
</div>

export const codeExample2 = `{
    "iss": "https://{yourDomain}/",
    "sub": "auth0|1a2b3c4d5e6f7g8h9i",
    "aud": "{yourClientId}",
    "iat": 1522838054,
    "exp": 1522874054
}`;

<AuthCodeBlock children={codeExample2} language="json" />

<div id="scenario-salary-data-with-push-notifications">
  ## Scénario : Données sur les salaires avec notifications push
</div>

Dans le scénario suivant, une application Web authentifie un utilisateur à l’aide d’un nom d’utilisateur et d’un mot de passe. Certains utilisateurs veulent accéder à un écran précis qui affiche des données sur les salaires; ils doivent donc s’authentifier avec le facteur push Guardian.

<div id="prerequisites">
  ### Prérequis
</div>

Pour ce scénario, vous devez configurer les éléments suivants dans l’Auth0 Dashboard :

* [Enregistrer une application Web](/fr-CA/docs/get-started/auth0-overview/create-applications/regular-web-apps).
* [Créer une connexion de base de données](https://manage.auth0.com/#/connections/database).
* [Activer la MFA](/fr-CA/docs/secure/multi-factor-authentication/enable-mfa) pour utiliser les notifications push.

<div id="create-an-action">
  ### Créer une Action
</div>

Créez une Action qui demande à l’utilisateur de s’authentifier avec MFA lorsque l’application web en fait la demande. Accédez à [Auth0 Dashboard > Actions > Flows](https://manage.auth0.com/#/actions/flows), puis créez une Action avec le contenu suivant :

```js lines theme={null}
exports.onExecutePostLogin = async (event, api) => {
 const CLIENTS_WITH_MFA = ['REPLACE_WITH_{yourClientId}'];
 // exécuter uniquement pour les applications spécifiées
 if (CLIENTS_WITH_MFA.includes(event.client.client_id)) {
 // demander la MFA uniquement si l'application web l'a spécifié dans la requête d'authentification
 if (event.transaction?.acr_values.includes('http://schemas.openid.net/pape/policies/2007/06/multi-factor')) {
 api.multifactor.enable('any', { allowRememberBrowser: false });
 }
 }
}
```

* La variable `CLIENTS_WITH_MFA` contient les <Tooltip tip="ID client : valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=client+IDs">ID client</Tooltip> des applications auxquelles vous souhaitez appliquer cette Action. Vous pouvez supprimer cet élément (ainsi que la condition `if` qui suit) si vous n’en avez pas besoin.
* La propriété `event.transaction.acr_values` est un tableau de chaînes qui contient la ou les références de classe du contexte d’authentification (`acr`). Il s’agit d’une propriété facultative qui n’existe que lorsque l’application l’inclut dans la requête d’authentification envoyée au <Tooltip tip="Serveur d’autorisation : serveur centralisé qui contribue à définir les limites de l’accès d’un utilisateur. Par exemple, votre serveur d’autorisation peut contrôler les données, les tâches et les fonctionnalités auxquelles un utilisateur a accès." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Authorization+Server">serveur d’autorisation</Tooltip>. Dans cet exemple, notre application web l’inclura dans la requête d’authentification, mais seulement lorsqu’un utilisateur qui ne s’est pas déjà authentifié avec MFA tente d’accéder aux données salariales. Lorsque notre application web l’inclut, elle définit la valeur `http://schemas.openid.net/pape/policies/2007/06/multi-factor`, ce qui indique que nous voulons que le serveur d’autorisation exige la MFA; la valeur de la propriété `api.multifactor` que nous définissons dans notre code demandera alors à l’utilisateur d’effectuer la MFA à l’aide de l’une des méthodes disponibles configurées dans le locataire. Pour en savoir plus sur la méthode `api.multifactor.enable()`, consultez [Action Triggers: objet API post-login](/fr-CA/docs/customize/actions/explore-triggers/password-reset-triggers/post-challenge-trigger/post-challenge-api-object).
* La stratégie `http://schemas.openid.net/pape/policies/2007/06/multi-factor` définit un mécanisme d’authentification dans lequel l’utilisateur final s’authentifie auprès du fournisseur <Tooltip tip="OpenID : norme ouverte d’authentification qui permet aux applications de vérifier l’identité des utilisateurs sans recueillir ni stocker les renseignements de connexion." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=OpenID">OpenID</Tooltip> en fournissant plus d’un facteur d’authentification, c’est-à-dire la MFA. Pour en savoir plus, consultez [OpenID Provider Authentication Policy Extension 1.0](https://openid.net/specs/openid-provider-authentication-policy-extension-1_0.html).

<div id="configure-app">
  ### Configurer l’application
</div>

Configurez l’application pour vérifier que l’utilisateur s’est authentifié au moyen de la MFA lorsqu’il tente d’accéder à la page des renseignements salariaux restreints. (Lorsqu’un utilisateur s’est authentifié avec la MFA, le jeton d’identité contient la revendication `amr` avec la valeur `mfa`.) Si l’utilisateur s’est déjà authentifié avec la MFA, l’application Web affichera la page restreinte; sinon, l’application Web enverra une nouvelle demande d’authentification qui inclut le paramètre `acr_values` avec la valeur suivante :
`http://schemas.openid.net/pape/policies/2007/06/multi-factor`, ce qui déclenchera l’Action.

L’application Web, dans ce scénario, utilise le [flux de code d’autorisation](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow) pour s’authentifier; la demande est donc la suivante :

export const codeExample3 = `https://{yourDomain}/authorize?
        audience=https://{yourDomain}/userinfo&
        scope=openid&
        response_type=code&
        client_id={yourClientId}&
        redirect_uri={https://yourApp/callback}&
        state={yourOpaqueValue}&
        acr_values=http://schemas.openid.net/pape/policies/2007/06/multi-factor`;

<AuthCodeBlock children={codeExample3} language="http" />

Une fois l’utilisateur authentifié avec MFA, l’application web reçoit le code d’autorisation, qui doit être échangé contre le nouveau jeton d’identité. Celui-ci devrait maintenant contenir la revendication `amr` ayant pour valeur `mfa`. Pour savoir comment échanger le code contre un jeton d’identité, consultez [Ajouter Login à l’aide du flux de code d’autorisation](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow/add-login-auth-code-flow).

<div id="validate-id-token">
  ### Valider le jeton d’identité
</div>

Dans ce scénario, effectuez les validations à l’aide de l’[exemple de code JSON Web Token](https://github.com/auth0/node-jsonwebtoken), qui vérifie la signature du jeton (`jwt.verify`), décode le jeton, vérifie si le payload contient `amr` et, le cas échéant, affiche les résultats dans la console.

export const codeExample4 = `const AUTH0_CLIENT_SECRET = '{yourClientSecret}';
const jwt = require('jsonwebtoken');

jwt.verify(id_token, AUTH0_CLIENT_SECRET, { algorithms: ['HS256'] }, function(err, decoded) {
  if (err) {
    console.log('jeton non valide');
    return;
  }

  if (Array.isArray(decoded.amr) && decoded.amr.indexOf('mfa') >= 0) {
    console.log('Vous utilisez MFA');
    return;
  }

  console.log('vous n\'utilisez pas MFA');
});`;

<AuthCodeBlock children={codeExample4} language="javascript" />

<div id="learn-more">
  ## En savoir plus
</div>

* [ID Tokens](/fr-CA/docs/secure/tokens/id-tokens)
* [Cas d’utilisation des Rules](/fr-CA/docs/customize/rules/use-cases)
* [JSON Web Tokens](/fr-CA/docs/secure/tokens/json-web-tokens)
* [Configurer l’authentification à niveau renforcé pour les API](/fr-CA/docs/secure/multi-factor-authentication/step-up-authentication/configure-step-up-authentication-for-apis)