Rede

Alt-N ou Comando → Rede mostra o que esta máquina faz na rede: as portas abertas e quem lhes consegue chegar, os processos que comunicam e a que velocidade, cada ligação e as interfaces de rede. Faz parte do plugin Sistema incluído, tal como o monitor de atividade. A lista ocupa o painel ativo, e o outro painel mostra a linha selecionada em pormenor, com gráficos dos últimos 60 segundos. O Borg recolhe uma amostra por segundo enquanto o ecrã está aberto e para quando o fecha. As velocidades aparecem a partir da segunda amostra, e cada uma é a média dos últimos 3 segundos, para que uma lista ordenada por tráfego fique parada o tempo suficiente para a ler.

Prima de 1 a 4, ou clique num separador, para mudar de página:

• 1 Portas lista cada porta em que um processo escuta, ordenadas por número. Alcance indica quem se pode ligar: Todas as redes para uma porta aberta em todos os endereços, o endereço para uma porta associada a endereços específicos, e Esta máquina para uma porta a que só os programas desta máquina chegam. As portas abertas a todas as redes destacam-se, porque outras máquinas as podem encontrar. Lig. conta as ligações que entraram pela porta, e os detalhes listam-nas com o respetivo tráfego.
• 2 Processos lista os processos que usam a rede, os mais ativos primeiro, com as velocidades de receção e envio e o número de ligações. Os detalhes acrescentam o que o processo transferiu desde que o ecrã foi aberto e cada ligação que mantém.
• 3 Ligações lista cada ligação com o processo, a outra extremidade e as velocidades. Um painel largo acrescenta o protocolo e o estado TCP. Os detalhes mostram as duas extremidades, o nome do host, o serviço e os bytes recebidos e enviados.
• 4 Interfaces lista as interfaces de rede com o tipo (Wi-Fi, Ethernet, Loopback, Túnel, Ponte ou Virtual), o primeiro endereço e as velocidades. ● marca uma interface ativa. Os detalhes acrescentam todos os endereços, a MTU, os bytes e pacotes que a interface recebeu e enviou até agora, e os erros.

O rodapé mostra a velocidade total de receção e envio da máquina em todas as interfaces exceto a de loopback. O Borg procura em segundo plano os nomes dos endereços remotos e mostra o nome em vez do endereço assim que o conhece.

Tecla	Ação
1 / 2 / 3 / 4	Mostrar Portas / Processos / Ligações / Interfaces
/	Filtrar as linhas; ↑↓ continuam a mover, Enter mantém o filtro, Esc limpa-o
T / N / P / C	Ordenar por tráfego / nome / porta / ligações; prima de novo para inverter
Enter	Mostrar o processo da linha selecionada no monitor de atividade
K	Mostrar o processo com Sinal ou prioridade aberto
R	Capturar o tráfego da linha selecionada ou parar a captura em curso
Ctrl-C	Copiar o endereço da porta, o PID, a outra extremidade ou o endereço da interface
Tab	Alternar entre a lista e os detalhes
Space	Pausar ou retomar a amostragem
Alt-W	Maximizar o painel com o foco
Esc	Voltar à lista e depois fechar o ecrã ou regressar ao monitor de atividade

P ordena as páginas que têm porta, e C as que contam ligações. Clique no cabeçalho de uma coluna para ordenar por ela, e faça duplo clique numa linha para mostrar o processo. Enter numa linha sem processo passa para os detalhes. Uma linha indica um processo e nenhum ficheiro de programa, por isso Alt-O aqui diz-lhe para premir Enter e depois Alt-O no monitor de atividade. O monitor de atividade que Enter e K abrem tem o processo selecionado, por isso a memória, os sinais e a prioridade ficam à distância de uma tecla (consulte Sinais e prioridade). Esc aí leva-o de volta ao ecrã de rede, à linha onde estava e com os gráficos.

Também funciona no sentido inverso. Alt-N no monitor de atividade abre este ecrã na linha do processo selecionado em 2 Processos, com o tráfego e as ligações nos detalhes, e Esc regressa ao monitor. Um processo sem ligações nem portas abertas recebe um aviso que o indica.

Filtrar

O filtro mantém as linhas que correspondem a todas as palavras que escreve. Uma palavra simples corresponde ao processo, ao PID, à porta, ao serviço, ao endereço, ao nome do host, ao estado, ao protocolo ou a uma etiqueta que a linha mostra, por isso postgres, 5432, https e example.com funcionam. Uma palavra com nome de campo procura apenas nesse campo:

