Autorização baseada em perfis no ASP.NET Core

Quando a identidade de um utilizador é criada após a autenticação, o utilizador pode pertencer a um ou mais papéis, refletindo várias autorizações que o utilizador tem para aceder a dados e realizar operações. Por exemplo, Tracy pode pertencer aos papéis de "Administrador" e "Utilizador" com acesso a páginas web administrativas na aplicação, enquanto Scott pode pertencer apenas ao papel de "Utilizador" e não ter acesso a dados ou operações administrativas. A forma como essas funções são criadas e gerenciadas depende do armazenamento de suporte do processo de autorização. Os papéis são disponibilizados ao desenvolvedor através de ClaimsPrincipal.IsInRole. AddRoles deve ser chamado para adicionar serviços de Função ao configurar o sistema de identidade da aplicação.

Embora as funções sejam declarações, nem todas as declarações são funções. Dependendo do emissor da identidade, um papel pode ser um conjunto de utilizadores que podem aplicar reivindicações para membros do grupo, bem como uma reivindicação real sobre uma identidade. No entanto, as declarações destinam-se a ser informações sobre um utilizador individual. Usar funções para adicionar declarações a um usuário pode confundir o limite entre o usuário e suas declarações individuais. Esta confusão é a razão pela qual os modelos de aplicação de página única (SPA) não são concebidos para funções. Além disso, para organizações que migram de um sistema legado on-premiss, a proliferação de funções ao longo dos anos pode significar que uma reivindicação de função pode ser demasiado grande para ser contida num token utilizável por uma SPA. Para proteger SPAs, consulte e utilize Identity para garantir um backend de API Web para SPAs.

Este artigo utiliza Razor exemplos de componentes e foca-se em Blazor cenários de autorização. Para orientações adicionais Blazor , consulte a secção de Recursos Adicionais . Para obter orientações sobre Razor Pages e MVC, consulte os seguintes recursos:

• Autorização baseada em funções em ASP.NET Core Razor Páginas
• Autorização baseada em funções no ASP.NET Core MVC

Aplicativo de exemplo

O exemplo Blazor Web App deste artigo é a aplicação de exemplo BlazorWebAppAuthorization (repositório dotnet/AspNetCore.Docs.Samples GitHub) (como descarregar). A aplicação de exemplo utiliza contas pré-definidas com funções pré-configuradas para demonstrar a maioria dos exemplos deste artigo. Para mais informações, consulte o ficheiro README do exemplo (README.md).

Adicionar serviços de função a Identity

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

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

services.AddDefaultIdentity<IdentityUser>()
    .AddRoles<IdentityRole>()
    ...

services.AddIdentityCore<IdentityUser>()
    .AddRoles<IdentityRole>()
    ...

app.UseAuthentication(); // Only present if not called internally
app.UseAuthorization();

app.UseAuthentication(); // Only present if not called internally
app.UseAuthorization();

app.UseAuthentication(); // Only present if not called internally
app.UseAuthorization();

builder.Services.AddAuthorizationCore();

Verificações de autorização baseadas em funções

Verificações de autorização baseadas em funções:

• São declarativas e especificam funções às quais o utilizador atual deve pertencer para aceder ao recurso solicitado.
• São aplicados a Razor componentes (exemplos neste artigo), Razor Páginas, ou controladores MVC ou ações dentro de um controlador.

O componente (componente na documentação ) oferece suporte a autorização baseada em funções. Esta secção cobre conceitos básicos. Para cobertura completa, consulte ASP.NET Core Blazor autenticação e autorização.

Para autorização baseada em funções nos componentes Razor, use o parâmetro AuthorizeView.Roles.

No exemplo a seguir:

• O utilizador deve ter uma atribuição de função para as funções Admin ou SuperUser para ver o conteúdo do primeiro componente AuthorizeView.
• Para exigir reivindicações de função tanto de Admin quanto de SuperUser, o segundo exemplo aninha AuthorizeView componentes.

Pages/RoleChecksWithAuthorizeView.razor:

@page "/role-checks-with-authorizeview"

<h3>Role Checks with AuthorizeView</h3>

<AuthorizeView Roles="Admin, SuperUser">
    <p>User: @context.User.Identity?.Name</p>
    <p>You have an 'Admin' or 'SuperUser' role claim.</p>
</AuthorizeView>

<AuthorizeView Roles="Admin">
    <p>User: @context.User.Identity?.Name</p>
    <p>You have the 'Admin' role claim.</p>
    <AuthorizeView Roles="SuperUser" Context="innerContext">
        <p>User: @innerContext.User.Identity?.Name</p>
        <p>You have both 'Admin' and 'SuperUser' role claims.</p>
    </AuthorizeView>
