Autorizzazione semplice in ASP.NET Core

  • Articolo

L'autorizzazione in ASP.NET Core viene controllata con l'attributo [Authorize] e i relativi vari parametri. Nella forma più semplice, l'applicazione dell'attributo a un controller, un'azione o Razor una pagina limita l'accesso [Authorize] a tale componente agli utenti autenticati.

Prerequisiti

Questo articolo presuppone che si abbia una conoscenza di base di ASP.NET Core Razor Pages e MVC. Se non si ha familiarità con ASP.NET Core, vedere le risorse seguenti:

Usare l'attributo [Authorize]

Il codice seguente limita l'accesso AccountController agli utenti autenticati:

[Authorize]
public class AccountController : Controller
{
    public ActionResult Login()
    {
    }

    public ActionResult Logout()
    {
    }
}

Se si vuole applicare l'autorizzazione a un'azione anziché al controller, applicare l'attributo AuthorizeAttribute all'azione stessa:

public class AccountController : Controller
{
   public ActionResult Login()
   {
   }

   [Authorize]
   public ActionResult Logout()
   {
   }
}

Ora solo gli utenti autenticati possono accedere alla Logout funzione.

È anche possibile usare l'attributo per consentire l'accesso AllowAnonymous da parte di utenti non autenticati a singole azioni. Ad esempio:

[Authorize]
public class AccountController : Controller
{
    [AllowAnonymous]
    public ActionResult Login()
    {
    }

    public ActionResult Logout()
    {
    }
}

Ciò consentirebbe solo agli utenti autenticati di , AccountControllerad eccezione dell'azione Login , accessibile da tutti, indipendentemente dal relativo stato autenticato o non autenticato/anonimo.

Avviso

[AllowAnonymous] ignora le istruzioni di autorizzazione. Se si combina [AllowAnonymous] e un [Authorize] attributo, gli [Authorize] attributi vengono ignorati. Ad esempio, se si applica [AllowAnonymous] a livello di controller:

  • Tutti i requisiti di autorizzazione degli [Authorize] attributi nello stesso controller o nello stesso metodo di azione nel controller vengono ignorati.
  • Il middleware di autenticazione non è corto circuito, ma non deve avere esito positivo.

Il codice seguente limita l'accesso LogoutModelRazor alla pagina agli utenti autenticati:

[Authorize]
public class LogoutModel : PageModel
{
    public async Task OnGetAsync()
    {

    }

    public async Task<IActionResult> OnPostAsync()
    {

    }
}

Per informazioni su come richiedere a livello globale l'autenticazione di tutti gli utenti, vedere Richiedere utenti autenticati.

Autorizzare attributi e Razor pagine

Non AuthorizeAttributepuò essere applicato ai Razor gestori di pagina. Ad esempio, [Authorize] non può essere applicato a OnGet, OnPosto a qualsiasi altro gestore di pagine. È consigliabile usare un controller MVC core ASP.NET per le pagine con requisiti di autorizzazione diversi per gestori diversi. Uso di un controller MVC quando sono necessari requisiti di autorizzazione diversi:

  • È l'approccio meno complesso.
  • È l'approccio consigliato da Microsoft.

Se si decide di non usare un controller MVC, è possibile usare i due approcci seguenti per applicare l'autorizzazione ai Razor metodi del gestore Page:

  • Usare pagine separate per i gestori di pagine che richiedono un'autorizzazione diversa. Spostare il contenuto condiviso in una o più visualizzazioni parziali. Quando possibile, si tratta dell'approccio consigliato.

  • Per il contenuto che deve condividere una pagina comune, scrivere un filtro che esegue l'autorizzazione come parte di IAsyncPageFilter.OnPageHandlerSelectionAsync. Il progetto GitHub PageHandlerAuth illustra questo approccio:

    [TypeFilter(typeof(AuthorizeIndexPageHandlerFilter))]
public class IndexModel : PageModel
{
    private readonly ILogger<IndexModel> _logger;

    public IndexModel(ILogger<IndexModel> logger)
    {
        _logger = logger;
    }

    public void OnGet()
    {

    }

    public void OnPost()
    {

    }

    [AuthorizePageHandler]
    public void OnPostAuthorized()
    {

    }
}

    public class AuthorizeIndexPageHandlerFilter : IAsyncPageFilter, IOrderedFilter
{
    private readonly IAuthorizationPolicyProvider policyProvider;
    private readonly IPolicyEvaluator policyEvaluator;

    public AuthorizeIndexPageHandlerFilter(
        IAuthorizationPolicyProvider policyProvider,
        IPolicyEvaluator policyEvaluator)
    {
        this.policyProvider = policyProvider;
        this.policyEvaluator = policyEvaluator;
    }

    // Run late in the selection pipeline
    public int Order => 10000;

    public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next) => next();

    public async Task OnPageHandlerSelectionAsync(PageHandlerSelectedContext context)
    {
        var attribute = context.HandlerMethod?.MethodInfo?.GetCustomAttribute<AuthorizePageHandlerAttribute>();
        if (attribute is null)
        {
            return;
        }

        var policy = await AuthorizationPolicy.CombineAsync(policyProvider, new[] { attribute });
        if (policy is null)
        {
            return;
        }

        await AuthorizeAsync(context, policy);
    }

    #region AuthZ - do not change
    private async Task AuthorizeAsync(ActionContext actionContext, AuthorizationPolicy policy)
    {
        var httpContext = actionContext.HttpContext;
        var authenticateResult = await policyEvaluator.AuthenticateAsync(policy, httpContext);
        var authorizeResult = await policyEvaluator.AuthorizeAsync(policy, authenticateResult, httpContext, actionContext.ActionDescriptor);
        if (authorizeResult.Challenged)
        {
            if (policy.AuthenticationSchemes.Count > 0)
            {
                foreach (var scheme in policy.AuthenticationSchemes)
                {
                    await httpContext.ChallengeAsync(scheme);
                }
            }
            else
            {
                await httpContext.ChallengeAsync();
            }

            return;
        }
        else if (authorizeResult.Forbidden)
        {
            if (policy.AuthenticationSchemes.Count > 0)
            {
                foreach (var scheme in policy.AuthenticationSchemes)
                {
                    await httpContext.ForbidAsync(scheme);
                }
            }
            else
            {
                await httpContext.ForbidAsync();
            }

            return;
        }
    }

Avviso

L'approccio di esempio PageHandlerAuth non è:

  • Comporre con attributi di autorizzazione applicati alla pagina, al modello di pagina o a livello globale. La composizione degli attributi di autorizzazione comporta l'autenticazione e l'autorizzazione eseguite più volte quando alla pagina sono applicate anche una o AuthorizeFilter più AuthorizeAttribute istanze.
  • Lavorare in combinazione con il rest sistema di autenticazione e autorizzazione di ASP.NET Core. È necessario verificare che l'uso di questo approccio funzioni correttamente per l'applicazione.

Non sono previsti piani per supportare i AuthorizeAttribute Razor gestori di pagine.