Comment rechercher les entrées du cache DNS Linux à l’aide d’un script Bash pour les professionnels de l’informatique

Dans le monde informatique actuel, une gestion efficace du réseau est cruciale. Un élément clé de cette gestion est la mise en cache du DNS (Domain Name System), qui peut améliorer de manière significative les performances du réseau en réduisant le temps nécessaire à la résolution des noms de domaine.

Pour les professionnels de l’informatique, en particulier ceux qui gèrent plusieurs systèmes, il est essentiel de comprendre et d’utiliser les informations du cache DNS. Ce billet de blog explore un script Bash conçu pour rechercher les entrées du cache DNS sur les systèmes Linux, en fournissant une description détaillée de son fonctionnement, de ses cas d’utilisation et des meilleures pratiques de mise en œuvre.

Contexte

La mise en cache DNS stocke les résultats des requêtes DNS localement sur un appareil, ce qui permet de répondre plus rapidement aux requêtes ultérieures portant sur les mêmes noms de domaine. Alors que les serveurs n’ont généralement pas de services de cache DNS activés par défaut, certains environnements de bureau comme GNOME ou KDE en ont souvent, utilisant des services comme systemd-resolved ou dnsmasq.

Ce script est conçu pour aider les professionnels de l’informatique et les fournisseurs de services gérés (MSP) à rechercher et à récupérer les entrées du cache DNS sur les systèmes Linux. La possibilité d’effectuer des recherches dans les entrées du cache DNS peut s’avérer cruciale pour résoudre des problèmes de réseau, enquêter sur des incidents de sécurité potentiels ou simplement optimiser les performances du réseau.

En fournissant un moyen systématique d’accéder à ces entrées et de les filtrer, le script permet de rationaliser des tâches qui, autrement, nécessiteraient des méthodes plus complexes ou plus longues.

Le script :

#!/usr/bin/env bash

# Description: Find DNS Cache entries on a Linux system. Supports systemd-resolved and dnsmasq(requires log-facility to be configured).
#
# Servers usually do not have a DNS cache service installed by default.
# systemd-resolved is commonly installed along with most Desktop Environments, such as GNOME and KDE.
#
# 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).

# A comma separated list of keywords to search for in the DNS cache. Example: "google,comcast,cloudflare"
keywords_to_search=$1
# A multiline custom field to save the DNS cache entries.
multiline_custom_field=$2

# Check if the multilineCustomField is set
if [[ -n "${multilineCustomField}" && "${multilineCustomField}" != "null" ]]; then
    multiline_custom_field=$multilineCustomField
fi

# Check if the keywordsToSearch is set
if [[ -n "${keywordsToSearch}" && "${keywordsToSearch}" != "null" ]]; then
    keywords_to_search=$keywordsToSearch
fi

# Check if the keywords_to_search is set
if [[ -z "${keywords_to_search}" ]]; then
    echo "[Info] keywords_to_search is not set."
    exit 1
else
    # Split the keywords_to_search into an array
    OLDIFS=$IFS
    IFS=',' read -r -a keywords <<<"${keywords_to_search}"
    IFS=$OLDIFS
    # Trim trailing and leading whitespace from each keyword
    keywords=("${keywords[@]/ /}")

fi

# Check if the multiline_custom_field is set
if [[ -z "${multiline_custom_field}" ]]; then
    echo "[Info] multilineCustomField is not set."
fi

# Check if ninjarmm-cli command exists in the default path
ninjarmm_cli="/opt/NinjaRMMAgent/programdata/ninjarmm-cli"
if [[ -z $ninjarmm_cli ]]; then
    echo "[Error] The ninjarmm-cli command does not exist in the default path. Please ensure the NinjaRMM agent is installed before running this script."
    exit 1
else
    # ninjarmm-cli command exists in the default path
    echo -n
fi

# Check that we are running as root
if [[ $EUID -ne 0 ]]; then
    echo "[Error] This script must be run as root."
    exit 1
fi

# Check for which dns cache service is installed
if [ "$(command -v resolvectl)" ]; then
    # resolvectl is installed
    dns_cache_service="resolvectl"
elif [ "$(command -v dnsmasq)" ]; then
    # dnsmasq is installed
    dns_cache_service="dnsmasq"
else
    # no dns cache service is installed
    echo "[Error] No DNS cache service is installed on this system that this script supports."
    echo ""
    echo "[Info] Supported DNS cache services: systemd-resolved, dnsmasq"
    echo "[Info] systemd-resolved commonly installed along with a Desktop Environment."
    echo "[Info] Servers usually do not have a DNS cache service installed by default."
    echo ""
    echo "[Info] Installing a DNS cache is not recommended on servers."
    exit 1
fi

# Check if the dns_cache_service is resolvectl
if [[ "${dns_cache_service}" == "resolvectl" ]]; then
    systemdVersion=$(systemctl --version | head -1 | awk '{ print $2}')
    if [ "$systemdVersion" -lt 254 ]; then
        echo "[Error] The version of systemd is less than 254. The resolvectl show-cache command is not available. Currently system version is ${systemdVersion}."
        exit 1
    fi
    # Get the DNS cache entries from resolvectl
    # https://github.com/systemd/systemd/pull/28012
    if ! dns_cache=$(resolvectl show-cache 2>/dev/null); then
        # Check if the systemd-resolved service is active
        if [[ $(systemctl is-active systemd-resolved) != "active" ]]; then
            echo "[Warn] The systemd-resolved service is not active."
        # Check /etc/resolv.conf that the nameserver is set to the default IP address 127.0.0.53 for systemd-resolved to work
        elif ! grep -q "^nameserver 127.0.0.53" /etc/resolv.conf; then
            echo "[Warn] The nameserver in /etc/resolv.conf is not set to an IP address 127.0.0.53 ."
            echo "[Info] The nameserver in /etc/resolv.conf should be set to an IP address 127.0.0.53 for systemd-resolved to work."
        else
            echo "[Warn] Failed to get the DNS cache entries. Is systemd-resolved installed, configured, and running?"
        fi
        echo ""
        echo "[Info] Supported DNS cache services: systemd-resolved, dnsmasq"
        echo "[Info] systemd-resolved commonly installed along with a Desktop Environment."
        echo "[Info] Servers usually do not have a DNS cache service installed by default."
        echo ""
        echo "[Info] Installing a DNS cache is not recommended on servers."
        exit 0
    fi

    dns_cache_entries=""
    # Get the DNS cache entries from resolvectl based on the keywords provided
    for keyword in "${keywords[@]}"; do
        # Example DNS cache entry:
        # consto.com IN A 123.123.123.123
        # consto.com IN AAAA 2001:0db8:85a3:0000:0000:8a2e:0370:7334
        dns_cache_entries+="DNS Cache Records Matching: ${keyword}"
        dns_cache_entries+=$'\n' # newline
        dns_cache_entries+=$(echo "$dns_cache" | grep -i -E "${keyword}")
        dns_cache_entries+=$'\n' # newline
    done
    # Print the DNS cache entries
    echo "" # newline
    echo "$dns_cache_entries"
# Check if the dns_cache_service is dnsmasq
elif [[ "${dns_cache_service}" == "dnsmasq" ]]; then
    if [ -f "/etc/dnsmasq.conf" ]; then
        echo "[Info] dnsmasq configuration file exists."
    else
        echo "[Warn] The dnsmasq configuration file does not exist and is likely not installed or configured."
        echo ""
        echo "[Info] Supported DNS cache services: systemd-resolved, dnsmasq"
        echo "[Info] systemd-resolved commonly installed along with a Desktop Environment."
        echo "[Info] Servers usually do not have a DNS cache service installed by default."
        echo ""
        echo "[Info] Installing a DNS cache is not recommended on servers."
        exit 0
    fi
    # Check that log-queries is enabled in the dnsmasq configuration file
    if ! grep -q "log-queries" /etc/dnsmasq.conf; then
        echo "[Warn] The 'log-queries' option is not enabled in the dnsmasq configuration file."
        echo ""
        echo "[Info] Supported DNS cache services: systemd-resolved, dnsmasq"
        echo "[Info] systemd-resolved commonly installed along with a Desktop Environment."
        echo "[Info] Servers usually do not have a DNS cache service installed by default."
        echo ""
        echo "[Info] Installing a DNS cache is not recommended on servers."
        exit 0
    fi
    # Get the log-facility from the dnsmasq configuration file
    log_facility=$(grep -E "^log-facility" /etc/dnsmasq.conf | awk '{print $2}')
    if [[ -z "${log_facility}" ]]; then
        echo "[Warn] The 'log-facility' option is not set in the dnsmasq configuration file."
        echo ""
        echo "[Info] Supported DNS cache services: systemd-resolved, dnsmasq"
        echo "[Info] systemd-resolved commonly installed along with a Desktop Environment."
        echo "[Info] Servers usually do not have a DNS cache service installed by default."
        echo ""
        echo "[Info] Installing a DNS cache is not recommended on servers."
        exit 0
    fi
    # Check that log_facility is a valid file
    if [[ ! -f "${log_facility}" ]]; then
        echo "[Error] The log facility file '${log_facility}' does not exist."
        echo ""
        echo "[Info] Supported DNS cache services: systemd-resolved, dnsmasq"
        echo "[Info] systemd-resolved commonly installed along with a Desktop Environment."
        echo "[Info] Servers usually do not have a DNS cache service installed by default."
        echo ""
        echo "[Info] Installing a DNS cache is not recommended on servers."
        exit 1
    fi
    # Get the DNS cache entries from log_facility
    # Example log_facility file:
    # Jan  1 00:00:00 dnsmasq[12345]: query[A] example.com from
    for keyword in "${keywords[@]}"; do
        # Get the DNS cache entries from the log_facility file
        # The awk command parses the log_facility file and extracts the time, query, and host
        if ! dns_cache_entries=$(grep -i -E "${keyword}" "${log_facility}" | awk 'BEGIN {OFS = ",";}$5 == "query[A]" {time = mktime(sprintf("%04d %02d %02d %s\n",strftime("%Y", systime()),(match("JanFebMarAprMayJunJulAugSepOctNovDec",$1)+2)/3,$2,gensub(":", " ", "g", $3)));query = $6;host = $8;print time, host, query;}'); then
            echo "[Error] Failed to get the DNS cache entries."
            echo "$dns_cache_entries"
            echo ""
            echo "[Info] Supported DNS cache services: systemd-resolved, dnsmasq"
            echo "[Info] systemd-resolved commonly installed along with a Desktop Environment."
            echo "[Info] Servers usually do not have a DNS cache service installed by default."
            echo ""
            echo "[Info] Installing a DNS cache is not recommended on servers."
            exit 1
        fi
    done
    echo "$dns_cache_entries"
fi

# Set the multiline_custom_field
if [[ -n "$multiline_custom_field" ]]; then
    if [[ -x "$ninjarmm_cli" ]]; then
        if hideOutput=$(echo "$dns_cache_entries" | "$ninjarmm_cli" set --stdin "$multiline_custom_field" 2>&1); then
            echo "[Info] Successfully set custom field: $multiline_custom_field"
        else
            echo "[Error] Failed to set custom field: $multiline_custom_field. Custom Field does not exist or does not have write permissions."
            exit 1
        fi
    else
        echo "[Error] NinjaRMM CLI not found or not executable"
        exit 1
    fi
fi

 

Description détaillée

Le script est structuré pour gérer les différents services de cache DNS (systemd-resolved et dnsmasq) qui peuvent être présents sur un système Linux. Voici une explication étape par étape du fonctionnement du script :

1. Configuration des paramètres :

• Le script commence par accepter deux paramètres : keywords_to_search et multiline_custom_field.
• keywords_to_search est une liste de mots-clés séparés par des virgules que le script utilisera pour rechercher dans les entrées du cache DNS. Le script vérifie si ces paramètres sont définis et les initialise en conséquence.

2. Contrôle de l’environnement:

• Il vérifie si la commande ninjarmm-cli est disponible, ce qui est nécessaire pour que le script interagisse avec la plateforme NinjaOne.
• Il vérifie si le script est exécuté avec les privilèges de l’administrateur, car l’accès à l’administrateur est nécessaire pour interroger les caches DNS.

3. Détection du service de cache DNS :

• Le script détecte si systemd-resolved ou dnsmasq est installé et actif sur le système. Si aucun service n’est trouvé, le script se termine par un message d’erreur approprié, informant l’utilisateur qu’aucun service de cache DNS pris en charge n’est installé.

4. Traitement de systemd-resolved :

• Si systemd-resolved est détecté, le script vérifie la version de systemd pour s’assurer qu’il prend en charge la commande show-cache (introduite dans la version 254).
• Le script interroge ensuite le cache DNS à l’aide de resolvectl show-cache et filtre les résultats en fonction des mots-clés fournis.

5. Gestion de dnsmasq :

