O ping não é um diagnóstico. É um túnel. O echo ICMP (o pedido que uma máquina envia e a resposta que recebe de volta) leva quaisquer bytes que lá ponhas, nos dois sentidos, sobre um protocolo que a maioria das firewalls deixa passar sem inspecionar e que a maioria dos registos conta em vez de ler. Uma rede que «só permite ping» já tem uma VPN inteira, encriptável, a sair dela, e qualquer pessoa que chegue a essa rede consegue conduzir uma.

Isto é antigo, e está documentado. O Loki1 publicou a técnica na Phrack 49 em 1996. O Ptunnel2 carrega sessões TCP inteiras dentro do ping há vinte anos e está a um pacote de distância em qualquer máquina Linux. Nenhum zero-day. O protocolo a comportar-se exatamente como está especificado.

É essa a causa: a norma, não um erro no produto de alguém. Todos os anfitriões do planeta são obrigados a pegar nos dados de um pedido de echo e devolvê-los de imediato, inalterados. Dados arbitrários à entrada, os mesmos dados à saída: é tudo o que um túnel precisa, e está mandatado desde 1981.

A correção é uma única alteração estreita. Descartar o echo ICMP, pedido e resposta, em IPv4 e IPv6, na fronteira, e manter todas as outras mensagens ICMP. Os erros, Time Exceeded, Packet Too Big, Destination Unreachable, são de carga; bloqueia-os e partes a descoberta do MTU do caminho e o traceroute à troca de nada. Por isso isto não é «bloquear o ICMP». É descartar a única mensagem que é um risco, e manter as que carregam a verdade.

O que a tua política de egresso permitia de facto

Se geres uma rede onde a saída é filtrada (e se não é, essa é outra conversa), então esta é a conta de uma linha dela. A política que diz «bloquear tudo à saída, permitir ICMP porque precisamos de fazer ping às coisas» não é uma política de egresso. É um túnel inteiro com a papelada arquivada em diagnósticos. Qualquer coisa do lado de dentro que consiga enviar um pedido de echo e ler a resposta pode mover dados para qualquer sítio do lado de fora que responda a um, ao ritmo que a ligação aguentar, e a passar por todos os controlos de conteúdo que compraste. Nos registos é alguém a verificar se a internet está de pé, e nada mais. O malware traz isto há anos exatamente por essa razão. Silencioso, normal, e normalmente já permitido.

É por isto que é um canal de primeira escolha para quem já está lá dentro e não devia estar. É a estadia, não o assalto. Alguém à procura de uma entrada e saída que dure evita a porta que dispara um alerta. Montam um túnel sobre o echo e deixam-no a correr durante meses. Um anfitrião que faz muito ping é um anfitrião que ninguém vigia. Rede nos dois sentidos para dentro da organização: comandos para dentro, dados para fora, sobre o único protocolo que ninguém limita no ritmo, alerta ou lê. E vai encriptado, como qualquer ferramenta a sério o encripta, por isso no fio a carga são os bytes de aspeto aleatório que um ping carrega de qualquer maneira e a inspeção de conteúdo não tem nada para ler. O tamanho e os tempos ainda o podem denunciar a quem esteja mesmo a olhar. Espreitar dentro do pacote não pode.

E a máquina que o conduz não precisa de pertencer a quem lá trabalha. Basta algo que chegue à tua rede e ponha um ping na internet, e chegar à tua rede é mais fácil do que ninguém gosta de admitir. O WiFi passa para lá das paredes, para o corredor, o parque de estacionamento, o apartamento de cima. A porta ethernet na parede da sala de reuniões, ou na receção, ou na secretária vazia junto à janela, está muitas vezes ativa e fala com tudo o que lá ligues, sem nenhum 802.1X a perguntar quem és. Um sinal ao alcance, ou uma tomada que ninguém trancou. É esse o preço de entrada. Sem crachá, sem conta, sem convite.

Imagina o visitante que de facto convidaste. Está na reunião, simpático, a tomar notas, a contribuir. O portátil dele não. No momento em que chegou à tua rede, pelo ar ou pela porta debaixo da mesa, ficou dentro da muralha, e se essa rede consegue emitir um pedido de echo, tem uma saída. Nada foi largado na tua organização. Nenhuma conta, nenhum privilégio sobre nada que seja teu, nada para os teus agentes de endpoint apanharem, porque os teus agentes não estão na máquina dele. A pessoa está do outro lado da mesa. O tráfego está a sair pela tua porta da frente, encriptado, indistinguível de um portátil que faz mais ping do que devia.

