Nmap Grundlagen und Scan-Techniken lernen

Einführung

In diesem Lab lernen Sie die Grundlagen von Nmap, einem leistungsstarken Netzwerk-Scanning-Tool, das in der Cybersicherheit häufig für die Netzwerkermittlung und Sicherheitsüberprüfung eingesetzt wird. Sie werden untersuchen, wie Sie Nmap verwenden können, um Netzwerke zu scannen, offene Ports zu entdecken und laufende Dienste zu identifizieren.

Durch das Beherrschen dieser Techniken erwerben Sie essentielle Fähigkeiten für die Netzwerkverwaltung und Sicherheitsbewertung. Diese praktische Erfahrung bietet praktisches Wissen, das in realen Szenarien anwendbar ist und Ihnen hilft, die Netzwerkinfrastruktur und Sicherheitsüberlegungen zu verstehen.

Skills Graph

Grundlagen von Nmap verstehen

Nmap, kurz für Network Mapper, ist ein Open-Source-Tool, das eine entscheidende Rolle bei der Netzwerkermittlung und Sicherheitsüberprüfung spielt. In der Welt der Cybersicherheit ist es wie ein Detektiv, der rohe IP-Pakete verwendet, um Informationen zu sammeln. Mit Nmap können Sie herausfinden, welche Hosts in einem Netzwerk vorhanden sind, welche Dienste diese Hosts anbieten, welches Betriebssystem sie ausführen und andere wichtige Eigenschaften.

Lassen Sie uns unsere Reise mit den Grundlagen von Nmap beginnen. Zunächst müssen wir ein Terminal öffnen. Das Terminal ist wie ein Kommandozentrum, in dem Sie Befehle eingeben können, um mit Ihrem System zu interagieren. Sie können es öffnen, indem Sie auf das Terminal-Symbol in der Taskleiste klicken oder Ctrl+Alt+T drücken.

Sobald das Terminal geöffnet ist, müssen wir sicherstellen, dass wir uns im Projektverzeichnis befinden. Das Projektverzeichnis ist ein spezieller Ordner, in dem alle unseren zugehörigen Dateien und Operationen für dieses Experiment stattfinden. Um in das Projektverzeichnis zu navigieren, verwenden Sie den folgenden Befehl:

cd /home/labex/project

Jetzt, da wir am richtigen Ort sind, lassen Sie uns die installierte Version von Nmap auf unserem System überprüfen. Die Kenntnis der Version ist wichtig, da verschiedene Versionen unterschiedliche Funktionen und Verhaltensweisen haben können. Um die Version zu überprüfen, führen Sie diesen Befehl aus:

nmap --version

Nachdem Sie den Befehl ausgeführt haben, sollten Sie eine Ausgabe ähnlich dieser sehen. Diese Ausgabe zeigt die installierte Version von Nmap auf Ihrem System zusammen mit einigen anderen Informationen über die Bibliotheken, mit denen es kompiliert wurde, und die verfügbaren nsock-Engines.

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

Jetzt führen wir unseren ersten grundlegenden Nmap-Scan durch. Wir werden unseren Localhost scannen, was wie eine Selbstüberprüfung Ihres eigenen Systems ist. Dieser Scan hilft uns zu sehen, welche Ports auf unserem System geöffnet sind. Ports sind wie Türen in einem Gebäude; verschiedene Dienste verwenden verschiedene Ports, um zu kommunizieren. Führen Sie den folgenden Befehl aus:

nmap localhost

Dieser Befehl scannt die 1000 häufigsten Ports auf Ihrem Localhost. Nach dem Ausführen des Befehls sollten Sie eine Ausgabe ähnlich dieser sehen. Die Ausgabe zeigt uns, welche Ports auf unserem System geöffnet sind. Beispielsweise wird Port 22 normalerweise für SSH (Secure Shell) verwendet, ein Protokoll für den sicheren Zugriff auf einen Remotecomputer, und Port 80 wird für HTTP (Webdienste) verwendet. Beachten Sie, dass Ihre Ausgabe je nach den auf Ihrem System ausgeführten Diensten unterschiedliche offene Ports anzeigen kann.

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 15:45 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).
Not shown: 998 closed ports
PORT   STATE SERVICE
22/tcp open  ssh
80/tcp open  http

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

