Ressourcenbasierte Autorisierung in ASP.NET Core

Der Autorisierungsansatz hängt von der Ressource ab. Beispielsweise ist nur der Ersteller eines Dokuments zu dessen Aktualisierung berechtigt. Folglich muss das Dokument aus dem Datenspeicher abgerufen werden, ehe eine Autorisierungsauswertung erfolgen kann.

Die Attributauswertung erfolgt vor der Datenbindung und vor Ausführung des Seitenhandlers oder der Aktion zum Laden des Dokuments. Aus diesen Gründen reicht eine deklarative Autorisierung mit einem [Authorize]-Attribut nicht aus. Stattdessen können Sie eine benutzerdefinierte Autorisierungsmethode aufrufen, die als imperative Autorisierung bezeichnet wird.

Zeigen Sie Beispielcode an, oder laden Sie diesen herunter (Vorgehensweise zum Herunterladen).

Unter Erstellen einer ASP.NET Core-App mit Benutzerdaten, die durch Autorisierung geschützt sind finden Sie eine Beispiel-App mit ressourcenbasierter Autorisierung.

Verwenden der imperativen Autorisierung

Die Autorisierung wird als ein IAuthorizationService-Dienst implementiert und in der Dienstsammlung als Anwendungsstartup registriert. Der Dienst wird Seitenhandlern oder Aktionen über Dependency Injection zur Verfügung gestellt.

public class DocumentController : Controller
{
    private readonly IAuthorizationService _authorizationService;
    private readonly IDocumentRepository _documentRepository;

    public DocumentController(IAuthorizationService authorizationService,
                              IDocumentRepository documentRepository)
    {
        _authorizationService = authorizationService;
        _documentRepository = documentRepository;
    }

IAuthorizationService hat zwei Überladungen der AuthorizeAsync-Methode: eine akzeptiert die Ressource und den Richtliniennamen, die andere die Ressource und eine Liste auszuwertender Anforderungen.

Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user,
                          object resource,
                          IEnumerable<IAuthorizationRequirement> requirements);
Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user,
                          object resource,
                          string policyName);

Im folgenden Beispiel wird die abzusichernde Ressource in ein benutzerdefiniertes Document-Objekt geladen. Eine AuthorizeAsync-Überladung wird aufgerufen, um zu bestimmen, ob der aktuelle Benutzer das bereitgestellte Dokument bearbeiten darf. Eine benutzerdefinierte EditPolicy-Autorisierungsrichtlinie wird bei der Entscheidung berücksichtigt. Weitere Informationen zum Erstellen von Autorisierungsrichtlinien finden Sie unter Benutzerdefinierte richtlinienbasierte Autorisierung.

Hinweis

In den folgenden Codebeispielen wird davon ausgegangen, dass die Authentifizierung ausgeführt und die User-Eigenschaft festgelegt hat.

public async Task<IActionResult> OnGetAsync(Guid documentId)
{
    Document = _documentRepository.Find(documentId);

    if (Document == null)
    {
        return new NotFoundResult();
    }

    var authorizationResult = await _authorizationService
            .AuthorizeAsync(User, Document, "EditPolicy");

    if (authorizationResult.Succeeded)
    {
        return Page();
    }
    else if (User.Identity.IsAuthenticated)
    {
        return new ForbidResult();
    }
    else
    {
        return new ChallengeResult();
    }
}

Schreiben eines ressourcenbasierten Handlers

Das Schreiben eines Handlers für ressourcenbasierte Autorisierung unterscheidet sich nicht wesentlich vom Schreiben eines einfachen Anforderungshandlers. Erstellen Sie eine benutzerdefinierte Anforderungsklasse, und implementieren Sie eine Anforderungshandlerklasse. Weitere Informationen zum Erstellen einer Anforderungsklasse finden Sie unter Anforderungen.

Die Handlerklasse gibt sowohl den Anforderungs- als auch den Ressourcentyp an. Ein Handler, der die Ressourcen SameAuthorRequirement und Document verwendet, sieht beispielsweise folgendermaßen aus:

public class DocumentAuthorizationHandler : 
    AuthorizationHandler<SameAuthorRequirement, Document>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   SameAuthorRequirement requirement,
                                                   Document resource)
    {
        if (context.User.Identity?.Name == resource.Author)
        {
            context.Succeed(requirement);
        }

        return Task.CompletedTask;
    }
}

public class SameAuthorRequirement : IAuthorizationRequirement { }

