Comment démonter la fonction principale d'une dépouillé application?

Disons que j'ai compilé le formulaire ci-dessous et dépouillé de ses symboles.

#include <stdio.h>

int main()
{
    printf("Hello\n");
}

Procédure de construction:

gcc -o hello hello.c
strip --strip-unneeded hello

Si l'application n'était pas dépouillé, démontage, la fonction principale serait facile. Cependant, je n'ai aucune idée de la façon de démonter le principal fonction d'une dépouillé application.

(gdb) disas main
No symbol table is loaded.  Use the "file" command.

(gdb) info line main
Function "main" not defined.

Comment pourrais-je le faire? Est-il même possible?

Notes: cela doit être fait avec GDB seulement. Oubliez objdump. Supposons que je n'ai pas accès au code.

Une étape-par-étape de l'exemple serait grandement apprécié.

  • Imaginez que je n'ai pas les sources de l'application et aussi que je n'ai pas accès à d'autres outils en plus de GDB.
  • L'utilisation de l'IDA 😉 ... désolé, pas pu résister. Je sais que vous le souhaitez pour GDB seulement.
  • Quiconque vers le bas voté à ma question, veuillez expliquer pourquoi.
  • Je ne vois pas downvote ...? Hein?
  • J'ai marqué quelques dizaines de réponses ce week-end, et je soupçonne que quelqu'un n'aime pas avoir leur réponse supprimé. Je suis descendu voix sur presque toutes mes questions et les récentes réponses en moins de 3 minutes. C'est pourquoi j'ai demandé la raison pour laquelle le vote vers le bas. Apparemment, la personne a décidé d'annuler leur vote.
  • ah, ok. Mais ne pas l'heuristique de sélection lorsque vous obtenez des sérieusement downvoted et recalcule votre rep? Pensais, j'ai lu quelque chose quelque part.
  • Ce n'était pas une énorme baisse de-vote-attaque, à seulement 7 ou 8 en 3 minutes.

InformationsquelleAutor karlphillip | 2011-03-29
  1. 42

    Ok, ici une grande édition de ma réponse précédente. Je crois que j'ai trouvé un moyen maintenant.

    Vous (encore 🙂 ont ce problème spécifique:

    (gdb) disas main
No symbol table is loaded.  Use the "file" command.

    Maintenant, si vous compilez le code (j'ai ajouté un return 0 à la fin), vous obtiendrez avec gcc -S:

        pushq   %rbp
    movq    %rsp, %rbp
    movl    $.LC0, %edi
    call    puts
    movl    $0, %eax
    leave
    ret

    Maintenant, vous pouvez voir que votre binaire vous donne quelques infos:

    Rayures:

    (gdb) info files
Symbols from "/home/beco/Documents/fontes/cpp/teste/stackoverflow/distrip".
Local exec file:
    `/home/beco/Documents/fontes/cpp/teste/stackoverflow/distrip', file type elf64-x86-64.
    Entry point: 0x400440
    0x0000000000400238 - 0x0000000000400254 is .interp
    ...
    0x00000000004003a8 - 0x00000000004003c0 is .rela.dyn
    0x00000000004003c0 - 0x00000000004003f0 is .rela.plt
    0x00000000004003f0 - 0x0000000000400408 is .init
    0x0000000000400408 - 0x0000000000400438 is .plt
    0x0000000000400440 - 0x0000000000400618 is .text
    ...
    0x0000000000601010 - 0x0000000000601020 is .data
    0x0000000000601020 - 0x0000000000601030 is .bss

    Le plus important ici est .text. C'est un nom commun pour une assemblée début de code, et de l'explication des principaux ci-dessous, à partir de sa taille, vous pouvez voir qu'il comprend principal. Si vous le démontage, vous verrez un appel à l' __libc_start_main. Le plus important, vous êtes le démontage d'un bon point d'entrée qui est vrai code (vous n'êtes pas trompeur de DONNÉES de changement de CODE).

    disas 0x0000000000400440,0x0000000000400618
Dump of assembler code from 0x400440 to 0x400618:
   0x0000000000400440:  xor    %ebp,%ebp
   0x0000000000400442:  mov    %rdx,%r9
   0x0000000000400445:  pop    %rsi
   0x0000000000400446:  mov    %rsp,%rdx
   0x0000000000400449:  and    $0xfffffffffffffff0,%rsp
   0x000000000040044d:  push   %rax
   0x000000000040044e:  push   %rsp
   0x000000000040044f:  mov    $0x400540,%r8
   0x0000000000400456:  mov    $0x400550,%rcx
   0x000000000040045d:  mov    $0x400524,%rdi
   0x0000000000400464:  callq  0x400428 <__libc_start_main@plt>
   0x0000000000400469:  hlt
   ...

   0x000000000040046c:  sub    $0x8,%rsp
   ...
   0x0000000000400482:  retq   
   0x0000000000400483:  nop
   ...
   0x0000000000400490:  push   %rbp
   ..
   0x00000000004004f2:  leaveq 
   0x00000000004004f3:  retq   
   0x00000000004004f4:  data32 data32 nopw %cs:0x0(%rax,%rax,1)
   ...
   0x000000000040051d:  leaveq 
   0x000000000040051e:  jmpq   *%rax
   ...
   0x0000000000400520:  leaveq 
   0x0000000000400521:  retq   
   0x0000000000400522:  nop
   0x0000000000400523:  nop
   0x0000000000400524:  push   %rbp
   0x0000000000400525:  mov    %rsp,%rbp
   0x0000000000400528:  mov    $0x40062c,%edi
   0x000000000040052d:  callq  0x400418 <puts@plt>
   0x0000000000400532:  mov    $0x0,%eax
   0x0000000000400537:  leaveq 
   0x0000000000400538:  retq

    L'appel à __libc_start_principaux obtient comme premier argument un pointeur à main(). Donc, le dernier argument de la pile immédiatement avant l'appel de votre main() adresse.

       0x000000000040045d:  mov    $0x400524,%rdi
   0x0000000000400464:  callq  0x400428 <__libc_start_main@plt>

    Ici, il est 0x400524 (comme nous le savons déjà). Maintenant, vous définissez un point d'arrêt d'un essayez ceci:

    (gdb) break *0x400524
Breakpoint 1 at 0x400524
(gdb) run
Starting program: /home/beco/Documents/fontes/cpp/teste/stackoverflow/disassembly/d2 

Breakpoint 1, 0x0000000000400524 in main ()
(gdb) n
Single stepping until exit from function main, 
which has no line number information.
hello 1
__libc_start_main (main=<value optimized out>, argc=<value optimized out>, ubp_av=<value optimized out>, 
    init=<value optimized out>, fini=<value optimized out>, rtld_fini=<value optimized out>, 
    stack_end=0x7fffffffdc38) at libc-start.c:258
258 libc-start.c: No such file or directory.
    in libc-start.c
(gdb) n

Program exited normally.
(gdb)

    Maintenant, vous pouvez démontage à l'aide de:

    (gdb) disas 0x0000000000400524,0x0000000000400600
Dump of assembler code from 0x400524 to 0x400600:
   0x0000000000400524:  push   %rbp
   0x0000000000400525:  mov    %rsp,%rbp
   0x0000000000400528:  sub    $0x10,%rsp
   0x000000000040052c:  movl   $0x1,-0x4(%rbp)
   0x0000000000400533:  mov    $0x40064c,%eax
   0x0000000000400538:  mov    -0x4(%rbp),%edx
   0x000000000040053b:  mov    %edx,%esi
   0x000000000040053d:  mov    %rax,%rdi
   0x0000000000400540:  mov    $0x0,%eax
   0x0000000000400545:  callq  0x400418 <printf@plt>
   0x000000000040054a:  mov    $0x0,%eax
   0x000000000040054f:  leaveq 
   0x0000000000400550:  retq   
   0x0000000000400551:  nop
   0x0000000000400552:  nop
   0x0000000000400553:  nop
   0x0000000000400554:  nop
   0x0000000000400555:  nop
   ...

    C'est surtout la solution.

    BTW, c'est un autre code, pour voir si elle fonctionne. C'est pourquoi l'assemblée ci-dessus est un peu différent. Le code ci-dessus est à partir de ce fichier c:

    #include <stdio.h>

int main(void)
{
    int i=1;
    printf("hello %d\n", i);
    return 0;
}

    Mais!

    si cela ne fonctionne pas, alors vous avez encore quelques conseils:

    Vous devriez être à la recherche pour définir des points d'arrêt au début de toutes les fonctions à partir de maintenant. Ils sont juste avant un ret ou leave. Le premier point d'entrée est .text lui-même. C'est le début de l'assemblée, mais pas le principal.

    Le problème est que pas toujours un point d'arrêt permettra à votre programme de course. Comme celui-ci dans le très .text:

    (gdb) break *0x0000000000400440
Breakpoint 2 at 0x400440
(gdb) run
Starting program: /home/beco/Documents/fontes/cpp/teste/stackoverflow/disassembly/d2 

Breakpoint 2, 0x0000000000400440 in _start ()
(gdb) n
Single stepping until exit from function _start, 
which has no line number information.
0x0000000000400428 in __libc_start_main@plt ()
(gdb) n
Single stepping until exit from function __libc_start_main@plt, 
which has no line number information.
0x0000000000400408 in ?? ()
(gdb) n
Cannot find bounds of current function

    De sorte que vous devez continuer d'essayer jusqu'à ce que vous trouver votre chemin, définition de points d'arrêt à:

    0x400440
0x40046c
0x400490
0x4004f4
0x40051e
0x400524

    De l'autre réponse, on devrait garder cette info:

    Dans le non-rayé version du fichier, nous voyons:

    (gdb) disas main
Dump of assembler code for function main:
   0x0000000000400524 <+0>: push   %rbp
   0x0000000000400525 <+1>: mov    %rsp,%rbp
   0x0000000000400528 <+4>: mov    $0x40062c,%edi
   0x000000000040052d <+9>: callq  0x400418 <puts@plt>
   0x0000000000400532 <+14>:    mov    $0x0,%eax
   0x0000000000400537 <+19>:    leaveq 
   0x0000000000400538 <+20>:    retq   
End of assembler dump.

    Maintenant, nous savons que la main est à 0x0000000000400524,0x0000000000400539. Si nous utilisons le même décalage de regarder les rayures binaire, nous obtenons les mêmes résultats:

    (gdb) disas 0x0000000000400524,0x0000000000400539
Dump of assembler code from 0x400524 to 0x400539:
   0x0000000000400524:  push   %rbp
   0x0000000000400525:  mov    %rsp,%rbp
   0x0000000000400528:  mov    $0x40062c,%edi
   0x000000000040052d:  callq  0x400418 <puts@plt>
   0x0000000000400532:  mov    $0x0,%eax
   0x0000000000400537:  leaveq 
   0x0000000000400538:  retq   
End of assembler dump.

    Donc, sauf si vous pouvez obtenir un peu d'astuce, où le principal chantier (comme l'utilisation d'un autre code avec des symboles), d'une autre manière, si vous pouvez avoir quelques infos sur les premières instructions de montage, de sorte que vous pouvez démonter en détails les lieux et regarder si elle correspond. Si vous n'avez pas accès à tout le code, vous pouvez toujours lire le ELFE de la définition à comprendre comment beaucoup de sections doit apparaître dans le code et essayer un calcul d'adresse. Encore, vous avez besoin d'info sur les articles dans le code!

    Que le travail est dur, mon ami! Bonne chance!

    Beco

    • En effet, si j'avais accès au code, il serait assez facile. Tout ce que je avez à faire est de compiler une version avec des symboles et des soit la charge que le binaire, ou de dire gdb où les symboles de charge de si j'ai vraiment eu pour déboguer l'dépouillé version. Le problème est que je n'ai pas vraiment les sources, ni un non-dépouillé version de l'application, je suis intéressé par le débogage. Merci pour vos efforts. +1
    • Ce que vous cherchez est un moyen de calculer le point de départ, donné un ELFE. Vous avez besoin de prendre un regard profond en ELFE de la définition, et comprendre combien chaque section peut se déplacer principaux dans le décalage. Mais encore, vous devez connaître le nombre et la taille des articles. Que info files peut vous aider un peu. Si je trouve une mise à jour dans les prochains jours, je commente ici. Bonne chance.
    • Merci à vous, Sensei.
    • Une autre information utile est de savoir comment essayer une étape-par-étape, sans savoir d'où pour définir un point d'arrêt. Vous pouvez utiliser catch syscall write ou tout simplement catch syscall, et puis vous essayez d'exécuter. Il ne travaille pas toujours, en raison de l'absence de contexte si le point d'arrêt est trop tôt.
    • La nouvelle édition de l'air prometteur. Je vais testé vite!!!
    • Je l'ai juste testé avec l'infâme commande gdb gdb, info files, disas 0x44f400,0x44f429, disas 0x44f4f0,0x44f500 et cela a fonctionné. 😉
    • Juste pour être sûr, j'ai testé avec un non-C programme. J'ai compilé une FORTRAN test et pourrait réussir à trouver et le démontage principal. BTW, nous sommes collègues contryman. 😉
    • Yeiy! 10 upvotes! Je viens de gagner ma première "belle réponse" badge. Grâce y'all. 😉
    • Félicitations. Merci à vous et profitez de votre générosité!
    • Merci pour l'affecter. Ma réponse était plus âgé que votre générosité, donc je pense que je ne serais pas la "moitié" bounty automatiquement. Il est d'une utilisation immédiate, here!
    • Vous n'avez pas besoin de deviner le point d'entrée d'adresse (pensez-vous du système de chargeur n'?). C'est là, dans l'en-tête ELF. Voir "point d'Entrée d'adresse" dans readelf -h de sortie.
    • excellente réponse! Au fait, comment savez-vous dans l'énoncé (gdb) disas 0x0000000000400524,0x0000000000400600 où est la fin de main?
    • Je suis confus avec ce trop.
    • À partir de la 0x0000000000400440 - 0x0000000000400618 is .text. Mais gardez à l'esprit que la fin de main peut-être ailleurs, en raison de la dissimulation de l'. Vous devriez vraiment suivre l'assemblée et continuer jusqu'à ce que cela a du sens. Le point important est le point d'entrée. À partir de là, le PC (program counter) va continuer, à la suite de nombres que des instructions (au lieu du segment de données où les nombres sont des données).

    InformationsquelleAutor Dr Beco
  2. 8

    Comment faire info files pour obtenir la liste de section (avec l'adresse), et va à partir de là?

    Exemple: 

    gdb) info files

Symbols from "/home/bob/tmp/t".
Local exec file:
`/home/bob/tmp/t', file type elf64-x86-64.
Entry point: 0x400490
0x0000000000400270 - 0x000000000040028c is .interp
0x000000000040028c - 0x00000000004002ac is .note.ABI-tag
    ....

0x0000000000400448 - 0x0000000000400460 is .init
    ....

    Le démonter .init:

    (gdb) disas 0x0000000000400448,0x0000000000400460
Dump of assembler code from 0x400448 to 0x400460:
   0x0000000000400448:  sub    $0x8,%rsp
   0x000000000040044c:  callq  0x4004bc
   0x0000000000400451:  callq  0x400550
   0x0000000000400456:  callq  0x400650
   0x000000000040045b:  add    $0x8,%rsp
   0x000000000040045f:  retq

    Puis aller de l'avant et de démonter le reste.

    Si j'étais vous, et j'ai eu la même version de GCC que votre exécutable a été construit avec, j'aimerais étudier la séquence des fonctions appelées sur un mannequin non dépouillé exécutable. La séquence d'appels est probablement similaire dans la plupart des cas habituels, ce qui pourra vous aider à moudre à travers la séquence de démarrage jusqu'à votre main par comparaison. Optimisations vont probablement venir de la manière que.

    Si votre binaire est dépouillé et optimisé, main peut ne pas exister comme une "entité" dans le binaire; les chances sont que vous ne pouvez pas obtenir beaucoup mieux que ce type de procédure.

    • C'est un début.
    • c'est à peu près aussi loin que vous obtiendrez. L'art de démontage est pour savoir ces choses, même lorsque vous n'avez pas les noms symboliques. La structure du fichier sera sur toutes les plates-formes vous permettent de voir par où commencer, mais ensuite c'est à vous de fouiller dans le code CRT et de trouver la main(). IDA, par exemple, utilise des signatures pour automatiser cela en grande partie à l'aide d'une approche similaire à celle du manuel de celui proposé par Tapis.
    • Si le binaire est liée de façon dynamique, vous pouvez toujours utiliser ltrace à trouver __libc_start_main (appels main(), en plus de certains d'installation), qui vous permettra d'être à proximité.
    InformationsquelleAutor Mat
  3. 1

    Il y a un nouvel outil gratuit appelé unstrip de la paradyn projet (divulgation complète: je travaille sur ce projet) qui va réécrire votre programme binaire, en ajoutant les informations de symbole à elle, et de récupérer tous (ou presque tous) les fonctions en dépouillé des binaires Elf pour vous, avec une grande précision. Il ne sera pas identifier la fonction principale comme "principal", mais il va le trouver, et vous pouvez appliquer l'heuristique vous l'avez déjà mentionné ci-dessus pour déterminer la fonction principale.

    http://www.paradyn.org/html/tools/unstrip.html

    Je suis désolé, ce n'est pas un gdb seule solution.

    • Hey, j'ai essayé le unstrip commande sur le noyau linux binaire. J'ai utilisé la commande "unstrip -f vmlinux". Cependant, il n'a pas de sortie de rien. Depuis vmlinux est un spécial binaire, toute option être fournis à unstrip commande ? Ici, c'est le binaire sous examen dl.dropboxusercontent.com/u/56211033/vmlinux
    InformationsquelleAutor Kevin
  4. -1

    IIRC, x/i <location> est votre ami. Bien sûr, vous devez trouver l'endroit où vous souhaitez démonter vous-même.

    • Je sais déjà que, et il ne m'aide pas à démonter la fonction principale puisque le problème est de trouver d'abord.
    • Si votre question est à propos de la localisation principale. L'obtention de l'instruction de la flux binaire est secondaire. J'ai mal compris la question.
    InformationsquelleAutor Laurent G