• Si dnsmasq est détecté, le script vérifie la présence et la configuration du fichier dnsmasq.conf, en s’assurant que l’enregistrement des requêtes DNS est activé.
• Il recherche ensuite dans le fichier journal spécifié dans dnsmasq.conf les requêtes DNS qui correspondent aux mots-clés fournis.

6. Traitement des sorties :

• Le script collecte et met en forme les entrées du cache DNS qui correspondent aux mots-clés.
• Si le paramètre multiline_custom_field est fourni, le script tente de définir ce champ dans NinjaOne à l’aide de la commande ninjarmm-cli.

Cas d’utilisation potentiels

Imaginez un scénario dans lequel un professionnel de l’informatique est chargé d’enquêter sur des activités suspectes sur le réseau. Ils remarquent des schémas de trafic inhabituels et soupçonnent que certains domaines font l’objet de requêtes fréquentes.

Grâce à ce script, ils peuvent rapidement rechercher dans le cache DNS des mots-clés spécifiques (par exemple, des noms de domaine suspects) et récupérer les entrées pertinentes. Ces informations peuvent ensuite être utilisées pour bloquer ces domaines, ajuster les paramètres du pare-feu ou mener une enquête plus approfondie.

Un autre scénario pourrait consister à optimiser les performances du réseau. Un prestataire de services de gestion gérant plusieurs réseaux de clients peut utiliser ce script pour identifier les domaines fréquemment consultés mis en cache sur différents systèmes.

En analysant ces entrées de cache, l’entreprise MSP peut recommander la mise en place de serveurs DNS locaux ou de politiques de mise en cache afin de réduire la latence et d’améliorer l’expérience de l’utilisateur.

Comparaisons

Bien qu’il existe d’autres méthodes pour rechercher les entrées du cache DNS sur les systèmes Linux, telles que l’inspection manuelle des fichiers journaux ou l’utilisation d’outils tels que Grep en combinaison avec les journaux du système, ce script offre une approche plus rationalisée et automatisée.

Il détecte non seulement le service de cache DNS approprié, mais gère également les éventuels problèmes de configuration, ce qui en fait une option plus conviviale, en particulier pour ceux qui gèrent plusieurs systèmes.

FAQ

• Que se passe-t-il si aucun service de cache DNS n’est installé ? Le script se termine et affiche un message indiquant qu’aucun service de cache DNS pris en charge n’est installé et recommandant de ne pas en installer un sur les serveurs.
• Ce script peut-il être utilisé sur des serveurs ? Bien que techniquement possible, il n’est généralement pas recommandé d’exécuter des services de cache DNS sur des serveurs, comme le soulignent les messages de sortie du script.
• Pourquoi ai-je besoin des privilèges root pour exécuter ce script ? L’accès aux entrées du cache DNS nécessite généralement des autorisations élevées, c’est pourquoi le script vérifie l’accès de root.

Implications

La possibilité de rechercher et d’analyser les entrées du cache DNS a des répercussions importantes sur la sécurité et les performances du réseau. En identifiant et en réagissant rapidement aux requêtes de domaine inhabituelles ou malveillantes, les professionnels de l’informatique peuvent atténuer les menaces potentielles avant qu’elles ne s’aggravent. De plus, l’analyse régulière du cache DNS peut contribuer à optimiser les configurations du réseau, ce qui permet d’améliorer l’efficacité globale.

Recommandations

Lorsque vous utilisez ce script :

• Exécutez-le avec les privilèges de la racine pour éviter les problèmes d’autorisation.
• Vérifiez que systemd-resolved ou dnsmasq est correctement configuré sur votre système.
• Mettez régulièrement votre système à jour pour assurer sa compatibilité avec les dernières fonctionnalités (par exemple, la version 254 de systemd ou une version plus récente).
• Utilisez des mots-clés significatifs et pertinents pour filtrer les entrées du cache DNS efficacement.

Conclusion

Ce script de recherche de cache DNS est un outil puissant pour les professionnels de l’informatique, en particulier lorsqu’il est intégré à la plateforme de gestion de NinjaOne. En automatisant le processus de récupération et d’analyse des entrées du cache DNS, il permet une gestion du réseau et une surveillance de la sécurité plus efficaces. La suite d’outils performante de NinjaOne peut encore améliorer l’utilité de ce script, en fournissant des solutions complètes pour les tâches de gestion informatique.