Différences entre la sortie Code de l'Assemblée du même programme

Question

J'ai essayé de reproduire le example3 de débordement de la mémoire tampon de cet article aleph one

Je fais cela comme une pratique d'un projet dans un cours de sécurité informatique que je prends alors s'il te plaît, j'ai terriblement besoin de ton aide. J'ai été la suivante l'exemple, en effectuant les tâches que je vais le long. Mon problème est le code d'assemblage déversé par gdb dans mon ordinateur (je le fais sur une image Linux debian fonctionnant sur VM Ware) est différent de celui de l'exemple dans l'article. Il y a certaines constructions que je trouve confuses.

Voici celui de mon ordinateur: alt text http://img692.imageshack.us/img692/7619/dump1.png

ici est celui de l'article ...

Dump of assembler code for function main: 
0x8000490 <main>:  pushl %ebp 
0x8000491 <main+1>:  movl %esp,%ebp 
0x8000493 <main+3>:  subl $0x4,%esp 
0x8000496 <main+6>:  movl $0x0,0xfffffffc(%ebp) 
0x800049d <main+13>: pushl $0x3 
0x800049f <main+15>: pushl $0x2 
0x80004a1 <main+17>: pushl $0x1 
0x80004a3 <main+19>: call 0x8000470 <function> 
0x80004a8 <main+24>: addl $0xc,%esp 
0x80004ab <main+27>: movl $0x1,0xfffffffc(%ebp) 
0x80004b2 <main+34>: movl 0xfffffffc(%ebp),%eax 
0x80004b5 <main+37>: pushl %eax 
0x80004b6 <main+38>: pushl $0x80004f8 
0x80004bb <main+43>: call 0x8000378 <printf> 
0x80004c0 <main+48>: addl $0x8,%esp 
0x80004c3 <main+51>: movl %ebp,%esp 
0x80004c5 <main+53>: popl %ebp 
0x80004c6 <main+54>: ret 
0x80004c7 <main+55>: nop 

Comme vous pouvez le voir, il y a des différences entre les deux. Je suis confus et je ne peux pas comprendre complètement le code d'assemblage de mon ordinateur. J'aimerais connaître les différences entre les deux.

Comment est pushl différent de push, mov vs movl, et ainsi de suite ...

qu'est-ce que l'expression 0xhexavalue(%register) moyens?

Je suis désolé Si je demande beaucoup, Mais j'ai vraiment besoin de votre aide.

MISE À JOUR:

Pourquoi est-ce que le paramètre à la fonction « fonction » se est traduite à différents code assembleur:

De l'article, je crois que les paramètres 1, 2, & 3 au fonction a été poussée à la pile ..

Dans celui de mon ordinateur, les paramètres ont été déplacés vers le registre «ESP» avec un certain décalage.

Sont-ils différents? Merci

Merci pour l'aide vraiment ...

Answer 1

Il me semble que votre compilateur et/ou votre système sont différents de ceux utilisés dans l'article. Certes, votre code a été généré différemment.

push vs pushl ne font que pousser (potentiellement) différentes quantités de données - vous aurez besoin de consulter la documentation de votre assembleur pour savoir quelles instructions ils correspondent à la puce. Regarder l'opcode de la machine peut aider là. Le Intel manual vous aidera à comprendre cela. Idem pour mov et movl.Il est tout à fait possible qu'ils soient identiques, et votre désassembleur quitte juste le l lorsqu'il n'est pas nécessaire pour plus de clarté. L'expression 0xhexvalue(%register) accède à la mémoire au décalage hexvalue à partir de register. Imaginez-le comme le code C *(register + hexvalue).

Answer 2

Il n'y a pas de différence réelle. «movl» signifie «déplacer long», c'est-à-dire déplacer une valeur de 32 bits. Le code dans l'article utilise cette forme explicite à chaque fois. Le code que vous avez désassemblé quitte le 'l' s'il peut être déduit des opérandes (par exemple, lorsque vous déplacez une valeur dans EAX, il doit s'agir d'une valeur 32 bits car EAX est un registre 32 bits, quand vous appuyez sur ECX vous devez pousser une valeur 32 bits car ECX est aussi un registre 32 bits).

Bien sûr, il y a de réelles différences entre les codes, mais il s'agit simplement de la notation que chacun utilise.

Answer 3

L'article Aleph One est sorti en 1996 si je me souviens bien. Ainsi, après 14 années de développement, GCC construit différemment les exécutables, ainsi le code effectif sera différent. Essayez de compiler avec toutes les optimisations désactivées (gcc -O0) et avec le code de débogage dans (gcc -g), peut-être que le code sera un peu plus propre/plus simple.