Segurança: autenticação e autorização no ASP.NET Web Forms e BlazorSecurity: Authentication and Authorization in ASP.NET Web Forms and Blazor

A migração de um aplicativo ASP.NET Web Forms para Blazor quase certamente exigirá a atualização de como a autenticação e a autorização são executadas, supondo que o aplicativo tenha a autenticação configurada.Migrating from an ASP.NET Web Forms application to Blazor will almost certainly require updating how authentication and authorization are performed, assuming the application had authentication configured. Este capítulo explicará como migrar do modelo de provedor universal do ASP.NET Web Forms (para associação, funções e perfis de usuário) e como trabalhar com ASP.NET Core identidade de Blazor aplicativos.This chapter will cover how to migrate from the ASP.NET Web Forms universal provider model (for membership, roles, and user profiles) and how to work with ASP.NET Core Identity from Blazor apps. Embora este capítulo aborde as etapas e considerações de alto nível, as etapas e os scripts detalhados podem ser encontrados na documentação referenciada.While this chapter will cover the high-level steps and considerations, the detailed steps and scripts may be found in the referenced documentation.

Provedores universais ASP.NETASP.NET universal providers

Desde ASP.NET 2,0, a plataforma de Web Forms ASP.NET tem suporte para um modelo de provedor para uma variedade de recursos, incluindo associação.Since ASP.NET 2.0, the ASP.NET Web Forms platform has supported a provider model for a variety of features, including membership. O provedor de Associação Universal, junto com o provedor de função opcional, é normalmente implantado com aplicativos de Web Forms de ASP.NET.The universal membership provider, along with the optional role provider, is commonly deployed with ASP.NET Web Forms applications. Ele oferece uma maneira robusta e segura de gerenciar a autenticação e a autorização que continuam funcionando bem hoje.It offers a robust and secure way to manage authentication and authorization that continues to work well today. A oferta mais recente desses provedores universais está disponível como um pacote NuGet, Microsoft. AspNet. Providers.The most recent offering of these universal providers is available as a NuGet package, Microsoft.AspNet.Providers.

O provedores universais trabalhar com um esquema de banco de dados SQL que inclui tabelas como aspnet_Applications ,, aspnet_Membership aspnet_Roles e aspnet_Users .The Universal Providers work with a SQL database schema that includes tables like aspnet_Applications, aspnet_Membership, aspnet_Roles, and aspnet_Users. Quando configurado executando o comandoaspnet_regsql.exe, os provedores instalam tabelas e procedimentos armazenados que fornecem todas as consultas e comandos necessários para trabalhar com os dados subjacentes.When configured by running the aspnet_regsql.exe command, the providers install tables and stored procedures that provide all of the necessary queries and commands to work with the underlying data. O esquema de banco de dados e esses procedimentos armazenados não são compatíveis com os sistemas de identidade ASP.NET Identity e ASP.NET Core mais recentes, portanto, os dados existentes devem ser migrados para o novo sistema.The database schema and these stored procedures are not compatible with newer ASP.NET Identity and ASP.NET Core Identity systems, so existing data must be migrated into the new system. A Figura 1 mostra um esquema de tabela de exemplo configurado para provedores universais.Figure 1 shows an example table schema configured for universal providers.

esquema de provedores universais

O provedor universal trata usuários, associação, funções e perfis.The universal provider handles users, membership, roles, and profiles. Os usuários recebem identificadores globais exclusivos e informações básicas como userId, userName etc. são armazenados na aspnet_Users tabela.Users are assigned globally unique identifiers and basic information like userId, userName etc. are stored in the aspnet_Users table. As informações de autenticação, como senha, formato de senha, Salt de senha, contadores de bloqueio e detalhes, etc., são armazenadas na aspnet_Membership tabela.Authentication information, such as password, password format, password salt, lockout counters and details, etc. are stored in the aspnet_Membership table. As funções consistem simplesmente em nomes e identificadores exclusivos, que são atribuídos aos usuários por meio da aspnet_UsersInRoles tabela de associação, fornecendo uma relação muitos-para-muitos.Roles consist simply of names and unique identifiers, which are assigned to users via the aspnet_UsersInRoles association table, providing a many-to-many relationship.

