Crittografia sempre attiva: Proteggere i dati sensibili nel database SQL e archiviare le chiavi di crittografia nell'insieme di credenziali delle chiavi di AzureAlways Encrypted: Protect sensitive data in SQL Database and store your encryption keys in Azure Key Vault

Questo articolo illustra come proteggere i dati sensibili in un database SQL con la crittografia dei dati tramite la procedura guidata Always Encrypted di SQL Server Management Studio (SSMS).This article shows you how to secure sensitive data in a SQL database with data encryption using the Always Encrypted Wizard in SQL Server Management Studio (SSMS). Include anche le istruzioni che illustrano come archiviare ogni chiave di crittografia nell'insieme di credenziali delle chiavi di Azure.It also includes instructions that will show you how to store each encryption key in Azure Key Vault.

La crittografia sempre attiva è una nuova tecnologia di crittografia dei dati del database SQL di Azure e di SQL Server, che protegge i dati sensibili inattivi sul server durante lo spostamento tra client e server e durante l'uso.Always Encrypted is a new data encryption technology in Azure SQL Database and SQL Server that helps protect sensitive data at rest on the server, during movement between client and server, and while the data is in use. La crittografia sempre attiva garantisce che i dati sensibili non vengano mai visualizzati come testo non crittografato all'interno del sistema di database.Always Encrypted ensures that sensitive data never appears as plaintext inside the database system. Dopo avere configurato la crittografia dei dati solo le applicazioni client o i server applicazioni, che hanno accesso alle chiavi, possono accedere ai dati di testo non crittografato.After you configure data encryption, only client applications or app servers that have access to the keys can access plaintext data. Per informazioni dettagliate, vedere l'articolo relativo alla crittografia sempre attiva (motore di database).For detailed information, see Always Encrypted (Database Engine).

Dopo avere configurato il database per usare la crittografia sempre attiva, viene creata un'applicazione client in C# con Visual Studio per lavorare con i dati crittografati.After you configure the database to use Always Encrypted, you will create a client application in C# with Visual Studio to work with the encrypted data.

Seguire i passaggi in questo articolo per imparare come configurare la crittografia sempre attiva per un database SQL di Azure.Follow the steps in this article and learn how to set up Always Encrypted for an Azure SQL database. Questo articolo spiega come eseguire le attività seguenti:In this article you will learn how to perform the following tasks:

PrerequisitiPrerequisites

Per questa esercitazione occorrono:For this tutorial, you'll need:

Abilitare l'applicazione client per accedere al servizio di database SQLEnable your client application to access the SQL Database service

