Comment exécuter du code machine en tant que fonction en C ++

Une chaîne littérale telle que "\ xB8 \ x0C \ x00 \ x00 \ x00 \ xC3" est un objet de durée de stockage statique [lex.string] / 15 . Un compilateur placera généralement de tels objets littéraux de chaîne dans la section .rdata de votre binaire, c'est-à-dire dans une mémoire non exécutable en lecture seule. Par conséquent, essayer d'exécuter les octets d'un littéral de chaîne entraînera une violation d'accès. Si vous souhaitez exécuter des octets de code machine contenus dans un objet tableau global, vous devez vous assurer que votre objet est alloué dans une section exécutable. Par exemple (ciblage de Windows avec Visual C ++):

#include <iostream>

#pragma section("runstuff", read, execute)

__declspec(allocate("runstuff"))
const unsigned char code[] = {
    0xB8, 0x0C, 0x0, 0x0, 0x0, 0xC3
};

int main()
{
    auto fun_ptr = reinterpret_cast<int(*)()>(&code[0]);
    std::cout << fun_ptr();
    return 0;
}

Notez que des éléments comme celui-ci ne sont pas par nature portables et ont au mieux un comportement défini par l'implémentation. Si vous savez au moment de la construction quel code machine vous souhaitez exécuter, envisagez d'utiliser un assembleur et de simplement lier le fichier objet résultant à votre exécutable. Si vous souhaitez générer dynamiquement du code machine sous Windows, vous devrez allouer de la mémoire exécutable. Pour ce faire, créez un tableau suffisamment grand dans la mémoire exécutable (et également inscriptible) (par exemple, de manière analogue à mon exemple ci-dessus) dans lequel vous pouvez placer votre code, ou allouez dynamiquement de la mémoire exécutable, par exemple en utilisant VirtualAlloc ou en utilisant HeapAlloc à partir d'un Heap avec l'indicateur exécutable défini . Vous voudrez également être conscient de la API FlushInstructionCache …

J'ai trouvé une méthode:

#include <iostream>
#include <windows.h>

using namespace std;

int main() {
    unsigned char bytes[] = "\xB8\x0C\x00\x00\x00\xC3";

    HANDLE mem_handle = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, 0, sizeof(bytes), NULL);
    void *mem_map = MapViewOfFile(mem_handle, FILE_MAP_ALL_ACCESS | FILE_MAP_EXECUTE, 0x0, 0x0, sizeof(bytes));

    memcpy(mem_map, bytes, sizeof(bytes));
    int result = ((int (*)(void))mem_map)();

    cout << "argument:\n" << result << '\n';

    return 0;
}

Vous pouvez le faire en utilisant un assembleur en ligne:

#include <iostream>

int code() {
    __asm (
        ".byte 0xB8, 0x0C, 0x00, 0x00, 0x00"
    );
}

int main() {
    std::cout << code() << std::endl;
    return 0;
}