Always Encrypted: gevoelige gegevens beveiligen en versleutelings sleutels opslaan in Azure Key VaultAlways Encrypted: Protect sensitive data and store encryption keys in Azure Key Vault

Dit artikel laat u zien hoe u met behulp van de Wizard always encrypted in SQL Server Management Studio (SSMS)gevoelige gegevens kunt beveiligen in een SQL database met gegevens versleuteling.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). Het bevat ook instructies voor het opslaan van elke versleutelings sleutel in Azure Key Vault.It also includes instructions that will show you how to store each encryption key in Azure Key Vault.

Always Encrypted is een nieuwe technologie voor gegevens versleuteling in Azure SQL Database en SQL Server die helpt bij het beschermen van gevoelige gegevens op de server, tijdens het verkeer tussen de client en de server, terwijl de gegevens in gebruik zijn.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. Always Encrypted zorgt ervoor dat gevoelige gegevens nooit als tekst zonder opmaak in het database systeem worden weer gegeven.Always Encrypted ensures that sensitive data never appears as plaintext inside the database system. Nadat u gegevens versleuteling hebt geconfigureerd, hebben alleen client toepassingen of app-servers die toegang hebben tot de sleutels toegang tot tekst zonder opmaak.After you configure data encryption, only client applications or app servers that have access to the keys can access plaintext data. Zie Always encrypted (data base-engine)voor meer informatie.For detailed information, see Always Encrypted (Database Engine).

Nadat u de Data Base hebt geconfigureerd voor het gebruik van Always Encrypted, maakt u in C# Visual Studio een client toepassing om met de versleutelde gegevens te werken.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.

Volg de stappen in dit artikel en meer informatie over het instellen van Always Encrypted voor een Azure SQL database.Follow the steps in this article and learn how to set up Always Encrypted for an Azure SQL database. In dit artikel wordt beschreven hoe u de volgende taken uitvoert:In this article you will learn how to perform the following tasks:

VereistenPrerequisites

Notitie

Dit artikel is bijgewerkt voor het gebruik van de nieuwe Azure PowerShell Az-module.This article has been updated to use the new Azure PowerShell Az module. De AzureRM-module kan nog worden gebruikt en krijgt bugoplossingen tot ten minste december 2020.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Zie voor meer informatie over de nieuwe Az-module en compatibiliteit met AzureRM Introductie van de nieuwe Az-module van Azure PowerShell.To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Raadpleeg Azure PowerShell installeren voor instructies over de installatie van de Az-module.For Az module installation instructions, see Install Azure PowerShell.

Belangrijk

De Power shell-Azure Resource Manager module wordt nog steeds ondersteund door Azure SQL Database, maar alle toekomstige ontwikkeling is voor de module AZ. SQL.The PowerShell Azure Resource Manager module is still supported by Azure SQL Database, but all future development is for the Az.Sql module. Zie AzureRM. SQLvoor deze cmdlets.For these cmdlets, see AzureRM.Sql. De argumenten voor de opdrachten in de module AZ en in de AzureRm-modules zijn aanzienlijk identiek.The arguments for the commands in the Az module and in the AzureRm modules are substantially identical.

Voor deze zelf studie hebt u het volgende nodig:For this tutorial, you'll need:

Uw client toepassing inschakelen voor toegang tot de SQL Database-ServiceEnable your client application to access the SQL Database service

U moet uw client toepassing inschakelen voor toegang tot de SQL Database-Service door een Azure Active Directory-toepassing (AAD) in te stellen en de toepassings-id en- sleutel te kopiëren die u nodig hebt om uw toepassing te verifiëren.You must enable your client application to access the SQL Database service by setting up an Azure Active Directory (AAD) application and copying the Application ID and key that you will need to authenticate your application.

Als u de toepassings-id en- sleutelwilt ophalen, volgt u de stappen in Create a Azure Active Directory-toepassing en service-principal die toegang heeft tot resources.To get the Application ID and key, follow the steps in create an Azure Active Directory application and service principal that can access resources.

Een sleutel kluis maken om uw sleutels op te slaanCreate a key vault to store your keys