Palavra	Mantém
port:443, port:ssh	Linhas com esse número de porta ou serviço
proc:node, process:node	Linhas cujo nome de processo contém o texto
pid:4100	Linhas desse PID
host:example	Linhas cujo endereço ou nome do host contém o texto; um endereço completo mantém apenas esse endereço
state:listen, state:time	Linhas TCP num estado que contém o texto
proto:udp, proto:tcp	Linhas desse protocolo
if:en0, interface:en0	Interfaces cujo nome contém o texto

Coloque ! antes de uma palavra para excluir as linhas que lhe correspondem: !state:time_wait oculta as ligações a fechar, e !proc:browser oculta um programa. O filtro aplica-se a todas as páginas e, enquanto escreve, indica quantas linhas da página mantém.

Capturar tráfego

Prima R para gravar os pacotes da linha selecionada com o tcpdump, que vem com o macOS e que no Linux se instala com o pacote tcpdump. A caixa de diálogo Capturar tráfego parte dessa linha:

• Tráfego é o que o tcpdump guarda. Em 1 Portas é a porta e as ligações que entraram por ela, e em 3 Ligações essa ligação nos dois sentidos. Em 2 Processos é Todo o tráfego, mostrado para esse processo: o tcpdump não consegue escolher pacotes por processo, por isso o Borg grava a interface inteira e abre o resultado no processo. Todo o tráfego da interface está sempre lá como segunda opção.
• Interface começa na que tem o endereço da linha ou, se não houver, na mais ativa.
• Duração é de 5, 10, 30 ou 60 segundos, ou Até parar.
• Guardar começa em Início de cada ligação, até 1 MiB: os pacotes de cada conversa ficam inteiros até transportarem 1 MiB de dados, e a partir daí o Borg guarda só os cabeçalhos. Os pedidos curtos ficam completos, e uma transferência longa ou uma videochamada não enchem o ficheiro. Pacotes inteiros guarda tudo, e Cabeçalhos, os primeiros 128 bytes de cada pacote guarda o início de cada pacote para os ficheiros mais pequenos. O Borg corta os pacotes à medida que escreve o ficheiro, que continua a ser um pcap ou pcapng normal, e cada pacote cortado continua a registar o seu tamanho na rede.
• Chaves TLS é Não, Definir SSLKEYLOGFILE na shell do Borg para guardar as chaves TLS dos programas que iniciar enquanto a captura decorre, ou Passar o HTTPS pelo proxy do Borg com uma CA temporária para programas que não escrevem as suas chaves (consulte Desencriptar TLS).
• Executar como aparece onde o Borg pode pedir ao sistema a palavra-passe de um administrador. Utilizador atual executa o tcpdump com o seu utilizador, e Administrador executa-o como root depois de introduzir a palavra-passe no diálogo do sistema. No macOS a opção chama-se Administrador, com o processo de cada pacote: o tcpdump escuta então através do pktap do macOS, que marca cada pacote com o processo que o enviou ou recebeu.

↑↓ escolhem um campo, ←→ ou Space mudam-no, Enter inicia a captura e Esc cancela. Com o rato, clique num campo para o escolher e clique outra vez para o mudar. Enquanto a captura decorre, o rodapé conta os pacotes, os bytes e os segundos que faltam, e R para-a mais cedo. Uma captura também para aos 200 000 pacotes ou 256 MiB, e quando o disco fica cheio, com o que já guardou. Para deixar espaço para o resto do sistema, defina keep-free-mib na secção [network] do ficheiro de configuração: a captura deixa então de começar quando o disco da pasta tem menos desses MiB livres e para quando o espaço livre desce abaixo disso. Depois dos primeiros 3 segundos, o rodapé diz quanto falta para o primeiro destes limites parar a captura ao ritmo atual, como cerca de 30 s até 256 MiB ou cerca de 2 min até o disco ficar cheio, quando isso acontece antes do fim da própria captura e dentro de uma hora. Quando um limite parou a captura, um aviso diz qual foi. Se fechar o ecrã antes, a captura para e um aviso diz onde o Borg a guardou.

