Megosztás a következőn keresztül:

Egyszerű engedélyezés a ASP.NET Core-ban

A ASP.NET Core-ban az engedélyezést a [Authorize] attribútum és annak különböző paraméterei vezérlik. A [Authorize] attribútum vezérlőre, műveletre vagy Razor lapra való alkalmazásának legalapvetőbb formájában korlátozza az összetevő elérését a hitelesített felhasználók számára.

Előfeltételek

Ez a cikk feltételezi, hogy alapszintű ismereteket tud ASP.NET Core Razor Pagesről és MVC-ről. Ha még nem használja a ASP.NET Core-t, tekintse meg a következő erőforrásokat:

A [Authorize] attribútum használata

Az alábbi kód a hitelesített felhasználók számára korlátozza a AccountController elérését:

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

    public ActionResult Logout()
    {
    }
}

Ha a vezérlő helyett egy műveletre szeretne engedélyezést alkalmazni, alkalmazza a AuthorizeAttribute attribútumot magára a műveletre:

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

   [Authorize]
   public ActionResult Logout()
   {
   }
}

Most már csak hitelesített felhasználók férhetnek hozzá a Logout függvényhez.

A AllowAnonymous attribútummal is engedélyezheti a nem hitelesített felhasználók számára az egyes műveletekhez való hozzáférést. Például:

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

    public ActionResult Logout()
    {
    }
}

Ez csak a hitelesített felhasználóknak engedélyezi a hozzáférést a AccountController-hoz, kivéve a Login műveletet, amely mindenki számára elérhető, függetlenül attól, hogy hitelesítettek, nem hitelesítettek vagy névtelenek.

Figyelmeztetés

[AllowAnonymous] megkerüli az engedélyezési utasításokat. Ha [AllowAnonymous] és egy [Authorize] attribútumot egyesít, a [Authorize] attribútumok figyelmen kívül lesznek hagyva. Ha például a [AllowAnonymous]-t a vezérlő szintjén alkalmazza:

  • A vezérlőhöz tartozó, [Authorize] attribútumokkal rendelkező bármilyen engedélyezési követelményt, valamint a vezérlőn található műveleti metódusokra vonatkozó követelményeket a rendszer figyelmen kívül hagyja.
  • A hitelesítési köztes szoftver nem rövidzárlatú, de nem kell sikerrel járnia.

Az alábbi kód a hitelesített felhasználók számára korlátozza a LogoutModelRazor lap elérését:

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

    }

    public async Task<IActionResult> OnPostAsync()
    {

    }
}

Ha tudni szeretné, hogyan követelheti meg globálisan az összes felhasználó hitelesítését, olvassa el Hitelesített felhasználók megkövetelésecímű témakört.

Attribútum és Razor lapok engedélyezése

A AuthorizeAttribute nem alkalmazható Razor lapkezelőkre. A [Authorize] például nem alkalmazható OnGet, OnPostvagy más lapkezelőre. Fontolja meg egy ASP.NET Core MVC-vezérlő használatát olyan lapokhoz, amelyek különböző engedélyezési követelményeket támasztanak a különböző kezelőkhöz. MVC-vezérlő használata különböző engedélyezési követelmények esetén:

  • Ez a legkevésbé összetett megközelítés.
  • A Microsoft által javasolt megközelítés.

Ha úgy dönt, hogy nem használ MVC-vezérlőt, az alábbi két módszer használható az engedélyezés alkalmazásához Razor Lapkezelő metódusokra:

  • Használjon külön lapokat a különböző engedélyezést igénylő lapkezelőkhöz. Helyezze át a megosztott tartalmat egy vagy több részleges nézetbe. Ha lehetséges, ez az ajánlott megközelítés.

  • Olyan tartalmak esetén, amelyeknek közös lapot kell megosztaniuk, írjon egy szűrőt, amely az IAsyncPageFilter.OnPageHandlerSelectionAsync részeként végzi az engedélyezést. A PageHandlerAuth GitHub-projekt a következő megközelítést mutatja be:

    [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;
        }
    }

Figyelmeztetés

A PageHandlerAuth mintául szolgáló megközelítés nem :

  • A lapra, oldalmodellre vagy globálisan alkalmazott engedélyezési attribútumokkal írjon. Az engedélyezési attribútumok összeállítása többszöri hitelesítést és engedélyezést eredményez, amikor egy vagy több AuthorizeAttribute vagy AuthorizeFilter példányt is alkalmaz a lapra.
  • Együttműködik a ASP.NET Core hitelesítési és engedélyezési rendszer többi részével. Ellenőriznie kell, hogy ez a módszer megfelelően működik-e az alkalmazáshoz.

Nincsenek tervek a AuthorizeAttribute támogatására a Razor lapkezelők esetében.

  • Last updated on