Una connessione che va in timeout non ti dice quasi niente. Dall’altra parte potrebbe non esserci nulla in ascolto, un firewall a tre hop potrebbe scartare il tuo SYN in silenzio senza generare nemmeno una riga di log, oppure la rotta potrebbe semplicemente non esistere. E da dove sei seduto, ognuno di questi casi sembra identico. Aspetti. Non succede niente.
Così il ticket viene scritto come «la porta 445 è bloccata da qualche parte», ed è proprio quel «da qualche parte» che lo fa rimbalzare. Il tuo provider controlla il suo edge, lo trova pulito e te lo rimanda. Tu controlli il firewall dell’host, lo trovi pulito e lo rimandi indietro. Passa una settimana. Non si è sistemato niente.
La parola che fa il danno è «da qualche parte». E non è necessaria. Ogni router tra te e la destinazione è obbligato a dirti quando è lui il colpevole, e quell’obbligo è scritto negli standard dal 1995. Devi solo chiedere nel modo giusto.
Perché bisogna spiegarlo per filo e per segno
Perché troppa gente in questo settore non sa fare le cose di base, e costa ai loro datori di lavoro soldi veri ogni settimana.
Non parlo dei junior. Parlo di persone con anni di esperienza alle spalle, certificazioni appese al muro e «senior» nel titolo, la cui diagnosi di una porta in timeout si ferma a «è bloccata» e non va oltre. Lanciano ping. Fallisce, o funziona, e in entrambi i casi non hanno imparato niente sulla porta di cui gli avevano chiesto. Poi il ticket va al provider, il provider lo rimbalza, e due settimane dello stipendio di qualcuno finiscono in una discussione che poteva essere un solo comando.
Niente di tutto questo è difficile. Distinguere un drop da un reject, leggere il TTL di una risposta, sapere che un asterisco in un traceroute da solo non significa nulla: è un pomeriggio per impararlo e dura tutta la carriera. Il motivo per cui la gente non lo sa non è che sia stupida. È che nessuno lo insegna. La formazione dei vendor ti insegna la console del vendor. Le certificazioni ti insegnano l’esame. I fondamentali che stanno sotto vengono dati per scontati dal primo giorno e mai davvero spiegati, così la gente arriva ai ruoli senior senza che nessuno glieli abbia mai mostrati, e a quel punto è imbarazzante chiedere.
Quindi, invece di lamentarmene, eccolo messo per iscritto. Sono le basi, spiegate per bene, con i comandi e uno script che puoi lanciare oggi.
E una parola sul perché me ne sono preso la briga: mentre lo scrivevo l’ho lanciato sulla mia linea e ho trovato tre guasti che non sapevo di avere. Un drop di SMB a undici hop. Reset SMTP falsificati a un hop di distanza. Una regola di firewall che esiste su IPv4 e non su IPv6. Un pomeriggio, senza root, su una linea che gestisco io e a cui faccio attenzione. Pensa un attimo a cosa se ne sta lì inosservato sulle reti che qualcuno viene pagato per gestire.
Perché il Fisher-Price OS (Windows) non è qui
Due motivi per cui non c’è. Uno è tecnico e l’altro no, e preferisco darti tutti e due piuttosto che fingere che sia tutta ingegneria.
Quello tecnico è che non ci riesce. tracert invia ICMP echo request e nient’altro: il riferimento di Microsoft stessa lo descrive come «sending Internet Control Message Protocol (ICMP) echo Request or ICMPv6 messages to the destination with incrementally increasing time to live (TTL) field values», e nella sua sintassi non c’è un parametro per la porta da nessuna parte. pathping è lo stesso strumento con delle statistiche attaccate sopra. Test-NetConnection ti dirà se una porta TCP è aperta o chiusa e assolutamente niente su quanto lontano sia arrivata la risposta. Nessuno di loro può sondare la porta che ti interessa davvero a una distanza scelta, che è l’intero metodo di questo articolo.
E non puoi nemmeno aggirarlo con uno script. Impostare il TTL su un socket in .NET è abbastanza facile, ma rileggere l’errore ICMP è la metà difficile, e non esiste un equivalente del trucco su cui si appoggia questo articolo: nessun modo di farsi riportare dal kernel l’errore sul socket ordinario che l’ha causato. Resta un raw socket, e la documentazione di Microsoft stessa dice «only members of the Administrators group can create sockets of type SOCK_RAW». Quindi la strada senza privilegi non esiste e quella con privilegi vuole un token di amministratore locale. Sei già ai download di terze parti prima di aver cominciato.
L’altro motivo è che non mi interessa, e preferisco dirlo piuttosto che abbellirlo. Nemmeno il nome è un colpo basso, è una descrizione. È il sistema operativo che ti mettono in mano quando non ne hai mai avuto un altro, ti nasconde la macchina come obiettivo di progetto e non per caso, e nel momento in cui vuoi fare alla rete una domanda precisa scopri che lo strumento non è mai stato costruito, perché dalle persone per cui è costruito non ci si è mai aspettati che la facessero. Trent’anni dopo, tracert non riesce ancora a mirare un pacchetto a una porta.
Non è un sistema operativo vero per chi fa IT sul serio, e se è l’unico che hai mai usato allora non stai facendo questo lavoro al livello per cui è scritto questo articolo. So che suona male. Non scrivo per piacere, metto per iscritto quello che misuro per persone che misurano le cose, e non mi importa granché che qualcuno che ha usato solo quello preferirebbe che lo dicessi in un altro modo.
L’argomento è l’elenco degli strumenti, non l’opinione. Ogni Unix nella tabella più sotto ti permette di impostare un limite di hop e scegliere un protocollo, quattro di loro con un solo comando, e Linux fa l’intera misurazione senza nemmeno sudo. Non è perché siano più difficili da usare. È perché sono stati costruiti da persone che si aspettavano che chi stava alla tastiera volesse sapere le cose. Un sistema operativo la cui diagnostica finisce con ping ti ha detto chiaramente cosa pensa di chi lo usa, e trent’anni di persone che l’hanno accettato sono il modo in cui siamo finiti con un settore che non sa localizzare un pacchetto scartato.
Quindi non lo uso, non lo uso sul serio da anni, e non gli scriverò una sezione tutta sua per sembrare imparziale riguardo a una lacuna che è reale. Tutto ciò su cui costruisco e tutto ciò da cui vale la pena misurare è Unix, ed è lì che vive questo articolo.
Se la macchina guasta per caso gira con il Fisher-Price OS (Windows), questo non cambia niente del metodo. Procurati una shell su qualsiasi altra cosa, una VM Linux, un Mac, un Raspberry Pi sullo stesso switch, e fai salire il limite di hop verso di lei. Alla misurazione non importa minimamente cosa gira dall’altra parte. Le importa solo cosa c’è in mezzo.
Il TTL è un budget di hop, e ogni router ti deve una ricevuta
L’header IPv4 ha un campo Time to Live di 8 bit. Il nome è un residuo: era specificato in secondi, e niente lo tratta più come secondi da decenni. RFC 1812 ha chiuso la questione nel 1995 e ha reso normativa la lettura come conteggio di hop:
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.
Poi la parte che conta qui, dalla stessa sezione:
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.
È un MUST. Non una cortesia, non un suggerimento. RFC 792 nel 1981 diceva solo che un gateway «may also notify the source host»; tredici anni dopo il requisito è stato reso più severo, e RFC 1812 dice perché senza giri di parole:
ICMP Time Exceeded messages are required because the traceroute diagnostic tool depends on them.
IPv6 ha lasciato perdere la finzione e ha rinominato il campo. RFC 8200 lo chiama Hop Limit, «8-bit unsigned integer. Decremented by 1 by each node that forwards the packet», e il messaggio di scadenza è diventato ICMPv6 tipo 3, codice 0, «hop limit exceeded in transit».
Leggilo come uno strumento e non come una regola, e dice qualcosa di utile. Ogni router sul percorso è un faro che puoi indirizzare per distanza. Imposta il limite di hop a 4 e il quarto router si identifica. Non ti serve conoscere la topologia, non ti serve accesso a niente e non ti serve la collaborazione dell’operatore. Ti serve un pacchetto per hop.
Traceroute fa esattamente questo dalla fine degli anni Ottanta. Quello che fa male è proprio la cosa che ti interessa, perché di default sonda porte UDP nella fascia 33434, una porta che nessuno filtra e nessuno serve, quindi ti racconta di un percorso che niente di reale usa mai. Un traceroute pulito verso un host che non raggiungi su TCP/445 dimostra solo che UDP/33434 ci arriva. Che non era mai la domanda.
Quindi sonda la porta che ti interessa.
Leggi cosa è tornato indietro, non se è tornato qualcosa
Prima di contare gli hop, guarda cosa fa l’altra parte quando la raggiungi con un limite di hop normale. Ci sono cinque risposte distinte e la gente le schiaccia regolarmente in una sola.
| Cosa torna indietro | Cosa significa | Chi l’ha inviato |
|---|---|---|
| SYN-ACK, la connessione si apre | la porta è aperta | l’host, o qualcosa che risponde al suo posto |
| TCP RST | rifiutata attivamente | l’host senza niente in ascolto, oppure un dispositivo configurato per rifiutare |
| ICMP 3/13, communication administratively prohibited | un dispositivo rifiuta per policy e lo dichiara | quel dispositivo: il suo indirizzo sorgente è la tua risposta |
| ICMP 3/1, 3/2, 3/3 | host, protocollo o porta irraggiungibile | l’ultimo router, o l’host |
| niente di niente | qualcuno scarta in silenzio | sconosciuto, quindi vai a misurarlo |
La terza riga è quella per cui vale la pena cambiare abitudini. Quando un firewall è configurato per rifiutare invece di scartare, mette il proprio indirizzo nel campo sorgente dell’ICMP e ti consegna il colpevole gratis. Su Linux è ciò che produce nft ... reject with icmpx admin-prohibited, e ciò che iptables -j REJECT --reject-with icmp-admin-prohibited ha sempre prodotto. La maggior parte degli strumenti lo butta via e stampa «filtered». nmap --reason te lo mostra. Anche lo script più sotto.
Le righe due e cinque sono il guasto interessante. Un drop silenzioso è una decisione di policy di non dirti niente, e siccome è il comportamento predefinito su quasi tutti i firewall commerciali è quello che incontrerai davvero. Aspettati il silenzio.
Anche la riga due merita sospetto. Un reset non prova che l’host l’abbia inviato, e ci tornerò con un esempio dal vivo, perché ne ho trovato uno sulla mia linea mentre scrivevo questo.
Percorri la porta che ti interessa, due volte
Il metodo è due esecuzioni e un confronto. Tutto qui.
- Fai salire il limite di hop da 1 a 20 usando esattamente il protocollo e la porta che falliscono, e annota quale router risponde a ogni hop.
- Fai lo stesso con qualcosa che funziona, idealmente lo stesso host e una porta che si apre.
- L’hop in cui le risposte si fermano nella prima esecuzione, e continuano nella seconda, è il dispositivo che ti scarta. La seconda esecuzione ti dà il suo indirizzo.
Perché le risposte si fermano invece di cambiare: un router applica la sua access list in ingresso prima di fare qualsiasi altra cosa con il pacchetto, quindi se la policy dice drop il pacchetto sparisce prima che il percorso di forwarding guardi il limite di hop, non viene generato nessun Time Exceeded, e il dispositivo non mette mai il suo nome su quello che ha fatto. Per questo il silenzio comincia *all’*hop colpevole, non dopo.
Ho scritto un piccolo strumento per la camminata perché nessuno di quelli nativi la fa in modo portabile. Imposta IP_TTL (o IPV6_UNICAST_HOPS) su un socket ordinario, si connette e rilegge l’errore ICMP. Su Linux IP_RECVERR riporta quell’errore proprio sul socket che l’ha provocato, il che significa che tutto gira senza privilegi: niente root, niente raw socket, niente capability. Su macOS, i BSD e Solaris il kernel non ti consegna l’ICMP in quel modo, quindi ripiega su un raw socket e richiede root.
Sono 279 righe di libreria standard e nient’altro, e il tutto è stampato alla fine di questo articolo se preferisci leggerlo invece di scaricarlo.
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 lo stesso protocollo per entrambe le esecuzioni. Confrontare una traccia TCP con una traccia ICMP significa confrontare due percorsi, perché il bilanciamento del carico fa l’hash sulla quintupla e ICMP non ha porte su cui fare l’hash. Stesso host, stesso protocollo, porta diversa: questo è il confronto onesto.
Tutto quello che segue è output reale della mia linea del 28 agosto 2026, eseguito come utente senza privilegi su Fedora. Ogni indirizzo è stato riscritto negli intervalli di documentazione: RFC 5737 per IPv4, RFC 3849 per IPv6, con anche l’unico interface identifier alterato. Quindi 198.51.100.x è il mio router e il mio ISP, 203.0.113.x è transit e peering, 192.0.2.x è la rete lontana, e 2001:db8::/32 è l’intero percorso IPv6. La struttura è preservata ovunque: stessi confini di prefisso, stesse forme della parte host, stesso numero di reti distinte. I numeri di hop, i tempi, i tipi ICMP e quale hop è rimasto in silenzio sono esattamente come misurati.
Un host, tre porte, tre guasti diversi
Stessa destinazione per tutto il tempo: un host su internet pubblica, a quattordici hop, con la 443 aperta. Prima l’esecuzione di riferimento.
$ 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.
Nota gli hop 3, 5, 12 e 13. Quattro router su un percorso che funziona chiaramente non hanno detto niente, perché parecchio hardware è configurato per non generare ICMP per conto proprio, o lo limita pesantemente. Un asterisco non è una prova di un firewall. Se ti porti via una sola cosa, porta via questa. Il segnale non è mai la presenza di asterischi in una singola esecuzione; è il punto in cui due esecuzioni smettono di concordare.
Ora lo stesso host sulla 445, che da qui va in 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.
L’hop 11 ha risposto all’esecuzione sulla 443 in 26,6 ms e non ha detto assolutamente niente all’esecuzione sulla 445. Stessa macchina, stesso percorso, stessi dieci router davanti. Incrocia con l’esecuzione che funziona e l’hop 11 ha un nome: 192.0.2.31. È il dispositivo che scarta SMB, tre hop prima della destinazione e otto hop oltre l’edge del mio provider. Non il mio, e non quello del mio ISP.
L’hop 5 dimostra la cosa sugli asterischi dalla direzione opposta. Era un asterisco nell’esecuzione sulla 443 e ha risposto in quella sulla 445: al contrario del guasto. Potrebbe essere il rate limiting dell’ICMP, o potrebbero essere le due esecuzioni che prendono percorsi diversi attraverso un load balancer. Non so quale delle due, e non lo saprai neanche tu. Ripeti entrambe le esecuzioni prima di credere all’una o all’altra.
Poi la porta 25. Questa mi ha fermato.
$ 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.
Un limite di hop pari a 1 significa che il pacchetto è morto sul mio router. Ha fatto un hop. Non può averne percorsi quattordici. Eppure un reset TCP è tornato in 0,4 ms con l’indirizzo della destinazione sopra, e il mio kernel ha diligentemente riportato connection refused. Senza il limite di hop impostato l’avrei letto come «dall’altra parte non c’è nessun mail server» e avrei chiuso il ticket.
Qualcosa a un hop di distanza sta falsificando reset per l’SMTP in uscita e li firma con l’indirizzo della destinazione. Bloccare la 25 in uscita è una cosa del tutto normale per un router domestico o un ISP, e farlo con un reset invece che con un drop è probabilmente la versione educata, ma il reset porta l’indirizzo di qualcun altro e non avevo idea che il mio lo facesse. È il limite di hop che l’ha beccato, e nient’altro nella risposta l’avrebbe fatto.
Sbagliato di uno: dove sta l’access list nella pipeline
Il verdetto qui sopra dice che chi scarta è l’hop 11 perché le risposte si sono fermate dopo l’hop 10. Fai attenzione con questa aritmetica, perché dipende dall’ordine in cui il dispositivo colpevole fa due lavori.
La maggior parte dell’hardware applica prima la policy in ingresso e poi il controllo del limite di hop. Il deny scatta, il pacchetto viene scartato e nessun Time Exceeded viene mai generato, quindi il dispositivo non compare mai e il silenzio comincia al suo stesso numero di hop. È il caso qui sopra. È anche quello comune.
Alcune piattaforme gestiscono la scadenza del limite di hop nel fast path prima che la policy venga valutata. Lì il dispositivo risponde alla sonda indirizzata a lui e scarta solo le sonde mirate oltre, quindi compare normalmente e il silenzio comincia un hop dopo.
Quindi la lettura onesta di «le risposte si fermano dopo l’hop N» è: chi scarta è l’hop N+1 se ha cestinato la tua sonda prima di accorgersi che il budget era finito, oppure l’hop N stesso se ha risposto alla sonda indirizzata a lui e ha ingoiato tutto quello mirato oltre. Due dispositivi adiacenti, e l’esecuzione che funziona li nomina entrambi. Cita gli indirizzi, non il numero di hop: un numero di hop non significa niente per chi legge il tuo ticket, che sta contando da un altro punto.
Il TTL della risposta ti dice chi ha risposto davvero
Il reset SMTP qui sopra è stato beccato dal limite di hop in uscita. C’è un secondo controllo, indipendente, disponibile in ogni risposta che torna indietro, e non costa niente.
I valori iniziali del TTL non sono standardizzati, ma in pratica sono tre:
| Parte da | Mittente tipico |
|---|---|
| 64 | Linux, macOS, i BSD, illumos, la maggior parte degli host |
| 255 | Cisco IOS, Junos, Solaris, il traffico proprio della maggior parte dell’hardware di rete |
| 128 | il Fisher-Price OS (Windows), che ti serve comunque per leggerne una risposta |
Sottrai il TTL che hai ricevuto dal valore successivo verso l’alto e riottieni il numero di hop. Una risposta che arriva con TTL 50 è partita da 64 e ha fatto 14 hop. Una che arriva con TTL 250 è partita da 255 e ne ha fatti 5. ping lo stampa senza che tu lo chieda:
ping -c1 192.0.2.4 # ttl=50 → 14 hops away
tcpdump -n -v 'icmp' # -v prints the ttl of every packet it shows
Ne vengono fuori due cose. Tutte e due gratis.
Una risposta il cui numero di hop di ritorno non corrisponde alle altre risposte dell’host non è stata inviata dall’host. Se un echo reply da un server torna da 14 hop e l’RST sulla porta 25 torna da 1 hop, l’RST l’ha scritto un middlebox. Stesso trucco della sezione precedente, dall’altra estremità, e funziona anche quando non puoi impostare il TTL in uscita.
Una risposta partita da 255 viene da hardware di rete, non da un server. Utile quando cerchi di capire se a rifiutarti è l’host o il router davanti a lui.
Per vedere il campo su TCP invece che su ICMP ti serve una cattura, e vale la pena memorizzare il 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'
tcpdump stampa la scadenza come ICMP time exceeded in-transit: la stessa frase che usano gli standard, e lo stesso evento che compare come «TTL expired in transit» sulle piattaforme che lo formulano così.
Lo stesso trucco con gli strumenti nativi, su cinque Unix
Se preferisci non lanciare uno script, gli strumenti nativi fanno quasi tutto. Solo che sono in disaccordo tra loro più di quanto ti aspetteresti. -P in particolare significa tre cose diverse a seconda di quale traceroute hai in mano, e una di queste ti rovinerà il test senza dire niente.
Linux (traceroute 2.1.x) | macOS / FreeBSD | OpenBSD | NetBSD | Solaris 11 | |
|---|---|---|---|---|---|
| Sonde TCP | -T | -P tcp | non utilizzabile | no | no |
| Sonde ICMP | -I | -I | -I | -I | -I |
| UDP verso una porta fissa | -U -p N | -e -p N | no | no | no |
| porta di destinazione | -p N (costante per TCP) | -p N (incrementa senza -e) | -p N (incrementa) | -p N (incrementa) | -p N (incrementa) |
cosa significa -P | non usato | protocollo della sonda | protocollo numerico, «will not work reliably for most protocols» | imposta DF e sonda il path MTU | pausa tra le sonde, in secondi |
| richiede privilegi | sì, per -T e -I | sì | sì | sì | sì |
Ognuno di questi richiede raw socket, quindi ognuno richiede privilegi, anche se macOS e i BSD di solito distribuiscono traceroute con setuid root, quindi potresti non dover scrivere sudo davanti. Linux no, e Fedora no, ed è metà del motivo per cui esiste lo script qui sopra.
Tre trappole in quella tabella, e le ho viste sprecare un pomeriggio tutte e tre.
Sui BSD e su macOS, -p è una porta base che incrementa a ogni sonda. Quindi traceroute -P tcp -p 445 host prova la 445, poi la 446, poi la 447, e all’hop 10 stai chiedendo di una porta di cui nessuno ha mai sentito parlare. Ti serve anche -e, che la man page chiama firewall evasion mode e che in realtà significa solo «tieni ferma la porta»:
sudo traceroute -P tcp -e -p 445 example.net # macOS, FreeBSD
Su Linux, -p da solo fa la stessa cosa per il metodo UDP predefinito e ti serve -U -p per una porta UDP costante. Per TCP, -T -p è già costante: la man page è esplicita nel dire che «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
Su Solaris e NetBSD non c’è proprio modo di fissare la porta, e su Solaris -P è una pausa in secondi, quindi una riga di comando Linux copiata girerà senza errori e non misurerà niente di quello che hai chiesto. Solaris non ha nemmeno una modalità di sonda TCP. È il caso in cui ti serve lo script.
Redox è l’eccezione e merita una frase perché mi aspetto la domanda. Tutto il suo kit di rete è netutils: dns, ifconfig, nc, ping, telnetd, wget. Niente traceroute, niente tcpdump, niente di niente per catturare. Se una macchina Redox è un’estremità del problema, misura dall’altra estremità e punta la camminata verso di lei.
Anche mtr merita una menzione, perché fa la parte di ripetere e fare la media che le tabelle qui sopra ti costringono a fare a mano:
sudo mtr -T -P 445 --report --report-cycles 20 example.net
Lancialo contro la porta che fallisce e di nuovo contro una che funziona, uno accanto all’altro. Stesso metodo, output più carino.
Niente di tutto questo funziona se qualcuno blocca l’ICMP
Ogni misurazione di questo articolo è fatta di errori ICMP che tornano verso di me. Bloccali e l’intera diagnostica si spegne, e con lei un bel po’ di altre cose.
Bloccare l’ICMP in blocco è ancora trattato come una postura di sicurezza in certi posti. Non è difendibile dagli anni Novanta. Gli attacchi che si immagina fermi erano ping of death e smurf, entrambi corretti negli stack e non al bordo, ed entrambi corretti prima che nascessero alcuni degli ingegneri che ancora ripetono il consiglio. Quello che il blocco totale ferma oggi è la diagnosi. Nient’altro.
RFC 1812 non lascia spazio a interpretazioni sul punto: Time Exceeded è un MUST, e lo standard dichiara che il motivo è che traceroute ne dipende. Scartalo e hai rotto uno strumento che il documento sui requisiti dei router di internet nomina come giustificazione dell’esistenza stessa del messaggio.
Il path MTU discovery è quello che costa caro. Ha bisogno che l’ICMP 3/4, fragmentation needed, torni al mittente. Filtralo e ottieni il guasto che ogni network engineer ha inseguito almeno una volta, quello in cui l’handshake si completa, i trasferimenti piccoli funzionano e qualsiasi cosa porti un pacchetto a dimensione piena resta appesa per sempre. SSH si connette e scp si blocca. La pagina si carica e l’immagine non arriva mai. Niente nei log. Niente su cui fare grep.
Su IPv6 smette di essere una questione di gusti. RFC 4890 §4.3.1 elenca i messaggi che un firewall non deve scartare:
- 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 su Packet Too Big è brutale riguardo alla conseguenza: «Effectively, parts of the Internet will become inaccessible.» I router IPv6 non frammentano. Se Packet Too Big non riesce a raggiungere il mittente, non c’è modo di recuperare.
Il controllo è un rate limit, non un drop. Permetti il tipo 3 e il tipo 11 in ingresso, contali, limitali a qualcosa come cento al secondo, registra quello che supera il limite, e hai conservato la diagnostica, mantenuto funzionante il path MTU discovery e conservato fino all’ultimo pezzo della protezione che la regola totale avrebbe dovuto dare in primo luogo. Limitare quanto accetti di qualcosa è un controllo. Rifiutarlo tutto e chiamarlo hardening è solo rifiutarsi di essere misurati.
Per chi gestisce un MSP: se la linea del tuo cliente scarta gli errori ICMP, gli hai tolto la possibilità di dimostrare in quale rete sta un guasto, e l’hai tolta anche a te. La prossima volta che un guasto sta tra due provider che dicono entrambi di essere puliti, ecco il conto di quella policy.
Tranne l’echo. Quello scartalo.
Tutto quello che c’è sopra riguarda gli errori ICMP. L’echo è un’altra bestia, ed è l’unica parte del protocollo che toglierei dal filo al bordo.
Guarda cosa gli richiede lo standard. In IPv4, RFC 792 dice di un echo request che «the data received in the echo message must be returned in the echo reply message». IPv6 è ancora più netto: RFC 4443 definisce il campo come «zero or more octets of arbitrary data» e poi richiede che «MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message».
Leggilo da attaccante e non da operatore. Lo standard obbliga ogni host sulla terra ad accettare un blocco di byte che scegli tu e a restituirtelo tale e quale. Non è un effetto collaterale. È un canale imposto, bidirezionale, con payload arbitrario, che gira su un protocollo che la maggior parte dei firewall lascia passare senza ispezionarlo e che la maggior parte dei log registra come conteggio di pacchetti e non come contenuto.
La gente ci costruisce tunnel da trent’anni. Loki l’ha fatto in Phrack 49 nel 1996. Ptunnel porta un’intera sessione TCP dentro il ping ed è a un pacchetto di distanza da vent’anni. Se la tua policy di egress è «blocca tutto, permetti l’ICMP perché al team di rete serve», non hai una policy di egress. Hai una VPN con qualche passaggio in più, e il traffico esce con l’aria di qualcuno che controlla se internet funziona.
RFC 4890 non è d’accordo con me, e vale la pena dirlo apertamente invece di citare solo la metà che fa comodo. Il §4.3.1 mette Echo Request ed Echo Response nella stessa lista da non scartare degli errori. Poi leggi la giustificazione che 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.
Il motivo dichiarato per tenere aperto l’echo è che qualcuno ha bisogno di costruirci un tunnel attraverso il tuo firewall. È il mio argomento, messo per iscritto da chi sostiene la tesi opposta.
Quindi la policy è mirata, non totale:
# 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
Su IPv6, non portare quello schema su una chain link-local o di host senza conservare il neighbour discovery. I tipi da 133 a 137, da nd-router-solicit a nd-redirect, sono il modo in cui IPv6 fa il lavoro che in IPv4 fa ARP. Scartali e il segmento smette di funzionare nel giro di minuti, e non sembrerà un guasto del firewall. Filtra l’echo al bordo, non sul filo tra un host e il suo router.
Cosa ti costa? ping attraverso il confine, e nient’altro. Tutto quello che c’è in questo articolo continua a funzionare, perché nessuna misurazione qui invia un echo request. hopfind.py percorre TCP e UDP e legge gli errori che tornano; traceroute -T e -U fanno lo stesso. Il path MTU discovery ha bisogno di Packet Too Big, che è un errore. Il trucco del TTL inverso funziona su qualsiasi risposta, e un handshake TCP te ne dà una. L’unica cosa che perdi è lo strumento meno informativo della cassetta, e questo intero articolo è un argomento sul perché fermarsi a ping sia il problema in primo luogo.
La mia linea fa già esattamente questo, anche se dubito che sia voluto. ping verso il mio default gateway ottiene il 100% di perdita, e l’ICMP Time Exceeded da quello stesso gateway torna in 0,3 ms, come mostra ogni traccia di questo articolo. Echo chiuso, errori aperti. Chi ha distribuito quel firmware ha dato la risposta giusta, e l’ho scoperto solo andando a cercare.
La stessa regola, scritta una volta sola
Ecco il guasto che non mi aspettavo di trovare in casa mia. Un resolver DNS pubblico, percorso su TCP/443 su entrambe le famiglie, a pochi minuti di distanza.
$ 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.
Niente di niente. Nemmeno un hop. Il mio router non ha nemmeno riportato la scadenza che deve aver generato, la stessa scadenza che ha riportato in 0,3 ms in ogni altra camminata di questo articolo. Quindi il drop avviene all’hop 1, prima che il controllo del limite di hop venga eseguito, e l’hop 1 è il mio.
Il percorso è a posto, e lo dimostra la stessa destinazione su 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 *
Sette hop di risposte pulite verso lo stesso indirizzo. Quindi non è il routing e non è la destinazione: qualcosa sulla mia linea scarta il TCP verso quell’host e lascia passare l’UDP.
Poi lo stesso resolver, stessa porta, su 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.
Dritto fino in fondo. Sette hop, nessun dramma. Stesso servizio, stessa porta, stessa intenzione, e la regola esiste su una sola famiglia di indirizzi.
Chi ha scritto quella regola l’ha scritta per IPv4 e non ha mai scritto la gemella. Non ho idea di cosa dovesse ottenere, la mia ipotesi è qualcosa per tenere il DNS in locale, ma qualunque cosa fosse, la ottiene su metà del traffico da quando questa linea ha IPv6. Se c’era per un motivo, non funziona. Se non c’era, non dovrebbe esserci.
È la versione di tutti i giorni del problema del dual stack, ed è molto più comune delle discussioni su se adottare IPv6 o meno. Due regolamenti. Uno mantenuto.
Lo script completo
Nessuna dipendenza, nessuna installazione, solo la libreria standard. Python 3.6 o successivo, e su Linux nessun privilegio.
Le due classi sono tutta la storia della portabilità. ErrorQueue è il percorso Linux: arma IP_RECVERR sul socket e, dopo che la sonda fallisce, legge MSG_ERRQUEUE ed estrae l’indirizzo del router dalla struttura sock_extended_err a cui il kernel lo accoda. RawIcmp è tutto il resto: apre un raw socket ICMP, legge quello che arriva, prende l’indirizzo sorgente dal pacchetto. Il primo non ha bisogno di niente, il secondo ha bisogno di root, e al resto del programma non importa quale gli sia stato dato.
Un dettaglio merita di essere sottolineato perché è la differenza tra una risposta giusta e una plausibile. In probe() la coda degli errori viene svuotata prima di consultare SO_ERROR. Un errore ICMP arriva a un socket TCP come un semplice errno, ICMP 3/3 port unreachable arriva come ECONNREFUSED, esattamente come un vero reset, quindi controllare prima SO_ERROR avrebbe riportato il reset SMTP falsificato più su in questo articolo come un rifiuto onesto dall’altra parte. Leggi prima la coda e ee_origin ti dice che ha parlato un router.
#!/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()
Cosa questo non può dirti
Il metodo è economico ed è onesto su quasi tutto, ma non è uno scanner di topologia. Sii chiaro nel ticket su cosa hai misurato davvero.
Quintuple diverse possono prendere percorsi diversi. L’ECMP fa l’hash delle porte sorgente e destinazione nella scelta del next hop, quindi due esecuzioni su due porte diverse non sono garantite attraversare gli stessi router, ed è una delle due cose che potrebbero spiegare l’hop 5 qui sopra che risponde a un’esecuzione e resta zitto nell’altra. Ripeti entrambe le esecuzioni. Un confine che si sposta non è provato.
L’MPLS nasconde gli hop. Un core a commutazione di etichette può presentarsi come un hop, o come nessuno. Qualsiasi conteggio attraverso la dorsale di qualcun altro è un limite inferiore.
La generazione di ICMP è limitata quasi ovunque. Sonda più in fretta di quanto il router voglia rispondere e ti fabbrichi da solo gli asterischi. hopfind.py invia una sonda per hop e aspetta; è voluto.
Il percorso di ritorno non deve per forza coincidere con quello di andata. Il numero di hop all’andata non è il numero di hop al ritorno, e l’aritmetica del TTL inverso misura solo la tratta di ritorno.
L’anycast significa che l’host all’hop N potrebbe non essere la stessa macchina due volte. I resolver pubblici e le CDN, in particolare.
Un handshake completato non significa che la sessione sopravviva. Un firewall stateful può permettere il SYN e scartare quello che segue dopo l’ispezione. Se la connessione si apre e poi muore, questo è lo strumento sbagliato: vai a catturare.
Hai trovato il primo dispositivo che scarta, non quello che qualcuno ammetterà. In una CGN o in una rete di un carrier l’indirizzo all’hop N+1 può essere una di diverse macchine dietro un unico indirizzo. Resta la cosa giusta da citare, perché è un fatto sul percorso.
A cosa serve davvero
A far finire i rimbalzi. È tutto il ritorno dell’esercizio.
«La porta 445 è bloccata da qualche parte» è un invito a rimandare indietro il ticket. Questo no:
TCP/445 verso 192.0.2.4 viene scartato in silenzio all’hop 11, indirizzo 192.0.2.31. L’hop 11 risponde con ICMP Time Exceeded a TCP/443 sullo stesso percorso in 26 ms e non risponde niente sulla 445, quindi il drop è una decisione di policy su quel dispositivo, non un guasto di routing. I dieci hop davanti sono puliti. Riprodotto quattro volte in venti minuti, da una shell senza privilegi, script allegato.
Nessuno lo rimanda indietro. Nomina un dispositivo, dice cosa ha fatto, dice cosa non ha fatto e mostra i passaggi. Se decidono di cambiarlo resta una loro scelta. Ma la settimana di ping-pong è finita, ed è servita a quattro comandi.
Tutto è venuto fuori da un campo di 8 bit che è stato specificato come timer nel 1981, non è mai stato usato come tale nemmeno una volta, e in silenzio trasforma «da qualche parte» in un indirizzo.
Vale la pena imparare a leggerlo.