netwatch v0.27.0
Diagnósticos de rede em tempo real no seu terminal. Um comando, zero configuração, visibilidade instantânea.
NetWatch
Veja o que a sua rede está realmente a fazer — ao vivo, no seu terminal.
Um monitor de rede que lê tráfego encriptado, identifica o processo por trás de cada ligação e apanha malware a comunicar com o servidor de comando. Um único binário. Zero configuração.
Tudo ao mesmo tempo, com zero linhas de cromo — sem barra de cabeçalho, sem barra de menu, sem barra de estado. O download cresce para cima a partir do eixo temporal partilhado, o upload cresce para baixo, pelo que a simetria do tráfego é uma forma que reconhece antes de ler um número. A cor codifica a magnitude, não a série.
…e o instrumento predefinido de dez separadores por baixo, a um V de distância e a partilhar os mesmos coletores quentes — o painel de controlo, o programa por trás de cada socket, inspeção profunda de pacotes, o mapa de rede, e aquilo com que cada programa comunica.
A maioria das ferramentas de rede responde a uma pergunta — "o que está a usar a minha largura de banda?" — e para por aí. A NetWatch continua. Descodifica os protocolos na linha, diz-lhe qual o programa que abriu cada ligação, e vigia os padrões que significam problemas — uma varredura de portas, malware a fazer beaconing para um servidor de comando, dados a sair às escondidas por DNS. Quando algo parece errado, uma tecla congela um pacote de evidências portátil que pode anexar a um relatório de bug.
Pense nela como um único binário de zero configuração que faz o trabalho de um medidor de largura de banda, da vista de triagem do Wireshark, e de um detetor de intrusões leve — sem sair do terminal.
Escala até à pergunta que está a fazer — em ambas as direções: --view dense preenche um terminal grande com quatro caixas sem cromo, e netwatch --lite é um ecrã 80×24 para "o que está a usar a minha rede agora?"; a vista completa de dez separadores está lá quando a resposta é "algo que preciso de investigar" — a uma tecla de distância, partilhando a mesma captura ao vivo.
Feita para membros de blue team, respondedores a incidentes, SREs e entusiastas de homelab que precisam de ver o que está a acontecer agora — não analisar um ficheiro de captura uma hora depois.
650+ testes · sandbox Landlock (Linux) · analisa tráfego hostil em segurança
E a parte que nenhuma outra ferramenta de terminal faz de todo: a NetWatch aprende com o que cada programa na máquina comunica, transforma essa linha de base observada numa política com uma tecla, e avisa-o no momento em que um programa começa a comunicar com algo novo.
Observar → promover → avisar. A linha de base torna-se uma política com uma tecla; o próximo destino novo chega como drift.
Porquê a NetWatch
- 🔓 Leia tráfego encriptado que controla — aponte o
SSLKEYLOGFILEde um navegador ou aplicação para a NetWatch e veja o texto simples das suas sessões TLS 1.3 a descodificar ao vivo, da mesma forma que o Wireshark o faz. Sem proxy, sem certificados, nada no meio. - 🛰️ Aprenda com o que cada programa comunica e depois seja avisado quando isso muda — a NetWatch observa quais os destinos que cada processo alcança (hostname do ClientHello, sistema autónomo, porta), e uma tecla promove essa linha de base observada para uma política de egress. A partir daí, avisa quando um programa começa a comunicar com algo novo. Essa é a frase que um conjunto de regras de firewall não consegue expressar:
curlcostumava alcançar apenasapi.github.com, e hoje alcançou outra coisa. Apenas observação — nunca bloqueia. - 🧬 Identifique o software por trás de uma ligação — o JA4 transforma cada handshake TLS/QUIC numa impressão digital estável, para que possa reconhecer um cliente específico — ou uma peça específica de malware — mesmo que o tráfego esteja encriptado, da mesma forma que reconheceria um navegador pelo seu user-agent. Faça pivot numa impressão digital para encontrar todos os outros fluxos do mesmo software.
- 🚨 Apanhe malware a comunicar com o servidor de comando — deteção integrada de beaconing C2 (check-ins regulares com pouco jitter), varreduras de portas e túneis DNS corre em segundo plano com zero configuração. Um alerta crítico congela automaticamente o gravador para que a evidência já esteja guardada quando olhar.
- ⚙️ Identifique o processo por trás de cada ligação — mapeia cada socket para o programa que o abriu a partir de
ss/lsof, com um kprobe eBPF opcional ao nível do kernel (Linux, a funcionalidadeebpf) que também apanha fluxos de curta duração que a sondagem pode perder. Funciona em todo o lado; o kprobe é um melhoramento, não um requisito. - 📡 Descodifique os protocolos, não apenas as portas — análise real de L7 de TLS, QUIC, HTTP e DNS (mais uma deteção de banner/versão SSH) e mais uma dúzia, com rastreio de fluxos por ligação e temporização de handshakes — para que veja
api.github.come a impressão digital JA4, não apenas "porta 443." - 🎥 Congele a evidência — arme um gravador rotativo e congele qualquer incidente num pacote portátil: os pacotes mais as ligações, DNS, saúde e alertas que os explicam. Feito para relatórios de bug e post-mortems.
- 🛡️ Segura por conceção — após a configuração, a NetWatch reduz os seus privilégios e tranca-se numa lista de permissões de sistema de ficheiros Landlock (Linux). Uma ferramenta que analisa tráfego hostil não pode ler as suas chaves SSH, perfis de navegador ou
/etc/shadow. - 🪟 Escala até um único ecrã —
--literesponde a "o que está a usar a minha rede, e a minha ligação está OK?" num único ecrã 80×24 com seis teclas, para caber numa sessão SSH para um Pi ou numa divisão de tmux. Uma tecla eleva para a vista forense completa com os coletores já quentes.
Sem ficheiros de configuração. Sem configuração. Sem flags necessárias.
Instalação```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 pega um binário pré-compilado em [Releases](https://github.com/matthart1983/netwatch/releases/latest).
**O Windows precisa do [Npcap](https://npcap.com/#download) instalado** — os padrões do instalador são suficientes, e sem ele o NetWatch sai na inicialização avisando isso. **Compilar a partir do código-fonte** (`cargo install`, `paru -S netwatch-tui`) precisa dos cabeçalhos de desenvolvimento do libpcap: `libpcap-dev` no Debian/Ubuntu e Alpine, `libpcap-devel` no Fedora/RHEL, `libpcap` no Arch. Se faltarem, aparece `cannot find -lpcap` na hora da linkagem. O macOS já traz o libpcap; os binários `-static` do Linux abaixo o incluem e não precisam de nada instalado.
Os pacotes Nix, Arch e Scoop são mantidos por empacotadores da comunidade — obrigado. Reporte
problemas de empacotamento com eles; reporte bugs do netwatch aqui. Se um pacote ficar atrás de um release, a
[página do Repology](https://repology.org/project/netwatch-tui/versions) mostra isso.
<details>
<summary><strong>Todas as plataformas & compilar a partir do código-fonte</strong></summary>
| Plataforma | 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, estático — Arch/Fedora/Alpine/qualquer distro) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, estático — Arch/Fedora/Alpine/qualquer 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) |
As compilações `-static` do Linux incluem o libpcap e não têm dependências em tempo de execução — use-as no Arch, Fedora, Alpine, ou em qualquer distro onde as compilações padrão reportem `libpcap.so.0.8: cannot open shared object file`.
A compilação do Windows requer o [Npcap](https://npcap.com/#download) — instale-o antes da primeira execução. Os padrões do instalador são suficientes: o NetWatch procura em `System32\Npcap`, onde o Npcap realmente coloca o `wpcap.dll`, então *Install Npcap in WinPcap API-compatible Mode* não é necessário. Sem Npcap nenhum, você recebe uma mensagem do NetWatch indicando o que está faltando, não uma caixa de erro do Windows. (Na v0.29.1 e anteriores você precisava dessa caixa de seleção — veja [#47](https://github.com/matthart1983/netwatch/issues/47).)
**A partir do código-fonte:**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release
Pré-requisitos: Rust 1.70+ e os cabeçalhos de desenvolvimento do libpcap. O mesmo se aplica a cargo install netwatch-tui.
| Plataforma | Instalação |
|---|---|
| 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 | incluído com o sistema |
| Windows | Npcap — a compilação obtém o SDK do Npcap automaticamente, ou defina NPCAP_SDK para uma cópia extraída |
Sem eles, a compilação falha na etapa de link com /usr/bin/ld: cannot find -lpcap. Se você quiser apenas executar o NetWatch em vez de compilá-lo, os binários Linux -static acima não precisam de nada disso.
Início rápido```bash
netwatch # interface stats, connections, config — no privileges needed sudo netwatch # full mode — adds live packet capture + health probes
Pronto. Mude de aba com `1`–`9`, pressione `?` para ajuda, `q` para sair. O Dashboard é útil em cinco segundos; tudo abaixo está lá para quando você precisar ir mais fundo.
> **Linux sem `sudo`:** conceda as capacidades de captura uma vez e execute como seu usuário normal —
> `sudo setcap 'cap_net_raw,cap_bpf,cap_perfmon+eip' "$(which netwatch)"`. Execute novamente após cada atualização ([detalhes](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#running-without-sudo-linux)).
### Veja a descriptografia de TLS em 60 segundos
A maneira mais rápida de entender o que é o NetWatch — observe-o ler o texto simples de uma sessão TLS 1.3 *que você* controla:```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
Os dados da aplicação descriptografados são renderizados inline. Uma falha de keylog nunca interrompe a captura — esse registro apenas permanece opaco. (SSLKEYLOGFILE é o mesmo mecanismo que o Wireshark usa; só funciona para tráfego que você controla, nunca para tráfego de terceiros ou malware.)
Lendo o texto puro de uma sessão TLS 1.3 ao vivo — descriptografada direto no terminal. Sem proxy, sem man-in-the-middle.
Veja-o detectar desvio de egress em 60 segundos
O loop da demonstração acima, em três comandos:```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
O novo destino chega com um veredito `✗ drift` e um alerta. Nada foi bloqueado — o ponto é que você foi *avisado*.
Os vereditos não são deliberadamente binários:
| | |
|---|---|
| `✓ sni` / `✓ ip` | Correspondeu a um hostname ou endereço declarado — preciso |
| `~ asn` | Correspondeu apenas por sistema autônomo — isso admite *tudo o que aquele AS opera*, o que para um hyperscaler é efetivamente ilimitado |
| `? ech` | Encrypted ClientHello: o nome está oculto por design, então isso é "não é possível julgar", não "ruim" |
| `✗ drift` | Fora da allowlist |
| `— no rule` | Este programa nunca foi declarado — nada foi verificado |
| `✗ undeclared` | Sem regra, sob `strict = true` — a política afirma ser completa, então a *ausência* é o achado |
As regras aceitam hostnames exatos, `*.wildcards`, sistemas autônomos, blocos CIDR (`10.0.0.0/8`) e portas. `strict = true` é o que transforma o linter de "me avise quando meu software declarado se comportar mal" em "me avise quando algo que eu nunca declarei começar a falar" — que é o formato que um comprometimento real tem.
## O que você obtém
Dez abas, alternadas com `1`–`9` e `0`:
| # | Aba | O que mostra |
|---|-----|---------------|
| 1 | **Dashboard** | Interfaces, gráfico de largura de banda, principais conexões, saúde do gateway/DNS, heatmap de latência. Útil em 5 segundos. |
| 2 | **Connections** | Cada socket com seu processo + PID, protocolo, estado, GeoIP e sparklines de latência. |
| 3 | **Interfaces** | IPv4/IPv6 por interface, MAC, MTU, RX/TX, erros, descartes. |
| 4 | **Packets** | Captura ao vivo com decodificação real de L7, descriptografia TLS 1.3, JA4, rastreamento de fluxo por conexão, filtros, exportação PCAP. |
| 5 | **Stats** | Divisão de protocolos por bytes + histograma de tempo de handshake TCP. |
| 6 | **Topology** | Mapa ASCII de máquina → gateway → DNS → principais hosts, com traceroute. |
| 7 | **Timeline** | Linha do tempo de conexões codificada por cor conforme o estado TCP; alertas de segurança chegam aqui. |
| 8 | **Processes** | Ranking de largura de banda por processo com RX/TX ao vivo e contagens de conexões. |
| 9 | **Insights** | *(opt-in)* envia um snapshot para um LLM local ou na nuvem para análise em linguagem simples. |
| 0 | **Egress** | Aprende com o que cada processo fala (hostname/AS/porta), promove essa linha de base para uma política com um toque de tecla e depois alerta sobre drift. Somente observação, nunca bloqueia. |
A aba Packets é onde vive a forense — decodificação profunda de protocolos, descriptografia TLS 1.3 ao vivo, caça a ameaças com JA4, filtros de exibição estilo Wireshark e captura de incidentes. **[Veja a referência completa de recursos →](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)**
### Visão Lite
Dez abas é um instrumento de operador. Quando a pergunta é apenas *"o que está usando minha rede, e minha conexão está OK?"* — uma máquina, uma sessão SSH para um Pi, uma divisão de tmux — existe o `--lite`:```bash
netwatch --lite # one screen, fits 80×24
Um ecrã, seis teclas. Throughput em tempo real, alcance e quem está a falar — expanda qualquer linha no local, filtre enquanto escreve.
Tudo num único ecrã: gráficos de throughput em tempo real, alcance de gateway/DNS/internet e os principais utilizadores por processo e host. Seis teclas — q sair, p pausar, / filtrar, ↵ expandir um utilizador, L voltar à vista completa, ? ajuda.
Prima L em qualquer uma das vistas para alternar. Ambas partilham os mesmos coletores, por isso escalar de "algo parece estranho" para a vista forense completa de dez separadores custa um toque de tecla — sem reiniciar, sem perder histórico, a captura continua a correr.
Vista densa
A outra direção: quando tem um terminal grande e quer tudo de uma vez, --view dense preenche-o com quatro caixas e sem decoração — sem barra de cabeçalho, sem barra de menu, sem barra de estado. Identidade, estado de ordenação, intervalo de páginas e todos os atalhos vivem dentro dos limites das caixas, por isso cada linha transporta dados. Precisa de 130×44 como mínimo e cresce para o que lhe der: mais largo significa mais histórico nos gráficos e espaço para hostnames completos, mais alto significa mais interfaces e mais ligações.```bash
netwatch --view dense # four boxes, needs 130×44
Esta é a tela no topo deste README. O elemento de assinatura é o **gráfico duplo espelhado**: o download cresce para cima a partir de um eixo de tempo central, o upload cresce para baixo a partir do mesmo eixo. A simetria do tráfego torna-se uma forma que reconheces sem ler um número — uma rajada de download é um penhasco acima da linha, um trabalho de backup é um penhasco abaixo dela. Ambas as metades são braille a duas amostras por célula de caractere, e cada célula é colorida pela sua **altura no gráfico** em vez de pela série a que pertence, para que vejas a gravidade de um pico antes de o medires contra o eixo.
As rampas de débito vão de frio→brilhante porque alta largura de banda é *ocupada*, não *má* — um link saturado durante um backup está a trabalhar. Apenas valores limitados onde alto é genuinamente mau — saturação de link, orçamento de latência por salto — recebem o tratamento verde→âmbar→vermelho, e os seus medidores colorem por posição ao longo da barra, para que a zona vermelha seja visível antes de lá chegares.
Abaixo do gráfico: taxas por interface com sparklines de 60 segundos, orçamentos de latência de quatro saltos (gateway, DNS, internet e o peer mais lento com quem estás realmente a falar), e a tabela de conexões com o detalhe da linha selecionada elevado para o topo da mesma caixa — sem novo ecrã, sem botão de voltar. A linha de detalhe transporta o estado TCP do kernel — `cwnd`, `ssthresh`, `mss`, `rwnd` — lido diretamente do kernel: `inet_diag` sobre netlink no Linux, o sysctl `net.inet.tcp.pcblist64` no macOS. Os dois kernels discordam sobre unidades (Linux conta segmentos, BSD conta bytes), por isso os valores do macOS são normalizados contra o MSS e a coluna significa o mesmo em ambos. O Windows lê `--` até `GetPerTcpConnectionEStats` ser ligado.
`V` alterna `full → lite → dense`, ou define-o uma vez em **Settings → View**. Abaixo de 130×44 recai na mesma grelha 80×24 que o Lite visa — que também preenche a sua área — e nunca faz scroll lateral.
## Mergulhos mais profundos
| Guia | O que contém |
|-------|--------------|
| **[Referência de funcionalidades](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)** | Cada atalho de teclado, a linguagem de filtro de exibição, lista de decodificadores de protocolo, temas e opções de configuração. |
| **[Descriptografia TLS 1.3](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#tls-13-decryption)** | Como funciona a descriptografia `SSLKEYLOGFILE`, suites de cifra suportadas e o que consegue e não consegue ler. |
| **[Caça a ameaças com JA4](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#threat-hunting-with-ja4)** | Impressão digital de clientes e pivoting entre fluxos. |
| **[Segurança & o sandbox Landlock](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#security--forensics)** | O modelo de ameaça, remoção de capacidades e a lista de permissões do sistema de ficheiros. |
| **[Linting de política de egress](https://github.com/matthart1983/netwatch/blob/main/docs/egress-linter-plan.md)** | O modelo observar → promover → avisar, a linguagem de regras, o modo `strict` e o esquema de exportação NDJSON. |
| **[Flight Recorder](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#flight-recorder)** | Armar, congelar e o conteúdo de um pacote de incidente. |
| **[AI Insights](https://github.com/matthart1983/netwatch/blob/main/docs/INSIGHTS.md)** | Análise LLM local/nuvem opcional (desligada por predefinição). |
## Como funciona```
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 |
|---|---|---|
| Conexões | lsof + PKTAP | /proc/net/tcp + kprobe eBPF |
| Pacotes | libpcap (BPF) | libpcap |
| Atribuição de processos | PKTAP | Polling de lsof/ss, com sobreposição opcional de kprobe eBPF |
Tudo degrada graciosamente: recursos que exigem privilégios elevados mostram uma mensagem clara e fazem fallback, nunca travam. As notas completas de arquitetura estão em WIKI.md.
Relacionados
Irmãos: SysWatch (sistema) e DiskWatch (disco) — mesma interface, superfície diferente. ESSH — um cliente SSH em Rust puro com a mesma estética TUI; conecta onde o NetWatch observa.
NetWatch Cloud — monitoramento de frota hospedado para os servidores onde você executa o NetWatch. Um pequeno agente Rust em cada host Linux, um dashboard em tempo real e alertas por e-mail e Slack sobre latência, perda de pacotes ou hosts offline. Grátis enquanto crescemos. O agente, o SDK e o dashboard são MIT; o backend hospedado é proprietário.
Agradecimentos
Empacotadores. O NetWatch está no homebrew-core, no nixpkgs, no AUR e no bucket principal do Scoop — e eu não empacotei nada disso. Cada um desses foi feito por alguém que achou a ferramenta útil, fez o trabalho sem ser pedido e a mantém atualizada desde então. A entrada no Scoop geralmente acompanha um release em poucas horas após a tag.
| Dominiquini | netwatch-tui no AUR, desde março de 2026 |
| kemelzaidan | netwatch-tui-bin no AUR |
| tomasrivera | netwatch no nixpkgs |
| scillidan | netwatch no bucket principal do Scoop, desde v0.15.3 |
| Mantenedores do Homebrew | por levar a fórmula ao core, e o bot que acompanhou cada release desde então |
Empacotar é um trabalho ingrato que só é notado quando quebra. Se você instala o NetWatch por um desses, agradeça a eles, não a mim.
Colaboradores. @lamchau, @fdncred e @PeteE enviaram patches. Obrigado — um pull request de um estranho é a melhor coisa que acontece a um projeto como este.
E a todos que abriram uma issue com uma reprodução real, discutiram uma decisão de design ou me disseram que a saída estava errada no seu terminal: esse é o ciclo de feedback sobre o qual isto é construído.
Contribuindo
Perguntas, ideias e relatórios de bugs são bem-vindos em GitHub Discussions e Issues. Veja CONTRIBUTING.md para convenções de código e WIKI.md para o guia de arquitetura.
Licença
MIT