Always Encrypted: Schützen von vertraulichen Daten und Speichern der Verschlüsselungsschlüssel in Azure Key VaultAlways Encrypted: Protect sensitive data and store encryption keys in Azure Key Vault

In diesem Artikel erfahren Sie, wie Sie vertrauliche Daten in einer SQL-Datenbank mithilfe der Datenverschlüsselung unter Einsatz des Always-Encrypted-Assistenten in SQL Server Management Studio (SSMS) sichern.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). Er enthält auch Anweisungen, die zeigen, wie Sie jeden Verschlüsselungsschlüssel in Azure Key Vault speichern.It also includes instructions that will show you how to store each encryption key in Azure Key Vault.

Always Encrypted ist eine neue Datenverschlüsselungstechnologie in Azure SQL-Datenbank und SQL Server, mit der vertrauliche ruhende Daten auf dem Server, auf dem Weg zwischen Client und Server und während der Verwendung geschützt werden.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 stellt sicher, dass vertrauliche Daten im Datenbanksystem niemals im Klartextformat angezeigt werden.Always Encrypted ensures that sensitive data never appears as plaintext inside the database system. Nachdem Sie die Datenverschlüsselung konfiguriert haben, können nur Clientanwendungen oder App-Server, die Zugriff auf die Schlüssel haben, auf Klartextdaten zugreifen.After you configure data encryption, only client applications or app servers that have access to the keys can access plaintext data. Ausführliche Informationen finden Sie unter Always Encrypted (Datenbank-Engine).For detailed information, see Always Encrypted (Database Engine).

Nach dem Konfigurieren der Datenbank für die Verwendung von Always Encrypted erstellen Sie eine Clientanwendung in C# mit Visual Studio, um mit den verschlüsselten Daten zu arbeiten.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ühren Sie die Schritte in diesem Artikel aus, um zu lernen, wie Sie Always Encrypted für eine Azure SQL-Datenbank einrichten.Follow the steps in this article and learn how to set up Always Encrypted for an Azure SQL database. In diesem Artikel erlernen Sie die Vorgehensweise für folgende Aufgaben:In this article you will learn how to perform the following tasks:

VoraussetzungenPrerequisites

Hinweis

Dieser Artikel wurde aktualisiert und beinhaltet jetzt das neue Az-Modul von Azure PowerShell.This article has been updated to use the new Azure PowerShell Az module. Sie können das AzureRM-Modul weiterhin verwenden, das bis mindestens Dezember 2020 weiterhin Fehlerbehebungen erhält.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Weitere Informationen zum neuen Az-Modul und zur Kompatibilität mit AzureRM finden Sie unter Introducing the new Azure PowerShell Az module (Einführung in das neue Az-Modul von Azure PowerShell).To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Anweisungen zur Installation des Az-Moduls finden Sie unter Install Azure PowerShell (Installieren von Azure PowerShell).For Az module installation instructions, see Install Azure PowerShell.

Wichtig

Das PowerShell Azure Resource Manager-Modul wird von Azure SQL-Datenbank weiterhin unterstützt, aber alle zukünftigen Entwicklungen erfolgen für das Az.Sql-Modul.The PowerShell Azure Resource Manager module is still supported by Azure SQL Database, but all future development is for the Az.Sql module. Informationen zu diesen Cmdlets finden Sie unter AzureRM.Sql.For these cmdlets, see AzureRM.Sql. Die Argumente für die Befehle im Az-Modul und den AzureRm-Modulen sind im Wesentlichen identisch.The arguments for the commands in the Az module and in the AzureRm modules are substantially identical.

Für dieses Tutorial benötigen Sie Folgendes:For this tutorial, you'll need:

Aktivieren der Clientanwendung für den Zugriff auf den SQL-Datenbank-DienstEnable your client application to access the SQL Database service

Sie müssen Ihre Clientanwendung aktivieren, um auf den SQL-Datenbank-Dienst zuzugreifen. Richten Sie dazu eine Azure Active Directory-Anwendung (AAD) ein, und kopieren Sie die Anwendungs-ID und den Schlüssel, die Sie zum Authentifizieren der Anwendung benötigen.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.

Führen Sie zum Abrufen von Anwendungs-ID und Schlüssel die Schritte unter Erstellen einer Azure Active Directory-Anwendung und eines Dienstprinzipals mit Ressourcenzugriff mithilfe des Portals aus.To get the Application ID and key, follow the steps in create an Azure Active Directory application and service principal that can access resources.

Erstellen eines Schlüsseltresors zum Speichern Ihrer SchlüsselCreate a key vault to store your keys

Da nun die Client-App konfiguriert ist und Sie über die Anwendungs-ID verfügen, ist es an der Zeit, einen Schlüsseltresor zu erstellen und die Zugriffsrichtlinie zu konfigurieren, damit Sie und Ihre Anwendung auf die Geheimnisse (Always Encrypted-Schlüssel) im Tresor zugreifen können.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). Die Berechtigungen create, get, list, sign, verify, wrapKey und unwrapKey sind zum Erstellen eines neuen Spaltenhauptschlüssels sowie zum Einrichten der Verschlüsselung mit SQL Server Management Studio erforderlich.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.

Sie können schnell einen Schlüsseltresor erstellen, indem Sie das folgende Skript ausführen.You can quickly create a key vault by running the following script. Eine ausführliche Erläuterung dieser Cmdlets und weitere Informationen zum Erstellen und Konfigurieren eines Schlüsseltresors finden Sie unter Was ist 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

Erstellen einer leeren SQL-DatenbankCreate a blank SQL database

  1. Melden Sie sich beim Azure-Portal an.Sign in to the Azure portal.

  2. Wechseln Sie zu Ressource erstellen > Datenbanken > SQL-Datenbank.Go to Create a resource > Databases > SQL Database.

  3. Erstellen Sie auf einem neuen oder vorhandenen Server eine leere Datenbank mit dem Namen Clinic.Create a Blank database named Clinic on a new or existing server. Eine ausführliche Anleitung zum Erstellen einer Datenbank im Azure-Portal finden Sie unter Ihre erste Azure SQL-Datenbank.For detailed directions about how to create a database in the Azure portal, see Your first Azure SQL database.

    Leere Datenbank erstellen

Sie benötigen die Verbindungszeichenfolge später im Tutorial – navigieren Sie also nach dem Erstellen der Datenbank zur neuen Clinic-Datenbank, und kopieren Sie die Verbindungszeichenfolge.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. Sie können die Verbindungszeichenfolge zu einem beliebigen Zeitpunkt abrufen, aber sie lässt sich im Azure-Portal einfach kopieren.You can get the connection string at any time, but it's easy to copy it in the Azure portal.

  1. Navigieren Sie zu SQL-Datenbanken > Clinic > Datenbank-Verbindungszeichenfolgen anzeigen.Go to SQL databases > Clinic > Show database connection strings.

  2. Kopieren Sie die Verbindungszeichenfolge für ADO.NET.Copy the connection string for ADO.NET.

    Verbindungszeichenfolge kopieren

Herstellen einer Verbindung für die Datenbank mit SSMSConnect to the database with SSMS

Öffnen Sie SSMS, und stellen Sie für die Clinic-Datenbank eine Verbindung mit dem Server her.Open SSMS and connect to the server with the Clinic database.

  1. Öffnen Sie SSMS.Open SSMS. (Navigieren Sie zu Verbinden > Datenbank-Engine, um das Fenster Mit Server verbinden zu öffnen, falls es nicht geöffnet ist.)(Go to Connect > Database Engine to open the Connect to Server window if it isn't open.)

  2. Geben Sie Ihren Servernamen und die Anmeldeinformationen ein.Enter your server name and credentials. Den Servernamen finden Sie auf dem Blatt „SQL-Datenbank“ und in der zuvor kopierten Verbindungszeichenfolge.The server name can be found on the SQL database blade and in the connection string you copied earlier. Geben Sie den vollständigen Servernamen ein, einschließlich database.windows.net.Type the complete server name, including database.windows.net.

    Verbindungszeichenfolge kopieren

Wenn das Fenster Neue Firewallregel geöffnet wird, melden Sie sich bei Azure an und lassen SSMS eine neue Firewallregel für Sie erstellen.If the New Firewall Rule window opens, sign in to Azure and let SSMS create a new firewall rule for you.

Erstellen einer TabelleCreate a table

In diesem Abschnitt erstellen Sie eine Tabelle zum Speichern von Patientendaten.In this section, you will create a table to hold patient data. Sie ist anfänglich nicht verschlüsselt – im nächsten Abschnitt konfigurieren Sie die Verschlüsselung.It's not initially encrypted--you will configure encryption in the next section.

  1. Erweitern Sie Datenbanken.Expand Databases.
  2. Klicken Sie mit der rechten Maustaste auf die Datenbank Clinic, und klicken Sie dann auf Neue Abfrage.Right-click the Clinic database and click New Query.
  3. Fügen Sie den folgenden Transact-SQL-Code (T-SQL) in das Fenster mit der neuen Abfrage ein, und wählen Sie Ausführen .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

Verschlüsseln von Spalten (Konfigurieren von Always Encrypted)Encrypt columns (configure Always Encrypted)

SSMS enthält einen Assistenten zum einfachen Konfigurieren von Always Encrypted, indem Spaltenhauptschlüssel, Spaltenverschlüsselungsschlüssel und verschlüsselte Spalten für Sie eingerichtet werden.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. Erweitern Sie Datenbanken > Clinic > Tabellensichern.Expand Databases > Clinic > Tables.

  2. Klicken Sie mit der rechten Maustaste auf die Tabelle Patients, und wählen Sie Spalten verschlüsseln aus, um den Always Encrypted-Assistenten zu öffnen:Right-click the Patients table and select Encrypt Columns to open the Always Encrypted wizard:

    Spalten verschlüsseln

Der Always Encrypted-Assistent enthält die folgenden Abschnitte: Spaltenauswahl, Konfiguration des Hauptschlüssels, Prüfung und Zusammenfassung.The Always Encrypted wizard includes the following sections: Column Selection, Master Key Configuration, Validation, and Summary.

SpaltenauswahlColumn Selection

Klicken Sie auf der Seite Einführung auf Weiter, um die Seite Spaltenauswahl zu öffnen.Click Next on the Introduction page to open the Column Selection page. Wählen Sie auf dieser Seite die Spalten, die Sie verschlüsseln möchten, den Typ der Verschlüsselung, und welcher Spaltenverschlüsselungsschlüssel (Column Encryption Key, CEK) verwendet werden soll.On this page, you will select which columns you want to encrypt, the type of encryption, and what column encryption key (CEK) to use.

Verschlüsseln Sie für jeden Patienten die Daten SSN (US-Sozialversicherungsnummer) und BirthDate (Geburtsdatum).Encrypt SSN and BirthDate information for each patient. Für die Spalte „SSN“ wird die deterministische Verschlüsselung verwendet, bei der Suchvorgänge nach Gleichheit, Joins und Group By unterstützt werden.The SSN column will use deterministic encryption, which supports equality lookups, joins, and group by. Für die Spalte „BirthDate“ wird die zufällige Verschlüsselung verwendet, bei der keine Operationen unterstützt werden.The BirthDate column will use randomized encryption, which does not support operations.

Legen Sie als Verschlüsselungstyp für die Spalte „SSN“ Deterministisch und für die Spalte „BirthDate“ Zufällig fest.Set the Encryption Type for the SSN column to Deterministic and the BirthDate column to Randomized. Klicken Sie auf Weiter.Click Next.

Spalten verschlüsseln

HauptschlüsselkonfigurationMaster Key Configuration

Auf der Seite Hauptschlüsselkonfiguration richten Sie Ihren CMK ein und wählen den Schlüsselspeicheranbieter aus, unter dem der CMK gespeichert werden soll.The Master Key Configuration page is where you set up your CMK and select the key store provider where the CMK will be stored. Derzeit können Sie einen CMK im Windows-Zertifikatspeicher, im Azure-Schlüsseltresor oder in einem Hardwaresicherheitsmodul (HSM) speichern.Currently, you can store a CMK in the Windows certificate store, Azure Key Vault, or a hardware security module (HSM).

Dieses Tutorial zeigt, wie Sie Ihre Schlüssel in Azure Key Vault speichern.This tutorial shows how to store your keys in Azure Key Vault.

  1. Wählen Sie Azure Key Vaultaus.Select Azure Key Vault.
  2. Wählen Sie in der Dropdownliste den gewünschten Schlüsseltresor aus.Select the desired key vault from the drop-down list.
  3. Klicken Sie auf Weiter.Click Next.

Hauptschlüsselkonfiguration

ÜberprüfenValidation

Sie können die Spalten jetzt verschlüsseln oder ein PowerShell-Skript für die spätere Ausführung speichern.You can encrypt the columns now or save a PowerShell script to run later. Wählen Sie für dieses Tutorial die Option Jetzt fertig stellen, und klicken Sie auf Weiter.For this tutorial, select Proceed to finish now and click Next.

ZusammenfassungSummary

Überprüfen Sie, ob alle Einstellungen richtig sind, und klicken Sie auf Fertig stellen , um die Einrichtung von Always Encrypted abzuschließen.Verify that the settings are all correct and click Finish to complete the setup for Always Encrypted.

Zusammenfassung

Überprüfen der Aktionen des AssistentenVerify the wizard's actions

Nach Abschluss des Assistenten ist die Datenbank für Always Encrypted eingerichtet.After the wizard is finished, your database is set up for Always Encrypted. Der Assistent führte die folgenden Aktionen aus:The wizard performed the following actions:

  • Erstellung eines Spaltenhauptschlüssels und Speicherung in Ihrem Azure Key Vault.Created a column master key and stored it in Azure Key Vault.
  • Erstellung eines Spaltenverschlüsselungsschlüssels und Speicherung in Ihrem Azure Key Vault.Created a column encryption key and stored it in Azure Key Vault.
  • Konfigurieren der ausgewählten Spalten für die VerschlüsselungConfigured the selected columns for encryption. Die Tabelle „Patients“ enthält derzeit noch keine Daten, aber alle vorhandenen Daten in den ausgewählten Spalten wären jetzt verschlüsselt.The Patients table currently has no data, but any existing data in the selected columns is now encrypted.

Sie können die Erstellung der Schlüssel in SSMS überprüfen, indem Sie die Optionen Clinic > Sicherheit > Always Encrypted-Schlüssel erweitern.You can verify the creation of the keys in SSMS by expanding Clinic > Security > Always Encrypted Keys.

Erstellen einer Clientanwendung für die Verwendung der verschlüsselten DatenCreate a client application that works with the encrypted data

Nach dem Einrichten von Always Encrypted können Sie eine Anwendung erstellen, die Einfügevorgänge und Auswahlvorgänge in den verschlüsselten Spalten durchführt.Now that Always Encrypted is set up, you can build an application that performs inserts and selects on the encrypted columns.

Wichtig

Für Ihre Anwendung müssen SqlParameter -Objekte verwendet werden, wenn Klartextdaten an den Server mit Always Encrypted-Spalten übergeben werden.Your application must use SqlParameter objects when passing plaintext data to the server with Always Encrypted columns. Das Übergeben von Literalwerten ohne SqlParameter-Objekte führt zu einer Ausnahme.Passing literal values without using SqlParameter objects will result in an exception.

  1. Öffnen Sie Visual Studio und erstellen Sie eine neue C#-Konsolenanwendung (Visual Studio 2015 und früher) oder Konsolenanwendung (.NET Framework) (Visual Studio 2017 und höher).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). Stellen Sie sicher, dass Ihr Projekt auf .NET Framework 4.6 oder höher festgelegt ist.Make sure your project is set to .NET Framework 4.6 or later.
  2. Geben Sie dem Projekt den Namen AlwaysEncryptedConsoleAKVApp, und klicken Sie auf OK.Name the project AlwaysEncryptedConsoleAKVApp and click OK.
  3. Installieren Sie die NuGet-Pakete, indem Sie zu Tools > NuGet-Paket-Manager > Paket-Manager-Konsole navigieren.Install the following NuGet packages by going to Tools > NuGet Package Manager > Package Manager Console.

Führen Sie diese beiden Codezeilen in der Paket-Manager-Konsole aus.Run these two lines of code in the Package Manager Console.

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

Ändern der Verbindungszeichenfolge zur Aktivierung von Always EncryptedModify your connection string to enable Always Encrypted

In diesem Abschnitt wird beschrieben, wie Sie Always Encrypted in Ihrer Datenbank-Verbindungszeichenfolge aktivieren.This section explains how to enable Always Encrypted in your database connection string.

Zum Aktivieren von Always Encrypted müssen Sie der Verbindungszeichenfolge das Schlüsselwort Column Encryption Setting hinzufügen und es auf Enabled festlegen.To enable Always Encrypted, you need to add the Column Encryption Setting keyword to your connection string and set it to Enabled.

Sie können dies direkt in der Verbindungszeichenfolge festlegen, oder Sie können zum Festlegen ein SqlConnectionStringBuilder-Element verwenden.You can set this directly in the connection string, or you can set it by using SqlConnectionStringBuilder. Die Beispielanwendung im nächsten Abschnitt veranschaulicht, wie Sie das SqlConnectionStringBuilder-Element verwenden.The sample application in the next section shows how to use SqlConnectionStringBuilder.

Aktivieren von Always Encrypted in der VerbindungszeichenfolgeEnable Always Encrypted in the connection string

Fügen Sie der Verbindungszeichenfolge das folgende Schlüsselwort hinzu.Add the following keyword to your connection string.

Column Encryption Setting=Enabled

Aktivieren von Always Encrypted per SqlConnectionStringBuilderEnable Always Encrypted with SqlConnectionStringBuilder

Der folgende Code zeigt, wie Sie Always Encrypted aktivieren, indem Sie SqlConnectionStringBuilder.ColumnEncryptionSetting auf Enabled festlegen.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;

Registrieren des Azure-Schlüsseltresor-AnbietersRegister the Azure Key Vault provider

Der folgende Code zeigt, wie Sie den Azure Key Vault-Anbieter mit dem ADO.NET-Treiber registrieren.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-BeispielkonsolenanwendungAlways Encrypted sample console application

In diesem Beispiel wird Folgendes veranschaulicht:This sample demonstrates how to:

  • Ändern der Verbindungszeichenfolge zur Aktivierung von Always EncryptedModify your connection string to enable Always Encrypted.
  • Registrieren Sie Azure Key Vault als Schlüsselspeicheranbieter für die Anwendung.Register Azure Key Vault as the application's key store provider.
  • Einfügen von Daten in die verschlüsselten SpaltenInsert data into the encrypted columns.
  • Auswählen eines Datensatzes per Filterung nach einem bestimmten Wert in einer verschlüsselten SpalteSelect a record by filtering for a specific value in an encrypted column.

Ersetzen Sie den Inhalt von Program.cs durch den folgenden Code.Replace the contents of Program.cs with the following code. Ersetzen Sie die Verbindungszeichenfolge für die globale connectionString-Variable in der Zeile direkt vor der Main-Methode durch Ihre gültige Verbindungszeichenfolge aus dem 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. Dies ist die einzige Änderung, die Sie an diesem Code vornehmen müssen.This is the only change you need to make to this code.

Führen Sie die App aus, um Always Encrypted in Aktion zu erleben.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; }
    }
    }

Überprüfen, ob die Daten verschlüsselt sindVerify that the data is encrypted

Sie können schnell überprüfen, ob die eigentlichen Daten auf dem Server verschlüsselt sind, indem Sie die Patientendaten mit SSMS abfragen (mit der aktuellen Verbindung, für die Column Encryption Setting noch nicht aktiviert ist).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).

Führen Sie die folgende Abfrage für die Clinic-Datenbank aus.Run the following query on the Clinic database.

    SELECT FirstName, LastName, SSN, BirthDate FROM Patients;

Sie sehen, dass die verschlüsselten Spalten keine Klartextdaten enthalten.You can see that the encrypted columns do not contain any plaintext data.

Neue Konsolenanwendung

Um mit SSMS auf Klartextdaten zuzugreifen, müssen Sie zuerst sicherstellen, dass der Benutzer über die erforderlichen Berechtigungen für den Azure Key Vault verfügt: get, unwrapKey und 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. Ausführliche Informationen finden Sie unter Erstellen und Speichern von Spaltenhauptschlüsseln (Always Encrypted).For detailed information, see Create and Store Column Master Keys (Always Encrypted).

Fügen Sie dann während der Verbindung den Parameter Column Encryption Setting=enabled hinzu.Then add the Column Encryption Setting=enabled parameter during your connection.

  1. Klicken Sie in SSMS im Objekt-Explorer mit der rechten Maustaste auf Ihren Server, und wählen Sie Trennen.In SSMS, right-click your server in Object Explorer and choose Disconnect.

  2. Klicken Sie auf Verbinden > Datenbank-Engine, um das Fenster Mit Server verbinden zu öffnen, und klicken Sie dann auf Optionen.Click Connect > Database Engine to open the Connect to Server window and click Options.

  3. Klicken Sie auf Zusätzliche Verbindungsparameter, und geben Sie Column Encryption Setting=enabled ein.Click Additional Connection Parameters and type Column Encryption Setting=enabled.

    Neue Konsolenanwendung

  4. Führen Sie die folgende Abfrage für die Clinic-Datenbank aus.Run the following query on the Clinic database.

       SELECT FirstName, LastName, SSN, BirthDate FROM Patients;
    

    Die Klartextdaten werden jetzt in den verschlüsselten Spalten angezeigt.You can now see the plaintext data in the encrypted columns. Neue KonsolenanwendungNew console application

Nächste SchritteNext steps

Nach dem Erstellen einer Datenbank, für die Always Encrypted verwendet wird, sollten Sie folgende Schritte ausführen:After you create a database that uses Always Encrypted, you may want to do the following: