Discussion :

[Ishan]

Bonjour à tous, voilà j'aurai besoin d'un peu d'aide pour comprendre à 100% le fonctionnement de ce petit code (qui est donc suivi du 'vrai' code à exécuter,lui même préalablement encodé en XOR avec la clé F5520488) :

Code :

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

1
2
3
4
5
6
7
8
9
10
adr : Hex :             Command :  Flags :
 
00    33C9              XOR        ecx,ecx
02    83E9CB            SUB        ecx,0xCB
05    D9EE              FLDZ         
07    D97424F4          FSTENV     [esp-0x0C]
0B    5B                POP        ebx
0C    817313880452F5    XOR        [ebx+0x13],0xF5520488
13    83EBFC            SUB        ebx,0xFC
16    E2F4              LOOP       [-0x0C]

Ce que j'ai compris :

1ere ligne : on initialise le compteur à 0, ecx := 0

2eme : on affecte au compteur la valeur correspondante au nombre d'itérations que l'on veut effectuer avec loop, ecx := 53(dec)
On peut donc en déduire que la taille du code encodé est de (53+1)*4 octets, soit 216 octets

3ème : ??
4 ème : ??

5éme : on affecte ?? à ebx, ebx := ??

6ème : le début du corps de la boucle, on va effectuer un XOR entre le contenu de [ebx+0x13] (à quoi correspond le 0x13??) et F5520488

7ème : on décale (incrémente?) ebx de 4 octets (pour pouvoir appliquer notre XOR à la suite du code
8ème : si ecx != 0, on décrémente ecx de 1 et on saute à l'adresse 0C, sinon on sort de la boucle en sautant à l'instruction suivant directement LOOP.
( mais à quoi correspond le '-' dans [-0x0C]? )

Question : remplacer les ??? dans mon post xD ( et accessoirement corriger toute affirmation erronée que j'aurai pu faire ^^' )

Merci d'avance pour toute aide !
car je comprends le but de ce code mais pas son fonctionnement exact

[Neitsa]

Bonjour,

1ere ligne : Ok .

2ème ligne : ECX = 0x35, donc 53*4 octets seront XOR-és. On passe dans la boucle exactement le nombre de fois dans ECX.

FLDZ : charge le réel 0 (format IEEE 754) sur la pile FPU. (Floating point LoaD Zero).

FSTENV [esp-0x0C] : Sauve l'environnement FPU sur la pile à [ESP - 0x0C]. L'environnement FPU fait 28 octets en taille.

POP EBX : difficile à dire ce qui est "popé" de la pile sans savoir ce qui a été "pushé" avant... Manque du code pour le dire.


XOR [ebx+0x13],0xF5520488 : XOR le DWORD pointé par [EBX + 0x13] par la valeur 0xF5520488. Le 0x13 indique juste un déplacement par rapport à l'adresse située dans EBX.

SUB ebx,0xFC : C'est de l'arithmétique signée, pas toujours facile à lire. Il faut lire : EBX = EBX - (-4) => EBX = EBX + 4. On incrémente bien EBX de 4. Donc EBX pointe maintenant sur le DWORD suivant celui qui a été "Xor-é" (un DWORD fait 4 octets).

LOOP [-0x0C] : Le raisonnement est juste, sauf pour "et on saute à l'adresse 0C". En fait LOOP (comme d'autres instructions) ne travaille qu'en relatif par rapport à sa position. Il faut juste comprendre que ce qui va avec l'instruction LOOP (ici [-0x0C]) n'indique pas l'adresse d'arrivée de la boucle, mais uniquement le déplacement.

Il faut juste faire un peut d'arithmétique pour connaitre l'adresse d'arrivée :

Destination du LOOP = Adresse de LOOP + Taille de l'instruction LOOP (en octet) + Déplacement.

Donc, Destination du LOOP = 0x16 + 2 + (-0x0C) = 0x18 - 0x0C = 0x0C.


Au final difficile de dire ce que fait le code sans avoir un aperçu de la pile (contenu de la pile, valeur d'ESP et d'EBP) au moment de commencer ce code...

N'hésites pas si tu as d'autres questions

[Ishan]

Merci beaucoup pour ces réponses!

Donc en fait le décodage se fait en partant de la 'fin' du code et en 'remontant' à coups de déplacements de 4 octets jusqu'à l'instruction qui succède 'LOOP' ? (en fait si j'ai bien compris, ça parait logique car une fois le décodage terminé, on obtient un pointeur vers la premiere instruction à executer (qui succede LOOP) c'est bien ça? )

pour la 2eme ligne,je pensais qu'il allait d'abord effectuer 1 premiere fois le XOR, puis ensuite 53 autres fois avec le LOOP donc 54x l'operation XOR donc un décodage sur 54x4 octets?

pour l'environnement FPU je vais faire des recherches pour comprendre un peu comment ça marche , mais est ce que ces 2 instructions s'y rapportant ont une quelconque importance dans l'execution de cette boucle?

pour le LOOP, j'étais à coté de la plaque donc en fait si le compteur n'est pas à 0, on se déplace de 13 octets en 'arrière' ?
et ce depl de -13 octets nous fait pointer sur l'execution du POP ou du XOR? ^^'

en tout cas merci beaucoup, ça commence à m'interesser tout ça

[Neitsa]

Bonjour,

Donc en fait le décodage se fait en partant de la 'fin' du code et en 'remontant' à coups de déplacements de 4 octets jusqu'à l'instruction qui succède 'LOOP' ? (en fait si j'ai bien compris, ça parait logique car une fois le décodage terminé, on obtient un pointeur vers la premiere instruction à executer (qui succede LOOP) c'est bien ça? )

En fait ma deuxième phrase étant en contradiction avec la première et je suis sincèrement désolé de t'avoir induit en erreur. Il fallait lire (j'avais écrit "précédent au lieu de "suivant") :

EBX pointe maintenant sur le DWORD suivant celui qui a été "Xor-é" (un DWORD fait 4 octets).

Je me suis emmêlé les pinceaux avec le SUB... Comme on soustrait un nombre négatif, en fait on ajoute, donc on incrémente bien à chaque passage de boucle (on ne décrémente pas !).

pour la 2eme ligne,je pensais qu'il allait d'abord effectuer 1 premiere fois le XOR, puis ensuite 53 autres fois avec le LOOP donc 54x l'operation XOR donc un décodage sur 54x4 octets?

En fait LOOP effectue deux opérations, dans un ordre bien précis :

1) Décrémente ECX
2) Test ECX == 0 ? ; NON => saute (boucle encore) ; OUI => continue sur instruction suivante.

Imaginons une boucle très simple :

Code :

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

1
2
3
4
5
6
7
 
<div style="margin-left:40px">xor eax, eax ; accu
xor ecx, ecx ; compteur de boucle
inc ecx ; compteur de boucle = 1</div>
boucle:
<div style="margin-left:40px">inc eax
LOOP boucle</div>

Avant d'entré dans le boucle : EAX = 0 ; ECX = 1
Arrivé sur le LOOP : ECX = ECX - 1 ; ECX == 0 ? ; OUI => continue sur l'instruction suivante.

On voit que lorsque ECX vaut 1, je ne fait qu'un passage dans la boucle (en réalité, il n'y a pas vraiment de boucle...). On peut en déduire que le nombre dans ECX est exactement égal au nombre de tour dans la boucle (sauf cas particulier du 0 dans ECX avant de commencer la boucle...).

mais est ce que ces 2 instructions s'y rapportant ont une quelconque importance dans l'execution de cette boucle?

C'est possible, mais il manque des informations sur l'état de la pile pour pouvoir te répondre, notamment à quoi correspond EBX lorsque le POP EBX est exécuté...

donc en fait si le compteur n'est pas à 0, on se déplace de 13 octets en 'arrière' ?
et ce depl de -13 octets nous fait pointer sur l'execution du POP ou du XOR? ^^'

13 octets en arrière à partir de l'adresse de fin du LOOP.

Pour l'adresse d'arrivée, relit bien la fin de mon message précédent :

Il faut juste faire un peut d'arithmétique pour connaitre l'adresse d'arrivée :

Destination du LOOP = Adresse de LOOP + Taille de l'instruction LOOP (en octet) + Déplacement.

Donc, Destination du LOOP = 0x16 + 2 + (-0x0C) = 0x18 - 0x0C = 0x0C.

[Ishan]

ok merci ^^

je commence pas vraiment avec le + facile mais appliqué aux shellcodes l'assembleur prend tout de suite beaucoup plus d'interet

Donc merci pour ces réponses j'y vois beaucoup plus clair ^^
Je vais tout de même arreter de sauter des étapes, et reprendre quelques tutoriaux