Passer au contenu principal
Pour utiliser les fonctionnalités Highly Regulated Identity, vous devez disposer d’un plan Enterprise avec l’option Highly Regulated Identity. Consultez Auth0 Pricing pour en savoir plus.
La requête d’autorisation sécurisée par JWT (JAR) est une extension du protocole OAuth 2.0 qui protège l’intégrité et l’authenticité des paramètres de la requête d’autorisation. En encapsulant les paramètres dans un JSON Web Token (JWT) signé, vous empêchez les intermédiaires de modifier ou de consulter des données de requête sensibles.

​
Prérequis

Avant d’utiliser JAR, vous devez :
  1. Générer une paire de clés RSA
  2. Enregistrer la clé publique en la téléversant dans Auth0 Dashboard, comme décrit dans Configurer les requêtes d’autorisation sécurisées par JWT

​
Fonctionnement

Au lieu de transmettre des paramètres comme scope ou redirect_uri en texte brut dans une URL, l’application cliente les regroupe dans un JSON Web Token (JWT) signé, qui sert d’objet de requête :
  • Signature : l’application cliente signe le JWT à l’aide de sa clé privée.
  • Vérification : le serveur d’autorisation Auth0 reçoit le JWT et en vérifie la signature à l’aide de la clé publique que vous avez enregistrée.
  • Traitement : s’il est valide, le serveur d’autorisation Auth0 extrait les paramètres. Si un paramètre existe à la fois dans le JAR et dans la chaîne de requête, la valeur du JAR prévaut.

​
Générer la requête JAR

Utilisez la bibliothèque JWT d’Auth0 pour générer un dans le langage de programmation de votre choix. L’en-tête du JWT indique à Auth0 quelle clé et quel algorithme utiliser pour la vérification. Il doit contenir les paramètres suivants :
  • alg : L’algorithme utilisé pour signer le JWT. Il doit être RS256, RS384 ou PS256.
  • typ : Le type de JWT. Il doit être jwt ou oauth-authz-req+jwt.
L’en-tête peut aussi contenir un champ kid qui identifie la clé utilisée pour signer le JWT. Si un kid est présent, Auth0 recherchera une clé publique enregistrée lors de la configuration de JAR dont l’ID de clé correspond, et utilisera cette clé pour vérifier la signature du JWT.

​
Payload

Le payload contient les paramètres d’autorisation. Il doit contenir les claims suivantes :
  • iss : doit contenir le client_id de votre application
  • aud : doit correspondre au Domaine de votre locataire, avec le protocole et une barre oblique à la fin. Par exemple, https://{YOUR_DOMAIN}.auth0.com/
Le JWT doit aussi contenir tous les paramètres obligatoires pour l’appel à /authorize. Par exemple :
  • client_id : doit aussi contenir le client_id de votre application
  • response_type : indique à Auth0 quel flux vous voulez utiliser. Utilisez code pour Authorization Code Grant Flow.
Le JWT peut contenir n’importe quel paramètre facultatif du demandé, comme audience, scope, state, redirect_uri, entre autres. De plus, le JWT peut contenir les claims facultatives suivantes :
  • iat : doit être une date numérique.
  • nbf : doit être une date numérique représentant un moment dans le passé.
  • exp : doit être une date numérique représentant un moment dans l’avenir.
  • jti : doit être une chaîne d’au plus 64 octets.

​
Exemple de code : générer et signer un JAR

L’exemple suivant en Node.js utilise la bibliothèque jsonwebtoken pour générer et signer un JAR : 
const jwt = require('jsonwebtoken');
const crypto = require("crypto");
const fs = require('fs');

const privateKey = fs.readFileSync('{PATH_TO_YOUR_PEM_FILE}');
const client_id = '{YOUR_CLIENT_ID}';
const nonce = crypto.randomBytes(16).toString('hex');

const requestObject = jwt.sign(
{
  iss: client_id,    
  aud: 'https://your_tenant.auth0.com/', // domaine de votre locataire
  client_id,
  response_type: "code",
  scope: "openid profile",
  redirect_uri : "https://myapp.com/callback", // URL de callback de votre application
  nonce
},
privateKey,
{
  keyid: '{YOUR_KID}', // valeur facultative de l'identifiant de clé (kid) de votre clé publique
  algorithm: 'RS256',
  header: {
    typ: 'oauth-authz-req+jwt',
  },
});

console.log(requestObject);

​
Appeler le point de terminaison d’autorisation

Vous pouvez envoyer le JAR au serveur d’autorisation Auth0 des façons suivantes :
  1. Requête JAR standard : transmettez le JWT signé sous forme de chaîne encodée pour l’URL dans le paramètre de requête.
  2. requête d’autorisation poussée : pour renforcer la sécurité et éviter les contraintes de longueur d’URL, utilisez PAR.

​
Requête JAR standard

Pour appeler le point de terminaison /authorize à l’aide d’une requête JAR standard :
  1. Ouvrez une nouvelle fenêtre de navigateur.
  2. Fournissez votre dans le paramètre client_id, et le JWT signé et encodé pour l’URL dans le paramètre request.
# macOS
open "https://{YOUR_DOMAIN}.auth0.com/authorize?client_id={YOUR_CLIENT_ID}&request={URL_ENCODED_JWT}"

# Windows
explorer "https://{YOUR_DOMAIN}.auth0.com/authorize?client_id={YOUR_CLIENT_ID}&request={URL_ENCODED_JWT}"

​
Requête d’autorisation poussée

Pour appeler le point de terminaison /authorize avec une requête d’autorisation poussée :
  1. Envoyez le JAR au point de terminaison /oauth/par au moyen d’une requête POST sur le canal arrière.
  2. Auth0 renverra un request_uri, que vous pourrez ensuite utiliser pour appeler le point de terminaison /authorize, comme dans un flux PAR standard.
La requête cURL suivante utilise PAR et JAR conjointement : 
curl --location 'https://{YOUR_DOMAIN}.auth0.com/oauth/par' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'client_id={YOUR_CLIENT_ID}' \
--data-urlencode 'client_secret={YOUR_CLIENT_SECRET}' \
--data-urlencode 'request={JWT}'

​
En savoir plus