netwatch v0.27.0
Diagnostica di rete in tempo reale nel tuo terminale. Un comando, zero configurazione, visibilità immediata.
NetWatch
Scopri cosa sta facendo davvero la tua rete — in tempo reale, nel tuo terminale.
Un monitor di rete che legge il traffico cifrato, identifica il processo dietro ogni connessione e intercetta il malware che contatta il suo comando. Un solo binario. Zero configurazione.
Tutto in una volta, con zero righe di chrome — nessuna barra di intestazione, nessuna barra dei menu, nessuna barra di stato. Il download cresce verso l'alto dall'asse del tempo condiviso, l'upload cresce verso il basso, così la simmetria del traffico è una forma che riconosci prima ancora di leggere un numero. Il colore codifica la magnitudine, non la serie.
…e lo strumento predefinito a dieci schede sotto di esso, a un solo V di distanza e che condivide gli stessi collector già attivi — la dashboard, il programma dietro ogni socket, l'ispezione approfondita dei pacchetti, la mappa di rete e ciò con cui parla ogni programma.
La maggior parte degli strumenti di rete risponde a una sola domanda — "cosa sta usando la mia banda?" — e si ferma. NetWatch va oltre. Decodifica i protocolli sul filo, ti dice quale programma ha aperto ogni connessione e osserva i pattern che significano guai — uno scan delle porte, malware che fa beaconing verso un server di comando, dati che escono di nascosto via DNS. Quando qualcosa sembra sospetto, un solo tasto congela un pacchetto di prove portabile che puoi allegare a un bug report.
Pensalo come un unico binario zero-config che fa il lavoro di un misuratore di banda, della vista di triage di Wireshark e di un rilevatore di intrusioni leggero — senza lasciare il terminale.
Si adatta alla domanda che stai ponendo — in entrambe le direzioni: --view dense riempie un grande terminale con quattro riquadri zero-chrome, e netwatch --lite è una singola schermata 80×24 per "cosa sta usando la mia rete in questo momento?"; la vista completa a dieci schede c'è quando la risposta è "qualcosa che devo investigare" — a un solo tasto di distanza, condividendo la stessa cattura live.
Pensato per blue-teamers, incident responder, SRE e homelabber che hanno bisogno di vedere cosa sta succedendo adesso — non di analizzare un file di cattura un'ora dopo.
650+ test · sandbox Landlock (Linux) · analizza in sicurezza traffico ostile
E la parte che nessun altro strumento da terminale fa affatto: NetWatch impara con cosa parla ogni programma sulla macchina, trasforma quella baseline osservata in una policy con un solo tasto e ti avvisa nel momento in cui un programma inizia a parlare con qualcosa di nuovo.
Osserva → promuovi → avvisa. La baseline diventa una policy con un solo tasto; la prossima nuova destinazione arriva come drift.
Perché NetWatch
- 🔓 Leggi il traffico cifrato che controlli — punta il
SSLKEYLOGFILEdi un browser o di un'app verso NetWatch e guarda il plaintext delle sue sessioni TLS 1.3 decodificarsi in tempo reale, nello stesso modo in cui fa Wireshark. Nessun proxy, nessun certificato, niente in mezzo. - 🛰️ Scopri con cosa parla ogni programma, poi vieni avvisato quando cambia — NetWatch osserva quali destinazioni raggiunge ogni processo (hostname dal ClientHello, sistema autonomo, porta), e un solo tasto promuove quella baseline osservata in una policy di egress. Da quel momento avvisa quando un programma inizia a parlare con qualcosa di nuovo. Questa è la frase che un ruleset di firewall non può esprimere:
curlraggiungeva soloapi.github.com, e oggi ha raggiunto qualcos'altro. Solo osservazione — non blocca mai. - 🧬 Identifica il software dietro una connessione — JA4 trasforma ogni handshake TLS/QUIC in un fingerprint stabile, così puoi riconoscere un client specifico — o un pezzo specifico di malware — anche se il traffico è cifrato, nello stesso modo in cui riconosceresti un browser dal suo user-agent. Fai pivot su un fingerprint per trovare ogni altro flusso dello stesso software.
- 🚨 Cattura il malware che contatta il suo comando — il rilevamento integrato per beaconing C2 (check-in regolari a basso jitter), scan delle porte e DNS tunneling gira in background con zero configurazione. Un alert critico congela automaticamente il registratore così le prove sono già salvate quando guardi.
- ⚙️ Identifica il processo dietro ogni connessione — mappa ogni socket al programma che lo ha aperto da
ss/lsof, con un kprobe eBPF opzionale a livello kernel (Linux, la featureebpf) che cattura anche i flussi di breve durata che il polling può perdere. Funziona ovunque; il kprobe è un miglioramento, non un requisito. - 📡 Decodifica i protocolli, non solo le porte — parsing L7 reale di TLS, QUIC, HTTP e DNS (più uno sniff del banner/versione SSH) e una dozzina di altri, con tracciamento dei flussi per connessione e timing degli handshake — così vedi
api.github.come il fingerprint JA4, non solo "porta 443." - 🎥 Congela le prove — arma un registratore rotante e congela qualsiasi incidente in un pacchetto portabile: i pacchetti più le connessioni, il DNS, la salute e gli alert che li spiegano. Pensato per bug report e post-mortem.
- 🛡️ Sicuro by design — dopo il setup, NetWatch abbandona i suoi privilegi e si blocca in una allow-list del filesystem Landlock (Linux). Uno strumento che analizza traffico ostile non può leggere le tue chiavi SSH, i profili del browser o
/etc/shadow. - 🪟 Si riduce a una sola schermata —
--literisponde a "cosa sta usando la mia rete, e la mia connessione è OK?" su una singola schermata 80×24 con sei tasti, così si adatta a una sessione SSH verso un Pi o a uno split di tmux. Un solo tasto fa salire alla vista forense completa con i collector già attivi.
Nessun file di configurazione. Nessun setup. Nessun flag richiesto.
Installazione```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
Oppure scarica un binario precompilato dalla sezione [Releases](https://github.com/matthart1983/netwatch/releases/latest).
**Su Windows è necessario installare [Npcap](https://npcap.com/#download)** — le impostazioni predefinite dell'installer vanno bene, e senza di esso NetWatch si chiude all'avvio segnalandolo. **Compilare dal sorgente** (`cargo install`, `paru -S netwatch-tui`) richiede gli header di sviluppo di libpcap: `libpcap-dev` su Debian/Ubuntu e Alpine, `libpcap-devel` su Fedora/RHEL, `libpcap` su Arch. Se mancano, al momento del link compare `cannot find -lpcap`. macOS include libpcap; i binari `-static` Linux qui sotto lo includono e non richiedono installazioni aggiuntive.
I pacchetti Nix, Arch e Scoop sono mantenuti da packager della community — grazie. Segnala i problemi di packaging a loro; segnala i bug di netwatch qui. Se un pacchetto è in ritardo rispetto a una release, la [pagina Repology](https://repology.org/project/netwatch-tui/versions) lo mostra.
<details>
<summary><strong>Tutte le piattaforme & compilazione dal sorgente</strong></summary>
| Piattaforma | 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, statico — Arch/Fedora/Alpine/qualsiasi distro) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, statico — Arch/Fedora/Alpine/qualsiasi distro) | [`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) |
Le build Linux `-static` includono libpcap e non hanno dipendenze a runtime — usale su Arch, Fedora, Alpine o qualsiasi distro dove le build predefinite segnalano `libpcap.so.0.8: cannot open shared object file`.
La build Windows richiede [Npcap](https://npcap.com/#download) — installalo prima del primo avvio. Le impostazioni predefinite dell'installer vanno bene: NetWatch cerca in `System32\Npcap`, dove Npcap mette effettivamente `wpcap.dll`, quindi *Install Npcap in WinPcap API-compatible Mode* non è necessario. Senza Npcap ricevi un messaggio di NetWatch che indica cosa manca, non una finestra di errore di Windows. (Su v0.29.1 e versioni precedenti serviva quella casella — vedi [#47](https://github.com/matthart1983/netwatch/issues/47).)
**Dal sorgente:**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release
Prerequisiti: Rust 1.70+ e le header di sviluppo di libpcap. Lo stesso vale per cargo install netwatch-tui.
| Piattaforma | Installazione |
|---|---|
| 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 | incluso nel sistema |
| Windows | Npcap — la build scarica automaticamente l'SDK di Npcap, oppure imposta NPCAP_SDK su una copia estratta |
Senza di essi, la build fallisce in fase di link con /usr/bin/ld: cannot find -lpcap. Se vuoi solo eseguire NetWatch invece di compilarlo, i binari Linux -static sopra non richiedono nulla di tutto ciò.
Avvio rapido```bash
netwatch # interface stats, connections, config — no privileges needed sudo netwatch # full mode — adds live packet capture + health probes
Basta. Cambia scheda con `1`–`9`, premi `?` per l'aiuto, `q` per uscire. La Dashboard è utile in cinque secondi; tutto il resto è lì quando ti serve andare più a fondo.
> **Linux senza `sudo`:** concedi le capacità di cattura una volta ed esegui come utente normale —
> `sudo setcap 'cap_net_raw,cap_bpf,cap_perfmon+eip' "$(which netwatch)"`. Rieseguilo dopo ogni aggiornamento ([dettagli](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#running-without-sudo-linux)).
### Guardalo decifrare TLS in 60 secondi
Il modo più veloce per capire cos'è NetWatch — guardalo leggere il testo in chiaro di una sessione TLS 1.3 *che controlli tu*:```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
I dati applicativi decrittati vengono visualizzati inline. Un mancato keylog non interrompe mai la cattura — quel record rimane semplicemente opaco. (SSLKEYLOGFILE è lo stesso meccanismo usato da Wireshark; funziona solo per il traffico che controlli tu, mai per traffico di terze parti o malware.)
Leggere il testo in chiaro da una sessione TLS 1.3 live — decrittato direttamente nel terminale. Nessun proxy, nessun man-in-the-middle.
Guardalo intercettare la deriva in uscita in 60 secondi
Il loop della demo qui sopra, in tre comandi:```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 nuova destinazione arriva con un verdetto `✗ drift` e un avviso. Non è stato bloccato nulla — il punto è che sei stato *informato*.
I verdetti non sono volutamente binari:
| | |
|---|---|
| `✓ sni` / `✓ ip` | Corrisponde a un hostname o indirizzo dichiarato — preciso |
| `~ asn` | Corrisponde solo per sistema autonomo — questo ammette *tutto ciò che opera quell'AS*, che per un hyperscaler è di fatto illimitato |
| `? ech` | Encrypted ClientHello: il nome è nascosto per design, quindi questo è "non posso giudicare", non "cattivo" |
| `✗ drift` | Fuori dall'allowlist |
| `— no rule` | Questo programma non è mai stato dichiarato — non è stato controllato nulla |
| `✗ undeclared` | Nessuna regola, con `strict = true` — la policy dichiara di essere completa, quindi *l'assenza* è il risultato |
Le regole accettano hostname esatti, `*.wildcards`, sistemi autonomi, blocchi CIDR (`10.0.0.0/8`) e porte. `strict = true` è ciò che trasforma il linter da "dimmi quando il mio software dichiarato si comporta male" in "dimmi quando qualcosa che non ho mai dichiarato inizia a parlare" — che è la forma che assume un compromesso reale.
## Cosa ottieni
Dieci schede, commutabili con `1`–`9` e `0`:
| # | Scheda | Cosa mostra |
|---|-----|---------------|
| 1 | **Dashboard** | Interfacce, grafico della larghezza di banda, connessioni principali, salute gateway/DNS, mappa di calore della latenza. Utile in 5 secondi. |
| 2 | **Connessioni** | Ogni socket con il suo processo + PID, protocollo, stato, GeoIP e sparkline di latenza. |
| 3 | **Interfacce** | IPv4/IPv6 per interfaccia, MAC, MTU, RX/TX, errori, pacchetti scartati. |
| 4 | **Pacchetti** | Cattura live con decodifica L7 reale, decrittazione TLS 1.3, JA4, tracciamento dei flussi per connessione, filtri, esportazione PCAP. |
| 5 | **Statistiche** | Ripartizione dei protocolli per byte + istogramma dei tempi di handshake TCP. |
| 6 | **Topologia** | Mappa ASCII di macchina → gateway → DNS → host principali, con traceroute. |
| 7 | **Timeline** | Timeline delle connessioni colorata per stato TCP; gli avvisi di sicurezza arrivano qui. |
| 8 | **Processi** | Classifica della larghezza di banda per processo con RX/TX live e conteggi delle connessioni. |
| 9 | **Insight** | *(opt-in)* invia uno snapshot a un LLM locale/cloud per un'analisi in linguaggio semplice. |
| 0 | **Egress** | Impara a cosa parla ogni processo (hostname/AS/porta), promuove quella baseline a policy con un tasto, poi avvisa su drift. Solo osservazione, non blocca mai. |
La scheda Pacchetti è dove vivono le indagini forensi — decodifica profonda dei protocolli, decrittazione live TLS 1.3, threat-hunting JA4, filtri di visualizzazione stile Wireshark e cattura degli incidenti. **[Vedi il riferimento completo delle funzionalità →](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)**
### Vista Lite
Dieci schede sono uno strumento da operatore. Quando la domanda è solo *"cosa sta usando la mia rete, e la mia connessione è OK?"* — una macchina, una sessione SSH verso un Pi, uno split tmux — c'è `--lite`:```bash
netwatch --lite # one screen, fits 80×24
Una schermata, sei tasti. Throughput in tempo reale, raggiungibilità e chi sta parlando — espandi qualsiasi riga sul posto, filtra mentre digiti.
Tutto su una singola schermata: grafici di throughput in tempo reale, raggiungibilità di gateway/DNS/internet e i principali interlocutori per processo e host. Sei tasti — q esci, p pausa, / filtra, ↵ espandi un interlocutore, L torna alla vista completa, ? aiuto.
Premi L da entrambe le viste per passare dall'una all'altra. Entrambe condividono gli stessi collector, quindi passare da "qualcosa non torna" alla vista forense completa a dieci schede costa una sola pressione di tasto — nessun riavvio, nessuna cronologia persa, la cattura continua a girare.
Vista densa
L'altra direzione: quando hai un terminale grande e vuoi tutto in una volta, --view dense lo riempie con quattro riquadri e nessuna cornice — nessuna barra dell'intestazione, nessuna barra dei menu, nessuna barra di stato. Identità, stato di ordinamento, intervallo di pagine e ogni scorciatoia da tastiera vivono dentro i bordi dei riquadri, così ogni riga trasporta dati. Richiede 130×44 come minimo e cresce in base a ciò che gli dai: più largo significa più cronologia nei grafici e spazio per hostname completi, più alto significa più interfacce e più connessioni.```bash
netwatch --view dense # four boxes, needs 130×44
Questa è la schermata in cima a questo README. L'elemento distintivo è il **doppio grafico speculare**: il download cresce verso l'alto da un asse temporale centrale, l'upload cresce verso il basso dallo stesso asse. La simmetria del traffico diventa una forma che riconosci senza leggere un numero — un picco di download è una scogliera sopra la linea, un job di backup è una scogliera sotto di essa. Entrambe le metà sono in braille a due campioni per cella di carattere, e ogni cella è colorata in base alla sua **altezza nel grafico** piuttosto che alla serie a cui appartiene, così vedi la gravità di un picco prima di misurarlo rispetto all'asse.
Le rampe di throughput passano da freddo→luminoso perché l'alta larghezza di banda è *occupata*, non *negativa* — un collegamento saturo durante un backup sta lavorando. Solo i valori limitati in cui l'alto è davvero negativo — saturazione del collegamento, budget di latenza per hop — ricevono il trattamento verde→ambra→rosso, e i loro misuratori si colorano in base alla posizione lungo la barra, così la zona rossa è visibile prima di raggiungerla.
Sotto il grafico: velocità per interfaccia con sparkline a 60 secondi, budget di latenza a quattro hop (gateway, DNS, internet e il peer più lento con cui stai effettivamente parlando), e la tabella delle connessioni con il dettaglio della riga selezionata sollevato nella parte superiore della stessa casella — nessuna nuova schermata, nessun pulsante indietro. La riga di dettaglio porta lo stato TCP del kernel — `cwnd`, `ssthresh`, `mss`, `rwnd` — letto direttamente dal kernel: `inet_diag` su netlink in Linux, il sysctl `net.inet.tcp.pcblist64` su macOS. I due kernel non concordano sulle unità (Linux conta i segmenti, BSD conta i byte), quindi i valori macOS sono normalizzati rispetto all'MSS e la colonna significa la stessa cosa su entrambi. Windows legge `--` finché `GetPerTcpConnectionEStats` non viene collegato.
`V` cicla `full → lite → dense`, oppure impostalo una volta sotto **Impostazioni → Vista**. Sotto 130×44 ripiega sulla stessa griglia 80×24 a cui mira Lite — che riempie anche la sua area — e non scorre mai lateralmente.
## Approfondimenti
| Guida | Cosa contiene |
|-------|--------------|
| **[Riferimento funzionalità](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)** | Ogni combinazione di tasti, il linguaggio dei filtri di visualizzazione, l'elenco dei decoder di protocollo, i temi e le opzioni di configurazione. |
| **[Decrittazione TLS 1.3](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#tls-13-decryption)** | Come funziona la decrittazione con `SSLKEYLOGFILE`, le suite di cifratura supportate e cosa può e non può leggere. |
| **[Threat hunting con JA4](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#threat-hunting-with-ja4)** | Identificazione dei client tramite impronta digitale e pivot tra i flussi. |
| **[Sicurezza & il sandbox Landlock](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#security--forensics)** | Il modello di minaccia, la riduzione dei privilegi e la lista bianca del filesystem. |
| **[Linting delle policy egress](https://github.com/matthart1983/netwatch/blob/main/docs/egress-linter-plan.md)** | Il modello osserva → promuovi → avvisa, il linguaggio delle regole, la modalità `strict` e lo schema di esportazione NDJSON. |
| **[Flight Recorder](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#flight-recorder)** | Armamento, congelamento e contenuto di un bundle di incidente. |
| **[AI Insights](https://github.com/matthart1983/netwatch/blob/main/docs/INSIGHTS.md)** | Analisi LLM locale/cloud opzionale (disattivata per impostazione predefinita). |
## Come funziona```
Raw bytes → Ethernet → IPv4/IPv6/ARP → TCP/UDP/ICMP → L7 decoders
↓
Per-flow stream tracking · Handshake timing
TLS 1.3 decryption · JA4 · Threat detection
| Collector | macOS | Linux |
|---|---|---|
| Connessioni | lsof + PKTAP | /proc/net/tcp + eBPF kprobe |
| Pacchetti | libpcap (BPF) | libpcap |
| Attribuzione dei processi | PKTAP | polling lsof/ss, con overlay eBPF kprobe opzionale |
Tutto degrada con eleganza: le funzionalità che richiedono privilegi elevati mostrano un messaggio chiaro e ripiegano, senza mai andare in crash. Le note complete sull'architettura sono in WIKI.md.
Correlati
Fratelli: SysWatch (sistema) e DiskWatch (disco) — stessa interfaccia, superficie diversa. ESSH — un client SSH in puro Rust con la stessa estetica TUI; si connette dove NetWatch osserva.
NetWatch Cloud — monitoraggio della flotta in hosting per i server su cui esegui NetWatch. Un piccolo agente Rust su ogni host Linux, una dashboard in tempo reale e avvisi via email e Slack su latenza, perdita di pacchetti o host offline. Gratuito mentre cresciamo. L'agente, l'SDK e la dashboard sono MIT; il backend in hosting è proprietario.
Ringraziamenti
Packager. NetWatch è in homebrew-core, nixpkgs, nell'AUR e nel bucket principale di Scoop — e non ho impacchettato nulla io. Ognuno di questi è stato fatto da qualcuno che ha trovato utile lo strumento, ha fatto il lavoro senza che glielo chiedessi e lo ha mantenuto aggiornato da allora. La voce Scoop di solito ha seguito una release entro poche ore dal tag.
| Dominiquini | netwatch-tui sull'AUR, da marzo 2026 |
| kemelzaidan | netwatch-tui-bin sull'AUR |
| tomasrivera | netwatch in nixpkgs |
| scillidan | netwatch nel bucket principale di Scoop, dalla v0.15.3 |
| Manutentori di Homebrew | per aver portato la formula in core, e il bot che ha seguito ogni release da allora |
Il packaging è un lavoro ingrato che viene notato solo quando si rompe. Se installi NetWatch tramite uno di questi, devi ringraziare loro, non me.
Contributori. @lamchau, @fdncred e @PeteE hanno inviato patch. Grazie — una pull request da uno sconosciuto è la cosa migliore che possa capitare a un progetto come questo.
E a tutti coloro che hanno aperto un issue con una riproduzione reale, hanno discusso una decisione di design o mi hanno detto che l'output era sbagliato sul loro terminale: è questo il ciclo di feedback su cui si basa tutto.
Contribuire
Domande, idee e segnalazioni di bug sono benvenute in GitHub Discussions e Issues. Vedi CONTRIBUTING.md per le convenzioni di codifica e WIKI.md per la guida all'architettura.
Licenza
MIT