Konfigurera Always Encrypted med Azure Key VaultConfigure Always Encrypted by using Azure Key Vault

gäller för: Azure SQL Database Azure SQL-hanterad instans

Den här artikeln visar hur du skyddar känsliga data i en databas i Azure SQL Database med data kryptering med hjälp av Always Encrypted-guiden i SQL Server Management Studio (SSMS).This article shows you how to secure sensitive data in a database in Azure SQL Database with data encryption by using the Always Encrypted wizard in SQL Server Management Studio (SSMS). Den innehåller också anvisningar som visar hur du lagrar varje krypterings nyckel i Azure Key Vault.It also includes instructions that will show you how to store each encryption key in Azure Key Vault.

Always Encrypted är en data krypterings teknik som skyddar känsliga data i vila på servern, under förflyttning mellan klienten och servern och medan data används.Always Encrypted is a data encryption technology 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 ser till att känsliga data aldrig visas som klartext i databas systemet.Always Encrypted ensures that sensitive data never appears as plaintext inside the database system. När du har konfigurerat data kryptering kan endast klient program eller App-servrar som har åtkomst till nycklarna komma åt oformaterade data.After you configure data encryption, only client applications or app servers that have access to the keys can access plaintext data. Detaljerad information finns i Always Encrypted (databas motor).For detailed information, see Always Encrypted (Database Engine).

När du har konfigurerat databasen att använda Always Encrypted skapar du ett klient program i C# med Visual Studio för att arbeta med krypterade data.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.

Följ stegen i den här artikeln och lär dig hur du konfigurerar Always Encrypted för din databas i Azure SQL Database eller SQL-hanterad instans.Follow the steps in this article and learn how to set up Always Encrypted for your database in Azure SQL Database or SQL Managed Instance. I den här artikeln får du lära dig hur du utför följande uppgifter:In this article you will learn how to perform the following tasks:

FörutsättningarPrerequisites

Aktivera åtkomst till klient programEnable client application access

Du måste aktivera klient programmet för att få åtkomst till din databas i SQL Database genom att konfigurera ett Azure Active Directory (Azure AD)-program och kopiera program-ID: t och nyckeln som du behöver för att autentisera ditt program.You must enable your client application to access your database in SQL Database by setting up an Azure Active Directory (Azure AD) application and copying the Application ID and key that you will need to authenticate your application.

Hämta program-ID och nyckel genom att följa stegen i skapa ett Azure Active Directory program och tjänstens huvud namn som kan komma åt resurser.To get the Application ID and key, follow the steps in create an Azure Active Directory application and service principal that can access resources.

Skapa ett nyckel valv för att lagra dina nycklarCreate a key vault to store your keys

Nu när din klient app har kon figurer ATS och du har ditt program-ID, är det dags att skapa ett nyckel valv och konfigurera dess åtkomst princip så att du och ditt program kan komma åt valvets hemligheter (Always Encrypted nycklar).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). Behörigheterna skapa, Hämta, lista, signera, Verifiera, wrapKey och unwrapKey krävs för att skapa en ny kolumn huvud nyckel och för att konfigurera kryptering med 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.

Du kan snabbt skapa ett nyckel valv genom att köra följande skript.You can quickly create a key vault by running the following script. En detaljerad förklaring av dessa kommandon och mer information om hur du skapar och konfigurerar ett nyckel valv finns i Azure Key Vault?.For a detailed explanation of these commands and more information about creating and configuring a key vault, see What is Azure Key Vault?.

Viktigt

PowerShell-modulen Azure Resource Manager (RM) stöds fortfarande av Azure SQL Database, men all framtida utveckling är för AZ. SQL-modulen.The PowerShell Azure Resource Manager (RM) module is still supported by Azure SQL Database, but all future development is for the Az.Sql module. AzureRM-modulen kommer att fortsätta att ta emot fel korrigeringar fram till minst december 2020.The AzureRM module will continue to receive bug fixes until at least December 2020. Argumenten för kommandona i AZ-modulen och i AzureRm-modulerna är i stort sett identiska.The arguments for the commands in the Az module and in the AzureRm modules are substantially identical. Mer information om deras kompatibilitet finns i Introduktion till den nya Azure PowerShell AZ-modulen.For more about their compatibility, see Introducing the new Azure PowerShell Az module.

