> ## 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écrit les étapes de migration à suivre, car Auth0 met fin à l’utilisation du point de terminaison /passwordless/start par les applications confidentielles sans secret client dans la requête.

# Migrer vers le point de terminaison sans mot de passe pour les applications confidentielles

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

Auth0 met progressivement fin à l’utilisation du point de terminaison `/passwordless/start` par les applications confidentielles lorsqu’Auth0 ne peut pas authentifier que la requête est effectuée au nom de l’application.

<Tooltip tip="OAuth 2.0 : cadre d’autorisation qui définit les protocoles et les workflows d’autorisation." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OAuth">OAuth</Tooltip> utilise le terme 'confidential' pour désigner les applications qui peuvent stocker des secrets. Dans Auth0, il s’agit des 'Regular Web Applications', qui servent des pages Web à partir d’une application côté serveur. Les Single Page Applications et les Native Applications sont considérées comme des applications 'public' et ne sont pas touchées par ce changement.

Auth0 peut authentifier les appels à `/passwordless/start` lorsqu’ils incluent un `client_secret` comme paramètre, ou lorsqu’ils sont effectués depuis la page de connexion personnalisée dans Classic Login et transmettent le paramètre `state`.

<div id="features-affected">
  ## Fonctionnalités touchées
</div>

Si l’une de vos applications envoie actuellement une requête directement au point de terminaison `/passwordless/start` pour lancer l’<Tooltip tip="Passwordless : forme d’authentification qui ne repose pas sur un mot de passe comme premier facteur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=passwordless">authentification sans mot de passe</Tooltip> depuis une Application Web, et que vous n’envoyez pas le paramètre `client_secret`, cette dépréciation vous concerne.

Si vous implémentez l’authentification sans mot de passe au moyen de la page Classic Login et que vous avez modifié la méthode d’initialisation par défaut des bibliothèques Auth0, cela pourrait aussi vous concerner.

