NetWatch

Sieh, was dein Netzwerk tatsächlich tut – live, in deinem Terminal.
Ein Netzwerkmonitor, der verschlüsselten Datenverkehr liest, den Prozess hinter jeder Verbindung benennt und Malware erkennt, die sich nach Hause meldet. Ein Binary. Keine Konfiguration.

Alles auf einmal, mit null Chrome – keine Kopfleiste, keine Menüleiste, keine Statusleiste. Der Download wächst von der gemeinsamen Zeitachse nach oben, der Upload nach unten – so erkennst du die Symmetrie des Datenverkehrs als Form, bevor du eine Zahl liest. Farbe kodiert die Größenordnung, nicht die Serie.

…und das darunterliegende Standard-Instrument mit zehn Tabs, nur ein V entfernt und mit denselben warmen Kollektoren – das Dashboard, das Programm hinter jedem Socket, Deep Packet Inspection, die Netzwerkkarte und das, womit jedes Programm spricht.

Die meisten Netzwerktools beantworten eine Frage – „Was verbraucht meine Bandbreite?“ – und hören dann auf. NetWatch geht weiter. Es dekodiert die Protokolle auf der Leitung, sagt dir welches Programm jede Verbindung geöffnet hat und achtet auf die Muster, die Ärger bedeuten – einen Portscan, Malware, die zu einem Command-Server funkt, Daten, die über DNS herausgeschmuggelt werden. Wenn etwas falsch aussieht, friert ein Tastendruck ein portables Beweisbündel ein, das du an einen Bugreport hängen kannst.

Sieh es als ein Binary ohne Konfiguration, das die Arbeit eines Bandbreitenmessers, der Triage-Ansicht von Wireshark und eines leichtgewichtigen Intrusion-Detectors erledigt – ganz ohne das Terminal zu verlassen.

Es skaliert mit der Frage, die du stellst – in beide Richtungen: --view dense füllt ein großes Terminal mit vier chromfreien Boxen, und netwatch --lite ist ein 80×24-Bildschirm für „Was nutzt gerade mein Netzwerk?“; die vollständige Zehn-Tab-Ansicht ist da, wenn die Antwort „etwas, das ich untersuchen muss“ lautet – einen Tastendruck entfernt und mit derselben Live-Erfassung.

Gemacht für Blue-Teamer, Incident Responder, SREs und Homelabber, die sehen müssen, was gerade jetzt passiert – nicht eine Stunde später eine Capture-Datei analysieren.

650+ Tests · Landlock-sandboxed (Linux) · parst feindlichen Datenverkehr sicher

Und der Teil, den kein anderes Terminaltool kann: NetWatch lernt, womit jedes Programm auf der Maschine spricht, macht aus dieser beobachteten Basislinie mit einem Tastendruck eine Policy und sagt dir den Moment, in dem ein Programm anfängt, mit etwas Neuem zu sprechen.

Beobachten → Übernehmen → Warnen. Die Basislinie wird mit einem Tastendruck zur Policy; das nächste neue Ziel erscheint als Drift.

Warum NetWatch

