Nmap (Network Mapper) ist der meistgenutzte Open-Source-Netzwerkscanner der Welt. Sicherheitsteams, Systemadministratoren und Penetrationstester setzen das Tool ein, um offene Ports zu erkennen, laufende Dienste zu identifizieren und Betriebssysteme zu bestimmen. Dieses Tutorial führt dich Schritt für Schritt von der Installation bis zu fortgeschrittenen Scan-Techniken mit Nmap 7.99 (veröffentlicht am 26. März 2026).
Nmap ist seit 1997 in aktiver Entwicklung, kostenlos und unterstützt Windows, Linux, macOS und BSD. Gordon Lyon (Pseudonym Fyodor) veröffentlichte es erstmals im September 1997 in der Phrack Magazine. Heute ist es in C, C++, Python und Lua geschrieben. Rapid7 integriert Nmap fest in InsightVM für Enterprise-Vulnerability-Scanning, und die NSE-Skriptbibliothek bietet hunderte spezialisierter Skripte für jeden Anwendungsfall.
Voraussetzungen und Systemanforderungen
Bevor du mit dem Tutorial startest, stelle sicher, dass folgende Punkte erfüllt sind:
- Nmap 7.99 (aktuellste stabile Version, März 2026)
- Betriebssystem: Linux (Ubuntu 22.04+, Debian 12+), Windows 10/11, macOS 12+
- Root- bzw. Administratorrechte für SYN-Scans und OS-Erkennung
- Npcap 1.79+ unter Windows (wird bei der Installation automatisch mitgeliefert)
- Schriftliche Genehmigung des Netzwerkeigentümers vor dem Scan eines fremden Netzes
- Grundkenntnisse der Kommandozeile (Bash unter Linux/macOS, PowerShell/CMD unter Windows)
- Testnetz oder eigenes Gerät für erste Übungen
Rechtlicher Hinweis: Das Scannen fremder Netzwerke ohne ausdrückliche schriftliche Erlaubnis des Eigentümers ist in Deutschland nach § 202c StGB (Vorbereiten des Ausspähens von Daten) strafbar. Alle Übungen in diesem Tutorial führst du ausschließlich in deinem eigenen Netz oder auf ausdrücklich autorisierten Systemen durch.
Schritt 1: Nmap installieren
Die Installation von Nmap dauert unter allen Betriebssystemen weniger als 3 Minuten. Die offiziellen Pakete findest du auf nmap.org/download.html.
Installation unter Ubuntu und Debian
# Repository-Index aktualisieren und Nmap installieren
sudo apt update && sudo apt install nmap -y
# Version prüfen
nmap --versionErwartete Ausgabe nach der Installation:
Nmap version 7.99 ( https://nmap.org )
Platform: x86_64-pc-linux-gnu
Compiled with: liblua-5.4.6 libpcre2-10.42 libz-1.2.13 openssl-3.0.11
Compiled without: liblinear libidn libssh2Installation unter Windows
Lade den Installer nmap-7.99-setup.exe von der offiziellen Download-Seite herunter. Der Installer enthält Npcap (den Windows-Paketfilter), Nmap selbst und optional Zenmap (grafische Oberfläche). Installiere Npcap mit WinPcap-Kompatibilitätsmodus, wenn du ältere Tools ebenfalls nutzt. Öffne anschließend eine PowerShell-Konsole als Administrator und prüfe:
nmap --version
# Ausgabe: Nmap version 7.99 ( https://nmap.org )Installation unter macOS
Über Homebrew:
brew install nmap
nmap --versionUnter Kali Linux ist Nmap vorinstalliert. Prüfe trotzdem die Version und aktualisiere bei Bedarf mit sudo apt upgrade nmap.
Schritt 2: Erster Scan, ein einzelner Host
Der einfachste Nmap-Scan prüft einen einzelnen Host auf die 1.000 häufigsten TCP-Ports. Nmap sendet dabei SYN-Pakete an die Zielpunkte und wertet die Antworten aus. Ein Port gilt als open, wenn das Ziel mit SYN-ACK antwortet, als filtered, wenn keine Antwort kommt (Firewall), und als closed, wenn ein RST-Paket zurückkommt.
# Einzelnen Host scannen (Standard: Top-1000-Ports)
sudo nmap 192.168.1.1
# Typische Ausgabe
Starting Nmap 7.99 ( https://nmap.org ) at 2026-06-17 09:00 CEST
Nmap scan report for router.local (192.168.1.1)
Host is up (0.0012s latency).
Not shown: 994 closed tcp ports (reset)
PORT STATE SERVICE
22/tcp open ssh
53/tcp open domain
80/tcp open http
443/tcp open https
8080/tcp open http-proxy
8443/tcp open https-alt
Nmap done: 1 IP address (1 host up) scanned in 1.34 secondsNmap hat in 1,34 Sekunden alle Top-1000-Ports geprüft und 6 offene Ports gefunden. Ohne sudo nutzt Nmap einen TCP-Connect-Scan statt des schnelleren SYN-Scans, was bei größeren Zielen deutlich mehr Zeit beansprucht.
Schritt 3: Netzwerksegment scannen und Hosts entdecken
Im Alltag willst du häufig nicht einen einzelnen Host, sondern ein ganzes Subnetz scannen, um alle aktiven Geräte zu finden. Nmap unterstützt CIDR-Notation, Bereiche und Listen.
# Ganzes /24-Netz auf aktive Hosts prüfen (Ping-Scan, kein Port-Scan)
sudo nmap -sn 192.168.1.0/24
# Beispiel-Ausgabe
Starting Nmap 7.99 ( https://nmap.org ) at 2026-06-17 09:05 CEST
Nmap scan report for 192.168.1.1
Host is up (0.0008s latency).
Nmap scan report for 192.168.1.10
Host is up (0.0031s latency).
Nmap scan report for 192.168.1.42
Host is up (0.0045s latency).
Nmap scan report for 192.168.1.100
Host is up (0.0019s latency).
Nmap done: 256 IP addresses (4 hosts up) scanned in 2.87 seconds
# Mehrere Ziele gleichzeitig
sudo nmap 192.168.1.1 192.168.1.10 192.168.1.100
# IP-Bereich
sudo nmap 192.168.1.1-50
# Aus Datei lesen
sudo nmap -iL ziele.txtDer -sn-Flag (früher -sP) deaktiviert den Port-Scan vollständig und führt nur Host-Discovery durch. Nmap sendet dabei standardmäßig ICMP Echo Request, TCP SYN an Port 443, TCP ACK an Port 80 und ICMP Timestamp-Anfragen. Das liefert zuverlässige Ergebnisse, auch wenn ICMP durch die Firewall geblockt wird.
Schritt 4: Dienste und Versionen erkennen
Die reine Port-Erkennung zeigt, welche Ports offen sind, aber nicht, welcher Dienst dort läuft. Mit dem Flag -sV fragt Nmap die Dienste aktiv ab und ermittelt Name, Version und Protokoll.
# Versionserkennung aktivieren
sudo nmap -sV 192.168.1.50
# Ausgabe (Beispiel)
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.7 (protocol 2.0)
80/tcp open http nginx 1.27.0
443/tcp open ssl/http nginx 1.27.0
3306/tcp open mysql MySQL 8.4.0
# Intensität der Versionserkennung festlegen (0-9, Standard: 7)
sudo nmap -sV --version-intensity 9 192.168.1.50Nmap vergleicht Dienstantworten gegen eine Datenbank mit über 7.300 Versions-Signaturen. Höhere Intensitätswerte senden mehr Probes und erhöhen die Erkennungsrate, verlängern aber auch die Scandauer. Für die meisten Anwendungsfälle reicht der Standard-Intensitätswert von 7.
Schritt 5: Betriebssystem-Erkennung mit TCP/IP-Fingerprinting
Nmap analysiert spezifische Merkmale des TCP/IP-Stacks (Fenstergröße, TTL, TCP-Optionen, Sequenznummern-Vorhersagbarkeit) und vergleicht sie mit einer Datenbank aus über 2.982 OS-Fingerabdrücken, um das Betriebssystem zu bestimmen.
# OS-Erkennung aktivieren (Root-Rechte erforderlich)
sudo nmap -O 192.168.1.50
# Ausgabe (Beispiel)
Device type: general purpose
Running: Linux 5.X|6.X
OS CPE: cpe:/o:linux:linux_kernel:5 cpe:/o:linux:linux_kernel:6
OS details: Linux 5.4 - 6.2
Network Distance: 1 hop
# Kombiniert mit Versionserkennung
sudo nmap -O -sV 192.168.1.50
# Unsichere Treffer mit Wahrscheinlichkeitswerten anzeigen
sudo nmap -O --osscan-guess 192.168.1.50Die OS-Erkennung funktioniert am besten, wenn mindestens ein offener und ein geschlossener Port gefunden werden. Bei Hosts mit aktivierter Firewall, die alle nicht-genutzten Ports filtert statt ablehnt, reduziert sich die Trefferquote deutlich. Der Flag --osscan-guess zeigt auch weniger eindeutige Treffer mit Wahrscheinlichkeitswerten an.
Schritt 6: Aggressive Scans mit vollständiger Analyse
Der -A-Flag kombiniert OS-Erkennung (-O), Versionserkennung (-sV), Standard-Skript-Scan (-sC) und Traceroute in einem einzigen Befehl. Er ist der Standard-Startpunkt für Penetrationstests, weil er in einem Durchlauf maximale Informationen liefert.
# Aggressiver Scan (benötigt Root)
sudo nmap -A -T4 192.168.1.50
# Vollständige Ausgabe (Beispiel)
Starting Nmap 7.99 ( https://nmap.org ) at 2026-06-17 09:15 CEST
Nmap scan report for server.local (192.168.1.50)
Host is up (0.0009s latency).
Not shown: 997 closed tcp ports (reset)
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.7 (protocol 2.0)
| ssh-hostkey:
| 256 a1:b2:c3:d4:e5:f6:... (ECDSA)
|_ 256 f1:e2:d3:c4:b5:... (ED25519)
80/tcp open http nginx 1.27.0
|_http-server-header: nginx/1.27.0
|_http-title: Willkommen
443/tcp open ssl/https nginx 1.27.0
| ssl-cert: Subject: commonName=server.local
| Not valid before: 2026-01-01T00:00:00
|_Not valid after: 2027-01-01T00:00:00
OS details: Linux 6.1 - 6.8
Network Distance: 1 hop
TRACEROUTE
HOP RTT ADDRESS
1 1.12 ms 192.168.1.50
Nmap done: 1 IP address (1 host up) scanned in 12.43 secondsDer aggressive Scan liefert SSH-Host-Keys, HTTP-Server-Header, SSL-Zertifikatsinformationen und OS-Versionen in einem Durchlauf. -T4 setzt das Timing auf “aggressive” (4 von 5 Stufen), was die Scandauer deutlich reduziert, ohne auf den meisten Heimnetzwerken zu Fehlern zu führen.
Schritt 7: Ports gezielt festlegen
Standardmäßig scannt Nmap die 1.000 häufigsten Ports. Für vollständige Analysen oder spezifische Dienste musst du den Portbereich anpassen.
# Bestimmte Ports angeben
sudo nmap -p 22,80,443,8080,8443 192.168.1.50
# Portbereich
sudo nmap -p 1-1024 192.168.1.50
# Alle 65535 Ports (dauert länger)
sudo nmap -p- 192.168.1.50
# Top 100 Ports
sudo nmap --top-ports 100 192.168.1.50
# Top 5000 Ports (guter Kompromiss)
sudo nmap --top-ports 5000 192.168.1.50
# UDP-Ports scannen (sehr langsam, Root erforderlich)
sudo nmap -sU -p 53,67,68,161,162,123 192.168.1.50UDP-Scans dauern deutlich länger als TCP-Scans, weil UDP zustandslos ist und Nmap auf Timeouts warten muss. Für einen vollständigen UDP-Scan aller Ports rechne mit Stunden. Beschränke UDP-Scans auf häufig genutzte Ports wie DNS (53), DHCP (67/68), SNMP (161/162) und NTP (123).
Schritt 8: Nmap Scripting Engine (NSE) einsetzen
Die Nmap Scripting Engine (NSE) ist in Lua geschrieben und einer der mächtigsten Teile von Nmap. NSE-Skripte automatisieren komplexe Aufgaben wie Schwachstellenprüfung, Brute-Force-Tests, Service-Enumeration und Malware-Erkennung. Die offizielle Bibliothek ist unter nmap.org/nsedoc dokumentiert.
# Standard-Skripte ausführen (-sC entspricht --script=default)
sudo nmap -sC 192.168.1.50
# Einzelnes Skript
sudo nmap --script http-title 192.168.1.50
# Skript-Kategorie: Schwachstellen prüfen
sudo nmap --script vuln 192.168.1.50
# Alle HTTP-Skripte
sudo nmap --script "http-*" 192.168.1.50
# Skript mit Argumenten
sudo nmap --script http-brute --script-args http-brute.path=/admin 192.168.1.50
# Alle verfügbaren Skripte auflisten
ls /usr/share/nmap/scripts/ | wc -l
# Typisch: 600+ SkripteDie NSE-Kategorien ermöglichen zielgerichtete Analysen. Für ein erstes Sicherheits-Audit empfiehlt sich die Kategorie vuln, die bekannte Schwachstellen ohne Ausnutzung prüft. Die Kategorie safe enthält nur Skripte, die keine Beeinträchtigung des Ziels verursachen, ideal für Produktionssysteme während regulärer Betriebszeiten.
| NSE-Kategorie | Beschreibung | Beispiel-Skripte | Risiko |
|---|---|---|---|
default | Standard-Skripte bei -sC | ssh-hostkey, http-title, ssl-cert | Niedrig |
safe | Keine Beeinträchtigung des Ziels | banner, dns-nsid, whois-ip | Sehr niedrig |
vuln | Bekannte Schwachstellen prüfen | http-shellshock, smb-vuln-ms17-010 | Mittel |
auth | Authentifizierungs-Tests | ftp-anon, http-auth, ssh-auth-methods | Mittel |
brute | Brute-Force-Tests | ssh-brute, ftp-brute, http-brute | Hoch |
discovery | Service-Enumeration | dns-zone-transfer, snmp-info | Niedrig |
exploit | Ausnutzung von Schwachstellen | ms08-067, vsftpd-backdoor | Sehr hoch |
malware | Malware-Erkennung | http-malware-host, smtp-strangeport | Niedrig |
Schritt 9: Ausgabeformate für Reporting nutzen
Nmap unterstützt mehrere Ausgabeformate, die sich für unterschiedliche Zwecke eignen: Lesbare Textdateien für schnelle Analysen, XML für die Integration in andere Tools und grepfähige Formate für Shell-Skripte.
# Normale Textausgabe in Datei speichern
sudo nmap -sV -oN scan-ergebnis.txt 192.168.1.0/24
# XML-Ausgabe (für Metasploit, Nessus-Import, eigene Tools)
sudo nmap -sV -oX scan-ergebnis.xml 192.168.1.0/24
# Grepfähige Ausgabe
sudo nmap -sV -oG scan-ergebnis.gnmap 192.168.1.0/24
# Alle Formate gleichzeitig (-oA = alle drei)
sudo nmap -A -T4 -oA vollscan 192.168.1.0/24
# Erstellt: vollscan.nmap, vollscan.xml, vollscan.gnmap
# Nur offene Ports anzeigen
sudo nmap --open 192.168.1.0/24
# Verbose-Modus für Echtzeit-Ausgabe
sudo nmap -v -sV 192.168.1.50Das XML-Format ist besonders nützlich für die Integration in Security-Tools. Metasploit importiert Nmap-XML-Dateien direkt mit dem Befehl db_import scan-ergebnis.xml. Python-Skripte können Nmap-XML mit der Bibliothek python-libnmap parsen und automatisch Berichte erstellen.
Schritt 10: Timing-Templates für Geschwindigkeit und Tarnung
Nmap bietet 6 Timing-Templates (T0 bis T5), die den Kompromiss zwischen Scangeschwindigkeit, Genauigkeit und Erkennungsrisiko durch IDS/IPS steuern. Für die meisten Anwendungsfälle im eigenen Netz eignen sich T3 oder T4.
| Template | Name | Beschreibung | Anwendungsfall |
|---|---|---|---|
-T0 | Paranoid | Zwischen jeder Probe 5 Minuten warten | IDS-Umgehung, sehr langsam |
-T1 | Sneaky | Zwischen Probes 15 Sekunden warten | IDS-Umgehung, langsam |
-T2 | Polite | 0,4 Sekunden zwischen Probes | Ressourcenschonend, langsam |
-T3 | Normal | Standardwert, ausgewogen | Alltägliche Scans |
-T4 | Aggressive | Kürzere Timeouts, schneller | Schnelle LAN-Scans |
-T5 | Insane | Maximale Geschwindigkeit | Nur eigenes LAN, fehleranfällig |
# Schneller Scan im LAN
sudo nmap -T4 -F 192.168.1.0/24
# Sehr langsamer, unauffälliger Scan
sudo nmap -T1 -p 80,443 10.0.0.1
# Manuell feintunen
sudo nmap --min-rate 1000 --max-retries 2 192.168.1.0/24-F steht für “Fast” und scannt nur die Top-100-Ports statt Top-1000. Kombiniert mit -T4 scannt Nmap ein /24-Netz mit 254 Hosts in weniger als 30 Sekunden. Für vollständige Port-Scans (-p-) plane einige Minuten ein, auch im LAN.
Schritt 11: Firewall-Erkennung und Scan-Techniken
Firewalls verändern das Scanverhalten. Ein gefilterter Port (filtered) deutet auf eine Firewall hin, die Pakete still verwirft. Nmap bietet verschiedene Techniken, um Firewalls zu erkennen und bestimmte Filter-Regeln zu testen.
# Firewall-Regeln durch verschiedene Scan-Typen testen
# TCP FIN Scan
sudo nmap -sF 192.168.1.50
# TCP Null Scan (keine Flags gesetzt)
sudo nmap -sN 192.168.1.50
# Xmas Scan (FIN, PSH, URG gesetzt)
sudo nmap -sX 192.168.1.50
# Host als "up" behandeln, auch wenn Ping nicht antwortet
sudo nmap -Pn 192.168.1.50
# DNS-Auflösung deaktivieren (schneller bei großen Netzen)
sudo nmap -n 192.168.1.0/24
# Fragmentierte Pakete senden
sudo nmap -f 192.168.1.50
# Decoy-IPs verwenden (verschleiert die Scan-Quelle)
sudo nmap -D 10.0.0.1,10.0.0.2,ME 192.168.1.50Der -Pn-Flag ist besonders nützlich, wenn Ziele ICMP-Ping blockieren. Ohne diesen Flag markiert Nmap solche Hosts als “down” und überspringt sie vollständig. Mit -Pn erzwingt Nmap den Port-Scan, unabhängig von der Ping-Antwort. Das ist der häufigste Fehler bei der Arbeit mit Produktionssystemen und Firewalls.
Schritt 12: Vollständiges Sicherheits-Audit durchführen
Zum Abschluss des Tutorials kombinierst du alle gelernten Techniken zu einem vollständigen Sicherheits-Audit. Dieses Skript analysiert einen einzelnen Server auf offene Ports, laufende Dienste, Betriebssystem und bekannte Schwachstellen.
#!/bin/bash
# Vollständiges Nmap-Audit-Skript
# Nutzung: sudo ./audit.sh 192.168.1.50
TARGET="$1"
DATUM=$(date +%Y%m%d_%H%M%S)
OUTPUT_DIR="./nmap-audit-${DATUM}"
if [ -z "$TARGET" ]; then
echo "Nutzung: sudo $0 "
exit 1
fi
mkdir -p "$OUTPUT_DIR"
echo "[+] Starte Audit für $TARGET"
echo "[+] Ergebnisse: $OUTPUT_DIR"
# Phase 1: Host-Entdeckung
echo "[1/4] Host-Entdeckung..."
nmap -sn -T4 "$TARGET" -oN "$OUTPUT_DIR/01_host_discovery.txt"
# Phase 2: Vollständiger Port-Scan
echo "[2/4] Vollständiger Port-Scan (alle 65535 Ports)..."
nmap -p- -T4 --open "$TARGET" -oN "$OUTPUT_DIR/02_full_portscan.txt"
# Offene Ports extrahieren
OPEN_PORTS=$(grep "^[0-9]" "$OUTPUT_DIR/02_full_portscan.txt" | cut -d'/' -f1 | tr '\n' ',' | sed 's/,$//')
# Phase 3: Dienst- und OS-Erkennung
echo "[3/4] Dienst- und OS-Erkennung auf offenen Ports..."
nmap -sV -O -sC -p "$OPEN_PORTS" "$TARGET" -oA "$OUTPUT_DIR/03_service_os"
# Phase 4: Schwachstellen-Scan
echo "[4/4] NSE-Schwachstellen-Scan..."
nmap --script vuln -p "$OPEN_PORTS" "$TARGET" -oN "$OUTPUT_DIR/04_vuln_scan.txt"
echo "[+] Audit abgeschlossen."
ls -la "$OUTPUT_DIR/" Das Skript führt vier Phasen durch: Host-Entdeckung, vollständigen Port-Scan, Dienst- und OS-Erkennung auf den gefundenen Ports, und abschließend einen NSE-Schwachstellen-Scan. Die modulare Struktur spart Zeit, weil Phase 3 und 4 nur die tatsächlich offenen Ports analysieren, statt alle 65.535 Ports durch alle Analysen zu schicken.
Scan-Techniken im Überblick
Nmap unterstützt über ein Dutzend verschiedene Scan-Typen, die unterschiedliche Informationen liefern und unterschiedliche Rechte erfordern.
| Scan-Typ | Flag | Root nötig | Beschreibung | Erkennungsrisiko |
|---|---|---|---|---|
| SYN Scan | -sS | Ja | Halboffene Verbindung, schnell, Standard mit Root | Mittel |
| Connect Scan | -sT | Nein | Vollständige TCP-Verbindung, langsamer | Hoch |
| UDP Scan | -sU | Ja | UDP-Ports, sehr langsam | Mittel |
| Ping Scan | -sn | Nein | Nur Host-Entdeckung, kein Port-Scan | Niedrig |
| Version Scan | -sV | Nein | Dienstname und Version ermitteln | Mittel |
| Script Scan | -sC | Nein | NSE-Standard-Skripte ausführen | Mittel |
| OS Erkennung | -O | Ja | Betriebssystem via TCP/IP-Fingerprint | Mittel |
| FIN Scan | -sF | Ja | FIN-Flag, umgeht manche Firewalls | Niedrig |
| Null Scan | -sN | Ja | Keine TCP-Flags gesetzt | Niedrig |
| Xmas Scan | -sX | Ja | FIN+PSH+URG gesetzt | Niedrig |
Häufige Fehler und wie du sie vermeidest
Diese Fehler machen Einsteiger und erfahrene Nutzer am häufigsten. Jeder davon führt entweder zu falschen Ergebnissen, unnötig langen Scans oder rechtlichen Problemen.
Fehler 1: Scannen ohne Root-Rechte
Problem: Ohne sudo fällt Nmap auf TCP Connect Scan (-sT) zurück, der messbar langsamer ist und in Logs erscheint. OS-Erkennung und SYN-Scan funktionieren ohne Root gar nicht. Die Fehlermeldung You requested a scan type which requires root privileges ist das eindeutige Zeichen.
Lösung: Führe alle produktiven Scans mit sudo aus. Unter Windows führe die PowerShell-Konsole als Administrator aus.
Fehler 2: Kein Portbereich angegeben
Problem: Standardmäßig scannt Nmap nur die 1.000 häufigsten Ports. Dienste auf ungewöhnlichen Ports wie 8080, 8443, 9200 (Elasticsearch), 5432 (PostgreSQL) oder 27017 (MongoDB) bleiben unsichtbar.
Lösung: Nutze -p- für vollständige Scans oder --top-ports 5000 für einen schnellen Kompromiss. Füge gezielt Ports hinzu, die für das jeweilige Ziel relevant sind.
Fehler 3: Host wird als “down” markiert
Problem: Viele Server und Firewalls blockieren ICMP-Ping. Nmap meldet dann Host seems down und überspringt den Port-Scan, obwohl der Host erreichbar ist.
Lösung: Füge -Pn hinzu, um die Ping-Prüfung zu überspringen und den Port-Scan trotzdem auszuführen.
Fehler 4: UDP-Scans zu früh abbrechen
Problem: UDP-Scans mit -sU sind extrem langsam. Viele Nutzer brechen den Scan ab, bevor er fertig ist, und verpassen wichtige Dienste wie DNS (53), SNMP (161), NTP (123) oder DHCP (67).
Lösung: Beschränke UDP-Scans auf bekannte Service-Ports: sudo nmap -sU -p 53,67,68,123,161,162,500,514 192.168.1.50. Das reduziert die Scandauer von Stunden auf Sekunden.
Fehler 5: Falsches Timing-Template
Problem: -T5 (Insane) führt über WAN-Verbindungen zu Paketverlusten und falschen “closed”-Ergebnissen, weil Pakete verloren gehen und Nmap nicht auf Antworten wartet.
Lösung: Nutze -T4 im LAN und -T3 über WAN-Verbindungen. Für Penetrationstests auf entfernten Zielen ist -T2 sicherer.
Fehler 6: DNS-Auflösung nicht deaktiviert
Problem: Nmap löst bei jedem gescannten Host den Hostnamen per DNS auf. Bei einem /16-Netz (65.536 Hosts) verdoppelt das die Scandauer und hinterlässt DNS-Logs beim Resolver.
Lösung: Füge -n hinzu, um DNS-Auflösung vollständig zu deaktivieren.
Fehler 7: NSE-Exploit-Skripte auf Produktionssystemen
Problem: Die Kategorie exploit enthält Skripte, die aktiv Schwachstellen ausnutzen und Dienste zum Absturz bringen können. Das ist auf Produktionssystemen gefährlich.
Lösung: Beginne immer mit safe und default. Nutze vuln nur für autorisierte Tests. Die Kategorie exploit ist ausschließlich für Pentests in isolierten Testumgebungen gedacht.
Fehler 8: Scannen ohne Autorisierung
Problem: Das unautorisierte Scannen fremder Netzwerke ist in Deutschland nach § 202c StGB strafbar, auch wenn nur Informationen gesammelt werden, ohne aktiv einzudringen.
Lösung: Hol dir immer schriftliche Genehmigung des Netzwerkeigentümers, bevor du scannst. Für Übungen nutze dedizierte Lernplattformen (TryHackMe, HackTheBox) oder isolierte Laborumgebungen mit virtuellen Maschinen.
Fehlerbehebung: 10 Probleme und Lösungen
| Fehlermeldung / Problem | Ursache | Lösung |
|---|---|---|
Operation not permitted | Root-Rechte fehlen | sudo nmap ... verwenden |
Host seems down | ICMP geblockt | -Pn hinzufügen |
| Scan hängt bei UDP | UDP-Timeouts | UDP auf wenige Ports begrenzen: -sU -p 53,161,123 |
NSE script not found | Falscher Skriptname | ls /usr/share/nmap/scripts/ zur Überprüfung |
| Alle Ports “filtered” | Strenge Firewall | -sF, -sN oder -sX probieren |
| Npcap-Fehler unter Windows | Npcap nicht installiert/veraltet | Npcap neu installieren von nmap.org |
| Sehr langsamer Scan | DNS-Auflösung aktiv | -n hinzufügen, Timing prüfen |
| OS-Erkennung schlägt fehl | Kein offener + geschlossener Port | --osscan-guess für unsichere Treffer |
Failed to open device | Netzwerkinterface-Problem | -e eth0 (oder gewünschtes Interface) angeben |
| Falsche Ergebnisse bei T5 | Paketverlust durch zu hohes Tempo | Auf -T4 oder -T3 wechseln |
Fortgeschrittene Techniken: Eigene NSE-Skripte schreiben
NSE-Skripte sind Lua-Dateien im Verzeichnis /usr/share/nmap/scripts/. Ein einfaches Skript, das HTTP-Server-Header ausgibt, hat diese Grundstruktur:
-- custom-http-header.nse
-- Eigenes NSE-Skript: HTTP-Server-Header ausgeben
description = [[Gibt den HTTP-Server-Header des Ziels aus.]]
author = "Dein Name"
license = "Same as Nmap"
categories = {"safe", "discovery"}
local http = require "http"
local shortport = require "shortport"
-- Nur auf HTTP/HTTPS-Ports ausführen
portrule = shortport.http
action = function(host, port)
local response = http.get(host, port, "/")
if response and response.header and response.header.server then
return "Server: " .. response.header.server
end
return "Kein Server-Header gefunden"
endSpeichere das Skript in /usr/share/nmap/scripts/custom-http-header.nse, führe nmap --script-updatedb aus und nutze es mit nmap --script custom-http-header 192.168.1.50. Die offizielle NSE-Dokumentation und Beispiele findest du auf nmap.org/nsedoc.
Nmap in Python-Skripte integrieren
Mit python-nmap lassen sich Nmap-Scans direkt aus Python heraus steuern und die Ergebnisse strukturiert verarbeiten:
import nmap
# Nmap-Scanner initialisieren
scanner = nmap.PortScanner()
# Scan durchführen
scanner.scan(hosts='192.168.1.0/24', arguments='-sV -T4 --top-ports 100')
# Ergebnisse verarbeiten
for host in scanner.all_hosts():
print(f"\nHost: {host} ({scanner[host].hostname()})")
print(f"Status: {scanner[host].state()}")
for proto in scanner[host].all_protocols():
ports = scanner[host][proto].keys()
for port in sorted(ports):
state = scanner[host][proto][port]['state']
service = scanner[host][proto][port]['name']
version = scanner[host][proto][port].get('version', '')
if state == 'open':
print(f" {port}/{proto}: {service} {version}")Die Bibliothek python-nmap installierst du mit pip install python-nmap. Sie unterstützt alle Nmap-Flags und gibt die Ergebnisse als Python-Dictionary zurück, was die Weiterverarbeitung und Integration in eigene SIEM-Tools oder Reporting-Systeme erheblich vereinfacht.
Nmap vs. alternative Scanner im Vergleich
Nmap ist nicht das einzige Netzwerkscanning-Tool. Je nach Anwendungsfall gibt es spezialisierte Alternativen mit eigenen Stärken.
| Tool | Stärke | Schwäche | Anwendungsfall | Lizenz |
|---|---|---|---|---|
| Nmap 7.99 | Vielseitig, NSE-Skripte, OS-Erkennung | Kein Massen-Scan | Allgemein, Pentests, Audits | NPSL (Open Source) |
| Masscan | Extrem schnell (Millionen Ports/Sekunde) | Wenig Detailtiefe, kein NSE | Internet-weites Scanning | AGPL v3 |
| ZMap | IPv4-Gesamtscan in unter einer Stunde | Nur ein Port pro Scan | Forschung, Internet-Scans | Apache 2.0 |
| Angry IP Scanner | Grafische Oberfläche, einfach | Wenig Optionen | Einsteiger, LAN-Übersicht | GPL v2 |
| Shodan | Passivscan ohne eigenen Scan | Kostenpflichtig, veraltet | OSINT, passive Reconnaissance | Proprietär |
| Netcat (nc) | Einzelne Port-Tests, Dateitransfer | Kein automatischer Scan | Debugging, manuelle Tests | Open Source |
Für die meisten Netzwerkadministratoren und Pentester ist Nmap die erste Wahl, weil es Vielseitigkeit, NSE-Erweiterbarkeit und eine aktive Community vereint. Masscan und ZMap sind sinnvolle Ergänzungen für Internet-weite Scans, ersetzen aber nicht Nmaps Detailtiefe bei der Dienst- und OS-Erkennung.
Nmap-Cheat-Sheet: Die wichtigsten Befehle
# ===== GRUNDLEGENDE SCANS =====
nmap 192.168.1.1 # Standard-Scan (Top-1000-Ports)
nmap 192.168.1.0/24 # Subnetz scannen
nmap -sn 192.168.1.0/24 # Nur Host-Entdeckung
nmap -F 192.168.1.1 # Fast Scan (Top-100-Ports)
nmap -p- 192.168.1.1 # Alle 65535 Ports
nmap --top-ports 5000 192.168.1.1 # Top-5000-Ports
# ===== SERVICE & OS =====
nmap -sV 192.168.1.1 # Dienst-Versionen erkennen
nmap -O 192.168.1.1 # OS erkennen
nmap -A 192.168.1.1 # Alles: OS, Version, Skripte, Traceroute
nmap -sV --version-intensity 9 # Maximale Versions-Erkennung
# ===== SCAN-TYPEN =====
nmap -sS 192.168.1.1 # SYN Scan (Standard mit Root)
nmap -sT 192.168.1.1 # Connect Scan (ohne Root)
nmap -sU -p 53,161 192.168.1.1 # UDP Scan
nmap -sF 192.168.1.1 # FIN Scan
nmap -sN 192.168.1.1 # Null Scan
nmap -sX 192.168.1.1 # Xmas Scan
# ===== TIMING =====
nmap -T0 192.168.1.1 # Paranoid (sehr langsam)
nmap -T4 192.168.1.1 # Aggressiv (schnell, für LAN)
nmap -T5 192.168.1.1 # Insane (nur eigenes LAN)
nmap --min-rate 1000 # Min. 1000 Pakete/Sekunde
# ===== NSE SCRIPTING =====
nmap -sC 192.168.1.1 # Standard-Skripte
nmap --script vuln 192.168.1.1 # Schwachstellen-Scan
nmap --script safe 192.168.1.1 # Nur sichere Skripte
nmap --script http-title 192.168.1.1 # HTTP-Titel auslesen
# ===== AUSGABE =====
nmap -oN ergebnis.txt 192.168.1.1 # Text-Ausgabe
nmap -oX ergebnis.xml 192.168.1.1 # XML-Ausgabe
nmap -oG ergebnis.gnmap 192.168.1.1 # Grepfähige Ausgabe
nmap -oA alle-formate 192.168.1.1 # Alle drei Formate gleichzeitig
# ===== NÜTZLICHE OPTIONEN =====
nmap -Pn 192.168.1.1 # Ping-Check überspringen
nmap -n 192.168.1.1 # Keine DNS-Auflösung
nmap -v 192.168.1.1 # Verbose
nmap --open 192.168.1.0/24 # Nur offene Ports zeigen
nmap -e eth0 192.168.1.1 # Bestimmtes InterfaceNmap in der Praxis: 5 Anwendungsszenarien
Nmap ist vielseitiger als reine Port-Scans. Diese fünf Szenarien zeigen, wie Systemadministratoren und Sicherheitsteams das Tool im Alltag einsetzen.
Szenario 1: Netzwerkdokumentation und Asset-Inventar. Regelmäßige Scans eines internen Netzes erstellen eine Bestandsaufnahme aller aktiven Geräte, Dienste und Versionen. Mit nmap -sV -oX inventar.xml 192.168.0.0/16 entsteht ein maschinenlesbares Inventar, das sich mit CMDB-Systemen synchronisieren lässt. Viele Sicherheitsrichtlinien (ISO 27001, BSI IT-Grundschutz) verlangen eine aktuelle, vollständige Liste aller netzwerkfähigen Geräte. Nmap liefert diese Liste automatisiert.
Szenario 2: Patch-Management und Versionskontrolle. Nmap erkennt veraltete Softwareversionen (z. B. OpenSSH 7.x, Apache 2.2.x) und hilft Administratoren, Prioritäten beim Patching zu setzen. Ein wöchentlicher automatisierter Scan mit Versionserkennung kann in CI/CD-Pipelines integriert werden. So erhältst du bei jedem Deployment eine aktuelle Übersicht aller exponierten Dienste und kannst Abweichungen vom Soll-Zustand sofort erkennen.
Szenario 3: Compliance-Checks und Sicherheitsaudits. Viele Compliance-Frameworks (ISO 27001, BSI IT-Grundschutz, PCI-DSS) verlangen regelmäßige Netzwerk-Audits. Nmap-Berichte im XML-Format lassen sich direkt in Compliance-Reports einbinden. PCI-DSS 4.0 verlangt beispielsweise vierteljährliche interne Vulnerability-Scans, für die Nmap mit der vuln-Kategorie eine kostengünstige Grundlage bietet.
Szenario 4: Penetrationstests und Red-Team-Übungen. In autorisierten Penetrationstests ist Nmap das erste Tool in der Reconnaissance-Phase. Die Ergebnisse fließen direkt in Metasploit (db_import scan.xml) und bilden die Basis für weitere Angriffsvektoren. Red-Team-Operatoren nutzen Nmap mit Low-and-Slow-Timing (-T1 oder -T0) und Decoy-Flags, um sich Detection zu entziehen und realistische Angriffsszenarien zu simulieren.
Szenario 5: Incident Response und forensische Analyse. Nach einem Sicherheitsvorfall helfen schnelle Nmap-Scans dabei, unbekannte Dienste oder neu erschienene Hosts im Netz zu erkennen, die auf eine laufende Kompromittierung hindeuten könnten. Ein schneller sudo nmap -sn 10.0.0.0/8 -T4 zeigt alle aktiven Hosts binnen Minuten. Vergleiche das Ergebnis mit deiner letzten Baseline-Aufnahme: Neue, unbekannte Hosts sind ein klares Warnsignal.
Wichtige NSE-Skripte für den Alltag
Die Nmap Scripting Engine enthält hunderte Skripte. Diese zehn Skripte sind in der täglichen Sicherheitsarbeit am nützlichsten.
ssl-cert: Zeigt SSL/TLS-Zertifikatsinformationen an, inklusive Ablaufdatum, Subject, Issuer und Subject Alternative Names. Unverzichtbar für die Überwachung von Zertifikaten im eigenen Netz. Ausführen mit nmap --script ssl-cert -p 443 192.168.1.50.
ssl-enum-ciphers: Listet alle unterstützten TLS-Versionen und Cipher-Suites auf und bewertet sie als “A” (stark), “B” (akzeptabel) oder “F” (schwach). Findet veraltete TLS 1.0- und TLS 1.1-Konfigurationen sowie schwache RC4- oder DES-Cipher-Suites. Aufruf: nmap --script ssl-enum-ciphers -p 443 192.168.1.50.
http-title und http-server-header: Liest den HTML-Titel und den Server-Header jeder HTTP/HTTPS-Antwort aus. Nützlich für schnelle Dienst-Identifikation in großen Netzen ohne tiefe Versionserkennung. Kombiniert: nmap --script http-title,http-server-header -p 80,443,8080,8443 192.168.1.0/24.
smb-vuln-ms17-010: Prüft auf EternalBlue (MS17-010), die Schwachstelle hinter WannaCry. Dieses Skript sollte in keinem Sicherheits-Audit eines Windows-Netzes fehlen. Aufruf: nmap --script smb-vuln-ms17-010 -p 445 192.168.1.0/24.
ftp-anon: Prüft, ob anonymes FTP-Login aktiviert ist. Anonymes FTP ist eine häufige Fehlkonfiguration, die vertrauliche Dateien für jedermann zugänglich macht. Aufruf: nmap --script ftp-anon -p 21 192.168.1.0/24.
ssh-auth-methods: Listet alle akzeptierten SSH-Authentifizierungsmethoden auf (Passwort, Public-Key, Keyboard-Interactive). Passwort-Authentifizierung auf SSH-Servern mit Internetzugang ist ein erhebliches Sicherheitsrisiko. Aufruf: nmap --script ssh-auth-methods -p 22 192.168.1.0/24.
dns-zone-transfer: Versucht einen DNS-Zonetransfer, der bei falsch konfigurierten DNS-Servern die vollständige Liste aller Hostnamen einer Domain preisgibt. Aufruf: nmap --script dns-zone-transfer --script-args dns-zone-transfer.domain=example.de -p 53 ns1.example.de.
http-shellshock: Prüft auf die Shellshock-Schwachstelle (CVE-2014-6271) in CGI-Skripten. Obwohl Shellshock alt ist, sind ungepatchte Embedded-Systeme und IoT-Geräte häufig noch verwundbar. Aufruf: nmap --script http-shellshock --script-args uri=/cgi-bin/test.cgi -p 80 192.168.1.50.
banner: Liest Service-Banner von offenen Ports. Viele Dienste senden beim Verbindungsaufbau einen Banner mit Versions- und Konfigurationsinformationen. Das Skript erfasst diese Informationen ohne tiefere Analyse. Aufruf: nmap --script banner 192.168.1.50.
whois-ip: Führt eine WHOIS-Abfrage für die Ziel-IP durch und gibt Registrar, Organisation, Land und ASN zurück. Nützlich in der Reconnaissance-Phase, um die Organisation hinter einer IP-Adresse zu identifizieren. Aufruf: nmap --script whois-ip 203.0.113.1.
Nmap-Ausgabe analysieren und interpretieren
Eine Nmap-Ausgabe zu lesen ist eine Fähigkeit für sich. Dieser Abschnitt erklärt, wie du die Ergebnisse korrekt interpretierst und welche Schlüsse du daraus ziehst.
Die Header-Zeile jeder Ausgabe zeigt Nmap-Version, Startzeit und Laufzeit. Die wichtigsten Elemente im Detail:
Starting Nmap 7.99 ( https://nmap.org ) at 2026-06-17 09:00 CEST
# ^ Nmap-Version ^ Datum und Uhrzeit des Scans
Nmap scan report for server.local (192.168.1.50)
# ^ Hostname (via Reverse-DNS) ^ IP-Adresse
Host is up (0.0009s latency).
# ^ Host erreichbar ^ Round-Trip-Time
Not shown: 997 closed tcp ports (reset)
# ^ Diese 997 Ports haben mit RST geantwortet (eindeutig geschlossen)
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.7 (protocol 2.0)
# ^ Port ^ Status ^ Dienst ^ Version (nur bei -sV)
443/tcp filtered https
# ^ "filtered": Keine Antwort, Firewall verwirft Pakete still
8080/tcp closed http-proxy
# ^ "closed": Port erreichbar, kein Dienst läuft
OS details: Linux 6.1 - 6.8
# ^ OS-Erkennung Ergebnis (nur bei -O)
Nmap done: 1 IP address (1 host up) scanned in 12.43 seconds
# ^ ZusammenfassungPort-Zustände im Detail: Ein open-Port hat einen aktiven Dienst und akzeptiert Verbindungen. Das ist dein primäres Angriffsziel bei Pentests. Ein closed-Port ist erreichbar, aber kein Dienst läuft. Er ist wenig interessant, zeigt aber, dass der Host kein vollständiges Paketfiltering verwendet. Ein filtered-Port deutet auf eine Firewall hin, die Pakete still verwirft (DROP) statt abzulehnen (REJECT). DROP ist besser für Firewall-Betreiber (hinterlässt dem Scanner keine Information), schlechter für Netzwerkdebugging (keine ICMP-Unreachable-Nachrichten).
Bei der Analyse von Scan-Ergebnissen für große Netze hilft grepfähige Ausgabe (-oG) und einfache Shell-Befehle, um schnell relevante Informationen zu extrahieren:
# Alle Hosts mit SSH (Port 22) finden
grep "22/open" scan.gnmap | awk '{print $2}'
# Alle Hosts mit offenem HTTP
grep "80/open" scan.gnmap | awk '{print $2}'
# Alle Hosts, die OpenSSH laufen haben (aus XML-Ausgabe)
grep -i "openssh" scan.nmap | grep -oP '\d+\.\d+\.\d+\.\d+'
# Hosts mit mehr als 10 offenen Ports finden
grep "Ports:" scan.gnmap | awk -F'/' 'NF>10{print $0}'Für systematischere Analysen nutze das Tool ndiff, das mit Nmap mitgeliefert wird und zwei Scan-Ergebnisse vergleicht. Das ist perfekt für Change-Detection: Führe wöchentlich denselben Scan durch, und ndiff zeigt dir genau, welche Ports oder Dienste sich verändert haben.
# Zwei Scan-Ergebnisse vergleichen
ndiff scan-vorwoche.xml scan-heute.xml
# Beispiel-Ausgabe:
# +Nmap 7.99 scan initiated...
# Nmap scan report for 192.168.1.50 (192.168.1.50)
# -Host: 192.168.1.50 () Status: Up
# +Host: 192.168.1.50 () Status: Up
# +8888/tcp open sun-answerbook
# ^ Neuer, unbekannter Dienst auf Port 8888 aufgetaucht!Nmap ethisch einsetzen: Rechtliche Grundlagen in Deutschland
Die Frage der Legalität von Nmap ist in Deutschland präziser geregelt als in vielen anderen Ländern. § 202a StGB (Ausspähen von Daten) und § 202c StGB (Vorbereiten des Ausspähens) sind die relevanten Normen. § 202c stellt das Herstellen und Verbreiten von Hacker-Werkzeugen unter Strafe, wenn die Absicht besteht, diese für strafbare Handlungen zu nutzen. Das Bundesverfassungsgericht hat 2009 klargestellt, dass § 202c verfassungskonform ist, aber eine Strafbarkeit eine konkrete Absicht zur Begehung von Computerstraftaten erfordert.
Für legitime Sicherheitsarbeit gelten drei Grundregeln: Erstens, das Scannen des eigenen Netzes (eigene IP-Ranges, eigene Server) ist immer legal. Zweitens, das Scannen fremder Netze ohne explizite schriftliche Genehmigung ist strafbar, unabhängig davon, ob du Daten extrahierst oder nur Ports scannst. Drittens, für Penetrationstests benötigst du einen schriftlichen Auftrag des Netzwerkeigentümers (Rules of Engagement), der Art, Umfang und Zeitraum des Tests präzise definiert.
Für sicheres Üben empfehlen sich diese Alternativen zum eigenen Netz: TryHackMe und HackTheBox bieten virtuelle Labore mit absichtlich verwundbaren Maschinen. Metasploitable ist eine absichtlich verwundbare Linux-VM für lokale Übungen. VulnHub stellt hunderte verwundbare VMs zum Download bereit. Der Schlüssel ist, in einer isolierten Umgebung (eigene VM, kein Internetzugang) zu üben.
Verwandte Artikel
Weitere Artikel zur Netzwerk- und Systemsicherheit auf shattered.io:
- Fail2ban einrichten: SSH-Schutz in 12 Schritten [2026]
- OpenSSL-Tutorial: Schlüssel und Zertifikate in 12 Schritten [2026]
- ModSecurity 3 + Nginx WAF einrichten: 12 Schritte [2026]
- Nginx Reverse Proxy: HTTPS in 12 Schritten [2026]
- HTTP Security Headers in Node.js: 12 Schritte mit Helmet.js [2026]
- Online-Sicherheit verständlich erklärt
Offizielle Ressourcen:
- Nmap Man Page: vollständige Referenz aller Optionen
- NSE-Dokumentation: alle offiziellen Skripte mit Beispielen
- Kali Linux Nmap-Seite: Integration in ethisches Hacking
- ubuntuusers.de Nmap-Wiki: deutschsprachige Grundlagenanleitung
- Nmap auf GitHub: Quellcode und aktuelle Entwicklung
FAQ: Häufig gestellte Fragen zu Nmap
Ist Nmap legal?
Nmap selbst ist ein legales Open-Source-Tool. Die Nutzung auf eigenen Systemen und Netzen ist vollkommen legal. Das Scannen fremder Netzwerke ohne ausdrückliche schriftliche Genehmigung des Eigentümers ist in Deutschland nach § 202c StGB strafbar. Das Strafmaß beträgt bis zu zwei Jahre Freiheitsstrafe. Für autorisierte Penetrationstests existiert ein schriftlicher Auftrag, der die Strafbarkeit ausschließt.
Welche Nmap-Version ist aktuell?
Die aktuelle stabile Version ist Nmap 7.99, veröffentlicht am 26. März 2026. Sie ist auf allen Plattformen (Linux, Windows, macOS) verfügbar. Prüfe deine Version mit nmap --version. Updates werden über die jeweiligen Paketmanager (apt, brew, rpm) oder direkt von nmap.org/download.html bezogen.
Wie lange dauert ein Nmap-Scan?
Ein Standard-Scan (Top-1000-Ports) eines einzelnen Hosts dauert mit -T4 typischerweise 1 bis 5 Sekunden im LAN. Ein vollständiger Scan aller 65.535 Ports (-p-) eines einzelnen Hosts dauert 1 bis 5 Minuten. Ein /24-Netz (254 Hosts) mit Fast-Scan (-F -T4) ist in unter 30 Sekunden abgeschlossen. UDP-Scans dauern deutlich länger, oft 5 bis 30 Minuten pro Host bei vollständigem Portscan.
Was ist der Unterschied zwischen SYN-Scan und Connect-Scan?
Der SYN-Scan (-sS) sendet ein SYN-Paket und wartet auf SYN-ACK (offen) oder RST (geschlossen), ohne die Verbindung vollständig aufzubauen. Das macht ihn schneller und unauffälliger, erfordert aber Root-Rechte. Der Connect-Scan (-sT) nutzt den normalen Betriebssystem-Socket und baut vollständige TCP-Verbindungen auf, keine Root-Rechte nötig, aber langsamer und besser in Logs sichtbar.
Was bedeuten die Port-Zustände bei Nmap?
Nmap unterscheidet 6 Port-Zustände: open (Dienst aktiv, nimmt Verbindungen an), closed (Port erreichbar, kein Dienst), filtered (Firewall blockiert, keine Antwort), unfiltered (erreichbar, offen oder geschlossen unklar), open|filtered (unklar bei UDP) und closed|filtered (unklar ob geschlossen oder gefiltert).
Kann Nmap eine Firewall umgehen?
Nmap bietet verschiedene Techniken, die einfache Firewalls umgehen können: FIN-Scan (-sF), Null-Scan (-sN), Xmas-Scan (-sX) und fragmentierte Pakete (-f). Moderne Stateful-Firewalls und IDS/IPS-Systeme erkennen diese Techniken in der Regel. Firewalls sind keine absolute Schutzmaßnahme, aber sie verlangsamen und erschweren das Scanning erheblich.
Was ist die Nmap Scripting Engine (NSE)?
Die Nmap Scripting Engine (NSE) ist ein in Lua geschriebenes Erweiterungssystem, das Nmap von einem reinen Port-Scanner zu einem vielseitigen Sicherheits-Framework macht. NSE-Skripte können Dienste enumieren, Schwachstellen prüfen, Brute-Force-Angriffe durchführen und Malware erkennen. Die offizielle Skriptbibliothek enthält Skripte in 14 Kategorien. Eigene Skripte lassen sich in Lua schreiben und in die lokale Bibliothek einbinden.
Wie aktualisiere ich Nmap auf die neueste Version?
Unter Ubuntu/Debian: sudo apt update && sudo apt upgrade nmap. Unter macOS (Homebrew): brew update && brew upgrade nmap. Unter Windows lädt man den neuen Installer von nmap.org herunter und führt ihn aus, er ersetzt die alte Version automatisch. Die aktuelle Version ist immer auf nmap.org/download.html einsehbar.
Welche Alternativen zu Nmap gibt es für Windows?
Nmap selbst läuft mit Npcap vollständig auf Windows und ist die empfohlene Wahl. Grafisch bietet Zenmap eine komfortable Alternative für Einsteiger. Für reine IP-Scans im LAN ist Angry IP Scanner eine einfachere Option mit grafischer Oberfläche. Masscan läuft ebenfalls auf Windows und bietet deutlich höhere Scan-Geschwindigkeiten, aber weniger Detailtiefe. Für Enterprise-Umgebungen integriert Rapid7 InsightVM Nmap fest in das Vulnerability-Management-Framework, das Rapid7 im August 2025 auf die aktuelle Engine-Version aktualisierte.
