Sviluppare con Always Encrypted e il provider di dati .NET FrameworkDevelop using Always Encrypted with .NET Framework Data Provider

QUESTO ARGOMENTO SI APPLICA A: sìSQL Server (a partire dalla versione 2016)sìDatabase SQL di AzurenoAzure SQL Data Warehouse noParallel Data Warehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2016)yesAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

Questo articolo fornisce informazioni su come sviluppare applicazioni .NET usando Always Encrypted e il provider di dati .NET Framework per SQL Server.This article provides information on how to develop .NET applications using Always Encrypted and the .NET Framework Data Provider for SQL Server.

Always Encrypted consente alle applicazioni client di eseguire la crittografia dei dati sensibili senza mai rivelare i dati o le chiavi di crittografia a SQL Server o al database SQL di Azure.Always Encrypted allows client applications to encrypt sensitive data and never reveal the data or the encryption keys to SQL Server or Azure SQL Database. Un driver abilitato per Always Encrypted, come il provider di dati .NET Framework per SQL Server, fa tutto questo eseguendo in modo trasparente la crittografia e la decrittografia dei dati sensibili nell'applicazione client.An Always Encrypted enabled driver, such as the .NET Framework Data Provider for SQL Server, achieves this by transparently encrypting and decrypting sensitive data in the client application. Il driver determina automaticamente i parametri di query corrispondenti alle colonne di database con dati sensibili (protette mediante Always Encrypted) e crittografa i valori di tali parametri prima di passare i dati a SQL Server o al database SQL di Azure.The driver automatically determines which query parameters correspond to sensitive database columns (protected using Always Encrypted), and encrypts the values of those parameters before passing the data to SQL Server or Azure SQL Database. Analogamente, il driver esegue in modo trasparente la decrittografia dei dati, recuperati dalle colonne di database crittografate nei risultati delle query.Similarly, the driver transparently decrypts data retrieved from encrypted database columns in query results. Per altre informazioni, vedere Always Encrypted (motore di database).For more information, see Always Encrypted (Database Engine).

PrerequisitiPrerequisites

  • Configurare Always Encrypted nel database.Configure Always Encrypted in your database. Ciò implica il provisioning di chiavi Always Encrypted e l'impostazione della crittografia per le colonne di database selezionate.This involves provisioning Always Encrypted keys and setting up encryption for selected database columns. Se non è presente un database in cui Always Encrypted è configurato, seguire le istruzioni fornite nel blog di introduzione a Always Encrypted.If you do not already have a database with Always Encrypted configured, follow the directions in Getting Started with Always Encrypted.
  • Verificare che .NET Framework versione 4.6 o successiva sia installato nel computer di sviluppo.Make sure .NET Framework version 4.6 or higher is installed on your development machine. Per informazioni dettagliate, vedere .NET Framework 4.6.For details, see .NET Framework 4.6. È necessario anche assicurarsi che .NET Framework versione 4.6 o successiva sia configurato come versione di .NET Framework di destinazione nell'ambiente di sviluppo.You also need to make sure .NET Framework version 4.6 or higher is configured as the target .NET Framework version in your development environment. Se si usa Visual Studio, vedere Procedura: Destinare una versione di .NET Framework.If you are using Visual Studio, please refer to How to: Target a Version of the .NET Framework.

Nota

Il livello di supporto per Always Encrypted varia in base alle specifiche versioni di .NET Framework.The level of support for Always Encrypted in particular versions of .NET Framework varies. Per informazioni dettagliate, vedere la sezione Riferimento all'API di Always Encrypted riportata di seguito.Please, see the Always Encrypted API reference section below for details.

Abilitazione di Always Encrypted per le query dell'applicazioneEnabling Always Encrypted for Application Queries

Il modo più semplice per abilitare la crittografia dei parametri e la decrittografia dei risultati delle query per le colonne crittografate consiste nell'impostare il valore della parola chiave della stringa di connessione Impostazione di crittografia di colonna su Abilitata.The easiest way to enable the encryption of parameters, and the decryption of query results targeting the encrypted columns, is by setting the value of the Column Encryption Setting connection string keyword to enabled.

Di seguito è riportato un esempio di stringa di connessione che abilita la Crittografia sempre attiva:The following is an example of a connection string that enables Always Encrypted:

string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true; Column Encryption Setting=enabled";
SqlConnection connection = new SqlConnection(connectionString);

L'esempio seguente, invece, riporta un esempio equivalente che usa la proprietà SqlConnectionStringBuilder.ColumnEncryptionSetting.And, the following is an equivalent example using the SqlConnectionStringBuilder.ColumnEncryptionSetting Property.

SqlConnectionStringBuilder strbldr = new SqlConnectionStringBuilder();
strbldr.DataSource = "server63";
strbldr.InitialCatalog = "Clinic";
strbldr.IntegratedSecurity = true;
strbldr.ColumnEncryptionSetting = SqlConnectionColumnEncryptionSetting.Enabled;
SqlConnection connection = new SqlConnection(strbldr.ConnectionString);

Always Encrypted può anche essere abilitato per le singole query.Always Encrypted can also be enabled for individual queries. Vedere la sezione Controllo dell'impatto di Always Encrypted sulle prestazioni di seguito.See the Controlling performance impact of Always Encrypted section below. Si noti che l'abilitazione di Always Encrypted non è sufficiente per l'esito positivo della crittografia o della decrittografia.Note that, enabling Always Encrypted is not sufficient for encryption or decryption to succeed. È necessario anche assicurarsi che:You also need to make sure:

  • L'applicazione abbia le autorizzazioni di database VIEW ANY COLUMN MASTER KEY DEFINITION e VIEW ANY COLUMN ENCRYPTION KEY DEFINITION , necessarie per accedere ai metadati sulle chiavi Always Encrypted nel database.The application has the VIEW ANY COLUMN MASTER KEY DEFINITION and VIEW ANY COLUMN ENCRYPTION KEY DEFINITION database permissions, required to access the metadata about Always Encrypted keys in the database. Per informazioni dettagliate, vedere la sezione Autorizzazioni in Always Encrypted (motore di database).For details, see Permissions section in Always Encrypted (Database Engine).
  • L'applicazione può accedere alla chiave master della colonna che protegge le chiavi di crittografia di colonna, crittografando le colonne di database sottoposte a query.The application can access the column master key that protects the column encryption keys, encrypting the queried database columns.

Recupero e modifica di dati nelle colonne crittografateRetrieving and Modifying Data in Encrypted Columns

Dopo aver abilitato Always Encrypted per le query dell'applicazione, è possibile usare API ADO.NET standard (vedere Recupero e modifica dei dati in ADO.NET) o le API del provider di dati .NET Framework per SQL Server , definite in System.Data.SqlClient Namespace, per recuperare o modificare dati nelle colonne di database crittografate.Once you enable Always Encrypted for application queries, you can use standard ADO.NET APIs (see Retrieving and Modifying Data in ADO.NET) or the .NET Framework Data Provider for SQL Server APIs, defined in the System.Data.SqlClient Namespace, to retrieve or modify data in encrypted database columns. Supponendo che l'applicazione abbia le autorizzazioni per il database necessarie e possa accedere alla chiave master della colonna, il provider di dati .NET Framework per SQL Server eseguirà la crittografia di eventuali parametri di query destinati a colonne crittografate ed eseguirà la decrittografia dei dati recuperati dalle colonne che restituiscono valori di testo non crittografato di tipi .NET, corrispondenti ai tipi di dati di SQL Server impostati per le colonne nello schema del database.Assuming your application has the required database permissions and can access the column master key, the .NET Framework Data Provider for SQL Server will encrypt any query parameters that target encrypted columns, and will decrypt data retrieved from encrypted columns returning plaintext values of .NET types, corresponding to the SQL Server data types set for the columns in the database schema. Se Always Encrypted non è abilitato, le query con parametri destinati alle colonne crittografate avranno esito negativo.If Always Encrypted is not enabled, queries with parameters that target encrypted columns will fail. Le query possono comunque recuperare dati dalle colonne crittografate, a condizione che non presentino parametri destinati alle colonne crittografate.Queries can still retrieve data from encrypted columns, as long as the query has no parameters targeting encrypted columns. Tuttavia, il provider di dati .NET Framework per SQL Server non proverà a decrittografare tutti i valori recuperati dalle colonne crittografate e l'applicazione riceverà dati crittografati binari (come matrici di byte).However, the .NET Framework Data Provider for SQL Server will not attempt to decrypt any values retrieved from encrypted columns and the application will receive binary encrypted data (as byte arrays).

La tabella seguente riepiloga il comportamento delle query, a seconda che Always Encrypted sia abilitato o meno:The below table summarizes the behavior of queries, depending on whether Always Encrypted is enabled or not:

Caratteristica della queryQuery characteristic Always Encrypted è abilitato e l'applicazione può accedere alle chiavi e ai metadati delle chiaviAlways Encrypted is enabled and application can access the keys and key metadata Always Encrypted è abilitato e l'applicazione non può accedere alle chiavi o ai metadati delle chiaviAlways Encrypted is enabled and application cannot access the keys or key metadata Always Encrypted è disabilitatoAlways Encrypted is disabled
Query con parametri destinati alle colonne crittografate.Queries with parameters targeting encrypted columns. I valori dei parametri vengono crittografati in modo trasparente.Parameter values are transparently encrypted. ErroreError ErroreError
Query che recuperano dati dalle colonne crittografate, senza parametri destinati alle colonne crittografate.Queries retrieving data from encrypted columns, without parameters targeting encrypted columns. I risultati delle colonne vengono decrittografati in modo trasparente.Results from encrypted columns are transparently decrypted. L'applicazione riceve valori di testo non crittografato dei tipi di dati .NET corrispondenti ai tipi di SQL Server configurati per le colonne crittografate.The application receives plaintext values of the .NET datatypes corresponding to the SQL Server types configured for the encrypted columns. ErroreError I risultati delle colonne crittografate non vengono decrittografate.Results from encrypted columns are not decrypted. L'applicazione riceve i valori crittografati come matrici di byte (byte[]).The application receives encrypted values as byte arrays (byte[]).

Gli esempi seguenti illustrano il recupero e la modifica dei dati nelle colonne crittografate.The following examples illustrate retrieving and modifying data in encrypted columns. Negli esempi si presuppone la presenza della tabella di destinazione con lo schema seguente.The examples assume the target table with the below schema. Si noti che le colonne SSN e BirthDate nascita sono crittografate.Note that the SSN and BirthDate columns are encrypted.

CREATE TABLE [dbo].[Patients]([PatientId] [int] IDENTITY(1,1), 
 [SSN] [char](11) COLLATE Latin1_General_BIN2 
 ENCRYPTED WITH (ENCRYPTION_TYPE = DETERMINISTIC, 
 ALGORITHM = 'AEAD_AES_256_CBC_HMAC_SHA_256', 
 COLUMN_ENCRYPTION_KEY = CEK1) NOT NULL,
 [FirstName] [nvarchar](50) NULL,
 [LastName] [nvarchar](50) NULL, 
 [BirthDate] [date] 
 ENCRYPTED WITH (ENCRYPTION_TYPE = RANDOMIZED, 
 ALGORITHM = 'AEAD_AES_256_CBC_HMAC_SHA_256', 
 COLUMN_ENCRYPTION_KEY = CEK1) NOT NULL
 PRIMARY KEY CLUSTERED ([PatientId] ASC) ON [PRIMARY])
 GO

Esempio di inserimento di datiInserting Data Example

Questo esempio illustra come inserire una riga nella tabella Patients.This example inserts a row into the Patients table. Si noti quanto segue:Note the following:

  • Il codice di esempio non contiene alcun elemento specifico per la crittografia.There is nothing specific to encryption in the sample code. Il provider di dati .NET Framework per SQL Server rileva automaticamente e crittografa i parametri paramSSN e paramBirthdate destinati alle colonne crittografate.The .NET Framework Data Provider for SQL Server automatically detects and encrypts the paramSSN and paramBirthdate parameters that target encrypted columns. In questo modo la crittografia diventa trasparente per l'applicazione.This makes encryption transparent to the application.
  • I valori inseriti nelle colonne di database, incluse quelle crittografate, vengono passati come oggetti SqlParameter .The values inserted into database columns, including the encrypted columns, are passed as SqlParameter objects. L'uso di SqlParameter è facoltativo quando si inviano i valori alle colonne non crittografate (è tuttavia consigliabile usarlo perché consente di impedire attacchi SQL injection), mentre è necessario per i valori destinati alle colonne crittografate.While using SqlParameter is optional when sending values to non-encrypted columns (although, it is highly recommended because it helps prevent SQL injection), it is required for values targeting encrypted columns. Se i valori inseriti nelle colonne SSN o BirthDate sono stati passati come valori letterali incorporati nell'istruzione della query, la query avrà esito negativo perché il provider di dati .NET Framework per SQL Server non riesce a determinare i valori delle colonne di destinazione crittografate e quindi non crittograferà i valori.If the values inserted in the SSN or BirthDate columns were passed as literals embedded in the query statement, the query would fail because the .NET Framework Data Provider for SQL Server would not be able to determine the values in the target encrypted columns, so it would not encrypt the values. Di conseguenza, il server li rifiuterà come incompatibili con le colonne crittografate.As a result, the server would reject them as incompatible with the encrypted columns.
  • Il tipo di dati del parametro destinato alla colonna SSN è impostato su una stringa ANSI (non Unicode), che esegue il mapping al tipo di dati di SQL Server char/varchar.The data type of the parameter targeting the SSN column is set to an ANSI (non-Unicode) string, which maps to the char/varchar SQL Server data type. Se il tipo del parametro è stato impostato su una stringa Unicode (stringa), che esegue il mapping a nchar/nvarchar, la query avrà esito negativo perché Always Encrypted non supporta le conversioni da valori nchar/nvarchar crittografati a valori char/varchar crittografati.If the type of the parameter was set to a Unicode string (String), which maps to nchar/nvarchar, the query would fail, as Always Encrypted does not support conversions from encrypted nchar/nvarchar values to encrypted char/varchar values. Vedere Mapping dei tipi di dati SQL Server per informazioni sui mapping dei tipi di dati.See SQL Server Data Type Mappings for information about the data type mappings.
  • Il tipo di dati del parametro inserito nella colonna BirthDate è impostato in modo esplicito sul tipo di dati SQL Server di destinazione tramite la proprietà SqlParameter.SqlDbType, anziché mediante il mapping implicito dei tipi .NET ai tipi di dati di SQL Server applicati quando si usa la proprietà SqlParameter.DbType.The data type of the parameter inserted into the BirthDate column is explicitly set to the target SQL Server data type using SqlParameter.SqlDbType Property, instead of relying on the implicit mapping of .NET types to SQL Server data types applied when using SqlParameter.DbType Property. Per impostazione predefinita, viene eseguito il mapping della struttura DateTime al tipo di dati datetime di SQL Server.By default, DateTime Structure maps to the datetime SQL Server data type. Considerato che il tipo di dati della colonna BirthDate corrisponde alla data e Always Encrypted non supporta una conversione dei valori di data e ora crittografati in valori di data crittografati, l'uso del mapping predefinito causerà un errore.As the data type of the BirthDate column is date and Always Encrypted does not support a conversion of encrypted datetime values to encrypted date values, using the default mapping would result in an error.
string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true; Column Encryption Setting=enabled";
using (SqlConnection connection = new SqlConnection(strbldr.ConnectionString))
{
   using (SqlCommand cmd = connection.CreateCommand())
   {
      cmd.CommandText = @"INSERT INTO [dbo].[Patients] ([SSN], [FirstName], [LastName], [BirthDate]) VALUES (@SSN, @FirstName, @LastName, @BirthDate);";

      SqlParameter paramSSN = cmd.CreateParameter();
      paramSSN.ParameterName = @"@SSN";
      paramSSN.DbType = DbType.AnsiStringFixedLength;
      paramSSN.Direction = ParameterDirection.Input;
      paramSSN.Value = "795-73-9838";
      paramSSN.Size = 11;
      cmd.Parameters.Add(paramSSN);

      SqlParameter paramFirstName = cmd.CreateParameter();
      paramFirstName.ParameterName = @"@FirstName";
      paramFirstName.DbType = DbType.String;
      paramFirstName.Direction = ParameterDirection.Input;
      paramFirstName.Value = "Catherine";
      paramFirstName.Size = 50;
      cmd.Parameters.Add(paramFirstName);

      SqlParameter paramLastName = cmd.CreateParameter();
      paramLastName.ParameterName = @"@LastName";
      paramLastName.DbType = DbType.String;
      paramLastName.Direction = ParameterDirection.Input;
      paramLastName.Value = "Abel";
      paramLastName.Size = 50;
      cmd.Parameters.Add(paramLastName);

      SqlParameter paramBirthdate = cmd.CreateParameter();
      paramBirthdate.ParameterName = @"@BirthDate";
      paramBirthdate.SqlDbType = SqlDbType.Date;
      paramBirthdate.Direction = ParameterDirection.Input;
      paramBirthdate.Value = new DateTime(1996, 09, 10);
      cmd.Parameters.Add(paramBirthdate);

      cmd.ExecuteNonQuery();
   } 
}

Esempio di recupero di dati di testo non crittografatoRetrieving Plaintext Data Example

L'esempio seguente illustra come filtrare i dati in base ai valori crittografati e recuperare i dati in testo non crittografato dalle colonne crittografate.The following example demonstrates filtering data based on encrypted values, and retrieving plaintext data from encrypted columns. Si noti quanto segue:Note the following:

  • Il valore usato nella clausola WHERE per filtrare la colonna SSN deve essere passato usando SqlParameter, in modo che il provider di dati .NET Framework per SQL Server possibile codificarli in modo trasparente prima dell'invio al database.The value used in the WHERE clause to filter on the SSN column needs to be passed using SqlParameter, so that the .NET Framework Data Provider for SQL Server can transparently encrypt it before sending it to the database.
  • Tutti i valori stampati dal programma saranno in testo non crittografato perché il provider di dati .NET Framework per SQL Server decrittografa in modo trasparente i dati recuperati dalle colonne SSN e BirthDate.All values printed by the program will be in plaintext, as the .NET Framework Data Provider for SQL Server will transparently decrypt the data retrieved from the SSN and BirthDate columns.

Nota

Le query possono eseguire confronti di uguaglianza nelle colonne se sono crittografate tramite crittografia deterministica.Queries can perform equality comparisons on columns if they are encrypted using deterministic encryption. Per altre informazioni, vedere la sezione Selezione della crittografia deterministica o casuale di Always Encrypted (motore di database).For more information, see the Selecting Deterministic or Randomized encryption section of Always Encrypted (Database Engine).

