DInvoke

Substituição dinâmica para PInvoke no Windows. O DInvoke contém primitivas poderosas que podem ser combinadas de forma inteligente para invocar dinamicamente código não gerenciado a partir do disco ou da memória com precisão cuidadosa. Isso pode ser usado para muitos propósitos, como análise de PE, resolução dinâmica inteligente de APIs, carregamento dinâmico de plugins PE em tempo de execução, injeção de processos e evitar ganchos de API.

Recursos:

• Invocar dinamicamente APIs não gerenciadas sem PInvoke
• Primitivas que permitem evasão estratégica de ganchos de API
• Mapear manualmente módulos PE não gerenciados a partir de código gerenciado
• Mapear módulos PE em seções respaldadas por módulos arbitrários no disco
• API modular de injeção de processos
• Biblioteca crescente de estruturas de dados, delegates e wrappers de funções (compartilhe :-)
• Suporte a .NET v3.5+

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

Postagens do blog:

1. Emulando Operações Secretas - Invocação Dinâmica (Evitando PInvoke e Ganchos de API): https://thewover.github.io/Dynamic-Invoke/
2. Em breve.

Este projeto foi originalmente criado para o SharpSploit (https://github.com/cobbr/SharpSploit). Com a permissão do(s) autor(es), agora está hospedado aqui como uma biblioteca independente e um pacote NuGet.

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

Exemplo 1 - Resolvendo APIs Não Gerenciadas Exportadas

O exemplo abaixo demonstra como usar o DInvoke para encontrar e chamar dinamicamente exportações de uma DLL.

1. Obtenha o endereço base da ntdll.dll. Ela é carregada em todos os processos Windows quando eles são inicializados, então sabemos que ela já estará carregada. Dessa forma, podemos pesquisar com segurança a lista de módulos carregados do PEB para encontrar uma referência a ela. Depois de encontrar seu endereço base pelo PEB, imprimimos o endereço.
2. Use GetLibraryAddress para encontrar uma exportação dentro da ntdll.dll pelo nome.
3. Use GetLibraryAddress para encontrar uma exportação dentro da ntdll.dll por ordinal.
4. Use GetLibraryAddress para encontrar uma exportação dentro da ntdll.dll por hash chaveado.
5. Dado o endereço base da ntdll.dll que encontramos anteriormente, use GetExportAddress para encontrar uma exportação dentro do módulo em memória pelo nome.

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

Exemplo 2 - Invocando Código Não Gerenciado

No exemplo abaixo, primeiro chamamos OpenProcess normalmente usando PInvoke. Em seguida, vamos chamá-la de várias maneiras usando DInvoke para demonstrar que cada mecanismo executa com sucesso o código não gerenciado e evade os ganchos de 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();