Um visitante ao alcance do sinal, ou numa porta aberta, obtém um túnel que sai por uma firewall que só vê pingsUm visitante ao alcance, ou numa porta aberta, obtém uma saídadentro da muralha, a tua redeo WiFi chega aocorredor,parque,apartamento de cimaportátil do visitantesem crachá, sem contauma porta de parede ativasem 802.1X a perguntar quem ésfirewall de fronteirasó vê pingsservidorna internetecho request →← echo replyqualquer tráfego IP, encriptado, a viajar dentro dos pings
O preço de entrada é o acesso à rede, um sinal WiFi ao alcance, ou uma porta de parede ativa sem 802.1X, e a saída é o echo pela fronteira. Para a firewall é um anfitrião que faz ping; dentro desses pings vai qualquer tráfego IP, encriptado, com destino a um servidor na internet.

As duas coisas a que vais deitar a mão não ajudam. O NAT é uma tabela de tradução, não um filtro: um pedido de echo de um anfitrião interno abre um mapeamento com chave no id ICMP, que o NAT trata exatamente como trata uma porta, e a resposta volta por ele como qualquer outro fluxo. Corri um cliente por trás do meu próprio NAT doméstico e ele nunca reparou que o NAT lá estava. Uma VLAN de convidados separada não é melhor. A segregação mantém o visitante longe dos teus servidores, mas não faz nada para o manter longe da internet, e a internet, alcançada com um ping, é o requisito todo. Um controlo toca nisto: essa rede deixa o echo sair?

Não resolves isto a inspecionar, e não resolves isto a segregar. Fechas a porta. Tudo o que vem a seguir é porque é que a norma a deixa aberta, três formas de construir o túnel para que a afirmação se apoie em mais do que a minha palavra, e a única alteração que a fecha.

A parte do ICMP que não te deve nada de útil

Começa pelo que a norma diz de facto, porque o argumento todo assenta numa frase e as pessoas deitam-na fora sem a ler.

Um pedido de echo carrega um campo de dados. Em IPv4, o RFC 7923 diz sem rodeios que «the data received in the echo message must be returned in the echo reply message». O IPv6 apertou a redação em vez de a afrouxar: o RFC 44434 define o campo como «zero or more octets of arbitrary data» e depois exige que «MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message».

Lê isso como operador e é um keepalive. Lê-o como quem move dados e é uma prenda. A norma obriga todos os anfitriões alcançáveis a aceitar um bloco de bytes que tu escolhes e a enviá-los de volta, inalterados, quando pedires. Comprimento arbitrário. Conteúdo arbitrário. Sem handshake, sem porta, sem aplicação do outro lado que tenha de concordar com o que quer que seja. O kernel fá-lo, antes de qualquer processo em userland dar por ele.

E são as duas famílias. Passar para IPv6 não arruma isto. Abre-o mais. O RFC 792 dizia que os dados «must be returned»; o RFC 4443 diz que «MUST be returned entirely and unmodified», que é a mesma porta com um trinco mais forte a mantê-la aberta. Como tal, o canal existe tanto no echo ICMP como no echo ICMPv6, e uma regra que o fecha numa família e não na outra não fechou nada. O túnel muda-se simplesmente para a família que deixaste aberta. Faças o que fizeres quanto a isto, fá-lo em ip e ip6 ao mesmo tempo.

Nada mais no protocolo faz isto. Um Time Exceeded carrega o cabeçalho do pacote que morreu e nada mais. Um Destination Unreachable é um relatório sobre algo que já aconteceu. Essas mensagens dizem-te factos sobre a rede. O echo carrega o que lá puseres, nos dois sentidos, e chama-lhe diagnóstico.

Os erros são de carga. O echo não é.

Esta é a distinção que o pessoal do «basta bloquear o ICMP» nunca faz, e é o ponto todo, por isso faço-a uma vez e como deve ser.

Bloquear os erros ICMP parte a rede em silêncio. Filtra o Packet Too Big e matas a descoberta do MTU do caminho: o handshake completa-se, as transferências pequenas funcionam, e tudo o que carregue um pacote de tamanho cheio fica pendurado para sempre sem nada nos registos. Em IPv6 isso nem sequer é uma questão de gosto. Os routers não fragmentam, por isso o RFC 48905 lista o Packet Too Big entre as mensagens que uma firewall «must not drop» e avisa que sem ele «parts of the Internet will become inaccessible». Filtra o Time Exceeded e partes o traceroute, que o RFC 18126 aponta como a razão pela qual a mensagem é obrigatória, para começar. Isto não é opcional. É o retorno que torna a rede autocorretiva, e cobri o custo de os perder ao pormenor da última vez.

Agora descarta o echo e vai à procura do que partiu. O ping através da fronteira deixa de funcionar. É essa a lista. A lista inteira.

A descoberta do MTU do caminho não quer saber, porque corre sobre o Packet Too Big, que é um erro. O traceroute não quer saber, porque o traceroute -T e o -U percorrem TCP e UDP e leem os erros que voltam. Nenhum deles envia um echo. A descoberta de vizinhos em IPv6 não quer saber, porque isso são os tipos 133 a 137, e tu mantém-nos ou o segmento morre. O truque do TTL inverso do último artigo funciona em qualquer resposta, e um handshake TCP dá-te uma. Tudo o que fez os diagnósticos do último artigo funcionar continua a funcionar, porque nem uma medição dele enviava um pedido de echo.

