Come creare criteri di Controllo app per In-Memory OLTP e di installazione gestita

si applica a:SQL Server

SQL Server compila e collega una libreria a collegamento dinamico (DLL) per ogni tabella e procedura memorizzata compilata nativamente, contenente l'implementazione nativa di quegli oggetti in codice C. Sebbene In-Memory DLL OLTP vengano generati dinamicamente, i file possono rappresentare sfide in ambienti in cui è richiesta l'applicazione dell'integrità del codice.

Cos'è HkDllGen?

Nelle versioni SQL Server 2022 (16.x) Cumulative Update 17 e successive, la funzionalità OLTP In-Memory include il generatore DLL Hekaton, o HkDllGen. Senza HkDllGen, SQL Server genera sorgente C all'interno sqlservr.exe e avvia il compilatore, che invoca il linker per creare la DLL OLTP In-Memory. Con la generazione esterna abilitata, SQL Server esporta i metadati serializzati degli oggetti e avvia il file firmato hkdllgen.exeda Microsoft . HkDllGen valida e importa quei metadati, genera la sorgente C nel proprio processo e avvia compilatore e linker.

Per applicare l'integrità del codice a queste DLL, usa AppLocker per designare hkdllgen.exe firmato da Microsoft come programma di installazione gestito e per abilitare l'attendibilità di Managed Installer nei criteri di App Control for Business, in precedenza Windows Defender Application Control (WDAC). Windows registra quindi che le DLL generate provengono dall'albero di processo HkDllGen, permettendo a App Control di fidarsi di esse in base alla loro origine gestita dall'installatore.

HkDllGen è il primo passo verso il rispetto dei requisiti normativi che includono l'integrità del codice per In-Memory OLTP. In questo scenario, l'integrità del codice garantisce che Windows possa stabilire un'origine affidabile per ogni DLL generata e valutare tale trust quando SQL Server la carica. La DLL generata non è firmata con Authenticode. Windows si fida di esso in base a come è stato creato.

Come funziona un programma di installazione gestito?

Un installatore gestito utilizza una collezione di regole speciali in AppLocker per designare i binari di cui la tua organizzazione si fida come fonte autorizzata per l'installazione delle applicazioni. Quando uno di questi file binari attendibili viene eseguito, Windows monitora il processo del file binario (e tutti i processi figlio che avvia) e controlla la scrittura dei file su disco. Quando vengono scritti i file, un'attestazione o un tag viene aggiunto al file come originato da un programma di installazione gestito.

La rivendicazione di origine è un attributo esteso gestito dal kernel. Non è una firma Authenticode e non cambia lo stato di editore o di firma della DLL generata.

Utilizzando AppLocker, App Control for Business (precedentemente Windows Defender Application Control, o WDAC) può essere configurato per fidarsi dei file installati da un installatore gestito aggiungendo l'opzione Enabled:Managed Installer a una policy di App Control. Quando imposti quell'opzione, App Control controlla le informazioni di origine gestite dell'installatore quando decidi se permettere l'esecuzione di un binario. Se non sono presenti regole di negazione per il file binario, Controllo app consente l'esecuzione esclusivamente in base all'origine del programma di installazione gestito. AppLocker controlla anche l'esecuzione dei file eseguibili che designa come programma di installazione gestito, ma non offre una catena di attendibilità per i file eseguibili e le DLL come WDAC. Questo articolo spiega come designare e configurare il processo HkDllGen come un installatore gestito che sia AppLocker che WDAC possono utilizzare.

Abilitare il generatore di DLL Hekaton

Esempio

Questo esempio abilita il generatore DLL di Hekaton usando sp_configure con l'opzione external xtp dll gen util enabled . Crea un database di test e una tabella ottimizzata per la memoria di test.

1. Creare un database di test.

   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. Creare una tabella di test all'interno del database di test.

   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. Un .gen file viene creato insieme a ogni DLL generata tramite HkDllGen nella <path-to-data-directory>\xtp\<database_id> sottodirectory. Questo file cattura l'output di HkDllGen e normalmente è di lunghezza zero dopo una compilazione riuscita. La sua presenza indica che il generatore esterno è stato attivato. Le DLL generate non sono firmate da Authenticode. Perché Windows possa fidarsi delle DLL generate in base alla loro origine, serve il tracciamento gestito degli installatori e una policy di controllo delle applicazioni.