$subscriptionName = '<subscriptionName>'
$userPrincipalName = '<username@domain.com>'
$applicationId = '<applicationId from AAD application>'
$resourceGroupName = '<resourceGroupName>' # use the same resource group name when creating your SQL Database below
$location = '<datacenterLocation>'
$vaultName = '<vaultName>'

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

Anslut med SSMSConnect with SSMS

Öppna SQL Server Management Studio (SSMS) och Anslut till servern eller hanterad med databasen.Open SQL Server Management Studio (SSMS) and connect to the server or managed with your database.

  1. Öppna SSMS.Open SSMS. (Gå till Anslut > Database Engine för att öppna fönstret Anslut till Server om det inte är öppet.)(Go to Connect > Database Engine to open the Connect to Server window if it isn't open.)

  2. Ange server namn eller instans namn och autentiseringsuppgifter.Enter your server name or instance name and credentials.

    Kopiera anslutningssträngen

Om fönstret ny brand Väggs regel öppnas loggar du in på Azure och låter SSMS skapa en ny brand Väggs regel åt dig.If the New Firewall Rule window opens, sign in to Azure and let SSMS create a new firewall rule for you.

Skapa en tabellCreate a table

I det här avsnittet ska du skapa en tabell för att lagra patient data.In this section, you will create a table to hold patient data. Den är inte initialt krypterad – du kommer att konfigurera kryptering i nästa avsnitt.It's not initially encrypted--you will configure encryption in the next section.

  1. Expandera databaser.Expand Databases.
  2. Högerklicka på databasen och klicka på ny fråga.Right-click the database and click New Query.
  3. Klistra in följande Transact-SQL (T-SQL) i fönstret ny fråga och Kör det.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

Kryptera kolumner (Konfigurera Always Encrypted)Encrypt columns (configure Always Encrypted)

SSMS innehåller en guide som hjälper dig att enkelt konfigurera Always Encrypted genom att ställa in kolumnens huvud nyckel, kolumn krypterings nyckel och krypterade kolumner åt dig.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. Expandera Databases > klinik- > tabeller för databaser.Expand Databases > Clinic > Tables.

  2. Högerklicka på tabellen patienter och välj kryptera kolumner för att öppna guiden Always Encrypted:Right-click the Patients table and select Encrypt Columns to open the Always Encrypted wizard:

    Skärm bild som visar krypterade kolumner... meny alternativ.

Guiden Always Encrypted innehåller följande avsnitt: kolumn val, huvud nyckel konfiguration, verifiering och Sammanfattning.The Always Encrypted wizard includes the following sections: Column Selection, Master Key Configuration, Validation, and Summary.

Kolumn valColumn Selection

Klicka på Nästa på sidan Introduktion för att öppna sidan kolumn val .Click Next on the Introduction page to open the Column Selection page. På den här sidan kan du välja vilka kolumner du vill kryptera, vilken typ av kryptering och vilken kolumn krypterings nyckel (CEK) som ska användas.On this page, you will select which columns you want to encrypt, the type of encryption, and what column encryption key (CEK) to use.

Kryptera uppgifter om SSN och födelse datum för varje patient.Encrypt SSN and BirthDate information for each patient. Kolumnen SSN använder deterministisk kryptering, som stöder likhets uppslag, kopplingar och gruppering av.The SSN column will use deterministic encryption, which supports equality lookups, joins, and group by. Kolumnen födelse datum kommer att använda slumpmässig kryptering, som inte stöder åtgärder.The BirthDate column will use randomized encryption, which does not support operations.

Ange krypterings typ för kolumnen SSN till deterministisk och kolumnen födelse datum till slumpmässig.Set the Encryption Type for the SSN column to Deterministic and the BirthDate column to Randomized. Klicka på Nästa.Click Next.

Kryptera kolumner

Huvud nyckel konfigurationMaster Key Configuration

På sidan konfiguration av huvud nyckel kan du konfigurera din CMK och välja den nyckel lagrings leverantör där CMK ska lagras.The Master Key Configuration page is where you set up your CMK and select the key store provider where the CMK will be stored. För närvarande kan du lagra en CMK i certifikat arkivet i Windows, Azure Key Vault eller en HSM (Hardware Security Module).Currently, you can store a CMK in the Windows certificate store, Azure Key Vault, or a hardware security module (HSM).

I den här självstudien visas hur du lagrar dina nycklar i Azure Key Vault.This tutorial shows how to store your keys in Azure Key Vault.

  1. Välj Azure Key Vault.Select Azure Key Vault.
  2. Välj önskat nyckel valv i den nedrullningsbara listan.Select the desired key vault from the drop-down list.
  3. Klicka på Nästa.Click Next.

Huvud nyckel konfiguration

ValideringValidation

Du kan kryptera kolumnerna nu eller spara ett PowerShell-skript för att köra senare.You can encrypt the columns now or save a PowerShell script to run later. I den här självstudien väljer du Fortsätt för att slutföra nu och klickar på Nästa.For this tutorial, select Proceed to finish now and click Next.

SammanfattningSummary

Kontrol lera att inställningarna är korrekta och klicka på Slutför för att slutföra installationen av Always Encrypted.Verify that the settings are all correct and click Finish to complete the setup for Always Encrypted.

Skärm bild som visar sidan resultat med aktiviteter som har marker ATS som slutförda.

Verifiera guidens åtgärderVerify the wizard's actions

När guiden har slutförts konfigureras databasen för Always Encrypted.After the wizard is finished, your database is set up for Always Encrypted. Följande åtgärder utfördes av guiden:The wizard performed the following actions:

  • Skapade en kolumn huvud nyckel och lagrat den i Azure Key Vault.Created a column master key and stored it in Azure Key Vault.
  • Skapade en kolumn krypterings nyckel och lagrade den i Azure Key Vault.Created a column encryption key and stored it in Azure Key Vault.
  • Konfigurerade de markerade kolumnerna för kryptering.Configured the selected columns for encryption. Tabellen patienter har för närvarande inga data, men alla befintliga data i de markerade kolumnerna är nu krypterade.The Patients table currently has no data, but any existing data in the selected columns is now encrypted.

Du kan kontrol lera att nycklarna skapas i SSMS genom att expandera Clinic > säkerhets > Always Encrypted nycklar för klinik.You can verify the creation of the keys in SSMS by expanding Clinic > Security > Always Encrypted Keys.

Skapa ett klient program som fungerar med krypterade dataCreate a client application that works with the encrypted data

Nu när Always Encrypted har kon figurer ATS kan du skapa ett program som utför infogningar och väljer i de krypterade kolumnerna.Now that Always Encrypted is set up, you can build an application that performs inserts and selects on the encrypted columns.

Viktigt

Ditt program måste använda SqlParameter -objekt när du skickar oformaterade data till servern med Always Encrypted kolumner.Your application must use SqlParameter objects when passing plaintext data to the server with Always Encrypted columns. Att skicka litterala värden utan att använda SqlParameter-objekt resulterar i ett undantag.Passing literal values without using SqlParameter objects will result in an exception.

  1. Öppna Visual Studio och skapa ett nytt C#- konsol program (visual Studio 2015 och tidigare) eller konsol program (.NET Framework) (Visual Studio 2017 och senare).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). Kontrol lera att ditt projekt är inställt på .NET Framework 4,6 eller senare.Make sure your project is set to .NET Framework 4.6 or later.
  2. Ge projektet namnet AlwaysEncryptedConsoleAKVApp och klicka på OK.Name the project AlwaysEncryptedConsoleAKVApp and click OK.
  3. Installera följande NuGet-paket genom att gå till verktyg > NuGet Package Manager > Package Manager-konsolen.Install the following NuGet packages by going to Tools > NuGet Package Manager > Package Manager Console.

Kör dessa två kodrader i Package Manager-konsolen:Run these two lines of code in the Package Manager Console:

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

Ändra anslutnings strängen för att aktivera Always EncryptedModify your connection string to enable Always Encrypted

I det här avsnittet beskrivs hur du aktiverar Always Encrypted i databas anslutnings strängen.This section explains how to enable Always Encrypted in your database connection string.

Om du vill aktivera Always Encrypted måste du lägga till nyckelordet för kolumn krypterings inställningen i anslutnings strängen och ange det som aktive rad.To enable Always Encrypted, you need to add the Column Encryption Setting keyword to your connection string and set it to Enabled.

Du kan ställa in detta direkt i anslutnings strängen, eller så kan du ange den med hjälp av SqlConnectionStringBuilder.You can set this directly in the connection string, or you can set it by using SqlConnectionStringBuilder. Exempel programmet i nästa avsnitt visar hur du använder SqlConnectionStringBuilder.The sample application in the next section shows how to use SqlConnectionStringBuilder.

Aktivera Always Encrypted i anslutnings strängenEnable Always Encrypted in the connection string

Lägg till följande nyckelord i anslutnings strängen.Add the following keyword to your connection string.

Column Encryption Setting=Enabled

Aktivera Always Encrypted med SqlConnectionStringBuilderEnable Always Encrypted with SqlConnectionStringBuilder

Följande kod visar hur du aktiverar Always Encrypted genom att ställa in SqlConnectionStringBuilder. ColumnEncryptionSettingEnabled.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;

Registrera Azure Key Vault-providernRegister the Azure Key Vault provider

Följande kod visar hur du registrerar Azure Key Vault-providern med ADO.NET-drivrutinen.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);
}

