Nmap Vollständiger Leitfaden

Aus Xinux Wiki
Zur Navigation springen Zur Suche springen

Nmap – Vollständiger Leitfaden

Nmap (Network Mapper) ist das zentrale Werkzeug für Host-Discovery, Port-Scanning, Service-Erkennung und Schwachstellenanalyse in der Netzwerksicherheit. Dieser Artikel deckt den kompletten Weg vom ersten Scan bis zum Schreiben eigener NSE-Scripts ab. Als Ziel dient durchgängig 192.168.1.10 bzw. das Netz 192.168.1.0/24.

Rechtlicher Hinweis

Nmap-Scans sind ohne ausdrückliche Erlaubnis des Netzbetreibers strafbar (§ 202a–c StGB bzw. vergleichbare Regelungen). Zum Üben eignet sich scanme.nmap.org – dieser Host ist von den Nmap-Entwicklern ausdrücklich zum Testen freigegeben.

Grundlagen

Was Nmap kann

Funktion Beschreibung
Host Discovery Ermittelt, welche Hosts in einem Netz aktiv sind
Port Scanning Ermittelt offene, geschlossene und gefilterte Ports
Service Detection Erkennt Dienst und Version hinter einem offenen Port
OS Fingerprinting Erkennt das Betriebssystem anhand des TCP/IP-Stack-Verhaltens
NSE Scripting Führt Lua-Scripts für Automatisierung, Enumeration und Schwachstellenprüfung aus
Output & Reporting Erzeugt Ergebnisse in mehreren maschinen- und menschenlesbaren Formaten

Architektur

Nmap besteht aus mehreren zusammenspielenden Komponenten:

  • Core Engine – rohes Senden/Empfangen von Paketen (benötigt Root für Raw Sockets)
  • Host Discovery Engine – filtert tote Hosts vor dem eigentlichen Scan heraus
  • Port Scanner – klassifiziert jeden Port
  • Version Detection Engine – identifiziert Dienst und Version
  • OS Detection Engine – vergleicht TCP/IP-Antworten mit einer Fingerprint-Datenbank
  • NSE – eingebetteter Lua-Interpreter für Scripting
  • Output Engine – schreibt Ergebnisse in mehreren Formaten gleichzeitig

Scan-Lebenszyklus

  1. Zielspezifikation – IPs, Bereiche, CIDR, Hostnamen oder Dateiliste einlesen
  2. Host Discovery – prüfen, welche Ziele überhaupt leben (außer bei -Pn)
  3. Reverse-DNS-Auflösung – außer bei -n
  4. Port-Scan – Zustand jedes Ports ermitteln
  5. Versionserkennung – nur mit -sV
  6. OS-Erkennung – nur mit -O
  7. NSE-Ausführung – nur mit --script
  8. Ausgabe – Ergebnis in gewähltem Format schreiben

Port-States

Zustand Bedeutung
open Dienst nimmt aktiv Verbindungen an
closed Port erreichbar, aber kein Dienst dahinter (RST erhalten)
filtered Keine Antwort oder ICMP-Fehler – vermutlich Firewall
unfiltered Port erreichbar, Zustand offen/geschlossen aber nicht bestimmbar (z. B. bei ACK-Scan)
filtered Keine Antwort erhalten – könnte offen oder gefiltert sein

Installation & erster Scan

Installation

Plattform Befehl
Kali Linux vorinstalliert
Ubuntu/Debian sudo apt install nmap -y
RHEL/Fedora sudo dnf install nmap
Arch Linux sudo pacman -S nmap
macOS (Homebrew) brew install nmap
aus dem Quellcode git clone https://github.com/nmap/nmap && cd nmap && ./configure && make && sudo make install
Installation prüfen
  • nmap --version
NSE-Datenbank aktualisieren
  • sudo nmap --script-updatedb

Erster Scan

Einfachster Scan (Top-1000-Ports, SYN-Scan, braucht Root)
  • sudo nmap 192.168.1.10
Legalen Übungshost scannen
  • sudo nmap scanme.nmap.org

Zielspezifikation

Einzelne IP
  • nmap 192.168.1.10
IP-Bereich
  • nmap 192.168.1.1-254
CIDR-Notation
  • nmap 192.168.1.0/24
Mehrere Ziele
  • nmap 192.168.1.1 192.168.1.10 10.0.0.1
Ziele aus Datei
  • nmap -iL targets.txt
IPs aus einem Bereich ausschließen
  • nmap 192.168.1.0/24 --exclude 192.168.1.1,192.168.1.254
Ausschlussliste aus Datei
  • nmap 192.168.1.0/24 --excludefile exclude.txt
Ziele nur auflisten, ohne zu scannen (Dry-Run)
  • nmap -sL 192.168.1.0/24

Host Discovery

Host Discovery ist Phase 1 jedes Scans: Bevor Ports geprüft werden, wird ermittelt, welche Adressen überhaupt einen aktiven Host haben. Auf einem /24-Netz mit 256 Adressen aber nur 10 aktiven Hosts spart das enorm Zeit.

Standard-Discovery

Als Root sendet Nmap standardmäßig vier verschiedene Sondierungen und wertet jede Antwort als "lebt":

Sondierung Zweck
ICMP Echo Request klassischer Ping
TCP SYN an Port 443 SYN-ACK oder RST von aktiven Hosts
TCP ACK an Port 80 RST von zustandsbehafteten Hosts
ICMP Timestamp Request wird von manchen Firewalls auch bei blockiertem Echo erlaubt

