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

Quando il sistema di protezione dei dati viene inizializzato, viene applicato 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 in genere adatte per le App in esecuzione in un singolo computer.These settings are generally appropriate for apps running on a single machine. Vi sono casi in cui 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 avanzate.For these scenarios, the Data Protection system offers a rich configuration API.

Avviso

Analogamente ai file di configurazione, il gruppo di chiavi di protezione dati devono essere protetti usando le autorizzazioni appropriate.Similar to configuration files, the data protection key ring should be protected using appropriate permissions. È possibile scegliere di crittografare le chiavi a riposo, ma ciò non impedisce agli utenti malintenzionati di creazione di nuove chiavi.You can choose to encrypt keys at rest, but this doesn't prevent attackers from creating new keys. Di conseguenza, la sicurezza dell'app è interessata.Consequently, your app's security is impacted. Il percorso di archiviazione configurato con la protezione dei dati deve avere l'accesso limitato all'app stessa, simile al modo in cui che 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 il gruppo di chiavi su disco, usare le autorizzazioni del file.For example, if you choose to store your key ring on disk, use file system permissions. Assicurarsi che solo l'identità con cui eseguire l'app web ha leggere, scrivere e creare l'accesso 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 archiviazione Blob di Azure, solo l'app web deve avere la possibilità di leggere, scrivere o creare nuove voci nell'archivio blob di 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 la protezione dati opzioni.IDataProtectionBuilder exposes extension methods that you can chain together to configure Data Protection options.

ProtectKeysWithAzureKeyVaultProtectKeysWithAzureKeyVault

Per archiviare le chiavi nel Azure Key Vault, configurare il sistema con ProtectKeysWithAzureKeyVault nel Startup classe: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 il percorso di archiviazione chiavi (ad esempio, PersistKeysToAzureBlobStorage).Set the key ring storage location (for example, PersistKeysToAzureBlobStorage). Il percorso deve essere impostato perché la chiamata ProtectKeysWithAzureKeyVault implementa un' IXmlEncryptor che disattiva le impostazioni di protezione automatica dei dati, tra cui la posizione di archiviazione del gruppo di chiavi.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'archiviazione Blob di Azure per rendere persistente il gruppo di chiavi.The preceding example uses Azure Blob Storage to persist the key ring. Per altre informazioni, vedere provider archiviazione chiavi: Archiviazione di Azure.For more information, see Key storage providers: Azure Storage. È anche possibile salvare il gruppo di chiavi in locale con PersistKeysToFileSystem.You can also persist the key ring locally with PersistKeysToFileSystem.

Il keyIdentifier è l'identificatore di chiave di insieme di credenziali delle chiavi usato per la chiave di crittografia.The keyIdentifier is the key vault key identifier used for key encryption. Ad esempio, una chiave creata in insieme di credenziali delle chiavi denominato dataprotection nella contosokeyvault è 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/. L'App disponga Unwrap Key e Wrap Key delle autorizzazioni per l'insieme di credenziali delle chiavi.Provide the app with Unwrap Key and Wrap Key permissions to the key vault.

ProtectKeysWithAzureKeyVault Overload:ProtectKeysWithAzureKeyVault overloads:

PersistKeysToFileSystemPersistKeysToFileSystem

Per archiviare le chiavi in una condivisione UNC invece che nel % LOCALAPPDATA % percorso predefinito, 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 chiave, il sistema di Crittografa non sono più automaticamente le chiavi a riposo, perché non conoscere 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 per proteggere le chiavi a riposo mediante la chiamata a uno qualsiasi dei ProtectKeysWith* API di configurazione.You can configure the system to protect keys at rest by calling any of the ProtectKeysWith* configuration APIs. Si consideri l'esempio seguente, che archivia le chiavi in una condivisione UNC e consente di crittografare tali chiavi a riposo 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' X509Certificate2 al 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"));
}

Visualizzare chiave di crittografia dei dati per altri esempi e una discussione sui meccanismi di crittografia della chiave incorporato.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 la decrittografia di chiavi a riposo usando la matrice di X509Certificate2 certificati 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 per l'uso di durata di una chiave di 14 giorni anziché il valore predefinito di 90 giorni, 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 dati consente di isolare le app una da altra in base i relativi percorsi radice del contenuto, anche se si condivide lo stesso repository chiave fisico.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. Ciò impedisce che le app la comprensione di payload protetti di altro.This prevents the apps from understanding each other's protected payloads.

