> ## Documentation Index > Fetch the complete documentation index at: https://docs-staging-feat-init-gt-translations.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Explique comment passer des jetons ID aux jetons d’accès pour la liaison de comptes d’utilisateur. # Migrer vers les jetons d’accès pour la liaison de comptes export const AuthCodeGroup = ({children, dropdown}) => { const [processedChildren, setProcessedChildren] = useState(children); useEffect(() => { let unsubscribe = null; function init() { unsubscribe = window.autorun(() => { const processChildren = node => { if (typeof node === "string") { let processedNode = node; for (const [key, value] of window.rootStore.variableStore.values.entries()) { const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`); processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value); } return processedNode; } else if (Array.isArray(node)) { return node.map(processChildren); } else if (node && node.props && node.props.children) { return { ...node, props: { ...node.props, children: processChildren(node.props.children) } }; } return node; }; setProcessedChildren(processChildren(children)); }); } if (window.rootStore) { init(); } else { window.addEventListener("adu:storeReady", init); } return () => { window.removeEventListener("adu:storeReady", init); unsubscribe?.(); }; }, [children]); return {processedChildren}; }; 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
{displayText}
; }; export const codeExample1 = `https://{yourDomain}/authorize? scope=openid &response_type=id_token &client_id={yourClientId} &redirect_uri=https://{yourApp}/callback &nonce=NONCE &state=OPAQUE_VALUE `; export const codeExample2 = `https://{yourDomain}/authorize? audience=https://{yourDomain}/api/v2/ &scope=update:current_user_identities &response_type=token%20id_token &client_id={yourClientId} &redirect_uri=https://{yourApp}/callback &nonce={nonce} &state={opaqueValue} `; export const codeExample3 = `{ "iss": "https://{yourDomain}/", "sub": "auth0|5a620d29a840170a9ef43672", "aud": "https://{yourDomain}/api/v2/", "iat": 1521031317, "exp": 1521038517, "azp": "{yourClientId}", "scope": "\${scope}" }`; export const codeExample4 = `{ "method": "POST", "url": "https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities", "httpVersion": "HTTP/1.1", "headers": [ { "name": "Authorization", "value": "Bearer ACCESS_TOKEN" }, { "name": "content-type", "value": "application/json" } ], "postData" : { "mimeType": "application/json", "text": "{\\"link_with\\":\\"SECONDARY_ACCOUNT_ID_TOKEN\\"}" } }`; export const codeExample5 = `// récupérer un ID Token var webAuth = new auth0.WebAuth({ clientID: '{yourClientId}', domain: '{yourDomain}', redirectUri: 'https://{yourApp}/callback', scope: 'openid', responseType: 'id_token' }); // créer une instance var auth0Manage = new auth0.Management({ domain: '{yourDomain}', token: '{yourIdToken}' });`; export const codeExample6 = `// récupérer un jeton d’accès var webAuth = new auth0.WebAuth({ clientID: '{yourClientId}', domain: '{yourDomain}', redirectUri: 'https://{yourApp}/callback', audience: 'https://{yourDomain}/api/v2/', scope: 'update:current_user_identities', responseType: 'token id_token' }); // créer une instance var auth0Manage = new auth0.Management({ domain: '{yourDomain}', token: '{yourMgmtApiAccessToken}' }); `; export const codeExample17 = `https://{yourDomain}/authorize? scope=openid &response_type=id_token &client_id={yourClientId} &redirect_uri=https://{yourApp}/callback &nonce={nonce} &state={opaqueValue}`; export const codeExample18 = `https://{yourDomain}/authorize? audience=https://{yourDomain}/api/v2/ &scope=update:current_user_identities &response_type=token%20id_token &client_id={yourClientId} &redirect_uri=https://{yourApp}/callback &nonce={nonce} &state={opaqueValue} `; export const codeExample19 = `{ "iss": "https://{yourDomain}/", "sub": "auth0|5a620d29a840170a9ef43672", "aud": "https://{yourDomain}/api/v2/", "iat": 1521031317, "exp": 1521038517, "azp": "{yourClientId}", "scope": "update:current_user_identities" }`; export const codeExample20 = `DELETE https://{yourDomain}/api/v2/users/{primaryAccountUserId}/identities/{secondaryAccountProvider}/{secondaryAccountUserId} Authorization: 'Bearer {yourMgmtApiAccessToken}' `; Auparavant, vous pouviez utiliser les jetons d’ID pour lier et dissocier des comptes d’utilisateur dans certains cas d’utilisation. Auth0 abandonne progressivement cette fonctionnalité. Vous devrez désormais utiliser des jetons d’accès dans tous les cas. Cette dépréciation vise à répondre à une vulnérabilité de sécurité potentielle. Auth0 vous recommande fortement de mettre à jour votre code dès que possible.