Le DLL esistenti non ottengono retroattivamente informazioni di origine gestite dall'installatore. Genera una nuova DLL dopo che il tracciamento gestito dell'installatore è attivo durante la convalida della policy.

Passaggi per creare In-Memory OLTP AppLocker e politiche di installazione gestite

Non puoi usare l'interfaccia di creazione di policy di AppLocker nell'editor GPO (gpedit.msc) o i cmdlet PowerShell di AppLocker per creare regole per la raccolta di regole gestita dall'installatore. Tuttavia, puoi utilizzare un editor XML o di testo per convertire una policy di raccolta regole EXE in una collezione di regole gestita per installatori.

Gli esempi rimanenti in questo articolo si applicano a Windows Server 2022 e Windows 11 e versioni successive.

Per verificare che almeno una collezione di regole exe esista all'interno della configurazione delle policy AppLocker Control del server, esegui il seguente comando PowerShell:

Get-AppLockerPolicy -Effective

Oppure, eseguire il seguente comando per salvare l'output delle policy effettive su un file XML per la visualizzazione:

Get-AppLockerPolicy -Effective -Xml > effective_app_policy.xml

I passaggi seguenti spiegano il processo di creazione e applicazione di una policy che puoi applicare a un server locale. Una policy di installatore gestito generata utilizzando questi passaggi può essere fusa in una policy a livello GPO e distribuita a tutte le istanze di SQL Server all'interno di un ambiente, oppure applicata alla policy locale di un singolo server. Dovresti collaborare con un amministratore di dominio per applicare la policy di Integrità del Codice a livello di dominio.

1. Usare New-AppLockerPolicy per creare una regola EXE per il file che hai designato come programma di installazione gestito. Questo esempio crea una regola per il generatore DLL di Hekaton usando il tipo di regola Publisher, ma puoi usare qualsiasi tipo di regola AppLocker. Potrebbe essere necessario riformattare l'output per la leggibilità.

   # 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. Modificare manualmente il AppLocker_HkDllGen_Policy.xml e modificare i valori di attributo seguenti:

   • RuleCollection Type a ManagedInstaller
   • EnforcementMode a AuditOnly
   • BinaryVersionRange LowSection a "*" e HighSection a "*"

   Cambiare:

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

   A:

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

   Cambiare:

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

   A:

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

3. Distribuire i criteri di configurazione del programma di installazione gestito di AppLocker. Puoi importare la policy AppLocker e distribuirla con Group Policy, oppure usare uno script per distribuire la policy con il Set-AppLockerPolicy cmdlet come mostrato nel seguente comando 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. Se distribuisci la policy AppLocker con uno script PowerShell, usa l'utilità appidtel.exe di un prompt dei comandi amministrativo per configurare il servizio Application Identity di AppLocker e il driver di filtro AppLocker.

   appidtel.exe start [-mionly]
   

Abilitare l'opzione del programma di installazione gestito nella Configurazione guidata di controllo applicazioni di Windows Defender per le aziende

Affinché Windows Defender Application Control (WDAC) possa fidarsi delle DLL generate dal hkdllgen.exe processo, specifica l'opzione Abilitato: Managed Installer nella tua policy di App Control. Definisci questa impostazione usando il cmdletSet-RuleOption con l'opzione 13.

Genera un file dei criteri di integrità del codice da uno dei criteri di base del modello di WDAC Base Policy Wizard.

A partire dal criterio di Predefinita di Windows sono disponibili meno opzioni, che vengono rimosse in questa guida. Per ulteriori informazioni sui criteri Default Windows Mode e Allow Microsoft Mode, consulta l'articolo sulle policy di base di esempio di App Control for Business.

Politica del modello di base

Dopo aver selezionato il modello della policy base di Windows, dai un nome alla policy e scegli dove salvare la policy di controllo app sul disco.

Selezionare un tipo di politica

Scegli il Formato di Polizza Multipla e la Politica di Base come tipo di politica.

Configurare il modello di criteri

Abilita solo le opzioni delle regole dei criteri Installer gestito, Aggiornamento dei criteri senza riavvio, Criterio di integrità del sistema non firmato e Integrità del codice in modalità utente. Disabilitare le altre opzioni della regola dei criteri. Per cambiare le impostazioni, seleziona il pulsante cursore accanto ai titoli delle regole politiche.

La tabella seguente descrive ogni regola politica, a partire dalla colonna più a sinistra. L'articolo sulle regole di politica fornisce una descrizione più dettagliata di ciascuna regola di politica.

Devi abilitare inizialmente la modalità di Audit, perché consente di testare i nuovi criteri di Controllo delle App per le Aziende prima di applicarli. Con la modalità audit, nessuna applicazione viene bloccata. Invece, il criterio registra un evento ogni volta che viene avviata un'applicazione non inclusa nel criterio. Per questo motivo, per impostazione predefinita è abilitata la modalità di controllo per tutti i modelli.

Regole del file

Rimuovi tutte le regole di firma dei criteri dall'elenco.

(Opzionale) Aggiungi una regola di permesso Custom Publisher per hkdllgen.exe. Questa regola utilizza le informazioni provenienti dal certificato di firma del codice Microsoft esistente dell'eseguibile per identificare e consentire versioni corrispondenti di HkDllGen.

Il tipo di regola file dell'editore utilizza le proprietà nella catena di certificati di firma del codice per stabilire le regole dei file.

Dopo aver selezionato Crea regola, dovrebbe essere presente un'unica regola di firma dei criteri.

Distribuire la politica di App Control. Vedere Distribuzione dei criteri di App Control for Business.

Dopo la creazione della policy, la nuova policy viene scritta sul percorso scelto come posizione del file della policy. La nuova versione binaria del nome del file policy include la versione della policy alla fine del nome del file. Puoi copiare il <policy>.cip file nella C:\Windows\System32\CodeIntegrity\CiPolicies\Active sottocartella dell'istanza di SQL Server.

Distribuire manualmente un criterio di integrità del codice

Per creare una policy di Integrità del Codice più snella, puoi modificare un file più generico <policy>.xml che generi dopo aver completato il Wizard delle Policy di Controllo App WDAC. Questo scenario può verificarsi se non esegui il Wizard delle Policy di Controllo delle Applicazioni WDAC su un SQL Server, ma da una workstation. Ad esempio, un file di criteri di integrità del codice meno personalizzato potrebbe essere simile al seguente:

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

Questo esempio non ha una regola di editore firmato e presume che il file policy utilizzi una directory di lavoro locale (ad esempio, C:\Temp) con il nome file di 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

Per applicare i criteri senza riavviare il server e controllare lo stato dell'integrità del codice, eseguire questo script di 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*

Verificare che le DLL Hekaton generate siano attendibili secondo l'integrità del codice

Dopo che la regola AppLocker Managed Installer e i servizi AppLocker richiesti sono attivi, genera una nuova DLL OLTP In-Memory tramite HkDllGen. Windows traccia l'albero di processo HkDllGen e aggiunge un $KERNEL.SMARTLOCKER.ORIGINCLAIM attributo esteso ai file creati da quell'albero di processo.

Quando App Control opera in modalità audit o enforcement con Enabled:Managed Installer, Code Integrity può fidarsi della DLL generata in base alla sua origine di installatore gestito. Per verificare che l'attributo esteso sia stato aggiunto, seleziona una nuova DLL generata dalla \Data\xtp\<database_id> cartella ed esegui il seguente comando da un prompt dei comandi elevato:

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

La sola presenza di $KERNEL.SMARTLOCKER.ORIGINCLAIM non conferma che il file abbia un'origine da installatore gestito. Lo stesso attributo esteso può registrare l'origine dell'Intelligent Security Graph e come la fiducia è stata ereditata. Nella prima riga dati, 00 all'inizio della seconda ULONG identifica l'origine del Managed Installer, mentre 01 identifica l'origine del Grafo di Sicurezza Intelligente. Per valutare i restanti valori delle attestazioni di origine, consultare il riferimento tecnico di Managed Installer e ISG.

Rimuovere la funzionalità Del programma di installazione gestito

Per rimuovere la funzione Installatore Gestito dal dispositivo, rimuovere la policy Managed Installer AppLocker dal dispositivo seguendo le istruzioni nella regola Elimina un AppLocker: Cancella le policy AppLocker su un singolo sistema o su sistemi remoti.

Contenuto correlato

• Consenti automaticamente le applicazioni distribuite da un programma di installazione gestito con App Control for Business
• In-Memory panoramica OLTP e scenari di utilizzo
• Guida all'elaborazione di query per le tabelle Memory-Optimized
• Database di esempio per OLTP in memoria
• guida alla distribuzione di AppLocker
• Implementazione dei criteri di controllo delle app aziendali