Présentation de Identity sur ASP.NET Core

Par Rick Anderson

ASP.NET Core Identity :

• Est une API qui prend en charge la fonctionnalité de connexion par interface utilisateur.
• Gère les utilisateurs, les mots de passe, les données de profil, les rôles, les revendications, les jetons, la confirmation par e-mail, etc.

Les utilisateurs peuvent créer un compte avec les informations de connexion stockées dans Identity ou utiliser un fournisseur de connexion externe. Les fournisseurs de connexion externes pris en charge incluent Facebook, Google, Compte Microsoft et Twitter.

Pour plus d’informations sur la façon d’exiger l’authentification globale de tous les utilisateurs, consultez la section Exiger des utilisateurs authentifiés.

Le code source Identity est disponible sur GitHub. Générez automatiquement des modèles Identity et affichez les fichiers générés pour passer en revue l’interaction du modèle avec Identity.

Identity est généralement configuré à l’aide d’une base de données SQL Server pour stocker les noms d’utilisateur, les mots de passe et les données de profil. Vous pouvez également utiliser un autre magasin persistant, par exemple Stockage Table Azure.

Dans cette rubrique, vous allez apprendre à utiliser Identity pour inscrire, connecter et déconnecter un utilisateur. Remarque : les modèles traitent le nom d’utilisateur et l’adresse e-mail comme étant identiques pour les utilisateurs. Pour obtenir des instructions plus détaillées sur la création d’applications qui utilisent Identity, consultez la section Étapes suivantes.

ASP.NET Core Identity n’est pas lié à la plateforme d’identités Microsoft. La plateforme d’identités Microsoft est :

• Une évolution de la plateforme de développement Azure Active Directory (Azure AD).
• Une solution d’identité alternative pour l’authentification et l’autorisation dans les applications ASP.NET Core.

ASP.NET Core Identity ajoute la fonctionnalité de connexion de l’interface utilisateur aux applications web ASP.NET Core. Pour sécuriser les API web et SPA, utilisez l’une des options suivantes :

• Microsoft Entra ID
• Azure Active Directory B2C (Azure AD B2C)
• Serveur Identity Duende

Duende Identity Server est un framework OpenID Connect et OAuth 2.0 pour ASP.NET Core. Duende Identity Server active les fonctionnalités de sécurité suivantes :

• Authentification en tant que service (AaaS)
• Authentification/déconnexion unique (SSO) sur plusieurs types d’applications
• Contrôle d’accès pour les API
• Federation Gateway

Important

Duende Software peut vous demander de payer des frais de licence pour une utilisation en production de Duende Identity Server. Pour plus d’informations, consultez Migrer de ASP.NET Core 5.0 vers 6.0.

Pour plus d’informations, consultez la documentation Duende Identity Server (site web de Duende Software).

Affichez ou téléchargez l’exemple de code (procédure de téléchargement).

Créer une application web avec authentification

Créez un projet d’application web ASP.NET Core avec des comptes d’utilisateur individuels.

Visual Studio

• Sélectionnez le modèle Application web ASP.NET Core. Nommez le projet WebApp1 pour que l’espace de noms soit le même que le téléchargement du projet. Cliquez sur OK.
• Dans l’entrée Type d’authentification, sélectionnez Comptes d’utilisateur individuels.

CLI .NET Core

dotnet new webapp --auth Individual -o WebApp1

La commande précédente crée une application web Razor à l’aide de SQLite. Pour créer l’application web avec LocalDB, exécutez la commande suivante :

dotnet new webapp --auth Individual -uld -o WebApp1

Le projet généré fournit ASP.NET Core Identity en tant que bibliothèque de classes Razor. La bibliothèque de classes IdentityRazor expose les points de terminaison avec la zone Identity. Par exemple :

• /Identity/Account/Login
• /Identity/Account/Logout
• /Identity/Account/Manage

Appliquer des migrations

Appliquez les migrations pour initialiser la base de données.

Visual Studio

Exécutez la commande suivante dans la console du Gestionnaire de package (PMC) :

Update-Database

CLI .NET Core

Les migrations ne sont pas nécessaires à cette étape en cas d’utilisation de SQLite.

Si dotnet ef n’a pas été installé, installez-le en tant qu’outil global :

  dotnet tool install --global dotnet-ef

Pour plus d’informations sur la CLI pour EF Core, consultez informations de référence sur les outils EF Core de la CLI .NET.

Remarque

Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option. Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.

Pour LocalDB, exécutez la commande suivante :

