Viktiga lagringsproviders i ASP.NET Core

Dataskyddssystemet använder som standard en identifieringsmekanism för att avgöra var kryptografiska nycklar ska sparas. Utvecklaren kan åsidosätta standardidentifieringsmekanismen och manuellt ange platsen.

Varning

Om du anger en explicit plats för nyckelpersistence avregistrerar dataskyddssystemet standardnyckelkryptering i vila, så nycklar krypteras inte längre i vila. Vi rekommenderar att du dessutom anger en explicit nyckelkrypteringsmekanism för produktionsdistributioner.

Filsystem

Om du vill konfigurera en filsystembaserad nyckellagringsplats anropar du konfigurationsrutinen PersistKeysToFileSystem enligt nedan. Ange en DirectoryInfo pekar på lagringsplatsen där nycklar ska lagras:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToFileSystem(new DirectoryInfo(@"c:\temp-keys\"));
}

DirectoryInfo Kan peka på en katalog på den lokala datorn eller peka på en mapp på en nätverksresurs. Om du pekar på en katalog på den lokala datorn (och scenariot är att endast appar på den lokala datorn behöver åtkomst för att använda den här lagringsplatsen) bör du överväga att använda Windows DPAPI (i Windows) för att kryptera nycklarna i vila. I annat fall bör du överväga att använda ett X.509-certifikat för att kryptera vilande nycklar.

Azure Storage

Azure.Extensions.AspNetCore.DataProtection.Blobs-paketet tillåter lagring av dataskyddsnycklar i Azure Blob Storage. Nycklar kan delas mellan flera instanser av en webbapp. Appar kan dela autentiseringscookies eller CSRF-skydd på flera servrar.

Om du vill konfigurera Azure Blob Storage-providern anropar du en av överlagringarna PersistKeysToAzureBlobStorage .

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToAzureBlobStorage(new Uri("<blob URI including SAS token>"));
}

Om webbappen körs som en Azure-tjänst kan anslutningssträngen användas för att autentisera till Azure Storage med hjälp av Azure.Storage.Blobs.

Varning

Den här artikeln visar användningen av anslutningssträngar. Med en lokal databas behöver användaren inte autentiseras, men i produktion innehåller anslutningssträngar ibland ett lösenord för att autentisera. En resursägares lösenordsautentiseringsuppgifter (ROPC) är en säkerhetsrisk som bör undvikas i produktionsdatabaser. Produktionsappar bör använda det säkraste tillgängliga autentiseringsflödet. Mer information om autentisering för appar som distribueras till test- eller produktionsmiljöer finns i Säkra autentiseringsflöden.

string connectionString = "<connection_string>";
string containerName = "my-key-container";
string blobName = "keys.xml";
BlobContainerClient container = new BlobContainerClient(connectionString, containerName);

// optional - provision the container automatically
await container.CreateIfNotExistsAsync();

BlobClient blobClient = container.GetBlobClient(blobName);

services.AddDataProtection()
    .PersistKeysToAzureBlobStorage(blobClient);

Anmärkning

Anslutningssträngen till ditt lagringskonto finns i Azure-portalen under avsnittet "Åtkomstnycklar" eller genom att köra följande CLI-kommando:

az storage account show-connection-string --name <account_name> --resource-group <resource_group>

Redis

Med paketet Microsoft.AspNetCore.DataProtection.StackExchangeRedis kan du lagra dataskyddsnycklar i en Redis-cache. Nycklar kan delas mellan flera instanser av en webbapp. Appar kan dela autentiseringscookies eller CSRF-skydd på flera servrar.

För att konfigurera Redis kan du anropa en av överlagringarna PersistKeysToStackExchangeRedis.

public void ConfigureServices(IServiceCollection services)
{
    var redis = ConnectionMultiplexer.Connect("<URI>");
    services.AddDataProtection()
        .PersistKeysToStackExchangeRedis(redis, "DataProtection-Keys");
}

