> ## 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.

> Explique comment configurer l’authentification unique SAML initiée par le fournisseur d’identité.

# Configurer l’authentification unique SAML initiée par le fournisseur d’identité

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

Bon nombre d’instructions pour configurer une fédération <Tooltip tip="Security Assertion Markup Language (SAML) : protocole normalisé permettant à deux parties d’échanger des renseignements d’authentification sans mot de passe." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=SAML">SAML</Tooltip> commencent par une <Tooltip tip="Security Assertion Markup Language (SAML) : protocole normalisé permettant à deux parties d’échanger des renseignements d’authentification sans mot de passe." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Single+Sign-on">authentification unique</Tooltip> (SSO) initiée par le fournisseur de services. Le fournisseur de services redirige l’utilisateur vers le <Tooltip tip="Single Sign-On (SSO) : service qui, après qu’un utilisateur se connecte à une application, le connecte automatiquement à d’autres applications." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=identity+provider">fournisseur d’identité</Tooltip> (IdP) à des fins d’authentification. Ce processus est couramment utilisé dans les scénarios destinés aux consommateurs.

Cependant, dans les contextes d’entreprise, il arrive qu’on commence plutôt par une SSO initiée par l’IdP que par le fournisseur de services. Par exemple, une entreprise peut mettre en place un portail pour s’assurer que les utilisateurs sont dirigés vers la bonne application après s’y être connectés.

<div id="risks-and-considerations">
  ## Risques et considérations
</div>

Les flux IdP-Initiated comportent un risque de sécurité et ne sont donc pas recommandés. Il est recommandé d’utiliser des flux SP-Initiated chaque fois que possible.

