Comment trouver la fonction principale du point d'entrée de l'elfe fichier exécutable sans aucune information symbolique?

J'ai développé un petit programme cpp sur la plate-forme de Ubuntu-Linux 11.10.
Maintenant, je veux désosser. Je suis débutant. - Je utiliser de tels outils: GDB 7.0, hte éditeur, hexeditor.

Pour la première fois que j'ai fait c'est assez facile. Avec l'aide de l'information symbolique, j'ai fondé l'adresse de la fonction principale et fait tout ce dont j'avais besoin.
Ensuite, j'ai rayé (--strip-all) exécutable elf-fichier et j'ai quelques problèmes.
Je sais que main fonction commence à partir de 0x8960 dans ce programme.
Mais je n'ai pas une idée de comment je dois faire pour trouver ce point sans cette connaissance.
J'ai essayé de déboguer mon programme étape par étape à l'aide de gdb, mais il va dans __libc_start_main
puis dans la ld-linux.so.3 (donc, il détecte et charge les bibliothèques partagées nécessaires par un programme). J'ai débogué environ 10 minutes. Bien sûr, peut-être dans 20 minutes, je peux atteindre la principale fonction du point d'entrée, mais, il semble, que le moyen plus facile est d'exister.

Que dois-je faire pour trouver la main de la fonction de point d'entrée sans aucune symbolique info?
Pourriez-vous me conseiller quelques bons livres/sites/other_sources de l'ingénierie inverse de elf-fichiers avec l'aide de gdb?
Toute aide serait appréciée.

(ld-linux.n'est-il pas le noyau, c'est l'éditeur de liens dynamique, dans l'espace utilisateur.)
Mat, Ok, je n'ai pas l'esprit, mais la question est la même.
Je pense que la glibc sur x86 pousse main()'s adresse avant d'appeler __libc_start_main sur _start. Au moins, il fait y a pas longtemps.
Oui, vous avez tout à fait raison! J'ai déjà trouvé hier dans une telle manière. 🙂

OriginalL'auteur Lucky Man | 2012-03-27

Localisation main() dans une dépouillé Linux binaire ELF est simple. Pas de symbole d'information est nécessaire.

Le prototype pour __libc_start_principal est

int __libc_start_main(int (*main) (int, char**, char**), 
                      int argc, 
                      char *__unbounded *__unbounded ubp_av, 
                      void (*init) (void), 
                      void (*fini) (void), 
                      void (*rtld_fini) (void), 
                      void (*__unbounded stack_end));

La mémoire d'exécution de l'adresse de main() est l'argument correspondant au premier paramètre, int (*main) (int, char**, char**). Cela signifie que la dernière adresse de mémoire enregistré sur l'exécution de la pile avant l'appel __libc_start_main est l'adresse mémoire de main(), puisque les arguments sont poussés dans l'exécution de la pile dans l'ordre inverse de leurs paramètres correspondants dans la définition de la fonction.

On peut entrer main() dans gdb en 4 étapes:

Trouver le point d'entrée du programme
Trouver où __libc_start_main est appelé
Définir un point d'arrêt à la dernière adresse enregistrée sur la pile avant l'appel de _libc_start_main
Laisser l'exécution du programme continue jusqu'à ce que le point de rupture pour les main() est frappé

Le processus est le même pour les deux versions 32 bits et 64 bits binaires ELF.

Entrer main() dans un exemple dépouillé 32-bit binaire ELF appelé "test_32":

$ gdb -q -nh test_32
Reading symbols from test_32...(no debugging symbols found)...done.
(gdb) info file                                  #step 1
Symbols from "/home/c/test_32".
Local exec file:
    `/home/c/test_32', file type elf32-i386.
    Entry point: 0x8048310
    < output snipped >
(gdb) break *0x8048310
Breakpoint 1 at 0x8048310
(gdb) run
Starting program: /home/c/test_32 

Breakpoint 1, 0x08048310 in ?? ()
(gdb) x/13i $eip                                 #step 2
=> 0x8048310:   xor    %ebp,%ebp
   0x8048312:   pop    %esi
   0x8048313:   mov    %esp,%ecx
   0x8048315:   and    $0xfffffff0,%esp
   0x8048318:   push   %eax
   0x8048319:   push   %esp
   0x804831a:   push   %edx
   0x804831b:   push   $0x80484a0
   0x8048320:   push   $0x8048440
   0x8048325:   push   %ecx
   0x8048326:   push   %esi
   0x8048327:   push   $0x804840b                # address of main()
   0x804832c:   call   0x80482f0 <__libc_start_main@plt>
(gdb) break *0x804840b                           # step 3
Breakpoint 2 at 0x804840b
(gdb) continue                                   # step 4 
Continuing.

Breakpoint 2, 0x0804840b in ?? ()                # now in main()
(gdb) x/x $esp+4
0xffffd110: 0x00000001                           # argc = 1
(gdb) x/s **(char ***) ($esp+8)
0xffffd35c: "/home/c/test_32"                    # argv[0]
(gdb)

Entrer main() dans un exemple dépouillé 64-bit binaire ELF appelé "test_64":

$ gdb -q -nh test_64
Reading symbols from test_64...(no debugging symbols found)...done.
(gdb) info file                                  # step 1
Symbols from "/home/c/test_64".
Local exec file:
    `/home/c/test_64', file type elf64-x86-64.
    Entry point: 0x400430
    < output snipped >
