Autorizzazione basata sulle risorse in ASP.NET Core MVC

Questo articolo descrive come autorizzare gli utenti per l'accesso alle risorse dell'app.

In un'app una risorsa è in genere rappresentata da una classe C# che include i dati archiviati in una raccolta, ad esempio una byte[] matrice. La classe contiene in genere metadati aggiuntivi relativi alla risorsa, ad esempio un identificatore di risorsa univoco, date, autori, informazioni di origine e un nome descrittivo per la visualizzazione in un'interfaccia utente. La raccolta che contiene i dati delle risorse viene in genere caricata dal contenuto del file fisico, da un oggetto di archiviazione cloud, da un oggetto in memoria o da un database.

L'autorizzazione basata sulle risorse richiede particolare attenzione nelle app ASP.NET Core. La valutazione degli attributi viene eseguita prima del data binding e prima dell'esecuzione di un'azione che carica una risorsa. L'autorizzazione dichiarativa con un [Authorize] attributo non è sufficiente per l'autorizzazione basata su risorse. L'app deve invece richiamare un metodo di autorizzazione personalizzato, un approccio noto come autorizzazione imperativa.

Visualizzare o scaricare il codice di esempio (procedura per il download).

Creare un'app ASP.NET Core con i dati utente protetti dall'autorizzazione contiene un'app di esempio che usa l'autorizzazione basata sulle risorse.

Gli esempi in questo articolo usano costruttori primari, disponibili in C# 12 (.NET 8) o versioni successive. Per altre informazioni, vedere Dichiara costruttori primari per classi e struct (esercitazione sulla documentazione di C#) e Costruttori primari (Guida di C#). Le applicazioni di esempio che accompagnano l'articolo e sono destinate a versioni di .NET precedenti a .NET 8 usano l'iniezione tramite costruttore.

Usare l'autorizzazione imperativa

L'autorizzazione viene implementata come un IAuthorizationService, che viene registrato nella raccolta di servizi all'avvio dell'app dal framework ASP.NET Core. Il servizio viene messo a disposizione di classi e azioni tramite iniezione delle dipendenze. Il controller seguente inserisce anche un repository di documenti, che lo sviluppatore crea e registra nel contenitore del servizio per gestire le operazioni dei documenti:

public class DocumentController(IAuthorizationService authorizationService,
    IDocumentRepository documentRepository) : Controller
{
    private readonly IAuthorizationService _authorizationService;
    private readonly IDocumentRepository _documentRepository;

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

    ...
}

IAuthorizationService ha due AuthorizeAsync sovraccarichi del metodo. Uno dei sovraccarichi accetta una risorsa e un nome di criterio:

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

L'altro sovraccarico accetta una risorsa e una raccolta di requisiti (IAuthorizationRequirement) da valutare:

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

Nell'esempio seguente la risorsa protetta viene caricata in un oggetto personalizzato Document . Viene richiamato un AuthorizeAsync overload per determinare se l'utente corrente è autorizzato a modificare il documento tramite un criterio di autorizzazione personalizzato "EditPolicy". Se authorizationResult.Succeeded è true, l'utente è autorizzato per il documento perché ha creato il documento (Document.Author corrisponde all'utente Name).

Note

Nell'esempio seguente si presuppone che l'autenticazione abbia esito positivo con il set di User proprietà .

[HttpGet]
public async Task<IActionResult> Edit(Guid documentId)
{
    Document document = _documentRepository.Find(documentId);

    ...

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

    ...
}

Creare un gestore basato su risorse

La creazione di un gestore di autorizzazione basato su risorse è simile alla creazione di un gestore di requisiti semplici. Creare una classe di requisiti personalizzata e implementare una classe del gestore dei requisiti. Per altre informazioni sulla creazione di una classe di requisiti, vedere Autorizzazione basata su criteri in ASP.NET Core.

La classe del gestore specifica il requisito e il tipo di risorsa. L'esempio seguente illustra un gestore che usa un SameAuthorRequirement requisito e una Document risorsa:

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 { }

Nell'esempio precedente si supponga che SameAuthorRequirement sia un caso speciale di una classe più generica SpecificAuthorRequirement . La SpecificAuthorRequirement classe (non visualizzata) contiene una Name proprietà che rappresenta il nome dell'autore. La proprietà Name può essere impostata sull'utente corrente.

Registrate il requisito e il gestore in Program.cs:

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("EditPolicy", policy =>
        policy.Requirements.Add(new SameAuthorRequirement()));

builder.Services.AddSingleton<IAuthorizationHandler, DocumentAuthorizationHandler>();

Registrate il requisito e il gestore in Startup.ConfigureServices:

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

services.AddSingleton<IAuthorizationHandler, DocumentAuthorizationHandler>();

Per ulteriori informazioni sulla creazione di criteri di autorizzazione, vedi Autorizzazione basata su criteri in ASP.NET Core.

Requisiti operativi

Per prendere decisioni in base ai risultati delle operazioni CRUD (Create, Read, Update, Delete), usare la OperationAuthorizationRequirement classe helper. Questa classe consente di scrivere un singolo gestore anziché una singola classe per ogni tipo di operazione. Per usarlo, specificare alcuni nomi di operazione:

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

Il gestore viene implementato come segue, usando un OperationAuthorizationRequirement requisito e una Document risorsa:

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

Il gestore precedente convalida l'operazione usando la risorsa, l'identità dell'utente e la proprietà Name del requisito.

Contestare e vietare con un gestore operativo delle risorse

In questa sezione viene illustrato come vengono elaborati i risultati delle azioni di verifica e proibizione e il modo in cui la sfida e la proibizione differiscono.

Quando l'autorizzazione ha esito negativo ma l'utente viene autenticato, l'app può restituire un ForbidResult, che informa il middleware di autenticazione che l'autorizzazione non è riuscita. Restituisce un ChallengeResult per gli utenti non autenticati. Per i client browser interattivi, potrebbe essere opportuno reindirizzare l'utente a una pagina di accesso.

Note

Nell'esempio seguente si presuppone che l'autenticazione abbia esito positivo con il set di User proprietà .

if ((await _authorizationService
    .AuthorizeAsync(User, document, Operations.Read)).Succeeded)
{
    return View(document);
}
else if (User.Identity?.IsAuthenticated ?? false)
{
    return new ForbidResult();
}
else
{
    return new ChallengeResult();
}