Cómo buscar en la caché DNS de forma eficaz con PowerShell: una guía completa

En el mundo interconectado de hoy en día, los profesionales de TI a menudo tienen que investigar y gestionar diversos problemas relacionados con la red. Uno de los aspectos críticos de la solución de problemas de red consiste en comprender las consultas DNS (Sistema de Nombres de Dominio) y resolver los problemas relacionados con estas.

El DNS es el protocolo responsable de traducir los nombres de dominio en direcciones IP que los ordenadores utilizan para comunicarse entre sí. En este contexto, buscar registros específicos en la caché DNS puede ser una tarea esencial para los administradores de red y los proveedores de servicios gestionados (MSP).

Este post profundizará en un script PowerShell diseñado para buscar en la caché DNS nombres de registros que coincidan con palabras clave especificadas. Exploraremos su contexto, cómo funciona, sus aplicaciones en el mundo real y por qué es una herramienta inestimable para los profesionales de TI.

La importancia de la gestión de la caché DNS

Antes de centrarnos en el script, es crucial comprender la importancia de la gestión de la caché DNS. La caché DNS es una base de datos temporal mantenida por el sistema operativo que almacena registros de todas las visitas recientes e intentos de visita a sitios web y otros dominios de Internet. Esta caché permite un acceso más rápido a los sitios visitados con frecuencia al reducir la necesidad de búsquedas DNS repetidas, lo que aumenta la eficacia de la navegación.

Sin embargo, a veces esta caché puede contener registros obsoletos o incorrectos, lo que puede provocar problemas de acceso al sitio web o vulnerabilidades de seguridad. Aquí es donde la capacidad de buscar y gestionar la caché DNS se vuelve vital. El script del que hablaremos hoy proporciona una forma simplificada de buscar y analizar registros de caché DNS, lo que lo convierte en una herramienta indispensable para los profesionales de TI.

El script para buscar en la caché DNS

#Requires -Version 5.1

<#
.SYNOPSIS
    Search for DNS cache record names that match the specified keywords.
.DESCRIPTION
    Search for DNS cache record names that match the specified keywords.
    The DNS cache is a temporary database maintained by the operating system that contains records of all the recent visits and attempted visits to websites and other internet domains.
    This script searches the DNS cache for record names that match the specified keywords and outputs the results to the Activity Feed.
    Optionally, the results can be saved to a multiline custom field.

PARAMETER: -Keywords "ExampleInput"
    Comma separated list of keywords to search for in the DNS cache.
.EXAMPLE
    -Keywords "arpa"
    ## EXAMPLE OUTPUT WITH Keywords ##
    Entry: 1.80.19.172.in-addr.arpa, Record Name: 1.80.19.172.in-addr.arpa., Record Type: 12, Data: test.mshome.net, TTL: 598963

PARAMETER: -Keywords "arpa,mshome" -MultilineCustomField "ReplaceMeWithAnyMultilineCustomField"
    The name of the multiline custom field to save the results to.
.EXAMPLE
    -Keywords "arpa,mshome" -MultilineCustomField "ReplaceMeWithAnyMultilineCustomField"
    ## EXAMPLE OUTPUT WITH MultilineCustomField ##
    Entry: 1.80.19.172.in-addr.arpa, Record Name: 1.80.19.172.in-addr.arpa., Record Type: 12, Data: test.mshome.net, TTL: 598963
    Entry: test.mshome.net, Record Name: test.mshome.net., Record Type: 1, Data: 172.19.80.1, TTL: 598963

.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://ninjastage2.wpengine.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#>

[CmdletBinding()]
param (
    [Parameter()]
    [String[]]$Keywords,
    [Parameter()]
    [String]$MultilineCustomField
)

