Autorização baseada em função no ASP.NET CoreRole-based authorization in ASP.NET Core

Quando uma identidade é criada, ela pode pertencer a uma ou mais funções.When an identity is created it may belong to one or more roles. Por exemplo, Tracy pode pertencer ao administrador e às funções de usuário, enquanto Scott só pode pertencer à função de usuário.For example, Tracy may belong to the Administrator and User roles whilst Scott may only belong to the User role. A forma como essas funções são criadas e gerenciadas depende do armazenamento de backup do processo de autorização.How these roles are created and managed depends on the backing store of the authorization process. As funções são expostas ao desenvolvedor por meio do método IsInRole na classe ClaimsPrincipal .Roles are exposed to the developer through the IsInRole method on the ClaimsPrincipal class.

Adicionando verificações de funçãoAdding role checks

As verificações de autorização baseadas em função são declarativas—o desenvolvedor as incorpora em seu código, em um controlador ou em uma ação dentro de um controlador, especificando funções das quais o usuário atual deve ser membro para acessar o recurso solicitado.Role-based authorization checks are declarative—the developer embeds them within their code, against a controller or an action within a controller, specifying roles which the current user must be a member of to access the requested resource.

Por exemplo, o código a seguir limita o acesso a qualquer ação no AdministrationController aos usuários que são membros da função Administrator:For example, the following code limits access to any actions on the AdministrationController to users who are a member of the Administrator role:

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

Você pode especificar várias funções como uma lista separada por vírgulas:You can specify multiple roles as a comma separated list:

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

Esse controlador só pode ser acessado por usuários que são membros da função HRManager ou da função Finance.This controller would be only accessible by users who are members of the HRManager role or the Finance role.

Se você aplicar vários atributos, um usuário de acesso deverá ser um membro de todas as funções especificadas; o exemplo a seguir requer que um usuário seja membro da função PowerUser e ControlPanelUser.If you apply multiple attributes then an accessing user must be a member of all the roles specified; the following sample requires that a user must be a member of both the PowerUser and ControlPanelUser role.

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

Você pode limitar ainda mais o acesso aplicando atributos de autorização de função adicionais no nível de ação:You can further limit access by applying additional role authorization attributes at the action level:

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

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

No trecho de código anterior, os membros da função Administrator ou a função PowerUser podem acessar o controlador e a ação SetTime, mas somente os membros da função Administrator podem acessar a ação ShutDown.In the previous code snippet members of the Administrator role or the PowerUser role can access the controller and the SetTime action, but only members of the Administrator role can access the ShutDown action.

Você também pode bloquear um controlador, mas permitir acesso anônimo e não autenticado a ações individuais.You can also lock down a controller but allow anonymous, unauthenticated access to individual actions.

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

    [AllowAnonymous]
    public ActionResult Login()
    {
    }
}

Por Razor Pages, o AuthorizeAttribute pode ser aplicado por um dos dois:For Razor Pages, the AuthorizeAttribute can be applied by either:

  • Usando uma ConvençãoouUsing a convention, or
  • Aplicando o AuthorizeAttribute à instância de PageModel:Applying the AuthorizeAttribute to the PageModel instance:
[Authorize(Policy = "RequireAdministratorRole")]
public class UpdateModel : PageModel
{
    public ActionResult OnPost()
    {
    }
}

Importante

Os atributos de filtro, incluindo AuthorizeAttribute, só podem ser aplicados a PageModel e não podem ser aplicados a métodos de manipuladores de páginas específicos.Filter attributes, including AuthorizeAttribute, can only be applied to PageModel and cannot be applied to specific page handler methods.

Verificações de função baseadas em políticaPolicy based role checks

Os requisitos de função também podem ser expressos usando a nova sintaxe de política, em que um desenvolvedor registra uma política na inicialização como parte da configuração do serviço de autorização.Role requirements can also be expressed using the new Policy syntax, where a developer registers a policy at startup as part of the Authorization service configuration. Isso normalmente ocorre em ConfigureServices() no arquivo Startup.cs .This normally occurs in ConfigureServices() in your Startup.cs file.

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"));
    });
}

As políticas são aplicadas usando a propriedade Policy no atributo AuthorizeAttribute:Policies are applied using the Policy property on the AuthorizeAttribute attribute:

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

Se você quiser especificar várias funções permitidas em um requisito, poderá especificá-las como parâmetros para o método de RequireRole:If you want to specify multiple allowed roles in a requirement then you can specify them as parameters to the RequireRole method:

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

Este exemplo autoriza os usuários que pertencem às funções Administrator, PowerUser ou BackupAdministrator.This example authorizes users who belong to the Administrator, PowerUser or BackupAdministrator roles.

Adicionar serviços de função à identidadeAdd Role services to Identity

Acrescente AddRoles para adicionar serviços de função:Append AddRoles to add Role services:

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);
}