Révoquer les jetons d'actualisation

Vous pouvez révoquer les jetons d’actualisation si ceux-ci sont compromis. Auth0 s’occupe de révoquer les jetons comme s’ils avaient été potentiellement compromis par des entités malveillantes.

You can also use refresh token rotation so that every time a client exchanges a refresh token to get a new access token, a new refresh token is also returned. Par conséquent, vous n’avez plus de jeton d’actualisation de durée de vie plus longue, lequel pourrait offrir un accès illégitime aux ressources. Puisque les jetons d’actualisation sont constamment échangés et invalidés, le risque est diminué.

Vous pouvez révoquer un jeton d’actualisation de plusieurs manières :

• Dans le Dashboard

• Envoyer une demande au point de terminaison /oauth/revoke d’Authentication API

• Envoyer une demande au point de terminaison /api/v2/device-credentials de Management API

Une autorisation permet à une application d’accéder à une ressource sur une autre entité sans exposer les identifiants de l’utilisateur. Les jetons sont délivrés dans le contexte d’une autorisation, et lorsqu’une autorisation est révoquée, tous les jetons délivrés dans le contexte de cette autorisation le sont également. En revanche, la révocation d’un jeton n’entraîne pas nécessairement la révocation de l’autorisation.

Vous pouvez choisir le comportement de révocation dans les paramètres du locataire du tableau de bord lorsqu’un appareil est dissocié d’un utilisateur dans Auth0, en utilisant Dashboard ou Management API.

1. Rendez-vous à Dashboard > Paramètres du locataire > Avancés et faites défiler jusqu’à la section Paramètres.

2. Activez ou désactivez l’option La révocation du jeton d’actualisation supprime l’autorisation en fonction de la manière dont vous souhaitez que la révocation fonctionne.

   1. Activez cette option pour supprimer l’autorisation sous-jacente lorsque vous révoquez le jeton d’actualisation. Chaque demande de révocation invalide non seulement le jeton en question, mais aussi tous les autres jetons basés sur la même autorisation. Cela signifie que tous les jetons d’actualisation émis pour le même utilisateur, la même application et la même audience seront révoqués.

   2. Désactivez l’option pour conserver l’autorisation sous-jacente lorsque vous révoquez le jeton d’actualisation. Lorsqu’un appareil est dissocié, seul le jeton d’actualisation associé est révoqué, ce qui laisse l’autorisation intacte.

Vous pouvez utiliser Dashboard pour révoquer l’accès autorisé d’un utilisateur à l’application qui a émis le jeton. Cela rend le jeton d’actualisation invalide, ce qui est d’un point de vue fonctionnel identique à la révocation du jeton lui-même.

1. Allez à Dashboard > Gestion des utilisateurs > Utilisateurs et cliquez sur le nom de l’utilisateur à afficher.

2. Sélectionnez l’onglet Applications autorisées. Cette page répertorie toutes les applications auxquelles l’utilisateur est autorisé à accéder.

3. Pour révoquer l’accès de l’utilisateur à une application autorisée, et donc invalider le jeton d’actualisation, cliquez sur Révoquer.

Pour révoquer un jeton d’actualisation, envoyez une demande POST à https://{yourDomain}/oauth/revoke.

Le point de terminaison /oauth/revoke révoque toute l’autorisation, pas seulement un jeton en particulier. Utilisez le point de terminaison /api/v2/device-credentials pour révoquer les jetons d’actualisation. L’API valide d’abord les identifiants de l’application, puis vérifie si le jeton a été fourni à l’application qui fait la demande de révocation. Si cette validation échoue, la demande est refusée et l’application est informée de l’erreur. Ensuite, l’API invalide le jeton. L’invalidation a lieu immédiatement et le jeton ne peut plus être utilisé après la révocation. Chaque demande de révocation invalide tous les jetons qui ont été émis pour la même autorisation.

curl --request POST \
  --url 'https://{yourDomain}/oauth/revoke' \
  --header 'content-type: application/json' \
  --data '{ "client_id": "{yourClientId}", "client_secret": "{yourClientSecret}", "token": "{yourRefreshToken}" }'

