Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

IdentityServer4 : utiliser ASP.NET Core Identity pour l'authentification,
Un billet de blog d'Hinault Romaric

Le , par Hinault Romaric

0PARTAGES

IdentityServer est une solution open source .NET de gestion d’identité et de contrôle d’accès. Il repose sur les protocoles OpenID Connect et OAuth 2.0.

IdentityServer peut être utilisé par les entreprises pour mettre en place une solution pour :

  • la protection de leurs ressources ;
  • l’authentification des utilisateurs via une base de données ou des fournisseurs externes d’identité (Microsoft, Google, Facebook, etc.) ;
  • la gestion des sessions et la fédération (single sign-on) ;
  • la génération des jetons pour les clients ;
  • la validation des jetons et bien plus.


Ce billet est le dixième que j’écris sur le sujet. Les billets précédents ont porté sur les points suivants :

Mise en place d’un STS avec IdentityServer4 pour sécuriser ses applications .NET

Sécurisation d’une Web API ASP.NET Core avec le STS IdentityServer4

IdentityServer4 : création et configuration du Client pour accéder à une Web API ASP.NET Core sécurisée

IdentityServer4 : Authentification d’un utilisateur avec OpenID Connect

IdentityServer4 : création et configuration d’un client utilisant OpenID Connect

IdentityServer4 : Autoriser l’application MVC à accéder à l’API, via le jeton obtenu du STS

IdentityServer4 : prise en charge du provider tiers Microsoft pour l'authentification

IdentityServer4 : prise en charge du provider tiers Github pour l'authentification

IdentityServer4 : persistance des données de configuration avec EntityFramework Core

Dans l'un des billets précédents, nous avons vu comment utiliser OpenID et permettre à l’utilisateur de s’authentifier via un formulaire. Pour la mise en place de la fenêtre de connexion, de déconnexion, etc., nous avons utilisé un Quickstart offert par IdentityServer. Ce modèle repose sur TestUserStore, qui nous permet de définir et charger nos utilisateurs depuis un fichier inclus dans le projet.

Maintenant, nous voulons que les utilisateurs soient stockés dans une base de données et que des interfaces soient disponibles pour l’enregistrement d’un nouvel utilisateur, la connexion, la gestion de son compte, etc.
Toutefois, nous ne voulons non plus développer ces fonctionnalités à partir de zéro, pourtant ASP.NET Core nous offre le nécessaire pour la gestion d’identité.

À propos de ASP.NET Core Identity

ASP.NET Core Identity est un système de gestion d’Identité qui ajoute à une application ASP.NET Core des fonctionnalités de connexion, gestion de compte, modification de mot de passe, réinitialisation de mot de passe, etc.
ASP.NET Core Identity est configuré par défaut pour utiliser EntityFramework Core pour assurer la persistance des données. Les informations d’Identité (nom d’utilisateur, mot de passe, données de profil) peuvent être stockées dans toute base de données supportée par EntityFramework Core.

Avec la version 2.1 de ASP.NET Core, ASP.NET Core Identity est désormais disponible comme une bibliothèque de classes Razor. Ce qui signifie qu’il est désormais possible d’utiliser le scaffolding pour générer le code de gestion d’identité dans une application existante.

ASP.NET Core Identity et IdentityServer4

IdentityServer a été conçu pour être extensible et flexible. De fait, il est possible d’utiliser IdentityServer tout en déléguant le stockage de données et la gestion des comptes à ASP.NET Core Identity. Voyons comment procéder.

Intégration de ASP.NET Core Identity au projet

Reprenons notre projet précédent. Vous pouvez le télécharger sur mon compte GitHub à l’adresse suivante : https://github.com/hinault/identitys...ee/aspnetcore2.

Pour la persistante, nous allons utiliser une base de données SQLite. La première chose à faire sera d’ajouter le package correspondant : Microsoft.EntityFrameworkCore.Sqlite.

L’étape suivante sera la génération du code pour Identity. Pour cela, vous devez faire un clic droit sur votre projet, aller sur Ajouter, ensuite cliquer sur « Nouvel élément généré automatiquement… ».



Dans la liste des modèles installés, vous devez sélectionner Identité et cliquer sur Ajouter. Une fenêtre va s’afficher permettant de sélectionner les fichiers à générer (AccessDenied, ForgotPassword, Login, Logout, ChangePassoword, Register, Index, ResetPassword).

Ensuite, nous devons définir le DataContext que nous souhaitons utiliser pour la persistance des données. Nous devons en créer un nouveau. Vous devez cliquer sur le « + » dans la ligne correspondante puis sur Ajouter.

