Nmap (Network Mapper) ist seit fast drei Jahrzehnten das meistgenutzte Werkzeug zur Netzwerkerkundung und Sicherheitsanalyse. Systemadministratoren, Penetrationstester und Sicherheitsanalysten setzen es ein, um offene Ports, laufende Dienste, Betriebssystemversionen und potenzielle Schwachstellen in Netzwerken zu identifizieren. Dieses Tutorial zeigt dir in 12 praxisnahen Schritten, wie du Nmap korrekt installierst, konfigurierst und für professionelle Netzwerkscans einsetzt, inklusive NSE-Scripts, Timing-Templates und Schwachstellenscans.

Was ist Nmap und warum ist es 2026 unverzichtbar?

Nmap wurde 1997 von Gordon Lyon (bekannt unter dem Pseudonym Fyodor Vaskovich) als Open-Source-Tool entwickelt und ist heute in nahezu jeder professionellen Sicherheitsumgebung weltweit im Einsatz. Das Tool wurde in mehreren Hollywood-Filmen gezeigt, darunter in “The Matrix Reloaded”, wo es für realistische Hacking-Szenen eingesetzt wurde. Über 70.000 Zeilen C- und C++-Code ermöglichen Funktionen, die von einfachen Ping-Sweeps bis hin zu komplexen skriptbasierten Schwachstellenscans reichen.

Im Jahr 2026 ist Nmap relevanter denn je: Laut dem Security Scorecard Report 2025 beginnen über 85 Prozent aller Netzwerkangriffe mit einer Reconnaissance-Phase, bei der Angreifer offene Ports und exponierte Dienste kartieren. Sicherheitsteams, die dieselben Werkzeuge wie potenzielle Angreifer verwenden, können Schwachstellen proaktiv identifizieren und schließen, bevor sie ausgenutzt werden. Nmap ist in Kali Linux und Parrot OS vorinstalliert und wird von der OWASP als unverzichtbares Werkzeug für Sicherheitsaudits empfohlen.

Das Nmap Scripting Engine (NSE) enthält über 600 vorgefertigte Scripts für Aufgaben wie die Erkennung von SMBv1-Exposition, veralteten SSL/TLS-Protokollen, Standard-Zugangsdaten und bekannten CVEs. Damit wandelt sich Nmap von einem reinen Port-Scanner zu einem vollwertigen Schwachstellen-Assessment-Tool. Die offizielle Dokumentation findet sich unter nmap.org.

Voraussetzungen und Systemanforderungen

Bevor du mit diesem Tutorial beginnst, solltest du folgende Voraussetzungen erfüllen. Das Tutorial setzt grundlegende TCP/IP-Kenntnisse und Erfahrung mit der Kommandozeile voraus.

AnforderungDetailsEmpfehlung
BetriebssystemLinux, Windows 10/11, macOS 12+Ubuntu 22.04 LTS oder Kali Linux 2026
Nmap-Version7.94 oder neuerAktuelle stabile Version von nmap.org
Root-/Admin-RechteFür SYN-Scans (-sS) erforderlichsudo unter Linux/macOS
NetzwerkzugangZu den ZielsystemenNur autorisierte Netzwerke scannen
SpeicherplatzCa. 30 MB für Nmap inkl. NSE-ScriptsAusreichend für alle Plattformen
GrundkenntnisseTCP/IP, Ports, ProtokolleBasiswissen Netzwerktechnik

Wichtiger rechtlicher Hinweis: In Deutschland ist das unerlaubte Scannen fremder Netzwerke nach § 202a StGB (Ausspähen von Daten) und § 202c StGB strafbar. Scanne ausschließlich Netzwerke und Systeme, für die du eine ausdrückliche schriftliche Genehmigung besitzt. Dieses Tutorial verwendet ausschließlich eigene Testumgebungen oder autorisierte Systeme.

Schritt 1: Nmap installieren auf Linux, Windows und macOS

Die Installation von Nmap unterscheidet sich je nach Betriebssystem. Alle Varianten stehen kostenlos auf der offiziellen Website zur Verfügung. Für produktive Einsätze empfiehlt sich immer die Installation der aktuellen stabilen Version, da NSE-Script-Updates und neue OS-Fingerprints regelmäßig veröffentlicht werden.

Installation unter Linux (Ubuntu/Debian)

# Paketlisten aktualisieren und Nmap installieren
sudo apt update
sudo apt install nmap -y

# Version prüfen
nmap --version

# Erwartete Ausgabe:
# Nmap version 7.94 ( https://nmap.org )
# Platform: x86_64-pc-linux-gnu
# Compiled with: liblua-5.4.6 openssl-3.0.2 libssh2-1.10.0

# Für die neueste Version aus dem offiziellen Repository:
sudo apt install nmap -y --install-recommends

Unter Kali Linux und Parrot OS ist Nmap bereits vorinstalliert. Du kannst die Installation direkt mit nmap --version prüfen. Für die aktuellste Version empfiehlt sich die Installation aus dem offiziellen Nmap-Repository. Auf Fedora/RHEL-Systemen lautet der Installationsbefehl sudo dnf install nmap -y, auf Arch Linux sudo pacman -S nmap.

Installation unter Windows (Nmap und Npcap)

# Option 1: Über Chocolatey (empfohlen)
choco install nmap

# Option 2: Über winget
winget install --id Insecure.Nmap

# Option 3: Grafischer Installer
# 1. Installer von https://nmap.org/download.html herunterladen
# 2. Npcap-Treiber wird automatisch mitinstalliert
# 3. Zenmap (GUI) optional mitinstallieren

# Nmap in PowerShell (als Administrator) aufrufen:
nmap --version

# SYN-Scan unter Windows (erfordert Admin + Npcap):
nmap -sS 192.168.1.1

Unter Windows benötigt Nmap den Npcap-Treiber für Low-Level-Paketerfassung, der den veralteten WinPcap ersetzt. Npcap wird automatisch bei der Nmap-Installation mitgeliefert. Für SYN-Scans (-sS) musst du PowerShell oder die Eingabeaufforderung als Administrator starten. Die Windows-Version unterstützt alle Kernfunktionen, allerdings sind UDP- und Raw-Socket-Operationen aufgrund der Windows-Kernel-Architektur langsamer als unter Linux.

Installation unter macOS

# Über Homebrew (empfohlen)
brew install nmap

# Version prüfen
nmap --version

# Für Scans mit Root-Rechten (SYN-Scans):
sudo nmap -sS 192.168.1.1

Schritt 2: Erster Scan und Grundsyntax verstehen

Nmap folgt einer einheitlichen Syntax: nmap [Scan-Typ] [Optionen] [Ziel]. Das Ziel kann eine einzelne IP-Adresse, ein Hostname, ein CIDR-Bereich oder eine Datei mit Zielen sein. Die einfachste Nutzungsform ohne zusätzliche Flags führt einen Standard-Scan der Top-1.000-Ports durch.

# Einzelnen Host scannen (Top 1000 Ports)
nmap 192.168.1.1

# Hostname scannen
nmap example.com

# Mehrere Hosts scannen
nmap 192.168.1.1 192.168.1.2 192.168.1.3

# IP-Bereich scannen
nmap 192.168.1.1-254

# CIDR-Notation (gesamtes Subnetz)
nmap 192.168.1.0/24

# Hosts aus einer Datei scannen
nmap -iL ziele.txt

# Beispiel-Ausgabe eines einfachen Scans:
# Starting Nmap 7.94 ( https://nmap.org )
# Nmap scan report for 192.168.1.1
# Host is up (0.0012s latency).
# Not shown: 997 closed ports
# PORT    STATE SERVICE
# 22/tcp  open  ssh
# 80/tcp  open  http
# 443/tcp open  https
# Nmap done: 1 IP address (1 host up) scanned in 1.23 seconds

Der Status eines Ports kann vier Werte annehmen: open (Port ist aktiv und nimmt Verbindungen an), closed (Port ist erreichbar, aber kein Dienst hört zu), filtered (Port wird durch eine Firewall blockiert) und open|filtered (bei UDP-Scans, wenn Nmap nicht sicher ist, ob ein Port offen oder gefiltert ist). Ein fünfter Status, unfiltered, tritt beim ACK-Scan auf und bedeutet, dass der Port erreichbar ist, aber der genaue Zustand unbekannt bleibt.

Die Latenzangabe in Millisekunden (z.B. “0.0012s latency”) gibt an, wie schnell der Host auf Nmap-Pakete antwortet. Sehr hohe Latenz (über 100ms) kann auf eine langsame Internetverbindung oder geografische Distanz hinweisen. Bei Werten über 300ms empfiehlt sich die Anpassung der Timeout-Parameter mit --min-rtt-timeout und --max-rtt-timeout.

Schritt 3: Port-Scan-Typen im Detail verstehen

Nmap unterstützt über ein Dutzend verschiedene Scan-Typen, die sich in Geschwindigkeit, Zuverlässigkeit und Erkennungsrisiko unterscheiden. Die Wahl des richtigen Scan-Typs hängt vom Ziel, der Netzwerkumgebung und den eigenen Berechtigungen ab.

Scan-TypFlagBeschreibungRoot erforderlichErkennungsrisiko
SYN-Scan (Stealth)-sSHalboffener TCP-Scan, sendet SYN, wartet auf SYN-ACK, RST abbrechendJaNiedrig
TCP-Connect-Scan-sTVollständiger 3-Wege-Handshake, wird in Anwendungs-Logs erfasstNeinHoch
UDP-Scan-sUScannt UDP-Ports, langsamer aber wichtig für DNS/SNMP/VPNJaMittel
ACK-Scan-sAErkennt Firewall-Regeln und gefilterte vs. ungefilterte PortsJaMittel
NULL-Scan-sNKeine TCP-Flags gesetzt, umgeht manche Firewall-RegelwerkeJaNiedrig
FIN-Scan-sFNur FIN-Flag gesetzt, ähnlich NULL-ScanJaNiedrig
Xmas-Scan-sXFIN, PSH und URG-Flags gleichzeitig gesetztJaNiedrig
Ping-Scan-snNur Host-Discovery ohne Port-ScanNeinSehr niedrig
# SYN-Scan (Standard, benötigt Root, bevorzugte Methode)
sudo nmap -sS 192.168.1.0/24

# TCP-Connect-Scan (ohne Root, erscheint in System-Logs)
nmap -sT 192.168.1.1

# UDP-Scan (langsam, für DNS Port 53, SNMP Port 161, VPN etc.)
sudo nmap -sU -p 53,67,68,69,123,161,500 192.168.1.1

# Kombinierten TCP SYN + UDP-Scan durchführen
sudo nmap -sS -sU -p T:80,443,U:53,161 192.168.1.1

# Ping-Scan (nur Host-Discovery, kein Port-Scan, sehr schnell)
nmap -sn 192.168.1.0/24

# Kein Ping (Host als online behandeln, auch ohne Ping-Antwort)
sudo nmap -Pn 192.168.1.1

# ACK-Scan zur Firewall-Analyse
sudo nmap -sA 192.168.1.1

Der SYN-Scan (-sS) ist der Standardscan von Nmap, wenn Root-Rechte verfügbar sind. Er sendet ein TCP-SYN-Paket und analysiert die Antwort: Ein SYN-ACK zeigt einen offenen Port, ein RST einen geschlossenen Port. Da die TCP-Verbindung nie vollständig aufgebaut wird, erscheint der Scan in vielen Anwendungs-Logs nicht. Der TCP-Connect-Scan (-sT) führt den vollständigen 3-Wege-Handshake durch und wird daher von Intrusion Detection Systems (IDS) leichter erkannt.

Schritt 4: Port-Auswahl und Scan-Umfang festlegen

Standardmäßig scannt Nmap die 1.000 häufigsten Ports aus einer internen Wahrscheinlichkeitstabelle. Für umfassendere Scans oder spezifische Anforderungen bietet Nmap flexible Port-Spezifikationen, die die Scanzeit erheblich beeinflussen können. Die richtige Port-Auswahl ist ein wichtiges Abwägungskriterium zwischen Vollständigkeit und Scangeschwindigkeit.

# Alle 65.535 Ports scannen (dauert länger, aber vollständiger)
sudo nmap -p- 192.168.1.1

# Spezifische Ports scannen
nmap -p 22,80,443,8080,8443,3306,5432,6379 192.168.1.1

# Port-Bereich scannen
nmap -p 1-1024 192.168.1.1

# Top 100 häufigste Ports (schneller Überblick)
nmap --top-ports 100 192.168.1.1

# Top 500 häufigste Ports (guter Kompromiss)
nmap --top-ports 500 192.168.1.1

# Ports nach Protokoll spezifizieren
sudo nmap -p T:80,443,U:53 192.168.1.1

# Schneller Fast-Scan (äquivalent zu --top-ports 100)
nmap -F 192.168.1.0/24

# Beispiel-Ausgabe vollständiger Scan mit Portliste:
# PORT      STATE    SERVICE
# 22/tcp    open     ssh
# 80/tcp    open     http
# 443/tcp   open     https
# 3306/tcp  open     mysql
# 8080/tcp  filtered http-proxy
# 8443/tcp  closed   https-alt

Ein vollständiger Scan aller 65.535 Ports dauert auf einem einzelnen Host je nach Netzwerklatenz und Timing-Template zwischen 30 Sekunden und mehreren Minuten. Für Subnetz-Scans mit vielen Hosts empfiehlt sich ein zweiphasiger Ansatz: Erst Host-Discovery (nmap -sn), dann gezielter Port-Scan der aktiven Hosts. Dies reduziert die Gesamtscanzeit erheblich, da keine Scans auf nicht erreichbare Hosts verschwendet werden.

Für Compliance-Audits nach NIS-2 oder ISO 27001 empfiehlt das BSI, zumindest die IANA-registrierten Well-Known Ports (0-1023) und die häufigsten Registered Ports (1024-49151) zu scannen. Für vollständige Audits aller potenziell genutzten Ports müssen alle 65.535 TCP-Ports geprüft werden, was bei großen Netzwerken erhebliche Rechenzeit erfordert.

Schritt 5: Service- und Versionserkennung mit -sV

Das Wissen, welche Dienste und welche Versionen auf offenen Ports laufen, ist für Sicherheitsanalysen entscheidend. Die Option -sV veranlasst Nmap, identifizierte offene Ports zu sondieren und die genaue Dienst-Software-Version zu ermitteln. Dies ist besonders wichtig, um veraltete Software-Versionen mit bekannten CVEs zu identifizieren. Die vollständige Nmap-Referenz ist unter nmap.org/book/man.html dokumentiert.

# Service- und Versionserkennung aktivieren
sudo nmap -sV 192.168.1.1

# Intensitätsstufe der Versionserkennung (0-9, Standard: 7)
sudo nmap -sV --version-intensity 9 192.168.1.1

# Leichte Versionserkennung (schneller, weniger präzise)
sudo nmap -sV --version-light 192.168.1.1

# Kombinierter Scan: SYN + Versionserkennung + Top-Ports
sudo nmap -sS -sV --top-ports 200 192.168.1.0/24

# Erwartete Ausgabe mit Versionserkennung:
# PORT     STATE SERVICE    VERSION
# 22/tcp   open  ssh        OpenSSH 9.2p1 Debian 2+deb12u2 (protocol 2.0)
# 80/tcp   open  http       Apache httpd 2.4.57 ((Debian))
# 443/tcp  open  ssl/http   Apache httpd 2.4.57 ((Debian))
# 3306/tcp open  mysql      MySQL 8.0.35-0ubuntu0.22.04.1
# 6379/tcp open  redis      Redis key-value store 7.0.14
# 5432/tcp open  postgresql PostgreSQL DB 14.10

Die Versionserkennung funktioniert durch das Senden von Sondenpaketen an offene Ports und die Analyse der Antworten anhand einer Datenbank mit über 11.000 Service-Fingerprints. Wenn Nmap die Version nicht sicher bestimmen kann, gibt es eine Schätzung aus oder zeigt “unknown” an. Mit der Intensitätsstufe 9 versucht Nmap alle verfügbaren Sonden, was präzisere Ergebnisse liefert, aber deutlich mehr Zeit benötigt.

In der Praxis ist die Versionserkennung einer der wertvollsten Aspekte eines Nmap-Scans. Findet man zum Beispiel Apache HTTP Server 2.4.49, lässt sich dies direkt mit CVE-2021-41773 (Path-Traversal-Schwachstelle, CVSS 9.8) in Verbindung bringen. Dieser Workflow aus Port-Scan, Versionserkennung und CVE-Datenbankabgleich bildet die Grundlage jedes professionellen Penetrationstests und sollte durch Tools wie OpenVAS oder Tenable Nessus ergänzt werden.

Schritt 6: Betriebssystem-Erkennung und Aggressive-Scan (-O und -A)

Nmap kann anhand charakteristischer Unterschiede in der TCP/IP-Implementierung verschiedener Betriebssysteme das OS eines Remote-Hosts erraten. Diese Technik wird als TCP/IP-Fingerprinting bezeichnet und basiert auf einer Datenbank mit über 5.000 OS-Fingerprints. Die Erkennung ist besonders nützlich für die Inventarisierung heterogener Netzwerkumgebungen und die Identifikation von End-of-Life-Betriebssystemen.

# Betriebssystem-Erkennung (benötigt Root-Rechte)
sudo nmap -O 192.168.1.1

# OS-Erkennung mit erweiterter Schätzung
sudo nmap -O --osscan-guess 192.168.1.1

# Erwartete OS-Erkennungs-Ausgabe:
# OS details: Linux 5.4 - 5.15
# Network Distance: 1 hop
# OS CPE: cpe:/o:linux:linux_kernel:5.4

# Aggressive-Scan: kombiniert -sV, -O, -sC und --traceroute
sudo nmap -A 192.168.1.1

# Erwartete -A Ausgabe (Auszug):
# PORT   STATE SERVICE VERSION
# 22/tcp open  ssh     OpenSSH 9.2p1 Debian
# | ssh-hostkey:
# |   256 9d:1a:b7:c2:... (ECDSA)
# |   256 aa:32:bc:e1:... (ED25519)
# Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
#
# TRACEROUTE (using port 22/tcp)
# HOP RTT    ADDRESS
# 1   0.42ms 192.168.1.1

Die Option -A kombiniert vier Funktionen in einem Befehl: Service-Versionserkennung (-sV), OS-Erkennung (-O), Standard-NSE-Scripts (-sC) und Traceroute. Dieser Aggressive-Scan liefert die umfangreichsten Informationen, hinterlässt aber auch die deutlichsten Spuren in Netzwerk-Logs und IDS-Systemen. Für Penetrationstests in produktiven Umgebungen empfiehlt sich ein schrittweises Vorgehen mit gezielten Optionen statt einem pauschalen -A-Scan.

Die Genauigkeit der OS-Erkennung hängt von der Verfügbarkeit offener und geschlossener Ports ab. Nmap benötigt mindestens einen offenen und einen geschlossenen Port, um zuverlässige TCP/IP-Fingerprints zu erstellen. Bei stark gefilterten Hosts mit nur wenigen sichtbaren Ports ist die Erkennungsrate entsprechend geringer. In diesen Fällen hilft --osscan-guess, das Nmap dazu veranlasst, auch bei weniger eindeutigen Fingerprints eine Schätzung auszugeben.

Schritt 7: Das Nmap Scripting Engine (NSE) effektiv nutzen

Das Nmap Scripting Engine (NSE) ist eine der mächtigsten Funktionen von Nmap und verwandelt es von einem Port-Scanner zu einem vollständigen Sicherheits-Assessment-Tool. NSE-Scripts sind in der Scriptsprache Lua geschrieben und können Aufgaben wie Dienst-Enumeration, Schwachstellenerkennung, Brute-Force-Tests und vieles mehr automatisieren. Die vollständige NSE-Dokumentation mit allen Scripts findet sich unter nmap.org/nsedoc.

# Standard-Scripts ausführen (entspricht -sC)
sudo nmap --script default 192.168.1.1

# Spezifisches Script ausführen
sudo nmap --script http-title 192.168.1.1

# Mehrere Scripts kombinieren
sudo nmap --script http-title,http-methods,http-headers 192.168.1.1

# Scripts nach Kategorie ausführen
sudo nmap --script safe 192.168.1.1
sudo nmap --script discovery 192.168.1.1
sudo nmap --script vuln 192.168.1.1

# Scripts mit Argumenten
sudo nmap --script http-brute --script-args brute.mode=user 192.168.1.1

# SMB-Scripts für Windows-Umgebungen
sudo nmap --script smb-security-mode,smb-vuln-ms17-010 -p 445 192.168.1.100

# Erwartete Ausgabe bei smb-vuln-ms17-010 (EternalBlue):
# Host script results:
# | smb-vuln-ms17-010:
# |   VULNERABLE:
# |   Remote Code Execution vulnerability in Microsoft SMBv1 (ms17-010)
# |     State: VULNERABLE
# |     IDs:  CVE:CVE-2017-0143
# |     Risk factor: HIGH

# Script-Hilfe anzeigen
nmap --script-help ssl-enum-ciphers

NSE-Scripts sind in 14 Kategorien unterteilt: auth (Authentifizierungstests), broadcast (Netzwerk-Discovery ohne Zieladresse), brute (Brute-Force-Angriffe auf Dienste), default (Standardscripts, ausgeführt mit -sC), discovery (Dienst-Enumeration), dos (Denial-of-Service, nur in kontrollierten Umgebungen), exploit (Schwachstellenausnutzung), external (externe Datenquellen wie Shodan), fuzzer (Fuzzing-Tests), intrusive (intensive Scripts, die deutliche Logs hinterlassen), malware (Malware-Erkennung), safe (keine Nebenwirkungen), version (Versionserkennung) und vuln (Schwachstellenerkennung).

Besonders wichtig für DACH-Unternehmen, die NIS-2-Compliance anstreben, sind die Scripts der Kategorien “safe” und “discovery”, die ohne Beeinträchtigung der Zielsysteme ausgeführt werden können. Die “vuln”-Kategorie kann intensive Tests durchführen und sollte nur in explizit autorisierten Umgebungen eingesetzt werden.

Schritt 8: Timing-Templates für optimale Scan-Performance

Nmap bietet sechs Timing-Templates (-T0 bis -T5), die das Verhältnis zwischen Scan-Geschwindigkeit und Erkennungsrisiko steuern. Die richtige Wahl des Timing-Templates ist entscheidend für effektive Netzwerkscans in verschiedenen Umgebungen. Laut der offiziellen Nmap-Dokumentation ist -T4 das empfohlene Template für lokale Netzwerke mit stabiler Verbindung.

TemplateNamePakete pro Sek.Min. RTT-TimeoutAnwendungsfall
-T0Paranoid1 alle 5 Min.5 MinutenIDS-Umgehung, maximale Tarnung
-T1Sneaky1 alle 15 Sek.15 SekundenLangsame, unauffällige Scans
-T2PoliteReduziert10 SekundenProduktionsnetz schonen
-T3NormalAdaptivAdaptivStandard, gute Balance
-T4AggressiveHoch500msLokale Netzwerke, empfohlen
-T5InsaneMaximal250msSehr schnelle Netzwerke, Genauigkeitsverlust möglich
# Normaler Scan (Standard, T3)
sudo nmap -T3 192.168.1.0/24

# Aggressiver Scan für lokale Netzwerke (T4, empfohlen für LANs)
sudo nmap -T4 192.168.1.0/24

# Maximale Geschwindigkeit für schnelle Netzwerke (T5)
sudo nmap -T5 192.168.1.0/24

# Langsamer unauffälliger Scan (T1, für autorisierte Stealth-Tests)
sudo nmap -T1 -sS 10.0.0.1

# Timing manuell anpassen (feinkörnige Kontrolle)
sudo nmap --min-rate 100 --max-rate 500 192.168.1.0/24

# Maximale Parallelscans festlegen
sudo nmap --min-parallelism 10 --max-parallelism 100 192.168.1.0/24

# Retry-Versuche reduzieren (beschleunigt Scan, reduziert Genauigkeit)
sudo nmap --max-retries 2 192.168.1.0/24

# Kombinierter aggressiver Scan mit Rate-Kontrolle
sudo nmap -sS -T4 --min-rate 1000 --max-retries 2 -p- 192.168.1.1

Für die meisten professionellen Netzwerkaudits in lokalen Umgebungen ist -T4 die optimale Wahl. Es bietet gute Geschwindigkeit ohne nennenswerten Datenverlust. -T5 kann zu verpassten Ports führen, wenn das Netzwerk langsam reagiert oder Pakete verloren gehen. Für Produktionsumgebungen empfiehlt sich -T2 oder -T3, um die Netzwerklast zu minimieren und Dienststörungen zu vermeiden. Bei langsamem WAN oder Verbindungen mit hoher Paketverlustraten sollte -T2 mit erhöhten Timeout-Werten verwendet werden.

Schritt 9: Ausgabeformate für Berichte und Automatisierung

Professionelle Sicherheitsanalysten speichern Nmap-Ergebnisse in verschiedenen Formaten für spätere Auswertung, Berichterstattung und Integration in andere Werkzeuge. Nmap unterstützt vier verschiedene Ausgabeformate, die parallel oder einzeln verwendet werden können. Die automatisierte Verarbeitung von Scan-Ergebnissen ist ein wesentlicher Bestandteil moderner Security-Automation-Pipelines.

# Normales Text-Format (-oN)
sudo nmap -sV -oN ergebnis.txt 192.168.1.0/24

# XML-Format für Tool-Integration (-oX)
sudo nmap -sV -oX ergebnis.xml 192.168.1.0/24

# Grepbare Ausgabe (-oG)
sudo nmap -sV -oG ergebnis.gnmap 192.168.1.0/24

# Alle drei Formate gleichzeitig (-oA) - empfohlen
sudo nmap -sV -oA scan-$(date +%Y%m%d) 192.168.1.0/24
# Erzeugt: scan-20260620.nmap, scan-20260620.xml, scan-20260620.gnmap

# Verbose-Ausgabe für Echtzeit-Fortschritt
sudo nmap -v -sV 192.168.1.1

# Sehr ausführliche Ausgabe
sudo nmap -vv -sV 192.168.1.1

# Offene Ports aus Grepable-Ausgabe extrahieren
grep "open" ergebnis.gnmap | awk '{print $2, $5}' | sort

# Hosts mit Port 80 aus Scan-Ergebnissen filtern
grep "80/open" ergebnis.gnmap | awk '{print $2}'

# XML mit Python parsen (python-nmap Bibliothek)
# pip install python-nmap
# import nmap; nm = nmap.PortScanner()
# nm.analyse_nmap_xml_scan(open('ergebnis.xml').read())

Das XML-Format (-oX) ist besonders wertvoll für die Integration mit anderen Sicherheitswerkzeugen. Metasploit kann Nmap-XML-Ergebnisse direkt importieren (db_import ergebnis.xml in msfconsole), ebenso wie OpenVAS und Tenable Nessus. Das Grepbare-Format (-oG) eignet sich hervorragend für Shell-Scripting und die schnelle Extraktion spezifischer Informationen. Für regelmäßige automatisierte Scans empfiehlt sich immer -oA mit einem Datumsstempel im Dateinamen, um historische Vergleiche zu ermöglichen und Netzwerkveränderungen über Zeit nachzuverfolgen.

Schritt 10: Schwachstellen-Scanning mit NSE-Scripts

Der leistungsstärkste Einsatz von Nmap als Sicherheitswerkzeug liegt in der automatisierten Erkennung bekannter Schwachstellen mittels NSE-Scripts. Die “vuln”-Kategorie umfasst Scripts für bekannte CVEs und Sicherheitsprobleme, von EternalBlue (CVE-2017-0143) über Heartbleed (CVE-2014-0160) bis hin zu SSL/TLS-Konfigurationsschwächen. Laut SecurityScorecard sind exponierte Services und ungepatchte Systeme nach wie vor für 43 Prozent aller Erstinfektionen verantwortlich.

# Vollständiger Schwachstellen-Scan (nur in autorisierten Umgebungen)
sudo nmap --script vuln 192.168.1.1

# Spezifische CVE-Scripts ausführen
sudo nmap --script smb-vuln-ms17-010 -p 445 192.168.1.1
sudo nmap --script ssl-heartbleed -p 443 192.168.1.1
sudo nmap --script http-shellshock -p 80,443 192.168.1.1

# SSL/TLS-Konfiguration prüfen (wichtig für NIS-2 Compliance)
sudo nmap --script ssl-enum-ciphers -p 443 192.168.1.1

# Erwartete ssl-enum-ciphers Ausgabe:
# PORT    STATE SERVICE
# 443/tcp open  https
# | ssl-enum-ciphers:
# |   TLSv1.2:
# |     ciphers:
# |       TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (ecdh_x25519) - A
# |       TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (ecdh_x25519) - A
# |     cipher preference: server
# |_  least strength: A

# SMB-Sicherheitsscan für Windows-Umgebungen
sudo nmap --script smb-security-mode,smb-vuln-ms17-010,smb2-security-mode -p 139,445 192.168.1.100

# HTTP-Sicherheitstest (fehlende Security-Header)
sudo nmap --script http-security-headers,http-methods -p 80,443,8080 192.168.1.1

# FTP-Schwachstellen prüfen
sudo nmap --script ftp-anon,ftp-vsftpd-backdoor -p 21 192.168.1.1

# DNS-Schwachstellen
sudo nmap --script dns-recursion,dns-cache-snoop -p 53 192.168.1.1

Der vollständige --script vuln Scan ist ressourcenintensiv und kann mehrere Minuten dauern. Er sollte nur in explizit autorisierten Penetrationstestumgebungen eingesetzt werden. Für reguläre Compliance-Checks in DACH-Unternehmen empfiehlt sich ein schrittweises Vorgehen: Zunächst ein allgemeiner Service-Scan (-sV), dann gezielte Schwachstellen-Scripts nur für die identifizierten Dienste.

Wichtig: NSE vuln-Scripts prüfen auf Indikatoren bekannter Schwachstellen, bestätigen die tatsächliche Ausnutzbarkeit aber nicht zu 100 Prozent. Falsch-positive Ergebnisse sind möglich, besonders bei obskuren oder nicht-standardkonformen Dienste-Konfigurationen. Jede gemeldete Schwachstelle sollte durch manuelle Verifikation oder spezialisierte Tools bestätigt werden, bevor sie in einen offiziellen Pentest-Bericht einfließt.

Schritt 11: Nmap unter Windows einsetzen

Nmap unter Windows hat einige Besonderheiten, die beim Einsatz in Windows-dominierten Unternehmensumgebungen bekannt sein sollten. Kali Linux unter Windows Subsystem for Linux 2 (WSL2) bietet eine Alternative, die die volle Linux-Performance von Nmap unter Windows ermöglicht.

# Windows PowerShell (als Administrator ausführen)

# Nmap-Version prüfen
nmap --version

# Standard-Scan unter Windows
nmap -sT 192.168.1.1

# SYN-Scan unter Windows (Admin-Rechte + Npcap erforderlich)
nmap -sS 192.168.1.1

# Windows-Hosts via SMB auflisten
nmap --script smb-enum-shares,smb-enum-users -p 445 192.168.1.100

# Active Directory Domain Controller finden
nmap --script ldap-rootdse -p 389 192.168.1.0/24

# Windows-Firewall-Konfiguration analysieren
nmap -sA 192.168.1.100

# Ausgabe in Windows-kompatiblem Pfad speichern
nmap -oA "C:\Users\%USERNAME%\Desktop\nmap-scan" 192.168.1.0/24

# Zenmap GUI starten (grafische Oberfläche)
zenmap

# Unter WSL2 (Linux-Performance unter Windows):
# wsl sudo nmap -sS 192.168.1.0/24

Zenmap ist die offizielle grafische Benutzeroberfläche für Nmap und wird zusammen mit dem Windows-Installer installiert. Sie eignet sich besonders für Einsteiger und für die visuelle Darstellung von Netzwerktopologien. Zenmap speichert häufig verwendete Befehle als Profile und zeigt Ergebnisse in einer übersichtlichen GUI an. Für professionelle Umgebungen und Automatisierung ist jedoch die Kommandozeile effizienter.

Ein bekanntes Problem unter Windows ist die langsamere Scan-Geschwindigkeit im Vergleich zu Linux, da Windows-Socket-Implementierungen weniger effizient für Raw-Packet-Operationen sind. Bei großen Subnetz-Scans kann der Unterschied je nach Netzwerkgröße erheblich sein. Wenn Scan-Geschwindigkeit kritisch ist, empfiehlt sich ein Linux-System (physisch, als VM oder via WSL2) als primäre Nmap-Plattform.

Schritt 12: Firewall-Erkennung und fortgeschrittene Scan-Techniken

In realen Netzwerken werden Scans häufig von Firewalls, IDS-Systemen und anderen Sicherheitsmechanismen erkannt oder blockiert. Nmap bietet verschiedene Techniken, um Informationen trotz dieser Schutzmaßnahmen zu gewinnen oder die Scan-Quellen zu analysieren. Diese Techniken sind ausschließlich für autorisierte Penetrationstests gedacht.

# Firewall-Erkennung: ACK-Scan zeigt gefilterte vs. ungefilterte Ports
sudo nmap -sA 192.168.1.1

# Fragment-Scan (Pakete aufteilen, umgeht manche Paketfilter)
sudo nmap -f 192.168.1.1

# Decoy-Scan (Fake-Quell-IPs einfügen, erschwert Zurückverfolgung)
sudo nmap -D RND:10 192.168.1.1

# Spezifische Decoy-IPs angeben (ME = eigene IP)
sudo nmap -D 10.0.0.1,10.0.0.2,ME,10.0.0.3 192.168.1.1

# Quell-Port manipulieren (umgeht manche Legacy-Firewall-Regeln)
sudo nmap --source-port 53 192.168.1.1

# Langsamer Scan mit Pausen zur Erkennungsvermeidung
sudo nmap -T1 --scan-delay 5s 192.168.1.1

# Paketgröße manipulieren (größere MTU-Fragmente)
sudo nmap --mtu 24 192.168.1.1

# Badsum-Scan (erkennt IDS/Firewall-Verhalten)
sudo nmap --badsum 192.168.1.1

# Erwartete Ausgabe bei Firewall-Analyse:
# PORT   STATE      SERVICE
# 22/tcp filtered   ssh
# 80/tcp open       http
# 443/tcp unfiltered https

Der ACK-Scan (-sA) ist besonders nützlich, um Firewall-Konfigurationen zu verstehen. Wenn ein Port beim -sA Scan als “unfiltered” erscheint, ist er tatsächlich erreichbar, unabhängig davon, ob er offen oder geschlossen ist. “Filtered” Ports blockieren ACK-Pakete aktiv. Diese Informationen helfen Sicherheitsteams, Firewall-Regeln zu validieren und Lücken im Perimeter zu identifizieren.

Häufige Fehler und wie du sie vermeidest

Nach der Analyse tausender Nmap-Scans in produktiven und Test-Umgebungen haben sich folgende zehn Fehler als besonders häufig herausgestellt.

Fehler 1: Scannen ohne Root-Rechte für SYN-Scans. Ohne Root-Rechte führt Nmap TCP-Connect-Scans (-sT) durch, die vollständige Verbindungen aufbauen und in System-Logs erscheinen. Für unauffällige SYN-Scans immer sudo nmap -sS verwenden.

Fehler 2: Alle Ports ohne Timing-Optimierung scannen. Ein nmap -p- 192.168.1.0/24 ohne Timing-Optimierung kann auf großen Subnetzen Stunden dauern. Besser: sudo nmap -p- -T4 --min-rate 1000 für deutlich kürzere Scanzeiten bei akzeptabler Genauigkeit.

Fehler 3: ICMP-blockierende Hosts übersehen. Viele Firewalls blockieren ICMP-Ping-Anfragen, sodass Nmap Hosts fälschlicherweise als offline meldet. Mit -Pn wird die Ping-Phase übersprungen und alle Hosts als online behandelt. Besonders unter Windows und hinter Stateful-Firewalls ist dieses Problem häufig.

Fehler 4: UDP-Dienste ignorieren. DNS (53), SNMP (161), DHCP (67/68) und VPN-Protokolle laufen auf UDP. UDP-Scans sind zwar langsamer, aber für vollständige Netzwerk-Inventarisierungen unerlässlich. Gezielt wichtige UDP-Ports scannen: sudo nmap -sU -p 53,67,68,69,123,161,500.

Fehler 5: NSE-Scripts ohne Verständnis der Nebenwirkungen ausführen. Scripts der Kategorien “dos” und “exploit” können Zielsysteme beeinträchtigen oder abstürzen lassen. Immer die Dokumentation mit nmap --script-help SCRIPTNAME lesen, bevor Scripts in produktiven Umgebungen eingesetzt werden.

Fehler 6: Scan-Ergebnisse nicht speichern. Einmalige Scan-Ergebnisse ohne Sicherung zu verlieren ist ein häufiger Fehler. Immer -oA dateiname verwenden, um alle drei Ausgabeformate zu speichern und spätere Vergleiche zu ermöglichen.

Fehler 7: Firewall-Ausgabe als offene Ports missverstehen. Ein Port mit Status “filtered” ist nicht zwingend geschlossen. Er könnte offen sein, aber durch eine Firewall blockiert werden. “Open” bedeutet, dass ein Dienst aktiv wartet, während “filtered” bedeutet, dass die Firewall keine Antwort durchlässt.

Fehler 8: Falsch positive Schwachstellen nicht verifizieren. NSE vuln-Scripts erzeugen gelegentlich falsch positive Ergebnisse, besonders bei ungewöhnlichen Dienste-Konfigurationen. Jede gemeldete Schwachstelle durch manuelle Verifikation oder spezialisierte Tools bestätigen, bevor sie in einen Pentest-Bericht einfließt.

Fehler 9: Scannen ohne schriftliche Genehmigung. Auch scheinbar harmlose Scans des eigenen Unternehmensnetzwerks können rechtliche Konsequenzen haben, wenn keine ausdrückliche Genehmigung vorliegt. Vor jedem Scan eine schriftliche Autorisierung einholen und archivieren.

Fehler 10: Rate-Limits und IDS-Erkennungssysteme ignorieren. Zu aggressive Scans (-T5 mit hohen –min-rate Werten) können IDS-Alerts auslösen, die als laufender Angriff interpretiert werden. In sensiblen Umgebungen immer mit dem Sicherheitsteam koordinieren und Wartungsfenster für intensive Scans nutzen.

Troubleshooting: 8 häufige Probleme lösen

Problem 1: “Operation not permitted” beim SYN-Scan. Nmap benötigt Root-Rechte für Raw-Socket-Operationen. Lösung: sudo nmap -sS [Ziel] oder unter Windows PowerShell als Administrator ausführen. Alternativ: TCP-Connect-Scan ohne Root: nmap -sT [Ziel].

Problem 2: Alle Ports erscheinen als “filtered”. Eine Firewall blockiert alle eingehenden Pakete zum Zielsystem. Lösung: Mit nmap -Pn --reason prüfen, warum Ports als gefiltert erscheinen. Die Option --reason zeigt an, auf welcher Basis ein Port-Status bestimmt wurde (z.B. “no-response” oder “admin-prohibited”).

Problem 3: Host erscheint als “down” obwohl er erreichbar ist. ICMP-Ping-Anfragen werden durch eine Firewall blockiert. Lösung: nmap -Pn [Ziel] verwenden, um die Ping-Phase zu überspringen und den Host als online zu behandeln.

Problem 4: UDP-Scan dauert extrem lange. UDP-Scans sind inhärent langsamer, da keine Verbindungsbestätigung existiert. Lösung: Gezielt nur wichtige UDP-Ports scannen: sudo nmap -sU -p 53,161,500 --max-retries 1 -T4 [Ziel]. Die Option --max-retries 1 reduziert die Scanzeit erheblich auf Kosten etwas niedrigerer Erkennungsrate.

Problem 5: OS-Erkennung schlägt fehl (“OS details: unknown”). Nmap braucht mindestens einen offenen und einen geschlossenen TCP-Port für OS-Fingerprinting. Lösung: Mit --osscan-guess erzwingen, dass Nmap auch bei unsicheren Ergebnissen eine Schätzung abgibt. Alternativ mehr Ports scannen: -p 1-1024.

Problem 6: NSE-Scripts werden nicht gefunden (“WARNING: Could not find nmap data files”). Script-Datenbank veraltet oder Installationspfad falsch. Lösung: sudo nmap --script-updatedb ausführen. Script-Verzeichnis prüfen: ls /usr/share/nmap/scripts/. Bei manueller Installation den Pfad mit --datadir angeben.

Problem 7: Scan läuft sehr langsam auf einem großen Subnetz. Zu viele Hosts, zu viele Ports und ungünstiges Timing führen zu langen Scanzeiten. Lösung: Zweiphasiger Ansatz: Erst Host-Discovery (nmap -sn 192.168.1.0/24 -oG hosts.txt), dann nur aktive Hosts scannen (grep "Up" hosts.txt | awk '{print $2}' > aktive_hosts.txt && nmap -iL aktive_hosts.txt -T4). Zusätzlich --min-rate 1000 und --max-retries 2 setzen.

Problem 8: Nmap erkennt falsche Dienst-Versionen. Einige Dienste liefern absichtlich falsche Banner-Informationen. Lösung: Versionserkennung mit höherer Intensität: nmap -sV --version-intensity 9 [Ziel]. Für kritische Systeme die identifizierte Version durch direkten Verbindungstest verifizieren, z.B. via curl -v http://[Ziel] oder ssh -v [Ziel].

Fortgeschrittene Nmap-Techniken für Profis

Wer Nmap professionell einsetzt, profitiert von erweiterten Techniken, die über den Standard-Port-Scan hinausgehen und für komplexe Netzwerkumgebungen optimiert sind. Sicherheitsexperten auf Kali Linux nutzen diese Techniken täglich in autorisierten Penetrationstests.

Vollständiger professioneller Audit-Workflow

#!/bin/bash
# Professioneller Nmap-Audit-Workflow

TARGET_SUBNET="192.168.1.0/24"
DATE=$(date +%Y%m%d_%H%M)
OUTPUT_DIR="./nmap-audit-${DATE}"
mkdir -p "$OUTPUT_DIR"

echo "[*] Phase 1: Host-Discovery..."
sudo nmap -sn "$TARGET_SUBNET" -oG "$OUTPUT_DIR/hosts.gnmap"
grep "Up" "$OUTPUT_DIR/hosts.gnmap" | awk '{print $2}' > "$OUTPUT_DIR/aktive_hosts.txt"
echo "[+] Aktive Hosts: $(wc -l < "$OUTPUT_DIR/aktive_hosts.txt")"

echo "[*] Phase 2: Schneller Port-Scan (Top 1000)..."
sudo nmap -sS -T4 -iL "$OUTPUT_DIR/aktive_hosts.txt" \
  -oA "$OUTPUT_DIR/phase2_quick"

echo "[*] Phase 3: Vollständiger Port-Scan..."
sudo nmap -p- -T4 --min-rate 1000 \
  -iL "$OUTPUT_DIR/aktive_hosts.txt" \
  -oA "$OUTPUT_DIR/phase3_full"

echo "[*] Phase 4: Service-Erkennung und Standard-Scripts..."
sudo nmap -sV -sC \
  -iL "$OUTPUT_DIR/aktive_hosts.txt" \
  -oA "$OUTPUT_DIR/phase4_services"

echo "[*] Phase 5: SSL/TLS-Audit..."
sudo nmap --script ssl-enum-ciphers,ssl-cert \
  -p 443,8443,465,993,995 \
  -iL "$OUTPUT_DIR/aktive_hosts.txt" \
  -oA "$OUTPUT_DIR/phase5_ssl"

echo "[*] Zusammenfassung..."
echo "Aktive Hosts: $(wc -l < "$OUTPUT_DIR/aktive_hosts.txt")"
echo "Offene TCP-Ports: $(grep "open/tcp" "$OUTPUT_DIR/phase4_services.gnmap" | wc -l)"
echo "Ergebnisse in: $OUTPUT_DIR/"

Nmap mit Metasploit und anderen Tools kombinieren

# Nmap-XML-Ergebnisse in Metasploit importieren
# In msfconsole eingeben:
# msf > db_import /pfad/zu/phase4_services.xml
# msf > hosts            (zeigt alle gefundenen Hosts)
# msf > services         (zeigt alle gefundenen Dienste)
# msf > vulns            (zeigt erkannte Schwachstellen)

# Nmap mit Nikto für Web-Schwachstellen kombinieren
nmap -p 80,443,8080 192.168.1.0/24 -oG - | \
  grep "open" | awk '{print $2}' | \
  xargs -I{} sh -c 'nikto -h {} -output nikto_{}.txt'

# Nmap + enum4linux für Windows/Samba
nmap --script smb-os-discovery -p 445 192.168.1.0/24 -oG - | \
  grep "445/open" | awk '{print $2}' | \
  xargs -I{} enum4linux -a {}

# Nmap-Ergebnisse für Berichterstattung aufbereiten
grep "open" phase4_services.gnmap | \
  awk -F'/' '{print $1}' | \
  awk '{print $NF}' | \
  sort -n | uniq -c | sort -rn | head -20

Nmap-Befehlsreferenz: Die wichtigsten Optionen

OptionBeschreibungBeispiel
-sSTCP SYN-Scan (Standard mit Root)sudo nmap -sS 192.168.1.1
-sTTCP-Connect-Scan (ohne Root)nmap -sT 192.168.1.1
-sUUDP-Scansudo nmap -sU 192.168.1.1
-sVService-Versionserkennungnmap -sV 192.168.1.1
-OOS-Erkennungsudo nmap -O 192.168.1.1
-AAggressiver Scan (kombiniert)sudo nmap -A 192.168.1.1
-sCStandard-NSE-Scriptsnmap -sC 192.168.1.1
-pPort-Spezifikationnmap -p 22,80,443 192.168.1.1
-p-Alle 65.535 Portsnmap -p- 192.168.1.1
-T[0-5]Timing-Templatenmap -T4 192.168.1.1
-oAAlle Ausgabeformatenmap -oA ergebnis 192.168.1.1
-PnPing überspringennmap -Pn 192.168.1.1
-v / -vvVerbose / sehr verbose Ausgabenmap -vv 192.168.1.1
--scriptNSE-Scripts ausführennmap --script vuln 192.168.1.1
-iLZiele aus Datei lesennmap -iL ziele.txt

Rechtliche Grundlagen für DACH-Unternehmen

In Deutschland, Österreich und der Schweiz unterliegt der Einsatz von Netzwerk-Scanning-Tools einem klaren rechtlichen Rahmen, den jeder professionelle Anwender kennen muss. Die Kenntnis dieser Regelungen schützt Sicherheitsexperten vor unbeabsichtigten Rechtsverstößen.

In Deutschland regeln § 202a StGB (Ausspähen von Daten) und § 202c StGB (Vorbereiten des Ausspähens von Daten) den Umgang mit Hacker-Werkzeugen. Nmap selbst ist legal, aber das Scannen fremder Systeme ohne Genehmigung kann als Straftat gewertet werden. Das BSI empfiehlt regelmäßige autorisierte Penetrationstests als Teil des ISMS nach ISO 27001.

Unter der NIS-2-Richtlinie, die in Deutschland durch das NIS2-Umsetzungsgesetz implementiert wurde, sind Unternehmen in kritischen Sektoren verpflichtet, regelmäßige Sicherheitsüberprüfungen ihrer Netzwerke durchzuführen. Autorisiertes Nmap-Scanning ist ein anerkannter Bestandteil solcher Sicherheitsüberprüfungen. Wichtig ist die Dokumentation: Datum, Umfang, authorisierende Management-Ebene und Ergebnisse des Scans sollten schriftlich festgehalten werden.

Für externe Penetrationstests empfiehlt sich ein formaler Pentestvertrag, der Umfang, Zeitraum, erlaubte Techniken und Haftungsfragen klar regelt. Nmap ist auf der Kali Linux Tool-Liste und bei Wikipedia als Standard-Sicherheitswerkzeug dokumentiert.

Verwandte Themen auf shattered.io

FAQ: Häufige Fragen zu Nmap

Nmap selbst ist ein legales Open-Source-Tool. Das Scannen eigener Netzwerke und Systeme ist vollkommen legal. Das Scannen fremder Netzwerke ohne ausdrückliche schriftliche Genehmigung des Eigentümers ist nach § 202a und § 202c StGB in Deutschland strafbar. Für professionelle Penetrationstests immer einen schriftlichen Vertrag und Genehmigung des Auftraggebers einholen.

Was ist der Unterschied zwischen nmap -sS und nmap -sT?

Der SYN-Scan (-sS) ist ein halboffener Scan, bei dem Nmap das TCP-Handshake nach dem ersten SYN-ACK abbricht. Er benötigt Root-Rechte, hinterlässt aber weniger Spuren in Anwendungs-Logs. Der TCP-Connect-Scan (-sT) baut vollständige TCP-Verbindungen auf, wird in Logs erfasst und benötigt keine Root-Rechte. Für unauffällige Scans ist -sS bevorzugt, für Systeme ohne Root-Rechte ist -sT die einzige Option.

Wie lange dauert ein vollständiger Nmap-Scan?

Die Scandauer hängt von Anzahl der Hosts, Anzahl der Ports, Netzwerklatenz und Timing-Template ab. Ein Standard-Scan (Top 1.000 Ports) eines einzelnen Hosts mit -T4 dauert 1 bis 5 Sekunden. Ein vollständiger Port-Scan aller 65.535 Ports dauert mit -T4 und --min-rate 1000 ca. 30 bis 120 Sekunden pro Host. Ein Subnetz mit 254 Hosts und Top-1.000-Ports dauert mit -T4 ungefähr 2 bis 10 Minuten.

Wie erkenne ich, ob meine Firewall Nmap-Scans blockiert?

Ein ACK-Scan (sudo nmap -sA [Ziel]) zeigt, ob Ports "unfiltered" (direkt erreichbar) oder "filtered" (durch Firewall blockiert) sind. Wenn viele Ports als "filtered" erscheinen, blockiert die Firewall aktiv. Mit der Option --reason zeigt Nmap den genauen Grund für den Port-Status: "no-response" bedeutet, dass Pakete schweigend verworfen werden (Drop), während "admin-prohibited" anzeigt, dass die Firewall aktiv zurückweist (Reject).

Welche NSE-Scripts sind für Windows-Netzwerke am wichtigsten?

Für Windows-Netzwerke sind folgende NSE-Scripts besonders relevant: smb-security-mode (prüft SMB-Sicherheitskonfiguration), smb-vuln-ms17-010 (EternalBlue-Check), smb2-security-mode (SMBv2-Konfiguration), smb-enum-shares (listet zugängliche Freigaben auf), smb-enum-users (listet Benutzerkonten auf) und ldap-rootdse (Active Directory-Informationen). Diese Scripts liefern zusammen ein umfassendes Bild der Windows-Infrastruktur-Sicherheit.

Kann Nmap IPv6-Netzwerke scannen?

Ja, Nmap unterstützt IPv6 vollständig. Mit der Option -6 wird der Scan auf IPv6-Adressen aktiviert: sudo nmap -6 2001:db8::1. Für IPv6-Subnetz-Scans gilt jedoch, dass die schiere Größe eines /64-Netzes (etwa 18 Trillionen Adressen) einen vollständigen Scan unmöglich macht. Stattdessen empfiehlt sich der --script ipv6-node-info Script oder das Tool masscan für größere IPv6-Netzwerke.

Wie integriere ich Nmap in automatisierte CI/CD-Pipelines?

Nmap lässt sich problemlos in CI/CD-Pipelines integrieren. Für GitHub Actions oder GitLab CI kann der Docker-Container instrumentisto/nmap verwendet werden. Die XML-Ausgabe (-oX) kann mit der Python-Bibliothek python-nmap geparst werden. Sinnvoll ist ein automatischer Nmap-Scan nach jedem Deployment, um unerwartete Port-Öffnungen zu erkennen. Das Ergebnis wird mit einem Baseline-Scan verglichen und bei Abweichungen schlägt die Pipeline an. So wird Nmap zum Security-Gate im DevSecOps-Prozess.

Was ist der Unterschied zwischen Nmap und einem dedizierten Schwachstellen-Scanner?

Nmap ist primär ein Netzwerk-Discovery- und Port-Scanning-Tool mit optionalen Schwachstellenprüfungs-Scripts via NSE. Dedizierte Schwachstellen-Scanner wie Tenable Nessus, OpenVAS oder Qualys VMDR bieten umfangreichere CVE-Datenbanken, automatische CVSS-Bewertungen, detaillierte Remediation-Empfehlungen und Compliance-Reporting nach Standards wie PCI DSS und ISO 27001. Nmap und dedizierte Scanner ergänzen sich: Nmap für die initiale Netzwerk-Kartierung und schnelle Discovery, Schwachstellen-Scanner für die vollständige CVE-Analyse und Berichterstattung.