Red

Alt-N o Comando → Red muestra lo que hace este equipo en la red: los puertos abiertos y quién puede llegar a ellos, los procesos que se comunican y a qué velocidad, cada conexión y las interfaces de red. Lo proporciona el complemento Sistema incluido, igual que el monitor de actividad. La lista ocupa el panel activo, y el otro panel muestra en detalle la fila seleccionada, con gráficos de los últimos 60 segundos. Borg toma una muestra por segundo mientras la pantalla está abierta y se detiene al cerrarla. Las velocidades aparecen a partir de la segunda muestra, y cada una es la media de los últimos 3 segundos, así que una lista ordenada por tráfico se queda quieta el tiempo suficiente para leerla.

Pulsa de 1 a 4, o haz clic en una pestaña, para cambiar de página:

• 1 Puertos lista cada puerto en el que escucha un proceso, ordenados por número. Alcance indica quién puede conectarse: Todas las redes para un puerto abierto en todas las direcciones, la dirección para un puerto vinculado a direcciones concretas, y Este equipo para un puerto al que solo llegan los programas de este equipo. Los puertos abiertos a todas las redes se destacan, porque otras máquinas pueden encontrarlos. Con. cuenta las conexiones que entraron por el puerto, y los detalles las listan con su tráfico.
• 2 Procesos lista los procesos que usan la red, los más activos primero, con sus velocidades de descarga y subida y su número de conexiones. Los detalles añaden lo que el proceso ha transferido desde que se abrió la pantalla y cada conexión que mantiene.
• 3 Conexiones lista cada conexión con su proceso, el otro extremo y sus velocidades. Un panel ancho añade el protocolo y el estado TCP. Los detalles muestran ambos extremos, el nombre del host, el servicio y los bytes recibidos y enviados.
• 4 Interfaces lista las interfaces de red con su tipo (Wi-Fi, Ethernet, Loopback, Túnel, Puente o Virtual), su primera dirección y sus velocidades. ● marca una interfaz activa. Los detalles añaden todas sus direcciones, la MTU, los bytes y paquetes que la interfaz ha recibido y enviado hasta ahora, y sus errores.

El pie muestra la velocidad total de descarga y subida del equipo en todas las interfaces salvo la de loopback. Borg busca en segundo plano los nombres de las direcciones remotas y muestra el nombre en lugar de la dirección en cuanto lo conoce.

Tecla	Acción
1 / 2 / 3 / 4	Mostrar Puertos / Procesos / Conexiones / Interfaces
/	Filtrar las filas; ↑↓ siguen moviendo, Enter conserva el filtro, Esc lo borra
T / N / P / C	Ordenar por tráfico / nombre / puerto / conexiones; pulsa de nuevo para invertir
Enter	Mostrar el proceso de la fila seleccionada en el monitor de actividad
K	Mostrar el proceso con Señal o prioridad abierto
R	Capturar el tráfico de la fila seleccionada o detener la captura en curso
Ctrl-C	Copiar la dirección del puerto, el PID, el otro extremo o la dirección de la interfaz
Tab	Alternar entre la lista y los detalles
Space	Pausar o reanudar el muestreo
Alt-W	Maximizar el panel con el foco
Esc	Volver a la lista y después cerrar la pantalla o regresar al monitor de actividad

P ordena las páginas que tienen puerto, y C las que cuentan conexiones. Haz clic en el encabezado de una columna para ordenar por ella, y doble clic en una fila para mostrar su proceso. Enter en una fila sin proceso pasa a los detalles. Una fila indica un proceso y ningún archivo de programa, así que Alt-O aquí te dice que pulses Enter y después Alt-O en el monitor de actividad. El monitor de actividad que abren Enter y K tiene el proceso seleccionado, así que su memoria, sus señales y su prioridad quedan a una tecla (consulta Señales y prioridad). Esc allí te devuelve a la pantalla de red, a la fila donde estabas y con sus gráficos.

También funciona al revés. Alt-N en el monitor de actividad abre esta pantalla en la fila del proceso seleccionado de 2 Procesos, con su tráfico y sus conexiones en los detalles, y Esc vuelve al monitor. Si el proceso no tiene conexiones ni puertos abiertos, un aviso te lo dice.

Filtrar

El filtro conserva las filas que coinciden con todas las palabras que escribes. Una palabra suelta coincide con el proceso, el PID, el puerto, el servicio, la dirección, el nombre del host, el estado, el protocolo o una etiqueta que muestra la fila, así que postgres, 5432, https y example.com funcionan. Una palabra con nombre de campo busca solo en ese campo:

