Dela via

Om auktorisering i .NET-mikrotjänster och webbprogram

  • Artikel

Dricks

Det här innehållet är ett utdrag från eBook, .NET Microservices Architecture for Containerized .NET Applications, tillgängligt på .NET Docs eller som en kostnadsfri nedladdningsbar PDF som kan läsas offline.

Ladda ned PDF

.NET Microservices Architecture for Containerized .NET Applications eBook cover thumbnail.

Efter autentiseringen måste ASP.NET Core Web API:er auktorisera åtkomst. Med den här processen kan en tjänst göra API:er tillgängliga för vissa autentiserade användare, men inte för alla. Auktorisering kan utföras baserat på användarnas roller eller baserat på en anpassad princip, som kan omfatta granskning av anspråk eller andra heuristiker.

Det är lika enkelt att begränsa åtkomsten till en ASP.NET Core MVC-väg som att tillämpa ett auktoriseringsattribut på åtgärdsmetoden (eller på kontrollantens klass om alla kontrollantens åtgärder kräver auktorisering), som du ser i följande exempel:

public class AccountController : Controller
{
    public ActionResult Login()
    {
    }

    [Authorize]
    public ActionResult Logout()
    {
    }
}

Om du lägger till ett auktoriseringsattribut utan parametrar begränsas åtkomsten till autentiserade användare för kontrollanten eller åtgärden som standard. Om du vill begränsa ett API till att endast vara tillgängligt för specifika användare kan attributet utökas för att ange nödvändiga roller eller principer som användarna måste uppfylla.

Implementera rollbaserad auktorisering

ASP.NET Core Identity har ett inbyggt rollbegrepp. Förutom användare lagrar ASP.NET Core Identity information om olika roller som används av programmet och håller reda på vilka användare som tilldelas till vilka roller. Dessa tilldelningar kan ändras programmatiskt med den RoleManager typ som uppdaterar roller i sparad lagring och den UserManager typ som kan bevilja eller återkalla roller från användare.

Om du autentiserar med JWT-ägartoken fyller mellanprogrammet ASP.NET Core JWT-ägarautentisering i en användares roller baserat på rollanspråk som finns i token. Om du vill begränsa åtkomsten till en MVC-åtgärd eller kontrollant till användare i specifika roller kan du inkludera en rollparameter i attributet Auktorisera anteckning (attribut) enligt följande kodfragment:

[Authorize(Roles = "Administrator, PowerUser")]
public class ControlPanelController : Controller
{
    public ActionResult SetTime()
    {
    }

    [Authorize(Roles = "Administrator")]
    public ActionResult ShutDown()
    {
    }
}

I det här exemplet kan endast användare i administratörs- eller PowerUser-rollerna komma åt API:er i ControlPanel-styrenheten (till exempel köra SetTime-åtgärden). ShutDown-API:et begränsas ytterligare för att endast tillåta åtkomst till användare i administratörsrollen.

Om du vill kräva att en användare har flera roller använder du flera auktoriseringsattribut, som du ser i följande exempel:

[Authorize(Roles = "Administrator, PowerUser")]
[Authorize(Roles = "RemoteEmployee ")]
[Authorize(Policy = "CustomPolicy")]
public ActionResult API1 ()
{
}

För att anropa API1 i det här exemplet måste en användare:

  • Vara i rollen Administratör eller PowerUser och

  • Ha rollen RemoteEmployee och

  • Uppfylla en anpassad hanterare för CustomPolicy-auktorisering.

Implementera principbaserad auktorisering

Anpassade auktoriseringsregler kan också skrivas med hjälp av auktoriseringsprinciper. Det här avsnittet innehåller en översikt. Mer information finns i ASP.NET auktoriseringsverkstad.

Anpassade auktoriseringsprinciper registreras i metoden Startup.ConfigureServices med hjälp av tjänsten. AddAuthorization-metod. Den här metoden tar ett ombud som konfigurerar ett AuthorizationOptions-argument.

services.AddAuthorization(options =>
{
    options.AddPolicy("AdministratorsOnly", policy =>
        policy.RequireRole("Administrator"));

    options.AddPolicy("EmployeesOnly", policy =>
        policy.RequireClaim("EmployeeNumber"));

    options.AddPolicy("Over21", policy =>
        policy.Requirements.Add(new MinimumAgeRequirement(21)));
});

Som du ser i exemplet kan principer associeras med olika typer av krav. När principerna har registrerats kan de tillämpas på en åtgärd eller kontrollant genom att skicka principens namn som principargumentet för attributet Auktorisera (till exempel [Authorize(Policy="EmployeesOnly")]) Principer kan ha flera krav, inte bara en (som visas i dessa exempel).

I föregående exempel är det första AddPolicy-anropet bara ett alternativt sätt att auktorisera efter roll. Om [Authorize(Policy="AdministratorsOnly")] tillämpas på ett API kan endast användare i administratörsrollen komma åt det.

Det andra AddPolicy anropet visar ett enkelt sätt att kräva att ett visst anspråk ska finnas för användaren. Metoden RequireClaim kan också ta förväntade värden för anspråket. Om värden anges uppfylls kravet endast om användaren har både ett anspråk av rätt typ och ett av de angivna värdena. Om du använder mellanprogrammet för JWT-ägarautentisering blir alla JWT-egenskaper tillgängliga som användaranspråk.

Den mest intressanta principen som visas här är i den tredje AddPolicy metoden, eftersom den använder ett anpassat auktoriseringskrav. Genom att använda anpassade auktoriseringskrav kan du ha stor kontroll över hur auktorisering utförs. För att detta ska fungera måste du implementera följande typer:

Om användaren uppfyller kravet anger ett anrop till context.Succeed att användaren är auktoriserad. Om det finns flera sätt som en användare kan uppfylla ett auktoriseringskrav på kan flera hanterare skapas.

Förutom att registrera anpassade principkrav med AddPolicy anrop måste du också registrera anpassade kravhanterare via beroendeinmatning (services.AddTransient<IAuthorizationHandler, MinimumAgeHandler>()).

Ett exempel på ett anpassat auktoriseringskrav och en hanterare för att kontrollera en användares ålder (baserat på ett DateOfBirth anspråk) finns i dokumentationen om ASP.NET Core-auktorisering.

Auktorisering och minimala API:ar

ASP.NET stöder minimala API:er som ett alternativ till styrenhetsbaserade API:er. Auktoriseringsprinciper är det rekommenderade sättet att konfigurera auktorisering för minimala API:er, vilket visas i det här exemplet:

// Program.cs
builder.Services.AddAuthorizationBuilder()
  .AddPolicy("admin_greetings", policy =>
        policy
            .RequireRole("admin")
            .RequireScope("greetings_api"));

// build the app

app.MapGet("/hello", () => "Hello world!")
  .RequireAuthorization("admin_greetings");

Ytterligare resurser

FöregåendeNästa