Uma ligação que dá timeout diz-te quase nada. A outra ponta pode não ter nada à escuta, uma firewall a três saltos pode estar a deitar fora o teu SYN em silêncio sem gerar sequer uma linha de log, ou a rota pode simplesmente não existir, e de onde estás sentado todas essas hipóteses parecem iguais. Esperas. Não acontece nada.

Por isso o ticket é escrito como «a porta 445 está bloqueada algures», e é o «algures» que o faz andar aos saltos. O teu fornecedor verifica a sua periferia, encontra-a limpa e devolve-o. Tu verificas a firewall do teu host, encontra-la limpa e devolve-lo. Passa uma semana. Nada fica resolvido.

A palavra que faz o estrago é «algures». Não tem de lá estar. Cada router entre ti e o destino é obrigado a dizer-te quando é ele o culpado, e essa obrigação está escrita nas normas desde 1995. Só tens de perguntar da maneira certa.

Porque é que isto precisa de ser explicado

Porque demasiadas pessoas nesta indústria não sabem fazer o básico, e isso custa dinheiro a sério aos seus empregadores todas as semanas.

Não me refiro aos juniores. Refiro-me a pessoas com anos de casa, certificações na parede e sénior no cargo, cujo diagnóstico de uma porta em timeout acaba em «está bloqueada» e não vai mais longe. Correm ping. Falha, ou funciona, e de qualquer maneira não aprenderam nada sobre a porta de que lhes perguntaram. Depois o ticket vai para o fornecedor, o fornecedor devolve-o, e quinze dias do salário de alguém vão para uma troca de mensagens que podia ter sido um comando.

Nada disto é difícil. Distinguir um drop de um reject, ler o TTL de uma resposta, saber que uma estrela num traceroute não quer dizer nada por si só: é uma tarde para aprender e dura uma carreira. A razão por que as pessoas não sabem isto não é serem burras. É que ninguém o ensina. A formação dos fabricantes ensina-te a consola de um fabricante. As certificações ensinam-te o exame. Os fundamentos por baixo são dados como adquiridos no primeiro dia e nunca chegam a ser dados, por isso as pessoas chegam a cargos séniores sem nunca lhos terem mostrado, e a essa altura já têm vergonha de perguntar.

Por isso, em vez de me queixar, aqui fica por escrito. Isto é o básico, explicado, com os comandos e um script que podes correr hoje.

E uma palavra sobre porque me dei ao trabalho: corri isto contra a minha própria linha enquanto o escrevia e encontrei três avarias que não sabia que tinha. Um drop de SMB a onze saltos. Resets SMTP forjados a um salto de distância. Uma regra de firewall que existe em IPv4 e não em IPv6. Uma tarde, sem root, numa linha de que eu próprio trato e a que presto atenção. Pensa um bocado no que estará parado sem ninguém dar por isso nas redes que alguém é pago para gerir.

Porque é que o Fisher-Price OS (Windows) não está aqui

Há duas razões para não estar aqui. Uma é técnica e a outra não, e prefiro dar-te as duas a fingir que é tudo engenharia.

A técnica é que não consegue fazer isto. O tracert envia pedidos de eco ICMP e mais nada: a própria referência da Microsoft descreve-o como «sending Internet Control Message Protocol (ICMP) echo Request or ICMPv6 messages to the destination with incrementally increasing time to live (TTL) field values», e não há parâmetro de porta em parte nenhuma da sua sintaxe. O pathping é essa mesma ferramenta com estatísticas aparafusadas. O Test-NetConnection diz-te se uma porta TCP está aberta ou fechada e absolutamente nada sobre a distância de onde veio a resposta. Nenhum deles consegue sondar a porta que realmente te interessa a uma distância escolhida, que é todo o método deste artigo.

Nem consegues dar a volta com um script. Definir o TTL num socket é bastante fácil em .NET, mas ler de volta o erro ICMP é a metade difícil, e não há equivalente do truque em que este artigo se apoia: nenhuma forma de pôr o kernel a reportar o erro no socket normal que o causou. Isso deixa um raw socket, e a própria documentação da Microsoft diz «only members of the Administrators group can create sockets of type SOCK_RAW». Portanto o caminho sem privilégios não existe e o privilegiado exige um token de administrador local. Estás a descarregar software de terceiros antes de teres começado.

A outra razão é que não me interessa, e prefiro dizê-lo a disfarçá-lo. O nome também não é uma provocação barata, é uma descrição. É o SO que te põem nas mãos quando nunca tiveste outro, esconde-te a máquina como objetivo de design e não por acidente, e no momento em que queres fazer uma pergunta precisa à rede descobres que a ferramenta nunca foi construída, porque nunca se esperou que as pessoas para quem é feito perguntassem. Trinta anos depois, o tracert continua sem conseguir apontar um pacote a uma porta.

Não é um sistema operativo a sério para gente de TI a sério, e se é o único que alguma vez usaste então não estás a fazer este trabalho ao nível para que este artigo foi escrito. Sei que isto cai mal. Não escrevo para ser simpático, escrevo o que meço para pessoas que medem coisas, e não me importa grande coisa que alguém que só alguma vez o usou preferisse que eu o dissesse de outra maneira.

A lista de ferramentas é o argumento, não a opinião. Todos os Unix da tabela mais abaixo te deixam definir um limite de saltos e escolher um protocolo, quatro deles com um único comando, e o Linux faz a medição inteira sem sequer precisar de sudo. Não é por serem mais difíceis de usar. É porque foram construídos por pessoas que esperavam que quem estivesse ao teclado quisesse saber coisas. Um sistema operativo cujo diagnóstico acaba no ping disse-te com clareza o que pensa de quem o usa, e trinta anos de pessoas a aceitar isso é a forma como acabámos com uma indústria que não consegue localizar um pacote perdido.

Por isso não o uso, não o uso a sério há anos, e não lhe vou escrever uma secção própria para parecer imparcial sobre uma lacuna que é real. Tudo aquilo em que construo e tudo aquilo a partir de onde vale a pena medir é Unix, e é aí que este artigo vive.

Se a máquina avariada estiver por acaso a correr o Fisher-Price OS (Windows), isso não muda nada no método. Arranja uma shell noutra coisa qualquer, uma VM Linux, um Mac, um Raspberry Pi no mesmo switch, e faz subir o limite de saltos em direção a ela. A medição não quer saber minimamente o que corre na outra ponta. Só quer saber o que está pelo meio.

O TTL é um orçamento de saltos, e cada router te deve um recibo