Condivisione protetta payload tra le app:To share protected payloads among apps:

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

DisableAutomaticKeyGenerationDisableAutomaticKeyGeneration

È possibile uno scenario in cui non si desidera distribuire automaticamente le chiavi (creazione di nuove chiavi) come approccio alla scadenza di un'app.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 di questo può essere impostate in una relazione primario/secondario, solo l'app principale è responsabile di competenze di gestione delle chiavi e App secondaria hanno semplicemente una vista di sola lettura del gruppo di chiavi in cui le app.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 considerare il gruppo di chiavi di sola lettura tramite la configurazione di 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 ogni applicazionePer-application isolation

Quando il sistema di protezione dei dati viene fornito da un host ASP.NET Core, automaticamente consente di isolare le app da uno a altro, anche se queste App sono in esecuzione con lo stesso account di processo di lavoro e utilizzano il materiale della chiave master stesso.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. Questo è un po' come il modificatore IsolateApps da System. Web <machineKey> elemento.This is somewhat similar to the IsolateApps modifier from System.Web's <machineKey> element.

Il meccanismo di isolamento funziona da prendere in considerazione ogni app nel computer locale come tenant univoco, pertanto il IDataProtector rooted per un'app include automaticamente l'ID dell'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. ID univoco dell'app è 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 web farm, questo valore è stabile, presupponendo che gli ambienti di IIS vengono configurati in modo analogo tra tutte le macchine nella 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 self-hosted in esecuzione sul server Kestrel, l'ID univoco è il percorso fisico per l'app sul 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—dell'app per le singole e della macchina stessa.The unique identifier is designed to survive resets—both of the individual app and of the machine itself.

Questo meccanismo di isolamento si presuppone che l'App non siano dannose.This isolation mechanism assumes that the apps are not malicious. Un'applicazione dannosa sempre può influire su qualsiasi altra app in esecuzione con lo stesso account di processo di lavoro.A malicious app can always impact any other app running under the same worker process account. In un ambiente di hosting condiviso in cui le app sono reciprocamente attendibili, provider di hosting deve provvedere a garantire isolamento a livello di sistema operativo tra le app, tra cui la separazione delle App sottostante repository della chiave.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 viene fornito da un host ASP.NET Core (ad esempio, se si crea un'istanza di quest'ultima con il DataProtectionProvider tipo concreto) isolamento delle app è disabilitata 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 è disabilitata, tutte le app supportate dal materiale della chiave stesso possono condividere i payload, purché forniscono appropriato scopi.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 fornire isolamento delle app in questo ambiente, chiamare il SetApplicationName metodo sulla configurazione dell'oggetto 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 gli algoritmi con UseCryptographicAlgorithmsChanging algorithms with UseCryptographicAlgorithms

Lo stack di protezione dei dati consente di modificare l'algoritmo predefinito usato dalle chiavi appena generato.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 EncryptionAlgorithm è AES-256-CBC e il valore predefinito ValidationAlgorithm è HMACSHA256.The default EncryptionAlgorithm is AES-256-CBC, and the default ValidationAlgorithm is HMACSHA256. Il criterio predefinito può essere impostato dall'amministratore di sistema tramite un dei criteri a livello di computer, ma una chiamata esplicita a UseCryptographicAlgorithms sovrascrivono 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.

La chiamata UseCryptographicAlgorithms consente di specificare l'algoritmo desiderato da un elenco incorporato predefinito.Calling UseCryptographicAlgorithms allows you to specify the desired algorithm from a predefined built-in list. Non è necessario preoccuparsi di 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 di CNG di AES se in esecuzione su Windows.In the scenario above, the Data Protection system attempts to use the CNG implementation of AES if running on Windows. In caso contrario, esegue il fallback a managed System.Security.Cryptography.Aes classe.Otherwise, it falls back to the managed System.Security.Cryptography.Aes class.

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

Suggerimento

Gli algoritmi di modifica non influenza le chiavi esistenti nel gruppo di chiavi.Changing algorithms doesn't affect existing keys in the key ring. Riguarda solo le chiavi appena generato.It only affects newly-generated keys.

Specifica di algoritmi personalizzati gestitiSpecifying custom managed algorithms

Per specificare gli algoritmi gestiti personalizzati, creare un ManagedAuthenticatedEncryptorConfiguration istanza che fa riferimento 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 gli algoritmi gestiti personalizzati, creare un ManagedAuthenticatedEncryptionSettings istanza che fa riferimento 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 il *proprietà del tipo devono puntare a concreto, implementazioni istanziabile (tramite un costruttore senza parametri pubblico) di SymmetricAlgorithm e KeyedHashAlgorithm, anche se la casi di speciali del sistema, ad esempio alcuni valori typeof(Aes) per motivi di praticità.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

Il 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 riempimento 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 KeyedHashAlgorithm deve avere una dimensione del digest di > = 128 bit, e deve supportare le chiavi di lunghezza uguale alla lunghezza di 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 è strettamente necessaria essere HMAC.The KeyedHashAlgorithm isn't strictly required to be HMAC.

Specifica gli algoritmi CNG di Windows personalizzatiSpecifying custom Windows CNG algorithms

Per specificare un algoritmo CNG di Windows personalizzato usando la crittografia in modalità CBC con convalida HMAC, creare un CngCbcAuthenticatedEncryptorConfiguration istanza che contiene le informazioni su algoritmi: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 usando la crittografia in modalità CBC con convalida HMAC, creare un CngCbcAuthenticatedEncryptionSettings istanza che contiene le informazioni su algoritmi: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 simmetriche debba avere una lunghezza della chiave di > = 128 bit, una dimensione del blocco di > = 64 bit, e deve supportare la crittografia in modalità CBC con riempimento 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 di hash deve avere una dimensione del digest di > = 128 bit e devono supportare viene aperto con la BCRYPT_ALG_gestire_HMAC_FLAG flag.The hash algorithm must have a digest size of >= 128 bits and must support being opened with the BCRYPT_ALG_HANDLE_HMAC_FLAG flag. Il *proprietà Provider possono essere impostate su null per usare il provider predefinito per l'algoritmo specificato.The *Provider properties can be set to null to use the default provider for the specified algorithm. Vedere le BCryptOpenAlgorithmProvider per altre informazioni.See the BCryptOpenAlgorithmProvider documentation for more information.

Per specificare un algoritmo CNG di Windows personalizzato usando la crittografia/contatore Galois modalità con la convalida, creare un CngGcmAuthenticatedEncryptorConfiguration istanza che contiene le informazioni su algoritmi: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 usando la crittografia/contatore Galois modalità con la convalida, creare un CngGcmAuthenticatedEncryptionSettings istanza che contiene le informazioni su algoritmi: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 simmetriche debba avere una lunghezza della chiave di > = 128 bit, una dimensione del blocco di esattamente a 128 bit, e deve supportare la crittografia di 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 il EncryptionAlgorithmProvider proprietà su null per usare il provider predefinito per l'algoritmo specificato.You can set the EncryptionAlgorithmProvider property to null to use the default provider for the specified algorithm. Vedere le BCryptOpenAlgorithmProvider per altre informazioni.See the BCryptOpenAlgorithmProvider documentation for more information.

Specifica altri algoritmi personalizzatiSpecifying other custom algorithms

Anche se non è esposta come un'API di alto livello, il sistema di protezione dei dati è sufficientemente estensibile per consentire la specifica di qualsiasi tipo 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 mantenere tutte le chiavi contenute all'interno di un modulo di protezione Hardware (HSM) e per fornire un'implementazione personalizzata di una core routine di crittografia e decrittografia.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. Visualizzare IAuthenticatedEncryptor nelle estendibilità della crittografia di base per altre informazioni.See IAuthenticatedEncryptor in Core cryptography extensibility for more information.

Mantenimento delle chiavi per l'hosting in un contenitore DockerPersisting keys when hosting in a Docker container

Durante l'hosting di un Docker contenitore, le chiavi devono essere mantenute in uno:When hosting in a Docker container, keys should be maintained in either:

  • Una cartella che è un volume di Docker che persiste oltre la durata del contenitore, ad esempio un volume condiviso o un volume montato 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.
  • Un provider esterno, ad esempio Azure Key Vault oppure Redis.An external provider, such as Azure Key Vault or Redis.

Risorse aggiuntiveAdditional resources