Always Encrypted exempel konsol programAlways Encrypted sample console application

Det här exemplet visar hur du:This sample demonstrates how to:

  • Ändra anslutnings strängen för att aktivera Always Encrypted.Modify your connection string to enable Always Encrypted.
  • Registrera Azure Key Vault som programmets nyckel lagrings leverantör.Register Azure Key Vault as the application's key store provider.
  • Infoga data i de krypterade kolumnerna.Insert data into the encrypted columns.
  • Välj en post genom att filtrera efter ett särskilt värde i en krypterad kolumn.Select a record by filtering for a specific value in an encrypted column.

Ersätt innehållet i program.cs med följande kod.Replace the contents of Program.cs with the following code. Ersätt anslutnings strängen för den globala connectionString-variabeln på raden som direkt föregår huvud metoden med en giltig anslutnings sträng från 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. Detta är den enda ändringen du behöver göra i den här koden.This is the only change you need to make to this code.

Kör appen för att se Always Encrypted i praktiken.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; }
    }
}

Verifiera att data är krypteradeVerify that the data is encrypted

Du kan snabbt kontrol lera att faktiska data på servern är krypterade genom att fråga patienternas data med SSMS (med den aktuella anslutningen där kolumn krypterings inställningen inte är aktive rad).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).

Kör följande fråga i klinik-databasen.Run the following query on the Clinic database.

