Always Encrypted: Ochrona danych poufnych i przechowywanie kluczy szyfrowania w programie Azure Key VaultAlways Encrypted: Protect sensitive data and store encryption keys in Azure Key Vault

W tym artykule opisano sposób zabezpieczania poufnych danych w bazie danych SQL przy użyciu szyfrowania danych za pomocą kreatora Always Encrypted w programie 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). Zawiera również instrukcje, które pokazują, jak przechowywać każdy klucz szyfrowania w Azure Key Vault.It also includes instructions that will show you how to store each encryption key in Azure Key Vault.

Always Encrypted to nowa technologia szyfrowania danych w Azure SQL Database i SQL Server, która pomaga chronić poufne dane przechowywane na serwerze, podczas przenoszenia między klientem i serwerem, a gdy dane są używane.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 zapewnia, że poufne dane nigdy nie pojawiają się jako zwykły tekst w systemie bazy danych.Always Encrypted ensures that sensitive data never appears as plaintext inside the database system. Po skonfigurowaniu szyfrowania danych tylko aplikacje klienckie lub serwery aplikacji, które mają dostęp do kluczy, mogą uzyskiwać dostęp do danych w postaci zwykłego tekstu.After you configure data encryption, only client applications or app servers that have access to the keys can access plaintext data. Aby uzyskać szczegółowe informacje, zobacz Always Encrypted (aparat bazy danych).For detailed information, see Always Encrypted (Database Engine).

Po skonfigurowaniu bazy danych do korzystania z Always Encrypted zostanie utworzona aplikacja kliencka w C# programie z programem Visual Studio do pracy z zaszyfrowanymi danymi.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.

Wykonaj kroki opisane w tym artykule, aby dowiedzieć się, jak skonfigurować Always Encrypted dla bazy danych Azure SQL Database.Follow the steps in this article and learn how to set up Always Encrypted for an Azure SQL database. W tym artykule dowiesz się, jak wykonywać następujące zadania:In this article you will learn how to perform the following tasks:

Wymagania wstępnePrerequisites

Uwaga

Ten artykuł został zaktualizowany o korzystanie z nowego modułu Azure PowerShell Az.This article has been updated to use the new Azure PowerShell Az module. Nadal możesz używać modułu AzureRM, który będzie nadal otrzymywać poprawki błędów do co najmniej grudnia 2020 r.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Aby dowiedzieć się więcej na temat nowego modułu Az i zgodności z modułem AzureRM, zobacz Wprowadzenie do nowego modułu Az programu Azure PowerShell.To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Aby uzyskać instrukcje dotyczące instalacji modułu Az, zobacz Instalowanie programu Azure PowerShell.For Az module installation instructions, see Install Azure PowerShell.

Ważne

Moduł Azure Resource Manager programu PowerShell jest nadal obsługiwany przez Azure SQL Database, ale wszystkie przyszłe Programowanie dla modułu 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. W przypadku tych poleceń cmdlet zobacz AzureRM. SQL.For these cmdlets, see AzureRM.Sql. Argumenty poleceń polecenia AZ module i w modułach AzureRm są zasadniczo identyczne.The arguments for the commands in the Az module and in the AzureRm modules are substantially identical.

W tym samouczku będą potrzebne następujące aplikacje:For this tutorial, you'll need:

Umożliwienie aplikacji klienckiej dostępu do usługi SQL DatabaseEnable your client application to access the SQL Database service

Musisz umożliwić aplikacji klienckiej dostęp do usługi SQL Database przez skonfigurowanie aplikacji Azure Active Directory (AAD) i skopiowanie identyfikatora aplikacji i klucza , który będzie potrzebny do uwierzytelnienia aplikacji.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.

Aby uzyskać Identyfikator aplikacji i klucz, wykonaj kroki opisane w temacie Tworzenie Azure Active Directory aplikacji i nazwy głównej usługi, która może uzyskiwać dostęp do zasobów.To get the Application ID and key, follow the steps in create an Azure Active Directory application and service principal that can access resources.

Tworzenie magazynu kluczy w celu przechowywania kluczyCreate a key vault to store your keys

