Wie man im Linux-DNS-Cache effizient mit einem Bash-Skript für IT-Experten sucht

In der heutigen IT-Welt ist eine effiziente Netzwerkverwaltung ausschlaggebend. Eine Schlüsselkomponente davon ist das DNS (Domain Name System)-Caching, das die Netzwerkleistung erheblich verbessern kann, indem sie die Zeit für die Auflösung von Domainnamen verkürzt.

Für IT-Experten, insbesondere für diejenigen, die mehrere Systeme verwalten, ist das Verständnis und die Nutzung von DNS-Cache-Informationen von entscheidender Bedeutung. Dieser Blog-Beitrag befasst sich mit einem Bash-Skript, das DNS-Cache-Einträge auf Linux-Systemen durchsuchen kann, und bietet eine detaillierte Aufschlüsselung der Funktionsweise, der Anwendungsfälle und der Best Practices für die Implementierung.

Kontext

Beim DNS-Caching werden die Ergebnisse von DNS-Abfragen lokal auf einem Gerät gespeichert, was eine schnellere Beantwortung nachfolgender Anfragen für dieselben Domainnamen ermöglicht. Während Server im Allgemeinen keine standardmäßig aktivierten DNS-Cache-Dienste haben, ist dies bei bestimmten Desktop-Umgebungen wie GNOME oder KDE oft der Fall, die Dienste wie systemd-resolved oder dnsmasq verwenden.

Dieses Skript soll IT-Experten und Managed Service Providern (MSPs) helfen, DNS-Cache-Einträge auf Linux-Systemen zu suchen und abzurufen. Die Möglichkeit, DNS-Cache-Einträge zu durchsuchen, kann für die Behebung von Netzwerkproblemen, die Untersuchung potenzieller Sicherheitsvorfälle oder einfach die Optimierung der Netzwerkleistung entscheidend sein.

Das Skript bietet eine systematische Möglichkeit, auf diese Einträge zuzugreifen und sie zu filtern, und trägt so zur Rationalisierung von Aufgaben bei, die andernfalls komplexere oder zeitaufwändigere Methoden erfordern würden.

Das Skript:

#!/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

 

Detailansicht

Das Skript ist so aufgebaut, dass es mit verschiedenen DNS-Caching-Diensten (systemd-resolved und dnsmasq) umgehen kann, die auf einem Linux-System vorhanden sein können. Im Folgenden wird Schritt für Schritt erklärt, wie das Skript funktioniert:

1. Parameter einrichten:

• Das Skript beginnt mit der Annahme von zwei Parametern: keywords_to_search und multiline_custom_field.
• keywords_to_search ist eine durch Kommata getrennte Liste von Schlüsselwörtern, die das Skript zum Durchsuchen von DNS-Cache-Einträgen verwenden wird. Das Skript prüft, ob diese Parameter gesetzt sind und initialisiert sie dementsprechend.

2. Umgebungsprüfung:

• Es prüft, ob der Befehl ninjarmm-cli verfügbar ist, der für das Skript zur Interaktion mit der NinjaRMM-Plattform erforderlich ist.
• Es wird überprüft, ob das Skript mit Root-Rechten ausgeführt wird, da Root-Zugriff erforderlich ist, um DNS-Caches abzufragen.

3. Erkennung des DNS-Cache-Dienstes:

• Das Skript erkennt, ob systemd-resolved oder dnsmasq auf dem System installiert und aktiv ist. Wenn keiner der beiden Dienste gefunden wird, bricht das Skript mit einer entsprechenden Fehlermeldung ab und informiert die Benutzer:innen, dass kein unterstützter DNS-Cache-Dienst installiert ist.

4. Nutzung von system-resolved:

• Wenn systemd-resolved erkannt wird, überprüft das Skript die Version von systemd, um sicherzustellen, dass es den Befehl show-cache (eingeführt in Version 254) unterstützt.
• Das Skript fragt dann den DNS-Cache mit resolvectl show-cache ab und filtert die Ergebnisse auf der Grundlage der angegebenen Schlüsselwörter.

5. Nutzung von dnsmasq:

• Wenn dnsmasq erkannt wird, prüft das Skript das Vorhandensein und die Konfiguration der Datei dnsmasq.conf und stellt sicher, dass die Protokollierung von DNS-Anfragen aktiviert ist.
• Er durchsucht dann die in dnsmasq.conf angegebene Protokolldatei nach DNS-Anfragen, die den angegebenen Schlüsselwörtern entsprechen.

6. Handhabung der Ausgabe:

• Das Skript sammelt und formatiert die DNS-Cache-Einträge, die den Schlüsselwörtern entsprechen.
• Wenn der Parameter multiline_custom_field angegeben wird, versucht das Skript, dieses Feld in NinjaRMM mit dem Befehl ninjarmm-cli zu setzen.

Potenzielle Anwendungsfälle

Stellen Sie sich ein Szenario vor, in dem ein IT-Experte damit beauftragt wird, verdächtige Netzwerkaktivitäten zu untersuchen. Sie bemerken ungewöhnliche Verkehrsmuster und vermuten, dass bestimmte Domains häufig abgefragt werden.

Mit diesem Skript können Sie den DNS-Cache schnell nach bestimmten Schlüsselwörtern (z. B. verdächtigen Domainnamen) durchsuchen und die entsprechenden Einträge abrufen. Diese Informationen können dann verwendet werden, um diese Domains zu blockieren, die Firewall-Einstellungen anzupassen oder weitere Untersuchungen durchzuführen.

Ein anderes Szenario könnte die Optimierung der Netzwerkleistung betreffen. Ein MSP, der mehrere Kundennetzwerke verwaltet, könnte dieses Skript verwenden, um häufig genutzte Domains zu identifizieren, die auf verschiedenen Systemen zwischengespeichert sind.

Durch die Analyse dieser Cache-Einträge könnte der MSP die Einrichtung lokaler DNS-Server oder Caching-Richtlinien empfehlen, um die Latenz zu verringern und die Benutzerfreundlichkeit zu verbessern.

Vergleiche

Es gibt zwar auch andere Methoden zum Durchsuchen von DNS-Cache-Einträgen auf Linux-Systemen, z. B. das manuelle Durchsuchen von Protokolldateien oder die Verwendung von Tools wie grep in Kombination mit Systemprotokollen, aber dieses Skript bietet einen optimierten und automatisierten Ansatz.

Er erkennt nicht nur den passenden DNS-Caching-Dienst, sondern kümmert sich auch um mögliche Konfigurationsprobleme, was ihn zu einer benutzerfreundlicheren Option macht, insbesondere für Administratoren, die mehrere Systeme verwalten.

FAQs

• Was passiert, wenn kein DNS-Cache-Dienst installiert ist? Das Skript bricht ab und gibt eine Meldung aus, die besagt, dass kein unterstützter DNS-Cache-Dienst installiert ist, und rät davon ab, einen solchen auf Servern zu installieren.
• Kann dieses Skript auf Servern verwendet werden? Obwohl es technisch möglich ist, wird im Allgemeinen nicht empfohlen, DNS-Cache-Dienste auf Servern auszuführen, wie aus den Ausgabemeldungen des Skripts hervorgeht.
• Warum benötige ich Root-Rechte, um dieses Skript auszuführen? Der Zugriff auf DNS-Cache-Einträge erfordert in der Regel erweiterte Rechte, weshalb das Skript den Root-Zugriff überprüft.

Folgen

Die Möglichkeit, DNS-Cache-Einträge zu suchen und zu analysieren, hat erhebliche Auswirkungen auf die Netzwerksicherheit und -leistung. Durch schnelles Erkennen und Reagieren auf ungewöhnliche oder bösartige Domainanfragen können IT-Experten potenzielle Bedrohungen entschärfen, bevor sie eskalieren. Darüber hinaus kann eine regelmäßige Analyse des DNS-Cache zur Optimierung der Netzwerkkonfigurationen beitragen und so die Gesamteffizienz verbessern.

Empfehlungen

Wenn Sie dieses Skript verwenden, stellen Sie sicher, dass Sie:

• Es mit Root-Rechten ausführen, um Rechteprobleme zu vermeiden.
• Überprüfen Sie, ob systemd-resolved oder dnsmasq auf Ihrem System richtig konfiguriert ist.
• Aktualisieren Sie Ihr System regelmäßig, um die Kompatibilität mit den neuesten Funktionen sicherzustellen (z. B. systemd Version 254 oder höher).
• Verwenden Sie sinnvolle und relevante Schlüsselwörter, um DNS-Cache-Einträge effektiv zu filtern.

Abschließende Überlegungen

Dieses DNS-Cache-Suchskript ist ein leistungsfähiges Tool für IT-Experten, insbesondere wenn es in die NinjaOne-Management-Plattform integriert ist. Durch die Automatisierung des Abrufs und der Analyse von DNS-Cache-Einträgen ermöglicht es eine effizientere Netzwerkverwaltung und Sicherheitsüberwachung. Die robuste Tools-Suite von NinjaOne kann den Nutzen dieses Skripts weiter erhöhen und bietet komplette Lösungen für IT-Management-Aufgaben.