Ejemplos de Uso

• 1: Flujo de trabajo de análisis de seguridad con SQL Server
• 2: Uso práctico en un entorno de dominio (colección y conversión impulsadas por GPO)
• 3: Ejemplo de tarea programada

1 - Flujo de trabajo de análisis de seguridad con SQL Server

Este ejemplo muestra un flujo de trabajo práctico para análisis de seguridad: analiza un registro de depuración DNS con Convert-DNSDebugLogFile, importa el CSV generado en SQL Server y ejecuta una consulta que resalta volúmenes inusualmente altos de búsquedas de registros TXT.

Para una mejor interoperabilidad, este ejemplo escribe marcas de tiempo en un formato tipo ISO usando -OutputCulture 'sv-SE'.

Módulos requeridos

Este ejemplo utiliza los siguientes módulos de PowerShell:

• DNSServer.DebugLogParser
• SqlServer

Instálalos si es necesario:

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

Escenario

Usa este flujo de trabajo cuando quieras mover datos analizados de registros de depuración DNS a SQL Server para poder:

• buscar grandes conjuntos de datos de forma eficiente
• crear consultas de detección repetibles
• correlacionar actividad en múltiples servidores DNS
• conservar datos normalizados para investigaciones posteriores

Salida del paso de conversión

Convert-DNSDebugLogFile no escribe directamente en SQL Server. Primero crea un archivo CSV. Ese archivo CSV es el conjunto de datos que se importa a la base de datos.

En este ejemplo:

• registro de entrada: C:\Administration\Logs\DNS\dns.log
• CSV generado: C:\Administration\Logs\DNS\dns.csv
• tabla destino: dbo.DNSQueries

Crear la tabla destino

Ejecuta la siguiente instrucción una vez en SQL Server para crear la tabla destino.

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;

Convertir el registro e importar el CSV

El siguiente ejemplo en PowerShell realiza el flujo completo:

1. importa los módulos requeridos
2. convierte el registro de depuración DNS a CSV
3. carga el CSV generado
4. importa masivamente las filas a 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 "El archivo CSV generado '$csvPath' no contiene filas."
}

$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()
}

Consulta para actividad sospechosa en registros TXT

Una vez que los datos están en SQL Server, puedes buscar clientes que realicen un número inusualmente alto de consultas de registros 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;

Si prefieres ejecutar la consulta desde PowerShell, usa Invoke-Sqlcmd del módulo 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

Por qué las consultas TXT son interesantes

Los volúmenes altos de búsquedas de registros TXT pueden valer la pena revisarse porque pueden indicar:

• túneles DNS
• exfiltración de datos por DNS
• abuso de registros TXT por malware o herramientas
• clientes inusualmente ruidosos o mal configurados

Esta consulta es solo un punto de partida. En producción, deberías ajustar el umbral y agregar filtros que se adapten a tu entorno.

Notas operativas

• Import-Csv lee el archivo completo en memoria. Para exportaciones de registros muy grandes, considera un enfoque de streaming en lugar de construir un DataTable completo.
• Mantén -ComputerName en el paso de conversión para que los registros sigan siendo atribuibles después de la ingestión centralizada.
• Usa un delimitador y cultura consistentes durante la exportación e importación.
• Valida la retención, indexación y control de acceso en SQL Server antes de usar este flujo para almacenamiento a largo plazo.

2 - Uso práctico en un entorno de dominio (colección y conversión impulsadas por GPO)

Este documento describe un ejemplo práctico y completo de ejecución de DNSServer.DebugLogParser en un entorno de dominio de Active Directory, centrado en convertir registros de depuración del servidor DNS de Windows en controladores de dominio.

Este ejemplo se acompaña de un archivo ZIP, que proporciona los artefactos de la política usados para implementar el flujo de trabajo descrito aquí.
Los artefactos más relevantes son el manifiesto de respaldo, el informe de GPO, Files.xml, Set-DNSServerDebugLogging.ps1 y ScheduledTasks.xml.

Escenario

• Varios controladores de dominio (DC) alojan el rol de servidor DNS.
• La depuración de DNS está habilitada y configurada de forma consistente en cada DC mediante una tarea programada (escribiendo archivos de registro en C:\Administration\Logs\DNSServer).
• Un proceso gestionado centralmente convierte los registros a CSV para:
  • análisis de seguridad
  • informes operativos
  • solución de problemas
  • cumplimiento/retención

Resultados esperados

