NetWatch

Scopri cosa fa davvero la tua rete — dal vivo, nel tuo terminale.
Un monitor di rete che legge il traffico cifrato, identifica il processo dietro ogni connessione e intercetta malware che contattano il proprio C2. Un unico binario. Zero configurazione.

Tutto insieme, con zero righe di chrome — niente barra superiore, niente barra dei menu, niente barra di stato. Il download cresce verso l'alto dall'asse temporale 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 magnitudo, non la serie.

…e la vista predefinita a dieci schede sotto di esso, a un solo V di distanza e con gli stessi collector già caldi — 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 consumando la mia banda?" — e si ferma. NetWatch va oltre. Decodifica i protocolli sulla rete, ti dice quale programma ha aperto ogni connessione e osserva i pattern che indicano problemi — una scansione delle porte, un 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 da allegare a una segnalazione di bug.

Pensalo come un unico binario zero-config che fa il lavoro di un misuratore di banda, della vista triage di Wireshark e di un rilevatore di intrusioni leggero — senza uscire dal terminale.

Si adatta alla domanda che stai ponendo — in entrambe le direzioni: --view dense riempie un grande terminale con quattro riquadri senza chrome, e netwatch --lite è una schermata 80×24 per "cosa sta usando la mia rete in questo momento?"; la vista completa a dieci schede è lì quando la risposta è "qualcosa che devo investigare" — a un tasto di distanza, condividendo la stessa cattura live.

Progettato per blue team, incident responder, SRE e appassionati di homelab 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: NetWatch impara con cosa comunica ogni programma sulla macchina, trasforma quella baseline osservata in una policy con un tasto e ti avvisa nel momento in cui un programma inizia a comunicare con qualcosa di nuovo.

Osserva → promuovi → avvisa. La baseline diventa una policy con un tasto; la prossima nuova destinazione arriva come drift.

Perché NetWatch

• 🔓 Leggi il traffico cifrato che controlli — punta SSLKEYLOGFILE di un browser o di un'app su NetWatch e guarda il plaintext delle sessioni TLS 1.3 decodificarsi dal vivo, come fa Wireshark. Nessun proxy, nessun certificato, nulla in mezzo.
• 🛰️ Impara con cosa comunica ogni programma e vieni avvisato quando cambia — NetWatch osserva quali destinazioni raggiunge ogni processo (hostname dal ClientHello, sistema autonomo, porta) e con un tasto promuove quella baseline osservata in una policy di egress. Da quel momento avvisa quando un programma inizia a comunicare con qualcosa di nuovo. È la frase che un ruleset firewall non può esprimere: curl prima raggiungeva solo api.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'impronta stabile, così puoi riconoscere un client specifico — o un particolare malware — anche se il traffico è cifrato, come riconosceresti un browser dal suo user-agent. Ruota su un'impronta per trovare ogni altro flusso dello stesso software.
• 🚨 Intercetta malware che contattano il C2 — la rilevazione integrata di beaconing C2 (check-in regolari a basso jitter), scansioni di porte e DNS tunneling gira in background senza configurazione. Un alert critico blocca automaticamente il registratore, così le prove sono già salvate quando guardi.
• ⚙️ Dai un nome al processo dietro ogni connessione — mappa ogni socket al programma che lo ha aperto da ss/lsof, con un'opzionale kprobe eBPF a livello kernel (Linux, la feature ebpf) che cattura anche i flussi di breve durata che il polling può perdere. Funziona ovunque; la kprobe è un miglioramento, non un requisito.
• 📡 Decodifica i protocolli, non solo le porte — parsing reale L7 di TLS, QUIC, HTTP e DNS (più uno sniff di banner/versione SSH) e una dozzina di altri, con tracciamento dei flussi per connessione e timing dell'handshake — così vedi api.github.com e l'impronta JA4, non solo "porta 443".
• 🎥 Congela le prove — arma un registratore circolare e congela qualsiasi incidente in un bundle portabile: i pacchetti più le connessioni, DNS, stato di salute e alert che li spiegano. Progettato per bug report e post-mortem.
• 🛡️ Sicuro by design — dopo la configurazione, NetWatch abbandona i privilegi e si chiude in una allow-list Landlock del filesystem (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 schermata — --lite risponde a "cosa sta usando la mia rete e la mia connessione è OK?" su una singola schermata 80×24 con sei tasti, così entra in una sessione SSH verso un Pi o in una split di tmux. Un tasto porta alla vista forense completa con i collector già caldi.

Nessun file di configurazione. Nessuna configurazione. 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 pagina [Releases](https://github.com/matthart1983/netwatch/releases/latest).

I pacchetti Nix, Arch e Scoop sono mantenuti dai 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 e build 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, static — Arch/Fedora/Alpine/qualsiasi distro) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, static — 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) |

