Nmap-Scanning und Ergebnisanalyse lernen

Einführung

In diesem Lab lernen Sie, wie Sie Nmap verwenden, ein leistungsstarkes Netzwerk-Scanning-Tool, das von Sicherheitsexperten weit verbreitet eingesetzt wird, um Hosts und Dienste in einem Computernetzwerk zu entdecken. Sie werden verschiedene Ausgabeformate von Nmap erkunden, die für die Interpretation von Scanergebnissen und die Durchführung weiterer Analysen von entscheidender Bedeutung sind.

Nmap, kurz für Network Mapper, ist ein kostenloses und quelloffenes Werkzeug zur Netzwerkermittlung und Sicherheitsüberprüfung. Es nutzt Roh-IP-Pakete, um Informationen über Netzwerkhoste zu sammeln, wie z. B. verfügbare Dienste und Betriebssysteme. In diesem Lab werden Sie durch die Einrichtung eines Testdienstes geführt und diesen mit verschiedenen Nmap-Ausgabeoptionen scannen, was für eine effektive Netzwerkanalyse und Dokumentation von entscheidender Bedeutung ist.

Einrichten einer Testumgebung für Nmap-Scans

In diesem Schritt werden wir eine einfache Umgebung erstellen, in der Sie Nmap-Scans üben können. Nmap ist ein leistungsstarkes Tool für die Netzwerkexploration und Sicherheitsüberprüfung. Indem Sie auf Ihrem lokalen Rechner einen einfachen Webserver einrichten und ihn dann mit Nmap scannen, können Sie Netzwerkscans in einer sicheren und kontrollierten Umgebung lernen. Auf diese Weise können Sie experimentieren, ohne reale Netzwerke zu beeinträchtigen.

Einrichten eines lokalen Webservers

Zunächst müssen wir einen einfachen Webserver einrichten, den wir mit Nmap scannen können. Python bietet eine einfache Möglichkeit, einen grundlegenden HTTP-Server zu erstellen. Ein HTTP-Server ist eine Software, die Webseiten an Clients wie Browser ausliefern kann.

Öffnen Sie ein Terminal und navigieren Sie in Ihr Projektverzeichnis:
```
cd /home/labex/project
```
Der Befehl cd steht für "change directory" (Verzeichnis wechseln). Er ermöglicht es Ihnen, sich in Ihrem Dateisystem zu bewegen. In diesem Fall wechseln wir in das Verzeichnis /home/labex/project, in dem wir unseren Webserver einrichten werden.
Erstellen Sie eine einfache HTML-Datei, die der Server ausliefern soll:
```
echo "Welcome to Nmap Testing Environment" > index.html
```
Der Befehl echo gibt Text in das Terminal aus. Das Symbol > leitet diese Ausgabe in eine Datei um. Wir erstellen also eine Datei namens index.html mit dem Text "Welcome to Nmap Testing Environment". Dies wird die Webseite sein, die unser Server ausliefert.
Starten Sie einen Python-HTTP-Server auf Port 8080:
```
python3 -m http.server 8080 &
```
Der Befehl python3 -m http.server startet einen einfachen HTTP-Server mit Python. Die Angabe 8080 gibt die Portnummer an, auf der der Server lauscht. Ein Port ist wie eine Tür, durch die Netzwerkverkehr in einen Computer hinein- oder hinausfließt. Das & am Ende des Befehls lässt den Server im Hintergrund laufen, sodass Sie das Terminal weiterhin für andere Befehle nutzen können.
Überprüfen Sie, ob Ihr Webserver läuft, indem Sie ihn aufrufen:
```
curl http://localhost:8080
```
Der Befehl curl wird verwendet, um Daten von oder zu einem Server zu übertragen. Hier versuchen wir, auf den Webserver zuzugreifen, den wir gerade unter http://localhost:8080 eingerichtet haben. localhost bezieht sich auf den aktuellen Computer.

Sie sollten die folgende Ausgabe sehen:
```
Welcome to Nmap Testing Environment
```
Wenn Sie diese Ausgabe sehen, bedeutet dies, dass Ihr Webserver korrekt läuft.

Grundlegender Nmap-Scan

Nachdem Sie nun einen laufenden Webserver haben, können Sie ihn mit Nmap scannen. Ein Server-Scan hilft Ihnen zu ermitteln, welche Ports geöffnet sind und welche Dienste möglicherweise darauf laufen.

Führen Sie einen grundlegenden Nmap-Scan auf Ihrem lokalen Webserver aus:
```
nmap -p 8080 localhost
```
Die Option -p im nmap-Befehl gibt den zu scannenden Port an. In diesem Fall sagen wir Nmap, nur Port 8080 auf localhost (die IP-Adresse 127.0.0.1) zu scannen.

Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 12:34 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE
8080/tcp open  http-proxy

Nmap done: 1 IP address (1 host up) scanned in 0.05 seconds
```
Diese Ausgabe ist im Standardformat von Nmap, das für Menschen lesbar ist und die grundlegenden Informationen über den Scan anzeigt.

Verständnis der Standard-Nmap-Ausgabe

Lassen Sie uns verstehen, was die Standardausgabe zeigt:

Starting Nmap: Diese Zeile zeigt die Version von Nmap, die Sie verwenden, und die Zeit an, zu der der Scan gestartet wurde. Sie hilft Ihnen, zu verfolgen, wann der Scan initiiert wurde.
Nmap scan report: Dies gibt das Ziel des Scans an. In unserem Fall ist das Ziel localhost.
Host is up: Dies bestätigt, dass das Ziel online ist. Die Latenzzeit zeigt, wie lange Nmap brauchte, um eine Antwort vom Ziel zu erhalten.
PORT: Dies zeigt die Portnummer an, die gescannt wurde. In unserem Scan haben wir Port 8080 gescannt.
STATE: Dies gibt an, ob der Port geöffnet, geschlossen oder gefiltert ist. Ein geöffneter Port bedeutet, dass ein Dienst auf diesem Port lauscht und Verbindungen akzeptiert.
SERVICE: Nmap versucht zu erraten, welcher Dienst möglicherweise auf diesem Port läuft. Hier hat es http - proxy geraten.
Nmap done: Dies ist eine Zusammenfassung des Scans. Sie sagt Ihnen, wie viele IP-Adressen gescannt wurden und wie lange der Scan gedauert hat.

Sie haben nun erfolgreich eine Testumgebung eingerichtet und einen grundlegenden Nmap-Scan durchgeführt. Im nächsten Schritt werden Sie die verschiedenen Ausgabeformate erkunden, die Nmap bietet.

Erkundung verschiedener Nmap-Ausgabeformate

In diesem Schritt werden wir die verschiedenen Ausgabeformate kennenlernen, die Nmap bietet. Ausgabeformate sind in der Cybersicherheit von entscheidender Bedeutung, da sie es uns ermöglichen, die Scanergebnisse je nach Bedarf auf verschiedene Weise darzustellen. Einige Formate sind beispielsweise für Menschen leicht lesbar, während andere für die maschinelle Verarbeitung ausgelegt sind, was bei der Integration mit anderen Tools nützlich ist.

Überblick über die Nmap-Ausgabeformate

Nmap unterstützt mehrere Ausgabeformate, jedes mit seinen eigenen einzigartigen Eigenschaften und Anwendungsfällen:

Normale Ausgabe (Standard): Dies ist ein für Menschen lesbares Format. Es stellt die Scanergebnisse so dar, dass wir sie auf einen Blick verstehen können, was es ideal für eine schnelle manuelle Analyse macht.
XML-Ausgabe (-oX): XML steht für Extensible Markup Language (erweiterbare Auszeichnungssprache). Es ist ein strukturiertes Format, d. h. die Daten sind hierarchisch organisiert. Dies erleichtert es Programmen und Skripten, die Daten zu verarbeiten, und es wird häufig bei der Integration von Nmap mit anderen Sicherheitstools verwendet.
Grep-fähige Ausgabe (-oG): Dies ist ein zeilenbasiertes Format. Es ist so konzipiert, dass es leicht mit Unix-Tools wie grep, awk und cut verarbeitet werden kann. Dieses Format ist nützlich, wenn Sie schnell bestimmte Informationen aus den Scanergebnissen extrahieren möchten.
Script Kiddie-Ausgabe (-oS): Dieses Format ähnelt der normalen Ausgabe, enthält jedoch ASCII-Art. Es wird jedoch in praktischen Szenarien selten verwendet.
Alle Formate (-oA): Mit dieser Option können Sie die Scanergebnisse gleichzeitig in normalem, XML- und grep-fähigem Format speichern. Es ist eine bequeme Möglichkeit, alle Arten von Ausgaben auf einmal zur Verfügung zu haben.

Lassen Sie uns diese Formate erkunden, indem wir erneut Ihren lokalen Webserver scannen.

XML-Ausgabeformat

XML, oder Extensible Markup Language, ist ein strukturiertes Format, das weit verbreitet für die Datenspeicherung und -austausch verwendet wird. Seine hierarchische Struktur erleichtert es Programmen, die Daten zu verarbeiten, weshalb es häufig für die Integration mit anderen Sicherheitstools verwendet wird.

Führen Sie einen Nmap-Scan aus und speichern Sie die Ausgabe im XML-Format:
```
nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml
```
In diesem Befehl gibt -p 8080 an, dass wir Port 8080 scannen, localhost ist das Ziel, das wir scannen (unser lokaler Rechner), und -oX sagt Nmap, die Ausgabe im XML-Format in den angegebenen Dateipfad zu speichern.

Zeigen Sie die XML-Ausgabe an:

cat /home/labex/project/scan_results.xml

Der Befehl cat wird verwendet, um den Inhalt einer Datei anzuzeigen. Wenn Sie diesen Befehl ausführen, sehen Sie eine XML-formatierte Ausgabe, die in etwa so aussieht (abgekürzt):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE nmaprun>
<nmaprun scanner="nmap" args="nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml" ...>
  <scaninfo type="connect" protocol="tcp" .../>
  <verbose level="0"/>
  <debugging level="0"/>
  <host>
    <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="8080">
        <state state="open" reason="syn - ack" reason_ttl="0"/>
        <service name="http - proxy" method="table" conf="3"/>
      </port>
    </ports>
    <times srtt="97" rttvar="5000" to="100000"/>
  </host>
  <runstats>...</runstats>
</nmaprun>

Das XML-Format enthält detaillierte Informationen, die in einer hierarchischen Struktur organisiert sind. Lassen Sie uns die spezifischen Portinformationen extrahieren:
```
grep -A5 "<port " /home/labex/project/scan_results.xml > /home/labex/project/port_details.txt
```
Der Befehl grep wird verwendet, um ein bestimmtes Muster in einer Datei zu suchen. -A5 bedeutet, dass 5 Zeilen nach der Zeile angezeigt werden, die dem Muster entspricht. Wir suchen nach Zeilen, die <port enthalten, in der XML-Datei und speichern die Ergebnisse in einer neuen Datei namens port_details.txt.
Zeigen Sie die extrahierten Portdetails an:
```
cat /home/labex/project/port_details.txt
```
Wenn Sie diesen Befehl ausführen, wird Ihnen der Portinformationsabschnitt aus der XML angezeigt.

Grep-fähiges Ausgabeformat

Die grep-fähige Ausgabe ist speziell für die einfache Verarbeitung mit Tools wie grep, awk und cut konzipiert. Diese Unix-Tools sind sehr leistungsstark für die Textverarbeitung und können uns helfen, schnell die benötigten Informationen aus den Scanergebnissen zu extrahieren.

Führen Sie einen Nmap-Scan aus und speichern Sie die Ausgabe im grep-fähigen Format:
```
nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep
```
Hier sagt -oG Nmap, die Ausgabe im grep-fähigen Format in die angegebene Datei zu speichern.

Zeigen Sie die grep-fähige Ausgabe an:

cat /home/labex/project/scan_results.grep

Die Ausgabe wird in etwa so aussehen:

## Nmap 7.80 scan initiated Wed Nov 8 12:40:00 2023 as: nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep
Host: 127.0.0.1 (localhost)   Status: Up
Host: 127.0.0.1 (localhost)   Ports: 8080/open/tcp//http - proxy///
## Nmap done at Wed Nov 8 12:40:00 2023 -- 1 IP address (1 host up) scanned in 0.05 seconds

Das grep-fähige Format stellt alle Hostinformationen in einer einzigen Zeile dar, was es einfach macht, es mit Textverarbeitungstools zu verwenden. Beispielsweise können Sie nur die Zeile extrahieren, die die Portinformationen enthält:
```
grep "Ports:" /home/labex/project/scan_results.grep > /home/labex/project/ports_info.txt
```
Dieser Befehl sucht nach Zeilen, die das Wort "Ports:" enthalten, in der grep-fähigen Ausgabedatei und speichert die übereinstimmende Zeile in einer neuen Datei namens ports_info.txt.
Zeigen Sie die extrahierten Portinformationen an:
```
cat /home/labex/project/ports_info.txt
```

Simultanes Speichern in allen Formaten

Nmap bietet die bequeme Option, die Ausgabe gleichzeitig in mehreren Formaten zu speichern, indem Sie die -oA-Option verwenden. Dies kann Ihnen Zeit sparen, wenn Sie verschiedene Arten von Ausgaben für verschiedene Zwecke benötigen.

Führen Sie einen Nmap-Scan aus und speichern Sie die Ausgabe in allen Formaten:
```
nmap -p 8080 localhost -oA /home/labex/project/all_formats
```
Dieser Befehl scannt Port 8080 auf dem lokalen Rechner und speichert die Ergebnisse in normalem, XML- und grep-fähigem Format.
Überprüfen Sie die erstellten Dateien:
```
ls -la /home/labex/project/all_formats.*
```
Der Befehl ls -la listet alle Dateien in einem Verzeichnis mit detaillierten Informationen auf. Wenn Sie diesen Befehl ausführen, sollten Sie drei Dateien sehen:
- all_formats.nmap (normale Ausgabe)
- all_formats.xml (XML-Ausgabe)
- all_formats.gnmap (grep-fähige Ausgabe)

Sie verstehen nun die verschiedenen Ausgabeformate, die Nmap bietet, und wie Sie sie verwenden können. Jedes Format hat seine eigenen Vorteile:

Die normale Ausgabe ist für Menschen leicht lesbar.
Die XML-Ausgabe ist strukturiert für die maschinelle Verarbeitung und die Integration mit anderen Tools.
Die grep-fähige Ausgabe ist für eine schnelle Analyse mit Unix-Textverarbeitungstools konzipiert.

Im nächsten Schritt werden Sie lernen, wie Sie diese Ausgaben detaillierter analysieren können.

Analyse der Nmap-Ausgabe und Extraktion nützlicher Informationen

In diesem Schritt lernen Sie, wie Sie spezifische Informationen aus Nmap-Scanergebnissen extrahieren und analysieren können. Dies ist eine entscheidende Fähigkeit für Netzwerkadministratoren und Sicherheitsexperten. Bei der Bearbeitung von Netzwerkscans erhalten Sie oft eine große Menge an Daten. Die Fähigkeit, die relevanten Teile effizient zu extrahieren, hilft Ihnen, den Sicherheitsstatus des Netzwerks zu verstehen und potenzielle Probleme zu identifizieren.

Analyse der XML-Ausgabe

Die XML-Ausgabe ist für eine detaillierte Analyse sehr nützlich und kann leicht mit anderen Tools integriert werden. XML ist ein strukturiertes Format, das Daten hierarchisch organisiert, was es einfacher macht, spezifische Informationen zu finden und zu extrahieren. Lassen Sie uns untersuchen, wie man spezifische Informationen aus der XML-Ausgabe extrahiert.

Zunächst betrachten wir die Struktur der XML-Ausgabe, um zu verstehen, welche Informationen verfügbar sind. Wir verwenden den grep-Befehl, um den Anfang des Host-Abschnitts in der XML-Datei zu finden. Der grep-Befehl sucht nach einem angegebenen Muster in einer Datei.
```
grep "<host" -A2 /home/labex/project/scan_results.xml
```
Dieser Befehl sucht nach dem <host>-Tag in der scan_results.xml-Datei und zeigt die nächsten zwei Zeilen nach der Übereinstimmung an. Dies hilft uns, den Anfang des Host-Abschnitts in der XML-Datei zu sehen.
Jetzt extrahieren wir Informationen über den Portstatus. Wir verwenden erneut grep, um alle Zeilen zu finden, die das <state>-Tag enthalten, und speichern die Ergebnisse in einer neuen Datei.
```
grep "<state " /home/labex/project/scan_results.xml > /home/labex/project/port_state.txt
```
Zeigen Sie den extrahierten Portstatus an. Wir verwenden den cat-Befehl, der zum Anzeigen des Inhalts einer Datei verwendet wird.
```
cat /home/labex/project/port_state.txt
```
Sie sollten etwas wie Folgendes sehen:
```
<state state="open" reason="syn-ack" reason_ttl="0"/>
```
Dies sagt uns, dass der Port geöffnet ist. Nmap hat dies festgestellt, weil es ein SYN - ACK-Paket als Antwort auf sein SYN-Paket erhalten hat. Dies ist Teil der TCP-Dreifachhandshake-Prozedur, mit der eine TCP-Verbindung zwischen zwei Geräten in einem Netzwerk hergestellt wird.

Verwendung von regulären Ausdrücken für komplexere Extraktionen

Für komplexere Datenextraktionen können Sie reguläre Ausdrücke mit Tools wie grep, sed oder awk verwenden. Reguläre Ausdrücke sind eine leistungsstarke Möglichkeit, Muster in Texten zu suchen und zu übereinstimmen. Sie ermöglichen es Ihnen, komplexe Suchkriterien zu definieren.

Lassen Sie uns sowohl die Portnummer als auch ihren Status extrahieren. Wir verwenden grep mit einem regulären Ausdruck, um die relevanten Informationen in der XML-Datei zu finden und sie in einer neuen Datei zu speichern.
```
grep -o 'portid="[0-9]*".*state="[^"]*"' /home/labex/project/scan_results.xml > /home/labex/project/port_and_state.txt
```
Zeigen Sie die extrahierten Informationen mit dem cat-Befehl an.
```
cat /home/labex/project/port_and_state.txt
```
Sie sollten eine Ausgabe wie diese sehen:
```
portid="8080" state="open"
```

Analyse der grep-fähigen Ausgabe

Das grep-fähige Ausgabeformat ist so konzipiert, dass es leicht mit Standard-Unix-Tools verarbeitet werden kann. Es ist ein textbasiertes Format, das es einfach macht, nach spezifischen Informationen mit Befehlen wie grep zu suchen.

Lassen Sie uns nur die offenen Ports aus der grep-fähigen Ausgabe extrahieren. Wir verwenden grep, um alle Zeilen zu finden, die das Wort "open" enthalten, und speichern die Ergebnisse in einer neuen Datei.
```
grep "open" /home/labex/project/scan_results.grep > /home/labex/project/open_ports.txt
```
Zeigen Sie die extrahierten Informationen mit dem cat-Befehl an.
```
cat /home/labex/project/open_ports.txt
```
Dies sollte Ihnen die Zeile mit allen offenen Ports anzeigen.
Sie können dies weiter verarbeiten, um nur die Portnummern zu extrahieren. Wir verwenden eine Kombination aus grep- und cut-Befehlen. Der cut-Befehl wird verwendet, um spezifische Teile einer Zeile basierend auf einem Trennzeichen zu extrahieren.
```
grep "open" /home/labex/project/scan_results.grep | grep -o "8080/open" | cut -d "/" -f1 > /home/labex/project/port_numbers.txt
```
Zeigen Sie die extrahierten Portnummern mit dem cat-Befehl an.
```
cat /home/labex/project/port_numbers.txt
```
Sie sollten Folgendes sehen:
```
8080
```

Erstellung eines einfachen Zusammenfassungsberichts

Jetzt erstellen wir einen einfachen Zusammenfassungsbericht, der Informationen aus verschiedenen Teilen des Scans kombiniert. Ein Zusammenfassungsbericht hilft Ihnen, die wichtigsten Ergebnisse des Scans schnell zu verstehen.

Erstellen Sie einen Zusammenfassungsbericht. Wir verwenden den echo-Befehl, um Text in eine Datei zu schreiben. Der >>-Operator hängt den Text an das Ende der Datei an.

echo "Nmap Scan Summary" > /home/labex/project/scan_summary.txt
echo "----------------" >> /home/labex/project/scan_summary.txt
echo "Target: localhost (127.0.0.1)" >> /home/labex/project/scan_summary.txt
echo "Open ports:" >> /home/labex/project/scan_summary.txt
grep "open" /home/labex/project/scan_results.grep | grep -o "[0-9]*/open/tcp//[^/]*" >> /home/labex/project/scan_summary.txt

Zeigen Sie den Zusammenfassungsbericht mit dem cat-Befehl an.

cat /home/labex/project/scan_summary.txt

Die Ausgabe sollte wie folgt aussehen:

Nmap Scan Summary
----------------
Target: localhost (127.0.0.1)
Open ports:
8080/open/tcp//http - proxy

Durch das Erlernen, wie man spezifische Informationen aus Nmap-Scanergebnissen extrahiert und analysiert, können Sie Netzwerkrekonnaissance-Daten effizient verarbeiten und interpretieren. Diese Fähigkeit ist besonders wertvoll, wenn Sie große Netzwerke mit zahlreichen Hosts und Diensten scannen.

Im nächsten Schritt lernen Sie über fortgeschrittene Nmap-Scantechniken.

Fortgeschrittene Nmap-Scantechniken

In diesem Schritt werden wir fortgeschrittene Nmap-Scantechniken erkunden. Diese Techniken sind von entscheidender Bedeutung, da sie zusätzliche und detaillierte Informationen über Netzwerkdienste liefern können. Insbesondere werden wir uns auf die Erkennung der Dienstversion und das Skriptscannen konzentrieren. Das Verständnis dieser Techniken hilft Ihnen, tiefere Einblicke in die Netzwerkdienste zu gewinnen, die Sie scannen. Dies ist für Sicherheitsbewertungen, Netzwerkbestandsaufnahmen und die Fehlerbehebung unerlässlich.

Erkennung der Dienstversion

Nmap verfügt über eine leistungsstarke Funktion, die es ermöglicht, die spezifische Version eines auf einem Port laufenden Dienstes zu ermitteln. Dies geschieht mit der Option -sV. Die Kenntnis der Dienstversion kann sehr nützlich sein, da verschiedene Versionen unterschiedliche Sicherheitslücken oder Funktionen aufweisen können.

Führen Sie einen Nmap-Scan mit Dienstversionserkennung aus:
```
nmap -p 8080 -sV localhost -oN /home/labex/project/version_scan.txt
```
In diesem Befehl teilt die Option -sV Nmap mit, die offenen Ports zu untersuchen. Dadurch kann Nmap Informationen über die auf diesen Ports laufenden Dienste sammeln, einschließlich ihrer Versionen. Die Option -oN wird verwendet, um die Ausgabe des Scans in einem normalen Format in die angegebene Datei /home/labex/project/version_scan.txt zu speichern. Das Speichern der Ausgabe in einer Datei ermöglicht es Ihnen, die Ergebnisse später zu überprüfen.
Zeigen Sie die Scanergebnisse an:
```
cat /home/labex/project/version_scan.txt
```
Nach dem Ausführen des cat-Befehls sollten Sie eine Ausgabe ähnlich der folgenden sehen:
```
Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:20:00 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE VERSION
8080/tcp open  http    Python/3.10 aiohttp/3.8.1 (Python httpd)

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 6.52 seconds
```
Beachten Sie, dass Nmap jetzt nicht nur den Dienstnamen, sondern auch Versionsinformationen anzeigt. In diesem Fall hat es erkannt, dass der HTTP-Server mit Python 3.10 läuft. Diese detaillierten Informationen können verwendet werden, um potenzielle Sicherheitsrisiken zu identifizieren oder die Funktionen des Dienstes zu verstehen.

Verwendung von Nmap-Skripten (NSE)

Der Nmap Script Engine (NSE) ist ein leistungsstarkes Tool, das es Ihnen ermöglicht, Skripts auszuführen, um verschiedene Aufgaben durchzuführen. Diese Aufgaben reichen von der Diensterkennung bis hin zum Schwachstellenscannen. Durch die Verwendung von NSE-Skripten können Sie die Funktionalität von Nmap erweitern und mehr Informationen über das Zielnetzwerk sammeln.

Führen Sie ein einfaches HTTP-Informationen-Skript auf Ihrem Webserver aus:
```
nmap -p 8080 --script=http-title localhost -oN /home/labex/project/script_scan.txt
```
Das http-title-Skript ist dafür konzipiert, den Titel von HTTP-Webseiten abzurufen. Dies kann nützlich sein, um schnell den Inhalt oder Zweck einer Webseite zu identifizieren. Die Option -oN speichert die Ausgabe des Skriptscans in einem normalen Format in die angegebene Datei /home/labex/project/script_scan.txt.

Zeigen Sie die Skriptscanergebnisse an:

cat /home/labex/project/script_scan.txt

Die Ausgabe sollte etwas wie Folgendes enthalten:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:25:00 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE
8080/tcp open  http-proxy
|_http-title: Directory listing for /

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

Das http-title-Skript hat den Titel der Webseite abgerufen, in diesem Fall eine Verzeichnisauflistung. Diese Informationen können Ihnen helfen, die Struktur und den Inhalt des Webservers zu verstehen.

Versuchen wir ein anderes Skript, das mehr Informationen über den HTTP-Server liefert:
```
nmap -p 8080 --script=http-server-header localhost -oN /home/labex/project/server_header_scan.txt
```
Das http-server-header-Skript wird verwendet, um den HTTP-Server-Header abzurufen. Der Server-Header enthält oft Informationen über die Serversoftware, wie z. B. die Version und den Typ. Diese Informationen können für Sicherheitsbewertungen und Netzwerkbestandsaufnahmen wertvoll sein. Die Option -oN speichert die Ausgabe des Scans in einem normalen Format in die angegebene Datei /home/labex/project/server_header_scan.txt.

Zeigen Sie die Server-Header-Scanergebnisse an:

cat /home/labex/project/server_header_scan.txt

Die Ausgabe sollte Informationen über die Serversoftware enthalten:

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

PORT     STATE SERVICE
8080/tcp open  http-proxy
|_http-server-header: SimpleHTTP/0.6 Python/3.10.12

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

Kombination mehrerer Techniken

Sie können mehrere Scantechniken in einem einzigen Nmap-Befehl kombinieren, um einen umfassenderen Scan durchzuführen. Dies ermöglicht es Ihnen, auf einmal eine Vielzahl von Informationen über das Zielnetzwerk zu sammeln.

Führen Sie einen umfassenden Scan durch, der Portscanning, Dienstversionserkennung und Skriptscanning umfasst:
```
nmap -p 8080 -sV --script=http-title,http-server-header localhost -oA /home/labex/project/comprehensive_scan
```
Dieser Befehl führt mehrere Aufgaben aus:
- Er scannt Port 8080 (-p 8080), was bedeutet, dass er prüft, ob dieser Port auf dem Zielhost geöffnet ist.
- Er erkennt Dienstversionen (-sV) und liefert Informationen über die spezifischen Versionen der auf dem Port laufenden Dienste.
- Er führt die Skripte http-title und http-server-header aus (--script=http-title,http-server-header), die jeweils den Webseiten-Titel und die Server-Header-Informationen abrufen.
- Er speichert die Ergebnisse in allen Formaten (-oA). Das Speichern in allen Formaten stellt sicher, dass Sie verschiedene Darstellungen der Scanergebnisse für verschiedene Zwecke haben.
Zeigen Sie die umfassenden Scanergebnisse an:
```
cat /home/labex/project/comprehensive_scan.nmap
```
Die Ausgabe wird alle Informationen aus den vorherigen Scans kombiniert enthalten. Dies gibt Ihnen einen umfassenden Überblick über den auf Port 8080 laufenden Zielnetzwerkdienst.

Erstellen Sie einen endgültigen Analysebericht, der alle Ihre Erkenntnisse zusammenfasst:

echo "Final Nmap Analysis Report" > /home/labex/project/final_report.txt
echo "------------------------" >> /home/labex/project/final_report.txt
echo "Target: localhost (127.0.0.1)" >> /home/labex/project/final_report.txt
echo "Port: 8080/tcp (open)" >> /home/labex/project/final_report.txt
echo "Service:" >> /home/labex/project/final_report.txt
grep "SERVICE VERSION" -A1 /home/labex/project/version_scan.txt | tail -1 >> /home/labex/project/final_report.txt
echo "HTTP Server Header:" >> /home/labex/project/final_report.txt
grep "http-server-header:" /home/labex/project/server_header_scan.txt >> /home/labex/project/final_report.txt
echo "HTTP Page Title:" >> /home/labex/project/final_report.txt
grep "http-title:" /home/labex/project/script_scan.txt >> /home/labex/project/final_report.txt

Diese Reihe von Befehlen erstellt eine Textdatei namens final_report.txt und füllt sie mit einer Zusammenfassung aller aus den vorherigen Scans gesammelten Informationen. Sie enthält Details über das Ziel, den Port, die Dienstversion, den Server-Header und den Webseiten-Titel.

Zeigen Sie Ihren endgültigen Bericht an:
```
cat /home/labex/project/final_report.txt
```
Ihr endgültiger Bericht sollte eine umfassende Zusammenfassung aller Informationen enthalten, die Sie über den auf Port 8080 laufenden Webserver gesammelt haben. Dieser Bericht kann für weitere Analysen, Sicherheitsbewertungen oder Dokumentationszwecke verwendet werden.

Durch das Erlernen dieser fortgeschrittenen Nmap-Scantechniken können Sie detaillierte Informationen über Netzwerkdienste sammeln, die für Sicherheitsbewertungen, Netzwerkbestandsaufnahmen und die Fehlerbehebung von Wert sind.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Nmap verwenden können, ein leistungsstarkes Netzwerkscantool für die Netzwerkermittlung und Sicherheitsüberprüfung. Sie haben praktische Erfahrungen in verschiedenen Nmap - Operationen gesammelt, darunter das Einrichten einer Testumgebung mit einem lokalen Webserver, das Durchführen von grundlegenden Portscans, das Untersuchen verschiedener Ausgabeformate, das Extrahieren und Analysieren von Scanergebnissen sowie das Verwenden fortgeschrittener Techniken wie der Dienstversionserkennung und des Skriptscannens.

Diese Fähigkeiten sind für Netzwerkadministratoren, Sicherheitsanalysten und Penetrationstester unerlässlich. Sie ermöglichen es Ihnen, Netzwerkhoste und -dienste zu entdecken, die Netzwerkinfrastruktur zu dokumentieren, Sicherheits Probleme zu identifizieren sowie das Scannen und Berichterstellen zu automatisieren. Das Beherrschen von Nmap und seiner Ausgabeformate ermöglicht eine effektive Netzwerkermittlung, die Integration mit anderen Sicherheitswerkzeugen und das Erstellen umfassender Netzwerkbestandsaufnahmen. Die von Ihnen geübten Befehlszeilenfähigkeiten sind auch auf andere Systemadministrations - und Sicherheitsaufgaben übertragbar.