Configurare la protezione dei dati ASP.NET CoreConfigure ASP.NET Core Data Protection

Quando il sistema di protezione dei dati viene inizializzato, applica le impostazioni predefinite in base all'ambiente operativo.When the Data Protection system is initialized, it applies default settings based on the operational environment. Queste impostazioni sono generalmente appropriate per le app in esecuzione in un singolo computer.These settings are generally appropriate for apps running on a single machine. In alcuni casi uno sviluppatore potrebbe voler modificare le impostazioni predefinite:There are cases where a developer may want to change the default settings:

  • L'app viene distribuita tra più computer.The app is spread across multiple machines.
  • Per motivi di conformità.For compliance reasons.

Per questi scenari, il sistema di protezione dei dati offre un'API di configurazione avanzata.For these scenarios, the Data Protection system offers a rich configuration API.

Avviso

Analogamente ai file di configurazione, l'anello della chiave di protezione dei dati deve essere protetto con le autorizzazioni appropriate.Similar to configuration files, the data protection key ring should be protected using appropriate permissions. È possibile scegliere di crittografare le chiavi inattive, ma ciò non impedisce agli utenti malintenzionati di creare nuove chiavi.You can choose to encrypt keys at rest, but this doesn't prevent attackers from creating new keys. Di conseguenza, si ripercuote sulla sicurezza dell'app.Consequently, your app's security is impacted. Il percorso di archiviazione configurato con la protezione dati dovrebbe avere accesso limitato all'app stessa, in modo analogo al modo in cui si proteggono i file di configurazione.The storage location configured with Data Protection should have its access limited to the app itself, similar to the way you would protect configuration files. Ad esempio, se si sceglie di archiviare l'anello chiave su disco, usare file system autorizzazioni.For example, if you choose to store your key ring on disk, use file system permissions. Verificare solo l'identità con cui viene eseguita l'app Web ha accesso in lettura, scrittura e creazione a tale directory.Ensure only the identity under which your web app runs has read, write, and create access to that directory. Se si usa l'archiviazione BLOB di Azure, solo l'app Web deve essere in grado di leggere, scrivere o creare nuove voci nell'archivio BLOB e così via.If you use Azure Blob Storage, only the web app should have the ability to read, write, or create new entries in the blob store, etc.

Il metodo di estensione AddDataProtection restituisce un IDataProtectionBuilder.The extension method AddDataProtection returns an IDataProtectionBuilder. IDataProtectionBuilder espone i metodi di estensione che è possibile concatenare per configurare le opzioni di protezione dati.IDataProtectionBuilder exposes extension methods that you can chain together to configure Data Protection options.

ProtectKeysWithAzureKeyVaultProtectKeysWithAzureKeyVault

Per archiviare le chiavi in Azure Key Vault, configurare il sistema con ProtectKeysWithAzureKeyVault nella classe Startup:To store keys in Azure Key Vault, configure the system with ProtectKeysWithAzureKeyVault in the Startup class:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToAzureBlobStorage(new Uri("<blobUriWithSasToken>"))
        .ProtectKeysWithAzureKeyVault("<keyIdentifier>", "<clientId>", "<clientSecret>");
}

Impostare la posizione di archiviazione dell'anello di chiave (ad esempio, PersistKeysToAzureBlobStorage).Set the key ring storage location (for example, PersistKeysToAzureBlobStorage). Il percorso deve essere impostato perché la chiamata a ProtectKeysWithAzureKeyVault implementa un IXmlEncryptor che disabilita le impostazioni di protezione dati automatiche, inclusa la posizione di archiviazione dell'anello di chiave.The location must be set because calling ProtectKeysWithAzureKeyVault implements an IXmlEncryptor that disables automatic data protection settings, including the key ring storage location. L'esempio precedente usa l'archivio BLOB di Azure per salvare in modo permanente l'anello di chiave.The preceding example uses Azure Blob Storage to persist the key ring. Per ulteriori informazioni, vedere provider di archiviazione Key: Archiviazione di Azure.For more information, see Key storage providers: Azure Storage. È anche possibile salvare l'anello chiave localmente con PersistKeysToFileSystem.You can also persist the key ring locally with PersistKeysToFileSystem.

