Autorizzazione semplice in ASP.NET Core

L'autorizzazione in ASP.NET Core viene controllata con AuthorizeAttribute 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.

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:

  • AuthorizeIndexPageHandlerFilter implementa il filtro di autorizzazione:

  [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()
      {
  
      }
  }
  

  • L'attributo [AuthorizePageHandler] viene applicato al gestore di OnPostAuthorized pagine:

  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 insieme al resto del 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 AuthorizeAttributeRazor gestori di pagine.