En 10 formas de analizar archivos binarios en Linux , expliqué cómo usar el rico conjunto de herramientas nativas de Linux para analizar archivos binarios. Pero si desea explorar más su binario, necesita una herramienta hecha a medida para el análisis binario. Si es nuevo en el análisis binario y ha trabajado principalmente con lenguajes de secuencias de comandos, 9 herramientas GNU binutils esenciales lo ayudará a comenzar a aprender el proceso de compilación y lo que constituye un binario.
¿Por qué necesito otra herramienta?
Más recursos de Linux
- Hoja de trucos de los comandos de Linux
- Hoja de trucos de comandos avanzados de Linux
- Curso en línea gratuito:Descripción general técnica de RHEL
- Hoja de trucos de red de Linux
- Hoja de trucos de SELinux
- Hoja de trucos de los comandos comunes de Linux
- ¿Qué son los contenedores de Linux?
- Nuestros últimos artículos sobre Linux
Es natural preguntarse por qué necesita otra herramienta más si las herramientas nativas de Linux existentes hacen cosas similares. Bueno, es por las mismas razones por las que usa su teléfono celular como despertador, para tomar notas, como cámara, para escuchar música, navegar por Internet y, ocasionalmente, para hacer y recibir llamadas. Anteriormente, dispositivos y herramientas separados manejaban estas funciones, como una cámara física para tomar fotografías, un pequeño bloc de notas para tomar notas, un despertador junto a la cama para despertarse, etc. Tener un dispositivo para hacer varias cosas (pero relacionadas) es conveniente para el usuario Además, la característica principal es la interoperabilidad entre las funciones separadas.
Del mismo modo, aunque muchas herramientas de Linux tienen un propósito específico, es muy útil tener una funcionalidad similar (y mejor) agrupada en una sola herramienta. Es por eso que creo que Radare2 debería ser su herramienta de referencia siempre que necesite trabajar con archivos binarios.
Radare2 (también conocido como r2) es un "marco de ingeniería inversa similar a Unix y un conjunto de herramientas de línea de comandos", según su perfil de GitHub. El "2" en su nombre se debe a que esta versión fue reescrita desde cero para hacerla más modular.
¿Por qué Radare2?
Hay toneladas de herramientas de Linux (no nativas) que se utilizan para el análisis binario, entonces, ¿por qué debería elegir Radare2? Mis razones son simples.
Primero, es un proyecto de código abierto con una comunidad activa y saludable. Si está buscando nuevas funciones ingeniosas o la disponibilidad de correcciones de errores, esto es muy importante.
En segundo lugar, Radare2 se puede utilizar en la línea de comandos y tiene un entorno de interfaz gráfica de usuario (GUI) enriquecido llamado Cutter para aquellos que se sienten más cómodos con las GUI. Siendo un usuario de Linux desde hace mucho tiempo, me alimento más cómodo en el shell. Si bien hay una ligera curva de aprendizaje para familiarizarse con los comandos de Radare2, lo compararía con aprender Vim. Aprendes cosas básicas primero, y una vez que las dominas, pasas a cosas más avanzadas. En poco tiempo, se convierte en una segunda naturaleza.
En tercer lugar, Radare2 tiene un buen soporte para herramientas externas a través de complementos. Por ejemplo, la herramienta de análisis e inversión binaria Ghidra de código abierto recientemente es popular por su función de descompilación, que es un elemento crítico del software de inversión. Puede instalar y usar el descompilador Ghidra directamente desde la consola Radare2, que es increíble y le brinda lo mejor de ambos mundos.
Empezar con Radare2
Para instalar Radare2, simplemente clone el repositorio y ejecute user.sh texto. Es posible que deba instalar algunos paquetes de requisitos previos si aún no están en su sistema. Una vez completada la instalación, ejecute r2 -v comando para ver si Radare2 se instaló correctamente:
$ git clone https://github.com/radareorg/radare2.git
$ cd radare2
$ sys/user.sh
# versión
$ r2 -v
radare2 4.6.0-git 25266 @ linux-x86-64 git.4.4.0-930-g48047b317
compromiso:48047b3171e6ed0480a71a04c3693a0650d03543 compilación:2020-11:31-17__ :03
$
Obtener un binario de prueba de muestra
Ahora que r2 está instalado, necesita un binario de muestra para probarlo. Podría usar cualquier sistema binario (ls , bash , etc.), pero para mantener las cosas simples para este tutorial, compile el siguiente programa en C:
$ cat sumador.c
#include
int sumador(int num) {
return num + 1;
}
int main() {
int res, num1 =100;
res =sumador(num1);
printf("El número ahora es :%d\n", res);
return 0;
}
$
$
$ gcc sumador.c -o sumador
$
$ sumador de archivo
adder:ELF ejecutable LSB de 64 bits, x86-64, versión 1 (SYSV), enlazado dinámicamente, intérprete /lib64/ld-linux-x86-64.so.2, para GNU/Linux 3.2.0, BuildID [sha1]=9d4366f7160e1ffb46b14466e8e0d70f10de2240, no eliminado
$
$ ./adder
El número ahora es:101
$
Cargar el binario
Para analizar el binario, debes cargarlo en Radare2. Cárguelo proporcionando el archivo como un argumento de línea de comando para r2 dominio. Te colocan en una consola Radare2 separada diferente de tu caparazón. Para salir de la consola, puede escribir Salir o Salir o presiona Ctrl +D :
$ r2 ./adder
-- ¡Aprende pancake como si fueras radare!
[0x004004b0]> quit
$
Analizar el binario
Antes de que pueda explorar el binario, debe pedirle a r2 que lo analice por usted. Puede hacerlo ejecutando aaa comando en la consola r2;
$ r2 ./adder
-- Lo sentimos, radare2 ha experimentado un error interno.
[0x004004b0]>
[0x004004b0]>
[0x004004b0]> aaa
[x] Analizar todas las banderas que comienzan con sym. and entry0 (aa)
[x] Analizar llamadas a funciones (aac)
[x] Analizar len bytes de instrucciones para referencias (aar)
[x] Verificar vtables
[ x] Tipo de análisis coincidente para todas las funciones (aaft)
[x] Propaga la información sin retorno
[x] Usa -AA o aaaa para realizar análisis experimentales adicionales.
[0x004004b0]>
Esto significa que cada vez que elige un binario para el análisis, debe escribir un comando adicional para aaa después de cargar el binario. Puede omitir esto llamando a r2 con -A seguido del nombre binario; esto le dice a r2 que analice automáticamente el binario por usted:
$ r2 -A ./adder
[x] Analiza todos los indicadores que comienzan con sym. and entry0 (aa)
[x] Analizar llamadas a funciones (aac)
[x] Analizar len bytes de instrucciones para referencias (aar)
[x] Verificar vtables
[ x] Escriba el análisis de coincidencia para todas las funciones (aaft)
[x] Propague la información sin devolución
[x] Use -AA o aaaa para realizar análisis experimentales adicionales.
-- Ya está al día fecha.
[0x004004b0]>
Obtener información básica sobre el binario
Antes de comenzar a analizar un binario, necesita un punto de partida. En muchos casos, puede ser el formato de archivo del binario (ELF, PE, etc.), la arquitectura para la que se creó el binario (x86, AMD, ARM, etc.) y si el binario es de 32 bits o de 64 bits. . El práctico iI de R2 El comando puede proporcionar la información requerida:
[0x004004b0]> iI
arch x86
baddr 0x400000
binsz 14724
bintype elf
bits 64
canary false
clase ELF64
compilador GCC:(GNU) 8.3.1 20190507 (Red Hat 8.3.1-4)
crypto false
endian little
havecode true
intrp /lib64/ld -linux-x86-64.so.2
laddr 0x0
lang c
linenum true
lsyms true
máquina arquitectura AMD x86-64
maxopsz 16
minopsz 1
nx verdadero
os linux
pcalign 0
pic falso
relocs verdadero
relro parcial
rpath NONE
sanitiz false
static false
stripped false
subsys linux
va true
[0x004004b0]>
[0x004004b0]>
Importaciones y exportaciones
A menudo, una vez que sabe con qué tipo de archivo está tratando, desea saber qué tipo de funciones de biblioteca estándar usa el binario o aprender las funcionalidades potenciales del programa. En el programa C de muestra de este tutorial, la única función de biblioteca es printf para imprimir un mensaje. Puede ver esto ejecutando ii comando, que muestra todas las importaciones del binario:
[0x004004b0]> ii
[Importaciones]
nth vaddr bind type lib name
――――――――――――――――――――― ―――――――――――――――
1 0x00000000 DÉBIL NOTYPE _ITM_deregisterTMCloneTable
2 0x004004a0 FUNCIÓN GLOBAL printf
3 0x00000000 FUNCIÓN GLOBAL __libc />040 ÚNICO 0x040 NOTYPE __gmon_start__
5 0x00000000 DÉBIL NOTYPE _ITM_registerTMCloneTable
El binario también puede tener sus propios símbolos, funciones o datos. Estas funciones generalmente se muestran en Exports . El binario de prueba tiene dos funciones, principal y sumador, que se exportan. El resto de las funciones se agregan durante la fase de compilación cuando se construye el binario. El cargador los necesita para cargar el binario (no se preocupe demasiado por ellos por ahora):
[0x004004b0]>
[0x004004b0]> iE
[Exportaciones]
nth paddr vaddr bind type lib name
――――――― ―――――――――――――――――――――――――――――――――———————————
82 0x00000650 0x00400650 Global FUNC 5 __LIBC_CSU_FINI
85 ---------------------------------------------------------------------------------------------------------------------------------------------------edata
86 0x00000658 0x00400658 global funtc 0 _fini
89 0x00001020 0x00601020 global notype 0 __data_start
90 0x00000596 0x00400596 Global FUNC 15 Adder
92 0x00000670 0x00400670 Global obj 0 __dsO_handle
93 0x00668 0x00400668 Global obj 4 _io_stdin_used
94 0x000005E0 0x004005E0 Global FUNC 101 __Libc_csu_init
95 - --------- 0x00601028 NOTYPE GLOBAL 0 _end
96 0x000004e0 0x004004e0 FUNCIÓN GLOBAL 5 _dl_relocate_static_pie
97 0x000004b0 0x004004b0 FUNCIÓN GLOBAL _ 8 br /> 47 _start 47 - 0x00601024 NOTYPE GLOBAL 0 __bss_start
99 0x00000 5A5 0x004005A5 Global FUNC 55 Main
100 ---------- 0x00601028 global obj 0 __tmc_end__
102 0x00000468 0x00400468 Global FUNC 0 _init
[0x004004b0]>
Información de hash
¿Cómo saber si dos binarios son similares? No puedes abrir exactamente un binario y ver el código fuente dentro de él. En la mayoría de los casos, el hash de un binario (md5sum, sha1, sha256) se usa para identificarlo de manera única. Puede encontrar el hash binario usando it comando:
[0x004004b0]>
md5 7e6732f2b11dec4a0c7612852cede670
sha1 d5fa848c4b53021f6570dd9b18d115595a2290ae
sha256 13dd5a492219dac1443a816ef5f91db8d149e8edbf26f24539c220861769e1c2
[0x004004b0]>
Funciones
El código se agrupa en funciones; para enumerar qué funciones están presentes dentro de un binario, ejecute afl dominio. La siguiente lista muestra las funciones principal y sumadora. Por lo general, las funciones que comienzan con sym.imp se importan de la biblioteca estándar (glibc en este caso):
[0x004004B0]> AFL
0x004004B0 1 46 Entry0
0x004004f0 4 41 -> 34 Sym.deregister_tm_clones
0x00400520 4 57 -> 51 Sym.register_tm_clones
0x00400560 3 33 -> 32 SYMY .__ DO_GLOBAL_DTORS_AUX
0x00400590 1 6 Entry.init0
0x00400650 1 5 Sym .__ libc_csu_fini
0x00400658 1 13 Sym._Fini
0x00400596 1 15 Sym.Adder
0x004005E0 4 101 loc..annobin_finit.c
0x004004e0 1 5 loc..anbin_static_reloc.c
0x004005a5 1 55 Main
0x004004a0 1 6 Sym.imp.printf
0x00400468 3 27 SYM. _init
[0x004004b0]>
Referencias cruzadas
En C, la función principal es donde un programa comienza su ejecución. Idealmente, otras funciones se llaman desde main y, al salir de un programa, la función principal devuelve un estado de salida al sistema operativo. Esto es evidente en el código fuente; sin embargo, ¿qué pasa con un binario? ¿Cómo puedes saber dónde se llama la función del sumador?
Puedes usar el axt comando seguido del nombre de la función para ver dónde se llama a la función sumadora; como puede ver a continuación, se llama desde la función principal. Esto se conoce como referencias cruzadas. Pero, ¿qué llama a la función principal en sí? El axt main La función a continuación muestra que es llamada por entry0 (Me iré aprendiendo sobre entry0 como ejercicio para el lector):
[0x004004b0]> axt sym.adder
main 0x4005b9 [CALL] call sym.adder
[0x004004b0]>
[0x004004b0]> axt main
entry0 0x4004d1 [DATA ] mov rdi, principal
[0x004004b0]>
Buscar ubicaciones
Cuando trabaja con archivos de texto, a menudo se mueve dentro de un archivo haciendo referencia a un número de línea seguido de un número de fila o columna; en un binario, usas direcciones. Estos son números hexadecimales que comienzan con 0x seguido de una dirección. Para encontrar dónde se encuentra en un binario, ejecute los s dominio. Para moverte a una ubicación diferente, usa los s comando seguido de la dirección.
Los nombres de las funciones son como etiquetas, que están representadas internamente por direcciones. Si el nombre de la función está en binario (sin eliminar), puede usar s seguido del nombre de la función para saltar a una dirección de función específica. De manera similar, si desea saltar al comienzo del binario, escriba s 0 :
[0x004004b0]> s
0x4004b0
[0x004004b0]>
[0x004004b0]> s principal
[0x004005a5]>
[0x004005a5]> s
0x4005a5
[0x004005a5]>
[0x004005a5]> s sumador simbólico
[0x00400596]>
[0x00400596]> s
0x400596
[ 0x00400596]>
[0x00400596]> s 0
[0x00000000]>
[0x00000000]> s
0x0
[0x00000000]>
Vista hexadecimal
A menudo, el binario en bruto no tiene sentido. Puede ayudar ver el binario en modo hexadecimal junto con su representación ASCII equivalente:
[0x004004b0]> s principal
[0x004005a5]>
[0x004005a5]> px
- offset - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
0x004005a5 5548 89e5 4883 ec10 c745 fc64 0000 008b UH..H....E.d....
0x004005b5 45fc 89c7 e8d8 ffff ff89 45f8 8b45 f889 E.........E..E. .
0x004005c5 c6bf 7806 4000 b800 0000 00e8 cbfe ffff ..x.@...........
0x004005d5 b800 0000 00c9 c30f 1f40 00f3 0f1e fa41 ....... [email protected]
0x004005e5 5749 89d7 4156 4989 f641 5541 89fd 4154 WI..AVI..AUA..AT
0x004005f5 4c8d 2504 0820 0055 488d 2d04 0820 005. .UH.-.. .S
0x00400605 4c29 e548 83ec 08e8 57fe ffff 48c1 fd03 L).H....W...H...
0x00400615 741f 31db 0f1f 8000 0000 004c 89fa 4c89 t.1........L..L.
0x00400625 f644 89ef 41ff 14dc 4883 c301 4839 dd75 .D..A...H...H9.u
0x00400635 ea48 83c4 085b 5d41 5c41 5d41 5e41 5fc3 .H...[]A\A]A^A_.
0x00400645 9066 2e0f 1f84 0000 0000 00f3 0f1e fac3 .f............. .
0x00400655 0000 00f3 0f1e fa48 83ec 0848 83c4 08c3 .......H...H....
0x00400665 0000 0001 0002 0000 0000 0000 0000 0000 ................
0x00400675 0000 004e 756d 6265 7220 6e6f 7720 6973 ...El número ahora es
0x00400685 2020 3a20 2564 0a00 0000 0001 1b03 3b44 D905:0%d........0; 0000 0007 0000 0000 feff ff88 0000 0020 ...............
[0x004005a5]>
Desmontaje
Si está trabajando con binarios compilados, no hay código fuente que pueda ver. El compilador traduce el código fuente a instrucciones en lenguaje de máquina que la CPU puede entender y ejecutar; el resultado es el binario o ejecutable. Sin embargo, puede ver las instrucciones de ensamblaje (mnemónicos) para entender lo que está haciendo el programa. Por ejemplo, si desea ver qué está haciendo la función principal, puede buscar la dirección de la función principal usando s main y luego ejecute el pdf Comando para ver las instrucciones de desmontaje.
Para comprender las instrucciones de ensamblaje, debe consultar el manual de arquitectura (x86 en este caso), su interfaz binaria de aplicación (su ABI o convenciones de llamada) y tener una comprensión básica de cómo funciona la pila:
[0x004004b0]> s principal
[0x004005a5]>
[0x004005a5]> s
0x4005a5
[0x004005a5]>
[0x004005a5]> pdf
; DATOS XREF de entrada0 @ 0x4004d1
┌ 55:int principal (int argc, char **argv, char **envp);
│ ; var int64_t var_8h @ rbp-0x8
│ ; var int64_t var_4h @ rbp-0x4
│ 0x004005a5 55 Push RBP
│ 0x004005A6 4889E5 MOV RBP, RSP
│ 0x004005A9 4883EC10 SUB RSP, 0x10
│ 0x004005Ad C745FC640000. mov dword [var_4h], 0x64 ; 'd'; 100
│ 0x004005B4 8B45FC MOV EAX, DWORD [VAR_4H]
│ 0x004005B7 89C7 MOV EDI, EAX
│ 0x004005B9 E8D8FFFFFFF Llame a Sym.Adder
│ 0x004005be 8945F8 MOV DWORD [VAR_8H], EAX
│ 0x004005C1 8B45F8 MOV EAX, DWORD [VAR_8H]
│ 0x004005C4 89C6 MOV ESI, EAX
│ 0x004005C6 BF78064000 MOV EDI, STR.NUMBER_NUDE_IS __:__ D; 0x400678; "El número ahora es :%d\n"; const char *format
│ 0x004005cb b800000000 mov eax, 0
│ 0x004005d0 e8cbfeffff call sym.imp.printf ; INT Printf (formato Const Char *)
│ 0x004005D5 B800000000 MOV EAX, 0
│ 0x004005DA C9 Dejar
└ 0x004005DB C3 RET
[0x004005A5]>
Aquí está el desmontaje de la función de sumador:
pdf; LLAME A XREF desde main @ 0x4005b9
┌ 15:sym.adder (int64_t arg1);
│ ; var int64_t var_4h @ rbp-0x4
│ ; arg int64_t arg1 @ rdi
│ 0x00400596 55 Push RBP
│ 0x00400597 4889E5 MOV RBP, RSP
│ 0x0040059A 897DFC MOV DWORD [VAR_4H], EDI; arg1
│ 0x0040059D 8B45FC MOV EAX, DWORD [VAR_4H]
│ 0x004005A0 83C001 Agregar EAX, 1
│ 0x004005A3 5D POP RBP
└ 0x004005A4 C3 RET
[0x00400596]>
Cadenas
Ver qué cadenas están presentes dentro del binario puede ser un punto de partida para el análisis binario. Las cadenas están codificadas en un binario y, a menudo, brindan sugerencias importantes para cambiar su enfoque y analizar ciertas áreas. Ejecute el iz comando dentro del binario para enumerar todas las cadenas. El binario de prueba tiene solo una cadena codificada en el binario:
[0x004004b0]> iz
[Strings]
nth paddr vaddr tipo de sección de tamaño de len string
――――――――――――――――――― ――――――――――――――――――――――――――――――――
0 0x00000678 0x00400678 20 21 .rodata ascii Número ahora es :%d\n
[0x004004b0]>
Cadenas de referencias cruzadas
Al igual que con las funciones, puede hacer una referencia cruzada de las cadenas para ver desde dónde se imprimen y comprender el código que las rodea:
[0x004004b0]> ps @ 0x400678
El número ahora es :%d
[0x004004b0]>
[0x004004b0]> axt 0x400678
principal 0x4005c6 [DATOS ] mov edi, str.Number_now_is__:__d
[0x004004b0]>
Modo visual
Cuando su código es complicado con múltiples funciones llamadas, es fácil perderse. Puede ser útil tener una vista gráfica o visual de qué funciones se llaman, qué caminos se toman en función de ciertas condiciones, etc. Puede explorar el modo visual de r2 usando el VV después de pasar a una función de interés. Por ejemplo, para la función sumadora:
[0x004004b0]> s sym.adder
[0x00400596]>
[0x00400596]> VV
Depurador
Hasta ahora, ha estado haciendo análisis estáticos:solo está mirando cosas en el binario sin ejecutarlo. A veces necesita ejecutar el binario y analizar información diversa en la memoria en tiempo de ejecución. El depurador interno de r2 le permite ejecutar un binario, colocar puntos de interrupción, analizar los valores de las variables o volcar el contenido de los registros.
Inicie el depurador con -d marca y agrega el -A marca para hacer un análisis a medida que se carga el binario. Puede establecer puntos de interrupción en varios lugares, como funciones o direcciones de memoria, utilizando el db <function-name> dominio. Para ver los puntos de interrupción existentes, use el dbi dominio. Una vez que haya colocado sus puntos de interrupción, comience a ejecutar el binario usando el dc dominio. Puede ver la pila usando dbt comando, que muestra las llamadas a funciones. Finalmente, puede volcar el contenido de los registros usando el drr comando:
$ r2 -d -A ./adder
Proceso con PID 17453 iniciado...
=adjuntar 17453 17453
bin.baddr 0x00400000
Usando 0x400000
asm.bits 64
[x] Analizar todos los indicadores que comienzan con sym. and entry0 (aa)
[x] Analizar llamadas a funciones (aac)
[x] Analizar len bytes de instrucciones para referencias (aar)
[x] Verificar vtables
[ x] Escriba el análisis de coincidencia para todas las funciones (aaft)
[x] Propague la información sin retorno
[x] Use -AA o aaaa para realizar análisis experimentales adicionales.
-- git checkout hamster
[0x7f77b0a28030]>
[0x7f77b0a28030]> db principal
[0x7f77b0a28030]>
[0x7f77b0a28030]> db sumador simbólico
[0x7f77b0a28030]>
[0x78f73b0 ]> dbi
0 0x004005a5 E:1 T:0
1 0x00400596 E:1 T:0
[0x7f77b0a28030]>
[0x7f77b0a28030]> afl | grep principal
0x004005a5 1 55 principal
[0x7f77b0a28030]>
[0x7f77b0a28030]> afl | grep sym.adder
0x00400596 1 15 sym.adder
[0x7f77b0a28030]>
[0x7f77b0a28030]> dc
hizo el punto de interrupción en:0x4005a5
[0x004005a5]>
[0x004005A5]> DBT
0 0x4005A5 SP:0x0 0 [Principal] Main Sym.Adder + 15
1 0x7f77b0687873 sp:0x7ffe35ff6858 0 [??] sección..gnu.build.attributes-1345820597
2 0x7f77b0a36e0a sp:0x7ffe35ff68e8 144 [??] map.usr_lib64_ld_2.28.so.r_x+65034
[0x004005a5]> dc
hizo el punto de interrupción en:0x400596
05x906> DBT
0 0x400596 SP:0x0 0 [Sym.Adder] RIP Entry.init0 + 6
1 0x4005be SP:0x7ffe35ff6838 0 [PRINCIPAL] PRINCIPAL + 25
2 0x7f77b0687873 sp:0x7ffe35ff6858 32 [ ??] sección..gnu.build.attributes-1345820597
3 0x7f77b0a36e0a sp:0x7ffe35ff68e8 144 [??] map.usr_lib64_ld_2.28.so.r_x+65034
[0x004005>96]> [0x00400596]>
[0x00400596]> dr
rax =0x00000064
rb r10 =0x02r13 =0x7ffe35ff6930
r14 =0x00000000
r15 =0x00000000
rsi =0x7ffe35ff6938
rdi =0x00000064
rsp =0x7bpffe35brff /6838 =<0x7ffe35ff6850
rip =0x00400596
rflags =0x00000202
orax =0xffffffffffffffff
[0x00400596]>
Descompilador
Ser capaz de comprender el ensamblaje es un requisito previo para el análisis binario. El lenguaje ensamblador siempre está vinculado a la arquitectura en la que se basa el binario y se supone que debe ejecutarse. Nunca hay un mapeo 1:1 entre una línea de código fuente y el código ensamblador. A menudo, una sola línea de código fuente C produce varias líneas de ensamblaje. Por lo tanto, leer código ensamblador línea por línea no es óptimo.
Aquí es donde entran los descompiladores. Intentan reconstruir el posible código fuente basándose en las instrucciones de montaje. Esto NUNCA es exactamente el mismo que el código fuente usado para crear el binario; es una representación cercana de la fuente basada en el ensamblaje. Además, tenga en cuenta que las optimizaciones del compilador que generan diferentes códigos ensambladores para acelerar las cosas, reducir el tamaño de un binario, etc., dificultarán el trabajo del decompilador. Además, los autores de malware a menudo ofuscan deliberadamente el código para desanimar a un analista de malware.
Radare2 proporciona descompiladores a través de complementos. Puede instalar cualquier descompilador compatible con Radare2. Ver complementos actuales con r2pm -l dominio. Instale una muestra r2dec decompilador con r2pm install comando:
$ r2pm -l
$
$ r2pm install r2dec
Clonación en 'r2dec'...
remoto:Enumeración de objetos:100, listo.
remoto :Recuento de objetos:100 % (100/100), listo.
remoto:Compresión de objetos:100 % (97/97), terminado.
remoto:Total 100 (delta 18), reutilizado 27 (delta 1), pack-reused 0
Recepción de objetos:100 % (100/100), 1,01 MiB | 1,31 MiB/s, listo.
Resolviendo deltas:100 % (18/18), listo.
Instalar Listo para r2dec
gmake:Ingresando al directorio '/root/.local/share/radare2 /r2pm/git/r2dec/p'
[CC] duktape/duktape.o
[CC] duktape/duk_console.o
[CC] core_pdd.o
[CC] core_pdd.so
gmake:Dejando el directorio '/root/.local/share/radare2/r2pm/git/r2dec/p'
$
$ r2pm -l
r2dec
$
Vista del descompilador
Para descompilar un binario, cárguelo en r2 y analícelo automáticamente. Vaya a la función de interés (sumador en este ejemplo) usando el s sym.adder comando, luego use el pdda comando para ver el ensamblado y el código fuente descompilado uno al lado del otro. Leer este código fuente descompilado suele ser más fácil que leer ensamblado línea por línea:
$ r2 -A ./adder
[x] Analiza todos los indicadores que comienzan con sym. and entry0 (aa)
[x] Analizar llamadas a funciones (aac)
[x] Analizar len bytes de instrucciones para referencias (aar)
[x] Verificar vtables
[ x] Escriba el análisis de coincidencia para todas las funciones (aaft)
[x] Propague la información sin retorno
[x] Utilice -AA o aaaa para realizar análisis experimentales adicionales.
-- ¿Qué desea depurar hoy?
[0x004004b0]>
[0x004004b0]> s sym.adder
[0x00400596]>
[0x00400596]> s
0x400596
[ 0x00400596]>
[0x00400596]> pdda
; montaje | /* salida de pseudocódigo r2dec */
| /* ./sumador @ 0x400596 */
| #incluir
|
; (fcn) sym.adder () | sumador int32_t (int64_t arg1) {
| int64_t var_4h;
| rdi =arg1;
0x00400596 empujar rbp |
0x00400597 mov rbp, rsp |
0x0040059a mov dword [rbp - 4], edi | *((rbp - 4)) =edi;
0x0040059d mov eax, dword [rbp - 4] | eax =*((rbp - 4));
0x004005a0 add eax, 1 | eax++;
0x004005a3 pop rbp |
0x004005a4 ret | volver eax;
| }
[0x00400596]>
Configurar ajustes
A medida que se sienta más cómodo con Radare2, querrá cambiar su configuración para ajustarlo a su forma de trabajar. Puede ver las configuraciones predeterminadas de r2 usando el e dominio. Para establecer una configuración específica, agregue config = value después de la e comando:
[0x004005a5]> y | wc -l
593
[0x004005a5]> e | sintaxis grep
asm.syntax =intel
[0x004005a5]>
[0x004005a5]> e asm.syntax =att
[0x004005a5]>
[0x004005a5]> e | sintaxis grep
asm.syntax =att
[0x004005a5]>
Para hacer que los cambios de configuración sean permanentes, colóquelos en un archivo de inicio llamado .radare2rc que r2 lee al inicio. Este archivo generalmente se encuentra en su directorio de inicio; si no, puedes crear uno. Algunas opciones de configuración de muestra incluyen:
$ cat ~/.radare2rc
e asm.syntax =att
e scr.utf8 =true
eco solarized
e cmd.stack =true
e pila.tamaño =256
$
Explorar más
Ha visto suficientes funciones de Radare2 para orientarse en la herramienta. Debido a que Radare2 sigue la filosofía de Unix, aunque puede hacer varias cosas desde su consola, utiliza un conjunto separado de archivos binarios debajo para realizar sus tareas.
Explore los archivos binarios independientes que se enumeran a continuación para ver cómo funcionan. Por ejemplo, la información binaria que se ve en la consola con el iI El comando también se puede encontrar usando rabin2 <binary> comando:
$ cd bin/
$
$ ls
prefijo r2agent r2pm rabin2 radiff2 ragg2 rarun2 rasm2
r2 r2-indent r2r radare2 rafind2 rahash2 rasign2 rax2
$
¿Qué opinas sobre Radare2? Comparta sus comentarios en los comentarios.