netwatch v0.27.0
Diagnostics réseau en temps réel dans votre terminal. Une commande, zéro configuration, visibilité instantanée.
NetWatch
Voyez ce que votre réseau fait réellement — en direct, dans votre terminal.
Un moniteur réseau qui lit le trafic chiffré, identifie le processus derrière chaque connexion et détecte les malwares qui appellent leur serveur. Un seul binaire. Zéro configuration.
Tout à la fois, avec zéro ligne de chrome — pas de barre d'en-tête, pas de barre de menu, pas de barre de statut. Le téléchargement croît vers le haut depuis l'axe temporel partagé, l'envoi croît vers le bas, si bien que la symétrie du trafic est une forme que vous reconnaissez avant même de lire un chiffre. La couleur encode la magnitude, pas la série.
…et la vue par défaut à dix onglets en dessous, à une touche V et partageant les mêmes collecteurs déjà chauds — le tableau de bord, le programme derrière chaque socket, l'inspection approfondie des paquets, la carte réseau, et ce à quoi chaque programme parle.
La plupart des outils réseau répondent à une seule question — « qu'est-ce qui utilise ma bande passante ? » — et s'arrêtent là. NetWatch va plus loin. Il décode les protocoles sur le fil, vous dit quel programme a ouvert chaque connexion, et surveille les schémas qui signalent un problème — un scan de ports, un malware qui fait du beaconing vers un serveur de commande, des données qui s'échappent via DNS. Quand quelque chose semble anormal, une seule pression de touche fige un bundle de preuves portable que vous pouvez joindre à un rapport de bug.
Considérez-le comme un seul binaire sans configuration qui fait le travail d'un compteur de bande passante, de la vue de triage de Wireshark et d'un détecteur d'intrusion léger — sans quitter le terminal.
Il s'adapte à la question que vous posez — dans les deux sens : --view dense remplit un grand terminal de quatre fenêtres sans chrome, et netwatch --lite tient sur un écran 80×24 pour « qu'est-ce qui utilise mon réseau en ce moment ? » ; la vue complète à dix onglets est là quand la réponse est « quelque chose que je dois investiguer » — à une pression de touche, partageant la même capture en direct.
Conçu pour les équipes bleues, les répondants aux incidents, les SRE et les passionnés de homelab qui ont besoin de voir ce qui se passe maintenant — pas d'analyser un fichier de capture une heure plus tard.
650+ tests · sandboxé Landlock (Linux) · analyse en toute sécurité du trafic hostile
Et la partie qu'aucun autre outil de terminal ne fait du tout : NetWatch apprend ce à quoi chaque programme de la machine parle, transforme cette base observée en politique d'une seule pression de touche, et vous prévient dès qu'un programme commence à parler à un nouvel endroit.
Observer → promouvoir → avertir. La base devient une politique d'une seule pression de touche ; la prochaine nouvelle destination arrive comme dérive.
Pourquoi NetWatch
- 🔓 Lisez le trafic chiffré que vous contrôlez — pointez le
SSLKEYLOGFILEd'un navigateur ou d'une application vers NetWatch et regardez le texte en clair de ses sessions TLS 1.3 se décoder en direct, de la même manière que Wireshark le fait. Pas de proxy, pas de certificats, rien au milieu. - 🛰️ Apprenez ce à quoi chaque programme parle, puis soyez prévenu quand cela change — NetWatch surveille quelles destinations chaque processus atteint (nom d'hôte depuis le ClientHello, système autonome, port), et une pression de touche promeut cette base observée en politique de trafic sortant. À partir de là, il avertit quand un programme commence à parler à un nouvel endroit. C'est la phrase qu'un ensemble de règles de pare-feu ne peut pas exprimer :
curln'atteignait queapi.github.com, et aujourd'hui il a atteint autre chose. Observation uniquement — il ne bloque jamais. - 🧬 Identifiez le logiciel derrière une connexion — JA4 transforme chaque poignée de main TLS/QUIC en une empreinte stable, pour que vous puissiez reconnaître un client spécifique — ou un malware spécifique — même si le trafic est chiffré, comme on reconnaît un navigateur à son user-agent. Pivotez sur une empreinte pour trouver tous les autres flux du même logiciel.
- 🚨 Attrapez les malwares qui appellent leur serveur — la détection intégrée du beaconing C2 (check-ins réguliers à faible gigue), des scans de ports et du tunneling DNS tourne en arrière-plan sans aucune configuration. Une alerte critique fige automatiquement l'enregistreur pour que les preuves soient déjà sauvegardées quand vous regardez.
- ⚙️ Identifiez le processus derrière chaque connexion — mappe chaque socket au programme qui l'a ouvert via
ss/lsof, avec un kprobe eBPF optionnel au niveau du noyau (Linux, la fonctionnalitéebpf) qui attrape aussi les flux de courte durée que le polling peut manquer. Fonctionne partout ; le kprobe est une amélioration, pas une exigence. - 📡 Décodez les protocoles, pas seulement les ports — un vrai parsing L7 de TLS, QUIC, HTTP et DNS (plus une détection de bannière/version SSH) et une douzaine d'autres, avec suivi des flux par connexion et chronométrage des poignées de main — pour que vous voyiez
api.github.comet l'empreinte JA4, pas seulement « port 443 ». - 🎥 Figez les preuves — armez un enregistreur rotatif et figez tout incident dans un bundle portable : les paquets plus les connexions, le DNS, la santé et les alertes qui les expliquent. Conçu pour les rapports de bug et les post-mortems.
- 🛡️ Sûr par conception — après la configuration, NetWatch abandonne ses privilèges et se verrouille dans une liste blanche de fichiers Landlock (Linux). Un outil qui analyse du trafic hostile ne peut pas lire vos clés SSH, vos profils de navigateur ou
/etc/shadow. - 🪟 Réduit à un seul écran —
--literépond à « qu'est-ce qui utilise mon réseau, et ma connexion est-elle OK ? » sur un seul écran 80×24 avec six touches, pour tenir dans une session SSH vers un Pi ou un split tmux. Une pression de touche fait passer à la vue forensique complète avec les collecteurs déjà chauds.
Aucun fichier de configuration. Aucune configuration. Aucun flag requis.
Install```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
Ou récupérez un binaire pré-compilé depuis [Releases](https://github.com/matthart1983/netwatch/releases/latest).
**Windows nécessite [Npcap](https://npcap.com/#download) installé** — les paramètres par défaut de l'installateur conviennent, et sans lui NetWatch se ferme au démarrage en l'indiquant. **Compiler depuis les sources** (`cargo install`, `paru -S netwatch-tui`) nécessite les en-têtes de développement de libpcap : `libpcap-dev` sur Debian/Ubuntu et Alpine, `libpcap-devel` sur Fedora/RHEL, `libpcap` sur Arch. S'ils manquent, cela apparaît comme `cannot find -lpcap` au moment de l'édition de liens. macOS inclut libpcap ; les binaires `-static` Linux ci-dessous l'intègrent et ne nécessitent rien d'installé.
Les paquets Nix, Arch et Scoop sont maintenus par des empaqueteurs de la communauté — merci à eux. Signalez les problèmes d'empaquetage auprès d'eux ; signalez les bugs de NetWatch ici. Si un paquet est en retard sur une version, la [page Repology](https://repology.org/project/netwatch-tui/versions) le montre.
<details>
<summary><strong>Toutes les plateformes & compilation depuis les sources</strong></summary>
| Plateforme | Téléchargement |
|----------|----------|
| 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, statique — Arch/Fedora/Alpine/toute distribution) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, statique — Arch/Fedora/Alpine/toute 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) |
| Windows (x86_64) | [`netwatch-windows-x86_64.exe.zip`](https://github.com/matthart1983/netwatch/releases/latest) |
Les builds Linux `-static` intègrent libpcap et n'ont aucune dépendance d'exécution — utilisez-les sur Arch, Fedora, Alpine, ou toute distribution où les builds par défaut signalent `libpcap.so.0.8: cannot open shared object file`.
Le build Windows nécessite [Npcap](https://npcap.com/#download) — installez-le avant la première exécution. Les paramètres par défaut de l'installateur conviennent : NetWatch cherche dans `System32\Npcap`, là où Npcap place réellement `wpcap.dll`, donc *Install Npcap in WinPcap API-compatible Mode* n'est pas nécessaire. Sans Npcap du tout, vous obtenez un message de NetWatch indiquant ce qui manque, et non une boîte d'erreur Windows. (Sur v0.29.1 et antérieures, cette case était nécessaire — voir [#47](https://github.com/matthart1983/netwatch/issues/47).)
**Depuis les sources :**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release
Prérequis : Rust 1.70+ et les en-têtes de développement de libpcap. Cela s'applique également à cargo install netwatch-tui.
| Plateforme | Installation |
|---|---|
| Debian / Ubuntu | sudo apt install libpcap-dev |
| Fedora / RHEL | sudo dnf install libpcap-devel |
| Arch | sudo pacman -S libpcap |
| Alpine | sudo apk add libpcap-dev |
| macOS | inclus avec le système |
| Windows | Npcap — la compilation récupère automatiquement le SDK Npcap, ou définissez NPCAP_SDK sur une copie extraite |
Sans eux, la compilation échoue à l'étape de liaison avec /usr/bin/ld: cannot find -lpcap. Si vous souhaitez uniquement exécuter NetWatch plutôt que de le compiler, les binaires Linux -static ci-dessus n'en ont pas besoin.
Démarrage rapide```bash
netwatch # interface stats, connections, config — no privileges needed sudo netwatch # full mode — adds live packet capture + health probes
Voilà. Changez d'onglet avec `1`–`9`, appuyez sur `?` pour l'aide, `q` pour quitter. Le tableau de bord est utile en cinq secondes ; tout ce qui suit est là quand vous avez besoin d'aller plus loin.
> **Linux sans `sudo` :** accordez les capacités de capture une fois et exécutez en tant qu'utilisateur normal —
> `sudo setcap 'cap_net_raw,cap_bpf,cap_perfmon+eip' "$(which netwatch)"`. Réexécutez-le après chaque mise à niveau ([détails](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#running-without-sudo-linux)).
### Voyez-le déchiffrer TLS en 60 secondes
Le moyen le plus rapide de comprendre ce qu'est NetWatch — regardez-le lire le texte en clair d'une session TLS 1.3 *que vous* contrôlez :```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
Les données applicatives déchiffrées s'affichent en ligne. Un échec de keylog ne casse jamais la capture — cet enregistrement reste simplement opaque. (SSLKEYLOGFILE est le même mécanisme qu'utilise Wireshark ; il ne fonctionne que pour le trafic que vous contrôlez, jamais pour le trafic tiers ou malveillant.)
Lecture du texte en clair d'une session TLS 1.3 en direct — déchiffré directement dans le terminal. Pas de proxy, pas d'homme du milieu.
Voyez-le détecter une dérive de trafic sortant en 60 secondes
La boucle de la démo ci-dessus, en trois commandes :```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
La nouvelle destination atterrit avec un verdict `✗ drift` et une alerte. Rien n'a été bloqué — le but est que vous ayez été *informé*.
Les verdicts ne sont volontairement pas binaires :
| | |
|---|---|
| `✓ sni` / `✓ ip` | Correspond à un nom d'hôte ou une adresse déclarée — précis |
| `~ asn` | Correspond uniquement par système autonome — cela admet *tout ce que cet AS exploite*, ce qui pour un hyperscaler est pratiquement illimité |
| `? ech` | Encrypted ClientHello : le nom est masqué par conception, donc c'est « impossible de juger », pas « mauvais » |
| `✗ drift` | Hors de la liste d'autorisation |
| `— no rule` | Ce programme n'a jamais été déclaré — rien n'a été vérifié |
| `✗ undeclared` | Aucune règle, sous `strict = true` — la politique prétend être complète, donc *l'absence* est le constat |
Les règles acceptent les noms d'hôtes exacts, les `*.wildcards`, les systèmes autonomes, les blocs CIDR (`10.0.0.0/8`) et les ports. `strict = true` est ce qui transforme le linter de « dis-moi quand mon logiciel déclaré se comporte mal » en « dis-moi quand quelque chose que je n'ai jamais déclaré commence à parler » — ce qui est la forme que prend une compromission réelle.
## Ce que vous obtenez
Dix onglets, commutés avec `1`–`9` et `0` :
| # | Onglet | Ce qu'il affiche |
|---|--------|------------------|
| 1 | **Dashboard** | Interfaces, graphique de bande passante, connexions principales, santé passerelle/DNS, heatmap de latence. Utile en 5 secondes. |
| 2 | **Connexions** | Chaque socket avec son processus + PID, protocole, état, GeoIP et sparklines de latence. |
| 3 | **Interfaces** | IPv4/IPv6 par interface, MAC, MTU, RX/TX, erreurs, pertes. |
| 4 | **Paquets** | Capture en direct avec décodage L7 réel, déchiffrement TLS 1.3, JA4, suivi de flux par connexion, filtres, export PCAP. |
| 5 | **Statistiques** | Répartition des protocoles par octets + histogramme de temporisation de la poignée de main TCP. |
| 6 | **Topologie** | Carte ASCII machine → passerelle → DNS → hôtes principaux, avec traceroute. |
| 7 | **Chronologie** | Chronologie des connexions codée par couleur selon l'état TCP ; les alertes de sécurité arrivent ici. |
| 8 | **Processus** | Classement de la bande passante par processus avec RX/TX en direct et nombres de connexions. |
| 9 | **Insights** | *(opt-in)* envoie un instantané à un LLM local/cloud pour une analyse en langage naturel. |
| 0 | **Egress** | Apprend à quoi chaque processus parle (nom d'hôte/AS/port), promeut cette base en politique avec une touche, puis avertit en cas de dérive. Observation seule, ne bloque jamais. |
L'onglet Paquets est là où vit la forensique — décodage de protocole approfondi, déchiffrement TLS 1.3 en direct, chasse aux menaces JA4, filtres d'affichage style Wireshark et capture d'incidents. **[Voir la référence complète des fonctionnalités →](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)**
### Vue allégée
Dix onglets, c'est un instrument d'opérateur. Quand la question est simplement *« qu'est-ce qui utilise mon réseau, et ma connexion est-elle OK ? »* — une machine, une session SSH vers un Pi, un split tmux — il y a `--lite` :```bash
netwatch --lite # one screen, fits 80×24
Un écran, six touches. Débit en direct, accessibilité et qui parle — développez n'importe quelle ligne sur place, filtrez au fur et à mesure que vous tapez.
Tout sur un seul écran : graphiques de débit en direct, accessibilité de la passerelle/DNS/Internet et les principaux émetteurs par processus et par hôte. Six touches — q quitter, p pause, / filtrer, ↵ développer un émetteur, L revenir à la vue complète, ? aide.
Appuyez sur L depuis l'une ou l'autre vue pour basculer. Les deux partagent les mêmes collecteurs, donc passer de « quelque chose semble anormal » à la vue forensique complète à dix onglets ne coûte qu'une pression de touche — pas de redémarrage, pas d'historique perdu, la capture continue de tourner.
Vue dense
L'autre direction : lorsque vous avez un grand terminal et que vous voulez tout d'un coup, --view dense le remplit de quatre zones sans fioritures — pas de barre d'en-tête, pas de barre de menu, pas de barre d'état. L'identité, l'état du tri, la plage de pages et chaque raccourci clavier vivent à l'intérieur des bordures des zones, donc chaque ligne porte des données. Elle nécessite 130×44 comme minimum et s'adapte à tout ce que vous lui donnez : plus large signifie plus d'historique dans les graphiques et de la place pour des noms d'hôtes complets, plus haut signifie plus d'interfaces et plus de connexions.```bash
netwatch --view dense # four boxes, needs 130×44
Voilà l'écran en haut de ce README. L'élément signature est le **graphe double miroir** : le téléchargement monte depuis un axe temporel central, l'envoi descend depuis le même axe. La symétrie du trafic devient une forme que vous reconnaissez sans lire un chiffre — un pic de téléchargement est une falaise au-dessus de la ligne, un travail de sauvegarde est une falaise en dessous. Les deux moitiés sont en braille à deux échantillons par cellule de caractère, et chaque cellule est colorée par sa **hauteur dans le graphe** plutôt que par la série à laquelle elle appartient, pour que vous voyiez la gravité d'un pic avant de le mesurer par rapport à l'axe.
Les rampes de débit passent de froid→lumineux car une bande passante élevée est *occupée*, pas *mauvaise* — un lien saturé pendant une sauvegarde travaille. Seules les valeurs bornées où un niveau élevé est réellement mauvais — saturation du lien, budget de latence par saut — reçoivent le traitement vert→ambre→rouge, et leurs jauges se colorent selon la position le long de la barre, pour que la zone rouge soit visible avant de l'atteindre.
Sous le graphe : les débits par interface avec des sparklines de 60 secondes, les budgets de latence sur quatre sauts (passerelle, DNS, internet, et le pair le plus lent avec lequel vous communiquez réellement), et la table des connexions avec le détail de la ligne sélectionnée hissé en haut de la même boîte — pas de nouvel écran, pas de bouton retour. La ligne de détail porte l'état TCP du noyau — `cwnd`, `ssthresh`, `mss`, `rwnd` — lu directement depuis le noyau : `inet_diag` via netlink sur Linux, le sysctl `net.inet.tcp.pcblist64` sur macOS. Les deux noyaux ne s'accordent pas sur les unités (Linux compte les segments, BSD compte les octets), donc les valeurs macOS sont normalisées par rapport au MSS et la colonne signifie la même chose sur les deux. Windows affiche `--` jusqu'à ce que `GetPerTcpConnectionEStats` soit câblé.
`V` fait défiler `full → lite → dense`, ou réglez-le une fois sous **Settings → View**. En dessous de 130×44, il retombe sur la même grille 80×24 que cible Lite — qui remplit aussi sa zone — et il ne défile jamais latéralement.
## Plongées approfondies
| Guide | Ce qu'il contient |
|-------|--------------|
| **[Référence des fonctionnalités](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)** | Chaque raccourci clavier, le langage de filtre d'affichage, la liste des décodeurs de protocole, les thèmes et les options de configuration. |
| **[Déchiffrement TLS 1.3](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#tls-13-decryption)** | Comment fonctionne le déchiffrement `SSLKEYLOGFILE`, les suites de chiffrement prises en charge et ce qu'il peut et ne peut pas lire. |
| **[Chasse aux menaces avec JA4](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#threat-hunting-with-ja4)** | Empreinte des clients et pivotement entre les flux. |
| **[Sécurité & le sandbox Landlock](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#security--forensics)** | Le modèle de menace, la suppression des capacités et la liste blanche du système de fichiers. |
| **[Linting de la politique egress](https://github.com/matthart1983/netwatch/blob/main/docs/egress-linter-plan.md)** | Le modèle observer → promouvoir → avertir, le langage de règles, le mode `strict` et le schéma d'export NDJSON. |
| **[Flight Recorder](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#flight-recorder)** | Armement, gel et contenu d'un bundle d'incident. |
| **[AI Insights](https://github.com/matthart1983/netwatch/blob/main/docs/INSIGHTS.md)** | Analyse LLM locale/cloud optionnelle (désactivée par défaut). |
## Comment ça fonctionne```
Raw bytes → Ethernet → IPv4/IPv6/ARP → TCP/UDP/ICMP → L7 decoders
↓
Per-flow stream tracking · Handshake timing
TLS 1.3 decryption · JA4 · Threat detection
| Collecteur | macOS | Linux |
|---|---|---|
| Connexions | lsof + PKTAP | /proc/net/tcp + kprobe eBPF |
| Paquets | libpcap (BPF) | libpcap |
| Attribution des processus | PKTAP | Interrogation lsof/ss, avec superposition kprobe eBPF optionnelle |
Tout se dégrade proprement : les fonctionnalités nécessitant des privilèges élevés affichent un message clair et se replient, sans jamais planter. Les notes complètes sur l'architecture se trouvent dans WIKI.md.
Liens connexes
Projets frères : SysWatch (système) et DiskWatch (disque) — même interface, surface différente. ESSH — un client SSH pur Rust avec la même esthétique TUI ; il se connecte là où NetWatch observe.
NetWatch Cloud — supervision de flotte hébergée pour les serveurs sur lesquels vous exécutez NetWatch. Un petit agent Rust sur chaque hôte Linux, un tableau de bord en temps réel, et des alertes par e-mail et Slack sur la latence, la perte de paquets ou les hôtes hors ligne. Gratuit pendant notre croissance. L'agent, le SDK et le tableau de bord sont sous licence MIT ; le backend hébergé est propriétaire.
Remerciements
Empaqueteurs. NetWatch est dans homebrew-core, nixpkgs, l'AUR et le bucket principal de Scoop — et je n'ai empaqueté aucun d'entre eux. Chacun a été réalisé par quelqu'un qui a trouvé l'outil utile, a fait le travail sans qu'on le lui demande, et l'a maintenu à jour depuis. L'entrée Scoop a généralement suivi une version dans les heures suivant le tag.
| Dominiquini | netwatch-tui sur l'AUR, depuis mars 2026 |
| kemelzaidan | netwatch-tui-bin sur l'AUR |
| tomasrivera | netwatch dans nixpkgs |
| scillidan | netwatch dans le bucket principal de Scoop, depuis v0.15.3 |
| Mainteneurs Homebrew | pour avoir intégré la formule dans core, et le bot qui a suivi chaque version depuis |
L'empaquetage est un travail ingrat qui n'est remarqué que lorsqu'il casse. Si vous installez NetWatch via l'un de ces canaux, c'est à eux que vous le devez, pas à moi.
Contributeurs. @lamchau, @fdncred et @PeteE ont envoyé des correctifs. Merci — une pull request d'un inconnu est la meilleure chose qui puisse arriver à un projet comme celui-ci.
Et à tous ceux qui ont ouvert une issue avec une reproduction réelle, contesté une décision de conception, ou signalé que la sortie était incorrecte sur leur terminal : c'est la boucle de rétroaction sur laquelle ce projet repose.
Contribuer
Les questions, idées et rapports de bugs sont les bienvenus dans GitHub Discussions et Issues. Consultez CONTRIBUTING.md pour les conventions de codage et WIKI.md pour le guide d'architecture.
Licence
MIT