> ## Documentation Index
> Fetch the complete documentation index at: https://auth0.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Révoquer les clés de connexion

> Découvrez comment révoquer la clé de connexion de l’application de votre locataire à l’aide du Auth0 Dashboard (Tableau de bord Auth0) ou de Management API.

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) + "*****MASKED*****";
          }
          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 révoquer la clé de connexion de l’application ou de l’API de votre locataire en utilisant Auth0 Dashboard ou Management API. La clé de connexion est utilisée pour signer les jetons d’ID, les jetons d’accès, les assertions <Tooltip href="/docs/fr-ca/glossary?term=security-assertion-markup-language" tip="Security Assertion Markup Language (SAML)
Protocole normalisé permettant à deux parties d’échanger des informations d’authentification sans mot de passe." cta="Voir le glossaire">SAML</Tooltip> et les assertions <Tooltip href="/docs/fr-ca/glossary?term=ws-fed" tip="Web Service Federation (WS-Fed)
Protocole de gestion des identités des utilisateurs à travers les domaines." cta="Voir le glossaire">WS-Fed</Tooltip> envoyées à votre application ou à votre API. Pour en savoir plus, consultez [Clés de connexion](/docs/fr-ca/get-started/tenant-settings/signing-keys).

## Prérequis

* Avant de pouvoir révoquer une clé de connexion précédemment utilisée, vous devez d’abord procéder à une rotation de la clé. Pour en savoir plus, consultez [Rotation des clés de connexion](/docs/fr-ca/get-started/tenant-settings/signing-keys/rotate-signing-keys) ou consultez la section **Rotation et révocation des clés de connexion** ci-dessous.
* Assurez-vous d’avoir mis à jour votre application ou votre API avec la nouvelle clé avant de révoquer la clé précédente.

<Warning>
  Une fois révoquée, une clé de connexion ne peut plus être réutilisée. Assurez-vous donc de vouloir la révoquer.
</Warning>

## Utiliser le Dashboard

### Révoquer la clé de connexion précédemment utilisée

1. Allez à [Dashboard > Paramètres > Clés de connexion](https://manage.auth0.com/#/tenant/signing_keys).
2. Dans la section **Liste des clés valides**, localisez la clé **précédemment utilisée**, sélectionnez le menu Plus d’options (**…**) et sélectionnez **Révoquer la clé**.
   La section **Liste des clés valides** répertorie la clé de connexion actuellement utilisée par votre locataire, ainsi que la prochaine clé de connexion qui sera attribuée si vous décidez d’effectuer une rotation de vos clés de connexion. Si vous avez déjà effectué une rotation des clés de connexion, cette section répertorie également les clés utilisées précédemment.
   La section **Liste des clés révoquées** répertorie les trois dernières clés révoquées de votre locataire.
3. Sélectionnez **Révoquer** pour confirmer.

### Rotation et révocation des clés de connexion

1. Allez à [Dashboard > Paramètres > Clés de connexion](https://manage.auth0.com/#/tenant/signing_keys).
2. Dans la section **Rotation Settings (Paramètres de rotation)**, localisez la section **Rotate & Revoke Signing Key (Rotation et révocation de la clé de connexion)** et sélectionnez **Rotate & Revoke Key (Rotation et révocation de la clé)**.
3. Sélectionnez **Rotation et révocation** pour confirmer.

## Utiliser Management API

<Warning>
  Vous ne pouvez révoquer que la clé de connexion précédemment utilisée.
</Warning>

1. Pour obtenir une liste des clés de connexion, effectuez un appel `GET` au point de terminaison [GObtenir toutes les clés de connexion d’application](/docs/fr-ca/api/management/v2#!/Keys/get_signing_keys).
2. Faites un appel `PUT` au point de terminaison [Révoquer une clé de connexion d’application par son identifiant de clé](/docs/fr-ca/api/management/v2#!/Keys/put_signing_keys). Assurez-vous de remplacer les valeurs des paramètres fictifs `{yourKeyId}` et `{yourMgmtApiAccessToken}` par votre identifiant de clé de connexion et votre jeton d’accès à Management API, respectivement.

<AuthCodeGroup>
  ```bash cURL theme={null}
     curl --request PUT \
     --url 'https://{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke' \
     --header 'authorization: Bearer {yourMgmtApiAccessToken}'

  ```

  ```csharp C# theme={null}
     var client = new RestClient("https://{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke");
  var request = new RestRequest(Method.PUT);
  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/%7ByourKeyId%7D/revoke"

     req, _ := http.NewRequest("PUT", 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.put("https://{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke")
     .header("authorization", "Bearer {yourMgmtApiAccessToken}")
     .asString();

  ```

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

  var options = {
  method: 'PUT',
  url: 'https://{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke',
  headers: {authorization: 'Bearer {yourMgmtApiAccessToken}'}
  };

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

  ```

  ```objc Obj-C theme={null}
     #import <Foundation/Foundation.h>

  NSDictionary *headers = @{ @"authorization": @"Bearer {yourMgmtApiAccessToken}" };

  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke"]
                                                        cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                     timeoutInterval:10.0];
  [request setHTTPMethod:@"PUT"];
  [request setAllHTTPHeaderFields:headers];

  NSURLSession *session = [NSURLSession sharedSession];
  NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                  if (error) {
                                                     NSLog(@"%@", error);
                                                  } else {
                                                     NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                     NSLog(@"%@", httpResponse);
                                                  }
                                            }];
  [dataTask resume];

  ```

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

  curl_setopt_array($curl, [
  CURLOPT_URL => "https://{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  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("PUT", "/{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke", 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/%7ByourKeyId%7D/revoke")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_NONE

  request = Net::HTTP::Put.new(url)
  request["authorization"] = 'Bearer {yourMgmtApiAccessToken}'

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

  ```

  ```swift Swift theme={null}
     import Foundation

  let headers = ["authorization": "Bearer {yourMgmtApiAccessToken}"]

  let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/api/v2/keys/signing/%7ByourKeyId%7D/revoke")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                      timeoutInterval: 10.0)
  request.httpMethod = "PUT"
  request.allHTTPHeaderFields = headers

  let session = URLSession.shared
  let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
     print(error)
  } else {
     let httpResponse = response as? HTTPURLResponse
     print(httpResponse)
  }
  })

  dataTask.resume()

  ```
</AuthCodeGroup>

| Valeur                  | Description                                                                                                                                                                                               |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `YOUR_KEY_ID`           | ID de la clé de connexion à révoquer. Pour savoir comment trouver l’ID de votre clé de connexion, consultez [Localiser des ensembles de clés Web JSON](https://auth0.com/docs/tokens/guides/locate-jwks). |
| `MGMT_API_ACCESS_TOKEN` | [Jeton d’accès pour Management API](https://auth0.com/docs/api/management/v2/tokens) avec la permission `update:signing_keys`.                                                                            |

## En savoir plus

* [Rotation des clés de connexion](/docs/fr-ca/get-started/tenant-settings/signing-keys/rotate-signing-keys)
* [Afficher les certificats de connexion](/docs/fr-ca/get-started/tenant-settings/signing-keys/view-signing-certificates)
* [Modification des algorithmes de signature des applications](/docs/fr-ca/get-started/applications/change-application-signing-algorithms)