Le build Linux `-static` includono libpcap e non hanno dipendenze runtime — usale su Arch, Fedora, Alpine o qualsiasi distro in cui le build predefinite segnalano `libpcap.so.0.8: cannot open shared object file`.

**Dal sorgente:**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release

Prerequisiti: Rust 1.70+, libpcap (sudo apt install libpcap-dev su Linux, incluso su macOS).

Avvio rapido```bash

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

Ecco fatto. Passa tra le schede con `1`–`9`, premi `?` per l'aiuto, `q` per uscire. La Dashboard è utile in cinque secondi; tutto ciò che segue è lì quando serve approfondire.

> **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)"`. Eseguilo di nuovo dopo ogni aggiornamento ([dettagli](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#running-without-sudo-linux)).

### Vedi la decrittazione TLS in 60 secondi

Il modo più veloce per capire cos'è NetWatch — osservalo mentre legge 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 resta 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 dal vivo — decrittata direttamente nel terminale. Nessun proxy, nessun man-in-the-middle.

Guardalo individuare la deriva di egress 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 atterra con un verdetto `✗ drift` e un avviso. Non è stato bloccato nulla — il punto è che sei stato *informato*.

I verdetti sono intenzionalmente non binari:

| | |
|---|---|
| `✓ sni` / `✓ ip` | Corrisponde a un hostname o indirizzo dichiarato — preciso |
| `~ asn` | Corrisponde solo per sistema autonomo — ammette *tutto ciò che l'AS gestisce*, 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 riscontro |

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" a "dimmi quando qualcosa che non ho mai dichiarato inizia a parlare" — che è la forma che ha una compromissione reale.

## Cosa ottieni

Dieci schede, attivabili con `1`–`9` e `0`:

| # | Scheda | Cosa mostra |
|---|-----|---------------|
| 1 | **Dashboard** | Interfacce, grafico della banda, connessioni principali, salute gateway/DNS, mappa di calore della latenza. Utile in 5 secondi. |
| 2 | **Connections** | Ogni socket con il suo processo + PID, protocollo, stato, GeoIP e sparkline di latenza. |
| 3 | **Interfaces** | IPv4/IPv6 per interfaccia, MAC, MTU, RX/TX, errori, perdite. |
| 4 | **Packets** | Cattura live con decodifica L7 reale, decriptazione TLS 1.3, JA4, tracciamento stream per flusso, filtri, esportazione PCAP. |
| 5 | **Stats** | Ripartizione dei protocolli per byte + istogramma dei tempi di handshake TCP. |
| 6 | **Topology** | Mappa ASCII di macchina → gateway → DNS → host principali, con traceroute. |
| 7 | **Timeline** | Timeline delle connessioni colorata in base allo stato TCP; gli avvisi di sicurezza finiscono qui. |
| 8 | **Processes** | Classifica della banda per processo con RX/TX live e conteggi delle connessioni. |
| 9 | **Insights** | *(opt-in)* invia un'istantanea a un LLM locale/cloud per un'analisi in linguaggio semplice. |
| 0 | **Egress** | Impara con cosa parla ogni processo (hostname/AS/porta), eleva quella baseline a policy con una singola pressione di tasto, poi avvisa in caso di drift. Solo osservazione, non blocca mai. |

La scheda Packets è dove vive la forensics — decodifica profonda dei protocolli, decriptazione TLS 1.3 live, threat-hunting con JA4, filtri di visualizzazione in stile Wireshark e cattura degli incidenti. **[Vedi il riferimento completo delle funzionalità →](https://github.com/matthart1983/netwatch/blob/HEAD/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, una split di tmux — c'è `--lite`:```bash
netwatch --lite     # one screen, fits 80×24

Uno schermo, sei tasti. Throughput in tempo reale, raggiungibilità e chi sta parlando — espandi qualsiasi riga sul posto, filtra mentre digiti.

Tutto su un unico schermo: grafici di throughput in tempo reale, raggiungibilità di gateway/DNS/internet e i principali talker per processo e host. Sei tasti — q esci, p pausa, / filtra, ↵ espandi un talker, L torna alla vista completa, ? aiuto.

Premi L da entrambe le viste per cambiare. Entrambe condividono gli stessi collector, quindi passare da "qualcosa non torna" alla piena vista forense a dieci schede costa un solo 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 nessun elemento decorativo — niente barra dell'intestazione, niente menu bar, niente barra di stato. Identità, stato di ordinamento, intervallo di pagine e ogni scorciatoia vivono dentro i bordi dei riquadri, così ogni riga trasporta dati. Richiede 130×44 come minimo e cresce in base a quello che gli dai: più largo significa più storico nei grafici e spazio per hostname completi, più alto significa più interfacce e più connessioni.```bash netwatch --view dense # four boxes, needs 130×44

That's the screen at the top of this README. The signature element is the **mirrored dual graph**: download grows up from a centre time axis, upload grows down from the same axis. Traffic symmetry becomes a shape you recognise without reading a number — a download burst is a cliff above the line, a backup job is a cliff below it. Both halves are braille at two samples per character cell, and every cell is coloured by its **height in the graph** rather than by which series it belongs to, so you see a spike's severity before you measure it against the axis.

Throughput ramps cool→bright because high bandwidth is *busy*, not *bad* — a saturated link during a backup is working. Only bounded values where high genuinely is bad — link saturation, latency budget per hop — get the green→amber→red treatment, and their meters colour by position along the bar, so the red zone is visible before you reach it.

Below the graph: per-interface rates with 60-second sparklines, four-hop latency budgets (gateway, DNS, internet, and the slowest peer you're actually talking to), and the connection table with the selected row's detail hoisted into the top of the same box — no new screen, no back button. The detail row carries kernel TCP state — `cwnd`, `ssthresh`, `mss`, `rwnd` — read straight from the kernel: `inet_diag` tramite netlink su Linux, il sysctl `net.inet.tcp.pcblist64` su macOS. I due kernel non concordano sulle unità di misura (Linux conta i segmenti, BSD conta i byte), quindi i valori macOS vengono normalizzati rispetto al MSS e la colonna ha lo stesso significato su entrambi. Windows mostra `--` finché `GetPerTcpConnectionEStats` non viene collegato.

`V` alterna `full → lite → dense`, oppure impostalo una volta in **Settings → View**. Sotto 130×44 ripiega sulla stessa griglia 80×24 a cui mira Lite — che riempie anch'essa la sua area — e non scorre mai orizzontalmente.

## Approfondimenti

| Guida | Cosa contiene |
|-------|--------------|
| **[Riferimento delle funzionalità](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md)** | Ogni keybinding, il linguaggio dei filtri di visualizzazione, l'elenco dei decoder di protocollo, i temi e le opzioni di configurazione. |
| **[Decifratura TLS 1.3](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#tls-13-decryption)** | Come funziona la decifratura tramite `SSLKEYLOGFILE`, le suite crittografiche supportate e cosa può e non può leggere. |
| **[Caccia alle minacce con JA4](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#threat-hunting-with-ja4)** | Fingerprinting dei client e pivoting tra i flussi. |
| **[Sicurezza e sandbox Landlock](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#security--forensics)** | Il modello di minaccia, il capability dropping e l'allow-list del filesystem. |
| **[Linting delle policy di egress](https://github.com/matthart1983/netwatch/blob/HEAD/docs/egress-linter-plan.md)** | Il modello observe → promote → warn, il linguaggio delle regole, la modalità `strict` e lo schema di esportazione NDJSON. |
| **[Flight Recorder](https://github.com/matthart1983/netwatch/blob/HEAD/docs/REFERENCE.md#flight-recorder)** | Arming, freezing e il contenuto di un incident bundle. |
| **[AI Insights](https://github.com/matthart1983/netwatch/blob/HEAD/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

Tutto degrada con eleganza: le funzionalità che richiedono privilegi elevati mostrano un messaggio chiaro e ripiegano, senza mai crashare. Le note complete sull'architettura sono in WIKI.md.

Correlati

Progetti gemelli: SysWatch (sistema) e DiskWatch (disco) — stessa interfaccia, diverso ambito. ESSH — un client SSH in puro Rust con la stessa estetica TUI; si connette dove NetWatch osserva.

NetWatch Cloud — monitoraggio della flotta ospitato per i server su cui esegui NetWatch. Un piccolo agente Rust su ogni host Linux, una dashboard in tempo reale e avvisi via email + Slack su latenza, perdita di pacchetti o host che vanno offline. Gratuito mentre cresciamo. L'agente, l'SDK e la dashboard sono MIT; il backend ospitato è proprietario.

Ringraziamenti

Packager. NetWatch è in homebrew-core, nixpkgs, 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 su Scoop di solito ha seguito una release entro poche ore dal tag.

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 parte di un estraneo è la cosa migliore che possa capitare a un progetto come questo.

E a tutti coloro che hanno aperto un issue con una riproduzione concreta, 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 tutto è costruito.

Contribuire

Domande, idee e segnalazioni di bug sono benvenuti in GitHub Discussions e Issues. Vedi CONTRIBUTING.md per le convenzioni di codifica e WIKI.md per la guida all'architettura.

Licenza

MIT