Autorisation basée sur les rôles dans ASP.NET Core

Lorsqu’une identité est créée, elle peut appartenir à un ou plusieurs rôles. Par exemple, Tracy peut appartenir aux rôles administrateur et utilisateur tandis que Scott ne peut appartenir qu’au rôle d’utilisateur. Le mode de création et de gestion de ces rôles dépend du magasin de stockage du processus d’autorisation. Les rôles sont exposés au développeur via la méthode IsInRole sur la classe ClaimsPrincipal .

Ajout de vérifications de rôle

Les vérifications d’autorisation basées sur les rôles sont déclaratives. — le développeur les incorpore dans leur code, sur un contrôleur ou une action au sein d’un contrôleur, en spécifiant les rôles dont l’utilisateur actuel doit être membre pour accéder à la ressource demandée.

Par exemple, le code suivant limite l’accès à toutes les actions sur le AdministrationController aux utilisateurs qui sont membres du Administrator rôle :

[Authorize(Roles = "Administrator")]
public class AdministrationController : Controller
{
}

Vous pouvez spécifier plusieurs rôles sous la forme d’une liste séparée par des virgules :

[Authorize(Roles = "HRManager,Finance")]
public class SalaryController : Controller
{
}

Ce contrôleur n’est accessible qu’aux utilisateurs qui sont membres du HRManager rôle ou du Finance rôle.

Si vous appliquez plusieurs attributs, un utilisateur ayant accès doit être membre de tous les rôles spécifiés. l’exemple suivant requiert qu’un utilisateur soit membre du PowerUser ControlPanelUser rôle et.

[Authorize(Roles = "PowerUser")]
[Authorize(Roles = "ControlPanelUser")]
public class ControlPanelController : Controller
{
}

Vous pouvez limiter l’accès en appliquant des attributs d’autorisation de rôle supplémentaires au niveau de l’action :

[Authorize(Roles = "Administrator, PowerUser")]
public class ControlPanelController : Controller
{
    public ActionResult SetTime()
    {
    }

    [Authorize(Roles = "Administrator")]
    public ActionResult ShutDown()
    {
    }
}

Dans l’extrait de code précédent, les membres du Administrator rôle ou le PowerUser rôle peuvent accéder au contrôleur et à l' SetTime action, mais seuls les membres du Administrator rôle peuvent accéder à l' ShutDown action.

Vous pouvez également verrouiller un contrôleur tout en autorisant l’accès anonyme et non authentifié aux actions individuelles.

[Authorize]
public class ControlPanelController : Controller
{
    public ActionResult SetTime()
    {
    }

    [AllowAnonymous]
    public ActionResult Login()
    {
    }
}

Pour Razor les pages, le AuthorizeAttribute peut être appliqué par :

  • À l’aide d’une Convention, ou
  • Application AuthorizeAttribute de à l' PageModel instance :
[Authorize(Policy = "RequireAdministratorRole")]
public class UpdateModel : PageModel
{
    public ActionResult OnPost()
    {
    }
}

Important

Les attributs de filtre, y compris AuthorizeAttribute , peuvent uniquement être appliqués à PageModel et ne peuvent pas être appliqués à des méthodes de gestionnaire de page spécifiques.

Vérifications des rôles basés sur des stratégies

Les exigences de rôle peuvent également être exprimées à l’aide de la nouvelle syntaxe de stratégie, où un développeur inscrit une stratégie au démarrage dans le cadre de la configuration du service d’autorisation. Cela se produit normalement dans ConfigureServices() dans votre fichier Startup. cs .

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("RequireAdministratorRole",
             policy => policy.RequireRole("Administrator"));
    });
}
public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("RequireAdministratorRole",
             policy => policy.RequireRole("Administrator"));
    });
}

Les stratégies sont appliquées à l’aide de la Policy propriété sur l' AuthorizeAttribute attribut :

[Authorize(Policy = "RequireAdministratorRole")]
public IActionResult Shutdown()
{
    return View();
}

Si vous souhaitez spécifier plusieurs rôles autorisés dans une spécification, vous pouvez les spécifier en tant que paramètres de la RequireRole méthode :

options.AddPolicy("ElevatedRights", policy =>
                  policy.RequireRole("Administrator", "PowerUser", "BackupAdministrator"));

Cet exemple autorise les utilisateurs qui appartiennent aux Administrator PowerUser BackupAdministrator rôles ou.

Ajouter des services de rôle à Identity

Ajoutez rôles pour ajouter des services de rôle :

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    services.AddDefaultIdentity<IdentityUser>()
        .AddRoles<IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>();

    services.AddControllersWithViews();
    services.AddRazorPages();
}
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    services.AddDefaultIdentity<IdentityUser>()
        .AddRoles<IdentityRole>()
        .AddDefaultUI(UIFramework.Bootstrap4)
        .AddEntityFrameworkStores<ApplicationDbContext>();

    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}