Discovery-Techniken

Ping Sweep – nur lebende Hosts finden, keine Portscans
  • sudo nmap -sn 192.168.1.0/24
ARP-Scan – zuverlässigste Methode im lokalen Netz, umgeht IP-Firewalls
  • sudo nmap -sn -PR 192.168.1.0/24
TCP-SYN-Ping – nützlich wenn ICMP blockiert, aber Webserver erreichbar sind
  • sudo nmap -sn -PS80,443,8080 192.168.1.0/24
TCP-ACK-Ping – funktioniert bei zustandslosen Firewalls ohne SYN-Tracking
  • sudo nmap -sn -PA80,443 192.168.1.0/24
UDP-Ping
  • sudo nmap -sn -PU53,161,123 192.168.1.0/24
Host Discovery deaktivieren – alle Ziele als aktiv annehmen
  • sudo nmap -Pn 192.168.1.0/24

Discovery-Flags im Überblick

Flag Bedeutung
-sn nur Ping-Scan, kein Portscan
-Pn Discovery überspringen, alle Ziele als aktiv behandeln
-PR ARP-Ping (lokales Netz, sehr zuverlässig)
-PS [Ports] TCP-SYN-Ping
-PA [Ports] TCP-ACK-Ping
-PU [Ports] UDP-Ping
-PE / -PP / -PM ICMP Echo / Timestamp / Address-Mask-Ping
--disable-arp-ping ARP-Discovery deaktivieren (z. B. in Cloud-Umgebungen)
--traceroute Route zu jedem gefundenen Host aufzeichnen
Discovery-Ergebnis speichern und später für gezieltes Port-Scanning nutzen
sudo nmap -sn -oG live_hosts.gnmap 192.168.1.0/24
grep 'Up' live_hosts.gnmap | awk '{print $2}' > hosts.txt
sudo nmap -iL hosts.txt -sS -T4 -p-
Hinweis für den SOC-Alltag

Ein Ping Sweep erzeugt ein sehr auffälliges Muster: sequenzielle ICMP-Anfragen an jede IP eines Bereichs, oft innerhalb weniger Sekunden. In NetFlow-Daten und jedem IDS/SIEM ist das gut sichtbar. Ein Ping Sweep von einer internen Workstation (nicht vom eigenen Scanner) ist ein starkes Indiz für Recon durch einen Angreifer.

Port-Scanning-Techniken

Scan-Typen im Vergleich

Flag Scan-Typ Root nötig Vollständiger Handshake Einsatz
-sS TCP-SYN-Scan ja nein Standard, unauffällig, in 99 % der Fälle die richtige Wahl
-sT TCP-Connect-Scan nein ja wenn kein Root verfügbar ist; wird in Anwendungslogs sichtbar
-sU UDP-Scan ja entfällt für DNS, SNMP, NTP – langsam, aber notwendig
-sA TCP-ACK-Scan ja nein bildet Firewall-Regeln ab, bestimmt nicht open/closed
-sW TCP-Window-Scan ja nein unterscheidet auf manchen Systemen open/closed über die TCP-Window-Größe
-sN TCP-Null-Scan ja nein keine Flags gesetzt, Firewall-Umgehung, wirkt nur bei Unix-Stacks
-sF TCP-FIN-Scan ja nein nur FIN-Flag, ähnliche Logik wie Null-Scan
-sX TCP-Xmas-Scan ja nein FIN+PSH+URG gesetzt, gleiche Umgehungstechnik
-sY / -sZ SCTP-Scan ja nein für VoIP/Telco-Netze
-sO IP-Protokoll-Scan ja entfällt ermittelt, welche IP-Protokolle unterstützt werden

TCP-SYN-Scan – der Standard

Der SYN-Scan ist Nmaps Standard als Root. Er sendet ein SYN-Paket und wartet auf Antwort. Offene Ports antworten mit SYN-ACK; Nmap schickt sofort ein RST, bevor die Verbindung vollständig aufgebaut wird. Dadurch taucht der Scan in den meisten Anwendungslogs gar nicht auf – nur in Firewall- und Kernel-Logs.

SYN-Scan der Top-1000-Ports
  • sudo nmap -sS 192.168.1.10
SYN-Scan aller 65535 Ports
  • sudo nmap -sS -p- 192.168.1.10

TCP-Connect-Scan

Funktioniert ohne Root, vollständiger Drei-Wege-Handschlag
  • nmap -sT 192.168.1.10

UDP-Scan

UDP-Scans sind wichtig, weil zentrale Dienste wie DNS, SNMP und NTP nur über UDP laufen – werden aber oft vernachlässigt, weil sie deutlich langsamer sind: geschlossene Ports antworten mit ICMP Port Unreachable (vom Kernel auf 1/Sekunde gedrosselt), offene UDP-Ports antworten häufig überhaupt nicht.

UDP-Scan wichtiger Dienste
  • sudo nmap -sU -p 53,67,68,69,123,161,162,500,514,1194 192.168.1.10
TCP- und UDP-Scan kombinieren
  • sudo nmap -sS -sU -p T:80,443,22,445 -p U:53,161,123 192.168.1.0/24

Firewall-Umgehungs-Scans

Null-Scan – keine Flags gesetzt; laut RFC 793 antworten geschlossene Ports mit RST, offene schweigen (funktioniert nur auf Unix-Stacks)
  • sudo nmap -sN 192.168.1.10
FIN-Scan – nur das FIN-Flag gesetzt
  • sudo nmap -sF 192.168.1.10
Xmas-Scan – FIN, PSH und URG gesetzt ("wie ein leuchtender Weihnachtsbaum")
  • sudo nmap -sX 192.168.1.10
ACK-Scan – bildet Firewall-Regeln ab, sagt nichts über open/closed
  • sudo nmap -sA 192.168.1.10

Port-Auswahl

Syntax Bedeutung
-p 22 nur Port 22
-p 22,80,443 bestimmte Ports
-p 1-1024 Portbereich
-p- alle 65535 Ports
-p U:53,T:80 UDP- und TCP-Port gleichzeitig
-p http,ftp,ssh Auswahl nach Dienstname (aus /etc/services)
--top-ports 100 die 100 häufigsten Ports
-F Fast-Modus, nur Top-100-Ports
-r Ports der Reihe nach statt zufällig scannen

Service- & Versionserkennung

Zu wissen, dass ein Port offen ist, reicht selten. Die Versionserkennung (-sV) findet heraus, welcher Dienst mit welcher Version dahinter läuft – aus "Port 80 offen" wird "Apache httpd 2.4.52 auf Ubuntu". Nmap schickt dafür protokollspezifische Sondierungen an jeden offenen Port und gleicht die Antwort gegen eine Datenbank mit über 11.000 Signaturen ab.

Versionserkennung aktivieren
  • sudo nmap -sV 192.168.1.10
Intensität erhöhen (0 = nur wahrscheinlichste Sonden, 9 = alle Sonden probieren)
  • sudo nmap -sV --version-intensity 9 192.168.1.10
Flag Bedeutung
--version-intensity 0-9 Sondierungstiefe einstellen (Standard: 7)
--version-light entspricht Intensität 2, schnelle Erkennung
--version-all entspricht Intensität 9, versucht wirklich jede Sonde
--version-trace zeigt die Versionserkennung im Detail (Debugging)
Banner manuell auslesen ohne Nmap
nc -w 3 192.168.1.10 22
echo -e 'HEAD / HTTP/1.0\r\n' | nc 192.168.1.10 80
nc 192.168.1.10 25
TLS-Zertifikatsdaten direkt mit OpenSSL
  • openssl s_client -connect 192.168.1.10:443 2>/dev/null | openssl x509 -noout -text | grep -E 'Subject:|Issuer:|Not After'

OS-Erkennung & Fingerprinting

Die OS-Erkennung (-O) analysiert, wie unterschiedliche Betriebssysteme denselben TCP/IP-Sonden antworten, und vergleicht das Ergebnis mit einer Datenbank von über 5000 Fingerprints.

Geprüfte Merkmale

Merkmal Beschreibung
Initial Sequence Number manche OS generieren sie zufällig, andere zeitbasiert
TCP-Optionen welche Optionen (MSS, SACK, Window Scale, Timestamps) in welcher Reihenfolge unterstützt werden
Window Size initiale Empfangsfenstergröße unterscheidet sich je nach OS/Version
IP-TTL Linux meist 64, Windows meist 128, manche Cisco-Systeme 255
TCP-Flags Reaktion auf ungewöhnliche Flag-Kombinationen (SYN+FIN, URG, NULL)
ICMP-Antworten Formatierung von ICMP-Fehlermeldungen unterscheidet sich
Don't-Fragment-Bit ob das DF-Bit in SYN-Antworten gesetzt wird
ECN-Unterstützung Explicit Congestion Notification, Support und Antwortformat
OS-Erkennung aktivieren
  • sudo nmap -O 192.168.1.10
Aggressiver Scan (OS + Version + Scripts + Traceroute in einem)
  • sudo nmap -A 192.168.1.10
OS-Erkennung erzwingen, auch bei unklaren Bedingungen
  • sudo nmap -O --osscan-guess 192.168.1.10
OS-Erkennung nur bei vielversprechenden Zielen versuchen
  • sudo nmap -O --osscan-limit 192.168.1.0/24
Hinweis zur Genauigkeit

Für eine zuverlässige OS-Erkennung braucht Nmap mindestens einen offenen und einen geschlossenen TCP-Port. Sind alle Ports gefiltert, kann Nmap das OS nicht sicher bestimmen – -Pn hilft hier nicht direkt, sondern nur ein Scan, der tatsächliche Portzustände sichtbar macht.

Nmap Scripting Engine (NSE)

Die NSE ist Nmaps mächtigstes Feature: ein eingebetteter Lua-Interpreter mit Zugriff auf über 600 Scripts für automatisierte Schwachstellenprüfung, Enumeration, Credential-Brute-Force und mehr – alles über dieselbe Netzwerkverbindung, die Nmap ohnehin aufbaut.

Script-Kategorien

Kategorie Beschreibung
auth Authentifizierung und Credential-Brute-Force
broadcast Dienste im lokalen Netz per Broadcast entdecken
brute Credential-Brute-Force gegen Netzwerkdienste
default sichere Scripts, die mit -sC oder -A laufen
discovery sammelt zusätzliche Informationen über das Ziel
dos Denial-of-Service-Tests – gefährlich, kann Ziele zum Absturz bringen
exploit aktive Ausnutzung bekannter Schwachstellen – nur mit Erlaubnis
external Anfragen an externe Datenbanken (z. B. VirusTotal)
fuzzer sendet Zufallsdaten zur Absturzerkennung
intrusive aggressivere Scripts, können Zielstabilität beeinflussen
malware erkennt Anzeichen von Malware/Backdoors
safe unwahrscheinlich, das Ziel negativ zu beeinflussen
version erweitert die eingebaute Versionserkennung
vuln prüft auf konkrete Schwachstellen

NSE-Scripts ausführen

Default-Scripts (Kurzform für --script=default)
  • sudo nmap -sC 192.168.1.10
Alle Scripts einer Kategorie
  • sudo nmap --script=vuln 192.168.1.10
Einzelnes Script
  • sudo nmap --script=http-title 192.168.1.10
Mehrere Scripts
  • sudo nmap --script=http-title,http-headers,http-methods 192.168.1.10
Wildcard-Muster
  • sudo nmap --script='http-*' 192.168.1.10
Scripts mit Argumenten
  • sudo nmap --script=http-brute --script-args http-brute.path=/login 192.168.1.10
Version- und Default-Scripts kombiniert (entspricht -A ohne OS-Erkennung)
  • sudo nmap -sV -sC 192.168.1.10

Wichtige Scripts nach Bereich

Netzwerk & Discovery

SNMP-Community-Strings und OIDs auslesen
  • sudo nmap -sU -p 161 --script=snmp-info,snmp-sysdescr,snmp-interfaces 192.168.1.1
DNS-Zonentransfer prüfen (kritische Fehlkonfiguration, wenn erlaubt)
  • sudo nmap --script=dns-zone-transfer --script-args dns-zone-transfer.domain=example.com -p 53 ns1.example.com
LDAP-Enumeration
  • sudo nmap --script=ldap-search -p 389 192.168.1.10
NetBIOS-Namen sammeln
  • sudo nmap --script=nbstat -p 137 192.168.1.0/24

HTTP / Webanwendungen

Seitentitel und Server-Header
  • nmap --script=http-title,http-server-header -p 80,443 192.168.1.10
Erlaubte HTTP-Methoden prüfen (PUT/DELETE = gefährlich)
  • nmap --script=http-methods -p 80 192.168.1.10
Web-Application-Firewall erkennen
  • nmap --script=http-waf-detect,http-waf-fingerprint -p 80 192.168.1.10
Interessante Dateien und Verzeichnisse finden
  • nmap --script=http-enum -p 80 192.168.1.10

SMB / Windows-Netzwerke

SMB-Freigaben und -Nutzer auflisten
  • sudo nmap --script=smb-enum-shares,smb-enum-users -p 445 192.168.1.10
EternalBlue prüfen (MS17-010 / WannaCry / NotPetya)
  • sudo nmap --script=smb-vuln-ms17-010 -p 445 192.168.1.10
SMB-Signing prüfen (bei deaktiviertem Signing sind NTLM-Relay-Angriffe möglich)
  • sudo nmap --script=smb-security-mode -p 445 192.168.1.0/24

SSH, FTP, Datenbanken

SSH-Hostkey und unterstützte Algorithmen
  • nmap --script=ssh-hostkey,ssh2-enum-algos -p 22 192.168.1.10
Anonymer FTP-Zugriff
  • nmap --script=ftp-anon -p 21 192.168.1.10
MySQL-Informationen sammeln
  • nmap --script=mysql-info,mysql-empty-password,mysql-databases -p 3306 192.168.1.10

Script-Argumente

Zugangsdaten an SMB-Scripts übergeben
  • sudo nmap --script=smb-enum-shares --script-args smbusername=admin,smbpassword=P@ss 192.168.1.10
HTTP-Login mit eigener Wortliste brute-forcen
  • nmap --script=http-form-brute --script-args http-form-brute.path=/login,brute.firstOnly=true 192.168.1.10
Script-Datenbank nach Installation neuer Scripts aktualisieren
  • sudo nmap --script-updatedb
Alle verfügbaren Scripts auflisten
  • ls /usr/share/nmap/scripts/ | wc -l
Hilfe zu einem bestimmten Script
  • nmap --script-help smb-vuln-ms17-010

Timing & Performance

Die Timing-Steuerung bestimmt, wie schnell Nmap scannt. Schnellere Scans sind lauter und leichter zu erkennen; langsamere sind unauffälliger, dauern aber deutlich länger. Sechs Timing-Templates (-T0 bis -T5) sowie zahlreiche granulare Optionen erlauben eine feine Abstimmung.

Timing-Templates

Flag Name Beschreibung
-T0 Paranoid Minimale Verzögerung 5 Minuten. Extrem langsam, zur IDS-Umgehung. Ein /24-Scan kann Tage dauern.
-T1 Sneaky Minimale Verzögerung 15 Sekunden. Sehr langsam, umgeht die meisten ratenbasierten IDS-Erkennungen.
-T2 Polite Minimale Verzögerung 0,4 Sekunden. Langsamer als Standard, schont Bandbreite und Ziel.
-T3 Normal Standardwert, Nmaps beste Einschätzung, passt sich den Netzbedingungen an.
-T4 Aggressive Geht von einem schnellen, zuverlässigen LAN aus, reduziert Timeouts. Empfohlen für lokale Netze.
-T5 Insane Maximale Geschwindigkeit. Kann in langsamen Netzen Ports übersehen.
Schnellstmöglicher Scan im lokalen Netz
  • sudo nmap -T4 -F 192.168.1.0/24
Stealth-Scan mit zufälligen Verzögerungen
  • sudo nmap -T1 --scan-delay 5s 192.168.1.10
Maximale Parallelität für ein schnelles Netz
  • sudo nmap -T4 --min-parallelism 100 192.168.1.0/24

Granulare Timing-Optionen

Flag Bedeutung
--min-rate <n> Mindestens n Pakete pro Sekunde senden
--max-rate <n> Höchstens n Pakete pro Sekunde – schützt das Ziel vor Überlastung
--min-parallelism / --max-parallelism <n> minimale/maximale Anzahl gleichzeitiger Sonden
--min-rtt-timeout / --max-rtt-timeout <zeit> minimales/maximales Round-Trip-Timeout
--initial-rtt-timeout <zeit> anfängliche RTT-Schätzung
--max-retries <n> wie oft eine Sonde wiederholt wird (Standard 6)
--host-timeout <zeit> Host überspringen, wenn er länger als angegeben braucht
--scan-delay / --max-scan-delay <zeit> minimale/maximale Pause zwischen Sonden an denselben Host
Empfohlene Rezepte
# Schnellstmöglich im lokalen Netz
sudo nmap -T5 --min-rate 5000 -F 192.168.1.0/24

# Ausgewogen: alle Ports, LAN, angemessene Geschwindigkeit
sudo nmap -T4 --min-rate 1000 --max-retries 2 -p- 192.168.1.10

# Unauffälliger externer Scan (kein ratenbasiertes IDS auslösen)
sudo nmap -T2 --scan-delay 1s --max-rate 10 -p 80,443,22 ziel.de

# Langsame Hosts überspringen (gut bei großen Netz-Sweeps)
sudo nmap -T4 --host-timeout 30s --max-retries 1 192.168.0.0/16

Firewall-Umgehung & Stealth-Techniken

Firewalls und IDS-Systeme versuchen, Portscans zu erkennen und zu blockieren. Nmap bietet mehrere Techniken, um Scans schwerer erkennbar oder zuordenbar zu machen – wichtig sowohl offensiv (autorisierte Pentests) als auch defensiv (zu wissen, worauf man in Logs achten muss).

Paketfragmentierung

Pakete in 8-Byte-Fragmente aufteilen
  • sudo nmap -f 192.168.1.10
Stärker fragmentiert (16 Byte)
  • sudo nmap -ff 192.168.1.10
Eigene Fragmentgröße (Vielfaches von 8)
  • sudo nmap --mtu 24 192.168.1.10

Decoy-Scanning

Sondierungen von mehreren Fake-Quell-IPs gleichzeitig senden
  • sudo nmap -D 10.0.0.5,10.0.0.6,10.0.0.7,ME 192.168.1.10
Zufällige Decoys generieren lassen
  • sudo nmap -D RND:10 192.168.1.10
Hinweis

Bei ME steht die eigene echte IP zwischen den Decoys. Das Ziel-Log zeigt Sondierungen von allen angegebenen IPs – welche davon real ist, lässt sich ohne weitere Analyse nicht bestimmen.

Quell-IP-Spoofing & Interface-Steuerung

Quell-IP fälschen (Antworten gehen an die gefälschte IP, nicht an einen selbst!)
  • sudo nmap -S 10.0.0.200 -e eth0 192.168.1.10
Netzwerk-Interface festlegen
  • sudo nmap -e eth0 192.168.1.10
Quellport festlegen (umgeht einfache portbasierte Firewall-Regeln)
  • sudo nmap --source-port 53 192.168.1.10
Quellport-Reihenfolge randomisieren
  • sudo nmap -g 53 -sS 192.168.1.10

Weitere Verschleierung

Zufällige Daten an Sonden anhängen (verändert die Paketsignatur)
  • sudo nmap --data-length 50 192.168.1.10
IP-TTL manuell setzen (Scan wirkt wie von weiter entfernt)
  • sudo nmap --ttl 128 192.168.1.10
Über SOCKS-Proxy scannen
  • nmap --proxies socks4://127.0.0.1:9050 192.168.1.10
Idle-/Zombie-Scan über einen Drittanbieter-Host
  • sudo nmap -sI zombie_host:port ziel 192.168.1.10
Eignung eines Hosts als Zombie prüfen (niedrige, vorhersehbare IP-ID-Rate nötig)
  • sudo nmap -O -v 192.168.1.100 | grep 'IP ID Sequence'
Grenzen der Umgehungstechniken

Diese Techniken hinterlassen erkennbare Spuren: fragmentierte Pakete haben untypische IP-ID-Folgen, Decoy-Scans zeigen mehrere IPs, die gleichzeitig dieselben Ports sondieren, ein Quellport 53 mit Nicht-DNS-Payload fällt sofort auf. Moderne Next-Generation-Firewalls (Palo Alto, Fortinet) führen vollständiges Stream-Reassembly durch und erkennen all das zuverlässig. Diese Umgehungstechniken wirken vor allem gegen ältere, zustandslose Firewalls.

Ausgabeformate & Reporting

Nmap kann Ergebnisse gleichzeitig in mehreren Formaten speichern – abhängig vom weiteren Workflow.

Formate

Flag Beschreibung
-oN <datei> Normale, menschenlesbare Ausgabe – wie auf der Konsole
-oX <datei> XML-Ausgabe – maschinenlesbar, für Metasploit, OpenVAS und eigene Tools
-oG <datei> Grepable Ausgabe – eine Zeile pro Host, ideal für grep/awk
-oJ <datei> JSON-Ausgabe – für moderne Pipelines, Python-Verarbeitung, SIEM-Ingestion
-oA <basisname> alle Standardformate (Normal, XML, Grepable) gleichzeitig
Alle Formate gleichzeitig speichern
  • sudo nmap -sS -sV -A -oA reports/scan 192.168.1.0/24
Offene Ports aus Grepable-Output extrahieren
  • grep 'open' scan.gnmap | awk '{print $2, $5}' | head -20
XML mit Python auswerten
import xml.etree.ElementTree as ET
tree = ET.parse('scan.xml')
for host in tree.findall('host'):
    ip = host.find('address').get('addr')
    for port in host.findall('.//port'):
        if port.find('state').get('state') == 'open':
            print(ip, port.get('portid'))
XML-Ergebnis in Metasploit importieren
  • msfconsole -q -x 'db_import scan.xml; hosts; services'

Ndiff – Scanergebnisse vergleichen

Heutigen Scan mit gestrigem vergleichen (neue offene Ports erkennen)
sudo nmap -sV -oX heute.xml 192.168.1.0/24
ndiff gestern.xml heute.xml
HTML-Diff-Report erzeugen
  • ndiff --xml gestern.xml heute.xml | xsltproc nmap.xsl - > diff_report.html
Einsatz

Regelmäßige Nmap-Scans per Cron plus Ndiff-Vergleich ergeben eine einfache, kostenlose Baseline: neu auftauchende Ports werden automatisch gemeldet – ein leichtgewichtiger Rogue-Service-Detektor.

Schwachstellen-Scanning mit NSE

Über die vuln-Kategorie und Scripts wie vulners wird Nmap zu einem einfachen Schwachstellenscanner. Nicht so umfassend wie dedizierte Tools (OpenVAS, Tenable), aber schnell, kostenlos und direkt in den Scan-Workflow integriert.

Alle Vulnerability-Scripts ausführen
  • sudo nmap -sV --script=vuln 192.168.1.10
Vulners-Script – fragt vulners.com nach bekannten CVEs für jede erkannte Version
  • sudo nmap -sV --script=vulners 192.168.1.10
Vulners-Script nachinstallieren, falls nicht vorhanden
sudo git clone https://github.com/vulnersCom/nmap-vulners /usr/share/nmap/scripts/
sudo nmap --script-updatedb

Wichtige Vulnerability-Scripts

Script Prüft
smb-vuln-ms17-010 EternalBlue – WannaCry/NotPetya, alle ungepatchten SMBv1-Systeme
smb-vuln-ms08-067 Conficker-Wurm-Schwachstelle – veraltet, taucht aber noch auf
http-vuln-cve2021-41773 Apache-2.4.49-Path-Traversal & RCE – kritisch
http-shellshock Shellshock (CVE-2014-6271) – CGI-Bash-Injection, RCE
ssl-heartbleed OpenSSL Heartbleed – Private-Key- und Speicher-Leak
ssl-poodle POODLE – SSL-3.0-Downgrade-Angriff
ftp-vsftpd-backdoor vsFTPd-2.3.4-Backdoor (CVE-2011-2523) – RCE
mysql-empty-password MySQL-Root ohne Passwort – kritische Fehlkonfiguration
Wichtige Unterscheidung

Die Kategorie exploit nutzt bekannte Schwachstellen aktiv aus und kann Dienste zum Absturz bringen oder Datenverlust verursachen. Die Kategorie vuln prüft nur, ohne auszunutzen (mit wenigen Ausnahmen wie Heartbleed, das einen Proof-of-Concept-Read durchführt). Vor dem Einsatz von Vulnerability-Scripts immer den Autorisierungsumfang bestätigen.

Nmap im SOC-Einsatz

Im Security Operations Center dient Nmap sowohl proaktiv (Asset-Inventar, Angriffsfläche) als auch reaktiv (Bewertung betroffener Systeme während eines Vorfalls).

Incident Response – schnelle Host-Bewertung

Szenario
IDS-Alarm auf einem Host, C2-Beacon vermutet
# Schritt 1: schnelles Dienst-Inventar des betroffenen Hosts
sudo nmap -sS -sV -sC -p- --min-rate 5000 192.168.1.10 -oA ir/host_$(date +%Y%m%d_%H%M)

# Schritt 2: prüfen, ob dieselbe Backdoor auf anderen Hosts installiert wurde
sudo nmap -p 4444,31337,1337,8888,9999 192.168.1.0/24 --open

# Schritt 3: nach untypischen Diensten auf allen Hosts suchen
sudo nmap -sS -p- --open --min-rate 2000 192.168.1.0/24 -oG - | grep -v '22\|80\|443\|53' | grep 'open'

Asset-Inventar & Angriffsflächen-Management

Vollständiges Netz-Inventar – alle Hosts, Top-1000-Ports, Versionen
  • sudo nmap -sS -sV -O --min-rate 1000 -oA inventory/$(date +%Y%m%d)_scan 192.168.0.0/16
Alle RDP-exponierten Hosts finden (sollten nie direkt aus dem Internet erreichbar sein)
  • sudo nmap -p 3389 --open 192.168.1.0/24
Hosts mit Standard-SNMP-Community-Strings
  • sudo nmap -sU -p 161 --script=snmp-brute 192.168.1.0/24
Alle Webserver mit Versionen finden (Web-Angriffsfläche)
  • sudo nmap -sV -p 80,443,8080,8443,8888 --open 192.168.0.0/16 -oG - | grep open
Unverschlüsselte Admin-Dienste finden (Telnet, HTTP-Management)
  • sudo nmap -p 23,80 --open --script=telnet-info,http-auth-finder 10.0.0.0/8

Automatisierte Scans & Baseline-Vergleich

Tägliches Scan-Script mit Diff-Benachrichtigung per Mail
#!/bin/bash
DATUM=$(date +%Y%m%d)
SCANDIR=/opt/soc/scans
mkdir -p $SCANDIR

sudo nmap -sS -sV --min-rate 2000 -oA $SCANDIR/scan_$DATUM 192.168.1.0/24

GESTERN=$(date -d '1 day ago' +%Y%m%d)
if [ -f $SCANDIR/scan_$GESTERN.xml ]; then
    ndiff $SCANDIR/scan_$GESTERN.xml $SCANDIR/scan_$DATUM.xml > $SCANDIR/diff_$DATUM.txt
    if [ -s $SCANDIR/diff_$DATUM.txt ]; then
        cat $SCANDIR/diff_$DATUM.txt | mail -s 'Netzwerkänderung erkannt' soc@firma.de
    fi
fi
Als Cronjob (täglich 2 Uhr)
  • echo '0 2 * * * /opt/soc/daily_scan.sh >> /var/log/nmap_scan.log 2>&1' | sudo crontab -

Eigene NSE-Scripts schreiben

Jedes Script in /usr/share/nmap/scripts/ ist eine Lua-Datei. Eigene Scripts lassen sich für beliebige wiederkehrende Aufgaben schreiben – etwa das Erkennen bestimmter Banner, das Prüfen auf hausinterne Schwachstellen oder das Auslesen proprietärer Protokolle.

Aufbau eines Scripts

Jedes NSE-Script besteht aus vier Abschnitten: 

-- Abschnitt 1: Beschreibung (Metadaten)
description = [[
  Verbindet sich zu einem Dienst und prüft auf einen bestimmten Banner-String.
  Nützlich zum Erkennen eigener Anwendungen oder Backdoors.
]]

-- Abschnitt 2: Kategorien und Autor
author      = "dein_name"
license     = "Same as Nmap -- see https://nmap.org/book/man-legal.html"
categories  = {"discovery", "safe"}

-- Abschnitt 3: Portrule – wann läuft das Script?
local nmap = require 'nmap'
local shortport = require 'shortport'
portrule = shortport.port_or_service({80, 8080, 8888}, "http")

-- Abschnitt 4: Action – was das Script tut
action = function(host, port)
  local socket = nmap.new_socket()
  socket:connect(host.ip, port.number)
  socket:send('GET / HTTP/1.0\r\nHost: ' .. host.ip .. '\r\n\r\n')
  local status, response = socket:receive_lines(10)
  socket:close()
  if response and response:match('MeinBackdoor%-Marker') then
    return '[ALERT] Bekannter Backdoor-Marker gefunden!'
  end
  return nil  -- nil unterdrückt die Ausgabe, wenn nichts gefunden wurde
end

Praktisches Beispiel – Detektor für bekannte C2-Ports

sudo tee /usr/share/nmap/scripts/detect-c2-ports.nse > /dev/null << 'EOF'
description = "Erkennt Ports, die häufig von RAT-C2-Frameworks genutzt werden"
author      = "dein_name"
categories  = {"malware", "safe", "discovery"}

portrule = function(host, port)
  local c2_ports = {4444, 1337, 31337, 6606, 8888, 9999, 1234, 4242}
  for _, p in ipairs(c2_ports) do
    if port.number == p and port.state == 'open' then
      return true
    end
  end
  return false
end

action = function(host, port)
  local names = {
    [4444]  = 'Metasploit-Standardport',
    [1337]  = 'verbreiteter Hacker-Port',
    [31337] = 'Elite (Back-Orifice/NetBus-Ära)',
    [6606]  = 'AsyncRAT-Standard-C2',
  }
  local name = names[port.number] or 'bekannter C2-Port'
  return string.format('[ALERT] C2-Indikator: %s - sofort untersuchen', name)
end
EOF

sudo nmap --script-updatedb
sudo nmap --script=detect-c2-ports 192.168.1.10
Wichtige NSE-Bibliotheken

Die vollständige Bibliotheksdokumentation liegt unter nmap.org/nsedoc/lib/. Am häufigsten gebraucht: nmap (Kernfunktionen), shortport (Portregeln), http (HTTP-Protokoll), brute (Brute-Force-Framework), creds (Zugangsdaten-Speicherung), stdnse (Hilfsfunktionen), comm (rohe Socket-Kommunikation).

Erweiterte Themen

IPv6-Scanning

IPv6 aktivieren
  • sudo nmap -6 fe80::1%eth0
IPv6-Host-Discovery über Neighbor Discovery Protocol (alle IPv6-Hosts im Segment)
  • sudo nmap -6 -sn ff02::1%eth0
Dual-Stack-Host per Hostname scannen
  • sudo nmap -6 -sS -sV ipv6-ziel.example.com

Broadcast-Discovery-Scripts

UPnP-Geräte im lokalen Netz finden
  • nmap --script=broadcast-upnp-info
DHCP-Server im Netz finden
  • sudo nmap --script=broadcast-dhcp-discover
mDNS-Hosts finden (Apple-Geräte, Chromecast, Drucker)
  • sudo nmap --script=broadcast-dns-service-discovery
NetBIOS-Namen per Broadcast finden
  • sudo nmap --script=broadcast-netbios-master-browser

Nping – gezielte Paketerzeugung

Nping ist Nmaps begleitendes Tool für gezielte, einzelne Pakete
  • sudo nping --tcp -p 80 192.168.1.10
ICMP Echo mit eigenem Payload
  • sudo nping --icmp --icmp-type 8 --data 'HALLO' 192.168.1.10
UDP-Paket mit eigenem Payload
  • sudo nping --udp -p 53 --data-string 'test' 192.168.1.10

Vollständige Flag-Referenz

Zielspezifikation

Flag Bedeutung
-iL <datei> Ziele aus Datei einlesen
-iR <n> zufällige Ziele wählen
--exclude <hosts> Hosts/Netze ausschließen
--excludefile <datei> Ausschlussliste aus Datei

Scan-Techniken

Flag Bedeutung
-sS / -sT / -sA / -sW / -sM SYN- / Connect- / ACK- / Window- / Maimon-Scan
-sU UDP-Scan
-sN / -sF / -sX Null-, FIN- und Xmas-Scan
-sY / -sZ SCTP-INIT- / COOKIE-ECHO-Scan
-sO IP-Protokoll-Scan
-b <FTP-Relay-Host> FTP-Bounce-Scan

Portauswahl

Flag Bedeutung
-p <bereich> nur angegebene Ports scannen
-F Fast-Modus, Top-100-Ports
-r Ports nacheinander statt zufällig
--top-ports <n> die n häufigsten Ports
--port-ratio <ratio> Ports scannen, die häufiger als angegeben vorkommen

Service-/Versionserkennung

Flag Bedeutung
-sV Portversion ermitteln
--version-intensity <0-9> Sondierungstiefe (Standard 7)
--version-light / --version-all Kurzform für Intensität 2 bzw. 9
--version-trace Versionserkennung im Detail protokollieren

Script-Scan

Flag Bedeutung
-sC entspricht --script=default
--script=<scripts> kommagetrennte Liste von Scripts, Kategorien, Verzeichnissen oder "all"
--script-args=<args> Argumente an Scripts übergeben
--script-args-file=<datei> Script-Argumente aus Datei lesen
--script-trace alle gesendeten/empfangenen Daten anzeigen
--script-updatedb Script-Datenbank aktualisieren

OS-Erkennung

Flag Bedeutung
-O OS-Erkennung aktivieren
--osscan-limit nur bei vielversprechenden Zielen versuchen
--osscan-guess aggressiver raten

Timing & Performance

Flag Bedeutung
-T<0-5> Timing-Template setzen
--min/max-hostgroup <größe> Größe paralleler Host-Gruppen
--min/max-parallelism <n> Parallelität der Sondierungen
--min/max-rtt-timeout <zeit> Round-Trip-Timeout
--max-retries <versuche> maximale Wiederholungen einer Sonde
--host-timeout <zeit> Ziel nach dieser Zeit aufgeben
--scan-delay / --max-scan-delay <zeit> Verzögerung zwischen Sonden anpassen
--min/max-rate <n> Pakete pro Sekunde begrenzen

Firewall-/IDS-Umgehung

Flag Bedeutung
-f / --mtu <wert> Pakete fragmentieren / eigene MTU setzen
-D <decoy1,decoy2,...> Scan mit Decoys tarnen
-S <IP> Quelladresse fälschen
-e <interface> Netzwerk-Interface festlegen
-g / --source-port <portnummer> Quellport festlegen
--proxies <url,...> über HTTP/SOCKS4-Proxy leiten
--data <hex-string> eigene Binärdaten anhängen
--data-string <string> eigenen ASCII-String anhängen
--data-length <n> zufällige Daten an Pakete anhängen
--ip-options <optionen> Pakete mit angegebenen IP-Optionen senden
--ttl <wert> IP-TTL setzen
--spoof-mac <mac/prefix/vendor> MAC-Adresse fälschen
--badsum Pakete mit ungültiger Prüfsumme senden

Ausgabe

Flag Bedeutung
-oN/-oX/-oS/-oG <datei> Ausgabe in Normal-/XML-/Script-Kiddie-/Grepable-Format
-oA <basisname> alle drei Hauptformate gleichzeitig
-v / -vv Ausführlichkeit erhöhen
-d / -dd Debug-Level erhöhen
--reason Grund für den gemeldeten Portzustand anzeigen
--open nur offene (bzw. möglicherweise offene) Ports anzeigen
--packet-trace alle gesendeten/empfangenen Pakete anzeigen
--iflist Interfaces und Routen auflisten
--append-output an bestehende Ausgabedatei anhängen statt zu überschreiben
--resume <datei> abgebrochenen Scan fortsetzen
--stylesheet <pfad/URL> XSL-Stylesheet für die XML-Ausgabe

Verschiedenes

Flag Bedeutung
-6 IPv6-Scan aktivieren
-A OS-Erkennung, Versionserkennung, Script-Scan und Traceroute kombiniert
-n DNS-Auflösung deaktivieren (schneller)
-R DNS immer auflösen, auch für nicht erreichbare Hosts
--dns-servers <server> eigene DNS-Server statt Systemstandard verwenden
--traceroute Route zu jedem Host aufzeichnen
--datadir <verzeichnis> eigenen Ort für Nmap-Datendateien angeben
--privileged / --unprivileged Rechteannahme erzwingen
-V / --version Versionsnummer anzeigen
-h / --help Kurzhilfe anzeigen
Abgerufen von „http://xinux.net/index.php?title=Nmap_Vollständiger_Leitfaden&oldid=72020“