• Configuraciones de conversión consistentes en todos los DC
• Ubicación y nombres de salida predecibles
• Compresión opcional para reducir el espacio de almacenamiento
• Salidas estadísticas opcionales para resúmenes diarios rápidos
• Riesgo mínimo en el host, con consideraciones explícitas para reejecución y limpieza

Arquitectura sugerida

Modelo de recopilación: conversión local + extracción central

1. Cada DC escribe los registros de depuración DNS en disco con habilitación de rollover.
2. Cada DC convierte los archivos rotados *.log en un CSV de datos y CSVs de estadísticas, luego comprime las salidas en *.zip según un horario (Programador de tareas).
3. Las salidas se escriben junto a los archivos de registro para mantener la canalización simple.
4. Un servidor central recopila las salidas *.zip, por ejemplo mediante ingestión por recurso compartido de archivos, copia programada, reenvío SIEM o un colector basado en agente.

Este modelo minimiza las lecturas de red de archivos de registro grandes y mantiene el análisis cerca de los datos.

Flujo de trabajo con GPO

El flujo de trabajo se implementa mediante la Directiva de Grupo (configuración del equipo) para asegurar configuraciones consistentes en todos los controladores de dominio.

Implementación de referencia incluida en este repositorio (informe de GPO):

• Nombre del archivo/informe: T0-C-Analytics-DNSDebugLogging
• ID de respaldo: {2B6F16BC-0E7C-4787-83D7-2854FED882EE}
• Destino del enlace GPO: corp.company.com/Domain Controllers
• Filtro de elementos (usado tanto para el despliegue de archivos como para tareas programadas): solo aplica si existe C:\Windows\System32\dns.exe

1) Requisitos previos (carpetas + módulo)

La copia de seguridad proporcionada asume que estas carpetas ya existen. Agrega elementos GPP separados si quieres que el despliegue las cree automáticamente:

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

La copia de seguridad también asume que Convert-DNSDebugLogFile ya está disponible en los DC. La tarea de conversión inicia Windows PowerShell 5.1 con -NoProfile y no importa el módulo explícitamente, por lo que el módulo debe estar instalado en una ruta de módulo de Windows PowerShell a nivel de máquina visible para LocalSystem. Enfoques recomendados:

• Instalar DNSServer.DebugLogParser en los DC. Por ejemplo, desde PowerShell Gallery (si la política lo permite).
• Desplegar el módulo vía repositorio interno / recurso compartido de archivos para que sea detectable en $env:PSModulePath
• Añadir un Import-Module explícito a la acción de la tarea si quieres un comportamiento de carga determinista

2) Desplegar el script de configuración de registro de depuración (GPP Archivos)

La GPO despliega el script:

• Origen (en SYSVOL vía GPP): %GptPath%\Preferences\Files\Set-DNSServerDebugLogging.ps1
• Destino (en cada DC): C:\Administration\Scripts\Set-DNSServerDebugLogging.ps1

Esto está implementado en el elemento de preferencia GPP Archivos en Files.xml.

3) Tarea programada: configurar el registro de depuración DNS

La GPO crea una tarea programada llamada Set-DNSServerDebugLogging.

• Contexto de seguridad en la copia de seguridad suministrada: SYSTEM con tipo de inicio de sesión S4U
• Disparador en la copia de seguridad suministrada: diario (inicio 2025-03-01T00:00:01)
• Acción en ScheduledTasks.xml:
  • powershell.exe -ExecutionPolicy RemoteSigned -command " & { C:\Administration\Scripts\Set-DNSServerDebugLogging.ps1 }"
  • Directorio de trabajo: C:\Administration\Scripts

El script vinculado Set-DNSServerDebugLogging.ps1 configura el registro de depuración DNS mediante Get-DnsServerDiagnostics / Set-DnsServerDiagnostics y (notablemente):

• Habilita el registro en archivo + rollover
• Escribe en: C:\Administration\Logs\DNSServer\DnsDebugLog_<COMPUTERNAME>.<Domain>_.log
• Usa un tamaño de rollover de 10 MB por archivo
• Captura principalmente actividad relacionada con consultas (consultas + notificaciones + actualizaciones + transacciones de preguntas) y excluye el registro completo de paquetes

4) Tarea programada: convertir registros de depuración rotados a CSV comprimido

La GPO crea una tarea programada llamada Convert-DNSDebugLogs.