(gdb) break *0x400430
Breakpoint 1 at 0x400430
(gdb) run 
Starting program: /home/c/test_64 

Breakpoint 1, 0x0000000000400430 in ?? ()
(gdb) x/11i $rip                                 # step 2
=> 0x400430:    xor    %ebp,%ebp
   0x400432:    mov    %rdx,%r9
   0x400435:    pop    %rsi
   0x400436:    mov    %rsp,%rdx
   0x400439:    and    $0xfffffffffffffff0,%rsp
   0x40043d:    push   %rax
   0x40043e:    push   %rsp
   0x40043f:    mov    $0x4005c0,%r8
   0x400446:    mov    $0x400550,%rcx
   0x40044d:    mov    $0x400526,%rdi            # address of main()
   0x400454:    callq  0x400410 <__libc_start_main@plt>
(gdb) break *0x400526                            # step 3
Breakpoint 2 at 0x400526
(gdb) continue                                   # step 4
Continuing.

Breakpoint 2, 0x0000000000400526 in ?? ()        # now in main()
(gdb) print $rdi                                    
$3 = 1                                           # argc = 1
(gdb) x/s **(char ***) ($rsp+16)
0x7fffffffe35c: "/home/c/test_64"                # argv[0]
(gdb)

Un traitement détaillé de l'initialisation du programme et ce qui se produit avant main() est appelé et comment arriver à main() peuvent être trouvés se trouve dans Patrick Horgan du tutoriel "Linux x86 Programme de Démarrage
ou - Comment diable pouvons-nous obtenir de main()?"

OriginalL'auteur julian

7

Autant que je sache, une fois qu'un programme a été dépouillé, il n'y a pas de façon simple d'accéder à la fonction que le symbole main aurait autrement référencés.

La valeur du symbole main est pas nécessaire pour le démarrage du programme: dans le format ELF, le début du programme est indiquée par le e_entry domaine de l'ELFE exécutable en-tête. Ce champ normalement points de la bibliothèque C du code d'initialisation, et non pas directement à main.

Tandis que la bibliothèque C du code d'initialisation fait appel main() après qu'il a mis en place le C de l'environnement d'exécution, cet appel est une fonction normale d'appel qui est entièrement résolu au moment de la liaison.

Dans certains cas, la mise en œuvre spécifique de l'heuristique (c'est à dire, la connaissance spécifique de l'intérieur de la C runtime) pourraient être utilisés pour déterminer l'emplacement de main dans une dépouillé exécutable. Cependant, je ne suis pas au courant d'un portable moyen de le faire.

OriginalL'auteur jkoshy

Si vous avez une version très dépouillée, ou même un fichier binaire qui est emballé, comme à l'aide de UPX, vous pouvez gdb sur elle dans le dur chemin que:

$ readelf -h echo | grep Entry
Entry point address:               0x103120

Et puis vous pouvez rompre dans GDB:

$ gdb mybinary
(gdb) break * 0x103120
Breakpoint 1 at 0x103120gdb) 
(gdb) r
Starting program: mybinary 
Breakpoint 1, 0x0000000000103120 in ?? ()

et puis, vous pouvez voir les instructions de participation:

(gdb) x/10i 0x0000000000103120
=> 0x103120:    bl      0x103394
  0x103124: dcbtst  0,r5
  0x103128: mflr    r13
  0x10312c: cmplwi  r7,2
  0x103130: bne     0x103214
  0x103134: stw     r5,0(r6)
  0x103138: add     r4,r4,r3
  0x10313c: lis     r0,-32768
  0x103140: lis     r9,-32768
  0x103144: addi    r3,r3,-1

J'espère que cela aide

OriginalL'auteur Breno Leitão

Vous devez vous connecter pour publier un commentaire.