Autorizzazione basata su attestazioni in ASP.NET Core

Quando viene creata un'identità, è possibile assegnare una o più attestazioni rilasciate da una parte attendibile. Un'asserzione è una coppia nome-valore che rappresenta ciò che il soggetto è, non le operazioni che il soggetto può eseguire. Ad esempio, potresti avere una patente di guida, rilasciata da un'autorità di patente di guida locale. La patente del conducente ha la data di nascita. In questo caso il nome dell'attestazione sarà DateOfBirth, il valore dell'attestazione sarà la data di nascita, ad esempio 8th June 1970 e l'autorità emittente sarebbe l'autorità di patente di guida. L'autorizzazione basata sulle attestazioni, al suo più semplice, controlla il valore di un'attestazione e consente l'accesso a una risorsa in base a tale valore. Ad esempio, se si vuole accedere a un night club, il processo di autorizzazione potrebbe essere:

L'addetto alla sicurezza degli accessi valuterà il valore della tua dichiarazione relativa alla data di nascita e se considerano attendibile l'autorità per la patente di guida prima di concederti l'accesso.

Un'identità può contenere più attestazioni con più valori e può contenere più attestazioni dello stesso tipo.

Aggiunta di controlli delle attestazioni

Controlli di autorizzazione basati su attestazioni:

• Sono dichiarativi.
• Vengono applicate a Razor pagine, controlleri o azioni all'interno di un controller.
• Non può essere applicato al livello del Razor gestore della pagina, ma deve essere applicato alla pagina.

Le attestazioni nel codice specificano le attestazioni che l'utente corrente deve possedere e, facoltativamente, il valore che l'attestazione deve contenere per accedere alla risorsa richiesta. I requisiti delle attestazioni sono basati su criteri; lo sviluppatore deve compilare e registrare un criterio che esprime i requisiti delle attestazioni.

Il tipo più semplice di politica di reclamo cerca la presenza di un reclamo e non controlla il valore.

Compilare e registrare la policy e chiamare UseAuthorization. La registrazione dei criteri avviene come parte della configurazione del servizio di autorizzazione, in genere nel Program.cs file :

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("EmployeeOnly", policy => policy.RequireClaim("EmployeeNumber"));

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseAuthentication();
app.UseAuthorization();

app.MapDefaultControllerRoute();
app.MapRazorPages();

app.Run();

In questo caso, i criteri di EmployeeOnly controllano la presenza di un'attestazione EmployeeNumber sull'identità corrente.

Applicare il criterio usando la Policy proprietà sull'attributo [Authorize] per specificare il nome del criterio.

[Authorize(Policy = "EmployeeOnly")]
public IActionResult VacationBalance()
{
    return View();
}

L'attributo [Authorize] può essere applicato a un intero controller o Razor a una pagina, nel qual caso solo le identità che corrispondono alla politica sono autorizzate ad accedere a qualunque Azione del controller.

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public ActionResult VacationBalance()
    {
        return View();
    }

    [AllowAnonymous]
    public ActionResult VacationPolicy()
    {
        return View();
    }
}

Il codice seguente applica l'attributo [Authorize] a una Razor pagina:

[Authorize(Policy = "EmployeeOnly")]
public class IndexModel : PageModel
{
    public void OnGet()
    {

    }
}

Le politiche non possono essere applicate a livello di gestore della pagina, ma devono essere applicate alla pagina.

Se si dispone di un controller protetto dall'attributo ma si vuole consentire l'accesso [Authorize] anonimo a determinate azioni, si applica l'attributo AllowAnonymousAttribute .

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public ActionResult VacationBalance()
    {
        return View();
    }

    [AllowAnonymous]
    public ActionResult VacationPolicy()
    {
        return View();
    }
}

Poiché i criteri non possono essere applicati a livello di Razor gestore di pagina, è consigliabile utilizzare un controller quando i criteri devono essere applicati proprio a questo livello. Il resto dell'app che non richiede criteri a livello di gestore pagina Razor può usare Razor Pages.

La maggior parte delle attestazioni è dotata di un valore. È possibile specificare un elenco di valori consentiti durante la creazione dei criteri. L'esempio seguente ha esito positivo solo per i dipendenti il cui numero di dipendente è 1, 2, 3, 4 o 5.

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("Founders", policy =>
        policy.RequireClaim("EmployeeNumber", "1", "2", "3", "4", "5"));

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseAuthentication();
app.UseAuthorization();

