DInvoke

Dynamischer Ersatz für PInvoke unter Windows. DInvoke enthält leistungsstarke Primitive, die intelligent kombiniert werden können, um nicht verwalteten Code von der Festplatte oder aus dem Speicher mit großer Präzision dynamisch aufzurufen. Dies kann für viele Zwecke genutzt werden, z. B. PE-Parsing, intelligente dynamische API-Auflösung, dynamisches Laden von PE-Plugins zur Laufzeit, Prozessinjektion und das Umgehen von API-Hooks.

Features:

• Nicht verwaltete APIs dynamisch ohne PInvoke aufrufen
• Primitive für strategische API-Hook-Umgehung
• Manuelles Mapping nicht verwalteter PE-Module aus verwaltetem Code
• PE-Module in Speicherbereiche mappen, die durch beliebige Module auf der Disk gestützt werden
• Modulare Prozessinjektions-API
• Wachsende Bibliothek von Datenstrukturen, Delegaten und Funktions-Wrappern (bitte teilen :-)
• .NET v3.5+ Unterstützung

Konferenzvortrag (Staying # & Bringing Covert Injection Tradecraft to .NET): https://www.youtube.com/watch?v=FuxpMXTgV9s

Blogbeiträge:

1. Emulieren verdeckter Operationen – Dynamischer Aufruf (PInvoke & API-Hooks vermeiden): https://thewover.github.io/Dynamic-Invoke/
2. Bald verfügbar.

Dieses Projekt wurde ursprünglich für SharpSploit (https://github.com/cobbr/SharpSploit) erstellt. Mit Genehmigung der Autoren wird es nun hier als eigenständige Bibliothek und NuGet-Paket gehostet.

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

Example 1 - Auflösen exportierter nicht verwalteter APIs

Das folgende Beispiel zeigt, wie Sie mit DInvoke Exporte einer DLL dynamisch finden und aufrufen können.

1. Ermitteln Sie die Basisadresse von ntdll.dll. Sie wird in jeden Windows-Prozess geladen, wenn dieser initialisiert wird, daher wissen wir, dass sie bereits geladen ist. Daher können wir sicher in der Liste der geladenen Module des PEB suchen, um einen Verweis darauf zu finden. Sobald wir die Basisadresse über den PEB gefunden haben, geben wir die Adresse aus.
2. Verwenden Sie GetLibraryAddress, um einen Export in ntdll.dll anhand des Namens zu finden.
3. Verwenden Sie GetLibraryAddress, um einen Export in ntdll.dll anhand der Ordinalzahl zu finden.
4. Verwenden Sie GetLibraryAddress, um einen Export in ntdll.dll anhand eines Schlüssel-Hashs zu finden.
5. Verwenden Sie ausgehend von der zuvor gefundenen Basisadresse von ntdll.dll GetExportAddress, um einen Export im Speicher anhand des Namens zu finden.

///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();
        }
    }
}

Example 2 - Aufrufen von nicht verwaltetem Code

Im folgenden Beispiel rufen wir zuerst OpenProcess normal über PInvoke auf. Danach rufen wir es auf verschiedene Weisen über DInvoke auf, um zu demonstrieren, dass jeder Mechanismus den nicht verwalteten Code erfolgreich ausführt und API-Hooks umgeht.

///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();