Autoryzacja oparta na oświadczeniach w usłudze ASP.NET Core

Po utworzeniu tożsamości można przypisać do niej jedno lub więcej oświadczeń wystawionych przez zaufaną stronę. Oświadczenie jest parą wartości nazwy, która reprezentuje temat, a nie to, co podmiot może zrobić. Na przykład może istnieć prawo jazdy wydane przez lokalny urząd prawa jazdy. Twoja licencja kierowcy ma swoją datę urodzenia. W takim przypadku nazwa roszczenia to DateOfBirth, wartość oświadczenia będzie twoją datą urodzenia, na przykład 8th June 1970 a wystawca będzie organem prawa jazdy. Autoryzacja oparta na oświadczeniach, najprościej, sprawdza wartość oświadczenia i umożliwia dostęp do zasobu na podstawie tej wartości. Jeśli na przykład chcesz uzyskać dostęp do klubu nocnego, proces autoryzacji może być:

Urzędnik ochrony drzwi oceni wartość twojego roszczenia urodzenia i czy ufa wystawcy (organowi prawa jazdy) przed udzieleniem dostępu.

Tożsamość może zawierać wiele oświadczeń z wieloma wartościami i może zawierać wiele oświadczeń tego samego typu.

Dodawanie kontroli oświadczeń

Sprawdzanie autoryzacji opartej na oświadczeniach:

• Są deklaratywne.
• Są stosowane do Razor stron, kontrolerów lub akcji w obrębie kontrolera.
• Nie można zastosować ich na Razor poziomie obsługi strony. Należy je zastosować do strony.

Oświadczenia w kodzie określają oświadczenia, które bieżący użytkownik musi posiadać, i opcjonalnie wartość, którą oświadczenie musi przechowywać w celu uzyskania dostępu do żądanego zasobu. Wymagania dotyczące oświadczeń są oparte na zasadach; deweloper musi utworzyć i zarejestrować zasady wyrażające wymagania dotyczące oświadczeń.

Najprostszy typ zasad oświadczeń wyszukuje obecność oświadczenia i nie sprawdza wartości.

Skompiluj i zarejestruj zasady i wywołaj metodę UseAuthorization. Rejestrowanie zasad odbywa się w ramach konfiguracji usługi autoryzacji, zazwyczaj w Program.cs pliku:

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

W tym przypadku zasada EmployeeOnly sprawdza obecność roszczenia EmployeeNumber w aktualnej tożsamości.

Zastosuj zasady przy użyciu właściwości w atrybucie Policy , [Authorize] aby określić nazwę zasad.

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

Atrybut [Authorize] można zastosować do całego kontrolera lub Razor strony, w tym przypadku tylko tożsamości pasujące do zasad mogą mieć dostęp do dowolnej akcji na kontrolerze.

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

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

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

Następujący kod stosuje [Authorize] atrybut do Razor strony:

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

    }
}

Nie można stosować zasad na Razor poziomie procedury obsługi strony. Należy je zastosować do strony.

Jeśli masz kontroler, który jest chroniony przez [Authorize] atrybut, ale chcesz zezwolić na anonimowy dostęp do określonych akcji, należy zastosować AllowAnonymousAttribute atrybut.

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

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

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

Ponieważ zasady nie mogą być stosowane na Razor poziomie procedury obsługi strony, zalecamy użycie kontrolera, gdy zasady muszą być stosowane na poziomie procedury obsługi strony. Pozostała część aplikacji, która nie wymaga zasad na poziomie obsługi strony Razor, może używać Razor Pages.

Większość oświadczeń ma wartość. Podczas tworzenia zasad można określić listę dozwolonych wartości. Poniższy przykład powiedzie się tylko dla pracowników, których numer pracownika to 1, 2, 3, 4 lub 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();

Dodawanie sprawdzania oświadczeń ogólnych

Jeśli wartość oświadczenia nie jest pojedynczą wartością lub wymagane jest przekształcenie, użyj polecenia RequireAssertion. Aby uzyskać więcej informacji, zobacz Używanie func do spełnienia zasad.

Ocena wielu zasad

Jeśli na poziomie kontrolera i akcji zastosowano wiele zasad, wszystkie zasady muszą zostać przekazane przed udzieleniem dostępu:

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

W poprzednim przykładzie każda tożsamość spełniająca zasady EmployeeOnly może uzyskać dostęp do akcji Payslip, ponieważ te zasady są wymuszane na kontrolerze. Jednak w celu wywołania akcji UpdateSalary tożsamość musi spełniać zarówno zasadami EmployeeOnly, jak i zasadami HumanResources.

Jeśli potrzebujesz bardziej skomplikowanych zasad, takich jak przyjęcie daty urodzenia, obliczenie wieku od niego, a następnie sprawdzenie, czy wiek wynosi 21 lat, musisz napisać niestandardowe procedury obsługi zasad.

W poniższym przykładzie obie metody obsługi stron muszą spełniać zarówno zasady, jak EmployeeOnly i HumanResources zasady:

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

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