MessageBoxA dans Windows AT & T Assembly

Question

J'essaie d'appeler MessageBoxA() directement dans l'assembly, en utilisant gcc inline. Cependant, je dois le faire de deux façons: d'abord en utilisant l'adressage dynamique, avec LoadLibrary() et GetProcAddress() - J'ai trouvé un tutoriel à ce sujet, en essayant de le suivre. Mais je suis également intéressé à appeler directement l'adresse de MessageBoxA, qui est 0x7e4507ea dans mon Windows SP3 anglais.

Je suis en train d'exécuter ce code:

/* 
* eax holds return value 
* ebx will hold function addresses 
* ecx will hold string pointers 
* edx will hold NULL 
* 
*/ 


int main(int argc, char **argv) 
{ 
asm(" xor %eax, %eax   \t\n\ 
     xor %ebx, %ebx   \t\n\ 
     xor %ecx, %ecx   \t\n\ 
     xor %edx, %edx   \t\n\ 
     push $0x0    \t\n\ 
     push $0x44444444  \t\n\ 
     push $0x44444444  \t\n\ 
     pop %ecx    \t\n\ 
     mov %dl,0x3(%ecx)  \t\n\ 
     mov $0x7e4507ea, %ebx \t\n\ 
     push %edx    \t\n\ 
     push %ecx    \t\n\ 
     push %ecx    \t\n\ 
     push %edx    \t\n\ 
     mov $0x8, %ax   \t\n\ 
     call *%ebx    \t\n\ 
     "); 
} 

Je ne sais pas si dans Windows est encore possible de le faire, appelez directement l'adresse, sans préciser la bibliothèque (dans ce user32.dll Cas). Je sais sous Linux, il est simple d'appeler write() syscall, mais dans Windows, je ne suis pas encore familier ..

Je m'attends à voir une boîte de message avec "DDDDDDDD". Quelqu'un pourrait-il m'aider s'il vous plaît? Appréciez toute aide, avec des liens tutoriels aussi!

Merci beaucoup

Answer 1

écrire en C d'abord, compiler et consulter la liste de l'ensemble pour voir ce que le compilateur généré. C'est la façon la plus facile d'apprendre. Si vous voyez une instruction que vous ne comprenez pas, recherchez-la dans les fichiers PDF de référence du jeu d'instructions Intel.

Answer 2

appeler directement l'adresse

On dirait un gros no-no. Les appels d'API n'ont pas d'adresse fixe. Cela dépend de l'endroit où la mémoire a été chargée. Bien que je suis sûr que User32.dll est chargé au démarrage de l'OS, je ne compterais pas qu'il occupait jamais le même espace.

Pour appeler une routine API, vous devez l'importer afin que le système d'exploitation puisse vous fournir une adresse correcte pour l'appel.

Answer 3

L'appel "Directement" MessageBoxA n'est pas vraiment possible. Oui, vous pouvez ajouter un appel à 0x7e4507ea, mais cela n'a pas vraiment d'importance. Vous devez ajouter une entrée à votre table d'adresses d'importation, qui indique que vous appelez MessageBoxA à partir de user32.dll et d'où. Lorsque Windows chargera votre exécutable, il verra que vous appelez MessageBoxA, chargera user32.dll pour vous, et corrigera l'adresse réelle où MessageBoxA s'est terminée.

Answer 4

Je l'ai fait ainsi:

int main() 
{ 
    asm("xorl %eax, %eax  \n" 
     "xorl %ebx, %ebx  \n" 
     "xorl %ecx, %ecx  \n" 
     "xorl %edx, %edx  \n" 
     "pushl %ecx    \n" 
     "pushl $0x20206c6c  \n" 
     "pushl $0x642e3233  \n" 
     "pushl $0x72657375  \n" 
     "movl %esp, %ecx  \n" 
     "movl $0x7c801d7b, %ebx \n" 
     "pushl %ecx    \n" 
     "call *%ebx    \n" 
     "movl $0xef30675e, %ecx \n" 
     "addl $0x11111111, %ecx \n" 
     "pushl %ecx    \n" 
     "pushl $0x42656761  \n" 
     "pushl $0x7373654d  \n" 
     "movl %esp, %ecx  \n" 
     "pushl %ecx    \n" 
     "pushl %eax    \n" 
     "movl $0x7c80ae40, %ebx \n" 
     "call *%ebx    \n" 
     "movl %esp, %ecx  \n" 
     "xorl %edx, %edx  \n" 
     "pushl %edx    \n" 
     "pushl %ecx    \n" 
     "pushl %ecx    \n" 
     "pushl %edx    \n" 
     "call *%eax    \n" 
     "xorl %eax, %eax  \n" 
     "pushl %eax    \n" 
     "movl $0x7c81cb12, %eax \n" 
     "call *%eax    \n" 
    ); 
} 

Même dur est parfaitement possible de coder les adresses des fonctions, je préfère charger dynamiquement (bien que je hardcoding adresse kernel32), de sorte que cela fonctionne sur n'importe quel Windows XP (SP1, 2, 3)