Nu uw client-app is geconfigureerd en u uw toepassings-ID hebt, is het tijd om een sleutel kluis te maken en het toegangs beleid te configureren, zodat u en uw toepassing toegang hebben tot de geheimen van de kluis (de Always Encrypted sleutels).Now that your client app is configured and you have your application 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). De machtigingen maken, ophalen, lijst, ondertekenen, verifiëren, wrapKeyen sleutel uitpakken zijn vereist voor het maken van een nieuwe kolom hoofd sleutel en voor het instellen van versleuteling met 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.

U kunt snel een sleutel kluis maken door het volgende script uit te voeren.You can quickly create a key vault by running the following script. Zie Wat is Azure Key Vault?voor een gedetailleerde uitleg van deze cmdlets en meer informatie over het maken en configureren van een sleutel kluis.For a detailed explanation of these cmdlets and more information about creating and configuring a key vault, see What is Azure Key Vault?.

    $subscriptionName = '<your Azure subscription name>'
    $userPrincipalName = '<username@domain.com>'
    $applicationId = '<application ID from your AAD application>'
    $resourceGroupName = '<resource group name>'
    # Use the same resource group name when creating your SQL Database below
    $location = '<datacenter location>'
    $vaultName = 'AeKeyVault'


    Connect-AzAccount
    $subscriptionId = (Get-AzSubscription -SubscriptionName $subscriptionName).Id
    Set-AzContext -SubscriptionId $subscriptionId

    New-AzResourceGroup -Name $resourceGroupName -Location $location
    New-AzKeyVault -VaultName $vaultName -ResourceGroupName $resourceGroupName -Location $location

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

Een lege SQL-database makenCreate a blank SQL database

  1. Meld u aan bij de Azure Portal.Sign in to the Azure portal.

  2. Ga naar een resource maken > data bases > SQL database.Go to Create a resource > Databases > SQL Database.

  3. Maak een lege data base met de naam Clinic op een nieuwe of bestaande server.Create a Blank database named Clinic on a new or existing server. Zie uw eerste Azure SQL databasevoor gedetailleerde instructies over het maken van een data base in de Azure Portal.For detailed directions about how to create a database in the Azure portal, see Your first Azure SQL database.

    Een lege database maken

U hebt de connection string verderop in de zelf studie nodig, dus nadat u de Data Base hebt gemaakt, bladert u naar de nieuwe Clinic-data base en kopieert u de connection string.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. U kunt de connection string op elk gewenst moment ophalen, maar dit is eenvoudig te kopiëren in de Azure Portal.You can get the connection string at any time, but it's easy to copy it in the Azure portal.

  1. Ga naar SQL data bases > Clinic > database verbindings reeksen weer geven.Go to SQL databases > Clinic > Show database connection strings.

  2. Kopieer de connection string voor ADO.net.Copy the connection string for ADO.NET.

    De verbindingsreeks kopiëren

Verbinding maken met de database via SQL Server Management StudioConnect to the database with SSMS

