# netcat (nc) — Das Schweizer Taschenmesser für TCP/IP

> Praxis-Guide zu netcat (nc) — rohe TCP-/UDP-Verbindungen lesen und schreiben, Ports scannen, Dateien übertragen und Netzwerkdienste auf der Kommandozeile debuggen.

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

<!-- PROSE:intro -->
netcat (nc) ist das Schweizer Taschenmesser des TCP/IP-Stacks: Mit einem einzigen Kommando liest und schreibst du rohe Daten über TCP- und UDP-Verbindungen, scannst Ports, überträgst Dateien zwischen Rechnern und debuggst Netzwerkdienste direkt auf der Shell. Das Tool ist auf nahezu jedem Unix-System vorinstalliert und benötigt keine zusätzlichen Abhängigkeiten. Dieser Guide zeigt dir die wichtigsten nc-Optionen für legitime Admin- und Diagnose-Aufgaben – vom schnellen Port-Check bis zur komprimierten Dateiübertragung.
<!-- PROSE:intro:end -->

## TCP-Verbindungen

`nc <host> <port>` — Verbindet sich mit einem TCP-Port.

```bash
nc example.com 80
```

`nc -v <host> <port>` — Verbindet mit ausführlicher Ausgabe.

```bash
nc -v example.com 443
```

`nc -z <host> <port>` — Port-Scan: prüft, ob ein Port offen ist (keine Daten werden gesendet).

```bash
nc -zv example.com 80
```

`nc -z <host> <start>-<end>` — Scannt einen Port-Bereich.

```bash
nc -zv localhost 3000-3100
```

`nc -w <seconds> <host> <port>` — Setzt einen Verbindungs-Timeout.

```bash
nc -w 5 -zv example.com 443
```

## Lauschen & Server

`nc -l <port>` — Lauscht auf einem TCP-Port (einfacher Server).

```bash
nc -l 8080
```

`nc -lk <port>` — Lauscht und akzeptiert weiterhin Verbindungen (persistent).

```bash
nc -lk 8080
```

`nc -l <port> > <file>` — Lauscht und speichert empfangene Daten in einer Datei.

```bash
nc -l 9999 > received.tar.gz
```

`nc <host> <port> < <file>` — Sendet eine Datei an ein lauschendes netcat.

```bash
nc 192.168.1.10 9999 < backup.tar.gz
```

## UDP

`nc -u <host> <port>` — Verbindet per UDP statt TCP.

```bash
nc -u localhost 5000
```

`nc -lu <port>` — Lauscht auf UDP-Pakete.

```bash
nc -lu 5000
```

`echo '<data>' | nc -u <host> <port>` — Sendet eine UDP-Nachricht.

```bash
echo 'test message' | nc -u localhost 5000
```

## HTTP & Tests

`echo -e 'GET / HTTP/1.1\r\nHost: <host>\r\n\r\n' | nc <host> 80` — Sendet einen rohen HTTP-GET-Request.

```bash
echo -e 'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n' | nc example.com 80
```

`nc -l 8080 <<< 'HTTP/1.1 200 OK\r\n\r\nHello'` — Erstellt einen minimalen Einmal-HTTP-Server.

```bash
while true; do echo -e 'HTTP/1.1 200 OK\r\n\r\nHello' | nc -l 8080; done
```

`echo 'QUIT' | nc <host> 25` — Prüft, ob ein SMTP-Server antwortet.

```bash
echo 'QUIT' | nc -w 3 mail.example.com 25
```

## Dateiübertragung

`nc -l <port> > <file>  (receiver)` — Empfängt eine Datei (auf der Zielmaschine ausführen).

```bash
nc -l 9999 > backup.tar.gz
```

`nc <host> <port> < <file>  (sender)` — Sendet eine Datei (auf der Quellmaschine ausführen).

```bash
nc 192.168.1.10 9999 < backup.tar.gz
```

`tar czf - <dir> | nc <host> <port>` — Sendet ein Verzeichnis als komprimierten Stream.

```bash
tar czf - project/ | nc 192.168.1.10 9999
```

`nc -l <port> | tar xzf -` — Empfängt und entpackt einen komprimierten Stream.

```bash
nc -l 9999 | tar xzf -
```

## Typische Anwendungsmuster

`nc -zv <host> <port> 2>&1 | grep succeeded` — Schneller Konnektivitäts-Check (skriptfreundlich).

```bash
nc -zv db.example.com 5432 2>&1 | grep succeeded
```

`nc -l <port> -e /bin/bash` — Bindet eine Shell an einen Port (nur für autorisierte Tests; nur netcat-traditional oder ncat; nicht im OpenBSD-nc).

```bash
nc -l 4444 -e /bin/bash
```

`nc -l <local-port> | nc <remote-host> <remote-port>` — Einfacher TCP-Proxy / Relay.

```bash
nc -l 8080 | nc backend.local 3000
```

`echo -n | nc -w 1 <host> <port> && echo 'open' || echo 'closed'` — Schneller Port-Check mit open/closed-Ausgabe.

```bash
echo -n | nc -w 1 localhost 3306 && echo 'MySQL open' || echo 'MySQL closed'
```

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

netcat bleibt unverzichtbar, weil es weder Abhängigkeiten noch besondere Rechte braucht: Ein einfaches `nc`-Kommando reicht für Port-Checks, schnelle Dateiübertragungen im LAN oder das Debuggen eines neuen Netzwerkdienstes. Wer komplexere Szenarien braucht – TLS, mehrere gleichzeitige Verbindungen oder Proxy-Funktionen – sollte `socat` als leistungsfähigere Alternative in Betracht ziehen.

## Weiterführende Links

- [Netcat – Wikipedia](https://de.wikipedia.org/wiki/Netcat) – Hintergrund und Geschichte
- [nc(1) – Manpage](https://man.openbsd.org/nc) – alle Optionen im Überblick (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [socat](https://www.jpkc.com/db/cheatsheets/networking/socat/) – vielseitigerer Socket-Relay mit TLS-Unterstützung
- [nmap](https://www.jpkc.com/db/cheatsheets/networking/nmap/) – mächtiger Port- und Service-Scanner
- [ss](https://www.jpkc.com/db/cheatsheets/networking/ss/) – aktive Socket-Verbindungen und lauschende Ports einsehen

