Skapa säkra .NET-mikrotjänster och webbprogram

Det finns så många aspekter av säkerhet i mikrotjänster och webbprogram att ämnet enkelt kan ta flera böcker som den här. I det här avsnittet fokuserar vi på autentisering, auktorisering och programhemligheter.

Implementera autentisering i .NET-mikrotjänster och webbprogram

Det är ofta nödvändigt att resurser och API:er som publiceras av en tjänst begränsas till vissa betrodda användare eller klienter. Det första steget för att fatta den här typen av förtroendebeslut på API-nivå är autentisering. Autentisering är en process för att verifiera en användares identitet på ett tillförlitligt sätt.

I mikrotjänstscenarier hanteras autentisering vanligtvis centralt. Om du använder en API Gateway är gatewayen en bra plats att autentisera, som du ser i bild 9–1. Om du använder den här metoden kontrollerar du att de enskilda mikrotjänsterna inte kan nås direkt (utan API Gateway) om inte ytterligare säkerhet finns för att autentisera meddelanden oavsett om de kommer från gatewayen eller inte.

Bild 9-1. Centraliserad autentisering med en API Gateway

När API Gateway centraliserar autentisering lägger den till användarinformation när begäranden vidarebefordras till mikrotjänsterna. Om tjänster kan nås direkt kan en autentiseringstjänst som Azure Active Directory eller en dedikerad mikrotjänst för autentisering som fungerar som en säkerhetstokentjänst (STS) användas för att autentisera användare. Förtroendebeslut delas mellan tjänster med säkerhetstoken eller cookies. (Dessa token kan delas mellan ASP.NET Core-program, om det behövs, genom att implementera cookiedelning.) Det här mönstret illustreras i bild 9-2.

Bild 9-2. Autentisering via identitets-mikrotjänst; förtroende delas med en auktoriseringstoken

När mikrotjänster nås direkt hanteras förtroende, inklusive autentisering och auktorisering, av en säkerhetstoken som utfärdas av en dedikerad mikrotjänst som delas mellan mikrotjänster.

Autentisera med ASP.NET Core Identity

Den primära mekanismen i ASP.NET Core för att identifiera ett programs användare är ASP.NET Core Identity-medlemskapssystemet . ASP.NET Core Identity lagrar användarinformation (inklusive inloggningsinformation, roller och anspråk) i ett datalager som konfigurerats av utvecklaren. Vanligtvis är datalagret för ASP.NET Core Identity ett Entity Framework-arkiv som tillhandahålls i Microsoft.AspNetCore.Identity.EntityFrameworkCore-paketet. Anpassade butiker eller andra tredjepartspaket kan dock användas för att lagra identitetsinformation i Azure Table Storage, CosmosDB eller andra platser.

Följande kod hämtas från MVC-projektmallen ASP.NET Core Web Application med individuell autentisering av användarkonto valt. Den visar hur du konfigurerar ASP.NET Core Identity med Entity Framework Core i filen Program.cs .

//...
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection")));

builder.Services.AddDefaultIdentity<IdentityUser>(options =>
    options.SignIn.RequireConfirmedAccount = true)
        .AddEntityFrameworkStores<ApplicationDbContext>();

builder.Services.AddRazorPages();
//...

När ASP.NET Core Identity har konfigurerats aktiverar du den genom att lägga till app.UseAuthentication() och endpoints.MapRazorPages() enligt följande kod i tjänstens Program.cs-fil :

//...
app.UseRouting();

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

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

Om du använder ASP.NET Core Identity kan du använda flera scenarier:

• Skapa ny användarinformation med userManager-typen (userManager.CreateAsync).

• Autentisera användare med typen SignInManager. Du kan använda signInManager.SignInAsync för att logga in direkt eller signInManager.PasswordSignInAsync för att bekräfta att användarens lösenord är korrekt och sedan logga in dem.

• Identifiera en användare baserat på information som lagras i en cookie (som läss av ASP.NET Core Identity-mellanprogram) så att efterföljande begäranden från en webbläsare inkluderar en inloggad användares identitet och anspråk.

ASP.NET Core Identity stöder också tvåfaktorautentisering.

För autentiseringsscenarier som använder ett lokalt användardatalager och som bevarar identiteten mellan begäranden med hjälp av cookies (vilket är typiskt för MVC-webbprogram) är ASP.NET Core Identity en rekommenderad lösning.

Autentisera med externa leverantörer

ASP.NET Core stöder även användning av externa autentiseringsprovidrar för att låta användare logga in via OAuth 2.0-flöden . Det innebär att användare kan logga in med befintliga autentiseringsprocesser från leverantörer som Microsoft, Google, Facebook eller Twitter och associera dessa identiteter med en ASP.NET Core-identitet i ditt program.

Om du vill använda extern autentisering, förutom att inkludera mellanprogrammet för autentisering som nämnts tidigare med hjälp av app.UseAuthentication()-metoden, måste du också registrera den externa providern i Program.cs som visas i följande exempel:

//...
services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();

services.AddAuthentication()
    .AddMicrosoftAccount(microsoftOptions =>
    {
        microsoftOptions.ClientId = builder.Configuration["Authentication:Microsoft:ClientId"];
        microsoftOptions.ClientSecret = builder.Configuration["Authentication:Microsoft:ClientSecret"];
    })
    .AddGoogle(googleOptions => { ... })
    .AddTwitter(twitterOptions => { ... })
    .AddFacebook(facebookOptions => { ... });
//...

Populära externa autentiseringsprovidrar och deras associerade NuGet-paket visas i följande tabell:

I samtliga fall måste du slutföra en programregistreringsprocedur som är leverantörsberoende och som vanligtvis omfattar:

1. Hämta ett klientapplikations-ID.
2. Hämta en klientprogramhemlighet.
3. Konfigurera en omdirigerings-URL som hanteras av mellanprogrammet för auktorisering och den registrerade providern
4. Du kan också konfigurera en utloggnings-URL för att hantera utloggning korrekt i ett scenario med enkel inloggning (SSO).

Mer information om hur du konfigurerar din app för en extern provider finns i autentiseringen för extern provider i dokumentationen om ASP.NET Core).

Bild 9-3. Välj alternativet Enskilda användarkonton för att använda extern autentisering när du skapar ett webbprogramprojekt i Visual Studio 2019.

Förutom de externa autentiseringsprovidrar som angavs tidigare är paket från tredje part tillgängliga som tillhandahåller mellanprogram för att använda många fler externa autentiseringsprovidrar. En lista finns i lagringsplatsen AspNet.Security.OAuth.Providers på GitHub.

Du kan också skapa ett eget mellanprogram för extern autentisering för att lösa vissa särskilda behov.

Autentisera med ägartoken

Att autentisera med ASP.NET Core Identity (eller identitet plus externa autentiseringsproviders) fungerar bra för många webbprogramscenarier där det är lämpligt att lagra användarinformation i en cookie. I andra scenarier är cookies dock inte ett naturligt sätt att bevara och överföra data.

I ett ASP.NET Core Web API som exponerar RESTful-slutpunkter som kan nås av ensidesprogram (SPA), av interna klienter eller till och med av andra webb-API:er, vill du vanligtvis använda ägartokenautentisering i stället. Denna typ av applikationer fungerar inte med cookies, men kan enkelt hämta en bärartoken och inkludera den i auktoriseringshuvudet för efterföljande begäranden. För att aktivera tokenautentisering stöder ASP.NET Core flera alternativ för att använda OAuth 2.0 och OpenID Connect.

Autentisera med en OpenID Connect- eller OAuth 2.0-identitetsprovider

Om användarinformation lagras i Azure Active Directory eller en annan identitetslösning som stöder OpenID Connect eller OAuth 2.0 kan du använda paketet Microsoft.AspNetCore.Authentication.OpenIdConnect för att autentisera med hjälp av OpenID Connect-arbetsflödet. Om du till exempel vill autentisera till mikrotjänsten Identity.Api i eShopOnContainers kan ett ASP.NET Core-webbprogram använda mellanprogram från paketet enligt följande förenklade exempel i Program.cs:

// Program.cs

var identityUrl = builder.Configuration.GetValue<string>("IdentityUrl");
var callBackUrl = builder.Configuration.GetValue<string>("CallBackUrl");
var sessionCookieLifetime = builder.Configuration.GetValue("SessionCookieLifetimeMinutes", 60);

// Add Authentication services

services.AddAuthentication(options =>
{
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddCookie(setup => setup.ExpireTimeSpan = TimeSpan.FromMinutes(sessionCookieLifetime))
.AddOpenIdConnect(options =>
{
    options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.Authority = identityUrl.ToString();
    options.SignedOutRedirectUri = callBackUrl.ToString();
    options.ClientId = useLoadTest ? "mvctest" : "mvc";
    options.ClientSecret = "secret";
    options.ResponseType = useLoadTest ? "code id_token token" : "code id_token";
    options.SaveTokens = true;
    options.GetClaimsFromUserInfoEndpoint = true;
    options.RequireHttpsMetadata = false;
    options.Scope.Add("openid");
    options.Scope.Add("profile");
    options.Scope.Add("orders");
    options.Scope.Add("basket");
    options.Scope.Add("marketing");
    options.Scope.Add("locations");
    options.Scope.Add("webshoppingagg");
    options.Scope.Add("orders.signalrhub");
});

// Build the app
//…
app.UseAuthentication();
//…
app.UseEndpoints(endpoints =>
{
    //...
});

När du använder det här arbetsflödet behövs inte mellanprogrammet ASP.NET Core Identity eftersom all lagring och autentisering av användarinformation hanteras av identitetstjänsten.

Utfärda säkerhetstoken från en ASP.NET Core-tjänst

Om du föredrar att utfärda säkerhetstoken för lokala ASP.NET Core Identity-användare i stället för att använda en extern identitetsprovider kan du dra nytta av några bra bibliotek från tredje part.

IdentityServer4 och OpenIddict är OpenID Connect-leverantörer som enkelt kan integreras med ASP.NET Core Identity så att du kan utfärda säkerhetstoken från en ASP.NET Core-tjänst. IdentityServer4-dokumentationen innehåller detaljerade instruktioner för hur du använder biblioteket. De grundläggande stegen för att använda IdentityServer4 för att utfärda token är dock följande.

1. Du konfigurerar IdentityServer4 i Program.cs genom att göra ett anrop till builder. Services.AddIdentityServer.

2. Du anropar app.UseIdentityServer i Program.cs till att lägga till IdentityServer4 i programmets bearbetningspipeline för HTTP-begäranden. På så sätt kan biblioteket hantera begäranden till OpenID Connect- och OAuth2-slutpunkter som /connect/token.

3. Du konfigurerar identitetsservern genom att ange följande data:

   • De autentiseringsuppgifter som ska användas för signering.

   • De identitets- och API-resurser som användarna kan begära åtkomst till:

     • API-resurser representerar skyddade data eller funktioner som en användare kan komma åt med en åtkomsttoken. Ett exempel på en API-resurs skulle vara ett webb-API (eller en uppsättning API:er) som kräver auktorisering.

     • Identitetsresurser representerar information (anspråk) som ges till en klient för att identifiera en användare. Anspråken kan innehålla användarnamn, e-postadress och så vidare.

   • Klienterna som ansluter för att begära token.

   • Lagringsmekanismen för användarinformation, till exempel ASP.NET Core Identity eller ett alternativ.

När du anger klienter och resurser som IdentityServer4 ska använda kan du skicka en samling av lämplig typ till metoder som hanterar minnesinterna klient- eller resurslager. Eller för mer komplexa scenarier kan du ange klienttypen eller resursprovidertypen via Dependency Injection.

En exempelkonfiguration för IdentityServer4 för användning av minnesinterna resurser och klienter som tillhandahålls av en anpassad IClientStore-typ kan se ut som i följande exempel:

// Program.cs

builder.Services.AddSingleton<IClientStore, CustomClientStore>();
builder.Services.AddIdentityServer()
    .AddSigningCredential("CN=sts")
    .AddInMemoryApiResources(MyApiResourceProvider.GetAllResources())
    .AddAspNetIdentity<ApplicationUser>();
//...

Förbruka säkerhetstoken

Att autentisera mot en OpenID Connect-slutpunkt eller utfärda egna säkerhetstoken omfattar vissa scenarier. Men hur är det med en tjänst som helt enkelt behöver begränsa åtkomsten till de användare som har giltiga säkerhetstoken som tillhandahölls av en annan tjänst?

I det scenariot är mellanprogram för autentisering som hanterar JWT-token tillgängliga i paketet Microsoft.AspNetCore.Authentication.JwtBearer . JWT står för "JSON Web Token" och är ett vanligt säkerhetstokenformat (definierat av RFC 7519) för kommunikation av säkerhetsanspråk. Ett förenklat exempel på hur du använder mellanprogram för att använda sådana token kan se ut som det här kodfragmentet, som hämtats från mikrotjänsten Ordering.Api för eShopOnContainers.

// Program.cs

var identityUrl = builder.Configuration.GetValue<string>("IdentityUrl");

// Add Authentication services

builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = AspNetCore.Authentication.JwtBearer.JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = AspNetCore.Authentication.JwtBearer.JwtBearerDefaults.AuthenticationScheme;

}).AddJwtBearer(options =>
{
    options.Authority = identityUrl;
    options.RequireHttpsMetadata = false;
    options.Audience = "orders";
});