Fonctionnalités touchées

Les changements apportés à la liaison de comptes sont les suivants : * Vous ne pouvez plus utiliser un ID token dans l’en-tête `Authorization`; vous devez utiliser un access token à la place. * Si vous utilisez un access token dans l’en-tête `Authorization` avec `update:users` comme permission accordée, vous pouvez envoyer dans le corps de la request soit le `user_id`, soit l’ID token du compte secondaire. * Si vous utilisez un access token dans l’en-tête `Authorization` avec `update:current_user_metadata` comme permission accordée, vous pouvez seulement envoyer l’ID token du compte secondaire dans le corps de la request. * Si vous envoyez l’ID token du compte secondaire dans le corps de la request (les cas d’utilisation décrits dans les deux puces précédentes), les conditions suivantes doivent être respectées : * L’ID token doit être signé à l’aide de `RS256` (vous pouvez définir cette valeur dans **Dashboard > Clients > Client Settings > Advanced Settings > OAuth**. * Le claim `aud` de l’ID Token doit identifier le client et avoir la même valeur que le claim `azp` de l’access token. * Pour dissocier des comptes, vous ne pouvez plus utiliser un ID token dans l’en-tête `Authorization`. Vous devez utiliser un access token à la place. Il existe plusieurs façons de lier et de dissocier des comptes. Dans la liste suivante, vous pouvez voir les cas d’utilisation et la façon dont ces changements les affectent. | Cas d’utilisation | Statut | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- | | Utiliser l’endpoint `POST /api/v2/users/{id}/identities` de la Management API et envoyer l’ID token du compte principal dans l’en-tête `Authorization`. | Concerné | | Utiliser l’endpoint `POST /api/v2/users/{id}/identities` de la Management API et envoyer un access token (avec le scope `update:users`) dans l’en-tête `authorization`, et le `user_id` du compte secondaire dans le payload. | Non concerné | | Utiliser l’endpoint `POST /api/v2/users/{id}/identities` de la Management API et envoyer un access token (avec le scope `update:current_user_identities`) dans l’en-tête `Authorization`, et le `user_id` du compte secondaire dans le payload. | Concerné | | Utiliser l’endpoint `POST /api/v2/users/{id}/identities` de la Management API et envoyer un access token dans l’en-tête `Authorization` ainsi que l’ID token du compte secondaire dans le payload. | Nouveau cas d’utilisation | | Utiliser la bibliothèque auth0.js et l’ID token du compte principal pour instancier `auth0.Management`. | Concerné | | Utiliser la bibliothèque auth0.js et un access token (avec le scope `update:users`) pour instancier `auth0.Management`. | Non concerné | | Utiliser la bibliothèque auth0.js et un access token (avec le scope `update:current_user_identities`) pour instancier `auth0.Management`. | Concerné | | Utiliser l’endpoint `DELETE /api/v2/users/{id}/identities/{provider}/{user_id}` de la Management API et envoyer l’ID token du compte principal dans l’en-tête `Authorization`. | Concerné | | Utiliser l’endpoint `DELETE /api/v2/users/{id}/identities/{provider}/{user_id}` de la Management API et envoyer un access token dans l’en-tête `Authorization`. | Non concerné |

Actions

Passez en revue tous vos appels au [point de terminaison Identities pour la liaison de comptes](https://auth0.com/docs/api/management/v2/#!/Users/post_identities) et mettez à jour ceux qui utilisent le flux vulnérable décrit ci-dessus. Vous pouvez mettre à jour vos appels de l’une des façons suivantes : * **Scénarios de liaison côté client / lancés par l’utilisateur :** Pour les scénarios de liaison côté client, effectuez la requête vers le point de terminaison Identities à l’aide d’un jeton d’accès avec la portée `update:current_user_identities`, et fournissez le jeton ID du compte secondaire dans la charge utile (`link_with`). Ce jeton ID doit être obtenu au moyen d’un flux conforme à OAuth/OIDC. * **Scénarios de liaison côté serveur** : Pour les scénarios de liaison côté serveur, effectuez la requête vers le point de terminaison Identities à l’aide d’un jeton d’accès avec la portée `update:users` et fournissez le `user_id` du compte secondaire dans la charge utile. Consultez [Lier des comptes d’utilisateur](/docs/fr-ca/manage-users/user-accounts/user-account-linking/link-user-accounts) pour en savoir plus. Pour lier des comptes d’utilisateur, vous pouvez soit effectuer une requête au [point de terminaison Link a User Account](https://auth0.com/docs/api/management/v2#!/Users/post_identities) de l’Management API, soit utiliser la [bibliothèque auth0.js](/docs/fr-ca/libraries/auth0js). Un cas d’utilisation courant consiste à permettre à l’utilisateur connecté de lier ses comptes à l’aide de votre application. Avant la dépréciation, vous pouviez utiliser l’ID token ou le jeton d’accès de l’utilisateur principal (qui contenait la portée `update:current_user_identities`) pour vous authentifier auprès de la Management API et utiliser le [endpoint Link a User Account](https://auth0.com/docs/api/management/v2#!/Users/post_identities). Vous devez maintenant obtenir un jeton d’accès (contenant la portée `update:current_user_identities`) et l’utiliser pour vous authentifier auprès de l’API afin d’utiliser l’endpoint Link a User Account. La charge utile doit être l’ID token de l’utilisateur secondaire. 1. Obtenez un jeton d’accès avec la portée `update:current_user_identities`, comme dans l’exemple suivant. L’exemple utilise le [flux implicite](/docs/fr-ca/get-started/authentication-and-authorization-flow/implicit-flow-with-form-post), mais vous pouvez [obtenir des jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/get-access-tokens) pour tout type d’application. 2. Avec l’ancienne méthode utilisant un ID token, votre code ressemblerait à ceci : Avec la nouvelle méthode utilisant un jeton d’accès, votre code ressemblera à ceci : 3. Pour obtenir un jeton d’accès qui peut accéder à la Management API : 1. Définissez `audience` sur `https://{yourDomain}/api/v2/`. 2. Demandez le `scope` `${scope}`. 3. Définissez `response_type` sur `id_token token` afin qu’Auth0 envoie à la fois un ID token et un jeton d’accès. Si nous décodons le jeton d’accès et examinons son contenu, nous pouvons voir ce qui suit : Remarquez que `aud` est défini sur l’URI de l’API de votre tenant, `scope` sur `${scope}` et `sub` sur l’ID de l’utilisateur connecté. 4. Les conditions suivantes doivent être respectées : 1. L’ID token du compte secondaire doit être signé avec `RS256.` 2. La claim `aud` dans l’ID token du compte secondaire doit identifier le client et avoir la même valeur que la claim `azp` du jeton d’accès utilisé pour effectuer la requête. 5. Une fois que vous avez le jeton d’accès, vous pouvez l’utiliser pour lier des comptes d’utilisateur. Cette partie reste inchangée : rien d’autre ne change dans la requête, sauf la valeur utilisée comme jeton `Bearer`. La réponse demeure également la même. Si vous utilisez la [bibliothèque auth0.js](/docs/fr-ca/libraries/auth0js) pour accéder à la Management API et lier des comptes, vous utilisez probablement le ID token de l’identité principale de l’utilisateur pour instancier `auth0.Management` et l’utiliser pour lier des comptes. 1. Obtenez un jeton d’accès avec le scope `update:current_user_identities`, puis utilisez ce jeton pour instancier `auth0.Management`. La requête finale à `linkUser` reste la même. 2. Avec l’ancienne méthode utilisant un ID token, votre code ressemblerait à ceci : Avec la nouvelle méthode utilisant un jeton d’accès, votre code ressemblera à ceci : 1. Demande à la fois un ID token et un jeton d’accès dans la réponse (`` responseType: `token id_token` ``). 2. Définit la Management API comme audience du jeton (`` audience: `https://YOUR_DOMAIN/api/v2/` ``). 3. Demande la permission requise (`` scope: `update:current_user_identities` ``). 4. S’authentifie auprès de la Management API à l’aide du jeton d’accès. Si vous obtenez un jeton d’accès pour la liaison de comptes qui contient le scope `update:users` et que vous envoyez le `user_id` et le `provider` du compte secondaire dans la requête, vous n’avez rien à changer. Cependant, cette nouvelle méthode offre une autre possibilité. Vous utilisez toujours un jeton d’accès contenant le scope `update:users` pour vous authentifier auprès de l’API, mais dans le payload de la requête, vous pouvez envoyer le jeton d’ID du compte secondaire (au lieu de `user_id` et `provider`). Vous utilisez l’Auth0 CLI ? Si ce n’est pas déjà fait, [configurez et authentifiez votre session CLI](/docs/fr-ca/deploy-monitor/auth0-cli) avant d’exécuter cette commande. ```bash Auth0 CLI lines theme={null} auth0 api post "users/PRIMARY_ACCOUNT_USER_ID/identities" \ --data '{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}' ``` ```bash cURL lines theme={null} curl --request POST \ --url 'https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities' \ --header 'authorization: Bearer ACCESS_TOKEN' \ --header 'content-type: application/json' \ --data '{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}' ``` ```csharp C# lines theme={null} var client = new RestClient("https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities"); var request = new RestRequest(Method.POST); request.AddHeader("authorization", "Bearer ACCESS_TOKEN"); request.AddHeader("content-type", "application/json"); request.AddParameter("application/json", "{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}", ParameterType.RequestBody); IRestResponse response = client.Execute(request); ``` ```go Go lines theme={null} package main import ( "fmt" "strings" "net/http" "io/ioutil" ) func main() { url := "https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities" payload := strings.NewReader("{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}") req, _ := http.NewRequest("POST", url, payload) req.Header.Add("authorization", "Bearer ACCESS_TOKEN") req.Header.Add("content-type", "application/json") res, _ := http.DefaultClient.Do(req) defer res.Body.Close() body, _ := ioutil.ReadAll(res.Body) fmt.Println(res) fmt.Println(string(body)) } ``` ```java Java lines theme={null} HttpResponse response = Unirest.post("https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities") .header("authorization", "Bearer ACCESS_TOKEN") .header("content-type", "application/json") .body("{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}") .asString(); ``` ```javascript Node.JS lines theme={null} var axios = require("axios").default; var options = { method: 'POST', url: 'https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities', headers: {authorization: 'Bearer ACCESS_TOKEN', 'content-type': 'application/json'}, data: {link_with: 'SECONDARY_ACCOUNT_ID_TOKEN'} }; axios.request(options).then(function (response) { console.log(response.data); }).catch(function (error) { console.error(error); }); ``` ```php PHP lines theme={null} $curl = curl_init(); curl_setopt_array($curl, [ CURLOPT_URL => "https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities", CURLOPT_RETURNTRANSFER => true, CURLOPT_ENCODING => "", CURLOPT_MAXREDIRS => 10, CURLOPT_TIMEOUT => 30, CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_POSTFIELDS => "{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}", CURLOPT_HTTPHEADER => [ "authorization: Bearer ACCESS_TOKEN", "content-type: application/json" ], ]); $response = curl_exec($curl); $err = curl_error($curl); curl_close($curl); if ($err) { echo "cURL Error #:" . $err; } else { echo $response; } ``` ```python Python lines theme={null} import http.client conn = http.client.HTTPSConnection("") payload = "{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}" headers = { 'authorization': "Bearer ACCESS_TOKEN", 'content-type': "application/json" } conn.request("POST", "/{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities", payload, headers) res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```ruby Ruby lines theme={null} require 'uri' require 'net/http' require 'openssl' url = URI("https://{yourDomain}/api/v2/users/PRIMARY_ACCOUNT_USER_ID/identities") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_PEER request = Net::HTTP::Post.new(url) request["authorization"] = 'Bearer ACCESS_TOKEN' request["content-type"] = 'application/json' request.body = "{"link_with":"SECONDARY_ACCOUNT_ID_TOKEN"}" response = http.request(request) puts response.read_body ``` Les conditions suivantes doivent être respectées : * Le jeton d’ID du compte secondaire doit être signé avec `RS256`. * Le claim `aud` du jeton d’ID du compte secondaire doit identifier le client et avoir la même valeur que le claim `azp` du jeton d’accès utilisé pour effectuer la requête. Si vous utilisez des jetons ID pour dissocier des comptes, vous devez mettre à jour votre code afin d’utiliser des jetons d’accès. 1. Vous devez d’abord obtenir un jeton d’accès avec la portée `update:current_user_identities`. 2. Avec l’ancienne méthode utilisant un jeton ID, votre code ressemblerait à ceci : Avec la nouvelle méthode utilisant un jeton d’accès, votre code ressemblera à ceci : 3. Pour obtenir un jeton d’accès permettant d’accéder à la Management API : 1. Définissez `audience` sur `https://{yourDomain}/api/v2/`. 2. Demandez la `scope` `${scope}`. 3. Définissez `response_type` sur `id_token token` afin qu’Auth0 envoie à la fois un jeton ID et un jeton d’accès. Si nous décodons le jeton d’accès et en examinons le contenu, nous pouvons voir ce qui suit : Notez que `aud` est défini sur l’URI de l’API de votre tenant, que `scope` est défini sur `update:current_user_identities` et que `sub` correspond à l’ID utilisateur de l’utilisateur connecté. 4. Une fois le jeton d’accès obtenu, vous pouvez envoyer une requête au [point de terminaison Dissocier une identité d’utilisateur](https://auth0.com/docs/api/management/v2#!/Users/delete_user_identity_by_user_id) de la Management API, en l’incluant dans l’en-tête `Authorization`. 5. Avec l’ancienne méthode, votre requête ressemblerait à ceci : ```http lines theme={null} DELETE https://YOUR_DOMAIN/api/v2/users/{primaryAccountUserId}/identities/{secondaryAccountProvider}/{secondaryAccountUserId} Authorization: 'Bearer {yourIdTokenOrMgmtApiAccessToken}' ``` Avec la nouvelle méthode, votre requête ressemblera à ceci :

Considérations de sécurité

Nous avons identifié une faiblesse dans un flux particulier de liaison de comptes qui pourrait être exploitée de façon abusive dans certaines circonstances. Nous n’avons trouvé aucune preuve d’utilisation malveillante, mais nous avons décidé de retirer ce flux afin d’éviter que cela ne se produise. Par conséquent, Auth0 exige que les clients qui utilisent le flux de liaison de comptes touché migrent vers une mise en œuvre plus sécuritaire avant le 19 octobre 2018. Des options de migration sont fournies dans ce guide et ne devraient entraîner aucune perte de fonctionnalité. À compter du 19 octobre 2018, le flux de liaison de comptes touché sera désactivé et vous obtiendrez des erreurs à l’exécution. Vous êtes touché si vous envoyez une requête au [endpoint Post Identities](https://auth0.com/docs/api/management/v2#!/Users/post_identities) à l’aide d’un token (ID ou jeton d’accès) avec la portée `update:current_user_identities` dans l’en-tête Authorization et incluez le `user_id` du compte secondaire dans la charge utile. Aucun autre cas d’utilisation n’est touché.

En savoir plus

* [Migrer vers les points de terminaison de la Management API à l’aide de jetons d’accès](/docs/fr-ca/troubleshoot/product-lifecycle/past-migrations/migrate-to-calling-api-with-access-tokens)