Por isso as duas metades do protocolo não podiam ser mais diferentes. Uma metade é a rede a dizer-te a verdade sobre si própria, e partes-la por tua conta e risco. A outra metade é um serviço mandatado de devolução de carga que por acaso se chama diagnóstico, e o mais forte que alguém pode dizer a favor de o manter aberto é que o ping dá jeito. Dá jeito. É também a única parte do ICMP que um atacante consegue conduzir, e posso mostrar-te exatamente com o quê a conduzem.

Mantém os erros ICMP, com limite de ritmo; descarta só o echo, nos dois sentidos e nas duas famíliasDuas metades de um protocolo, e só uma delas é um riscoMANTERlimitar o ritmo, nunca bloquearDestination Unreachablediz porque um pacote não foi entreguePacket Too Biga descoberta do MTU do caminho depende deleTime Exceededo traceroute depende deleParameter Problemreporta um cabeçalho malformadoNeighbour Discovery 133–137IPv6: o segmento local depende deleParte estes e a rede parte-se em silêncio.DESCARTARnos dois sentidos e famíliasEcho requesttipo 8 (IPv4) · tipo 128 (IPv6)Echo replytipo 0 (IPv4) · tipo 129 (IPv6)Nada precisa destes a não ser opingcomando.Tudo o que um atacante conduzpelo ICMP passa por eles.Um túnel deixado aberto numa família não está fechado.
Os erros ICMP são de carga: a descoberta do MTU do caminho, o traceroute e a descoberta de vizinhos de IPv6 dependem todos deles, e bloqueá-los parte a rede em silêncio. O echo é a única parte de que nada depende a não ser o ping, e a única parte que um atacante consegue conduzir. Descarta isso, mantém o resto, nas duas famílias.

A prova: uma VPN feita de ping

A ferramenta é o Hans7, escrito por Friedrich Schöller. A descrição dele é uma linha: «makes it possible to tunnel IPv4 through ICMP echo packets, so you could call it a ping tunnel.» Levanta uma interface tun em cada ponta, dá-lhes endereços, e move cada pacote entre elas dentro de echo ICMP. Para a rede que está no meio é alguém a fazer ping a um servidor e o servidor a responder. Para mim é uma rota.

Um pacote IP inteiro viaja dentro do campo de dados de um só pingUm pacote inteiro viaja dentro de um pingO pacote que a tua sessão SSH enviacabeçalho IPsrc / dstcabeçalho TCPporta 22dados da aplicaçãoas tuas teclas, o teu ficheiroO Hans copia o pacote inteiro para o campo de dados de echoO pacote que sai no fiocabeçalho IPtu para o servidorpedido de echo ICMPtipo 8 · id · seqcampo de dados de echoo pacote inteiro acima, inalteradoPara a firewall de fronteira isto é um pedido de echo, e o registo anota um ping.Dentro do campo de dados está um pacote com destino a onde a outra ponta consiga chegar.A norma obriga a outra ponta a devolver logo esses dados, por isso a resposta também é um pacote.
Cada pacote que o túnel carrega é copiado para o campo de dados de um pedido de echo ICMP. A norma obriga a outra ponta a devolver esses dados inalterados, por isso a resposta também carrega um pacote. A firewall conta um ping; a carga vai para onde quer que a outra ponta consiga encaminhar.

Corri-o através da minha própria linha, um servidor num endereço público e um cliente por trás do meu NAT doméstico, e empurrei tráfego real por ele. Não pings sintéticos com uma flag ligada. Um login SSH e uma transferência de ficheiro, a viajar dentro do echo.

Está a um pacote de distância onde corri o servidor, e constrói-se a partir do código-fonte do Schöller em qualquer outro sítio. O servidor tem de ser Linux e precisa de root, porque abrir um dispositivo tun e um socket ICMP em bruto, ambos precisam. A sintaxe é deliberadamente pequena:

# 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>'

Assim que as duas pontas estão de pé há uma interface nova de cada lado com um endereço na rede do túnel, e comporta-se como qualquer outra ligação ponto a ponto:

Nada daquela sessão sabe que está dentro de um ping. O SSH abre uma ligação TCP a 10.8.0.1, o kernel encaminha-a para fora pela tun0, o Hans embrulha cada pacote como a carga de um pedido de echo, e a outra ponta desembrulha-o e entrega-o à sua própria tun0. A resposta volta como a carga de uma resposta de echo. Tanto quanto o SSH sabe, está a falar sobre uma ligação normal. Tanto quanto a firewall sabe, ninguém abriu nada. Está a ser feito ping a um anfitrião.

Que aspeto tem no fio

Esta é a parte que acaba com o argumento, por isso observa a vista a partir da firewall em vez da minha.

