# nmap — Netzwerke scannen und analysieren

> Praxis-Guide zu nmap — Hosts entdecken, Ports und Dienste scannen, Betriebssysteme erkennen und Sicherheitslücken prüfen; für Admins und Security-Profis.

Source: https://www.jpkc.com/db/cheatsheets/networking/nmap/

<!-- PROSE:intro -->
nmap ist das Standardwerkzeug für Netzwerk-Inventarisierung und Sicherheitsaudits: Du scannst einzelne Hosts ebenso wie ganze Subnetze, erkennst offene Ports, laufende Dienste und Betriebssysteme – und prüfst mit der Nmap Scripting Engine, ob bekannte Schwachstellen vorhanden sind. Dieses Cheat-Sheet zeigt dir die wichtigsten Optionen, vom schnellen Ping-Sweep bis zum vollständigen Audit-Scan – ausschließlich für Systeme, auf denen du autorisiert bist.
<!-- PROSE:intro:end -->

## Grundlegende Scans

`nmap TARGET` — Scannt die 1000 häufigsten Ports eines Zielhosts. TARGET kann eine IP-Adresse, ein Hostname oder ein CIDR-Bereich sein.

```bash
nmap 192.168.1.1
```

`nmap HOST1 HOST2 HOST3` — Scannt mehrere Hosts, die durch Leerzeichen getrennt angegeben werden.

```bash
nmap 192.168.1.1 192.168.1.2 192.168.1.3
```

`nmap NETWORK/CIDR` — Scannt ein ganzes Subnetz.

```bash
nmap 192.168.1.0/24
```

`nmap START-END` — Scannt einen IP-Adressbereich.

```bash
nmap 192.168.1.1-50
```

`nmap -iL FILE` — Liest Ziele aus einer Datei (ein Eintrag pro Zeile).

```bash
nmap -iL targets.txt
```

`nmap --exclude HOST1,HOST2` — Schließt bestimmte Hosts vom Scan aus.

```bash
nmap 192.168.1.0/24 --exclude 192.168.1.1,192.168.1.254
```

`nmap --excludefile FILE` — Schließt Hosts aus, die in einer Datei aufgelistet sind.

```bash
nmap 192.168.1.0/24 --excludefile exclude.txt
```

`nmap -6 TARGET` — Scannt ein IPv6-Ziel.

```bash
nmap -6 2001:db8::1
```

## Host-Erkennung

`nmap -sn NETWORK/CIDR` — Nur Ping-Scan – findet aktive Hosts, ohne Ports zu scannen.

```bash
nmap -sn 192.168.1.0/24
```

`nmap -Pn TARGET` — Überspringt die Host-Erkennung. Behandelt alle Hosts als online. Nützlich, wenn ICMP geblockt ist.

```bash
nmap -Pn 192.168.1.1
```

`nmap -PS PORT(S) TARGET` — TCP-SYN-Erkennung auf bestimmten Ports.

```bash
nmap -PS22,80,443 192.168.1.0/24
```

`nmap -PA PORT(S) TARGET` — TCP-ACK-Erkennung auf bestimmten Ports.

```bash
nmap -PA80,443 192.168.1.0/24
```

`nmap -PU PORT(S) TARGET` — UDP-Erkennung auf bestimmten Ports.

```bash
nmap -PU53,161 192.168.1.0/24
```

`nmap -PE TARGET` — ICMP-Echo-Erkennung (klassischer Ping).

```bash
nmap -PE 192.168.1.0/24
```

`nmap -PP TARGET` — ICMP-Timestamp-Erkennung.

```bash
nmap -PP 192.168.1.0/24
```

`nmap -PM TARGET` — ICMP-Adressmaske-Erkennung.

```bash
nmap -PM 192.168.1.0/24
```

`nmap -PR TARGET` — ARP-Erkennung im lokalen Netzwerk. Schnell und zuverlässig im LAN.