O cabeçalho IPv4 tem um campo Time to Live de 8 bits. O nome é um resto do passado: foi especificado em segundos, e nada o trata como segundos há décadas. O RFC 1812 arrumou a discussão em 1995 e tornou normativa a leitura como contagem de saltos:

Each router (or other module) that handles a packet MUST decrement the TTL by at least one, even if the elapsed time was much less than a second. Since this is very often the case, the TTL is effectively a hop count limit on how far a datagram can propagate through the Internet.

Depois a parte que importa aqui, da mesma secção:

If the TTL is reduced to zero (or less), the packet MUST be discarded, and if the destination is not a multicast address the router MUST send an ICMP Time Exceeded message, Code 0 (TTL Exceeded in Transit) message to the source.

Isso é um MUST. Não é uma cortesia, não é uma sugestão. O RFC 792, em 1981, só dizia que um gateway «may also notify the source host»; treze anos depois o requisito foi apertado, e o RFC 1812 diz porquê com todas as letras:

ICMP Time Exceeded messages are required because the traceroute diagnostic tool depends on them.

O IPv6 deixou-se de fingimentos e mudou o nome ao campo. O RFC 8200 chama-lhe Hop Limit, «8-bit unsigned integer. Decremented by 1 by each node that forwards the packet», e a mensagem de expiração passou a ser o ICMPv6 tipo 3, código 0, «hop limit exceeded in transit».

Lê isso como um instrumento em vez de uma regra e diz algo útil. Cada router no caminho é um farol que podes endereçar pela distância. Põe o limite de saltos em 4 e o quarto router identifica-se. Não precisas de conhecer a topologia, não precisas de acesso a nada, e não precisas da colaboração do operador. Precisas de um pacote por salto.

O traceroute faz exatamente isto desde o fim dos anos 80. O que faz mal é aquilo que realmente te interessa, porque por predefinição sonda portas UDP lá para a gama dos 33434, que é uma porta que ninguém filtra e ninguém serve, por isso fala-te de um caminho que nada de real alguma vez usa. Um traceroute limpo para um host que não consegues alcançar em TCP/445 prova apenas que o UDP/33434 lá chega. O que nunca foi a pergunta.

Portanto sonda a porta que te interessa.

Lê o que voltou, não se alguma coisa voltou

Antes de contar saltos, olha para o que a outra ponta faz quando lá chegas com um limite de saltos normal. Há cinco respostas distintas e as pessoas reduzem-nas habitualmente a uma.

O que voltaO que significaQuem o enviou
SYN-ACK, a ligação abrea porta está abertao host, ou algo que responde por ele
TCP RSTrecusada ativamenteo host sem nada à escuta, ou um dispositivo configurado para rejeitar
ICMP 3/13, comunicação proibida administrativamenteum dispositivo está a recusar por política e di-loesse dispositivo: o seu endereço de origem é a tua resposta
ICMP 3/1, 3/2, 3/3host, protocolo ou porta inalcançávelo último router, ou o host
nada de nadaalguém está a deitar fora em silênciodesconhecido, por isso vai medir

A terceira linha é a que justifica mudar de hábitos. Quando uma firewall está configurada para rejeitar em vez de deitar fora, põe o seu próprio endereço no campo de origem do ICMP e entrega-te o culpado de graça. Em Linux é isso que nft ... reject with icmpx admin-prohibited produz, e o que iptables -j REJECT --reject-with icmp-admin-prohibited sempre produziu. A maioria das ferramentas deita isso fora e imprime «filtered». O nmap --reason mostra-o. O script mais abaixo também.

As linhas dois e cinco são a falha interessante. Um drop silencioso é uma decisão de política de não te dizer nada, e como é a predefinição em quase todas as firewalls comerciais é aquela com que vais mesmo dar. Espera silêncio.

A linha dois também merece desconfiança. Um reset não prova que foi o host a enviá-lo, e vou voltar a isso com um exemplo ao vivo, porque encontrei um na minha própria linha enquanto escrevia isto.

Percorre a porta que te interessa, duas vezes

O método são duas execuções e uma comparação. É tudo.

  1. Faz subir o limite de saltos de 1 a 20 usando exatamente o protocolo e a porta que falham, e anota que router responde em cada salto.
  2. Faz o mesmo com algo que funciona, de preferência o mesmo host e uma porta que abre.
  3. O salto onde as respostas param na primeira execução e continuam na segunda é o dispositivo que te está a deitar fora. A segunda execução dá-te o seu endereço.

Porque é que as respostas param em vez de mudarem: um router aplica a sua lista de acesso de entrada antes de fazer qualquer outra coisa com o pacote, por isso se a política diz drop então o pacote desaparece antes de o caminho de encaminhamento olhar sequer para o limite de saltos, não é gerado nenhum Time Exceeded, e o dispositivo nunca assina o que fez. Como tal, o silêncio começa no salto culpado, não depois dele.

Escrevi uma pequena ferramenta para percorrer os saltos porque nenhuma das nativas o faz de forma portável. Define IP_TTL (ou IPV6_UNICAST_HOPS) num socket normal, liga-se e lê de volta o erro ICMP. Em Linux, o IP_RECVERR reporta esse erro no próprio socket que o provocou, o que quer dizer que a coisa toda corre sem privilégios: sem root, sem raw sockets, sem capabilities. Em macOS, nos BSD e em Solaris o kernel não te entrega o ICMP dessa maneira, por isso recorre a um raw socket e precisa de root.

hopfind.py: o caminhante do TTL hopfind.py · 11 kB

São 279 linhas de biblioteca padrão e mais nada, e está tudo impresso no fim deste artigo se preferires lê-lo em vez de o descarregar.

python3 hopfind.py example.net 445      # the port under suspicion
python3 hopfind.py example.net 443      # the reference run
python3 hopfind.py example.net 53 --proto udp
python3 hopfind.py 2001:db8::1 443 -6

Usa o mesmo protocolo nas duas execuções. Comparar um rasto TCP com um rasto ICMP é comparar dois caminhos, porque o balanceamento de carga faz hash sobre o tuplo de cinco elementos e o ICMP não tem portas para o hash. Mesmo host, mesmo protocolo, porta diferente: essa é a comparação honesta.

Tudo o que está abaixo é saída real da minha própria linha a 28 de agosto de 2026, corrida como utilizador sem privilégios em Fedora. Cada endereço foi reescrito para as gamas de documentação: o RFC 5737 para IPv4, o RFC 3849 para IPv6, com o único identificador de interface também alterado. Portanto 198.51.100.x é o meu próprio router e o meu ISP, 203.0.113.x é trânsito e peering, 192.0.2.x é a rede distante, e 2001:db8::/32 é todo o caminho IPv6. A estrutura mantém-se do princípio ao fim: as mesmas fronteiras de prefixo, as mesmas formas da parte do host, o mesmo número de redes distintas. Os números dos saltos, os tempos, os tipos ICMP e o salto que ficou calado estão exatamente como foram medidos.

Um host, três portas, três avarias diferentes

O mesmo destino do princípio ao fim: um host na internet pública, a catorze saltos, com a 443 aberta. Primeiro a execução de referência.

$ python3 hopfind.py 192.0.2.4 443 --max 15
walking to 192.0.2.4  TCP/443  hop limit 1-15
  1  198.51.100.254                              0.3 ms  ICMP 11/0 time exceeded in-transit
  2  198.51.100.133                             28.8 ms  ICMP 11/0 time exceeded in-transit
  3  *
  4  198.51.100.153                              6.3 ms  ICMP 11/0 time exceeded in-transit
  5  *
  6  203.0.113.240                              16.5 ms  ICMP 11/0 time exceeded in-transit
  7  203.0.113.188                              16.5 ms  ICMP 11/0 time exceeded in-transit
  8  203.0.113.185                              16.5 ms  ICMP 11/0 time exceeded in-transit
  9  203.0.113.15                               15.6 ms  ICMP 11/0 time exceeded in-transit
 10  203.0.113.125                              16.1 ms  ICMP 11/0 time exceeded in-transit
 11  192.0.2.31                                 26.6 ms  ICMP 11/0 time exceeded in-transit
 12  *
 13  *
 14  192.0.2.4                                  19.5 ms  connected

Verdict: TCP/443 is open. It answered at hop 14.

Repara nos saltos 3, 5, 12 e 13. Quatro routers num caminho que claramente funciona não disseram nada, porque há muito equipamento configurado para não gerar ICMP para si próprio, ou que o limita com força. Uma estrela não é prova de uma firewall. Se só levares uma coisa daqui, leva esta. O sinal nunca é haver estrelas numa só execução; é onde duas execuções deixam de concordar.

Agora o mesmo host na 445, que daqui dá timeout.

$ python3 hopfind.py 192.0.2.4 445 --max 15
walking to 192.0.2.4  TCP/445  hop limit 1-15
  1  198.51.100.254                              0.3 ms  ICMP 11/0 time exceeded in-transit
  2  198.51.100.133                              8.0 ms  ICMP 11/0 time exceeded in-transit
  3  *
  4  198.51.100.153                              6.4 ms  ICMP 11/0 time exceeded in-transit
  5  203.0.113.76                                5.6 ms  ICMP 11/0 time exceeded in-transit
  6  203.0.113.240                              15.9 ms  ICMP 11/0 time exceeded in-transit
  7  203.0.113.188                              15.8 ms  ICMP 11/0 time exceeded in-transit
  8  203.0.113.185                              16.6 ms  ICMP 11/0 time exceeded in-transit
  9  203.0.113.15                               15.9 ms  ICMP 11/0 time exceeded in-transit
 10  203.0.113.125                              15.0 ms  ICMP 11/0 time exceeded in-transit
 11  *
 12  *
 13  *
 14  *
 15  *

Verdict: answers stop after hop 10 (203.0.113.125).
         Whatever swallows TCP/445 is hop 11.
         Walk a port that works and read off the address at hop 11.

O salto 11 respondeu à execução da 443 em 26,6 ms e não disse rigorosamente nada à execução da 445. A mesma caixa, o mesmo caminho, os mesmos dez routers à frente dela. Cruza com a execução que funciona e o salto 11 tem nome: 192.0.2.31. É esse o dispositivo que deita fora o SMB, a três saltos do destino e oito saltos depois da periferia do meu fornecedor. Não é meu, nem do meu ISP.

O salto 5 mostra a questão das estrelas pelo lado contrário. Foi uma estrela na execução da 443 e respondeu na da 445, ao contrário da avaria. Pode ser limitação de ICMP, ou podem ser as duas execuções a seguir caminhos diferentes através de um balanceador de carga. Não sei qual é, e tu também não vais saber. Repete as duas execuções antes de acreditares em qualquer uma delas.

Duas caminhadas do limite de saltos até ao mesmo host, e o salto onde deixam de concordarDuas caminhadas até ao mesmo host, e o salto onde deixam de concordarUma sonda por limite de saltos. Uma célula sombreada quer dizer que esse router devolveu ICMP Time Exceeded e se identificou.o router respondeunão voltou nadacalado daqui em diante1234567891011121314limite de saltos definido na sondaTCP/443referência, abre••*•*••••••**✓abreTCP/445em teste, dá timeout••*•••••••****o salto 11 respondeu a uma caminhada e não à outraOs saltos 3, 5, 12 e 13 nada disseram num caminho que funciona: uma estrela sozinha não quer dizer nada.O salto 11 respondeu à caminhada de referência em 26,6 ms e nunca respondeu à de teste.É essa a fronteira, e é a caminhada de referência que lhe dá um endereço: 192.0.2.31.
As mesmas duas execuções, lado a lado. A única célula que importa é a do salto 11, e o que importa nela é o desacordo: respondeu a uma execução e não à outra.

Depois a porta 25. Esta fez-me parar.

$ python3 hopfind.py 192.0.2.4 25 --max 15
walking to 192.0.2.4  TCP/25  hop limit 1-15
  1  192.0.2.4                                   0.4 ms  TCP reset

Verdict: a reset came back to a probe with a hop limit of 1.
         Nothing more than one hop away can have sent it, so check the reply
         TTL before you believe the host did.

Um limite de saltos de 1 quer dizer que o pacote morreu no meu próprio router. Fez um salto. Não pode ter viajado catorze. E no entanto voltou um reset TCP em 0,4 ms com o endereço do destino, e o meu kernel reportou obedientemente connection refused. Sem o limite de saltos definido eu tê-lo-ia lido como «a outra ponta não tem servidor de correio» e fechado o ticket.

Alguma coisa a um salto de distância está a forjar resets para SMTP de saída e a assiná-los com o endereço do destino. Bloquear a porta 25 de saída é uma coisa perfeitamente normal para um router doméstico ou um ISP fazer, e fazê-lo com um reset em vez de um drop é discutivelmente a versão educada, mas o reset leva o endereço de outra pessoa e eu não fazia ideia de que o meu o fazia. Foi o limite de saltos que o apanhou, e mais nada na resposta o teria apanhado.

Desvio de um: onde fica a lista de acesso no pipeline

O veredicto acima diz que quem deita fora é o salto 11 porque as respostas pararam depois do salto 10. Cuidado com essa aritmética, porque depende da ordem em que o dispositivo culpado faz duas tarefas.

A maior parte do equipamento aplica primeiro a política de entrada e depois a verificação do limite de saltos. A regra de negação dispara, o pacote é descartado, e nunca é gerado nenhum Time Exceeded, por isso o dispositivo nunca aparece e o silêncio começa no seu próprio número de salto. É o caso acima. É também o mais comum.

Algumas plataformas tratam a expiração do limite de saltos no caminho rápido, antes de a política ser avaliada. Aí, o dispositivo responde à sonda que lhe é dirigida e só deita fora as sondas apontadas para lá dele, por isso aparece normalmente e o silêncio começa um salto mais tarde.

Porque é que o salto culpado normalmente não aparece: a política é avaliada antes da verificação do limite de saltosDentro do salto que te deita fora, a ordem de duas verificações decide o que vêsA tua sonda chega com um salto de orçamento, e corresponde a uma regra que diz deny.Primeiro a política: quase todas as firewalls, e todos os casos medidos neste artigoo router no salto Nsonda entrapolítica de entradalimite de saltosencaminhardescartada antes de algo olhar para o limite de saltosNão é gerado ICMP, por isso este router nunca assina o drop.A tua caminhada fica calada no salto N.Primeiro a expiração: algumas plataformas tratam-na no caminho rápidoo router no salto Nsonda entralimite de saltospolítica de entradaencaminharexpirou, por isso o ICMP 11/0 volta com o endereço deste routerResponde por si e só engole as sondas apontadas para lá dele.A tua caminhada fica calada a partir do salto N+1.
Porque é que o salto que deita fora fica normalmente invisível. Em quase todas as firewalls a negação é avaliada primeiro, por isso a sonda desaparece antes de o caminho de encaminhamento reparar que o limite de saltos expirou, e nunca é gerado nenhum ICMP. Em equipamento que trata a expiração no caminho rápido, o mesmo dispositivo responde à sonda que lhe é dirigida e só engole as que apontam mais além.

Portanto a leitura honesta de «as respostas param depois do salto N» é: quem deita fora é o salto N+1 se deitou a tua sonda ao lixo antes de reparar que o orçamento se tinha esgotado, ou o próprio salto N se respondeu à sonda que lhe era dirigida e engoliu tudo o que apontava para lá. Dois dispositivos adjacentes, e a execução que funciona dá nome a ambos. Cita os endereços, não a contagem de saltos: uma contagem de saltos não quer dizer nada a quem lê o teu ticket, que está a contar a partir de outro sítio.

O TTL da resposta diz-te quem respondeu de facto

O reset SMTP acima foi apanhado pelo limite de saltos à ida. Há uma segunda verificação, independente, disponível em cada resposta que volta, e não custa nada.

Os valores iniciais de TTL não estão normalizados, mas na prática há três:

Começa emRemetente típico
64Linux, macOS, os BSD, illumos, a maioria dos hosts
255Cisco IOS, Junos, Solaris, o tráfego próprio da maior parte do equipamento de rede
128o Fisher-Price OS (Windows), de que continuas a precisar para ler uma resposta vinda de um

Subtrai o TTL que recebeste ao valor seguinte acima e tens a contagem de saltos de volta. Uma resposta que chega com TTL 50 começou em 64 e fez 14 saltos. Uma que chega com TTL 250 começou em 255 e fez 5. O ping imprime-o sem que lho peçam:

ping -c1 192.0.2.4          # ttl=50 → 14 hops away
tcpdump -n -v 'icmp'        # -v prints the ttl of every packet it shows

Daí saem duas coisas. Ambas de graça.

Uma resposta cuja contagem de saltos de volta não bate com as outras respostas do host não foi enviada pelo host. Se uma resposta de eco de um servidor volta a 14 saltos e o RST na porta 25 volta a 1 salto, foi uma middlebox que escreveu o RST. O mesmo truque da secção acima, pela outra ponta, e funciona mesmo quando não consegues definir o TTL de saída.

Uma resposta que começou em 255 veio de equipamento de rede, não de um servidor. Útil quando estás a tentar perceber se aquilo que te rejeita é o host ou o router à frente dele.

Para veres o campo em TCP em vez de ICMP precisas de uma captura, e vale a pena decorar o filtro:

# every hop-limit expiry coming back to you, IPv4 and IPv6
tcpdump -n -v 'icmp[icmptype] == 11 or icmp6[icmp6type] == 3'

# who is resetting you, and from how far
tcpdump -n -v 'tcp[tcpflags] & tcp-rst != 0'

O tcpdump imprime a expiração como ICMP time exceeded in-transit, a mesma expressão que as normas usam, e o mesmo evento que aparece como «TTL expired in transit» nas plataformas que o formulam assim.

O mesmo truque com ferramentas nativas, em cinco Unix

Se preferires não correr um script, as ferramentas nativas fazem a maior parte. Só que discordam umas das outras mais do que esperarias. O -P, em particular, quer dizer três coisas diferentes consoante o traceroute que tens na mão, e uma delas estraga-te o teste sem dizer nada.

Linux (traceroute 2.1.x)macOS / FreeBSDOpenBSDNetBSDSolaris 11
Sondas TCP-T-P tcpinutilizávelnãonão
Sondas ICMP-I-I-I-I-I
UDP para uma porta fixa-U -p N-e -p Nnãonãonão
porta de destino-p N (constante para TCP)-p N (incrementa sem -e)-p N (incrementa)-p N (incrementa)-p N (incrementa)
o que quer dizer -Pnão usadoprotocolo da sondaprotocolo numérico, «will not work reliably for most protocols»define DF e sonda a MTU do caminhopausa entre sondas, em segundos
precisa de privilégiossim, para -T e -Isimsimsimsim

Todas essas precisam de raw sockets, por isso todas precisam de privilégios, embora o macOS e os BSD costumem trazer o traceroute com setuid root, por isso talvez não tenhas de escrever sudo antes dele. O Linux não traz, e o Fedora não traz, que é metade da razão por que o script acima existe.

Três armadilhas nessa tabela, e já vi as três desperdiçarem uma tarde.

Nos BSD e no macOS, o -p é uma porta base que incrementa a cada sonda. Por isso traceroute -P tcp -p 445 host testa a 445, depois a 446, depois a 447, e lá para o salto 10 estás a perguntar por uma porta de que nunca ninguém ouviu falar. Queres também o -e, a que a página do manual chama modo de evasão de firewall e que na verdade quer só dizer «mantém a porta quieta»:

sudo traceroute -P tcp -e -p 445 example.net     # macOS, FreeBSD

Em Linux, o -p sozinho faz o mesmo no método UDP predefinido e precisas de -U -p para uma porta UDP constante. Para TCP, o -T -p já é constante: a página do manual é explícita em que «for TCP and others specifies just the (constant) destination port to connect».

sudo traceroute -T -p 445 example.net            # Linux
sudo traceroute -U -p 53  example.net            # Linux, UDP/53 specifically

Em Solaris e NetBSD não há forma nenhuma de fixar a porta, e em Solaris o -P é uma pausa em segundos, por isso uma linha de comando copiada do Linux corre sem erro e não mede nada daquilo que pediste. O Solaris também não tem modo de sonda TCP. Este é o caso em que queres o script.

O Redox é o caso à parte e merece uma frase, porque conto com a pergunta. Todo o seu conjunto de ferramentas de rede é o netutils: dns, ifconfig, nc, ping, telnetd, wget. Sem traceroute, sem tcpdump, nada com que capturar. Se uma máquina Redox for uma das pontas do problema, mede a partir da outra ponta e aponta-lhe a caminhada.

O mtr também merece uma menção, porque faz a parte de repetir e tirar a média que as tabelas acima te obrigam a fazer à mão:

sudo mtr -T -P 445 --report --report-cycles 20 example.net

Corre isso contra a porta que falha e outra vez contra uma que funciona, lado a lado. O mesmo método, saída mais bonita.

Nada disto funciona se alguém bloquear o ICMP

Cada medição neste artigo é feita de erros ICMP a viajar de volta até mim. Bloqueia-os e o diagnóstico inteiro fica às escuras, e muito mais com ele.

Bloquear o ICMP por atacado ainda é tratado em alguns sítios como uma postura de segurança. Não é defensável desde os anos 90. Os ataques que se imagina que trava eram o ping of death e o smurf, ambos corrigidos nas pilhas de rede e não na fronteira, e ambos corrigidos antes de terem nascido alguns dos engenheiros que ainda repetem o conselho. O que o bloqueio geral trava hoje é o diagnóstico. Mais nada.

O RFC 1812 não deixa margem para interpretações neste ponto: o Time Exceeded é um MUST, e a norma diz que a razão é o traceroute depender dele. Deita-o fora e partiste uma ferramenta que o próprio documento de requisitos dos routers da internet aponta como a justificação para a mensagem existir.

A descoberta da MTU do caminho é a cara. Precisa que o ICMP 3/4, fragmentation needed, volte ao remetente. Filtra isso e tens a avaria que todos os engenheiros de rede já perseguiram pelo menos uma vez, aquela em que o handshake completa e as transferências pequenas funcionam e tudo o que leve um pacote de tamanho completo fica pendurado para sempre. O SSH liga e o scp empanca. A página carrega e a imagem nunca chega. Nada nos logs. Nada a que fazer grep.

Em IPv6 deixa de ser uma questão de gosto. O RFC 4890 §4.3.1 enumera as mensagens que uma firewall não pode deitar fora:

  • Destination Unreachable (Type 1) - All codes
  • Packet Too Big (Type 2)
  • Time Exceeded (Type 3) - Code 0 only
  • Parameter Problem (Type 4) - Codes 1 and 2 only

e sobre o Packet Too Big é direto quanto à consequência: «Effectively, parts of the Internet will become inaccessible.» Os routers IPv6 não fragmentam. Se o Packet Too Big não conseguir chegar ao remetente, não há caminho de recuperação.

O controlo é um limite de ritmo, não um drop. Permite o tipo 3 e o tipo 11 à entrada, conta-os, limita-os a qualquer coisa como cem por segundo, regista o que passar do limite, e manténs o diagnóstico, manténs a descoberta da MTU do caminho a funcionar, e manténs toda a proteção que se imaginava que a regra geral estava a dar à partida. Restringir quanto de uma coisa aceitas é um controlo. Recusar tudo e chamar-lhe endurecimento é só recusar ser medido.

Para quem gere um MSP: se a linha do teu cliente deita fora os erros ICMP, tiraste-lhe a capacidade de provar em que rede está uma avaria, e a ti também. Da próxima vez que uma avaria ficar entre dois fornecedores que dizem ambos estar limpos, essa é a conta da política.

Exceto o eco. Esse deita-o fora.

Tudo o que está acima é sobre erros ICMP. O eco é outro bicho, e é a única parte do protocolo que eu tiraria da linha na fronteira.

Vê o que a norma lhe exige. Em IPv4, o RFC 792 diz de um pedido de eco que «the data received in the echo message must be returned in the echo reply message». O IPv6 é ainda mais direto: o RFC 4443 define o campo como «zero or more octets of arbitrary data» e depois exige que «MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message».

Lê isso como um atacante e não como um operador. A norma obriga todos os hosts do planeta a aceitar um bloco de bytes que tu escolhes e a devolver-to tal e qual. Isso não é um efeito secundário. É um canal obrigatório, bidirecional, de carga arbitrária, a correr sobre um protocolo que a maioria das firewalls deixa passar sem inspecionar e que a maior parte dos registos guarda como contagem de pacotes e não como conteúdo.

Há trinta anos que se constroem túneis em cima dele. O Loki fê-lo na Phrack 49 em 1996. O Ptunnel leva uma sessão TCP inteira dentro de um ping e está a um pacote de distância há duas décadas. Se a tua política de saída é «bloquear tudo, permitir ICMP porque a equipa de rede precisa», não tens uma política de saída. Tens uma VPN com passos a mais, e o tráfego sai com ar de alguém a testar se a internet está em cima.

O RFC 4890 discorda de mim, e vale a pena dizê-lo com clareza em vez de citar só a metade que me convém. O §4.3.1 põe o Echo Request e o Echo Response na mesma lista de mensagens a não deitar fora que os erros. Depois lê a justificação que dá:

For Teredo tunneling [RFC4380] to IPv6 nodes on the site to be possible, it is essential that the connectivity checking messages are allowed through the firewall.

A razão declarada para manter o eco aberto é que alguém precisa de construir um túnel através da tua firewall com ele. Esse é o meu argumento, escrito pelas pessoas que defendem o contrário.

Por isso a política é estreita, não geral:

# transit rules. permit the errors, drop the ping
ip protocol icmp icmp type { destination-unreachable, time-exceeded, parameter-problem } \
    limit rate 100/second accept
ip protocol icmp icmp type { echo-request, echo-reply } drop

