NetWatch

Voyez ce que fait réellement votre réseau — 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 communiquent avec 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 à partir de l'axe temporel commun, l'envoi 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 l'instrument 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 du 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. NetWatch continue. Il décode les protocoles sur le fil, vous dit quel programme a ouvert chaque connexion, et surveille les schémas qui annoncent des problèmes — un balayage de ports, un malware qui communique avec un serveur de commande, des données qui s'échappent discrètement via DNS. Quand quelque chose semble anormal, une seule pression de touche fige un lot de preuves portable que vous pouvez joindre à un rapport de bug.

Considérez-le comme un binaire unique sans configuration qui fait le travail d'un compteur de bande passante, de la vue de tri de Wireshark et d'un détecteur d'intrusion léger — sans quitter le terminal.

Il s'adapte à la question que vous vous posez — dans les deux directions : --view dense remplit un grand terminal de quatre boîtes sans chrome, et netwatch --lite est 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 blue-teamers, les intervenants en réponse à incident, les SRE et les homelabbers qui ont besoin de voir ce qui se passe maintenant — pas d'analyser un fichier de capture une heure plus tard.

650+ tests · isolé par Landlock (Linux) · analyse le trafic hostile en toute sécurité

Et ce qu'aucun autre outil de terminal ne fait du tout : NetWatch apprend à quoi chaque programme de la machine parle, transforme cette ligne de base observée en politique avec une seule pression de touche, et vous indique le moment où un programme commence à parler à une nouvelle destination.

Observer → promouvoir → avertir. La ligne de base devient une politique avec une seule pression de touche ; la nouvelle destination suivante arrive comme dérive.

Why NetWatch

• 🔓 Lisez le trafic chiffré que vous contrôlez — pointez le SSLKEYLOGFILE d'un navigateur ou d'une application vers NetWatch et regardez le texte clair de ses sessions TLS 1.3 se décoder en direct, comme le fait Wireshark. Pas de proxy, pas de certificats, rien au milieu.
• 🛰️ Apprenez à quoi chaque programme parle, puis soyez averti quand cela change — NetWatch observe quelles destinations chaque processus atteint (nom d'hôte depuis le ClientHello, système autonome, port), et une pression de touche promeut cette ligne de base observée en politique de sortie. Dès lors, il avertit quand un programme commence à parler à une nouvelle destination. C'est la phrase qu'un ensemble de règles de pare-feu ne peut pas exprimer : curl n'atteignait auparavant que api.github.com, et aujourd'hui il a atteint autre chose. Observation seule — il ne bloque jamais.
• 🧬 Identifiez le logiciel derrière une connexion par son empreinte — JA4 transforme chaque poignée de main TLS/QUIC en une empreinte stable, vous permettant de reconnaître un client spécifique — ou un malware spécifique — même si le trafic est chiffré, de la même manière que vous reconnaissez un navigateur à son user-agent. Pivotez sur une empreinte pour trouver tous les autres flux du même logiciel.
• 🚨 Attrapez les malwares qui rappellent leur base — la détection intégrée des beacons C2 (check-ins réguliers à faible gigue), des scans de ports et du tunneling DNS s'exécute en arrière-plan sans aucune configuration. Une alerte critique gèle automatiquement l'enregistreur, de sorte que les preuves sont déjà sauvegardées lorsque vous regardez.
• ⚙️ Nommez le processus derrière chaque connexion — mappe chaque socket au programme qui l'a ouvert via ss/lsof, avec une kprobe eBPF facultative au niveau du noyau (Linux, option ebpf) qui capture également les flux de courte durée que le polling peut manquer. Fonctionne partout ; la kprobe est un plus, 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 bien d'autres encore, avec suivi du flux par connexion et minutage des poignées de main — pour voir api.github.com et l'empreinte JA4, pas seulement « port 443 ».
• 🎥 Gelez les preuves — armez un enregistreur circulaire et gelez 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 l'installation, NetWatch abandonne ses privilèges et s'enferme dans une liste d'autorisation du système 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.
• 🪟 Se réduit à un seul écran — --lite répond à « qu'est-ce qui utilise mon réseau, et ma connexion est-elle OK ? » sur un seul écran 80×24 avec six touches, de quoi tenir dans une session SSH vers un Pi ou un split tmux. Une pression de touche passe à la vue forensique complète avec les collecteurs déjà chauds.

Aucun fichier de configuration. Aucune installation. Aucune option requise.

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

Ou récupérez un binaire précompilé depuis [Releases](https://github.com/matthart1983/netwatch/releases/latest).

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 bogues 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 &amp; 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, static — Arch/Fedora/Alpine/toute distribution) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, static — 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) |

