netwatch v0.30.0
Diagnósticos de red en tiempo real en tu terminal. Un comando, cero configuración, visibilidad instantánea.
NetWatch
Ve lo que tu red está haciendo realmente — en vivo, en tu terminal.
Un monitor de red que lee tráfico cifrado, identifica el proceso detrás de cada conexión y detecta malware que se comunica con su servidor. Un solo binario. Cero configuración.
Todo a la vez, con cero filas de adorno — sin barra de cabecera, sin barra de menú, sin barra de estado. La descarga crece hacia arriba desde el eje de tiempo compartido, la subida crece hacia abajo desde él, así que la simetría del tráfico es una forma que reconoces antes de leer un número. El color codifica la magnitud, no la serie.
…y el instrumento por defecto de diez pestañas debajo de él, a una V de distancia y compartiendo los mismos recolectores activos — el panel de control, el programa detrás de cada socket, inspección profunda de paquetes, el mapa de red, y con qué habla cada programa.
La mayoría de las herramientas de red responden una pregunta — "¿qué está usando mi ancho de banda?" — y se detienen. NetWatch sigue adelante. Decodifica los protocolos en el cable, te dice qué programa abrió cada conexión, y vigila los patrones que significan problemas — un escaneo de puertos, malware haciendo beaconing hacia un servidor de comando, datos escapando por DNS. Cuando algo parece sospechoso, una pulsación de tecla congela un paquete de evidencia portátil que puedes adjuntar a un informe de error.
Piénsalo como un solo binario de cero configuración que hace el trabajo de un medidor de ancho de banda, la vista de triaje de Wireshark y un detector de intrusiones ligero — sin salir de la terminal.
Se adapta a la pregunta que estás haciendo — en ambas direcciones: --view dense llena una terminal grande con cuatro cajas sin adorno, y netwatch --lite es una pantalla 80×24 para "¿qué está usando mi red ahora mismo?"; la vista completa de diez pestañas está ahí cuando la respuesta es "algo que necesito investigar" — a una pulsación de tecla de distancia, compartiendo la misma captura en vivo.
Hecho para equipos de defensa (blue-teamers), respondedores de incidentes, SREs y aficionados al homelab que necesitan ver lo que está pasando ahora mismo — no analizar un archivo de captura una hora después.
840+ pruebas · sandbox Landlock (Linux) · parsea tráfico hostil de forma segura
Y la parte que ninguna otra herramienta de terminal hace en absoluto: NetWatch aprende con qué habla cada programa de la máquina, convierte esa línea base observada en una política con una pulsación de tecla, y te avisa en el momento en que un programa empieza a hablar con un destino nuevo.
Observar → promover → advertir. La línea base se convierte en una política con una pulsación de tecla; el siguiente destino nuevo llega como deriva.
Y cuando algo está mal, NetWatch no se detiene en el gráfico. Nombra el problema, clasifica las explicaciones según las comprobaciones que las discriminaron, ofrece la solución, y cierra el problema por sí mismo cuando se cumple su propia condición de éxito.
Problema → causa probable → remediación → cierre verificado. Al motor nunca se le
dice que el problema está resuelto; observa el resolvedor y cierra el problema cuando
dns.rtt_p50 < 5ms se ha mantenido durante 60s. Grabado con
netwatch --demo, que reproduce un escenario a través del motor real
y lo indica en cada fotograma.
Por qué NetWatch
- 🔓 Lee tráfico cifrado que controlas — apunta el
SSLKEYLOGFILEde un navegador o aplicación hacia NetWatch y observa el texto plano de sus sesiones TLS 1.3 decodificarse en vivo, igual que hace Wireshark. Sin proxy, sin certificados, nada en el medio. - 🛰️ Aprende con qué habla cada programa, y luego te avisa cuando cambia — NetWatch observa qué destinos alcanza cada proceso (hostname del ClientHello, sistema autónomo, puerto), y una pulsación de tecla promueve esa línea base observada a una política de salida. A partir de entonces advierte cuando un programa empieza a hablar con un destino nuevo. Esa es la frase que una regla de firewall no puede expresar:
curlsolía alcanzar soloapi.github.com, y hoy alcanzó otra cosa. Solo observación — nunca bloquea. - 🧬 Identifica el software detrás de una conexión — JA4 convierte cada handshake TLS/QUIC en una huella estable, así puedes reconocer un cliente específico — o una pieza específica de malware — aunque el tráfico esté cifrado, igual que reconocerías un navegador por su user-agent. Pivota sobre una huella para encontrar todos los demás flujos del mismo software.
- 🚨 Detecta malware que se comunica con su servidor — detección integrada de beaconing C2 (check-ins regulares con baja jitter), escaneos de puertos y tunelización DNS que se ejecuta en segundo plano con cero configuración. Una alerta crítica congela automáticamente la grabadora para que la evidencia ya esté guardada cuando mires.
- ⚙️ Identifica el proceso detrás de cada conexión — mapea cada socket al programa que lo abrió desde
ss/lsof, con una sonda eBPF kprobe opcional a nivel de kernel (Linux, la característicaebpf) que también captura flujos de corta duración que el polling puede pasar por alto. Funciona en todas partes; la kprobe es una mejora, no un requisito. - 📡 Decodifica los protocolos, no solo los puertos — parseo real de L7 de TLS, QUIC, HTTP y DNS (además de un sniff de banner/versión SSH) y una docena más, con seguimiento de flujo por conexión y temporización de handshake — así ves
api.github.comy la huella JA4, no solo "puerto 443." - 🎥 Congela la evidencia — arma una grabadora rotatoria y congela cualquier incidente en un paquete portátil: los paquetes más las conexiones, DNS, salud y alertas que los explican. Hecho para informes de error y post-mortems.
- 🛡️ Seguro por diseño — después de la configuración, NetWatch abandona sus privilegios y se encierra en una lista blanca de sistema de archivos Landlock (Linux). Una herramienta que parsea tráfico hostil no puede leer tus claves SSH, perfiles de navegador o
/etc/shadow. - 🪟 Se reduce a una pantalla —
--literesponde "¿qué está usando mi red, y está bien mi conexión?" en una sola pantalla 80×24 con seis teclas, así que cabe en una sesión SSH a una Pi o en una división de tmux. Una pulsación de tecla escala a la vista forense completa con los recolectores ya activos.
Sin archivos de configuración. Sin instalación. Sin banderas requeridas.
Instalación```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
O descarga un binario precompilado desde [Releases](https://github.com/matthart1983/netwatch/releases/latest).
**Windows necesita [Npcap](https://npcap.com/#download) instalado** — los valores predeterminados del instalador son suficientes, y sin él NetWatch se cierra al iniciar indicándolo. **Compilar desde el código fuente** (`cargo install`, `paru -S netwatch-tui`) requiere los encabezados de desarrollo de libpcap: `libpcap-dev` en Debian/Ubuntu y Alpine, `libpcap-devel` en Fedora/RHEL, `libpcap` en Arch. Si faltan, aparece `cannot find -lpcap` en el momento del enlazado. macOS incluye libpcap; los binarios `-static` de Linux que se muestran abajo lo incluyen y no necesitan nada instalado.
Los paquetes de Nix, Arch y Scoop son mantenidos por empaquetadores de la comunidad — gracias. Reporta los problemas de empaquetado con ellos; reporta los errores de netwatch aquí. Si un paquete se queda atrás respecto a una versión, la [página de Repology](https://repology.org/project/netwatch-tui/versions) lo muestra.
<details>
<summary><strong>Todas las plataformas y compilación desde el código fuente</strong></summary>
| Plataforma | Descarga |
|----------|----------|
| 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/cualquier distro) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, estático — Arch/Fedora/Alpine/cualquier 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) |
Las compilaciones `-static` de Linux incluyen libpcap y no tienen dependencias en tiempo de ejecución — úsalas en Arch, Fedora, Alpine o cualquier distro donde las compilaciones predeterminadas reporten `libpcap.so.0.8: cannot open shared object file`.
La compilación de Windows requiere [Npcap](https://npcap.com/#download) — instálalo antes de la primera ejecución. Los valores predeterminados del instalador son suficientes: NetWatch busca en `System32\Npcap`, donde Npcap realmente coloca `wpcap.dll`, por lo que *Install Npcap in WinPcap API-compatible Mode* no es necesario. Sin Npcap en absoluto recibes un mensaje de NetWatch que indica qué falta, no un cuadro de error de Windows. (En v0.29.1 y anteriores sí necesitabas esa casilla — ver [#47](https://github.com/matthart1983/netwatch/issues/47).)
**Desde el código fuente:**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release
Requisitos previos: Rust 1.70+ y los encabezados de desarrollo de libpcap. Lo mismo aplica para cargo install netwatch-tui.
| Plataforma | Instalación |
|---|---|
| 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 | incluido con el sistema |
| Windows | Npcap — la compilación obtiene el SDK de Npcap automáticamente, o establece NPCAP_SDK a una copia extraída |
Sin ellos, la compilación falla en el enlace con /usr/bin/ld: cannot find -lpcap. Si solo quieres ejecutar NetWatch en lugar de compilarlo, los binarios -static de Linux anteriores no necesitan nada de esto.
Inicio rápido```bash
netwatch # interface stats, connections, config — no privileges needed sudo netwatch # full mode — adds live packet capture + health probes
Eso es todo. Cambia de pestaña con `1`–`9`, pulsa `?` para obtener ayuda, `q` para salir. El Dashboard es útil en cinco segundos; todo lo demás está ahí para cuando necesites profundizar.
> **Linux sin `sudo`:** concede las capacidades de captura una vez y ejecuta como tu usuario normal —
> `sudo setcap 'cap_net_raw,cap_bpf,cap_perfmon+eip' "$(which netwatch)"`. Vuelve a ejecutarlo tras cada actualización ([detalles](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#running-without-sudo-linux)).
### Ver cómo descifra TLS en 60 segundos
La forma más rápida de entender qué es NetWatch — observa cómo lee el texto plano de una sesión TLS 1.3 *que tú* controlas:```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
Los datos de la aplicación descifrados se muestran en línea. Una pulsación de tecla que no se registra nunca rompe la captura — ese registro simplemente permanece opaco. (SSLKEYLOGFILE es el mismo mecanismo que usa Wireshark; solo funciona con tráfico que tú controlas, nunca con tráfico de terceros o malware).
Leyendo el texto plano de una sesión TLS 1.3 en vivo — descifrado directamente en la terminal. Sin proxy, sin intermediario.
Compruébalo detectando la deriva de salida en 60 segundos
El bucle de la demo anterior, en tres 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
El nuevo destino aterriza con un veredicto `✗ drift` y una alerta. No se bloqueó nada — el punto es que se te *informó*.
Los veredictos no son deliberadamente binarios:
| | |
|---|---|
| `✓ sni` / `✓ ip` | Coincidió con un hostname o dirección declarado — preciso |
| `~ asn` | Coincidió solo por sistema autónomo — eso admite *todo lo que opera ese AS*, que para un hyperscaler es efectivamente ilimitado |
| `? ech` | Encrypted ClientHello: el nombre está oculto por diseño, así que esto es "no se puede juzgar", no "malo" |
| `✗ drift` | Fuera de la allowlist |
| `— no rule` | Este programa nunca fue declarado — no se comprobó nada |
| `✗ undeclared` | Sin regla, bajo `strict = true` — la política afirma ser completa, así que la *ausencia* es el hallazgo |
Las reglas aceptan hostnames exactos, `*.wildcards`, sistemas autónomos, bloques CIDR (`10.0.0.0/8`) y puertos. `strict = true` es lo que convierte al linter de "dime cuando mi software declarado se comporta mal" en "dime cuando algo que nunca declaré empieza a hablar" — que es la forma que tiene un compromiso real.
## Lo que obtienes
Diez pestañas, cambiadas con `1`–`9` y `0`:
| # | Pestaña | Qué muestra |
|---|---------|-------------|
| 1 | **Dashboard** | Interfaces, gráfico de ancho de banda, conexiones principales, salud de gateway/DNS, mapa de calor de latencia. Útil en 5 segundos. |
| 2 | **Connections** | Cada socket con su proceso + PID, protocolo, estado, GeoIP y sparklines de latencia. |
| 3 | **Interfaces** | IPv4/IPv6 por interfaz, MAC, MTU, RX/TX, errores, descartes. |
| 4 | **Packets** | Captura en vivo con decodificación L7 real, descifrado TLS 1.3, JA4, seguimiento de flujos por conexión, filtros, exportación PCAP. |
| 5 | **Stats** | Desglose de protocolos por bytes + histograma de tiempos de handshake TCP. |
| 6 | **Topology** | Mapa ASCII de máquina → gateway → DNS → hosts principales, con traceroute. |
| 7 | **Timeline** | Línea de tiempo de conexiones codificada por color según estado TCP; las alertas de seguridad aterrizan aquí. |
| 8 | **Processes** | Ranking de ancho de banda por proceso con RX/TX en vivo y conteos de conexiones. |
| 9 | **Diagnose** | Qué está mal, por qué y qué hacer al respecto. Detección basada en línea base sobre un catálogo de 25 reglas, causas clasificadas con las comprobaciones que las discriminaron, correcciones reversibles vinculadas a teclas y un `report.md` / `report.json` generado desde los mismos objetos que renderiza la pantalla. *(Una narrativa de IA opcional aparece aquí como comentario — nunca como fuente de hechos.)* |
| 0 | **Egress** | Aprende con qué habla cada proceso (hostname/AS/puerto), promueve esa línea base a una política con una pulsación de tecla y luego advierte sobre drift. Solo observación, nunca bloquea. |
La pestaña Packets es donde vive la forensia — decodificación profunda de protocolos, descifrado TLS 1.3 en vivo, caza de amenazas JA4, filtros de visualización estilo Wireshark y captura de incidentes. **[Consulta la referencia completa de funciones →](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)**
### Vista Lite
Diez pestañas son un instrumento de operador. Cuando la pregunta es solo *"¿qué está usando mi red y mi conexión está bien?"* — una máquina, una sesión SSH a una Pi, una división de tmux — existe `--lite`:```bash
netwatch --lite # one screen, fits 80×24
Una pantalla, seis teclas. Rendimiento en vivo, alcance y quién está hablando: expande cualquier fila en su lugar, filtra mientras escribes.
Todo en una sola pantalla: gráficos de rendimiento en vivo, alcance de puerta de enlace/DNS/internet y los principales interlocutores por proceso y host. Seis teclas — q salir, p pausar, / filtrar, ↵ expandir un interlocutor, L volver a la vista completa, ? ayuda.
Pulsa L desde cualquiera de las dos vistas para cambiar. Ambas comparten los mismos recolectores, así que pasar de "algo parece raro" a la vista forense completa de diez pestañas cuesta una sola pulsación de tecla — sin reiniciar, sin perder historial, la captura sigue en ejecución.
Vista densa
La otra dirección: cuando tienes un terminal grande y quieres todo a la vez, --view dense lo llena con cuatro cajas y sin adornos — sin barra de cabecera, sin barra de menú, sin barra de estado. Identidad, estado de ordenación, rango de páginas y cada combinación de teclas viven dentro de los bordes de las cajas, así que cada fila lleva datos. Necesita 130×44 como mínimo y crece hasta ocupar lo que le des: más ancho significa más historial en los gráficos y espacio para nombres de host completos, más alto significa más interfaces y más conexiones.```bash
netwatch --view dense # four boxes, needs 130×44
Esa es la pantalla que aparece en la parte superior de este README. El elemento distintivo es el **grafo dual espejado**: la descarga crece hacia arriba desde un eje de tiempo central, y la subida crece hacia abajo desde el mismo eje. La simetría del tráfico se convierte en una forma que reconoces sin leer un número — una ráfaga de descarga es un acantilado por encima de la línea, un trabajo de copia de seguridad es un acantilado por debajo. Ambas mitades son braille a dos muestras por celda de carácter, y cada celda se colorea por su **altura en el grafo** en lugar de por la serie a la que pertenece, de modo que ves la gravedad de un pico antes de medirlo contra el eje.
Las rampas de rendimiento van de frío a brillante porque el ancho de banda alto es *ocupado*, no *malo* — un enlace saturado durante una copia de seguridad está trabajando. Solo los valores acotados donde lo alto realmente es malo — saturación del enlace, presupuesto de latencia por salto — reciben el tratamiento verde→ámbar→rojo, y sus medidores se colorean por la posición a lo largo de la barra, de modo que la zona roja es visible antes de alcanzarla.
Debajo del grafo: tasas por interfaz con sparklines de 60 segundos, presupuestos de latencia de cuatro saltos (puerta de enlace, DNS, internet y el par más lento con el que realmente estás hablando), y la tabla de conexiones con el detalle de la fila seleccionada elevado a la parte superior de la misma caja — sin nueva pantalla, sin botón de retroceso. La fila de detalle lleva el estado TCP del kernel — `cwnd`, `ssthresh`, `mss`, `rwnd` — leído directamente del kernel: `inet_diag` sobre netlink en Linux, el sysctl `net.inet.tcp.pcblist64` en macOS. Los dos kernels discrepan sobre las unidades (Linux cuenta segmentos, BSD cuenta bytes), por lo que los valores de macOS se normalizan contra el MSS y la columna significa lo mismo en ambos. Windows muestra `--` hasta que se conecte `GetPerTcpConnectionEStats`.
`V` alterna `full → lite → dense`, o configúralo una vez en **Settings → View**. Por debajo de 130×44 vuelve a la misma cuadrícula de 80×24 que Lite busca — que también llena su área — y nunca se desplaza lateralmente.
## Inmersiones más profundas
| Guía | Qué contiene |
|-------|--------------|
| **[Referencia de funciones](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)** | Cada combinación de teclas, el lenguaje de filtros de visualización, la lista de decodificadores de protocolo, los temas y las opciones de configuración. |
| **[Configuración](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#configuration)** | La ubicación del archivo de configuración y cada clave que contiene, con valores predeterminados — incluidos `graph_style` / `graph_fade` para los gráficos braille estilo btop. |
| **[Descifrado TLS 1.3](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#tls-13-decryption)** | Cómo funciona el descifrado con `SSLKEYLOGFILE`, las suites de cifrado compatibles y qué puede y qué no puede leer. |
| **[Caza de amenazas con JA4](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#threat-hunting-with-ja4)** | Huella digital de clientes y pivoteo entre flujos. |
| **[Seguridad y el sandbox Landlock](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#security--forensics)** | El modelo de amenazas, la eliminación de capacidades y la lista de permitidos del sistema de archivos. |
| **[Linting de políticas de salida](https://github.com/matthart1983/netwatch/blob/main/docs/egress-linter-plan.md)** | El modelo observar → promover → advertir, el lenguaje de reglas, el modo `strict` y el esquema de exportación NDJSON. |
| **[Flight Recorder](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#flight-recorder)** | Armado, congelación y el contenido de un paquete de incidentes. |
| **[AI Insights](https://github.com/matthart1983/netwatch/blob/main/docs/INSIGHTS.md)** | Análisis LLM local/en la nube opcional (desactivado por defecto). |
## Cómo 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 |
|---|---|---|
| Conexiones | lsof + PKTAP | /proc/net/tcp + sonda eBPF kprobe |
| Paquetes | libpcap (BPF) | libpcap |
| Atribución de procesos | PKTAP | Sondeo de lsof/ss, con superposición opcional de sonda eBPF kprobe |
Todo se degrada con elegancia: las funciones que requieren privilegios elevados muestran un mensaje claro y recurren a alternativas, nunca fallan. Las notas completas de arquitectura están en WIKI.md.
Relacionados
Hermanos: SysWatch (sistema) y DiskWatch (disco) — mismo estilo, diferente superficie. ESSH — un cliente SSH en Rust puro con la misma estética TUI; conecta donde NetWatch observa.
NetWatch Cloud — monitoreo de flotas alojado para los servidores donde ejecutas NetWatch. Un pequeño agente Rust en cada host Linux, un panel en tiempo real y alertas por correo electrónico y Slack sobre latencia, pérdida de paquetes u hosts que se desconectan. Gratis mientras crecemos. El agente, el SDK y el panel son MIT; el backend alojado es propietario.
Agradecimientos
Empaquetadores. NetWatch está en homebrew-core, nixpkgs, el AUR y el bucket principal de Scoop — y yo no empaqueté nada de eso. Cada uno de esos paquetes fue hecho por alguien que encontró útil la herramienta, hizo el trabajo sin que se lo pidieran y lo ha mantenido actualizado desde entonces. La entrada de Scoop normalmente ha seguido a un lanzamiento en cuestión de horas tras la etiqueta.
| Dominiquini | netwatch-tui en el AUR, desde marzo de 2026 |
| kemelzaidan | netwatch-tui-bin en el AUR |
| tomasrivera | netwatch en nixpkgs |
| scillidan | netwatch en el bucket principal de Scoop, desde v0.15.3 |
| Mantenedores de Homebrew | por llevar la fórmula a core, y el bot que ha seguido cada lanzamiento desde entonces |
Empaquetar es un trabajo ingrato que solo se nota cuando se rompe. Si instalas NetWatch a través de uno de estos, a ellos debes agradecérselo, no a mí.
Colaboradores. @lamchau, @fdncred y @PeteE han enviado parches. Gracias — una solicitud de extracción de un desconocido es lo mejor que le puede pasar a un proyecto como este.
Y a todos los que han abierto un issue con una reproducción real, han debatido una decisión de diseño o me han dicho que la salida era incorrecta en su terminal: ese es el ciclo de retroalimentación sobre el que se construye esto.
Contribuir
Preguntas, ideas e informes de errores son bienvenidos en GitHub Discussions e Issues. Consulta CONTRIBUTING.md para las convenciones de código y WIKI.md para la guía de arquitectura.
Licencia
MIT