dotnet ef database update

Tester l’inscription et la connexion

Exécutez l’application et inscrivez un utilisateur. Selon la taille de votre écran, vous devrez peut-être sélectionner le bouton bascule de navigation pour afficher les liens d’inscription et de connexion.

Afficher la base de données Identity

Visual Studio

• Dans le menu Affichage, sélectionnez Explorateur d’objets SQL Server (SSOX).
• Accédez à (localdb)MSSQLLocalDB(SQL Server 13). Cliquez avec le bouton droit sur dbo.AspNetUsers>Afficher les données :

CLI .NET Core

Vous pouvez télécharger de nombreux outils tiers pour gérer et afficher une base de données SQLite, par exemple DB Browser for SQLite.

Configurer les services Identity

Les services sont ajoutés dans Program.cs. Le modèle classique consiste à appeler les méthodes dans l’ordre suivant :

1. Add{Service}
2. builder.Services.Configure{Service}

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using WebApp1.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();
builder.Services.AddRazorPages();

builder.Services.Configure<IdentityOptions>(options =>
{
    // Password settings.
    options.Password.RequireDigit = true;
    options.Password.RequireLowercase = true;
    options.Password.RequireNonAlphanumeric = true;
    options.Password.RequireUppercase = true;
    options.Password.RequiredLength = 6;
    options.Password.RequiredUniqueChars = 1;

    // Lockout settings.
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
    options.Lockout.MaxFailedAccessAttempts = 5;
    options.Lockout.AllowedForNewUsers = true;

    // User settings.
    options.User.AllowedUserNameCharacters =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
    options.User.RequireUniqueEmail = false;
});

builder.Services.ConfigureApplicationCookie(options =>
{
    // Cookie settings
    options.Cookie.HttpOnly = true;
    options.ExpireTimeSpan = TimeSpan.FromMinutes(5);

    options.LoginPath = "/Identity/Account/Login";
    options.AccessDeniedPath = "/Identity/Account/AccessDenied";
    options.SlidingExpiration = true;
});

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseMigrationsEndPoint();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();

app.Run();

Le code précédent configure Identity avec les valeurs d’option par défaut. Les services sont accessibles à l’application au moyen de l’injection de dépendances.

Identity est activé en appelant UseAuthentication. UseAuthentication ajoute un intergiciel d’authentification au pipeline de requêtes.

L’application générée par un modèle n’utilise pas l’autorisation. app.UseAuthorization est inclus pour s’assurer qu’il est ajouté dans l’ordre correct si l’application ajoute une autorisation. UseRouting, UseAuthentication et UseAuthorization doivent être appelés dans l’ordre indiqué dans le code précédent.

Pour plus d’informations sur IdentityOptions, consultez les articles IdentityOptions et Démarrage d’une application.

Générer automatiquement les modèles Register, Login, LogOut et RegisterConfirmation

Visual Studio

Ajoutez les fichiers Register, Login, LogOut et RegisterConfirmation. Suivez les instructions de la section Générer un modèle d’Identity dans un projet Razor avec autorisation pour générer le code présenté dans cette section.

CLI .NET Core

Si vous avez créé le projet avec le nom WebApp1 et que vous n’utilisez pas SQLite, exécutez les commandes suivantes. Sinon, utilisez l’espace de noms approprié pour ApplicationDbContext :

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation"

Si vous utilisez SQLite, ajoutez --useSqLite ou -sqlite :

dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation" --useSqLite

PowerShell utilise un point-virgule comme séparateur de commandes. En cas d’utilisation de PowerShell, échappez les points-virgules dans la liste des fichiers ou placez la liste de fichiers entre guillemets, comme illustré dans l’exemple précédent.

Pour plus d’informations sur la génération d’un modèle Identity, consultez la section Générer un modèle d’Identity dans un projet Razor avec autorisation.

Examiner l’inscription

