> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-feat-init-gt-translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Décrit comment configurer des applications nouvelles ou existantes pour utiliser l’authentification Private Key JWT.

# Configurer l’authentification Private Key JWT

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Private Key JWT est offert aux clients du plan Enterprise. Pour passer à un forfait supérieur, consultez [Auth0 pricing](https://auth0.com/pricing/).
</Callout>

L’authentification Private Key <Tooltip tip="JSON Web Token (JWT) : format standard de ID Token (et souvent de jeton d’accès) utilisé pour représenter des claims de façon sécurisée entre deux parties." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=JWT">JWT</Tooltip> prend en charge l’authentification du client selon [OIDC Connect Core Client Authentication 1.0](https://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication), à l’aide d’assertions JWT signées avec des paires de clés asymétriques. Vous pouvez créer une nouvelle application pour utiliser `private_key_jwt` ou permettre à des applications existantes d’utiliser des paires de clés asymétriques pour l’authentification.

<h2 id="prerequisites">
  Prérequis
</h2>

Avant de configurer une application qui s’authentifie au moyen de Private Key JWT, vous devez [générer une paire de clés RSA](/docs/fr-ca/secure/application-credentials/generate-rsa-key-pair).

<h2 id="configure-private-key-jwt">
  Configurer Private Key JWT
</h2>

<Tabs>
  <Tab title="Auth0 Dashboard">
    Vous pouvez utiliser l’Auth0 Dashboard pour créer une nouvelle application et configurer les identifiants, ou mettre à jour une application existante.

    Nous vous recommandons de stocker de façon sécuritaire le paramètre `client_secret` actuel avant de définir la méthode d’authentification de votre application sur Private Key JWT. Le paramètre `client_secret` sera masqué une fois la configuration de Private Key JWT terminée.

    <h4 id="configure-a-new-application-for-private_key_jwt">
      Configurer une nouvelle application pour `private_key_jwt`
    </h4>

    1. Accédez à [**Auth0 Dashboard > Applications > Application**](https://manage.auth0.com/#/applications).
    2. Sélectionnez **Create Application**.
    3. Choisissez votre type d’application.
    4. Dans les paramètres de l’application, sélectionnez l’onglet **Credentials**.
    5. Sous **Authentication Methods**, sélectionnez **Private Key JWT**.

           <Frame>
             <img src="https://mintcdn.com/docs-dev-feat-init-gt-translations/AcBWN86l7cA24wcQ/docs/images/cdy7uua7fh8z/33kfi48tkbMIOQJ8PBxj76/5b79ffda11ad58b27128068057e6e05c/Default_App_-_Creds_-_English.png?fit=max&auto=format&n=AcBWN86l7cA24wcQ&q=85&s=f37a840110a12b0be1b8c66ecca8ad16" alt="Configurer l’authentification Private Key JWT - instructions dans l’Auth0 Dashboard" width="1102" height="1197" data-path="docs/images/cdy7uua7fh8z/33kfi48tkbMIOQJ8PBxj76/5b79ffda11ad58b27128068057e6e05c/Default_App_-_Creds_-_English.png" />
           </Frame>
    6. Configurez les détails de l’identifiant :

       1. Saisissez un nom pour l’identifiant.
       2. Téléversez votre certificat au format PEM ou X.509.
       3. Sélectionnez l’algorithme utilisé pour signer les assertions.
       4. Facultatif : activez une date d’expiration personnalisée. Sélectionnez **Set an explicit expiry date for this Credential** et définissez une date ultérieure.

              <Warning>
                Vous pourriez recevoir une erreur de certificat invalide si vous soumettez une clé mal formée. Pour éviter tout problème, il est préférable de téléverser directement le fichier créé par openssl.
              </Warning>
    7. Sélectionnez **Add Credential**.

    <h4 id="configure-an-existing-application">
      Configurer une application existante
    </h4>

    1. Accédez à [Auth0 Dashboard > Applications](http://manage.auth0.com/#/applications).
    2. Sélectionnez l’application que vous souhaitez mettre à jour.
    3. Sélectionnez l’onglet **Credentials**.
    4. Choisissez **Private Key JWT**.
    5. Configurez les détails de l’identifiant :

       1. Saisissez un nom pour l’identifiant.
       2. Téléversez votre certificat au format PEM ou X.509.
       3. Sélectionnez l’algorithme utilisé pour signer les assertions.
       4. Facultatif : activez une date d’expiration personnalisée. Sélectionnez **Set an explicit expiry date for this Credential** et définissez une date ultérieure.
    6. Sélectionnez **Add Credential**.

    <h4 id="configure-an-application-to-use-client-secret-authentication">
      Configurer une application pour utiliser l’authentification Client Secret
    </h4>

    1. Accédez à [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/dashboard/#/applications/) et sélectionnez l’application que vous souhaitez mettre à jour.
    2. Sélectionnez l’onglet **Credentials**.
    3. Choisissez **Client Secret (Post)** ou **Client Secret (Basic)**.
    4. Sélectionnez **Save**.

    <h4 id="update-credential-expiration">
      Mettre à jour l’expiration d’un identifiant
    </h4>

    Vous pouvez mettre à jour la date d’expiration d’un identifiant existant dans l’Auth0 Dashboard.

    1. Accédez à [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/dashboard/#/applications/) et sélectionnez l’application que vous souhaitez mettre à jour.
    2. Sélectionnez l’onglet **Credentials**.
    3. Choisissez l’identifiant que vous souhaitez mettre à jour et sélectionnez **Edit Credential**.

           <Frame>
             <img src="https://mintcdn.com/docs-dev-feat-init-gt-translations/ga3rC1_4s-OF6Vr-/docs/images/cdy7uua7fh8z/6858PTDkNCRZiIqtBVmciZ/ec25a602cfae5a0a5cf38049d050ceaa/Demo_Key2_-_English.png?fit=max&auto=format&n=ga3rC1_4s-OF6Vr-&q=85&s=e0671008b89015d8304d0151a133ba6d" alt="Dashboard - Applications - Paramètres de l’application - Credentials - mettre à jour la date d’expiration" width="1102" height="383" data-path="docs/images/cdy7uua7fh8z/6858PTDkNCRZiIqtBVmciZ/ec25a602cfae5a0a5cf38049d050ceaa/Demo_Key2_-_English.png" />
           </Frame>
    4. Sélectionnez **Set an explicit expiry date for this Credential** et définissez une date ultérieure.
    5. Sélectionnez **Update Credential**.
  </Tab>

  <Tab title="Management API">
    <h4 id="configure-a-new-application-for-private_key_jwt-2">
      Configurer une nouvelle application pour « private\_key\_jwt »
    </h4>

    Vous pouvez créer une nouvelle application avec `private_key_jwt` comme méthode d'authentification en utilisant la Management API. Effectuez un appel `POST` vers l'endpoint [`Create a Client`](https://auth0.com/docs/api/management/v2#!/Clients/get_clients) avec la charge utile suivante :

    <Tabs>
      <Tab title="Auth0 CLI">
        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">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.</Callout>

        ```bash theme={null}
        auth0 api post "clients" \
          --data '{
           "name": "{clientName}",
           "app_type": "non_interactive",
           "client_authentication_methods": {
             "private_key_jwt": {
               "credentials": [
                 {
                    "name": "{credentialName}",
                    "credential_type": "public_key",
                    "pem": "{credentialPublicKey}",
                    "alg": "{algorithm}",
                    "expires_at": "{expiresAt}"
                 }
               ]
             },
             "jwt_configuration": {
               "alg": "RS256"
             }
           }
          }'
        ```
      </Tab>

      <Tab title="cURL">
        ```bash lines theme={null}
        curl --location --request POST 'https://{domain}/api/v2/clients' \
          --header 'Authorization: Bearer {managementApiAccessToken} \
          --header 'Content-Type: application/json' \
          --data-raw '{
         "name": "{clientName}",
         "app_type": "non_interactive",
         "client_authentication_methods": {
           "private_key_jwt": {
             "credentials": [
               { 
                  "name": "{credentialName}", 
                  "credential_type": "public_key", 
                  "pem": "{credentialPublicKey}",
                  "alg": "{algorithm}",
                  "expires_at": "{expiresAt}"
               }
             ]
           },
           "jwt_configuration": {
             "alg": "RS256"
           }
         }
        }'
        ```
      </Tab>
    </Tabs>

    | Paramètre                  | Description                                                                                                                                                                                                                                                                                 |
    | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `algorithme`               | Algorithme utilisé pour signer les assertions. Les valeurs prises en charge sont RS256, RS384 et PS256. S’il n’est pas indiqué, l’algorithme par défaut est RS256.                                                                                                                          |
    | `clientName`               | Nom de votre nouveau client.                                                                                                                                                                                                                                                                |
    | `credentialName`           | Nom de la clé publique.                                                                                                                                                                                                                                                                     |
    | `expires_at`               | Facultatif. Date d’expiration du justificatif au format ISO 8601. Par exemple, `2020-08-20T19:10:06.299Z`. Une fois cette date passée, le justificatif n’est plus valide.                                                                                                                   |
    | `managementApiAccessToken` | [Jeton d’accès pour la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) ayant la portée `create:credentials`.                                                                                                                                          |
    | `pem`                      | Clé publique ou certificat x.509, encodé au format PEM.                                                                                                                                                                                                                                     |
    | `parse_expiry_from_cert`   | Facultatif. Booléen indiquant si Auth0 doit analyser la date d’expiration lorsqu’un certificat est fourni. Si aucun certificat n’est fourni, Auth0 renverra une erreur. `parse_expiry_from_cert` et `expires_at` s’excluent également mutuellement. Dans ce cas, Auth0 renverra une erreur. |

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      La clé publique PEM doit être échappée en JSON avant d’être transmise à Auth0. Dans notre exemple, voici le contenu à transmettre :

      `-----BEGIN PUBLIC KEY-----
                              MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA53VzmIVVZZWyNm266l82
                              mnoDc9g/snXklax5kChEhqK/WnTUvuXP4Gd4THj8rchxgUGKXd4PF3SUcKyn/qPm
                              Tet0idVHk2PwP//FOVgYo5Lb04js0pgZkbyB/WjuMp1w+yMuSn0NYAP7Q9U7DfTb
                              jmox8OQt4tCB4m7UrJghGqT8jkPyZO/Ka6/XsyjTYPOUL3t3PD7JShVAgo1mAY6g
                              Sr4SORywIiuHsg+59ad7MXGy78LirhtqAcDECKF7VZpxMuEjMLg3o2yzNUeWI2Mg
                              IF+t0HbO1E387fvLcuSyai1yWbSr1PXyiB2aXyDpbD4u7d3ux4ahU2opH11lBqvx
                              +wIDAQAB -----END PUBLIC KEY-----`
    </Callout>

    La réponse contient la propriété `client_id` qui associera votre application au serveur de ressources. Elle contient également un `kid` généré pour le justificatif que vous avez créé, qui sera utilisé plus tard pour générer le `client_assertion`.

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      Auth0 suit la norme [JSON Web Key Thumbprint](https://datatracker.ietf.org/doc/html/rfc7638) pour générer le kid de vos informations d’authentification.

      Le kid correspond à un condensé SHA256 de la représentation JWK de votre clé publique, encodé en base64URL.
    </Callout>

    <h4 id="configure-an-existing-application-2">
      Configurer une application existante
    </h4>

    Vous pouvez également configurer une application existante pour utiliser l'authentification Private Key JWT avec l'Auth0 Management API. Vous devrez supprimer toutes les valeurs du champ `token_endpoint_auth_method` et ajouter des valeurs dans le champ `client_authentication_methods`.

    <Warning>
      Si vous mettez à jour une application de production existante pour qu’elle s’authentifie avec `private_key_jwt`, nous vous recommandons de conserver en lieu sûr votre valeur actuelle de `client_secret` pour référence ultérieure.

      Après avoir configuré private\_key\_jwt, vous ne pourrez plus accéder à la valeur client\_secret, à moins de rétablir la configuration de votre application pour utiliser un Client Secret.
    </Warning>

    <h5 id="create-the-credential-resource">
      Créer la ressource d'identification
    </h5>

    Une fois la paire de clés générée, créez la ressource d'identification. Effectuez la requête POST suivante à l'endpoint [`/clients`](https://auth0.com/docs/api/management/v2#!/Clients/post_clients) de la Management API.

    <Tabs>
      <Tab title="Auth0 CLI">
        ```bash theme={null}
        auth0 api post "clients/{clientId}/credentials" \
          --data '{
                    "name": "{credentialName}",
                    "credential_type": "public_key",
                    "pem": "{credentialPublicKey}",
                    "alg": "{algorithm}",
                    "expires_at ": "{expiresAt}",
          }'
        ```
      </Tab>

      <Tab title="cURL">
        ```bash lines theme={null}
        curl --location --request POST 'https://{domain}/api/v2/clients/{clientId}/credentials' \
          --header 'Authorization: Bearer {managementApiAccessToken} \
          --header 'Content-Type: application/json' \
          --data-raw '{
                  "name": "{credentialName}", 
                  "credential_type": "public_key", 
                  "pem": "{credentialPublicKey}",
                  "alg": "{algorithm}",
                  "expires_at ": "{expiresAt}",
        }'
        ```
      </Tab>
    </Tabs>

    | Paramètre                  | Description                                                                                                                                                                                                                                                                            |
    | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `algorithme`               | Algorithme utilisé pour signer les assertions. Les valeurs prises en charge sont RS256, RS384 et PS256. Si rien n’est précisé, l’algorithme par défaut est RS256.                                                                                                                      |
    | `clientId`                 | ID de l’application à mettre à jour.                                                                                                                                                                                                                                                   |
    | `credentialName`           | Nom de la clé publique.                                                                                                                                                                                                                                                                |
    | `managementApiAccessToken` | [Jeton d’accès pour la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) ayant la portée `create:credentials`.                                                                                                                                     |
    | `pem`                      | Clé publique ou certificat x.509, encodés au format PEM.                                                                                                                                                                                                                               |
    | `expires_at`               | Facultatif. Date d’expiration de l’information d’authentification au format ISO 8601. Par exemple : `2020-08-20T19:10:06.299Z`. Une fois cette date passée, l’information d’authentification n’est plus valide.                                                                        |
    | `parse_expiry_from_cert`   | Facultatif. Un booléen qui indique qu’Auth0 doit extraire la date d’expiration lorsqu’un certificat est fourni. Si aucun certificat n’est fourni, Auth0 renverra une erreur. `parse_expiry_from_cert` et `expires_at` s’excluent mutuellement. Dans ce cas, Auth0 renverra une erreur. |

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      La clé publique PEM doit être échappée au format JSON avant d’être transmise à Auth0. Dans cet exemple, le contenu que nous devons transmettre est :

      ```pem lines theme={null}
      -----BEGIN PUBLIC KEY-----
      MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA53VzmIVVZZWyNm266l82
      mnoDc9g/snXklax5kChEhqK/WnTUvuXP4Gd4THj8rchxgUGKXd4PF3SUcKyn/qPm
      Tet0idVHk2PwP//FOVgYo5Lb04js0pgZkbyB/WjuMp1w+yMuSn0NYAP7Q9U7DfTb
      jmox8OQt4tCB4m7UrJghGqT8jkPyZO/Ka6/XsyjTYPOUL3t3PD7JShVAgo1mAY6g
      Sr4SORywIiuHsg+59ad7MXGy78LirhtqAcDECKF7VZpxMuEjMLg3o2yzNUeWI2Mg
      IF+t0HbO1E387fvLcuSyai1yWbSr1PXyiB2aXyDpbD4u7d3ux4ahU2opH11lBqvx
      +wIDAQAB
      -----END PUBLIC KEY-----
      ```
    </Callout>

    L’ID du justificatif est renvoyé dans la réponse. Utilisez-le à l’étape suivante.

    <h5 id="associate-the-credential">
      Associer les informations d’identification
    </h5>

    Après avoir créé le credential, associez-le à votre application. Votre application utilise ces credentials lors de l'authentification avec `private_key_jwt`.

    Envoyez une requête PATCH à l'endpoint [`Update a Client`](https://auth0.com/docs/api/management/v2#!/Clients/patch_clients_by_id) de la Management API :

    <Tabs>
      <Tab title="Auth0 CLI">
        ```bash theme={null}
        auth0 api patch "clients/{clientId}" \
          --data '{
                 "token_endpoint_auth_method": null,
                 "client_authentication_methods": {
                    "private_key_jwt": {
                       "credentials": [{ "id": {credentialId} }]
                    }
                 }
          }​​'
        ```
      </Tab>

      <Tab title="cURL">
        ```bash lines theme={null}
        curl --location --request PATCH 'https://{domain}/api/v2/clients/{clientId} \
          --header 'Authorization: Bearer {managementApiAccessToken} \
          --header 'Content-Type: application/json' \
          --data-raw '{
                  "token_endpoint_auth_method": null, 
                  "client_authentication_methods": {
                     "private_key_jwt": {
                        "credentials": [{ "id": {credentialId} }]
                     }
                  }
           }​​'​​
        ```
      </Tab>
    </Tabs>

    | Paramètre                  | Description                                                                                                                                                           |
    | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `clientId`                 | ID de l’application à mettre à jour.                                                                                                                                  |
    | `managementApiAccessToken` | [Jeton d’accès pour l’API de gestion](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec les portées `update:client` et `update:credentials`. |
    | `credentialId`             | ID des informations d’identification que vous avez créées.                                                                                                            |
    | `pem`                      | La clé publique au format PEM.                                                                                                                                        |

    <Warning>
      Auth0 ne prend pas en charge l’utilisation de HS256 comme algorithme de signature JWT pour l’application. Le champ `jwt_configuration.alg` doit être défini sur l’algorithme RS256. Pour savoir comment modifier l’algorithme de signature, consultez [Modifier les algorithmes de signature de l’application](/docs/fr-ca/get-started/applications/change-application-signing-algorithms).
    </Warning>

    <h4 id="configure-an-application-to-use-client-secret-authentication-2">
      Configurer une application pour utiliser l’authentification par secret client
    </h4>

    Pour rétablir la configuration de votre application afin d’utiliser un Client Secret, vous devez désactiver `client_authentication_methods` et réactiver `token_endpoint_auth_method` avec la méthode d’authentification.

    <Warning>
      Une fois votre méthode d’authentification configurée avec `client_secret`, vos applications ne pourront plus s’authentifier au moyen de `private_key_jwt` tant que vous ne les aurez pas mises à jour pour s’authentifier avec `client_secret`.
    </Warning>

    **Exemple**

    <Tabs>
      <Tab title="Auth0 CLI">
        ```bash theme={null}
        auth0 api patch "clients/{clientId}" \
          --data '{
                 "token_endpoint_auth_method": "{tokenEndpointAuthMethod}",
                 "client_authentication_methods": null
          }​​'
        ```
      </Tab>

      <Tab title="cURL">
        ```bash lines theme={null}
        curl --location --request PATCH 'https://{domain}/api/v2/clients/{clientId} \
          --header 'Authorization: Bearer {managementApiAccessToken} \
          --header 'Content-Type: application/json' \
          --data-raw '{
                  "token_endpoint_auth_method": "{tokenEndpointAuthMethod}", 
                  "client_authentication_methods": null
           }​​'​​
        ```
      </Tab>
    </Tabs>

    | Paramètre                  | Description                                                                                                                                                           |
    | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `clientId`                 | ID de l’application mise à jour.                                                                                                                                      |
    | `managementApiAccessToken` | [Jeton d’accès pour la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec les scopes `update:client` et `update:credentials`. |
    | `tokenEndpointAuthMethod`  | Méthode d’authentification finale. Par exemple : `client_secret_basic` ou `client_secret_post`.                                                                       |

    <h4 id="patch-credentials-with-an-expiration-field">
      Mettre à jour les informations d’identification avec un champ d’expiration
    </h4>

    Vous pouvez mettre à jour un identifiant existant avec une date d’expiration à l’aide du point de terminaison [Update a credential](https://auth0.com/docs/api/management/v2#!/Clients/patch_credentials_by_credential_id) de l’API de gestion.

    <Tabs>
      <Tab title="Auth0 CLI">
        ```bash theme={null}
        auth0 api patch "clients/{clientId}/credentials/{credentialId}" \
          --data '{
                 "expires_at": {expiresAt}
          }'
        ```
      </Tab>

      <Tab title="cURL">
        ```bash lines theme={null}
        curl --location --request PATCH 'https://{domain}/api/v2/clients/{clientId}/credentials/{credentialId} ' \
          --header 'Authorization: Bearer {managementApiAccessToken} \
          --header 'Content-Type: application/json' \
          --data-raw '{
                  "expires_at": {expiresAt}
           }'
        ```
      </Tab>
    </Tabs>

    | Paramètre                  | Description                                                                                                           |
    | -------------------------- | --------------------------------------------------------------------------------------------------------------------- |
    | `managementApiAccessToken` | Jetons d’accès pour la Management API avec les portées ` update:credentials`.                                         |
    | `clientId`                 | Le client à mettre à jour.                                                                                            |
    | `expires_at`               | La date d’expiration de l’identifiant d’authentification au format ISO 8601. Par exemple, `2020-08-20T19:10:06.299Z`. |

    Le seul champ que vous pouvez mettre à jour est le champ `expires_at`. Les autres attributs sont immuables et nécessitent une rotation du credential pour être modifiés.
  </Tab>
</Tabs>

<h2 id="credential-limits">
  Limites des identifiants
</h2>

Auth0 impose une taille minimale de 2 048 bits et une taille maximale de 4 096 bits pour les clés RSA. Les applications peuvent avoir au plus deux identifiants configurés.

<h2 id="rotate-credentials">
  Effectuer la rotation des identifiants
</h2>

Pour éviter qu’une fuite de clés ne compromette la sécurité, Auth0 recommande d’effectuer périodiquement la rotation de la paire de clés. Pour savoir comment procéder, consultez [Effectuer la rotation des identifiants](/docs/fr-ca/get-started/applications/rotate-credentials).

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

* [Identifiants de l’application](/docs/fr-ca/secure/application-credentials)
* [Paramètres des identifiants](/docs/fr-ca/get-started/applications/credentials)
* [S’authentifier à l’aide de Private Key JWT](/docs/fr-ca/get-started/authentication-and-authorization-flow/authenticate-with-private-key-jwt)