Ping non è una diagnostica. È un tunnel. L’ICMP echo (la richiesta che una macchina invia e la risposta che riceve) trasporta qualsiasi byte ci metti dentro, in entrambe le direzioni, su un protocollo che la maggior parte dei firewall lascia passare senza ispezionare e che la maggior parte dei log conta invece di leggere. Una rete che «permette solo il ping» ha già una VPN completa e cifrabile verso l’esterno, e chiunque possa raggiungere quella rete può pilotarne una.

È una cosa vecchia, ed è documentata. Loki1 pubblicò la tecnica su Phrack 49 nel 1996. Ptunnel2 trasporta intere sessioni TCP dentro il ping da vent’anni ed è a un pacchetto di distanza su qualsiasi macchina Linux. Nessuno zero-day. Il protocollo che si comporta esattamente come specificato.

È questa la causa: lo standard, non un bug nel prodotto di qualcuno. Ogni host sulla Terra è obbligato a prendere i dati di una richiesta echo e a restituirli pari pari, immutati. Dati arbitrari dentro, gli stessi dati fuori: è tutto quello di cui un tunnel ha bisogno, ed è imposto dal 1981.

La soluzione è un’unica modifica puntuale. Scarta l’ICMP echo, richiesta e risposta, su IPv4 e IPv6, al confine, e tieni ogni altro messaggio ICMP. Gli errori, Time Exceeded, Packet Too Big, Destination Unreachable, sono portanti; bloccali e rompi la path MTU discovery e il traceroute per niente. Quindi non è «blocca ICMP». È scarta l’unico messaggio che è un rischio, e tieni quelli che portano la verità.

Cosa permetteva davvero la tua policy di egress

Se gestisci una rete in cui l’uscita è filtrata (e se non lo fai, quello è un altro discorso), allora questo è il conto di una riga al suo interno. La policy che dice «blocca tutto in uscita, permetti ICMP perché ci serve fare ping» non è una policy di egress. È un tunnel completo con le pratiche archiviate sotto diagnostica. Qualsiasi cosa all’interno che possa inviare una richiesta echo e leggere la risposta può spostare dati verso qualsiasi punto all’esterno che ne risponda, al ritmo che la linea reggerà, e oltre ogni controllo sui contenuti che hai comprato. Nei log è qualcuno che controlla se internet funziona, e niente più. Il malware lo spedisce da anni proprio per questo motivo. Silenzioso, standard, e di solito già permesso.

Ecco perché è un canale di prima scelta per chiunque sia già dentro e non dovrebbe esserci. È l’inquilino, non lo scippo. Chi cerca una via di entrata e di uscita che duri evita la porta che fa scattare un allarme. Monta un tunnel su echo e lo lascia in funzione per mesi. Un host che fa molti ping è un host che nessuno guarda. Rete bidirezionale dentro il patrimonio aziendale: comando dentro, dati fuori, sul protocollo che nessuno limita, su cui nessuno allarma e che nessuno legge. Ed è cifrato, come lo cifra qualsiasi strumento vero, così sul filo il payload sono i byte dall’aria casuale che un ping porta comunque, e l’ispezione dei contenuti non ha niente da leggere. La dimensione e la tempistica possono ancora tradirlo a chi guarda davvero. Sbirciare dentro il pacchetto no.

E la macchina che lo pilota non deve appartenere a nessuno che ci lavora. Basta qualcosa che possa raggiungere la tua rete e mettere un ping su internet, e raggiungere la tua rete è più facile di quanto a nessuno piaccia ammettere. Il WiFi arriva oltre i muri, nel corridoio, nel parcheggio, nell’appartamento di sopra. La porta ethernet nel muro della sala riunioni, o della reception, o della scrivania vuota vicino alla finestra, molto spesso è attiva e parla con qualsiasi cosa ci colleghi, senza nessun 802.1X che chieda chi sei. Un segnale a portata, o una presa che nessuno ha messo in sicurezza. È questo il biglietto d’ingresso. Nessun badge, nessun account, nessun invito.

Immagina il visitatore che hai invitato tu. È in riunione, gentile, prende appunti, partecipa. Il suo portatile no. Nel momento in cui ha raggiunto la tua rete, via etere o attraverso la porta sotto il tavolo, era dentro il muro, e se quella rete può emettere una richiesta echo, ha una via d’uscita. Niente è stato rilasciato sul tuo patrimonio. Nessun account, nessun privilegio su niente di tuo, niente che i tuoi agenti di endpoint possano intercettare, perché i tuoi agenti non sono sulla sua macchina. La persona è dall’altra parte del tavolo. Il traffico esce dalla tua porta d’ingresso, cifrato, indistinguibile da un portatile che fa più ping del dovuto.

Un visitatore a portata di segnale, o a una porta aperta, ottiene un tunnel che esce da un firewall che vede solo pingUn visitatore a portata, o a una porta aperta, ottiene una via d'uscitadentro il muro, la tua reteil WiFi arrivaal corridoio,al parcheggio,all'appartamento di sopraportatile del visitatorenessun badge, nessun accountuna porta a muro attivanessun 802.1X che chiede chi seifirewall al confinevede solo pingserversu internetecho request →← echo replyqualsiasi traffico IP, cifrato, che viaggia dentro i ping
Il biglietto d’ingresso è l’accesso alla rete, un segnale WiFi a portata o una porta a muro attiva senza 802.1X, e l’uscita è echo attraverso il confine. Per il firewall è un host che fa ping; dentro quei ping c’è qualsiasi traffico IP, cifrato, diretto a un server su internet.

Le due cose a cui penserai non aiutano. Il NAT è una tabella di traduzione, non un filtro: una richiesta echo da un host interno apre una mappatura basata sull’id ICMP, che il NAT tratta esattamente come tratta una porta, e la risposta torna indietro attraverso di essa come qualsiasi altro flusso. Ho fatto girare un client dietro il mio NAT di casa e non si è mai accorto che il NAT c’era. Una VLAN guest separata non è meglio. La segregazione tiene il visitatore lontano dai tuoi server, ma non fa niente per tenerlo lontano da internet, e internet, raggiunto con un ping, è tutto il requisito. Un solo controllo tocca questo: quella rete fa uscire echo?

Non lo ispezioni via, e non lo segreghi via. Chiudi la porta. Tutto quello che segue è il perché lo standard la lascia aperta, tre modi di costruire il tunnel così che l’affermazione regga su più del mio parere, e l’unica modifica che la chiude.

La parte di ICMP che non ti deve niente di utile

Parti da cosa dice davvero lo standard, perché tutto l’argomento poggia su una frase e la gente la liquida senza leggerla.

Una richiesta echo porta un campo dati. In IPv4, la RFC 7923 afferma chiaramente che «the data received in the echo message must be returned in the echo reply message». IPv6 ha irrigidito la formulazione invece di allentarla: la RFC 44434 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 operatore ed è un keepalive. Leggilo da chi sposta dati ed è un regalo. Lo standard obbliga ogni host raggiungibile ad accettare un blocco di byte che scegli tu e a rimandarteli pari pari, immutati, su richiesta. Lunghezza arbitraria. Contenuto arbitrario. Nessun handshake, nessuna porta, nessuna applicazione all’altro capo che debba essere d’accordo su qualcosa. Lo fa il kernel, prima che qualsiasi processo userland ci metta gli occhi.

Ed è su entrambe le famiglie. Passare a IPv6 non mette la cosa in ordine. La allarga. La RFC 792 diceva che i dati «must be returned»; la RFC 4443 dice che «MUST be returned entirely and unmodified», che è la stessa porta con un lucchetto più robusto a tenerla aperta. Per questo il canale esiste sia su ICMP echo sia su ICMPv6 echo, e una regola che lo chiude su una famiglia e non sull’altra non ha chiuso niente. Il tunnel si sposta sulla famiglia che hai lasciato aperta. Qualunque cosa tu faccia a riguardo, falla su ip e ip6 insieme.

Niente altro nel protocollo fa questo. Un Time Exceeded porta l’header del pacchetto che è morto e niente più. Un Destination Unreachable è un rapporto su qualcosa che è già successo. Quei messaggi ti dicono fatti sulla rete. Echo porta qualsiasi cosa ci metti dentro, in entrambe le direzioni, e lo chiama diagnostica.

Gli errori sono portanti. Echo no.

Questa è la distinzione che quelli del «basta bloccare ICMP» non fanno mai, ed è tutto il punto, quindi la farò una volta e per bene.

Bloccare gli errori ICMP rompe la rete in silenzio. Filtra Packet Too Big e uccidi la path MTU discovery: l’handshake si completa, i trasferimenti piccoli funzionano, e qualsiasi cosa che porti un pacchetto a dimensione piena si blocca per sempre senza niente nei log. Su IPv6 non è nemmeno una questione di gusti. I router non frammentano, quindi la RFC 48905 elenca Packet Too Big tra i messaggi che un firewall «must not drop» e avverte che senza di esso «parts of the Internet will become inaccessible». Filtra Time Exceeded e rompi il traceroute, che la RFC 18126 indica come il motivo per cui il messaggio è obbligatorio in primo luogo. Non sono opzionali. Sono il feedback che rende la rete auto-correttiva, e ho trattato a lungo il costo di perderli la volta scorsa.

Adesso scarta echo e va’ a cercare cosa si è rotto. ping oltre il confine smette di funzionare. È tutto l’elenco. L’elenco intero.

La path MTU discovery non se ne cura, perché gira su Packet Too Big, che è un errore. Il traceroute non se ne cura, perché traceroute -T e -U percorrono TCP e UDP e leggono gli errori che tornano indietro. Nessuno di loro invia un echo. La neighbour discovery su IPv6 non se ne cura, perché sono i tipi da 133 a 137, e quelli li tieni o il segmento muore. Il trucco del TTL inverso dell’articolo scorso funziona su qualsiasi risposta, e un handshake TCP te ne dà una. Tutto quello che faceva funzionare le diagnostiche dell’articolo scorso continua a funzionare, perché nessuna misurazione lì dentro inviava una richiesta echo.

Quindi le due metà del protocollo non potrebbero essere più diverse. Una metà è la rete che ti dice la verità su sé stessa, e la rompi a tuo rischio. L’altra metà è un servizio di restituzione payload imposto che per caso si chiama diagnostica, e la cosa più forte che si possa dire per tenerlo aperto è che ping è comodo. È comodo. È anche l’unica parte di ICMP che un attaccante può pilotare, e posso mostrarti esattamente con cosa la pilota.

Tieni gli errori ICMP, con rate limit; scarta solo echo, entrambe le direzioni ed entrambe le famiglieDue metà di un protocollo, e solo una delle due è un rischioTIENIlimita il ritmo, non bloccare maiDestination Unreachableporta il perché un pacchetto non è stato consegnatoPacket Too Bigla path MTU discovery dipende da luiTime Exceededil traceroute dipende da luiParameter Problemsegnala un header malformatoNeighbour Discovery 133–137IPv6: il segmento locale dipende da luiRompi questi e la rete si rompe in silenzio.SCARTAin entrambe le direzioni e famiglieEcho requesttipo 8 (IPv4) · tipo 128 (IPv6)Echo replytipo 0 (IPv4) · tipo 129 (IPv6)Nessuno ha bisogno di questi tranne ilpingcomando.Tutto quello che un attaccante pilotaattraverso ICMP ci passa.Un tunnel lasciato aperto su una famiglia non è chiuso.
Gli errori ICMP sono portanti: la path MTU discovery, il traceroute e la neighbour discovery IPv6 dipendono tutti da loro, e bloccarli rompe la rete in silenzio. Echo è l’unica parte da cui non dipende niente tranne ping, e l’unica parte che un attaccante può pilotare. Scarta quella, tieni il resto, su entrambe le famiglie.

La prova: una VPN fatta di ping

Lo strumento è Hans7, scritto da Friedrich Schöller. La sua stessa descrizione è una riga: «makes it possible to tunnel IPv4 through ICMP echo packets, so you could call it a ping tunnel.» Tira su un’interfaccia tun a ciascun capo, dà loro degli indirizzi, e sposta ogni pacchetto tra di loro dentro l’ICMP echo. Per la rete in mezzo è qualcuno che fa ping a un server e il server che risponde. Per me è una rotta.