Open SSMS en maak verbinding met de server met de Clinic-data base.Open SSMS and connect to the server with the Clinic database.

  1. Open SQL Server Management Studio.Open SSMS. (Ga naar verbinding maken > Data base-engine om het venster verbinding maken met server te openen als dit niet is geopend.)(Go to Connect > Database Engine to open the Connect to Server window if it isn't open.)

  2. Voer uw server naam en referenties in.Enter your server name and credentials. U kunt de naam van de server vinden op de Blade SQL database en in de connection string die u eerder hebt gekopieerd.The server name can be found on the SQL database blade and in the connection string you copied earlier. Typ de volledige server naam, inclusief database.Windows.net.Type the complete server name, including database.windows.net.

    De verbindingsreeks kopiëren

Als het venster nieuwe firewall regel wordt geopend, meldt u zich aan bij Azure en laat SSMS een nieuwe firewall regel voor u maken.If the New Firewall Rule window opens, sign in to Azure and let SSMS create a new firewall rule for you.

Een tabel makenCreate a table

In deze sectie maakt u een tabel om patiënten-gegevens op te slaan.In this section, you will create a table to hold patient data. Het is niet eerst versleuteld. u configureert de versleuteling in de volgende sectie.It's not initially encrypted--you will configure encryption in the next section.

  1. Vouw data basesuit.Expand Databases.
  2. Klik met de rechter muisknop op de Clinic -data base en klik op nieuwe query.Right-click the Clinic database and click New Query.
  3. Plak de volgende Transact-SQL (T-SQL) in het nieuwe query venster en Voer dit uit.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

Kolommen versleutelen (Always Encrypted configureren)Encrypt columns (configure Always Encrypted)

SSMS biedt een wizard waarmee u Always Encrypted eenvoudig kunt configureren door de kolom hoofd sleutel, kolom versleutelings sleutel en versleutelde kolommen in te stellen.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. Vouw data bases uit > Clinic > tabellen.Expand Databases > Clinic > Tables.

  2. Klik met de rechter muisknop op de tabel patiënten en selecteer kolommen versleutelen om de wizard always encrypted te openen:Right-click the Patients table and select Encrypt Columns to open the Always Encrypted wizard:

    Kolommen versleutelen

De wizard Always Encrypted bevat de volgende secties: kolom selectie, configuratie van hoofd sleutel, validatieen samen vatting.The Always Encrypted wizard includes the following sections: Column Selection, Master Key Configuration, Validation, and Summary.

Kolom selectieColumn Selection

Klik op volgende op de pagina Inleiding om de pagina kolom selectie te openen.Click Next on the Introduction page to open the Column Selection page. Op deze pagina selecteert u de kolommen die u wilt versleutelen, het type versleuteling en welke kolom versleutelings sleutel (CEK) u wilt gebruiken.On this page, you will select which columns you want to encrypt, the type of encryption, and what column encryption key (CEK) to use.

Gegevens van SSN en geboorte datum versleutelen voor elke patiënt.Encrypt SSN and BirthDate information for each patient. De kolom SSN maakt gebruik van deterministische versleuteling, die ondersteuning biedt voor treffers, samen voegingen en Group by.The SSN column will use deterministic encryption, which supports equality lookups, joins, and group by. In de kolom geboorte datum wordt wille keurige versleuteling gebruikt, die geen ondersteuning biedt voor bewerkingen.The BirthDate column will use randomized encryption, which does not support operations.

Stel het versleutelings type voor de kolom SSN in op deterministisch en de kolom geboorte datum in wille keurige volg orde.Set the Encryption Type for the SSN column to Deterministic and the BirthDate column to Randomized. Klik op Volgende.Click Next.

Kolommen versleutelen

Configuratie van hoofd sleutelMaster Key Configuration

Op de pagina hoofd sleutel configuratie kunt u uw CMK instellen en de sleutel archief provider selecteren waar de CMK worden opgeslagen.The Master Key Configuration page is where you set up your CMK and select the key store provider where the CMK will be stored. Op dit moment kunt u een CMK opslaan in het Windows-certificaat archief, Azure Key Vault of een Hardware Security module (HSM).Currently, you can store a CMK in the Windows certificate store, Azure Key Vault, or a hardware security module (HSM).

Deze zelf studie laat zien hoe u uw sleutels opslaat in Azure Key Vault.This tutorial shows how to store your keys in Azure Key Vault.

  1. Selecteer Azure Key Vault.Select Azure Key Vault.
  2. Selecteer de gewenste sleutel kluis in de vervolg keuzelijst.Select the desired key vault from the drop-down list.
  3. Klik op Volgende.Click Next.

Configuratie van hoofd sleutel

ValidatieValidation

U kunt de kolommen nu versleutelen of een Power shell-script opslaan om het later uit te voeren.You can encrypt the columns now or save a PowerShell script to run later. Voor deze zelf studie selecteert u nu door gaan naar volt ooien en klikt u op volgende.For this tutorial, select Proceed to finish now and click Next.

SamenvattingSummary

Controleer of de instellingen juist zijn en klik op volt ooien om de installatie voor always encrypted te volt ooien.Verify that the settings are all correct and click Finish to complete the setup for Always Encrypted.

Samenvatting

De acties van de wizard controlerenVerify the wizard's actions

Nadat de wizard is voltooid, is de data base ingesteld op Always Encrypted.After the wizard is finished, your database is set up for Always Encrypted. De wizard heeft de volgende acties uitgevoerd:The wizard performed the following actions:

  • Een kolom hoofd sleutel gemaakt en opgeslagen in Azure Key Vault.Created a column master key and stored it in Azure Key Vault.
  • Een kolom versleutelings sleutel gemaakt en opgeslagen in Azure Key Vault.Created a column encryption key and stored it in Azure Key Vault.
  • De geselecteerde kolommen voor versleuteling zijn geconfigureerd.Configured the selected columns for encryption. De tabel patiënten heeft momenteel geen gegevens, maar alle bestaande gegevens in de geselecteerde kolommen zijn nu versleuteld.The Patients table currently has no data, but any existing data in the selected columns is now encrypted.

U kunt het maken van de sleutels in SSMS controleren door de ** > ** beveiliging > Always encrypted sleutelsuit te breiden.You can verify the creation of the keys in SSMS by expanding Clinic > Security > Always Encrypted Keys.

Een client toepassing maken die werkt met de versleutelde gegevensCreate a client application that works with the encrypted data

Nu Always Encrypted is ingesteld, kunt u een toepassing bouwen waarmee de versleutelde kolommen worden ingevoegd en geselecteerd .Now that Always Encrypted is set up, you can build an application that performs inserts and selects on the encrypted columns.

Belangrijk

Uw toepassing moet SqlParameter -objecten gebruiken bij het door geven van ongecodeerde gegevens naar de server met Always encrypted-kolommen.Your application must use SqlParameter objects when passing plaintext data to the server with Always Encrypted columns. Het door geven van letterlijke waarden zonder gebruik te maken van SqlParameter-objecten leidt tot een uitzonde ring.Passing literal values without using SqlParameter objects will result in an exception.

  1. Open Visual Studio en maak een nieuwe C# console toepassing (Visual Studio 2015 en eerder) of console-app (.NET Framework) (Visual Studio 2017 en hoger).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). Zorg ervoor dat uw project is ingesteld op .NET Framework 4,6 of hoger.Make sure your project is set to .NET Framework 4.6 or later.
  2. Geef het project de naam AlwaysEncryptedConsoleAKVApp en klik op OK.Name the project AlwaysEncryptedConsoleAKVApp and click OK.
  3. Installeer de volgende NuGet-pakketten door naar Hulpprogram ma's > NuGet package manager > Package Manager consolete gaan.Install the following NuGet packages by going to Tools > NuGet Package Manager > Package Manager Console.

Voer deze twee regels code uit in de Package Manager-console.Run these two lines of code in the Package Manager Console.

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

Wijzig uw connection string om Always Encrypted in te scha kelenModify your connection string to enable Always Encrypted

In deze sectie wordt uitgelegd hoe u Always Encrypted in uw data base inschakelt connection string.This section explains how to enable Always Encrypted in your database connection string.

Als u Always Encrypted wilt inschakelen, moet u het tref woord voor de kolom versleutelings instelling toevoegen aan de Connection String en instellen op ingeschakeld.To enable Always Encrypted, you need to add the Column Encryption Setting keyword to your connection string and set it to Enabled.

U kunt dit rechtstreeks in het connection string instellen of u kunt dit instellen met behulp van SqlConnectionStringBuilder.You can set this directly in the connection string, or you can set it by using SqlConnectionStringBuilder. De voorbeeld toepassing in de volgende sectie laat zien hoe u SqlConnectionStringBuilderkunt gebruiken.The sample application in the next section shows how to use SqlConnectionStringBuilder.

Always Encrypted in het connection string inschakelenEnable Always Encrypted in the connection string

Voeg het volgende tref woord toe aan uw connection string.Add the following keyword to your connection string.

Column Encryption Setting=Enabled

Always Encrypted met SqlConnectionStringBuilder inschakelenEnable Always Encrypted with SqlConnectionStringBuilder

De volgende code laat zien hoe u Always Encrypted inschakelt door SqlConnectionStringBuilder. ColumnEncryptionSetting in te stellen op ingeschakeld.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;

De Azure Key Vault provider registrerenRegister the Azure Key Vault provider

De volgende code laat zien hoe u de Azure Key Vault provider registreert bij het ADO.NET-stuur programma.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(applicationId, clientKey);

       SqlColumnEncryptionAzureKeyVaultProvider azureKeyVaultProvider =
          new SqlColumnEncryptionAzureKeyVaultProvider(GetToken);

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

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

Voorbeeld console toepassing Always EncryptedAlways Encrypted sample console application

Dit voor beeld laat zien hoe u:This sample demonstrates how to:

  • Wijzig uw connection string om Always Encrypted in te scha kelen.Modify your connection string to enable Always Encrypted.
  • Registreer Azure Key Vault als provider van de sleutel opslag van de toepassing.Register Azure Key Vault as the application's key store provider.
  • Gegevens invoegen in de versleutelde kolommen.Insert data into the encrypted columns.
  • Selecteer een record door te filteren op een specifieke waarde in een versleutelde kolom.Select a record by filtering for a specific value in an encrypted column.

Vervang de inhoud van Program.cs door de volgende code.Replace the contents of Program.cs with the following code. Vervang de connection string voor de globale Connections Tring-variabele in de regel die de hoofd methode direct voorafgaat met uw geldige connection string van de Azure Portal.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. Dit is de enige wijziging die u moet aanbrengen in deze code.This is the only change you need to make to this code.

Voer de app uit om Always Encrypted in actie te zien.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 applicationId = @"<application ID from your AAD application>";
        static string clientKey = "<key from your AAD application>";


        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(applicationId, clientKey);

            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; }
    }
    }

