Megosztás a következőn keresztül:

Az Always Encrypted használata az SQL Serverhez készült .NET-keretrendszer adatszolgáltatójával

A következőkre vonatkozik:SQL ServerAzure SQL DatabaseAzure SQL Managed Instance

Ez a cikk bemutatja, hogyan fejleszthet .NET-keretrendszeralkalmazásokat az Always Encrypted vagy Always Encrypted használatával biztonságos enklávékkal és az SQL Serverhez készült .NET-keretrendszer adatszolgáltatójával (System.Data.SqlClient).

Megjegyzés:

A .NET-keretrendszer adatszolgáltatójának használata az SQL Serverhez (System.Data.SqlClient) nem ajánlott az új fejlesztéshez. További információ: System.Data.SqlClient.

Az Always Encrypted lehetővé teszi az ügyfélalkalmazások számára a bizalmas adatok titkosítását, és soha nem fedik fel az ADATOKAT vagy a titkosítási kulcsokat az SQL Server vagy az Azure SQL Database számára. Az Always Encrypted-kompatibilis illesztőprogramok( például az SQL Server .NET-keretrendszer adatszolgáltatója) ezt úgy érik el, hogy transzparensen titkosítják és visszafejtik a bizalmas adatokat az ügyfélalkalmazásban. Az illesztő automatikusan meghatározza, hogy mely lekérdezési paraméterek felelnek meg a bizalmas adatbázisoszlopoknak (always encrypted használatával védve), és titkosítja ezeknek a paramétereknek az értékeit, mielőtt továbbítanák az adatokat az SQL Servernek vagy az Azure SQL Database-nek. Hasonlóképpen, az illesztőprogram transzparensen visszafejti a titkosított adatbázis oszlopaiból lekért adatokat a lekérdezési eredményekben. További információ: Alkalmazások fejlesztése Always Encrypted használatával és Alkalmazások fejlesztése Always Encrypted és biztonságos enklávék használatával.

Megjegyzés:

Az SQL Server .NET-keretrendszer adatszolgáltatója (System.Data.SqlClient) nem támogatja a VBS-enklávék igazolás nélküli használatát.

Előfeltételek

Megjegyzés:

Az Always Encrypted támogatottsága a .NET-keretrendszer bizonyos verzióiban eltérő. Az Always Encrypted API-hivatkozások a következő szakaszokban találhatók.

Az Always Encrypted engedélyezése alkalmazás-lekérdezésekhez

A paraméterek titkosításának és a titkosított oszlopokra irányuló lekérdezési eredmények visszafejtésének engedélyezésének legegyszerűbb módja az oszloptitkosítási beállítás kapcsolati sztringjének engedélyezése.

Az alábbiakban egy példa egy kapcsolati sztringre, amely engedélyezi az Always Encryptedt:

string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true; Column Encryption Setting=enabled";
SqlConnection connection = new SqlConnection(connectionString);

Az alábbi példában az SqlConnectionStringBuilder.ColumnEncryptionSetting tulajdonságot használjuk.

SqlConnectionStringBuilder strbldr = new SqlConnectionStringBuilder();
strbldr.DataSource = "server63";
strbldr.InitialCatalog = "Clinic";
strbldr.IntegratedSecurity = true;
strbldr.ColumnEncryptionSetting = SqlConnectionColumnEncryptionSetting.Enabled;
SqlConnection connection = new SqlConnection(strbldr.ConnectionString);

Az Always Encrypted egyéni lekérdezésekhez is engedélyezhető. Tekintse meg az Always Encrypted (Mindig titkosított) teljesítményre gyakorolt hatása szabályozása című szakaszt alább. Az Always Encrypted engedélyezése nem elegendő a titkosítás vagy a visszafejtés sikerességéhez. A következőket is ellenőriznie kell:

  • Az alkalmazás rendelkezik a VIEW ANY COLUMN MASTER KEY DEFINITION és VIEW ANY COLUMN ENCRYPTION KEY DEFINITION adatbázis engedélyekkel, amely az adatbázisban lévő Always Encrypted kulcsok metaadatainak eléréséhez szükséges. További részletekért lásd az Always Encrypted (Adatbázismotor) Engedélyek szakaszát.
  • Az alkalmazás hozzáférhet az oszloptitkosítási kulcsokat védő oszlop főkulcsához, titkosítva a lekérdezett adatbázisoszlopokat.

Az Always Encrypted engedélyezése biztonságos enklávékkal

A .NET-keretrendszer 4.7.2-es verziójától kezdve az illesztőprogram biztonságos enklávékkal támogatja az Always Encryptedt.

Az enklávészámítások és enklávéigazolások ügyfélillesztői szerepkörével kapcsolatos általános információkért lásd: Alkalmazások fejlesztése az Always Encrypted használatával biztonságos enklávékkal.

Az alkalmazás konfigurálása:

  1. Engedélyezze az Always Encryptedt az alkalmazás-lekérdezésekhez az előző szakaszban leírtak szerint.

  2. Integrálja a Microsoft.SqlServer.Management.AlwaysEncrypted.EnclaveProviders NuGet csomagot az alkalmazással. A NuGet az enklávészolgáltatók könyvtára, amely implementálja az igazolási protokollok ügyféloldali logikáját, és biztonságos csatornát hoz létre egy biztonságos enklávéval.

  3. Frissítse az alkalmazáskonfigurációt (például web.config vagy app.config) az adatbázishoz konfigurált enklávétípus és egy enklávészolgáltató közötti leképezés meghatározásához.

    1. Ha SQL Server és Host Guardian Service (HGS) szolgáltatást használ, a VBS-enklávé típusát le kell képezni a Microsoft.SqlServer.Management.AlwaysEncrypted.EnclaveProviders.HostGuardianServiceEnclaveProvider osztályra a NuGet-csomagból.
    2. Ha az Azure SQL Database-t és a Microsoft Azure Attestation szolgáltatást használja, össze kell kapcsolnia az SGX enklávé típusát a Microsoft.SqlServer.Management.AlwaysEncrypted.EnclaveProviders.AzureAttestationEnclaveProvider osztályra a NuGet csomagból.

    Az alkalmazáskonfiguráció szerkesztésére vonatkozó részletes útmutatásért tekintse meg az oktatóanyagot: .NET-keretrendszeralkalmazás fejlesztése az Always Encrypted használatával biztonságos enklávékkal.

  4. Állítsa be az adatbázis-kapcsolati Enclave Attestation URL sztringben szereplő paramétert egy igazolási szolgáltatás URL-címére (egy igazolási szolgáltatás végpontjához). Be kell szereznie a környezet igazolási URL-címét az igazolási szolgáltatás rendszergazdájától.

    1. Ha SQL Server-t és a Host Guardian Service-t (HGS) használ, lásd a HGS igazolási URL-címének meghatározása és megosztásacímet.
    2. Ha az Azure SQL Database-t és a Microsoft Azure Hitelesítést használja, tekintse meg hogyan határozza meg az igazolási szabályzatának igazolási URL-címét.

Részletes oktatóanyagért tekintse meg az oktatóanyagot: .NET-keretrendszeralkalmazás fejlesztése az Always Encrypted használatával biztonságos enklávékkal

Adatok beolvasása és módosítása titkosított oszlopokban

Miután engedélyezte az Always Encryptedt az alkalmazáslekérdezésekhez, használhat szabványos ADO.NET API-kat (lásd: Adatok lekérése és módosítása a ADO.NET-ben) vagy a System.Data.SqlClient névtérben definiált SQL Server API-k .NET-keretrendszer-adatszolgáltatója segítségével titkosított adatbázisoszlopokban lévő adatok lekéréséhez vagy módosításához. Feltéve, hogy az alkalmazás rendelkezik a szükséges adatbázis-engedélyekkel, és hozzáfér az oszlop főkulcsához, az SQL Server .NET-keretrendszer adatszolgáltatója titkosítja a titkosított oszlopokat megcélzó lekérdezési paramétereket, és visszafejti a titkosított oszlopokból lekért adatokat, és a .NET-típusok egyszerű szöveges értékeit adja vissza, amelyek megfelelnek az adatbázisséma oszlopaihoz beállított SQL Server-adattípusoknak. Ha az Always Encrypted nincs engedélyezve, a titkosított oszlopokat megcélzott paraméterekkel rendelkező lekérdezések sikertelenek lesznek. A lekérdezések továbbra is lekérhetik az adatokat a titkosított oszlopokból, amennyiben a lekérdezés nem tartalmaz titkosított oszlopokat célzó paramétereket. Az SQL Serverhez készült .NET-keretrendszer adatszolgáltatója azonban nem kísérli meg visszafejteni a titkosított oszlopokból lekért értékeket, és az alkalmazás binárisan titkosított adatokat (bájttömbökként) kap.

Az alábbi táblázat összefoglalja a lekérdezések viselkedését attól függően, hogy az Always Encrypted engedélyezve van-e, vagy sem:

Lekérdezési jellemző Az Always Encrypted engedélyezve van, és az alkalmazás hozzáférhet a kulcsokhoz és a kulcs metaadataihoz Az Always Encrypted engedélyezve van, és az alkalmazás nem tudja elérni a kulcsokat vagy a kulcs metaadatait Az "Always Encrypted" funkció le van tiltva.
Titkosított oszlopokat célzó paraméterekkel rendelkező lekérdezések. A paraméterértékek transzparensen titkosítva vannak. Error Error
Titkosított oszlopokból adatokat lekérdező lekérdezések, a titkosított oszlopokat megcélzó paraméterek nélkül. A titkosított oszlopok eredményei transzparensen visszafejthetők. Az alkalmazás megkapja a titkosított oszlopokhoz konfigurált SQL Server-típusoknak megfelelő .NET-adattípusok egyszerű szöveges értékeit. Error A titkosított oszlopok eredményei nem lesznek visszafejtve. Az alkalmazás bájttömbökként (bájt[]) fogadja a titkosított értékeket.

Az alábbi példák az adatok titkosított oszlopokban való beolvasását és módosítását szemléltetik. A példák a céltáblát feltételezik az alábbi sémával. Az SSN- és BirthDate-oszlopok titkosítva vannak.

CREATE TABLE [dbo].[Patients]([PatientId] [int] IDENTITY(1,1), 
 [SSN] [char](11) COLLATE Latin1_General_BIN2 
 ENCRYPTED WITH (ENCRYPTION_TYPE = DETERMINISTIC, 
 ALGORITHM = 'AEAD_AES_256_CBC_HMAC_SHA_256', 
 COLUMN_ENCRYPTION_KEY = CEK1) NOT NULL,
 [FirstName] [nvarchar](50) NULL,
 [LastName] [nvarchar](50) NULL, 
 [BirthDate] [date] 
 ENCRYPTED WITH (ENCRYPTION_TYPE = RANDOMIZED, 
 ALGORITHM = 'AEAD_AES_256_CBC_HMAC_SHA_256', 
 COLUMN_ENCRYPTION_KEY = CEK1) NOT NULL
 PRIMARY KEY CLUSTERED ([PatientId] ASC) ON [PRIMARY])
 GO

Adatbeszúrási példa

Ez a példa beszúr egy sort a Betegek táblába. Vegye figyelembe a következőket:

  • A mintakód nem tartalmaz titkosítást. Az SQL Server .NET-keretrendszer adatszolgáltatója automatikusan észleli és titkosítja a titkosított oszlopokat célzó paramSSN és paramBirthdate paramétereket. Ez transzparenssé teszi a titkosítást az alkalmazás számára.
  • Az adatbázisoszlopokba beszúrt értékek, beleértve a titkosított oszlopokat, SqlParameter-objektumokként lesznek átadva. Az SqlParameter használata nem kötelező, ha nem titkosított oszlopokba küld értékeket (bár erősen ajánlott, mert segít megelőzni az SQL-injektálást), a titkosított oszlopokat megcélzó értékekhez szükséges. Ha az SSN- vagy BirthDate-oszlopokba beszúrt értékeket a lekérdezési utasításba beágyazott literálként adná át, a lekérdezés meghiúsulna, mert az SQL Server .NET-keretrendszer adatszolgáltatója nem tudná meghatározni a célként megadott titkosított oszlopok értékeit, így nem titkosítaná az értékeket. Ennek eredményeképpen a kiszolgáló elutasítja őket, mivel nem kompatibilisek a titkosított oszlopokkal.
  • Az SSN-oszlopot megcélzó paraméter adattípusa ANSI (nem Unicode) sztringre van állítva, amely a char/varchar SQL Server-adattípusra van leképezve. Ha a paraméter típusa Unicode karaktersorozatra (String) lett állítva, amely leképeződik az nchar/nvarchar típusra, a lekérdezés sikertelen lesz, mivel az Always Encrypted nem támogatja a titkosított nchar/nvarchar értékek titkosított char/varchar értékekké való átalakítását. Az adattípus-leképezésekkel kapcsolatos információkért tekintse meg az SQL Server adattípus-leképezéseit.
  • A BirthDate oszlopba beszúrt paraméter adattípusa explicit módon a cél SQL Server-adattípusra van beállítva az SqlParameter.SqlDbType tulajdonság használatával, ahelyett, hogy az SqlParameter.DbType tulajdonság használatakor alkalmazott .NET-típusok implicit leképezésére támaszkodik az SQL Server-adattípusokra. A DateTime Structure alapértelmezés szerint a datetime SQL Server adattípusra van leképezve. Mivel a BirthDate oszlop adattípusa dátum, és az Always Encrypted nem támogatja a titkosított dátum/idő értékek titkosított dátumértékekké való konvertálását, az alapértelmezett leképezés használata hibát eredményez.
string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true; Column Encryption Setting=enabled";
using (SqlConnection connection = new SqlConnection(strbldr.ConnectionString))
{
   using (SqlCommand cmd = connection.CreateCommand())
   {
      cmd.CommandText = @"INSERT INTO [dbo].[Patients] ([SSN], [FirstName], [LastName], [BirthDate]) VALUES (@SSN, @FirstName, @LastName, @BirthDate);";

      SqlParameter paramSSN = cmd.CreateParameter();
      paramSSN.ParameterName = @"@SSN";
      paramSSN.DbType = DbType.AnsiStringFixedLength;
      paramSSN.Direction = ParameterDirection.Input;
      paramSSN.Value = "795-73-9838";
      paramSSN.Size = 11;
      cmd.Parameters.Add(paramSSN);

      SqlParameter paramFirstName = cmd.CreateParameter();
      paramFirstName.ParameterName = @"@FirstName";
      paramFirstName.DbType = DbType.String;
      paramFirstName.Direction = ParameterDirection.Input;
      paramFirstName.Value = "Catherine";
      paramFirstName.Size = 50;
      cmd.Parameters.Add(paramFirstName);

      SqlParameter paramLastName = cmd.CreateParameter();
      paramLastName.ParameterName = @"@LastName";
      paramLastName.DbType = DbType.String;
      paramLastName.Direction = ParameterDirection.Input;
      paramLastName.Value = "Abel";
      paramLastName.Size = 50;
      cmd.Parameters.Add(paramLastName);

      SqlParameter paramBirthdate = cmd.CreateParameter();
      paramBirthdate.ParameterName = @"@BirthDate";
      paramBirthdate.SqlDbType = SqlDbType.Date;
      paramBirthdate.Direction = ParameterDirection.Input;
      paramBirthdate.Value = new DateTime(1996, 09, 10);
      cmd.Parameters.Add(paramBirthdate);

      cmd.ExecuteNonQuery();
   } 
}

Egyszerű szöveges adatok beolvasása – példa

Az alábbi példa bemutatja az adatok titkosított értékeken alapuló szűrését és egyszerű szöveges adatok titkosított oszlopokból való lekérését. Vegye figyelembe a következőket:

  • Az SSN-oszlopra való szűréshez használt WHERE záradékban használt értéket az SqlParameter használatával kell átadni, hogy az SQL Server .NET-keretrendszer adatszolgáltatója transzparensen titkosíthassa, mielőtt elküldené az adatbázisba.
  • A program által kinyomtatott összes érték egyszerű szöveges lesz, mivel az SQL Server .NET-keretrendszer adatszolgáltatója transzparensen visszafejti az SSN és a BirthDate oszlopokból lekért adatokat.

Megjegyzés:

A lekérdezések akkor végezhetnek egyenlőség-összehasonlítást az oszlopokon, ha determinisztikus titkosítással vannak titkosítva. További információ: Determinisztikus vagy véletlenszerű titkosítás kiválasztása.

string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true; Column Encryption Setting=enabled";
    
using (SqlConnection connection = new SqlConnection(strbldr.ConnectionString))
 {
    using (SqlCommand cmd = connection.CreateCommand())
 {

 cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE SSN=@SSN";
 SqlParameter paramSSN = cmd.CreateParameter();
 paramSSN.ParameterName = @"@SSN";
 paramSSN.DbType = DbType.AnsiStringFixedLength;
 paramSSN.Direction = ParameterDirection.Input;
 paramSSN.Value = "795-73-9838";
 paramSSN.Size = 11;
 cmd.Parameters.Add(paramSSN);
 using (SqlDataReader reader = cmd.ExecuteReader())
 {
   if (reader.HasRows)
 {
 while (reader.Read())
 {
    Console.WriteLine(@"{0}, {1}, {2}, {3}", reader[0], reader[1], reader[2], ((DateTime)reader[3]).ToShortDateString());
 }

Példa titkosított adatok beolvasására

Ha az Always Encrypted nincs engedélyezve, a lekérdezések továbbra is lekérhetik az adatokat titkosított oszlopokból, feltéve, hogy a lekérdezés nem tartalmaz titkosított oszlopokat célzó paramétereket.

Az alábbi példa bemutatja, hogyan lehet bináris titkosított adatokat lekérni a titkosított oszlopokból. Vegye figyelembe a következőket:

  • Mivel az Always Encrypted nincs engedélyezve a kapcsolati sztringben, a lekérdezés az SSN és a BirthDate titkosított értékeit adja vissza bájttömbökként (a program sztringekké alakítja az értékeket).
  • Az Always Encrypted letiltott titkosított oszlopaiból adatokat lekérő lekérdezésnek lehetnek paraméterei, feltéve, hogy egyik paraméter sem céloz meg titkosított oszlopot. A fenti lekérdezés a LastName szerint szűr, amely nincs titkosítva az adatbázisban. Ha a lekérdezésT SSN vagy BirthDate szűri, a lekérdezés sikertelen lesz.
string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true";
                
using (SqlConnection connection = new SqlConnection(connectionString))
{
   connection.Open();
   using (SqlCommand cmd = connection.CreateCommand())
   {
      cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE [LastName]=@LastName";
      SqlParameter paramLastName = cmd.CreateParameter();
      paramLastName.ParameterName = @"@LastName";
      paramLastName.DbType = DbType.String;
      paramLastName.Direction = ParameterDirection.Input;
      paramLastName.Value = "Abel";
      paramLastName.Size = 50;
      cmd.Parameters.Add(paramLastName);
      using (SqlDataReader reader = cmd.ExecuteReader())
      {
         if (reader.HasRows)
         {
            while (reader.Read())
         {
         Console.WriteLine(@"{0}, {1}, {2}, {3}", BitConverter.ToString((byte[])reader[0]), reader[1], reader[2], BitConverter.ToString((byte[])reader[3]));
      }
   }
}

A titkosított oszlopok lekérdezésével kapcsolatos gyakori problémák elkerülése

Ez a szakasz a .NET-alkalmazásokból származó titkosított oszlopok lekérdezésekor előforduló gyakori hibakategóriákat ismerteti, valamint néhány útmutatást az elkerülésükhöz.

Nem támogatott adattípus-konverziós hibák

Az Always Encrypted kevés konverziót támogat a titkosított adattípusokhoz. A támogatott típuskonverziók részletes listáját az Always Encryptedben találja. Az adattípusok konvertálási hibáinak elkerülése érdekében tegye a következőket:

  • Állítsa be a titkosított oszlopokat célzó paraméterek típusait, így a paraméter SQL Server-adattípusa pontosan megegyezik a céloszlop típusával, vagy a paraméter SQL Server-adattípusának konvertálása az oszlop céltípusára támogatott. Az SqlParameter.SqlDbType tulajdonság használatával kényszerítheti a .NET-adattípusok kívánt leképezését adott SQL Server-adattípusokra.
  • Ellenőrizze, hogy a decimális és numerikus SQL Server-adattípusok oszlopait megcélzó paraméterek pontossága és mérete megegyezik-e a céloszlophoz konfigurált pontossági és méretezési értékekkel.
  • Ellenőrizze, hogy a datetime2, datetimeoffset vagy time SQL Server-adattípusok oszlopait megcélzó paraméterek pontossága nem nagyobb-e a céloszlop pontosságánál (a céloszlop értékeit módosító lekérdezésekben).

A titkosított értékek helyett egyszerű szöveg átadása miatti hibák

Minden olyan értéket, amely egy titkosított oszlopot céloz meg, titkosítva kell lennie az alkalmazásban. Ha egy titkosított oszlop egyszerű szöveges értéke alapján próbál meg beszúrni/módosítani vagy szűrni, az a következőhöz hasonló hibát fog eredményezni:

System.Data.SqlClient.SqlException (0x80131904): Operand type clash: varchar is incompatible with varchar(8000) encrypted with (encryption_type = 'DETERMINISTIC', encryption_algorithm_name = 'AEAD_AES_256_CBC_HMAC_SHA_256', column_encryption_key_name = 'CEK_Auto1', column_encryption_key_database_name = 'Clinic') collation_name = 'SQL_Latin1_General_CP1_CI_AS'

Az ilyen hibák megelőzése érdekében győződjön meg arról, hogy:

  • Az Always Encrypted engedélyezve van a titkosított oszlopokat célzó alkalmazás-lekérdezésekhez (a kapcsolati sztringhez vagy egy adott lekérdezés SqlCommand objektumához).
  • Az SqlParameter használatával titkosított oszlopokat célzó adatokat küldhet. Az alábbi példa egy olyan lekérdezést mutat be, amely helytelenül szűr egy konstans/állandó alapján egy titkosított oszlopon (SSN)(ahelyett, hogy a literálist egy SqlParameter-objektumon belül adja át).
using (SqlCommand cmd = connection.CreateCommand())
{
   cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE SSN='795-73-9838'";
cmd.ExecuteNonQuery();
}

Az oszlop főkulcstárolóinak használata

Egy paraméterérték titkosításához vagy az adatok lekérdezési eredményekben való visszafejtéséhez az SQL Server .NET-keretrendszer adatszolgáltatójának be kell szereznie egy, a céloszlophoz konfigurált oszloptitkosítási kulcsot. Az oszloptitkosítási kulcsok titkosított formában vannak tárolva az adatbázis metaadataiban. Minden oszloptitkosítási kulcshoz tartozik egy oszlopmester kulcs, amelyet az oszloptitkosítási kulcs titkosításához használtak. Az adatbázis metaadatai nem tárolják az oszlop főkulcsait, és csak egy adott oszlop főkulcsát és a kulcs helyét tartalmazó kulcstároló adatait tartalmazzák.

Egy oszloptitkosítási kulcs egyszerű szöveges értékének lekéréséhez az SQL Server .NET-keretrendszer adatszolgáltatója először az oszloptitkosítási kulcsra és annak megfelelő oszlop-főkulcsára vonatkozó metaadatokat szerzi be, majd a metaadatokban szereplő információkat felhasználva kapcsolatba lép a kulcstárolóval, amely tartalmazza az oszlop főkulcsát, és visszafejti a titkosított oszloptitkosítási kulcsot. Az SQL Server-hez készült .NET-keretrendszer adatszolgáltatója egy oszlop főkulcstár-szolgáltatón keresztül kommunikál egy kulcstárolóval, amely az SqlColumnEncryptionKeyStoreProvider osztályból származtatott osztály egy példánya.

Az oszloptitkosítási kulcs beszerzésének folyamata:

  1. Ha az Always Encrypted engedélyezve van egy lekérdezéshez, az SQL Server .NET-keretrendszer adatszolgáltatója transzparensen meghívja sys.sp_describe_parameter_encryption , hogy kérje le a titkosított oszlopokat megcélzó paraméterek titkosítási metaadatait, ha a lekérdezés rendelkezik paraméterekkel. A lekérdezés eredményeiben szereplő titkosított adatok esetében az SQL Server automatikusan csatolja a titkosítási metaadatokat. Az oszlop főkulcsával kapcsolatos információk a következők:

    • A kulcstároló-szolgáltató neve, amely egy kulcstárolót foglal magában, ami az oszlop főkulcsát tartalmazza.
    • A kulcs elérési útja, amely meghatározza az oszlop főkulcsának helyét a kulcstárolóban.

    Az oszloptitkosítási kulcsra vonatkozó információk a következők:

    • Az oszloptitkosítási kulcs titkosított értéke.
    • Az oszloptitkosítási kulcs titkosításához használt algoritmus neve.

  2. Az SQL Serverhez készült .NET-keretrendszer adatszolgáltatója az oszlop főkulcstároló-szolgáltatójának nevével keresi meg a szolgáltató objektumot (az SqlColumnEncryptionKeyStoreProvider osztályból származó osztály egy példányát) egy belső adatstruktúrában.

  3. Az oszloptitkosítási kulcs visszafejtéséhez az SQL Server .NET-keretrendszer adatszolgáltatója meghívja az SqlColumnEncryptionKeyStoreProvider.DecryptColumnEncryptionKey metódust, átadva az oszlop főkulcsának elérési útját, az oszloptitkosítási kulcs titkosított értékét és a titkosított oszloptitkosítási kulcs előállításához használt titkosítási algoritmus nevét.

Beépített oszlop főkulcstároló-szolgáltatók használata

Az SQL Serverhez készült .NET-keretrendszer adatszolgáltatója a következő beépített oszlop főkulcstár-szolgáltatókkal rendelkezik, amelyek előre vannak regisztrálva a megadott szolgáltatónevekkel (a szolgáltató keresésére szolgálnak).

Class Description Szolgáltató (keresési) neve
SqlColumnEncryptionCertificateStoreProvider osztály A Windows Tanúsítványtároló szolgáltatója. MSSQL_CERTIFICATE_STORE
SqlColumnEncryptionCngProvider osztály

Megjegyzés: ez a szolgáltató a .NET-keretrendszer 4.6.1-s és újabb verzióiban érhető el.		 A Microsoft Cryptography API: Next Generation (CNG) API-t támogató kulcstár szolgáltatója. Az ilyen típusú tárolók általában hardveres biztonsági modulok – olyan fizikai eszközök, amelyek védik és kezelik a digitális kulcsokat, és kriptográfiai feldolgozást biztosítanak. MSSQL_CNG_STORE
SqlColumnEncryptionCspProvider osztály

Megjegyzés: ez a szolgáltató a .NET-keretrendszer 4.6.1-s vagy újabb verzióiban érhető el.		 A Microsoft Cryptography API (CAPI) használatát támogató kulcstár szolgáltatója. Az ilyen típusú tárolók általában hardveres biztonsági modulok – olyan fizikai eszközök, amelyek védik és kezelik a digitális kulcsokat, és kriptográfiai feldolgozást biztosítanak. MSSQL_CSP_PROVIDER

A szolgáltatók használatához nem kell módosítania az alkalmazáskódokat, de vegye figyelembe a következőket:

  • Önnek (vagy a DBA-nak) meg kell győződnie arról, hogy az oszlop főkulcs metaadataiban konfigurált szolgáltatónév helyes, és az oszlop főkulcsának elérési útja megfelel az adott szolgáltatóra érvényes kulcsútvonal-formátumnak. Javasoljuk, hogy a kulcsokat olyan eszközökkel konfigurálja, mint az SQL Server Management Studio, amely automatikusan létrehozza az érvényes szolgáltatóneveket és kulcsútvonalakat a CREATE COLUMN MASTER KEY (Transact-SQL) utasítás kiadásakor. További információ: Always Encrypted konfigurálása az SQL Server Management Studióval és az Always Encrypted konfigurálása a PowerShell használatával.
  • Győződjön meg arról, hogy az alkalmazás hozzáfér a kulcstároló kulcsához. Ez magában foglalhatja az alkalmazás hozzáférésének biztosítását a kulcstártól függően a kulcstárhoz és/vagy a kulcstárolóhoz, vagy más kulcstároló-specifikus konfigurációs lépések végrehajtásával. Ha például egy CNG-t vagy CAPI-t implementáló kulcstárhoz (például hardveres biztonsági modulhoz) szeretne hozzáférni, győződjön meg arról, hogy a kulcstárához tartozó CNG- vagy CAPI-implementációt megvalósító könyvtár telepítve van az alkalmazására használt gépen. További információ: Az Always Encrypted oszlop főkulcsainak létrehozása és tárolása.

Az Azure Key Vault-szolgáltató használata

Az Azure Key Vault egy kényelmes lehetőség az Always Encrypted oszlop-főkulcsainak tárolására és kezelésére (különösen akkor, ha az alkalmazások az Azure-ban vannak üzemeltetve). Az SQL Serverhez készült .NET-keretrendszer adatszolgáltatója nem tartalmaz beépített oszlop-főkulcstár-szolgáltatót az Azure Key Vaulthoz, de NuGet-csomagként érhető el, amelyet egyszerűen integrálhat az alkalmazással. Részletekért lásd:

Egyéni oszlop főkulcstároló-szolgáltató implementálása

Ha olyan kulcstárolóban szeretné tárolni az oszlop főkulcsait, amelyet egy meglévő szolgáltató nem támogat, egyéni szolgáltatót az SqlColumnEncryptionCngProvider osztály kibővítésével és a szolgáltató sqlConnection.RegisterColumnEncryptionKeyStoreProviders metódussal történő regisztrálásával valósíthat meg.

public class MyCustomKeyStoreProvider : SqlColumnEncryptionKeyStoreProvider
    {
        public override byte[] EncryptColumnEncryptionKey(string masterKeyPath, string encryptionAlgorithm, byte[] columnEncryptionKey)
        {
            // Logic for encrypting a column encrypted key.
        }
        public override byte[] DecryptColumnEncryptionKey(string masterKeyPath, string encryptionAlgorithm, byte[] EncryptedColumnEncryptionKey)
        {
            // Logic for decrypting a column encrypted key.
        }
    }  
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary\<string, SqlColumnEncryptionKeyStoreProvider> providers =
               new Dictionary\<string, SqlColumnEncryptionKeyStoreProvider>();
            providers.Add("MY_CUSTOM_STORE", customProvider);
            SqlConnection.RegisterColumnEncryptionKeyStoreProviders(providers);
            providers.Add(SqlColumnEncryptionCertificateStoreProvider.ProviderName, customProvider);
            SqlConnection.RegisterColumnEncryptionKeyStoreProviders(providers); 
       // ...
        }

    }

Oszlop főkulcstároló-szolgáltatóinak használata programozott kulcsok kiépítéséhez

Titkosított oszlopok elérésekor az SQL Server .NET-keretrendszer adatszolgáltatója transzparens módon megkeresi és meghívja a megfelelő oszlop főkulcstároló-szolgáltatót az oszloptitkosítási kulcsok visszafejtéséhez. A normál alkalmazáskód általában nem hívja meg közvetlenül az oszlop főkulcstároló-szolgáltatóját. Azonban létrehozhat és meghívhat egy szolgáltatót kifejezetten az Always Encrypted kulcsok programozott kiépítésére és kezelésére: titkosított oszloptitkosítási kulcs létrehozásához és egy oszloptitkosítási kulcs visszafejtéséhez (például az oszlop főkulcsának rotálásához). További információ: Az Always Encrypted kulcskezelésének áttekintése. A saját kulcskezelési eszközök implementálása csak egyéni kulcstároló-szolgáltató használata esetén lehet szükséges. Ha kulcstárolókban tárolt kulcsokat használ, amelyekhez beépített szolgáltatók léteznek, vagy az Azure Key Vaultban, a meglévő eszközök, például az SQL Server Management Studio vagy a PowerShell használatával kezelheti és kiépítheti a kulcsokat. Az alábbi példa egy oszloptitkosítási kulcs generálását mutatja be, és az SqlColumnEncryptionCertificateStoreProvider osztály használatával titkosítja a kulcsot egy tanúsítvánnyal.

using System.Security.Cryptography;
static void Main(string[] args)
{
    byte[] EncryptedColumnEncryptionKey = GetEncryptedColumnEncryptionKey(); 
    Console.WriteLine("0x" + BitConverter.ToString(EncryptedColumnEncryptionKey).Replace("-", "")); 
    Console.ReadKey();
}

static byte[]  GetEncryptedColumnEncryptionKey()
{
    int cekLength = 32;
    String certificateStoreLocation = "CurrentUser";
    String certificateThumbprint = "698C7F8E21B2158E9AED4978ADB147CF66574180";
    // Generate the plaintext column encryption key.
    byte[] columnEncryptionKey = new byte[cekLength];
    RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider();
    rngCsp.GetBytes(columnEncryptionKey);

    // Encrypt the column encryption key with a certificate.
    string keyPath = String.Format(@"{0}/My/{1}", certificateStoreLocation, certificateThumbprint);
    SqlColumnEncryptionCertificateStoreProvider provider = new SqlColumnEncryptionCertificateStoreProvider();
    return provider.EncryptColumnEncryptionKey(keyPath, @"RSA_OAEP", columnEncryptionKey); 
}

Az Always Encrypted teljesítményhatásának szabályozása

Mivel az Always Encrypted egy ügyféloldali titkosítási technológia, a teljesítményterhelések nagy része az ügyféloldalon figyelhető meg, nem az adatbázisban. A titkosítási és visszafejtési műveletek költségein kívül az ügyféloldal egyéb teljesítményterhelési forrásai a következők:

  • A lekérdezési paraméterek metaadatainak lekéréséhez további oda-vissza utak az adatbázisba.
  • Egy oszlop főkulcstárának hívása az oszlop főkulcsának eléréséhez.

Ez a szakasz az SQL Serverhez készült .NET-keretrendszer-szolgáltató beépített teljesítményoptimalizálásait ismerteti, valamint azt, hogy hogyan szabályozható a fenti két tényező hatása a teljesítményre.

A kérés körforgásainak szabályozása a lekérdezési paraméterek metaadatainak lekéréséhez

Ha az Always Encrypted engedélyezve van egy kapcsolathoz, az SQL Server .NET-keretrendszer adatszolgáltatója alapértelmezés szerint meghívja sys.sp_describe_parameter_encryption minden paraméteres lekérdezéshez, és átadja a lekérdezési utasítást (paraméterértékek nélkül) az SQL Servernek. sys.sp_describe_parameter_encryption elemzi a lekérdezési utasítást, hogy megtudja, van-e szükség paraméterek titkosítására, és ha igen, mindegyiknél visszaadja a titkosítással kapcsolatos információkat, amelyek lehetővé teszik az SQL Server .NET-keretrendszer adatszolgáltatójának a paraméterértékek titkosítását. A fenti viselkedés magas szintű átláthatóságot biztosít az ügyfélalkalmazás számára. Az alkalmazásnak (és az alkalmazásfejlesztőnek) nem kell tudnia, hogy mely lekérdezések férnek hozzá a titkosított oszlopokhoz, amíg a titkosított oszlopokat megcélzó értékek az SqlParameter-objektumokban lévő SQL Server.NET-keretrendszer adatszolgáltatójának lesznek átadva.

Metaadat gyorsítótár lekérdezése

A .NET-keretrendszer 4.6.2-s és újabb verzióiban az SQL Server .NET-keretrendszer adatszolgáltatója gyorsítótárazza az egyes lekérdezési utasításokhoz tartozó sys.sp_describe_parameter_encryption eredményeit. Ha tehát ugyanazt a lekérdezési utasítást többször hajtja végre, az illesztőprogram csak egyszer hívja sys.sp_describe_parameter_encryption . A lekérdezési utasítások titkosítási metaadatainak gyorsítótárazása jelentősen csökkenti a metaadatok adatbázisból való lekérésének teljesítményköltségét. A gyorsítótárazás alapértelmezés szerint engedélyezve van. A paraméterek metaadatainak gyorsítótárazását letilthatja az SqlConnection.ColumnEncryptionQueryMetadataCacheEnabled tulajdonság false értékre állításával, de ez nem ajánlott, kivéve a leírtakhoz hasonló ritka esetekben:

Vegyünk egy adatbázist, amely két különböző sémával rendelkezik: s1 és s2. Minden séma tartalmaz egy táblát ugyanazzal a névvel: t. A s1.t és s2.t táblák definíciói megegyeznek, kivéve a titkosítással kapcsolatos tulajdonságokat: A c táblában a s1.t oszlop nincs titkosítva, míg a s2.t titkosítva van. Az adatbázisnak két felhasználója van: u1 és u2. A u1 felhasználók alapértelmezett sémája a s1. Az alapértelmezett séma a u2 esetében a s2. A .NET-alkalmazások két kapcsolatot nyitnak meg az adatbázissal, megszemélyesítve a u1 felhasználót egy kapcsolaton, a u2 felhasználót pedig egy másik kapcsolaton. Az alkalmazás lekérdezést küld egy olyan paraméterrel, amely a c oszlopot célozza meg a u1 felhasználó kapcsolatán keresztül (mivel a lekérdezés nem adja meg a sémát, a rendszer az alapértelmezett felhasználói sémát feltételezi). Ezután az alkalmazás ugyanazt a lekérdezést küldi a felhasználó kapcsolatán u2 keresztül. Ha a lekérdezés metaadatainak gyorsítótárazása engedélyezve van, az első lekérdezés után a gyorsítótár az oszlopot jelző c metaadatokkal lesz feltöltve, a lekérdezési paraméter céljai nem lesznek titkosítva. Mivel a második lekérdezés azonos lekérdezési utasítással rendelkezik, a rendszer a gyorsítótárban tárolt információkat fogja használni. Ennek eredményeképpen az illesztőprogram a paraméter titkosítása nélkül küldi el a lekérdezést (ami helytelen, mivel a céloszlop s2.t.c titkosítva van), így a paraméter egyszerű szöveges értéke kiszivárog a kiszolgálóra. A kiszolgáló észleli ezt az inkompatibilitást, és arra kényszeríti az illesztőprogramot, hogy frissítse a gyorsítótárat, így az alkalmazás transzparensen újraküldi a lekérdezést a helyesen titkosított paraméterértékkel. Ilyen esetben le kell tiltani a gyorsítótárazást, hogy ne szivárogjanak ki bizalmas értékek a kiszolgálóra.

Always Encrypted beállítása a lekérdezés szintjén

A paraméteres lekérdezések titkosítási metaadatainak lekérése teljesítményhatásának szabályozásához engedélyezheti az Always Encryptedt az egyes lekérdezésekhez a kapcsolat beállítása helyett. Így biztosítható, hogy sys.sp_describe_parameter_encryption csak olyan lekérdezések esetén legyen meghívva, amelyekről tudja, hogy a paraméterek titkosított oszlopokat céloznak. Vegye figyelembe azonban, hogy ezzel csökkenti a titkosítás átláthatóságát: ha módosítja az adatbázisoszlopok titkosítási tulajdonságait, előfordulhat, hogy módosítania kell az alkalmazás kódját, hogy igazodjon a séma változásaihoz.

Megjegyzés:

Az Always Encrypted lekérdezési szinten történő beállítása korlátozott teljesítménybeli előnyökkel jár a .NET 4.6.2-es és újabb verzióiban, amelyek paramétertitkosítási metaadatok gyorsítótárazását implementálják.

Az egyes lekérdezések Always Encrypted viselkedésének szabályozásához az SqlCommand és az SqlCommandColumnEncryptionSetting konstruktorát kell használnia. Íme néhány hasznos irányelv:

  • Ha az ügyfélalkalmazás a legtöbb lekérdezést egy adatbáziskapcsolaton keresztül, titkosított oszlopok elérésére küldi:
    • Állítsa az Oszloptitkosítás beállítása kapcsolatisztring-kulcsszót az Engedélyezett értékre.
    • Állítsa be az SqlCommandColumnEncryptionSetting.Disabled értéket olyan egyes lekérdezésekhez, amelyek nem férnek hozzá titkosított oszlopokhoz. Ez letiltja a sys.sp_describe_parameter_encryption hívását, valamint az eredményhalmaz értékeinek visszafejtésére tett kísérletet.
    • Az SqlCommandColumnEncryptionSetting.ResultSet beállítása olyan egyedi lekérdezésekhez, amelyek nem rendelkeznek titkosítást igénylő paraméterekkel, de titkosított oszlopokból kérnek le adatokat. Ez letiltja sys.sp_describe_parameter_encryption hívását és a paramétertitkosítást. A lekérdezés képes lesz visszafejteni az eredményeket a titkosítási oszlopokból.
  • Ha az ügyfélalkalmazás által adatbázis-kapcsolaton keresztül küldött legtöbb lekérdezés nem fér hozzá a titkosított oszlopokhoz:
    • Állítsa az Oszloptitkosítás beállítása kapcsolati sztringkulcsot Letiltva értékre.
    • Állítsa be az SqlCommandColumnEncryptionSetting.Enabled parancsot olyan egyedi lekérdezésekhez, amelyek minden olyan paramétert használnak, amelyet titkosítani kell. Ez lehetővé teszi sys.sp_describe_parameter_encryption hívását, valamint a titkosított oszlopokból lekért lekérdezési eredmények visszafejtést.
    • Az SqlCommandColumnEncryptionSetting.ResultSet beállítása olyan lekérdezésekhez, amelyek nem rendelkeznek titkosítást igénylő paraméterekkel, de titkosított oszlopokból kérnek le adatokat. Ez letiltja sys.sp_describe_parameter_encryption hívását és a paramétertitkosítást. A lekérdezés képes lesz visszafejteni az eredményeket a titkosítási oszlopokból.

Az alábbi példában az Always Encrypted le van tiltva az adatbázis-kapcsolat esetében. Az alkalmazás által kiadott lekérdezés olyan paraméterrel rendelkezik, amely a nem titkosított LastName oszlopot célozza meg. A lekérdezés adatokat kér le a titkosított SSN és BirthDate oszlopokból. Ilyen esetben nem szükséges meghívni sys.sp_describe_parameter_encryption a titkosítási metaadatok lekéréséhez. Azonban engedélyezni kell a lekérdezési eredmények visszafejtésének engedélyezését, hogy az alkalmazás egyszerű szöveges értékeket fogadhasson a két titkosított oszlopból. Ezt az SqlCommandColumnEncryptionSetting.ResultSet beállítással biztosíthatja.

string connectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    using (SqlCommand cmd = new SqlCommand(@"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE [LastName]=@LastName",
connection, null, SqlCommandColumnEncryptionSetting.ResultSetOnly))
    {
        SqlParameter paramLastName = cmd.CreateParameter();
        paramLastName.ParameterName = @"@LastName";
        paramLastName.DbType = DbType.String;
        paramLastName.Direction = ParameterDirection.Input;
        paramLastName.Value = "Abel";
        paramLastName.Size = 50;
        cmd.Parameters.Add(paramLastName);
        using (SqlDataReader reader = cmd.ExecuteReader())
            {
               if (reader.HasRows)
               {
                  while (reader.Read())
                  {
                     Console.WriteLine(@"{0}, {1}, {2}, {3}", reader[0], reader[1], reader[2], ((DateTime)reader[3]).ToShortDateString());
                  }
               }
            }
  } 
}

Oszloptitkosítási kulcs gyorsítótárazása

Az oszloptitkosítási kulcsok visszafejtéséhez az oszlop főkulcstárolójába irányuló hívások számának csökkentése érdekében az SQL Server .NET-keretrendszer adatszolgáltatója gyorsítótárazza a memória egyszerű szöveges oszloptitkosítási kulcsait. Miután megkapta a titkosított oszloptitkosítási kulcs értékét az adatbázis metaadataitól, az illesztőprogram először megpróbálja megtalálni a titkosított kulcs értékének megfelelő egyszerű szöveges oszloptitkosítási kulcsot. Az illesztőprogram csak akkor hívja meg az oszlop főkulcsát tartalmazó kulcstárolót, ha nem találja a titkosított oszloptitkosítási kulcs értékét a gyorsítótárban.

Megjegyzés:

A .NET-keretrendszer 4.6-os és 4.6.1-ben a gyorsítótár oszloptitkosítási kulcsbejegyzései soha nem törlődnek. Ez azt jelenti, hogy egy adott titkosított oszloptitkosítási kulcs esetében az illesztőprogram csak egyszer lép kapcsolatba a kulcstárolóval az alkalmazás élettartama alatt.

A .NET-keretrendszer 4.6.2-s és újabb verzióiban a rendszer biztonsági okokból kizárja a gyorsítótár-bejegyzéseket egy konfigurálható élettartam-intervallum után. Az alapértelmezett élettartam 2 óra. Ha szigorúbb biztonsági követelmények vonatkoznak arra, hogy mennyi ideig gyorsítótárazhatók az oszloptitkosítási kulcsok egyszerű szövegben az alkalmazásban, az SqlConnection.ColumnEncryptionKeyCacheTtl tulajdonság használatával módosíthatja.

További védelem engedélyezése sérült SQL Server esetén

Alapértelmezés szerint az .NET-keretrendszer SQL Server adatszolgáltatója az adatbázisrendszertől (SQL Server vagy Azure SQL Database) függ, hogy metaadatokat szolgáltasson arról, mely oszlopok vannak titkosítva az adatbázisban, és hogyan. A titkosítási metaadatok lehetővé teszik, hogy az SQL Server .NET-keretrendszer adatszolgáltatója titkosítsa a lekérdezési paramétereket és visszafejtse a lekérdezési eredményeket az alkalmazás bemenete nélkül, ami jelentősen csökkenti az alkalmazásban szükséges módosítások számát. Ha azonban az SQL Server-folyamat veszélybe kerül, és egy támadó módosítja az SQL Server sql server-alapú .NET-keretrendszer adatszolgáltatójának küldött metaadatokat, a támadó képes lehet bizalmas információkat ellopni. Ez a szakasz azokat az API-kat ismerteti, amelyek további szintű védelmet nyújtanak az ilyen típusú támadások ellen a csökkentett átláthatóság árán.

Paramétertitkosítás kényszerítése

Mielőtt az SQL Serverhez készült .NET-keretrendszer adatszolgáltatója paraméteres lekérdezést küld az SQL Servernek, megkéri az SQL Servert ( a sys.sp_describe_parameter_encryption meghívásával), hogy elemezze a lekérdezési utasítást, és adjon meg információkat arról, hogy a lekérdezés mely paramétereit kell titkosítani. Egy feltört SQL Server-példány félrevezetheti az SQL Server .NET-keretrendszer adatszolgáltatóját azzal, hogy elküldi a metaadatokat, amelyek azt jelzik, hogy a paraméter nem céloz meg titkosított oszlopot, annak ellenére, hogy az oszlop titkosítva van az adatbázisban. Ennek eredményeképpen az SQL Server .NET-keretrendszer adatszolgáltatója nem titkosítja a paraméter értékét, és egyszerű szövegként küldené el a sérült SQL Server-példánynak.

Az ilyen támadás megakadályozása érdekében egy alkalmazás true értékre állíthatja a paraméter SqlParameter.ForceColumnEncryption tulajdonságát . Ez azt eredményezi, hogy az SQL Server .NET-keretrendszer adatszolgáltatója kivételt okoz, ha a kiszolgálótól kapott metaadatok azt jelzik, hogy a paramétert nem kell titkosítani.

Bár az SqlParameter.ForceColumnEncryption tulajdonság használata segít a biztonság javításában, az ügyfélalkalmazás titkosításának átláthatóságát is csökkenti. Ha úgy frissíti az adatbázis sémáját, hogy módosítsa a titkosított oszlopok készletét, előfordulhat, hogy az alkalmazást is módosítania kell.

Az alábbi kódminta az SqlParameter.ForceColumnEncryption tulajdonság használatával szemlélteti, hogy a társadalombiztosítási számokat ne lehessen egyszerű szövegben elküldeni az adatbázisba.

SqlCommand cmd = _sqlconn.CreateCommand(); 

// Use parameterized queries to access Always Encrypted data. 
 
cmd.CommandText = @"SELECT [SSN], [FirstName], [LastName], [BirthDate] FROM [dbo].[Patients] WHERE [SSN] = @SSN;"; 

SqlParameter paramSSN = cmd.CreateParameter(); 
paramSSN.ParameterName = @"@SSN"; 
paramSSN.DbType = DbType.AnsiStringFixedLength; 
paramSSN.Direction = ParameterDirection.Input; 
paramSSN.Value = ssn; 
paramSSN.Size = 11; 
paramSSN.ForceColumnEncryption = true; 
cmd.Parameters.Add(paramSSN); 

SqlDataReader reader = cmd.ExecuteReader();

Megbízható oszlopmesterkulcs-elérési útvonalak konfigurálása

Az SQL Server által visszaadott titkosítási metaadatok a titkosított oszlopokat célzó lekérdezési paraméterekhez és a titkosítási oszlopokból lekért eredményekhez tartalmazzák az oszlop főkulcsának kulcsútvonalát, amely azonosítja a kulcstárolót és a kulcs helyét a kulcstárolóban. Ha az SQL Server-példány biztonsága sérül, elküldheti az SQL Server .NET-keretrendszer adatszolgáltatójának kulcsútvonalát a támadó által vezérelt helyre. Ez a kulcstároló hitelesítő adatainak kiszivárgásához vezethet abban az esetben, ha a kulcstároló megköveteli az alkalmazás hitelesítését.

Az ilyen támadások megelőzése érdekében az alkalmazás az SqlConnection.ColumnEncryptionTrustedMasterKeyPaths tulajdonság használatával megadhatja egy adott kiszolgáló megbízható kulcsútvonalainak listáját. Ha the.NET SQL Server-keretrendszer adatszolgáltatója a megbízható kulcs elérési útjának listáján kívül kap egy kulcsútvonalat, kivételt fog eredményezni.

Bár a megbízható kulcs elérési útjainak beállítása javítja az alkalmazás biztonságát, módosítania kell a kódot vagy/és az alkalmazás konfigurációját, amikor elforgatja az oszlop főkulcsát (amikor megváltozik az oszlop főkulcsának elérési útja).

Az alábbi példa bemutatja, hogyan konfigurálhatók a megbízható oszlopfőkulcsok elérési útjai:

// Configure trusted key paths to protect against fake key paths sent by a compromised SQL Server instance 
// First, create a list of trusted key paths for your server 
List<string> trustedKeyPathList = new List<string>(); 
trustedKeyPathList.Add("CurrentUser/my/425CFBB9DDDD081BB0061534CE6AB06CB5283F5Ea"); 

// Register the trusted key path list for your server 

SqlConnection.ColumnEncryptionTrustedMasterKeyPaths.Add(serverName, trustedKeyPathList);

Titkosított adatok másolása az SqlBulkCopy használatával

Az SqlBulkCopy használatával az egyik táblában már titkosított és tárolt adatokat egy másik táblába másolhatja az adatok visszafejtése nélkül. Ehhez tegye a következőt:

  • Győződjön meg arról, hogy a céltábla titkosítási konfigurációja megegyezik a forrástábla konfigurációval. Különösen mindkét táblának ugyanazokkal az oszlopokkal kell rendelkeznie, és az oszlopokat ugyanazokkal a titkosítási típusokkal és ugyanazokkal a titkosítási kulcsokkal kell titkosítani. Megjegyzés: ha a céloszlopok bármelyike másként van titkosítva, mint a megfelelő forrásoszlop, a másolási művelet után nem tudja visszafejteni a céltáblában lévő adatokat. Az adatok sérültek lesznek.
  • Konfigurálja mindkét adatbázis-kapcsolatot, a forrástáblát és a céltáblát anélkül, hogy engedélyezve van az Always Encrypted.
  • Állítsa be az AllowEncryptedValueModifications beállítást (lásd : SqlBulkCopyOptions). Megjegyzés: Az AllowEncryptedValueModifications megadásakor körültekintően kell eljárni, mert ez az adatbázis sérüléséhez vezethet, mert az SQL Server .NET-keretrendszer adatszolgáltatója nem ellenőrzi, hogy az adatok valóban titkosítottak-e, vagy a céloszloptal megegyező titkosítási típussal, algoritmussal és kulccsal van-e megfelelően titkosítva.

Az AllowEncryptedValueModifications beállítás a .NET-keretrendszer 4.6.1-s és újabb verzióiban érhető el.

Íme egy példa, amely adatokat másol az egyik táblából a másikba. Az SSN- és BirthDate-oszlopok titkosítását feltételezzük.

static public void CopyTablesUsingBulk(string sourceTable, string targetTable)
{
   string sourceConnectionString = "Data Source=server63; Initial Catalog=Clinic; Integrated Security=true";
   string targetConnectionString = "Data Source= server64; Initial Catalog=Clinic; Integrated Security=true";
   using (SqlConnection connSource = new SqlConnection(sourceConnectionString))
   {
      connSource.Open();
      using (SqlCommand cmd = new SqlCommand(string.Format("SELECT [PatientID], [SSN], [FirstName], [LastName], [BirthDate] FROM {0}", sourceTable), connSource))
      {
         using (SqlDataReader reader = cmd.ExecuteReader())
         {
            SqlBulkCopy copy = new SqlBulkCopy(targetConnectionString, SqlBulkCopyOptions.KeepIdentity | SqlBulkCopyOptions.AllowEncryptedValueModifications);
            copy.EnableStreaming = true;
            copy.DestinationTableName = targetTable;
            copy.WriteToServer(reader);
         }
      }
}

Always Encrypted API-referencia

Névtér:System.Data.SqlClient

Összeszerelés: System.Data (System.Data.dll)

Név Description Bevezetés a .NET-verzióba
SqlColumnEncryptionCertificateStoreProvider osztály A Windows Tanúsítványtároló kulcstároló-szolgáltatója. 4.6
SqlColumnEncryptionCngProvider osztály A Microsoft Cryptography API kulcstároló-szolgáltatója: Next Generation (CNG). 4.6.1
SqlColumnEncryptionCspProvider osztály A Microsoft CAPI-alapú titkosítási szolgáltatók (CSP) kulcstároló-szolgáltatója. 4.6.1
SqlColumnEncryptionKeyStoreProvider osztály A kulcstároló-szolgáltatók alaposztálya. 4.6
SqlCommandColumnEncryptionSetting Enumeration Az adatbázis-kapcsolat titkosításának és visszafejtéséhez szükséges beállítások. 4.6
SqlConnection oszlop titkosítási beállítás felsorolása Az Always Encrypted viselkedésének szabályozására szolgáló beállítások az egyes lekérdezésekhez. 4.6
SqlConnectionStringBuilder.ColumnEncryptionSetting tulajdonság Lekéri és beállítja az Always Encryptedt a kapcsolati sztringben. 4.6
SqlConnection.ColumnEncryptionQueryMetadataCacheEnabled tulajdonság Engedélyezi és letiltja a titkosítási lekérdezés metaadatainak gyorsítótárazását. 4.6.2
SqlConnection.ColumnEncryptionKeyCacheTtl Property Lekéri és beállítja az oszloptitkosítási kulcs gyorsítótárában lévő bejegyzések élettartamát. 4.6.2
SqlConnection.ColumnEncryptionTrustedMasterKeyPaths Tulajdonság Lehetővé teszi az adatbázis-kiszolgáló megbízható kulcsútvonalainak listáját. Ha egy alkalmazás-lekérdezés feldolgozása során az illesztő olyan kulcselérési utat kap, amely nem szerepel a listán, a lekérdezés sikertelen lesz. Ez a tulajdonság további védelmet nyújt az olyan biztonsági támadások ellen, amelyek egy feltört SQL Servert érintenek, amely hamis kulcsútvonalakat biztosít, ami a kulcstároló hitelesítő adatainak kiszivárgásához vezethet. 4.6
SqlConnection.RegisztrálOszlopTitkosításiKulcsTárolóSzolgáltatókat metódus Lehetővé teszi egyéni kulcstároló-szolgáltatók regisztrálását. Ez egy szótár, amely a kulcstár-szolgáltató neveket a kulcstár-szolgáltató implementációkra térképezi. 4.6
SqlCommand Konstruktor (String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting) Lehetővé teszi az Always Encrypted viselkedésének szabályozását az egyes lekérdezések esetében. 4.6
SqlParameter.ForceColumnEncryption tulajdonság Kényszeríti egy paraméter titkosítását. Ha az SQL Server tájékoztatja az illesztőprogramot, hogy a paramétert nem kell titkosítani, a paramétert használó lekérdezés sikertelen lesz. Ez a tulajdonság további védelmet nyújt az olyan biztonsági támadások ellen, amelyek egy sérült SQL Servert érintenek, amely helytelen titkosítási metaadatokat biztosít az ügyfélnek, ami adatfeltárást eredményezhet. 4.6
Új kapcsolati karakterlánc kulcsszó: Column Encryption Setting=enabled Engedélyezi vagy letiltja az Always Encrypted funkciót a kapcsolathoz. 4.6

Lásd még

  • Last updated on