Richtlinien basierte Autorisierung in ASP.net CorePolicy-based authorization in ASP.NET Core

Im Hintergrund werden bei der rollenbasierten Autorisierung und der Anspruchs basierten Autorisierung eine Anforderung, ein Anforderungs Handler und eine vorkonfigurierte Richtlinie verwendet.Underneath the covers, role-based authorization and claims-based authorization use a requirement, a requirement handler, and a pre-configured policy. Diese Bausteine unterstützen den Ausdruck der Autorisierungs Auswertungen im Code.These building blocks support the expression of authorization evaluations in code. Das Ergebnis ist eine umfangreichere, wiederverwendbare, testbare Autorisierungs Struktur.The result is a richer, reusable, testable authorization structure.

Eine Autorisierungs Richtlinie besteht aus einer oder mehreren Anforderungen.An authorization policy consists of one or more requirements. Sie wird als Teil der Autorisierungs Dienst Konfiguration in der- Startup.ConfigureServices Methode registriert:It's registered as part of the authorization service configuration, in the Startup.ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();
    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });
}

Im vorherigen Beispiel wird eine Richtlinie "AtLeast21" erstellt.In the preceding example, an "AtLeast21" policy is created. Sie verfügt über eine einzige Anforderung, die ein — minimal Alter ist, das als Parameter für die Anforderung angegeben wird.It has a single requirement—that of a minimum age, which is supplied as a parameter to the requirement.

IAuthorizationServiceIAuthorizationService

Der primäre Dienst, der bestimmt, ob die Autorisierung erfolgreich war, ist IAuthorizationService :The primary service that determines if authorization is successful is IAuthorizationService:

/// <summary>
/// Checks policy based permissions for a user
/// </summary>
public interface IAuthorizationService
{
    /// <summary>
    /// Checks if a user meets a specific set of requirements for the specified resource
    /// </summary>
    /// <param name="user">The user to evaluate the requirements against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="requirements">The requirements to evaluate.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// This value is <value>true</value> when the user fulfills the policy; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check 
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, 
                                     IEnumerable<IAuthorizationRequirement> requirements);

    /// <summary>
    /// Checks if a user meets a specific authorization policy
    /// </summary>
    /// <param name="user">The user to check the policy against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="policyName">The name of the policy to check against a specific 
    /// context.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// Returns a flag indicating whether the user, and optional resource has fulfilled 
    /// the policy.    
    /// <value>true</value> when the policy has been fulfilled; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(
                                ClaimsPrincipal user, object resource, string policyName);
}

Im vorangehenden Code werden die beiden Methoden des IAuthorizationServicehervorgehoben.The preceding code highlights the two methods of the IAuthorizationService.

IAuthorizationRequirement ist ein markerdienst ohne Methoden und der Mechanismus für die Überwachung, ob die Autorisierung erfolgreich war.IAuthorizationRequirement is a marker service with no methods, and the mechanism for tracking whether authorization is successful.

Jeder IAuthorizationHandler ist für die Überprüfung zuständig, ob die Anforderungen erfüllt sind:Each IAuthorizationHandler is responsible for checking if requirements are met:

/// <summary>
/// Classes implementing this interface are able to make a decision if authorization
/// is allowed.
/// </summary>
public interface IAuthorizationHandler
{
    /// <summary>
    /// Makes a decision if authorization is allowed.
    /// </summary>
    /// <param name="context">The authorization information.</param>
    Task HandleAsync(AuthorizationHandlerContext context);
}

Mit der- AuthorizationHandlerContext Klasse wird der Handler verwendet, um zu kennzeichnen, ob Anforderungen erfüllt sind:The AuthorizationHandlerContext class is what the handler uses to mark whether requirements have been met:

 context.Succeed(requirement)

Der folgende Code zeigt die vereinfachte (und mit Kommentaren versehene) Standard Implementierung des Autorisierungs Dienstanbieter:The following code shows the simplified (and annotated with comments) default implementation of the authorization service:

public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, 
             object resource, IEnumerable<IAuthorizationRequirement> requirements)
{
    // Create a tracking context from the authorization inputs.
    var authContext = _contextFactory.CreateContext(requirements, user, resource);

    // By default this returns an IEnumerable<IAuthorizationHandlers> from DI.
    var handlers = await _handlers.GetHandlersAsync(authContext);

    // Invoke all handlers.
    foreach (var handler in handlers)
    {
        await handler.HandleAsync(authContext);
    }

    // Check the context, by default success is when all requirements have been met.
    return _evaluator.Evaluate(authContext);
}

Der folgende Code zeigt ein typisches ConfigureServices :The following code shows a typical ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    // Add all of your handlers to DI.
    services.AddSingleton<IAuthorizationHandler, MyHandler1>();
    // MyHandler2, ...

    services.AddSingleton<IAuthorizationHandler, MyHandlerN>();

    // Configure your policies
    services.AddAuthorization(options =>
          options.AddPolicy("Something",
          policy => policy.RequireClaim("Permission", "CanViewPage", "CanViewAnything")));


    services.AddControllersWithViews();
    services.AddRazorPages();
}

Verwenden Sie IAuthorizationService oder [Authorize(Policy = "Something")] für die Autorisierung.Use IAuthorizationService or [Authorize(Policy = "Something")] for authorization.

Anwenden von Richtlinien auf MVC-ControllerApply policies to MVC controllers

Wenn Sie Seiten verwenden Razor , finden Sie weitere Informationen unter Anwenden von Richtlinien auf Razor Seiten in diesem Dokument.If you're using Razor Pages, see Apply policies to Razor Pages in this document.

Richtlinien werden mithilfe des- [Authorize] Attributs mit dem Richtlinien Namen auf Controller angewendet.Policies are applied to controllers by using the [Authorize] attribute with the policy name. Zum Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseController : Controller
{
    public IActionResult Index() => View();
}

Anwenden von Richtlinien auf Razor SeitenApply policies to Razor Pages

Richtlinien werden Razor mithilfe des- [Authorize] Attributs mit dem Richtlinien Namen auf Seiten angewendet.Policies are applied to Razor Pages by using the [Authorize] attribute with the policy name. Zum Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseModel : PageModel
{
}

Richtlinien können * nicht _ auf Razor seitenhandlerebene angewendet werden, Sie müssen auf die Seite angewendet werden.Policies can * not _ be applied at the Razor Page handler level, they must be applied to the Page.

Richtlinien können Razor mithilfe einer Autorisierungs Konventionauf Seiten angewendet werden.Policies can be applied to Razor Pages by using an authorization convention.

AnforderungenRequirements

Eine Autorisierungs Anforderung ist eine Auflistung von Daten Parametern, die eine Richtlinie verwenden kann, um den aktuellen Benutzer Prinzipal auszuwerten.An authorization requirement is a collection of data parameters that a policy can use to evaluate the current user principal. In unserer Richtlinie "AtLeast21" ist die Anforderung ein einzelner Parameter — das minimale Alter.In our "AtLeast21" policy, the requirement is a single parameter—the minimum age. Eine Anforderung implementiert iauthorizationrequirements, bei dem es sich um eine leere markerschnittstelle handelt.A requirement implements IAuthorizationRequirement, which is an empty marker interface. Eine parametrisierte minimale Alters Anforderung kann wie folgt implementiert werden:A parameterized minimum age requirement could be implemented as follows:

using Microsoft.AspNetCore.Authorization;

public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public int MinimumAge { get; }

    public MinimumAgeRequirement(int minimumAge)
    {
        MinimumAge = minimumAge;
    }
}

Wenn eine Autorisierungs Richtlinie mehrere Autorisierungs Anforderungen enthält, müssen alle Anforderungen bestanden werden, damit die Richtlinien Auswertung erfolgreich ist.If an authorization policy contains multiple authorization requirements, all requirements must pass in order for the policy evaluation to succeed. Anders ausgedrückt: mehrere Autorisierungs Anforderungen, die einer einzelnen Autorisierungs Richtlinie hinzugefügt werden, werden auf Basis von _ und * behandelt.In other words, multiple authorization requirements added to a single authorization policy are treated on an _ AND * basis.

Hinweis

Eine Anforderung muss keine Daten oder Eigenschaften haben.A requirement doesn't need to have data or properties.

Autorisierungs HandlerAuthorization handlers

Ein Autorisierungs Handler ist dafür verantwortlich, die Eigenschaften einer Anforderung zu evaluieren.An authorization handler is responsible for the evaluation of a requirement's properties. Der Autorisierungs Handler wertet die Anforderungen anhand eines angegebenen authorizationhandlercontext aus, um zu bestimmen, ob der Zugriff zulässig ist.The authorization handler evaluates the requirements against a provided AuthorizationHandlerContext to determine if access is allowed.

Eine Anforderung kann mehrere Handleraufweisen.A requirement can have multiple handlers. Ein Handler kann den authorizationhandler <TRequirement> erben, wobei TRequirement die zu behandelnde Anforderung ist.A handler may inherit AuthorizationHandler<TRequirement>, where TRequirement is the requirement to be handled. Alternativ kann ein Handler iauthorizationhandler implementieren, um mehr als eine Art von Anforderung zu verarbeiten.Alternatively, a handler may implement IAuthorizationHandler to handle more than one type of requirement.

Verwenden eines Handlers für eine AnforderungUse a handler for one requirement

Im folgenden finden Sie ein Beispiel für eine 1:1-Beziehung, bei der ein minimaler Alters Handler eine einzige Anforderung verwendet:The following is an example of a one-to-one relationship in which a minimum age handler utilizes a single requirement:

using System;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   MinimumAgeRequirement requirement)
    {
        if (!context.User.HasClaim(c => c.Type == ClaimTypes.DateOfBirth &&
                                        c.Issuer == "http://contoso.com"))
        {
            //TODO: Use the following if targeting a version of
            //.NET Framework older than 4.6:
            //      return Task.FromResult(0);
            return Task.CompletedTask;
        }

        var dateOfBirth = Convert.ToDateTime(
            context.User.FindFirst(c => c.Type == ClaimTypes.DateOfBirth && 
                                        c.Issuer == "http://contoso.com").Value);

        int calculatedAge = DateTime.Today.Year - dateOfBirth.Year;
        if (dateOfBirth > DateTime.Today.AddYears(-calculatedAge))
        {
            calculatedAge--;
        }

        if (calculatedAge >= requirement.MinimumAge)
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Der vorangehende Code bestimmt, ob der aktuelle Benutzer Prinzipal über ein Geburtsdatum des Geburts Anspruchs verfügt, das von einem bekannten und vertrauenswürdigen Aussteller ausgestellt wurde.The preceding code determines if the current user principal has a date of birth claim which has been issued by a known and trusted Issuer. Die Autorisierung kann nicht ausgeführt werden, wenn der Anspruch fehlt. in diesem Fall wird eine abgeschlossene Aufgabe zurückgegeben.Authorization can't occur when the claim is missing, in which case a completed task is returned. Wenn ein Anspruch vorhanden ist, wird das Alter des Benutzers berechnet.When a claim is present, the user's age is calculated. Wenn der Benutzer das durch die Anforderung definierte mindestage erfüllt, wird die Autorisierung als erfolgreich eingestuft.If the user meets the minimum age defined by the requirement, authorization is deemed successful. Wenn die Autorisierung erfolgreich ist, context.Succeed wird mit der Erfüllung der Anforderungen als einziger Parameter aufgerufen.When authorization is successful, context.Succeed is invoked with the satisfied requirement as its sole parameter.

Verwenden eines Handlers für mehrere AnforderungenUse a handler for multiple requirements

Im folgenden finden Sie ein Beispiel für eine 1: n-Beziehung, in der ein Berechtigungs Handler drei verschiedene Arten von Anforderungen verarbeiten kann:The following is an example of a one-to-many relationship in which a permission handler can handle three different types of requirements:

using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class PermissionHandler : IAuthorizationHandler
{
    public Task HandleAsync(AuthorizationHandlerContext context)
    {
        var pendingRequirements = context.PendingRequirements.ToList();

        foreach (var requirement in pendingRequirements)
        {
            if (requirement is ReadPermission)
            {
                if (IsOwner(context.User, context.Resource) ||
                    IsSponsor(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
            else if (requirement is EditPermission ||
                     requirement is DeletePermission)
            {
                if (IsOwner(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }

    private bool IsOwner(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }

    private bool IsSponsor(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }
}

Der vorangehende Code durchsucht die " pdingrequirequirements"- — Eigenschaft mit den Anforderungen, die nicht als erfolgreich gekennzeichnet sind.The preceding code traverses PendingRequirements—a property containing requirements not marked as successful. Für eine ReadPermission Anforderung muss der Benutzer entweder ein Besitzer oder ein Sponsor sein, um auf die angeforderte Ressource zuzugreifen.For a ReadPermission requirement, the user must be either an owner or a sponsor to access the requested resource. Bei einer-oder- EditPermission DeletePermission Anforderung muss er ein Besitzer sein, um auf die angeforderte Ressource zugreifen zu können.In the case of an EditPermission or DeletePermission requirement, he or she must be an owner to access the requested resource.

HandlerregistrierungHandler registration

Handler werden während der Konfiguration in der Dienste-Sammlung registriert.Handlers are registered in the services collection during configuration. Zum Beispiel:For example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();
    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });

    services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();
}

Der vorangehende Code MinimumAgeHandler wird als Singleton registriert, indem aufgerufen wird services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>(); .The preceding code registers MinimumAgeHandler as a singleton by invoking services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();. Handler können mithilfe einer beliebigen integrierten Dienst Lebensdauerregistriert werden.Handlers can be registered using any of the built-in service lifetimes.

Was sollte ein Handler zurückgeben?What should a handler return?

Beachten Sie, dass die- Handle Methode im handlerbeispiel keinen Wert zurückgibt.Note that the Handle method in the handler example returns no value. Wie wird der Status "erfolgreich" oder "Fehler" angegeben?How is a status of either success or failure indicated?

  • Ein Handler gibt den Erfolg durch Aufrufen von an context.Succeed(IAuthorizationRequirement requirement) und übergibt die Anforderung, die erfolgreich überprüft wurde.A handler indicates success by calling context.Succeed(IAuthorizationRequirement requirement), passing the requirement that has been successfully validated.

  • Ein Handler muss im Allgemeinen keine Fehler behandeln, da andere Handler für dieselbe Anforderung erfolgreich ausgeführt werden können.A handler doesn't need to handle failures generally, as other handlers for the same requirement may succeed.

  • Um einen Fehler zu gewährleisten, müssen Sie, auch wenn andere Anforderungs Handler erfolgreich sind, den Befehl context.FailTo guarantee failure, even if other requirement handlers succeed, call context.Fail.

Wenn ein Handler context.Succeed oder aufruft context.Fail , werden alle anderen Handler immer noch aufgerufen.If a handler calls context.Succeed or context.Fail, all other handlers are still called. Dies ermöglicht die Generierung von Nebeneffekten, wie z. b. die Protokollierung, die auch dann stattfindet, wenn ein anderer Handler eine Anforderung erfolgreich überprüft oder nicht erfüllt hat.This allows requirements to produce side effects, such as logging, which takes place even if another handler has successfully validated or failed a requirement. Wenn diese Eigenschaft auf festgelegt false ist, wird die Ausführung von Handlern durch die invokehandlersafterfailure -Eigenschaft kurz verknüpft, wenn context.Fail aufgerufen wird.When set to false, the InvokeHandlersAfterFailure property short-circuits the execution of handlers when context.Fail is called. InvokeHandlersAfterFailure der Standardwert true ist. in diesem Fall werden alle Handler aufgerufen.InvokeHandlersAfterFailure defaults to true, in which case all handlers are called.

Hinweis

Autorisierungs Handler werden auch dann aufgerufen, wenn die Authentifizierung fehlschlägt.Authorization handlers are called even if authentication fails.

Warum sollte ich mehrere Handler für eine Anforderung wünschen?Why would I want multiple handlers for a requirement?

Wenn Sie evaluieren möchten, können Sie mehrere Handler für eine einzelne Anforderung implementieren.In cases where you want evaluation to be on an OR basis, implement multiple handlers for a single requirement. Beispielsweise verfügt Microsoft über Türen, die nur mit Schlüsselkarten geöffnet werden.For example, Microsoft has doors which only open with key cards. Wenn Sie Ihre Schlüsselkarte zuhause lassen, druckt die Rezeption einen temporären Aufkleber und öffnet die Tür für Sie.If you leave your key card at home, the receptionist prints a temporary sticker and opens the door for you. In diesem Szenario verfügen Sie über eine einzige Anforderung, buildingentry , aber mehrere Handler, die jeweils eine einzelne Anforderung untersuchen.In this scenario, you'd have a single requirement, BuildingEntry , but multiple handlers, each one examining a single requirement.

BuildingEntryRequirement.csBuildingEntryRequirement.cs

using Microsoft.AspNetCore.Authorization;

public class BuildingEntryRequirement : IAuthorizationRequirement
{
}

BadgeEntryHandler.csBadgeEntryHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class BadgeEntryHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "BadgeId" &&
                                       c.Issuer == "http://microsoftsecurity"))
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

TemporaryStickerHandler.csTemporaryStickerHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class TemporaryStickerHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, 
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "TemporaryBadgeId" &&
                                       c.Issuer == "https://microsoftsecurity"))
        {
            // We'd also check the expiration date on the sticker.
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Stellen Sie sicher, dass beide Handler registriertsind.Ensure that both handlers are registered. Wenn einer der beiden Handler erfolgreich ist, wenn eine Richtlinie den BuildingEntryRequirement auswertet, ist die Richtlinien Auswertung erfolgreich.If either handler succeeds when a policy evaluates the BuildingEntryRequirement, the policy evaluation succeeds.

Verwenden eines Func zum erfüllen einer RichtlinieUse a func to fulfill a policy

Es kann Situationen geben, in denen das erfüllen einer Richtlinie einfach im Code ausgedrückt werden kann.There may be situations in which fulfilling a policy is simple to express in code. Func<AuthorizationHandlerContext, bool>Beim Konfigurieren Ihrer Richtlinie mit dem Richtlinien Generator ist es möglich, eine bereitzustellen RequireAssertion .It's possible to supply a Func<AuthorizationHandlerContext, bool> when configuring your policy with the RequireAssertion policy builder.

Die vorherige könnte z. b. BadgeEntryHandler wie folgt umgeschrieben werden:For example, the previous BadgeEntryHandler could be rewritten as follows:

services.AddAuthorization(options =>
{
     options.AddPolicy("BadgeEntry", policy =>
        policy.RequireAssertion(context =>
            context.User.HasClaim(c =>
                (c.Type == "BadgeId" ||
                 c.Type == "TemporaryBadgeId") &&
                 c.Issuer == "https://microsoftsecurity")));
});

Zugreifen auf den MVC-Anforderungs Kontext in HandlernAccess MVC request context in handlers

Die HandleRequirementAsync Methode, die Sie in einem Autorisierungs Handler implementieren, verfügt über zwei Parameter: einen AuthorizationHandlerContext und den, den TRequirement Sie behandeln.The HandleRequirementAsync method you implement in an authorization handler has two parameters: an AuthorizationHandlerContext and the TRequirement you are handling. Frameworks wie MVC oder SignalR können jedes beliebige Objekt der- Resource Eigenschaft im hinzufügen AuthorizationHandlerContext , um zusätzliche Informationen zu übergeben.Frameworks such as MVC or SignalR are free to add any object to the Resource property on the AuthorizationHandlerContext to pass extra information.

Wenn Sie das Endpunkt Routing verwenden, wird die Autorisierung in der Regel von der Autorisierungs Middleware verarbeitet.When using endpoint routing, authorization is typically handled by the Authorization Middleware. In diesem Fall ist die Resource Eigenschaft eine Instanz von Endpoint .In this case, the Resource property is an instance of Endpoint. Der Endpunkt kann verwendet werden, um die zugrunde liegende Ressource zu überprüfen, an die Sie weiterleiten.The endpoint can be used to probe the underlying resource to which you're routing. Zum Beispiel:For example:

if (context.Resource is Endpoint endpoint)
{
   var actionDescriptor = endpoint.Metadata.GetMetadata<ControllerActionDescriptor>();
   ...
}

Der-Endpunkt bietet keinen Zugriff auf die aktuelle HttpContext .The endpoint doesn't provide access to the current HttpContext. Wenn Sie das Endpunkt Routing verwenden, verwenden IHttpContextAcessor Sie für den Zugriff HttpContext innerhalb eines Autorisierungs Handlers.When using endpoint routing, use IHttpContextAcessor to access HttpContext inside of an authorization handler. Weitere Informationen finden Sie unter Verwenden von HttpContext aus benutzerdefinierten Komponenten.For more information, see Use HttpContext from custom components.

Mit herkömmlichem Routing oder wenn die Autorisierung im Rahmen des Autorisierungs Filters von MVC erfolgt, ist der Wert von Resource eine AuthorizationFilterContext Instanz von.With traditional routing, or when authorization happens as part of MVC's authorization filter, the value of Resource is an AuthorizationFilterContext instance. Diese Eigenschaft ermöglicht den Zugriff auf HttpContext , RouteData und alles andere, was von MVC und Seiten bereitgestellt wird Razor .This property provides access to HttpContext, RouteData, and everything else provided by MVC and Razor Pages.

Die Verwendung der- Resource Eigenschaft ist Framework-spezifisch.The use of the Resource property is framework specific. Die Verwendung von Informationen in der- Resource Eigenschaft schränkt Ihre Autorisierungs Richtlinien auf bestimmte Frameworks ein.Using information in the Resource property limits your authorization policies to particular frameworks. Sie sollten die Resource -Eigenschaft mit dem is -Schlüsselwort umwandeln und dann bestätigen, dass die Umwandlung erfolgreich war, um sicherzustellen, dass der Code nicht mit einem stürzt InvalidCastExceptionYou should cast the Resource property using the is keyword, and then confirm the cast has succeeded to ensure your code doesn't crash with an InvalidCastException when run on other frameworks:

// Requires the following import:
//     using Microsoft.AspNetCore.Mvc.Filters;
if (context.Resource is AuthorizationFilterContext mvcContext)
{
    // Examine MVC-specific things like routing data.
}

Erfordert Global, dass alle Benutzer authentifiziert werden.Globally require all users to be authenticated

Informationen dazu, wie global die Authentifizierung aller Benutzer angefordert werden kann, finden Sie unter Authentifizierte Benutzer erforderlich.For information on how to globally require all users to be authenticated, see Require authenticated users.

Im Hintergrund werden bei der rollenbasierten Autorisierung und der Anspruchs basierten Autorisierung eine Anforderung, ein Anforderungs Handler und eine vorkonfigurierte Richtlinie verwendet.Underneath the covers, role-based authorization and claims-based authorization use a requirement, a requirement handler, and a pre-configured policy. Diese Bausteine unterstützen den Ausdruck der Autorisierungs Auswertungen im Code.These building blocks support the expression of authorization evaluations in code. Das Ergebnis ist eine umfangreichere, wiederverwendbare, testbare Autorisierungs Struktur.The result is a richer, reusable, testable authorization structure.

Eine Autorisierungs Richtlinie besteht aus einer oder mehreren Anforderungen.An authorization policy consists of one or more requirements. Sie wird als Teil der Autorisierungs Dienst Konfiguration in der- Startup.ConfigureServices Methode registriert:It's registered as part of the authorization service configuration, in the Startup.ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });
}

Im vorherigen Beispiel wird eine Richtlinie "AtLeast21" erstellt.In the preceding example, an "AtLeast21" policy is created. Sie verfügt über eine einzige Anforderung, die ein — minimal Alter ist, das als Parameter für die Anforderung angegeben wird.It has a single requirement—that of a minimum age, which is supplied as a parameter to the requirement.

IAuthorizationServiceIAuthorizationService

Der primäre Dienst, der bestimmt, ob die Autorisierung erfolgreich war, ist IAuthorizationService :The primary service that determines if authorization is successful is IAuthorizationService:

/// <summary>
/// Checks policy based permissions for a user
/// </summary>
public interface IAuthorizationService
{
    /// <summary>
    /// Checks if a user meets a specific set of requirements for the specified resource
    /// </summary>
    /// <param name="user">The user to evaluate the requirements against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="requirements">The requirements to evaluate.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// This value is <value>true</value> when the user fulfills the policy; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check 
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, 
                                     IEnumerable<IAuthorizationRequirement> requirements);

    /// <summary>
    /// Checks if a user meets a specific authorization policy
    /// </summary>
    /// <param name="user">The user to check the policy against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="policyName">The name of the policy to check against a specific 
    /// context.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// Returns a flag indicating whether the user, and optional resource has fulfilled 
    /// the policy.    
    /// <value>true</value> when the policy has been fulfilled; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(
                                ClaimsPrincipal user, object resource, string policyName);
}

Wenn Sie möchten, dass Codekommentare in anderen Sprachen als Englisch angezeigt werden, informieren Sie uns in diesem GitHub-Issue.If you would like to see code comments translated to languages other than English, let us know in this GitHub discussion issue.

Im vorangehenden Code werden die beiden Methoden des IAuthorizationServicehervorgehoben.The preceding code highlights the two methods of the IAuthorizationService.

IAuthorizationRequirement ist ein markerdienst ohne Methoden und der Mechanismus für die Überwachung, ob die Autorisierung erfolgreich war.IAuthorizationRequirement is a marker service with no methods, and the mechanism for tracking whether authorization is successful.

Jeder IAuthorizationHandler ist für die Überprüfung zuständig, ob die Anforderungen erfüllt sind:Each IAuthorizationHandler is responsible for checking if requirements are met:

/// <summary>
/// Classes implementing this interface are able to make a decision if authorization
/// is allowed.
/// </summary>
public interface IAuthorizationHandler
{
    /// <summary>
    /// Makes a decision if authorization is allowed.
    /// </summary>
    /// <param name="context">The authorization information.</param>
    Task HandleAsync(AuthorizationHandlerContext context);
}

Mit der- AuthorizationHandlerContext Klasse wird der Handler verwendet, um zu kennzeichnen, ob Anforderungen erfüllt sind:The AuthorizationHandlerContext class is what the handler uses to mark whether requirements have been met:

 context.Succeed(requirement)

Der folgende Code zeigt die vereinfachte (und mit Kommentaren versehene) Standard Implementierung des Autorisierungs Dienstanbieter:The following code shows the simplified (and annotated with comments) default implementation of the authorization service:

public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, 
             object resource, IEnumerable<IAuthorizationRequirement> requirements)
{
    // Create a tracking context from the authorization inputs.
    var authContext = _contextFactory.CreateContext(requirements, user, resource);

    // By default this returns an IEnumerable<IAuthorizationHandlers> from DI.
    var handlers = await _handlers.GetHandlersAsync(authContext);

    // Invoke all handlers.
    foreach (var handler in handlers)
    {
        await handler.HandleAsync(authContext);
    }

    // Check the context, by default success is when all requirements have been met.
    return _evaluator.Evaluate(authContext);
}

Der folgende Code zeigt ein typisches ConfigureServices :The following code shows a typical ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    // Add all of your handlers to DI.
    services.AddSingleton<IAuthorizationHandler, MyHandler1>();
    // MyHandler2, ...

    services.AddSingleton<IAuthorizationHandler, MyHandlerN>();

    // Configure your policies
    services.AddAuthorization(options =>
          options.AddPolicy("Something",
          policy => policy.RequireClaim("Permission", "CanViewPage", "CanViewAnything")));


    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Verwenden Sie IAuthorizationService oder [Authorize(Policy = "Something")] für die Autorisierung.Use IAuthorizationService or [Authorize(Policy = "Something")] for authorization.

Anwenden von Richtlinien auf MVC-ControllerApply policies to MVC controllers

Wenn Sie Seiten verwenden Razor , finden Sie weitere Informationen unter Anwenden von Richtlinien auf Razor Seiten in diesem Dokument.If you're using Razor Pages, see Apply policies to Razor Pages in this document.

Richtlinien werden mithilfe des- [Authorize] Attributs mit dem Richtlinien Namen auf Controller angewendet.Policies are applied to controllers by using the [Authorize] attribute with the policy name. Zum Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseController : Controller
{
    public IActionResult Index() => View();
}

Anwenden von Richtlinien auf Razor SeitenApply policies to Razor Pages

Richtlinien werden Razor mithilfe des- [Authorize] Attributs mit dem Richtlinien Namen auf Seiten angewendet.Policies are applied to Razor Pages by using the [Authorize] attribute with the policy name. Zum Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseModel : PageModel
{
}

Richtlinien können auch Razor mithilfe einer Autorisierungs Konventionauf Seiten angewendet werden.Policies can also be applied to Razor Pages by using an authorization convention.

AnforderungenRequirements

Eine Autorisierungs Anforderung ist eine Auflistung von Daten Parametern, die eine Richtlinie verwenden kann, um den aktuellen Benutzer Prinzipal auszuwerten.An authorization requirement is a collection of data parameters that a policy can use to evaluate the current user principal. In unserer Richtlinie "AtLeast21" ist die Anforderung ein einzelner Parameter — das minimale Alter.In our "AtLeast21" policy, the requirement is a single parameter—the minimum age. Eine Anforderung implementiert iauthorizationrequirements, bei dem es sich um eine leere markerschnittstelle handelt.A requirement implements IAuthorizationRequirement, which is an empty marker interface. Eine parametrisierte minimale Alters Anforderung kann wie folgt implementiert werden:A parameterized minimum age requirement could be implemented as follows:

using Microsoft.AspNetCore.Authorization;

public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public int MinimumAge { get; }

    public MinimumAgeRequirement(int minimumAge)
    {
        MinimumAge = minimumAge;
    }
}

Wenn eine Autorisierungs Richtlinie mehrere Autorisierungs Anforderungen enthält, müssen alle Anforderungen bestanden werden, damit die Richtlinien Auswertung erfolgreich ist.If an authorization policy contains multiple authorization requirements, all requirements must pass in order for the policy evaluation to succeed. Anders ausgedrückt: mehrere Autorisierungs Anforderungen, die einer einzelnen Autorisierungs Richtlinie hinzugefügt werden, werden auf der Grundlage von und behandelt.In other words, multiple authorization requirements added to a single authorization policy are treated on an AND basis.

Hinweis

Eine Anforderung muss keine Daten oder Eigenschaften haben.A requirement doesn't need to have data or properties.

Autorisierungs HandlerAuthorization handlers

Ein Autorisierungs Handler ist dafür verantwortlich, die Eigenschaften einer Anforderung zu evaluieren.An authorization handler is responsible for the evaluation of a requirement's properties. Der Autorisierungs Handler wertet die Anforderungen anhand eines angegebenen authorizationhandlercontext aus, um zu bestimmen, ob der Zugriff zulässig ist.The authorization handler evaluates the requirements against a provided AuthorizationHandlerContext to determine if access is allowed.

Eine Anforderung kann mehrere Handleraufweisen.A requirement can have multiple handlers. Ein Handler kann den authorizationhandler <TRequirement> erben, wobei TRequirement die zu behandelnde Anforderung ist.A handler may inherit AuthorizationHandler<TRequirement>, where TRequirement is the requirement to be handled. Alternativ kann ein Handler iauthorizationhandler implementieren, um mehr als eine Art von Anforderung zu verarbeiten.Alternatively, a handler may implement IAuthorizationHandler to handle more than one type of requirement.

Verwenden eines Handlers für eine AnforderungUse a handler for one requirement

Im folgenden finden Sie ein Beispiel für eine 1:1-Beziehung, bei der ein minimaler Alters Handler eine einzige Anforderung verwendet:The following is an example of a one-to-one relationship in which a minimum age handler utilizes a single requirement:

using System;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   MinimumAgeRequirement requirement)
    {
        if (!context.User.HasClaim(c => c.Type == ClaimTypes.DateOfBirth &&
                                        c.Issuer == "http://contoso.com"))
        {
            //TODO: Use the following if targeting a version of
            //.NET Framework older than 4.6:
            //      return Task.FromResult(0);
            return Task.CompletedTask;
        }

        var dateOfBirth = Convert.ToDateTime(
            context.User.FindFirst(c => c.Type == ClaimTypes.DateOfBirth && 
                                        c.Issuer == "http://contoso.com").Value);

        int calculatedAge = DateTime.Today.Year - dateOfBirth.Year;
        if (dateOfBirth > DateTime.Today.AddYears(-calculatedAge))
        {
            calculatedAge--;
        }

        if (calculatedAge >= requirement.MinimumAge)
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Der vorangehende Code bestimmt, ob der aktuelle Benutzer Prinzipal über ein Geburtsdatum des Geburts Anspruchs verfügt, das von einem bekannten und vertrauenswürdigen Aussteller ausgestellt wurde.The preceding code determines if the current user principal has a date of birth claim which has been issued by a known and trusted Issuer. Die Autorisierung kann nicht ausgeführt werden, wenn der Anspruch fehlt. in diesem Fall wird eine abgeschlossene Aufgabe zurückgegeben.Authorization can't occur when the claim is missing, in which case a completed task is returned. Wenn ein Anspruch vorhanden ist, wird das Alter des Benutzers berechnet.When a claim is present, the user's age is calculated. Wenn der Benutzer das durch die Anforderung definierte mindestage erfüllt, wird die Autorisierung als erfolgreich eingestuft.If the user meets the minimum age defined by the requirement, authorization is deemed successful. Wenn die Autorisierung erfolgreich ist, context.Succeed wird mit der Erfüllung der Anforderungen als einziger Parameter aufgerufen.When authorization is successful, context.Succeed is invoked with the satisfied requirement as its sole parameter.

Verwenden eines Handlers für mehrere AnforderungenUse a handler for multiple requirements

Im folgenden finden Sie ein Beispiel für eine 1: n-Beziehung, in der ein Berechtigungs Handler drei verschiedene Arten von Anforderungen verarbeiten kann:The following is an example of a one-to-many relationship in which a permission handler can handle three different types of requirements:

using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class PermissionHandler : IAuthorizationHandler
{
    public Task HandleAsync(AuthorizationHandlerContext context)
    {
        var pendingRequirements = context.PendingRequirements.ToList();

        foreach (var requirement in pendingRequirements)
        {
            if (requirement is ReadPermission)
            {
                if (IsOwner(context.User, context.Resource) ||
                    IsSponsor(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
            else if (requirement is EditPermission ||
                     requirement is DeletePermission)
            {
                if (IsOwner(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }

    private bool IsOwner(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }

    private bool IsSponsor(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }
}

Der vorangehende Code durchsucht die " pdingrequirequirements"- — Eigenschaft mit den Anforderungen, die nicht als erfolgreich gekennzeichnet sind.The preceding code traverses PendingRequirements—a property containing requirements not marked as successful. Für eine ReadPermission Anforderung muss der Benutzer entweder ein Besitzer oder ein Sponsor sein, um auf die angeforderte Ressource zuzugreifen.For a ReadPermission requirement, the user must be either an owner or a sponsor to access the requested resource. Bei einer-oder- EditPermission DeletePermission Anforderung muss er ein Besitzer sein, um auf die angeforderte Ressource zugreifen zu können.In the case of an EditPermission or DeletePermission requirement, he or she must be an owner to access the requested resource.

HandlerregistrierungHandler registration

Handler werden während der Konfiguration in der Dienste-Sammlung registriert.Handlers are registered in the services collection during configuration. Zum Beispiel:For example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });

    services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();
}

Der vorangehende Code MinimumAgeHandler wird als Singleton registriert, indem aufgerufen wird services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>(); .The preceding code registers MinimumAgeHandler as a singleton by invoking services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();. Handler können mithilfe einer beliebigen integrierten Dienst Lebensdauerregistriert werden.Handlers can be registered using any of the built-in service lifetimes.

Was sollte ein Handler zurückgeben?What should a handler return?

Beachten Sie, dass die- Handle Methode im handlerbeispiel keinen Wert zurückgibt.Note that the Handle method in the handler example returns no value. Wie wird der Status "erfolgreich" oder "Fehler" angegeben?How is a status of either success or failure indicated?

  • Ein Handler gibt den Erfolg durch Aufrufen von an context.Succeed(IAuthorizationRequirement requirement) und übergibt die Anforderung, die erfolgreich überprüft wurde.A handler indicates success by calling context.Succeed(IAuthorizationRequirement requirement), passing the requirement that has been successfully validated.

  • Ein Handler muss im Allgemeinen keine Fehler behandeln, da andere Handler für dieselbe Anforderung erfolgreich ausgeführt werden können.A handler doesn't need to handle failures generally, as other handlers for the same requirement may succeed.

  • Um einen Fehler zu gewährleisten, müssen Sie, auch wenn andere Anforderungs Handler erfolgreich sind, den Befehl context.FailTo guarantee failure, even if other requirement handlers succeed, call context.Fail.

Wenn ein Handler context.Succeed oder aufruft context.Fail , werden alle anderen Handler immer noch aufgerufen.If a handler calls context.Succeed or context.Fail, all other handlers are still called. Dies ermöglicht die Generierung von Nebeneffekten, wie z. b. die Protokollierung, die auch dann stattfindet, wenn ein anderer Handler eine Anforderung erfolgreich überprüft oder nicht erfüllt hat.This allows requirements to produce side effects, such as logging, which takes place even if another handler has successfully validated or failed a requirement. Wenn diese Eigenschaft auf festgelegt false ist, wird die Ausführung von Handlern durch die invokehandlersafterfailure -Eigenschaft kurz verknüpft, wenn context.Fail aufgerufen wird.When set to false, the InvokeHandlersAfterFailure property short-circuits the execution of handlers when context.Fail is called. InvokeHandlersAfterFailure der Standardwert true ist. in diesem Fall werden alle Handler aufgerufen.InvokeHandlersAfterFailure defaults to true, in which case all handlers are called.

Hinweis

Autorisierungs Handler werden auch dann aufgerufen, wenn die Authentifizierung fehlschlägt.Authorization handlers are called even if authentication fails.

Warum sollte ich mehrere Handler für eine Anforderung wünschen?Why would I want multiple handlers for a requirement?

Wenn Sie evaluieren möchten, können Sie mehrere Handler für eine einzelne Anforderung implementieren.In cases where you want evaluation to be on an OR basis, implement multiple handlers for a single requirement. Beispielsweise verfügt Microsoft über Türen, die nur mit Schlüsselkarten geöffnet werden.For example, Microsoft has doors which only open with key cards. Wenn Sie Ihre Schlüsselkarte zuhause lassen, druckt die Rezeption einen temporären Aufkleber und öffnet die Tür für Sie.If you leave your key card at home, the receptionist prints a temporary sticker and opens the door for you. In diesem Szenario verfügen Sie über eine einzige Anforderung, buildingentry , aber mehrere Handler, die jeweils eine einzelne Anforderung untersuchen.In this scenario, you'd have a single requirement, BuildingEntry , but multiple handlers, each one examining a single requirement.

BuildingEntryRequirement.csBuildingEntryRequirement.cs

using Microsoft.AspNetCore.Authorization;

public class BuildingEntryRequirement : IAuthorizationRequirement
{
}

BadgeEntryHandler.csBadgeEntryHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class BadgeEntryHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "BadgeId" &&
                                       c.Issuer == "http://microsoftsecurity"))
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

TemporaryStickerHandler.csTemporaryStickerHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class TemporaryStickerHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, 
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "TemporaryBadgeId" &&
                                       c.Issuer == "https://microsoftsecurity"))
        {
            // We'd also check the expiration date on the sticker.
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Stellen Sie sicher, dass beide Handler registriertsind.Ensure that both handlers are registered. Wenn einer der beiden Handler erfolgreich ist, wenn eine Richtlinie den BuildingEntryRequirement auswertet, ist die Richtlinien Auswertung erfolgreich.If either handler succeeds when a policy evaluates the BuildingEntryRequirement, the policy evaluation succeeds.

Verwenden eines Func zum erfüllen einer RichtlinieUse a func to fulfill a policy

Es kann Situationen geben, in denen das erfüllen einer Richtlinie einfach im Code ausgedrückt werden kann.There may be situations in which fulfilling a policy is simple to express in code. Func<AuthorizationHandlerContext, bool>Beim Konfigurieren Ihrer Richtlinie mit dem Richtlinien Generator ist es möglich, eine bereitzustellen RequireAssertion .It's possible to supply a Func<AuthorizationHandlerContext, bool> when configuring your policy with the RequireAssertion policy builder.

Die vorherige könnte z. b. BadgeEntryHandler wie folgt umgeschrieben werden:For example, the previous BadgeEntryHandler could be rewritten as follows:

services.AddAuthorization(options =>
{
     options.AddPolicy("BadgeEntry", policy =>
        policy.RequireAssertion(context =>
            context.User.HasClaim(c =>
                (c.Type == "BadgeId" ||
                 c.Type == "TemporaryBadgeId") &&
                 c.Issuer == "https://microsoftsecurity")));
});

Zugreifen auf den MVC-Anforderungs Kontext in HandlernAccess MVC request context in handlers

Die HandleRequirementAsync Methode, die Sie in einem Autorisierungs Handler implementieren, verfügt über zwei Parameter: einen AuthorizationHandlerContext und den, den TRequirement Sie behandeln.The HandleRequirementAsync method you implement in an authorization handler has two parameters: an AuthorizationHandlerContext and the TRequirement you are handling. Frameworks wie MVC oder SignalR können jedes beliebige Objekt der- Resource Eigenschaft im hinzufügen AuthorizationHandlerContext , um zusätzliche Informationen zu übergeben.Frameworks such as MVC or SignalR are free to add any object to the Resource property on the AuthorizationHandlerContext to pass extra information.

MVC übergibt z. b. eine Instanz von authorizationfiltercontext in der- Resource Eigenschaft.For example, MVC passes an instance of AuthorizationFilterContext in the Resource property. Diese Eigenschaft ermöglicht den Zugriff auf HttpContext , RouteData und alles andere, was von MVC und Seiten bereitgestellt wird Razor .This property provides access to HttpContext, RouteData, and everything else provided by MVC and Razor Pages.

Die Verwendung der- Resource Eigenschaft ist Framework-spezifisch.The use of the Resource property is framework specific. Die Verwendung von Informationen in der- Resource Eigenschaft schränkt Ihre Autorisierungs Richtlinien auf bestimmte Frameworks ein.Using information in the Resource property limits your authorization policies to particular frameworks. Sie sollten die Resource -Eigenschaft mit dem is -Schlüsselwort umwandeln und dann bestätigen, dass die Umwandlung erfolgreich war, um sicherzustellen, dass der Code nicht mit einem stürzt InvalidCastExceptionYou should cast the Resource property using the is keyword, and then confirm the cast has succeeded to ensure your code doesn't crash with an InvalidCastException when run on other frameworks:

// Requires the following import:
//     using Microsoft.AspNetCore.Mvc.Filters;
if (context.Resource is AuthorizationFilterContext mvcContext)
{
    // Examine MVC-specific things like routing data.
}