Comment faire une recherche dans le cache DNS avec PowerShell : le guide complet

Dans le monde interconnecté d’aujourd’hui, les professionnels de l’informatique doivent souvent étudier et gérer divers problèmes liés au réseau. L’un des aspects essentiels du dépannage d’un réseau consiste à comprendre les requêtes DNS (Domain Name System) et à résoudre les problèmes liés au DNS.

Le DNS est le protocole responsable de la traduction des noms de domaine conviviaux en adresses IP que les ordinateurs utilisent pour communiquer entre eux. Dans ce contexte, la recherche d’enregistrements spécifiques dans le cache DNS peut être une tâche essentielle pour les administrateurs de réseaux et les fournisseurs de services gérés (MSP).

Cet article se penche sur un script PowerShell conçu pour rechercher des noms d’enregistrements de cache DNS correspondant à des mots-clés spécifiés. Nous examinerons son historique, son fonctionnement, ses applications concrètes et les raisons pour lesquelles il s’agit d’un outil inestimable pour les professionnels de l’informatique.

L’importance de la gestion du cache DNS

Avant de plonger dans le script, il est essentiel de comprendre l’importance de la gestion du cache DNS. Le cache DNS est une base de données temporaire gérée par le système d’exploitation qui stocke les enregistrements de toutes les visites et tentatives de visites récentes de sites web et d’autres domaines internet. Ce cache permet d’accéder plus rapidement aux sites fréquemment visités en réduisant la nécessité d’effectuer des recherches DNS répétées, ce qui améliore l’efficacité de la navigation.

Toutefois, ce cache peut parfois contenir des enregistrements obsolètes ou incorrects, ce qui peut entraîner des problèmes d’accès au site web ou des failles de sécurité. C’est là que la possibilité de rechercher et de gérer le cache DNS devient vitale. Le script dont nous allons parler aujourd’hui offre un moyen simplifié de rechercher et d’analyser les enregistrements de cache DNS, ce qui en fait un outil indispensable pour les professionnels de l’informatique.

Le script :

#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 {
    
    
    
}

 

Une analyse détaillée du script

Décortiquons le script pour comprendre son fonctionnement et les fonctionnalités qu’il offre.

1. Initialisation du script :

• Le script commence par définir des paramètres qui permettent aux utilisateurs de spécifier des mots-clés à rechercher dans le cache DNS. Ces mots-clés sont saisis sous la forme d’une liste séparée par des virgules.
• Un paramètre facultatif permet aux utilisateurs d’enregistrer les résultats dans un champ personnalisé multiligne. Cette fonction est particulièrement utile à des fins de journalisation et de documentation.

2. Traitement des mots-clés :

• Le script traite les mots-clés fournis, en veillant à ce qu’ils soient correctement formatés pour l’opération de recherche. Si aucun mot-clé n’est fourni, le script se termine par une erreur, ce qui permet de s’assurer que les utilisateurs sont conscients de l’absence de données.

3. Récupération du cache DNS :

• Le cœur du script consiste à récupérer les entrées du cache DNS à l’aide de la cmdlet Get-DnsClientCache. Cette cmdlet récupère les enregistrements DNS du cache local qui correspondent aux mots-clés spécifiés.
• Les résultats sont ensuite formatés pour afficher l’entrée, le nom de l’enregistrement, le type d’enregistrement, les données et la durée de vie (TTL) pour chaque enregistrement DNS trouvé.

4. Traitement des sorties :

• Si le champ personnalisé multiligne facultatif est spécifié, le script tente d’enregistrer les résultats dans ce champ à l’aide d’une fonction personnalisée appelée Set-NinjaProperty. Cette fonction traite différents types de données d’entrée et veille à ce que le champ soit mis à jour correctement.
• Si le champ personnalisé n’est pas spécifié, les résultats sont simplement affichés dans le flux d’activité, ce qui permet un examen et une analyse rapides.

Cas d’utilisation dans le monde réel