O que se passa de facto, e o que a firewall regista, não são a mesma imagemUm túnel, duas imagensO que se passa de factoo teu anfitriãotun0 · 10.8.0.2o servidortun0 · 10.8.0.1onde quer queconsiga chegarSSH, transferênciasencaminhado para foraqualquer tráfego IP, pelo túnelcomo pacotes normaisO que a firewall de fronteira vê e registao teu anfitrião198.51.100.9o servidor192.0.2.7pedido de echoresposta de 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... contados como pings, conteúdo não lidoMesmo fio. A firewall nunca vê os pacotes lá dentro.
O túnel move tráfego real entre dois anfitriões e depois para fora, para onde quer que o servidor consiga chegar. Na fronteira é só pedido de echo e resposta de echo, a firewall regista pings e nunca vê os pacotes carregados dentro deles.

Senta-te na interface de fora com o tcpdump e captura só ICMP enquanto a sessão SSH corre. Nenhum TCP para a porta 22 atravessa a fronteira. O que atravessa é pedido de echo e resposta de echo, para trás e para a frente, cada um mais gordo do que um ping real porque carrega uma fatia de um segmento TCP na sua carga:

# 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'

Lê as duas coisas que importam nessa captura. Primeiro, os comprimentos da carga: um ping normal envia 56 bytes e cada linha tem o mesmo tamanho, enquanto estes variam e vão grandes, porque o tamanho da coisa que estás a mover vaza para o tamanho do ping. Segundo, o ritmo: um ping de diagnóstico é um por segundo, e isto é uma enxurrada, porque está a mover um ficheiro. Nenhum dos dois está escondido. Ambos estão à vista de todos, num protocolo a que ninguém está a prestar atenção.

E é esse o ponto todo. Não que isto seja esperto, ou difícil de ver assim que olhas. Quase ninguém olha, porque a caixa está configurada para permitir ICMP, os registos contam-no como pings, e os alertas foram afinados para as portas que alguém se lembrou de recear. O tráfego sai com aspeto de verificação de saúde e a verificação de saúde é uma rota para onde quer que o servidor consiga chegar.

Uma VPN full-tunnel a sério, construída à mão

O Hans prova que o canal lá está, mas faz a interface e o endereçamento por ti e devolve-te uma rota, por isso não te mostra bem o que construíste. Para ver que isto é uma VPN no sentido pleno, o tráfego da máquina inteira a sair pelo ping, não uma ligação entre dois anfitriões nomeados, monta-a à mão. O icmptunnel8, de Dhaval Kapil, é o indicado para isso, e a descrição dele é uma só linha: «Transparently tunnel your IP traffic through ICMP echo and reply packets.» Mesma ideia, dispositivo tun e cargas de echo, mas estendes a canalização tu próprio e nada se esconde dentro de um binário.

No servidor arrancas o túnel, levantas a interface, e depois fazes a coisa que entrega o jogo todo: dizer ao kernel para deixar de responder ele próprio aos pings, para que as suas próprias respostas de echo não briguem com as que o túnel está a enviar.

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

Lê a linha do icmp_echo_ignore_all outra vez, porque diz mais do que parece. Esse botão é do próprio kernel, e vem como defesa: liga-o e, nas palavras do kernel, ele «will ignore all ICMP ECHO requests sent to it»9, para que um operador possa tirar um anfitrião do radar do ping por completo. Está nas duas famílias agora. O net.ipv4.icmp_echo_ignore_all há anos, e o net.ipv6.icmp.echo_ignore_all acrescentado mais tarde para condizer.10 O túnel vira esse interruptor defensivo pela razão oposta: com o kernel já a não responder ele próprio ao echo, as suas duas pontas ficam livres para usar o echo como transporte puro. Que é o sinal. As pessoas que escreveram a pilha já tratam o echo como algo que um anfitrião pode razoavelmente recusar, a regra deste artigo faz essa mesma escolha uma vez, na fronteira, por cada anfitrião atrás dela.

No cliente levantas a interface e depois apontas a rota predefinida para baixo por ela. Não um anfitrião alcançado pelo túnel. Tudo.

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

Os próprios client.sh e server.sh do projeto ainda deitam a mão ao ifconfig e ao route do net-tools. Os comandos ip acima são os equivalentes em iproute2 e fazem o mesmo trabalho. Aquela rota para o servidor é a linha de que as pessoas se esquecem: mantém-na fora do túnel, ou os pacotes de echo que carregam o túnel tentam viajar pelo túnel, e nada sai. Tudo o resto vai agora pela tun0, embrulhado em echo, e chega ao servidor. Se vai mais longe é uma escolha de encaminhamento. Uma única regra de masquerade no servidor pô-lo-ia na internet pública sob o próprio endereço do servidor, e está deliberadamente ausente aqui, porque o túnel é a coisa a mostrar e não precisa dela.

Isso é uma VPN full-tunnel, construída a partir de ping numa mão-cheia de comandos. Cada pacote que o cliente envia, web, DNS, SSH, tudo, é capturado na tun0 e sai como um pedido de echo para o servidor, e as respostas voltam como respostas de echo. Uma máquina numa rede que «só permite ICMP» acabou de entregar o seu tráfego de saída inteiro a uma caixa lá fora, e a fronteira registou um anfitrião que gosta de fazer ping.

Escrever o teu em Python

Aqui está a parte que devia preocupar quem espera defender-se disto detetando uma ferramenta. Nem o Hans nem o icmptunnel fazem nada que tu não pudesses escrever numa tarde. Abrir um dispositivo tun, embrulhar cada pacote como a carga de um pedido de echo, desembrulhar os que voltam. É esse o mecanismo todo, e o túnel nu são cerca de sessenta linhas de Python de biblioteca-padrão sem nada para instalar. A versão abaixo acrescenta uma coisa por cima: encripta a carga, e essa é a única parte que puxa uma dependência.

#!/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()

É esse o túnel inteiro. Abre a tun0 e um socket ICMP em bruto e faz os pacotes vaivém entre eles: o que sai do anfitrião é embrulhado como um pedido de echo, ou uma resposta de echo no servidor, e enviado para a outra ponta; o que chega por ICMP é desembrulhado e entregue de volta à pilha. O campo id está fixo num valor para passar por cima dos pings reais, e o servidor aprende de onde responder a partir da origem do primeiro pacote que vê.

A encriptação é o ponto que vale a pena demorar, porque é o que as ferramentas a sério fazem e é por isso que não vais apanhar isto a olhar dentro do pacote. A carga é selada com AES-128-GCM sob uma chave pré-partilhada antes de ser embrulhada, por isso os bytes nos dados de echo são indistinguíveis do enchimento aleatório que um ping real carrega. Tira as duas linhas de cripto e o túnel ainda corre sobre nada mais do que a biblioteca-padrão, a única razão por que precisa de pip install cryptography é o AES, e o AES é exatamente a parte que transforma um túnel legível num ilegível. Levanta-o da mesma maneira que antes, menos o masquerade. Não precisas dele para provar o ponto:

# 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

A razão para o escrever não é a ferramenta. É que a ferramenta é descartável. Um ficheiro curto, sem dependências até acrescentares a encriptação, e cada cópia que alguém escreve fica um bocadinho diferente no fio. Por isso uma assinatura que apanha esta não apanha nada para a semana. Não te consegues safar disto a bloquear, nomeando o software, porque não há software para nomear.

Nem sequer precisa de uma shell. A lógica é bytes para dentro, bytes para fora, por isso porta-se para qualquer coisa que consiga abrir um socket. Até WebAssembly: a sandbox do navegador normalmente recusa a uma página um socket em bruto de forma categórica, mas onde essa barreira é levantada (um navegador com a permissão dada pelo utilizador, numa máquina onde o utilizador corre com privilégio suficiente para um socket em bruto poder ser aberto) o mesmo programa curto corre dentro de um separador. Que é a metade incómoda disto. Não podes confiar nos teus utilizadores aqui. O anfitrião que conduz o túnel está do lado de dentro, nas mãos de alguém que decidiste ser seguro porque se senta atrás da firewall, e a firewall é a coisa pela qual se está a fazer o túnel. A confiança no perímetro assume que a ameaça está fora da muralha. Esta começa dentro dela, sempre.

Olho ao MTU, e ao piso de 1280 do IPv6

O túnel não sai de graça no fio. Cada pacote que carregas ganha um cabeçalho IP exterior e um cabeçalho ICMP antes de sair, por isso a interface interior tem de ficar abaixo do que o caminho consegue carregar. Em IPv4 isso quase não custa nada ao atacante. Põe o MTU interior baixo (o 1472 do icmptunnel é 1500 menos 20 do cabeçalho IP exterior e 8 do cabeçalho ICMP, e o Python acima desce para 1400 para ter folga), e onde o número ainda está errado, o IPv4 fragmenta o pacote demasiado grande e remonta-o na outra ponta em vez de o descartar. Entre o piso baixo que podes escolher e a fragmentação a tapar o resto, o túnel corre em quase qualquer caminho. É essa flexibilidade que faz do IPv4 o sítio confortável para fazer isto.

A fragmentação e a folga de MTU do IPv4 deixam o túnel correr em qualquer lado; o IPv6 não tem nenhuma, por isso falha fechadoPorque corre em qualquer lado em IPv4 e falha fechado em IPv6IPv4cab. IP20 BICMP8 Bpacote interiortun MTU 1472 BDemasiado grande? O IPv4 fragmenta e remonta, o túnel corre em quase qualquer caminho.IPv6cab. IPv640 BICMPv68 Bpacote interiornão desce abaixo de 1280 Bpiso duro de 1280 B (RFC 8200)Demasiado grande? Os routers IPv6 descartam-no, sem fragmentação, o túnel falha fechado.Os recursos do IPv4, um piso à tua escolha e a fragmentação para o resto, são o que torna o túnel fiável.O IPv6 não tem nenhuma, por isso o ataque que corre em quase todo o lado em IPv4 é frágil em IPv6. A família mais segura aqui.O Packet Too Big, um erro que manténs, não um echo, é o que deixa um remetente encontrar o tamanho que cabe. Fora de escala.
O túnel perde um cabeçalho IP e ICMP exterior em cada pacote. O IPv4 deixa-te raspar o MTU interior e fragmenta o que ainda for demasiado grande, por isso corre quase em qualquer lado; o IPv6 impõe um piso duro de 1280 bytes e os seus routers não fragmentam, por isso um pacote demasiado grande é descartado e o túnel falha fechado, o que faz do IPv6 a família mais segura aqui.

O IPv6 é menos tolerante, e por uma vez isso está do teu lado. O piso é duro: o RFC 820011 §5 exige que «every link in the Internet have an MTU of 1280 octets or greater», e os routers IPv6 não fragmentam em trânsito. Isso retira os dois recursos do IPv4 de uma vez, e morde o túnel nos dois sentidos. Corre-o sobre ICMPv6 e cada ligação do caminho tem de carregar 1280, por isso um caminho que desça abaixo disso derruba o transporte, e não há como raspar sob o piso como podes em IPv4. Carrega IPv6 dentro do túnel e encontras a mesma parede pelo outro lado: a interface interior também não pode descer abaixo de 1280, enquanto o invólucro ICMPv6 exterior, 40 bytes de cabeçalho e 8 de ICMPv6, já está a gastar o orçamento, por isso o caminho tem de ter de sobra 1280 mais a sobrecarga. Falha-o num dos dois sítios e o pacote é descartado, não cortado para caber: o túnel levanta-se, as coisas pequenas funcionam, tudo o que seja de tamanho cheio fica pendurado. Por isso o IPv6 é a família mais segura aqui, não a mais arriscada. O ataque que corre em quase tudo em IPv4 é frágil em IPv6, e falha fechado. Mais seguro não é o mesmo que seguro, atenção: o canal de echo está aberto também em IPv6, por isso a regra ainda o descarta nas duas famílias, o atacante é que não se pode apoiar no IPv6 como se apoia no IPv4.

A recuperação disso é o erro ICMP que tiveste o cuidado de manter. O Packet Too Big é o que deixa um remetente encontrar o tamanho que funciona, e é um erro, não um echo, por isso a regra que este artigo defende deixa-o em paz. Descarta o túnel e mantém os diagnósticos, é esse o desenho todo, e o MTU é mais um sítio onde ele justifica o seu lugar.

A regra, estreitada ao echo

O último artigo deu o conjunto de regras de trânsito completo: permitir os erros sob um limite de ritmo, descartar o echo. Não o vou reimprimir. A alteração que este artigo defende é um par de linhas, e é o par que faz o trabalho:

# 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

A regra não é do Linux, porém. É a mesma intenção em qualquer firewall digna do nome: permitir os erros, limitar o ritmo, descartar o echo nos dois sentidos nas duas famílias. Por isso aqui está nos dialetos que é mais provável que tenhas em mãos.

pf do BSD (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 }

Mantém os tipos de descoberta de vizinhos na linha icmp6; esses são os que derrubam o segmento se os perderes.

Cisco IOS (ACLs estendidas, aplicadas na borda):

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

Em IPv4 o tipo de echo é echo; em IPv6 é echo-request. A limitação de ritmo vive no CoPP, não na ACL.

Juniper Junos (filtro de firewall; o filtro inet6 espelha isto e mantém a descoberta de vizinhos):

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 — descarta os dois tipos de echo, depois aceita o resto do ICMP, o que mantém os erros e, em v6, a descoberta de vizinhos:

/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"

Sintaxe diferente, uma regra. Permite as mensagens que carregam a verdade, descarta a que carrega os teus bytes.

Dois cuidados, e ambos te mordem se leres por cima.

Descarta o echo na fronteira, não no fio entre um anfitrião e o seu próprio router. Em IPv6, a descoberta de vizinhos é ICMP, tipos 133 a 137, de nd-router-solicit a nd-redirect, e é como o segmento faz o trabalho que o ARP faz em IPv4. Leva um descarte de echo para uma cadeia link-local ou de anfitrião sem manter esses e o segmento deixa de funcionar em minutos, e não vai parecer uma falha de firewall. Filtra o echo onde o tráfego sai da tua rede, e deixa as cadeias internas em paz.

Descarta-o nos dois sentidos e deixa de ser útil de qualquer dos lados. Bloquear só o pedido impede que se faça ping aos teus anfitriões mas ainda deixa sair uma resposta, e um túnel pode ser construído só sobre respostas com um pouco mais de esforço. Descarta pedido e resposta, em IPv4 e IPv6, e o canal fica fechado dos dois lados.

