Nmap-Skripte erkunden und erstellen

NmapNmapBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie über den Nmap Scripting Engine (NSE) und wie Sie Nmap-Skripte kategorisieren und aktualisieren können. Nmap, ein leistungsstarkes Open-Source-Tool zur Netzwerkermittlung und Sicherheitsüberprüfung, erweitert seine Funktionalität durch den NSE. Der NSE ermöglicht es Benutzern, Skripte zu schreiben und zu teilen, um verschiedene Netzwerkaufgaben zu automatisieren.

Dieses Lab führt Sie durch die Exploration der Nmap-Skriptkategorien, das Erstellen von benutzerdefinierten Skriptverzeichnissen, das Hinzufügen eigener Skripte und die Aktualisierung der Nmap-Skriptdatenbank. Diese Fähigkeiten sind für Netzwerkadministratoren und Sicherheitsexperten von entscheidender Bedeutung, um Netzwerke effizient zu scannen und Schwachstellen zu identifizieren.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/installation("Installation and Setup") nmap/NmapGroup -.-> nmap/service_detection("Service Detection") nmap/NmapGroup -.-> nmap/scripting_basics("Scripting Engine Basics") nmap/NmapGroup -.-> nmap/script_management("Script Categories and Updating") subgraph Lab Skills nmap/installation -.-> lab-415930{{"Nmap-Skripte erkunden und erstellen"}} nmap/service_detection -.-> lab-415930{{"Nmap-Skripte erkunden und erstellen"}} nmap/scripting_basics -.-> lab-415930{{"Nmap-Skripte erkunden und erstellen"}} nmap/script_management -.-> lab-415930{{"Nmap-Skripte erkunden und erstellen"}} end

Exploration der Nmap-Skriptkategorien

In diesem Schritt werden wir die Kategorien der Nmap-Skripte erkunden, die auf Ihrem System bereits voreingestellt sind. Nmap-Skripte sind leistungsstarke Werkzeuge im Bereich der Cybersicherheit. Sie sind nach ihrer Funktionalität organisiert. Beispielsweise werden einige Skripte für die Erkundung (Discovery) verwendet, was bedeutet, dass sie Geräte und Dienste in einem Netzwerk finden können. Andere dienen der Schwachstellenbewertung (Vulnerability Assessment), was bei der Identifizierung von Sicherheitslücken in Systemen hilft.

Zunächst müssen wir ein Terminal öffnen. Ein Terminal ist eine textbasierte Schnittstelle, in der Sie Befehle eingeben können, um mit Ihrem System zu interagieren. Sobald das Terminal geöffnet ist, müssen wir sicherstellen, dass wir im richtigen Verzeichnis sind. Ein Verzeichnis ist wie ein Ordner auf Ihrem Computer, in dem Dateien und andere Ordner gespeichert werden. Führen Sie den folgenden Befehl im Terminal aus:

cd /home/labex/project

Dieser Befehl wechselt das aktuelle Arbeitsverzeichnis zu /home/labex/project.

Jetzt überprüfen wir die auf unserem System installierte Version von Nmap. Die Kenntnis der Version ist wichtig, da verschiedene Versionen unterschiedliche Funktionen und Kompatibilitäten haben können. Führen Sie diesen Befehl im Terminal aus:

nmap --version

Die Ausgabe wird in etwa so aussehen:

Nmap version 7.80 ( https://nmap.org )
Platform: x86_64-pc-linux-gnu
Compiled with: liblua-5.3.3 openssl-1.1.1f libpcre-8.39 libpcap-1.9.1 nmap-libdnet-1.12 ipv6
Compiled without:
Available nsock engines: epoll poll select

Als nächstes werden wir die verfügbaren Nmap-Skriptkategorien untersuchen. Nmap-Skripte werden im Verzeichnis /usr/share/nmap/scripts/ gespeichert. Um eine Vorstellung davon zu bekommen, welche Skripte verfügbar sind, können wir sie auflisten und nach ihren Namen sortieren. Führen Sie diesen Befehl im Terminal aus:

ls /usr/share/nmap/scripts/ | grep -v .lua | sort | head -10

Dieser Befehl listet zunächst alle Dateien im Verzeichnis /usr/share/nmap/scripts/ auf. Dann verwendet er grep -v .lua, um Dateien mit der Endung .lua auszuschließen. Danach sortiert er die verbleibenden Dateien nach ihren Namen und zeigt die ersten 10 Ergebnisse an. Die Ausgabe wird in etwa so aussehen:

address-info.nse
afp-brute.nse
afp-ls.nse
afp-path-vuln.nse
afp-serverinfo.nse
afp-showmount.nse
ajp-auth.nse
ajp-brute.nse
ajp-headers.nse
ajp-methods.nse

Um alle Skriptkategorien anzuzeigen, können wir den folgenden Befehl verwenden:

grep -r categories /usr/share/nmap/scripts/*.nse | grep -o "categories = {[^}]*}" | sort | uniq | head -10

Dieser Befehl sucht in allen .nse-Skriptdateien im Verzeichnis /usr/share/nmap/scripts/ nach der Zeichenkette "categories". Dann extrahiert er die Kategorieninformationen, sortiert sie, entfernt alle doppelten Einträge und zeigt die ersten 10 Ergebnisse an. Die Ausgabe wird in etwa so aussehen:

categories = {"auth", "brute", "intrusive"}
categories = {"auth", "default", "discovery", "safe"}
categories = {"auth", "discovery", "safe"}
categories = {"auth", "intrusive"}
categories = {"auth", "safe"}
categories = {"broadcast", "discovery"}
categories = {"broadcast", "discovery", "safe"}
categories = {"default", "discovery"}
categories = {"default", "discovery", "safe"}
categories = {"default", "discovery", "safe", "version"}

Zur besseren Organisation werden wir eine Verzeichnisstruktur erstellen, um Skripte nach ihrer Funktionalität zu kategorisieren. Dies wird es später einfacher machen, die Skripte zu finden und zu verwenden. Wir werden separate Verzeichnisse für verschiedene Kategorien erstellen. Führen Sie diese Befehle im Terminal aus:

mkdir -p /home/labex/project/NmapScripts/vulnerability
mkdir -p /home/labex/project/NmapScripts/discovery
mkdir -p /home/labex/project/NmapScripts/authentication

Der Befehl mkdir -p erstellt Verzeichnisse. Wenn die übergeordneten Verzeichnisse nicht existieren, erstellt er sie ebenfalls.

Jetzt kopieren wir einige Schwachstellen-bezogene Skripte in unser neu erstelltes Verzeichnis für Schwachstellen. Führen Sie diesen Befehl im Terminal aus:

cp /usr/share/nmap/scripts/smb-vuln* /home/labex/project/NmapScripts/vulnerability/

Dieser Befehl kopiert alle Skripte im Verzeichnis /usr/share/nmap/scripts/, deren Namen mit smb - vuln beginnen, in das Verzeichnis /home/labex/project/NmapScripts/vulnerability/.

Lassen Sie uns überprüfen, ob die Dateien korrekt kopiert wurden. Führen Sie diesen Befehl im Terminal aus:

ls -la /home/labex/project/NmapScripts/vulnerability/

Die Ausgabe zeigt die kopierten Schwachstellen-Skripte:

total 88
drwxr-xr-x 2 labex labex  4096 Mar 15 12:30 .
drwxr-xr-x 4 labex labex  4096 Mar 15 12:30 ..
-rw-r--r-- 1 labex labex  3355 Mar 15 12:30 smb-vuln-conficker.nse
-rw-r--r-- 1 labex labex  8045 Mar 15 12:30 smb-vuln-cve2009-3103.nse
-rw-r--r-- 1 labex labex  5100 Mar 15 12:30 smb-vuln-cve-2017-7494.nse
-rw-r--r-- 1 labex labex  9595 Mar 15 12:30 smb-vuln-ms06-025.nse
-rw-r--r-- 1 labex labex 11645 Mar 15 12:30 smb-vuln-ms07-029.nse
-rw-r--r-- 1 labex labex 12558 Mar 15 12:30 smb-vuln-ms08-067.nse
-rw-r--r-- 1 labex labex  9719 Mar 15 12:30 smb-vuln-ms10-054.nse
-rw-r--r-- 1 labex labex  7326 Mar 15 12:30 smb-vuln-ms10-061.nse
-rw-r--r-- 1 labex labex  8091 Mar 15 12:30 smb-vuln-ms17-010.nse
-rw-r--r-- 1 labex labex  4245 Mar 15 12:30 smb-vuln-regsvc-dos.nse

In ähnlicher Weise kopieren wir einige Erkundungs- und Authentifizierungs-Skripte in ihre jeweiligen Verzeichnisse. Führen Sie diese Befehle im Terminal aus:

cp /usr/share/nmap/scripts/dns-* /home/labex/project/NmapScripts/discovery/
cp /usr/share/nmap/scripts/ssh-* /home/labex/project/NmapScripts/authentication/

Jetzt haben Sie einige Nmap-Skripte nach ihrer Funktionalität kategorisiert, was es einfacher macht, sie für bestimmte Aufgaben zu finden und zu verwenden.

Verständnis der Skriptfunktionalität

In diesem Schritt werden wir lernen, wie man Nmap-Skripte untersucht und versteht, um herauszufinden, was sie können. Dies ist sehr wichtig, da es Ihnen hilft, die richtigen Skripte für verschiedene Netzwerkscangänge auszuwählen.

Beginnen wir damit, uns eines der Schwachstellen-Skripte genauer anzusehen, das wir im vorherigen Schritt kopiert haben. Wir verwenden den Befehl cat, um den Inhalt des Skripts anzuzeigen, und dann head -20, um nur die ersten 20 Zeilen anzuzeigen. Auf diese Weise können wir schnell die wichtigen Informationen am Anfang des Skripts sehen.

cat /home/labex/project/NmapScripts/vulnerability/smb-vuln-ms17-010.nse | head -20

Die Ausgabe zeigt den Anfang des Skripts. Dieser Teil enthält normalerweise Details darüber, wofür das Skript dient und wie man es verwendet.

local smb = require "smb"
local vulns = require "vulns"
local stdnse = require "stdnse"
local string = require "string"

description = [[
Attempts to detect if a Microsoft SMBv1 server is vulnerable to a remote code
execution vulnerability (ms17-010, a.k.a. EternalBlue). The vulnerability affects
Windows Vista, 7, 8.1, 10, Server 2008, Server 2008 R2, Server 2012 Gold and R2, and Server 2016.

The script connects to the $IPC tree, executes a transaction on FID 0 and
checks if the error "STATUS_INSUFF_SERVER_RESOURCES" is returned to
determine if the target is not patched against ms17-010. Additionally it checks
for a matching error code on EternalChampion.

References:
* https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
* https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/
* https://msrc-blog.microsoft.com/2017/05/12/customer-guidance-for-wannacrypt-attacks/
* https://github.com/rapid7/metasploit-framework/pull/8654/files

Dieses Skript ist darauf ausgelegt, zu prüfen, ob ein Microsoft SMBv1-Server die MS17-010-Schwachstelle hat, die auch als EternalBlue bekannt ist.

Jetzt schauen wir uns die Struktur eines Nmap-Skripts an, um seine verschiedenen Teile zu verstehen. Die meisten Nmap-Skripte haben diese wichtigen Komponenten:

  1. Eine Beschreibungssektion: Dies sagt Ihnen, was das Skript macht. Es ist wie eine kurze Zusammenfassung, die Ihnen hilft, schnell den Zweck des Skripts zu verstehen.
  2. Eine Autorenangabe: Dies gibt dem Ersteller des Skripts die Ehre. Es ist wichtig zu wissen, wer das Skript erstellt hat, insbesondere wenn Sie ihn kontaktieren oder weitere Skripte desselben Autors suchen müssen.
  3. Kategorien: Diese gruppieren ähnliche Skripte zusammen. Beispielsweise können Skripte, die sich auf die Schwachstellensuche beziehen, in der Kategorie "vuln" sein. Dies erleichtert die Suche und Verwaltung von Skripten.
  4. Regeln: Diese bestimmen, wann das Skript ausgeführt werden soll. Es gibt verschiedene Arten von Regeln, wie portrule und hostrule. Beispielsweise kann eine hostrule festlegen, dass das Skript nur auf bestimmten Hosts ausgeführt werden soll.
  5. Die Hauptaktionsfunktion: Hier findet die eigentliche Arbeit des Skripts statt. Sie enthält den Code, der die Aufgabe ausführt, wie das Prüfen auf eine Schwachstelle oder das Abrufen von Informationen über einen Host.

Erstellen wir nun unser eigenes einfaches Nmap-Skript, um diese Struktur in Aktion zu sehen. Wir verwenden den Befehl cat, um eine neue Datei zu erstellen und das Skript hineinzuschreiben.

cat << 'EOF' > /home/labex/project/my-ping-check.nse
description = [[
A simple script that checks if a host responds to ICMP echo requests (ping).
]]

author = "LabEx User"

categories = {"discovery", "safe"}

-- The rule section determines when the script should be run
hostrule = function(host)
  return true  -- Run the script for all hosts
end

-- The action section contains the main function of the script
action = function(host)
  local output = "Host status: "
  
  if host.pingresponse then
    output = output .. "Responds to ping"
  else
    output = output .. "Does not respond to ping"
  end
  
  return output
end
EOF

Lassen Sie uns dieses Skript analysieren:

  • Die description-Sektion erklärt klar, dass das Skript prüft, ob ein Host auf Ping-Anfragen antwortet.
  • Die author-Sektion sagt, dass das Skript von einem LabEx-Benutzer erstellt wurde.
  • Die categories-Sektion gruppiert dieses Skript mit anderen Erkundungs- und sicheren Skripten. Erkundungsskripte werden verwendet, um Informationen über Hosts zu finden, und sichere Skripte sind solche, die keine Schäden am Ziel verursachen.
  • Die hostrule-Funktion ist so eingestellt, dass sie true zurückgibt, was bedeutet, dass das Skript für alle Hosts ausgeführt wird.
  • Die action-Funktion enthält die Hauptlogik. Sie prüft, ob der Host eine Ping-Antwort hat und gibt dann eine Nachricht zurück, die angibt, ob der Host auf Ping antwortet oder nicht.

Jetzt führen wir unser benutzerdefiniertes Skript gegen den localhost (127.0.0.1) aus. Wir verwenden den Befehl nmap mit der Option --script, um unser benutzerdefiniertes Skript anzugeben.

nmap --script /home/labex/project/my-ping-check.nse 127.0.0.1

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000091s latency).
Not shown: 998 closed ports
PORT     STATE SERVICE
22/tcp   open  ssh
| my-ping-check: Host status: Responds to ping
3001/tcp open  nessus
|_my-ping-check: Host status: Responds to ping

Nmap done: 1 IP address (1 host up) scanned in 0.24 seconds

Diese Ausgabe zeigt, dass unser Skript korrekt funktioniert. Es hat festgestellt, dass der localhost auf Ping-Anfragen antwortet. Dies ist ein einfaches Beispiel, aber es zeigt Ihnen die grundlegende Struktur und Funktion eines Nmap-Skripts.

Erstellen und Hinzufügen benutzerdefinierter Skripte zu Nmap

In diesem Schritt werden wir lernen, wie man ein benutzerdefiniertes Nmap-Skript erstellt und es zur Nmap-Skriptdatenbank hinzufügt. Nmap ist ein leistungsstarkes Netzwerkscantool, und durch das Hinzufügen benutzerdefinierter Skripte können Sie seine Funktionalität erweitern, um Ihren spezifischen Anforderungen gerecht zu werden. Dies bedeutet, dass Sie während Netzwerkscans einzigartige Aufgaben ausführen können, die von den Standard-Nmap-Skripten nicht abgedeckt werden.

Zunächst erstellen wir ein neues, etwas komplexeres Skript. Dieses Skript wird prüfen, ob ein bestimmter Port geöffnet ist. Ports sind wie Türen in einem Netzwerk; sie ermöglichen es verschiedenen Arten von Netzwerkverkehr, ein Gerät zu betreten oder zu verlassen. Indem wir prüfen, ob ein Port geöffnet ist, können wir herausfinden, ob ein bestimmter Dienst auf einem Gerät läuft.

cat << 'EOF' > /usr/share/nmap/scripts/port-check.nse
description = [[
A script that checks if a specific port is open and reports its status.
]]

author = "LabEx User"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"discovery", "safe"}

-- The portrule determines when the script should be run
portrule = function(host, port)
  return port.protocol == "tcp" and port.state == "open"
end

-- The action section contains the main function of the script
action = function(host, port)
  local output = string.format("Port %d is open on host %s", port.number, host.ip)
  return output
end
EOF

Im obigen Code definieren wir zunächst eine Beschreibung dessen, was das Skript tut. Dann setzen wir die Autoren- und Lizenzinformationen. Die portrule-Funktion entscheidet, wann das Skript ausgeführt werden soll. Hier prüft sie, ob der Port das TCP-Protokoll verwendet und geöffnet ist. Die action-Funktion ist der Hauptteil des Skripts. Sie erstellt eine Nachricht, die angibt, dass ein bestimmter Port auf einem bestimmten Host geöffnet ist.

Beachten Sie, dass wir dieses Skript direkt im Nmap-Skriptverzeichnis (/usr/share/nmap/scripts/) erstellt haben. Dies ist wichtig, da Nmap nach Skripten in diesem Verzeichnis sucht. Allerdings reicht es nicht aus, das Skript einfach zu erstellen. Nmap muss von diesem neuen Skript wissen, daher müssen wir die Nmap-Skriptdatenbank aktualisieren.

Um die Nmap-Skriptdatenbank zu aktualisieren, führen Sie den folgenden Befehl aus:

sudo nmap --script-updatedb

Die Ausgabe sollte in etwa so aussehen:

Starting Nmap 7.80 ( https://nmap.org )
NSE: Updating rule database.
NSE: Script Database updated successfully.
Nmap done: 0 IP addresses (0 hosts up) scanned in 0.36 seconds

Diese Ausgabe zeigt, dass die Skriptdatenbank erfolgreich aktualisiert wurde. Jetzt überprüfen wir, ob unser Skript zur Nmap-Skriptdatenbank hinzugefügt wurde. Wir können dies tun, indem wir nach unserem Skript in der script.db-Datei suchen.

grep port-check /usr/share/nmap/scripts/script.db

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Entry { filename = "port-check.nse", categories = { "discovery", "safe", } }

Dies bestätigt, dass unser Skript erfolgreich zur Nmap-Skriptdatenbank hinzugefügt wurde.

Jetzt erstellen wir noch ein Skript, das zeigt, wie man Bibliotheken in Nmap-Skripten verwendet. Bibliotheken sind vorgefertigter Code, den wir verwenden können, um unsere Skripte leistungsfähiger zu machen. Dieses Skript wird nach HTTP-Headern auf Webservern suchen. HTTP-Header enthalten wichtige Informationen über eine Webseite, wie z. B. den Typ des Servers, das Datum der letzten Änderung usw.

cat << 'EOF' > /usr/share/nmap/scripts/http-headers-check.nse
description = [[
A script that retrieves and displays HTTP headers from web servers.
]]

author = "LabEx User"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"discovery", "safe"}

local http = require "http"
local shortport = require "shortport"
local stdnse = require "stdnse"

-- The portrule determines when the script should be run
portrule = function(host, port)
  return shortport.http(host, port)
end

-- The action section contains the main function of the script
action = function(host, port)
  local response = http.get(host, port, "/")
  
  if not response or not response.status then
    return "Failed to retrieve HTTP headers"
  end
  
  local output = stdnse.output_table()
  output["Status"] = response.status
  
  if response.header then
    output["Headers"] = {}
    for name, value in pairs(response.header) do
      output["Headers"][name] = value
    end
  end
  
  return output
end
EOF

Dieses Skript verwendet mehrere Nmap-Bibliotheken:

  • http für das Senden von HTTP-Anfragen. Diese Bibliothek ermöglicht es unserem Skript, mit Webservern zu kommunizieren und Informationen von ihnen zu erhalten.
  • shortport für die Bestimmung, ob ein Port wahrscheinlich einen HTTP-Dienst ausführt. Sie hilft uns herauszufinden, ob ein bestimmter Port auf einem Host für Webverkehr verwendet wird.
  • stdnse für die Formatierung der Ausgabe. Dies macht die Informationen, die wir vom Webserver erhalten, leichter lesbar.

Lassen Sie uns die Skriptdatenbank erneut aktualisieren, damit Nmap von unserem neuen Skript weiß:

sudo nmap --script-updatedb

Jetzt führen wir unser neues Skript gegen einen Webserver aus. Zu Demonstrationszwecken verwenden wir einen lokalen Webserver auf Port 3001 (der oft von Entwicklungsservern verwendet wird).

nmap --script http-headers-check -p 3001 127.0.0.1

Wenn kein Webserver auf Port 3001 läuft, wird die Ausgabe anzeigen, dass der Port geschlossen oder gefiltert ist. Wenn es einen Webserver gibt, werden Sie die abgerufenen HTTP-Header sehen.

Schließlich führen wir beide unserer benutzerdefinierten Skripte zusammen aus. Auf diese Weise können wir die Ergebnisse beider Skripte auf einmal sehen.

nmap --script "port-check,http-headers-check" -p 22,3001 127.0.0.1

Dieser Befehl führt beide unsere benutzerdefinierten Skripte gegen die Ports 22 und 3001 auf dem localhost aus. Port 22 wird üblicherweise für SSH (Secure Shell)-Verbindungen verwendet.

Die Ausgabe wird anzeigen, ob diese Ports geöffnet sind, und wenn Port 3001 einen HTTP-Dienst ausführt, wird sie die HTTP-Header anzeigen.

Durch das Erstellen und Hinzufügen benutzerdefinierter Skripte zu Nmap können Sie seine Funktionalität erweitern, um spezifische Aufgaben auszuführen, die für Ihre Netzwerkscans und Sicherheitsbewertungen erforderlich sind.

Ausführen von Skriptkategorien und Verwalten der Skriptausgabe

In diesem Schritt werden wir untersuchen, wie man Nmap-Skripte nach Kategorie ausführt und die Ausgabe dieser Skriptscans verwaltet. Dies ist eine sehr nützliche Fähigkeit, da sie es Ihnen ermöglicht, mehrere verwandte Skripte auszuführen, ohne jedes einzeln angeben zu müssen.

Nmap-Skripte werden basierend auf ihrer Funktion in verschiedene Kategorien gruppiert. Das Verständnis dieser Kategorien hilft Ihnen, schnell die benötigten Skripte zu finden und auszuführen. Hier sind einige häufige Kategorien:

  • auth: Dies sind Skripte, die sich auf die Authentifizierung beziehen. Sie können Ihnen helfen, zu prüfen, ob die Authentifizierungsmechanismen eines Ziels sicher sind.
  • broadcast: Skripte in dieser Kategorie senden Broadcasts im lokalen Netzwerk. Sie sind nützlich, um Geräte und Dienste im gleichen Netzwerk zu entdecken.
  • brute: Dies sind Brute-Force-Passwort-Auditskripte. Sie versuchen verschiedene Passwörter, um zu sehen, ob sie unbefugten Zugang zu einem Dienst erhalten können.
  • default: Wenn Sie die Option -sC in Nmap verwenden, werden diese Skripte standardmäßig ausgeführt. Sie bieten einen guten Ausgangspunkt für einen grundlegenden Scan.
  • discovery: Diese Skripte werden für die Entdeckung von Hosts und Diensten verwendet. Sie können herausfinden, welche Hosts in einem Netzwerk verfügbar sind und welche Dienste sie ausführen.
  • dos: Denial-of-Service-Skripte sind darauf ausgelegt, ein Zielsystem zu überlasten und es nicht verfügbar zu machen. Seien Sie vorsichtig, wenn Sie diese verwenden, da sie echte Schäden verursachen können.
  • exploit: Exploitationsskripte werden verwendet, um bekannte Schwachstellen in einem System auszunutzen. Sie können für Sicherheitstests verwendet werden, sollten jedoch verantwortungsvoll eingesetzt werden.
  • external: Diese Skripte können Daten an Drittanbieter-Datenbanken senden. Sie können zusätzliche Informationen über das Ziel liefern, aber Sie müssen sich der Datenschutzimplikationen bewusst sein.
  • fuzzer: Fuzzer-Skripte verwenden Fuzzing-Techniken. Sie senden zufällige oder fehlerhafte Daten an ein Ziel, um zu sehen, ob es zu Fehlern oder der Entdeckung von Schwachstellen führt.
  • intrusive: Skripte in dieser Kategorie können Dienste abstürzen lassen oder als einmischend angesehen werden. Verwenden Sie sie mit Vorsicht, insbesondere in einer Produktionsumgebung.
  • malware: Malware-Detektionsskripte werden verwendet, um zu prüfen, ob ein Zielsystem mit Malware infiziert ist.
  • safe: Diese Skripte gelten als sicher und nicht einmischend. Sie verursachen keine Schäden am Zielsystem.
  • version: Versionserkennungsskripte helfen Ihnen, die Version der Software zu ermitteln, die auf einem Ziel-Dienst läuft. Diese Informationen können nützlich sein, um potenzielle Schwachstellen zu identifizieren.
  • vuln: Schwachstellendetektionsskripte werden verwendet, um Sicherheitslücken in einem Zielsystem zu finden.

Jetzt sehen wir uns an, wie man Skripte aus einer bestimmten Kategorie ausführt. Wenn Sie beispielsweise alle Skripte in der Kategorie "discovery" ausführen möchten, können Sie den folgenden Befehl verwenden:

nmap --script discovery 127.0.0.1

Dieser Befehl teilt Nmap mit, alle Entdeckungsskripte gegen den localhost (127.0.0.1) auszuführen. Die Ausgabe wird recht lang sein, da sie die Ergebnisse aller Entdeckungsskripte zeigt.

Manchmal möchten Sie möglicherweise Skripte aus mehreren Kategorien ausführen. Sie können dies tun, indem Sie die Kategorienamen mit einem Komma trennen. Hier ist ein Beispiel:

nmap --script "discovery,safe" -p 1-100 127.0.0.1

Dieser Befehl führt alle Skripte in den Kategorien discovery und safe gegen die Ports 1 - 100 auf dem localhost aus.

Sie können auch bestimmte Kategorien mit dem Operator not ausschließen. Beispielsweise:

nmap --script "discovery and not broadcast" 127.0.0.1

Dieser Befehl führt die Entdeckungsskripte aus, schließt jedoch alle aus, die auch in der Broadcast-Kategorie sind.

Als nächstes sehen wir uns verschiedene Möglichkeiten an, die Ausgabe von Nmap-Skriptscans zu formatieren und zu speichern. Nmap bietet mehrere Ausgabeformate, die für verschiedene Zwecke nützlich sind:

  1. Normale Ausgabe (Standard): Dies ist die Standardtextausgabe, die Nmap auf dem Bildschirm anzeigt.
  2. XML-Ausgabe: XML ist ein strukturiertes Format, das von anderen Tools leicht geparst werden kann.
  3. Grepable-Ausgabe: Dieses Format ist so gestaltet, dass es leicht mit Tools wie grep durchsucht werden kann.
  4. JSON-Ausgabe (mit dem entsprechenden Skript): JSON ist ein weiteres strukturiertes Format, das häufig für den Datenaustausch verwendet wird.

Um die Ausgabe im XML-Format zu speichern, können Sie den folgenden Befehl verwenden:

nmap --script vuln -p 1-1000 127.0.0.1 -oX /home/labex/project/scan_results.xml

Dieser Befehl führt alle Schwachstellenskripte gegen die Ports 1 - 1000 auf dem localhost aus und speichert die Ergebnisse im XML-Format in der Datei /home/labex/project/scan_results.xml.

Lassen Sie uns den Inhalt der XML-Datei überprüfen:

head -20 /home/labex/project/scan_results.xml

Dieser Befehl zeigt die ersten 20 Zeilen der XML-formatierte Ausgabe. Sie werden Informationen über den Scan, die verwendeten Optionen und die Scanergebnisse sehen.

Für die grepable-Ausgabe können Sie diesen Befehl verwenden:

nmap --script "default" 127.0.0.1 -oG /home/labex/project/scan_results.gnmap

Dieser Befehl speichert die Ergebnisse in einem Format, das leicht mit Tools wie grep geparst werden kann.

Lassen Sie uns den Inhalt der gnmap-Datei überprüfen:

cat /home/labex/project/scan_results.gnmap

Sie werden sehen, dass jeder Host in einer einzigen Zeile steht, was es einfach macht, nach bestimmten Informationen zu suchen.

Wenn Sie die Ausgabe gleichzeitig sowohl im normalen als auch im XML-Format speichern möchten, können Sie diesen Befehl verwenden:

nmap --script "default" 127.0.0.1 -oX /home/labex/project/scan_results2.xml -oN /home/labex/project/scan_results.txt

Dieser Befehl speichert die Ausgabe gleichzeitig sowohl im normalen Textformat als auch im XML-Format.

Schließlich können Sie die Option -oA verwenden, um die Ausgabe gleichzeitig in allen drei Formaten (normal, XML und grepable) zu speichern:

nmap --script "default" 127.0.0.1 -oA /home/labex/project/all_formats

Dieser Befehl erstellt drei Dateien:

  • /home/labex/project/all_formats.nmap (normale Ausgabe)
  • /home/labex/project/all_formats.xml (XML-Ausgabe)
  • /home/labex/project/all_formats.gnmap (grepable-Ausgabe)

Durch das Beherrschen dieser Techniken zum Ausführen von Skriptkategorien und Verwalten der Skriptausgabe können Sie effizient Netzwerkscans durchführen und die Ergebnisse für eine weitere Analyse organisieren.

Zusammenfassung

In diesem Lab haben Sie essentielle Fähigkeiten für die Arbeit mit Nmap's Scripting Engine (NSE) gelernt. Sie haben untersucht, wie man Nmap-Skripte nach ihrer Funktionalität kategorisiert und organisiert, was für effiziente Netzwerkscans und Sicherheitsbewertungen von entscheidender Bedeutung ist.

Sie haben praktische Erfahrungen in mehreren Bereichen gesammelt, darunter die Erkundung von Skriptkategorien, die Erstellung organisierter Verzeichnisse, das Verständnis von Skriptstrukturen, das Erstellen benutzerdefinierter Skripte, das Hinzufügen dieser Skripte zur Datenbank, das Ausführen von Skripten nach Kategorie mit logischen Operatoren und das Verwalten der Ausgabe in verschiedenen Formaten. Diese Fähigkeiten ermöglichen es Ihnen, die Funktionalität von Nmap auf Ihre spezifischen Bedürfnisse auszurichten. Durch das Beherrschen der Skripterstellung, -kategorisierung und -aktualisierung können Sie zielgerichtetere und effizientere Scanworkflows entwickeln. Die Fähigkeit, Scanergebnisse zu organisieren und zu formatieren, ist auch nützlich für die Dokumentation und die Kommunikation mit Teammitgliedern und Interessengruppen. Wenn Sie weiterhin Nmap nutzen, können Sie auf diesen Fähigkeiten aufbauen, um komplexere Skripte und Scanstrategien zu entwickeln.