Quand un utilisateur clique sur le bouton d’inscription sur la page Register, l’action RegisterModel.OnPostAsync est appelée. L’utilisateur est créé par CreateAsync(TUser) sur l’objet _userManager :

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");
    ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
                                          .ToList();
    if (ModelState.IsValid)
    {
        var user = new IdentityUser { UserName = Input.Email, Email = Input.Email };
        var result = await _userManager.CreateAsync(user, Input.Password);
        if (result.Succeeded)
        {
            _logger.LogInformation("User created a new account with password.");

            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            var callbackUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = user.Id, code = code },
                protocol: Request.Scheme);

            await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

            if (_userManager.Options.SignIn.RequireConfirmedAccount)
            {
                return RedirectToPage("RegisterConfirmation", 
                                      new { email = Input.Email });
            }
            else
            {
                await _signInManager.SignInAsync(user, isPersistent: false);
                return LocalRedirect(returnUrl);
            }
        }
        foreach (var error in result.Errors)
        {
            ModelState.AddModelError(string.Empty, error.Description);
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Désactiver la vérification du compte par défaut

Avec les modèles par défaut, l’utilisateur est redirigé vers Account.RegisterConfirmation où il peut sélectionner un lien pour que le compte soit confirmé. La valeur par défaut Account.RegisterConfirmation est utilisée uniquement à des fins de test. La vérification automatique du compte doit être désactivée dans une application de production.

Pour exiger un compte confirmé et empêcher la connexion immédiate lors de l’inscription, définissez DisplayConfirmAccountLink = false dans /Areas/Identity/Pages/Account/RegisterConfirmation.cshtml.cs :

[AllowAnonymous]
public class RegisterConfirmationModel : PageModel
{
    private readonly UserManager<IdentityUser> _userManager;
    private readonly IEmailSender _sender;

    public RegisterConfirmationModel(UserManager<IdentityUser> userManager, IEmailSender sender)
    {
        _userManager = userManager;
        _sender = sender;
    }

    public string Email { get; set; }

    public bool DisplayConfirmAccountLink { get; set; }

    public string EmailConfirmationUrl { get; set; }

    public async Task<IActionResult> OnGetAsync(string email, string returnUrl = null)
    {
        if (email == null)
        {
            return RedirectToPage("/Index");
        }

        var user = await _userManager.FindByEmailAsync(email);
        if (user == null)
        {
            return NotFound($"Unable to load user with email '{email}'.");
        }

        Email = email;
        // Once you add a real email sender, you should remove this code that lets you confirm the account
        DisplayConfirmAccountLink = false;
        if (DisplayConfirmAccountLink)
        {
            var userId = await _userManager.GetUserIdAsync(user);
            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            EmailConfirmationUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = userId, code = code, returnUrl = returnUrl },
                protocol: Request.Scheme);
        }

        return Page();
    }
}

Se connecter

Le formulaire de connexion s’affiche dans les cas suivants :

• Le lien de connexion est sélectionné.
• Un utilisateur tente d’accéder à une page restreinte à laquelle il n’est pas autorisé à accéder ou quand il n’a pas été authentifié par le système.