ip6 nexthdr ipv6-icmp icmpv6 type { destination-unreachable, packet-too-big, \
    time-exceeded, parameter-problem } limit rate 100/second accept
ip6 nexthdr ipv6-icmp icmpv6 type { echo-request, echo-reply } drop

Em IPv6, não leves esse padrão para uma cadeia link-local ou de host sem manter a descoberta de vizinhos. Os tipos 133 a 137, do nd-router-solicit ao nd-redirect, são a forma como o IPv6 faz o trabalho que o ARP faz em IPv4. Deita-os fora e o segmento deixa de funcionar em minutos, e não vai parecer uma avaria de firewall. Filtra o eco na fronteira, não na ligação entre um host e o seu próprio router.

Quanto é que isso te custa? O ping através da fronteira, e mais nada. Tudo o que está neste artigo continua a funcionar, porque nem uma das medições aqui envia um pedido de eco. O hopfind.py percorre TCP e UDP e lê os erros que voltam; o traceroute -T e o -U fazem o mesmo. A descoberta da MTU do caminho precisa do Packet Too Big, que é um erro. O truque do TTL inverso funciona com qualquer resposta, e um handshake TCP dá-te uma. A única coisa que perdes é a ferramenta menos informativa da caixa, e este artigo inteiro é um argumento sobre porque é que parar no ping é, à partida, o problema.

A minha própria linha já faz exatamente isto, embora duvide que tenha sido de propósito. O ping para o meu gateway predefinido dá 100% de perda, e o ICMP Time Exceeded desse mesmo gateway volta em 0,3 ms, como mostram todos os rastos deste artigo. Eco fechado, erros abertos. Quem lançou esse firmware acertou, e eu só descobri que tinha acertado por ir à procura.

A mesma regra, escrita uma só vez

Aqui está a avaria que não esperava encontrar em minha casa. Um resolver DNS público, percorrido em TCP/443 nas duas famílias, com minutos de diferença.

$ python3 hopfind.py 192.0.2.53 443 --max 10
walking to 192.0.2.53  TCP/443  hop limit 1-10
  1  *
  2  *
  3  *
  4  *
  5  *
  6  *
  7  *
  8  *
  9  *
 10  *

Verdict: nothing answered at all, not even the first hop.

Nada de nada. Nem um salto. O meu próprio router nem sequer reportou a expiração que tem de ter gerado, a mesma expiração que reportou em 0,3 ms em todas as outras caminhadas deste artigo, por isso o drop acontece no salto 1, antes de a verificação do limite de saltos chegar a correr, e o salto 1 é meu.

O caminho está bem, como o mesmo destino prova em UDP:

$ python3 hopfind.py 192.0.2.53 53 --proto udp --max 10
  1  198.51.100.254                              0.3 ms  ICMP 11/0 time exceeded in-transit
  2  198.51.100.133                              5.4 ms  ICMP 11/0 time exceeded in-transit
  3  *
  4  198.51.100.167                             14.5 ms  ICMP 11/0 time exceeded in-transit
  5  203.0.113.50                                6.3 ms  ICMP 11/0 time exceeded in-transit
  6  203.0.113.174                               5.7 ms  ICMP 11/0 time exceeded in-transit
  7  203.0.113.201                               6.4 ms  ICMP 11/0 time exceeded in-transit
  8  *

Sete saltos de respostas limpas para o mesmo endereço. Portanto não é o encaminhamento e não é o destino: alguma coisa na minha linha deita fora o TCP para esse host e deixa passar o UDP para ele.

Depois o mesmo resolver, a mesma porta, em IPv6:

$ python3 hopfind.py 2001:db8:53::53 443 -6 --max 10
walking to 2001:db8:53::53  TCP/443  hop limit 1-10
  1  2001:db8:1:ee:beef:abcd:fec0:2a30           0.5 ms  ICMP 3/0 hop limit exceeded in-transit
  2  2001:db8:1::15c                            24.6 ms  ICMP 3/0 hop limit exceeded in-transit
  3  *
  4  2001:db8:2:200::50                          5.5 ms  ICMP 3/0 hop limit exceeded in-transit
  5  2001:db8:2:2::4                             5.7 ms  ICMP 3/0 hop limit exceeded in-transit
  6  2001:db8:2:991::                           16.6 ms  ICMP 3/0 hop limit exceeded in-transit
  7  2001:db8:53::53                             5.7 ms  connected

Verdict: TCP/443 is open. It answered at hop 7.

A direito. Sete saltos, sem drama. O mesmo serviço, a mesma porta, a mesma intenção, e a regra só existe numa família de endereços.

Quem escreveu essa regra escreveu-a para IPv4 e nunca escreveu a gémea. Não faço ideia do que pretendia conseguir, o meu palpite é algo para manter o DNS local, mas fosse o que fosse, tem-no conseguido em metade do tráfego desde que esta linha tem IPv6. Se estava lá por uma razão, não funciona. Se não estava, não devia lá estar.

Essa é a versão do dia a dia do problema do dual-stack, e é muito mais comum do que as discussões sobre se se deve sequer implementar IPv6. Dois livros de regras. Um mantido.

O script, completo

Sem dependências, sem instalação, nada além da biblioteca padrão. Python 3.6 ou posterior, e em Linux sem privilégio nenhum.

As duas classes são toda a história da portabilidade. A ErrorQueue é o caminho do Linux: ativa IP_RECVERR no socket e, depois de a sonda falhar, lê MSG_ERRQUEUE e tira o endereço do router da estrutura sock_extended_err à qual o kernel o acrescenta. A RawIcmp é para todo o resto: abre um raw socket ICMP, lê o que chegar, tira o endereço de origem do pacote. A primeira não precisa de nada, a segunda precisa de root, e o resto do programa não quer saber qual delas lhe calhou.

Há um pormenor que vale a pena apontar porque é a diferença entre uma resposta certa e uma plausível. Em probe() a fila de erros é esvaziada antes de se consultar o SO_ERROR. Um erro ICMP chega a um socket TCP como um errno simples, ICMP 3/3 port unreachable chega como ECONNREFUSED, exatamente como um reset verdadeiro, por isso verificar primeiro o SO_ERROR teria reportado o reset SMTP forjado mais acima neste artigo como uma recusa honesta da outra ponta. Lê primeiro a fila e o ee_origin diz-te que foi um router a falar.

#!/usr/bin/env python3
"""hopfind - work out how many hops away the thing blocking your port is.

Walks the IPv4 TTL, or the IPv6 hop limit, up from 1 and records which router
answers at each step - using the protocol and port you actually care about
instead of traceroute's default UDP high ports.

Run it twice. Once against something that works, once against the port that
does not. The hop where the answers stop is the device dropping you, and the
run that works gives you its address.

    python3 hopfind.py example.net 445            # the port under suspicion
    python3 hopfind.py example.net 443            # the reference run
    python3 hopfind.py example.net 53 --proto udp
    python3 hopfind.py 2001:db8::1 443 -6

On Linux this needs no privileges at all: IP_RECVERR and IPV6_RECVERR hand the
ICMP errors back on the ordinary socket that caused them. On macOS, the BSDs
and Solaris the errors have to be read off a raw ICMP socket, which means root.

Written for https://blogs.damiendye.uk/networking/how-far-away-is-the-firewall/
Public domain. Do what you like with it.
"""

import argparse
import errno
import os
import select
import socket
import struct
import sys
import time

# Linux socket options. Absent from the socket module on some builds, so they
# are spelled out rather than looked up.
IP_RECVERR = 11
IPV6_RECVERR = 25

# ee_origin values from linux/errqueue.h. Anything else means the errno came
# from the local stack rather than from a router.
SO_EE_ORIGIN_ICMP = 2
SO_EE_ORIGIN_ICMP6 = 3

ICMP_V4 = {
    (11, 0): "time exceeded in-transit",
    (11, 1): "fragment reassembly time exceeded",
    (3, 0): "net unreachable",
    (3, 1): "host unreachable",
    (3, 2): "protocol unreachable",
    (3, 3): "port unreachable",
    (3, 4): "fragmentation needed",
    (3, 9): "net administratively prohibited",
    (3, 10): "host administratively prohibited",
    (3, 13): "communication administratively prohibited",
    (5, 0): "redirect",
}

ICMP_V6 = {
    (3, 0): "hop limit exceeded in-transit",
    (3, 1): "fragment reassembly time exceeded",
    (1, 0): "no route to destination",
    (1, 1): "communication administratively prohibited",
    (1, 3): "address unreachable",
    (1, 4): "port unreachable",
    (2, 0): "packet too big",
}


def describe(family, icmp_type, icmp_code):
    table = ICMP_V4 if family == socket.AF_INET else ICMP_V6
    return table.get((icmp_type, icmp_code), "unrecognised")


def is_expiry(family, icmp_type):
    """Was this the router saying 'your hop budget ran out here'?"""
    return icmp_type == (11 if family == socket.AF_INET else 3)


class ErrorQueue:
    """Linux. The kernel reports the ICMP error on the socket that provoked it."""

    def arm(self, sock, family):
        if family == socket.AF_INET:
            sock.setsockopt(socket.IPPROTO_IP, IP_RECVERR, 1)
        else:
            sock.setsockopt(socket.IPPROTO_IPV6, IPV6_RECVERR, 1)

    def extra_readers(self):
        return []

    def collect(self, sock, family):
        try:
            _, ancillary, _, _ = sock.recvmsg(0, 1024, socket.MSG_ERRQUEUE)
        except OSError:
            return None
        wanted = (socket.IPPROTO_IP, IP_RECVERR) if family == socket.AF_INET \
            else (socket.IPPROTO_IPV6, IPV6_RECVERR)
        for level, kind, data in ancillary:
            if (level, kind) != wanted or len(data) < 16:
                continue
            # struct sock_extended_err, then the sockaddr of the router that
            # sent the error - SO_EE_OFFENDER in the kernel headers.
            _, origin, icmp_type, icmp_code = struct.unpack_from("=IBBB", data, 0)
            if origin not in (SO_EE_ORIGIN_ICMP, SO_EE_ORIGIN_ICMP6):
                return None
            addr = None
            if len(data) >= 24:
                offender_family, = struct.unpack_from("=H", data, 16)
                if offender_family == socket.AF_INET:
                    addr = socket.inet_ntoa(data[20:24])
                elif offender_family == socket.AF_INET6 and len(data) >= 40:
                    addr = socket.inet_ntop(socket.AF_INET6, data[24:40])
            return addr, icmp_type, icmp_code
        return None


class RawIcmp:
    """macOS, the BSDs, illumos, Solaris. Read the ICMP off a raw socket, as root."""

    def __init__(self, family):
        proto = socket.IPPROTO_ICMP if family == socket.AF_INET else socket.IPPROTO_ICMPV6
        self.sock = socket.socket(family, socket.SOCK_RAW, proto)
        self.sock.setblocking(False)

    def arm(self, sock, family):
        pass

    def extra_readers(self):
        return [self.sock]

    def collect(self, sock, family):
        try:
            packet, peer = self.sock.recvfrom(1500)
        except OSError:
            return None
        if family == socket.AF_INET:
            # BSD raw sockets hand back the IP header too.
            header_len = (packet[0] & 0x0F) * 4
            packet = packet[header_len:]
        if len(packet) < 2:
            return None
        return peer[0], packet[0], packet[1]


def probe(dest, port, proto, family, hop_limit, timeout, listener):
    """One probe at one hop limit. Returns (icmp, socket_state, note)."""
    kind = socket.SOCK_STREAM if proto == "tcp" else socket.SOCK_DGRAM
    sock = socket.socket(family, kind)
    if family == socket.AF_INET:
        sock.setsockopt(socket.IPPROTO_IP, socket.IP_TTL, hop_limit)
    else:
        sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_UNICAST_HOPS, hop_limit)
    listener.arm(sock, family)
    sock.setblocking(False)

    try:
        if kind == socket.SOCK_DGRAM:
            sock.connect((dest, port))
            sock.send(b"\x00" * 32)
        else:
            try:
                sock.connect((dest, port))
            except BlockingIOError:
                pass
    except OSError as exc:
        sock.close()
        return None, None, "local error: %s" % exc.strerror

    readers = [sock] + listener.extra_readers()
    writers = [] if kind == socket.SOCK_DGRAM else [sock]
    deadline = time.time() + timeout
    icmp = state = None

    while time.time() < deadline:
        ready_r, ready_w, ready_x = select.select(
            readers, writers, [sock], max(0.01, deadline - time.time()))
        if not (ready_r or ready_w or ready_x):
            continue
        # Drain the error queue first, always. An ICMP error reaches a TCP
        # socket as a plain errno, so SO_ERROR on its own cannot tell you
        # whether a router spoke or the far end did.
        icmp = listener.collect(sock, family)
        if icmp:
            break
        if ready_w:
            err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
            if err == 0:
                state = "connected"
            elif err == errno.ECONNREFUSED:
                state = "TCP reset"
            else:
                state = os.strerror(err)
            break

    sock.close()
    if icmp or state:
        return icmp, state, None
    return None, None, "no reply"