Für unsere nächste Übung benötigen wir einen Dienst zum Scannen. Wir werden einen einfachen Dienst mit netcat erstellen, einem vielseitigen Netzwerktool. Dieser Dienst wird auf Port 8888 lauschen. Führen Sie den folgenden Befehl aus:

nc -lk 8888 &

Lassen Sie uns diesen Befehl zerlegen. Die Option -l teilt netcat mit, auf eingehende Verbindungen zu lauschen. Die Option -k sorgt dafür, dass netcat auch nach dem Trennen eines Clients weiterhin lauscht. Das & am Ende führt den Befehl im Hintergrund aus, sodass Sie das Terminal weiterhin für andere Aufgaben verwenden können.

Um zu überprüfen, ob der Dienst läuft, können wir den folgenden Befehl verwenden:

netstat -tuln | grep 8888

Dieser Befehl listet alle Netzwerkverbindungen auf und filtert die Ausgabe, um nur die Informationen in Bezug auf Port 8888 anzuzeigen. Wenn der Dienst läuft, sollten Sie eine Ausgabe ähnlich dieser sehen:

tcp        0      0 0.0.0.0:8888            0.0.0.0:*               LISTEN

Diese Ausgabe bestätigt, dass unser Mock-Dienst läuft und auf Port 8888 lauscht.

Erkundung von Nmap-Portscanning-Techniken

Nmap ist ein leistungsstarkes Tool auf dem Gebiet der Cybersicherheit, insbesondere wenn es um Portscans geht. Portscanning ist eine Methode, um zu ermitteln, welche Ports auf einem Zielsystem geöffnet sind und welche Dienste möglicherweise auf diesen Ports laufen. Es gibt verschiedene Arten von Portscanning-Techniken, jede mit ihren eigenen einzigartigen Vorteilen und spezifischen Anwendungsfällen. In diesem Schritt werden wir einige dieser Techniken durch das Scannen unseres Mock-Dienstes erkunden.

Zunächst führen wir einen grundlegenden TCP Connect-Scan durch, der speziell auf unseren Port 8888 abzielt. Ein TCP Connect-Scan ist eine einfache Möglichkeit, zu überprüfen, ob ein Port geöffnet ist. Er funktioniert, indem er versucht, eine vollständige TCP-Verbindung zum Zielport herzustellen. Wenn die Verbindung erfolgreich ist, wird der Port als geöffnet angesehen.

nmap -p 8888 localhost

In diesem Befehl wird die Option -p verwendet, um anzugeben, welche Ports wir scannen möchten. Hier sagen wir Nmap, Port 8888 auf dem localhost (dem aktuellen Computer) zu scannen. Nach dem Ausführen dieses Befehls sollten Sie eine Ausgabe ähnlich der folgenden sehen:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 15:50 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

Diese Ausgabe bestätigt, dass unser Port 8888 geöffnet ist. Nmap hat auch den mit diesem Port verbundenen Dienstnamen gemäß seiner internen Datenbank identifiziert.

Jetzt versuchen wir einen SYN-Scan. Ein SYN-Scan ist im Vergleich zum TCP Connect-Scan eine diskretere Methode. Er vollzieht keine vollständige TCP-Verbindung, was es weniger wahrscheinlich macht, dass er von Intrusion Detection Systemen (Eindringlingserkennungssystemen) erkannt wird.

sudo nmap -sS -p 8888 localhost

Die Option -sS gibt an, dass wir einen SYN-Scan durchführen möchten. Dieser Scan erfordert Root-Rechte, da er das Senden roher Netzwerkpakete beinhaltet, was eine niedrigere Ebene der Netzwerkoperationen ist. Deshalb verwenden wir den sudo-Befehl. Die Ausgabe sollte ähnlich wie beim vorherigen Scan sein:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 15:55 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

Als nächstes versuchen wir einen UDP-Scan. UDP (User Datagram Protocol) ist ein anderer Typ von Netzwerkprotokoll im Vergleich zu TCP. Während TCP einen zuverlässigen, verbindungsorientierten Dienst bietet, ist UDP ein verbindungsloses Protokoll. Wir verwenden einen UDP-Scan, um zu überprüfen, ob Port 8888 für UDP-Verkehr geöffnet ist.