Les versions Linux `-static` intègrent libpcap et n'ont aucune dépendance à l'exécution — utilisez-les sur Arch, Fedora, Alpine ou toute distribution où les versions par défaut signalent `libpcap.so.0.8: cannot open shared object file`.

**Depuis les sources :**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release

Prérequis : Rust 1.70+, libpcap (sudo apt install libpcap-dev sous Linux, inclus sur macOS).

Démarrage rapide```bash

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

C'est tout. 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-la après chaque mise à niveau ([détails](https://github.com/matthart1983/netwatch/blob/HEAD/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 directement. Une clé manquante dans le 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 du 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 aboutit à un verdict `✗ drift` et à une alerte. Rien n'a été bloqué — le but est que vous ayez été *prévenu*.

Les verdicts ne sont volontairement pas binaires :

| | |
|---|---|
| `✓ sni` / `✓ ip` | Correspond à un nom d'hôte ou une adresse déclarés — précis |
| `~ asn` | Correspond uniquement par système autonome — cela admet *tout ce que l'AS exploite*, ce qui est effectivement illimité pour un hyperscaler |
| `? ech` | Encrypted ClientHello : le nom est caché par conception, c'est donc « impossible à juger », pas « mauvais » |
| `✗ drift` | En dehors 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 des noms d'hôte exacts, `*.wildcards`, des systèmes autonomes, des blocs CIDR (`10.0.0.0/8`) et des ports. `strict = true` est ce qui fait passer le linter de « dis-moi quand mon logiciel déclaré se comporte mal » à « 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, accessibles avec `1`–`9` et `0` :

| # | Tab | What it shows |
|---|-----|---------------|
| 1 | **Dashboard** | Interfaces, graphique de bande passante, connexions principales, santé de la passerelle/DNS, heatmap de latence. Utile en 5 secondes. |
| 2 | **Connections** | 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 | **Packets** | Capture en direct avec décodage L7 réel, déchiffrement TLS 1.3, JA4, suivi de flux par connexion, filtres, export PCAP. |
| 5 | **Stats** | Répartition des protocoles par octets + histogramme des temps de handshake TCP. |
| 6 | **Topology** | Carte ASCII de machine → passerelle → DNS → principaux hôtes, avec traceroute. |
| 7 | **Timeline** | Chronologie des connexions codée par couleur selon l'état TCP ; les alertes de sécurité arrivent ici. |
| 8 | **Processes** | Classement de la bande passante par processus avec RX/TX en direct et nombre de connexions. |
| 9 | **Insights** | *(opt-in)* envoie un instantané à un LLM local/cloud pour une analyse en langage clair. |
| 0 | **Egress** | Apprend avec quoi chaque processus communique (nom d'hôte/AS/port), promeut cette base en politique d'une seule pression de touche, puis avertit en cas de dérive. Uniquement en observation, ne bloque jamais. |

L'onglet Packets est là où vit la forensique — décodage profond des protocoles, 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/HEAD/docs/REFERENCE.md)**

### Vue Lite

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 tmux split — il y a `--lite` :```bash
netwatch --lite     # one screen, fits 80×24

Un écran, six touches. Débit en direct, joignabilité et qui parle — développez n'importe quelle ligne sur place, filtrez au fil de la frappe.

Tout sur un seul écran : les graphiques de débit en direct, la joignabilité passerelle/DNS/internet et les principaux émetteurs par processus et hôte. Six touches — q quitter, p pause, / filtrer, ↵ développer un émetteur, L retour à la vue complète, ? aide.