Controleren of de gegevens zijn versleuteldVerify that the data is encrypted

U kunt snel controleren of de daad werkelijke gegevens op de server zijn versleuteld door de gegevens van de patiënten te doorzoeken met SSMS (met behulp van de huidige verbinding waar de instelling van de kolom versleuteling nog niet is ingeschakeld).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).

Voer de volgende query uit op de Clinic-data base.Run the following query on the Clinic database.

    SELECT FirstName, LastName, SSN, BirthDate FROM Patients;

U kunt zien dat de versleutelde kolommen geen lees bare gegevens bevatten.You can see that the encrypted columns do not contain any plaintext data.

Nieuwe console toepassing

Als u SSMS wilt gebruiken om toegang te krijgen tot de Lees bare gegevens, moet u eerst controleren of de gebruiker de juiste machtigingen heeft voor de Azure Key Vault: Get, sleutel uitpakkenen verify.To use SSMS to access the plaintext data, you first need to ensure that the user has proper permissions to the Azure Key Vault: get, unwrapKey, and verify. Zie Column Master-sleutels maken en opslaan (always encrypted)voor meer informatie.For detailed information, see Create and Store Column Master Keys (Always Encrypted).

Voeg vervolgens de para meter voor de kolom versleutelings instelling = ingeschakeld toe tijdens de verbinding.Then add the Column Encryption Setting=enabled parameter during your connection.

  1. Klik in SSMS met de rechter muisknop op uw server in objectverkenner en kies verbinding verbreken.In SSMS, right-click your server in Object Explorer and choose Disconnect.

  2. Klik op verbinding maken > Data base-engine om het venster verbinding maken met server te openen en klik op Opties.Click Connect > Database Engine to open the Connect to Server window and click Options.

  3. Klik op extra verbindings parameters en type kolom versleutelings instelling = ingeschakeld.Click Additional Connection Parameters and type Column Encryption Setting=enabled.

    Nieuwe console toepassing

  4. Voer de volgende query uit op de Clinic-data base.Run the following query on the Clinic database.

       SELECT FirstName, LastName, SSN, BirthDate FROM Patients;
    

    U kunt nu de Lees bare gegevens in de versleutelde kolommen weer geven.You can now see the plaintext data in the encrypted columns. nieuwe console toepassingNew console application

Volgende stappenNext steps

Nadat u een Data Base hebt gemaakt die gebruikmaakt van Always Encrypted, kunt u het volgende doen:After you create a database that uses Always Encrypted, you may want to do the following: