> ## 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 faire la rotation de la clé de signature de l’application ou de l’API de votre tenant à l’aide de l’Auth0 Dashboard ou de la Management API.

# Rotation des clés de signature

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 <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

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

Vous pouvez effectuer manuellement, de façon périodique, la rotation d’une clé de signature afin de changer la clé JSON Web Key (JWK) utilisée par les applications et les API pour valider les jetons. Si votre application ou votre API **ne prend pas en charge** ce changement de clé et tente d’utiliser une clé de signature expirée pour vérifier un jeton, la requête d’authentification échouera.

<Warning>
  Auth0 recommande d’effectuer d’abord la rotation de la clé de signature dans un tenant de développement, puis de vérifier que vos applications et vos API fonctionnent toujours comme prévu. Après avoir confirmé que tout fonctionne correctement, effectuez la même rotation de clé de signature dans votre tenant de production.
</Warning>

Bien qu’Auth0 ne signe qu’avec une seule clé de signature à la fois, le document de découverte <Tooltip tip="OpenID : norme ouverte d’authentification qui permet aux applications de vérifier l’identité des utilisateurs sans recueillir ni stocker d’informations de connexion." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OpenID">OpenID</Tooltip> Connect (OIDC) de votre tenant contient toujours plusieurs clés. Le document de découverte OIDC inclura toujours la clé actuelle et la clé suivante, et il peut aussi inclure la clé précédente si celle-ci n’a pas encore été révoquée. Afin d’offrir une expérience fluide en cas d’urgence, votre application devrait pouvoir utiliser n’importe laquelle des clés indiquées dans le document. Pour en savoir plus sur les documents de découverte OpenID Connect, consultez [Localiser les ensembles de clés Web JSON](/docs/fr-ca/secure/tokens/json-web-tokens/locate-json-web-key-sets).

<Warning>
  Pour vous laisser le temps de mettre à jour votre application avec la nouvelle clé de signature, tous les jetons signés avec la clé précédente resteront valides jusqu’à ce que vous révoquiez cette clé. Pour en savoir plus, consultez [Révoquer les clés de signature](/docs/fr-ca/get-started/tenant-settings/signing-keys/revoke-signing-keys).
</Warning>