O que descartar o ping te custa de facto

Sê honesto sobre a perda, porque um controlo que vendeste a mais é um controlo que alguém reverte em silêncio da primeira vez que dá jeito.

Perdes o ping através da fronteira. É esse o custo, dito por inteiro. É um custo real. O ping é o reflexo, está nos dedos de toda a gente, e no dia a seguir a lançares isto alguém vai dizer que a internet está em baixo porque o ping dele ao gateway dá timeout. Não está em baixo. Disseste ao gateway para deixar de responder a um pedido que nunca foi mais do que uma conveniência.

Testar a alcançabilidade não precisa de echo. Uma ligação TCP a uma porta que sabes estar aberta diz-te que o anfitrião está de pé e o caminho funciona, e diz-te mais do que um ping diz, porque prova que um serviço respondeu, não só um 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

Ambos viajam sobre os erros ICMP que mantiveste e o TCP que um serviço a sério já fala. Nenhum envia um echo. Por isso a troca honesta é esta: desistes da ferramenta menos informativa da caixa, a que responde «um kernel está disposto a responder» e nada mais, e em troca fechas a única parte do ICMP que um atacante consegue transformar numa rota para fora da tua rede. Os diagnósticos a que de facto deitas a mão num dia mau estão todos do outro lado da linha, intactos.

O Fisher-Price OS (Windows) não é uma saída disto

Se geres uma casa com o Fisher-Price OS (Windows) talvez estejas a ler isto como um problema de outra pessoa. Não é. O risco está no protocolo, não no sistema operativo. A norma obriga todos os anfitriões que respondem a um ping a devolver os teus bytes, e não para para perguntar primeiro o que o anfitrião está a correr.

Uma caixa nesse sistema operativo faz uma ponta de túnel perfeitamente boa. O Hans traz um cliente Windows, por isso uma máquina interna pode ser a ponta cliente e passar o seu tráfego para fora dentro de echo como qualquer outra. O que ela não pode ser facilmente é a ponta servidor, porque isso quer um dispositivo tun e um socket ICMP em bruto mantido aberto, e neste sistema operativo só os membros do grupo Administrators podem criar sockets do tipo SOCK_RAW12, palavras da própria Microsoft. Por isso o servidor senta-se num sistema operativo a sério, como o meu sentou, e a caixa atrás da firewall a fazer o seu caminho para fora em silêncio com pings é aquela que te disseram ser segura por estar do lado de dentro.

É esse o ponto para quem o defende. A regra de fronteira não quer saber o que o lado de dentro corre. Descarta o echo onde o tráfego sai da rede e todos os anfitriões atrás dela ficam cobertos, os que administras, e aquele que te garantiram estar escondido atrás do NAT. Eu não corro a coisa, e não vou fingir que o túnel a respeita. A correção é a mesma regra, no mesmo sítio, seja qual for o sistema em que o endpoint arrancou.

Se a própria caixa é o que estás a endurecer (a caixa, não a rede), o PowerShell pelo menos impede-a de responder ou emitir um ping por conta própria:

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 }

Acrescenta gémeos -Direction Outbound para a impedir de se esticar para fora como cliente de túnel em vez de ficar ali como alvo, e deixa os tipos de erro ICMPv6 e de descoberta de vizinhos em paz, pela razão por que são deixados em paz em todo o lado nesta página. Mas não o confundas com o controlo. Uma firewall de anfitrião não é uma firewall de trânsito. Endurece a caixa e não muda nada quanto à fronteira, e a fronteira é onde isto fica mesmo fechado.

Levanta isto hoje com quem gere a tua fronteira

Provavelmente leste até aqui a pensar numa rede que não é tua para mudar. A maioria das pessoas está nessa. Por isso a coisa útil a fazer não é deitar a mão à firewall, é pôr a questão a quem a tem, a tua própria equipa de rede, o teu MSP, ou o fornecedor cuja caixa está na borda, e pô-la hoje, porque isto é uma porta aberta desde 1996 e mais uma semana dela é uma escolha.

Pergunta sem rodeios, e pergunta à espera de um olhar vazio, porque eu apostava o PIB inteiro do Reino Unido em como ninguém aí deu ao echo um segundo pensamento. É o único pacote que toda a gente permite e ninguém é dono, e uma regra sem dono é exatamente aquela que esteve mal assente durante anos sem ninguém para reparar.