</AuthorizeView>

O código anterior define um Context para o componente interno AuthorizeView, de forma a evitar uma colisão no contexto AuthenticationState. O contexto AuthenticationState é acedido na AuthorizeView externa com o método padrão para aceder ao contexto (@context.User). O contexto na AuthorizeView interna é acessado com o contexto nomeado innerContext (@innerContext.User).

O [Authorize] atributo suporta autorização baseada em funções para componentes inteiros Razor . Use o AuthorizeAttribute.Roles parâmetro. O código seguinte limita o acesso dos componentes a utilizadores que são membros da Admin função.

Pages/RequireAdminRoleWithAuthorizeAttribute.razor:

@page "/require-admin-role-with-authorize-attribute"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Roles = "Admin")]

<h1>Require 'Admin' role with [Authorize] attribute</h1>

<p>You can only see this if you're in the 'Admin' role.</p>

Múltiplos papéis podem ser especificados como uma lista separada por vírgulas. No exemplo seguinte, o acesso é limitado a utilizadores que sejam membros da Admin função ou da função SuperUser.

Pages/RequireAdminOrSuperUserRoleWithAuthorizeAttribute.razor:

@page "/require-admin-or-superuser-role-with-authorize-attribute"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Roles = "Admin, SuperUser")]

<h1>Require 'Admin' or 'SuperUser' role with [Authorize] attribute</h1>

<p>
    You can only see this if you're in the 'Admin' role or the 'SuperUser' role.
</p>

Quando múltiplos atributos são aplicados, o utilizador deve ser membro de todos os papéis especificados. O exemplo seguinte requer ambosAdmin os papéis eSuperUser funções.

Pages/RequireAdminAndSuperUserRolesWithAuthorizeAttributes.razor:

@page "/require-admin-and-superuser-roles-with-authorize-attributes"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Roles = "Admin")]
@attribute [Authorize(Roles = "SuperUser")]

<h1>Require 'Admin' and 'SuperUser' roles with [Authorize] attributes</h1>

<p>
    You can only see this if you're in both the 'Admin' role 
    and the 'SuperUser' role.
</p>

A correspondência de funções é tipicamente sensível a maiúsculas e minúsculas porque os nomes das funções são armazenados e comparados usando comparações de strings do .NET. Por exemplo, Admin (maiúscula A) não é tratada como o mesmo papel que admin (minúscula a). Para mais informações, consulte Autorização baseada em pedidos em ASP.NET Core.

Verificações de autorização baseadas em políticas

Os requisitos de função podem ser expressos usando sintaxe de políticas, onde a aplicação regista uma política no arranque como parte da configuração do serviço de autorização.

No exemplo a seguir:

• A RequireAdminRole política especifica que os utilizadores devem estar na Admin função.
• A RequireSuperUserRole política especifica que os utilizadores devem estar na SuperUser função.

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("RequireAdminRole",
         policy => policy.RequireRole("Admin"))
    .AddPolicy("RequireSuperUserRole",
         policy => policy.RequireRole("SuperUser"));

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("RequireAdminRole",
        policy => policy.RequireRole("Admin"));
    options.AddPolicy("RequireSuperUserRole",
        policy => policy.RequireRole("SuperUser"));
});

services.AddAuthorization(options =>
{
    options.AddPolicy("RequireAdminRole",
        policy => policy.RequireRole("Admin"));
    options.AddPolicy("RequireSuperUserRole",
        policy => policy.RequireRole("SuperUser"));
});

Para autorização baseada em políticas usando um AuthorizeView componente, use o AuthorizeView.Policy parâmetro com um único nome de política.

Pages/PassRequireAdminRolePolicy.razor:

@page "/pass-requireadminrole-policy-with-authorizeview"

<h1>Pass 'RequireAdminRole' policy with AuthorizeView</h1>

<AuthorizeView Policy="RequireAdminRole">
    <p>You satisfy the 'RequireAdminRole' policy.</p>
</AuthorizeView>

Para lidar com o caso em que o usuário deve satisfazer uma das várias políticas, crie uma política que confirme que o usuário satisfaz outras políticas.

Para lidar com o caso em que o usuário deve satisfazer várias políticas simultaneamente, execute uma das seguintes abordagens:

• Crie uma política para AuthorizeView que confirme que o usuário satisfaz várias outras políticas.