Vous pouvez vérifier si vous êtes concerné en consultant les [journaux du tenant](https://manage.auth0.com/#/logs), en filtrant par "Avis de dépréciation" et en recherchant des journaux indiquant "Enforce client authentication for passwordless connections". Vous pouvez aussi effectuer cette recherche directement avec la requête suivante : `type:depnote AND description:*passwordless*`. Notez que cette requête précise ne fonctionne que pour les tenants en Public Cloud, car il n’est pas possible d’effectuer une recherche dans le champ description des journaux en Private Cloud.

<div id="actions">
  ## Actions
</div>

Si vous appelez le point de terminaison `/passwordless/start` sans authentification appropriée de l’application, vous devez :

* Suivre les instructions ci-dessous pour ajuster le code afin d’appeler correctement `/passwordless/start`.
* Vérifier vos [journaux du tenant](https://manage.auth0.com/#/logs) pour vous assurer que la modification a bien été effectuée et qu’aucun journal de dépréciation n’est généré pour « Enforce client authentication for passwordless connections ».
* Dans la section **Migrations** des **Paramètres avancés du tenant**, activez la bascule **Enforce client authentication for passwordless connections**.

Quelques cas d’utilisation pourraient être touchés, mais, dans chaque cas, le parcours de migration est assez simple :

<div id="api-calls-from-backend">
  ### Appels d’API depuis le backend
</div>

Pour tout appel provenant de votre backend vers le point de terminaison `/passwordless/start`, votre requête doit inclure le <Tooltip tip="Client Secret : secret utilisé par un client (application) pour s’authentifier auprès de l’Authorization Server; il ne doit être connu que du client et de l’Authorization Server et doit être suffisamment aléatoire pour ne pas pouvoir être deviné." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=client+secret">secret client</Tooltip> en tant que paramètre.

Si vous envoyez une requête POST directement à `/passwordless/start`, incluez `client_secret` dans la charge utile :

export const codeExample = `POST https://{yourDomain}/passwordless/start
    Content-Type: application/json
    {
      "client_id": "{yourClientId}",
      "client_secret": "{yourClientSecret}",
      "connection": "email|sms",
      "email": "{userEmailAddress}", //à renseigner si connection=email
      "phone_number": "{userPhoneNumber}", //à renseigner si connection=sms
      "send": "link|code",
      "authParams": { 
          "scope": "openid",
          "state": "{yourState}"
        }
      }`;

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

Si vous utilisez un SDK, ajoutez le paramètre à la méthode qui lance le flux d’authentification sans mot de passe. La procédure diffère selon le SDK, et tous les SDK n’ont pas encore été mis à jour. Si vous utilisez un SDK qui n’a pas encore été mis à jour, vous pouvez effectuer la requête HTTP directement en attendant que la mise à jour soit terminée.

<div id="auth0js-or-lockjs-in-the-classic-login-page">
  ### Auth0.js ou Lock.js dans la page Classic Login
</div>

Si la page Classic Login est utilisée pour l’authentification sans mot de passe d’une application Web, elle effectuera des appels au point de terminaison `/passwordless/start`, en utilisant soit Lock.js, soit Auth0.js.

Comme vous ne pouvez pas stocker de secret client dans une page Web, la façon d’authentifier la requête consiste à transmettre au point de terminaison `/passwordless/start` le paramètre `state` reçu dans la page Classic Login. Ce paramètre est stocké dans le champ `config.internalOptions` de la page de connexion personnalisée.

Les modèles par défaut pour personnaliser la page de connexion l’utilisent comme suit lors de l’initialisation de Lock.js ou d’auth0.js :

```javascript lines theme={null}
var lock = new Auth0Lock(
  config.clientID, 
  config.auth0Domain, 
  {
    auth: {
      // .. autres champs définis
      params: {
       scope: config.internalOptions.scope,
       _csrf: config.internalOptions._csrf,
       state: config.internalOptions.state,
      }
    }
  });
```

```javascript lines theme={null}
var params = Object.assign({
    scope: config.internalOptions.scope,
    _csrf: config.internalOptions._csrf,
    state: config.internalOptions.state,
  }, {
    // ...paramètres d'authentification
  });

var webAuth = new auth0.WebAuth(params);
```

Veuillez vérifier dans la mise en œuvre de votre page personnalisée que ce code n’a pas été supprimé.

<div id="call-passwordlessstart-from-the-client-in-a-web-application">
  ### Faire une requête à /passwordless/start depuis le client dans une application web
</div>

Si vous faites une requête au point de terminaison `/passwordless/start` à partir d’une page qui utilise JavaScript (par exemple, avec auth0.js sur la page) dans des applications de type Regular Web Apps, vous ne pourrez pas préciser de client secret dans une requête effectuée au moyen de JavaScript. Si c’est le cas pour votre application, vous devrez modifier vos applications pour que `/passwordless/start` soit appelé depuis le backend de votre application web plutôt que depuis le frontend.

<div id="rate-limits">
  ### Limites de débit
</div>

Une conséquence de l’ajout de l’authentification du client à `/passwordless/start` est qu’Auth0 peut faire confiance aux en-têtes envoyés avec la requête. Si vous définissez l’en-tête `auth0-forwarded-for`, l’adresse IP apparaîtra dans les journaux et sera utilisée à des fins de <Tooltip tip="Protection contre les attaques : fonctionnalités qu’Auth0 fournit pour détecter et atténuer les attaques, y compris la protection contre les attaques par force brute, la limitation du débit des IP suspectes, la détection des mots de passe compromis, la détection des bots et l’authentification multifacteur adaptative." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=attack+protection">protection contre les attaques</Tooltip>.

Les requêtes authentifiées vers `/passwordless/start` seront traitées comme des requêtes authentifiées standard, et la limite de débit globale correspondante de l’Authentication API s’appliquera.