Palabra	Conserva
port:443, port:ssh	Filas con ese número de puerto o servicio
proc:node, process:node	Filas cuyo nombre de proceso contiene el texto
pid:4100	Filas de ese PID
host:example	Filas cuya dirección o nombre de host contiene el texto; una dirección completa conserva solo esa dirección
state:listen, state:time	Filas TCP en un estado que contiene el texto
proto:udp, proto:tcp	Filas de ese protocolo
if:en0, interface:en0	Interfaces cuyo nombre contiene el texto

Pon ! delante de una palabra para descartar las filas que coinciden con ella: !state:time_wait oculta las conexiones que se están cerrando, y !proc:browser oculta un programa. El filtro se aplica a todas las páginas y, mientras escribes, indica cuántas filas de la página conserva.

Capturar tráfico

Pulsa R para grabar los paquetes de la fila seleccionada con tcpdump, que macOS trae de serie y Linux instala con el paquete tcpdump. El diálogo Capturar tráfico parte de esa fila:

• Tráfico es lo que guarda tcpdump. En 1 Puertos es el puerto y las conexiones que entraron por él, y en 3 Conexiones esa conexión en ambos sentidos. En 2 Procesos es Todo el tráfico, mostrado para ese proceso: tcpdump no puede elegir paquetes por proceso, así que Borg graba toda la interfaz y abre el resultado en el proceso. Todo el tráfico de la interfaz está siempre como segunda opción.
• Interfaz empieza en la que tiene la dirección de la fila o, si no la hay, en la más activa.
• Duración es de 5, 10, 30 o 60 segundos, o Hasta detenerla.
• Guardar empieza en Inicio de cada conexión, hasta 1 MiB: los paquetes de cada conversación se guardan completos hasta que llevan 1 MiB de datos, y a partir de ahí Borg guarda solo sus cabeceras. Las peticiones cortas quedan completas, y una descarga larga o una videollamada no llenan el archivo. Paquetes completos guarda todo, y Cabeceras, los primeros 128 bytes de cada paquete guarda el principio de cada paquete para los archivos más pequeños. Borg recorta los paquetes a medida que escribe el archivo, que sigue siendo un pcap o pcapng normal, y cada paquete recortado conserva su longitud en la red.
• Claves TLS es No, Definir SSLKEYLOGFILE en el shell de Borg para guardar las claves TLS de los programas que inicies mientras la captura se ejecuta, o Pasar el HTTPS por el proxy de Borg con una CA temporal para programas que no escriben sus claves (consulta Descifrar TLS).
• Ejecutar como aparece donde Borg puede pedir al sistema la contraseña de un administrador. Tu usuario ejecuta tcpdump como tú, y Administrador lo ejecuta como root después de que escribas tu contraseña en el diálogo del sistema. En macOS la opción se llama Administrador, con el proceso de cada paquete: tcpdump escucha entonces a través de pktap de macOS, que marca cada paquete con el proceso que lo envió o recibió.

↑↓ eligen un campo, ←→ o Space lo cambian, Enter inicia la captura y Esc la cancela. Con el ratón, haz clic en un campo para elegirlo y otra vez para cambiarlo. Mientras la captura se ejecuta, el pie cuenta sus paquetes, sus bytes y los segundos que quedan, y R la detiene antes de tiempo. Una captura también se detiene a los 200.000 paquetes o 256 MiB, y cuando se llena el disco, con lo que ya guardó. Para dejar espacio al resto del sistema, define keep-free-mib en la sección [network] del archivo de configuración: entonces la captura no empieza cuando al disco de la carpeta le quedan menos de esos MiB libres, y se detiene cuando el espacio libre baja de ahí. Pasados sus primeros 3 segundos, el pie dice cuánto falta para que el primero de estos límites detenga la captura al ritmo actual, como unos 30 s hasta 256 MiB o unos 2 min hasta llenar el disco, cuando eso llega antes del final de la propia captura y dentro de la hora. Cuando un límite detuvo la captura, un aviso dice cuál. Si cierras la pantalla antes, la captura se detiene y un aviso dice dónde la guardó Borg.

