Appeler une API de fournisseur d’identité

Lorsque vous authentifiez avec succès un utilisateur auprès d’un fournisseur d’identité externe (IdP), tel que Facebook ou GitHub, l’IdP inclut souvent un jeton d’accès dans le profil utilisateur qu’il renvoie à Auth0.

Vous pouvez récupérer et utiliser ce jeton pour appeler l’API de l’IdP.

La procédure à suivre diffère selon que votre code s’exécute dans le système dorsal ou dans le système du côté client.

• Si votre code s’exécute dans le système dorsal, nous pouvons supposer que votre serveur est fiable pour stocker des secrets en toute sécurité (comme vous le verrez, nous utilisons un secret dans le scénario du système dorsal). Si c’est le cas, passez à la section système dorsal de cet article.

• Si votre code s’exécute dans le système du côté client (par exemple, il s’agit d’une application à page unique, d’une application native de bureau ou d’une application mobile), votre application ne peut pas conserver les informations d’identification de manière sécurisée et doit suivre une autre approche. Dans ce cas, passez à la section système du côté client de cet article.

Lorsque vous authentifiez un utilisateur, l’IdP inclut souvent un jeton d’accès dans le profil utilisateur qu’il renvoie à Auth0.

Pour des raisons de sécurité et de conformité, Auth0 n’envoie pas ce jeton à votre application dans le cadre du profil utilisateur. Pour l’obtenir, vous devez accéder à Management API d’Auth0 et récupérer le profil complet de l’utilisateur.

1. Obtenez un jeton d’accès qui vous permet d’appeler la Management API d’Auth0.

2. Appelez le point de terminaison Obtenir les utilisateurs selon leurs ID du Management API d’Auth0 à l’aide du jeton d’accès obtenu à la première étape. Ce point final renvoie le profil complet de l’utilisateur, qui contient le jeton d’accès à l’IdP.

3. Extraire le jeton d’accès de l’IdP de la réponse et l’utiliser pour appeler l’API de l’IdP.

Vous aurez besoin d’un jeton d’accès pour appeler la Management API.

Si c’est la première fois que vous demandez un Jeton Management APIv2, vous devrez créer et configurer une application qui peut être utilisée pour appeler Management API :

1. Naviguez vers Auth0 Dashboard > Applications > API, et sélectionnez Auth0 Management API.

2. Sélectionnez la vue Explorateur d’API et cliquez sur Créer et autoriser une application d’essai.

Cela créera une nouvelle application et accordera toutes les permissions de Management API, ce qui signifie que les jetons générés pour cette application pourront accéder à tous les points de terminaison du Management API.

Pour accorder ou supprimer des permissions de Management API d’Auth0 enregistrée, sélectionnez la vueMachine to Machine Applications (Applications de communication entre machines) :

Vous avez maintenant terminé la configuration et êtes prêt à obtenir votre jeton de Management API :

1. À partir de la Management API d’Auth0 enregistrée , sélectionnez la vueEssai.

2. Choisissez votre application dans le menu déroulant Application pour pré-remplir les extraits prêts à l’emploi avec des variables personnalisées.

3. Choisissez le langage de votre choix pour l’extrait, puis copiez-le et exécutez-le.

4. Extrayez la propriété access_token de la réponse. C’est ce que vous utiliserez pour accéder à Management API.

Par défaut, le jeton que vous avez reçu expire dans 24 heures (86 400 secondes). Pour changer cela :

1. Naviguez vers Auth0 Dashboard > Applications > API, et sélectionnez Auth0 Management API.

2. Sélectionnez la vue Paramètres, localisez le champ Expiration du jeton (secondes), saisissez une nouvelle valeur et cliquez sur Enregistrer. La valeur maximale que vous pouvez définir est de 2 592 000 secondes (30 jours), mais nous vous recommandons de conserver la valeur par défaut.

Le prochain jeton que vous générerez utilisera le délai d’expiration mis à jour.

Pour obtenir le profil d’un utilisateur, appelez le point de terminaison Obtenir un utilisateur du Management API en utilisant le jeton d’accès que vous avez extrait dans la section précédente.

curl --request GET \
  --url 'https://{yourDomain}/api/v2/users/%7BuserId%7D' \
  --header 'authorization: Bearer {yourAccessToken}'

var client = new RestClient("https://{yourDomain}/api/v2/users/%7BuserId%7D");
var request = new RestRequest(Method.GET);
request.AddHeader("authorization", "Bearer {yourAccessToken}");
IRestResponse response = client.Execute(request);

package main

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