Se o sistema existente estiver usando funções além da associação, você precisará migrar as contas de usuário, as senhas associadas, as funções e a associação de função em ASP.NET Core identidade.If your existing system is using roles in addition to membership, you will need to migrate the user accounts, the associated passwords, the roles, and the role membership into ASP.NET Core Identity. Você também precisará atualizar seu código, no qual você está executando verificações de função usando instruções IF para utilizar filtros declarativos, atributos e/ou auxiliares de marca.You will also most likely need to update your code where you're currently performing role checks using if statements to instead leverage declarative filters, attributes, and/or tag helpers. Analisaremos as considerações de migração com mais detalhes no final deste capítulo.We will review migration considerations in greater detail at the end of this chapter.

Configuração de autorização no Web FormsAuthorization configuration in Web Forms

Para configurar o acesso autorizado a determinadas páginas em um aplicativo ASP.NET Web Forms, normalmente você especifica que determinadas páginas ou pastas estão inacessíveis para usuários anônimos.To configure authorized access to certain pages in an ASP.NET Web Forms application, typically you specify that certain pages or folders are inaccessible to anonymous users. Essa configuração é feita no arquivo de web.config:This configuration is done in the web.config file:

<?xml version="1.0"?>
<configuration>
    <system.web>
      <authentication mode="Forms">
        <forms defaultUrl="~/home.aspx" loginUrl="~/login.aspx"
          slidingExpiration="true" timeout="2880"></forms>
      </authentication>

      <authorization>
        <deny users="?" />
      </authorization>
    </system.web>
</configuration>

A authentication seção de configuração configura a autenticação de formulários para o aplicativo.The authentication configuration section sets up the forms authentication for the application. A authorization seção é usada para não permitir usuários anônimos para todo o aplicativo.The authorization section is used to disallow anonymous users for the entire application. No entanto, você pode fornecer regras de autorização mais granulares em uma base por local, bem como aplicar verificações de autorização baseadas em função.However, you can provide more granular authorization rules on a per-location basis as well as apply role-based authorization checks.

<location path="login.aspx">
  <system.web>
    <authorization>
      <allow users="*" />
    </authorization>
  </system.web>
</location>

A configuração acima, quando combinada com a primeira, permitiria que usuários anônimos acessassem a página de logon, substituindo a restrição em todo o site em usuários não autenticados.The above configuration, when combined with the first one, would allow anonymous users to access the login page, overriding the site-wide restriction on non-authenticated users.

<location path="/admin">
  <system.web>
    <authorization>
      <allow roles="Administrators" />
      <deny users="*" />
    </authorization>
  </system.web>
</location>

A configuração acima, quando combinada com as outras, restringe o acesso à /admin pasta e a todos os recursos dentro dela para os membros da função "administradores".The above configuration, when combined with the others, restricts access to the /admin folder and all resources within it to members of the "Administrators" role. Essa restrição também pode ser aplicada colocando um arquivo separado web.config dentro da /admin raiz da pasta.This restriction could also be applied by placing a separate web.config file within the /admin folder root.

Código de autorização no Web FormsAuthorization code in Web Forms

Além de configurar o acesso usando web.config o, você também pode configurar programaticamente o acesso e o comportamento em seu aplicativo Web Forms.In addition to configuring access using web.config, you can also programmatically configure access and behavior in your Web Forms application. Por exemplo, você pode restringir a capacidade de executar determinadas operações ou exibir determinados dados com base na função do usuário.For instance, you can restrict the ability to perform certain operations or view certain data based on the user's role.

Esse código pode ser usado na lógica code-behind, bem como na própria página:This code can be used both in code-behind logic as well as in the page itself:

<% if (HttpContext.Current.User.IsInRole("Administrators")) { %>
  <a href="/admin">Go To Admin</a>
<% } %>

Além de verificar a associação de função de usuário, você também pode determinar se elas são autenticadas (embora geralmente isso seja melhor usando a configuração baseada em local abordada acima).In addition to checking user role membership, you can also determine if they are authenticated (though often this is better done using the location-based configuration covered above). Veja abaixo um exemplo dessa abordagem.Below is an example of this approach.

