Autorizar com um esquema específico no ASP.NET Core

Para ver uma introdução aos esquemas de autenticação no ASP.NET Core, consulte Esquema de autenticação.

Em alguns cenários, como SPAs (Aplicativos de Página Única), é comum usar vários métodos de autenticação. Por exemplo, o aplicativo pode usar a autenticação baseada em para fazer logon e autenticação de portador cookie JWT para solicitações JavaScript. Em alguns casos, o aplicativo pode ter várias instâncias de um manipulador de autenticação. Por exemplo, dois manipuladores em que um contém uma identidade básica e um é criado quando uma cookie MFA (autenticação multifafação) foi disparada. A MFA pode ser disparada porque o usuário solicitou uma operação que requer segurança extra. Para obter mais informações sobre como impor a MFA quando um usuário solicita um recurso que requer MFA, consulte a seção proteger GitHub problema com a MFA.

Um esquema de autenticação é nomeado quando o serviço de autenticação é configurado durante a autenticação. Por exemplo:

public void ConfigureServices(IServiceCollection services)
{
    // Code omitted for brevity

    services.AddAuthentication()
        .AddCookie(options => {
            options.LoginPath = "/Account/Unauthorized/";
            options.AccessDeniedPath = "/Account/Forbidden/";
        })
        .AddJwtBearer(options => {
            options.Audience = "http://localhost:5001/";
            options.Authority = "http://localhost:5000/";
        });

No código anterior, dois manipuladores de autenticação foram adicionados: um para cookie s e outro para portador.

Observação

Especificar o esquema padrão resulta na propriedade HttpContext.User que está sendo definida para essa identidade. Se esse comportamento não for desejado, desabilite-o invocando a forma sem parâmetros de AddAuthentication .

Selecionando o esquema com o atributo Authorize

No ponto de autorização, o aplicativo indica o manipulador a ser usado. Selecione o manipulador com o qual o aplicativo autorizará passando uma lista delimitada por vírgulas de esquemas de autenticação para [Authorize] . O [Authorize] atributo especifica o esquema de autenticação ou esquemas a ser usado, independentemente de um padrão estar configurado. Por exemplo:

[Authorize(AuthenticationSchemes = AuthSchemes)]
public class MixedController : Controller
    // Requires the following imports:
    // using Microsoft.AspNetCore.Authentication.Cookies;
    // using Microsoft.AspNetCore.Authentication.JwtBearer;
    private const string AuthSchemes =
        CookieAuthenticationDefaults.AuthenticationScheme + "," +
        JwtBearerDefaults.AuthenticationScheme;

No exemplo anterior, os manipuladores de portador e são executados e têm a oportunidade de criar e anexar uma cookie identidade para o usuário atual. Especificando apenas um único esquema, o manipulador correspondente é executado.

[Authorize(AuthenticationSchemes = 
    JwtBearerDefaults.AuthenticationScheme)]
public class MixedController : Controller

No código anterior, somente o manipulador com o esquema "Portador" é executado. Todas cookie as identidades baseadas em são ignoradas.

Selecionando o esquema com políticas

Se preferir especificar os esquemas desejados na política, você poderá definir a AuthenticationSchemes coleção ao adicionar sua política:

services.AddAuthorization(options =>
{
    options.AddPolicy("Over18", policy =>
    {
        policy.AuthenticationSchemes.Add(JwtBearerDefaults.AuthenticationScheme);
        policy.RequireAuthenticatedUser();
        policy.Requirements.Add(new MinimumAgeRequirement());
    });
});

No exemplo anterior, a política "Over18" só é executado em relação à identidade criada pelo manipulador "Portador". Use a política definindo [Authorize] a propriedade do Policy atributo:

[Authorize(Policy = "Over18")]
public class RegistrationController : Controller

Usar vários esquemas de autenticação

Alguns aplicativos talvez precisem dar suporte a vários tipos de autenticação. Por exemplo, seu aplicativo pode autenticar usuários de Azure Active Directory e de um banco de dados de usuários. Outro exemplo é um aplicativo que autentica usuários de Serviços de Federação do Active Directory (AD FS) e Azure Active Directory B2C. Nesse caso, o aplicativo deve aceitar um token de portador JWT de vários emissores.

Adicione todos os esquemas de autenticação que você gostaria de aceitar. Por exemplo, o código a seguir no Startup.ConfigureServices adiciona dois esquemas de autenticação de portador JWT com emissores diferentes:

public void ConfigureServices(IServiceCollection services)
{
    // Code omitted for brevity

    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
        .AddJwtBearer(options =>
        {
            options.Audience = "https://localhost:5000/";
            options.Authority = "https://localhost:5000/identity/";
        })
        .AddJwtBearer("AzureAD", options =>
        {
            options.Audience = "https://localhost:5000/";
            options.Authority = "https://login.microsoftonline.com/eb971100-6f99-4bdc-8611-1bc8edd7f436/";
        });
}

Observação

Apenas uma autenticação de portador JWT é registrada com o esquema de autenticação padrão JwtBearerDefaults.AuthenticationScheme . A autenticação adicional deve ser registrada com um esquema de autenticação exclusivo.

A próxima etapa é atualizar a política de autorização padrão para aceitar ambos os esquemas de autenticação. Por exemplo:

public void ConfigureServices(IServiceCollection services)
{
    // Code omitted for brevity

    services.AddAuthorization(options =>
    {
        var defaultAuthorizationPolicyBuilder = new AuthorizationPolicyBuilder(
            JwtBearerDefaults.AuthenticationScheme,
            "AzureAD");
        defaultAuthorizationPolicyBuilder = 
            defaultAuthorizationPolicyBuilder.RequireAuthenticatedUser();
        options.DefaultPolicy = defaultAuthorizationPolicyBuilder.Build();
    });
}

Como a política de autorização padrão é substituído, é possível usar o [Authorize] atributo em controladores. Em seguida, o controlador aceita solicitações com JWT emitidas pelo primeiro ou segundo emissor.

Confira este GitHub sobre como usar vários esquemas de autenticação.