• 🔓 Lies verschlüsselten Datenverkehr, den du kontrollierst — richte den SSLKEYLOGFILE eines Browsers oder einer App auf NetWatch und sieh zu, wie der Klartext seiner TLS-1.3-Sitzungen live dekodiert wird, genau wie Wireshark es tut. Kein Proxy, keine Zertifikate, nichts dazwischen.
• 🛰️ Erfahre, womit jedes Programm spricht, und lass dich benachrichtigen, wenn es sich ändert — NetWatch beobachtet, welche Ziele jeder Prozess erreicht (Hostname aus dem ClientHello, autonomes System, Port), und ein Tastendruck macht aus dieser beobachteten Basislinie eine Egress-Policy. Von da an warnt es, wenn ein Programm anfängt, mit etwas Neuem zu sprechen. Das ist der Satz, den eine Firewall-Regel nicht ausdrücken kann: curl hat früher nur api.github.com erreicht, und heute hat es etwas anderes erreicht. Nur Beobachtung — es blockiert nie.
• 🧬 Ermittle den Fingerabdruck der Software hinter einer Verbindung — JA4 verwandelt jeden TLS/QUIC-Handshake in einen stabilen Fingerabdruck, sodass du einen bestimmten Client erkennen kannst — oder ein bestimmtes Stück Malware — obwohl der Datenverkehr verschlüsselt ist, so wie du einen Browser an seinem User-Agent erkennen würdest. Pivote auf einen Fingerabdruck, um jeden anderen Flow derselben Software zu finden.
• 🚨 Erkenne Malware, die sich nach Hause meldet — die eingebaute Erkennung für C2-Beaconing (regelmäßige Check-ins mit geringem Jitter), Portscans und DNS-Tunneling läuft ohne Einrichtung im Hintergrund. Ein kritischer Alert friert den Recorder automatisch ein, sodass die Beweise bereits gespeichert sind, wenn du hinschaust.
• ⚙️ Benenne den Prozess hinter jeder Verbindung — ordnet jeden Socket dem Programm zu, das ihn geöffnet hat, per ss/lsof, mit optionaler eBPF-kprobe auf Kernel-Ebene (Linux, das ebpf-Feature), die auch kurzlebige Flows erfasst, die Polling übersehen kann. Funktioniert überall; die kprobe ist eine Verbesserung, keine Voraussetzung.
• 📡 Dekodiere die Protokolle, nicht nur die Ports — echtes L7-Parsing von TLS, QUIC, HTTP und DNS (plus ein SSH-Banner-/Versions-Sniff) sowie einem Dutzend weiterer, mit Stream-Tracking pro Flow und Handshake-Timing — du siehst also api.github.com und den JA4-Fingerabdruck, nicht nur „Port 443“.
• 🎥 Friere die Beweise ein — aktiviere einen Rolling-Recorder und friere jeden Vorfall in ein portables Bündel ein: die Pakete plus die Verbindungen, DNS, Health und Alerts, die sie erklären. Entwickelt für Bugreports und Post-Mortems.
• 🛡️ Sicher von Grund auf — nach der Einrichtung gibt NetWatch seine Privilegien ab und sperrt sich in eine Landlock-Dateisystem-Allowlist (Linux). Ein Tool, das feindlichen Datenverkehr parst, kann deine SSH-Schlüssel, Browserprofile oder /etc/shadow nicht lesen.
• 🪟 Skaliert bis auf einen Bildschirm — --lite beantwortet „Was nutzt mein Netzwerk, und ist meine Verbindung in Ordnung?“ auf einem einzigen 80×24-Bildschirm mit sechs Tasten, passt also in eine SSH-Sitzung zu einem Pi oder einen tmux-Split. Ein Tastendruck eskaliert zur vollständigen Forensik-Ansicht, während die Kollektoren bereits warm sind.

Keine Konfigurationsdateien. Keine Einrichtung. Keine Flags erforderlich.

