Fournisseurs de stockage de clés dans ASP.NET CoreKey storage providers in ASP.NET Core

Le système de protection des données utilise un mécanisme de découverte par défaut pour déterminer où les clés de chiffrement doivent être rendue persistante.The data protection system employs a discovery mechanism by default to determine where cryptographic keys should be persisted. Le développeur peut remplacer le mécanisme de découverte par défaut et spécifier manuellement l’emplacement.The developer can override the default discovery mechanism and manually specify the location.

Avertissement

Si vous spécifiez un emplacement de persistance des clés explicites, le système de protection des données annule l’inscription du chiffrement à clé par défaut au mécanisme de rest, donc les clés ne sont plus chiffrés au repos.If you specify an explicit key persistence location, the data protection system deregisters the default key encryption at rest mechanism, so keys are no longer encrypted at rest. Il est recommandé que vous en outre spécifier un mécanisme de chiffrement à clé explicite pour les déploiements de production.It's recommended that you additionally specify an explicit key encryption mechanism for production deployments.

Système de fichiersFile system

Pour configurer un référentiel de clé basée sur le système de fichiers, appelez le PersistKeysToFileSystem routine de configuration comme indiqué ci-dessous.To configure a file system-based key repository, call the PersistKeysToFileSystem configuration routine as shown below. Fournir un DirectoryInfo pointant vers le référentiel où les clés doivent être stockées :Provide a DirectoryInfo pointing to the repository where keys should be stored:

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

Le DirectoryInfo peut pointer vers un répertoire sur l’ordinateur local, ou il peut pointer vers un dossier sur un partage réseau.The DirectoryInfo can point to a directory on the local machine, or it can point to a folder on a network share. Si vous pointez vers un répertoire sur l’ordinateur local (et le scénario est que seules les applications sur l’ordinateur local requièrent l’accès à utiliser ce référentiel), envisagez d’utiliser Windows DPAPI (on Windows) pour chiffrer les clés au repos.If pointing to a directory on the local machine (and the scenario is that only apps on the local machine require access to use this repository), consider using Windows DPAPI (on Windows) to encrypt the keys at rest. Sinon, envisagez d’utiliser un certificat X.509 pour chiffrer les clés au repos.Otherwise, consider using an X.509 certificate to encrypt keys at rest.

Azure StorageAzure Storage

Le Microsoft.AspNetCore.DataProtection.AzureStorage package permet de stocker des clés de protection des données dans le stockage Blob Azure.The Microsoft.AspNetCore.DataProtection.AzureStorage package allows storing data protection keys in Azure Blob Storage. Les clés peuvent être partagées entre plusieurs instances d’une application web.Keys can be shared across several instances of a web app. Applications peuvent partager des cookies d’authentification ou de protection de CSRF sur plusieurs serveurs.Apps can share authentication cookies or CSRF protection across multiple servers.

Pour configurer le fournisseur de stockage Blob Azure, appelez une de la PersistKeysToAzureBlobStorage surcharges.To configure the Azure Blob Storage provider, call one of the PersistKeysToAzureBlobStorage overloads.

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

Si l’application web s’exécute comme un service Azure, les jetons d’authentification peuvent être créés automatiquement à l’aide de Microsoft.Azure.Services.AppAuthentication.If the web app is running as an Azure service, authentication tokens can be automatically created using Microsoft.Azure.Services.AppAuthentication.

var tokenProvider = new AzureServiceTokenProvider();
var token = await tokenProvider.GetAccessTokenAsync("https://storage.azure.com/");
var credentials = new StorageCredentials(new TokenCredential(token));
var storageAccount = new CloudStorageAccount(credentials, "mystorageaccount", "core.windows.net", useHttps: true);
var client = storageAccount.CreateCloudBlobClient();
var container = client.GetContainerReference("my-key-container");

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

services.AddDataProtection()
    .PersistKeysToAzureBlobStorage(container, "keys.xml");

Consultez plus d’informations sur la configuration de l’authentification de service à service.See more details about configuring service-to-service authentication.

RedisRedis

Le Microsoft.AspNetCore.DataProtection.StackExchangeRedis package permet de stocker des clés de protection des données dans un cache Redis.The Microsoft.AspNetCore.DataProtection.StackExchangeRedis package allows storing data protection keys in a Redis cache. Les clés peuvent être partagées entre plusieurs instances d’une application web.Keys can be shared across several instances of a web app. Applications peuvent partager des cookies d’authentification ou de protection de CSRF sur plusieurs serveurs.Apps can share authentication cookies or CSRF protection across multiple servers.

Le Microsoft.AspNetCore.DataProtection.Redis package permet de stocker des clés de protection des données dans un cache Redis.The Microsoft.AspNetCore.DataProtection.Redis package allows storing data protection keys in a Redis cache. Les clés peuvent être partagées entre plusieurs instances d’une application web.Keys can be shared across several instances of a web app. Applications peuvent partager des cookies d’authentification ou de protection de CSRF sur plusieurs serveurs.Apps can share authentication cookies or CSRF protection across multiple servers.

Pour configurer sur Redis, appelez une de la PersistKeysToStackExchangeRedis surcharges :To configure on Redis, call one of the PersistKeysToStackExchangeRedis overloads:

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

Pour configurer sur Redis, appelez une de la PersistKeysToRedis surcharges :To configure on Redis, call one of the PersistKeysToRedis overloads:

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

Pour plus d’informations, consultez les rubriques suivantes :For more information, see the following topics:

RegistreRegistry

S’applique uniquement aux déploiements de Windows.Only applies to Windows deployments.

Parfois l’application ne peut pas avoir accès en écriture au système de fichiers.Sometimes the app might not have write access to the file system. Imaginez un scénario dans lequel une application s’exécute comme compte de service virtuel (tel que w3wp.exed’identité du pool d’application).Consider a scenario where an app is running as a virtual service account (such as w3wp.exe's app pool identity). Dans ce cas, l’administrateur peut configurer une clé de Registre qui est accessible par l’identité de compte de service.In these cases, the administrator can provision a registry key that's accessible by the service account identity. Appelez le PersistKeysToRegistry méthode d’extension comme indiqué ci-dessous.Call the PersistKeysToRegistry extension method as shown below. Fournir un RegistryKey pointant vers l’emplacement de stockage des clés de chiffrement :Provide a RegistryKey pointing to the location where cryptographic keys should be stored:

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

Important

Nous vous recommandons d’utiliser Windows DPAPI pour chiffrer les clés au repos.We recommend using Windows DPAPI to encrypt the keys at rest.

Entity Framework CoreEntity Framework Core

Le Microsoft.AspNetCore.DataProtection.EntityFrameworkCore package fournit un mécanisme pour stocker les clés de protection des données à une base de données à l’aide d’Entity Framework Core.The Microsoft.AspNetCore.DataProtection.EntityFrameworkCore package provides a mechanism for storing data protection keys to a database using Entity Framework Core. Le Microsoft.AspNetCore.DataProtection.EntityFrameworkCore package NuGet doit être ajouté au fichier projet, il n’est pas dans le cadre de la Microsoft.AspNetCore.App métapackage.The Microsoft.AspNetCore.DataProtection.EntityFrameworkCore NuGet package must be added to the project file, it's not part of the Microsoft.AspNetCore.App metapackage.

Avec ce package, les clés peuvent être partagées entre plusieurs instances d’une application web.With this package, keys can be shared across multiple instances of a web app.

Pour configurer le fournisseur EF Core, appelez le PersistKeysToDbContext<TContext> méthode :To configure the EF Core provider, call the PersistKeysToDbContext<TContext> method:

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

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

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

Le paramètre générique, TContext, doit hériter de DbContext et implémenter IDataProtectionKeyContext:The generic parameter, TContext, must inherit from DbContext and implement 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; }
    }
}

Créer le DataProtectionKeys table.Create the DataProtectionKeys table.

Exécutez les commandes suivantes dans le Console du Gestionnaire de Package fenêtre de (PMC) :Execute the following commands in the Package Manager Console (PMC) window:

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

MyKeysContext est le DbContext défini dans l’exemple de code précédent.MyKeysContext is the DbContext defined in the preceding code sample. Si vous utilisez un DbContext avec un nom différent, remplacez votre DbContext nom MyKeysContext.If you're using a DbContext with a different name, substitute your DbContext name for MyKeysContext.

Le DataProtectionKeys classe/entité adopte la structure illustrée dans le tableau suivant.The DataProtectionKeys class/entity adopts the structure shown in the following table.

Propriété ou un champProperty/Field Type CLRCLR Type Type SQLSQL Type
Id int int, PK, non nullint, PK, not null
FriendlyName string nvarchar(MAX), nullnvarchar(MAX), null
Xml string nvarchar(MAX), nullnvarchar(MAX), null

Dépôt de clé personnaliséCustom key repository

Si les mécanismes d’origine ne sont pas appropriées, le développeur peut spécifier leur propre mécanisme de persistance des clés en fournissant un personnalisé IXmlRepository.If the in-box mechanisms aren't appropriate, the developer can specify their own key persistence mechanism by providing a custom IXmlRepository.