begin {
    $ExitCode = 0
    function Set-NinjaProperty {
        [CmdletBinding()]
        Param(
            [Parameter(Mandatory = $True)]
            [String]$Name,
            [Parameter()]
            [String]$Type,
            [Parameter(Mandatory = $True, ValueFromPipeline = $True)]
            $Value,
            [Parameter()]
            [String]$DocumentName
        )
    
        $Characters = $Value | Measure-Object -Character | Select-Object -ExpandProperty Characters
        if ($Characters -ge 10000) {
            throw [System.ArgumentOutOfRangeException]::New("Character limit exceeded, value is greater than 10,000 characters.")
        }
        
        # If we're requested to set the field value for a Ninja document we'll specify it here.
        $DocumentationParams = @{}
        if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }
        
        # This is a list of valid fields that can be set. If no type is given, it will be assumed that the input doesn't need to be changed.
        $ValidFields = "Attachment", "Checkbox", "Date", "Date or Date Time", "Decimal", "Dropdown", "Email", "Integer", "IP Address", "MultiLine", "MultiSelect", "Phone", "Secure", "Text", "Time", "URL", "WYSIWYG"
        if ($Type -and $ValidFields -notcontains $Type) { Write-Warning "$Type is an invalid type! Please check here for valid types. https://ninjarmm.zendesk.com/hc/en-us/articles/16973443979789-Command-Line-Interface-CLI-Supported-Fields-and-Functionality" }
        
        # The field below requires additional information to be set
        $NeedsOptions = "Dropdown"
        if ($DocumentName) {
            if ($NeedsOptions -contains $Type) {
                # We'll redirect the error output to the success stream to make it easier to error out if nothing was found or something else went wrong.
                $NinjaPropertyOptions = Ninja-Property-Docs-Options -AttributeName $Name @DocumentationParams 2>&1
            }
        }
        else {
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Options -Name $Name 2>&1
            }
        }
        
        # If an error is received it will have an exception property, the function will exit with that error information.
        if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }
        
        # The below type's require values not typically given in order to be set. The below code will convert whatever we're given into a format ninjarmm-cli supports.
        switch ($Type) {
            "Checkbox" {
                # While it's highly likely we were given a value like "True" or a boolean datatype it's better to be safe than sorry.
                $NinjaValue = [System.Convert]::ToBoolean($Value)
            }
            "Date or Date Time" {
                # Ninjarmm-cli expects the GUID of the option to be selected. Therefore, the given value will be matched with a GUID.
                $Date = (Get-Date $Value).ToUniversalTime()
                $TimeSpan = New-TimeSpan (Get-Date "1970-01-01 00:00:00") $Date
                $NinjaValue = $TimeSpan.TotalSeconds
            }
            "Dropdown" {
                # Ninjarmm-cli is expecting the guid of the option we're trying to select. So we'll match up the value we were given with a guid.
                $Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
                $Selection = $Options | Where-Object { $_.Name -eq $Value } | Select-Object -ExpandProperty GUID
        
                if (-not $Selection) {
                    throw [System.ArgumentOutOfRangeException]::New("Value is not present in dropdown")
                }
        
                $NinjaValue = $Selection
            }
            default {
                # All the other types shouldn't require additional work on the input.
                $NinjaValue = $Value
            }
        }
        
        # We'll need to set the field differently depending on if its a field in a Ninja Document or not.
        if ($DocumentName) {
            $CustomField = Ninja-Property-Docs-Set -AttributeName $Name -AttributeValue $NinjaValue @DocumentationParams 2>&1
        }
        else {
            $CustomField = Ninja-Property-Set -Name $Name -Value $NinjaValue 2>&1
        }
        
        if ($CustomField.Exception) {
            throw $CustomField
        }
    }
}
process {
    # Get the keywords to search for in the DNS cache
    $Keywords = if ($env:keywordsToSearch -and $env:keywordsToSearch -ne "null") {
        $env:keywordsToSearch -split "," | ForEach-Object { $_.Trim() }
    }
    else {
        $Keywords -split "," | ForEach-Object { $_.Trim() }
    }
    $Keywords = if ($Keywords -and $Keywords -ne "null") {
        $Keywords | ForEach-Object {
            Write-Host "[Info] Searching for DNS Cache Records Matching: $_"
            Write-Output "*$_*"
        }
    }
    else {
        # Exit if Keywords is empty
        Write-Host "[Error] No Keywords Provided"
        $ExitCode = 1
        exit $ExitCode
    }
    # Get the multiline custom field to save the results to
    $MultilineCustomField = if ($env:multilineCustomField -and $env:multilineCustomField -ne "null") {
        $env:multilineCustomField -split "," | ForEach-Object { $_.Trim() }
    }
    else {
        $MultilineCustomField -split "," | ForEach-Object { $_.Trim() }
    }

    Write-Host ""

    # Get the DNS cache entries that match the keywords
    $DnsCache = Get-DnsClientCache -Name $Keywords | Select-Object -Property Entry, Name, Type, Data, TimeToLive

    if ($null -eq $DnsCache) {
        Write-Host "[Warn] No DNS Cache Entries Found"
    }
    else {
        # Format the DNS cache entries
        $Results = $DnsCache | ForEach-Object {
            "Entry: $($_.Entry), Record Name: $($_.Name), Record Type: $($_.Type), Data: $($_.Data), TTL: $($_.TimeToLive)"
        }
        Write-Host "[Info] DNS Cache Entries Found"
        # Save the results to a multiline custom field if specified
        if ($MultilineCustomField -and $MultilineCustomField -ne "null") {
            Write-Host "[Info] Attempting to set Custom Field '$MultilineCustomField'."
            try {
                Set-NinjaProperty -Name $MultilineCustomField -Value $($Results | Out-String)
                Write-Host "[Info] Successfully set Custom Field '$MultilineCustomField'!"
            }
            catch {
                Write-Host "[Warn] Failed to set Custom Field '$MultilineCustomField'."
                $Results | Out-String | Write-Host
            }
        }
        else {
            # Output the results to the Activity Feed
            $Results | Out-String | Write-Host
        }
    }
    exit $ExitCode
}
end {
    
    
    
}

 

Desglose detallado del script

Vamos a desglosar el script para entender cómo funciona y la funcionalidad que ofrece.

1. Inicialización del script:

• El script comienza configurando parámetros que permiten a los usuarios especificar palabras clave para buscar en la caché DNS. Estas palabras clave se introducen como una lista separada por comas.
• Un parámetro opcional permite a los usuarios guardar los resultados en un campo personalizado multilínea. Esto es especialmente útil para fines de registro y documentación.

2. Tratamiento de palabras clave:

• El script procesa las palabras clave proporcionadas, asegurándose de que están formateadas correctamente para la operación de búsqueda. Si no se proporcionan palabras clave, el script saldrá con un error, asegurándose de que los usuarios son conscientes de la entrada que falta.

3. Recuperación de caché DNS:

• El núcleo del script consiste en recuperar las entradas de la caché DNS mediante el cmdlet Get-DnsClientCache. Este cmdlet obtiene los registros DNS de la caché local que coinciden con las palabras clave especificadas.
• A continuación, los resultados se formatean para mostrar la entrada, el nombre del registro, el tipo de registro, los datos y el tiempo de vida (TTL) de cada registro DNS encontrado.

4. Gestión del output:

• Si se especifica el campo personalizado multilínea opcional, el script intenta guardar los resultados en este campo utilizando una función personalizada llamada Set-NinjaProperty. Esta función maneja varios tipos de datos de entrada y garantiza que el campo se actualice correctamente.
• Si no se especifica el campo personalizado, los resultados se envían simplemente al feed de actividad, lo que permite una revisión y un análisis rápidos.

Casos de uso concretos

Para ilustrar la utilidad de este script, imagínate a un profesional de TI que está solucionando un problema de red para un cliente, que informa de problemas intermitentes de conectividad con determinados sitios web. El profesional de TI sospecha que las entradas de caché DNS obsoletas o incorrectas pueden estar causando el problema.

Con este script PowerShell, el profesional de TI puede buscar rápidamente en la caché DNS cualquier registro relacionado con los sitios web problemáticos. Al identificar estos registros, puede determinar si es necesario limpiar la caché DNS o actualizar entradas específicas. Este enfoque selectivo ahorra tiempo y garantiza que los problemas de red del cliente se resuelvan con eficacia.

Comparación con otros métodos

Este script PowerShell proporciona un enfoque más automatizado y personalizable para buscar en la caché DNS en comparación con otros métodos manuales. Aunque es posible inspeccionar manualmente las entradas de la caché DNS utilizando el comando ipconfig /displaydnscommand, este enfoque puede ser laborioso y llevar mucho tiempo, especialmente cuando se trata de cachés grandes o de múltiples palabras clave.

Además, la posibilidad de guardar los resultados en un campo personalizado para su posterior revisión o documentación diferencia este script de otros métodos más básicos, lo que lo hace más versátil para uso profesional.

Preguntas frecuentes

¿Qué sistemas operativos admiten este script?

Este script es compatible con Windows 10 y Windows Server 2016 o posteriores.

¿Qué ocurre si no se proporcionan palabras clave?

El script saldrá con un error, notificando al usuario que se necesitan palabras clave para realizar la búsqueda.

¿Se pueden guardar los resultados para utilizarlos más adelante?

Sí, los resultados pueden guardarse en un campo personalizado multilínea, que puede ser útil para documentación o análisis posteriores.

Implicaciones para la seguridad de las búsquedas en la caché DNS

Buscar en la caché DNS no es sólo solucionar problemas; también tiene importantes implicaciones para la seguridad. Mediante la supervisión periódica de las entradas de caché DNS, los profesionales de TI pueden detectar entradas potencialmente maliciosas o patrones inusuales que podrían indicar una brecha de seguridad o un intento de phishing. Este enfoque proactivo de la gestión de DNS es un aspecto crucial para mantener un entorno de red seguro.

Recomendaciones para utilizar este script

Cuando utilices este script, ten en cuenta las siguientes prácticas recomendadas:

• Supervisa regularmente la caché DNS para asegurarte de que las entradas están actualizadas y libres de registros potencialmente maliciosos.
• Documenta cualquier hallazgo significativo guardando los resultados en un campo personalizado, al que se puede hacer referencia en futuras soluciones de problemas o auditorías de seguridad.
• Combina este script con otras herramientas de gestión de DNS para un enfoque integral de la seguridad y el rendimiento de DNS.

Reflexiones finales

La gestión eficaz de la caché de DNS es una tarea crítica para los profesionales de TI y los MSP, y este script de PowerShell ofrece una potente herramienta para agilizar este proceso. Al permitir búsquedas rápidas y específicas de las entradas de la caché DNS, los equipos de TI pueden resolver los problemas de la red con mayor eficacia y mejorar la seguridad general de la red.

NinjaOne, líder en soluciones de gestión de TI, proporciona las herramientas necesarias para automatizar y optimizar dichas tareas, garantizando que los profesionales puedan mantener entornos de red robustos, seguros y eficientes. Este script es sólo un ejemplo de cómo la automatización y un scripting bien planteado pueden mejorar las operaciones de TI y la prestación de servicios.