• Contexto de seguridad en la copia de seguridad suministrada: SYSTEM con tipo de inicio de sesión InteractiveToken
• Disparador en la copia de seguridad suministrada: diario (inicio 2026-01-01T00:30:00)
• Directorio de trabajo: C:\Administration\Logs\DNSServer
• Acción en ScheduledTasks.xml (formateado para legibilidad):

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

Notas de diseño:

• Select-Object -Skip 1 evita intencionadamente procesar el archivo de registro más nuevo (activo).
• Eso significa que los datos actuales solo se exportan después del rollover; en DCs de bajo volumen, el registro activo puede permanecer sin procesar por más de un día.
• Porque Convert-DNSDebugLogFile por defecto usa -OutputFile en “misma carpeta, mismo nombre, .csv”, las salidas quedan junto a las entradas *.log.
• Con -CompressOutput, cada registro procesado produce un *.zip y los CSV intermedios se eliminan.
• A menos que archives o elimines los archivos *.log procesados, ejecuciones posteriores reprocesarán cada registro no activo.
• La tarea falla si $Error.Count -gt 0 para señalar una ejecución fallida.

5) Ingestión central

Opciones (elige una):

• Ingestión por recurso compartido de archivos: el DC escribe (o copia) C:\Administration\Logs\DNSServer\*.zip a \\fileserver\share\dns\$env:COMPUTERNAME\... (otorga permisos de recurso compartido y NTFS a las cuentas de equipo DC o al grupo Domain Controllers si la tarea se ejecuta como SYSTEM)
• Modelo pull: trabajo central lee \\dc\C$\Administration\Logs\DNSServer\*.zip (menos preferido; requiere recursos compartidos administrativos)
• Reenviador agente: SIEM / canalización de registros que envía las salidas *.zip

Consideraciones operativas

• Mínimos privilegios: las tareas se ejecutan como SYSTEM; asegúrate de que las carpetas locales sean escribibles y que cualquier destino UNC otorgue acceso a la cuenta de equipo si se usa.
• Política de firma: ambas tareas usan -ExecutionPolicy RemoteSigned; firma o desbloquea el script y módulo desplegados según tu política.
• Uso de disco: -CompressOutput ayuda significativamente, pero este flujo no elimina los registros fuente; planifica retención y limpieza.
• Comportamiento de reprocesamiento: a menos que archives o elimines registros procesados, la tarea de conversión procesará cada archivo *.log no activo nuevamente en ejecuciones posteriores. Esto es simple y robusto, pero puede sobrescribir salidas y crear ingestiones duplicadas si tu colector no hace deduplicación.
• Consolidación multi-DC: -ComputerName $env:COMPUTERNAME se incluye para que los conjuntos de datos consolidados sean rastreables.
• Validación: la validación de encabezado permanece habilitada porque la tarea no usa -SkipHeaderValidation (recomendado).

Validar y adaptar (usando el ZIP)

Usa el archivo ZIP como implementación de referencia, luego ajusta los siguientes aspectos a tu entorno:

• Alcance objetivo: qué DCs / UOs reciben la política
• Identidad de ejecución: confirma que ambas tareas programadas usan el tipo de inicio de sesión previsto (S4U vs InteractiveToken) o normalízalos a tu estándar
• Creación de carpetas: decide si C:\Administration\Scripts y C:\Administration\Logs\DNSServer se preconfiguran en otro lugar o deben crearse con elementos GPP adicionales
• Rutas: confirma que C:\Administration\Scripts y C:\Administration\Logs\DNSServer coinciden con tus estándares
• Retención: decide si conservar los registros sin procesar y por cuánto tiempo (especialmente si habilitas opciones de limpieza)
• Ingestión: confirma dónde se escriben las salidas CSV/ZIP y cómo se recopilan centralmente

Si quieres validar la configuración exacta de la GPO sin importarla, las fuentes autorizadas en este repositorio son:

• manifest.xml para metadatos de respaldo
• gpreport.xml para el informe completo legible
• Files.xml para despliegue de archivos
• Set-DNSServerDebugLogging.ps1 para contenido del script
• ScheduledTasks.xml para tareas programadas

3 - Ejemplo de tarea programada

Este script crea una tarea programada de Windows que se ejecuta diariamente a las 2:00 AM. Importa el módulo y procesa todos los archivos de registro en la carpeta donde se ejecuta el script (en este ejemplo “C:\Administration\Logs\DNS”). El proceso comprime la salida en archivos ZIP y elimina el original para mantener la limpieza.

$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"