• Aninhem as políticas em múltiplos AuthorizeView componentes.

  Pages/PassRequireAdminRoleAndRequireSuperUserRolePoliciesWithAuthorizeViews.razor:

  @page "/pass-requireadminrole-and-requiresuperuserrole-policies-with-authorizeviews"
  
  <h1>
      Pass 'RequireAdminRole' and 'RequireSuperUserRole' policies with AuthorizeViews
  </h1>
  
  <AuthorizeView Policy="RequireAdminRole">
      <AuthorizeView Policy="RequireSuperUserRole" Context="innerContext">
          <p>
              You satisfy the 'RequireAdminRole' and 
              'RequireSuperUserRole' policies.
          </p>
      </AuthorizeView>
  </AuthorizeView>
  

Se tanto Roles como Policy forem definidos, a autorização só será bem-sucedida quando ambas as condições forem satisfeitas. Ou seja, o usuário deve pertencer a pelo menos uma das funções especificadas e atender aos requisitos definidos pela política.

Se nem Roles nem Policy for especificado, AuthorizeView usará a política padrão:

• Os usuários autenticados (conectados) são autorizados.
• Os usuários não autenticados (desconectados) não são autorizados.

Em contraste com a correspondência de papéis, que normalmente é sensível a maiúsculas e minúsculas, a pesquisa do nome da política no ASP.NET Core é geralmente insensível a maiúsculas e minúsculas, pelo que RequireAdminRole e requireadminrole referem-se à mesma política.

As políticas são aplicadas a um componente inteiro Razor através da propriedade Policy no atributo [Authorize].

Pages/PassRequireAdminRolePolicyWithAuthorizeAttribute.razor:

@page "/pass-requireadminrole-policy-with-authorize-attribute"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "RequireAdminRole")]

<h1>Pass RequireAdminRole policy with [Authorize] attribute</h1>

<p>You can only see this if the 'RequireAdminRole' policy is satisfied.</p>

Para especificar múltiplos papéis permitidos num requisito, especifique os papéis como parâmetros do RequireRole método. No exemplo seguinte, os utilizadores estão autorizados se pertencerem às Admin funções ouSuperUser:

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("ElevatedRights", policy =>
        policy.RequireRole("Admin", "SuperUser"));

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy =>
        policy.RequireRole("Admin", "SuperUser"));
});

services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy =>
        policy.RequireRole("Admin", "SuperUser"));
});

Se quiser que a política exija todos os papéis anteriores, encadeie os papéis ao construtor de políticas ou especifique-os individualmente ao construtor de políticas numa declaração lambda.

Vinculado ao construtor de políticas

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("ElevatedRights", policy => 
        policy
            .RequireRole("Admin")
            .RequireRole("SuperUser"));

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("ElevatedRights",
        policy =>
        {
            policy.RequireRole("Admin");
            policy.RequireRole("SuperUser");
        });

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy => 
        policy
            .RequireRole("Admin")
            .RequireRole("SuperUser"));
});

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights",
        policy =>
        {
            policy.RequireRole("Admin");
            policy.RequireRole("SuperUser");
        });
});

services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy => 
        policy
            .RequireRole("Admin")
            .RequireRole("SuperUser"));
});

services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights",
        policy =>
        {
            policy.RequireRole("Admin");
            policy.RequireRole("SuperUser");
        });
});

Grupos de segurança de autenticação do Windows como funções de aplicação

O User.Identity é tipicamente um WindowsIdentity quando se usa Windows Autenticação, e pode recuperar as reivindicações do grupo SID ou verificar se um utilizador está numa função com o seguinte código, onde o marcador de lugar {DOMAIN} é o domínio e o {SID GROUP NAME} é o nome do grupo SID:

if (User.Identity is WindowsIdentity windowsIdentity)
{
    var groups = windowsIdentity.Groups;

    // If needed, obtain a list of the SID groups
    var securityGroups = 
        groups.Select(g => g.Translate(typeof(NTAccount)).ToString()).ToList();

    // If needed, obtain the user's Windows identity name
    var windowsIdentityName = windowsIdentity.Name;

    // Check if the user is in a specific SID group
    if (User.IsInRole(@"{DOMAIN}\{SID GROUP NAME}"))
    {
        // User is in the specified group
    }
    else
    {
        // User isn't in the specified group
    }
}
else
{
    // The user isn't authenticated with Windows Authentication
}

Recursos adicionais

• ASP.NET Core Blazor autenticação e autorização
• ASP.NET Core Blazor WebAssembly com grupos e perfis do Microsoft Entra ID
• Autorização baseada em funções em ASP.NET Core Razor Páginas
• Autorização baseada em funções no ASP.NET Core MVC
• Estenda ou adicione reivindicações personalizadas, incluindo reivindicações de função, usando IClaimsTransformation