Un intero pacchetto IP viaggia dentro il campo dati di un solo pingUn intero pacchetto viaggia dentro un pingIl pacchetto che invia la tua sessione SSHheader IPsrc / dstheader TCPporta 22dati applicativii tuoi tasti, il tuo fileHans copia l'intero pacchetto nel campo dati echoIl pacchetto che parte sul filoheader IPtu verso il serverrichiesta ICMP echotipo 8 · id · seqcampo dati echol'intero pacchetto qui sopra, immutatoPer il firewall al confine questa è una richiesta echo, e il log registra un ping.Dentro il campo dati c'è un pacchetto diretto ovunque l'altro capo possa arrivare.Lo standard impone all'altro capo di rimandare subito quei dati, quindi anche la risposta è un pacchetto.
Ogni pacchetto che il tunnel trasporta viene copiato nel campo dati di una richiesta ICMP echo. Lo standard obbliga l’altro capo a restituire quei dati immutati, quindi la risposta porta anch’essa un pacchetto. Il firewall conta un ping; il payload va dovunque l’altro capo possa instradarlo.

L’ho fatto girare sulla mia linea, un server su un indirizzo pubblico e un client dietro il NAT di casa, e ci ho spinto dentro traffico vero. Non ping sintetici con un flag impostato. Un login SSH e il prelievo di un file, in sella dentro echo.

È a un pacchetto di distanza dove ho fatto girare il server, e si compila dai sorgenti di Schöller ovunque altro. Il server deve essere Linux e vuole root, perché aprire un dispositivo tun e un socket ICMP raw lo richiedono entrambi. La sintassi è volutamente minima:

# on the server (public IP), pick the tunnel network and a password
hans -s 10.8.0.0 -p '<password>'
# server takes 10.8.0.1; clients are handed 10.8.0.2 and up

# on the client, point it at the server's public address
hans -c <server-public-ip> -p '<password>'

Una volta su entrambi i capi c’è una nuova interfaccia per lato con un indirizzo sulla rete del tunnel, e si comporta come qualsiasi altro collegamento punto-punto:

Niente di quella sessione sa di essere dentro un ping. SSH apre una connessione TCP verso 10.8.0.1, il kernel la instrada fuori per tun0, Hans incarta ogni pacchetto come payload di una richiesta echo, e l’altro capo lo scarta e lo passa al suo tun0. La risposta torna indietro come payload di una risposta echo. Per quanto riguarda SSH, sta parlando su un collegamento ordinario. Per quanto riguarda il firewall, nessuno ha aperto niente. Un host sta ricevendo dei ping.

Che aspetto ha sul filo

Questa è la parte che chiude l’argomento, quindi guarda la vista dagli occhi del firewall invece della mia.

Quello che succede davvero, e quello che registra il firewall, non sono la stessa immagineUn tunnel, due immaginiQuello che succede davveroil tuo hosttun0 · 10.8.0.2il servertun0 · 10.8.0.1dovunque possaarrivareSSH, prelievi di fileinstradato fuoriqualsiasi traffico IP, attraverso il tunnelcome pacchetti ordinariQuello che il firewall al confine vede e registrail tuo host198.51.100.9il server192.0.2.7richiesta echorisposta echoicmp echo request 198.51.100.9 > 192.0.2.7icmp echo reply 192.0.2.7 > 198.51.100.9icmp echo request 198.51.100.9 > 192.0.2.7... contati come ping, contenuto non lettoStesso filo. Il firewall non vede mai i pacchetti al suo interno.
Il tunnel sposta traffico vero tra due host e poi fuori verso dovunque il server possa arrivare. Al confine ci sono solo richiesta echo e risposta echo: il firewall registra dei ping e non vede mai i pacchetti trasportati al loro interno.

Siediti sull’interfaccia esterna con tcpdump e cattura solo ICMP mentre gira la sessione SSH. Nessun TCP verso la porta 22 attraversa il confine. Quello che attraversa è richiesta echo e risposta echo, avanti e indietro, ciascuna più grassa di un ping vero perché porta una fetta di un segmento TCP nel suo payload:

# on the boundary, watch only ICMP echo while traffic runs over the tunnel
tcpdump -ni <wan-iface> 'icmp[icmptype] = icmp-echo or icmp[icmptype] = icmp-echoreply'

Leggi le due cose che contano in quella cattura. Primo, le lunghezze del payload: un ping normale invia 56 byte e ogni riga è della stessa dimensione, mentre queste variano e sono grandi, perché la dimensione della cosa che stai spostando trapela nella dimensione del ping. Secondo, il ritmo: un ping di diagnostica è uno al secondo, e questo è un diluvio, perché sta spostando un file. Nessuno dei due è nascosto. Entrambi stanno in piena vista su un protocollo che nessuno guarda.

Ed è tutto il punto. Non che questo sia furbo, o difficile da notare una volta che guardi. Quasi nessuno guarda, perché la macchina è configurata per permettere ICMP, i log lo contano come ping, e gli allarmi erano tarati per le porte che qualcuno si è ricordato di temere. Il traffico esce con l’aria di un controllo di salute, e il controllo di salute è una rotta verso dovunque il server possa arrivare.

Una VPN full-tunnel vera, costruita a mano

Hans dimostra che il canale c’è, ma fa lui l’interfaccia e l’indirizzamento e ti restituisce una rotta, quindi non ti mostra bene cosa hai costruito. Per vedere che questa è una VPN in senso pieno, il traffico dell’intera macchina che esce attraverso il ping, non un collegamento tra due host nominati, mettila insieme a mano. icmptunnel8, di Dhaval Kapil, è quello giusto, e la sua stessa descrizione è una riga sola: «Transparently tunnel your IP traffic through ICMP echo and reply packets.» Stessa idea, dispositivo tun e payload echo, ma la tubatura la posi tu e niente si nasconde dentro un binario.

Sul server avvii il tunnel, tiri su l’interfaccia, e poi fai la cosa che svela tutto il gioco: dici al kernel di smettere di rispondere ai ping da sé, così le sue risposte echo non litigano con quelle che il tunnel sta inviando.

sudo ./icmptunnel -s 10.0.1.1                 # server mode; creates tun0, then blocks
# from a second shell, bring the interface up (iproute2, not the net-tools the repo ships)
sudo ip addr add 10.0.1.1/24 dev tun0
sudo ip addr add 2001:db8:1::1/64 dev tun0
sudo ip link set tun0 mtu 1472 up             # 1500 − 20 (IP) − 8 (ICMP); see below
# stop the kernel replying to pings — echo now belongs to the tunnel
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=1
sudo sysctl -w net.ipv6.icmp.echo_ignore_all=1
# let the server route the client's packets onward
sudo sysctl -w net.ipv4.ip_forward=1

Rileggi la riga icmp_echo_ignore_all, perché dice più di quanto sembri. Quella manopola è del kernel stesso, e arriva come difesa: impostala e, con le parole del kernel, «will ignore all ICMP ECHO requests sent to it»9, così un operatore può togliere un host dal radar dei ping del tutto. Adesso è su entrambe le famiglie. net.ipv4.icmp_echo_ignore_all da anni, e net.ipv6.icmp.echo_ignore_all aggiunta più tardi per pareggiare.10 Il tunnel aziona quell’interruttore difensivo per il motivo opposto: con il kernel che non risponde più da sé a echo, i suoi due capi sono liberi di usare echo come puro trasporto. Ed è la spia. Chi ha scritto lo stack tratta già echo come qualcosa che un host può ragionevolmente rifiutare; la regola in questo articolo fa quella stessa scelta una volta, al confine, per ogni host dietro di esso.

Sul client tiri su l’interfaccia e poi punti la rotta di default giù per essa. Non un host raggiunto attraverso il tunnel. Tutto.

sudo ./icmptunnel -c <server-public-ip>       # client mode; creates tun0
sudo ip addr add 10.0.1.2/24 dev tun0
sudo ip addr add 2001:db8:1::2/64 dev tun0
sudo ip link set tun0 mtu 1472 up
# keep the route to the server itself OUT of the tunnel...
sudo ip route add <server-public-ip> via <gateway> dev <iface>
# ...then send everything else down it
sudo ip route replace default dev tun0

I client.sh e server.sh del progetto stesso ricorrono ancora a ifconfig e route di net-tools. I comandi ip qui sopra sono gli equivalenti iproute2 e fanno lo stesso lavoro. Quella rotta verso il server è la riga che la gente dimentica: tienila fuori dal tunnel, o i pacchetti echo che trasportano il tunnel provano a viaggiare giù per il tunnel, e non esce niente. Tutto il resto adesso passa per tun0, incartato in echo, e raggiunge il server. Se vada oltre è una scelta di routing. Una sola regola di masquerade sul server lo metterebbe su internet pubblico sotto l’indirizzo del server stesso, e volutamente non c’è, perché la cosa mostrata è il tunnel e non ne ha bisogno.

Quella è una VPN full-tunnel, costruita con il ping in una manciata di comandi. Ogni pacchetto che il client invia, web, DNS, SSH, tutto, viene catturato in tun0 ed esce come una richiesta echo verso il server, e le risposte tornano indietro come risposte echo. Una macchina su una rete che «permette solo ICMP» ha appena consegnato tutto il suo traffico in uscita a una scatola fuori, e il confine ha registrato un host a cui piace fare ping.

Scriverne uno tuo in Python

Ecco la parte che dovrebbe preoccupare chiunque speri di difendersi da questo riconoscendo uno strumento. Né Hans né icmptunnel fanno qualcosa che non potresti scrivere tu stesso in un pomeriggio. Apri un dispositivo tun, incarta ogni pacchetto come payload di una richiesta echo, scarta quelli che tornano indietro. È tutto il meccanismo, e il tunnel nudo è circa sessanta righe di Python di libreria standard, senza niente da installare. La versione qui sotto aggiunge una cosa sopra: cifra il payload, ed è l’unica parte che tira dentro una dipendenza.

#!/usr/bin/env python3
# pingvpn.py — a VPN tunnel over ICMP echo, in one short file.
#
# Not a product. It exists to show the channel is trivial to rebuild, so a
# defence that hunts for a known tool is chasing the wrong thing entirely.
# Linux, needs root (a tun device and a raw ICMP socket both do), and the
# `cryptography` package for the AES (pip install cryptography).
#
#   server:  sudo python3 pingvpn.py --server
#   client:  sudo python3 pingvpn.py --client <server-public-ip>
#
# The payload is encrypted with AES-128-GCM under a pre-shared key before it
# goes on the wire, so what a firewall sees in the echo data is random bytes —
# the same as a real ping's padding, and nothing for content inspection to read.

import argparse
import fcntl
import hashlib
import os
import select
import socket
import struct
import sys

from cryptography.hazmat.primitives.ciphers.aead import AESGCM

TUNSETIFF    = 0x400454CA
IFF_TUN      = 0x0001
IFF_NO_PI    = 0x1000
MAGIC        = 0x4954          # 'IT' in the id field, so we ignore real pings
ECHO_REQUEST = 8
ECHO_REPLY   = 0

PSK   = b"change-me-to-a-shared-secret"          # pre-shared secret, both ends
KEY   = hashlib.sha256(PSK).digest()[:16]        # 128-bit key -> AES-128-GCM
AEAD  = AESGCM(KEY)


def open_tun(name=b"tun0"):
    fd = os.open("/dev/net/tun", os.O_RDWR)
    fcntl.ioctl(fd, TUNSETIFF, struct.pack("16sH", name, IFF_TUN | IFF_NO_PI))
    return fd


def encrypt(data):                                # -> nonce || ciphertext+tag
    nonce = os.urandom(12)
    return nonce + AEAD.encrypt(nonce, data, None)


def decrypt(blob):                                # raises on a packet that is not ours
    return AEAD.decrypt(blob[:12], blob[12:], None)