sudo nmap -sU -p 8888 localhost

Die Option -sU gibt einen UDP-Scan an. UDP-Scans können zeitaufwändiger sein als TCP-Scans, da UDP nicht über den gleichen eingebauten Bestätigungsmechanismus wie TCP verfügt. Daher muss Nmap länger warten, um zu bestimmen, ob ein Port geöffnet oder geschlossen ist. Die Ausgabe könnte so aussehen:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 16:00 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE  SERVICE
8888/udp closed sun-answerbook

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

Beachten Sie, dass der UDP-Port als geschlossen angezeigt wird. Dies ist zu erwarten, da unser netcat-Dienst auf TCP-Verbindungen wartet, nicht auf UDP.

Schließlich führen wir einen Dienstversionserkennungs-Scan durch. Dieser Scan hilft uns zu identifizieren, welcher spezifische Dienst und welche Version auf einem bestimmten Port läuft.

nmap -sV -p 8888 localhost

Die Option -sV teilt Nmap mit, eine Dienst-/Versionserkennung durchzuführen. Es versucht, spezifische Anfragen an die geöffneten Ports zu senden und die Antworten zu analysieren, um den Dienst und seine Version zu bestimmen. Die Ausgabe könnte so aussehen:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 16:05 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE VERSION
8888/tcp open  http    Apache httpd
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

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

Die Versionserkennung kann unseren netcat-Dienst möglicherweise nicht als echtes Programm korrekt identifizieren, aber es zeigt, wie Nmap versucht, zu bestimmen, was auf geöffneten Ports läuft.

Lassen Sie uns unsere Ergebnisse in einer Datei speichern, um sie später nachschlagen zu können. Das Speichern der Scanergebnisse ermöglicht es uns, sie später zu überprüfen, mit anderen zu teilen oder für weitere Analysen zu verwenden.

nmap -p 8888 localhost > /home/labex/project/nmap_scan_results.txt

In diesem Befehl wird das >-Symbol verwendet, um die Ausgabe des Nmap-Scans in eine Datei namens nmap_scan_results.txt im Verzeichnis /home/labex/project umzuleiten.

Sie können die gespeicherten Ergebnisse mit folgendem Befehl anzeigen:

cat /home/labex/project/nmap_scan_results.txt

Der cat-Befehl wird verwendet, um den Inhalt einer Datei anzuzeigen.

Dies schließt unsere Erkundung der verschiedenen Nmap-Portscanning-Techniken ab.

Verständnis von Timing- und Leistungsschablonen

Wenn Sie Nmap-Scans durchführen, spielt die Timing-Strategie eine entscheidende Rolle. Wenn Ihre Scans zu aggressiv sind, können sie von Intrusion Detection Systemen (IDS, Eindringlingserkennungssystemen) erkannt werden. Ein IDS ist ein Sicherheitstool, das den Netzwerkverkehr auf verdächtige Aktivitäten überwacht. Aggressive Scans können auch das Zielsystem überlasten, was dazu führen kann, dass es fehlerhaft arbeitet oder nicht mehr antwortet. Andererseits können zu langsame Scans eine unrealistisch lange Zeit in Anspruch nehmen, was insbesondere bei einer großen Anzahl von Zielen ineffizient ist.

Nmap bietet Timing-Schablonen, mit denen Sie die Geschwindigkeit und Aggressivität Ihrer Scans steuern können. Diese Schablonen reichen von T0 (paranoid) bis T5 (wahnsinnig). Je höher die Zahl, desto schneller und aggressiver wird der Scan.

Hier ist eine detaillierte Aufschlüsselung der Timing-Schablonen:

• -T0 (Paranoid): Dies ist eine extrem langsame Timing-Schablone. Sie wird hauptsächlich verwendet, wenn Sie Eindringlingserkennungssysteme umgehen möchten. Indem Anfragen sehr langsam gesendet werden, ist es weniger wahrscheinlich, dass Alarme im IDS ausgelöst werden.
• -T1 (Sneaky): Ähnlich wie die paranoid Schablone ist auch diese langsam und wird für das Umgehen von IDS verwendet. Sie sendet Anfragen etwas schneller als die paranoid Schablone, aber immer noch langsam genug, um nicht erkannt zu werden.
• -T2 (Polite): Diese Schablone verlangsamt den Scan, um weniger Bandbreite und Ressourcen auf dem Zielrechner zu verbrauchen. Sie ist eine gute Wahl, wenn Sie das Zielsystem nicht stören möchten.
• -T3 (Normal): Dies ist die Standard-Timing-Schablone von Nmap. Sie stellt ein Gleichgewicht zwischen Geschwindigkeit und Zuverlässigkeit her und eignet sich für die meisten allgemeinen Scans.
• -T4 (Aggressive): Diese Schablone beschleunigt den Scan, unter der Annahme, dass Sie ein hinreichend schnelles und zuverlässiges Netzwerk haben. Sie sendet Anfragen schneller, was die Gesamt-Scanzeit verkürzen kann.
• -T5 (Insane): Dies ist eine sehr aggressive Timing-Schablone. Sie setzt voraus, dass Sie ein außergewöhnlich schnelles Netzwerk haben. Sie sendet Anfragen mit einer sehr hohen Rate, was die Scanzeit erheblich verkürzen kann, aber auch das Risiko der Erkennung erhöht.

Beginnen wir damit, einen Scan mit der Standard-Timing-Schablone (T3) durchzuführen. Wir verwenden den time-Befehl, um zu messen, wie lange der Scan dauert. Der time-Befehl ist ein nützliches Tool, das Ihnen zeigt, wie viel Realzeit, Benutzerzeit und Systemzeit ein Befehl benötigt, um ausgeführt zu werden.

time nmap -T3 -p 8888 localhost

Nachdem Sie diesen Befehl ausgeführt haben, sollten Sie eine Ausgabe ähnlich der folgenden sehen:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 16:10 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

real    0m0.115s
user    0m0.033s
sys     0m0.015s

Jetzt versuchen wir eine aggressivere Timing-Schablone (T4). Wir verwenden erneut den time-Befehl, um die Scanzeit zu messen.

time nmap -T4 -p 8888 localhost

Sie werden möglicherweise bemerken, dass der Scan etwas schneller abgeschlossen wird. Hier ist ein Beispiel für die Ausgabe:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 16:15 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

real    0m0.105s
user    0m0.032s
sys     0m0.014s

Um einen deutlichereren Unterschied in der Scanzeit zu sehen, versuchen wir, alle Ports mit den Schablonen T3 und T4 zu scannen.

time nmap -T3 -p- --max-retries 0 localhost | grep "open" > /dev/null

Die Option -p- teilt Nmap mit, alle 65535 Ports auf dem Zielsystem zu scannen. Die Option --max - retries 0 reduziert die Anzahl der Wiederholungen für jeden Portscan, was dazu beiträgt, den Scan zu beschleunigen. Wir leiten die Ausgabe an grep weiter, um nur die Zeilen herauszufiltern, die das Wort "open" enthalten, und leiten dann das Ergebnis an /dev/null weiter, damit wir uns auf die Timing des Scans konzentrieren können.

time nmap -T4 -p- --max-retries 0 localhost | grep "open" > /dev/null

Sie sollten bei diesen umfassenden Scans einen deutlichen Unterschied in der Scanzeit bemerken.

Jetzt, wie in der ursprünglichen Übung verlangt, speichern wir ein diskretes Scanergebnis in einer Datei. Wir verwenden die T4-Timing-Schablone, um Geschwindigkeit und Zuverlässigkeit zu balancieren.

nmap -T4 -p 8888 localhost > /home/labex/project/nmap_stealthy_scan.txt

Sie können die gespeicherten Ergebnisse mit dem cat-Befehl anzeigen:

cat /home/labex/project/nmap_stealthy_scan.txt

Die T4-Timing-Schablone ist für die meisten Szenarien eine gute Wahl, da sie Geschwindigkeit und Zuverlässigkeit ausbalanciert. Bei der Durchführung von Sicherheitsbewertungen ist es wichtig, die Timing-Schablone auf Ihre spezifischen Anforderungen und Beschränkungen abzustimmen, wie z. B. die Netzwerkgeschwindigkeit, die Sensibilität des Zielsystems und das Risiko der Erkennung.

Ausgabeformate und Analyse von Scanergebnissen

Nmap bietet mehrere Ausgabeformate, die für verschiedene Zwecke äußerst nützlich sind. Beispielsweise können sie für die Dokumentation verwendet werden, um Ihre Scanergebnisse zu protokollieren, für eine weitere tiefergehende Analyse oder für die Integration mit anderen Sicherheitstools. In diesem Schritt werden wir uns diese Ausgabeformate genauer ansehen und lernen, wie wir die Scanergebnisse effektiv analysieren können.

Nmap unterstützt die folgenden Hauptausgabeformate:

1. Normale Ausgabe (Standard): Dies ist ein für Menschen lesbares Textformat. Es präsentiert die Scanergebnisse auf eine Weise, die Sie auf einen Blick verstehen können, ähnlich einem Bericht.
2. XML-Ausgabe (-oX): XML ist ein strukturiertes Format. Es ordnet die Daten hierarchisch und organisiert an, was für Programme sehr praktisch zum Parsen und Verarbeiten ist.
3. Greppable-Ausgabe (-oG): Dieses Format ist so gestaltet, dass es einfach mit Tools wie grep und anderen Textverarbeitungs-Utilities geparst werden kann. Es hat eine spezifische Struktur, die es einfach macht, relevante Informationen zu extrahieren.
4. Alle Formate (-oA): Wenn Sie diese Option verwenden, speichert Nmap die Scanergebnisse gleichzeitig im normalen, XML- und Greppable-Format. Dies ist nützlich, wenn Sie alle Arten von Ausgaben für verschiedene Bedürfnisse haben möchten.

Versuchen wir nun jedes dieser Formate nacheinander:

Zunächst speichern wir einen Scan im normalen Format. Der folgende Befehl scannt Port 8888 auf dem localhost und speichert die Ergebnisse in einer Textdatei:

nmap -p 8888 localhost -oN /home/labex/project/normal_output.txt

Jetzt speichern wir einen Scan im XML-Format. Dieser Befehl führt denselben Scan auf Port 8888 des localhost durch und speichert die Ergebnisse in einer XML-Datei:

nmap -p 8888 localhost -oX /home/labex/project/xml_output.xml

Als nächstes speichern wir einen Scan im Greppable-Format. Der folgende Befehl scannt Port 8888 auf dem localhost und speichert die Ergebnisse in einer Datei, die einfach von grep geparst werden kann:

nmap -p 8888 localhost -oG /home/labex/project/grep_output.txt

Schließlich speichern wir einen Scan in allen Formaten. Der folgende Befehl erstellt drei Dateien mit verschiedenen Formaten für denselben Scan auf Port 8888 des localhost:

nmap -p 8888 localhost -oA /home/labex/project/all_formats

Dadurch werden drei Dateien erstellt: all_formats.nmap, all_formats.xml und all_formats.gnmap.

Jetzt untersuchen wir jede dieser Dateien, um die Unterschiede in ihren Formaten zu verstehen.

Um die normale Ausgabe anzuzeigen, verwenden wir den cat-Befehl:

cat /home/labex/project/normal_output.txt

Sie sollten die Standard-Nmap-Ausgabe sehen, die für Menschen leicht lesbar ist. Hier ist ein Beispiel für die mögliche Ausgabe:

## Nmap 7.80 scan initiated Mon Oct 30 16:45:00 2023 as: nmap -p 8888 -oN /home/labex/project/normal_output.txt localhost
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00010s latency).

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

## Nmap done at Mon Oct 30 16:45:00 2023 -- 1 IP address (1 host up) scanned in 0.04 seconds

Um die XML-Ausgabe anzuzeigen, verwenden wir ebenfalls den cat-Befehl:

cat /home/labex/project/xml_output.xml

Dieses Format ist für das einfache Parsen durch Programme strukturiert. Hier ist ein Beispiel für die XML-Ausgabe:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE nmaprun>
<nmaprun scanner="nmap" args="nmap -p 8888 -oX /home/labex/project/xml_output.xml localhost" start="1698684307" startstr="Mon Oct 30 16:45:07 2023" version="7.80" xmloutputversion="1.04">
<scaninfo type="connect" protocol="tcp" numservices="1" services="8888"/>
<verbose level="0"/>
<debugging level="0"/>
<host starttime="1698684307" endtime="1698684307"><status state="up" reason="conn-refused" reason_ttl="0"/>
<address addr="127.0.0.1" addrtype="ipv4"/>
<hostnames>
<hostname name="localhost" type="user"/>
<hostname name="localhost" type="PTR"/>
</hostnames>
<ports><port protocol="tcp" portid="8888"><state state="open" reason="syn-ack" reason_ttl="0"/><service name="sun-answerbook" method="table" conf="3"/></port>
</ports>
<times srtt="100" rttvar="5000" to="100000"/>
</host>
<runstats><finished time="1698684307" timestr="Mon Oct 30 16:45:07 2023" elapsed="0.04" summary="Nmap done at Mon Oct 30 16:45:07 2023; 1 IP address (1 host up) scanned in 0.04 seconds" exit="success"/><hosts up="1" down="0" total="1"/>
</runstats>
</nmaprun>

Um die Greppable-Ausgabe anzuzeigen, verwenden wir erneut den cat-Befehl:

cat /home/labex/project/grep_output.txt

Dieses Format ist so gestaltet, dass es einfach mit Tools wie grep geparst werden kann. Hier ist ein Beispiel für die Greppable-Ausgabe:

## Nmap 7.80 scan initiated Mon Oct 30 16:45:15 2023 as: nmap -p 8888 -oG /home/labex/project/grep_output.txt localhost
Host: 127.0.0.1 (localhost)	Status: Up
Host: 127.0.0.1 (localhost)	Ports: 8888/open/tcp//sun-answerbook///
## Nmap done at Mon Oct 30 16:45:15 2023 -- 1 IP address (1 host up) scanned in 0.04 seconds

Üben wir nun das Verwenden von grep, um spezifische Informationen aus der Greppable-Ausgabe zu extrahieren. Der folgende Befehl zeigt alle Zeilen mit offenen Ports an:

grep "open" /home/labex/project/grep_output.txt

Die Ausgabe sollte wie folgt aussehen:

Host: 127.0.0.1 (localhost)	Ports: 8888/open/tcp//sun-answerbook///

Sie können auch komplexere Filter verwenden. Der folgende Befehl extrahiert nur die Portnummer der offenen Ports:

grep -E "Ports:.*open" /home/labex/project/grep_output.txt | cut -d':' -f3 | cut -d'/' -f1

Die Ausgabe wird sein:

8888

Diese verschiedenen Ausgabeformate ermöglichen es Ihnen, die Nmap-Scanergebnisse mit anderen Tools und Workflows zu integrieren, was Nmap zu einem vielseitigen Bestandteil Ihres Sicherheitstoolkits macht.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen von Nmap gelernt, einem leistungsstarken Netzwerkscanning- und Sicherheitsbewertungstool. Sie haben zunächst die grundlegende Verwendung von Nmap beherrscht, wie z. B. das Scannen von Hosts und das Identifizieren offener Ports. Anschließend haben Sie verschiedene Portscanning-Techniken wie TCP Connect Scans, SYN Scans und UDP Scans erkundet, die jeweils einzigartige Vorteile und Anwendungsfälle haben.

Sie haben auch das Verwenden von Timing-Schablonen geübt, um die Scan-Geschwindigkeit und die Diskretion auszugleichen. Schließlich haben Sie gelernt, Scanergebnisse in verschiedenen Formaten zu speichern und mit Textverarbeitungstools zu analysieren. Diese Fähigkeiten bilden die Grundlage für die Netzwerkermittlung, Sicherheitsbewertung und Schwachstellenidentifizierung. Nmap ist für Netzwerkadministratoren, Sicherheitsexperten und ethische Hacker von entscheidender Bedeutung. Denken Sie daran, diese Tools verantwortungsvoll und ethisch einzusetzen, und holen Sie sich immer die entsprechende Genehmigung, bevor Sie unbekannte Netzwerke oder Systeme scannen.