Autorisation simple dans ASP.NET Core

L’autorisation dans ASP.NET Core est contrôlée avec l’attribut [Authorize] et ses différents paramètres. Dans sa forme la plus basique, l’application de l’attribut [Authorize] à un contrôleur, à une action ou à une page Razor, limite l’accès à ce composant aux utilisateurs authentifiés.

Prérequis

Cet article suppose que vous avez des connaissances de base sur ASP.NET Core Razor Pages et MVC. Si vous débutez avec ASP.NET Core, consultez les ressources suivantes :

• Introduction à Razor Pages dans ASP.NET Core
• Vue d’ensemble d’ASP.NET Core MVC
• Tutoriel : Bien démarrer avec Razor Pages dans ASP.NET Core
• Présentation d’Identity sur ASP.NET Core

Utilisez l’attribut [Authorize]

Le code suivant limite l’accès à AccountController aux utilisateurs authentifiés :

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

    public ActionResult Logout()
    {
    }
}

Si vous souhaitez appliquer l’autorisation à une action plutôt qu’au contrôleur, appliquez l’attribut AuthorizeAttribute à l’action elle-même :

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

   [Authorize]
   public ActionResult Logout()
   {
   }
}

Désormais, seuls les utilisateurs authentifiés peuvent accéder à la fonction Logout.

Vous pouvez également utiliser l’attribut AllowAnonymous pour autoriser les utilisateurs non authentifiés à accéder à des actions individuelles. Par exemple :

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

    public ActionResult Logout()
    {
    }
}

Cela autoriserait uniquement les utilisateurs authentifiés à accéder à AccountController, à l’exception de l’action Login, qui est accessible par tout le monde, quelle que soit leur état authentifié ou non authentifié/anonyme.

Le code suivant limite l’accès à la page LogoutModelRazor aux utilisateurs authentifiés :

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

    }

    public async Task<IActionResult> OnPostAsync()
    {

    }
}

Pour plus d’informations sur la façon d’exiger l’authentification globale de tous les utilisateurs, consultez Exiger des utilisateurs authentifiés.

Attribut d’autorisation et Razor Pages

AuthorizeAttribute ne peut pas être appliqué aux gestionnaires de page Razor. Par exemple, [Authorize] ne peut pas être appliqué à OnGet, OnPost ou à tout autre gestionnaire de page. Envisagez d’utiliser un contrôleur MVC ASP.NET Core pour les pages avec des exigences d’autorisation différentes pour différents gestionnaires. L’utilisation d’un contrôleur MVC lorsque des exigences d’autorisation différentes sont requises :

• Est l’approche la moins complexe.
• Est l’approche recommandée par Microsoft.

Si vous décidez de ne pas utiliser de contrôleur MVC, les deux approches suivantes peuvent être utilisées pour appliquer l’autorisation aux méthodes du gestionnaire Razor Page :

• Utiliser des pages distinctes pour les gestionnaires de page nécessitant une autorisation différente. Déplacer le contenu partagé dans une ou plusieurs vues partielles. Lorsque cela est possible, il s’agit de l’approche recommandée.

• Pour le contenu qui doit partager une page commune, écrire un filtre qui effectue l’autorisation dans le cadre de IAsyncPageFilter.OnPageHandlerSelectionAsync. Le projet GitHub PageHandlerAuth illustre cette approche :

  • Le filtre AuthorizeIndexPageHandlerFilter implémente le filtre d’autorisation :

  [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’attribut [AuthorizePageHandler] est appliqué au gestionnaire de page 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;
          }
      }
  

Il n’est pas prévu de prendre en charge AuthorizeAttribute sur les gestionnaires Razor Page.