Il keyIdentifier è l'identificatore di chiave dell'insieme di credenziali delle chiavi usato per la crittografia delle chiavi.The keyIdentifier is the key vault key identifier used for key encryption. Ad esempio, una chiave creata nell'insieme di credenziali delle chiavi denominata dataprotection nell'contosokeyvault ha l'identificatore di chiave https://contosokeyvault.vault.azure.net/keys/dataprotection/.For example, a key created in key vault named dataprotection in the contosokeyvault has the key identifier https://contosokeyvault.vault.azure.net/keys/dataprotection/. Fornire all'app le autorizzazioni Unwrap Key e Wrap Key per l'insieme di credenziali delle chiavi.Provide the app with Unwrap Key and Wrap Key permissions to the key vault.

Overload ProtectKeysWithAzureKeyVault:ProtectKeysWithAzureKeyVault overloads:

PersistKeysToFileSystemPersistKeysToFileSystem

Per archiviare le chiavi in una condivisione UNC anziché nel percorso predefinito % LocalAppData% , configurare il sistema con PersistKeysToFileSystem:To store keys on a UNC share instead of at the %LOCALAPPDATA% default location, configure the system with PersistKeysToFileSystem:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToFileSystem(new DirectoryInfo(@"\\server\share\directory\"));
}

Avviso

Se si modifica il percorso di persistenza della chiave, il sistema non crittografa più automaticamente le chiavi inattive, perché non è in grado di stabilire se DPAPI è un meccanismo di crittografia appropriato.If you change the key persistence location, the system no longer automatically encrypts keys at rest, since it doesn't know whether DPAPI is an appropriate encryption mechanism.

ProtectKeysWith*ProtectKeysWith*

È possibile configurare il sistema in modo da proteggere le chiavi inattive chiamando una delle API di configurazione ProtectKeysWith @ no__t-1 .You can configure the system to protect keys at rest by calling any of the ProtectKeysWith* configuration APIs. Si consideri l'esempio seguente, in cui le chiavi vengono archiviate in una condivisione UNC e le chiavi inattive vengono crittografate con un certificato X. 509 specifico:Consider the example below, which stores keys on a UNC share and encrypts those keys at rest with a specific X.509 certificate:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToFileSystem(new DirectoryInfo(@"\\server\share\directory\"))
        .ProtectKeysWithCertificate("thumbprint");
}

In ASP.NET Core 2,1 o versioni successive, è possibile fornire un oggetto X509Certificate2 a ProtectKeysWithCertificate, ad esempio un certificato caricato da un file:In ASP.NET Core 2.1 or later, you can provide an X509Certificate2 to ProtectKeysWithCertificate, such as a certificate loaded from a file:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToFileSystem(new DirectoryInfo(@"\\server\share\directory\"))
        .ProtectKeysWithCertificate(
            new X509Certificate2("certificate.pfx", "password"));
}

Per ulteriori esempi e discussioni sui meccanismi di crittografia chiavi incorporati, vedere la pagina relativa alla crittografia dei tasti inattivi.See Key Encryption At Rest for more examples and discussion on the built-in key encryption mechanisms.

UnprotectKeysWithAnyCertificateUnprotectKeysWithAnyCertificate

In ASP.NET Core 2,1 o versioni successive è possibile ruotare i certificati e decrittografare le chiavi inattive usando una matrice di certificati X509Certificate2 con UnprotectKeysWithAnyCertificate:In ASP.NET Core 2.1 or later, you can rotate certificates and decrypt keys at rest using an array of X509Certificate2 certificates with UnprotectKeysWithAnyCertificate:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .PersistKeysToFileSystem(new DirectoryInfo(@"\\server\share\directory\"))
        .ProtectKeysWithCertificate(
            new X509Certificate2("certificate.pfx", "password"));
        .UnprotectKeysWithAnyCertificate(
            new X509Certificate2("certificate_old_1.pfx", "password_1"),
            new X509Certificate2("certificate_old_2.pfx", "password_2"));
}

SetDefaultKeyLifetimeSetDefaultKeyLifetime

Per configurare il sistema in modo da usare una durata della chiave di 14 giorni anziché i 90 giorni predefiniti, usare SetDefaultKeyLifetime:To configure the system to use a key lifetime of 14 days instead of the default 90 days, use SetDefaultKeyLifetime:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .SetDefaultKeyLifetime(TimeSpan.FromDays(14));
}

SetApplicationNameSetApplicationName

Per impostazione predefinita, il sistema di protezione dei dati isola le app l'una dall'altra in base ai percorsi radice del contenuto , anche se condividono lo stesso repository di chiavi fisiche.By default, the Data Protection system isolates apps from one another based on their content root paths, even if they're sharing the same physical key repository. In questo modo si impedisce alle app di comprendere i payload protetti degli altri.This prevents the apps from understanding each other's protected payloads.

Per condividere i payload protetti tra le app:To share protected payloads among apps:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .SetApplicationName("shared app name");
}