// Build the app

app.UseAuthentication();
//…
app.UseEndpoints(endpoints =>
{
    //...
});

Parametrarna i den här användningen är:

• Audience representerar mottagaren av den inkommande token eller resursen som token ger åtkomst till. Om värdet som anges i den här parametern inte matchar parametern i token avvisas token.

• Authority är adressen till den tokenutfärdande autentiseringsservern. Mellanprogrammet för JWT-ägarautentisering använder den här URI:n för att hämta den offentliga nyckeln som kan användas för att verifiera tokens signatur. Mellanprogrammet bekräftar också att parametern iss i token matchar den här URI:n.

En annan parameter, RequireHttpsMetadata, är användbar i testsyfte. Du anger den här parametern till false så att du kan testa i miljöer där du inte har certifikat. I verkliga distributioner bör JWT-ägartoken alltid skickas endast via HTTPS.

Med det här mellanprogrammet på plats extraheras JWT-token automatiskt från auktoriseringshuvuden. De deserialiseras, verifieras (med hjälp av värdena i parametrarna Audience och Authority ) och lagras som användarinformation som ska refereras senare av MVC-åtgärder eller auktoriseringsfilter.

Mellanprogrammet för JWT-ägarautentisering kan också stödja mer avancerade scenarier, till exempel att använda ett lokalt certifikat för att verifiera en token om utfärdaren inte är tillgänglig. I det här scenariot kan du ange ett TokenValidationParameters objekt i objektet JwtBearerOptions .

Ytterligare resurser

• Dela cookies mellan program
  https://free.blessedness.top/aspnet/core/security/cookie-sharing

• Introduktion till identitet
  https://free.blessedness.top/aspnet/core/security/authentication/identity

• Tvåfaktorsautentisering med SMS
  https://free.blessedness.top/aspnet/core/security/authentication/2fa

• Aktivera autentisering med Hjälp av Facebook, Google och andra externa leverantörer
  https://free.blessedness.top/aspnet/core/security/authentication/social/

• Michell Anicas. En introduktion till OAuth 2
  https://www.digitalocean.com/community/tutorials/an-introduction-to-oauth-2

• AspNet.Security.OAuth.Providers (GitHub-lagringsplats för ASP.NET OAuth-leverantörer)
  https://github.com/aspnet-contrib/AspNet.Security.OAuth.Providers/tree/dev/src

• IdentityServer4. Officiell dokumentation
  https://identityserver4.readthedocs.io/en/latest/