var client = new RestClient("https://{yourDomain}/oauth/revoke");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{ \"client_id\": \"{yourClientId}\", \"client_secret\": \"{yourClientSecret}\", \"token\": \"{yourRefreshToken}\" }", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://{yourDomain}/oauth/revoke"

	payload := strings.NewReader("{ \"client_id\": \"{yourClientId}\", \"client_secret\": \"{yourClientSecret}\", \"token\": \"{yourRefreshToken}\" }")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://{yourDomain}/oauth/revoke")
  .header("content-type", "application/json")
  .body("{ \"client_id\": \"{yourClientId}\", \"client_secret\": \"{yourClientSecret}\", \"token\": \"{yourRefreshToken}\" }")
  .asString();

var axios = require("axios").default;

var options = {
  method: 'POST',
  url: 'https://{yourDomain}/oauth/revoke',
  headers: {'content-type': 'application/json'},
  data: {
    client_id: '{yourClientId}',
    client_secret: '{yourClientSecret}',
    token: '{yourRefreshToken}'
  }
};

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

#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"client_id": @"{yourClientId}",
                              @"client_secret": @"{yourClientSecret}",
                              @"token": @"{yourRefreshToken}" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/oauth/revoke"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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];

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://{yourDomain}/oauth/revoke",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "{ \"client_id\": \"{yourClientId}\", \"client_secret\": \"{yourClientSecret}\", \"token\": \"{yourRefreshToken}\" }",
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

import http.client

conn = http.client.HTTPSConnection("")

payload = "{ \"client_id\": \"{yourClientId}\", \"client_secret\": \"{yourClientSecret}\", \"token\": \"{yourRefreshToken}\" }"

headers = { 'content-type': "application/json" }

conn.request("POST", "/{yourDomain}/oauth/revoke", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://{yourDomain}/oauth/revoke")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{ \"client_id\": \"{yourClientId}\", \"client_secret\": \"{yourClientSecret}\", \"token\": \"{yourRefreshToken}\" }"

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

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "client_id": "{yourClientId}",
  "client_secret": "{yourClientSecret}",
  "token": "{yourRefreshToken}"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/oauth/revoke")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()

Où :

L’application doit correspondre à celle pour laquelle le jeton d’actualisation a été émis.

Pour les applications qui ne peuvent pas garder le secret du client en sécurité (comme les applications natives), le point de terminaison /oauth/revoke prend en charge l’accès sans secret client. Toutefois, la propriété tokenEndpointAuthMethod de l’application elle-même doit être définie sur none. Vous pouvez changer la valeur tokenEndpointAuthMethod, dans Dashboard > Applications > Applications, ou avec Management API.

Si la demande est valide, le jeton d’actualisation est révoqué et la réponse est HTTP 200, avec un corps de réponse vide. Dans le cas contraire, le corps de la réponse contient le code d’erreur et la description.

{
      "error": "invalid_request|invalid_client",
      "error_description": "Description of the error"
    }

Réponses possibles :

Pour révoquer un jeton d’actualisation à l’aide d’Auth0 Management API, vous avez besoin de l’id du jeton d’actualisation que vous souhaitez révoquer. Pour obtenir la liste des jetons d’actualisation existants, appelez le point de terminaison/api/v2/device-credentials, en indiquant type=refresh_token et user_id avec un jeton d’accès contenant la permission read:device_credentials. Pour limiter les résultats, vous pouvez également indiquer le client_id associé au jeton (s’il est connu).

GET https://{yourDomain}/api/v2/device-credentials?
      type=refresh_token
      &client_id=
      &user_id=
    
    {
      "Authorization":   "Bearer {your_access_token}"
    }

Le corps de la réponse:

[
      {
    "id": "dcr_dFJiaAxbEroQ5xxx",
    "device_name": "my-device" // the value of 'device' provided in the /authorize call when creating the token
      }
    ]

Pour révoquer un jeton d’actualisation, appelez le point de terminaison /api/v2/device-credentials avec un jeton d’accès contenant la permission delete:device_credentials et la valeur de l’ID obtenu plus haut :

DELETE https://{yourDomain}/api/v2/device-credentials/{id}
    
    {
      "Authorization":   "Bearer {your_access_token}"
    }

La réponse sera HTTP 204: The credential no longer exists.

Avec le flux d’autorisation d’appareil, la seule manière de forcer un appareil à se réautoriser consiste à révoquer le jeton d’actualisation attribué à cet appareil. Consultez Dissocier les appareils des utilisateurs pour en savoir plus. L’appareil ne sera pas obligé de se réautoriser tant que le jeton d’accès actuel n’aura pas expiré et que l’application n’aura pas essayé d’utiliser le jeton d’actualisation révoqué.

Avec la rotation des jetons d’actualisation, si un jeton déjà invalidé est utilisé, tous les autres jetons d’actualisation émis après qu’il ait été invalidé seront immédiatement révoqués, exigeant ainsi une nouvelle authentification de la part de l’utilisateur final.

• Utilisez le point de terminaison/oauth/revoke d’Authentication API pour révoquer un jeton d’actualisation. Ce point de terminaison ne supprime pas l’autorisation sous-jacente. Vous pouvez modifier ce comportement pour supprimer également l’autorisation sous-jacente dans Dashboard : Dashboard > Paramètres du locataire > Avancés. Faites défiler jusqu’à Paramètres et activez l’option La révocation du jeton d’actualisation supprime l’autorisation.

• Utilisez le point de terminaison/api/v2/device-credentials de Management API pour révoquer des jetons d’actualisation.

• Obtenir des jetons d’actualisation
• Utilisation des jetons d’actualisation
• Rotation des jetons d’actualisation
• Configurer le délai d’expiration du jeton d’actualisation