Teraz, gdy aplikacja kliencka jest skonfigurowana i masz identyfikator aplikacji, można utworzyć magazyn kluczy i skonfigurować zasady dostępu, aby umożliwić aplikacji dostęp do wpisów tajnych magazynu (Always Encrypted kluczy).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). Uprawnienia Create, Get, list, Sign, verify, wrapKeyi unwrapKey są wymagane do utworzenia nowego klucza głównego kolumny i konfigurowania szyfrowania przy użyciu 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.

Możesz szybko utworzyć magazyn kluczy, uruchamiając Poniższy skrypt.You can quickly create a key vault by running the following script. Aby uzyskać szczegółowy opis tych poleceń cmdlet i więcej informacji na temat tworzenia i konfigurowania magazynu kluczy, zobacz co to jest Azure Key Vault?.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

Tworzenie pustej bazy danych SQLCreate a blank SQL database

  1. Zaloguj się w witrynie Azure Portal.Sign in to the Azure portal.

  2. Przejdź do obszaru Tworzenie zasobów > baz danych > SQL Database.Go to Create a resource > Databases > SQL Database.

  3. Utwórz pustą bazę danych o nazwie Klinika na nowym lub istniejącym serwerze.Create a Blank database named Clinic on a new or existing server. Aby uzyskać szczegółowe instrukcje dotyczące sposobu tworzenia bazy danych w Azure Portal, zobacz pierwszą bazę danych Azure SQL Database.For detailed directions about how to create a database in the Azure portal, see Your first Azure SQL database.

    Tworzenie pustej bazy danych

Parametry połączenia będą potrzebne później w samouczku, więc po utworzeniu bazy danych przejdź do nowej bazy danych kliniki i skopiuj parametry połączenia.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. Parametry połączenia można uzyskać w dowolnym momencie, ale jest to łatwe do skopiowania w Azure Portal.You can get the connection string at any time, but it's easy to copy it in the Azure portal.

  1. Przejdź do bazy danych SQL , > Klinika > Pokaż parametry połączenia bazy danych.Go to SQL databases > Clinic > Show database connection strings.

  2. Skopiuj parametry połączenia dla ADO.NET.Copy the connection string for ADO.NET.

    Kopiowanie parametrów połączenia

Nawiązywanie połączenia z bazą danych za pomocą programu SSMSConnect to the database with SSMS

Otwórz program SSMS i Połącz się z serwerem przy użyciu bazy danych kliniki.Open SSMS and connect to the server with the Clinic database.

  1. Otwórz program SSMS.Open SSMS. (Przejdź do programu connect > Database Engine , aby otworzyć okno łączenie z serwerem , jeśli nie jest otwarte).(Go to Connect > Database Engine to open the Connect to Server window if it isn't open.)

  2. Wprowadź nazwę serwera i poświadczenia.Enter your server name and credentials. Nazwę serwera można znaleźć w bloku bazy danych SQL i w wcześniej kopiowanych parametrach połączenia.The server name can be found on the SQL database blade and in the connection string you copied earlier. Wpisz pełną nazwę serwera, łącznie z Database.Windows.NET.Type the complete server name, including database.windows.net.

    Kopiowanie parametrów połączenia

Jeśli zostanie otwarte okno Nowa reguła zapory , zaloguj się do platformy Azure i zezwól PROGRAMowi ssmsemu na utworzenie nowej reguły zapory.If the New Firewall Rule window opens, sign in to Azure and let SSMS create a new firewall rule for you.

Tworzenie tabeliCreate a table

W tej sekcji utworzysz tabelę do przechowywania danych pacjenta.In this section, you will create a table to hold patient data. Nie jest on początkowo zaszyfrowany — skonfigurujesz szyfrowanie w następnej sekcji.It's not initially encrypted--you will configure encryption in the next section.

  1. Rozwiń węzeł bazy danych.Expand Databases.
  2. Kliknij prawym przyciskiem myszy bazę danych kliniki , a następnie kliknij pozycję nowe zapytanie.Right-click the Clinic database and click New Query.
  3. Wklej następujący język Transact-SQL (T-SQL) do nowego okna zapytania i Wykonaj go.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

Szyfruj kolumny (Konfigurowanie Always Encrypted)Encrypt columns (configure Always Encrypted)

Program SSMS zawiera kreatora, który ułatwia konfigurowanie Always Encrypted przez skonfigurowanie klucza głównego kolumny, klucza szyfrowania kolumn i zaszyfrowanych kolumn.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. Rozwiń węzeł bazy danych > Klinika > tabele.Expand Databases > Clinic > Tables.

  2. Kliknij prawym przyciskiem myszy tabelę pacjentów i wybierz pozycję Szyfruj kolumny , aby otworzyć Kreatora Always Encrypted:Right-click the Patients table and select Encrypt Columns to open the Always Encrypted wizard:

    Szyfruj kolumny

Kreator Always Encrypted zawiera następujące sekcje: wybór kolumn, Konfiguracja klucza głównego, Walidacjai Podsumowanie.The Always Encrypted wizard includes the following sections: Column Selection, Master Key Configuration, Validation, and Summary.

Wybór kolumnyColumn Selection

Kliknij przycisk dalej na stronie wprowadzenie , aby otworzyć stronę wybór kolumny .Click Next on the Introduction page to open the Column Selection page. Na tej stronie można wybrać kolumny, które mają zostać zaszyfrowane, typ szyfrowania i klucz szyfrowania kolumn (CEK) , które mają być używane.On this page, you will select which columns you want to encrypt, the type of encryption, and what column encryption key (CEK) to use.

Szyfruj informacje o PESEL i dataurodzeniu dla każdego pacjenta.Encrypt SSN and BirthDate information for each patient. Kolumna SSN będzie używać deterministycznego szyfrowania, które obsługuje wyszukiwania równości, sprzężeń i grupowania.The SSN column will use deterministic encryption, which supports equality lookups, joins, and group by. Kolumna dataurodzenie będzie używać losowego szyfrowania, które nie obsługuje operacji.The BirthDate column will use randomized encryption, which does not support operations.

Ustaw typ szyfrowania dla kolumny SSN na wartość deterministyczną i kolumnę DataUrodzenia, która ma być Losowa.Set the Encryption Type for the SSN column to Deterministic and the BirthDate column to Randomized. Kliknij przycisk Dalej.Click Next.

Szyfruj kolumny

Konfiguracja klucza głównegoMaster Key Configuration

Na stronie Konfiguracja klucza głównego można skonfigurować CMK i wybrać dostawcę magazynu kluczy, w którym będzie przechowywany 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. Obecnie można przechowywać CMK w magazynie certyfikatów systemu Windows, Azure Key Vault lub sprzętowym module zabezpieczeń (HSM).Currently, you can store a CMK in the Windows certificate store, Azure Key Vault, or a hardware security module (HSM).

W tym samouczku pokazano, jak przechowywać klucze w Azure Key Vault.This tutorial shows how to store your keys in Azure Key Vault.

  1. Wybierz Azure Key Vault.Select Azure Key Vault.
  2. Wybierz żądany Magazyn kluczy z listy rozwijanej.Select the desired key vault from the drop-down list.
  3. Kliknij przycisk Dalej.Click Next.

Konfiguracja klucza głównego

WalidacjaValidation

Możesz zaszyfrować kolumny teraz lub zapisać skrypt programu PowerShell, aby uruchomić go później.You can encrypt the columns now or save a PowerShell script to run later. Na potrzeby tego samouczka wybierz pozycję Przejdź do pozycji Zakończ teraz , a następnie kliknij przycisk dalej.For this tutorial, select Proceed to finish now and click Next.

PodsumowanieSummary

Sprawdź, czy ustawienia są poprawne, a następnie kliknij przycisk Zakończ , aby ukończyć konfigurację Always Encrypted.Verify that the settings are all correct and click Finish to complete the setup for Always Encrypted.

Podsumowanie

Weryfikuj działania kreatoraVerify the wizard's actions

Po zakończeniu działania kreatora baza danych jest skonfigurowana do Always Encrypted.After the wizard is finished, your database is set up for Always Encrypted. Kreator wykonał następujące akcje:The wizard performed the following actions:

  • Utworzono klucz główny kolumny i zapisany w Azure Key Vault.Created a column master key and stored it in Azure Key Vault.
  • Utworzono klucz szyfrowania kolumny i zapisany w Azure Key Vault.Created a column encryption key and stored it in Azure Key Vault.
  • Skonfigurowano wybrane kolumny do szyfrowania.Configured the selected columns for encryption. Tabela pacjentów nie ma obecnie żadnych danych, ale wszystkie istniejące dane w wybranych kolumnach są teraz szyfrowane.The Patients table currently has no data, but any existing data in the selected columns is now encrypted.

Aby sprawdzić, jak utworzyć klucze w programie SSMS, można powiększać > > zabezpieczeń i Always Encrypted kluczy.You can verify the creation of the keys in SSMS by expanding Clinic > Security > Always Encrypted Keys.

Tworzenie aplikacji klienckiej, która współpracuje z zaszyfrowanymi danymiCreate a client application that works with the encrypted data

Teraz, gdy Always Encrypted jest skonfigurowany, można skompilować aplikację, która wykonuje operacje wstawiania i wybiera w zaszyfrowanej kolumnie.Now that Always Encrypted is set up, you can build an application that performs inserts and selects on the encrypted columns.

Ważne

Aplikacja musi używać obiektów SqlParameter podczas przekazywania danych w postaci zwykłego tekstu do serwera przy użyciu kolumn Always Encrypted.Your application must use SqlParameter objects when passing plaintext data to the server with Always Encrypted columns. Przekazanie wartości literałów bez używania obiektów SqlParameter spowoduje wyjątek.Passing literal values without using SqlParameter objects will result in an exception.

  1. Otwórz program Visual Studio i Utwórz nową C# aplikację konsolową (Visual Studio 2015 i starsze) lub aplikację konsolową (.NET Framework) (Visual Studio 2017 i nowsze).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). Upewnij się, że projekt jest ustawiony na .NET Framework 4,6 lub nowszy.Make sure your project is set to .NET Framework 4.6 or later.
  2. Nadaj projektowi nazwę AlwaysEncryptedConsoleAKVApp i kliknij przycisk OK.Name the project AlwaysEncryptedConsoleAKVApp and click OK.
  3. Zainstaluj następujące pakiety NuGet, przechodząc do narzędzi > menedżera pakietów NuGet > konsoli Menedżera pakietów.Install the following NuGet packages by going to Tools > NuGet Package Manager > Package Manager Console.

Uruchom te dwa wiersze kodu w konsoli Menedżera pakietów.Run these two lines of code in the Package Manager Console.

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

Zmodyfikuj parametry połączenia, aby włączyć Always EncryptedModify your connection string to enable Always Encrypted

W tej sekcji wyjaśniono, jak włączyć Always Encrypted w ciągu połączenia z bazą danych.This section explains how to enable Always Encrypted in your database connection string.

Aby włączyć Always Encrypted, należy dodać słowo kluczowe Ustawienia szyfrowania kolumn do parametrów połączenia i ustawić je na włączone.To enable Always Encrypted, you need to add the Column Encryption Setting keyword to your connection string and set it to Enabled.

Można ustawić tę wartość bezpośrednio w parametrach połączenia lub ustawić ją przy użyciu SqlConnectionStringBuilder.You can set this directly in the connection string, or you can set it by using SqlConnectionStringBuilder. Przykładowa aplikacja w następnej sekcji pokazuje, jak używać SqlConnectionStringBuilder.The sample application in the next section shows how to use SqlConnectionStringBuilder.

Włącz Always Encrypted w parametrach połączeniaEnable Always Encrypted in the connection string

Dodaj następujące słowo kluczowe do parametrów połączenia.Add the following keyword to your connection string.

Column Encryption Setting=Enabled

Włącz Always Encrypted przy użyciu SqlConnectionStringBuilderEnable Always Encrypted with SqlConnectionStringBuilder

Poniższy kod pokazuje, jak włączyć Always Encrypted przez ustawienie SqlConnectionStringBuilder. ColumnEncryptionSetting na włączone.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;

Rejestrowanie dostawcy Azure Key VaultRegister the Azure Key Vault provider

Poniższy kod przedstawia sposób rejestrowania dostawcy Azure Key Vault za pomocą sterownika 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(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 Przykładowa aplikacja konsolowaAlways Encrypted sample console application

W tym przykładzie pokazano, jak:This sample demonstrates how to:

  • Zmodyfikuj parametry połączenia, aby włączyć Always Encrypted.Modify your connection string to enable Always Encrypted.
  • Zarejestruj Azure Key Vault jako dostawcę magazynu kluczy aplikacji.Register Azure Key Vault as the application's key store provider.
  • Wstaw dane do zaszyfrowanych kolumn.Insert data into the encrypted columns.
  • Wybierz rekord, filtrując określoną wartość w zaszyfrowanej kolumnie.Select a record by filtering for a specific value in an encrypted column.

Zastąp zawartość pliku Program.cs poniższym kodem.Replace the contents of Program.cs with the following code. Zastąp ciąg połączenia dla zmiennej Global connectionString w wierszu, który bezpośrednio poprzedza metodę Main prawidłowymi parametrami połączenia z 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. Jest to jedyna zmiana, którą trzeba wykonać w tym kodzie.This is the only change you need to make to this code.

Uruchom aplikację, aby zobaczyć Always Encrypted w działaniu.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; }
    }
    }

Sprawdzanie, czy dane są szyfrowaneVerify that the data is encrypted

Możesz szybko sprawdzić, czy rzeczywiste dane na serwerze są szyfrowane przez wykonywanie zapytań dotyczących danych pacjentów za pomocą programu SSMS (przy użyciu bieżącego połączenia, w którym ustawienie szyfrowania kolumn nie jest jeszcze włączone).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).

Uruchom następujące zapytanie w bazie danych kliniki.Run the following query on the Clinic database.

    SELECT FirstName, LastName, SSN, BirthDate FROM Patients;

Można zobaczyć, że zaszyfrowane kolumny nie zawierają żadnych danych w postaci zwykłego tekstu.You can see that the encrypted columns do not contain any plaintext data.

Nowa aplikacja konsolowa

Aby używać narzędzia SSMS do uzyskiwania dostępu do danych w postaci zwykłego tekstu, należy najpierw upewnić się, że użytkownik ma odpowiednie uprawnienia do Azure Key Vault: Get, unwrapKeyi 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. Aby uzyskać szczegółowe informacje, zobacz Tworzenie i przechowywanie kluczy głównych kolumn (Always Encrypted).For detailed information, see Create and Store Column Master Keys (Always Encrypted).

Następnie Dodaj ustawienie szyfrowanie kolumn = włączone parametr podczas połączenia.Then add the Column Encryption Setting=enabled parameter during your connection.

  1. W programie SSMS kliknij prawym przyciskiem myszy serwer w Eksplorator obiektów i wybierz polecenie Rozłącz.In SSMS, right-click your server in Object Explorer and choose Disconnect.

  2. Kliknij pozycję połącz > aparat bazy danych , aby otworzyć okno łączenie z serwerem , a następnie kliknij przycisk Opcje.Click Connect > Database Engine to open the Connect to Server window and click Options.

  3. Kliknij pozycję dodatkowe parametry połączenia i ustawienie szyfrowania kolumny Typ = włączone.Click Additional Connection Parameters and type Column Encryption Setting=enabled.

    Nowa aplikacja konsolowa

  4. Uruchom następujące zapytanie w bazie danych kliniki.Run the following query on the Clinic database.

       SELECT FirstName, LastName, SSN, BirthDate FROM Patients;
    

    Teraz można zobaczyć dane w postaci zwykłego tekstu w zaszyfrowanych kolumnach.You can now see the plaintext data in the encrypted columns. nową aplikację konsolowąNew console application

Następne krokiNext steps

Po utworzeniu bazy danych korzystającej z Always Encrypted można wykonać następujące czynności:After you create a database that uses Always Encrypted, you may want to do the following: