Hur man skapar In-Memory OLTP App Control och hanterade installationspolicyer

gäller för:SQL Server

SQL Server kompilerar och länkar ett dynamiskt länkbibliotek (DLL) för varje nativt kompilerad tabell och lagrad procedur, som innehåller den inbyggda implementationen av dessa objekt i C-kod. Även om In-Memory OLTP-DLL:er genereras dynamiskt kan filerna utgöra utmaningar i miljöer där efterlevnad av kodintegritet krävs.

Vad är HkDllGen?

I SQL Server 2022 (16.x) Cumulative Update 17 och senare versioner inkluderar In-Memory OLTP-funktionen Hekaton DLL-generatorn, eller HkDllGen. Utan HkDllGen genererar SQL Server C-källkoden inuti sqlservr.exe och startar kompilatorn, som anropar länkaren för att skapa den In-Memory OLTP-DLL:n. Med extern generering aktiverad exporterar SQL Server serialiserad objektmetadata och startar den Microsoft-signerade hkdllgen.exe. HkDllGen validerar och importerar den metadatan, genererar C-källkoden i sin egen process och startar kompilatorn och länkaren.

För att upprätthålla kodintegritet för dessa DLL:er, använd AppLocker för att utse den Microsoft-signerade hkdllgen.exe som en hanterad installerare och aktivera Managed Installer-förtroende i App Control for Business-policyn, tidigare Windows Defender Application Control (WDAC). Windows registrerar sedan att de genererade DLL:erna kommer från HkDllGen-processträdet, vilket gör att App Control kan lita på dem baserat på deras ursprungliga hanterade installationsprogram.

HkDllGen är det första steget mot att uppfylla regulatoriska krav som inkluderar kodintegritet för In-Memory OLTP. I detta scenario säkerställer kodintegritet att Windows kan etablera en betrodd källa för varje genererad DLL och utvärdera den förtroendet när SQL Server laddar den. Den genererade DLL:n är inte Authenticode-signerad. Windows litar på den baserat på hur den skapades.

Hur fungerar ett hanterat installationsprogram?

En hanterad installationsprogram använder en speciell regelsamling i AppLocker för att utse binärfiler som din organisation litar på som auktoriserad källa för applikationsinstallation. När en av dessa betrodda binärfiler körs övervakar Windows binärfilens process (och eventuella underordnade processer som startas) och söker efter filer som skrivs till disk. När filer skrivs läggs en uppgift eller tagg till i filen som anger att den kommer från ett hanterat installationsprogram.

Anspråket på ursprung är ett kärnhanterat utökat attribut. Det är inte en Authenticode-signatur och ändrar inte den genererade DLL:ns publicerings- eller signeringsstatus.

Genom att använda AppLocker kan App Control for Business (tidigare Windows Defender Application Control, eller WDAC) konfigureras att lita på filer som en hanterad installerare installerar genom att lägga till alternativet Enabled:Managed Installer i en App Control-policy. När du sätter det alternativet kontrollerar App Control efter ursprungsinformation för hanterad installation när de avgör om en binär ska tillåtas köras. Så länge det inte finns några nekanderegler för binärfilen tillåter App Control att den körs enbart baserat på dess ursprung för det hanterade installationsprogrammet. AppLocker styr också exekveringen av exekverbara filer som den utser som en hanterad installerare, men erbjuder ingen förtroendekedja för körbara filer och DLL:er som WDAC. Den här artikeln går igenom hur man utser och konfigurerar HkDllGen-processen som en hanterad installerare som både AppLocker och WDAC kan använda.

Aktivera Hekaton DLL-generatorn

Exempel

Detta exempel aktiverar Hekaton DLL-generatorn genom att använda sp_configure med alternativet external xtp dll gen util enabled . Skapa en testdatabas och en minnesoptimerad tabell för testet.

1. Skapa en testdatabas.

   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. Skapa en testtabell i testdatabasen.

   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. En .gen fil skapas vid sidan av varje DLL som genereras via HkDllGen i underkatalogen <path-to-data-directory>\xtp\<database_id>. Denna fil fångar HkDllGen-utdata och är normalt noll längd efter en lyckad kompilering. Dess närvaro indikerar att den externa generatorn aktiverades. De genererade DLL:erna är inte Authenticode-signerade. För att Windows ska kunna lita på de genererade DLL:erna baserat på deras ursprung behöver du spårning av Managed Installer och en App Control-policy.

Befintliga DLL-filer får inte retroaktivt ursprungsinformation om det hanterade installationsprogrammet. Generera en ny DLL när spårning av hanterade installationsprogram har aktiverats vid validering av principen.

Steg för att skapa In-Memory OLTP AppLocker och hanterade installationspolicys

Du kan inte använda AppLockers policyskapande UI i GPO Editor (gpedit.msc) eller AppLocker PowerShell-cmdlets för att skapa regler för den hanterade installationsregelsamlingen. Du kan dock använda en XML- eller textredigerare för att konvertera en EXE-regelsamlingspolicy till en hanterad installationsregelsamling.

De återstående exemplen i denna artikel gäller för Windows Server 2022 och Windows 11 och senare versioner.

För att verifiera att åtminstone en exe-regelsamling finns inom serverns AppLocker Control-policykonfiguration, kör följande PowerShell-kommando:

Get-AppLockerPolicy -Effective

Eller kör följande kommando för att spara utdata från de effektiva policyerna till en XML-fil för visning:

Get-AppLockerPolicy -Effective -Xml > effective_app_policy.xml

Följande steg går igenom processen att skapa och tillämpa en policy som du kan tillämpa på en lokal server. En hanterad installationspolicy som genereras med dessa steg kan slås ihop med en GPO-övergripande policy och distribueras till alla SQL Server-instanser inom en miljö, eller appliceras på en enskild servers lokala policy. Du bör samarbeta med en domänadministratör för att tillämpa Code Integrity-policyn från domännivå.

1. Använd New-AppLockerPolicy för att skapa en EXE-regel för filen som du anger som ett hanterat installationsprogram. Detta exempel skapar en regel för Hekaton DLL-generator genom att använda Publisher-regeltypen, men du kan använda vilken AppLocker-regeltyp som helst. Du kan behöva formatera om utdata för läsbarhet.

   # 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. Redigera AppLocker_HkDllGen_Policy.xml manuellt och ändra följande attributvärden:

   • RuleCollection Type till ManagedInstaller
   • EnforcementMode till AuditOnly
   • BinaryVersionRange LowSection till "*" och HighSection till "*"

   Förändring:

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

   till:

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

   Förändring:

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

   till:

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

3. Distribuera konfigurationsprincipen för AppLocker-hanterat installationsprogram. Du kan antingen importera AppLocker-policyn och distribuera den med Group Policy, eller använda ett skript för att distribuera policyn med cmdleten Set-AppLockerPolicy som visas i följande PowerShell-kommando.

   #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. Om du distribuerar AppLocker-policyn med ett PowerShell-skript, använd appidtel.exe verktyget från en administrativ kommandoprompt för att konfigurera AppLocker Application Identity-tjänsten och AppLocker-filterdrivrutinen.

   appidtel.exe start [-mionly]
   

Aktivera alternativet för hanterat installationsprogram i guiden Programkontroll för företag i Windows Defender

För att Windows Defender Application Control (WDAC) ska lita på de DLL:er som genereras av hkdllgen.exe processen, ange alternativet Enabled: Managed Installer i din App Control-policy. Definiera denna inställning genom att använda cmdletenSet-RuleOption med alternativ 13.

Generera kodintegritetsprincipfilen från en av mallarna för basprinciper som finns i WDAC-basprincipguiden.

Om man utgår från principen Standard-Windows får man färre alternativ, vilka tas bort i den här guiden. Mer information om principerna Default Windows Mode och Allow Microsoft Mode finns i artikeln Exempel på App Control for Business-grundprinciper.

Policy för bas-mall

Efter att du valt Windows policybasmall, namnge policyn och välj var App Control-policyn ska sparas på disken.

Välj en principtyp

Välj Multiple Policy Format och Base Policy som policytyp.

Konfigurera principmall

Aktivera endast alternativen för principreglerna Managed Installer, Uppdateringsprincip utan omstart, Unsigned System Integrity Policy och User Mode Code Integrity. Inaktivera de andra principregelalternativen. För att ändra inställningarna väljer du skjutreglaget intill titlarna på policyreglerna.

Följande tabell beskriver varje policyregel, med början i den vänstra kolumnen. Artikeln om policyregler ger en mer detaljerad beskrivning av varje policyregel.

Du bör först aktivera granskningsläge eftersom du kan testa nya App Control for Business-principer innan du tillämpar dem. I revisionsläge blockeras ingen applikation. Istället loggar policyn en händelse varje gång en applikation utanför policyn startar. Därför har alla mallar granskningsläge aktiverat som standard.

Filregler

Ta bort alla regler för signering av policyer från listan.

(Valfritt) Lägg till en Custom Publisher allow rule för hkdllgen.exe. Denna regel använder information från den körbara filens befintliga Microsoft-kodsigneringscertifikat för att identifiera och tillåta matchande versioner av HkDllGen.

Regeltypen för utgivarens fil använder egenskaper i kodsigneringscertifikatkedjan för att fastställa filregler.

Efter att du valt Create Rule bör en enda Policy Signing-regel finnas.

Distribuera din App Control-policy. Se Distribuera appkontroll för företagspolicyer.

Efter att policyn har skapats skrivs den nya policyn till den sökväg som valdes som policyfilens plats. Den nya binära versionen av policyfilnamnet inkluderar policyversionen i slutet av filnamnet. Du kan kopiera <policy>.cip filen till underkatalogen C:\Windows\System32\CodeIntegrity\CiPolicies\Active i SQL Server-instansen.

Distribuera en kodintegritetspolicy manuellt

För att skapa en mer strömlinjeformad kodintegritetspolicy kan du redigera en mer generell <policy>.xml fil som du genererar efter att ha slutfört WDAC App Control Policy Wizard. Detta scenario kan uppstå om du inte kör WDAC App Control Policy Wizard på en SQL Server, utan från en arbetsstation. En mindre anpassad kodintegritetsprincipfil kan till exempel se ut så här:

<?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>

Detta exempel har ingen signerad publicistregel och antar att policyfilen använder en lokal arbetskatalog (till exempel C:\Temp) med filnamnet .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

Om du vill tillämpa principen utan att starta om servern och kontrollera statusen för kodintegritet kör du det här PowerShell-skriptet:

# 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*

Kontrollera att hekaton-DLL:er som genereras är betrodda av kodintegritet

När AppLocker Managed Installer-regeln och nödvändiga AppLocker-tjänster är aktiva, generera en ny In-Memory OLTP DLL via HkDllGen. Windows spårar HkDllGen-processträdet och lägger till ett $KERNEL.SMARTLOCKER.ORIGINCLAIM utökat attribut till filer som skapas av det processträdet.

När App Control körs i gransknings- eller tillsynsläge med Enabled:Managed Installer kan Code Integrity lita på den genererade DLL:n baserat på dess ursprungliga hanterade installationsprogram. För att verifiera att det utökade attributet lades till, välj en nygenererad DLL från \Data\xtp\<database_id> mappen och kör följande kommando från en upphöjd kommandoprompt:

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

Förekomsten av $KERNEL.SMARTLOCKER.ORIGINCLAIM ensam bekräftar inte att filen har ett hanterat installationsursprung. Samma utökade attribut kan registrera ursprung för Intelligent Security Graph och hur förtroende ärvdes. I den första dataraden identifierar 00 i början av den andra ULONG Managed Installer-ursprung, medan 01 identifierar Intelligent Security Graph-ursprung. För att utvärdera de återstående värdena för ursprungsanspråk, se den tekniska referensen för Managed Installer och ISG.

Ta bort funktionen Managed Installer

För att ta bort funktionen Managed Installer från enheten, ta bort Managed Installer AppLocker-policyn från enheten genom att följa instruktionerna i Delete an AppLocker-regeln: Rensa AppLocker-policys på ett enskilt system eller fjärrsystem.

Relaterat innehåll

• Tillåt automatiskt appar som distribueras av ett hanterat installationsprogram med App Control för företag
• In-Memory OLTP-översikt och användningsscenarier
• En guide till frågebearbetning för Memory-Optimized-tabeller
• Exempeldatabas för minnesintern OLTP
• distributionsguide för AppLocker
• Distribuera appkontroll för affärsprinciper