protected void Page_Load(object sender, EventArgs e)
{
    if (!User.Identity.IsAuthenticated)
    {
        FormsAuthentication.RedirectToLoginPage();
    }
    if (!Roles.IsUserInRole(User.Identity.Name, "Administrators"))
    {
        MessageLabel.Text = "Only administrators can view this.";
        SecretPanel.Visible = false;
    }
}

No código acima, o RBAC (controle de acesso baseado em função) é usado para determinar se determinados elementos da página, como um SecretPanel , são visíveis com base na função do usuário atual.In the code above, role-based access control (RBAC) is used to determine whether certain elements of the page, such as a SecretPanel, are visible based on the current user's role.

Normalmente, ASP.NET Web Forms aplicativos configuram a segurança dentro do web.config arquivo e, em seguida, adicionam verificações adicionais quando necessário em .aspx páginas e seus .aspx.cs arquivos code-behind relacionados.Typically, ASP.NET Web Forms applications configure security within the web.config file and then add additional checks where needed in .aspx pages and their related .aspx.cs code-behind files. A maioria dos aplicativos aproveita o provedor de Associação Universal, frequentemente com o provedor de função adicional.Most applications leverage the universal membership provider, frequently with the additional role provider.

Identidade do ASP.NET CoreASP.NET Core Identity

Embora ainda sejam tarefas com autenticação e autorização, a identidade ASP.NET Core usa um conjunto diferente de abstrações e suposições quando comparada aos provedores universais.Although still tasked with authentication and authorization, ASP.NET Core Identity uses a different set of abstractions and assumptions when compared to the universal providers. Por exemplo, o novo modelo de identidade dá suporte à autenticação de terceiros, permitindo que os usuários se autentiquem usando uma conta de mídia social ou outro provedor de autenticação confiável.For example, the new Identity model supports third party authentication, allowing users to authenticate using a social media account or other trusted authentication provider. ASP.NET Core identidade dá suporte à interface do usuário para páginas comumente necessárias, como logon, Logout e registro.ASP.NET Core Identity supports UI for commonly needed pages like login, logout, and register. Ele aproveita EF Core para seu acesso a dados e usa EF Core migrações para gerar o esquema necessário necessário para dar suporte ao seu modelo de dados.It leverages EF Core for its data access, and uses EF Core migrations to generate the necessary schema required to support its data model. Esta introdução à identidade em ASP.NET Core fornece uma boa visão geral do que está incluído com a identidade ASP.NET Core e como começar a trabalhar com ele.This introduction to Identity on ASP.NET Core provides a good overview of what is included with ASP.NET Core Identity and how to get started working with it. Se você ainda não tiver configurado ASP.NET Core identidade em seu aplicativo e seu banco de dados, ele o ajudará a começar.If you haven't already set up ASP.NET Core Identity in your application and its database, it will help you get started.

Funções, declarações e políticasRoles, claims, and policies

Tanto os provedores universais quanto a identidade de ASP.NET Core dão suporte ao conceito de funções.Both the universal providers and ASP.NET Core Identity support the concept of roles. Você pode criar funções para usuários e atribuir usuários a funções.You can create roles for users and assign users to roles. Os usuários podem pertencer a qualquer número de funções e você pode verificar a associação de função como parte da sua implementação de autorização.Users can belong to any number of roles, and you can verify role membership as part of your authorization implementation.

Além das funções, ASP.NET Core identidade dá suporte aos conceitos de declarações e políticas.In addition to roles, ASP.NET Core identity supports the concepts of claims and policies. Embora uma função deva corresponder especificamente a um conjunto de recursos que um usuário nessa função deve ser capaz de acessar, uma declaração é simplesmente parte da identidade de um usuário.While a role should specifically correspond to a set of resources a user in that role should be able to access, a claim is simply part of a user's identity. Uma declaração é um par de valor de nome que representa qual é o assunto, não o que o assunto pode fazer.A claim is a name value pair that represents what the subject is, not what the subject can do.

