Jak utworzyć zasady In-Memory OLTP App Control i zarządzanego instalatora

Dotyczy:programu SQL Server

SQL Server kompiluje i łączy bibliotekę dynamicznych łącz (DLL) dla każdej natywnie skompilowanej tabeli i procedury przechowywanej, zawierając natywną implementację tych obiektów w kodzie C. Chociaż In-Memory DLL OLTP są generowane dynamicznie, pliki te mogą stanowić wyzwania w środowiskach, gdzie wymagane jest egzekwowanie integralności kodu.

Czym jest HkDllGen?

W aktualizacji zbiorczej 17 (Cumulative Update 17) programu SQL Server 2022 (16.x) i nowszych wersjach funkcja In-Memory OLTP obejmuje generator bibliotek DLL Hekaton, czyli HkDllGen. Bez HkDllGen program SQL Server generuje kod źródłowy w języku C wewnątrz sqlservr.exe i uruchamia kompilator, który wywołuje program konsolidujący w celu utworzenia biblioteki DLL mechanizmu In-Memory OLTP. Po włączeniu generowania zewnętrznego SQL Server eksportuje serializowane metadane obiektów i uruchamia system Microsoft-signed hkdllgen.exe. HkDllGen weryfikuje i importuje te metadane, generuje źródło C w swoim procesie oraz uruchamia kompilator i linker.

Aby wymusić integralność kodu tych bibliotek DLL, użyj AppLocker, aby wskazać podpisany przez firmę Microsoft element hkdllgen.exe jako instalator zarządzany i włączyć zaufanie do instalatora zarządzanego w zasadach App Control for Business, dawniej Windows Defender Application Control (WDAC). System Windows rejestruje następnie, że wygenerowane biblioteki DLL pochodzą z drzewa procesów HkDllGen, co pozwala funkcji App Control uznać je za zaufane na podstawie ich pochodzenia z zarządzanego instalatora.

HkDllGen to pierwszy krok w kierunku spełnienia wymogów regulacyjnych, które obejmują integralność kodu dla In-Memory OLTP. W tym scenariuszu integralność kodu zapewnia, że system Windows może ustalić wiarygodne pochodzenie każdej wygenerowanej biblioteki DLL i ocenić to zaufanie podczas jej ładowania przez program SQL Server. Wygenerowane DLL nie jest podpisane przez Authenticode. Windows ufa mu na podstawie sposobu jego tworzenia.

Jak działa instalator zarządzany?

Zarządzany instalator używa specjalnej kolekcji reguł w AppLocker , aby wyznaczyć pliki binarne, którym Twoja organizacja ufa jako autoryzowane źródło instalacji aplikacji. Po uruchomieniu jednego z tych zaufanych plików binarnych system Windows monitoruje proces binarny (i wszystkie procesy podrzędne uruchamiane) i obserwuje pliki zapisywane na dysku. W miarę zapisywania plików oświadczenie lub tag są dodawane do pliku jako pochodzące z zarządzanego instalatora.

Twierdzenie o pochodzeniu jest rozszerzonym atrybutem zarządzanym przez jądro. To nie jest podpis Authenticode i nie zmienia wydawcy ani statusu podpisu wygenerowanego DLL.

Dzięki zastosowaniu AppLocker, App Control for Business (dawniej Windows Defender Application Control lub WDAC) może być skonfigurowany tak, aby ufał plikom instalowanym przez zarządzany instalator poprzez dodanie opcji Włączony:Zarządzany instalator do polityki App Control. Gdy ustawiasz tę opcję, App Control sprawdza informacje o pochodzeniu zarządzanego instalatora przy decydowaniu, czy pozwolić na uruchomienie pliku binarnego. Tak długo, jak nie ma reguł odmowy dla pliku binarnego, kontrolka aplikacji umożliwia jej uruchamianie wyłącznie na podstawie źródła zarządzanego instalatora. AppLocker kontroluje także uruchamianie plików wykonywalnych, które oznacza jako pochodzące z zarządzanego instalatora, ale nie zapewnia łańcucha zaufania dla plików wykonywalnych i bibliotek DLL tak jak WDAC. W tym artykule wyjaśniamy, jak wyznaczyć i skonfigurować proces HkDllGen jako zarządzany instalator, z którego mogą korzystać zarówno AppLocker, jak i WDAC.

Włączanie generatora bibliotek DLL Hekaton

Przykład

Ten przykład włącza generator DLL Hekaton przy użyciu sp_configure z opcją external xtp dll gen util enabled. Stwórz bazę testową oraz tabelę zoptymalizowaną pod pamięć testową.