Installation```bash

brew install netwatch # macOS / Linux nix-shell -p netwatch # NixOS / Nix paru -S netwatch-tui-bin # Arch (prebuilt; netwatch-tui builds from source) scoop install netwatch # Windows cargo install netwatch-tui # anywhere with Rust

Oder lade ein vorgefertigtes Binärpaket von den [Releases](https://github.com/matthart1983/netwatch/releases/latest) herunter.

Die Nix-, Arch- und Scoop-Pakete werden von Community-Packagern gepflegt — vielen Dank. Melde
Verpackungsprobleme dort; Netwatch-Fehler hier. Wenn ein Paket hinter einem Release zurückliegt,
zeigt die [Repology-Seite](https://repology.org/project/netwatch-tui/versions) dies an.

<details>
<summary><strong>Alle Plattformen &amp; Build aus dem Quellcode</strong></summary>

| Plattform | Download |
|----------|----------|
| Linux (x86_64, Debian/Ubuntu) | [`netwatch-linux-x86_64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, Debian/Ubuntu) | [`netwatch-linux-aarch64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (x86_64, statisch — Arch/Fedora/Alpine/jede Distribution) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, statisch — Arch/Fedora/Alpine/jede Distribution) | [`netwatch-linux-aarch64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| macOS (Intel) | [`netwatch-macos-x86_64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| macOS (Apple Silicon) | [`netwatch-macos-aarch64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |

Die `-static`-Linux-Builds bündeln libpcap und haben keine Laufzeitabhängigkeiten — verwende diese auf Arch, Fedora, Alpine oder einer beliebigen Distribution, bei der die Standard-Builds `libpcap.so.0.8: cannot open shared object file` melden.

**Aus dem Quellcode:**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release

Voraussetzungen: Rust 1.70+, libpcap (sudo apt install libpcap-dev unter Linux, unter macOS enthalten).

Schnellstart```bash

netwatch # interface stats, connections, config — no privileges needed sudo netwatch # full mode — adds live packet capture + health probes

That's it. Wechsle die Tabs mit `1`–`9`, drücke `?` für Hilfe, `q` zum Beenden. Schon nach fünf Sekunden ist das Dashboard nützlich; alles darunter ist vorhanden, wenn du tiefer eintauchen musst.

> **Linux ohne `sudo`:** erteile die Capture-Capabilities einmal und führe es als dein normaler Benutzer aus —
> `sudo setcap 'cap_net_raw,cap_bpf,cap_perfmon+eip' "$(which netwatch)"`. Führe es nach jedem Upgrade erneut aus ([Details](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#running-without-sudo-linux)).

### Sieh zu, wie es TLS in 60 Sekunden entschlüsselt

Der schnellste Weg zu verstehen, was NetWatch ist — sieh zu, wie es den Klartext einer TLS-1.3-Sitzung liest, die *du* kontrollierst:```bash
sudo netwatch                                              # 1. launch, then open the Packets tab (4)
SSLKEYLOGFILE=/tmp/sslkeylog.txt curl https://example.com  # 2. any client that exports its keys
#                                                            3. filter the Packets tab with:  decrypted:true

The decrypted application data renders inline. A keylog miss never breaks capture — that record just stays opaque. (SSLKEYLOGFILE is the same mechanism Wireshark uses; it only works for traffic you control, never third-party or malware traffic.)

Den Klartext aus einer Live-TLS 1.3-Sitzung lesen — direkt im Terminal entschlüsselt. Kein Proxy, kein Man-in-the-Middle.

Sehen Sie, wie es Egress-Drift in 60 Sekunden aufspürt

Die Schleife aus der Demo oben, in drei Befehlen:```bash sudo netwatch # 1. launch and open the Egress tab (0). Leave it a minute # while it learns; each process grows a list of destinations # with hostnames, autonomous systems and ports # 2. put the cursor on a process and press Enter — its observed # baseline becomes a rule in egress-policy.toml curl https://example.org # 3. same program, somewhere it has never been

Das neue Ziel landet mit einem `✗ drift`-Urteil und einem Alarm. Nichts wurde blockiert — der Punkt ist, dass du benachrichtigt wurdest.

Die Urteile sind bewusst nicht binär:

| | |
|---|---|
| `✓ sni` / `✓ ip` | Hat einen deklarierten Hostnamen oder eine Adresse abgeglichen — präzise |
| `~ asn` | Nur nach autonomen System abgeglichen — das lässt *alles zu, was dieses AS betreibt*, was bei einem Hyperscaler praktisch unbegrenzt ist |
| `? ech` | Encrypted ClientHello: Der Name ist absichtlich verborgen, das ist also „kann nicht beurteilt werden“, nicht „schlecht“ |
| `✗ drift` | Außerhalb der Zulassungsliste |
| `— no rule` | Dieses Programm wurde nie deklariert — es wurde nichts geprüft |
| `✗ undeclared` | Keine Regel, unter `strict = true` — die Richtlinie beansprucht vollständig zu sein, also ist das *Fehlen* der Befund |

Regeln akzeptieren exakte Hostnamen, `*.wildcards`, autonome Systeme, CIDR-Blöcke (`10.0.0.0/8`) und Ports. `strict = true` ist das, was den Linter von „sag mir, wenn sich meine deklarierte Software danebenbenimmt“ zu „sag mir, wenn etwas zu reden beginnt, das ich nie deklariert habe“ macht — was der Form einer tatsächlichen Kompromittierung entspricht.

## Was du bekommst

Zehn Tabs, umgeschaltet mit `1`–`9` und `0`:

| # | Tab | Was es zeigt |
|---|-----|---------------|
| 1 | **Dashboard** | Schnittstellen, Bandbreitendiagramm, Top-Verbindungen, Gateway/DNS-Zustand, Latenz-Heatmap. In 5 Sekunden nützlich. |
| 2 | **Connections** | Jeder Socket mit seinem Prozess + PID, Protokoll, Zustand, GeoIP und Latenz-Sparklines. |
| 3 | **Interfaces** | Pro Schnittstelle IPv4/IPv6, MAC, MTU, RX/TX, Fehler, Drops. |
| 4 | **Packets** | Live-Erfassung mit echtem L7-Dekodieren, TLS-1.3-Entschlüsselung, JA4, pro-Flow-Stream-Verfolgung, Filter, PCAP-Export. |
| 5 | **Stats** | Protokoll-Aufschlüsselung nach Bytes + Histogramm der TCP-Handshake-Zeiten. |
| 6 | **Topology** | ASCII-Karte von Maschine → Gateway → DNS → Top-Hosts, mit Traceroute. |
| 7 | **Timeline** | Verbindungs-Timeline farbcodiert nach TCP-Zustand; Sicherheitswarnungen landen hier. |
| 8 | **Processes** | Prozessbezogene Bandbreiten-Rangliste mit Live-RX/TX und Verbindungszahlen. |
| 9 | **Insights** | *(opt-in)* speist eine Momentaufnahme in ein lokales/Cloud-LLM ein, für eine Analyse in einfacher Sprache. |
| 0 | **Egress** | Lernt, womit jeder Prozess spricht (Hostname/AS/Port), erhebt diese Baseline mit einem Tastendruck zu einer Richtlinie und warnt dann bei Abweichung. Nur Beobachtung, blockiert nie. |

Im Packets-Tab lebt die Forensik — tiefe Protokoll-Dekodierung, Live-TLS-1.3-Entschlüsselung, JA4-Threat-Hunting, Wireshark-artige Anzeigefilter und Incident-Capture. **[Siehe die vollständige Feature-Referenz →](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md)**

### Lite-Ansicht

Zehn Tabs sind ein Instrument für Operatoren. Wenn die Frage nur *„Was nutzt mein Netzwerk, und ist meine Verbindung OK?“* ist — eine Maschine, eine SSH-Sitzung zu einem Pi, ein tmux-Split — dann gibt es `--lite`:```bash
netwatch --lite     # one screen, fits 80×24

Ein Bildschirm, sechs Tasten. Live-Durchsatz, Erreichbarkeit und wer kommuniziert — jede Zeile direkt an Ort und Stelle erweitern, während der Eingabe filtern.

Alles auf einem einzigen Bildschirm: Live-Durchsatzdiagramme, Gateway-/DNS-/Internet-Erreichbarkeit und die Top-Teilnehmer nach Prozess und Host. Sechs Tasten — q beenden, p pausieren, / filtern, ↵ Teilnehmer erweitern, L zurück zur Gesamtansicht, ? Hilfe.

Drücken Sie L in einer der beiden Ansichten, um zu wechseln. Beide verwenden dieselben Collectors, sodass der Weg von "irgendetwas sieht seltsam aus" zur vollständigen forensischen Ansicht mit zehn Tabs nur einen Tastendruck kostet — kein Neustart, kein verlorener Verlauf, die Erfassung läuft weiter.

Dense view

Die andere Richtung: Wenn Sie ein großes Terminal haben und alles auf einmal sehen möchten, füllt --view dense es mit vier Boxen und ohne Beiwerk — keine Kopfzeile, keine Menüleiste, keine Statusleiste. Identität, Sortierzustand, Seitenbereich und jede Tastenzuordnung leben innerhalb der Boxrahmen, sodass jede Zeile Daten trägt. Es benötigt mindestens 130×44 und wächst in das hinein, was Sie ihm geben: mehr Breite bedeutet mehr Verlauf in den Diagrammen und Platz für vollständige Hostnamen, mehr Höhe bedeutet mehr Schnittstellen und mehr Verbindungen.```bash netwatch --view dense # four boxes, needs 130×44

Das ist der Bildschirm oben in diesem README. Das Markenzeichen ist das **gespiegelte Doppeldiagramm**: Download wächst von einer mittleren Zeitachse nach oben, Upload wächst von derselben Achse nach unten. Verkehrssymmetrie wird zu einer Form, die du erkennst, ohne eine Zahl zu lesen — ein Download-Burst ist eine Klippe über der Linie, ein Backup-Job ist eine Klippe darunter. Beide Hälften sind als Braille dargestellt, mit zwei Samples pro Zeichenzelle, und jede Zelle ist nach ihrer **Höhe im Diagramm** gefärbt statt danach, zu welcher Serie sie gehört, sodass du die Schwere eines Spikes siehst, bevor du ihn an der Achse misst.

Durchsatz-Verläufe laufen von kühl → hell, weil hohe Bandbreite *beschäftigt* und nicht *schlecht* ist — eine gesättigte Leitung während eines Backups arbeitet. Nur begrenzte Werte, bei denen hoch wirklich schlecht ist — Link-Sättigung, Latenzbudget pro Hop — erhalten die Grün→Gelb→Rot-Behandlung, und ihre Anzeigen färben sich je nach Position entlang des Balkens, sodass die rote Zone sichtbar ist, bevor du sie erreichst.

Unter dem Diagramm: Raten pro Schnittstelle mit 60-Sekunden-Sparklines, Vier-Hop-Latenzbudgets (Gateway, DNS, Internet und der langsamste Peer, mit dem du gerade tatsächlich sprichst), und die Verbindungstabelle, bei der die Detailansicht der ausgewählten Zeile in den oberen Bereich desselben Felds angehoben wird — kein neuer Bildschirm, kein Zurück-Button. Die Detailzeile enthält den TCP-Kernel-Status — `cwnd`, `ssthresh`, `mss`, `rwnd` — direkt aus dem Kernel ausgelesen: auf Linux `inet_diag` über netlink, auf macOS der `net.inet.tcp.pcblist64`-Sysctl. Die beiden Kernel sind sich bei den Einheiten uneinig (Linux zählt Segmente, BSD zählt Bytes), daher werden macOS-Werte gegen die MSS normalisiert und die Spalte bedeutet auf beiden dasselbe. Windows zeigt `--` an, bis `GetPerTcpConnectionEStats` angebunden ist.

`V` wechselt zwischen `full → lite → dense`, oder stell es einmal unter **Einstellungen → Ansicht** ein. Unterhalb von 130×44 fällt es auf dasselbe 80×24-Raster zurück, das Lite anstrebt — welches ebenfalls seinen Bereich ausfüllt — und es scrollt nie seitwärts.

## Tiefergehende Einblicke

| Leitfaden | Inhalt |
|-------|--------------|
| **[Funktionsreferenz](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md)** | Alle Tastenkombinationen, die Display-Filter-Sprache, die Protokoll-Decoder-Liste, Themes und Konfigurationsoptionen. |
| **[TLS-1.3-Entschlüsselung](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#tls-13-decryption)** | Wie die `SSLKEYLOGFILE`-Entschlüsselung funktioniert, unterstützte Cipher-Suites und was sie lesen kann und was nicht. |
| **[Threat Hunting mit JA4](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#threat-hunting-with-ja4)** | Client-Fingerprinting und Flow-Pivoting. |
| **[Sicherheit & die Landlock-Sandbox](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#security--forensics)** | Das Bedrohungsmodell, Capability-Dropping und die Dateisystem-Allowlist. |
| **[Egress-Policy-Linting](https://github.com/matthart1983/netwatch/blob/HEAD/docs/egress-linter-plan.md)** | Das Modell beobachten → hochstufen → warnen, die Regelsprache, der `strict`-Modus und das NDJSON-Export-Schema. |
| **[Flight Recorder](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#flight-recorder)** | Scharfschalten, Einfrieren und der Inhalt eines Incident-Bundles. |
| **[KI-Einblicke](https://github.com/matthart1983/netwatch/blob/HEAD/docs/INSIGHTS.md)** | Optionale lokale/Cloud-LLM-Analyse (standardmäßig deaktiviert). |

## Funktionsweise```
Raw bytes → Ethernet → IPv4/IPv6/ARP → TCP/UDP/ICMP → L7 decoders
                                            ↓
                          Per-flow stream tracking · Handshake timing
                          TLS 1.3 decryption · JA4 · Threat detection

Alles degradiert kontrolliert: Funktionen, die erweiterte Rechte benötigen, zeigen eine klare Meldung und fallen zurück, ohne abzustürzen. Ausführliche Architekturhinweise finden sich in WIKI.md.

Verwandt

Geschwister: SysWatch (System) und DiskWatch (Festplatte) – gleiche Optik, andere Oberfläche. ESSH – ein reiner Rust-SSH-Client mit derselben TUI-Ästhetik; er verbindet sich dort, wo NetWatch beobachtet.

NetWatch Cloud – gehostetes Flotten-Monitoring für die Server, gegen die du NetWatch ausführst. Ein winziger Rust-Agent auf jedem Linux-Host, ein Echtzeit-Dashboard und E-Mail- sowie Slack-Benachrichtigungen bei Latenz, Paketverlust oder Hosts, die offline gehen. Kostenlos, solange wir wachsen. Der Agent, das SDK und das Dashboard sind MIT-lizenziert; das gehostete Backend ist proprietär.

Danksagung

Paketierer. NetWatch ist in homebrew-core, nixpkgs, dem AUR und dem Scoop-Haupt-Bucket – und ich habe nichts davon gepackt. Jedes einzelne Paket wurde von jemandem erstellt, der das Werkzeug nützlich fand, die Arbeit unaufgefordert erledigt hat und es seitdem aktuell hält. Der Scoop-Eintrag hat in der Regel ein Release innerhalb von Stunden nach dem Tag nachgezogen.

Paketierung ist undankbare Arbeit, die nur auffällt, wenn etwas kaputtgeht. Wenn du NetWatch über eines dieser Pakete installierst, hast du ihnen dafür zu danken, nicht mir.

Mitwirkende. @lamchau, @fdncred und @PeteE haben Patches geschickt. Danke – ein Pull-Request von einem Fremden ist das Schönste, was einem Projekt wie diesem passieren kann.

Und an alle, die ein Issue mit einem echten Reproduktionsbeispiel eröffnet, eine Designentscheidung angefochten oder mir gesagt haben, dass die Ausgabe auf ihrem Terminal falsch ist: Das ist die Feedbackschleife, auf der dieses Projekt aufbaut.

Mitwirken

Fragen, Ideen und Fehlerberichte sind in GitHub Discussions und Issues willkommen. Siehe CONTRIBUTING.md für Code-Konventionen und WIKI.md für den Architekturleitfaden.

Lizenz

MIT