Trouver l'addresse de retour d'une fonction API

Bonjour à tous,

J'aimerai trouver l'addresse de retour (mémoire) d'une fonction API, c'est pourquoi je vous demande votre aide...

Voilà comment je compte procéder:

1) Lancer l'application à l'aide de la fonction createProcess   //Jusque-là, ca va...
2) Trouver les frontières (boundaries) de l'import Table en mémoire
3) Trouver les frontières (boundaries) du Stub programm

4) Trouver le Byte FF dans le code et être sûr que l'on a bien affaire à l'instruction call (assembler)
5) Une fois la function call trouvée, contrôler quelle se trouve bien dans la plage mémoire de l'Import Table définie avant
6) Si oui, alors l'addresse suivante sera l'addresse de retour...

7) Trouver le Byte E8 dans le code (également l'instruction call)
8) Rechercher dans le registre (suivant E8) l'addresse qui nous permettera de vérifier si elle fait partie de la plage Stub
9) Si oui, alors l'addresse suivante sera l'addresse de retour...

Je voudrais réaliser cela en C++.

Je viens de débuter ce "challenge" et toute aide sera la bienvenue à partir du point 2 ;-)
Naturellement, si quelqu'un connait un autre moyen de procéder, je suis preneur.

Voilà, j'espère avoir été clair et vous remercie ne serait-ce pour avoir lu ce message jusqu'au bout.

Merci et bonne Prog.


 ElpenS

salut je n'ai pas bien compris ce que tu appelles adresse de retour
un call X c'est mettre le contenu d'eip dans la pile, incrémenter esp, et en même temps faire un jump X

Désolé,

Ce que j'appelle addresse de retour est en fait l'addresse de l'instruction suivant le call

c-a-d.

0x00001234   call OpenFile   <-- call de fonction API
0x00001238   push eax  <-- @ de retour

Voilà ce que j'appelle @ de retour (Naturellement, l'addresse mémoire)

 j'espère avoir été un peu plus precis...
    
Merci

 ElpenS

ben non c'est pas très clair

tu veux connaître l'adresse du bout de code machine qui fait le call et ce qui suit ?

est-ce que ce code te convient ????

#include <stdio.h>

int i,j;

asm("func:");
asm("movl (%esp), %eax");
asm("ret");

asm("l1:");
asm("movl %eax, _i");
asm("call func2");
asm("ret");
asm("l2:");

asm("func2:");
asm("movl _i, %eax");
asm("addl _j, %eax");
asm("movl %eax, (%esp)");
asm("ret");

int main() {

    // on calcule la taille des 3 instructions situees entre l1 et l2
    asm("movl $l2, %eax");
    asm("subl $l1, %eax");
    // on enregistre dans la variable j
    asm("movl %eax, _j");
    // on appelle func qui va récupérer l'adresse du movl %eax, _i juste après
    asm("call func");
    asm("movl %eax, _i");
    // on appelle func2, qui va plcer notre adresse de retour calculée à la place de son adresse de retour
    asm("call func2");
    // ainsi le ret n'est pas effectué !
    asm("ret");
    printf("l'adresse de retour de func2 etait bien %d", i+j);
    return 0;
}

Oui et non....

Le principe que tu utilises dans cet exemple est correcte. Seulement, mes fonctions call ne se trouvent pas dans mon code, mais dans celui du .exe

J'essaie de réexpliquer la chose:

- Dans un premier temps, je vais "executer" un .exe avec CreateProcess(myExe.exe,...)
- Dans mon myExe.exe, il y aura des appels de fonctions API   (call    ntdll.RtlRaiseException;)

Je voudrai donc détecter tout les call de fonction API, et retrouver l'addresse à laquelle ils reviennent une fois la fonction effectué

0x7C90EC5F     call    ntdll.RtlRaiseException;
0x7C90EC64      int3;
...

0x7C95300D call    ntdll.ZwQueryInformationThread; 
0x7C953012 mov     ( EAX, EBX );
...

Et ainsi de suite

Voilà, j'espère avoir éclairci un peu plus la chose

 ElpenS

une idée: ça pourrait être plus simple de carrément le désassembler ton exe sinon (puis de parser le listing asm ) ?

Ouais, ca pourrait être une idee, mais j'ai aucune idee comment desassembler un exe en c++....

 ElpenS

j'ai regardé desassembleur sur wikipedia et je suis tombé sur un lien:

[ Lien ]

qui m'a l'air pas mal

Ok, merci je vais jeter un oeil la-dessus!

Sinon, j'ai testé récupérer les différents call mais ma méthode ne fonctionne pas...

//Lance le process a tester
CreateProcess(TEXT("c:\\Microsoft Office\\OFFICE11\\MSACCESS.EXE"), 0, 0, 0, TRUE, CREATE_SUSPENDED, 0, 0, &startup, &procinfo);

// Execute le programme
ResumeThread(procinfo.hThread);

// position de dépard ('MZ')
DWORD myOffset = pimage_nt_headers->OptionalHeader.ImageBase;

// Ecrit dans memread la valeur
ReadProcessMemory(procinfo.hProcess, (LPVOID) myOffset, memread, 1, NULL);

// tant que la zone != 0xE8: call
while ((memread[0] != 0xE8) )
{
   // Est-ce dans les boundaries
    if (myOffset <= pimage_nt_headers->OptionalHeader.ImageBase + pimage_nt_headers->OptionalHeader.SizeOfImage)
   {
      ReadProcessMemory(procinfo.hProcess, (LPVOID) myOffset, memread, 1, NULL);
      myOffset++;
   }
}


Je sais qu'il a des choses (stupides) à améliorer, mais je voulais juste tester si je pouvais sortir les instructions call qui ont la valeur E8, mais c'est un echec.

Merci encore


 ElpenS

Tu le récupères où et comment le pimage_nt_headers?