func main() {

	url := "https://{yourDomain}/api/v2/users/%7BuserId%7D"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "Bearer {yourAccessToken}")

	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.get("https://{yourDomain}/api/v2/users/%7BuserId%7D")
  .header("authorization", "Bearer {yourAccessToken}")
  .asString();

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

var options = {
  method: 'GET',
  url: 'https://{yourDomain}/api/v2/users/%7BuserId%7D',
  headers: {authorization: 'Bearer {yourAccessToken}'}
};

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

#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"authorization": @"Bearer {yourAccessToken}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/api/v2/users/%7BuserId%7D"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}/api/v2/users/%7BuserId%7D",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: Bearer {yourAccessToken}"
  ],
]);

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

headers = { 'authorization': "Bearer {yourAccessToken}" }

conn.request("GET", "/{yourDomain}/api/v2/users/%7BuserId%7D", headers=headers)

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

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

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

url = URI("https://{yourDomain}/api/v2/users/%7BuserId%7D")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Bearer {yourAccessToken}'

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

import Foundation

let headers = ["authorization": "Bearer {yourAccessToken}"]

let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/api/v2/users/%7BuserId%7D")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

Remplacer ces valeurs :

• {userId} : ID de l’utilisateur pour lequel vous souhaitez appeler l’API de l’IdP.

• {yourAccessToken} : Jeton d’accès que vous avez extrait dans la section précédente.

Vous pouvez trouver le jeton d’accès utilisé pour appeler l’API de l’IdP dans le tableau identities de l’utilisateur : user.identities[0].access_token.

Dans la plupart des cas, l’utilisateur n’aura qu’une seule identité, mais si l’utilisateur s’est connecté plusieurs fois via différentes connexions et que vous avez utilisé l’association de comptes, il peut y en avoir plusieurs.

Dans cet exemple de réponse, nous voyons que notre utilisateur n’a qu’une seule identité : google-oauth2.

{
  "email": "john.doe@test.com",
  "email_verified": true,
  "name": "John Doe",
  "given_name": "John",
  "family_name": "Doe",
  "picture": "https://myavatar/photo.jpg",
  "gender": "male",
  "locale": "en",
  "updated_at": "2017-03-15T07:14:32.451Z",
  "user_id": "google-oauth2|111199914890750704174",
  "nickname": "john.doe",
  "identities": [
    {
      "provider": "google-oauth2",
      "access_token": "ya29.GlsPBCS6ahokDlgCYnVLnDKNE71HBXPEzNhAPoKJLAGKDSe1De3_xclahNcdZXoU-26hCpa8h6240TV86dtaEQ4ZWoeeZduHDq_yeu9QyQqUr--S9B2CR9YJrLTD",
      "expires_in": 3599,
      "user_id": "111199914890750704174",
      "connection": "google-oauth2",
      "isSocial": true
    }
  ],
  "created_at": "2017-03-15T07:13:41.134Z",
  "last_ip": "127.0.0.1",
  "last_login": "2017-03-15T07:14:32.451Z",
  "logins_count": 99
}

Vous êtes maintenant prêt à appeler l’API de l’IdP. Veuillez vous référer à la documentation de l’IdP pour plus de détails sur la façon de procéder.

Si vous travaillez avec une application publique (application à page unique, bureau natif ou application mobile), vous êtes au bon endroit.

Lorsque vous travaillez avec une application du côté client, le processus d’appel des IdP API diffère du processus du système dorsal, car les applications du côté client sont des applications publiques qui ne peuvent pas conserver les informations d’identification en toute sécurité. Étant donné que le code d’une application à page unique peut être consulté et modifié, et que les applications natives/mobiles peuvent être décompilées et inspectées, on ne peut pas leur faire confiance pour conserver des informations sensibles telles que des clés secrètes ou des mots de passe.

En particulier, elles ne peuvent pas contenir en toute sécurité le Secret du client pour l’application de communication entre machines, laquelle vous utilisez pour appeler /oauth/token au cours de la première étape du processus dorsal.

Au lieu de cela, vous devez construire un proxy pour votre système dorsal et l’exposer à votre application en tant qu’API.

Tout d’abord, vous allez construire un processus dans votre programme dorsal qui mettra en œuvre les étapes incluses dans la section du système dorsal de cet article, et l’exposer à votre application en tant qu’API.

Vous appellerez l’API de l’IdP à partir du même processus dorsal, de sorte que le jeton d’accès ne soit jamais exposé à votre application publique.

Ensuite, vous appelerez l’API de votre proxy à partir de votre application publique en utilisant le Flux de code d’autorisation avec Proof Key for Code Exchange (PKCE).