Quand le formulaire de la page de connexion est envoyé, l’action OnPostAsync est appelée. PasswordSignInAsync est appelé sur l’objet _signInManager.

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");

    if (ModelState.IsValid)
    {
        // This doesn't count login failures towards account lockout
        // To enable password failures to trigger account lockout, 
        // set lockoutOnFailure: true
        var result = await _signInManager.PasswordSignInAsync(Input.Email,
                           Input.Password, Input.RememberMe, lockoutOnFailure: true);
        if (result.Succeeded)
        {
            _logger.LogInformation("User logged in.");
            return LocalRedirect(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToPage("./LoginWith2fa", new
            {
                ReturnUrl = returnUrl,
                RememberMe = Input.RememberMe
            });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning("User account locked out.");
            return RedirectToPage("./Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Pour plus d’informations sur la prise de décisions en ce qui concerne l’autorisation, consultez l’article Présentation de l’autorisation dans ASP.NET Core.

Se déconnecter

Le lien de déconnexion appelle l’action LogoutModel.OnPost.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

namespace WebApp1.Areas.Identity.Pages.Account
{
    [AllowAnonymous]
    public class LogoutModel : PageModel
    {
        private readonly SignInManager<IdentityUser> _signInManager;
        private readonly ILogger<LogoutModel> _logger;

        public LogoutModel(SignInManager<IdentityUser> signInManager, ILogger<LogoutModel> logger)
        {
            _signInManager = signInManager;
            _logger = logger;
        }

        public void OnGet()
        {
        }

        public async Task<IActionResult> OnPost(string returnUrl = null)
        {
            await _signInManager.SignOutAsync();
            _logger.LogInformation("User logged out.");
            if (returnUrl != null)
            {
                return LocalRedirect(returnUrl);
            }
            else
            {
                return RedirectToPage();
            }
        }
    }
}

Dans le code précédent, le code return RedirectToPage(); doit être une redirection afin que le navigateur effectue une nouvelle demande et que l’identité de l’utilisateur soit mise à jour.

SignOutAsync efface les revendications de l’utilisateur stockées dans un cookie.

Post est spécifié dans Pages/Shared/_LoginPartial.cshtml :

@using Microsoft.AspNetCore.Identity
@inject SignInManager<IdentityUser> SignInManager
@inject UserManager<IdentityUser> UserManager

<ul class="navbar-nav">
@if (SignInManager.IsSignedIn(User))
{
    <li class="nav-item">
        <a  class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Manage/Index" 
                                              title="Manage">Hello @User.Identity.Name!</a>
    </li>
    <li class="nav-item">
        <form class="form-inline" asp-area="Identity" asp-page="/Account/Logout" 
                                  asp-route-returnUrl="@Url.Page("/", new { area = "" })" 
                                  method="post" >
            <button  type="submit" class="nav-link btn btn-link text-dark">Logout</button>
        </form>
    </li>
}
else
{
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a>
    </li>
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a>
    </li>
}
</ul>

Tester Identity

Les modèles de projet web par défaut autorisent l’accès anonyme aux pages d’accueil. Pour tester Identity, ajoutez [Authorize] :

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;

namespace WebApp1.Pages
{
    [Authorize]
    public class PrivacyModel : PageModel
    {
        private readonly ILogger<PrivacyModel> _logger;

        public PrivacyModel(ILogger<PrivacyModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
        }
    }
}

Si vous êtes connecté, déconnectez-vous. Exécutez l'application et sélectionnez le lien Privacy. Vous êtes redirigé vers la page de connexion.

Explorer Identity

Pour explorer Identity en détail :

• Créez une source d’interface utilisateur d’Identity complète.
• Examinez la source de chaque page et effectuez la procédure du débogueur.

Identity Components

Tous les packages NuGet dépendants d’Identity sont inclus dans l’infrastructure partagée ASP.NET Core.

Le package principal pour Identity est Microsoft.AspNetCore.Identity. Ce package contient l’ensemble d’interfaces de base pour ASP.NET Core Identity et est inclus par Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Migration vers ASP.NET Core Identity

Pour plus d’informations et pour obtenir de l’aide sur la migration de votre magasin Identity existant, consultez l’article Migrer l’authentification et Identity.

Définition de la force du mot de passe

Consultez la section sur la configuration pour obtenir un exemple qui définit les exigences minimales relatives aux mots de passe.

AddDefaultIdentity et AddIdentity

AddDefaultIdentity a été introduit dans ASP.NET Core 2.1. L’appel de AddDefaultIdentity est similaire à l’appel de ce qui suit :

• AddIdentity
• AddDefaultUI
• AddDefaultTokenProviders

Pour plus d’informations, consultez la source AddDefaultIdentity.

Empêcher la publication de ressources Identity statiques

Pour empêcher la publication de ressources Identity statiques (feuilles de style et fichiers JavaScript pour l’interface utilisateur Identity) sur la racine web, ajoutez la propriété et la cible ResolveStaticWebAssetsInputsDependsOn suivantes RemoveIdentityAssets au fichier projet de l’application :

<PropertyGroup>
  <ResolveStaticWebAssetsInputsDependsOn>RemoveIdentityAssets</ResolveStaticWebAssetsInputsDependsOn>
</PropertyGroup>

<Target Name="RemoveIdentityAssets">
  <ItemGroup>
    <StaticWebAsset Remove="@(StaticWebAsset)" Condition="%(SourceId) == 'Microsoft.AspNetCore.Identity.UI'" />
  </ItemGroup>
</Target>

Étapes suivantes

• Code source ASP.NET Core Identity
• Comment utiliser les rôles dans ASP.NET Core Identity

• Consulter ce problème GitHub pour plus d’informations sur la configuration d’Identity à l’aide de SQLite
• Configuration de Identity
• Créer une application ASP.NET Core avec des données utilisateur protégées par une autorisation
• Ajouter, télécharger et supprimer des données utilisateur dans Identity dans un projet ASP.NET Core
• Activer la génération de code QR pour les applications d’authentification TOTP dans ASP.NET Core
• Migrer l’authentification et Identity vers ASP.NET Core
• Account confirmation and password recovery in ASP.NET Core (Confirmation de compte et récupération de mot de passe dans ASP.NET Core)
• Authentification à deux facteurs avec SMS dans ASP.NET Core
• Hôte ASP.NET Core dans une batterie de serveurs web