Verwendung von C++ mit Assembly zum Zuweisen und Erstellen neuer Funktionen zur Laufzeit

Question

Ich habe an einem (C++) Projekt gearbeitet, das erfordert vollständig dynamisch zugewiesene Funktionen, die malloc/new und mprotect bedeutet und dann den Puffer manuell ändern Assemblercode. Aus diesem Grund habe ich mich genau gefragt, was in diesem "Puffer" von mir erforderlich ist, denn es ist ein Replikat irgendeiner anderen _cdecl-Funktion. Zum Beispiel:

int ImAcDeclFunc(int a, int b) 
{ 
    return a + b; 
} 

Wenn ich möchte buchstäblich ein Duplikat dieser Funktion erstellen, aber völlig dynamisch, was würde erforderlich machen (und denken Sie daran, es ist C++ mit Inline Montag)? Für den Anfang, ich denke, ich würde so etwas zu tun habe (oder eine ähnliche Lösung):

// My main.... 
byte * ImAcDeclFunc = new byte[memory]; 
mprotect(Align(ImAcDeclFunc), pageSize, PROT_EXEC | PROT_READ | PROT_WRITE); 

Danach würde ich den Assembler-Code für die ImAcDeclFunc(int a, int b); herauszufinden muß. Jetzt bin ich immer noch mies bei der Montage, also wie wäre diese Funktion in AT & T Syntax? Hier ist mein kühner Versuch:

push %ebp 
movl %%ebp, %%esp 
movl 8(%ebp), %%eax 
movl 12(%ebp), %%edx 
addl edx, eax 
pop ebp 
ret 

Nun, wenn dieser Code korrekt ist (was ich sehr Zweifel, bitte korrigieren Sie mich) würde ich muss nur diesen Code Wert in Hex finden (zum Beispiel ‚JMP‘ ist 0xE9 und ' inc 'ist 0xFE), und verwenden Sie diese Werte direkt in C++? Wenn ich meinen früheren C++ Code weiter:

*ImAcDeclFunc = 'hex value for push'; // This is 'push' from the first line 
*(uint)(ImAcDeclFunc + 1) = 'address to push'; // This is %ebp from the first line 
*(ImAcDeclFunc + 5) = 'hex value for movl' // This is movl from the second line 
// and so on... 

Nachdem ich dies für den gesamten Code/Puffer getan haben, wäre das für eine völlig dynamische _cdecl Funktion genug sein (dh konnte ich warf es einfach auf einen Funktionszeiger und tun int result = ((int (*)(int, int))ImAcDeclFunc)(firstArg, secondArg)?). Und ich bin nicht daran interessiert, mit boost :: function oder etwas ähnlich, ich die Funktion muß vollständig dynamisch, daher mein Interesse sein :)

HINWEIS: Diese Frage ist eine Fortsetzung auf meinem previous one, aber mit viel mehr Details.

Answer 1

Wenn Sie nehmen diese lala.c:

int ImAcDeclFunc(int a, int b) 
{ 
    return a + b; 
} 

int main(void) 
{ 
    return 0; 
} 

Sie können es mit gcc -Wall lala.c -o lala kompilieren. Sie können dann die ausführbare Datei mit objdump -Dslx lala >> lala.txt zerlegen. Sie werden feststellen, ImAcDeclFunc zu zusammengesetzt ist:

00000000004004c4 <ImAcDeclFunc>: 
ImAcDeclFunc(): 
    4004c4: 55      push %rbp 
    4004c5: 48 89 e5    mov %rsp,%rbp 
    4004c8: 89 7d fc    mov %edi,-0x4(%rbp) 
    4004cb: 89 75 f8    mov %esi,-0x8(%rbp) 
    4004ce: 8b 45 f8    mov -0x8(%rbp),%eax 
    4004d1: 8b 55 fc    mov -0x4(%rbp),%edx 
    4004d4: 8d 04 02    lea (%rdx,%rax,1),%eax 
    4004d7: c9      leaveq 
    4004d8: c3      retq 

Eigentlich ist diese Funktion relativ einfach ist, an anderer Stelle zu kopieren. In diesem Fall haben Sie vollkommen Recht damit zu sagen, dass Sie die Bytes kopieren können und es würde einfach funktionieren.

Probleme treten auf, wenn Sie beginnen, Anweisungen zu verwenden, die relative Offsets als Teil des Opcodes verwenden. Zum Beispiel ein relativer Sprung oder ein relativer Aufruf. In diesen Fällen müssen Sie die Anweisung richtig verschieben, es sei denn, Sie können es an die Adresse kopieren, an der es ursprünglich war.

Kurz gesagt, müssen Sie, um neu zu lokalisieren, wo sie ursprünglich basierte, den Unterschied berechnen, wo Sie sie basieren, und jede relative Anweisung in Bezug auf diesen Offset verschieben. Dies ist machbar.Ihre eigentliche Schwierigkeit besteht in der Bearbeitung von Aufrufen anderer Funktionen, insbesondere von Funktionsaufrufen an Bibliotheken. In diesem Fall müssen Sie sicherstellen, dass die Bibliothek verknüpft ist, und sie dann auf die Weise aufrufen, die durch das ausführbare Format definiert ist, auf das Sie ausgerichtet sind. Dies ist sehr nicht trivial. Wenn Sie immer noch interessiert sind, kann ich Sie in die Richtung zeigen, wo Sie für das lesen sollten.

---

In Ihrem einfachen Fall oben, können Sie dies tun:

#include <stdlib.h> 
#include <stdio.h> 
#include <string.h> 
#include <malloc.h> 
#include <sys/mman.h> 
#include <unistd.h> 

int main(void) 
{ 
    char func[] = {0x55, 0x48, 0x89, 0xe5, 0x89, 0x7d, 0xfc, 
    0x89, 0x75, 0xf8, 0x8b, 0x45, 0xf8, 
    0x8b, 0x55, 0xfc, 0x8d, 0x04, 0x02, 
    0xc9, 0xc3}; 

    int (* func_copy)(int,int) = mmap(NULL, sizeof(func), 
     PROT_WRITE | PROT_READ | PROT_EXEC, 
     MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); 

    memcpy(func_copy, func, sizeof(func)); 
    printf("1 + 2 = %d\n", func_copy(1,2)); 

    munmap(func_copy, sizeof(func)); 
    return EXIT_SUCCESS; 
} 

Dies funktioniert auf x86-64 gut. Er druckt:

1 + 2 = 3 

Answer 2

Sie möchten vielleicht GNU Blitz: http://www.gnu.org/software/lightning/. Es könnte dir bei dem, was du versuchst, helfen.

Answer 3

Ich denke, dass es bessere Idee, werde einige Skriptsprache in Ihr Projekt einbinden, anstatt sich selbst modifizierende Programm zu schreiben. Es dauert weniger Zeit und Sie werden flexibler.

Wenn ich buchstäblich ein Duplikat dieser Funktion erstellen möchte, aber vollständig dynamisch, was würde das erfordern (und daran erinnern, es ist C++ mit Inline-Assembly)?

Es würde Mensch mit Disassembler erfordern. Technisch gesehen sollte die Funktion bei einer Adresse beginnen und bei der Rückkehranweisung enden. Es ist jedoch unbekannt, was genau der Compiler während der Optimierungsphase mit der Funktion gemacht hat. Ich wäre nicht überrascht, wenn sich der Funktionseintrittspunkt an einer Art seltsamer Stelle befindet (wie am Ende der Funktion, nach der return-Anweisung) oder wenn die Funktion in mehrere Teile aufgeteilt wurde, die mit anderen Funktionen geteilt wurden.