Stellen Sie sich im vorherigen Beispiel vor, dass es sich bei SameAuthorRequirement um einen Sonderfall einer generischeren SpecificAuthorRequirement-Klasse handelt. Die (nicht abgebildete) SpecificAuthorRequirement-Klasse enthält eine Name-Eigenschaft, die den Namen des Erstellers darstellt. Die Name-Eigenschaft kann auf den aktuellen Benutzer festgelegt werden.

Registrieren Sie die Anforderung und den Handler in Program.cs:

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("EditPolicy", policy =>
        policy.Requirements.Add(new SameAuthorRequirement()));
});

builder.Services.AddSingleton<IAuthorizationHandler, DocumentAuthorizationHandler>();
builder.Services.AddSingleton<IAuthorizationHandler, DocumentAuthorizationCrudHandler>();
builder.Services.AddScoped<IDocumentRepository, DocumentRepository>();

Betriebsanforderungen

Wenn Sie Entscheidungen basierend auf den Ergebnissen von CRUD-Vorgängen (Erstellen, Lesen, Aktualisieren, Löschen) treffen, verwenden Sie die Hilfsklasse OperationAuthorizationRequirement. Mit dieser Klasse können Sie für jeden Vorgangstyp einen einzelnen Handler anstelle einer einzelnen Klasse schreiben. Geben Sie zur Verwendung einige Vorgangsnamen an:

public static class Operations
{
    public static OperationAuthorizationRequirement Create =
        new OperationAuthorizationRequirement { Name = nameof(Create) };
    public static OperationAuthorizationRequirement Read =
        new OperationAuthorizationRequirement { Name = nameof(Read) };
    public static OperationAuthorizationRequirement Update =
        new OperationAuthorizationRequirement { Name = nameof(Update) };
    public static OperationAuthorizationRequirement Delete =
        new OperationAuthorizationRequirement { Name = nameof(Delete) };
}

Der Handler wird wie folgt mithilfe einer OperationAuthorizationRequirement-Anforderung und einer Document-Ressource implementiert:

public class DocumentAuthorizationCrudHandler :
    AuthorizationHandler<OperationAuthorizationRequirement, Document>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   OperationAuthorizationRequirement requirement,
                                                   Document resource)
    {
        if (context.User.Identity?.Name == resource.Author &&
            requirement.Name == Operations.Read.Name)
        {
            context.Succeed(requirement);
        }

        return Task.CompletedTask;
    }
}

Der vorherige Handler überprüft den Vorgang mithilfe der Ressource, der Benutzeridentität und der Name-Eigenschaft der Anforderung.

Aufforderung und Unterbindung mit einem betriebsbereiten Ressourcenhandler

In diesem Abschnitt wird gezeigt, wie die Ergebnisse der Aufforderung und Unterbindung von Aktionen verarbeitet werden und wie sich Aufforderung und Unterbindung unterscheiden.

Um einen betriebsbereiten Ressourcenhandler aufzurufen, geben Sie den Vorgang beim Aufruf von AuthorizeAsync in Ihrem Seitenhandler oder Ihrer Aktion an. Im folgenden Beispiel wird ermittelt, ob der authentifizierte Benutzer das bereitgestellte Dokument anzeigen darf.

Hinweis

In den folgenden Codebeispielen wird davon ausgegangen, dass die Authentifizierung ausgeführt und die User-Eigenschaft festgelegt hat.

public async Task<IActionResult> OnGetAsync(Guid documentId)
{
    Document = _documentRepository.Find(documentId);

    if (Document == null)
    {
        return new NotFoundResult();
    }

    var authorizationResult = await _authorizationService
            .AuthorizeAsync(User, Document, Operations.Read);

    if (authorizationResult.Succeeded)
    {
        return Page();
    }
    else if (User.Identity.IsAuthenticated)
    {
        return new ForbidResult();
    }
    else
    {
        return new ChallengeResult();
    }
}

Bei erfolgreicher Autorisierung wird die Seite zum Anzeigen des Dokuments zurückgegeben. Wenn die Autorisierung fehlschlägt, der Benutzer aber authentifiziert wurde, wird durch die Rückgabe von ForbidResult jede Authentifizierungsmiddleware darüber informiert, dass die Autorisierung fehlgeschlagen ist. ChallengeResult wird zurückgegeben, wenn die Authentifizierung ausgeführt werden muss. Für interaktive Browserclients kann es sinnvoll sein, den Benutzer zu einer Anmeldeseite umzuleiten.