Nous allons utiliser SQLite comme base de données. Vous devez donc cocher la case « Use SQLite instead of SQL Server ».

Nous allons également ajouter une nouvelle classe utilisateur ayant pour nom « ApplicationUser ». Une fois cela effectué, cliquez sur Ajouter.


Le code permettant d’intégrer la gestion d’identité dans votre projet est généré dans le dossier Areas/Identity. Ce code a été développé en utilisant Razor Pages. Il faut noter qu’ASP.NET Core MVC, Web API et Razor Page peuvent cohabiter sans aucun problème dans le même projet.


La configuration des services d’Identité se trouve dans le fichier Areas/Identity/IdentityHostingStartup.cs. Je ne vais pas m’attarder sur les détails d’implémentation de ASP.NET Core Identity. Pour en savoir plus sur le sujet, vous pouvez consulter le tutoriel suivant.

Génération de la base de données

Nous allons utiliser la migration pour générer la base de données SQLite. Dans la console de gestion de package de Visual Studio, vous devez exécuter les deux commandes suivantes :

Code : Sélectionner tout
1
2
Add-Migration CreateIdentitySchema 
Update-Database
Si vous voulez le faire en utilisant l’invite de commande, vous devez exécuter les deux commandes suivantes :

Code : Sélectionner tout
1
2
dotnet ef migrations add CreateIdentitySchema 
dotnet ef database update
Un fichier AspNetCoreIdentityServer.db sera créé à la racine de votre projet.

Configuration d’IdentityServer pour utiliser ASP.NET Core Identity

À cette étape, nous allons dans un premier temps ajouter à notre projet le package IdentityServer4.AspNetIdentity :


Une fois le package installer, nous allons éditer le fichier Startup.cs et remplacer AddTestUsers(Config.GetUsers()) par AddAspNetIdentity(). Il faudra également ajouter le service suivant AddInMemoryPersistedGrants().

Nous devons également spécifier les pages de connexion et déconnexion qui seront dorénavant utilisées :

Code c# : Sélectionner tout
1
2
3
4
5
services.AddIdentityServer(options => 
        { 
            options.UserInteraction.LoginUrl = "/Identity/Account/Login"; 
            options.UserInteraction.LogoutUrl = "/Identity/Account/Logout"; 
        })

Le code complet de la méthode ConfigureServices devient ceci :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void ConfigureServices(IServiceCollection services) 
        { 
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); 
  
            //configure identity server with in-memory stores, keys, clients and resources 
            services.AddIdentityServer(options => 
                    { 
                        options.UserInteraction.LoginUrl = "/Identity/Account/Login"; 
                        options.UserInteraction.LogoutUrl = "/Identity/Account/Logout"; 
                    }) 
                   .AddDeveloperSigningCredential() 
                    .AddInMemoryPersistedGrants() 
                   .AddInMemoryIdentityResources(Config.GetIdentityResources()) 
                    .AddInMemoryApiResources(Config.GetApiResources()) 
                   .AddInMemoryClients(Config.GetClients()) 
                    .AddAspNetIdentity<ApplicationUser>(); 
        }

Vous devez modifier par défaut la configuration de ASP.NET Core Identity pour définir l’entité utilisée pour la gestion de rôle. Pour cela, devez éditer le fichier IdentityHostingStartup.cs et changer services.AddDefaultIdentity() par services.AddIdentity().

Le code de cette classe devient ce qui suit :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
public void Configure(IWebHostBuilder builder) 
        { 
            builder.ConfigureServices((context, services) => { 
                services.AddDbContext<AspNetCoreIdentityServerContext>(options => 
                    options.UseSqlite( 
                        context.Configuration.GetConnectionString("AspNetCoreIdentityServerContextConnection"))); 
  
                services.AddDefaultIdentity<ApplicationUser>() 
                    .AddEntityFrameworkStores<AspNetCoreIdentityServerContext>() 
                    .AddDefaultTokenProviders() 
                     .AddDefaultUI(); 
            }); 
        }

Sauvegardez et exécutez votre application. Lorsque vous allez essayer d’accéder à une ressource sécurisée, vous verrez le formulaire de Login d’ASP.NET Core Identity.



Si nous nous connectons avec l’application MVCAppClient une fois un utilisateur créé, nous verrons ce qui suit :


C’est tout pour cette partie. Dans la prochaine partie, nous verrons comment utiliser notre propre service d'accès au données pour authentifier un utilisateur et comment définir les revendications de ce dernier dans ce cas.

Une erreur dans cette actualité ? Signalez-le nous !