1. Utwórz testową bazę danych.

   USE master;
   GO
   
   EXECUTE sp_configure 'external xtp dll gen util enabled', 1;
   RECONFIGURE;
   GO
   
   CREATE DATABASE HekatonDbForTesting ON
   PRIMARY (
       NAME = N'HekatonDbForTesting_Data',
       FILENAME = N'<path-to-data-directory>\HekatonDbForTesting_Data.mdf'
   ),
   FILEGROUP [HekatonDbForTestin_XTP_FG] CONTAINS MEMORY_OPTIMIZED_DATA (
       NAME = HekatonDbForTesting_XTP_CHKPOINT,
       FILENAME = N'<path-to-data-directory>\HekatonDbForTesting_XTP_CHKPOINT'
   )
   LOG ON (
       NAME = N'HekatonDbForTesting_log',
       FILENAME = N'<Path_To_Log_Directory>\HekatonDbForTesting_Log.ldf'
   );
   GO
   

2. Utwórz tabelę testową w testowej bazie danych.

   USE HekatonDbForTesting;
   GO
   
   CREATE TABLE dbo.TestCustomerTable
   (
       CustomerId INT NOT NULL
           PRIMARY KEY NONCLUSTERED HASH WITH (BUCKET_COUNT = 1000000),
       FirstName NVARCHAR (50) NOT NULL,
       LastName NVARCHAR (50) NOT NULL
   )
   WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA);
   GO
   

3. Plik .gen jest tworzony obok każdej biblioteki DLL wygenerowanej za pomocą HkDllGen w podkatalogu <path-to-data-directory>\xtp\<database_id>. Ten plik rejestruje wyjście HkDllGen i zazwyczaj ma zerową długość po pomyślnym skompilowaniu. Jego obecność wskazuje, że generator zewnętrzny został wywołany. Wygenerowane pliki DLL nie są podpisane przez Authenticode. Aby system Windows uznawał wygenerowane biblioteki DLL za zaufane na podstawie ich pochodzenia, potrzebne są funkcja śledzenia Managed Installer oraz zasady App Control.

Istniejące DLL nie odzyskują zarządzanych informacji o pochodzeniu instalatora wstecznie. Wygeneruj nowy plik DLL po włączeniu śledzenia zarządzanego instalatora podczas weryfikowania zasad.

Kroki tworzenia In-Memory OLTP AppLocker oraz zarządzanych polityk instalatora

Nie możesz używać interfejsu tworzenia polityk AppLocker w GPO Editor (gpedit.msc) ani cmdletów PowerShell AppLocker do tworzenia reguł dla zarządzanej kolekcji reguł instalatora. Możesz jednak użyć edytora XML lub tekstu, aby przekonwertować politykę kolekcji reguł EXE na zarządzaną kolekcję reguł instalatora.

Pozostałe przykłady w tym artykule dotyczą wersji Windows Server 2022 oraz Windows 11 i nowszych.

Aby zweryfikować, czy przynajmniej kolekcja reguł exe istnieje w konfiguracji polityki AppLocker Control serwera, uruchom następujące polecenie PowerShell:

Get-AppLockerPolicy -Effective

Lub wykonaj następujące polecenie, aby zapisać wynik efektywnych polityk do pliku XML do przeglądu:

Get-AppLockerPolicy -Effective -Xml > effective_app_policy.xml

Poniższe kroki prowadzą przez proces tworzenia i wdrażania polityki, którą możesz zastosować na lokalnym serwerze. Zarządzana polityka instalatora, wygenerowana za pomocą tych kroków, może zostać zintegrowana z polityką ogólno-GPO-ową i rozpowszechniona do wszystkich instancji SQL Server w środowisku lub zastosowana do lokalnej polityki jednego serwera. Powinieneś współpracować z administratorem domeny, aby zastosować politykę integralności kodu na poziomie domeny.