Pergunta-lhes quatro coisas, nestas palavras, para que não haja espaço para acenar e não mudar nada:

  • Descartamos o pedido de echo ICMP e a resposta de echo na fronteira, em IPv4 e IPv6 os dois? Não «permitimos ICMP», a mensagem específica, os dois sentidos, as duas famílias. Se a resposta for só uma família, não é resposta, porque o túnel muda-se para a outra.
  • Ainda permitimos os erros ICMP? Destination Unreachable, Time Exceeded, Parameter Problem, e Packet Too Big em IPv6, sob um limite de ritmo em vez de um bloqueio. Se não souberem dizer, as probabilidades são meio a meio de terem deixado tudo aberto ou bloqueado o lote, e ambos estão errados.
  • Mantivemos a descoberta de vizinhos de IPv6 nas cadeias internas? Tipos 133 a 137. Esta é a que transforma «endurecemos o ICMP» num segmento que morre em silêncio uma semana depois, e é o erro que uma alteração à pressa comete.
  • Mostra-me a regra. Não uma declaração de política, a linha de facto na caixa de facto, e a data em que foi posta. Um controlo para o qual ninguém consegue apontar é um controlo que não está lá.

Terá a caixa chegado do fornecedor com isto já fechado? Não terá. A predefinição em quase todo o lado é deixar passar o echo e registá-lo como uma contagem de pacotes, que é a razão toda por que o túnel funciona. Não está a explorar um erro, está a usar a configuração que vem de origem. Ninguém fecha uma porta que nunca lhe disseram estar aberta.

A razão para insistir na redação é que a correção preguiçosa a este artigo é «certo, vamos bloquear o ICMP», e essa correção é pior do que o buraco. Parte a descoberta do MTU do caminho e o traceroute, vai pôr-te a perseguir transferências penduradas sem nada nos registos, e em IPv6 tira partes da internet da mesa por completo. Se a pessoa a quem perguntas deitar a mão a isso, trava-a. A instrução é estreita de propósito: descartar o echo, manter os erros, manter a descoberta de vizinhos. Como tal, quem corre firewalls para viver devia conseguir fazer essa alteração numa tarde e dizer-te que está feita.

E se forem um MSP a quem pagas para gerir isto: um fornecedor que não te consegue dizer de cabeça a tua própria postura de echo e erros, ou que responde «bloqueamos o ICMP» como se isso fosse a opção segura, acabou de te dizer algo sobre o resto da organização. Da próxima vez que uma falha se sentar entre duas redes e ambas disserem que estão limpas, lembra-te de qual delas não soube descrever o que a sua própria firewall faz a um ping.

O diagnóstico que nunca foi um diagnóstico

O ping teve uma boa corrida. Mike Muuss escreveu-o em 1983 para verificar se um anfitrião estava a responder, deu-lhe o nome a partir do sonar, e fez esse único trabalho tão bem que se tornou a primeira coisa a que toda a gente deita a mão e a última coisa que alguém questiona. Quarenta anos depois é memória muscular, e a memória muscular é exatamente como um risco sobrevive. Ninguém reexamina a coisa que sempre fez.

Mas olha para o que ele é de facto, despido do hábito. Uma mensagem que não carrega nenhum facto sobre a rede, que todos os anfitriões são obrigados a responder com os teus próprios bytes devolvidos, que corre sobre um protocolo que os controlos não inspecionam e os registos não leem. Tudo o que o faz parecer inofensivo, é só um diagnóstico, é só um keepalive, toda a gente o permite, é a mesma coisa que o torna a forma mais limpa de sair de uma rede filtrada que existe. A indústria bloqueia os erros ICMP, que carregam a verdade e partem a rede quando desaparecem, e deixa passar o echo, que carrega o que lá carregares. Tem o protocolo exatamente ao contrário.

A correção não é esperta. Mantém as mensagens que te dizem a verdade, e descarta a que apenas devolve os teus bytes. Custa-te um comando em que não tinhas nada que confiar para um diagnóstico de qualquer maneira, e fecha uma porta que está de pé aberta desde 1996, documentada numa revista hacker, empacotada durante duas décadas, e deixada escancarada porque fechá-la significaria que alguém não podia fazer ping. Sabe o que uma coisa custa, não o que está cotada. O ping está cotado a nada. Custa-te o único canal que não consegues ver.


  1. Loki, Phrack 49 — um canal de comandos carregado dentro de cargas de echo ICMP, 1996. ↩︎

  2. Ptunnel — carrega uma sessão TCP dentro de echo ICMP. ↩︎

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

  4. RFC 4443 — ICMPv6: os dados de echo «MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message». ↩︎

  5. RFC 4890 — as mensagens ICMPv6 que uma firewall não deve descartar. ↩︎

  6. RFC 1812 — requisitos de router: o Time Exceeded é um MUST, nomeado por causa do traceroute. ↩︎

  7. Hans — túnel de IP sobre echo ICMP, por Friedrich Schöller. ↩︎

  8. icmptunnel — faz túnel de tráfego IP através de pacotes de echo e resposta ICMP, por 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” — o equivalente em IPv6, por Virgile Jarry. ↩︎

  11. RFC 8200 §5 — o IPv6 exige que cada ligação tenha um MTU de pelo menos 1280 octetos. ↩︎

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