> ## 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 configurer JSON Web Encryption (JWE) pour une API.

# Configurer JSON Web Encryption (JWE)

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour utiliser les fonctionnalités de Highly Regulated Identity, vous devez disposer d’un plan Enterprise avec le module complémentaire Highly Regulated Identity. Consultez [Auth0 Pricing](https://auth0.com/pricing/) pour en savoir plus.
</Callout>

Par défaut, Auth0 émet des <Tooltip tip="Jeton d’accès : information d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=access+tokens">jetons d’accès</Tooltip> au format [JSON Web Token (JWT)](/fr-CA/docs/secure/tokens/json-web-tokens) signé, ce qui signifie que, même si leur intégrité est protégée, les clients et les autres intermédiaires peuvent quand même les inspecter. Cela peut compromettre la confidentialité des données destinées à n’être exposées qu’à un <Tooltip tip="Serveur de ressources : serveur hébergeant des ressources protégées. Les serveurs de ressources acceptent les requêtes visant des ressources protégées et y répondent." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=resource+server">serveur de ressources</Tooltip>.

Pour empêcher l’inspection non autorisée des jetons d’accès, Auth0 prend en charge l’utilisation de jetons d’accès <Tooltip tip="JSON Web Token (JWT) : format standard d’ID Token (et souvent format de jeton d’accès) utilisé pour représenter des claims de manière sécurisée entre deux parties." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=JWT">JWT</Tooltip> imbriqués, où les informations d’accès sont signées dans un JWT, puis chiffrées et représentées au moyen de JSON Web Encryption (JWE). Les serveurs de ressources doivent à la fois déchiffrer ces jetons d’accès et vérifier la signature du payload JWT, tandis que ces informations restent opaques pour toute autre partie.

<div id="generate-rsa-key-pair">
  ## Générer une paire de clés RSA
</div>

Avant de configurer une API pour utiliser JWE, vous devez [générer une paire de clés RSA](/fr-CA/docs/secure/application-credentials/generate-rsa-key-pair).

La clé privée doit rester secrète. Téléversez la clé publique dans Auth0, encodée au format PEM, comme indiqué dans [Générer une paire de clés RSA](/fr-CA/docs/secure/application-credentials/generate-rsa-key-pair). Seul le serveur de ressources ou le serveur d’API peut accéder de manière sécurisée à la clé privée pour déchiffrer le jeton d’accès.

<div id="configure-jwe-for-an-api">
  ## Configurer JWE pour une API
</div>

<Tabs>
  <Tab title="Auth0 Dashboard">
    Utilisez [Auth0 Dashboard](https://manage.auth0.com/) pour configurer JWE pour votre API. Pour commencer, activez l’option **JSON Web Encryption (JWE)** sous **Token Settings** pour votre API.

    <Frame>
      <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/5xHKQ3rKN7DZogzD5qFDLp/8747f7f3d36c578e0f4622929cefb8e9/Access_Tokens_Settings_-_English.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=f54a4c12267ef55cbb1076f046bd3fcc" alt="" width="1202" height="881" data-path="docs/images/cdy7uua7fh8z/5xHKQ3rKN7DZogzD5qFDLp/8747f7f3d36c578e0f4622929cefb8e9/Access_Tokens_Settings_-_English.png" />
    </Frame>

    Lorsque vous y êtes invité, ajoutez une clé JSON Web Encryption (JWE) :

    * Entrez un nom convivial pour la repérer facilement.
    * Téléversez un certificat contenant la clé publique encodée au format PEM.
    * Sélectionnez l’algorithme de chiffrement.
    * (Facultatif) Entrez un identifiant de clé.

    Cliquez sur **Add** pour enregistrer la clé JWE, ce qui générera l’empreinte du certificat.
  </Tab>

  <Tab title="Management API">
    Utilisez [Auth0 Management API](https://auth0.com/docs/api/management/v2) pour configurer JWE pour un serveur de ressources ou un serveur d’API. Vous devez configurer JWE pour chaque API afin que chacune ait sa propre clé de chiffrement publique.

    La requête POST suivante configure une nouvelle API pour recevoir des jetons d’accès chiffrés :

    ```bash lines theme={null}
    curl -X POST --location "https://{domain}/api/v2/resource-servers" \
        -H "Authorization: Bearer {managementAccessToken}" \
        -H "Content-Type: application/json" \
        --data-raw '{
      "name": "{apiName}",
      "identifier": "{apiIdentifier}",
      "token_encryption": {
        "format": "compact-nested-jwe",
        "encryption_key":
        {
          "name": "{credentialName}",
          "pem": "{pem}",
          "alg": "{alg}",
          "kid": "{kid}"
        }
      }
    }'
    ```

    Le tableau suivant explique la signification des différents paramètres :

    | Paramètre        | Obligatoire? | Description                                                                                                                                                              |
    | ---------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
    | `apiName`        | Obligatoire  | Le nom de votre nouvelle API.                                                                                                                                            |
    | `apiIdentifier`  | Obligatoire  | L’identifiant unique de votre API. Il sera utilisé comme audience de votre jeton.                                                                                        |
    | `credentialName` | Facultatif   | Le nom de votre clé publique.                                                                                                                                            |
    | `pem`            | Obligatoire  | Clé publique encodée au format PEM.                                                                                                                                      |
    | `alg`            | Obligatoire  | L’algorithme de chiffrement doit être `RSA-OAEP-256`, `RSA-OAEP-384` ou `RSA-OAEP-512`.                                                                                  |
    | `kid`            | Facultatif   | L’identifiant utilisé pour écrire dans l’en-tête `kid` de votre jeton JWE. Il peut servir à identifier la clé utilisée pour le chiffrement pendant la rotation des clés. |

    La réponse contient la propriété `id`, qui identifie de façon unique le serveur de ressources. Elle contient aussi un champ `thumbprint_sha256` généré, qui peut être utilisé pour identifier la clé. Auth0 ne renverra pas les données de la clé après sa création initiale (dans ce cas-ci, votre PEM).

    Il existe plusieurs façons de générer `thumbprint_sha256`. Pour en savoir plus, consultez la [RFC 8705 OAuth 2.0 Mutual-TLS Client Authentication and Certificate-Bound Access Tokens](https://datatracker.ietf.org/doc/html/rfc8705#name-jwt-certificate-thumbprint-).

    Pour vous assurer d’avoir généré le bon `thumbprint_sha256`, vous pouvez utiliser l’exemple de code Node.js suivant pour extraire l’empreinte :

    ```javascript lines theme={null}
    const fs = require('fs');
    const crypto = require('crypto');

    const { calculateJwkThumbprint, exportJWK } = require('jose');

    const publicKeyObject = crypto.createPublicKey(fs.readFileSync('./my_cert.pem'));
    exportJWK(publicKeyObject).then((jwk) => {
      calculateJwkThumbprint(jwk, 'sha256').then((thumbprint) => {
        console.log(thumbprint);
      });
    });
    ```
  </Tab>
</Tabs>

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

* [JSON Web Encryption](/fr-CA/docs/secure/tokens/access-tokens/json-web-encryption)