> ## 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 éviter les problèmes courants liés à l’utilisation du flux Resource Owner Password pour effectuer des requêtes aux API côté serveur lorsque la protection contre les attaques est activée.

# Éviter les problèmes courants liés au flux Resource Owner Password et à la protection contre les attaques

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

<Warning>
  Comme le flux Resource Owner Password (ROP) exige que l’application traite le mot de passe de l’utilisateur, il ne doit pas être utilisé par des clients tiers.
</Warning>

Bien que nous ne le recommandions pas, les applications hautement fiables peuvent appeler des API côté serveur à l’aide du [flux Resource Owner Password](/docs/fr-ca/get-started/authentication-and-authorization-flow/resource-owner-password-flow) (parfois appelé <Tooltip tip="Resource Owner : Entité (comme un utilisateur ou une application) capable d’accorder l’accès à une ressource protégée." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Resource+Owner">octroi de mot de passe du Resource Owner</Tooltip> ou ROPG), qui demande aux utilisateurs de fournir des identifiants (nom d’utilisateur et mot de passe), généralement au moyen d’un formulaire interactif. Si la [protection contre les attaques par force brute est activée](/docs/fr-ca/secure/attack-protection/brute-force-protection), lorsque Auth0 valide les identifiants, nous pouvons aussi [détecter des attaques](/docs/fr-ca/secure/attack-protection) et prendre les mesures appropriées si une attaque est détectée.

Malheureusement, lorsqu’on utilise ce flux avec la <Tooltip tip="Protection contre les attaques par force brute : Forme de protection contre les attaques qui protège contre les attaques par force brute provenant d’une seule adresse IP et visant un seul compte d’utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=brute-force+protection">protection contre les attaques par force brute</Tooltip>, certaines fonctionnalités de <Tooltip tip="Protection contre les attaques par force brute : Forme de protection contre les attaques qui protège contre les attaques par force brute provenant d’une seule adresse IP et visant un seul compte d’utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=attack+protection">protection contre les attaques</Tooltip> peuvent ne pas fonctionner. Certains problèmes courants peuvent toutefois être évités.

<div id="attack-protection-and-server-side-apis">
  ## Protection contre les attaques et API côté serveur
</div>

La protection contre les attaques par force brute et <Tooltip tip="Suspicious IP Throttling : forme de protection contre les attaques qui protège votre tenant contre les connexions suspectes visant trop de comptes à partir d’une seule adresse IP." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=suspicious+IP+throttling">Suspicious IP Throttling</Tooltip> reposent sur l’adresse IP de l’utilisateur. Lorsque vous envoyez une requête à une API depuis votre serveur, Auth0 considère l’adresse IP de votre serveur comme étant celle de l’utilisateur et l’utilise comme donnée d’entrée pour la protection contre les attaques par force brute et Suspicious IP Throttling. Cela peut entraîner de faux positifs et amener la protection contre les attaques à bloquer des utilisateurs ou à générer des avertissements pour des requêtes légitimes.

Pour éviter cela, envoyez l’adresse IP de l’utilisateur à Auth0 avec ses identifiants, puis configurez votre application pour qu’elle se fie à cette adresse IP.

<Warning>
  Pour des raisons de sécurité, seules les applications authentifiées (par exemple, celles dont l’authentification repose sur un secret client) peuvent être configurées de cette façon. Les applications authentifiées doivent être utilisées uniquement à partir de ressources protégées, qui sont généralement côté serveur. Ne les utilisez pas à partir d’applications natives ou d’applications monopages (SPA), car elles ne peuvent pas stocker de secrets.
</Warning>

<div id="configure-your-application-to-trust-the-ip-address">
  ## Configurez votre application pour faire confiance à l’adresse IP
</div>

Enregistrez soit une [application Web régulière](/docs/fr-ca/get-started/auth0-overview/create-applications/regular-web-apps), soit une [application machine à machine](/docs/fr-ca/get-started/auth0-overview/create-applications/machine-to-machine-apps). Pendant la configuration de l’application :

1. Sous **Identifiants**, sélectionnez une **méthode d’authentification** autre que `None`.
2. Sous **Paramètres > Paramètres avancés**, repérez l’onglet **OAuth** et activez **Faire confiance à l’en-tête IP du point de terminaison de jeton**, ce qui fera de l’en-tête `auth0-forwarded-for` une source fiable de l’adresse IP de l’utilisateur pour la protection contre les attaques par force brute. Ce paramètre ne sera pas disponible pour les applications sans authentification.

<div id="send-the-users-ip-address-from-your-server">
  ## Envoyez l'adresse IP de l'utilisateur depuis votre serveur
</div>

1. Lorsque vous demandez des jetons au moyen du [Resource Owner Password Flow](/docs/fr-ca/get-started/authentication-and-authorization-flow/resource-owner-password-flow/call-your-api-using-resource-owner-password-flow), incluez un en-tête `auth0-forwarded-for` contenant la valeur de l'adresse IP de l'utilisateur. Assurez-vous que l'adresse IP que vous fournissez appartient bien à votre utilisateur.

   <Warning>
     Se fier à des en-têtes comme `auth0-forwarded-for` (ou, plus généralement, à des données provenant d'applications) comme source de l'adresse IP de l'utilisateur peut être risqué. Comme cet en-tête est facile à usurper et qu'il permet de contourner la validation de la protection contre les attaques, ne faites cela que si vous êtes certain de pouvoir vous y fier.
   </Warning>
2. Définissez des listes d'autorisation d'adresses IP à ignorer lors du déclenchement de la protection contre les attaques par force brute et de Suspicious IP Throttling.

<Card title="Liste d'autorisation avec la protection contre les attaques par force brute et Suspicious IP Throttling">
  Si votre application authentifiée est configurée pour envoyer l'en-tête `auth0-forwarded-for` :

  * Seule l'adresse IP contenue dans l'en-tête `auth0-forwarded-for` est vérifiée par rapport aux listes d'autorisation de la protection contre les attaques par force brute et de Suspicious IP Throttling.
  * L'adresse IP du proxy est ignorée par la protection contre les attaques par force brute et Suspicious IP Throttling; elle n'a donc pas besoin d'être ajoutée aux listes d'autorisation.
  * Si certaines applications clientes qui utilisent le proxy ne doivent pas être assujetties à la protection contre les attaques par force brute ou à Suspicious IP Throttling, ajoutez-les aux listes d'autorisation.

  L'en-tête `auth0-forwarded-for` ne sera accepté que pour les requêtes authentifiées avec le Client Secret. Si votre application n'est pas authentifiée ou n'est pas configurée pour envoyer l'en-tête `auth0-forwarded-for` :

  * L'adresse IP d'origine de chaque requête est vérifiée par rapport aux listes d'autorisation de la protection contre les attaques par force brute et de Suspicious IP Throttling.
  * Si vous ajoutez l'IP du proxy à une liste d'autorisation, tout le trafic acheminé par le proxy sera exempté de la protection contre les attaques par force brute et de Suspicious IP Throttling. Ce n'est probablement pas ce que vous voulez.
</Card>

<div id="example">
  ### Exemple
</div>

export const codeExample = `var request = require("request");

app.post('/api/auth', function(req, res, next) {
  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/oauth/token',
    headers: {
      'content-type': 'application/x-www-form-urlencoded',
      'auth0-forwarded-for': req.ip // Adresse IP de l’utilisateur final
    },
    form: {
      grant_type: 'password',
      username: 'USERNAME',
      password: 'PASSWORD',
      audience: 'YOUR_API_IDENTIFIER',
      scope: 'SCOPE',
      client_id: '{yourClientId}',
      client_secret: '{yourClientSecret}' // Le client est authentifié
    }
  };

  request(options, function (error, response, body) {
    if (error) return next(error);

    // ...
  });
});`;

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

<div id="handle-breached-password-detection-responses">
  ## Gérer les réponses de Breached Password Detection
</div>

Si vous avez activé [Breached Password Detection](/docs/fr-ca/secure/attack-protection/breached-password-detection) pour votre tenant, vous devez configurer votre application pour gérer correctement les réponses de l’[API d’authentification Auth0](https://auth0.com/docs/api/authentication).

Par exemple, si vous envoyez un mot de passe au moyen du flux ROP et qu’Auth0 détecte qu’il a été compromis, l’API d’authentification renvoie une réponse avec le code d’état HTTP `401 Unauthorized` et le corps suivant :

```json lines theme={null}
{
    "error": "password_leaked",
    "error_description": "This login attempt has been blocked because the password you're using was previously disclosed through a data breach (not in this application). Please check your email for more information."
}
```

Votre application doit gérer cette erreur, afficher un message à l’utilisateur et [déclencher un processus interactif de réinitialisation du mot de passe](/docs/fr-ca/authenticate/database-connections/password-change#authentication-api).

<div id="validate-with-logs">
  ## Valider à l’aide des journaux
</div>

Si vos paramètres sont configurés correctement, vous verrez ce qui suit dans les journaux :

```bash lines theme={null}
type:  sepft
...
ip:  <ip from auth0-forwarded-for header>
client_ip:  <ip of actual client/proxy>
...
```

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

* [Resource Owner Password Flow](/docs/fr-ca/get-started/authentication-and-authorization-flow/resource-owner-password-flow)
* [Effectuer une requête vers votre API à l’aide du Resource Owner Password Flow](/docs/fr-ca/get-started/authentication-and-authorization-flow/resource-owner-password-flow/call-your-api-using-resource-owner-password-flow)
* [protection contre les attaques](/docs/fr-ca/secure/attack-protection)