app.MapDefaultControllerRoute();
app.MapRazorPages();

app.Run();

Aggiungere un controllo attestazione generico

Se il valore dell'attestazione non è un singolo valore o è necessaria una trasformazione, usare RequireAssertion. Per altre informazioni, vedere Usare un func per soddisfare un criterio.

Valutazione di più politiche

Se vengono applicati più criteri a livello di controller e azione, tutti i criteri devono superare prima che venga concesso l'accesso:

[Authorize(Policy = "EmployeeOnly")]
public class SalaryController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public IActionResult Payslip()
    {
        return View();
    }

    [Authorize(Policy = "HumanResources")]
    public IActionResult UpdateSalary()
    {
        return View();
    }
}

Nell'esempio precedente qualsiasi identità che soddisfi i criteri di EmployeeOnly può accedere all'azione Payslip in quanto tale criterio viene applicato al controller. Tuttavia, per chiamare l'azione di UpdateSalary l'identità deve soddisfare sia i criteri di EmployeeOnly che i criteri di HumanResources.

Se si vogliono criteri più complessi, ad esempio l'assunzione di una data di nascita, il calcolo di un'età da esso e quindi il controllo che l'età è 21 o più recente, è necessario scrivere gestori di criteri personalizzati.

Nell'esempio seguente, entrambi i metodi del gestore di pagine devono soddisfare entrambe le politiche: e HumanResources.

[Authorize(Policy = "EmployeeOnly")]
[Authorize(Policy = "HumanResources")]
public class SalaryModel : PageModel
{
    public ContentResult OnGetPayStub()
    {
        return Content("OnGetPayStub");
    }

    public ContentResult OnGetSalary()
    {
        return Content("OnGetSalary");
    }
}

Quando viene creata un'identità, è possibile assegnare una o più attestazioni rilasciate da una parte attendibile. Un'attestazione è una coppia nome-valore che rappresenta ciò che il soggetto è, non ciò che il soggetto può fare. Ad esempio, potresti avere una patente di guida, rilasciata da un'autorità di patente di guida locale. La patente del conducente ha la data di nascita. In questo caso il nome dell'attestazione sarà DateOfBirth, il valore dell'attestazione sarà la data di nascita, ad esempio 8th June 1970 e l'autorità emittente sarebbe l'autorità di patente di guida. L'autorizzazione basata sulle attestazioni, al suo più semplice, controlla il valore di un'attestazione e consente l'accesso a una risorsa in base a tale valore. Ad esempio, se si vuole accedere a un night club, il processo di autorizzazione potrebbe essere:

L'addetto alla sicurezza degli accessi valuterà il valore della tua dichiarazione relativa alla data di nascita e se considerano attendibile l'autorità per la patente di guida prima di concederti l'accesso.

Un'identità può contenere più attestazioni con più valori e può contenere più attestazioni dello stesso tipo.

Aggiunta di controlli delle attestazioni

Controlli di autorizzazione basati su attestazioni:

• Sono dichiarativi.
• Vengono applicati a Razor pagine, controller o azioni all'interno di un controller.
• Non può essere applicato a livello di Razor gestore pagina, devono essere applicati alla pagina.

Le attestazioni nel codice specificano le attestazioni che l'utente corrente deve possedere e, facoltativamente, il valore che l'attestazione deve contenere per accedere alla risorsa richiesta. I requisiti delle attestazioni sono basati su criteri; lo sviluppatore deve compilare e registrare un criterio che esprime i requisiti delle attestazioni.

Il tipo più semplice di criterio di attestazione cerca la presenza di un'attestazione e non controlla il valore.

