pueden - hashtag instagram para conseguir seguidores

¿Cómo desmontar la función principal de una aplicación despojada?

Question

Digamos que compilé la aplicación a continuación y quité sus símbolos.

#include <stdio.h>

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

Procedimiento de construcción:

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

Si la aplicación no se eliminó, desmontar la función principal sería fácil. Sin embargo, no tengo idea de cómo desmontar la función principal de una aplicación despojada.

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

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

¿Cómo podría hacerlo? ¿Es posible?

Notas : esto debe hacerse solo con GDB. Olvídate de objdump . Supongamos que no tengo acceso al código.

Un ejemplo paso a paso sería muy apreciado.

Answer 1

¿Qué tal si hacemos info files para obtener la lista de secciones (con direcciones) y vamos desde allí?

Ejemplo:

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
    ....

El desmonte .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   

Luego adelante y desarme el resto.

Si yo fuera tú, y tuviera la misma versión de GCC con la que se construyó tu ejecutable, examinaría la secuencia de funciones llamadas en un ejecutable ficticio sin pelar. La secuencia de llamadas es probablemente similar en la mayoría de los casos habituales, por lo que podría ayudarlo a analizar la secuencia de inicio hasta su main por comparación. Sin embargo, las optimizaciones probablemente vendrán en el camino.

Si su binario está eliminado y optimizado, main podría no existir como una "entidad" en el binario; lo más probable es que no pueda ser mucho mejor que este tipo de procedimiento.

Answer 2

Hay una nueva herramienta gratuita llamada Unstrip from the paradyn project (revelación completa: trabajo en este proyecto) que reescribirá el programa binario, agregará información de símbolos y recuperará todas (o casi todas) las funciones en los binarios de Elf despojados Para ti, con gran exactitud. No identificará la función principal como "principal", pero la encontrará, y puede aplicar la heurística que ya mencionó anteriormente para averiguar qué función es la principal.

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

Lo siento, esto no es una solución sólo para gdb.

Answer 3

IIRC, x/i <location> es tu amigo. Por supuesto, tienes que averiguar en qué lugar quieres desarmarte.

Answer 4

Ok, aquí una gran edición de mi respuesta anterior. Creo que encontré un camino ahora.

Usted (todavía :) tiene este problema específico:

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

Ahora, si compilas el código (agregué un return 0 al final), obtendrás con gcc -S :

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

Ahora, puedes ver que tu binario te da información:

A rayas:

(gdb) info files
Symbols from "/home/beco/Documents/fontes/cpp/teste//distrip".
Local exec file:
    `/home/beco/Documents/fontes/cpp/teste//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

La entrada más importante aquí es .text . Es un nombre común para el inicio del código de un ensamblado, y de nuestra explicación de la página principal, por su tamaño, puede ver que incluye main. Si lo desmonta, verá una llamada a __libc_start_main. Lo más importante es que está desarmando un buen punto de entrada que es código real (no es engañoso cambiar DATA a 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   

La llamada a __libc_start_main obtiene como primer argumento un puntero a main (). Por lo tanto, el último argumento en la pila justo antes de la llamada es su dirección principal ().

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

Aquí está 0x400524 (como ya sabemos). Ahora establece un punto de interrupción e intente esto:

(gdb) break *0x400524
Breakpoint 1 at 0x400524
(gdb) run
Starting program: /home/beco/Documents/fontes/cpp/teste//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) 

Ahora puedes desmontarlo usando:

(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
   ...

Esta es principalmente la solución.

Por cierto, este es un código diferente, para ver si funciona. Es por eso que el montaje anterior es un poco diferente. El código de arriba es de este archivo c:

#include <stdio.h>

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

¡Pero!

Si esto no funciona, entonces todavía tienes algunos consejos:

Debería estar buscando establecer puntos de interrupción al comienzo de todas las funciones a partir de ahora. Están justo antes de un ret o se leave . El primer punto de entrada es el propio .text . Este es el inicio de la asamblea, pero no el principal.

El problema es que no siempre un punto de interrupción permitirá que su programa se ejecute. Como este en el .text :

(gdb) break *0x0000000000400440
Breakpoint 2 at 0x400440
(gdb) run
Starting program: /home/beco/Documents/fontes/cpp/teste//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

Por lo tanto, debe seguir intentando hasta que encuentre su camino, estableciendo puntos de interrupción en:

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

De la otra respuesta, debemos mantener esta información:

En la versión no rayada del archivo, vemos:

(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.

Ahora sabemos que el principal está en 0x0000000000400524,0x0000000000400539 . Si usamos el mismo desplazamiento para ver el binario con bandas obtenemos los mismos resultados:

(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.

Por lo tanto, a menos que pueda obtener alguna sugerencia donde comienza el inicio (como usar otro código con símbolos), otra forma es si puede tener alguna información acerca de las primeras instrucciones de ensamblaje, así puede desensamblar en lugares específicos y ver si coinciden. Si no tiene acceso al código, puede leer la definición ELF para comprender cuántas secciones deben aparecer en el código y probar una dirección calculada. Aún así, ¡necesitas información sobre secciones en el código!

Eso es un trabajo duro, mi amigo! ¡Buena suerte!

Beco