Avant d’effectuer la rotation, consultez les [Impact de la rotation des clés](#key-rotation-impact) pour comprendre comment ce changement affecte vos applications, vos API et vos intégrations de fournisseur d’identité.

Vous pouvez effectuer la rotation de la clé de signature d’application de votre tenant à l’aide du <Tooltip tip="Auth0 Dashboard : le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> ou de 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> d’Auth0.

<div id="use-the-dashboard">
  ## Utiliser le Dashboard
</div>

1. Accédez à [Dashboard > Settings > Signing Keys](https://manage.auth0.com/#/tenant/signing_keys).

   <Frame>
     <img src="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7r8t3EGctFmvkCgPrU0i2R/f79ac74dac5cded37b39bd8a8b80951d/dashboard-tenant-settings-signing-keys.png?fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=fabe447a0f3162e565209798a32f94e2" alt="Onglet Signing Keys dans les Tenant Settings du Dashboard" width="1900" height="1830" data-path="docs/images/cdy7uua7fh8z/7r8t3EGctFmvkCgPrU0i2R/f79ac74dac5cded37b39bd8a8b80951d/dashboard-tenant-settings-signing-keys.png" />
   </Frame>
2. Sous **Rotation Settings**, repérez **Rotate Signing Key**, puis sélectionnez **Rotate Key**.
3. Cliquez sur **Rotate** pour confirmer.

   <Frame>
     <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6Ofp24mgt8ZrvaxF2wLA5N/5cca1a3267ffdc07f61d7990b4e85989/Rotating_Key_Warning_-_English.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=f180272ba6d3a4cd8ff88942d9e7919a" alt="Dashboard Settings onglet Signing Keys confirmation de la rotation" width="555" height="459" data-path="docs/images/cdy7uua7fh8z/6Ofp24mgt8ZrvaxF2wLA5N/5cca1a3267ffdc07f61d7990b4e85989/Rotating_Key_Warning_-_English.png" />
   </Frame>

<div id="use-the-management-api">
  ## Utiliser la Management API
</div>

1. Pour obtenir la liste des clés de signature, faites une requête `GET` au point de terminaison [Get all Application Signing Keys](https://auth0.com/docs/api/management/v2#!/Keys/get_signing_keys).
2. Pour effectuer la rotation de la clé de signature, faites une requête `POST` au point de terminaison [Rotate the Application Signing Key](https://auth0.com/docs/api/management/v2#!/Keys/post_signing_keys). Assurez-vous de remplacer la valeur de l’espace réservé `MGMT_API_ACCESS_TOKEN` par votre jeton d’accès de la Management API.

<AuthCodeGroup>
  ```bash cURL theme={null}
     curl --request POST \
  --url 'https://{yourDomain}/api/v2/keys/signing/rotate' \
  --header 'authorization: Bearer {yourMgmtApiAccessToken}'

  ```

  ```csharp C# theme={null}
     var client = new RestClient("https://{yourDomain}/api/v2/keys/signing/rotate");
  var request = new RestRequest(Method.POST);
  request.AddHeader("authorization", "Bearer {yourMgmtApiAccessToken}");
  IRestResponse response = client.Execute(request);

  ```

  ```go Go theme={null}
     package main

  import (
     "fmt"
     "net/http"
     "io/ioutil"
  )

  func main() {

     url := "https://{yourDomain}/api/v2/keys/signing/rotate"

     req, _ := http.NewRequest("POST", url, nil)

     req.Header.Add("authorization", "Bearer {yourMgmtApiAccessToken}")

     res, _ := http.DefaultClient.Do(req)

     defer res.Body.Close()
     body, _ := ioutil.ReadAll(res.Body)

     fmt.Println(res)
     fmt.Println(string(body))

  }

  ```

  ```java Java theme={null}
     HttpResponse response = Unirest.post("https://{yourDomain}/api/v2/keys/signing/rotate")
     .header("authorization", "Bearer {yourMgmtApiAccessToken}")
     .asString();

  ```

  ```javascript Node.JS theme={null}
     var axios = require("axios").default;

  var options = {
  method: 'POST',
  url: 'https://{yourDomain}/api/v2/keys/signing/rotate',
  headers: {authorization: 'Bearer {yourMgmtApiAccessToken}'}
  };

  axios.request(options).then(function (response) {
  console.log(response.data);
  }).catch(function (error) {
  console.error(error);
  });

  ```

  ```php PHP theme={null}
     $curl = curl_init();

  curl_setopt_array($curl, [
  CURLOPT_URL => "https://{yourDomain}/api/v2/keys/signing/rotate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
     "authorization: Bearer {yourMgmtApiAccessToken}"
  ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
  echo "cURL Error #:" . $err;
  } else {
  echo $response;
  }

  ```

  ```python Python theme={null}
     import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer {yourMgmtApiAccessToken}" }

  conn.request("POST", "/{yourDomain}/api/v2/keys/signing/rotate", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))

  ```

  ```ruby Ruby theme={null}
     require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/keys/signing/rotate")

  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 {yourMgmtApiAccessToken}'

  response = http.request(request)
  puts response.read_body

  ```
</AuthCodeGroup>

| Valeur                  | Description                                                                                                                                            |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `MGMT_API_ACCESS_TOKEN` | [Access Token for the Management API](https://auth0.com/docs/api/management/v2/tokens) avec les scopes `create:signing_keys` et `update:signing_keys`. |

<div id="key-rotation-impact">
  ## Impact de la rotation des clés
</div>

<div id="apis-and-api-gateways-accepting-access-tokens">
  ### API et passerelles d’API acceptant des jetons d’accès
</div>

La plupart des middleware et des passerelles d’API utilisent le point de terminaison JSON Web Key Set (JWKS) pour récupérer, à intervalles réguliers, les clés de signature actuelles et futures. Si vos middleware et/ou vos passerelles d’API **ne** prennent **pas** en charge ce point de terminaison et exigent que vous configuriez manuellement un fichier `*.cer`, vous devrez coordonner la rotation des clés de signature dans Auth0 avec la reconfiguration de vos middleware et passerelles.

<div id="auth0-as-a-saml-or-ws-fed-idp">
  ### Auth0 comme IdP SAML ou WS-Fed
</div>

Lorsque Auth0 agit comme <Tooltip tip="Security Assertion Markup Language (SAML) : protocole normalisé permettant à deux parties d’échanger des renseignements d’authentification sans mot de passe." cta="Consulter le glossaire" href="/docs/fr-ca/glossary?term=SAML">SAML</Tooltip> ou <Tooltip tip="Web Service Federation (WS-Fed) : protocole de gestion des identités utilisateur entre les domaines." cta="Consulter le glossaire" href="/docs/fr-ca/glossary?term=WS-Fed">WS-Fed</Tooltip> en tant que fournisseur d’identité, la rotation de la clé de signature modifie la clé utilisée pour signer les réponses. Vous devez mettre à jour chacun de vos fournisseurs de services avec le nouveau certificat afin qu’ils puissent continuer à valider les réponses signées par Auth0. Pour mettre à jour vos fournisseurs de services afin qu’ils fassent confiance au prochain certificat avant d’effectuer la rotation des clés de signature, consultez [Effectuer la rotation de la clé de signature du tenant](/docs/fr-ca/authenticate/protocols/saml/saml-sso-integrations/sign-and-encrypt-saml-requests#rotate-the-tenant-signing-key).

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

* [Révoquer les clés de signature](/docs/fr-ca/get-started/tenant-settings/signing-keys/revoke-signing-keys)
* [Localiser les ensembles de clés Web JSON](/docs/fr-ca/secure/tokens/json-web-tokens/locate-json-web-key-sets)
* [Modifier les algorithmes de signature de l’application](/docs/fr-ca/get-started/applications/change-application-signing-algorithms)
* [Afficher les certificats de signature](/docs/fr-ca/get-started/tenant-settings/signing-keys/view-signing-certificates)