> ## 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 à l’aide de l’authentification multifacteur (MFA) en examinant son jeton d’identité.

# 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) + "*****MASQUÉ*****";
          }
          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 consulter des renseignements sensibles ou effectuer certaines transactions.

Par exemple, un utilisateur peut être autorisé à accéder à des vues contenant des données sensibles ou à réinitialiser son mot de passe seulement après avoir confirmé son identité à l’aide 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 envoyé par SMS." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=multi-factor+authentication">authentification multifacteur</Tooltip> (MFA).

Pour mettre en œuvre l’authentification renforcée pour votre application web, vous allez créer une Action qui invite l’utilisateur à s’authentifier avec MFA lorsque l’application web en fait la demande, vérifier les claims du <Tooltip tip="jeton d’identité : jeton destiné au client lui-même plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+Token">jeton d’identité</Tooltip> pour MFA si l’utilisateur tente d’accéder à une page restreinte, puis soumettre l’utilisateur à une vérification MFA si elle n’est pas incluse dans le claim.

<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é](/docs/fr-ca/secure/tokens/id-tokens/get-id-tokens) qui contient des informations pertinentes sur la session de l’utilisateur sous forme de claims. Le claim pertinent est `amr` (authentication methods reference), soit un tableau JSON de chaînes de caractères qui indique la méthode d’authentification utilisée lors de la connexion. Il doit être présent dans le payload du jeton d’identité et 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 il peut contenir des claims autres que `mfa`, lors de la validation, vous devez à la fois vérifier qu’il est présent et examiner son contenu pour voir s’il contient 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 relancer l’authentification, que vous avez configurée pour déclencher la MFA à l’aide d’une Action. Une fois que l’utilisateur fournit le second facteur, un nouveau jeton d’identité contenant le claim `amr` est généré et envoyé à l’application.

1. [Obtenez le jeton d’identité](/docs/fr-ca/secure/tokens/id-tokens/get-id-tokens).
2. Vérifiez la signature du jeton, qui sert à confirmer que l’émetteur du jeton est bien celui qu’il prétend être et à garantir que le message n’a pas été modifié en cours de route.
3. Validez les claims suivants :

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

<div id="amr-claim-exceptions">
  #### Exceptions concernant la claim `amr`
</div>

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

1. Dans les flux de connexion hébergés, la claim `amr` n’est injectée dans le jeton d’identité qu’une fois que l’utilisateur a réussi une vérification MFA. Si l’application utilise l’authentification silencieuse ou des jetons d’actualisation pour des jetons d’identité nouvellement émis, la claim `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 claim `amr`. La claim `amr` indique les méthodes d’authentification utilisées au moment où l’utilisateur reçoit le jeton d’identité. Dans le processus d’authentification de l’API MFA, l’application contrôle le flux d’authentification et peut exiger la MFA au besoin.

Dans les exemples ci-dessous, vous pouvez comparer les valeurs possibles incluses dans la charge utile d’un jeton d’identité lorsqu’un utilisateur s’est authentifié avec MFA et lorsqu’il ne l’a pas fait.

<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 salariales avec notifications push
</div>

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

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

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

* [Enregistrer une application web](/docs/fr-ca/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 MFA](/docs/fr-ca/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 le demande. Allez à [Dashboard > Actions > Flows](https://manage.auth0.com/#/actions/flows), puis créez une Action qui contient le contenu suivant :

```js lines theme={null}
exports.onExecutePostLogin = async (event, api) => {
 const CLIENTS_WITH_MFA = ['REPLACE_WITH_{yourClientId}'];
 // exécuter uniquement pour les clients spécifiés
 if (CLIENTS_WITH_MFA.includes(event.client.client_id)) {
 // demander l'AMF uniquement si l'application web l'a indiqué 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="/docs/fr-ca/glossary?term=client+IDs">ID client</Tooltip> des applications auxquelles vous voulez que cette Action s’applique. 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 de caractères 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 offertes à un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/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 à des renseignements salariaux. 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 MFA, et la valeur de la propriété `api.multifactor` que nous définissons dans notre code demandera à l’utilisateur d’effectuer une vérification MFA au moyen de l’une des méthodes disponibles configurées dans le tenant. Pour en savoir plus sur la méthode `api.multifactor.enable()`, consultez [Déclencheurs d’Action : objet API de post-login](/docs/fr-ca/customize/actions/explore-triggers/password-reset-triggers/post-challenge-trigger/post-challenge-api-object).
* La politique `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="/docs/fr-ca/glossary?term=OpenID">OpenID</Tooltip> en fournissant plus d’un facteur d’authentification, ou 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é à l’aide de la MFA lorsqu’il tente d’accéder à la page contenant les renseignements salariaux restreints. (Lorsqu’un utilisateur s’est authentifié avec la MFA, les claims du jeton d’identité contiennent le claim `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 requête d’authentification qui comprend le paramètre `acr_values` avec la valeur :
`http://schemas.openid.net/pape/policies/2007/06/multi-factor`ce qui déclenchera l’Action.

Dans ce scénario, l’application Web utilise le [flux du code d’autorisation](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow) pour s’authentifier; la requête 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 que l’utilisateur s’authentifie avec MFA, l’application web reçoit le code d’autorisation, qui doit être échangé contre le nouveau jeton d’identité, lequel devrait maintenant contenir la claim `amr` avec la valeur `mfa`. Pour savoir comment échanger le code contre un jeton d’identité, consultez [Ajouter la connexion à l’aide du flux de code d’autorisation](/docs/fr-ca/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, consigne 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 invalide');
    return;
  }

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

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

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

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

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