1. Użyj New-AppLockerPolicy, aby utworzyć regułę EXE dla pliku, który wyznaczasz jako zarządzany instalator. Ten przykład tworzy regułę dla generatora Hekaton DLL, używając typu reguły Publisher, ale możesz użyć dowolnego typu reguły AppLocker. Może być konieczne ponowne sformatowanie danych wyjściowych w celu zapewnienia czytelności.

   # Change the current working path of the PowerShell command line or ISE to
   # something other than the default (that is, C:\Temp). Retrieve SQL Server Path.
   $sqlPathParams = @{
      Path = 'HKLM:\SOFTWARE\Microsoft\MSSQLServer\Setup'
      Name = 'SQLPath'
   }
   $SQLPath = Get-ItemProperty @sqlPathParams
   
   $joinPathParams = @{
      Path = $SQLPath.SQLPath
      ChildPath = 'Binn\xtp'
   }
   $FullPath = Join-Path @joinPathParams
   
   # Set an environment variable for the In-memory OLTP Path.
   [System.Environment]::SetEnvironmentVariable('SQLPathWithXtp', $FullPath, 'Process')
   
   # Generate an AppLocker Policy for hkdllgen.exe in the current working directory.
   # The Get-AppLockerFileInformation cmdlet extracts the executable's publisher
   # information, and generates a hash for the binary.
   $hkDllGenPath = Join-Path -Path $env:SQLPathWithXtp -ChildPath 'hkdllgen.exe'
   
   $newPolicyParams = @{
      RuleType = 'Publisher'
      User = 'Everyone'
      Xml = $true
   }
   Get-ChildItem -Path $hkDllGenPath |
   Get-AppLockerFileInformation |
   New-AppLockerPolicy @newPolicyParams > AppLocker_HkDllGen_Policy.xml
   

2. Ręcznie edytuj AppLocker_HkDllGen_Policy.xml i zmień następujące wartości atrybutów:

   • RuleCollection Type do ManagedInstaller
   • EnforcementMode do AuditOnly
   • BinaryVersionRange LowSection do "*" i HighSection do "*"

   Zmiana

   <RuleCollection Type="Exe" EnforcementMode="NotConfigured">
   

   do:

   <RuleCollection Type="ManagedInstaller" EnforcementMode="AuditOnly">
   

   Zmiana

   <BinaryVersionRange LowSection="2022.160.4175.1" HighSection="2022.160.4175.1"/>
   

   do:

   <BinaryVersionRange LowSection="*" HighSection="*"/>
   

3. Wdróż zasady konfiguracji instalatora zarządzanego funkcji AppLocker. Możesz albo zaimportować politykę AppLocker i wdrożyć ją za pomocą polityki grupowej, albo użyć skryptu, aby wdrożyć politykę za pomocą Set-AppLockerPolicy cmdletu, jak pokazano w poniższym poleceniu PowerShell.

   #Enable the AppLocker Policy and merge with the existing policy that exists on the system.
   Set-AppLockerPolicy -XmlPolicy .\AppLocker_HkDllGen_Policy.xml -Merge -ErrorAction SilentlyContinue
   

4. Jeśli wdrożysz politykę AppLocker za pomocą skryptu PowerShell, użyj appidtel.exe narzędzia z wiersza poleceń administracyjnych do skonfigurowania usługi AppLocker Application Identity oraz sterownika filtra AppLocker.

   appidtel.exe start [-mionly]
   

Włącz opcję zarządzanego instalatora w Kreatorze kontroli aplikacji usługi Windows Defender dla firm

Aby Windows Defender Application Control (WDAC) uznawała biblioteki DLL generowane przez proces hkdllgen.exe, włącz opcję Włączone: Zarządzany instalator w zasadach kontroli aplikacji. Zdefiniuj to ustawienie za pomocą polecenia cmdlet Set-RuleOption, przy użyciu opcji 13.

Wygeneruj plik zasad integralności kodu z jednego z kreatorów zasad podstawowych WDAC zasad podstawowych szablonów.

Zaczynając od domyślnych zasad Windows i, oferowane jest mniej opcji, które zostały usunięte w tym przewodniku. Aby uzyskać więcej informacji o zasadach Default Windows Mode i Allow Microsoft Mode, zobacz artykuł Przykładowe zasady bazowe funkcji App Control for Business.

Podstawowe zasady szablonu

Po wybraniu szablonu bazy polityk Windows, nazwij ją i wybierz miejsce, gdzie zapisać politykę App Control na dysku.

Wybierz typ zasad

Wybierz format Multiple Policy oraz Base Policy jako typ polisy.

Konfigurowanie szablonu zasad

Włącz tylko opcje reguł zasad Zarządzany instalator, Zasada aktualizacji bez ponownego uruchamiania, Niepodpisana zasada integralności systemu i Integralność kodu w trybie użytkownika. Wyłącz inne opcje reguły zasad. Aby zmienić ustawienia, wybierz suwak obok tytułów reguł polityki.

Poniższa tabela opisuje każdą regułę polityki, zaczynając od najbardziej lewej kolumny. Artykuł o zasadach polityki zawiera bardziej szczegółowy opis każdej reguły politycznej.

Najpierw należy włączyć tryb inspekcji, ponieważ umożliwia testowanie nowych zasad kontroli aplikacji dla firm przed ich wymuszeniem. W trybie audytu żadna aplikacja nie jest blokowana. Zamiast tego polityka rejestruje zdarzenie za każdym razem, gdy uruchamia się aplikacja spoza polityki. Z tego powodu wszystkie szablony mają domyślnie włączony tryb inspekcji.

Reguły plików

Usuń z listy wszystkie reguły podpisywania zasad.

(Opcjonalne) Dodaj regułę Custom Publisher zezwalającej na hkdllgen.exe. Ta reguła wykorzystuje informacje z istniejącego certyfikatu Microsoft do podpisywania kodu pliku wykonywalnego, aby zidentyfikować i umożliwić dopasowanie wersji HkDllGen.

Typ reguły pliku Publisher używa właściwości w łańcuchu certyfikatów podpisywania kodu, aby tworzyć reguły plików.

Po wybraniu Utwórz Regułę powinna istnieć pojedyncza Reguła Podpisywania Polityki.

Wdróż zasady kontroli aplikacji. Zobacz Wdrażanie zasad kontroli aplikacji dla biznesu.

Po utworzeniu polityki nowa polityka jest zapisywana na ścieżce wybranej jako lokalizacja pliku polityki. Nowa wersja binarna nazwy pliku polityki zawiera wersję polityki na końcu nazwy pliku. Możesz skopiować <policy>.cip plik do podkatalogu C:\Windows\System32\CodeIntegrity\CiPolicies\Active na instancji SQL Server.

Ręczne wdrażanie zasad integralności kodu

Aby stworzyć bardziej uproszczoną politykę integralności kodu, możesz edytować bardziej ogólny <policy>.xml plik, który generujesz po ukończeniu Kreatora Polityki Kontroli Aplikacji WDAC. Taka sytuacja może wystąpić, jeśli Kreator zasad kontroli aplikacji WDAC zostanie uruchomiony nie na serwerze SQL Server, ale na stacji roboczej. Na przykład mniej dostosowany plik zasad integralności kodu może wyglądać następująco:

<?xml version="1.0" encoding="utf-8"?>
<SiPolicy xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="urn:schemas-microsoft-com:sipolicy" PolicyType="Base Policy">
  <VersionEx>10.0.5.0</VersionEx>
  <PlatformID>{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}</PlatformID>
  <PolicyID>{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}</PolicyID>
  <BasePolicyID>{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}</BasePolicyID>
  <Rules>
    <Rule>
      <Option>Enabled:Unsigned System Integrity Policy</Option>
    </Rule>
    <Rule>
      <Option>Enabled:UMCI</Option>
    </Rule>
    <Rule>
      <Option>Enabled:Audit Mode</Option>
    </Rule>
    <Rule>
      <Option>Enabled:Managed Installer</Option>
    </Rule>
    <Rule>
      <Option>Enabled:Update Policy No Reboot</Option>
    </Rule>
  </Rules>
  <EKUs>
    <!--EKU ID-->
  </EKUs>
  <FileRules>
    <!--FileAttrib ID -->
  </FileRules>
  <Signers />
  <SigningScenarios>
    <SigningScenario ID="ID_SIGNINGSCENARIO_KMCI" FriendlyName="Kernel Mode Signing Scenario" Value="131">
      <ProductSigners />
    </SigningScenario>
    <SigningScenario ID="ID_SIGNINGSCENARIO_UMCI" FriendlyName="User Mode Signing Scenario" Value="12">
      <ProductSigners />
    </SigningScenario>
  </SigningScenarios>
  <UpdatePolicySigners />
  <HvciOptions>0</HvciOptions>
</SiPolicy>

Ten przykład nie zawiera reguły podpisanego wydawcy i zakłada, że plik zasad używa lokalnego katalogu roboczego (na przykład C:\Temp) i ma nazwę Hekaton_Custom_CIPolicy.xml.

$policyPath = 'C:\Temp\Hekaton_Custom_CIPolicy.xml'

# Create Windows Defender Application Control (WDAC)
# policy and set Option 13 (Enabled:Managed Installer)
# and Option 16 (Enabled:Update Policy No Reboot)
$policyIdParams = @{
    FilePath = $policyPath
    PolicyName = 'Hekaton Managed Installer Policy'
    ResetPolicyID = $true
}
Set-CIPolicyIdInfo @policyIdParams

$option13Params = @{
    FilePath = $policyPath
    Option = 13
}
Set-RuleOption @option13Params

$option16Params = @{
    FilePath = $policyPath
    Option = 16
}
Set-RuleOption @option16Params

# Retrieve the Policy ID from the App Control policy XML.
# Code Integrity uses this ID as the binary file name.
[xml]$AppControlPolicy = Get-Content -Path $policyPath
$PolicyID = $AppControlPolicy.SiPolicy.PolicyID
$PolicyBinary = $PolicyID + '.cip'

# Convert the App Control policy XML to binary format and
# save it into the Active Code Integrity path.
$convertParams = @{
    XmlFilePath = $policyPath
    BinaryFilePath = "C:\Windows\System32\CodeIntegrity\CiPolicies\Active\$PolicyBinary"
}
ConvertFrom-CIPolicy @convertParams

Aby zastosować zasady bez ponownego uruchamiania serwera i sprawdzić stan integralności kodu, uruchom ten skrypt programu PowerShell:

# Refresh the Code Integrity policy without a reboot of the system
$updateCiParams = @{
    Namespace  = 'root\Microsoft\Windows\CI'
    ClassName  = 'PS_UpdateAndCompareCIPolicy'
    MethodName = 'Update'
    Arguments  = @{ FilePath = "C:\Windows\System32\CodeIntegrity\CiPolicies\Active\$PolicyBinary" }
}
Invoke-CimMethod @updateCiParams

# View the current status of WDAC Code Integrity. If WDAC is in Audit mode
# the "UserModeCodeIntegrityPolicyEnforcementStatus" has a value of "1"
# for Audit mode. A value of "0" mean that Code Integrity is not active.
$deviceGuardParams = @{
    ClassName = 'Win32_DeviceGuard'
    Namespace = 'root\Microsoft\Windows\DeviceGuard'
}
Get-CimInstance @deviceGuardParams | Format-List *codeintegrity*

Sprawdź, czy wygenerowane biblioteki DLL Hekaton są zaufane przez integralność kodu

Po uaktywnieniu reguły Managed Installer w AppLocker oraz wymaganych usług AppLocker wygeneruj nową bibliotekę DLL funkcji In-Memory OLTP za pomocą HkDllGen. System Windows śledzi drzewo procesów procesu HkDllGen i dodaje rozszerzony atrybut $KERNEL.SMARTLOCKER.ORIGINCLAIM do plików utworzonych przez procesy należące do tego drzewa.

Gdy App Control działa w trybie inspekcji lub wymuszania z włączoną opcją Enabled:Managed Installer, Code Integrity może ufać wygenerowanemu plikowi DLL ze względu na jego pochodzenie z zarządzanego instalatora. Aby zweryfikować, że rozszerzony atrybut został dodany, wybierz nowo wygenerowane DLL z folderu \Data\xtp\<database_id> i uruchom następujące polecenie z podwyższonego wiersza poleceń:

fsutil file queryea "D:\SQL\MSSQL17.MSSQLSERVER\MSSQL\DATA\xtp\5\xtp_t_5_64719283_196202718557591_1.dll"

Sama obecność pliku $KERNEL.SMARTLOCKER.ORIGINCLAIM nie potwierdza, że plik ma zarządzane źródło instalatora. Ten sam rozszerzony atrybut może rejestrować pochodzenie Intelligent Security Graph oraz sposób dziedziczenia zaufania. W pierwszym wierszu danych element ULONG na początku drugiego elementu 00 oznacza pochodzenie Managed Installer, natomiast 01 oznacza pochodzenie Intelligent Security Graph. Aby ocenić pozostałe wartości oświadczeń pochodzenia, zobacz dokumentację techniczną Managed Installer i ISG.

Usuń funkcję instalatora zarządzanego

Aby usunąć funkcję Zarządzanego Instalatora z urządzenia, usuń politykę Zarządzanego Instalatora AppLocker z urządzenia, postępując zgodnie z instrukcjami w Usuń regułę AppLocker: Usuń polityki AppLocker na pojedynczym systemie lub zdalnych systemach.

Powiązana zawartość

• Automatycznie zezwalaj aplikacjom wdrażanym przez zarządzany program instalacyjny za pomocą "App Control for Business"
• In-Memory przegląd i scenariusze użycia OLTP
• przewodnik dotyczący przetwarzania zapytań dla tabel Memory-Optimized
• Przykładowa baza danych dla olTP w pamięci
• Przewodnik wdrażania AppLocker
• wdrażanie zasad kontroli aplikacji dla firm