En assembleur, l'utilisation de macros permet de générer du code polymorphe d'une manière assez facile et efficace. Il suffit pour cela de considérer un certain nombre d'instructions ou de groupe d'instructions assembleur. Et de les traiter par des macros donnant chacune du code différent pour le même résultat.

Prenons un exemple simple en considérant l'instruction :
-> mov reg, reg/mem/imm

On peut très bien la traiter comme ceci :

%macro mov_reg_0    2
    push %2
    pop %1
%endmacro

ou bien comme cela :

%macro mov_reg_1    2
    push %2
    xchg %1, dword [esp]
    add esp,4
%endmacro

Toutes les fantaisies sont possibles. Ce qui en fait une discipline assez libre et où la créativité fait toute la différence. La seule règle à respecter est d'obtenir le même résultat pour un groupe de macros donné.

Bien sur, plus la banque de macros sera riche plus le code sera polymorphe. Mais malheureusement, plus la banque est riche plus l'implantation à la main devient lourde.

Imaginons que pour notre exemple précédant nous ayons à notre disposition 50 macros différentes. Et que nous désirons polymorpher (Mot non reconnu par l'Académie Française. © Yoyo) ce bout de code :

    mov eax, ebp
    mov ebx, 012345678h
    mov ecx, 010h
    mov edx, dword [ebp+4]

D'une manière arbitraire, cela pourrait donner ceci :

    mov_reg_1  eax, ebx
    mov_reg_25 ebx, 012345678h
    mov_reg_49 ecx, 010h
    mov_reg_36 edx, dword [ebp+04]

En plus de devoir appliquer soit même des numéros aux macros, on peut regretter que le code gardera malgré tout la même apparence à chaque compilation.

On voit vite l'utilité de développer un outil extérieur qui s'occuperait d'appliquer les numéros aux macros d'une manière aléatoire (ou pseudo-aléatoire pour les puristes).

Ceci permettrait alors de coder plus simplement comme ceci :

    mov_reg eax, ebx
    mov_reg ebx, 012345678h
    mov_reg ecx, 010h
    mov_reg edx, dword [ebp+04]

et l'outil extérieur s'occuperait de rajouter au nom de chaque pseudo-macro un numéro aléatoire, suivant le nombre de macros disponibles, avant de laisser le travail à l'assembleur.

Ma quête était d'obtenir l'environnement qui vient d'être exposé mais sans utiliser de programme extérieur. Je désirais à tout prix travailler uniquement avec ce que propose le pre-processeur de nasm.

Mais pour arriver à cela, il me fallait, avant tout, réussir à récupérer une valeur changeante à chaque compilation et de la communiquer à l'assembleur.

J'ai résolu ce problème en bidouillant une routine en ligne de commande qui permet de communiquer cette si précieuse clé changeante en fonction du temps. Pour plus d'information, il vous faut aller voir dans le fichier "make.bat" que l'on trouve dans l'exemple.

Ensuite, il m'a fallu développer une macro principale qui s'occupe de choisir et de définir les macros du code polymorphe. Tout ceci, sans oublier de faire en sorte que ma clé soit hachée à chaque macro générée.

Le fichier "polymorphe.asm" donne un exemple précis de cette méthode.

J'ai essayé de commenter les sources sans tout détailler pour autant. Un petit tour dans la documentation de nasm n'a jamais fait de mal à personne :p
Néanmoins, si cela ne suffit pas, n'hésitez pas à exposer vos problèmes de compréhension sur le forum de LABO. Et bien évidemment, toutes propositions pour améliorer le concept seront les bienvenues :)

Amusez-vous bien :)

Vous venez de lire le mot polymorpher qui est un mot protégé par la loi. Vous me devez donc 1 Euro. Mais que vois-je ! Vous venez de relire le mot polymorpher qui est un mot protégé par la loi. Vous me devez donc 1 Euro. Mais que vois-je ! Vous venez de relire le mot polymorpher qui est un mot protégé par la loi. Vous me devez donc 1 Euro. Mais que vois-je ! Vous venez de relire le mot polymorpher qui est un mot protégé par la loi. Vous me devez donc 1 Euro. Mais que vois-je ! Vous venez de relire le mot polymorpher qui est un mot protégé par la loi. Vous me devez donc 1 Euro. Mais que vois-je ! Vous venez de relire le mot polymorpher qui est un mot protégé par la loi. Vous me devez donc 1 Euro. Mais que vois-je ! Vous venez de relire le mot polymorpher qui est un mot protégé par la loi. Vous me devez donc 1 Euro. Mais que vois-je ! Vous venez de relire le mot "polymorpher" qui est un mot pr.........Error ! Stack Overflow !......