DisableAutomaticKeyGenerationDisableAutomaticKeyGeneration

Si potrebbe avere uno scenario in cui non si vuole che un'app richieda automaticamente le chiavi (creare nuove chiavi) Man mano che si avvicinano alla scadenza.You may have a scenario where you don't want an app to automatically roll keys (create new keys) as they approach expiration. Un esempio potrebbe essere costituito da app configurate in una relazione primaria/secondaria, in cui solo l'app principale è responsabile per i problemi di gestione delle chiavi e le app secondarie dispongono semplicemente di una visualizzazione di sola lettura dell'anello chiave.One example of this might be apps set up in a primary/secondary relationship, where only the primary app is responsible for key management concerns and secondary apps simply have a read-only view of the key ring. Le app secondarie possono essere configurate per trattare l'anello chiave come di sola lettura configurando il sistema con DisableAutomaticKeyGeneration:The secondary apps can be configured to treat the key ring as read-only by configuring the system with DisableAutomaticKeyGeneration:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDataProtection()
        .DisableAutomaticKeyGeneration();
}

Isolamento per applicazionePer-application isolation

Quando il sistema di protezione dei dati viene fornito da un host ASP.NET Core, isola automaticamente le app l'una dall'altra, anche se tali app sono in esecuzione con lo stesso account del processo di lavoro e usano lo stesso materiale per le chiavi master.When the Data Protection system is provided by an ASP.NET Core host, it automatically isolates apps from one another, even if those apps are running under the same worker process account and are using the same master keying material. Si tratta di un tipo simile al modificatore IsolateApps dell'elemento <machineKey> di System. Web.This is somewhat similar to the IsolateApps modifier from System.Web's <machineKey> element.

Il meccanismo di isolamento funziona tenendo conto di ogni app nel computer locale come tenant univoco, quindi il IDataProtector rooted per una determinata app include automaticamente l'ID app come discriminatore.The isolation mechanism works by considering each app on the local machine as a unique tenant, thus the IDataProtector rooted for any given app automatically includes the app ID as a discriminator. L'ID univoco dell'app è il percorso fisico dell'app:The app's unique ID is the app's physical path:

  • Per le app ospitate in IIS, l'ID univoco è il percorso fisico IIS dell'app.For apps hosted in IIS, the unique ID is the IIS physical path of the app. Se un'app viene distribuita in un ambiente di Web farm, questo valore è stabile supponendo che gli ambienti IIS siano configurati in modo analogo in tutti i computer del Web farm.If an app is deployed in a web farm environment, this value is stable assuming that the IIS environments are configured similarly across all machines in the web farm.
  • Per le app indipendenti in esecuzione nel Server gheppio, l'ID univoco è il percorso fisico dell'app su disco.For self-hosted apps running on the Kestrel server, the unique ID is the physical path to the app on disk.

L'identificatore univoco è progettato per sopravvivere alle reimpostazioni @ no__t-0both della singola app e del computer stesso.The unique identifier is designed to survive resets—both of the individual app and of the machine itself.

Questo meccanismo di isolamento presuppone che le app non siano dannose.This isolation mechanism assumes that the apps are not malicious. Un'app dannosa può sempre influenzare qualsiasi altra app in esecuzione con lo stesso account del processo di lavoro.A malicious app can always impact any other app running under the same worker process account. In un ambiente host condiviso in cui le app non sono attendibili reciprocamente, il provider di hosting deve eseguire le operazioni necessarie per garantire l'isolamento a livello di sistema operativo tra le app, inclusa la separazione dei repository di chiavi sottostanti delle app.In a shared hosting environment where apps are mutually untrusted, the hosting provider should take steps to ensure OS-level isolation between apps, including separating the apps' underlying key repositories.