def walk(dest, port, proto, family, first, last, timeout, listener):
    print("walking to %s  %s/%d  hop limit %d-%d" % (dest, proto.upper(), port, first, last))
    answered = []
    for hop in range(first, last + 1):
        started = time.time()
        icmp, state, _ = probe(dest, port, proto, family, hop, timeout, listener)
        rtt = (time.time() - started) * 1000
        if icmp:
            addr, icmp_type, icmp_code = icmp
            print(" %2d  %-39s %7.1f ms  ICMP %d/%d %s"
                  % (hop, addr or "?", rtt, icmp_type, icmp_code,
                     describe(family, icmp_type, icmp_code)))
            if is_expiry(family, icmp_type):
                answered.append((hop, addr))
            else:
                return answered, hop, "icmp-reject", addr
        elif state:
            print(" %2d  %-39s %7.1f ms  %s" % (hop, dest, rtt, state))
            return answered, hop, state, dest
        else:
            print(" %2d  *" % hop)
    return answered, None, "silent", None


def main():
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("host")
    parser.add_argument("port", nargs="?", type=int, default=443)
    parser.add_argument("--proto", choices=("tcp", "udp"), default="tcp")
    parser.add_argument("--first", type=int, default=1, help="hop limit to start at")
    parser.add_argument("--max", type=int, default=20, help="hop limit to stop at")
    parser.add_argument("--wait", type=float, default=2.0, help="seconds to wait per hop")
    parser.add_argument("-6", dest="v6", action="store_true", help="force IPv6")
    parser.add_argument("-4", dest="v4", action="store_true", help="force IPv4")
    args = parser.parse_args()

    family = socket.AF_INET6 if args.v6 else socket.AF_INET
    kind = socket.SOCK_STREAM if args.proto == "tcp" else socket.SOCK_DGRAM
    dest = socket.getaddrinfo(args.host, args.port, family, kind)[0][4][0]

    if sys.platform.startswith("linux"):
        listener = ErrorQueue()
    else:
        try:
            listener = RawIcmp(family)
        except PermissionError:
            sys.exit("%s cannot report ICMP errors on a normal socket, so this "
                     "needs a raw one. Run it as root." % sys.platform)

    answered, stop, why, who = walk(dest, args.port, args.proto, family,
                                    args.first, args.max, args.wait, listener)
    what = "%s/%d" % (args.proto.upper(), args.port)
    print()

    if why == "connected":
        print("Verdict: %s is open. It answered at hop %d." % (what, stop))
    elif why == "icmp-reject":
        print("Verdict: %s at hop %d is refusing %s on policy, and is honest "
              "enough to say so." % (who, stop, what))
    elif why == "TCP reset":
        print("Verdict: a reset came back to a probe with a hop limit of %d." % stop)
        print("         Nothing more than %s away can have sent it, so check the reply"
              % ("one hop" if stop == 1 else "%d hops" % stop))
        print("         TTL before you believe the host did.")
    elif answered:
        last_hop, last_addr = answered[-1]
        print("Verdict: answers stop after hop %d (%s)." % (last_hop, last_addr))
        print("         Whatever swallows %s is hop %d." % (what, last_hop + 1))
        print("         Walk a port that works and read off the address at hop %d."
              % (last_hop + 1))
    else:
        print("Verdict: nothing answered at all, not even the first hop. Either the")
        print("         first hop is the one dropping you, or the ICMP errors are being")
        print("         filtered on the way back. Walk a port that works to tell those")
        print("         two apart.")


if __name__ == "__main__":
    main()

O que isto não te consegue dizer

O método é barato e é honesto sobre quase tudo, mas não é um scanner de topologia. Sê franco no ticket sobre o que mediste de facto.

Tuplos de cinco elementos diferentes podem seguir caminhos diferentes. O ECMP faz hash das portas de origem e de destino na escolha do próximo salto, por isso não há garantia nenhuma de que duas execuções em duas portas diferentes atravessem os mesmos routers, que é uma das duas coisas que podiam explicar o salto 5 acima responder a uma execução e ficar calado na outra. Repete as duas execuções. Uma fronteira que se mexe não está provada.

O MPLS esconde saltos. Um núcleo com comutação de etiquetas pode apresentar-se como um salto, ou como nenhum. Qualquer contagem através da rede dorsal de outra pessoa é um limite inferior.

A geração de ICMP tem limite de ritmo em quase todo o lado. Sonda mais depressa do que o router responde e fabricas as tuas próprias estrelas. O hopfind.py envia uma sonda por salto e espera; é de propósito.

O caminho de volta não tem de coincidir com o de ida. A contagem de saltos à ida não é a contagem de saltos à volta, e a aritmética do TTL inverso mede só a perna de regresso.

Anycast quer dizer que o host no salto N pode não ser a mesma caixa duas vezes. Resolvers públicos e CDN, em particular.

Um handshake completo não quer dizer que a sessão sobrevive. Uma firewall com estado pode permitir o SYN e deitar fora o que vem a seguir após inspeção. Se a ligação abre e depois morre, este é o instrumento errado: vai capturar.

Encontraste o primeiro dispositivo que deita fora, não aquele que alguém vai admitir. Numa CGN ou numa rede de operador, o endereço no salto N+1 pode ser uma de várias caixas atrás de um só endereço. Continua a ser a coisa certa a citar, porque é um facto sobre o caminho.

Para que serve de facto

Acabar com o pingue-pongue. É todo o retorno do exercício.

«A porta 445 está bloqueada algures» é um convite a devolver o ticket. Isto não é:

TCP/445 para 192.0.2.4 é deitado fora em silêncio no salto 11, endereço 192.0.2.31. O salto 11 responde com ICMP Time Exceeded a TCP/443 no mesmo caminho em 26 ms e não responde rigorosamente nada na 445, por isso o drop é uma decisão de política nesse dispositivo, não uma avaria de encaminhamento. Os dez saltos à frente dele estão limpos. Reproduzido quatro vezes ao longo de vinte minutos, a partir de uma shell sem privilégios, script em anexo.

Ninguém devolve isso. Dá nome a um dispositivo, diz o que ele fez, diz o que ele não fez, e mostra as contas. Se decidem mudá-lo continua a ser decisão deles. Mas a semana de pingue-pongue acabou, e bastaram quatro comandos.

Tudo isto saiu de um campo de 8 bits que foi especificado como temporizador em 1981, nunca foi usado como tal uma única vez, e transforma discretamente «algures» num endereço.

Vale a pena aprender a lê-lo.