Désassemblage sous gdb

Recherche :

Dernière réponse
Sujet : Désassemblage sous gdb
slvn	Deimos_ >> bon j'ai regardé..enfin un peu de temps libre (fait trop chaud pour aller a la plage :D) Il se trouve qu'il fait pas appel directement au nom exit. mais qu'il le traduit par une adresse + un offset.. c'est la maniere specific à gcc.. Par contre, quand tu utilises GDB, rien ne t'empêche de mettre une break point sur la fonction exit: Tappe "b exit". Le debugger te demandera simplement de confirmer que le breakpoint intervient une fonction venant d'une librarie à charger, à savoir libc6.so. En fait il en connais pas encore a ce moment le nom du symbol exit. D'ailleurs ta remarque était qu'aucun appel a exit n'apparaissait, mais simplement "jmp <_init+0xXX>". Peut etre qu'il s'agit simplement d'un moyen/d'une astuce pour alléger la table de symbol. Ensuite, tu démarres ton programme avec la commande "run" le breakpoint est touché, preuve que exit, bien que ne figurant pas explicitement, est réellement appellée. Et finallement, tu peux désassembler exit: "disassemble exit" Le code que tu voit pour exit, tu peux retrouver ses Sources, comme le dit Jar Jar, dans le package source de libc6. Mea culpa, car je t'ai induit en erreur, je pensais que exit était directement un appel au noyau, ce qui se serait traduit, non pas par une fonction précise, mais [ar une fonction plus généric (syscall). Sylvain

Dernière réponse

Sujet : Désassemblage sous gdb

slvn

Deimos_ >>

bon j'ai regardé..enfin un peu de temps libre (fait trop chaud pour aller a la plage :D)

Il se trouve qu'il fait pas appel directement au nom exit.
mais qu'il le traduit par une adresse + un offset.. c'est la maniere specific à gcc..

Par contre, quand tu utilises GDB, rien ne t'empêche de mettre une break point sur la fonction exit:

Tappe "b exit". Le debugger te demandera simplement de confirmer que le breakpoint intervient une fonction venant d'une librarie à charger, à savoir libc6.so.

En fait il en connais pas encore a ce moment le nom du symbol exit. D'ailleurs ta remarque était qu'aucun appel a exit n'apparaissait, mais simplement "jmp <_init+0xXX>".
Peut etre qu'il s'agit simplement d'un moyen/d'une astuce pour alléger la table de symbol.

Ensuite, tu démarres ton programme avec la commande "run"
le breakpoint est touché, preuve que exit, bien que ne figurant pas explicitement, est réellement appellée.

Et finallement, tu peux désassembler exit: "disassemble exit"

Le code que tu voit pour exit, tu peux retrouver ses Sources, comme le dit Jar Jar, dans le package source de libc6.

Mea culpa, car je t'ai induit en erreur, je pensais que exit était directement un appel au noyau, ce qui se serait traduit, non pas par une fonction précise, mais [ar une fonction plus généric (syscall).

Sylvain

Votre réponse

Nom d'utilisateur

Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !

Le ton de votre message

Votre réponse

Smilies

Liste des smilies perso
Wiki smilies
Chercher un smiley

Options

Activer votre signature
Désactiver les smilies
Activer la notification par email du sujet

Aperçu

Vous avez perdu votre mot de passe ?

Vue Rapide de la discussion

slvn

Jar Jar

Si vous voulez désassembler les bibliothèques vers lesquelles le programme pointe, il faudrait peut-être installer leurs versions de déboguage, à commencer par libc6-dbg pour la libc.

Deimos_

J'ai looké le désassemblage complet du programme, ya aucun symbole <_exit> ou un truc dans le genre, comme l'avait dit objdump -t

Pour le désassemblage de call_gmon_start :

Code :

(gdb) disass call_gmon_start
Dump of assembler code for function call_gmon_start:
0x080482e4 <call_gmon_start+0>: push %ebp
0x080482e5 <call_gmon_start+1>: mov %esp,%ebp
0x080482e7 <call_gmon_start+3>: push %ebx
0x080482e8 <call_gmon_start+4>: call 0x80482ed <call_gmon_start+9>
0x080482ed <call_gmon_start+9>: pop %ebx
0x080482ee <call_gmon_start+10>: add $0x1277,%ebx
0x080482f4 <call_gmon_start+16>: push %edx
0x080482f5 <call_gmon_start+17>: mov 0x14(%ebx),%eax
0x080482fb <call_gmon_start+23>: test %eax,%eax
0x080482fd <call_gmon_start+25>: je 0x8048301 <call_gmon_start+29>
0x080482ff <call_gmon_start+27>: call *%eax
0x08048301 <call_gmon_start+29>: pop %eax
0x08048302 <call_gmon_start+30>: pop %ebx
0x08048303 <call_gmon_start+31>: leave
0x08048304 <call_gmon_start+32>: ret
0x08048305 <call_gmon_start+33>: nop
0x08048306 <call_gmon_start+34>: nop
0x08048307 <call_gmon_start+35>: nop
0x08048308 <call_gmon_start+36>: nop
0x08048309 <call_gmon_start+37>: nop
0x0804830a <call_gmon_start+38>: nop
---Type <return> to continue, or q <return> to quit---
0x0804830b <call_gmon_start+39>: nop
0x0804830c <call_gmon_start+40>: nop
0x0804830d <call_gmon_start+41>: nop
0x0804830e <call_gmon_start+42>: nop
0x0804830f <call_gmon_start+43>: nop
End of assembler dump.

J'ai regardé celui des deux autrs, ya rien de super dedans non plus ....
Je comprends vraiment pas ça, en plus je suis pas le seul à avoir ce problème, et je le trouve encore (assez) important :/

Merci
@+, Deimos

slvn	desassemble aussi call_gmon_start apparemment :/ pour tout voir, tu peux tapper: objdump -D nom_du_fichier

Deimos_

Ok, donc mon code :

Code :

#include <unistd.h>
int main()
{
_exit(0);
}

Je compile avec :
$ gcc -W -Wall -ggdb -o code -g code.c

Quand je désassemble main :

Code :

(gdb) disass main
Dump of assembler code for function main:
0x0804836c <main+0>: push %ebp
0x0804836d <main+1>: mov %esp,%ebp
0x0804836f <main+3>: sub $0x8,%esp
0x08048372 <main+6>: and $0xfffffff0,%esp
0x08048375 <main+9>: mov $0x0,%eax
0x0804837a <main+14>: add $0xf,%eax
0x0804837d <main+17>: add $0xf,%eax
0x08048380 <main+20>: shr $0x4,%eax
0x08048383 <main+23>: shl $0x4,%eax
0x08048386 <main+26>: sub %eax,%esp
0x08048388 <main+28>: sub $0xc,%esp
0x0804838b <main+31>: push $0x0
0x0804838d <main+33>: call 0x80482b0 <_init+56>
End of assembler dump.

Quand je désassemble _init :

Code :

(gdb) disass _init
Dump of assembler code for function _init:
0x08048278 <_init+0>: push %ebp
0x08048279 <_init+1>: mov %esp,%ebp
0x0804827b <_init+3>: sub $0x8,%esp
0x0804827e <_init+6>: call 0x80482e4 <call_gmon_start>
0x08048283 <_init+11>: call 0x8048340 <frame_dummy>
0x08048288 <_init+16>: call 0x8048430 <__do_global_ctors_aux>
0x0804828d <_init+21>: leave
0x0804828e <_init+22>: ret
End of assembler dump

Voilà ... pour désassembler tout le programme, on fait comment ?

Merci de ton aide ;)

++

slvn

un system call, c'est pas un appel de fonction mais plutot une trap+un parametre.

peut-etre que dans _init, y a qq chose pour faire de maniere generic n'importe quel system call.

Est-ce que tu peux faire un disassemble de _init?
(voir meme un disassemble de tout le programe, ie pas uniquement le main)

Deimos_

J'ai utilisé _exit moi, et c'est un syscall.
J'ai fait "objdump -t" et là je vois justement que le symbole _exit n'y est pas ... je comprends pas, justment il devrait y être, vu que l'option -ggdb de gcc est prévue pour fournir tous les symboles a GDB !
Non, aucune optimisation.

Pour le path vers les sources, c'est inutile, avec -ggdb, lorsqu'on désassemble avec GDB le progamme, il suffit de faire "list" et GDB affiche le code source du programme !

slvn	exit est une macro? le code a subit une optimisation ? Apparement, y a pas le symbole :/ fait un "objdump -t" dessus, et il ne devrait pas trouver de symbol exit :/

l0ky	Il n'y a pas une histoire qu'il faut indiquer le path vers les sources ou quelque chose comme ca ? Sinon tu auras peut etre plus de chance dans la prog

deather2

Moi de meme, j'ai compile avec -g

Deimos_

C'est ce que je croyais aussi au début, pourtant j'ai compilé comme cela :
$ gcc -W -Wall -ggdb -o code -g code.c

l0ky	Parce que la compilation n'a pas été faite avec les options de déboggage, ou que l'exécutable a été "stripé" :??:

deather2

Pareil pour moi, bizarre...

barney% cat test.c
#include <unistd.h>
main(){exit(0);}

(gdb) disassemble main
Dump of assembler code for function main:
0x08048384 <main+0>: push ebp
0x08048385 <main+1>: mov ebp,esp
0x08048387 <main+3>: sub esp,0x8
0x0804838a <main+6>: and esp,0xfffffff0
0x0804838d <main+9>: mov eax,0x0
0x08048392 <main+14>: sub esp,eax
0x08048394 <main+16>: mov DWORD PTR [esp],0x0
0x0804839b <main+23>: call 0x80482b0 <_init+56>
End of assembler dump.

Deimos_

(gdb) x 0x80482e4
0x80482c4 <_init+40>: 0x95c825ff

Voilà ce qu'il me renvoie ...
En fait ce que je voudrais comprendre, c'est surtout pourquoi comme dans certains articles que j'ai lu sur gdb, yai pas <nom_de_la_fonction> lors du désassemblage, et pas ce <_init+40> :/

Merci quand même
++

slvn	c'est pas "x $0x804...." pour dumper la mémoire. ...de mémoire

Deimos_

Bonsoir à tous,

J'ai un problème de désassemblage sous gdb 6.2-2 (je tourne sous Mandrake 10.1) ... En fait, je désassemble tout d'abord un simple programme en C et la fonction main avec la commande
(gdb) disassemble main

J'ai donc le code asm de la fonction main, et des appels vers les fonctions que mon programme utilise. Dans celui-ci, j'utilise la fonction _exit() et je voudrais par exemple la désassembler. Je suis entièrement sûr que cette fonction correspond à ce call :
0x080483e0 <main+48>: call 0x80482e4 <_init+72>

L'embêtant, c'est que je n'arrive pas a voir le code assembleur de cette fonction. J'ai essayé :
(gdb) disassemble $0x80482e4
(gdb) disassemble *0x80482e4
...
(gdb) disassemble _exit
...

Rien ne marche !
Pourquoi GDB m'affiche-t-il <_init+72> et pas <_exit> ?

J'ai compilé le code C avec gcc, avec l'option -ggdb, pour que ce dernier puisse avoir le maximum d'informations sur le code ... Mais ça ne change rien au résultat du désassemblage ... :??:

En espérant que quelqu'un voit une solution ou a déjà rencontré ce problème,

Ciao @+,
Deimos