Pour illustrer l’utilité de ce script, prenons l’exemple d’un professionnel de l’informatique qui cherche à résoudre un problème de réseau pour un client. Le client signale des problèmes intermittents de connectivité avec certains sites web. L’informaticien soupçonne que des entrées de cache DNS obsolètes ou incorrectes peuvent être à l’origine du problème.

À l’aide de ce script PowerShell, le professionnel de l’informatique peut rapidement rechercher dans le cache DNS les enregistrements liés aux sites web problématiques. En identifiant ces enregistrements, ils peuvent déterminer si le cache DNS doit être vidé ou si des entrées spécifiques doivent être mises à jour. Cette approche ciblée permet de gagner du temps et de résoudre efficacement les problèmes de réseau du client.

Comparaison avec d’autres méthodes

Ce script PowerShell offre une approche plus automatisée et personnalisable de la recherche dans le cache DNS par rapport à d’autres méthodes manuelles. Bien qu’il soit possible d’inspecter manuellement les entrées du cache DNS à l’aide de la commande ipconfig /displaydns, cette approche peut s’avérer fastidieuse et chronophage, en particulier lorsqu’il s’agit de caches volumineux ou de mots-clés multiples.

De plus, la possibilité d’enregistrer les résultats dans un champ personnalisé en vue d’un examen ou d’une documentation ultérieurs distingue ce script des méthodes plus basiques, ce qui le rend plus polyvalent pour une utilisation professionnelle.

Questions fréquemment posées

Quels sont les systèmes d’exploitation qui prennent en charge ce script ?

Ce script est compatible avec Windows 10 et Windows Server 2016 ou une version ultérieure.

Que se passe-t-il si aucun mot-clé n’est fourni ?

Le script sortira avec une erreur, notifiant à l’utilisateur que des mots-clés sont nécessaires pour effectuer la recherche.

Les résultats peuvent-ils être sauvegardés pour une utilisation ultérieure ?

Oui, les résultats peuvent être enregistrés dans un champ personnalisé multiligne, ce qui peut être utile pour la documentation ou une analyse plus approfondie.

Conséquences sur la sécurité des recherches dans le cache DNS

La recherche dans le cache DNS n’est pas seulement une question de dépannage ; elle a également des implications importantes en termes de sécurité. En contrôlant régulièrement les entrées du cache DNS, les professionnels de l’informatique peuvent détecter des entrées potentiellement malveillantes ou des schémas inhabituels qui pourraient indiquer une faille de sécurité ou une tentative d’hameçonnage. Cette approche proactive de la gestion des DNS est un aspect crucial du maintien d’un environnement réseau sécurisé.

Recommandations pour l’utilisation de ce texte

Lors de l’utilisation de ce script, il est important de suivre les bonnes pratiques suivantes :

• Contrôler régulièrement le cache DNS pour s’assurer que les entrées sont à jour et ne contiennent pas d’enregistrements potentiellement malveillants.
• Documenter les résultats significatifs en les enregistrant dans un champ personnalisé, qui pourra être utilisé lors de dépannages ou d’audits de sécurité ultérieurs.
• Combinez ce script avec d’autres outils de gestion DNS pour obtenir une approche complète de la sécurité et des performances DNS.

Conclusion

La gestion efficace du cache DNS est une tâche essentielle pour les professionnels de l’informatique et les MSP, et ce script PowerShell offre un outil puissant pour rationaliser ce processus. En permettant des recherches rapides et ciblées dans les entrées du cache DNS, les équipes informatiques peuvent résoudre les problèmes de réseau plus efficacement et améliorer la sécurité globale du réseau.

NinjaOne, leader dans le domaine des solutions de gestion informatique, fournit les outils nécessaires à l’automatisation et à l’optimisation de ces tâches, permettant ainsi aux professionnels de l’informatique de maintenir des environnements de réseau robustes, sécurisés et efficaces. Ce script n’est qu’un exemple de la manière dont l’automatisation et la création de scripts bien pensés peuvent améliorer les opérations informatiques et la fourniture de services.