Se il sistema di protezione dei dati non è fornito da un host ASP.NET Core (ad esempio, se si crea un'istanza tramite il tipo concreto DataProtectionProvider), l'isolamento delle app è disabilitato per impostazione predefinita.If the Data Protection system isn't provided by an ASP.NET Core host (for example, if you instantiate it via the DataProtectionProvider concrete type) app isolation is disabled by default. Quando l'isolamento delle app è disabilitato, tutte le app supportate dallo stesso materiale di chiave possono condividere i payload purché forniscano gli scopiappropriati.When app isolation is disabled, all apps backed by the same keying material can share payloads as long as they provide the appropriate purposes. Per garantire l'isolamento delle app in questo ambiente, chiamare il metodo Seapplicationname nell'oggetto Configuration e specificare un nome univoco per ogni app.To provide app isolation in this environment, call the SetApplicationName method on the configuration object and provide a unique name for each app.

Modifica degli algoritmi con UseCryptographicAlgorithmsChanging algorithms with UseCryptographicAlgorithms

Lo stack di protezione dei dati consente di modificare l'algoritmo predefinito usato dalle chiavi appena generate.The Data Protection stack allows you to change the default algorithm used by newly-generated keys. Il modo più semplice per eseguire questa operazione consiste nel chiamare UseCryptographicAlgorithms dal callback di configurazione:The simplest way to do this is to call UseCryptographicAlgorithms from the configuration callback:

services.AddDataProtection()
    .UseCryptographicAlgorithms(
        new AuthenticatedEncryptorConfiguration()
    {
        EncryptionAlgorithm = EncryptionAlgorithm.AES_256_CBC,
        ValidationAlgorithm = ValidationAlgorithm.HMACSHA256
    });
services.AddDataProtection()
    .UseCryptographicAlgorithms(
        new AuthenticatedEncryptionSettings()
    {
        EncryptionAlgorithm = EncryptionAlgorithm.AES_256_CBC,
        ValidationAlgorithm = ValidationAlgorithm.HMACSHA256
    });

Il valore predefinito di EncryptionAlgorithm è AES-256-CBC e il valore predefinito di ValidationAlgorithm è HMACSHA256.The default EncryptionAlgorithm is AES-256-CBC, and the default ValidationAlgorithm is HMACSHA256. I criteri predefiniti possono essere impostati da un amministratore di sistema tramite criteri a livello di computer, ma una chiamata esplicita a UseCryptographicAlgorithms sostituisce i criteri predefiniti.The default policy can be set by a system administrator via a machine-wide policy, but an explicit call to UseCryptographicAlgorithms overrides the default policy.

Chiamando UseCryptographicAlgorithms è possibile specificare l'algoritmo desiderato da un elenco predefinito predefinito.Calling UseCryptographicAlgorithms allows you to specify the desired algorithm from a predefined built-in list. Non è necessario preoccuparsi dell'implementazione dell'algoritmo.You don't need to worry about the implementation of the algorithm. Nello scenario precedente, il sistema di protezione dei dati tenta di usare l'implementazione CNG di AES se eseguita in Windows.In the scenario above, the Data Protection system attempts to use the CNG implementation of AES if running on Windows. In caso contrario, viene eseguito il fallback alla classe gestita System. Security. Cryptography. AES .Otherwise, it falls back to the managed System.Security.Cryptography.Aes class.

È possibile specificare manualmente un'implementazione tramite una chiamata a UseCustomCryptographicAlgorithms.You can manually specify an implementation via a call to UseCustomCryptographicAlgorithms.

Suggerimento

La modifica degli algoritmi non influisce sulle chiavi esistenti nell'anello di chiave.Changing algorithms doesn't affect existing keys in the key ring. Influiscono solo sulle chiavi appena generate.It only affects newly-generated keys.

Specifica di algoritmi gestiti personalizzatiSpecifying custom managed algorithms

Per specificare algoritmi gestiti personalizzati, creare un'istanza di ManagedAuthenticatedEncryptorConfiguration che punti ai tipi di implementazione:To specify custom managed algorithms, create a ManagedAuthenticatedEncryptorConfiguration instance that points to the implementation types:

serviceCollection.AddDataProtection()
    .UseCustomCryptographicAlgorithms(
        new ManagedAuthenticatedEncryptorConfiguration()
    {
        // A type that subclasses SymmetricAlgorithm
        EncryptionAlgorithmType = typeof(Aes),

        // Specified in bits
        EncryptionAlgorithmKeySize = 256,

        // A type that subclasses KeyedHashAlgorithm
        ValidationAlgorithmType = typeof(HMACSHA256)
    });

Per specificare algoritmi gestiti personalizzati, creare un'istanza di ManagedAuthenticatedEncryptionSettings che punti ai tipi di implementazione:To specify custom managed algorithms, create a ManagedAuthenticatedEncryptionSettings instance that points to the implementation types:

serviceCollection.AddDataProtection()
    .UseCustomCryptographicAlgorithms(
        new ManagedAuthenticatedEncryptionSettings()
    {
        // A type that subclasses SymmetricAlgorithm
        EncryptionAlgorithmType = typeof(Aes),

        // Specified in bits
        EncryptionAlgorithmKeySize = 256,

        // A type that subclasses KeyedHashAlgorithm
        ValidationAlgorithmType = typeof(HMACSHA256)
    });

In genere, le proprietà *Type devono puntare alle implementazioni concrete, istanziabile (tramite un ctor pubblico senza parametri) di SymmetricAlgorithm e KeyedHashAlgorithm, anche se il sistema specifica alcuni valori come typeof(Aes) per convenienza.Generally the *Type properties must point to concrete, instantiable (via a public parameterless ctor) implementations of SymmetricAlgorithm and KeyedHashAlgorithm, though the system special-cases some values like typeof(Aes) for convenience.

Nota

SymmetricAlgorithm deve avere una lunghezza della chiave di ≥ 128 bit e una dimensione del blocco di ≥ 64 bit e deve supportare la crittografia in modalità CBC con la spaziatura interna PKCS #7.The SymmetricAlgorithm must have a key length of ≥ 128 bits and a block size of ≥ 64 bits, and it must support CBC-mode encryption with PKCS #7 padding. Il valore di KeyedHashAlgorithm deve avere una dimensione del digest di > = 128 bit e deve supportare chiavi di lunghezza uguale alla lunghezza del digest dell'algoritmo hash.The KeyedHashAlgorithm must have a digest size of >= 128 bits, and it must support keys of length equal to the hash algorithm's digest length. Il KeyedHashAlgorithm non deve necessariamente essere HMAC.The KeyedHashAlgorithm isn't strictly required to be HMAC.

Specifica di algoritmi CNG personalizzati di WindowsSpecifying custom Windows CNG algorithms

Per specificare un algoritmo CNG di Windows personalizzato utilizzando la crittografia in modalità CBC con la convalida HMAC, creare un'istanza di CngCbcAuthenticatedEncryptorConfiguration contenente le informazioni algoritmiche:To specify a custom Windows CNG algorithm using CBC-mode encryption with HMAC validation, create a CngCbcAuthenticatedEncryptorConfiguration instance that contains the algorithmic information:

services.AddDataProtection()
    .UseCustomCryptographicAlgorithms(
        new CngCbcAuthenticatedEncryptorConfiguration()
    {
        // Passed to BCryptOpenAlgorithmProvider
        EncryptionAlgorithm = "AES",
        EncryptionAlgorithmProvider = null,

        // Specified in bits
        EncryptionAlgorithmKeySize = 256,

        // Passed to BCryptOpenAlgorithmProvider
        HashAlgorithm = "SHA256",
        HashAlgorithmProvider = null
    });

Per specificare un algoritmo CNG di Windows personalizzato utilizzando la crittografia in modalità CBC con la convalida HMAC, creare un'istanza di CngCbcAuthenticatedEncryptionSettings contenente le informazioni algoritmiche:To specify a custom Windows CNG algorithm using CBC-mode encryption with HMAC validation, create a CngCbcAuthenticatedEncryptionSettings instance that contains the algorithmic information:

services.AddDataProtection()
    .UseCustomCryptographicAlgorithms(
        new CngCbcAuthenticatedEncryptionSettings()
    {
        // Passed to BCryptOpenAlgorithmProvider
        EncryptionAlgorithm = "AES",
        EncryptionAlgorithmProvider = null,

        // Specified in bits
        EncryptionAlgorithmKeySize = 256,

        // Passed to BCryptOpenAlgorithmProvider
        HashAlgorithm = "SHA256",
        HashAlgorithmProvider = null
    });

Nota

L'algoritmo di crittografia a blocchi simmetrico deve avere una lunghezza della chiave di > = 128 bit, una dimensione del blocco di > = 64 bit e deve supportare la crittografia in modalità CBC con la spaziatura interna PKCS #7.The symmetric block cipher algorithm must have a key length of >= 128 bits, a block size of >= 64 bits, and it must support CBC-mode encryption with PKCS #7 padding. L'algoritmo hash deve avere una dimensione del digest di > = 128 bit e deve supportare l'apertura con il flag BCRYPT @ no__t-0ALG @ no__t-1HANDLE @ no__t-2HMAC @ no__t-3FLAG.The hash algorithm must have a digest size of >= 128 bits and must support being opened with the BCRYPT_ALG_HANDLE_HMAC_FLAG flag. Le proprietà *Provider possono essere impostate su null per utilizzare il provider predefinito per l'algoritmo specificato.The *Provider properties can be set to null to use the default provider for the specified algorithm. Per ulteriori informazioni, vedere la documentazione di BCryptOpenAlgorithmProvider .See the BCryptOpenAlgorithmProvider documentation for more information.

Per specificare un algoritmo CNG di Windows personalizzato con la crittografia della modalità di crittografia/contatore con la convalida, creare un'istanza di CngGcmAuthenticatedEncryptorConfiguration contenente le informazioni algoritmiche:To specify a custom Windows CNG algorithm using Galois/Counter Mode encryption with validation, create a CngGcmAuthenticatedEncryptorConfiguration instance that contains the algorithmic information:

services.AddDataProtection()
    .UseCustomCryptographicAlgorithms(
        new CngGcmAuthenticatedEncryptorConfiguration()
    {
        // Passed to BCryptOpenAlgorithmProvider
        EncryptionAlgorithm = "AES",
        EncryptionAlgorithmProvider = null,

        // Specified in bits
        EncryptionAlgorithmKeySize = 256
    });

Per specificare un algoritmo CNG di Windows personalizzato con la crittografia della modalità di crittografia/contatore con la convalida, creare un'istanza di CngGcmAuthenticatedEncryptionSettings contenente le informazioni algoritmiche:To specify a custom Windows CNG algorithm using Galois/Counter Mode encryption with validation, create a CngGcmAuthenticatedEncryptionSettings instance that contains the algorithmic information:

services.AddDataProtection()
    .UseCustomCryptographicAlgorithms(
        new CngGcmAuthenticatedEncryptionSettings()
    {
        // Passed to BCryptOpenAlgorithmProvider
        EncryptionAlgorithm = "AES",
        EncryptionAlgorithmProvider = null,

        // Specified in bits
        EncryptionAlgorithmKeySize = 256
    });

Nota

L'algoritmo di crittografia a blocchi simmetrico deve avere una lunghezza della chiave di > = 128 bit, una dimensione del blocco di esattamente 128 bit e deve supportare la crittografia GCM.The symmetric block cipher algorithm must have a key length of >= 128 bits, a block size of exactly 128 bits, and it must support GCM encryption. È possibile impostare la proprietà EncryptionAlgorithmProvider su null per utilizzare il provider predefinito per l'algoritmo specificato.You can set the EncryptionAlgorithmProvider property to null to use the default provider for the specified algorithm. Per ulteriori informazioni, vedere la documentazione di BCryptOpenAlgorithmProvider .See the BCryptOpenAlgorithmProvider documentation for more information.

Specifica di altri algoritmi personalizzatiSpecifying other custom algorithms

Sebbene non venga esposto come API di prima classe, il sistema di protezione dei dati è sufficientemente estensibile per consentire l'impostazione di quasi tutti i tipi di algoritmo.Though not exposed as a first-class API, the Data Protection system is extensible enough to allow specifying almost any kind of algorithm. Ad esempio, è possibile salvare tutte le chiavi contenute in un modulo di protezione hardware (HSM) e fornire un'implementazione personalizzata delle routine di crittografia e decrittografia di base.For example, it's possible to keep all keys contained within a Hardware Security Module (HSM) and to provide a custom implementation of the core encryption and decryption routines. Per altre informazioni, vedere IAuthenticatedEncryptor nell' estensibilità di crittografia di base .See IAuthenticatedEncryptor in Core cryptography extensibility for more information.

Salvataggio permanente delle chiavi durante l'hosting in un contenitore DockerPersisting keys when hosting in a Docker container

Quando si esegue l'hosting in un contenitore Docker , le chiavi devono essere mantenute in uno degli:When hosting in a Docker container, keys should be maintained in either:

  • Una cartella che è un volume Docker che è permanente oltre la durata del contenitore, ad esempio un volume condiviso o un volume montato dall'host.A folder that's a Docker volume that persists beyond the container's lifetime, such as a shared volume or a host-mounted volume.
  • Provider esterno, ad esempio Azure Key Vault o Redis.An external provider, such as Azure Key Vault or Redis.

Salvataggio permanente delle chiavi con RedisPersisting keys with Redis

Per archiviare le chiavi è necessario usare solo le versioni di redis che supportano la persistenza dei dati Redis .Only Redis versions supporting Redis Data Persistence should be used to store keys. L' archiviazione BLOB di Azure è persistente e può essere usata per archiviare le chiavi.Azure Blob storage is persistent and can be used to store keys. Per altre informazioni, vedere questo problema su GitHub.For more information, see this GitHub issue.

Risorse aggiuntiveAdditional resources