Configurare e registrare le politiche e chiamare UseAuthorization. La registrazione dei criteri avviene come parte della configurazione del servizio di autorizzazione, in genere nel Program.cs file :

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddAuthorization(options =>
{
   options.AddPolicy("EmployeeOnly", policy => policy.RequireClaim("EmployeeNumber"));
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseAuthentication();
app.UseAuthorization();

app.MapDefaultControllerRoute();
app.MapRazorPages();

app.Run();

In questo caso, i criteri di EmployeeOnly controllano la presenza di un'attestazione EmployeeNumber sull'identità corrente.

Applicare il criterio usando la Policy proprietà sull'attributo [Authorize] per specificare il nome del criterio.

[Authorize(Policy = "EmployeeOnly")]
public IActionResult VacationBalance()
{
    return View();
}

L'attributo [Authorize] può essere applicato a un intero controller o Razor a una pagina, nel qual caso solo le identità che corrispondono ai criteri sono autorizzate ad accedere a qualsiasi azione nel controller.

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public ActionResult VacationBalance()
    {
        return View();
    }

    [AllowAnonymous]
    public ActionResult VacationPolicy()
    {
        return View();
    }
}

Il codice seguente applica l'attributo [Authorize] a una Razor pagina:

[Authorize(Policy = "EmployeeOnly")]
public class IndexModel : PageModel
{
    public void OnGet()
    {

    }
}

Le politiche non possono essere applicate a livello di Razor gestore pagina, ma devono essere applicate alla pagina.

Se si dispone di un controller protetto dall'attributo ma si vuole consentire l'accesso [Authorize] anonimo a determinate azioni, si applica l'attributo AllowAnonymousAttribute .

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public ActionResult VacationBalance()
    {
        return View();
    }

    [AllowAnonymous]
    public ActionResult VacationPolicy()
    {
        return View();
    }
}

Poiché i criteri non possono essere applicati a livello del gestore di pagina, è consigliabile usare un controller quando i criteri devono essere applicati a livello del gestore di pagina. Il resto dell'app che non richiede criteri a livello di gestore pagina Razor può usare Razor Pages.

La maggior parte delle attestazioni è dotata di un valore. È possibile specificare un elenco di valori consentiti durante la creazione dei criteri. L'esempio seguente ha esito positivo solo per i dipendenti il cui numero di dipendente è 1, 2, 3, 4 o 5.

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("Founders", policy =>
                      policy.RequireClaim("EmployeeNumber", "1", "2", "3", "4", "5"));
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseAuthentication();
app.UseAuthorization();

app.MapDefaultControllerRoute();
app.MapRazorPages();

app.Run();

Aggiungere una verifica dell'attestazione generica

Se il valore dell'attestazione non è un singolo valore o è necessaria una trasformazione, usare RequireAssertion. Per altre informazioni, vedere Usare un func per soddisfare un criterio.

Valutazione di più politiche

Se vengono applicati più criteri a livello di controller e azione, tutti i criteri devono superare prima che venga concesso l'accesso:

[Authorize(Policy = "EmployeeOnly")]
public class SalaryController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public IActionResult Payslip()
    {
        return View();
    }

    [Authorize(Policy = "HumanResources")]
    public IActionResult UpdateSalary()
    {
        return View();
    }
}

Nell'esempio precedente qualsiasi identità che soddisfi i criteri di EmployeeOnly può accedere all'azione Payslip in quanto tale criterio viene applicato al controller. Tuttavia, per chiamare l'azione di UpdateSalary l'identità deve soddisfare sia i criteri di EmployeeOnly che i criteri di HumanResources.

Se si vogliono criteri più complessi, ad esempio l'assunzione di una data di nascita, il calcolo di un'età da esso e quindi il controllo che l'età è 21 o più recente, è necessario scrivere gestori di criteri personalizzati.

Nell'esempio seguente, entrambi i metodi del gestore di pagine devono soddisfare entrambe le EmployeeOnly politiche e le HumanResources politiche:

[Authorize(Policy = "EmployeeOnly")]
[Authorize(Policy = "HumanResources")]
public class SalaryModel : PageModel
{
    public ContentResult OnGetPayStub()
    {
        return Content("OnGetPayStub");
    }

    public ContentResult OnGetSalary()
    {
        return Content("OnGetSalary");
    }
}

Quando viene creata un'identità, è possibile assegnare una o più attestazioni rilasciate da una parte attendibile. Un'attestazione è una coppia nome-valore che rappresenta ciò che il soggetto è, non quello che il soggetto può fare. Ad esempio, potresti avere una patente di guida, rilasciata da un'autorità di patente di guida locale. La patente del conducente ha la data di nascita. In questo caso il nome dell'attestazione sarà DateOfBirth, il valore dell'attestazione sarà la data di nascita, ad esempio 8th June 1970 e l'autorità emittente sarebbe l'autorità di patente di guida. L'autorizzazione basata sulle attestazioni, al suo più semplice, controlla il valore di un'attestazione e consente l'accesso a una risorsa in base a tale valore. Ad esempio, se si vuole accedere a un night club, il processo di autorizzazione potrebbe essere:

Il responsabile della sicurezza degli accessi valuterà la validità della tua dichiarazione sulla data di nascita e se ritengono affidabile l'ente emittente (l'autorità preposta al rilascio delle patenti di guida) prima di concedere l'accesso.

Un'identità può contenere più attestazioni con più valori e può contenere più attestazioni dello stesso tipo.

Aggiunta dei controlli delle attestazioni

I controlli di autorizzazione basati sulle attestazioni sono dichiarativi: gli sviluppatori li incorporano all'interno del codice, in un controller o in un'azione all'interno di un controller, specificando le attestazioni che l'utente corrente deve possedere e, facoltativamente, il valore che l'attestazione deve contenere per accedere alla risorsa richiesta. I requisiti delle attestazioni sono basati su criteri, lo sviluppatore deve compilare e registrare un criterio che esprime i requisiti delle attestazioni.

Il tipo più semplice di criterio di attestazione verifica la presenza di un'attestazione e non controlla il valore.

Creare e registrare la politica. Questa operazione viene eseguita come parte della configurazione del servizio di autorizzazione, che in genere fa parte del file ConfigureServices()Startup.cs.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("EmployeeOnly", policy => policy.RequireClaim("EmployeeNumber"));
    });
}

Chiama UseAuthorization in Configure. Il codice seguente viene generato dai modelli di app Web core di ASP.NET:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseMigrationsEndPoint();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

In questo caso, i criteri di EmployeeOnly controllano la presenza di un'attestazione EmployeeNumber sull'identità corrente.

Applicare quindi il criterio usando la Policy proprietà sull'attributo [Authorize] per specificare il nome del criterio;

[Authorize(Policy = "EmployeeOnly")]
public IActionResult VacationBalance()
{
    return View();
}

L'attributo [Authorize] può essere applicato a un intero controller, in questa istanza solo le identità corrispondenti ai criteri potranno accedere a qualsiasi azione nel controller.

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public ActionResult VacationBalance()
    {
    }
}

Se si dispone di un controller protetto dall'attributo [Authorize], ma si vuole consentire l'accesso anonimo a determinate azioni, si applica l'attributo AllowAnonymousAttribute.

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public ActionResult VacationBalance()
    {
    }

    [AllowAnonymous]
    public ActionResult VacationPolicy()
    {
    }
}

La maggior parte delle attestazioni è dotata di un valore. È possibile specificare un elenco di valori consentiti durante la creazione dei criteri. L'esempio seguente ha esito positivo solo per i dipendenti il cui numero di dipendente è 1, 2, 3, 4 o 5.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("Founders", policy =>
                          policy.RequireClaim("EmployeeNumber", "1", "2", "3", "4", "5"));
    });
}

Aggiungere un controllo attestazioni generico

Se il valore dell'attestazione non è un singolo valore o è necessaria una trasformazione, usare RequireAssertion. Per altre informazioni, vedere Usare un func per soddisfare un criterio.

Valutazione di più politiche

Se si applicano più criteri a un controller o a un'azione, tutti i criteri devono essere passati prima che venga concesso l'accesso. Ad esempio:

[Authorize(Policy = "EmployeeOnly")]
public class SalaryController : Controller
{
    public ActionResult Payslip()
    {
    }

    [Authorize(Policy = "HumanResources")]
    public ActionResult UpdateSalary()
    {
    }
}

Nell'esempio precedente qualsiasi identità che soddisfi i criteri di EmployeeOnly può accedere all'azione Payslip in quanto tale criterio viene applicato al controller. Tuttavia, per chiamare l'azione di UpdateSalary l'identità deve soddisfare sia i criteri di EmployeeOnly che i criteri di HumanResources.

Se vuoi criteri più complessi, ad esempio prendere una data di nascita, calcolare l'età a partire da essa e verificare che l'età sia di 21 anni o più, devi scrivere gestori personalizzati di criteri.

