DInvoke

Windows पर PInvoke के लिए डायनेमिक रिप्लेसमेंट। DInvoke में शक्तिशाली प्रिमिटिव्स होते हैं जिन्हें बुद्धिमानी से संयोजित करके डिस्क या मेमोरी से अनमैनेज्ड कोड को सटीक रूप से डायनेमिक रूप से इनवोक किया जा सकता है। इसका उपयोग कई उद्देश्यों के लिए किया जा सकता है, जैसे PE पार्सिंग, बुद्धिमान डायनेमिक API रिज़ॉल्यूशन, रनटाइम पर PE प्लगइन्स को डायनेमिक रूप से लोड करना, प्रोसेस इंजेक्शन और API हुक्स से बचना।

विशेषताएँ:

• बिना PInvoke के अनमैनेज्ड APIs को डायनेमिक रूप से इनवोक करें
• रणनीतिक API हुक से बचाव में सक्षम प्रिमिटिव्स
• मैनेज्ड कोड से अनमैनेज्ड PE मॉड्यूल को मैन्युअल रूप से मैप करें
• PE मॉड्यूल को डिस्क पर मौजूद मनमाने मॉड्यूल द्वारा समर्थित सेक्शन में मैप करें
• मॉड्यूलर प्रोसेस इंजेक्शन API
• डेटा संरचनाओं, डेलीगेट्स और फंक्शन रैपरों की बढ़ती हुई लाइब्रेरी (कृपया साझा करें :-)
• .NET v3.5+ समर्थन