Mer information finns i följande avsnitt:

• StackExchange.Redis ConnectionMultiplexer
• Azure Redis Cache
• ASP.NET Core DataProtection-exempel

Registeringssystem

gäller endast för Windows-distributioner.

Ibland kanske appen inte har skrivåtkomst till filsystemet. Tänk dig ett scenario där en app körs som ett virtuellt tjänstkonto (till exempel w3wp.exe apppoolsidentitet). I dessa fall kan administratören tilldela en registernyckel som är tillgänglig för tjänstekontots identitet. PersistKeysToRegistry Anropa tilläggsmetoden enligt nedan. Ange en RegistryKey pekar på den plats där kryptografiska nycklar ska lagras:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToRegistry(Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Sample\keys", true));
}

Viktigt!

Vi rekommenderar att du använder Windows DPAPI för att kryptera nycklarna i vila.

Entity Framework Core

Paketet Microsoft.AspNetCore.DataProtection.EntityFrameworkCore tillhandahåller en mekanism för att lagra dataskyddsnycklar till en databas med Entity Framework Core. Microsoft.AspNetCore.DataProtection.EntityFrameworkCore NuGet-paketet måste läggas till i projektfilen, det är inte en del av Microsoft.AspNetCore.App metapaket.

Med det här paketet kan nycklar delas mellan flera instanser av en webbapp.

Om du vill konfigurera providern EF Core anropar du PersistKeysToDbContext metoden:

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<CookiePolicyOptions>(options =>
    {
        options.CheckConsentNeeded = context => true;
        options.MinimumSameSitePolicy = SameSiteMode.None;
    });

    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));

    // Add a DbContext to store your Database Keys
    services.AddDbContext<MyKeysContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("MyKeysConnection")));

    // using Microsoft.AspNetCore.DataProtection;
    services.AddDataProtection()
        .PersistKeysToDbContext<MyKeysContext>();

    services.AddDefaultIdentity<IdentityUser>()
        .AddDefaultUI(UIFramework.Bootstrap4)
        .AddEntityFrameworkStores<ApplicationDbContext>();
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Om du vill se kodkommentar översatta till andra språk än engelska kan du meddela oss i det här GitHub-diskussionsproblemet.

Den generiska parametern , TContextmåste ärva från DbContext och implementera IDataProtectionKeyContext:

using Microsoft.AspNetCore.DataProtection.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using WebApp1.Data;

namespace WebApp1
{
    class MyKeysContext : DbContext, IDataProtectionKeyContext
    {
        // A recommended constructor overload when using EF Core 
        // with dependency injection.
        public MyKeysContext(DbContextOptions<MyKeysContext> options) 
            : base(options) { }

        // This maps to the table that stores keys.
        public DbSet<DataProtectionKey> DataProtectionKeys { get; set; }
    }
}

DataProtectionKeys Skapa tabellen.

Visual Studio

Kör följande kommandon i fönstret Package Manager Console (PMC):

Add-Migration AddDataProtectionKeys -Context MyKeysContext
Update-Database -Context MyKeysContext

.NET CLI

Kör följande kommandon i ett kommandogränssnitt:

dotnet ef migrations add AddDataProtectionKeys --context MyKeysContext
dotnet ef database update --context MyKeysContext

MyKeysContext är DbContext definierat i föregående kodexempel. Om du använder ett DbContext med ett annat namn ersätter du ditt DbContext namn med MyKeysContext.

Klassen DataProtectionKeys /entiteten antar strukturen som visas i följande tabell.

Egenskap/fält	CLR-typ	SQL-typ
Id	int	int, PK, IDENTITY(1,1), inte null
FriendlyName	string	nvarchar(MAX)noll
Xml	string	nvarchar(MAX)noll

Lagringsplats för anpassad nyckel

Om de inbyggda mekanismerna inte är lämpliga kan utvecklaren ange sin egen mekanism för nyckelvaraktighet genom att tillhandahålla en anpassad IXmlRepository.