Quando viene creata un'identità, è possibile assegnare una o più attestazioni rilasciate da una parte attendibile. Un'attestazione è una coppia nome-valore che rappresenta ciò che il soggetto è, non cosa può fare. Ad esempio, potresti avere una patente di guida, rilasciata da un'autorità di patente di guida locale. La patente del conducente ha la data di nascita. In questo caso il nome dell'attestazione sarà DateOfBirth, il valore dell'attestazione sarà la data di nascita, ad esempio 8th June 1970 e l'autorità emittente sarebbe l'autorità di patente di guida. L'autorizzazione basata sulle attestazioni, al suo più semplice, controlla il valore di un'attestazione e consente l'accesso a una risorsa in base a tale valore. Ad esempio, se si vuole accedere a un night club, il processo di autorizzazione potrebbe essere:

L'addetto alla sicurezza degli accessi valuterà il valore della tua dichiarazione relativa alla data di nascita e se considerano attendibile l'autorità per la patente di guida prima di concederti l'accesso.

Un'identità può contenere più attestazioni con più valori e può contenere più attestazioni dello stesso tipo.

Aggiunta di controlli delle attestazioni

I controlli di autorizzazione basati sulle attestazioni sono dichiarativi: gli sviluppatori li incorporano all'interno del codice, in un controller o in un'azione all'interno di un controller, specificando le attestazioni che l'utente corrente deve possedere e, facoltativamente, il valore che l'attestazione deve contenere per accedere alla risorsa richiesta. I requisiti delle attestazioni sono basati su criteri, lo sviluppatore deve compilare e registrare un criterio che esprime i requisiti delle attestazioni.

Il tipo più semplice di politica di reclamo cerca la presenza di un reclamo e non controlla il valore.

Costruire e registrare la politica. Questa operazione viene eseguita come parte della configurazione del servizio di autorizzazione, che in genere fa parte del file ConfigureServices()Startup.cs.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("EmployeeOnly", policy => policy.RequireClaim("EmployeeNumber"));
    });
}

In questo caso, i criteri di EmployeeOnly controllano la presenza di un'attestazione EmployeeNumber sull'identità corrente.

Applicare quindi il criterio usando la Policy proprietà sull'attributo [Authorize] per specificare il nome del criterio;

[Authorize(Policy = "EmployeeOnly")]
public IActionResult VacationBalance()
{
    return View();
}

L'attributo [Authorize] può essere applicato a un intero controller, in questa istanza solo le identità corrispondenti ai criteri potranno accedere a qualsiasi azione nel controller.

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public ActionResult VacationBalance()
    {
    }
}

Se si dispone di un controller protetto dall'attributo [Authorize], ma si vuole consentire l'accesso anonimo a determinate azioni, si applica l'attributo AllowAnonymousAttribute.

[Authorize(Policy = "EmployeeOnly")]
public class VacationController : Controller
{
    public ActionResult VacationBalance()
    {
    }

    [AllowAnonymous]
    public ActionResult VacationPolicy()
    {
    }
}

La maggior parte delle attestazioni è dotata di un valore. È possibile specificare un elenco di valori consentiti durante la creazione dei criteri. L'esempio seguente ha esito positivo solo per i dipendenti il cui numero di dipendente è 1, 2, 3, 4 o 5.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("Founders", policy =>
                          policy.RequireClaim("EmployeeNumber", "1", "2", "3", "4", "5"));
    });
}

Aggiungere un controllo attestazione generico

Se il valore dell'attestazione non è un singolo valore o è necessaria una trasformazione, usare RequireAssertion. Per altre informazioni, vedere Usare un func per soddisfare un criterio.

Valutazione di più politiche

Se si applicano più criteri a un controller o a un'azione, tutti i criteri devono essere passati prima che venga concesso l'accesso. Ad esempio:

[Authorize(Policy = "EmployeeOnly")]
public class SalaryController : Controller
{
    public ActionResult Payslip()
    {
    }

    [Authorize(Policy = "HumanResources")]
    public ActionResult UpdateSalary()
    {
    }
}

Nell'esempio precedente qualsiasi identità che soddisfi i criteri di EmployeeOnly può accedere all'azione Payslip in quanto tale criterio viene applicato al controller. Tuttavia, per chiamare l'azione di UpdateSalary l'identità deve soddisfare sia i criteri di EmployeeOnly che i criteri di HumanResources.

Se vuoi criteri più complessi, ad esempio l'acquisizione di una data di nascita, calcolarne l'età e poi verificare se l'età è pari o superiore a 21 anni, devi scrivere gestori personalizzati di criteri.