सम्मेलन वार्ता (Staying # & Bringing Covert Injection Tradecraft to .NET): https://www.youtube.com/watch?v=FuxpMXTgV9s

ब्लॉग पोस्ट:

1. गुप्त ऑपरेशनों का अनुकरण - डायनेमिक इनवोकेशन (PInvoke और API हुक्स से बचना): https://thewover.github.io/Dynamic-Invoke/
2. जल्द आ रहा है।

यह प्रोजेक्ट मूल रूप से SharpSploit (https://github.com/cobbr/SharpSploit) के लिए बनाया गया था। लेखक(ों) की अनुमति से, इसे अब एक स्टैंडअलोन लाइब्रेरी और NuGet के रूप में यहाँ होस्ट किया गया है।

NuGet: https://www.nuget.org/packages/DInvoke/

उदाहरण 1 - एक्सपोर्टेड अनमैनेज्ड APIs को रिज़ॉल्व करना

नीचे दिया गया उदाहरण दर्शाता है कि DInvoke का उपयोग करके किसी DLL के एक्सपोर्ट्स को डायनेमिक रूप से कैसे खोजा और कॉल किया जा सकता है।

1. ntdll.dll का बेस एड्रेस प्राप्त करें। यह हर Windows प्रोसेस में प्रारंभ होने पर लोड होता है, इसलिए हम जानते हैं कि यह पहले से लोड होगा। इस प्रकार, हम सुरक्षित रूप से PEB की लोडेड मॉड्यूल की सूची में खोज कर इसका संदर्भ पा सकते हैं। जब हमें PEB से इसका बेस एड्रेस मिल जाता है, तब हम एड्रेस प्रिंट करते हैं।
2. नाम के आधार पर ntdll.dll के भीतर एक एक्सपोर्ट खोजने के लिए GetLibraryAddress का उपयोग करें।
3. ऑर्डिनल के आधार पर ntdll.dll के भीतर एक एक्सपोर्ट खोजने के लिए GetLibraryAddress का उपयोग करें।
4. कीड हैश के आधार पर ntdll.dll के भीतर एक एक्सपोर्ट खोजने के लिए GetLibraryAddress का उपयोग करें।
5. पहले मिले ntdll.dll के बेस एड्रेस का उपयोग करते हुए, मेमोरी में मॉड्यूल के भीतर नाम के आधार पर एक एक्सपोर्ट खोजने के लिए GetExportAddress का उपयोग करें।

///Author: b33f (@FuzzySec, Ruben Boonen)
using System;

using DynamicInvoke = DInvoke.DynamicInvoke;

namespace SpTestcase
{
    class Program
    {

        static void Main(string[] args)
        {
            // Details
            String testDetail = @"
            #=================>
            # Hello there!
            # I find things dynamically; base
            # addresses and function pointers.
            #=================>
            ";
            Console.WriteLine(testDetail);

            // Get NTDLL base from the PEB
            Console.WriteLine("[?] Resolve Ntdll base from the PEB..");
            IntPtr hNtdll = DynamicInvoke.Generic.GetPebLdrModuleEntry("ntdll.dll");
            Console.WriteLine("[>] Ntdll base address : " + string.Format("{0:X}", hNtdll.ToInt64()) + "\n");

            // Search function by name
            Console.WriteLine("[?] Specifying the name of a DLL (\"ntdll.dll\"), resolve a function by walking the export table in-memory..");
            Console.WriteLine("[+] Search by name --> NtCommitComplete");
            IntPtr pNtCommitComplete = DynamicInvoke.Generic.GetLibraryAddress("ntdll.dll", "NtCommitComplete", true);
            Console.WriteLine("[>] pNtCommitComplete : " + string.Format("{0:X}", pNtCommitComplete.ToInt64()) + "\n");

            Console.WriteLine("[+] Search by ordinal --> 0x260 (NtSetSystemTime)");
            IntPtr pNtSetSystemTime = DynamicInvoke.Generic.GetLibraryAddress("ntdll.dll", 0x260, true);
            Console.WriteLine("[>] pNtSetSystemTime : " + string.Format("{0:X}", pNtSetSystemTime.ToInt64()) + "\n");

            Console.WriteLine("[+] Search by keyed hash --> 138F2374EC295F225BD918F7D8058316 (RtlAdjustPrivilege)");
            Console.WriteLine("[>] Hash : HMACMD5(Key).ComputeHash(FunctionName)");
            String fHash = DynamicInvoke.Generic.GetAPIHash("RtlAdjustPrivilege", 0xaabb1122);
            IntPtr pRtlAdjustPrivilege = DynamicInvoke.Generic.GetLibraryAddress("ntdll.dll", fHash, 0xaabb1122);
            Console.WriteLine("[>] pRtlAdjustPrivilege : " + string.Format("{0:X}", pRtlAdjustPrivilege.ToInt64()) + "\n");

            // Search for function from base address of DLL
            Console.WriteLine("[?] Specifying the base address of DLL in memory ({0:X}), resolve function by walking its export table...", hNtdll.ToInt64());
            Console.WriteLine("[+] Search by name --> NtCommitComplete");
            IntPtr pNtCommitComplete2 = DynamicInvoke.Generic.GetExportAddress(hNtdll, "NtCommitComplete");
            Console.WriteLine("[>] pNtCommitComplete : " + string.Format("{0:X}", pNtCommitComplete2.ToInt64()) + "\n");

            // Pause execution
            Console.WriteLine("[*] Pausing execution..");
            Console.ReadLine();
        }
    }
}

उदाहरण 2 - अनमैनेज्ड कोड इनवोक करना

नीचे दिए गए उदाहरण में, हम पहले PInvoke का उपयोग करके सामान्य रूप से OpenProcess को कॉल करते हैं। फिर, हम इसे DInvoke का उपयोग करके कई तरीकों से कॉल करेंगे, ताकि यह प्रदर्शित किया जा सके कि प्रत्येक तंत्र अनमैनेज्ड कोड को सफलतापूर्वक निष्पादित करता है और API हुक्स से बचता है।

///Author: TheWover
using System;
using System.Runtime.InteropServices;

using Data = DInvoke.Data;
using DynamicInvoke = DInvoke.DynamicInvoke;
using ManualMap = DInvoke.ManualMap;

namespace SpTestcase
{
    class Program
    {

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern IntPtr OpenProcess(
            Data.Win32.Kernel32.ProcessAccessFlags processAccess,
            bool bInheritHandle,
            uint processId
        );

        static void Main(string[] args)
        {
            // Details
            String testDetail = @"
            #=================>
            # Hello there!
            # I demonstrate API Hooking bypasses
            # by calling OpenProcess via
            # PInvoke then DInvoke.
            # All handles are requested with
            # PROCESS_ALL_ACCESS permissions.
            #=================>
            ";
            Console.WriteLine(testDetail);

            //PID of current process.
            uint id = Convert.ToUInt32(System.Diagnostics.Process.GetCurrentProcess().Id);

            //Process handle
            IntPtr hProc;

            // Create the array for the parameters for OpenProcess
            object[] paramaters =
            {
                Data.Win32.Kernel32.ProcessAccessFlags.PROCESS_ALL_ACCESS,
                false,
                id
            };

            // Pause execution
            Console.WriteLine("[*] Pausing execution..");
            Console.ReadLine();

            //////////////////////////////////////////////////////////////////////////////////////////////////////////
            // Call OpenProcess using PInvoke
            Console.WriteLine("[?] Call OpenProcess via PInvoke ...");
            hProc = OpenProcess(Data.Win32.Kernel32.ProcessAccessFlags.PROCESS_ALL_ACCESS, false, id);
            Console.WriteLine("[>] Process handle : " + string.Format("{0:X}", hProc.ToInt64()) + "\n");

            // Pause execution
            Console.WriteLine("[*] Pausing execution..");
            Console.ReadLine();