Assurez-vous de bien comprendre les risques avant d’activer le SSO IdP-Initiated. Dans ce scénario, Auth0 reçoit une réponse non sollicitée de l’IdP, et l’application reçoit une réponse non sollicitée d’Auth0. Aucune des deux entités ne peut vérifier que l’utilisateur est bien à l’origine du flux. Par conséquent, l’activation de ce flux ouvre la porte à une [attaque Login CSRF](https://support.detectify.com/support/solutions/articles/48001048951-login-csrf), dans laquelle un attaquant peut amener un utilisateur légitime à se connecter à l’application, à son insu, avec l’identité de l’attaquant.

<div id="openid-connect-idp-initiated-flow">
  ### Flux IdP-Initiated d’OpenID Connect
</div>

<Tooltip tip="OpenID : norme ouverte d’authentification qui permet aux applications de vérifier l’identité des utilisateurs sans recueillir ni stocker de renseignements de connexion." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OpenID">OpenID</Tooltip> Connect (OIDC) ne prend pas en charge le concept de flux IdP-Initiated. Ainsi, même si Auth0 offre la possibilité de convertir un flux SAML IdP-Initiated (à partir d’une connexion SAML) en réponse OIDC pour une application, toute application qui implémente correctement le protocole OIDC/OAuth2 rejettera une réponse non sollicitée.

Lorsque vous utilisez des applications OIDC, la meilleure option est que votre application crée un endpoint de connexion. Cet endpoint a pour seul objectif d’amorcer la redirection vers l’IdP (votre tenant Auth0).

Si vous utilisez plusieurs IdP, assurez-vous que l’endpoint de connexion est soit propre au fournisseur d’identité, soit en mesure d’accepter un paramètre pour identifier quel IdP lance le workflow.

Une autre approche consiste à demander aux utilisateurs de démarrer le flux de connexion à partir de l’application.

<div id="post-back-url">
  ### URL de retour
</div>

Lorsque vous utilisez le SSO initié par l’IdP, veillez à inclure le paramètre connection dans l’URL de retour :

export const codeExample1 = `https://{yourDomain}/login/callback?connection={yourConnectionName}`;

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

Si vous utilisez la fonctionnalité [Organizations](/docs/fr-ca/manage-users/organizations), vous pouvez inclure, au besoin, un paramètre organization contenant l’ID de l’organisation souhaitée :

export const codeExample2 = `https://{yourDomain}/login/callback?connection={yourConnectionName}&organization={yourCustomersOrganizationId}`;

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

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour que les utilisateurs puissent se connecter avec succès à l’aide de cette méthode, la connexion doit être activée pour l’Organisation. De plus, vous devez soit configurer [l’adhésion automatique](/docs/fr-ca/manage-users/organizations/configure-organizations/grant-just-in-time-membership) pour la connexion activée, soit vous assurer que les utilisateurs sont membres de l’Organisation.
</Callout>

<div id="lockauth0js">
  ### Lock/Auth0.js
</div>

Si votre application est une application monopage qui utilise Lock ou Auth0.js pour traiter les résultats de l’authentification, vous devez indiquer explicitement que vous souhaitez autoriser les flux IdP-Initiated et ainsi exposer l’application à d’éventuelles attaques de type Login CSRF.

Si vous utilisez Auth0.js, vous devez mettre à jour la méthode `webAuth.parseHash` de la bibliothèque et définir l’indicateur `__enableIdPInitiatedLogin` à `true`.

```javascript lines theme={null}
var data = webAuth.parseHash(
      {
        ...
        __enableIdPInitiatedLogin: true
        ...
      }
```

Si vous utilisez Lock, vous pouvez inclure l’indicateur au moyen du paramètre options transmis au constructeur.

`const lock = new Auth0Lock(clientID, domain, options)`

Voici l’indicateur en question :

`var options = { _enableIdPInitiatedLogin: true };`

Notez que l’indicateur `enableIdPInitiatedLogin` est précédé d’un trait de soulignement lorsqu’il est utilisé avec Lock, et de deux traits de soulignement lorsqu’il est utilisé avec la bibliothèque auth0.js.

<div id="set-up-idp-initiated-sso">
  ## Configurer le SSO initié par l’IdP
</div>

1. Accédez à [Dashboard > Authentication > Enterprise](https://manage.auth0.com/#/connections/enterprise) et choisissez **SAMLP Identity Provider**.
2. Sous **Settings**, vous pouvez voir la configuration du SSO initié par l’IdP.

   <Frame>
     <img src="https://mintcdn.com/translations/eVsQcTnbClN-oB7d/docs/images/cdy7uua7fh8z/1HORCAp4fZQg0BOoIopvoS/0009d4b5f405c2436af5729d52a3867d/2025-01-28_13-47-26.png?fit=max&auto=format&n=eVsQcTnbClN-oB7d&q=85&s=a1b34df487e00d763e5ae8e760e4779a" alt="Écran de configuration des protocoles pour le SSO initié par l’IdP" width="1072" height="961" data-path="docs/images/cdy7uua7fh8z/1HORCAp4fZQg0BOoIopvoS/0009d4b5f405c2436af5729d52a3867d/2025-01-28_13-47-26.png" />
   </Frame>

* **Comportement du SSO initié par l’IdP** : Cette option vous permet d’activer les connexions initiées par l’IdP pour la connexion SAML. Sélectionnez **Accept Requests** et remplissez tous les champs requis.
* **Application par défaut :** Lorsque la connexion initiée par l’IdP réussit, les utilisateurs sont redirigés vers cette application. Ce paramètre affiche les applications disponibles activées pour cette connexion. Sélectionnez dans la liste déroulante l’application avec laquelle vous voulez que les utilisateurs se connectent par l’entremise de l’IdP. Une seule application peut être sélectionnée pour une connexion initiée par l’IdP par connexion SAML.
* **Protocole de réponse :** Il s’agit du protocole utilisé pour connecter l’**Application par défaut** sélectionnée. Le plus souvent, les applications sont configurées avec le protocole OpenID Connect (voir ci-dessus). Toutefois, si vous avez configuré le module complémentaire SAML2 Web App pour votre application et que vous voulez acheminer l’assertion SAML, vous devrez sélectionner SAML. Une fois qu’une assertion SAML valide a été transmise à l’URL de postback, Auth0 envoie une réponse de connexion à la première URL de rappel autorisée de l’application par défaut configurée à l’aide du protocole de réponse choisi, lequel peut être modifié à l’aide du champ de chaîne de requête pour préciser un `redirect_uri` si vous utilisez OIDC.
  * Si l’URL de rappel configurée pour l’application comprend un espace réservé Multiple Custom Domains (MCD), le système le remplit dynamiquement à l’aide de la valeur de métadonnées correspondant au custom domain de l’URL de postback qui a reçu la requête initiale de l’IdP. Pour en savoir plus, consultez [Multiple Custom Domains](/docs/fr-ca/customize/custom-domains/multiple-custom-domains).
* **Chaîne de requête :** Les options de chaîne de requête permettent de personnaliser le comportement lorsque le protocole OpenID Connect est utilisé. Vous pouvez définir plusieurs options, de façon semblable à des paramètres dans une [chaîne de requête](https://en.wikipedia.org/wiki/Query_string). Vous pouvez définir :

| Paramètre       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `redirect_uri`  | Lorsque la connexion initiée par l’IdP est terminée, la requête est ensuite redirigée vers la première URL figurant dans les **Allowed Callback URLs** de l’application. Toutefois, si vous définissez un `redirect_uri`, l’IdP redirigera vers cette URL. Cela offre plus de souplesse, par exemple si vous avez un schéma de sous-domaines avec un caractère générique et que vous voulez rediriger uniquement vers un sous-domaine précis. |
| `scope`         | Définissez les scopes du ID token envoyé. Vous pouvez en définir plusieurs.                                                                                                                                                                                                                                                                                                                                                                   |
| `response_type` | Définissez le token pour le flux Implicit Grant pour les SPA. Vous pouvez définir code pour le flux Authorization Code Grant pour les regular web apps.                                                                                                                                                                                                                                                                                       |

<Warning>
  Dans un flux initié par l’IdP, les serveurs Auth0 suppriment les scopes à l’intérieur d’un token si l’URL de rappel est un domaine non vérifié. Auth0 considère uniquement `localhost` et [127.0.0.1](http://127.0.0.1/) comme des domaines non vérifiés. Si vous utilisez l’un ou l’autre comme URL de rappel, les tokens du endpoint `/userinfo` renverront une réponse vide. Pour obtenir une réponse de token avec les scopes demandés, utilisez un domaine vérifié.
</Warning>

Exemple de chaîne de requête :
`redirect_uri=https://jwt.io&scope=openid email&response_type=token`

<div id="application-drop-down-list-limited-to-100">
  ## Liste déroulante d’applications limitée à 100
</div>

Si vous souhaitez sélectionner une application comme **Application par défaut** dans le cadre du SSO initié par l’IdP et que l’application ne figure pas parmi les 100 premières de la liste déroulante de votre tenant, vous devez utiliser la <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> pour sélectionner cette application. Vous devez effectuer une requête PATCH :

```json lines theme={null}
{
"options": {
"signInEndpoint": "yourIdpSignInUrl",
"idpinitiated": {
"client_id": "yourClientId",
"client_protocol": "saml",
"client_authorizequery": ""
},
"signingCert": "[copied-from-GET]"
}
}
```

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

* [Utiliser les certificats et les clés sous forme de chaînes de caractères](/docs/fr-ca/authenticate/protocols/saml/saml-sso-integrations/work-with-certificates-and-keys-as-strings)