É possível inspecionar diretamente as declarações de um usuário e determinar com base nesses valores se um usuário deve receber acesso a um recurso.It is possible to directly inspect a user's claims and determine based on these values whether a user should be given access to a resource. No entanto, essas verificações costumam ser repetitivas e espalhadas em todo o sistema.However, such checks are often repetitive and scattered throughout the system. Uma abordagem melhor é definir uma política.A better approach is to define a policy.

Uma política de autorização consiste em um ou mais requisitos.An authorization policy consists of one or more requirements. As políticas são registradas como parte da configuração do serviço de autorização no ConfigureServices método de Startup.cs .Policies are registered as part of the authorization service configuration in the ConfigureServices method of Startup.cs. Por exemplo, o trecho de código a seguir configura uma política chamada "CanadiansOnly", que tem o requisito de que o usuário tenha a declaração Country com o valor de "Canada".For example, the following code snippet configures a policy called "CanadiansOnly", which has the requirement that the user has the Country claim with the value of "Canada".

services.AddAuthorization(options =>
{
    options.AddPolicy("CanadiansOnly", policy => policy.RequireClaim(ClaimTypes.Country, "Canada"));
});

Você pode aprender mais sobre como criar políticas personalizadas na documentação do.You can learn more about how to create custom policies in the documentation.

Se você estiver usando políticas ou funções, poderá especificar que uma página específica em seu Blazor aplicativo requer essa função ou política com o [Authorize] atributo, aplicada com a @attribute diretiva.Whether you're using policies or roles, you can specify that a particular page in your Blazor application requires that role or policy with the [Authorize] attribute, applied with the @attribute directive.

Exigindo uma função:Requiring a role:

@attribute [Authorize(Roles ="administrators")]

Exigir que uma política seja satisfeita:Requiring a policy be satisfied:

@attribute [Authorize(Policy ="CanadiansOnly")]

Se você precisar acessar o estado de autenticação, as funções ou as declarações de um usuário em seu código, há duas maneiras principais de obter essa funcionalidade.If you need access to a user's authentication state, roles, or claims in your code, there are two primary ways to achieve this functionality. A primeira é receber o estado de autenticação como um parâmetro em cascata.The first is to receive the authentication state as a cascading parameter. A segunda é acessar o estado usando um injetado AuthenticationStateProvider .The second is to access the state using an injected AuthenticationStateProvider. Os detalhes de cada uma dessas abordagens são descritos na Blazor documentação de segurança.The details of each of these approaches are described in the Blazor Security documentation.

O código a seguir mostra como receber o AuthenticationState como um parâmetro em cascata:The following code shows how to receive the AuthenticationState as a cascading parameter:

[CascadingParameter]
private Task<AuthenticationState> authenticationStateTask { get; set; }

Com esse parâmetro em vigor, você pode obter o usuário usando este código:With this parameter in place, you can get the user using this code:

var authState = await authenticationStateTask;
var user = authState.User;

O código a seguir mostra como injetar AuthenticationStateProvider :The following code shows how to inject the AuthenticationStateProvider:

@using Microsoft.AspNetCore.Components.Authorization
@inject AuthenticationStateProvider AuthenticationStateProvider

Com o provedor em vigor, você pode obter acesso ao usuário com o seguinte código:With the provider in place, you can gain access to the user with the following code:

AuthenticationState authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
ClaimsPrincipal user = authState.User;

if (user.Identity.IsAuthenticated)
{
  // work with user.Claims and/or user.Roles
}

Observação: O AuthorizeView componente, abordado mais adiante neste capítulo, fornece uma maneira declarativa de controlar o que um usuário vê em uma página ou componente.Note: The AuthorizeView component, covered later in this chapter, provides a declarative way to control what a user sees on a page or component.

Para trabalhar com usuários e declarações (em Blazor aplicativos de servidor), talvez você também precise injetar um UserManager<T> (use IdentityUser para o padrão), que pode ser usado para enumerar e modificar declarações para um usuário.To work with users and claims (in Blazor Server applications) you may also need to inject a UserManager<T> (use IdentityUser for default) which you can use to enumerate and modify claims for a user. Primeiro, insira o tipo e atribua-o a uma propriedade:First inject the type and assign it to a property:

@inject UserManager<IdentityUser> MyUserManager

Em seguida, use-o para trabalhar com as declarações do usuário.Then use it to work with the user's claims. O exemplo a seguir mostra como adicionar e manter uma declaração em um usuário:The following sample shows how to add and persist a claim on a user:

private async Task AddCountryClaim()
{
    var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
    var user = authState.User;
    var identityUser = await MyUserManager.FindByNameAsync(user.Identity.Name);

    if (!user.HasClaim(c => c.Type == ClaimTypes.Country))
    {
        // stores the claim in the cookie
        ClaimsIdentity id = new ClaimsIdentity();
        id.AddClaim(new Claim(ClaimTypes.Country, "Canada"));
        user.AddIdentity(id);

        // save the claim in the database
        await MyUserManager.AddClaimAsync(identityUser, new Claim(ClaimTypes.Country, "Canada"));
    }
}

Se você precisar trabalhar com funções, siga a mesma abordagem.If you need to work with roles, follow the same approach. Talvez seja necessário injetar um RoleManager<T> (usar IdentityRole para o tipo padrão) para listar e gerenciar as funções em si.You may need to inject a RoleManager<T> (use IdentityRole for default type) to list and manage the roles themselves.

Observação: Em Blazor projetos Webassembly, você precisará fornecer APIs de servidor para executar essas operações (em vez de usar UserManager<T> ou RoleManager<T> diretamente).Note: In Blazor WebAssembly projects, you will need to provide server APIs to perform these operations (instead of using UserManager<T> or RoleManager<T> directly). Um Blazor aplicativo cliente Webassembly gerenciaria declarações e/ou funções chamando com segurança pontos de extremidade de API expostos para essa finalidade.A Blazor WebAssembly client application would manage claims and/or roles by securely calling API endpoints exposed for this purpose.

Guia de migraçãoMigration guide

Migrar do ASP.NET Web Forms e provedores universais para ASP.NET Core identidade requer várias etapas:Migrating from ASP.NET Web Forms and universal providers to ASP.NET Core Identity requires several steps:

  1. Criar ASP.NET Core esquema de banco de dados de identidade no banco de dados de destinoCreate ASP.NET Core Identity database schema in the destination database
  2. Migrar dados do esquema do provedor universal para ASP.NET Core esquema de identidadeMigrate data from universal provider schema to ASP.NET Core Identity schema
  3. Migre a configuração do web.config para middleware e serviços, normalmente em Startup.csMigrate configuration from the web.config to middleware and services, typically in Startup.cs
  4. Atualize páginas individuais usando controles e condicionais para usar auxiliares de marca e novas APIs de identidade.Update individual pages using controls and conditionals to use tag helpers and new identity APIs.

Cada uma dessas etapas é descrita mais detalhadamente nas seções a seguir.Each of these steps is described in detail in the following sections.

Criando o esquema de identidade ASP.NET CoreCreating the ASP.NET Core Identity schema

Há várias maneiras de criar a estrutura de tabela necessária usada para ASP.NET Core identidade.There are several ways to create the necessary table structure used for ASP.NET Core Identity. A mais simples é criar um novo aplicativo Web ASP.NET Core.The simplest is to create a new ASP.NET Core Web application. Escolha aplicativo Web e, em seguida, altere a autenticação para usar contas de usuário individuais.Choose Web Application and then change Authentication to use Individual User Accounts.

novo projeto com contas de usuário individuais

Na linha de comando, você pode fazer a mesma coisa executando dotnet new webapp -au Individual .From the command line, you can do the same thing by running dotnet new webapp -au Individual. Depois que o aplicativo tiver sido criado, execute-o e registre-se no site.Once the app has been created, run it and register on the site. Você deve disparar uma página como a mostrada abaixo:You should trigger a page like the one shown below:

página aplicar migrações

Clique no botão "aplicar migrações" e as tabelas de banco de dados necessárias devem ser criadas para você.Click on the "Apply Migrations" button and the necessary database tables should be created for you. Além disso, os arquivos de migração devem aparecer em seu projeto, conforme mostrado:In addition, the migration files should appear in your project, as shown:

arquivos de migração

Você pode executar a migração por conta própria, sem executar o aplicativo Web, usando essa ferramenta de linha de comando:You can run the migration yourself, without running the web application, using this command-line tool:

dotnet ef database update

Se você preferir executar um script para aplicar o novo esquema a um banco de dados existente, poderá gerar script dessas migrações na linha de comando.If you would rather run a script to apply the new schema to an existing database, you can script these migrations from the command-line. Execute este comando para gerar o script:Run this command to generate the script:

dotnet ef migrations script -o auth.sql

O comando acima produzirá um script SQL no arquivo de saída auth.sql , que pode ser executado em qualquer banco de dados que você desejar.The above command will produce a SQL script in the output file auth.sql, which can then be run against whatever database you like. Se você tiver problemas para executar dotnet ef comandos, Verifique se você tem as ferramentas de EF Core instaladas no sistema.If you have any trouble running dotnet ef commands, make sure you have the EF Core tools installed on your system.

Caso você tenha colunas adicionais em suas tabelas de origem, será necessário identificar o melhor local para essas colunas no novo esquema.In the event you have additional columns on your source tables, you will need to identify the best location for these columns in the new schema. Em geral, as colunas encontradas na aspnet_Membership tabela devem ser mapeadas para a AspNetUsers tabela.Generally, columns found on the aspnet_Membership table should be mapped to the AspNetUsers table. As colunas em aspnet_Roles devem ser mapeadas para AspNetRoles .Columns on aspnet_Roles should be mapped to AspNetRoles. Todas as colunas adicionais na aspnet_UsersInRoles tabela seriam adicionadas à AspNetUserRoles tabela.Any additional columns on the aspnet_UsersInRoles table would be added to the AspNetUserRoles table.

Também vale a pena considerar colocar qualquer coluna adicional em tabelas separadas.It's also worth considering putting any additional columns on separate tables. Para que as migrações futuras não precisem levar em conta essas personalizações do esquema de identidade padrão.So that future migrations won't need to take into account such customizations of the default identity schema.

Migrando dados de provedores universais para identidade ASP.NET CoreMigrating data from universal providers to ASP.NET Core Identity

Quando você tiver o esquema da tabela de destino em vigor, a próxima etapa será migrar seus registros de usuário e função para o novo esquema.Once you have the destination table schema in place, the next step is to migrate your user and role records to the new schema. Uma lista completa das diferenças de esquema, incluindo quais colunas são mapeadas para quais novas colunas podem ser encontradas aqui.A complete list of the schema differences, including which columns map to which new columns, can be found here.

Para migrar os usuários da associação às novas tabelas de identidade, você deve seguir as etapas descritas na documentação do.To migrate your users from membership to the new identity tables, you should follow the steps described in the documentation. Depois de seguir essas etapas e o script fornecido, os usuários precisarão alterar sua senha na próxima vez que fizerem logon.After following these steps and the script provided, your users will need to change their password the next time they log in.

É possível migrar senhas de usuário, mas o processo é muito mais envolvido.It is possible to migrate user passwords but the process is much more involved. Exigir que os usuários atualizem suas senhas como parte do processo de migração e incentivando-as a usar senhas novas e exclusivas, provavelmente aumentará a segurança geral do aplicativo.Requiring users to update their passwords as part of the migration process, and encouraging them to use new, unique passwords, is likely to enhance the overall security of the application.

Migrando configurações de segurança de web.config para Startup.csMigrating security settings from web.config to Startup.cs

Conforme observado acima, a associação de ASP.NET e os provedores de função são configurados no arquivo do aplicativo web.config .As noted above, ASP.NET membership and role providers are configured in the application's web.config file. Como os aplicativos ASP.NET Core não estão vinculados ao IIS e usam um sistema separado para configuração, essas configurações devem ser configuradas em outro lugar.Since ASP.NET Core apps are not tied to IIS and use a separate system for configuration, these settings must be configured elsewhere. Para a maior parte, ASP.NET Core identidade é configurada no Startup.cs arquivo.For the most part, ASP.NET Core Identity is configured in the Startup.cs file. Abra o projeto Web que foi criado anteriormente (para gerar o esquema da tabela de identidade) e examine seu Startup.cs arquivo.Open the web project that was created earlier (to generate the identity table schema) and review its Startup.cs file.