SELECT FirstName, LastName, SSN, BirthDate FROM Patients;

Du kan se att de krypterade kolumnerna inte innehåller några oformaterade data.You can see that the encrypted columns do not contain any plaintext data.

Skärm bild som visar att de krypterade kolumnerna inte innehåller några oformaterade data.

Om du vill använda SSMS för att komma åt data i klartext måste du först se till att användaren har rätt behörighet till Azure Key Vault: Get, unwrapKey och 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. Detaljerad information finns i skapa och lagra kolumn huvud nycklar (Always Encrypted).For detailed information, see Create and Store Column Master Keys (Always Encrypted).

Lägg sedan till kolumn krypterings inställningen = aktive rad parameter under anslutningen.Then add the Column Encryption Setting=enabled parameter during your connection.

  1. I SSMS högerklickar du på din server i Object Explorer och väljer Koppla från.In SSMS, right-click your server in Object Explorer and choose Disconnect.

  2. Klicka på Anslut > databas motor för att öppna fönstret Anslut till Server och klicka på alternativ.Click Connect > Database Engine to open the Connect to Server window and click Options.

  3. Klicka på ytterligare anslutnings parametrar och ange kolumn krypterings inställning = aktive rad.Click Additional Connection Parameters and type Column Encryption Setting=enabled.

    Skärm bild som visar fliken Ytterligare korrektions parametrar.

  4. Kör följande fråga i klinik-databasen.Run the following query on the Clinic database.

    SELECT FirstName, LastName, SSN, BirthDate FROM Patients;
    

    Nu kan du se data i klartext i de krypterade kolumnerna.You can now see the plaintext data in the encrypted columns.

    Nytt konsol program

Nästa stegNext steps

När databasen har kon figurer ATS för att använda Always Encrypted kanske du vill göra följande:After your database is configured to use Always Encrypted, you may want to do the following: