Esempi di utilizzo

• 1: Flusso di lavoro per l'analisi della sicurezza con SQL Server
• 2: Esempio di Attività Pianificata
• 3: Utilizzo pratico in un ambiente di dominio (raccolta e conversione guidate da GPO)

1 - Flusso di lavoro per l'analisi della sicurezza con SQL Server

Questo esempio mostra un flusso di lavoro pratico per l’analisi della sicurezza: analizza un log di debug DNS con Convert-DNSDebugLogFile, importa il CSV generato in SQL Server ed esegui una query che evidenzia volumi insolitamente alti di interrogazioni a record TXT.

Per la migliore interoperabilità, questo esempio scrive i timestamp in un formato simile all’ISO usando -OutputCulture 'sv-SE'.

Moduli richiesti

Questo esempio utilizza i seguenti moduli PowerShell:

• DNSServer.DebugLogParser
• SqlServer

Installali se necessario:

Install-Module -Name DNSServer.DebugLogParser -Scope CurrentUser
Install-Module -Name SqlServer -Scope CurrentUser

Scenario

Usa questo flusso di lavoro quando vuoi spostare i dati del log di debug DNS analizzati in SQL Server per poter:

• cercare grandi dataset in modo efficiente
• costruire query di rilevamento ripetibili
• correlare attività tra più server DNS
• conservare dati normalizzati per indagini successive

Output del passaggio di conversione

Convert-DNSDebugLogFile non scrive direttamente in SQL Server. Prima crea un file CSV. Quel file CSV è il dataset importato nel database.

In questo esempio:

• log di input: C:\Administration\Logs\DNS\dns.log
• CSV generato: C:\Administration\Logs\DNS\dns.csv
• tabella di destinazione: dbo.DNSQueries

Creare la tabella di destinazione

Esegui la seguente istruzione una volta in SQL Server per creare la tabella di destinazione.

IF OBJECT_ID('dbo.DNSQueries', 'U') IS NULL
BEGIN
    CREATE TABLE dbo.DNSQueries (
        DateTime      datetime2(0)   NOT NULL,
        ThreadId      int            NULL,
        Context       nvarchar(20)   NULL,
        PacketId      int            NULL,
        Protocol      nvarchar(10)   NULL,
        Direction     nvarchar(10)   NULL,
        ClientIP      nvarchar(64)   NULL,
        Xid           nvarchar(16)   NULL,
        Type          nvarchar(16)   NULL,
        Opcode        nvarchar(16)   NULL,
        FlagsHex      nvarchar(16)   NULL,
        FlagsChar     nvarchar(16)   NULL,
        ResponseCode  nvarchar(32)   NULL,
        QuestionType  nvarchar(32)   NULL,
        QuestionName  nvarchar(512)  NULL,
        Information   nvarchar(max)  NULL,
        Details       nvarchar(max)  NULL,
        ComputerName  nvarchar(256)  NULL
    );
END;

Convertire il log e importare il CSV

Il seguente esempio PowerShell esegue l’intero flusso di lavoro:

1. importa i moduli richiesti
2. converte il log di debug DNS in CSV
3. carica il CSV generato
4. importa in blocco le righe in SQL Server

# Requires -Modules DNSServer.DebugLogParser, SqlServer

Import-Module -Name DNSServer.DebugLogParser -ErrorAction Stop
Import-Module -Name SqlServer -ErrorAction Stop

$logPath = 'C:\Administration\Logs\DNS\dns.log'
$csvPath = 'C:\Administration\Logs\DNS\dns.csv'
$serverInstance = 'SQLServer'
$databaseName = 'DNSLogs'
$delimiter = ';'

$createTableSql = @'
IF OBJECT_ID('dbo.DNSQueries', 'U') IS NULL
BEGIN
    CREATE TABLE dbo.DNSQueries (
        DateTime      datetime2(0)   NOT NULL,
        ThreadId      int            NULL,
        Context       nvarchar(20)   NULL,
        PacketId      int            NULL,
        Protocol      nvarchar(10)   NULL,
        Direction     nvarchar(10)   NULL,
        ClientIP      nvarchar(64)   NULL,
        Xid           nvarchar(16)   NULL,
        Type          nvarchar(16)   NULL,
        Opcode        nvarchar(16)   NULL,
        FlagsHex      nvarchar(16)   NULL,
        FlagsChar     nvarchar(16)   NULL,
        ResponseCode  nvarchar(32)   NULL,
        QuestionType  nvarchar(32)   NULL,
        QuestionName  nvarchar(512)  NULL,
        Information   nvarchar(max)  NULL,
        Details       nvarchar(max)  NULL,
        ComputerName  nvarchar(256)  NULL
    );
END
'@

Convert-DNSDebugLogFile `
    -InputFile $logPath `
    -ComputerName 'DNS01' `
    -OutputType CSV `
    -OutputFile $csvPath `
    -Delimiter $delimiter `
    -OutputCulture 'sv-SE'

$rows = Import-Csv -Path $csvPath -Delimiter $delimiter

if (-not $rows) {
    throw "Il file CSV generato '$csvPath' non contiene righe."
}

$dataTable = [System.Data.DataTable]::new()
foreach ($columnName in $rows[0].PSObject.Properties.Name) {
    $null = $dataTable.Columns.Add($columnName, [string])
}

foreach ($row in $rows) {
    $dataRow = $dataTable.NewRow()
    foreach ($column in $dataTable.Columns) {
        $columnName = $column.ColumnName
        $dataRow[$columnName] = $row.$columnName
    }

    $null = $dataTable.Rows.Add($dataRow)
}

$connectionString = "Server=$serverInstance;Database=$databaseName;Integrated Security=True"
$connection = [System.Data.SqlClient.SqlConnection]::new($connectionString)

try {
    $connection.Open()

    $command = $connection.CreateCommand()
    $command.CommandText = $createTableSql
    $null = $command.ExecuteNonQuery()

    $bulkCopy = [System.Data.SqlClient.SqlBulkCopy]::new($connection)
    $bulkCopy.DestinationTableName = 'dbo.DNSQueries'

    foreach ($column in $dataTable.Columns) {
        $null = $bulkCopy.ColumnMappings.Add($column.ColumnName, $column.ColumnName)
    }

    $bulkCopy.WriteToServer($dataTable)
}
finally {
    $connection.Dispose()
}

Query per attività sospette sui record TXT

Una volta che i dati sono in SQL Server, puoi cercare i client che effettuano un numero insolitamente alto di query ai record TXT.

SELECT
    ComputerName,
    ClientIP,
    QuestionName,
    COUNT(*) AS QueryCount
FROM dbo.DNSQueries
WHERE QuestionType = 'TXT'
GROUP BY
    ComputerName,
    ClientIP,
    QuestionName
HAVING COUNT(*) > 100
ORDER BY QueryCount DESC;

Se preferisci eseguire la query da PowerShell, usa Invoke-Sqlcmd dal modulo SqlServer:

$query = @'
SELECT
    ComputerName,
    ClientIP,
    QuestionName,
    COUNT(*) AS QueryCount
FROM dbo.DNSQueries
WHERE QuestionType = 'TXT'
GROUP BY
    ComputerName,
    ClientIP,
    QuestionName
HAVING COUNT(*) > 100
ORDER BY QueryCount DESC;
'@

Invoke-Sqlcmd `
    -ServerInstance 'SQLServer' `
    -Database 'DNSLogs' `
    -Query $query

Perché le query TXT sono interessanti

Volumi elevati di interrogazioni ai record TXT possono valere la pena di essere esaminati perché potrebbero indicare:

• tunneling DNS
• esfiltrazione di dati tramite DNS
• abuso dei record TXT da parte di malware o strumenti
• client insolitamente rumorosi o mal configurati

Questa query è solo un punto di partenza. In produzione, dovresti regolare la soglia e aggiungere filtri che si adattino al tuo ambiente.

Note operative

• Import-Csv carica l’intero file in memoria. Per esportazioni di log molto grandi, considera un approccio in streaming invece di costruire un intero DataTable.
• Mantieni -ComputerName nel passaggio di conversione così i record rimangono attribuibili dopo l’ingestione centralizzata.
• Usa un delimitatore e una cultura coerenti durante esportazione e importazione.
• Valida la conservazione, l’indicizzazione e il controllo degli accessi in SQL Server prima di usare questo flusso di lavoro per l’archiviazione a lungo termine.

2 - Esempio di Attività Pianificata

Questo script crea un’attività pianificata di Windows che viene eseguita ogni giorno alle 2:00 AM. Importa il modulo ed elabora tutti i file di log nella cartella in cui viene eseguito lo script (in questo esempio “C:\Administration\Logs\DNS”). Il processo comprime l’output in file ZIP e rimuove l’originale per mantenere l’ordine.

$actionParams = @{
    Execute = "powershell.exe"
    Argument = '-ExecutionPolicy RemoteSigned -Command "Import-Module DNSServer.DebugLogParser; Get-ChildItem .\*.log | Sort-Object lastwritetime, Name -Descending | Convert-DNSDebugLogFile -ComputerName $env:COMPUTERNAME -Delimiter \";\" -OutputType Both -ContextFilter Packet -OutputCulture sv-SE -CompressOutput"'
    WorkingDirectory = "C:\Administration\Logs\DNS"
}
$Action = New-ScheduledTaskAction @actionParams

$Trigger = New-ScheduledTaskTrigger -Daily -At "2:00AM"

Register-ScheduledTask -TaskName "Process DNS Logs" -Action $Action -Trigger $Trigger -Description "Convert DNS debug logs to CSV daily"

3 - Utilizzo pratico in un ambiente di dominio (raccolta e conversione guidate da GPO)

Questo documento descrive un esempio pratico e completo di esecuzione di DNSServer.DebugLogParser in un ambiente di dominio Active Directory, focalizzato sulla conversione dei log di debug del server DNS di Windows sui controller di dominio.

Questo esempio è accompagnato da un archivio ZIP, che fornisce gli artefatti della policy utilizzati per implementare il flusso di lavoro descritto qui.
Gli artefatti più rilevanti sono il manifest di backup, il report GPO, Files.xml, Set-DNSServerDebugLogging.ps1 e ScheduledTasks.xml.

Scenario

• Diversi controller di dominio (DC) ospitano il ruolo DNS Server.
• Il debug logging DNS è abilitato e configurato in modo coerente su ogni DC tramite un’attività pianificata (scrivendo i file di log in C:\Administration\Logs\DNSServer).
• Un processo gestito centralmente converte i log in CSV per:
  • analisi di sicurezza
  • report operativi
  • risoluzione dei problemi
  • conformità/retention

Risultati attesi

• Impostazioni di conversione coerenti su tutti i DC
• Posizione e denominazione dell’output prevedibili
• Compressione opzionale per ridurre lo spazio di archiviazione
• Output statistici opzionali per riepiloghi giornalieri rapidi
• Rischio minimo lato host, con considerazioni esplicite su riesecuzione e pulizia

Architettura suggerita

Modello di raccolta: conversione locale + raccolta centrale

1. Ogni DC scrive i log di debug DNS su disco con rollover abilitato.
2. Ogni DC converte i file *.log ruotati in un CSV dati e CSV statistici, quindi comprime gli output in *.zip secondo una pianificazione (Utilità di pianificazione).
3. Gli output sono scritti accanto ai file di log per mantenere semplice la pipeline.
4. Un server centrale raccoglie gli output *.zip, ad esempio tramite ingestione da condivisione file, copia pianificata, forwarder SIEM o un collector basato su agent.

Questo modello minimizza le letture di rete di grandi file di log grezzi e mantiene il parsing vicino ai dati.

Flusso di lavoro GPO

Il flusso di lavoro è implementato tramite Group Policy (configurazione computer) per garantire impostazioni coerenti su tutti i controller di dominio.

Implementazione di riferimento inclusa in questo repository (report GPO):

• Nome archivio/report: T0-C-Analytics-DNSDebugLogging
• ID backup: {2B6F16BC-0E7C-4787-83D7-2854FED882EE}
• Target link GPO: corp.company.com/Domain Controllers
• Filtro elementi (usato sia per il deployment file che per le attività pianificate): si applica solo se esiste C:\Windows\System32\dns.exe

1) Prerequisiti (cartelle + modulo)

Il backup fornito assume che queste cartelle esistano già. Aggiungi elementi GPP separati se vuoi che il deployment le crei automaticamente:

• C:\Administration\Scripts
• C:\Administration\Logs\DNSServer

Il backup fornito assume anche che Convert-DNSDebugLogFile sia già disponibile sui DC. L’attività di conversione avvia Windows PowerShell 5.1 con -NoProfile e non importa esplicitamente il modulo, quindi il modulo deve essere installato in un percorso modulo PowerShell a livello macchina visibile a LocalSystem. Approcci consigliati:

• Installa DNSServer.DebugLogParser sui DC. Ad esempio, da PowerShell Gallery (se la policy lo consente).
• Distribuisci il modulo tramite repo interno / condivisione file in modo che sia rilevabile in $env:PSModulePath
• Aggiungi un esplicito Import-Module all’azione dell’attività se vuoi un caricamento deterministico

2) Distribuire lo script di configurazione del debug logging (GPP Files)

La GPO distribuisce lo script:

• Sorgente (in SYSVOL tramite GPP): %GptPath%\Preferences\Files\Set-DNSServerDebugLogging.ps1
• Destinazione (su ogni DC): C:\Administration\Scripts\Set-DNSServerDebugLogging.ps1

Questo è implementato nell’elemento preferenze GPP Files in Files.xml.

3) Attività pianificata: configurare il debug logging DNS

La GPO crea un’attività pianificata chiamata Set-DNSServerDebugLogging.

• Contesto di sicurezza nel backup fornito: SYSTEM con tipo di accesso S4U
• Trigger nel backup fornito: giornaliero (inizio 2025-03-01T00:00:01)
• Azione in ScheduledTasks.xml:
  • powershell.exe -ExecutionPolicy RemoteSigned -command " & { C:\Administration\Scripts\Set-DNSServerDebugLogging.ps1 }"
  • Directory di lavoro: C:\Administration\Scripts

Lo script Set-DNSServerDebugLogging.ps1 configura il debug logging DNS tramite Get-DnsServerDiagnostics / Set-DnsServerDiagnostics e (in particolare):

• Abilita il logging su file + rollover
• Scrive in: C:\Administration\Logs\DNSServer\DnsDebugLog_<COMPUTERNAME>.<Domain>_.log
• Usa una dimensione di rollover di 10 MB per file
• Cattura principalmente attività correlate a query (query + notifiche + aggiornamenti + transazioni di domanda) ed esclude il logging completo dei pacchetti

4) Attività pianificata: convertire i log di debug ruotati in CSV compressi

La GPO crea un’attività pianificata chiamata Convert-DNSDebugLogs.

• Contesto di sicurezza nel backup fornito: SYSTEM con tipo di accesso InteractiveToken
• Trigger nel backup fornito: giornaliero (inizio 2026-01-01T00:30:00)
• Directory di lavoro: C:\Administration\Logs\DNSServer
• Azione in ScheduledTasks.xml (formattata per leggibilità):

Get-ChildItem .\*.log |
  Sort-Object lastwritetime, Name -Descending |
  Select-Object -Skip 1 |
  Convert-DNSDebugLogFile `
    -ComputerName $env:COMPUTERNAME `
    -Delimiter ';' `
    -OutputType Both `
    -ContextFilter Packet `
    -OutputCulture sv-SE `
    -CompressOutput

Note di progettazione:

• Select-Object -Skip 1 evita intenzionalmente di processare il file di log più recente (attivo).
• Ciò significa che i dati correnti vengono esportati solo dopo il rollover; su DC a basso volume, il log attivo può rimanere non processato per più di un giorno.
• Poiché Convert-DNSDebugLogFile imposta di default -OutputFile su “stessa cartella, stesso nome, .csv”, gli output vengono creati accanto agli input *.log.
• Con -CompressOutput, ogni log processato produce un *.zip e i CSV intermedi vengono rimossi.
• A meno che non si archivino o eliminino i file *.log processati, le esecuzioni successive rielaboreranno ogni log non attivo.
• L’attività genera un errore se $Error.Count -gt 0 per segnalare un’esecuzione fallita.

5) Ingestione centrale

Opzioni (scegli una):

• Ingestione da condivisione file: il DC scrive (o copia) C:\Administration\Logs\DNSServer\*.zip in \\fileserver\share\dns\$env:COMPUTERNAME\... (concedi diritti di condivisione e NTFS agli account computer DC o al gruppo Domain Controllers se l’attività gira come SYSTEM)
• Modello pull: un job centrale legge \\dc\C$\Administration\Logs\DNSServer\*.zip (meno preferito; richiede condivisioni amministrative)
• Forwarder agent: SIEM / pipeline di log che spedisce gli output *.zip

Considerazioni operative

• Minimo privilegio: le attività girano come SYSTEM; assicurati che le cartelle locali siano scrivibili e che eventuali destinazioni UNC concedano accesso all’account computer se usate.
• Policy di firma: entrambe le attività usano -ExecutionPolicy RemoteSigned; firma o sblocca lo script e il modulo distribuiti secondo la tua policy.
• Utilizzo disco: -CompressOutput aiuta significativamente, ma questo flusso di lavoro non rimuove i log sorgente; pianifica retention e pulizia.
• Comportamento di rielaborazione: a meno che non si archivino o eliminino i log processati, l’attività di conversione processerà ogni file *.log non attivo di nuovo nelle esecuzioni successive. È semplice e robusto, ma può sovrascrivere output e creare duplicati a valle se il collector non fa deduplicazione.
• Consolidamento multi-DC: -ComputerName $env:COMPUTERNAME è incluso per mantenere tracciabilità nei dataset consolidati.
• Validazione: la validazione dell’intestazione rimane abilitata perché l’attività non usa -SkipHeaderValidation (consigliato).

Validare e adattare (usando lo ZIP)

Usa l’archivio ZIP come implementazione di riferimento, quindi allinea i seguenti aspetti al tuo ambiente:

• Ambito target: quali DC / OU ricevono la policy
• Identità di esecuzione: conferma che entrambe le attività pianificate usino il tipo di accesso previsto (S4U vs InteractiveToken) o normalizzali al tuo standard
• Creazione cartelle: decidi se C:\Administration\Scripts e C:\Administration\Logs\DNSServer sono pre-creati altrove o devono essere creati da ulteriori elementi GPP
• Percorsi: conferma che C:\Administration\Scripts e C:\Administration\Logs\DNSServer corrispondano ai tuoi standard
• Retention: decidi se mantenere i log grezzi e per quanto tempo (specialmente se abiliti opzioni di pulizia)
• Ingestione: conferma dove vengono scritti gli output CSV/ZIP e come vengono raccolti centralmente

Se vuoi validare la configurazione GPO esatta senza importarla, le fonti autorevoli in questo repo sono:

• manifest.xml per i metadati di backup
• gpreport.xml per il report completo leggibile
• Files.xml per il deployment file
• Set-DNSServerDebugLogging.ps1 per il contenuto script
• ScheduledTasks.xml per le attività pianificate