O Borg guarda cada captura como capture-<date>-<time>.pcap na pasta do painel que o ecrã de rede cobre, legível só por si, para que o Wireshark e outras ferramentas a possam abrir mais tarde. Uma captura que marca cada pacote com o seu processo é guardada como capture-<date>-<time>.pcapng, o formato que consegue guardar essas marcas. O mesmo acontece a uma captura que guardou chaves TLS, depois de o Borg as colocar lá dentro. Uma captura contém tudo o que os pacotes transportavam, por isso guarde-a com o mesmo cuidado que esses dados. Cada captura fica também na lista de Ficheiros do Borg.

Um agente ligado através de borg mcp também pode pedir uma captura, que aguarda igualmente a sua aprovação (consulte O que o agente pode fazer).

Quando a captura termina, o visualizador de tráfego toma o lugar das páginas ao vivo, com uma página para cada forma de a ver:

• 1 Processos mostra cada processo com os hosts com que comunicou, os seus pacotes e os seus bytes. Quando os pacotes trazem o seu processo, cada pacote pertence ao processo que o enviou ou recebeu. Assim, até um processo que durou menos de um segundo fica com o seu nome, e o filtro de um processo mantém exatamente os seus pacotes. Caso contrário, uma conversa pertence ao processo cujo socket a tinha durante a captura, e o resto vai para Processo desconhecido.
• 2 Hosts mostra as outras máquinas com os protocolos vistos. Os nomes vêm das respostas DNS da própria captura e dos nomes de servidor que as ligações TLS pediram, por isso a maioria dos hosts tem um.
• 3 Ligações mostra cada conversa com o seu processo, a outra ponta, o protocolo, os pacotes e os bytes. Os detalhes mostram as duas pontas, o nome do servidor, o serviço, os bytes enviados e recebidos, e o fluxo da conversa: o que cada lado enviou, por ordem e com os bytes retransmitidos contados uma só vez, num dump hexadecimal com os bytes que se imprimem como texto ao lado. O fluxo divide-se em vezes, cada uma com uma seta que indica o sentido, os bytes que contém e a hora a que chegou. Quando faltam na captura bytes antes de uma vez, essa vez indica quantos faltam. Quando a captura guardou só o início da ligação, o título do fluxo diz quantos bytes ficaram de fora depois disso, segundo os cabeçalhos dos pacotes. ] e [ saltam para a vez seguinte e para a anterior. F3 mostra o fluxo inteiro em linhas hexadecimais no visualizador, com as vezes umas a seguir às outras, para o percorrer e pesquisar lá. Enter mostra os pacotes da conversa um a um. Quando o Borg tem as chaves TLS da ligação, o fluxo mostra o que os seus registos encriptados transportavam (consulte Desencriptar TLS).
• 4 Pacotes mostra todos os pacotes por ordem com o tempo desde o início, o protocolo, o tamanho e um resumo como ClientHello example.com ou A example.com → 203.0.113.10. Os detalhes mostram as camadas (Ethernet, IP, TCP ou UDP, e DNS, TLS ou HTTP quando o Borg as lê) e os bytes num dump hexadecimal. Um dump dispõe os bytes como as linhas hexadecimais do visualizador, com tantos em cada linha quantos couberem no painel. F3 mostra os bytes do pacote em linhas hexadecimais no visualizador.

Tecla	Ação
1 / 2 / 3 / 4	Mostrar Processos / Hosts / Ligações / Pacotes
Enter	Descer um nível: de um processo ou host para as suas ligações, de uma ligação para os seus pacotes, de um pacote para os seus detalhes
] / [	Nos detalhes de uma ligação, saltar para a vez seguinte ou anterior do fluxo
/	Filtrar as linhas, como nas páginas ao vivo
Ctrl-C	Copiar o PID, o endereço, a outra ponta ou os bytes do pacote em hex
F3	Mostrar o fluxo da ligação ou os bytes do pacote em linhas hexadecimais no visualizador
Tab	Alternar entre a lista e os detalhes, onde ↑↓ percorrem
Esc	Voltar à lista, depois subir um nível, depois limpar o filtro e depois voltar ao ecrã ao vivo

O filtro aceita as mesmas palavras que as páginas ao vivo, e proto: também corresponde ao que o Borg reconheceu nos pacotes: proto:dns, proto:tls, proto:http e proto:quic. Um filtro aplica-se a todas as páginas, e o Enter define um para descer um nível, por isso o Esc consegue voltar atrás.

F3 num ficheiro .pcap, .pcapng ou .cap num painel abre-o no mesmo visualizador, a começar em 2 Hosts. Um ficheiro gravado noutro sítio não tem sockets com que corresponder, por isso as suas conversas mostram Processo desconhecido. Um ficheiro .pcapng cujos pacotes trazem o seu processo, como os que o Borg e o tcpdump -i pktap guardam no macOS, continua a mostrar o nome de cada processo. O visualizador lê ficheiros até 256 MiB e os seus primeiros 200 000 pacotes.

Quando o Borg não encontra o tcpdump, a captura propõe instalá-lo. A caixa de diálogo Instalar tcpdump mostra o comando exato do gestor de pacotes que o Borg encontrou: apt-get, dnf, pacman, zypper ou apk no Linux, ou o brew do Homebrew no macOS e num Linux sem nenhum deles. Os gestores de pacotes do sistema são executados com sudo, ou com doas onde não houver sudo, a menos que o Borg seja executado como root. Enter escreve o comando na shell do Borg, onde vê o que ele faz e introduz a sua palavra-passe, e Esc cancela. Quando o comando termina, um aviso diz se correu bem, e Ctrl-O mostra a saída. O Borg volta a procurar o tcpdump sempre que uma captura começa, no PATH e em /usr/sbin, /usr/bin, /sbin, /bin e nas pastas sbin do Homebrew, por isso o R funciona logo que a instalação termina. Sem um gestor de pacotes que o Borg conheça, a captura termina com Para capturar é preciso o tcpdump, e o Borg não o encontra.

O tcpdump precisa de acesso ao dispositivo de captura. O Borg executa-o com o seu utilizador, por isso dê a si próprio esse acesso uma vez:

• No macOS, de início só o root consegue abrir os dispositivos /dev/bpf. Instale uma vez o Wireshark com o componente ChmodBPF: este entrega os dispositivos a um grupo access_bpf e acrescenta-o a esse grupo, e a partir daí pode capturar em todas as interfaces.
• No Linux, dê uma vez ao tcpdump as capacidades de captura com sudo setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump. Algumas distribuições deixam capturar os membros de um grupo pcap ou wireshark.

Sem acesso, o Borg pergunta Capturar como administrador onde o sistema pode pedir a sua palavra-passe: no macOS no diálogo de palavra-passe do próprio sistema, e no Linux através do pkexec, cujo diálogo vem do seu ambiente de trabalho. Escolha Sim e introduza a palavra-passe no diálogo do sistema, que o Borg nunca vê. Enquanto o diálogo está aberto, o rodapé mostra À espera da palavra-passe para capturar em e o nome da interface. O Borg executa então uma cópia de si próprio como root, que verifica o que lhe pediram para capturar e inicia o tcpdump a partir das pastas do próprio sistema. Os pacotes voltam ao Borg, que guarda o ficheiro com o seu utilizador. R e a duração param a captura como antes, e se o Borg terminar, a captura para com ele. Se cancelar o diálogo do sistema, a captura termina sem aviso. Para evitar a pergunta, escolha Administrador em Executar como antes de começar.

No Linux sem pkexec, o Borg usa o sudo quando este pode executar o tcpdump sem palavra-passe. Por SSH não há ambiente de trabalho que mostre o diálogo, por isso a captura termina com O Borg não consegue capturar como administrador e o motivo indicado pelo sistema. Quando o próprio Borg é executado como root, nunca pergunta, e no macOS as suas capturas trazem sempre o processo de cada pacote. Onde o Borg não pode perguntar, a captura termina com Sem permissão para capturar em e o nome da interface.

Desencriptar TLS

Quando o Borg tem as chaves de uma ligação TLS, o fluxo dela em 3 Ligações mostra o que os registos encriptados transportavam, como um pedido HTTP e a respetiva resposta, e o cabeçalho do fluxo termina em desencriptado.

As chaves vêm de um ficheiro de chaves TLS, o ficheiro que os browsers, o curl, o Python e muitos outros programas escrevem quando a variável de ambiente SSLKEYLOGFILE indica um. Nesse caso nada se interpõe entre o programa e o servidor, por isso isto também funciona com programas que fixam os seus certificados. Para programas que nunca escrevem um ficheiro de chaves, o Borg pode colocar-se ele próprio no meio (consulte Pelo proxy do Borg).

Para as guardar com uma captura, escolha Definir SSLKEYLOGFILE na shell do Borg em Chaves TLS no diálogo Capturar tráfego. Quando a captura começa, o Borg cria capture-<date>-<time>.keylog ao lado da captura, legível só por si, e escreve uma linha como esta no prompt da sua shell, onde a vê ser executada e a encontra mais tarde no histórico da shell:

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

No fish a linha começa por set -gx. Depois o Borg volta ao ecrã de rede, onde o rodapé indica Chaves TLS enquanto a captura decorre.

Agora inicie o programa a partir da linha de comando do Borg, ou prima Ctrl-O e inicie-o na shell. O programa herda a variável e escreve as suas chaves no ficheiro. Para um programa noutro terminal, prima L no ecrã de rede para copiar SSLKEYLOGFILE='…' com o caminho do ficheiro de chaves, cole-o lá e escreva o programa a seguir. Um programa que já estava em execução mantém a definição com que arrancou, por isso feche-o e inicie-o de novo. Isto vale sobretudo para os browsers, que passam um segundo arranque à janela que já está aberta. No macOS, o open inicia as aplicações sem as variáveis da shell, por isso inicie o próprio programa da aplicação, como /Applications/Firefox.app/Contents/MacOS/firefox.

Se a shell do Borg estiver ocupada, ou se a linha de comando pertencer a um contentor ou a outra máquina, o Borg não escreve nada e um aviso indica-o. A tecla L continua a copiar a linha.

Quando a captura termina, o Borg escreve unset SSLKEYLOGFILE no prompt (set -e SSLKEYLOGFILE no fish), ou repõe o valor com que o próprio Borg arrancou, e um aviso indica a linha. Se um programa que iniciou ainda estiver em execução na shell, a linha espera que termine. Depois o Borg coloca as chaves das ligações da captura dentro da captura como um bloco de segredos de desencriptação, por isso um .pcap passa a ser um .pcapng com o mesmo nome, que o Wireshark abre já desencriptado. O ficheiro de chaves fica ao lado, porque os programas iniciados durante a captura continuam a escrever nele até terminarem. As capturas pedidas por um agente não guardam chaves.

Leem SSLKEYLOGFILE o Firefox, o Chrome e outros browsers baseados em Chromium, a maioria das compilações do curl e os programas em Python que usam o contexto predefinido do módulo ssl. Outros precisam da sua própria opção:

• O Node.js escreve as chaves com --tls-keylog, por isso inicie-o como node --tls-keylog="$SSLKEYLOGFILE" app.js.
• Os programas em Go só as escrevem quando o programa define KeyLogWriter na configuração TLS.
• Os programas em Rust com rustls só as escrevem quando usam o seu KeyLogFile.
• O Java precisa de um agente que se ligue ao seu código TLS.

O Safari e outras aplicações criadas sobre as bibliotecas TLS da própria Apple nunca escrevem um ficheiro de chaves, e o seu tráfego continua encriptado.

Pelo proxy do Borg

Defina Chaves TLS como Passar o HTTPS pelo proxy do Borg com uma CA temporária para ler o HTTPS de programas que nunca escrevem um ficheiro de chaves, como programas em Go e Rust ou um cliente que não pode alterar. Quando a captura começa, o Borg corre um proxy em 127.0.0.1 e cria uma autoridade de certificação (CA) só para esta captura. A chave da CA vive na memória do Borg e desaparece quando a captura termina. O Borg escreve uma linha no prompt da sua shell que envia o HTTPS pelo proxy e faz os programas confiarem na 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='…'

As quatro variáveis de certificados indicam um único ficheiro na pasta de execução do Borg, legível só por si. Esse ficheiro tem o certificado da CA seguido dos certificados do próprio sistema, por isso os programas continuam a confiar em todos os outros anfitriões. Enquanto a captura decorre, o rodapé mostra Proxy em e o endereço do proxy, e L Copiar definições do proxy copia as mesmas variáveis para um programa noutro terminal. Quando a captura termina, o Borg devolve à shell o que ela tinha, tal como faz com SSLKEYLOGFILE, e apaga o ficheiro. O Borg nunca acrescenta a sua CA ao repositório de certificados de confiança do sistema.

Um programa que passa pelo proxy pede-lhe um túnel até ao anfitrião. O proxy liga-se ao anfitrião, verifica o certificado dele como o sistema o faz e depois mostra ao programa um certificado para o mesmo anfitrião assinado pela CA. O programa e o anfitrião continuam a falar HTTP/2 ou HTTP/1.1, conforme o que o anfitrião escolheu. O proxy escreve as chaves das duas sessões TLS no ficheiro de chaves da captura, por isso a cópia da ligação ao anfitrião que está na captura abre desencriptada, e o visualizador atribui-a ao processo que pediu o túnel. Tudo o que passa num túnel sem ser TLS segue tal como está.

Os programas passam pelo proxy quando leem os dois tipos de variáveis:

• O curl, o git e o Python com requests ou urllib seguem HTTPS_PROXY ou https_proxy, e confiam no ficheiro de certificados através de CURL_CA_BUNDLE, REQUESTS_CA_BUNDLE, ou SSL_CERT_FILE quando usam OpenSSL.
• O Go segue HTTPS_PROXY, exceto em pedidos para localhost, e lê SSL_CERT_FILE no Linux. No macOS confia apenas nos certificados do sistema, por isso aí as suas ligações falham.
• O Node.js confia na CA através de NODE_EXTRA_CA_CERTS. As versões recentes enviam fetch e https pelo proxy quando também define NODE_USE_ENV_PROXY=1.
• Programas com a sua própria lista de certificados, programas que fixam certificados e aplicações que tiram o proxy das definições do sistema, como o Safari, recusam ou contornam o proxy. Uma recusa aparece como Um programa não confiou no certificado do proxy para e o anfitrião.

Quando o certificado do anfitrião não passa na verificação, o proxy fecha a ligação e um aviso diz O Borg não conseguiu verificar e o anfitrião. É o que acontece com os seus próprios serviços quando os certificados vêm de uma CA de desenvolvimento em que o sistema não confia, como a que o mkcert cria. Aponte proxy-ca, na secção [network] do config.toml, para a pasta dessa CA:

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

A pasta tem de conter o certificado e a respetiva chave como rootCA.pem e rootCA-key.pem, os nomes que o mkcert lhes dá, ou como ca.pem e ca-key.pem. A opção no diálogo passa então a ser Passar o HTTPS pelo proxy do Borg com a CA em e a pasta. O proxy assina com a sua CA, em que os seus programas já confiam, e também confia nela quando verifica os seus serviços. Use uma CA que exista apenas para desenvolvimento, porque quem tiver a chave dela pode ler o tráfego de tudo o que confia nela.

A tecla F3 procura chaves em dois sítios:

• Um bloco de segredos de desencriptação dentro de um ficheiro .pcapng, onde o Wireshark também as guarda.
• Um ficheiro de chaves ao lado da captura, com o mesmo nome e a extensão .keylog, como capture-20260101-120000.keylog ao lado de capture-20260101-120000.pcap.

Para desencriptar uma captura feita de outra forma, execute o programa com a variável definida durante a captura e, quando a captura estiver guardada, mude o nome do ficheiro de chaves para que coincida com o da captura:

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

O Borg abre registos TLS 1.3 e TLS 1.2 cifrados com AES-128-GCM, AES-256-GCM ou ChaCha20-Poly1305, as cifras que os browsers e os servidores atuais acordam entre si. Um registo que nenhuma chave abre mantém os bytes encriptados, e a sua vez indica ainda encriptado. Isso acontece quando faltam ao ficheiro de chaves algumas chaves da ligação, e depois de bytes que faltam na captura, porque o Borg não consegue saber onde começa o registo seguinte. O tráfego QUIC continua encriptado.

Um ficheiro de chaves desencripta todas as ligações para as quais tem chaves, incluindo palavras-passe, cookies e tokens, e o mesmo faz uma captura com as chaves lá dentro. O Borg torna ambos legíveis só por si. Faça o mesmo com um ficheiro de chaves que escreva por si com chmod 600, guarde os ficheiros de chaves com o mesmo cuidado que as capturas e apague ambos quando terminar.

O que o sistema indica

No macOS, o Borg lê cada socket com as contagens de bytes e o processo a partir do netstat, por isso o tráfego aparece tanto para TCP como para UDP. Os sockets dos processos de outros utilizadores também são listados.

No Linux, o Borg lê os sockets de /proc/net e encontra o processo de cada socket através dos ficheiros abertos dos processos. Sem direitos de administrador só consegue ver os seus próprios processos, por isso os sockets de outros utilizadores mostram Processo desconhecido. As contagens de bytes de TCP vêm do ss quando está instalado; os sockets UDP e as máquinas sem ss mostram — nas velocidades, e os detalhes indicam O sistema não indica contagens de bytes aqui. Os totais e as velocidades das interfaces funcionam sempre.