Borg guarda cada captura como capture-<date>-<time>.pcap en la carpeta del panel que cubre la pantalla de red, legible solo por ti, para que Wireshark y otras herramientas puedan abrirla después. Una captura que marca cada paquete con su proceso se guarda como capture-<date>-<time>.pcapng, el formato que puede llevar esas marcas. Lo mismo pasa con una captura que guardó claves TLS, una vez que Borg las pone dentro. Una captura contiene todo lo que llevaban los paquetes, así que guárdala con el mismo cuidado que esos datos. Cada captura queda también en la lista de Archivos de Borg.

Un agente conectado mediante borg mcp también puede pedir una captura, que también espera tu aprobación (consulta Qué puede hacer el agente).

Cuando la captura termina, el visor de tráfico ocupa el lugar de las páginas en vivo, con una página para cada forma de mirarla:

• 1 Procesos muestra cada proceso con los hosts con los que habló, sus paquetes y sus bytes. Cuando los paquetes llevan su proceso, cada paquete pertenece al proceso que lo envió o recibió. Así, hasta un proceso que duró menos de un segundo recibe su nombre, y el filtro de un proceso conserva exactamente sus paquetes. Si no, una conversación pertenece al proceso cuyo socket la tenía durante la captura, y el resto va a Proceso desconocido.
• 2 Hosts muestra las demás máquinas con los protocolos vistos. Los nombres salen de las respuestas DNS de la propia captura y de los nombres de servidor que pidieron las conexiones TLS, así que la mayoría de los hosts tienen uno.
• 3 Conexiones muestra cada conversación con su proceso, el otro extremo, el protocolo, los paquetes y los bytes. Los detalles muestran ambos extremos, el nombre del servidor, el servicio, los bytes enviados y recibidos, y el flujo de la conversación: lo que envió cada lado, en orden y con los bytes retransmitidos contados una sola vez, en un volcado hexadecimal con los bytes que se imprimen como texto al lado. El flujo se divide en turnos, cada uno con una flecha que indica su sentido, los bytes que contiene y cuándo llegó. Cuando a la captura le faltan bytes antes de un turno, ese turno dice cuántos faltan. Cuando la captura guardó solo el principio de la conexión, el encabezado del flujo dice cuántos bytes dejó fuera después, según las cabeceras de los paquetes. ] y [ saltan al turno siguiente y al anterior. F3 muestra el flujo entero como filas hexadecimales en el visor, con sus turnos uno tras otro, para recorrerlo y buscar en él. Enter muestra los paquetes de la conversación uno a uno. Cuando Borg tiene las claves TLS de la conexión, el flujo muestra lo que llevaban sus registros cifrados (consulta Descifrar TLS).
• 4 Paquetes muestra todos los paquetes en orden con su tiempo desde el inicio, protocolo, longitud y un resumen como ClientHello example.com o A example.com → 203.0.113.10. Los detalles muestran sus capas (Ethernet, IP, TCP o UDP, y DNS, TLS o HTTP cuando Borg los lee) y sus bytes en un volcado hexadecimal. Un volcado dispone sus bytes como las filas hexadecimales del visor, con tantos en cada línea como quepan en el panel. F3 muestra los bytes del paquete como filas hexadecimales en el visor.

Tecla	Acción
1 / 2 / 3 / 4	Mostrar Procesos / Hosts / Conexiones / Paquetes
Enter	Bajar un nivel: de un proceso o host a sus conexiones, de una conexión a sus paquetes, de un paquete a sus detalles
] / [	En los detalles de una conexión, saltar al turno siguiente o anterior del flujo
/	Filtrar las filas, como en las páginas en vivo
Ctrl-C	Copiar el PID, la dirección, el otro extremo o los bytes del paquete en hex
F3	Mostrar el flujo de la conexión o los bytes del paquete como filas hexadecimales en el visor
Tab	Pasar entre la lista y los detalles, donde ↑↓ desplazan
Esc	Volver a la lista, luego subir un nivel, luego borrar el filtro y luego volver a la pantalla en vivo

El filtro acepta las mismas palabras que las páginas en vivo, y proto: además coincide con lo que Borg reconoció en los paquetes: proto:dns, proto:tls, proto:http y proto:quic. Un filtro se aplica a todas las páginas, y Enter pone uno para bajar un nivel, por eso Esc puede volver atrás.

F3 sobre un archivo .pcap, .pcapng o .cap en un panel lo abre en el mismo visor, empezando por 2 Hosts. Un archivo grabado en otro sitio no tiene sockets con los que emparejarse, así que sus conversaciones muestran Proceso desconocido. Un archivo .pcapng cuyos paquetes llevan su proceso, como los que guardan Borg y tcpdump -i pktap en macOS, sigue nombrando cada proceso. El visor lee archivos de hasta 256 MiB y sus primeros 200.000 paquetes.

Cuando Borg no encuentra tcpdump, la captura ofrece instalarlo. El diálogo Instalar tcpdump muestra el comando exacto del gestor de paquetes que encontró Borg: apt-get, dnf, pacman, zypper o apk en Linux, o el brew de Homebrew en macOS y en un Linux sin ninguno de ellos. Los gestores de paquetes del sistema se ejecutan con sudo, o con doas donde no hay sudo, salvo que Borg se ejecute como root. Enter escribe el comando en el shell de Borg, donde ves lo que hace y escribes tú mismo la contraseña, y Esc cancela. Cuando el comando termina, un aviso dice si funcionó, y Ctrl-O muestra su salida. Borg vuelve a buscar tcpdump cada vez que empieza una captura, en PATH y en /usr/sbin, /usr/bin, /sbin, /bin y las carpetas sbin de Homebrew, así que R funciona en cuanto termina la instalación. Sin un gestor de paquetes que Borg conozca, la captura termina con Para capturar hace falta tcpdump, y Borg no lo encuentra.

tcpdump necesita acceso al dispositivo de captura. Borg lo ejecuta como tú, así que date acceso una vez:

• En macOS, al principio solo root puede abrir los dispositivos /dev/bpf. Instala una vez Wireshark con su componente ChmodBPF: entrega los dispositivos a un grupo access_bpf y te añade a él, y a partir de entonces puedes capturar en todas las interfaces.
• En Linux, da una vez a tcpdump las capacidades de captura con sudo setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump. Algunas distribuciones permiten capturar a los miembros de un grupo pcap o wireshark.

Sin acceso, Borg pregunta Capturar como administrador donde el sistema puede pedir tu contraseña: en macOS en el diálogo de contraseña del propio sistema, y en Linux a través de pkexec, cuyo diálogo viene de tu escritorio. Elige Sí y escribe la contraseña en el diálogo del sistema, que Borg nunca ve. Mientras el diálogo está abierto, el pie dice Esperando tu contraseña para capturar en y el nombre de la interfaz. Después Borg ejecuta una copia de sí mismo como root, que comprueba qué se le pidió capturar e inicia tcpdump desde las carpetas del propio sistema. Los paquetes vuelven a Borg, que guarda el archivo como tú. R y la duración detienen la captura como antes, y si Borg termina, la captura se detiene con él. Si cancelas el diálogo del sistema, la captura termina sin aviso. Para saltarte la pregunta, elige Administrador en Ejecutar como antes de empezar.

En Linux sin pkexec, Borg usa sudo cuando puede ejecutar tcpdump sin contraseña. Por SSH no hay escritorio que muestre el diálogo, así que la captura termina con Borg no puede capturar como administrador y el motivo del sistema. Cuando el propio Borg se ejecuta como root, nunca pregunta, y en macOS sus capturas siempre llevan el proceso de cada paquete. Donde Borg no puede preguntar, la captura termina con No tienes permiso para capturar en y el nombre de la interfaz.

Descifrar TLS

Cuando Borg tiene las claves de una conexión TLS, su flujo en 3 Conexiones muestra lo que llevaban los registros cifrados, como una petición HTTP y su respuesta, y el encabezado del flujo termina en descifrado.

Las claves salen de un archivo de claves TLS, el que escriben los navegadores, curl, Python y muchos otros programas cuando la variable de entorno SSLKEYLOGFILE nombra uno. Entonces nada se interpone entre el programa y el servidor, así que esto también funciona con programas que fijan sus certificados. Para los programas que nunca escriben un archivo de claves, Borg puede ponerse él mismo en medio (consulta Por el proxy de Borg).

Para guardarlas con una captura, pon Claves TLS en Definir SSLKEYLOGFILE en el shell de Borg en el diálogo Capturar tráfico. Cuando la captura empieza, Borg crea capture-<date>-<time>.keylog junto a la captura, legible solo por ti, y escribe una línea como esta en el prompt de su shell, donde la ves ejecutarse y la encuentras después en el historial del shell:

export SSLKEYLOGFILE='/home/me/projects/capture-20260101-120000.keylog'

En fish la línea empieza con set -gx. Después Borg vuelve a la pantalla de red, donde el pie dice Claves TLS mientras la captura se ejecuta.

Ahora inicia el programa desde la línea de comandos de Borg, o pulsa Ctrl-O e inícialo en el shell. Hereda la variable y escribe sus claves en el archivo. Para un programa en otra terminal, pulsa L en la pantalla de red para copiar SSLKEYLOGFILE='…' con la ruta del archivo de claves, pégalo allí y escribe el programa detrás. Un programa que ya estaba en marcha conserva el ajuste con el que empezó, así que ciérralo e inícialo de nuevo. Eso vale sobre todo para los navegadores, que pasan un segundo inicio a la ventana que ya está abierta. En macOS, open inicia las aplicaciones sin las variables del shell, así que inicia el propio programa de la aplicación, como /Applications/Firefox.app/Contents/MacOS/firefox.

Si el shell de Borg está ocupado, o la línea de comandos pertenece a un contenedor o a otra máquina, Borg no escribe nada y un aviso lo dice. L sigue copiando la línea.

Cuando la captura termina, Borg escribe unset SSLKEYLOGFILE en el prompt (set -e SSLKEYLOGFILE en fish), o restablece el valor con el que arrancó el propio Borg, y un aviso nombra la línea. Si un programa que iniciaste sigue ejecutándose en el shell, la línea espera a que termine. Luego Borg pone las claves de las conexiones de la captura dentro de la captura como un bloque de secretos de descifrado, así que un .pcap pasa a ser un .pcapng con el mismo nombre, que Wireshark abre ya descifrado. El archivo de claves se queda a su lado, porque los programas iniciados durante la captura siguen escribiendo en él hasta que terminan. Las capturas que pide un agente no guardan claves.

Leen SSLKEYLOGFILE Firefox, Chrome y otros navegadores basados en Chromium, la mayoría de las compilaciones de curl y los programas de Python que usan el contexto predeterminado del módulo ssl. Otros necesitan su propia opción:

• Node.js escribe sus claves con --tls-keylog, así que inícialo como node --tls-keylog="$SSLKEYLOGFILE" app.js.
• Los programas de Go las escriben solo cuando el programa define KeyLogWriter en su configuración TLS.
• Los programas de Rust con rustls las escriben solo cuando usan su KeyLogFile.
• Java necesita un agente que se enganche a su código TLS.

Safari y otras aplicaciones creadas sobre las bibliotecas TLS propias de Apple nunca escriben un archivo de claves, y su tráfico sigue cifrado.

Por el proxy de Borg

Pon Claves TLS en Pasar el HTTPS por el proxy de Borg con una CA temporal para leer el HTTPS de programas que nunca escriben un archivo de claves, como programas en Go y Rust o un cliente que no puedes cambiar. Cuando empieza la captura, Borg ejecuta un proxy en 127.0.0.1 y crea una autoridad de certificación (CA) solo para esta captura. La clave de la CA vive en la memoria de Borg y desaparece cuando termina la captura. Borg escribe una línea en el prompt de su shell que envía el HTTPS por el proxy y hace que los programas confíen en la CA:

export HTTPS_PROXY='http://127.0.0.1:54321' https_proxy='http://127.0.0.1:54321' SSL_CERT_FILE='…' CURL_CA_BUNDLE='…' REQUESTS_CA_BUNDLE='…' NODE_EXTRA_CA_CERTS='…'

Las cuatro variables de certificados nombran un único archivo en la carpeta de ejecución de Borg, que solo tú puedes leer. Ese archivo tiene el certificado de la CA seguido de los certificados del propio sistema, así que los programas siguen confiando en todos los demás hosts. Mientras la captura se ejecuta, el pie muestra Proxy en y la dirección del proxy, y L Copiar ajustes del proxy copia las mismas variables para un programa en otro terminal. Cuando la captura termina, Borg le devuelve al shell lo que tenía, igual que con SSLKEYLOGFILE, y borra el archivo. Borg nunca añade su CA al almacén de certificados de confianza del sistema.

Un programa que pasa por el proxy le pide un túnel hasta el host. El proxy se conecta al host, comprueba su certificado como lo hace el sistema y luego le muestra al programa un certificado para el mismo host firmado por la CA. El programa y el host siguen hablando HTTP/2 o HTTP/1.1, según lo que eligió el host. El proxy escribe las claves de las dos sesiones TLS en el archivo de claves de la captura, así que la copia de la conexión con el host que hay en la captura se abre descifrada, y el visor se la asigna al proceso que pidió el túnel. Todo lo que pasa por un túnel sin ser TLS sigue tal cual.

Los programas pasan por el proxy cuando leen los dos tipos de variables:

• curl, git y Python con requests o urllib siguen HTTPS_PROXY o https_proxy, y confían en el archivo de certificados a través de CURL_CA_BUNDLE, REQUESTS_CA_BUNDLE, o SSL_CERT_FILE cuando usan OpenSSL.
• Go sigue HTTPS_PROXY, salvo en las peticiones a localhost, y lee SSL_CERT_FILE en Linux. En macOS solo confía en los certificados del sistema, así que allí sus conexiones fallan.
• Node.js confía en la CA a través de NODE_EXTRA_CA_CERTS. Las versiones recientes envían fetch y https por el proxy cuando además defines NODE_USE_ENV_PROXY=1.
• Los programas con su propia lista de certificados, los que fijan certificados y las aplicaciones que toman el proxy de los ajustes del sistema, como Safari, rechazan o esquivan el proxy. Un rechazo aparece como Un programa no confió en el certificado del proxy para y el host.

Cuando el certificado del host no pasa la comprobación, el proxy cierra la conexión y un aviso dice Borg no pudo verificar y el host. Es lo que pasa con tus propios servicios cuando sus certificados vienen de una CA de desarrollo en la que el sistema no confía, como la que crea mkcert. Apunta proxy-ca, en la sección [network] de config.toml, a la carpeta de esa CA:

[network]
proxy-ca = "~/Library/Application Support/mkcert"  # mkcert -CAROOT prints the folder

La carpeta debe contener el certificado y su clave como rootCA.pem y rootCA-key.pem, los nombres que les da mkcert, o como ca.pem y ca-key.pem. La opción del diálogo pasa a ser Pasar el HTTPS por el proxy de Borg con la CA de y la carpeta. El proxy firma con tu CA, en la que tus programas ya confían, y también confía en ella cuando comprueba tus servicios. Usa una CA que exista solo para desarrollo, porque quien tenga su clave puede leer el tráfico de todo lo que confía en ella.

F3 busca claves en dos sitios:

• Un bloque de secretos de descifrado dentro de un archivo .pcapng, donde Wireshark también las guarda.
• Un archivo de claves junto a la captura, con el mismo nombre y la extensión .keylog, como capture-20260101-120000.keylog junto a capture-20260101-120000.pcap.

Para descifrar una captura que hiciste de otra forma, ejecuta el programa con la variable definida durante la captura y, cuando la captura se haya guardado, cambia el nombre del archivo de claves para que coincida con el de la captura:

SSLKEYLOGFILE=~/tls.keylog curl https://example.com

Borg abre registros de TLS 1.3 y TLS 1.2 cifrados con AES-128-GCM, AES-256-GCM o ChaCha20-Poly1305, los cifrados que acuerdan los navegadores y los servidores actuales. Un registro que ninguna clave abre conserva sus bytes cifrados, y su turno dice aún cifrado. Eso pasa cuando al archivo de claves le faltan algunas claves de la conexión, y después de bytes que faltan en la captura, porque Borg no puede saber dónde empieza el registro siguiente. El tráfico QUIC sigue cifrado.

Un archivo de claves descifra todas las conexiones de las que tiene claves, con contraseñas, cookies y tokens incluidos, y lo mismo hace una captura con las claves dentro. Borg hace que solo tú puedas leer ambos. Haz lo mismo con un archivo de claves que escribas tú con chmod 600, guarda los archivos de claves con el mismo cuidado que las capturas y borra ambos cuando termines.

Lo que informa el sistema

En macOS, Borg lee cada socket con sus recuentos de bytes y su proceso desde netstat, así que el tráfico aparece tanto para TCP como para UDP. También se listan los sockets de los procesos de otros usuarios.

En Linux, Borg lee los sockets de /proc/net y encuentra el proceso de cada socket a través de los archivos abiertos de los procesos. Sin derechos de administrador solo puede mirar dentro de tus propios procesos, así que los sockets de otros usuarios muestran Proceso desconocido. Los recuentos de bytes de TCP vienen de ss cuando está instalado; los sockets UDP y los equipos sin ss muestran — en las velocidades, y los detalles dicen El sistema no informa recuentos de bytes aquí. Los totales y las velocidades de las interfaces funcionan siempre.