Passer au contenu principal

​
Configurer les ORT

Les jetons d’actualisation en ligne (ORT) doivent être activés au niveau de l’API (serveur de ressources), dans Auth0 Dashboard ou à l’aide de la Management API.

​
Configurer à l’aide d’Auth0 Dashboard

  1. Accédez à Auth0 Dashboard > Applications > API.
  2. Sélectionnez l’API que vous souhaitez configurer.
  3. Dans l’onglet Paramètres, activez l’interrupteur Autoriser l’accès en ligne.
    Paramètres des API des applications du Dashboard : autoriser l’accès en ligne
  4. Sélectionnez Enregistrer.
Pour consulter et configurer les valeurs du délai d’inactivité et de la durée de vie maximale des sessions, consultez les paramètres Expiration de session du locataire. Pour en savoir plus, consultez Configurer la durée de vie de la session.

​
Configurer à l’aide de la Management API

Pour activer les ORT, envoyez une requête PATCH au point de terminaison Update Resource Server : 
curl --request PATCH \
  --url 'https://<YOUR_DOMAIN>/api/v2/resource-servers/<YOUR_RESOURCE_SERVER_ID>' \
  --header 'authorization: Bearer <YOUR_MANAGEMENT_API_TOKEN>' \
  --header 'content-type: application/json' \
  --data '{"allow_online_access": true}'
Pour vérifier la configuration, effectuez une requête GET au serveur de ressources : 
curl --request GET \
  --url 'https://<YOUR_DOMAIN>/api/v2/resource-servers/<YOUR_RESOURCE_SERVER_ID>' \
  --header 'authorization: Bearer <YOUR_MANAGEMENT_API_TOKEN>'
La réponse comprend la propriété allow_online_access : 
{
  "id": "resource-server-id",
  "name": "My API",
  "identifier": "https://my-api.example.com",
  "allow_online_access": true,
  ...
}

​
Obtenir un ORT

Pour obtenir un ORT, incluez le online_access scope dans votre requête d’autorisation en utilisant le flux du code d’autorisation ou le flux du code d’autorisation avec PKCE. 
https://<YOUR_DOMAIN>/authorize \
    audience=<YOUR_API_AUDIENCE> \
    scope=openid profile online_access \
    response_type=code \
    client_id=<YOUR_CLIENT_ID> \
    redirect_uri=<https://YOUR_APP/callback> \
    state=<OPAQUE_VALUE>
Une fois l’utilisateur authentifié, échangez le code d’autorisation contre des jetons : 
curl --request POST \
  --url 'https://<YOUR_DOMAIN>/oauth/token' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data grant_type=authorization_code \
  --data 'client_id=<YOUR_CLIENT_ID>' \
  --data 'code=<YOUR_AUTHORIZATION_CODE>' \
  --data 'redirect_uri=<https://YOUR_APP/callback>' \
  --data 'code_verifier=<YOUR_CODE_VERIFIER>'
La réponse du jeton comprend l’ORT : 
{
  "access_token": "eyJ...",
  "id_token": "eyJ...",
  "refresh_token": "ORT...",
  "token_type": "Bearer",
  "expires_in": 86400
}
Les ORT portent le préfixe ORT afin de les distinguer des jetons d’actualisation. Toutefois, vous devez considérer le jeton comme opaque et ne pas vous fier à sa structure interne.

​
Utiliser un ORT

Échangez l’ORT contre un nouveau jeton d’accès lorsque le jeton d’accès actuel a expiré ou est sur le point d’expirer : 
curl --request POST \
  --url 'https://<YOUR_DOMAIN>/oauth/token' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data grant_type=refresh_token \
  --data 'client_id=<YOUR_CLIENT_ID>' \
  --data 'refresh_token=<YOUR_ONLINE_REFRESH_TOKEN>'
La réponse contient un nouveau jeton d’accès. Si votre requête inclut un scope openid, la réponse contient un nouveau jeton d’identité: 
{
  "access_token": "eyJ...",
  "id_token": "eyJ...",
  "token_type": "Bearer",
  "expires_in": 86400
}
Auth0 n’émet pas de nouveau refresh_token et, comme les ORT ne sont pas renouvelés par rotation, vous continuez à utiliser le même ORT pour les échanges suivants.

​
Comportement de la prolongation de session

Chaque échange de jeton réussi :
  • Réinitialise le délai d’inactivité de la session : Le délai d’inactivité est rétabli à sa durée complète.
  • Ne prolonge pas la durée de vie absolue : L’expiration absolue de la session reste inchangée.
  • Maintient le SSO : D’autres applications peuvent obtenir des jetons par SSO tant que la session est active.

​
Révoquer un ORT

Lorsque vous révoquez un ORT, cela met fin à toute la session Auth0, et non seulement au jeton. Tous les ORT associés à cette session sont alors invalidés, et le SSO de l’utilisateur prend fin. 
curl --request POST \
  --url 'https://<YOUR_DOMAIN>/oauth/revoke' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data 'client_id=<YOUR_CLIENT_ID>' \
  --data 'token=<YOUR_ONLINE_REFRESH_TOKEN>'

​
Utiliser des ORT avec Actions

Vous pouvez utiliser des ORT avec Auth0 Actions et le déclencheur post-login. Avec Actions, vous pouvez :
  • Utiliser l’objet event.refresh_token pour déterminer si le jeton est un ORT.
  • Accéder à des données propres à la session à l’aide de l’objet event.session afin de prendre des décisions en fonction de l’état actuel de la session
exports.onExecutePostLogin = async (event, api) => {
  // Vérifier si le jeton est un jeton d'actualisation en ligne
  
  if (event.refresh_token?.access == 'online') {
    // Le jeton est un ORT, vous pouvez ensuite référencer event.session et api.session
    console.log('Exchanging Online Refresh Token bound to Session ID: ', event.session?.id);
    // Récupérer les métadonnées de session et les ajouter aux jetons
    // En supposant que les métadonnées de session ont été stockées au préalable
    const importantInformation = event.session?.metadata?.importantInformation;
    api.accessToken.setCustomClaim('info', importantInformation);
    api.idToken.setCustomClaim('info', importantInformation);
  }
};
Auth0 révoque l’intégralité de la session de l’utilisateur, et non seulement le jeton, lorsque la méthode api.refreshToken.revoke() est utilisée avec un ORT.

​
Pour en savoir plus