string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true; Column Encryption Setting=enabled";

using (SqlConnection connection = new SqlConnection(strbldr.ConnectionString))
 {
    using (SqlCommand cmd = connection.CreateCommand())
 {

 cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE SSN=@SSN";
 SqlParameter paramSSN = cmd.CreateParameter();
 paramSSN.ParameterName = @"@SSN";
 paramSSN.DbType = DbType.AnsiStringFixedLength;
 paramSSN.Direction = ParameterDirection.Input;
 paramSSN.Value = "795-73-9838";
 paramSSN.Size = 11;
 cmd.Parameters.Add(paramSSN);
 using (SqlDataReader reader = cmd.ExecuteReader())
 {
   if (reader.HasRows)
 {
 while (reader.Read())
 {
    Console.WriteLine(@"{0}, {1}, {2}, {3}", reader[0], reader[1], reader[2], ((DateTime)reader[3]).ToShortDateString());
 }

Esempio di recupero di dati crittografatiRetrieving Encrypted Data Example

Se Always Encrypted non è abilitato, una query può comunque recuperare dati dalle colonne crittografate, a condizione che non presenti parametri destinati alle colonne crittografate.If Always Encrypted is not enabled, a query can still retrieve data from encrypted columns, as long as the query has no parameters targeting encrypted columns.

L'esempio seguente illustra come recuperare i dati crittografati binari dalle colonne crittografate.The following example demonstrates how to retrieve binary encrypted data from encrypted columns. Si noti quanto segue:Note the following:

  • Considerato che Always Encrypted non è abilitato nella stringa di connessione, la query restituirà i valori crittografati di SSN e BirthDate come matrici di byte (il programma converte i valori in stringhe).As Always Encrypted is not enabled in the connection string, the query will return encrypted values of SSN and BirthDate as byte arrays (the program converts the values to strings).
  • Una query che recupera dati dalle colonne crittografate con Always Encrypted disabilitato può avere parametri, a condizione che nessuno dei parametri sia destinato a una colonna crittografata.A query retrieving data from encrypted columns with Always Encrypted disabled can have parameters, as long as none of the parameters target an encrypted column. La query precedente filtra in base alla colonna LastName, non è crittografata nel database.The above query filters by LastName, which is not encrypted in the database. Se la query avesse filtrato per SSN o data di nascita, avrebbe avuto esito negativo.If the query filtered by SSN or BirthDate, the query would fail.
string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true";

using (SqlConnection connection = new SqlConnection(connectionString))
{
   connection.Open();
   using (SqlCommand cmd = connection.CreateCommand())
   {
      cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE [LastName]=@LastName";
      SqlParameter paramLastName = cmd.CreateParameter();
      paramLastName.ParameterName = @"@LastName";
      paramLastName.DbType = DbType.String;
      paramLastName.Direction = ParameterDirection.Input;
      paramLastName.Value = "Abel";
      paramLastName.Size = 50;
      cmd.Parameters.Add(paramLastName);
      using (SqlDataReader reader = cmd.ExecuteReader())
      {
         if (reader.HasRows)
         {
            while (reader.Read())
         {
         Console.WriteLine(@"{0}, {1}, {2}, {3}", BitConverter.ToString((byte[])reader[0]), reader[1], reader[2], BitConverter.ToString((byte[])reader[3]));
      }
   }
}

Come evitare i problemi comuni quando si eseguono query su colonne crittografateAvoiding common problems when querying encrypted columns

Questa sezione descrive le categorie di errori che si verificano con maggiore frequenza quando si eseguono query su colonne crittografate da applicazioni .NET e fornisce alcune linee guida su come evitare il problema.This section describes common categories of errors when querying encrypted columns from .NET applications and a few guidelines on how to avoid them.

Errori di conversione dei tipi di dati non supportatiUnsupported data type conversion errors

Always Encrypted supporta alcune conversioni per i tipi di dati crittografati.Always Encrypted supports few conversions for encrypted data types. Per l'elenco dettagliato delle conversioni di tipi supportate, vedere Always Encrypted (motore di database) .See Always Encrypted (Database Engine) for a detailed list of supported type conversions. Per evitare errori di conversione dei tipi di dati, eseguire le operazioni seguenti:Do the following to avoid data type conversion errors:

  • Impostare i tipi di parametri destinati alle colonne crittografate in modo che il tipo di dati di SQL Server del parametro corrisponda esattamente al tipo della colonna di destinazione oppure che sia supportata una conversione del tipo di dati di SQL Server del parametro nel tipo di destinazione della colonna.Set the types of parameters targeting encrypted columns, so the SQL Server data type of the parameter is either exactly the same as the type of the target column, or a conversion of the SQL Server data type of the parameter to the target type of the column is supported. È possibile applicare il mapping desiderato dei tipi di dati .NET a specifici tipi di dati di SQL Server usando la proprietà SqlParameter.SqlDbType.You can enforce the desired mapping of .NET data types to specific SQL Server data types by using SqlParameter.SqlDbType Property.
  • Verificare che la precisione e la scala dei parametri destinati alle colonne dei tipi di dati di SQL Server decimali e numerici siano uguali a quelle configurate per la colonna di destinazione.Verify the precision and scale of parameters targeting columns of the decimal and numeric SQL Server data types is the same as the precision and scale configured for the target column.
  • Verificare che la precisione dei parametri destinati alle colonne dei tipi di dati di SQL Server datetime2, datetimeoffset o time non sia maggiore della precisione per la colonna di destinazione, nelle query che modificano i valori di tale colonna.Verify the precision of parameters targeting columns of datetime2, datetimeoffset, or time SQL Server data types is not greater than the precision for the target column (in queries that modify values in the target column).

Errori causati dal passaggio di testo non crittografato anziché di valori crittografatiErrors due to passing plaintext instead of encrypted values

Qualsiasi valore destinato a una colonna crittografata deve essere crittografato all'interno dell'applicazione.Any value that targets an encrypted column needs to be encrypted inside the application. Il tentativo di inserire, modificare o filtrare in base a un valore di testo non crittografato su una colonna crittografata comporterà un errore simile al seguente:An attempt to insert/modify or to filter by a plaintext value on an encrypted column will result in an error similar to this:

System.Data.SqlClient.SqlException (0x80131904): Operand type clash: varchar is incompatible with varchar(8000) encrypted with (encryption_type = 'DETERMINISTIC', encryption_algorithm_name = 'AEAD_AES_256_CBC_HMAC_SHA_256', column_encryption_key_name = 'CEK_Auto1', column_encryption_key_database_name = 'Clinic') collation_name = 'SQL_Latin1_General_CP1_CI_AS'

Per evitare tali errori, verificare che:To prevent such errors, make sure:

  • Always Encrypted sia abilitato per le query dell'applicazione destinate alle colonne crittografate (per la stringa di connessione o nell'oggetto SqlCommand per una query specifica).Always Encrypted is enabled for application queries targeting encrypted columns (for the connection string or in the SqlCommand object for a specific query).
  • Per inviare i dati destinati alle colonne crittografate venga usato SqlParameter.You use SqlParameter to send data targeting encrypted columns. L'esempio seguente illustra una query che filtra in modo errato in base a un valore letterale o costante in una colonna crittografata (SSN), anziché passare il valore letterale all'interno di un oggetto SqlParameter.The following example shows a query that incorrectly filters by a literal/constant on an encrypted column (SSN)(instead of passing the literal inside a SqlParameter object).
using (SqlCommand cmd = connection.CreateCommand())
{
   cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE SSN='795-73-9838'";
cmd.ExecuteNonQuery();
}

Uso degli archivi delle chiavi master delle colonneWorking with Column Master Key Stores

Per crittografare un valore di parametro o decrittografare i dati nei risultati della query, il provider di dati .NET Framework per SQL Server deve ottenere una chiave di crittografia di colonna che è configurata per la colonna di destinazione.To encrypt a parameter value or to decrypt data in query results, the .NET Framework Data Provider for SQL Server needs to obtain a column encryption key that is configured for the target column. Le chiavi di crittografia di colonna vengono archiviate in forma crittografata nei metadati del database.Column encryption keys are stored in the encrypted form in the database metadata. Ogni chiave di crittografia di colonna ha una chiave master corrispondente che è stata usata per crittografare la chiave di crittografia.Each column encryption key has a corresponding column master key that was used to encrypt the column encryption key. I metadati del database non archiviano le chiavi master delle colonne, ma contengono solo le informazioni su un archivio delle chiavi contenente una specifica chiave master di colonna e il percorso della chiave nell'archivio.The database metadata does not store the column master keys – it only contains the information about a key store containing a particular column master key and the location of the key in the key store.

Per ottenere un valore di testo non crittografato nella chiave di crittografia della colonna, il provider di dati .NET Framework per SQL Server ottiene prima di tutto i metadati relativi sia alla chiave di crittografia della colonna che alla chiave master della colonna corrispondente e quindi usa le informazioni nei metadati per contattare l'archivio delle chiavi, che contiene la chiave master della colonna, e per decrittografare la chiave di crittografia della colonna crittografata.To obtain a plaintext value of a column encryption key, the .NET Framework Data Provider for SQL Server first obtains the metadata about both the column encryption key and its corresponding column master key, and then it uses the information in the metadata to contact the key store, containing the column master key, and to decrypt the encrypted column encryption key. Il provider di dati .NET Framework per SQL Server comunica con un archivio delle chiavi usando un provider di archivio delle chiavi master delle colonne, ossia un'istanza di una classe derivata dalla classe SqlColumnEncryptionKeyStoreProvider.The .NET Framework Data Provider for SQL Server communicates with a key store using a column master key store provider – which is an instance of a class derived from SqlColumnEncryptionKeyStoreProvider Class.

Il processo per ottenere la chiave di crittografia di una colonna consiste nelle fasi seguenti:The process to obtain a column encryption key:

  1. Se Always Encrypted è abilitato per una query, il provider di dati .NET Framework per SQL Server chiama sys.sp_describe_parameter_encryption in modo trasparente per recuperare i metadati di crittografia per i parametri destinati alle colonne crittografate, se la query include parametri.If Always Encrypted is enabled for a query, the .NET Framework Data Provider for SQL Server transparently calls sys.sp_describe_parameter_encryption to retrieve encryption metadata for parameters targeting encrypted columns, if the query has parameters. Per i dati crittografati contenuti nei risultati di una query, SQL Server associa automaticamente i metadati di crittografia.For encrypted data contained in the results of a query, SQL Server automatically attaches encryption metadata. Le informazioni sulla chiave master della colonna includono:The information about the column master key includes:

    • Il nome di un provider di archivio delle chiavi che incapsula un archivio contenente la chiave master della colonna.The name of a key store provider that encapsulates a key store containing the column master key.
    • Il percorso che specifica la posizione della chiave master della colonna nell'archivio delle chiavi.The key path that specifies the location of the column master key in the key store.

    Le informazioni sulla chiave di crittografia della colonna includono:The information about the column encryption key includes:

    • Il valore crittografato della chiave di crittografia della colonna.The encrypted value of a column encryption key.
    • Il nome dell'algoritmo usato per crittografare la chiave di crittografia della colonna.The name of the algorithm that was used to encrypt the column encryption key.
  2. Il provider di dati .NET Framework per SQL Server usa il nome del provider di archivio delle chiavi master delle colonne per cercare l'oggetto provider (un'istanza di una classe derivata dalla classe SqlColumnEncryptionKeyStoreProvider) in una struttura di dati interna.The .NET Framework Data Provider for SQL Server uses the name of the column master key store provider to look up the provider object (an instance of a class derived from SqlColumnEncryptionKeyStoreProvider Class) in an internal data structure.
  3. Per decrittografare la chiave di crittografia della colonna, il provider di dati .NET Framework per SQL Server chiama il metodo SqlColumnEncryptionKeyStoreProvider.DecryptColumnEncryptionKey, passando il percorso della chiave master della colonna, il valore crittografato della chiave di crittografia della colonna e il nome dell'algoritmo di crittografia, usato per generare la chiave di crittografia della colonna crittografata.To decrypt the column encryption key, the .NET Framework Data Provider for SQL Server calls SqlColumnEncryptionKeyStoreProvider.DecryptColumnEncryptionKey Method, passing the column master key path, the encrypted value of the column encryption key and the name of the encryption algorithm, used to produce the encrypted column encryption key.

Uso dei provider predefiniti di archivio delle chiavi master delle colonneUsing built-in column master key store providers

Il provider di dati .NET Framework per SQL Server viene fornito con i seguenti provider predefiniti di archivio delle chiavi master delle colonne, che sono pre-registrati con i nomi di provider specifici (usati per cercare il provider).The .NET Framework Data Provider for SQL Server comes with the following built-in column master key store providers, which are pre-registered with the specific provider names (used to look up the provider).

ClasseClass DescrizioneDescription Nome del provider (ricerca)Provider (lookup) name
Classe SqlColumnEncryptionCertificateStoreProviderSqlColumnEncryptionCertificateStoreProvider Class Un provider per l'archivio certificati di Windows.A provider for Windows Certificate Store. MSSQL_CERTIFICATE_STOREMSSQL_CERTIFICATE_STORE
Classe SqlColumnEncryptionCngProviderSqlColumnEncryptionCngProvider Class

Nota: questo provider è disponibile in .NET Framework 4.6.1 e versioni successive.Note: this provider is available in .NET Framework 4.6.1 and later versions.
Un provider di archivio delle chiavi che supporta Microsoft Cryptography API: Next Generation (CNG).A provider for a key store that supports Microsoft Cryptography API: Next Generation (CNG) API. In genere, un archivio di questo tipo è un modulo di protezione hardware, ovvero un dispositivo fisico che protegge e gestisce le chiavi digitali e fornisce l'elaborazione della crittografia.Typically, a store of this type is a hardware security module - a physical device that safeguards and manages digital keys and provides crypto-processing. MSSQL_CNG_STOREMSSQL_CNG_STORE
Classe SqlColumnEncryptionCspProviderSqlColumnEncryptionCspProvider Class

Nota: questo provider è disponibile in .NET Framework 4.6.1 o versioni successive.Note: this provider is available in .NET Framework 4.6.1 or later versions.
Un provider di un archivio delle chiavi che supporta Microsoft CryptoAPI (CAPI).A provider for a key store that supports Microsoft Cryptography API (CAPI). In genere, un archivio di questo tipo è un modulo di protezione hardware, ovvero un dispositivo fisico che protegge e gestisce le chiavi digitali e fornisce l'elaborazione della crittografia.Typically, a store of this type is a hardware security module - a physical device that safeguards and manages digital keys and provides crypto-processing. MSSQL_CSP_PROVIDERMSSQL_CSP_PROVIDER

Per usare questi provider non è necessario apportare alcuna modifica del codice dell'applicazione, ma tenere presente quanto segue:You do not need to make any application code changes to use these providers but note the following:

  • È necessario che l'utente (o l'amministratore del database) verifichi che il nome del provider, configurato nei metadati della chiave master della colonna, sia corretto e che il percorso della chiave master sia conforme al formato del percorso della chiave valido per un determinato provider.You (or your DBA) need to make sure the provider name, configured in the column master key metadata, is correct and the column master key path complies with the key path format that is valid for a given provider. È consigliabile configurare le chiavi usando strumenti come SQL Server Management Studio, che genera automaticamente i nomi di provider e i percorsi di chiave validi quando viene eseguita l'istruzione CREATE COLUMN MASTER KEY (Transact-SQL) .It is recommended that you configure the keys using tools such as SQL Server Management Studio, which automatically generates the valid provider names and key paths when issuing the CREATE COLUMN MASTER KEY (Transact-SQL) statement. Per altre informazioni, vedere Configurare Always Encrypted usando SQL Server Management Studio e Configurare Always Encrypted tramite PowerShell.For more information, see Configuring Always Encrypted using SQL Server Management Studio and Configure Always Encrypted using PowerShell.
  • È necessario verificare che l'applicazione possa accedere alla chiave nell'archivio delle chiavi.You need to ensure your application can access the key in the key store. Questa operazione potrebbe comportare l'accesso da parte dell'applicazione alla chiave e/o all'archivio delle chiavi, a seconda dell'archivio, o l'esecuzione di altri passaggi di configurazione specifici dell'archivio delle chiavi.This may involve granting your application access to the key and/or the key store, depending on the key store, or performing other key store-specific configuration steps. Ad esempio, per accedere a un archivio delle chiavi che implementa CNG o CAPI (come un modulo di protezione hardware), è necessario assicurarsi che una libreria di implementazione di CNG o CAPI per l'archivio sia installata nel computer dell'applicazione.For example, to access a key store implementing CNG or CAPI (e.g. a hardware security module), you need to make sure a library implementing CNG or CAPI for your store is installed on your application machine. Per informazioni dettagliate, vedere Creare e archiviare chiavi master della colonna (Always Encrypted).For details, see Create and Store Column Master Keys (Always Encrypted).

Uso del provider dell'insieme di credenziali delle chiavi di AzureUsing Azure Key Vault provider

L'insieme di credenziali delle chiavi di Azure rappresenta una scelta valida per archiviare e gestire le chiavi master delle colonne per Always Encrypted, soprattutto se le applicazioni sono ospitate in Azure.Azure Key Vault is a convenient option to store and manage column master keys for Always Encrypted (especially if your applications are hosted in Azure). Il provider di dati .NET Framework per SQL Server non include un provider predefinito di archivio delle chiavi master delle colonne per l'insieme di credenziali delle chiavi di Azure, ma è disponibile come pacchetto Nuget, che è possibile integrare facilmente con l'applicazione.The .NET Framework Data Provider for SQL Server does not include a built-in column master key store provider for Azure Key Vault, but it is available as a Nuget package, that you can easily integrate with your application. Per informazioni dettagliate, vedere Always Encrypted: Proteggere i dati sensibili nel database SQL con la crittografia dei dati e archiviare le chiavi di crittografia nell'insieme di credenziali delle chiavi di Azure.For details, see Always Encrypted - Protect sensitive data in SQL Database with data encryption and store your encryption keys in the Azure Key Vault.

Implementazione di un provider personalizzato di archivio delle chiavi master delle colonneImplementing a custom column master key store provider

Se si vuole archiviare le chiavi master delle colonne in un archivio delle chiavi che non è supportato da un provider esistente, è possibile implementare un provider personalizzato estendendo la classe SqlColumnEncryptionCngProvider e registrando il provider con il metodo SqlConnection.RegisterColumnEncryptionKeyStoreProviders .If you want to store column master keys in a key store that is not supported by an existing provider, you can implement a custom provider by extending the SqlColumnEncryptionCngProvider Class and registering the provider using the SqlConnection.RegisterColumnEncryptionKeyStoreProviders method.

public class MyCustomKeyStoreProvider : SqlColumnEncryptionKeyStoreProvider
    {
        public override byte[] EncryptColumnEncryptionKey(string masterKeyPath, string encryptionAlgorithm, byte[] columnEncryptionKey)
        {
            // Logic for encrypting a column encrypted key.
        }
        public override byte[] DecryptColumnEncryptionKey(string masterKeyPath, string encryptionAlgorithm, byte[] EncryptedColumnEncryptionKey)
        {
            // Logic for decrypting a column encrypted key.
        }
    }  
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary\<string, SqlColumnEncryptionKeyStoreProvider> providers =
               new Dictionary\<string, SqlColumnEncryptionKeyStoreProvider>();
            providers.Add("MY_CUSTOM_STORE", customProvider);
            SqlConnection.RegisterColumnEncryptionKeyStoreProviders(providers);
            providers.Add(SqlColumnEncryptionCertificateStoreProvider.ProviderName, customProvider);
            SqlConnection.RegisterColumnEncryptionKeyStoreProviders(providers); 
       // ...
        }

    }

Uso di provider di archivio delle chiavi master delle colonne per il provisioning di chiavi a livello di codiceUsing column master key store providers for programmatic key provisioning

Quando si accede a colonne crittografate, il provider di dati .NET Framework per SQL Server trova in modo trasparente e chiama il provider di archivio delle chiavi master delle colonne per decrittografare le chiavi di crittografia delle colonne.When accessing encrypted columns, the .NET Framework Data Provider for SQL Server transparently finds and calls the right column master key store provider to decrypt column encryption keys. In genere, il codice dell'applicazione normale non chiama direttamente i provider di archivio delle chiavi master delle colonne.Typically, your normal application code does not directly call column master key store providers. È tuttavia possibile creare un'istanza e chiamare un provider in modo esplicito a livello di codice e gestire le chiavi Always Encrypted per generare la chiave di crittografia di una colonna crittografata e decrittografare la chiave di crittografia di una colonna (ad esempio nell'ambito della rotazione della chiave master della colonna).You may, however, instantiate and call a provider explicitly to programmatically provision and manage Always Encrypted keys: to generate an encrypted column encryption key and decrypt a column encryption key (e.g. as part column master key rotation). Per altre informazioni, vedere Panoramica della gestione delle chiavi per Always Encrypted.For more information, see Overview of Key Management for Always Encrypted. Si noti che l'implementazione dei propri strumenti di gestione delle chiavi potrebbe essere necessaria solo se si usa un provider di archivio delle chiavi personalizzato.Note that implementing your own key management tools may be required only if you use a custom key store provider. Quando si usano chiavi archiviate in archivi delle chiavi, per i quali esistono provider predefiniti, e/o nell'insieme di credenziali delle chiavi di Azure, è possibile usare gli strumenti esistenti, ad esempio SQL Server Management Studio o PowerShell per gestire le chiavi ed eseguirne il provisioning.When using keys stored in keys stores, for which built-in providers exist, and or in Azure Key Vault, you can use existing tools, such as SQL Server Management Studio or PowerShell, to manage and provision keys. L'esempio seguente illustra la generazione della chiave di crittografia di una colonna e l'uso della classe SqlColumnEncryptionCertificateStoreProvider per crittografare la chiave con un certificato.The below example, illustrates generating a column encryption key and using SqlColumnEncryptionCertificateStoreProvider Class to encrypt the key with a certificate.

using System.Security.Cryptography;
static void Main(string[] args)
{
    byte[] EncryptedColumnEncryptionKey = GetEncryptedColumnEncryptonKey(); 
    Console.WriteLine("0x" + BitConverter.ToString(EncryptedColumnEncryptionKey).Replace("-", "")); 
    Console.ReadKey();
}

static byte[]  GetEncryptedColumnEncryptonKey()
{
    int cekLength = 32;
    String certificateStoreLocation = "CurrentUser";
    String certificateThumbprint = "698C7F8E21B2158E9AED4978ADB147CF66574180";
    // Generate the plaintext column encryption key.
    byte[] columnEncryptionKey = new byte[cekLength];
    RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider();
    rngCsp.GetBytes(columnEncryptionKey);

    // Encrypt the column encryption key with a certificate.
    string keyPath = String.Format(@"{0}/My/{1}", certificateStoreLocation, certificateThumbprint);
    SqlColumnEncryptionCertificateStoreProvider provider = new SqlColumnEncryptionCertificateStoreProvider();
    return provider.EncryptColumnEncryptionKey(keyPath, @"RSA_OAEP", columnEncryptionKey); 
}

Controllo dell'impatto di Always Encrypted sulle prestazioniControlling Performance Impact of Always Encrypted

Considerato che Always Encrypted è una tecnologia di crittografia lato client, la maggior parte del sovraccarico delle prestazioni si verifica sul lato client, non nel database.Because Always Encrypted is a client-side encryption technology, most of performance overheads are observed on the client side, not in the database. A parte il costo delle operazioni di crittografia e decrittografia, le altre origini di sovraccarico delle prestazioni sul lato client sono le seguenti:Apart from the cost of encryption and decryption operations, the other sources of performance overheads on the client side are:

  • Round trip aggiuntivi al database per recuperare i metadati per i parametri di query.Additional round trips to the database to retrieve metadata for query parameters.
  • Chiamate a un archivio delle chiavi master delle colonne per accedere alla chiave master di una colonna.Calls to a column master key store to access a column master key.

Questa sezione descrive le ottimizzazioni delle prestazioni predefinite nel provider .NET Framework per SQL Server e come controllare l'impatto sulle prestazioni esercitato dai due fattori descritti.This section describes the built-in performance optimizations in .NET Framework Provider for SQL Server and how you can control the impact of the above two factors on performance.

Controllo dei round trip per recuperare i metadati per i parametri di queryControlling round trips to retrieve metadata for query parameters

Se Always Encrypted è abilitato per una connessione, per impostazione predefinita il provider di dati .NET Framework per SQL Server chiamerà sys.sp_describe_parameter_encryption per ogni query con parametri, passando l'istruzione di query (senza i valori dei parametri) a SQL Server.If Always Encrypted is enabled for a connection, by default, the .NET Framework Data Provider for SQL Server will call sys.sp_describe_parameter_encryption for each parameterized query, passing the query statement (without any parameter values) to SQL Server. sys.sp_describe_parameter_encryption analizza l'istruzione di query per verificare se sono presenti parametri da crittografare e, in tal caso, restituisce le informazioni relative alla crittografia che consentiranno al provider di dati .NET Framework per SQL Server di crittografare i valori dei parametri.sys.sp_describe_parameter_encryption analyzes the query statement to find out if any parameters need to be encrypted, and if so, for each such, it returns the encryption-related information that will allow the .NET Framework Data Provider for SQL Server to encrypt parameter values. Il comportamento descritto garantisce all'applicazione client un elevato livello di trasparenza.The above behavior ensures a high-level of transparency to the client application. Non è necessario che l'applicazione (e lo sviluppatore dell'applicazione) sappiano quali query accedono alle colonne crittografate, a condizione che i valori destinati alle colonne crittografate vengano passati al provider di dati .NET Framework per SQL Server negli oggetti SqlParameter.The application (and the application developer) does not need to be aware of which queries access encrypted columns, as long as the values targeting encrypted columns are passed to the .NET Framework Data Provider for SQL Server in SqlParameter objects.

Memorizzazione nella cache dei metadati di queryQuery metadata caching

In .NET Framework 4.6.2 e versioni successive, il provider di dati .NET Framework per SQL Server memorizza nella cache i risultati di sys.sp_describe_parameter_encryption per ogni istruzione di query.In .NET Framework 4.6.2 and later, the .NET Framework Data Provider for SQL Server caches the results of sys.sp_describe_parameter_encryption for each query statement. Di conseguenza, se la stessa istruzione di query viene eseguita più volte, il driver chiama sys.sp_describe_parameter_encryption una sola volta.Consequently, if the same query statement is executed multiple times, the driver calls sys.sp_describe_parameter_encryption only once. La memorizzazione nella cache dei metadati di crittografia per le istruzioni di query consente di ridurre in modo sostanziale l'impatto sulle prestazioni del recupero dei metadati dal database.Encryption metadata caching for query statements substantially reduces the performance cost of fetching metadata from the database. La memorizzazione nella cache è abilitata per impostazione predefinita.Caching is enabled by default. È possibile disabilitare la memorizzazione nella cache dei metadati dei parametri impostando su false la proprietà SqlConnection.ColumnEncryptionQueryMetadataCacheEnabled , ma questa operazione non è consigliabile tranne in rari casi, come quello descritto di seguito:You can disable parameter metadata caching by setting the SqlConnection.ColumnEncryptionQueryMetadataCacheEnabled Property to false, but doing so is not recommended except in very rare cases like the one described below:

Si consideri un database che ha due schemi diversi: s1 e s2.Consider a database that has two different schemas: s1 and s2. Ogni schema contiene una tabella con lo stesso nome: t.Each schema contains a table with the same name: t. Le definizioni delle tabelle s1.t e s2.t sono identiche, ad eccezione delle proprietà relative alla crittografia: una colonna, denominata c, in s1.t non è crittografata ed è crittografata in s2.t.The definitions of the s1.t and s2.t tables are identical, except encryption-related properties: A column, named c, in s1.t is not encrypted, and it is encrypted in s2.t. Il database ha due utenti: u1 e u2.The database has two users: u1 and u2. Lo schema predefinito per l'utente u1 è s1,The default schema for the u1 users it s1. mentre quello per l'utente u2 è s2.The default schema for u2 is s2. Un'applicazione .NET apre due connessioni al database, rappresentando l'utente u1 su una connessione e l'utente u2 su un'altra connessione.A .NET application opens two connections to the database, impersonating the u1 user on one connection, and the u2 user on another connection. L'applicazione invia una query con un parametro destinato alla colonna c tramite la connessione per l'utente u1. La query non specifica lo schema e quindi si presuppone che venga usato lo schema utente predefinito.The application sends a query with a parameter targeting the c column over the connection for user u1 (the query does not specify the schema, so the default user scheme is assumed). Successivamente, l'applicazione invia la stessa query tramite la connessione per l'utente u2.Next, the application sends the same query over the connection for the u2 user. Se la memorizzazione nella cache dei metadati di query è abilitata, dopo la prima query la cache verrà popolata con metadati indicanti che la colonna c, contenente le destinazioni dei parametri di query, non è crittografata.If query metadata caching is enabled, after the first query, the cache will be populated with metadata indicating the c column, the query parameter targets, is not encrypted. Poiché la seconda query ha la stessa istruzione di query, verranno usate le informazioni memorizzate nella cache.As the second query has the identical query statement, the information stored in the cache will be used. Di conseguenza, il driver invierà la query senza crittografare il parametro (anche se questo non è corretto perché la colonna di destinazione, s2.t.c, è crittografata), passando al server il valore di testo non crittografato del parametro.As a result, the driver will send the query without encrypting the parameter (which is incorrect, as the target column, s2.t.c, is encrypted), leaking the plaintext value of the parameter to the server. Il server rileverà l'incompatibilità e forzerà l'aggiornamento della cache. Di conseguenza, l'applicazione invierà nuovamente la query in modo trasparente con il valore del parametro correttamente crittografato.The server will detect that incompatibility and it will force the driver to refresh the cache, so the application will transparently resend the query with the correctly encrypted parameter value. In tal caso, la memorizzazione nella cache deve essere disabilitata per impedire che valori sensibili vengano passati al server in modalità non crittografata.In such a case, caching should be disabled to prevent leaking sensitive values to the server.

Impostazione di Always Encrypted a livello di querySetting Always Encrypted at the query level

Per controllare l'impatto sulle prestazioni del recupero dei metadati di crittografia per le query con parametri, è possibile abilitare Always Encrypted per singole query, anziché l'impostarla per la connessione.To control performance impact of retrieving encryption metadata for parameterized queries, you can enable Always Encrypted for individual queries, instead of setting it up for the connection. In questo modo, è possibile assicurarsi che sys.sp_describe_parameter_encryption venga richiamato solo per le query con parametri destinati alle colonne crittografate.This way, you can ensure that sys.sp_describe_parameter_encryption is invoked only for queries that you know have parameters targeting encrypted columns. Si noti, tuttavia, che in tal modo si riduce la trasparenza della crittografia: se si modificano le proprietà di crittografia delle colonne di database, potrebbe essere necessario modificare il codice dell'applicazione per allinearlo alle modifiche dello schema.Note, however, that by doing so, you reduce transparency of encryption: if you change encryption properties of your database columns, you may need to change the code of your application to align it with the schema changes.

Nota

L'impostazione di Always Encrypted a livello di query offre vantaggi limitati per le prestazioni in .NET 4.6.2 e versioni successive, che implementano la memorizzazione nella cache dei metadati di crittografia dei parametri.Setting Always Encrypted at the query level has limited performance benefits in .NET 4.6.2 and later versions, which implement parameter encryption metadata caching.

Per controllare il comportamento di Always Encrypted per le singole query, è necessario usare questo costruttore di SqlCommand e SqlCommandColumnEncryptionSetting.To control the Always Encrypted behavior of individual queries, you need to use this constructor of SqlCommand and SqlCommandColumnEncryptionSetting. Di seguito sono riportate alcune linee guida utili:Here are some useful guidelines:

  • Se la maggior parte delle query che un'applicazione client invia alla connessione del database accede alle colonne crittografate:If most queries a client application sends over a database connection access encrypted columns:
    • Impostare la parola chiave della stringa di connessione di Impostazione di crittografia di colonna su Abilitata.Set the Column Encryption Setting connection string keyword to Enabled.
    • Impostare SqlCommandColumnEncryptionSetting.Disabled per le singole query che non accedono alle colonne crittografate.Set SqlCommandColumnEncryptionSetting.Disabled for individual queries that do not access any encrypted columns. In questo modo verranno disabilitati sia la chiamata di sys.sp_describe_parameter_encryption chiamante che il tentativo di decrittografare tutti i valori nel set di risultati.This will disable both calling sys.sp_describe_parameter_encryption as well as an attempt to decrypt any values in the result set.
    • Impostare SqlCommandColumnEncryptionSetting.ResultSet per le singole query che non presentano parametri da crittografare, ma che recuperano i dati dalle colonne crittografate.Set SqlCommandColumnEncryptionSetting.ResultSet for individual queries that do not have any parameters requiring encryption, but retrieve data from encrypted columns. In questo modo verranno disabilitati la chiamata di sys.sp_describe_parameter_encryption e la crittografia dei parametri.This will disable calling sys.sp_describe_parameter_encryption and parameter encryption. La query potrà decrittografare i risultati delle colonne di crittografia.The query will be able to decrypt the results from encryption columns.
  • Se la maggior parte delle query che un'applicazione client invia alla connessione del database non accede alle colonne crittografate:If most queries a client application sends over a database connection do not access encrypted columns:
    • Impostare la parola chiave della stringa di connessione di Impostazione di crittografia di colonna su Disabilitata.Set the Column Encryption Setting connection string keyword to Disabled.
    • Impostare SqlCommandColumnEncryptionSetting.Enabled per le singole query che presentano parametri da crittografare.Set SqlCommandColumnEncryptionSetting.Enabled for individual queries that have any parameters that need to be encrypted. In questo modo verranno abilitate sia la chiamata di sys.sp_describe_parameter_encryption che la decrittografia dei risultati di query recuperati da colonne crittografate.This will enable both calling sys.sp_describe_parameter_encryption as well as the decryption of any query results retrieved from encrypted columns.
    • Impostare SqlCommandColumnEncryptionSetting.ResultSet per le query che non presentano parametri da crittografare, ma che recuperano i dati dalle colonne crittografate.Set SqlCommandColumnEncryptionSetting.ResultSet for queries that do not have any parameters requiring encryption, but retrieve data from encrypted columns. In questo modo verranno disabilitati la chiamata di sys.sp_describe_parameter_encryption e la crittografia dei parametri.This will disable calling sys.sp_describe_parameter_encryption and parameter encryption. La query potrà decrittografare i risultati delle colonne di crittografia.The query will be able to decrypt the results from encryption columns.

Nell'esempio seguente Always Encrypted è disabilitato per la connessione al database.In the below example, Always Encrypted is disabled for the database connection. La query eseguita dall'applicazione ha un parametro la cui destinazione è la colonna LastName non crittografata.The query, the application issues, has a parameter that targets the LastName column that is not encrypted. La query recupera i dati dalle colonne SSN e BirthDate, che sono entrambe crittografate.The query retrieves data from the SSN and BirthDate columns that are both encrypted. In tal caso, la chiamata di sys.sp_describe_parameter_encryption per recuperare i metadati di crittografia non è necessaria.In such a case, calling sys.sp_describe_parameter_encryption to retrieve encryption metadata is not required. Tuttavia, è necessario abilitare la decrittografia dei risultati della query in modo che l'applicazione possa ricevere i valori di testo non crittografato dalle due colonne crittografate.However, the decryption of the query results need to be enabled, so that the application can receive plaintext values from the two encrypted columns. A tale scopo, usare l'impostazione SqlCommandColumnEncryptionSetting.ResultSet.SqlCommandColumnEncryptionSetting.ResultSet setting is used to ensure that.

string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    using (SqlCommand cmd = new SqlCommand(@"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE [LastName]=@LastName",
connection, null, SqlCommandColumnEncryptionSetting.ResultSetOnly))
    {
        SqlParameter paramLastName = cmd.CreateParameter();
        paramLastName.ParameterName = @"@LastName";
        paramLastName.DbType = DbType.String;
        paramLastName.Direction = ParameterDirection.Input;
        paramLastName.Value = "Abel";
        paramLastName.Size = 50;
        cmd.Parameters.Add(paramLastName);
        using (SqlDataReader reader = cmd.ExecuteReader())
            {
               if (reader.HasRows)
               {
                  while (reader.Read())
                  {
                     Console.WriteLine(@"{0}, {1}, {2}, {3}", reader[0], reader[1], reader[2], ((DateTime)reader[3]).ToShortDateString());
                  }
               }
            }
  } 
}

Memorizzazione nella cache delle chiavi di crittografia della colonnaColumn encryption key caching

Per ridurre il numero di chiamate a un archivio chiavi master della colonna per decrittografare le chiavi di crittografia della colonna, il provider di dati .NET Framework per SQL Server memorizza nella cache le chiavi di crittografia della colonna di testo non crittografato.To reduce the number of calls to a column master key store to decrypt column encryption keys, the .NET Framework Data Provider for SQL Server caches the plaintext column encryption keys in memory. Dopo aver ricevuto il valore delle chiavi di crittografia della colonna crittografata dai metadati del database, il driver prova prima di tutto a trovare la chiave di crittografia della colonna di testo non crittografato corrispondente al valore della chiave crittografata.After receiving the encrypted column encryption key value from database metadata, the driver first tries to find the plaintext column encryption key, corresponding to the encrypted key value. Il driver chiama l'archivio delle chiavi contenente la chiave master della colonna solo se non trova nella cache il valore della chiave di crittografia della colonna crittografata.The driver calls the key store containing the column master key, only if it cannot find the encrypted column encryption key value in the cache.

Nota

In .NET Framework 4.6 e 4.6.1, le voci delle chiavi di crittografia delle colonne nella cache non vengono mai rimosse.In .NET Framework 4.6 and 4.6.1, the column encryption key entries in the cache are never evicted. Questo significa che per una determinata chiave di crittografia della colonna crittografata specificata, il driver contatta l'archivio chiavi una sola volta nel corso della durata dell'applicazione.This means that for a given encrypted column encryption key, the driver contacts the key store only once during the life time of the application.

In .NET Framework 4.6.2 e versioni successive, le voci della cache vengono rimosse per motivi di sicurezza dopo un intervallo di durata (TTL) configurabile.In .NET Framework 4.6.2 and later, the cache entries are evicted after a configurable time-to-live interval for security reasons. Il valore predefinito di questo intervallo è 2 ore.The default time-to-live value is 2 hours. Se si preferisce impostare requisiti di sicurezza più severi riguardo al tempo in cui le chiavi di crittografia delle colonne possono rimanere memorizzate nella cache in testo non crittografato nell'applicazione, è possibile modificare il valore della durata (TTL) tramite la proprietà SqlConnection.ColumnEncryptionKeyCacheTtl.If you have stricter security requirements about how long column encryption keys can be cached in plaintext in the application, you can change it using the SqlConnection.ColumnEncryptionKeyCacheTtl Property.

Abilitazione della protezione aggiuntiva per un'istanza di SQL Server compromessaEnabling Additional Protection for a Compromised SQL Server

Per impostazione predefinita, il provider di dati .NET Framework per SQL Server si basa sul sistema di database (SQL Server o database SQL di Azure) per fornire i metadati sulle colonne del database crittografate e sulla modalità di crittografia usata.By default, the .NET Framework Data Provider for SQL Server relies on the database system (SQL Server or Azure SQL Database) to provide metadata about which columns in the database are encrypted and how. I metadati di crittografia consentono al provider di dati .NET Framework per SQL Server di crittografare i parametri di query e decrittografare i risultati di query senza alcun intervento da parte dell'applicazione, riducendo così notevolmente la quantità di modifiche necessarie nell'applicazione.The encryption metadata enables the .NET Framework Data Provider for SQL Server to encrypt query parameters and decrypt query results without any input from the application, which greatly reduces the amount of changes required in the application. Se tuttavia il processo di SQL Server è compromesso e un utente malintenzionato manomette i metadati inviati da SQL Server al provider di dati .NET Framework per SQL Server, tale utente potrebbe essere in grado di sottrarre informazioni sensibili.However, if the SQL Server process gets compromised and an attacker tampers with the metadata SQL Server sends to the .NET Framework Data Provider for SQL Server, the attacker might be able to steal sensitive information. Questa sezione descrive le API che consentono di fornire un ulteriore livello di protezione da questo tipo di attacco, anche se a discapito della trasparenza.This section describes APIs that help provide an additional level of protection against this type of attack, at the price of reduced transparency.

Forzare la crittografia dei parametriForcing Parameter Encryption

Prima di inviare una query con parametri a SQL Server, il provider di dati .NET Framework per SQL Server chiede a SQL Server (chiamando sys.sp_describe_parameter_encryption) di analizzare l'istruzione di query e di fornire informazioni sui parametri della query da crittografare.Before the .NET Framework Data Provider for SQL Server sends a parameterized query to SQL Server, it asks SQL Server (by calling sys.sp_describe_parameter_encryption) to analyze the query statement and provide information about which parameters in the query should be encrypted. Un'istanza di SQL Server compromessa può fuorviare il provider di dati .NET Framework per SQL Server inviando metadati indicanti che il parametro non è destinato a una colonna crittografata, anche se questa è crittografata nel database.A compromised SQL Server instance could mislead the .NET Framework Data Provider for SQL Server by sending the metadata indicating the parameter does not target an encrypted column, despite the fact the column is encrypted in the database. Di conseguenza, il provider di dati .NET Framework per SQL Server non crittograferà il valore del parametro e lo invierà come testo non crittografato all'istanza di SQL Server compromessa.As a result, the .NET Framework Data Provider for SQL Server would not encrypt the parameter value and it would send it as plaintext to the compromised SQL Server instance.

Per evitare un attacco di questo tipo, un'applicazione può impostare su true la proprietà SqlParameter.ForceColumnEncryption del parametro.To prevent such an attack, an application can set the SqlParameter.ForceColumnEncryption Property for the parameter to true. In questo modo, il provider di dati .NET Framework per SQL Server genererà un'eccezione, se i metadati ricevuti dal server indicano che il parametro non deve essere crittografato.This will cause the .NET Framework Data Provider for SQL Server to throw an exception, if the metadata, it has received from the server, indicates the parameter does not need to be encrypted.

Si noti che, sebbene l'uso della proprietà SqlParameter.ForceColumnEncryption consenta di migliorare la sicurezza, ha l'effetto di ridurre la trasparenza della crittografia per l'applicazione client.Note that although using the SqlParameter.ForceColumnEncryption Property helps improve security, it also reduces the transparency of encryption to the client application. Se si aggiorna lo schema del database per modificare il set di colonne crittografate, può essere necessario apportare modifiche anche all'applicazione.If you update the database schema to change the set of encrypted columns, you might need to make application changes as well.

L'esempio di codice seguente illustra l'uso della proprietà SqlParameter.ForceColumnEncryption per impedire che i numeri SSN vengano inviati in testo non crittografato al database.The following code sample illustrates using the SqlParameter.ForceColumnEncryption Property to prevent social security numbers to be sent in plaintext to the database.

SqlCommand cmd = _sqlconn.CreateCommand(); 

// Use parameterized queries to access Always Encrypted data. 

cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE [SSN] = @SSN;"; 

SqlParameter paramSSN = cmd.CreateParameter(); 
paramSSN.ParameterName = @"@SSN"; 
paramSSN.DbType = DbType.AnsiStringFixedLength; 
paramSSN.Direction = ParameterDirection.Input; 
paramSSN.Value = ssn; 
paramSSN.Size = 11; 
paramSSN.ForceColumnEncryption = true; 
cmd.Parameters.Add(paramSSN); 

SqlDataReader reader = cmd.ExecuteReader();

Configurazione di percorsi attendibili per le chiavi master delle colonneConfiguring Trusted Column Master Key Paths

I metadati di crittografia, restituiti da SQL Server per i parametri di query destinati alle colonne crittografate e per i risultati recuperati dalle colonne di crittografia, includono il percorso della chiave master della colonna che identifica l'archivio delle chiavi e la posizione della chiave nell'archivio.The encryption metadata, SQL Server returns for query parameters targeting encrypted columns and for the results retrieved from encryption columns, includes the key path of the column master key that identifies the key store and the location of the key in the key store. Se l'istanza di SQL Server è compromessa, può inviare il percorso della chiave che indirizza il provider di dati .NET Framework per SQL Server verso la posizione controllata da un utente malintenzionato.If the SQL Server instance is compromised, it could send the key path directing the .NET Framework Data Provider for SQL Server to the location controlled by an attacker. Ciò può causare una perdita di credenziali dell'archivio delle chiavi, nel caso in cui l'archivio richieda l'autenticazione dell'applicazione.This may lead to leaking key store credentials, in the case of the key store that requires the application to authenticate.

Per impedire attacchi di questo tipo, l'applicazione può specificare l'elenco dei percorsi di chiave attendibili per un determinato server usando la proprietà SqlConnection.ColumnEncryptionTrustedMasterKeyPaths.To prevent such attacks, the application can specify the list of trusted key paths for a given server using the SqlConnection.ColumnEncryptionTrustedMasterKeyPaths Property. Se il provider di dati .NET Framework per SQL Server riceve un percorso di chiave non incluso nell'elenco dei percorsi di chiave attendibili, verrà generata un'eccezione.If the.NET Framework Data Provider for SQL Server receives a key path outside of the trusted key path list, it will throw an exception.

Si noti che, anche se l'impostazione di percorsi di chiave attendibili consente di migliorare la sicurezza dell'applicazione, è necessario modificare il codice o/e la configurazione dell'applicazione ogni volta che si ruota la chiave master della colonna, ossia ogni volta che il percorso della chiave master della colonna cambia.Note that although setting trusted key paths improves security of your application, you will need to change the code or/and the configuration of the application, whenever you rotate your column master key (whenever the column master key path changes).

L'esempio seguente mostra come configurare i percorsi attendibili delle chiavi master delle colonne:The following example shows how to configure trusted column master key paths:

// Configure trusted key paths to protect against fake key paths sent by a compromised SQL Server instance 
// First, create a list of trusted key paths for your server 
List<string> trustedKeyPathList = new List<string>(); 
trustedKeyPathList.Add("CurrentUser/my/425CFBB9DDDD081BB0061534CE6AB06CB5283F5Ea"); 

// Register the trusted key path list for your server 

SqlConnection.ColumnEncryptionTrustedMasterKeyPaths.Add(serverName, trustedKeyPathList);

Copia dei dati crittografati mediante SqlBulkCopyCopying Encrypted Data using SqlBulkCopy

Con SqlBulkCopy, è possibile copiare dati, che sono già crittografati e archiviati in una tabella, in un'altra tabella, senza la decrittografia dei dati.With SqlBulkCopy, you can copy data, which is already encrypted and stored in one table, to another table, without decrypting the data. Per eseguire questa operazione:To do that:

  • Assicurarsi che la configurazione di crittografia della tabella di destinazione sia identica alla configurazione della tabella di origine.Make sure the encryption configuration of the target table is identical to the configuration of the source table. In particolare, entrambe le tabelle devono avere le stesse colonne crittografate e le colonne devono essere crittografate usando gli stessi tipi di crittografia e le stesse chiavi di crittografia.In particular, both tables must have the same columns encrypted, and the columns must be encrypted using the same encryption types and the same encryption keys. Nota: se una o più colonne di destinazione sono crittografate in modo diverso dalla relativa colonna di origine corrispondente, non sarà possibile decrittografare i dati nella tabella di destinazione dopo l'operazione di copia.Note: if any of the target columns is encrypted differently than its corresponding source column, you will not be able to decrypt the data in the target table after the copy operation. I dati risulteranno danneggiati.The data will be corrupted.
  • Configurare entrambe le connessioni di database, per la tabella di origine e la tabella di destinazione, senza Always Encrypted abilitato.Configure both database connections, to the source table and to the target table, without Always Encrypted enabled.
  • Impostare l'opzione AllowEncryptedValueModifications (vedere SqlBulkCopyOptions).Set the AllowEncryptedValueModifications option (see SqlBulkCopyOptions). Nota: prestare attenzione quando si specifica AllowEncryptedValueModifications; questa operazione può causare, infatti, il danneggiamento del database perché il provider di dati .NET Framework per SQL Server non verifica se i dati vengono effettivamente crittografati o se vengono crittografati correttamente usando lo stesso tipo di crittografia, l'algoritmo e la chiave come colonna di destinazione.Note: Use caution when specifying AllowEncryptedValueModifications as this may lead to corrupting the database because the .NET Framework Data Provider for SQL Server does not check if the data is indeed encrypted, or if it is correctly encrypted using the same encryption type, algorithm and key as the target column.

Si noti che l'opzione AllowEncryptedValueModifications è disponibile in .NET Framework 4.6.1 e versioni successive.Note that the AllowEncryptedValueModifications option is available in .NET Framework 4.6.1 and later versions.

Di seguito è riportato un esempio che copia i dati da una tabella a altra.Here is an example that copies data from one table to another. Si presuppone che le colonne SSN e BirthDate nascita siano crittografate.The SSN and BirthDate columns are assumed to be encrypted.

static public void CopyTablesUsingBulk(string sourceTable, string targetTable)
{
   string sourceConnectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true";
   string targetConnectionString = "Data Source= server64; Initial Catalog=Clinic; Integrated Security=true";
   using (SqlConnection connSource = new SqlConnection(sourceConnectionString))
   {
      connSource.Open();
      using (SqlCommand cmd = new SqlCommand(string.Format("SELECT [PatientID], [SSN], [FirstName], [LastName], [BirthDate] FROM {0}", sourceTable), connSource))
      {
         using (SqlDataReader reader = cmd.ExecuteReader())
         {
            SqlBulkCopy copy = new SqlBulkCopy(targetConnectionString, SqlBulkCopyOptions.KeepIdentity | SqlBulkCopyOptions.AllowEncryptedValueModifications);
            copy.EnableStreaming = true;
            copy.DestinationTableName = targetTable;
            copy.WriteToServer(reader);
         }
      }
}

Riferimento all'API di Always EncryptedAlways Encrypted API Reference

Spazio dei nomi: System.Data.SqlClientNamespace: System.Data.SqlClient

Assembly: System.Data (in System.Data.dll)Assembly: System.Data (in System.Data.dll)

NomeName DescrizioneDescription Introdotta nella versione di .NETIntroduced in .NET version
Classe SqlColumnEncryptionCertificateStoreProviderSqlColumnEncryptionCertificateStoreProvider Class Un provider di archivi di chiavi per l'archivio certificati di Windows.A key store provider for Windows Certificate Store. 4.64.6
Classe SqlColumnEncryptionCngProviderSqlColumnEncryptionCngProvider Class Un provider di archivi di chiavi per l'API di crittografia di Microsoft: Next Generation (CNG).A key store provider for Microsoft Cryptography API: Next Generation (CNG). 4.6.14.6.1
Classe SqlColumnEncryptionCspProviderSqlColumnEncryptionCspProvider Class Un provider di archivio di chiavi CAPI di Microsoft sulla base dei provider di servizi di crittografia (CSP).A key store provider for Microsoft CAPI based Cryptographic Service Providers (CSP). 4.6.14.6.1
classe SqlColumnEncryptionKeyStoreProviderSqlColumnEncryptionKeyStoreProvider Class Classe base per tutti i provider di archivi di chiavi.Base class of the key store providers. 4.64.6
Enumerazione SqlCommandColumnEncryptionSettingSqlCommandColumnEncryptionSetting Enumeration Impostazioni per abilitare la crittografia e la decrittografia per una connessione al database.Settings to enable encryption and decryption for a database connection. 4.64.6
Enumerazione SqlConnectionColumnEncryptionSettingSqlConnectionColumnEncryptionSetting Enumeration Impostazioni per controllare il comportamento della Crittografia sempre attiva per ogni singola query.Settings to control the behavior of Always Encrypted for individual queries. 4.64.6
Proprietà SqlConnectionStringBuilder.ColumnEncryptionSettingSqlConnectionStringBuilder.ColumnEncryptionSetting Property Ottiene e imposta Always Encrypted nella stringa di connessione.Gets and sets Always Encrypted in the connection string. 4.64.6
proprietà SqlConnection.ColumnEncryptionQueryMetadataCacheEnabledSqlConnection.ColumnEncryptionQueryMetadataCacheEnabled Property Abilita e disabilita la memorizzazione nella cache dei metadati di crittografia delle query.Enables and disables encryption query metadata caching. 4.6.24.6.2
proprietà SqlConnection.ColumnEncryptionKeyCacheTtlSqlConnection.ColumnEncryptionKeyCacheTtl Property Ottiene e imposta la durata (TTL) per le voci nella cache delle chiavi di crittografia delle colonne.Gets and sets time-to-live for entries in the column encryption key cache. 4.6.24.6.2
proprietà SqlConnection.ColumnEncryptionTrustedMasterKeyPathsSqlConnection.ColumnEncryptionTrustedMasterKeyPaths Property Consente di impostare un elenco di percorsi principali attendibili per un server di database.Allows you to set a list of trusted key paths for a database server. Se durante l'elaborazione di una query dell'applicazione, il driver riceve il percorso di una chiave che non è presente nell'elenco, la query ha esito negativo.If while processing an application query the driver receives a key path that is not on the list, the query will fail. Questa proprietà fornisce un’ulteriore protezione da attacchi alla sicurezza in cui un SQL Server compromesso fornisce falsi percorsi chiavi. Questo potrebbe causare la perdita delle credenziali dell’archivio di chiavi.This property provides additional protection against security attacks that involve a compromised SQL Server providing fake key paths, which may lead to leaking key store credentials. 4.64.6
Metodo SqlConnection.RegisterColumnEncryptionKeyStoreProvidersSqlConnection.RegisterColumnEncryptionKeyStoreProviders Method Consente di registrare provider personalizzati per gli archivi delle chiavi.Allows you to register custom key store providers. È un dizionario che esegue il mapping dei nomi dei provider degli archivi delle chiavi per le implementazioni del provider dell’archivio delle chiavi.It is a dictionary that maps key store provider names to key store provider implementations. 4.64.6
SqlCommand Constructor (String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting)SqlCommand Constructor (String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting) Consente di controllare il comportamento della Crittografia sempre attiva per ogni singola query.Enables you to control the behavior of Always Encrypted for individual queries. 4.64.6
proprietà SqlParameter.ForceColumnEncryptionSqlParameter.ForceColumnEncryption Property Applica la crittografia di un parametro.Enforces encryption of a parameter. Se SQL Server indica al driver che il parametro non deve essere crittografato, la query che usa il parametro avrà esito negativo.If SQL Server informs the driver that the parameter does not need to be encrypted, the query using the parameter will fail. Questa proprietà fornisce protezione aggiuntiva contro attacchi alla sicurezza in cui un SQL Server compromesso fornisce al client metadati di crittografia non corretti, con conseguente rischio di divulgazione dei dati.This property provides additional protection against security attacks that involve a compromised SQL Server providing incorrect encryption metadata to the client, which may lead to data disclosure. 4.64.6
Nuova parola chiave della stringa di connessione : Column Encryption Setting=enabledNew connection string keyword: Column Encryption Setting=enabled Abilita o disabilita la funzionalità Crittografia sempre attiva per la connessione.Enables or disables Always Encrypted functionality for the connection. 4.64.6

Vedere ancheSee Also