```bash
nmap -PR 192.168.1.0/24
```

`nmap -sn -n NETWORK/CIDR` — Schneller Ping-Sweep ohne DNS-Auflösung.

```bash
nmap -sn -n 10.0.0.0/24
```

## Port-Auswahl

`nmap -p PORT TARGET` — Scannt einen bestimmten Port.

```bash
nmap -p 80 192.168.1.1
```

`nmap -p PORT1,PORT2,PORT3 TARGET` — Scannt eine Liste bestimmter Ports.

```bash
nmap -p 22,80,443,8080 192.168.1.1
```

`nmap -p START-END TARGET` — Scannt einen Port-Bereich.

```bash
nmap -p 1-1024 192.168.1.1
```

`nmap -p- TARGET` — Scannt alle 65535 Ports.

```bash
nmap -p- 192.168.1.1
```

`nmap -p U:PORT,T:PORT TARGET` — Gibt UDP- (U:) und TCP- (T:) Ports separat an.

```bash
nmap -p U:53,161,T:22,80,443 192.168.1.1
```

`nmap --top-ports N TARGET` — Scannt die N häufigsten Ports.

```bash
nmap --top-ports 100 192.168.1.1
```

`nmap -F TARGET` — Schnell-Scan – nur die 100 häufigsten Ports (statt 1000).

```bash
nmap -F 192.168.1.0/24
```

`nmap -r TARGET` — Scannt Ports sequenziell statt in zufälliger Reihenfolge.

```bash
nmap -r -p 1-1024 192.168.1.1
```

## Scan-Techniken

`nmap -sS TARGET` — TCP-SYN-Scan (Stealth/Half-Open). Standard für privilegierte Benutzer. Schnell und zuverlässig.

```bash
sudo nmap -sS 192.168.1.1
```

`nmap -sT TARGET` — TCP-Connect-Scan. Nutzt den vollständigen TCP-Handshake. Standard für nicht-privilegierte Benutzer.

```bash
nmap -sT 192.168.1.1
```

`nmap -sU TARGET` — UDP-Scan. Langsamer als TCP-Scans, aber unverzichtbar für UDP-Dienste.

```bash
sudo nmap -sU -p 53,67,68,123,161,500 192.168.1.1
```

`nmap -sA TARGET` — TCP-ACK-Scan. Dient zur Analyse von Firewall-Regeln und erkennt gefilterte/ungefilterte Ports.

```bash
sudo nmap -sA 192.168.1.1
```

`nmap -sW TARGET` — TCP-Window-Scan. Ähnlich dem ACK-Scan, kann aber auf manchen Systemen offene Ports erkennen.

```bash
sudo nmap -sW 192.168.1.1
```

`nmap -sN TARGET` — TCP-Null-Scan. Sendet Pakete ohne gesetzte TCP-Flags.

```bash
sudo nmap -sN 192.168.1.1
```

`nmap -sF TARGET` — TCP-FIN-Scan. Sendet Pakete mit nur dem FIN-Flag.

```bash
sudo nmap -sF 192.168.1.1
```

`nmap -sX TARGET` — TCP-Xmas-Scan. Sendet Pakete mit den Flags FIN, PSH und URG.

```bash
sudo nmap -sX 192.168.1.1
```

`nmap -sM TARGET` — TCP-Maimon-Scan. Sendet FIN/ACK-Probes. Funktioniert auf manchen BSD-basierten Systemen.

```bash
sudo nmap -sM 192.168.1.1
```

`nmap -sO TARGET` — IP-Protokoll-Scan. Ermittelt, welche IP-Protokolle unterstützt werden.

```bash
sudo nmap -sO 192.168.1.1
```

`nmap -sS -sU TARGET` — Kombinierter TCP-SYN- und UDP-Scan für umfassende Ergebnisse.

```bash
sudo nmap -sS -sU -p T:22,80,443,U:53,161 192.168.1.1
```

## Dienst- und Versionserkennung