O método configureservices padrão adiciona suporte para EF Core e identidade:The default ConfigureServices method adds support for EF Core and Identity:

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));

    services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
        .AddEntityFrameworkStores<ApplicationDbContext>();

    services.AddRazorPages();
}

O AddDefaultIdentity método de extensão é usado para configurar a identidade para usar o padrão ApplicationDbContext e o IdentityUser tipo da estrutura.The AddDefaultIdentity extension method is used to configure Identity to use the default ApplicationDbContext and the framework's IdentityUser type. Se você estiver usando um personalizado IdentityUser , certifique-se de especificar seu tipo aqui.If you're using a custom IdentityUser, be sure to specify its type here. Se esses métodos de extensão não estiverem funcionando em seu aplicativo, verifique se você tem as instruções de uso apropriadas e se você tem as referências de pacote NuGet necessárias.If these extension methods aren't working in your application, check that you have the appropriate using statements and that you have the necessary NuGet package references. Por exemplo, seu projeto deve ter alguma versão dos Microsoft.AspNetCore.Identity.EntityFrameworkCore pacotes e Microsoft.AspNetCore.Identity.UI referenciados.For example, your project should have some version of the Microsoft.AspNetCore.Identity.EntityFrameworkCore and Microsoft.AspNetCore.Identity.UI packages referenced.

Além disso Startup.cs , você deve ver o middleware necessário configurado para o site.Also in Startup.cs you should see the necessary middleware configured for the site. Especificamente, UseAuthentication e UseAuthorization deve ser configurado e no local apropriado.Specifically, UseAuthentication and UseAuthorization should be set up, and in the proper location.


// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }

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

    app.UseRouting();

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

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

ASP.NET Identity não configura o acesso anônimo ou baseado em função a locais do Startup.cs .ASP.NET Identity does not configure anonymous or role-based access to locations from Startup.cs. Você precisará migrar quaisquer dados de configuração de autorização específicos do local para filtros no ASP.NET Core.You will need to migrate any location-specific authorization configuration data to filters in ASP.NET Core. Anote quais pastas e páginas exigirão essas atualizações.Make note of which folders and pages will require such updates. Você fará essas alterações na próxima seção.You will make these changes in the next section.

Atualizando páginas individuais para usar ASP.NET Core abstrações de identidadeUpdating individual pages to use ASP.NET Core Identity abstractions

No aplicativo ASP.NET Web Forms, se você tivesse web.config configurações para negar acesso a determinadas páginas ou pastas a usuários anônimos, migraria essas alterações adicionando o [Authorize] atributo a essas páginas:In your ASP.NET Web Forms application, if you had web.config settings to deny access to certain pages or folders to anonymous users, you would migrate these changes by adding the [Authorize] attribute to such pages:

@attribute [Authorize]

Se você tiver tido o acesso negado, exceto os usuários que pertencem a uma determinada função, você migraria o comportamento adicionando um atributo especificando uma função:If you further had denied access except to those users belonging to a certain role, you would likewise migrate this behavior by adding an attribute specifying a role:

@attribute [Authorize(Roles ="administrators")]

O [Authorize] atributo só funciona em @page componentes que são alcançados por meio do Blazor roteador.The [Authorize] attribute only works on @page components that are reached via the Blazor Router. O atributo não funciona com componentes filho que, em vez disso, devem usar AuthorizeView .The attribute does not work with child components, which should instead use AuthorizeView.

Se você tiver lógica dentro da marcação de página para determinar se um código deve ser exibido para um determinado usuário, você poderá substituí-lo pelo AuthorizeView componente.If you have logic within page markup for determining whether to display some code to a certain user, you can replace this with the AuthorizeView component. O componente AuthorizeView exibe de forma seletiva a interface do usuário, dependendo se ele está autorizado a vê-la.The AuthorizeView component selectively displays UI depending on whether the user is authorized to see it. Ele também expõe uma context variável que pode ser usada para acessar informações do usuário.It also exposes a context variable that can be used to access user information.

