Apprendre à sécuriser une Web API ASP.NET Core avec le STS IdentityServer4
Par Hinault Romaric

Le , par Hinault Romaric, Responsable .NET
Dans mon billet précédent sur IdentityServer4, nous avons vu comment mettre en place un service de gestion sécurisé de gestion (STS) en utilisant IdentityServer4. Ce dernier est prêt. Mais, il lui manque encore des ressources à sécuriser et des clients à gérer l’accès.

Dans cette partie, nous verrons comment sécuriser une API en utilisant IdentityServer. Pour qu’un client puisse consommer l’API, il devra au préalable s’authentifier auprès de IdentityServer, pour obtenir un jeton d’accès qu’il utilisera pour accéder à l’API.

1 - Création de l’API

La première chose à faire sera la création de l’API. Nous allons ajouter à notre solution une nouvelle application ASP.NET Core Web API :


Une fois l’application créée, nous allons ajouter un nouveau Controlleur d’API ayant pour nom SecureController, avec le code suivant :

Code C# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
[Route("api/[controller]")] 
    [Authorize] 
    public class SecureController : Controller 
    { 
        // GET: api/<controller> 
        [HttpGet] 
        public IActionResult Get() 
        { 
            return new JsonResult(from c in User.Claims select new { c.Type, c.Value }); 
        } 
    }

Vous remarquerez que notre contrôleur est décoré avec l’attribut [Authorize]. Ce qui veut dire que tout accès aux méthodes de cette classe est conditionné par l’obtention au préalable des droits. Pour un client ayant des accès, il pourra visualiser les informations de revendication (Claims) associée à son profile utilisateur.

2 - Configuration d’IdentityServer

Nous allons configurer IdentityServer afin que ce dernier puisse procéder à la validation du jeton de sécurité d’un client, afin de s’assurer que ce dernier provient d’un client de confiance ayant les autorisations nécessaires pour accéder à l’API.

Pour cela, nous allons dans un premier temps ajouter le package IdentityServer4.AccessTokenValidation.



Si vous utilisez Visual Studio Code, vous devez exécuter dans le terminal intégré la commande : dotnet add package IdentityServer4.AccessTokenValidation

Ensuite, nous allons éditer le fichier Startup.cs et modifier la méthode ConfigureServices :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 public void ConfigureServices(IServiceCollection services) 
        { 
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); 
  
            services.AddAuthentication("Bearer") 
            .AddIdentityServerAuthentication(options => 
            { 
                options.Authority = "https://localhost:5001"; 
                options.RequireHttpsMetadata = false; 
  
                options.ApiName = "testapi"; 
            }); 
  
        }

La méthode AddAuthentication() va permettre d’enregistrer auprès du conteneur d’IoC le service d’authentification en utilisant « Bearer » comme schéma par défaut. Cette configuration permet à notre application d’être basée sur une authentification par jeton (token authentication) basique. Avant d’accéder à notre API, le client sera donc obligé de passer un jeton d’autorisation dans l’entête HTTP.

La méthode AddIdentityServerAuthentication va permettre d’enregistrer le service qui permettra de valider le jeton fourni par le client par IdentityServer.

Vous devez aussi modifier la méthode Configure de la classe Startup pour ajouter au pipeline HTTP d’ASP.NET Core le middleware d’authentification :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void Configure(IApplicationBuilder app, IHostingEnvironment env) 
        { 
            if (env.IsDevelopment()) 
            { 
                app.UseDeveloperExceptionPage(); 
            } 
            else 
            { 
                app.UseHsts(); 
            } 
  
            app.UseHttpsRedirection(); 
            app.UseAuthentication(); 
            app.UseMvc(); 
  
        }

Pour finir, je vous recommande également de modifier les propriétés du projet pour que l’API soit toujours accessible via les adresses :

https://localhost:5003
et
http://localhost:5002


3 - Référencement de l’API dans IdentityServer

Pour que notre API soit protégée, nous devons la référencer auprès de IdentityServer comme ressource.

Pour cela, nous allons simplement éditer le fichier Config.cs dans l’application IdentityServer et ajouter notre API dans la liste des ApiResources :

Code C# : Sélectionner tout
1
2
3
4
5
6
7
 public static IEnumerable<ApiResource> GetApiResources() 
        { 
            return new List<ApiResource> 
            { 
                new ApiResource("testapi", "My Test API") 
            }; 
        }

Le premier paramètre est le nom de l’API. Il doit être identique au nom d’API défini dans les options lors de l’appel à AddIdentityServerAuthentication dans le projet d’API.

Si vous essayez d’accéder à l’adresse https://localhost:5003/api/secure dans votre navigateur, vous aurez l’erreur 401. Cela signifie qu’une authentification est nécessaire pour accéder à cette ressource.

NB : pour déboguer et exécuter vos deux applications simultanément. Vous pouvez ouvrir deux invites de commandes, chacune positionnée sur le répertoire de chaque projet et exécuter la commande dotnet run. Ou modifier les propriétés de votre solution Visual Studio pour définir les deux projets comme des projets de démarrage.

C’est tout pour cette partie. Dans la prochaine partie, nous verrons comment mettre en place le client et lui donner les autorisations nécessaires pour accéder à l’API.

Restez connecté !


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :
Contacter le responsable de la rubrique Accueil