Autorisatie op basis van rollen in ASP.NET Core

Wanneer een identity wordt gemaakt, kan deze deel uitmaken van een of meer rollen. Tracy kan bijvoorbeeld behoren tot de Administrator en User rollen, terwijl Scott alleen tot de User rol behoort. Hoe deze rollen worden gemaakt en beheerd, is afhankelijk van het back-uparchief van het autorisatieproces. Rollen worden beschikbaar gesteld aan de ontwikkelaar via de IsInRole methode in de ClaimsPrincipal-klasse. AddRoles moet worden toegevoegd aan functieservices.

Hoewel rollen claims zijn, zijn niet alle claims rollen. Afhankelijk van de identity verlener kan een rol een verzameling gebruikers zijn die claims voor groepsleden kunnen indienen, en daarnaast een directe claim op een identitybevatten. Claims zijn echter bedoeld als informatie over een afzonderlijke gebruiker. Het gebruik van rollen om claims toe te voegen aan een gebruiker kan de grens tussen de gebruiker en hun afzonderlijke claims verwarren. Deze verwarring is de reden waarom de SPA-sjablonen niet zijn ontworpen rond rollen. Bovendien kunnen organisaties die migreren vanuit een on-premises verouderd systeem de verspreiding van rollen in de loop van de jaren betekenen dat een rolclaim te groot kan zijn om te worden opgenomen in een token dat kan worden gebruikt door SPA's. Zie Identity gebruiken om een web-API-back-end te beveiligen voor SPA'som SPA's te beveiligen.

Dit artikel bevat een overzicht van op rollen gebaseerde autorisatie voor ASP.NET Core MVC- en Razor-apps. Zie voor Blazor apps ASP.NET Core Blazor verificatie en autorisatie en ASP.NET Core Blazor WebAssembly met Microsoft Entra ID-groepen en -rollen.

Rolservices toevoegen aan Identity

Registreer autorisatieservices op basis van rollen in Program.cs door AddRoles aan te roepen met het roltype in de Identity configuratie van de app. Het roltype in het volgende voorbeeld is IdentityRole:

builder.Services.AddDefaultIdentity<IdentityUser>( ... )
    .AddRoles<IdentityRole>()
    ...

Voor de voorgaande code is de Microsoft.AspNetCore vereist.Identity. UI pakket en een using richtlijn voor Microsoft.AspNetCore.Identity.

Rolcontroles toevoegen

Autorisatiecontroles op basis van rollen:

• Zijn declaratief en geven rollen op waarvan de huidige gebruiker lid moet zijn om toegang te krijgen tot de aangevraagde resource.
• Worden toegepast op pagina's, controllers of acties binnen een controller Razor.
• Kan niet worden toegepast op het niveau van de Razor Pagina-handler. Deze moeten worden toegepast op de pagina.

De volgende code beperkt bijvoorbeeld de toegang tot acties op de AdministrationController voor gebruikers die lid zijn van de Administrator rol:

[Authorize(Roles = "Administrator")]
public class AdministrationController : Controller
{
    public IActionResult Index() =>
        Content("Administrator");
}

Meerdere rollen kunnen worden opgegeven als een door komma's gescheiden lijst:

[Authorize(Roles = "HRManager,Finance")]
public class SalaryController : Controller
{
    public IActionResult Payslip() =>
                    Content("HRManager || Finance");
}

De SalaryController is alleen toegankelijk voor gebruikers die lid zijn van de rol HRManagerof van de rol Finance.

Wanneer meerdere kenmerken worden toegepast, moet een toegangsgebruiker lid zijn van alle de opgegeven rollen. Voor het volgende voorbeeld moet een gebruiker lid zijn van zowel de rol van de PowerUseralsControlPanelUser:

[Authorize(Roles = "PowerUser")]
[Authorize(Roles = "ControlPanelUser")]
public class ControlPanelController : Controller
{
    public IActionResult Index() =>
        Content("PowerUser && ControlPanelUser");
}

Toegang tot een actie kan worden beperkt door aanvullende rolautorisatiekenmerken toe te passen op actieniveau:

[Authorize(Roles = "Administrator, PowerUser")]
public class ControlAllPanelController : Controller
{
    public IActionResult SetTime() =>
        Content("Administrator || PowerUser");

    [Authorize(Roles = "Administrator")]
    public IActionResult ShutDown() =>
        Content("Administrator only");
}

In de voorgaande ControlAllPanelController controller:

• Leden van de Administrator-rol of de rol PowerUser hebben toegang tot de controller en de actie ShutDown.
• Alleen leden van de rol Administrator hebben toegang tot de actie SetTime.

Een controller kan worden beveiligd, maar anonieme, niet-geverifieerde toegang tot afzonderlijke acties toestaan:

[Authorize]
public class Control3PanelController : Controller
{
    public IActionResult SetTime() =>
        Content("[Authorize]");

    [AllowAnonymous]
    public IActionResult Login() =>
        Content("[AllowAnonymous]");
}

Voor Razor pagina's kan [Authorize] worden toegepast via:

• Een conventie gebruikenof
• Het [Authorize] wordt toegepast op het PageModel-exemplaar.

[Authorize(Policy = "RequireAdministratorRole")]
public class UpdateModel : PageModel
{
    public IActionResult OnPost() =>
         Content("OnPost RequireAdministratorRole");
}

Belangrijk

Filterkenmerken, waaronder AuthorizeAttribute, kunnen alleen worden toegepast op PageModel en kunnen niet worden toegepast op specifieke pagina-handlermethoden.

Op beleid gebaseerde rolcontroles

Rolvereisten kunnen ook worden uitgedrukt met behulp van de syntaxis van het beleid, waarbij een ontwikkelaar een beleid registreert bij het opstarten van de toepassing als onderdeel van de autorisatieserviceconfiguratie. Dit gebeurt meestal in het Program.cs-bestand:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

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

var app = builder.Build();

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

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

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

app.MapDefaultControllerRoute();
app.MapRazorPages();

app.Run();

Beleidsregels worden toegepast met behulp van de eigenschap Policy op het kenmerk [Authorize]:

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

Als u meerdere toegestane rollen in een vereiste wilt opgeven, geeft u deze op als parameters voor de RequireRole methode:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy =>
          policy.RequireRole("Administrator", "PowerUser", "BackupAdministrator"));
});

var app = builder.Build();

De voorgaande code autoriseert gebruikers die deel uitmaken van de Administrator, PowerUser of BackupAdministrator rollen.