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 la conversión de 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 manifest.xml de respaldo, el informe GPO, Files.xml, Set-DNSServerDebugLogging.ps1 y ScheduledTasks.xml.

Escenario

• Varios controladores de dominio (DC) alojan el rol de servidor DNS.
• El registro de depuración DNS está habilitado y configurado de forma coherente 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
  • resolución de problemas
  • cumplimiento/retención

Resultados esperados

• Configuraciones de conversión coherentes 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 de 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 activación de rollover.
2. Cada DC convierte los archivos *.log rotados 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, reenviador SIEM o un colector basado en agente.

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

Flujo de trabajo GPO

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

Implementación de referencia incluida en este repositorio (informe 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 despliegue de archivos como para tareas programadas): solo se aplica si existe C:\Windows\System32\dns.exe

1) Requisitos previos (carpetas + módulo)

El respaldo proporcionado asume que estas carpetas ya existen. Añade elementos GPP separados si quieres que el despliegue las cree automáticamente:

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

El respaldo 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 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 se implementa 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 el respaldo suministrado: SYSTEM con tipo de inicio de sesión S4U
• Disparador en el respaldo suministrado: 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 el respaldo suministrado: SYSTEM con tipo de inicio de sesión InteractiveToken
• Disparador en el respaldo suministrado: 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). Convert-DNSDebugLogFile puede leer un registro que el servidor DNS tiene abierto actualmente, pero ese archivo cambia mientras se lee: la salida puede perder las entradas más nuevas o terminar con un registro truncado, y dos ejecuciones no producen resultados idénticos. Omitir el archivo activo mantiene la salida programada reproducible.
• 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. Reduce el tamaño de rollover si ese retraso es demasiado largo para tu caso de uso.
• Como 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 lanza error si $Error.Count -gt 0 para señalar una ejecución fallida.

5) Ingesta central

Opciones (elige una):

• Ingesta por recurso compartido de archivos: el DC escribe (o copia) C:\Administration\Logs\DNSServer\*.zip a \\fileserver\share\dns\$env:COMPUTERNAME\... (concede 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ínimo privilegio: las tareas se ejecutan como SYSTEM; asegúrate de que las carpetas locales sean escribibles y que cualquier destino UNC conceda 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 los 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 aguas abajo si tu colector no deduplica.
• Consolidación multi-DC: -ComputerName $env:COMPUTERNAME se incluye para que los conjuntos de datos consolidados sigan siendo rastreables. Ten en cuenta que -ComputerName solo etiqueta la salida — no realiza conexión remota.
• Recursos compartidos de red: Convert-DNSDebugLogFile puede leer registros fuente desde rutas SMB/UNC, pero convertir localmente y enviar los resultados comprimidos sigue siendo el mejor patrón para registros sin procesar grandes. Si usas una ruta UNC, recuerda que una tarea ejecutándose como SYSTEM se autentica en la red como la cuenta de equipo y necesita permisos de recurso compartido y NTFS allí.
• Formato de fecha: -OutputCulture sv-SE se usa deliberadamente para que las marcas de tiempo se escriban como 2026-01-20 23:00:16. Ese formato es leído sin indicación por SQL Server, Power BI y la mayoría de herramientas de importación, independientemente de la configuración regional del DC que produjo el registro.
• Validación: la validación del 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 alinea 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 cumplen con tus estándares
• Retención: decide si conservar los registros sin procesar y por cuánto tiempo (especialmente si habilitas opciones de limpieza)
• Ingesta: 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"