def checksum(data):
    if len(data) % 2:
        data += b"\x00"
    total = sum(struct.unpack("!%dH" % (len(data) // 2), data))
    total = (total >> 16) + (total & 0xFFFF)
    total += total >> 16
    return ~total & 0xFFFF


def build_echo(icmp_type, payload):
    head = struct.pack("!BBHHH", icmp_type, 0, 0, MAGIC, 0)
    csum = checksum(head + payload)
    return struct.pack("!BBHHH", icmp_type, 0, csum, MAGIC, 0) + payload


def main():
    ap = argparse.ArgumentParser(description="a VPN tunnel over ICMP echo")
    group = ap.add_mutually_exclusive_group(required=True)
    group.add_argument("--server", action="store_true")
    group.add_argument("--client", metavar="SERVER_IP")
    args = ap.parse_args()

    out_type = ECHO_REQUEST if args.client else ECHO_REPLY
    in_type  = ECHO_REPLY   if args.client else ECHO_REQUEST
    peer     = args.client        # None on the server until a client is seen

    tun  = open_tun()
    sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
    print("tun0 created. bring it up with an address and route, then send traffic.",
          file=sys.stderr)

    while True:
        readable, _, _ = select.select([tun, sock], [], [])

        if tun in readable:                       # a packet wants to leave this host
            packet = os.read(tun, 65535)
            if peer:
                sock.sendto(build_echo(out_type, encrypt(packet)), (peer, 0))

        if sock in readable:                      # something arrived over ICMP
            data, _ = sock.recvfrom(65535)
            ihl  = (data[0] & 0x0F) * 4           # skip the IP header the kernel adds
            icmp = data[ihl:]
            if len(icmp) < 8 or icmp[0] != in_type or icmp[4:6] != struct.pack("!H", MAGIC):
                continue
            try:
                packet = decrypt(icmp[8:])        # wrong key or a real ping -> skip
            except Exception:
                continue
            if args.server:
                peer = socket.inet_ntoa(data[12:16])   # reply to whoever sent
            os.write(tun, packet)                 # hand the carried packet to the stack


if __name__ == "__main__":
    main()

Quello è l’intero tunnel. Apre tun0 e un socket ICMP raw e fa la spola di pacchetti tra i due: quello che lascia l’host è incartato come una richiesta echo, o una risposta echo sul server, e inviato all’altro capo; quello che arriva via ICMP viene scartato e restituito allo stack. Il campo id è fissato a un valore solo così scavalca i ping veri, e il server impara dove rispondere dalla sorgente del primo pacchetto che vede.

La cifratura è il punto su cui vale la pena soffermarsi, perché è quello che fanno gli strumenti veri ed è il motivo per cui non lo prenderai guardando dentro il pacchetto. Il payload è sigillato con AES-128-GCM sotto una chiave pre-condivisa prima di essere incartato, così i byte nei dati echo sono indistinguibili dal riempimento casuale che un ping vero porta. Togli le due righe di crypto e il tunnel gira ancora su niente più della libreria standard: l’unico motivo per cui serve pip install cryptography è l’AES, e l’AES è esattamente la parte che trasforma un tunnel leggibile in uno illeggibile. Tiralo su nello stesso modo di prima, meno il masquerade. Non ti serve per dimostrare il punto:

# server: start it (creates tun0, then blocks), then configure from the same shell
sudo python3 pingvpn.py --server &
sudo ip addr add 10.9.0.1/24 dev tun0
sudo ip addr add 2001:db8:9::1/64 dev tun0
sudo ip link set tun0 mtu 1400 up
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=1
sudo sysctl -w net.ipv6.icmp.echo_ignore_all=1

# client
sudo python3 pingvpn.py --client <server-public-ip> &
sudo ip addr add 10.9.0.2/24 dev tun0
sudo ip addr add 2001:db8:9::2/64 dev tun0
sudo ip link set tun0 mtu 1400 up
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=1
sudo sysctl -w net.ipv6.icmp.echo_ignore_all=1
sudo ip route add <server-public-ip> via <gateway> dev <iface>
sudo ip route replace default dev tun0

Il motivo per scriverlo per esteso non è lo strumento. È che lo strumento è usa e getta. Un file breve, nessuna dipendenza finché non aggiungi la cifratura, e ogni copia che qualcuno digita appare un po’ diversa sul filo. Quindi una firma che prende questo non prende niente la settimana dopo. Non puoi bloccarti fuori da questo nominando il software, perché non c’è software da nominare.

Non gli serve nemmeno una shell. La logica è byte dentro, byte fuori, quindi si porta su qualsiasi cosa possa aprire un socket. Perfino WebAssembly: la sandbox del browser normalmente rifiuta a una pagina un socket raw in modo netto, ma dove quella barriera è sollevata (un browser a cui l’utente ha concesso il permesso, su una macchina dove l’utente gira con privilegi sufficienti ad aprire un socket raw) lo stesso breve programma gira dentro una scheda. Ed è la metà scomoda della cosa. Qui non puoi fidarti dei tuoi utenti. L’host che pilota il tunnel è all’interno, in mano a qualcuno che hai deciso fosse sicuro perché siede dietro il firewall, e il firewall è la cosa attraverso cui si fa il tunnel. La fiducia perimetrale presume che la minaccia sia fuori dal muro. Questa parte dentro, ogni volta.

Occhio all’MTU, e al floor di 1280 di IPv6

Il tunnel non è gratis sul filo. Ogni pacchetto che trasporti guadagna un header IP esterno e un header ICMP prima di uscire, quindi l’interfaccia interna deve stare sotto quello che il percorso può portare. Su IPv4 questo costa all’attaccante quasi niente. Imposta l’MTU interno basso (il 1472 di icmptunnel è 1500 meno 20 per l’header IP esterno e 8 per l’header ICMP, e il Python qui sopra scende a 1400 per avere margine), e dove il numero è ancora sbagliato, IPv4 frammenta il pacchetto troppo grande e lo riassembla all’altro capo invece di scartarlo. Tra il floor basso che puoi scegliere e la frammentazione che copre il resto, il tunnel gira su quasi qualsiasi percorso. Quella flessibilità è esattamente ciò che rende IPv4 il posto comodo dove farlo.

La frammentazione e il margine di MTU di IPv4 fanno girare il tunnel dappertutto; IPv6 non ha nessuno dei due, quindi fallisce in modo chiusoPerché gira dappertutto su IPv4 e fallisce in modo chiuso su IPv6IPv4hdr IP20 BICMP8 Bpacchetto internotun MTU 1472 BTroppo grande? IPv4 frammenta e riassembla, il tunnel gira su quasi ogni percorso.IPv6hdr IPv640 BICMPv68 Bpacchetto internonon può scendere sotto 1280 Bfloor rigido di 1280 B (RFC 8200)Troppo grande? I router IPv6 lo scartano, niente frammentazione, il tunnel fallisce in modo chiuso.I ripieghi di IPv4, un floor che scegli tu e la frammentazione per il resto, sono ciò che rende il tunnel affidabile.IPv6 non ha nessuno dei due, quindi l'attacco che gira quasi dappertutto su IPv4 è fragile su IPv6. La famiglia più sicura qui.Packet Too Big, un errore che tieni, non un echo, è ciò che lascia a un mittente trovare la dimensione che entra. Non in scala.
Il tunnel perde un header IP esterno e un header ICMP da ogni pacchetto. IPv4 ti lascia limare l’MTU interno e frammenta quel che è ancora troppo grande, così gira quasi dappertutto; IPv6 fissa un floor rigido di 1280 byte e i suoi router non frammentano, quindi un pacchetto troppo grande viene scartato e il tunnel fallisce in modo chiuso, il che rende IPv6 la famiglia più sicura qui.

IPv6 perdona meno, e per una volta è dalla tua parte. Il floor è rigido: la RFC 820011 §5 richiede che «every link in the Internet have an MTU of 1280 octets or greater», e i router IPv6 non frammentano in transito. Questo toglie entrambi i ripieghi di IPv4 in un colpo solo, e morde il tunnel in entrambe le direzioni. Fallo girare sopra ICMPv6 e ogni collegamento sul percorso deve portare 1280, così un percorso che scende sotto quella soglia manda giù il trasporto, e non c’è modo di limare sotto il floor come puoi su IPv4. Trasporta IPv6 dentro il tunnel e incontri lo stesso muro dall’altro lato: anche l’interfaccia interna non può scendere sotto 1280, mentre l’involucro ICMPv6 esterno, 40 byte di header e 8 di ICMPv6, sta già spendendo il budget, così il percorso deve risparmiare 1280 più l’overhead. Mancalo in uno dei due posti e il pacchetto viene scartato, non tagliato per entrare: il tunnel sale, le cose piccole funzionano, qualsiasi cosa a dimensione piena si blocca. Quindi IPv6 è la famiglia più sicura qui, non la più rischiosa. L’attacco che su IPv4 gira su quasi tutto è fragile su IPv6, e fallisce in modo chiuso. Più sicuro non è lo stesso che sicuro, bada: il canale echo è aperto anche su IPv6, quindi la regola lo scarta comunque su entrambe le famiglie; l’attaccante semplicemente non può appoggiarsi a IPv6 come si appoggia a IPv4.

Il recupero da quello è l’errore ICMP che ti sei premurato di tenere. Packet Too Big è ciò che permette a un mittente di trovare la dimensione che funziona, ed è un errore, non un echo, quindi la regola che questo articolo sostiene lo lascia stare. Scarta il tunnel e tieni le diagnostiche: è tutto il progetto, e l’MTU è un altro posto in cui si guadagna da vivere.

La regola, ristretta a echo

L’articolo scorso dava l’intero ruleset di transito: permetti gli errori sotto un rate limit, scarta echo. Non lo ristamperò. La modifica che questo articolo sostiene è una sola coppia di righe, ed è la coppia che fa il lavoro:

# permit the ICMP errors — these are load-bearing, keep them
ip protocol icmp icmp type { destination-unreachable, time-exceeded, parameter-problem } \
    limit rate 100/second accept
ip6 nexthdr ipv6-icmp icmpv6 type { destination-unreachable, packet-too-big, \
    time-exceeded, parameter-problem } limit rate 100/second accept

# drop the tunnel — echo, both directions, both families
ip  protocol icmp     icmp   type { echo-request, echo-reply } drop
ip6 nexthdr ipv6-icmp icmpv6 type { echo-request, echo-reply } drop

La regola non è di Linux, però. È lo stesso intento su qualsiasi firewall degno del nome: permetti gli errori, limita il loro ritmo, scarta echo in entrambi i sensi su entrambe le famiglie. Quindi eccola nei dialetti che è più probabile tu abbia in mano.

BSD pf (pfSense, OPNsense, OpenBSD, FreeBSD):

# permit the errors; block echo both directions, both families
pass  in proto icmp  icmp-type  { unreach, timex, paramprob }
pass  in proto icmp6 icmp6-type { unreach, toobig, timex, paramprob, \
                                  routersol, routeradv, neighbrsol, neighbradv }
block in proto icmp  icmp-type  { echoreq, echorep }
block in proto icmp6 icmp6-type { echoreq, echorep }

Tieni i tipi di neighbour discovery sulla riga icmp6; sono quelli che mandano giù il segmento se li perdi.

Cisco IOS (ACL estese, applicate all’edge):

ip access-list extended ICMP-EDGE
 permit icmp any any unreachable
 permit icmp any any time-exceeded
 permit icmp any any parameter-problem
 deny   icmp any any echo
 deny   icmp any any echo-reply
!
ipv6 access-list ICMP6-EDGE
 permit icmp any any packet-too-big
 permit icmp any any unreachable
 permit icmp any any time-exceeded
 permit icmp any any parameter-problem
 permit icmp any any nd-ns
 permit icmp any any nd-na
 deny   icmp any any echo-request
 deny   icmp any any echo-reply

Su IPv4 il tipo echo è echo; su IPv6 è echo-request. Il rate-limiting vive in CoPP, non nell’ACL.

Juniper Junos (firewall filter; il filtro inet6 rispecchia questo e tiene la neighbour discovery):

firewall family inet filter icmp-edge {
    term errors {
        from { protocol icmp; icmp-type [ unreachable time-exceeded parameter-problem ]; }
        then { policer icmp-cap; accept; }
    }
    term drop-echo {
        from { protocol icmp; icmp-type [ echo-request echo-reply ]; }
        then discard;
    }
}

MikroTik RouterOS — scarta i due tipi echo, poi accetta il resto di ICMP, il che tiene gli errori e, su v6, la neighbour discovery:

/ip firewall filter
add chain=forward protocol=icmp icmp-options=8:0 action=drop comment="echo request"
add chain=forward protocol=icmp icmp-options=0:0 action=drop comment="echo reply"
add chain=forward protocol=icmp action=accept comment="keep the errors (add limit= to cap)"
/ipv6 firewall filter
add chain=forward protocol=icmpv6 icmp-options=128:0 action=drop comment="echo request"
add chain=forward protocol=icmpv6 icmp-options=129:0 action=drop comment="echo reply"
add chain=forward protocol=icmpv6 action=accept comment="keep errors and ND"

Sintassi diversa, una regola. Permetti i messaggi che portano la verità, scarta quello che porta i tuoi byte.

Due avvertenze, che ti morderanno entrambe se leggi di sfuggita.

Scarta echo al confine, non sul filo tra un host e il suo stesso router. Su IPv6 la neighbour discovery è ICMP, tipi da 133 a 137, da nd-router-solicit a nd-redirect, ed è come il segmento fa il lavoro che ARP fa in IPv4. Porta uno scarto di echo su una catena link-local o di host senza tenere quelli e il segmento smette di funzionare entro pochi minuti, e non sembrerà un guasto del firewall. Filtra echo dove il traffico lascia la tua rete, e lascia stare le catene interne.

Scartalo in entrambe le direzioni e smette di essere utile in entrambi i sensi. Bloccare solo la richiesta ferma i tuoi host dall’essere pingati ma lascia comunque uscire una risposta, e un tunnel può essere costruito solo sulle risposte con un po’ più di sforzo. Scarta richiesta e risposta, su IPv4 e IPv6, e il canale è chiuso in entrambi i sensi.

Cosa ti costa davvero scartare il ping

Sii onesto sulla perdita, perché un controllo che hai venduto troppo è un controllo che qualcuno annulla in silenzio la prima volta che è scomodo.

Perdi ping oltre il confine. È questo il costo, detto per intero. È un costo reale. ping è il riflesso, è nelle dita di tutti, e il giorno dopo che spedisci questo qualcuno dirà che internet è giù perché il suo ping al gateway va in timeout. Non è giù. Hai detto al gateway di smettere di rispondere a una richiesta che era solo una comodità.

Il test di raggiungibilità non ha bisogno di echo. Una connessione TCP a una porta che sai essere aperta ti dice che l’host è su e che il percorso funziona, e ti dice più di un ping perché dimostra che un servizio ha risposto, non solo un kernel:

# "is it up and reachable?" without sending a single echo
nc -zv <host> 443           # did the TCP handshake complete?
traceroute -T -p 443 <host> # walk the path on TCP, read the errors back

Entrambi quelli viaggiano sugli errori ICMP che hai tenuto e sul TCP che un servizio vero parla già. Nessuno dei due invia un echo. Quindi lo scambio onesto è questo: rinunci allo strumento meno informativo della cassetta, quello che risponde a «un kernel è disposto a rispondere» e niente più, e in cambio chiudi l’unica parte di ICMP che un attaccante può trasformare in una rotta fuori dalla tua rete. Le diagnostiche a cui davvero ricorri in una brutta giornata sono tutte dall’altra parte della linea, intatte.

Il Fisher-Price OS (Windows) non è una via d’uscita da questo

Se gestisci un’azienda su Fisher-Price OS (Windows) potresti leggere questo come un problema di qualcun altro. Non lo è. Il rischio è nel protocollo, non nel sistema operativo. Lo standard obbliga ogni host che risponde a un ping a restituirti i tuoi byte, e non si ferma a chiedere prima cosa fa girare l’host.

Una scatola su quel sistema operativo fa un ottimo capo di un tunnel. Hans spedisce un client Windows, quindi una macchina interna può essere il capo client e passare il suo traffico fuori dentro echo come qualsiasi altra. Quello che non può facilmente essere è il capo server, perché quello vuole un dispositivo tun e un socket ICMP raw tenuto aperto, e su quel sistema operativo solo i membri del gruppo Administrators possono creare socket di tipo SOCK_RAW12, parole di Microsoft stessa. Quindi il server sta su un sistema operativo vero, come il mio, e la scatola dietro il firewall che in silenzio si fa strada fuori a ping è quella che ti era stata detta sicura perché era all’interno.

È questo il punto per chiunque lo stia difendendo. La regola al confine non si cura di cosa fa girare l’interno. Scarta echo dove il traffico lascia la rete e ogni host dietro è coperto: quelli che amministri, e quello che ti era stato assicurato nascosto dietro il NAT. Io non la faccio girare, e non ho intenzione di fingere che il tunnel la rispetti. La soluzione è la stessa regola, nello stesso posto, qualunque cosa sia l’endpoint.

Se è la scatola stessa quello che stai irrobustendo (la scatola, non la rete), PowerShell la fermerà almeno dal rispondere o emettere un ping per conto suo:

foreach ($t in 8,0)     { New-NetFirewallRule -DisplayName "Drop ICMPv4 Echo $t" -Protocol ICMPv4 -IcmpType $t -Direction Inbound -Action Block }
foreach ($t in 128,129) { New-NetFirewallRule -DisplayName "Drop ICMPv6 Echo $t" -Protocol ICMPv6 -IcmpType $t -Direction Inbound -Action Block }

Aggiungi dei gemelli -Direction Outbound per fermarla dal raggiungere l’esterno come client di un tunnel invece che starsene lì come bersaglio, e lascia stare i tipi di errore ICMPv6 e di neighbour discovery, per il motivo per cui sono lasciati stare ovunque altro in questa pagina. Ma non scambiarlo per il controllo. Un firewall di host non è un firewall di transito. Irrobustisce la scatola e non cambia niente del confine, e il confine è dove questo si chiude davvero.

Solleva la questione con chi gestisce il tuo confine, oggi

Probabilmente sei arrivato fin qui pensando a una rete che non è tua da cambiare. Lo è per la maggior parte delle persone. Quindi la cosa utile da fare non è allungare la mano verso il firewall, è porre la domanda a chi lo tiene, la tua squadra di rete, il tuo MSP, o il vendor la cui scatola sta all’edge, e porla oggi, perché questa è una porta aperta dal 1996 e un’altra settimana così è una scelta.

Chiedi chiaro, e chiedi aspettandoti uno sguardo vuoto, perché scommetterei tutto il PIL del Regno Unito che nessuno lì ha dato a echo un secondo pensiero. È l’unico pacchetto che tutti permettono e che nessuno possiede, e una regola senza padrone è esattamente quella che sta sbagliata da anni senza nessuno che se ne accorga.

Chiedi loro quattro cose, con queste parole, così non c’è spazio per annuire e non cambiare niente:

  • Scartiamo la richiesta echo e la risposta echo ICMP al confine, su IPv4 e IPv6 entrambi? Non «permettiamo ICMP», il messaggio specifico, entrambe le direzioni, entrambe le famiglie. Se la risposta è una sola famiglia, non è una risposta, perché il tunnel si sposta sull’altra.
  • Permettiamo ancora gli errori ICMP? Destination Unreachable, Time Exceeded, Parameter Problem, e Packet Too Big su IPv6, sotto un rate limit invece di un blocco. Se non sanno dirlo, c’è una probabilità su due che abbiano lasciato tutto aperto o bloccato tutto, ed entrambe sono sbagliate.
  • Abbiamo tenuto la neighbour discovery IPv6 sulle catene interne? Tipi da 133 a 137. È quella che trasforma «abbiamo irrobustito ICMP» in un segmento che muore in silenzio una settimana dopo, ed è l’errore che fa una modifica fatta di fretta.
  • Mostrami la regola. Non una dichiarazione di policy, la riga vera sulla scatola vera, e la data in cui ci è andata. Un controllo che nessuno sa indicare è un controllo che non c’è.

La scatola sarà arrivata dal vendor con questo già chiuso? Non lo sarà. Il default quasi ovunque è lasciar passare echo e registrarlo come un conteggio di pacchetti, che è tutto il motivo per cui il tunnel funziona. Non sta sfruttando un bug, sta usando la configurazione che arriva di serie. Nessuno chiude una porta che non gli è mai stata detta aperta.

Il motivo per insistere sulla formulazione è che la soluzione pigra a questo articolo è «va bene, blocchiamo ICMP», e quella soluzione è peggio del buco. Rompe la path MTU discovery e il traceroute, ti farà rincorrere trasferimenti bloccati senza niente nei log, e su IPv6 toglie parti di internet dal tavolo del tutto. Se la persona a cui chiedi allunga la mano verso quella, fermala. L’istruzione è stretta apposta: scarta echo, tieni gli errori, tieni la neighbour discovery. Per questo chiunque gestisca firewall per mestiere dovrebbe saper fare quella modifica in un pomeriggio e dirti che è fatta.

E se sono un MSP che paghi per gestire questo: un fornitore che non sa dirti la tua stessa postura su echo ed errori a memoria, o che risponde «blocchiamo ICMP» come se quella fosse l’opzione sicura, ti ha appena detto qualcosa sul resto del patrimonio. La prossima volta che un guasto sta tra due reti ed entrambe dicono di essere pulite, ricorda quale delle due non sapeva descrivere cosa fa il suo stesso firewall a un ping.

La diagnostica che non è mai stata una diagnostica

Ping ha avuto una bella corsa. Mike Muuss lo scrisse nel 1983 per controllare se un host rispondeva, lo chiamò come il sonar, e fece quell’unico lavoro così bene da diventare la prima cosa a cui tutti ricorrono e l’ultima che nessuno mette in discussione. Quarant’anni dopo è memoria muscolare, e la memoria muscolare è esattamente il modo in cui un rischio sopravvive. Nessuno riesamina la cosa che ha sempre fatto.

Ma guarda cos’è davvero, spogliato dell’abitudine. Un messaggio che non porta nessun fatto sulla rete, a cui ogni host è obbligato a rispondere con i tuoi stessi byte restituiti, che gira su un protocollo che i controlli non ispezionano e i log non leggono. Tutto quello che lo fa sembrare innocuo, è solo una diagnostica, è solo un keepalive, tutti lo permettono, è la stessa cosa che lo rende la via più pulita fuori da una rete filtrata che esista. L’industria blocca gli errori ICMP, che portano la verità e rompono la rete quando spariscono, e fa passare echo, che porta qualsiasi cosa ci carichi dentro. Ha il protocollo esattamente a rovescio.

La soluzione non è furba. Tieni i messaggi che ti dicono la verità, e scarta quello che si limita a restituirti i tuoi byte. Ti costa un comando di cui non avevi comunque motivo di fidarti per una diagnosi, e chiude una porta che è rimasta aperta dal 1996, documentata in una rivista di hacker, impacchettata per due decenni, e lasciata spalancata perché chiuderla significherebbe che qualcuno non può fare ping. Sappi cosa costa una cosa, non quanto è prezzata. Ping è prezzato a niente. Ti costa l’unico canale che non puoi vedere.


  1. Loki, Phrack 49 — un canale di comando trasportato dentro i payload ICMP echo, 1996. ↩︎

  2. Ptunnel — trasporta una sessione TCP dentro l’ICMP echo. ↩︎

  3. RFC 792 — ICMP: “the data received in the echo message must be returned in the echo reply message”. ↩︎

  4. RFC 4443 — ICMPv6: i dati echo “MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message”. ↩︎

  5. RFC 4890 — i messaggi ICMPv6 che un firewall non deve scartare. ↩︎

  6. RFC 1812 — requisiti dei router: Time Exceeded è un MUST, indicato per il traceroute. ↩︎

  7. Hans — tunnel IP su ICMP echo, di Friedrich Schöller. ↩︎

  8. icmptunnel — fa il tunnel del traffico IP attraverso pacchetti ICMP echo e reply, di Dhaval Kapil. ↩︎

  9. Linux kernel — IP sysctl — icmp_echo_ignore_all: “the kernel will ignore all ICMP ECHO requests sent to it”. ↩︎

  10. Linux commit e6f86b0f — “ipv6: Add icmp_echo_ignore_all support for ICMPv6” — l’equivalente IPv6, di Virgile Jarry. ↩︎

  11. RFC 8200 §5 — IPv6 richiede che ogni collegamento abbia un MTU di almeno 1280 ottetti. ↩︎

  12. Microsoft — TCP/IP raw sockets — “only members of the Administrators group can create sockets of type SOCK_RAW”. ↩︎