Appuyez sur L depuis l'une ou l'autre vue pour basculer. Elles 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 : avec un grand terminal et l'envie de voir tout d'un coup, --view dense le remplit de quatre boîtes, sans chrome — pas de barre d'en-tête, pas de barre de menu, pas de barre de statut. L'identité, l'état du tri, la plage de pages et chaque raccourci clavier se trouvent à l'intérieur des bordures des boîtes, si bien que chaque ligne porte des données. Il lui faut 130×44 comme minimum et s'étend à tout ce que vous lui donnez : plus large signifie plus d'historique dans les graphiques et de la place pour les noms d'hôte 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 en 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 l'on reconnaît sans lire de 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 selon sa **hauteur dans le graphe** plutôt que selon la série à laquelle elle appartient, de sorte que l'on voit la gravité d'un pic avant de le mesurer par rapport à l'axe.

Les débits évoluent du froid au lumineux parce qu'une bande passante élevée est *occupée*, pas *mauvaise* — une liaison saturée pendant une sauvegarde fonctionne. Seules les valeurs bornées où un niveau élevé est réellement mauvais — saturation de la liaison, budget de latence par saut — reçoivent le traitement vert→ambre→rouge, et leurs jauges se colorent en fonction de la position le long de la barre, de sorte que la zone rouge est 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 sous Linux, le sysctl `net.inet.tcp.pcblist64` sous macOS. Les deux noyaux ne s'accordent pas sur les unités (Linux compte les segments, BSD compte les octets), c'est pourquoi les valeurs macOS sont normalisées par rapport au MSS et la colonne a la même signification sur les deux. Windows affiche `--` jusqu'à ce que `GetPerTcpConnectionEStats` soit branché.

`V` fait défiler `full → lite → dense`, ou réglez-le une fois sous **Paramètres → Affichage**. En dessous de 130×44, il retombe sur la même grille 80×24 que Lite cible — qui remplit elle aussi sa zone — et il ne défile jamais latéralement.

## Pour aller plus loin

| Guide | Ce qu'il contient |
|-------|--------------|
| **[Référence des fonctionnalités](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md)** | Tous les raccourcis 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/HEAD/docs/REFERENCE.md#tls-13-decryption)** | Comment fonctionne le déchiffrement via `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/HEAD/docs/REFERENCE.md#threat-hunting-with-ja4)** | Prise d'empreinte des clients et pivotement entre les flux. |
| **[Sécurité et le sandbox Landlock](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#security--forensics)** | Le modèle de menace, l'abandon de capacités et la liste blanche du système de fichiers. |
| **[Linting de politique egress](https://github.com/matthart1983/netwatch/blob/HEAD/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. |
| **[Enregistreur de vol](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#flight-recorder)** | Armement, gel et contenu d'un bundle d'incident. |
| **[Insights IA](https://github.com/matthart1983/netwatch/blob/HEAD/docs/INSIGHTS.md)** | Analyse LLM locale/cloud optionnelle (désactivée par défaut). |

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

Tout se dégrade gracieusement : les fonctionnalités qui nécessitent des privilèges élevés affichent un message clair et se replient, sans jamais planter. Les notes d'architecture complètes se trouvent dans WIKI.md.

Voir aussi

Outils frères : SysWatch (système) et DiskWatch (disque) — même habillage, surface différente. ESSH — un client SSH en Rust pur 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 que vous supervisez avec NetWatch. Un petit agent Rust sur chaque hôte Linux, un tableau de bord en temps réel, et des alertes e-mail + Slack sur la latence, la perte de paquets ou les hôtes hors ligne. Gratuit pendant que nous grandissons. L'agent, le SDK et le tableau de bord sont sous licence MIT ; le backend hébergé est propriétaire.

Remerciements

Mainteneurs de paquets. NetWatch est dans homebrew-core, nixpkgs, l'AUR et le bucket principal de Scoop — et je n'ai empaqueté aucun d'entre eux. Chacun d'entre eux 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 publication dans les heures qui ont suivi le tag.

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 qu'il faut adresser vos remerciements, pas à moi.

Contributeurs. @lamchau, @fdncred et @PeteE ont envoyé des patchs. 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 vraie reproduction, contesté une décision de conception, ou m'ont dit que la sortie était fausse 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. Voir CONTRIBUTING.md pour les conventions de code et WIKI.md pour le guide d'architecture.

Licence

MIT