Discussion :

[LastSpear]

Bonjour à tous,

Je développe actuellement un moteur graphique sous OpenGL et j'ai eu il n'y a pas longtemps du matériel neuf de haut de gamme. Seulement, quand j'exécute mon moteur, je découvre que je ne parviens pas à utiliser mes cartes graphiques à 100 %. Mais un cœur de mon CPU est au max, celui qui contrôle le rendu. Le souci est qu'il est impossible de faire du multi-threading avec OpenGL. Donc, entre des appels de fonctions OpenGL (en C, donc) il y a des boucles, conditions, incrémentations et compagnie ...

Mon idée pour aller plus vite, est de générer des fonctions directement en langage machine pour le rendu graphique sur les autres cœurs. Donc les boucles, conditions (etc…) seraient donc exécutées une seule fois sur un autre thread, en ne mettant bout à bout que les appels OpenGL nécessaires dans un emplacement mémoire. Puis, cet emplacement mémoire serait exécute comme si c'était une fonction par le thread chargé de faire les appels OpenGL. Fini, donc, les pertes de temps entre chaque appel OpenGL.

Jusque là, j'ai juste programmé en assembleur juste pour utiliser les instruction SSE (1 à 4.2) pour accélérer les opérations sur les floats et dans le langage « humain » (ex : mov eax, [ebx]).

Est-il possible d'exécuter un emplacement mémoire comme si c'était une fonction ?

Comment fait-on ?
Comment appelle-t-on une fonction C avec l'assembleur ?
Connaissez vous une bonne documentation assembleur pour avoir les valeurs hexadécimales correspondantes aux instructions ?

Merci de votre lecture ainsi que de vos réponses.

[supersnail]

Bonjour,

Pour ta question "Est-il possible d'exécuter un emplacement mémoire comme si c'était une fonction ?":

Bien sûr, c'est d'ailleurs en mémoire qu'un exécutable est exécuté. Lorsque tu lances un exécutable, celui-ci est mappé en mémoire, et le processeur va "sauter" sur l'entry point en mémoire de ton programme.
Donc, pour exécuter un bout de code en mémoire, il suffit juste de faire un jmp (ou un call) sur la zone mémoire que tu veux exécuter

Ensuite pour "Comment appelle-t-on une fonction C avec l'assembleur ?":

Ça dépend de plein de choses: l'OS sur lequel tu développes, le linker que tu utilises, si tu fais de l'"assembleur pur", ou si tu l'interfaces avec un programme en C... Mais globalement c'est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
extern tafonction;
;du code...
call tafonction

Et enfin pour ta dernière question, jette un oeil ici: http://ref.x86asm.net/coder32.html

[LastSpear]

Merci bien pour ces détails !

J'ai essayer d'experimenté mais çà ne fonctionne pas :
Petite fonction en C:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
int maFonction ()
{
return 1 ;
}

Donc, en assembleur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
0xB8 0x01 0x00 0x00 0x00 (mov eax, 1)
0xC3 (retn)

et ai ensuite ajouté-intégré ce code hexadécimal dans un petit fichier C comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
const char MonCodeMachine[] = {0xB8, 0x01, 0x00, 0x00, 0x00, 0xC3};
 
typedef int (*function)();
 
int main (int, char **)
{
int Return ;
function maFonction = reinterpret_cast <function> (reinterpret_cast <unsigned int> (MonCodeMachine));
 
Return = (*maFonction)();
 
printf ("it return %i", Return);
 
return 0 ;
}

Mais ça ne fonctionne pas. Avec le call du (*maFonction)(), il arrive bien sur ma première instruction « mov eax, 1 » mais dès que j'exécute cette instruction, Visual C++ me sort comme erreur :

Exception non gérée à 0x011c20ec dans Test.exe : 0xC0000005:access violation.

Pourquoi une telle erreur ? Faudrait-il allouer une mémoire spéciale pour y mettre du code ?

[supersnail]

As-tu essayé de désassembler/débugguer ton programme pour savoir ce qu'il se passait dedans?

A mon avis, Visual C++ a dû rajouter des codes internes qui ont tout fait bugguer... (Personnellement j'ai compilé ton programme sous Linux avec g++ et ça fonctionne correctement). Faudrait faire le call en inline asm directement je pense .

Autre hypothèse: il se peut que le segment sur lequel est ton shellcode ne soit pas exécutable (et seule une analyse du PE pourra nous éclairer).

Edit: je viens juste de compiler le code sous VC++ 2010, et tout fonctionne normalement aussi... Tu as quelle version de Visual C++?

[LastSpear]

C'est frustrant, j'ai Visual C++ 2010 expresse, et j'ai verifié, il fais juste un mov pour aller chercher le pointeur de la fonction dans le registre eax et fais un call. (je regarde avec Déboguer -> Fenêtres -> Code machine) As tu configuré quelque chose en particulier ?

"et seule une analyse du PE pourra nous éclairer" : eu .... pas tout compris.

Et pour la memoir, si elle ne veux pas faire d'exécution, je suppose qu'on doit pouvoir faire des allocation qui autorise les executions ?

[supersnail]

Bonjour,

Pourrais-tu coller le désassemblage que donne ton débuggeur ici? (avec si possible le désassemblage de ton pointeur)

Sinon le format PE, c'est le format utilisé par Windows pour utiliser les exécutables, et ce format contient entres autre les différentes sections du programme, la table d'imports, l'adresse du point d'entrée...

Sinon, quelle version de Windows as-tu?

[LastSpear]

Je travaille sous windows seven 32bits.

désassemblage par visual C++ 2010:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
 
#include <stdio.h>
#include <cstdlib>
#include <memory.h>
#include <Windows.h>
 
const unsigned char Fn [] = {0xB8, 0x01, 0x00, 0x00, 0x00, 0xC3}; //ptr: 0x011020dc
 
typedef int (*function)();
 
int main (int argc, char ** argv)
{
	unsigned int Return = 0 ;
	function NewFunction = reinterpret_cast <function> (reinterpret_cast <unsigned int> (Fn));
 
	Return = (*NewFunction)();
01101000  mov         eax,offset Fn (11020DCh)  
01101005  call        eax  
 
	return 0 ;
01101007  xor         eax,eax  
}
01101009  ret
 
 
 
//-------------------- ASSEMBLEUR AFFICHER JUSTE APRES LE 'CALL EAX' (exactement ce qui est prévu):
011020DC  mov         eax,1  
011020E1  ret

Et donc le message "Exception non gérée à 0x011c20ec dans Test.exe : 0xC0000005:access violation." arrive lorsqu'il execute cette ligne 011020DC

Donc le PE, c'est le fichier .exe ?

[supersnail]

Bonjour,

Visiblement ce n'est pas un problème avec le système d'exploitation... (je viens de tester avec Windows 7 32 bits), et je n'ai pas rencontré de soucis particulier lors de l'exécution de mon programme...
Il me faudrait directement ton exécutable qui ne fonctionne pas afin que je l'autopsie, mais rien ne nous dit que cet exécutable n'est pas un virus (et donc je pense pas que tu puisses le poster ici)

Sinon le format PE est le format commun aux .exe, .dll, .scr etc...