<AuthorizeView>
    <Authorized>
        <h1>Hello, @context.User.Identity.Name!</h1>
        <p>You can only see this content if you are authenticated.</p>
    </Authorized>
    <NotAuthorized>
        <h1>Authentication Failure!</h1>
        <p>You are not signed in.</p>
    </NotAuthorized>
</AuthorizeView>

Você pode acessar o estado de autenticação na lógica de procedimento acessando o usuário de um Task<AuthenticationState configurado com o [CascadingParameter] atributo.You can access the authentication state within procedural logic by accessing the user from a Task<AuthenticationState configured with the [CascadingParameter] attribute. Essa configuração lhe dará acesso ao usuário, que pode permitir que você determine se eles são autenticados e se eles pertencem a uma função específica.This configuration will get you access to the user, which can let you determine if they are authenticated and if they belong to a particular role. Se você precisar avaliar uma política com um procedimento, poderá injetar uma instância do IAuthorizationService e chamar o AuthorizeAsync método nele.If you need to evaluate a policy procedurally, you can inject an instance of the IAuthorizationService and calls the AuthorizeAsync method on it. O código de exemplo a seguir demonstra como obter informações do usuário e permitir que um usuário autorizado execute uma tarefa restrita pela content-editor política.The following sample code demonstrates how to get user information and allow an authorized user to perform a task restricted by the content-editor policy.

@using Microsoft.AspNetCore.Authorization
@inject IAuthorizationService AuthorizationService

<button @onclick="@DoSomething">Do something important</button>

@code {
    [CascadingParameter]
    private Task<AuthenticationState> authenticationStateTask { get; set; }

    private async Task DoSomething()
    {
        var user = (await authenticationStateTask).User;

        if (user.Identity.IsAuthenticated)
        {
            // Perform an action only available to authenticated (signed-in) users.
        }

        if (user.IsInRole("admin"))
        {
            // Perform an action only available to users in the 'admin' role.
        }

        if ((await AuthorizationService.AuthorizeAsync(user, "content-editor"))
            .Succeeded)
        {
            // Perform an action only available to users satisfying the
            // 'content-editor' policy.
        }
    }
}

A AuthenticationState primeira necessidade de ser configurada como um valor em cascata antes que ela possa ser associada a um parâmetro em cascata como este.The AuthenticationState first need to be set up as a cascading value before it can be bound to a cascading parameter like this. Isso normalmente é feito usando o CascadingAuthenticationState componente.That's typically done using the CascadingAuthenticationState component. Essa configuração normalmente é feita em App.razor :This configuration is typically done in App.razor:

<CascadingAuthenticationState>
    <Router AppAssembly="@typeof(Program).Assembly">
        <Found Context="routeData">
            <AuthorizeRouteView RouteData="@routeData"
                DefaultLayout="@typeof(MainLayout)" />
        </Found>
        <NotFound>
            <LayoutView Layout="@typeof(MainLayout)">
                <p>Sorry, there's nothing at this address.</p>
            </LayoutView>
        </NotFound>
    </Router>
</CascadingAuthenticationState>

ResumoSummary

Blazor usa o mesmo modelo de segurança que ASP.NET Core, que é ASP.NET Core identidade.Blazor uses the same security model as ASP.NET Core, which is ASP.NET Core Identity. A migração de provedores universais para ASP.NET Core identidade é relativamente simples, supondo que uma personalização muito grande foi aplicada ao esquema de dados original.Migrating from universal providers to ASP.NET Core Identity is relatively straightforward, assuming not too much customization was applied to the original data schema. Depois que os dados são migrados, trabalhar com autenticação e autorização em Blazor aplicativos é bem documentado, com suporte configurável e de programação para a maioria dos requisitos de segurança.Once the data has been migrated, working with authentication and authorization in Blazor apps is well documented, with configurable as well as programmatic support for most security requirements.

ReferênciasReferences