`nmap -sV TARGET` — Testet offene Ports, um Dienstname und Version zu ermitteln.

```bash
nmap -sV 192.168.1.1
```

`nmap -sV --version-intensity N TARGET` — Legt die Intensität der Versionserkennung fest (0=gering, 9=alle Probes). Standard: 7.

```bash
nmap -sV --version-intensity 5 192.168.1.1
```

`nmap -sV --version-light TARGET` — Schnelle Versionserkennung (Intensität 2). Schneller, aber weniger genau.

```bash
nmap -sV --version-light 192.168.1.1
```

`nmap -sV --version-all TARGET` — Probiert jeden einzelnen Probe zur Versionserkennung (Intensität 9).

```bash
nmap -sV --version-all 192.168.1.1
```

`nmap -A TARGET` — Aggressiver Scan. Aktiviert OS-Erkennung, Versionserkennung, Skript-Scan und Traceroute.

```bash
sudo nmap -A 192.168.1.1
```

`nmap -sC TARGET` — Führt Standard-NSE-Skripte aus. Entspricht --script=default.

```bash
nmap -sC 192.168.1.1
```

`nmap -sV -sC TARGET` — Versionserkennung kombiniert mit Standard-Skripten. Eine häufige Kombination.

```bash
nmap -sV -sC 192.168.1.1
```

## Betriebssystem-Erkennung

`nmap -O TARGET` — Aktiviert die OS-Erkennung per TCP/IP-Stack-Fingerprinting.

```bash
sudo nmap -O 192.168.1.1
```

`nmap -O --osscan-limit TARGET` — Versucht OS-Erkennung nur, wenn mindestens ein offener und ein geschlossener TCP-Port gefunden wird.

```bash
sudo nmap -O --osscan-limit 192.168.1.0/24
```

`nmap -O --osscan-guess TARGET` — Rät das Betriebssystem aggressiver, wenn die Erkennung unsicher ist.

```bash
sudo nmap -O --osscan-guess 192.168.1.1
```

`nmap -O --max-os-tries N TARGET` — Begrenzt die Anzahl der OS-Erkennungsversuche (Standard: 5).

```bash
sudo nmap -O --max-os-tries 2 192.168.1.1
```

## Timing und Performance

`nmap -T0 TARGET` — Paranoides Timing. Extrem langsam, zur IDS-Umgehung. Serieller Scan, 5 Minuten zwischen Probes.

```bash
nmap -T0 192.168.1.1
```

`nmap -T1 TARGET` — Schleichendes Timing. Langsam, 15 Sekunden zwischen Probes.

```bash
nmap -T1 192.168.1.1
```

`nmap -T2 TARGET` — Höfliches Timing. Reduziert die Scan-Geschwindigkeit, um Bandbreite zu schonen. 0,4 Sekunden zwischen Probes.

```bash
nmap -T2 192.168.1.1
```

`nmap -T3 TARGET` — Normales Timing. Standard. Ausgewogen zwischen Geschwindigkeit und Genauigkeit.

```bash
nmap -T3 192.168.1.1
```

`nmap -T4 TARGET` — Aggressives Timing. Schneller, setzt ein schnelles und zuverlässiges Netzwerk voraus.

```bash
nmap -T4 192.168.1.1
```

`nmap -T5 TARGET` — Wahnsinniges Timing. Sehr schnell, kann aber die Genauigkeit beeinträchtigen. Kann Ziele überlasten.

```bash
nmap -T5 192.168.1.1
```

`nmap --min-rate N TARGET` — Sendet mindestens N Pakete pro Sekunde.

```bash
nmap --min-rate 1000 192.168.1.0/24
```

`nmap --max-rate N TARGET` — Sendet höchstens N Pakete pro Sekunde.

```bash
nmap --max-rate 100 192.168.1.1
```

`nmap --min-parallelism N TARGET` — Legt die minimale Anzahl paralleler Probes fest.

```bash
nmap --min-parallelism 10 192.168.1.0/24
```

`nmap --max-retries N TARGET` — Begrenzt die Anzahl der Wiederholungsversuche für Port-Scan-Probes.

```bash
nmap --max-retries 2 192.168.1.1
```

`nmap --host-timeout TIME TARGET` — Bricht den Scan eines Ziels nach dieser Zeit ab (z. B. 30s, 5m, 1h).

```bash
nmap --host-timeout 5m 192.168.1.0/24
```

`nmap --scan-delay TIME TARGET` — Wartet mindestens TIME zwischen den Probes.

```bash
nmap --scan-delay 1s 192.168.1.1
```

## NSE-Skripte (Nmap Scripting Engine)

`nmap --script SCRIPT TARGET` — Führt ein bestimmtes NSE-Skript aus.

```bash
nmap --script http-title 192.168.1.1
```

`nmap --script CATEGORY TARGET` — Führt alle Skripte einer Kategorie aus: auth, broadcast, default, discovery, exploit, external, fuzzer, intrusive, malware, safe, version, vuln.

```bash
nmap --script safe 192.168.1.1
```

`nmap --script "SCRIPT1,SCRIPT2" TARGET` — Führt mehrere Skripte aus.

```bash
nmap --script "http-title,http-headers" 192.168.1.1
```

`nmap --script "http-*" TARGET` — Führt alle Skripte aus, die einem Wildcard-Muster entsprechen.

```bash
nmap --script "http-*" -p 80,443 192.168.1.1
```

`nmap --script "not intrusive" TARGET` — Führt alle Skripte außer denen einer bestimmten Kategorie aus.

```bash
nmap --script "not intrusive" 192.168.1.1
```

`nmap --script "default and safe" TARGET` — Führt Skripte aus, die in beiden Kategorien liegen (logisches UND).

```bash
nmap --script "default and safe" 192.168.1.1
```

`nmap --script SCRIPT --script-args KEY=VAL TARGET` — Übergibt Argumente an NSE-Skripte.

```bash
nmap --script http-brute --script-args http-brute.path=/admin 192.168.1.1
```

`nmap --script-updatedb` — Aktualisiert die NSE-Skript-Datenbank nach dem Hinzufügen eigener Skripte.

```bash
sudo nmap --script-updatedb
```

`nmap --script-help SCRIPT` — Zeigt Hilfe und Dokumentation für ein bestimmtes Skript an.

```bash
nmap --script-help http-enum
```

## Nützliche NSE-Skripte

`nmap --script http-enum TARGET` — Enumeriert gängige Web-Verzeichnisse und -Dateien (robots.txt, Admin-Panels usw.).

```bash
nmap --script http-enum -p 80,443 192.168.1.1
```

`nmap --script http-title TARGET` — Zeigt den Titel von Webseiten auf offenen HTTP-Ports an.

```bash
nmap --script http-title -p 80,443,8080 192.168.1.0/24
```

`nmap --script http-headers TARGET` — Zeigt HTTP-Antwort-Header an.

```bash
nmap --script http-headers -p 80 192.168.1.1
```

`nmap --script ssl-enum-ciphers TARGET` — Listet SSL/TLS-Cipher-Suites auf und bewertet sie.

```bash
nmap --script ssl-enum-ciphers -p 443 192.168.1.1
```

`nmap --script ssl-cert TARGET` — Ruft SSL/TLS-Zertifikatsdetails ab und zeigt sie an.

```bash
nmap --script ssl-cert -p 443 192.168.1.1
```

`nmap --script dns-brute TARGET` — Brute-forcet DNS-Hostnamen für eine Domain.

```bash
nmap --script dns-brute example.com
```

`nmap --script smb-os-discovery TARGET` — Erkennt Betriebssysteminfos über das SMB-Protokoll.

```bash
nmap --script smb-os-discovery -p 445 192.168.1.1
```

`nmap --script banner TARGET` — Liest Dienst-Banner von offenen Ports aus.

```bash
nmap --script banner -p 21,22,25,80 192.168.1.1
```

`nmap --script vuln TARGET` — Führt alle Schwachstellenerkennungs-Skripte aus.

```bash
sudo nmap --script vuln 192.168.1.1
```

`nmap --script whois-ip TARGET` — Ruft WHOIS-Informationen für die Ziel-IP ab.

```bash
nmap --script whois-ip 8.8.8.8
```

`nmap --script traceroute-geolocation TARGET` — Geolokaliert jeden Hop eines Traceroutes.

```bash
sudo nmap --traceroute --script traceroute-geolocation 8.8.8.8
```

`nmap --script mysql-info TARGET` — Ruft MySQL-Server-Informationen ab.

```bash
nmap --script mysql-info -p 3306 192.168.1.1
```

## Ausgabeformate

`nmap -oN FILE TARGET` — Normale Ausgabe in eine Datei (menschenlesbar).

```bash
nmap -oN scan.txt 192.168.1.1
```

`nmap -oX FILE TARGET` — XML-Ausgabe in eine Datei. Nützlich für den Import in andere Tools.

```bash
nmap -oX scan.xml 192.168.1.1
```

`nmap -oG FILE TARGET` — Grep-freundliche Ausgabe in eine Datei. Einfach mit grep/awk zu verarbeiten.

```bash
nmap -oG scan.gnmap 192.168.1.1
```

`nmap -oS FILE TARGET` — Script-Kiddie-Ausgabe (Leet Speak). Hauptsächlich ein Witz.

```bash
nmap -oS scan.txt 192.168.1.1
```

`nmap -oA BASENAME TARGET` — Ausgabe in allen drei Hauptformaten (.nmap, .xml, .gnmap).

```bash
nmap -oA scan_results 192.168.1.1
```

`nmap -v TARGET` — Erhöht die Ausführlichkeit. Zeigt offene Ports, sobald sie gefunden werden.

```bash
nmap -v 192.168.1.1
```

`nmap -vv TARGET` — Doppelte Ausführlichkeit für noch mehr Details.

```bash
nmap -vv 192.168.1.1
```

`nmap -d TARGET` — Aktiviert Debug-Ausgabe.

```bash
nmap -d 192.168.1.1
```

`nmap --reason TARGET` — Zeigt den Grund an, warum jeder Port in einem bestimmten Zustand ist.

```bash
nmap --reason 192.168.1.1
```

`nmap --open TARGET` — Zeigt nur offene (oder möglicherweise offene) Ports in der Ausgabe an.

```bash
nmap --open 192.168.1.1
```

`nmap --packet-trace TARGET` — Zeigt alle gesendeten und empfangenen Pakete an. Sehr ausführlich.

```bash
nmap --packet-trace -p 80 192.168.1.1
```

`nmap --resume FILE` — Setzt einen abgebrochenen Scan aus einer normalen Ausgabedatei fort.

```bash
nmap --resume scan.txt
```

## Firewall- und IDS-Umgehung

`nmap -f TARGET` — Fragmentiert Pakete in 8-Byte-Blöcke, um Paketfilter zu umgehen.

```bash
sudo nmap -f 192.168.1.1
```

`nmap --mtu N TARGET` — Legt eine eigene MTU für fragmentierte Pakete fest (muss ein Vielfaches von 8 sein).

```bash
sudo nmap --mtu 24 192.168.1.1
```

`nmap -D DECOY1,DECOY2,ME TARGET` — Verschleiert den Scan mit Schein-IP-Adressen. ME fügt deine echte IP ein.

```bash
sudo nmap -D 10.0.0.1,10.0.0.2,ME 192.168.1.1
```

`nmap -D RND:N TARGET` — Verwendet N zufällige Schein-Adressen.

```bash
sudo nmap -D RND:5 192.168.1.1
```

`nmap -S SOURCE_IP TARGET` — Fälscht die Quell-IP-Adresse.

```bash
sudo nmap -S 10.0.0.1 -e eth0 192.168.1.1
```

`nmap -e INTERFACE TARGET` — Gibt das zu verwendende Netzwerkinterface an.

```bash
nmap -e eth0 192.168.1.1
```

`nmap --source-port PORT TARGET` — Verwendet eine bestimmte Quellportnummer. Manche Firewalls erlauben Datenverkehr von Port 53 oder 80.

```bash
sudo nmap --source-port 53 192.168.1.1
```

`nmap --data-length N TARGET` — Hängt N zufällige Bytes an Pakete an, um Signaturerkennung zu vermeiden.

```bash
nmap --data-length 25 192.168.1.1
```

`nmap --spoof-mac MAC TARGET` — Fälscht die MAC-Adresse. 0 für zufällig oder ein Herstellername.

```bash
sudo nmap --spoof-mac Apple 192.168.1.1
```

`nmap --badsum TARGET` — Sendet Pakete mit einer ungültigen TCP/UDP-Prüfsumme. Antworten zeigen Firewalls, die keine Prüfsummen verifizieren.

```bash
nmap --badsum 192.168.1.1
```

`nmap --ttl N TARGET` — Legt einen eigenen IP-Time-to-Live-Wert fest.

```bash
nmap --ttl 64 192.168.1.1
```

## DNS und Reverse-Lookup

`nmap -n TARGET` — Führt keine DNS-Auflösung durch. Beschleunigt Scans erheblich.

```bash
nmap -n 192.168.1.0/24
```

`nmap -R TARGET` — Führt immer eine Reverse-DNS-Auflösung durch (auch für Offline-Hosts).

```bash
nmap -R 192.168.1.0/24
```

`nmap --dns-servers DNS1,DNS2 TARGET` — Verwendet eigene DNS-Server für die Auflösung.

```bash
nmap --dns-servers 8.8.8.8,1.1.1.1 192.168.1.0/24
```

`nmap --system-dns TARGET` — Verwendet den OS-DNS-Resolver statt nmaps eingebautem Resolver.

```bash
nmap --system-dns 192.168.1.1
```

`nmap -sL NETWORK/CIDR` — Listen-Scan – listet nur Ziele mit Reverse-DNS auf. Kein tatsächliches Scannen.

```bash
nmap -sL 192.168.1.0/24
```

## Weitere Optionen

`nmap --traceroute TARGET` — Verfolgt den Netzwerkpfad zum Ziel.

```bash
sudo nmap --traceroute 8.8.8.8
```

`nmap --iflist` — Zeigt lokale Netzwerkinterfaces und Routen an, wie nmap sie sieht.

```bash
nmap --iflist
```

`nmap -sV --version-trace TARGET` — Zeigt detaillierte Versionserkennungsaktivität zur Fehlersuche an.

```bash
nmap -sV --version-trace -p 80 192.168.1.1
```

`nmap --privileged TARGET` — Nimmt an, dass der Benutzer vollständige Berechtigungen hat (umgeht Berechtigungsprüfungen).

```bash
nmap --privileged 192.168.1.1
```

`nmap --send-eth TARGET` — Sendet rohe Ethernet-Frames statt IP-Pakete.

```bash
sudo nmap --send-eth 192.168.1.1
```

`nmap -V` — Zeigt die nmap-Version an.

```bash
nmap -V
```

## Häufige Scan-Kombinationen

`nmap -sS -sV -O -p- TARGET` — Umfassender Scan: SYN-Scan aller Ports mit Versions- und OS-Erkennung.

```bash
sudo nmap -sS -sV -O -p- 192.168.1.1
```

`nmap -sn -n NETWORK/CIDR -oG - | grep 'Up'` — Schnelle Host-Erkennung: listet alle aktiven Hosts im Netzwerk auf.

```bash
nmap -sn -n 192.168.1.0/24 -oG - | grep 'Up'
```

`nmap -T4 -F -sV TARGET` — Schnellscan mit Versionserkennung auf den 100 häufigsten Ports.

```bash
nmap -T4 -F -sV 192.168.1.1
```

`nmap -sS -sU -T4 -A -v TARGET` — Vollständiger TCP+UDP-Aggressiv-Scan mit allen Erkennungsfunktionen.

```bash
sudo nmap -sS -sU -T4 -A -v 192.168.1.1
```

`nmap -sV -sC --open -p 80,443 NETWORK/CIDR` — Findet alle Web-Server im Netzwerk mit Skripten und Versionsinformationen.

```bash
nmap -sV -sC --open -p 80,443 192.168.1.0/24
```

`nmap -Pn -sS -p 22 --open NETWORK/CIDR -oG - | grep open` — Findet alle SSH-Server im Netzwerk.

```bash
sudo nmap -Pn -sS -p 22 --open 192.168.1.0/24 -oG - | grep open
```

`nmap -sV --script ssl-cert -p 443 NETWORK/CIDR` — Scannt nach SSL-Zertifikaten im Netzwerk.

```bash
nmap -sV --script ssl-cert -p 443 192.168.1.0/24
```

`nmap -sU -p 161 --script snmp-info NETWORK/CIDR` — Findet SNMP-fähige Geräte und ruft Systeminformationen ab.

```bash
sudo nmap -sU -p 161 --script snmp-info 192.168.1.0/24
```

`nmap --script http-enum,http-title,http-methods -p 80,443,8080,8443 TARGET` — Web-Reconnaissance: Verzeichnisse, Titel und erlaubte HTTP-Methoden.

```bash
nmap --script http-enum,http-title,http-methods -p 80,443,8080,8443 192.168.1.1
```

## Port-Zustände erklärt

`open` — Eine Anwendung lauscht aktiv auf diesem Port und nimmt Verbindungen an.

`closed` — Der Port ist erreichbar (antwortet auf Probes), aber keine Anwendung lauscht.

`filtered` — Eine Firewall oder ein Filter blockiert Probes. nmap kann nicht feststellen, ob der Port offen ist.

`unfiltered` — Der Port ist erreichbar, aber nmap kann nicht feststellen, ob er offen oder geschlossen ist (ACK-Scan).

`open|filtered` — nmap kann nicht feststellen, ob der Port offen oder gefiltert ist (häufig bei UDP-Scans).

`closed|filtered` — nmap kann nicht feststellen, ob der Port geschlossen oder gefiltert ist.

<!-- PROSE:outro -->
## Fazit

nmap gehört in jede Admintoolbox: Ob du eine Bestandsaufnahme deines Netzwerks machst, einen Penetrationstest vorbereitest oder einfach prüfst, welche Dienste erreichbar sind – kein anderes Tool liefert so viel Aufschluss mit einem einzigen Befehl. Nutze `-oA` für reproduzierbare Ergebnisse und die NSE-Skripte für gezielte Checks.

## Weiterführende Links

- [nmap – offizielle Dokumentation](https://nmap.org/docs.html) – Referenz und NSE-Skriptbibliothek (englisch)
- [nmap(1) – Manpage](https://nmap.org/book/man.html) – alle Optionen im Überblick (englisch)
- [Nmap – Wikipedia](https://de.wikipedia.org/wiki/Nmap) – Hintergrund und Geschichte
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [nc](https://www.jpkc.com/db/cheatsheets/networking/nc/) – TCP/UDP-Verbindungen öffnen und testen
- [ping](https://www.jpkc.com/db/cheatsheets/networking/ping/) – Erreichbarkeit von Hosts prüfen
- [traceroute](https://www.jpkc.com/db/cheatsheets/networking/traceroute/) – Netzwerkpfade zum Ziel verfolgen