È necessario abilitare l'applicazione client per accedere al servizio del database SQL tramite la configurazione dell'autenticazione richiesta e l'acquisizione di ClientId e Secret, necessari per autenticare l'applicazione nel codice seguente.You must enable your client application to access the SQL Database service by setting up the required authentication and acquiring the ClientId and Secret that you will need to authenticate your application in the following code.

  1. Aprire il portale di Azure classico.Open the Azure classic portal.
  2. Selezionare Active Directory e fare clic sull'istanza di Active Directory che verrà usata dall'applicazione.Select Active Directory and click the Active Directory instance that your application will use.
  3. Fare clic su Applicazioni e quindi su AGGIUNGI.Click Applications, and then click ADD.
  4. Digitare un nome per l'applicazione, ad esempio myClientApp, selezionare APPLICAZIONE WEBe fare clic sulla freccia per continuare.Type a name for your application (for example: myClientApp), select WEB APPLICATION, and click the arrow to continue.
  5. Per l'URL DI ACCESSO e l'URI ID APP digitare un URL valido (ad esempio, http://myClientApp) e continuare.For the SIGN-ON URL and APP ID URI you can type a valid URL (for example, http://myClientApp) and continue.
  6. Fare clic su CONFIGURA.Click CONFIGURE.
  7. Copiare l' ID CLIENT.Copy your CLIENT ID. Sarà necessario immettere questo valore nel codice in un secondo momento.(You will need this value in your code later.)
  8. Nella sezione relativa alle chiavi selezionare 1 anno dall'elenco a discesa Seleziona durata.In the keys section, select 1 year from the Select duration drop-down list. La chiave verrà copiata dopo il salvataggio nel passaggio 13.(You will copy the key after you save in step 13.)
  9. Scorrere verso il basso e fare clic su Aggiungi applicazione.Scroll down and click Add application.
  10. Lasciare MOSTRA impostato su App Microsoft e selezionare API di gestione del servizio Microsoft Azure.Leave SHOW set to Microsoft Apps and select Microsoft Azure Service Management API. Fare clic sul segno di spunta per continuare.Click the checkmark to continue.
  11. Nell'elenco a discesa Autorizzazioni delegate selezionare Access Azure Service Management... (Gestione servizio di accesso Azure).Select Access Azure Service Management... from the Delegated Permissions drop-down list.
  12. Fare clic su SAVE.Click SAVE.
  13. Al termine del salvataggio copiare il valore della chiave nella sezione Chiavi .After the save finishes, copy the key value in the keys section. Sarà necessario immettere questo valore nel codice in un secondo momento.(You will need this value in your code later.)

Creare un insieme di credenziali delle chiavi per archiviare le chiaviCreate a key vault to store your keys

Quando l'app client è configurata e si dispone dell'ID client, è necessario creare un insieme di credenziali delle chiavi e configurare il criterio di accesso per consentire all'utente e all'applicazione di accedere alle chiavi private dell'insieme di credenziali, ovvero le chiavi con crittografia sempre attiva.Now that your client app is configured and you have your client ID, it's time to create a key vault and configure its access policy so you and your application can access the vault's secrets (the Always Encrypted keys). Sono necessarie le autorizzazioni create, get, list, sign, verify, wrapKey e unwrapKey per creare una nuova chiave master di colonna e per configurare la crittografia con SQL Server Management Studio.The create, get, list, sign, verify, wrapKey, and unwrapKey permissions are required for creating a new column master key and for setting up encryption with SQL Server Management Studio.

È possibile creare rapidamente un insieme di credenziali delle chiavi eseguendo lo script seguente.You can quickly create a key vault by running the following script. Per una spiegazione dettagliata di questi cmdlet e altre informazioni sulla creazione e la configurazione di un insieme di credenziali delle chiavi, vedere Introduzione all'insieme di credenziali delle chiavi di Azure.For a detailed explanation of these cmdlets and more information about creating and configuring a key vault, see Get started with Azure Key Vault.

$subscriptionName = '<your Azure subscription name>'
$userPrincipalName = '<username@domain.com>'
$clientId = '<client ID that you copied in step 7 above>'
$resourceGroupName = '<resource group name>'
$location = '<datacenter location>'
$vaultName = 'AeKeyVault'


Login-AzureRmAccount
$subscriptionId = (Get-AzureRmSubscription -SubscriptionName $subscriptionName).Id
Set-AzureRmContext -SubscriptionId $subscriptionId

New-AzureRmResourceGroup -Name $resourceGroupName -Location $location
New-AzureRmKeyVault -VaultName $vaultName -ResourceGroupName $resourceGroupName -Location $location

Set-AzureRmKeyVaultAccessPolicy -VaultName $vaultName -ResourceGroupName $resourceGroupName -PermissionsToKeys create,get,wrapKey,unwrapKey,sign,verify,list -UserPrincipalName $userPrincipalName
Set-AzureRmKeyVaultAccessPolicy  -VaultName $vaultName  -ResourceGroupName $resourceGroupName -ServicePrincipalName $clientId -PermissionsToKeys get,wrapKey,unwrapKey,sign,verify,list

Creare un database SQL vuotoCreate a blank SQL database

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Fare clic su Nuovo > Dati e archiviazione > Database SQL.Go to New > Data + Storage > SQL Database.
  3. Creare un database vuoto denominato Clinic in un server nuovo o esistente.Create a Blank database named Clinic on a new or existing server. Per istruzioni dettagliate su come creare un database nel portale di Azure, vedere Primo database SQL di Azure.For detailed directions about how to create a database in the Azure portal, see Your first Azure SQL database.

    Creazione di un database vuoto

La stringa di connessione sarà necessaria più avanti nell'esercitazione. Dopo avere creato il database selezionare quindi il nuovo database Clinic e copiare la stringa di connessione.You will need the connection string later in the tutorial, so after you create the database, browse to the new Clinic database and copy the connection string. È possibile ottenere la stringa di connessione in qualsiasi momento, ma è facile copiarla nel portale di Azure.You can get the connection string at any time, but it's easy to copy it in the Azure portal.

  1. Passare a Database SQL > Clinic > Show database connection strings (Mostra stringhe di connessione del database).Go to SQL databases > Clinic > Show database connection strings.
  2. Copiare la stringa di connessione per ADO.NET.Copy the connection string for ADO.NET.

    Copia della stringa di connessione

Connettersi al database con SSMSConnect to the database with SSMS

Aprire SSMS e connettersi al server con il database Clinic.Open SSMS and connect to the server with the Clinic database.

  1. Aprire SQL Server Management Studio.Open SSMS. Passare a Connetti > Motore di database per aprire la finestra Connetti al server, se non è già aperta.(Go to Connect > Database Engine to open the Connect to Server window if it isn't open.)
  2. Immettere il nome e le credenziali del server.Enter your server name and credentials. Il nome del server è disponibile nel pannello del database SQL e nella stringa di connessione copiata in precedenza.The server name can be found on the SQL database blade and in the connection string you copied earlier. Digitare il nome completo del server, compreso database.windows.net.Type the complete server name, including database.windows.net.

    Copia della stringa di connessione

Se viene visualizzata la finestra Nuova regola firewall , accedere ad Azure e lasciare che SSMS crei una nuova regola firewall per l'utente.If the New Firewall Rule window opens, sign in to Azure and let SSMS create a new firewall rule for you.

Creare una tabellaCreate a table

Questa sezione contiene istruzioni per creare una tabella con i dati dei pazienti.In this section, you will create a table to hold patient data. Non è crittografata inizialmente e la crittografia verrà configurata nella sezione successiva.It's not initially encrypted--you will configure encryption in the next section.

  1. Espandere Database.Expand Databases.
  2. Fare clic con il pulsante destro del mouse sul database Clinic e fare clic su Nuova query.Right-click the Clinic database and click New Query.
  3. Incollare il comando Transact-SQL (T-SQL) seguente nella finestra della nuova query ed eseguirlo .Paste the following Transact-SQL (T-SQL) into the new query window and Execute it.

     CREATE TABLE [dbo].[Patients](
      [PatientId] [int] IDENTITY(1,1),
      [SSN] [char](11) NOT NULL,
      [FirstName] [nvarchar](50) NULL,
      [LastName] [nvarchar](50) NULL,
      [MiddleName] [nvarchar](50) NULL,
      [StreetAddress] [nvarchar](50) NULL,
      [City] [nvarchar](50) NULL,
      [ZipCode] [char](5) NULL,
      [State] [char](2) NULL,
      [BirthDate] [date] NOT NULL
      PRIMARY KEY CLUSTERED ([PatientId] ASC) ON [PRIMARY] );
      GO
    

Crittografare le colonne configurando la crittografia sempre attivaEncrypt columns (configure Always Encrypted)

SSMS offre una procedura guidata per configurare facilmente la crittografia sempre attiva impostando la chiave master di colonna, la chiave di crittografia di colonna e le colonne crittografate automaticamente.SSMS provides a wizard that helps you easily configure Always Encrypted by setting up the column master key, column encryption key, and encrypted columns for you.

  1. Espandere Database > Clinic > Tabelle.Expand Databases > Clinic > Tables.
  2. Fare clic con il pulsante destro del mouse sulla tabella Patients e selezionare Crittografa colonne per aprire la procedura guidata Always Encrypted:Right-click the Patients table and select Encrypt Columns to open the Always Encrypted wizard:

    Crittografa colonne

La procedura guidata Always Encrypted include le sezioni seguenti: Selezione colonne, Configurazione della chiave master, Convalida e Riepilogo.The Always Encrypted wizard includes the following sections: Column Selection, Master Key Configuration, Validation, and Summary.

Selezione colonneColumn Selection

Fare clic su Avanti nella pagina Introduzione per aprire la pagina Selezione colonne.Click Next on the Introduction page to open the Column Selection page. In questa pagina verranno selezionate le colonne da crittografare, il tipo di crittografia e la chiave di crittografia di colonna (CEK) da usare.On this page, you will select which columns you want to encrypt, the type of encryption, and what column encryption key (CEK) to use.

Crittografare il CF e la data di nascita per ogni paziente.Encrypt SSN and BirthDate information for each patient. La colonna relativa al codice fiscale usa la crittografia deterministica, che supporta ricerche di uguaglianza, join e raggruppamenti.The SSN column will use deterministic encryption, which supports equality lookups, joins, and group by. La colonna relativa alla data di nascita usa la crittografia casuale, che non supporta le operazioni.The BirthDate column will use randomized encryption, which does not support operations.

Impostare il Tipo di crittografia per la colonna CF su Deterministica e per la colonna Data di nascita su Casuale.Set the Encryption Type for the SSN column to Deterministic and the BirthDate column to Randomized. Fare clic su Avanti.Click Next.

Crittografa colonne

Configurazione della chiave masterMaster Key Configuration

La pagina Configurazione della chiave master consente di impostare la CMK e selezionare il provider dell'archivio chiavi in cui verrà archiviata la CMK.The Master Key Configuration page is where you set up your CMK and select the key store provider where the CMK will be stored. Attualmente è possibile archiviare una chiave master di colonna nell'archivio certificati di Windows, nell'insieme di credenziali delle chiavi di Azure o in un modulo di protezione hardware.Currently, you can store a CMK in the Windows certificate store, Azure Key Vault, or a hardware security module (HSM).

Questa esercitazione illustra come archiviare le chiavi nell'insieme di credenziali delle chiavi di Azure.This tutorial shows how to store your keys in Azure Key Vault.

  1. Selezionare Insieme di credenziali delle chiavi di Azure.Select Azure Key Vault.
  2. Selezionare l'insieme di credenziali delle chiavi desiderato dall'elenco a discesa.Select the desired key vault from the drop-down list.
  3. Fare clic su Avanti.Click Next.

Configurazione della chiave master

ConvalidaValidation

È attualmente possibile crittografare le colonne o salvare uno script di PowerShell da eseguire in un secondo momento.You can encrypt the columns now or save a PowerShell script to run later. Per questa esercitazione selezionare Procedi per completare ora e fare clic su Avanti.For this tutorial, select Proceed to finish now and click Next.

RiepilogoSummary

Verificare che tutte le impostazioni siano corrette e fare clic su Fine per completare la configurazione della crittografia sempre attiva.Verify that the settings are all correct and click Finish to complete the setup for Always Encrypted.

Riepilogo

Confermare le azioni della procedura guidataVerify the wizard's actions

Al termine della procedura guidata, il database è configurato per la crittografia sempre attiva.After the wizard is finished, your database is set up for Always Encrypted. La procedura guidata esegue le azioni seguenti:The wizard performed the following actions:

  • È stata creata una chiave master di colonna ed è stata archiviata nell'insieme di credenziali delle chiavi di Azure.Created a column master key and stored it in Azure Key Vault.
  • È stata creata una chiave di crittografia di colonna ed è stata archiviata nell'insieme di credenziali delle chiavi di Azure.Created a column encryption key and stored it in Azure Key Vault.
  • Configurazione delle colonne selezionate per la crittografia.Configured the selected columns for encryption. La tabella Patients attualmente è vuota, ma eventuali dati esistenti nelle colonne selezionate sono ora crittografati.The Patients table currently has no data, but any existing data in the selected columns is now encrypted.

È possibile verificare la creazione di chiavi in SSMS espandendo Clinic > Sicurezza > Chiavi Always Encrypted.You can verify the creation of the keys in SSMS by expanding Clinic > Security > Always Encrypted Keys.

Creare un'applicazione client che funziona con i dati crittografatiCreate a client application that works with the encrypted data

Ora che la crittografia Always Encrypted è configurata, è possibile creare un'applicazione che esegua inserimenti e selezioni nelle colonne crittografate.Now that Always Encrypted is set up, you can build an application that performs inserts and selects on the encrypted columns.

Importante

L'applicazione deve usare oggetti SqlParameter per trasferire dati di testo non crittografato al server con colonne con la crittografia sempre attiva.Your application must use SqlParameter objects when passing plaintext data to the server with Always Encrypted columns. Il trasferimento di valori letterali senza usare oggetti SqlParameter genererà un'eccezione.Passing literal values without using SqlParameter objects will result in an exception.

  1. Aprire Visual Studio e creare una nuova Applicazione console C# (Visual Studio 2015 e versioni precedenti) o App console (.NET Framework) (Visual Studio 2017 e versioni successive).Open Visual Studio and create a new C# Console Application (Visual Studio 2015 and earlier) or Console App (.NET Framework) (Visual Studio 2017 and later). Verificare che il progetto sia impostato su .NET Framework 4.6 o versione successiva.Make sure your project is set to .NET Framework 4.6 or later.
  2. Denominare il progetto AlwaysEncryptedConsoleAKVApp e fare clic su OK.Name the project AlwaysEncryptedConsoleAKVApp and click OK.
  3. Installare i pacchetti NuGet seguenti facendo clic su Strumenti > Gestione pacchetti NuGet > Console di Gestione pacchetti.Install the following NuGet packages by going to Tools > NuGet Package Manager > Package Manager Console.

Eseguire queste 2 righe di codice nella Console di Gestione pacchetti.Run these two lines of code in the Package Manager Console.

Install-Package Microsoft.SqlServer.Management.AlwaysEncrypted.AzureKeyVaultProvider
Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory

Modificare la stringa di connessione per abilitare la crittografia sempre attivaModify your connection string to enable Always Encrypted

Questa sezione descrive come abilitare Always Encrypted nella stringa di connessione del database.This section explains how to enable Always Encrypted in your database connection string.

Per abilitare Always Encrypted è necessario aggiungere la parola chiave di Column Encryption Setting alla stringa di connessione e impostarla su Abilitata.To enable Always Encrypted, you need to add the Column Encryption Setting keyword to your connection string and set it to Enabled.

È possibile impostarla direttamente nella stringa di connessione o tramite SqlConnectionStringBuilder.You can set this directly in the connection string, or you can set it by using SqlConnectionStringBuilder. L'applicazione di esempio nella sezione successiva mostra come usare SqlConnectionStringBuilder.The sample application in the next section shows how to use SqlConnectionStringBuilder.

Abilitare la crittografia sempre attiva nella stringa di connessioneEnable Always Encrypted in the connection string

Aggiungere la parola chiave seguente alla stringa di connessione.Add the following keyword to your connection string.

Column Encryption Setting=Enabled

Abilitare la crittografia sempre attiva con SqlConnectionStringBuilderEnable Always Encrypted with SqlConnectionStringBuilder

Il codice seguente mostra come abilitare Always Encrypted impostando SqlConnectionStringBuilder.ColumnEncryptionSetting su Abilitata.The following code shows how to enable Always Encrypted by setting SqlConnectionStringBuilder.ColumnEncryptionSetting to Enabled.

// Instantiate a SqlConnectionStringBuilder.
SqlConnectionStringBuilder connStringBuilder =
   new SqlConnectionStringBuilder("replace with your connection string");

// Enable Always Encrypted.
connStringBuilder.ColumnEncryptionSetting =
   SqlConnectionColumnEncryptionSetting.Enabled;

Registrare il provider dell'insieme di credenziali delle chiavi di AzureRegister the Azure Key Vault provider

Il codice seguente mostra come registrare il provider dell'insieme di credenziali delle chiavi di Azure con il driver ADO.NET.The following code shows how to register the Azure Key Vault provider with the ADO.NET driver.

private static ClientCredential _clientCredential;

static void InitializeAzureKeyVaultProvider()
{
   _clientCredential = new ClientCredential(clientId, clientSecret);

   SqlColumnEncryptionAzureKeyVaultProvider azureKeyVaultProvider =
      new SqlColumnEncryptionAzureKeyVaultProvider(GetToken);

   Dictionary<string, SqlColumnEncryptionKeyStoreProvider> providers =
      new Dictionary<string, SqlColumnEncryptionKeyStoreProvider>();

   providers.Add(SqlColumnEncryptionAzureKeyVaultProvider.ProviderName, azureKeyVaultProvider);
   SqlConnection.RegisterColumnEncryptionKeyStoreProviders(providers);
}

Applicazione console di esempio della crittografia sempre attivaAlways Encrypted sample console application

Questo esempio dimostra come:This sample demonstrates how to:

  • Modificare la stringa di connessione per abilitare la crittografia sempre attiva.Modify your connection string to enable Always Encrypted.
  • Registrare l'insieme di credenziali delle chiavi di Azure come provider dell'archivio chiavi dell'applicazione.Register Azure Key Vault as the application's key store provider.
  • Inserire dati nelle colonne crittografate.Insert data into the encrypted columns.
  • Selezionare un record filtrando in base a un valore specifico in una colonna crittografata.Select a record by filtering for a specific value in an encrypted column.

Sostituire il contenuto del file Program.cs con il codice seguente.Replace the contents of Program.cs with the following code. Sostituire la stringa di connessione per la variabile globale connectionString nella riga che precede immediatamente il metodo Main con la stringa di connessione valida del portale di Azure.Replace the connection string for the global connectionString variable in the line that directly precedes the Main method with your valid connection string from the Azure portal. Questa è l'unica modifica che è necessario apportare al codice.This is the only change you need to make to this code.

Eseguire l'app per vedere in azione la crittografia sempre attiva.Run the app to see Always Encrypted in action.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Microsoft.SqlServer.Management.AlwaysEncrypted.AzureKeyVaultProvider;

namespace AlwaysEncryptedConsoleAKVApp
{
class Program
{
    // Update this line with your Clinic database connection string from the Azure portal.
    static string connectionString = @"<connection string from the portal>";
    static string clientId = @"<client id from step 7 above>";
    static string clientSecret = "<key from step 13 above>";


    static void Main(string[] args)
    {
        InitializeAzureKeyVaultProvider();

        Console.WriteLine("Signed in as: " + _clientCredential.ClientId);

        Console.WriteLine("Original connection string copied from the Azure portal:");
        Console.WriteLine(connectionString);

        // Create a SqlConnectionStringBuilder.
        SqlConnectionStringBuilder connStringBuilder =
            new SqlConnectionStringBuilder(connectionString);

        // Enable Always Encrypted for the connection.
        // This is the only change specific to Always Encrypted
        connStringBuilder.ColumnEncryptionSetting =
            SqlConnectionColumnEncryptionSetting.Enabled;

        Console.WriteLine(Environment.NewLine + "Updated connection string with Always Encrypted enabled:");
        Console.WriteLine(connStringBuilder.ConnectionString);

        // Update the connection string with a password supplied at runtime.
        Console.WriteLine(Environment.NewLine + "Enter server password:");
        connStringBuilder.Password = Console.ReadLine();


        // Assign the updated connection string to our global variable.
        connectionString = connStringBuilder.ConnectionString;


        // Delete all records to restart this demo app.
        ResetPatientsTable();

        // Add sample data to the Patients table.
        Console.Write(Environment.NewLine + "Adding sample patient data to the database...");

        InsertPatient(new Patient()
        {
            SSN = "999-99-0001",
            FirstName = "Orlando",
            LastName = "Gee",
            BirthDate = DateTime.Parse("01/04/1964")
        });
        InsertPatient(new Patient()
        {
            SSN = "999-99-0002",
            FirstName = "Keith",
            LastName = "Harris",
            BirthDate = DateTime.Parse("06/20/1977")
        });
        InsertPatient(new Patient()
        {
            SSN = "999-99-0003",
            FirstName = "Donna",
            LastName = "Carreras",
            BirthDate = DateTime.Parse("02/09/1973")
        });
        InsertPatient(new Patient()
        {
            SSN = "999-99-0004",
            FirstName = "Janet",
            LastName = "Gates",
            BirthDate = DateTime.Parse("08/31/1985")
        });
        InsertPatient(new Patient()
        {
            SSN = "999-99-0005",
            FirstName = "Lucy",
            LastName = "Harrington",
            BirthDate = DateTime.Parse("05/06/1993")
        });


        // Fetch and display all patients.
        Console.WriteLine(Environment.NewLine + "All the records currently in the Patients table:");

        foreach (Patient patient in SelectAllPatients())
        {
            Console.WriteLine(patient.FirstName + " " + patient.LastName + "\tSSN: " + patient.SSN + "\tBirthdate: " + patient.BirthDate);
        }

        // Get patients by SSN.
        Console.WriteLine(Environment.NewLine + "Now lets locate records by searching the encrypted SSN column.");

        string ssn;

        // This very simple validation only checks that the user entered 11 characters.
        // In production be sure to check all user input and use the best validation for your specific application.
        do
        {
            Console.WriteLine("Please enter a valid SSN (ex. 999-99-0003):");
            ssn = Console.ReadLine();
        } while (ssn.Length != 11);

        // The example allows duplicate SSN entries so we will return all records
        // that match the provided value and store the results in selectedPatients.
        Patient selectedPatient = SelectPatientBySSN(ssn);

        // Check if any records were returned and display our query results.
        if (selectedPatient != null)
        {
            Console.WriteLine("Patient found with SSN = " + ssn);
            Console.WriteLine(selectedPatient.FirstName + " " + selectedPatient.LastName + "\tSSN: "
                + selectedPatient.SSN + "\tBirthdate: " + selectedPatient.BirthDate);
        }
        else
        {
            Console.WriteLine("No patients found with SSN = " + ssn);
        }

        Console.WriteLine("Press Enter to exit...");
        Console.ReadLine();
    }


    private static ClientCredential _clientCredential;

    static void InitializeAzureKeyVaultProvider()
    {

        _clientCredential = new ClientCredential(clientId, clientSecret);

        SqlColumnEncryptionAzureKeyVaultProvider azureKeyVaultProvider =
          new SqlColumnEncryptionAzureKeyVaultProvider(GetToken);

        Dictionary<string, SqlColumnEncryptionKeyStoreProvider> providers =
          new Dictionary<string, SqlColumnEncryptionKeyStoreProvider>();

        providers.Add(SqlColumnEncryptionAzureKeyVaultProvider.ProviderName, azureKeyVaultProvider);
        SqlConnection.RegisterColumnEncryptionKeyStoreProviders(providers);
    }

    public async static Task<string> GetToken(string authority, string resource, string scope)
    {
        var authContext = new AuthenticationContext(authority);
        AuthenticationResult result = await authContext.AcquireTokenAsync(resource, _clientCredential);

        if (result == null)
            throw new InvalidOperationException("Failed to obtain the access token");
        return result.AccessToken;
    }

    static int InsertPatient(Patient newPatient)
    {
        int returnValue = 0;

        string sqlCmdText = @"INSERT INTO [dbo].[Patients] ([SSN], [FirstName], [LastName], [BirthDate])
 VALUES (@SSN, @FirstName, @LastName, @BirthDate);";

        SqlCommand sqlCmd = new SqlCommand(sqlCmdText);


        SqlParameter paramSSN = new SqlParameter(@"@SSN", newPatient.SSN);
        paramSSN.DbType = DbType.AnsiStringFixedLength;
        paramSSN.Direction = ParameterDirection.Input;
        paramSSN.Size = 11;

        SqlParameter paramFirstName = new SqlParameter(@"@FirstName", newPatient.FirstName);
        paramFirstName.DbType = DbType.String;
        paramFirstName.Direction = ParameterDirection.Input;

        SqlParameter paramLastName = new SqlParameter(@"@LastName", newPatient.LastName);
        paramLastName.DbType = DbType.String;
        paramLastName.Direction = ParameterDirection.Input;

        SqlParameter paramBirthDate = new SqlParameter(@"@BirthDate", newPatient.BirthDate);
        paramBirthDate.SqlDbType = SqlDbType.Date;
        paramBirthDate.Direction = ParameterDirection.Input;

        sqlCmd.Parameters.Add(paramSSN);
        sqlCmd.Parameters.Add(paramFirstName);
        sqlCmd.Parameters.Add(paramLastName);
        sqlCmd.Parameters.Add(paramBirthDate);

        using (sqlCmd.Connection = new SqlConnection(connectionString))
        {
            try
            {
                sqlCmd.Connection.Open();
                sqlCmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                returnValue = 1;
                Console.WriteLine("The following error was encountered: ");
                Console.WriteLine(ex.Message);
                Console.WriteLine(Environment.NewLine + "Press Enter key to exit");
                Console.ReadLine();
                Environment.Exit(0);
            }
        }
        return returnValue;
    }


    static List<Patient> SelectAllPatients()
    {
        List<Patient> patients = new List<Patient>();


        SqlCommand sqlCmd = new SqlCommand(
          "SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients]",
            new SqlConnection(connectionString));


        using (sqlCmd.Connection = new SqlConnection(connectionString))

        using (sqlCmd.Connection = new SqlConnection(connectionString))
        {
            try
            {
                sqlCmd.Connection.Open();
                SqlDataReader reader = sqlCmd.ExecuteReader();

                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        patients.Add(new Patient()
                        {
                            SSN = reader[0].ToString(),
                            FirstName = reader[1].ToString(),
                            LastName = reader["LastName"].ToString(),
                            BirthDate = (DateTime)reader["BirthDate"]
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        return patients;
    }


    static Patient SelectPatientBySSN(string ssn)
    {
        Patient patient = new Patient();

        SqlCommand sqlCmd = new SqlCommand(
            "SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE [SSN]=@SSN",
            new SqlConnection(connectionString));

        SqlParameter paramSSN = new SqlParameter(@"@SSN", ssn);
        paramSSN.DbType = DbType.AnsiStringFixedLength;
        paramSSN.Direction = ParameterDirection.Input;
        paramSSN.Size = 11;

        sqlCmd.Parameters.Add(paramSSN);


        using (sqlCmd.Connection = new SqlConnection(connectionString))
        {
            try
            {
                sqlCmd.Connection.Open();
                SqlDataReader reader = sqlCmd.ExecuteReader();

                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        patient = new Patient()
                        {
                            SSN = reader[0].ToString(),
                            FirstName = reader[1].ToString(),
                            LastName = reader["LastName"].ToString(),
                            BirthDate = (DateTime)reader["BirthDate"]
                        };
                    }
                }
                else
                {
                    patient = null;
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }
        return patient;
    }


    // This method simply deletes all records in the Patients table to reset our demo.
    static int ResetPatientsTable()
    {
        int returnValue = 0;

        SqlCommand sqlCmd = new SqlCommand("DELETE FROM Patients");
        using (sqlCmd.Connection = new SqlConnection(connectionString))
        {
            try
            {
                sqlCmd.Connection.Open();
                sqlCmd.ExecuteNonQuery();

            }
            catch (Exception ex)
            {
                returnValue = 1;
            }
        }
        return returnValue;
    }
}

class Patient
{
    public string SSN { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }
}
}

Verificare che i dati siano crittografatiVerify that the data is encrypted

È possibile verificare rapidamente che i dati effettivi del server siano crittografati eseguendo una query dei dati della tabella Patients con SSMS tramite la connessione corrente in cui l'impostazione Column Encryption Setting non è ancora abilitata.You can quickly check that the actual data on the server is encrypted by querying the Patients data with SSMS (using your current connection where Column Encryption Setting is not yet enabled).

Eseguire la query seguente nel database Clinic.Run the following query on the Clinic database.

SELECT FirstName, LastName, SSN, BirthDate FROM Patients;

È possibile osservare che le colonne crittografate non contengono dati di testo non crittografato.You can see that the encrypted columns do not contain any plaintext data.

Nuova applicazione console

Per usare SSMS per accedere ai dati di testo non crittografato, aggiungere il parametro Column Encryption Setting=Enabled alla connessione.To use SSMS to access the plaintext data, you can add the Column Encryption Setting=enabled parameter to the connection.

  1. In SSMS fare clic con il pulsante destro del mouse sul server in Esplora oggetti e scegliere Disconnetti.In SSMS, right-click your server in Object Explorer and choose Disconnect.
  2. Fare clic su Connetti > Motore di database per aprire la finestra Connetti al server e quindi fare clic su Opzioni.Click Connect > Database Engine to open the Connect to Server window and click Options.
  3. Fare clic su Parametri aggiuntivi per la connessione e digitare Column Encryption Setting=Enabled.Click Additional Connection Parameters and type Column Encryption Setting=enabled.

    Nuova applicazione console

  4. Eseguire la query seguente nel database Clinic.Run the following query on the Clinic database.

     SELECT FirstName, LastName, SSN, BirthDate FROM Patients;
    

    È ora possibile visualizzare i dati non crittografati nelle colonne crittografate.You can now see the plaintext data in the encrypted columns.

    Nuova applicazione console

Passaggi successiviNext steps

Dopo avere creato un database che usa la crittografia sempre attiva, è possibile eseguire le operazioni seguenti:After you create a database that uses Always Encrypted, you may want to do the following: