Spickzettel für Netzwerk-Tools
🇬🇧 Read in English~11 min read
DevOpsnetworkingtcpdumpdigcurltroubleshootingdnssysadmin
Back openDesk Edu for a sovereign, open-source education — every vote counts.
Vote nowSave products you love by clicking the heart icon.
Ein unverzichtbares Referenzwerk für socat — das bidirektionale Daten-Relay-Schweizer Taschenmesser für TCP, UDP, UNIX-Sockets, SSL/TLS, PTY, Dateien und Proxy-Verbindungen.
Ein praktischer Quick-Reference-Guide für Netzwerkdiagnose und Fehlerbehebung unter Linux. Die Befehle sind nach Tools organisiert, ergänzt durch gängige Flags und realistische Beispiele.
Der moderne Ersatz für ifconfig, route und arp. Teil der iproute2-Suite.
# List all interfaces with addresses
ip addr show
# Show a specific interface
ip addr show eth0
# Brief listing (no extra details)
ip -brief addr show
# Show only assigned addresses
ip -4 addr show
# Add an IP address to an interface
ip addr add 192.168.1.100/24 dev eth0
# Add a secondary IP
ip addr add 10.0.0.50/24 dev eth0 label eth0:1
# Remove an IP address
ip addr del 192.168.1.100/24 dev eth0
# Flush all addresses on an interface
ip addr flush dev eth0
# Bring an interface up
ip link set eth0 up
# Bring an interface down
ip link set eth0 down
# Set the MTU
ip link set eth0 mtu 9000
# Change the MAC address (requires link down first)
ip link set eth0 address 00:11:22:33:44:55
# Enable promiscuous mode
ip link set eth0 promisc on
# Disable promiscuous mode
ip link set eth0 promisc off
# Show the routing table
ip route show
# Show route to a specific destination
ip route get 8.8.8.8
# Add a default gateway
ip route add default via 192.168.1.1
# Add a static route
ip route add 10.0.0.0/24 via 192.168.1.254
# Add a route through a specific interface
ip route add 172.16.0.0/16 dev eth1
# Delete a route
ip route del 10.0.0.0/24 via 192.168.1.254
# Show routing cache
ip route show cache
# Show ARP table
ip neigh show
# Show ARP for a specific device
ip neigh show dev eth0
# Add a static ARP entry
ip neigh add 192.168.1.10 lladdr aa:bb:cc:dd:ee:ff dev eth0
# Delete an ARP entry
ip neigh del 192.168.1.10 dev eth0
# Flush the ARP table
ip neigh flush all
Paketanalysator zum Erfassen und Untersuchen von Netzwerkverkehr. Erfordert Root-Rechte oder CAP_NET_RAW.
# Capture auf einem spezifischen Interface
tcpdump -i eth0
# Capture auf jedem Interface
tcpdump -i any
# Capture mit detaillierter Ausgabe (verbose)
tcpdump -i eth0 -v
tcpdump -i eth0 -c 100
tcpdump -i eth0 -S
### Filter by Host, Port, Protocol
```bash
# Traffic von/zu einem Host erfassen
tcpdump -i eth0 host 192.168.1.10
# Nur Traffic von einer Quelle erfassen
tcpdump -i eth0 src 192.168.1.10
# Nur Traffic zu einem Ziel erfassen
tcpdump -i eth0 dst 192.168.1.10
# Traffic auf einem bestimmten Port erfassen
tcpdump -i eth0 port 80
# Erfassung in einem Portbereich
tcpdump -i eth0 portrange 80-90
# Bestimmtes Protokoll erfassen (tcp, udp, icmp, arp)
tcpdump -i eth0 icmp
# Filter mit and/or/not kombinieren
tcpdump -i eth0 'tcp port 80 and host 192.168.1.10'
tcpdump -i eth0 'tcp port 443 or tcp port 80'
tcpdump -i eth0 'not port 22'
# TCP SYN-Pakete erfassen (neue Verbindungen)
tcpdump -i eth0 'tcp[tcpflags] & (tcp-syn) != 0'
# Nur SYN-ACK-Pakete erfassen
tcpdump -i eth0 'tcp[tcpflags] & (tcp-syn|tcp-ack) = (tcp-syn|tcp-ack)'
# TCP RST-Pakete erfassen (Verbindungsabbrüche)
tcpdump -i eth0 'tcp[tcpflags] & (tcp-rst) != 0'
# Pakete erfassen, die größer als 1000 Bytes sind
tcpdump -i eth0 'greater 1000'
# Pakete erfassen, die kleiner als 100 Bytes sind
tcpdump -i eth0 'less 100'
# Traffic in einem bestimmten Subnetz erfassen
tcpdump -i eth0 'net 10.0.0.0/24'
# HTTP GET-Requests erfassen
tcpdump -i eth0 -A -s 0 'tcp port 80 and ((tcp[((tcp[12:1] & 0xf0) >> 2):4] = 0x47455420))'
# DNS-Queries erfassen
tcpdump -i eth0 -s 0 'port 53'
# Erfassung in einer pcap-Datei speichern
tcpdump -i eth0 -w capture.pcap
# Mit Ringpuffer speichern (Dateien bei 100MB rotieren, 5 behalten)
tcpdump -i eth0 -w capture.pcap -C 100 -W 5
# Eine pcap-Datei lesen
tcpdump -r capture.pcap
# Lesen mit detaillierter Ausgabe (verbose)
tcpdump -r capture.pcap -v
# Lesen mit Hex- und ASCII-Inhalt
tcpdump -r capture.pcap -XX
# ASCII-Inhalt neben Hex anzeigen
tcpdump -i eth0 -A
# Hex und ASCII nebeneinander anzeigen
tcpdump -i eth0 -XX
# Jedes Paket detailliert ausgeben
tcpdump -i eth0 -vv
# Hostnamen nicht auflösen (schneller)
tcpdump -i eth0 -n
# Portnamen nicht auflösen
tcpdump -i eth0 -nn
# Absolute Zeitstempel ausgeben
tcpdump -i eth0 -tttt
DNS lookup utility from the BIND suite. Preferred over nslookup for scripting.
# Einfacher A-Record-Lookup
dig example.com
# Lookup mit kurzer Ausgabe
dig +short example.com
# Lookup eines bestimmten Record-Typs
dig example.com A
dig example.com AAAA
dig example.com MX
dig example.com NS
dig example.com TXT
dig example.com CNAME
dig example.com SOA
# Abfrage gegen einen spezifischen DNS-Server
dig @8.8.8.8 example.com
# Abfrage von einem spezifischen DNS-Server mit kurzer Ausgabe
dig @1.1.1.1 +short example.com
# Reverse Lookup (PTR-Record)
dig -x 8.8.8.8
# Reverse Lookup mit kurzer Ausgabe
dig -x 8.8.8.8 +short
# Den vollständigen Auflösungspfad verfolgen (Trace)
dig +trace example.com
# Trace von einem spezifischen Root-Server
dig +trace @a.root-servers.net example.com
# Die vollständige DNS-Antwort anzeigen (Header, Question, Answer, Authority, Additional)
dig example.com +noall +answer
# Nur den Answer-Bereich anzeigen
dig example.com +answer
# DNSSEC Chain of Trust anzeigen
dig example.com DNSKEY +short
dig example.com DS +short
# DNSSEC-Validierung prüfen
dig example.com +dnssec
# Abfrage via TCP statt UDP
dig +tcp example.com
# Timing-Informationen anzeigen
dig example.com +stats
# Abfrage über einen spezifischen Port
dig @localhost -p 5353 example.com
# Mehrere Record-Typen gleichzeitig abfragen
dig example.com ANY +noall +answer
# Abfrage aus einer Datei (eine Domain pro Zeile)
dig -f domains.txt +short
# Abfrage mit spezifischen EDNS-Optionen
dig +edns=0 example.com
Interactive DNS lookup tool. Simpler than dig but less scriptable.
# Eine Domain auflösen
nslookup example.com
# Auflösung gegen einen spezifischen Server
nslookup example.com 8.8.8.8
# Einen spezifischen Record-Typ auflösen
nslookup -type=MX example.com
nslookup -type=NS example.com
nslookup -type=TXT example.com
# Reverse Lookup
nslookup 8.8.8.8
# Interaktiver Modus
nslookup
> server 8.8.8.8
> set type=MX
> example.com
> exit
Versatile tool for transferring data with URL syntax. Supports HTTP, HTTPS, FTP, and more.
# GET-Request (Standard)
curl https://api.example.com/users
# POST-Request mit Daten
curl -X POST https://api.example.com/users -d "name=alice"
# POST mit JSON-Body
curl -X POST https://api.example.com/users \
-H "Content-Type: application/json" \
-d '{"name": "alice", "role": "admin"}'
# PUT-Request
curl -X PUT https://api.example.com/users/1 -d "name=bob"
# PATCH-Request
curl -X PATCH https://api.example.com/users/1 -d "role=editor"
# DELETE-Request
curl -X DELETE https://api.example.com/users/1
# HEAD-Request (nur Header)
curl -I https://api.example.com/users
# OPTIONS-Request
curl -X OPTIONS https://api.example.com/users -i
# Benutzerdefinierten Header setzen
curl -H "Authorization: Bearer TOKEN" https://api.example.com/me
# Mehrere Header setzen
curl -H "Accept: application/json" -H "X-Request-ID: 123" https://api.example.com
# Antwort-Header anzeigen
curl -i https://api.example.com
# Nur Antwort-Header anzeigen
curl -s -D - https://api.example.com -o /dev/null
# Cookie senden
curl -b "session=abc123" https://api.example.com/me
# Cookies aus einer Datei senden
curl -b cookies.txt https://api.example.com
# Antwort-Cookies in einer Datei speichern
curl -c cookies.txt https://api.example.com/login
# Basic Auth
curl -u user:password https://api.example.com
# Bearer Token
curl -H "Authorization: Bearer TOKEN" https://api.example.com
# OAuth2 Client Credentials (zuerst Token abrufen)
curl -X POST https://auth.example.com/token \
-d "grant_type=client_credentials" \
-u "CLIENT_ID:CLIENT_SECRET"
# Token verwenden
TOKEN="eyJhbGci..."
curl -H "Authorization: Bearer $TOKEN" https://api.example.com/me
# Authentifizierung per Client-Zertifikat
curl --cert client.pem --key key.pem https://secure.example.com
# TLS-Verifizierung überspringen (unsicher, nur für Tests)
curl -k https://self-signed.example.com
# Antwort in Datei speichern
curl -o output.html https://example.com
# Originalen Remote-Dateinamen verwenden
curl -O https://example.com/file.zip
# Silent-Modus (kein Fortschritt oder Fehler)
curl -s https://example.com
# Verbose-Ausgabe anzeigen (Header, Verbindungsinfo)
curl -v https://example.com
# Nur HTTP-Statuscode anzeigen
curl -s -o /dev/null -w "%{http_code}" https://example.com
# Antwortdetails formatieren
curl -s -o /dev/null -w "Status: %{http_code}\nTime: %{time_total}s\nSize: %{size_download}\n" https://example.com
# Bei Serverfehlern lautlos abbrechen
curl -f https://example.com
# Debug-Log schreiben
curl --trace-ascii debug.log https://example.com
# Redirects folgen
curl -L https://example.com
# Redirects mit maximalem Limit folgen
curl -L --max-redirs 5 https://example.com
# Timeout setzen (Sekunden)
curl --max-time 10 https://example.com
# Nur Connect-Timeout setzen
curl --connect-timeout 5 https://example.com
# Bei Fehlern wiederholen (bis zu 3 Mal)
curl --retry 3 https://example.com
# Datei mit PUT hochladen
curl -T upload.tar.gz https://example.com/upload
# Multipart-Formdaten senden
curl -F "file=@photo.jpg" https://example.com/upload
# Formdaten senden (application/x-www-form-urlencoded)
curl -d "user=alice&action=submit" https://example.com/form
# Einen Proxy verwenden
curl --proxy http://proxy.example.com:8080 https://example.com
# Den Referer-Header setzen
curl -e "https://example.com" https://other.example.com
# User-Agent setzen
curl -A "MyBot/1.0" https://example.com
# Anfrage komprimieren (Accept-Encoding senden)
curl --compressed https://example.com
Modern replacement for netstat. Inspect sockets, connections, and network statistics.
# Alle TCP-Verbindungen auflisten
ss -t
# Alle TCP-Verbindungen mit Prozessinformationen auflisten
ss -tp
# Alle listening TCP-Sockets auflisten
ss -tln
# Alle UDP-Sockets auflisten
ss -u
# Alle listening UDP-Sockets auflisten
ss -uln
# Alle Sockets auflisten (TCP, UDP, UNIX)
ss -a
# Alle Sockets mit Prozessinformationen auflisten
ss -tap
# Etablierte Verbindungen anzeigen
ss -t state established
# TIME-WAIT-Verbindungen anzeigen
ss -t state time-wait
# Geschlossene Verbindungen anzeigen
ss -t state closed
# Alle Zustände anzeigen
ss -t state all
# Verbindungen in einem bestimmten Zustand mit Prozessinformationen anzeigen
ss -tp state established
# Verbindungen zu einem bestimmten Port anzeigen
ss -t 'sport = :443'
# Verbindungen von einer bestimmten Quelle anzeigen
ss -t 'src = 192.168.1.0/24'
# Verbindungen zu einem bestimmten Ziel anzeigen
ss -t 'dst = 10.0.0.1'
# Filter kombinieren
ss -t 'dst = 10.0.0.1 and dport = :443'
# Verbindungen auf einem bestimmten Interface anzeigen
ss -t 'dev = eth0'
# Zusammenfassung der Socket-Statistiken anzeigen
ss -s
# TCP-Statistiken anzeigen
ss -st
# UDP-Statistiken anzeigen
ss -su
# Speicherverbrauch pro Socket anzeigen
ss -tm
# Numerische Adressen und Ports anzeigen (keine DNS-Auflösung)
ss -tn
# Erweiterte Informationen anzeigen (uid, ino, sk, etc.)
ss -te
# Socket-Speicherinformationen anzeigen
ss -tm
# Timer-Informationen anzeigen (keepalive, retransmission)
ss -to
# Nur IPv4 anzeigen
ss -4 -tln
# Nur IPv6 anzeigen
ss -6 -tln
# Kontinuierliche Überwachung (jede Sekunde)
ss -tlnp -i 1
Veraltetes Tool für Netzwerkstatistiken. Verwenden Sie auf modernen Systemen ss, aber netstat ist auf vielen Servern immer noch zu finden.
# List all TCP connections
netstat -t
# List all listening TCP sockets
netstat -tln
# List all UDP sockets
netstat -uln
# List all sockets
netstat -a
# Show process info (PID/program name)
netstat -tlnp
# Show numeric addresses only (skip DNS lookup)
netstat -tn
# Show interface statistics
netstat -i
# Show kernel routing table
netstat -rn
# Show kernel interface table
netstat -ie
# Show TCP statistics
netstat -st
# Show UDP statistics
netstat -su
# Show all statistics
netstat -s
# Find what's listening on a port
netstat -tlnp | grep :8080
# Count established connections per IP
netstat -tn | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn
Verfolgt die Route, die Pakete zu einem Netzwerkhost nehmen, und zeigt jeden Hop entlang des Pfades an.
# Trace route to a host
traceroute example.com
# Trace with a maximum of 20 hops
traceroute -m 20 example.com
# Trace with ICMP probes instead of UDP (more reliable through firewalls)
traceroute -I example.com
# Trace using TCP SYN on a specific port
traceroute -T -p 443 example.com
# Trace with a specific number of queries per hop
traceroute -q 3 example.com
# Trace and resolve hostnames
traceroute example.com
# Trace without resolving hostnames (faster)
traceroute -n example.com
Kombiniert traceroute und ping in einem einzigen Tool mit einer in Echtzeit aktualisierten Ausgabe.
# Run mtr (real-time updating display)
mtr example.com
# Run in report mode (no interactive display)
mtr --report example.com
# Run report with a specific number of pings
mtr --report --report-cycles 50 example.com
# Use ICMP instead of UDP
mtr --icmp example.com
# Use TCP on a specific port
mtr --tcp --port 443 example.com
# Resolve hostnames (or skip with -n)
mtr --report --no-dns example.com
# Show both ASN and IP info
mtr --report --aslookup example.com
Tool zur Netzwerkexploration und für Sicherheitsaudits. Wird für Port-Scanning, Service-Erkennung und OS-Fingerprinting verwendet.
# Scan a single host (common ports)
nmap example.com
# Scan a specific port
nmap -p 80 example.com
# Scan a range of ports
nmap -p 1-1024 example.com
# Scan specific ports
nmap -p 22,80,443,3306 example.com
# Scan all 65535 ports
nmap -p- example.com
# Fast scan (top 100 ports)
nmap -F example.com
# TCP SYN scan (stealth, default if root)
nmap -sS example.com
# TCP connect scan (full handshake, works without root)
nmap -sT example.com
# UDP scan (slow, requires root)
nmap -sU example.com
# Ping scan (host discovery only)
nmap -sn 192.168.1.0/24
# Skip host discovery (scan directly)
nmap -Pn example.com
# ARP scan on local network (fast)
nmap -PR 192.168.1.0/24
# Detect service versions
nmap -sV example.com
# Detect operating system
nmap -O example.com
# Aggressive scan (OS, version, scripts, traceroute)
nmap -A example.com
# Service detection with intensity level (0-9)
nmap -sV --version-intensity 7 example.com
# Scan a full subnet
nmap 192.168.1.0/24
# Scan a range of IPs
nmap 192.168.1.1-50
# Scan from a file
nmap -il hosts.txt
# Exclude a host from scan
nmap 192.168.1.0/24 --exclude 192.168.1.100
# Scan multiple targets
nmap 192.168.1.1 192.168.1.10 10.0.0.1
# Run default scripts
nmap -sC example.com
# Run a specific script
nmap --script http-headers example.com
# Run multiple scripts
nmap --script=http-headers,ssl-heartbleed example.com
# Run scripts with arguments
nmap --script http-title --script-args http.useragent="MyBot" example.com
# List all available scripts
nmap --script-help="http-*"
# Vuln scan (all vulnerability scripts)
nmap --script vuln example.com
# Ausgabe in einer normalen Textdatei speichern
nmap -oN scan.txt example.com
# Ausgabe als XML speichern
nmap -oX scan.xml example.com
# Ausgabe in einem grep-fähigen Format speichern
nmap -oG scan.gnmap example.com
# Gleichzeitig in allen Formaten speichern
nmap -oA scan_results example.com
## nc (netcat)
Swiss-army knife for TCP/UDP connections. Useful for testing ports, transferring files, and quick ad-hoc services.
### Port Scanning and Testing
```bash
# Einen einzelnen Port scannen
nc -zv example.com 80
# Einen Portbereich scannen
nc -zv example.com 20-100
# Spezifische Ports scannen
nc -zv example.com 22 80 443
# Einen UDP-Port testen
nc -zuv example.com 53
# Verbindung zu einem Port herstellen (interaktiv)
nc example.com 80
# Auf einem Port lauschen (Listen)
nc -l 8080
# Lauschen und nach Trennung des Clients weiterlaufen
nc -lk 8080
# Auf einer spezifischen Adresse lauschen
nc -l 192.168.1.10 8080
# Eine Datei über einen Port bereitstellen
nc -l 8080 < myfile.txt
# Eine Datei empfangen
nc example.com 8080 > received.txt
# Einfacher Chat zwischen zwei Maschinen
# Maschine A:
nc -l 4444
# Maschine B:
nc machine-a-ip 4444
# Manuell eine HTTP-Anfrage senden
nc example.com 80
GET / HTTP/1.1
Host: example.com
# Zweimal Enter drücken
# Eine TLS-Verbindung testen (unter Verwendung von -l mit --ssl)
nc -l --ssl 8443
nc --ssl example.com 8443
# Einfaches Port-Forwarding (Relay)
nc -l 8080 | nc example.com 80
# Port-Scan mit Timeout
nc -zv -w 3 example.com 80
Linux kernel firewall for filtering and NAT. Requires root.
# Alle Regeln in der Filter-Tabelle auflisten
iptables -L
# Regeln mit Zeilennummern und Paketanzahlen auflisten
iptables -L -v -n --line-numbers
# Regeln in einer spezifischen Chain auflisten
iptables -L INPUT -v -n
# NAT-Tabellen-Regeln auflisten
iptables -t nat -L -v -n
# Alle Regeln in einer Chain löschen (Flush)
iptables -F
# Eine spezifische Chain löschen
iptables -F INPUT
# Etablierten und verwandten Traffic zulassen
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
# Eingehenden SSH-Traffic zulassen
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
# Eingehenden HTTP- und HTTPS-Traffic zulassen
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT
# Ping (ICMP) zulassen
iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT
# Traffic von einer spezifischen IP zulassen
iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT
# Allen anderen eingehenden Traffic verwerfen (Drop)
iptables -A INPUT -j DROP
# Allen ausgehenden Traffic erlauben
iptables -A OUTPUT -j ACCEPT
# Masquerade (SNAT für dynamische IPs, üblich für Router)
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
# Destination NAT (Port-Weiterleitung)
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.1.10:8080
# Source NAT (statisch)
iptables -t nat -A POSTROUTING -j SNAT --to-source 203.0.113.5
# Eine Regel an einer bestimmten Position einfügen
iptables -I INPUT 3 -p tcp --dport 3306 -j ACCEPT
# Eine Regel über die Zeilennummer löschen
iptables -D INPUT 3
# Eine Regel über die Spezifikation löschen
iptables -D INPUT -p tcp --dport 80 -j ACCEPT
# Die Standard-Policy für eine Chain festlegen
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT
# Regeln in einer Datei speichern
iptables-save > /etc/iptables/rules.v4
# Regeln aus einer Datei wiederherstellen
iptables-restore < /etc/iptables/rules.v4
# Regeln persistent machen (Debian/Ubuntu)
apt install iptables-persistent
netfilter-persistent save
netfilter-persistent reload
Non-interactive network downloader. Ideal for scripts, recursive downloads, and mirroring.
# Eine Datei herunterladen
wget https://example.com/file.zip
# Download mit benutzerdefiniertem Dateinamen
wget -O myfile.zip https://example.com/file.zip
# Download in ein spezifisches Verzeichnis
wget -P /tmp https://example.com/file.zip
# Download im Hintergrund ausführen
wget -b https://example.com/large-file.iso
# Einen unterbrochenen Download fortsetzen
wget -c https://example.com/large-file.iso
# Eine Website spiegeln (gesamte Seite herunterladen)
wget --mirror --convert-links --adjust-extension --page-requisites https://example.com
# Alle Dateien in einem Verzeichnis herunterladen (kein Parent-Verzeichnis)
wget -r -np -nH --cut-dirs=2 https://example.com/docs/files/
# Spezifische Dateitypen rekursiv herunterladen
wget -r -l1 -A pdf https://example.com/docs/
# Rekursionstiefe des Downloads festlegen
wget -r -l 3 https://example.com/
# Download mit Basic-Auth
wget --user=admin --password=secret https://example.com/admin.zip
# Download mit benutzerdefiniertem Header
wget --header="Authorization: Bearer TOKEN" https://example.com/api/data
# Download mit benutzerdefiniertem User-Agent
wget -U "MyBot/1.0" https://example.com
# Download-Geschwindigkeit auf 1 MB/s begrenzen
wget --limit-rate=1M https://example.com/large-file.iso
# Timeout festlegen (Sekunden)
wget --timeout=10 https://example.com/file.zip
# Anzahl der Wiederholungsversuche festlegen
wget --tries=3 https://example.com/file.zip
# Bei Fehlern fortfahren (defekte Links im rekursiven Modus überspringen)
wget -r -nc https://example.com/
# Verbose output
wget -v https://example.com/file.zip
# Debug output (even more verbose)
wget -d https://example.com/file.zip
# Quiet mode (no output)
wget -q https://example.com/file.zip
# Log output to a file
wget -o download.log https://example.com/file.zip
Anzeigen und Manipulieren des ARP-Caches.
# Show the ARP table
arp -a
# Show ARP table in numeric mode (no DNS resolution)
arp -an
# Show ARP for a specific host
arp -a 192.168.1.10
# Show ARP for a specific interface
arp -i eth0
# Add a static ARP entry
arp -s 192.168.1.10 aa:bb:cc:dd:ee:ff
# Delete an ARP entry
arp -d 192.168.1.10
# Delete all entries for an interface
arp -d -i eth0 -a
Tools und Techniken zur Diagnose von DNS- und Hostnamen-Auflösungsproblemen.
# Resolve a hostname using system resolver (respects /etc/nsswitch.conf)
getent hosts example.com
# Resolve using only DNS
getent ahosts example.com
# Resolve with IPv4 only
getent ahostsv4 example.com
# Resolve with IPv6 only
getent ahostsv6 example.com
# Check local hostname mappings
cat /etc/hosts
# Check DNS resolver configuration
cat /etc/resolv.conf
# Check the name service switch order
cat /etc/nsswitch.conf | grep hosts
# Simple lookup
host example.com
# Lookup a specific record type
host -t MX example.com
host -t NS example.com
host -t TXT example.com
# Lookup against a specific server
host example.com 8.8.8.8
# Verbose mode (show TTL)
host -v example.com
# 1. Zuerst lokale Hosts-Datei prüfen
getent hosts example.com
# 2. DNS direkt abfragen (lokalen Cache umgehen)
dig +short example.com
# 3. Einen spezifischen DNS-Server abfragen
dig @8.8.8.8 example.com
# 4. Prüfen, ob die Domain überhaupt existiert
dig example.com NS +short
# 5. Den vollständigen Auflösungspfad verfolgen
dig +trace example.com
# 6. Reverse DNS verifizieren
dig -x 93.184.216.34
dig +short resolver1.opendns.com
nc -zuv 8.8.8.8 53
## Quick Reference
| Tool | Purpose | Key Flags |
| -------------- | ---------------------------- | ----------------------------------------- |
| **ip** | Network interfaces & routing | `addr`, `link`, `route`, `neigh` |
| **tcpdump** | Packet capture & analysis | `-i`, `-w`, `-r`, `-n`, host/port filters |
| **dig** | DNS lookups | `+short`, `+trace`, `-x`, `-t`, `@server` |
| **curl** | HTTP requests | `-X`, `-H`, `-d`, `-o`, `-I`, `-L` |
| **ss** | Socket statistics | `-t`, `-u`, `-l`, `-n`, `-p`, `state` |
| **netstat** | Legacy socket stats | `-tlnp`, `-rn`, `-s`, `-i` |
| **traceroute** | Trace packet path | `-I`, `-T`, `-n`, `-m`, `-q` |
| **mtr** | Combined traceroute + ping | `--report`, `--tcp`, `--icmp` |
| **nmap** | Port scanning & discovery | `-sS`, `-sV`, `-O`, `-A`, `-p`, `-sn` |
| **nc** | TCP/UDP Swiss-army knife | `-zv`, `-l`, `-lk`, `-u` |
| **iptables** | Firewall rules | `-A`, `-D`, `-I`, `-L`, `-F`, `-t nat` |
| **wget** | File downloads | `-O`, `-c`, `-b`, `-r`, `-q` |
| **arp** | ARP cache | `-a`, `-an`, `-s`, `-d` |
## Common Troubleshooting Workflows
### Can't Reach a Remote Host
```bash
# 1. Kann der Hostname aufgelöst werden?
dig +short example.com
# 2. Ist die IP erreichbar?
ping -c 4 93.184.216.34
# 3. Ist der Port offen?
nc -zv example.com 443
# 4. Wo bricht die Route ab?
traceroute -n -m 20 example.com
# 5. Was gibt der Server zurück?
curl -vI https://example.com
# 1. Verbindungen pro IP zählen
ss -tn state established | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -20
# 2. Auf TIME-WAIT-Anhäufungen prüfen
ss -tn state time-wait | wc -l
# 3. Auf SYN-Flood prüfen (viele SYN_RECV)
ss -tn state syn-recv | wc -l
# 4. Sockets pro Prozess anzeigen
ss -tpn | awk '{print $6}' | sort | uniq -c | sort -rn
# 1. System-Resolver prüfen
cat /etc/resolv.conf
# 2. Test mit dig gegen den konfigurierten Server
dig @$(grep nameserver /etc/resolv.conf | awk '{print $2}') example.com
# 3. Test mit einem bekannten, funktionierenden Server
dig @8.8.8.8 example.com
# 4. Auf veralteten lokalen Cache prüfen
dig +trace example.com
# 5. Überprüfen, ob /etc/hosts stört
grep example.com /etc/hosts