Académique Documents
Professionnel Documents
Culture Documents
Tabla de contenido
Introducción 1.1
Introducción 1.2
1.2.3
1.2.8
1.2.9
1.2.10
1.3
Colores 1.3.1
1.4.7
1.4.8
1.4.9
1.4.10
1.4.11
1.5
2
Desmontaje visual visual 1.5.1
1.6
1.6.7
firmas 1.7
1.9
Macros 1.9.1
bucles 1.9.2
R2pipe 1.9.3
Rabin2 1.10
1.10.4
1.10.7
Radiff2 1.11
Rasm2 1.12
montar 1.12.1
Desmontar 1.12.2
3
Análisis 1.13
Ragg2 1.14
Rahash2 1.15
depurador 1.16
Empezando 1.16.1
1.16.3
plugins 1.18
Plugins 1.18.1
Crackmes 1.19
IOLI 1.19.1
Avatao 1.19.2
R3v3rs3 4 1.19.2.1
.Introducción 1.19.2.1.1
.radare2 1.19.2.1.2
. principal 1.19.2.1.4
. vmloop 1.19.2.1.5
. outro 1.19.2.1.8
4
Introducción
R2 "libro"
En línea: http://radare.gitbooks.io/radare2book/content/
PDF: https://www.gitbook.com/download/pdf/book/radare/radare2book
Epub: https://www.gitbook.com/download/epub/book/radare/radare2book
mobi: https://www.gitbook.com/download/mobi/book/radare/radare2book
Autores y Colaboradores
El libro radare2
originales:
aoighost Anton
Kochkov
Austin Hartzheim
David Tomaschik
DZ_ruyk
hdznrrd grigory
Rechistov
Jeffrey John
Crowell
jvoisin Juez
Dredd
Kevin Grandemange
muzlightbeer Peter C
sghctoma SkUaTeR
TDKPS Thanat0s
5
Introducción
Nibble (puerto w32 depurador, syscallproxying, puntos de interrupción HW ..) chicos nopcode (por
trabajo principal) ora8 (vamos a PWN los tapones!) 48bits (mantener el buen trabajo) Gerardo
(ideas y consejos para el libro) POF (por el tutorial crackme y consejos de usabilidad) Esteve (motor
de búsqueda + un poco de materia gráfica código) venganza (OSX + depurador trabajo mach0) Lia
(LUF 4teh :)
6
Introducción
Introducción
Este libro pretende cubrir la mayoría de los aspectos de uso de radare2. Un marco para los binarios de ingeniería
y análisis inversa.
- - Pancake
7
Historia
Historia
El proyecto radare comenzó en febrero de 2006 para proporcionar un editor hexadecimal de línea de comandos sencillo y gratuito con
soporte para las compensaciones de 64 bits. La intención era utilizar la herramienta para realizar búsquedas y ayudar a recuperar datos
de-discos duros.
Desde entonces, el proyecto ha evolucionado para proporcionar un marco completo para analizar los binarios, mientras que haciendo uso
de conceptos básicos * NIX. Estos conceptos incluyen el famoso "todo es un archivo", "pequeños programas que interactúan utilizando
stdin / stdout" y "mantenerlo simple" paradigmas. Es sobre todo un proyecto de una sola persona. Sin embargo, las ideas y contribuciones
El eje central de este proyecto es el editor hexadecimal. Además, este proyecto contiene un ensamblador / desensamblador,
código / análisis de datos y gráficas, herramientas de scripting características, fácil integración de Unix, y más.
8
Visión de conjunto
Visión de conjunto
El proyecto Radare2 es un conjunto de pequeñas utilidades de línea de comandos que se pueden utilizar juntos o independientemente.
radare2
El núcleo del editor hexadecimal y depurador. radare2 le permite abrir un número de fuentes de entrada / salida, como si fueran
simples, archivos planos, incluyendo discos, conexiones de red, controladores del núcleo, procesos bajo la depuración, y así
sucesivamente.
Implementa una interfaz de línea de comandos avanzados para moverse alrededor de un archivo, análisis de datos, desmontaje,
parchear binarios, comparación de datos, buscar, reemplazar, visualizando. Puede ser escrito con una variedad de idiomas,
rabin2
Un programa para extraer información de binarios ejecutables, tales como ELF, PE, Java CLASS, y Mach-O. rabin2 es utilizado por el
núcleo para obtener símbolos exportados, importaciones, de información de archivos, referencias cruzadas (refx), dependencias de
rasm2
Un ensamblador de línea de comandos y desensamblador para múltiples arquitecturas (incluyendo Intel x86 y x86-64,
Ejemplos
rahash2
9
Visión de conjunto
Una implementación de una herramienta de hash basado en bloques. Desde pequeñas cadenas de texto a discos grandes, rahash2
soporta múltiples algoritmos, incluyendo MD4, MD5, CRC16, CRC32, SHA1, SHA256, SHA384, SHA512, par, xor, xorpair, mod255,
hamdist, o entropía. rahash2 se puede utilizar para comprobar la integridad de, o seguir los cambios, archivos grandes, volcados de
memoria, y discos.
Ejemplos
$ archivo rahash2
radiff2
Una utilidad diffing binario que implementa múltiples algoritmos. Es compatible a nivel de byte o delta diffing para archivos binarios, y diffin
código-análisis para encontrar cambios en los bloques de código básicas obtenidas a partir del análisis de código radare, o desde el análisis
rafind2
ragg2
Un frontend para r_egg. ragg2 compila los programas escritos en un simple lenguaje de alto nivel en pequeños binarios para
Ejemplos
10
Visión de conjunto
$ Hi.r gato
$ Hi.c gato
(0); }
$ Ragg2 hi.c $
./hi.c.bin Hola
rarun2
Un lanzador para ejecutar programas dentro de los diferentes entornos, con diferentes argumentos, permisos, directorios
Crackmes suites
de prueba
Fuzzing
$ Foo.rr2 gato
# = Chroot.
. /foo.rr2
11
Visión de conjunto
$ Nc -l 9999
1 - abrir una nueva terminal y el tipo 'TTY' para obtener un nombre de terminal:
rax2
Un evaluador expresión matemática minimalista para la carcasa que es útil para hacer las conversiones de base entre los valores de
punto, representaciones hexadecimales, cuerdas hexpair a ASCII, octal a número entero, etc. flotante También es compatible con la
configuración de endianness y se puede utilizar como un shell interactivo si no hay argumentos son dados.
Ejemplos
$ 01.111.001 y rax2 -b
$ Rax2 -S radare2
72616461726532
12
Visión de conjunto
13
radare2 conseguir
radare2 conseguir
https://github.com/radare/radare2 .
Los paquetes binarios están disponibles para un número de sistemas operativos (Ubuntu, Maemo, Gentoo, de Windows,
iPhone, etc.). Sin embargo, está muy aconsejable para obtener el código fuente y compilarlo usted mismo para entender mejor
las dependencias, para hacer ejemplos más accesible y, por supuesto, tener la versión más reciente.
Una nueva versión estable se publica normalmente cada mes. bolas de alquitrán todas las noches a veces están disponibles en http://bin.rada.re
El repositorio de desarrollo radare es a menudo más estables que los comunicados de 'estables'. Para obtener la última versión:
Esto probablemente tomará un tiempo, por lo que tomar un café y seguir leyendo este libro. Para actualizar su copia local
$ Git pull
Si tiene modificaciones locales de la fuente, puede volver ellos (y perder ellos!) Con:
La forma más común de adquirir R2 actualiza y el sistema instalado ancha es mediante el uso de:
$ Sys / install.sh
scripts de ayuda
14
radare2 conseguir
Echar un vistazo a las sys / * guiones, éstos se utilizan para automatizar cosas relacionadas con la sincronización, construcción e instalación de R2 y
sus fijaciones.
La más importante es sys / install.sh. Que se tire, limpio, construir y sistema de r2 symstall amplia. Symstalling es el proceso de la
instalación de todos los programas, bibliotecas, documentación y archivos de datos utilizando los enlaces simbólicos en lugar de copiar los
archivos.
Por defecto se instalará en / usr, pero se puede definir un nuevo prefijo como argumento. Esto es útil para los
desarrolladores, ya que les permite ejecutar sólo 'hacer' y probar los cambios sin tener que ejecutar make install de nuevo.
Limpiando
La limpieza de la estructura de directorios es importante para evitar problemas como el que une a los viejos archivos de objetos o no actualización de los
$ git pull
Si desea quitar las instalaciones anteriores de su sistema, debe ejecutar los siguientes comandos:
15
Compilación y Portabilidad
Compilación y Portabilidad
Actualmente el núcleo de radare2 puede compilarse en muchos sistemas y arquitecturas, pero el desarrollo principal se realiza
en GNU / Linux con GCC, y en MacOS X con sonido metálico. Radare también se conoce para compilar en muchos sistemas
Las personas a menudo quieren utilizar radare como un depurador para la ingeniería inversa. Actualmente, la capa
depurador se puede utilizar en Windows, GNU / Linux (Intel x86 y x86_64, MIPS y ARM), FreeBSD, NetBSD, y OpenBSD
En comparación con núcleo, la característica de depurador es la portabilidad a gota más restrictivo. Si el depurador no ha
sido portado a la plataforma favorita, puede desactivar la capa depurador con el -sin-depurador
configuraropción de escritura
al compilar radare2.
Observe que hay E / S conector que utilice el BGF, GDB remoto, o el vino como back-ends, y por lo tanto dependen de la presencia de
herramientas de terceros correspondiente. Para construir un sistema que utiliza ACR / gmake (por ejemplo, en sistemas * BSD):
$ Sys / install.sh
Construir estática
Usted puede construir de forma estática radare2 y todas las herramientas con el comando:
$ Sys / static.sh
Estibador
Radare2 barcos repositorio una Dockerfile que se puede utilizar con estibador. Este dockerfile también es utilizado por la
dieciséis
Compilación y Portabilidad
17
Compilación en Windows
Compilación en Windows
Meson (MSVC)
ADVERTENCIA: Esta construcción no está siendo probado por el momento. Tenga en cuenta que no se compila cada plugins
disponibles en radare2 todavía. Referirse a mingw32 construir abajo por la acumulación más estable y completa.
La forma más nativa para compilar radare2 bajo Windows es utilizar mesón + msvc. Lo primero que necesita python3 para
ser instalado en su ordenador. Una vez hecho esto, se puede instalar el sistema de acumulación usando mesón
PIP3 instalar
mesón.Ahora vaya a la carpeta de instalación de Python, y copiar elde . \Guiones subcarpeta en la carpeta radare2. Mesón
meson.py
compilar
Utilizando Ninja sistema de construcción: Esta es la más fácil, sólo tiene que ejecutar
y esperar hasta que la compilación
meson.bat
está terminada. Utilizando Estudio visual: Si desea trabajar en radare2 en Visual Studio, simplemente puede ejecutar el
comandomeson.bat -plo que generará un proyecto de Visual Studio 2015. A continuación, puede cargarlo desde
construir \ radare2.sln.
En cualquier caso, todo lo que se genera en el carpeta por defecto, excepto para el proceso de generación de archivos SDB.
construir
Instalación
Ahora que se ha compilado con éxito radare2, es posible que desee para recoger cada ejecutables y los requisitos en el
18
Compilación en Windows
mingw32
La manera fácil de recopilar cosas para Windows está utilizando Mingw32. El w32 construye distribuido desde la página principal radare se
genera a partir de una caja de GNU / Linux usando Mingw32 y se prueban con el vino. También hay que tener en cuenta, que Mingw-W64 no se
ha probado, por lo que no hay garantías aquí. Asegúrese de configurar su Mingw32 a compilar con modelo de hilo: Win32, no POSIX, y el obje
debe ser mingw32. Antes de la puesta en marcha de la compilación de lo necesario para la instalación por primera git, para ir a buscar una
El siguiente es un ejemplo de compilar con MinGW32 (es necesario tener instalado cremallera para ventanas):
hacer w32dist
Esto genera una aplicación de consola nativa de 32 bits para Windows. El compilador 'i486-mingw32-gcc' es el que
tengo en mi caja, es probable que necesite cambiar esto. Para simplificar la construcción bajo Windows / Mingw32
Simplemente
sys / mingw32.bat. ejecutarlo desde el cmd.exe (o ConEmu / cmd.exe). Se supone que se ha instalado en
Por favor, tenga en cuenta, que este script se debe ejecutar desde el directorio radare2. Hay un script que automatiza el proceso de detección de
la cadena de herramientas de configuración compilador cruzado, y construye un archivo zip que contiene los programas y librerías r2 que se
19
Compilación en Windows
sys / mingw32.sh
Cygwin
Cygwin es otra posibilidad; Sin embargo, las cuestiones relacionadas con las bibliotecas de Cygwin pueden hacer la depuración difícil.
Pero el uso binario compilado para Cygwin le permitirá utilizar Unicode en la consola de Windows, y para tener 256 colores.
Nota, Cygwin acumulación requiere exactamente la configuración opuesta GIT, por lo que la instalación por primera git, para ir a buscar una
Por favor, asegúrese de construir radare2 desde el mismo entorno que va a utilizar en r2 Si se va a usar r2 con cáscara
MinGW32 o cmd.exe -. R2 se debe construir en el entorno MinGW32. Y si se va a utilizar R2 en Cygwin - usted tiene
que construir r2 desde el shell de Cygwin. Desde Cygwin es más compatible con UNIX que MinGW, la radare2 es
Mingw-W64
Cierre MSYS2, ejecutarlo de nuevo desde el menú Inicio y actualizar el resto con
pacman -Su
20
Compilación en Windows
Compilar el radare2:
encuadernaciones
Para construir enlaces de radare2, tendrá que instalar Vala (valac) para Windows
hacer
make install
Después de que ha instalado valabind, se puede construir radare2-fijaciones, por ejemplo para Python y Perl:
make install
21
Banderas de línea de comandos
$ Radare2 -h
Uso: r2 [-dDwntLqv] [parche -P] [-p prj] [-a arco] [bits de -b] [-i archivo] [-s addr] [-B blocksize] [-c cmd] [-ek = v] archivo | -
Abrir un archivo en modo de escritura sin necesidad de analizar los encabezados de formato de archivo. archivo
$ r2 -nw
22
Banderas de línea de comandos
$ R2 -a -b 32 ppc ls.fat
$ R2 -i patch.r2 target.bin
Depurar un programa:
$ Ls -d r2
prueba $ r2 -p
23
Uso básico
La curva de aprendizaje para radare suele ser algo empinada al principio. Aunque después de una hora de su utilización, usted
debe entender fácilmente cómo funcionan la mayoría de las cosas, y cómo combinar varias herramientas radare ofertas, se le
anima a leer el resto de este libro para entender cómo funcionan algunas cosas no triviales, y para mejorar en última instancia su
competencias con radare. Navegación, inspección y modificación de un archivo binario cargado se realiza mediante tres acciones
simples: buscar (la posición), impresión (buffer), y se alternan (escribir, agregar). El comando 'buscar' se sabrevia
y acepta
como
basados en bloques, es posible que prefiera para establecer el tamaño de bloque a un valor requerido
segundo con
mando, y buscar hacia adelante o hacia atrás con posiciones alineadas a la misma.
s ++Utilizar
y s--
Si R2 se abre un archivo ejecutable, por defecto se abrirá el archivo en modo de VA y las secciones se va a proyectar a sus direcciones
virtuales. En el modo de VA, la búsqueda se basa en la dirección virtual y la posición de inicio se establece en el punto de entrada del
ejecutable. Utilizandonorte
- opción que puede suprimir este comportamiento por defecto y pedir r2 para abrir el archivo en modo no-VA
para usted. En el modo no-VA, la búsqueda se basa en el desplazamiento desde el principio del archivo. El comando 'imprimir' se
abrevia como
pag y tiene un número de sub-modos - la segunda carta que especifica un modo de impresión deseado. variantes incluyen
Ejemplos:
> wx 90 90 90 90 ; hexpairs
navegar hjkl (izquierda, abajo, arriba, ya la derecha, respectivamente). Puede utilizar estas teclas en el modo de cursor
do llave.
quitarse
Para o
su selección. Mientras
24
Uso básico
25
Formato de los comandos
Los comandos se identifican por un solo caso sensible carácter [a-zA-Z]. Repetir la ejecución de un comando,
px # ejecutar px
Los ! prefijo se utiliza para ejecutar un comando en contexto shell. Si se utiliza un único signo de exclamación, los comandos se
enviarán al gancho sistema () definido en cargado actualmente plugin de I / O. Esto se utiliza, por ejemplo, por el ptrace / plugin
O, que acepta comandos del depurador de interfaz radare. Unos pocos ejemplos:
pd 2000 | eax grep ; grep códigos de operación que utilizan el 'EAX' registrarse
Los @ carácter se utiliza para especificar un desplazamiento temporal en el que se ejecutará el comando a su izquierda. a
la dirección 0x100000fce. el ~ carácter permite la función grep-como interno utilizado para filtrar la salida de cualquier comando. Por
ejemplo:
26
Formato de los comandos
O incluso combinarlos:
Esta función grep interna es una característica clave para radare secuencias de comandos, ya que puede ser utilizado para iterar sobre una
lista de desplazamientos o datos generados por desensamblador, oscila, o cualquier otro comando. Consulte la sección de macros
(iteradores) para obtener más información. La mayoría de los comandos ofrecen apoyo terminación automática
TAB>usando
clave, por
<
ejemplos eek oF desfases comandos. Ofrece terminación automática usando los todos los valores posibles, teniendo flagnames en este caso.
! ~ ...comando - que ofrece un modo visual para desplazarse por el historial de comandos radare2.
27
expresiones
expresiones
Las expresiones son representaciones matemáticas de los valores numéricos de 64 bits. Se pueden mostrar en diferentes
formatos, se comparan o se utilizan con todos los comandos que aceptan argumentos numéricos. Las expresiones pueden utilizar
operaciones aritméticas tradicionales, así como unos binarios y booleanos. Para evaluar expresiones matemáticas añada las rutas
[0xB7F9D810]>? 0x8048000
134512640 01001100000 0x8048000 128.0M 804000: 0000 134512640 00000000 134512640,0 0.00 0000
[0xB7F9D810]>? 0x8048000 + 34
134512674 01001100042 0x8048022 128.0M 804000: 0022 134512674 00100010 134512674,0 0.00 0000
134512692 01001100064 0x8048034 128.0M 804000: 0034 134512692 00110100 134512692,0 0.00 0000
[0xB7F9D810]>? 1 + 2 + 3-4 * 3
+ : adición
- : la resta
* : Multiplicación /:
división%: módulo
> : Desplazamiento
El uso de lógica o debería ser escapó el uso de citas, o será confundido con un tubo de opeator:
: decimal
28
expresiones
También puede utilizar variables y buscar posiciones para construir expresiones complejas. Los valores disponibles son:
? @? o escriba @@? ; ayuda misceláneos '@' (buscar), '~' (grep) (ver ~ ??)
$m ; opcode referencia de memoria (por ejemplo, mov eax, [0x10] => 0x10)
[0x4A13B8C0]>? + $ L $ m
0x4a13c000
29
Rax2
Rax2
los rax2 utilidad viene con el marco radare y pretende ser un evaluador de expresión minimalista para la cáscara. Es útil para
hacer las conversiones de base entre los valores de punto, representaciones hexadecimales, cuerdas hexpair flotante para
ascii, octal a entero. Es compatible con endianness y se puede utilizar como una cáscara si no se dan argumentos.
$ Rax2 -h
- mi codificar base64 ;
- v versión ; rax2 -v
30
Rax2
Algunos ejemplos:
$ Rax2 -s 4142 AB
$ Rax2 -S AB 4142
$ Rax2 -S <bin.foo
. . .
$ Rax2 -e 33
0x21000000
$ Rax2 -e 0x21000000 33
$ Rax2 -K 90203010
|.... |
| o |
| . |
| S |
| |
| |
| |
| |
+ -- - - - - - - - - - - - - - - - +
31
Sesión básica depurador
$ Pidof MC 32220
$ R2 -d 32220
$ R2 -d / bin / ls
principios de
ld.so enlazador dinámico. Por lo tanto, no esperar ver un punto de entrada o bibliotecas compartidas en este punto. Puede
anular este comportamiento estableciendo otro nombre para la entrada y punto de interrupción. Para ello, agregue un comando
malicioso u otros programas complicados en realidad puede ejecutar código antesy por lo tanto no podrás controlarlos.
principal()
A continuación se muestra una lista de los comandos más comunes utilizados con depurador:
> dmp A S rwx; cambiar de página en página con permisos de protección de tamaño S
Tal vez un método más sencillo de usar depurador en radare es para cambiar al modo visual. De esa manera usted no tendrá que recordar
muchos comandos ni para mantener el estado del programa en su mente. Para entrar en el modoV:visual el uso
[0xB7F0C8C0]> V
La vista inicial después de entrar en el modo visual es una vista hexdump de contador de programa objetivo actual (por
32
Sesión básica depurador
modos. Uso F7 os para entrar en y F8Soa pasar por encima de la instrucción actual. Con
do el
clave que puede cambiar el modo de cursor para marcar una selección de rangos de bytes (por ejemplo, para sobrescribir tarde con NOP).
ejemplo, para volcar un un bloque de contenido de la memoria en la ESI: x @ ESI Para obtener ayuda sobre el modo visual, pulse? . Para
desplazarse por la pantalla de ayuda, utilizar las flechas. Para salir de la vista de ayuda,
q. pulse
33
Contribuyendo a radare2
contribuyendo
Radare2 libro
Si quieres contribuir al libro Radare2, puede hacerlo en el repositorio de Github . contribuciones sugeridas
incluyen:
relatos CTF
Por favor, obtener el permiso para el puerto cualquier contenido que no es dueño / no creó antes de colocarlo en el libro Radare2.
34
Configuración
Configuración
su gusto.
realiza con la
eval comandos. Un archivo de configuración inicial típica es el siguiente:
e dbg.bep = cargador
de la línea de comandos, manteniendo el archivo .radare2rc intacta. Por ejemplo, para comenzar con la configuración vacía y luego
Internamente, la configuración se almacena en una tabla hash. Las variables se agrupan en espacios cfg.
de ,nombres: y
archivo. , Dbg. , Scr.
así. Para obtener una lista de todas las variables de configuración sólo tiene que
mi en
escribir
la línea de comandos. Para limitar la
mostrará todas las variables definidas en el interior del espacio de nombres "archivo". Para
er [clave] establecer clave de configuración como de sólo lectura. sin vuelta atrás
CE [k] [color] conjunto de colores para la clave dada (pronta, offset, ...) e una
35
Configuración
ve así:
eval espacios:
dbg cmd fs
hex http
gráfico
HUD scr
búsqueda
io
Para los valores de configuración que pueden tomar uno de varios valores, puede utilizar los =? operador para obtener una lista de valores
válidos:
36
Colores
Colores
acceso a la consola está envuelto en API que permite mostrar la salida de cualquier comando como ANSI, consola w32 o formatos
HTML (más por venir: ncurses, Pango, etc.) Esto permite que el núcleo de radare para ejecutar entornos interiores con capacidades que
muestran limitadas, como granos o incrustado dispositivos. Todavía es posible recibir los datos de ella en su formato favorito. Para
habilitar el soporte de colores por defecto, añadir una opción de configuración correspondiente al archivo de configuración .radare2:
Es posible configurar el color de casi cualquier elemento de salida de desmontaje. Para los terminales * NIX, R2 acepta especificación de color en
37
Colores
tema xvilka
38
Colores
39
Variables de configuración común
A continuación se muestra una lista de las variables de configuración de uso más frecuente. Puede obtener una lista completa mediante la
emisiónmi comando sin argumentos. Por ejemplo, para ver todas las variables definidas en el "cfg" espacio de nombres,
e cfg. (mente
temael punto
final). Usted puede obtener ayuda en cualquier variable de configuración mediante el ¿mi?
uso cfg.
de eval
asm.arch
Puede encontrar la lista de posible valor observando el resultado de =?o rasm2 -L.Es muy sencillo añadir nuevas
e asm.arch
arquitecturas para el desmontaje y el análisis de código. Existe una interfaz para eso. Para x86, que se utiliza para unir
una serie de motores de desensamblador de terceros, incluyendo GNU binutils, Udis86 y algunos de los hechos a mano.
asm.bits
Determina anchura en bits de los registros para la arquitectura actual. Los valores admitidos: 8, 16, 32, 64. Nótese que no todos arquitecturas de
asm.syntax
Los cambios de sabor sintaxis para desensamblador entre Intel y AT & T. Por el momento, este ajuste afecta Udis86
y att.
asm.pseudo
Un valor booleano para elegir un motor de cadena de desmontaje. "Falso" indica un nativo, definido por la arquitectura actual,
asm.os
Selecciona un sistema operativo de destino de binario cargado actualmente. Por lo general, OS detecta automáticamente
Rabin-ri.Todavía,
asm.os se puede utilizar para cambiar a una mesa diferente syscall empleado por otro sistema operativo.
40
Variables de configuración común
asm.flags
asm.lines.call
cambios de flujo de control (saltos y llamadas) que están dirigidos dentro del bloque actual. Ver también
asm.linesout.
asm.linesout
Cuando se define como "verdadero", la vista desmontaje también dibujar líneas de flujo de control que van del ouside del bloque.
asm.linestyle
Un valor booleano que cambia la dirección de análisis de flujo de control. Si se establece en "false", se realiza de arriba hacia abajo
de un bloque; de lo contrario, va de abajo hacia arriba. El ajuste de "falsa" parece ser una mejor opción para mejorar la legibilidad,
asm.offset
valor booleano que controla la visibilidad de las compensaciones para las instrucciones individuales desmontadas.
asm.trace
Un valor booleano que controla la visualización de la información de seguimiento (número de secuencia y el contador) a la izquierda de cada
asm.bytes
Un valor booleano se utiliza para mostrar u ocultar la visualización de bytes sin formato de instrucciones.
cfg.bigendian
Cambiar orden de bits. "Verdadero" significa big endian, "falso" es para ascendente hacia la izquierda. "File.id" y "file.flag" tanto para ser
verdad.
41
Variables de configuración común
scr.color
scr.seek
Esta variable acepta una expresión, un puntero (por ejemplo. EIP), etc. Si se establece, radare fijará buscar la posición de su valor en
el arranque.
cfg.fortunes
Activa o desactiva los mensajes de "Fortune" que se muestran en cada radare comienzan.
42
Los comandos básicos
La mayoría de los nombres de comandos en radare se derivan de nombres de acción. Deben ser fáciles de recordar, si son cortas.
En realidad, todos los comandos son letras individuales. Subcomandos o comandos relacionados se especifican utilizando el
El formato general para un comando válido (como se explica en el capítulo 'Formato de los comandos') es el siguiente:
[[] [Veces] [cmd] [~ grep] [@ [@ iter] addr tamaño] [|> tubería].!; ...
Por ejemplo,
Si un comando comienza con =! , El resto de la cadena se pasa a cargado actualmente IO complemento (un depurador, por ejemplo). La
$ R2 -d / bin / ls
Si un comandos comienza con! , Posix_system () es llamado para pasar el comando a su concha. Compruebe!? para más
El significado de los argumentos (iter, addr, tamaño) depende del comando específico. Como regla general, la mayoría de los comandos
tienen un número como argumento para especificar el número de bytes a trabajar, en lugar de tamaño de bloque definido actualmente.
43
Los comandos básicos
Los @ signo se utiliza para especificar una ubicación de desplazamiento temporal o buscar la posición en la que se ejecuta el
comando, en lugar de buscar la posición actual. Esto es muy útil ya que no tiene que buscar alrededor todo el tiempo.
Utilizando @@ puede ejecutar un solo comando en una lista de banderas que coinciden con el pegote. Se puede pensar en esto como una
operación foreach:
> s0
los > operación se utiliza para redirigir la salida de un comando en un archivo (sobrescribir si ya existe).
> PR> dump.bin; volcar bytes 'en bruto' del bloque actual a archivo llamado 'dump.bin'
el | operación (tubería) es similar a lo que estás acostumbrado a esperar de él en una cáscara * NIX: US salida de un comando
Puede pasar varios comandos en una sola línea separándolos con punto y coma; :
> px; Dr
44
buscando
buscando
compuesto por las operaciones de cambio, operaciones matemáticas básicas, o las operaciones de acceso a memoria.
s- deshacer buscar
s+ rehacer buscar
PC sr solicitar el registro
Si desea examinar el resultado de una expresión matemática, se puede evaluar utilizando el? mando. Basta con
pasar la expresión como argumento. El resultado se puede visualizar en formato hexadecimal, decimal, octal o
binario.
a la siguiente ubicación.
Abrir documento
45
buscando
Como archivo de prueba permite utilizar algunos hello_world.c sencilla compilado en formato ELF Linux. Después hemos compilado que permite
hola_mundo r2
[0x00400410]>
Todos los comandos que buscan que tienen direcciones en parámetros de comando se puede utilizar cualquier base, tal como / octal / binario hexadecimal
o decimal.
[0x00400410]> s 0x0
[0x00000000]>
0x0 [0x00000000]> s
[0x00000000]>
[0x00000000]> s + 128
[0x00000080]>
[0x00000080]> s
[0x00000000]> s
[0x00400410]>
0x00400410.
estamos de vuelta en
46
buscando
Vamos a buscar en el archivo ELF hola_mundo 'Hola'. Después de la búsqueda nuestra posición se fijará en la posición de la
[0x00400410]> s / hola
[0x00400410]> s * f undo_3 @
0x400411
0x4005b4
47
Tamaño de bloque
Tamaño de bloque
El tamaño del bloque determina cuántos bytes comandos Radare procesarán cuando no se le da un argumento tamaño explícito.
Puede cambiar temporalmente el tamaño de bloque especificando un argumento numérico a los comandos de impresión. Por
ejemplo20 px.
| b EIP + 4 argumento numérico puede ser una expresión | establecer bf foo tamaño de
; ... = 0x110
los bf comando se utiliza para cambiar el tamaño de bloque de valor especificado por una bandera. Por ejemplo, en símbolos,
. . .
48
secciones
secciones
imágenes de firmware, gestores de arranque y los archivos binarios suelen colocar varias secciones de un archivo binario en diferentes
[0xB7EE8810]> S?
secciones de la lista
vaddr)
| Sa [-] [A] [B] [[off]] Especificar arco y los bits de sección dada
| S off va SZ nombre vsz mrwx añadir nueva sección (si (vsz) vsz = SZ!) | S- [id]
Por ejemplo:
49
secciones
# Lista de secciones
[0x00404888]> S
[00]. 0x00000238 -r-- va = 0x00400238 sz = 0x0000001c vsz = 0000001c .interp [01]. 0x00000254 -r-- va = 0x00400254 sz = 0x00000020 vsz =
00000020 .note.ABI_tag [02]. 0x00000274 -r-- va = 0x00400274 sz = 0x00000024 vsz = 00000024 .note.gnu.build_id [03]. 0x00000298 -r-- va =
0x00400298 sz = 0x00000068 vsz = 00000068 .gnu.hash [04]. 0x00000300 -r-- va = 0x00400300 sz = 0x00000c18 vsz = 00000c18 .dynsym
. . .
[0xB7EEA810]> S =
. . .
.shstrtab 27 * 0x00000000 | ############################## | 0x0001ae08 -rwx EHDR => 0x00004888 | ----- ^ ------------------------ |
0x00004988
Las tres primeras líneas son secciones y el último (el prefijo => ) Es la ubicación de búsqueda actual.
[0xB7EE8810]> S-4
50
archivos de asignación
archivos de asignación
sistema IO Radare permite asignar contenido de los archivos en el mismo espacio IO utilizado para contener binario cargado. Los
nuevos contenidos se pueden colocar en desplazamientos aleatorios. Esto le permite crear un entorno estático, que emulan la vista
que tendría cuando se utiliza un depurador, donde el programa y todas sus bibliotecas se cargan en la memoria y se puede acceder.
Utilizando elS ( secciones) comando se puede definir la dirección base para cada biblioteca se va a cargar.
[0x00000000]> O?
| [?] Ob [lbdos] [...] lista de archivos binarios abierta respaldada por fd | oc [Archivo]
| O- cierre todos los archivos, análisis, BINFILES, banderas, igual que r2! -
51
archivos de asignación
Vinculados] libselinux.so.1
4 bibliotecas
Convertir un archivo:
[0x00000000]> o
- 6 / bin / ls @ 0x0; r
- 10 /lib/ld-linux.so.2 @ 0x100000000; r
[0x00000000]> px @ 0x499999
[0x00000000]> O-14
52
Modos de impresión
Modos de impresión
Una de las características clave de radare está mostrando la información en muchos formatos. El objetivo es ofrecer una selección de opciones de
visualización para interpretar mejor los datos binarios. Los datos binarios pueden ser representados como enteros, pantalones cortos, largos,
flotadores, marcas de tiempo, cuerdas hexpair, o formatos más complejos como estructuras C, listados de desmontaje, decompilations, ser el
[0x08049AD0]> p?
| p = [BEP] [] [BLKS len] [B] Mostrar entropía / chars imprimibles / chars bares [?] | p2 [len]
8x8 2bpp-azulejos
| pd [?] [sz] [a] [b] desmontar N códigos de operación (PD) o N bytes (PD)
| PF [?] [. nam] [fmt] datos de impresión con formato (pf.name, pf.name $ <expr>)
| p [II] [DF] [len] impresión N ops / bytes (f = func) (véase pi? y PDI)
| pr [?] [GLX] [len] impresión N bytes primas (en líneas o hexblocks, 'g'unzip)
Consejo: cuando se utiliza la salida JSON, puede anexar el ~ {} al comando para obtener una versión prettyprinted de la
salida:
53
Modos de impresión
[0x00000000]> DO
[{ "Elevado": false, "fd": 563280, "URI": "malloc: // 512", "de": 0 "puede escribir": true, "tamaño": 512, "solapamientos": false} ] [0x00000000]> DO ~} {[
563280,
false}]
Para más información sobre los poderes mágicos de ~ consulte la ayuda en? @? Y el capítulo "Formato de los comandos", anteriormente en el
libro.
Ver hexadecimal
px da una salida fácil de usar que muestra 16 pares de números por fila con desplazamientos y representaciones primas:
[0x00404888]> px
- compensado - 0 1 2 3 4 5 6 7 8 9 ABCDEF 0123456789ABCDEF 0x00404888 31ed 4989 d15e 4889 E248 83e4 F050
5449 1.I .. ^ H..H ... PTI 0x00404898 c7c0 4024 4100 2341 0048 48c7 c1b0 c7c7 .. @ $ AH AH. 0x004048a8 D028 4000 e83f
[0x00404888]> PXW
0x00404888 0x8949ed31 0x89485ed1 0xe48348e2 0x495450f0 1.I .. ^ H..H ... PTI 0x00404898 0x2440c0c7 0xc7480041
0x4123b0c1 0xc7c74800 .. @ $ AH .. # AH. 0x004048a8 0x004028d0 0xffdc3fe8 0x9066f4ff 0x1f0f2e66. (@ ..? .... y ss ..
[0x00404888]> PXW
0x00404888 0x31ed4989 0xd15e4889 0xe24883e4 0xf0505449 1.I .. ^ H..H ... PTI 0x00404898 0xc7c04024 0x410048c7
0xc1b02341 0x0048c7c7 .. @ $ AH .. # AH. 0x004048a8 0xd0284000 0xe83fdcff 0xfff46690 0x662e0f1f. (@ ..? .... y ss ..
54
Modos de impresión
[0x00404888]> p8 16
31ed4989d15e4889e24883e4f0505449
[0x08049A80]> PXQ
. . .
Dn] | pt
Por ejemplo, se puede 'ver' el búfer en uso como marcas de tiempo en el momento NTFS:
Como se puede ver, el orden de bits afecta el resultado. Una vez que haya impreso un sello de tiempo, puede grep de salida, por
16:15:43 +0000
El formato de fecha por defecto se puede configurar mediante elvariable. Reglas de formato para que siga el (3) formato
cfg.datefmt
55
Modos de impresión
% A El nombre abreviado del día de la semana según la localización actual. % A El nombre completo del día de la semana según la localización
actual. % B El nombre abreviado meses de acuerdo con la localización actual. % B El nombre completo del mes de acuerdo a la localización
actual. % C La fecha preferida y la representación de tiempo para la localización actual. % C El número siglo (año / 100) como un número entero
de 2 dígitos. (SU)% d El día del mes como un número decimal (rango 01 a 31).
% D Equivalente a% y% m /% d /. (Yecch-sólo para norteamericanos. Norteamericanos deben darse cuenta de que en otros países% d /% m /% y es
bastante común. Esto significa que en el contexto internacional t su formato es ambiguo y no debe ser utilizado.) (SU)
% e igual% d, el día del mes como un número decimal, pero un cero inicial se reemplaza por un espacio. (SU)
Modificador% E: utilizar un formato alternativo, ver más abajo. (SU)% F Equivalente a% Y-% m-% d (el
% G El ISO 8601 basada en la semana del año (ver notas) con siglo como número decimal. El año de 4 dígitos correspondiente al número de semanas ISO
(ver% V). Esto tiene el mismo formato de un valor de D como% Y, excepto que si el número de semana ISO pertenece al año anterior o siguiente
% G Como% G, pero sin siglo, es decir, con un año de 2 dígitos (00-99). (TZ)% h Equivalente a% b. (SU)
% H La hora como un número decimal usando un reloj de 24 horas (rango 00 a 23). % I La hora como un número decimal usando
un reloj de 12 horas (rango 01 a 12). % J El día del año como un número decimal (rango 001 a 366).
% K La hora (reloj de 24 horas) como un número decimal (rango de 0 a 23); solo dígito son pr eceded por un espacio en blanco. (Véase también el% H.)
(TZ)
% L La (reloj de 12 horas) horas como un número decimal (rango 1 a 12); solo dígito son pr eceded por un espacio en blanco. (Ver también% I.) (TZ)% m El
mes como un número decimal (rango 01 a 12). % M El minuto como un número decimal (rango 00 a 59). % N Un carácter de nueva línea. (SU)
% P O "AM" o "PM", según el valor de tiempo dado, o la cadena correspondiente s de la localización actual. Mediodía es tratado como "PM" y medianoche
como "AM". % P Como% p pero en minúsculas: "am" o "pm" o una cadena correspondiente para la l OCALE actual. (ÑU)
% R El tiempo en notación am o pm. En la configuración regional POSIX esto es equivalente a% I:% M:% S% p. (SU)
% R La hora en notación de 24 horas (% H:% M). (SU) Para una versión que incluye los segundos, s ee% T a continuación.
% S El número de segundos desde la Época, 1970-01-01 00:00:00 0000 (UTC). (TZ)% S El segundo como un número decimal (rango de 00 a 60). (El
alcance es de hasta 60 para permitir segundos bisiestos ocasionales.)% T Un carácter de tabulación. (SU)
% U El día de la semana como un decimal, rango de 1 a 7, siendo 1 el Lunes Véase también% w. (SU
% T El número de semana del año actual como un número decimal, rango de 00 a 53, comenzando con el primer domingo como el primer día de la semana
01. Véase también% V y W%. % V El número de semana ISO 8601 (ver Notas) del año actual como un número decimal, sonó E01 a 53, donde la semana 1
es la primera semana que tiene al menos 4 días en el nuevo año. Ver también% U y W%. (U)
56
Modos de impresión
% W El número de semana del año actual como un número decimal, rango de 00 a 53, comenzando con el primer lunes como el primer día de la semana
01.
% X La representación fecha preferida para la localización actual sin el tiempo. % X La representación de tiempo preferido para la localización
actual sin la fecha. % Y El año como un número decimal sin un siglo (rango 00 a 99). % Y El año como un número decimal incluyendo el siglo.
% Z La + hhmm o -hhmm zona horaria numérico (es decir, la hora y el minuto desplazamiento desde UTC)
. (SU)
% + La fecha y la hora en la fecha (1) formato. (TZ) (No se admite en glibc2.) %% un carácter literal '%'.
Tipos basicos
Hay modos de impresión disponibles para todos los tipos básicos. Si usted está interesado en una estructura más PF
compleja,
?? para tipo
[0x00499999]> PF ??
| PF: pf [.k [.f [= v]] | [v]] | [n] | [0 | cnt] [fmt] [a0 a1 ...] | Formato: | segundo
| re desensamblar un opcode
| norte siguiente Char especifica el tamaño de valor con signo (1, 2, 4 o 8 byte (s))
| norte siguiente Char especifica el tamaño de valor sin signo (1, 2, 4 o 8 byte (s))
|z \ 0 cadena terminada
|: omitir 4 bytes
|. saltar 1 byte
57
Modos de impresión
[0x00499999]> PF ???
| PF: pf [.k [.f [= v]] | [v]] | [n] | [0 | cnt] [fmt] [a0 a1 ...] | Ejemplos:
| PF barra 3xi foo 3-array de struct, cada uno con fiel llamado
| pf.obj xxdz anterior siguiente nombre de tamaño Definir el formato obj como xxdz
| PF IWQ foo bar trol Imprimir el formato IWQ con foo, bar, tro
ll como los nombres respectivos de los campos | PF 0iwq foo bar trol
t (BiFC)
RRay de 7 enteros
| ? PF ic i ... foo bar "(PF XW yo foo) troll" yo Imprimir anidado structres anónimos | pfn2
[0x4A13B8C0]> pf i 0x00404888 =
837634441
[0x4A13B8C0]> PF
0x00404888 = 837634432,000000
formatos de códigos de impresión válido para los idiomas legible por humanos son:
58
Modos de impresión
C
ordenador personal
PCs de
JSON
pitón
[0xB7F8E810]> PC 32
# definir _BUFFER_SIZE 32
0x89, 0xE0, 0xe8, 0x49, 0x02, 0x00, 0x00, 0x89, 0xc7, 0xe8, 0xE2, 0xff, 0xff, 0xff, 0x
81, 0xC3, 0xd6, 0xA7, 0x01, 0x00, 0x8B, 0x83, 0x00, 0xff, 0xff, 0xff, 0x5A, 0x8d, 0x24
[0x7fcd6a891630]> PC
"\ X48 \ x89 \ XE7 \ XE8 \ x68 \ x39 \ x00 \ x00 \ x49 \ x89 \ XC4 \ X8b \ x05 \ XEF \ x16 \ x22 \ x00 \ X5a \ x48 \ x8d \ x24 \ XC4 \ x29 \ xc2 \ x52 \ x48 \ x89 \
xd6 \ x49 \ x89 \ xe5 \ x48 \ x83 \ xe4 \ xf0 \ x48 \ X8b \ X3D \ x06 \ X1A
Instrumentos de cuerda
Las cadenas son probablemente uno de los puntos de entrada más importantes al comenzar a realizar ingeniería inversa de un programa, ya que
suelen hacer referencia a la información sobre las acciones de funciones (afirma, los mensajes de depuración o de información ...) Por lo tanto
[0x00000000]> ps?
impresión PS
JSON
La mayoría de las cadenas están terminados en cero. He aquí un ejemplo utilizando el depurador para continuar la ejecución de un programa
hasta que se ejecuta la llamada al sistema 'abierto'. Cuando recuperamos el control sobre el proceso, se obtienen los argumentos que se pasan a
59
Modos de impresión
la llamada 'abierta', que es una cadena terminada en cero, lo que podemos inspeccionar
PSZ. el uso
[0x4A13B8C0]>
Esto puede ser utilizado para mirar a los argumentos que se pasan a una función. Para lograr esto, basta con pasar una 'secuencia en la
nombre para cada campo de la estructura añadiéndolos como una lista de argumentos separados por espacios.
puntero:
0x00404890 = 0x48e2}
60
Modos de impresión
sym.gst_plugin_desc
[0x000185E0]> PF iissxsssss Mayor Menor versión _init nombre desc \ fuente de origen del paquete de licencia
0x000185e4 = 10
http://www.fluendo.com
desmontaje
los pd comando se utiliza para desmontar código. Se acepta un valor numérico para especificar el número de instrucciones que
determinado de bytes.
bsize bytes
[0x00404888]> pd 1
; - Entry0: 0x00404888
61
Modos de impresión
[0xB7F08810]> e = asm.arch?
ad 32 bf LGPL3 Brainfuck
Hay varias opciones que se pueden utilizar para configurar la salida de desensamblador. Todas estas opciones se
describen en
¿mi? asm.
62
Modos de impresión
asm.os: Seleccionar sistema operativo (kernel) (Linux, Darwin, w32, ..) asm.bytes: Muestra los bytes de cada
asm.cmtright: Mostrar comentarios derecha de desmontaje si encajan en asm.comments pantalla: Mostrar los comentarios en vista
de desmontaje
mnemotécnica
l nombre de desmontaje
asm.lines: Si las líneas del arte ASCII muestran permitido en asm.linescall desmontaje: habilitar líneas
de llamada
asm.linesright: Si muestran líneas habilitadas antes de código de operación en lugar de asm.linesstyle offset: Si iterate
permitido a la lista de saltos hacia atrás asm.lineswide: Si está habilitado poner un espacio entre las líneas
asm.middle: Permitir que desmontar saltos en medio de una instrucción asm.offset: Mostrar compensatorias especiales en
asm.profile: desensamblador de configuración (por defecto, simple, gas, inteligente, depuración, lleno
asm.nbytes: Número de bytes para cada código de operación en asm.bytespace desmontaje: bytes
desmontaje de sintaxis
los asm.syntaxvariable se utiliza para cambiar el sabor de la sintaxis de montaje utilizado por un motor de
att
63
Modos de impresión
que da salida a ESIL ( 'evaluable Cuerdas intermedate Idioma'). El objetivo de ESIL es tener una representación legible de
cada código de operación semántica. Tales representaciones pueden ser evaluados (interpretado) para emular efectos de
instrucciones individuales.
64
banderas
banderas
Las banderas son conceptualmente similares a los marcadores. Se asocian un nombre con un offset dado en un archivo. Las banderas pueden ser
agrupados en 'espacios bandera'. Un espacio bandera es un espacio de nombres para banderas, la agrupación de banderas de características o tipo
Se puede quitar una bandera añadiendo el - carácter de comando. La mayoría de los comandos aceptan
[0x4A13B8C0]> f-flag_name
[0x4A13B8C0]> fs
00 símbolos
importaciones 01 02 03
Secciones 04 cuerdas,
reglas 05 mapas
[0x4A13B8C0]> símbolos fs; seleccionar sólo las banderas de símbolos flagspace [0x4A13B8C0]> f
[0x4A13B8C0]> f myflag; crear un nuevo indicador denominado 'myflag' [0x4A13B8C0]> f-myflag; eliminar la
sesenta y cinco
Escribir
Radare puede manipular un archivo binario cargado de muchas maneras. Puede cambiar el tamaño del archivo, mover y bytes de copiar /
pegar, insertar nuevos bytes (cambiantes datos al final del bloque o archivo), o simplemente sobrescribir bytes. Los nuevos datos se pueden
dar como widestring, como instrucciones de ensamblador, o los datos pueden ser leídos desde otro archivo. Cambiar el tamaño del archivo
mediante el
r mando. Se acepta un argumento numérico. Un valor positivo establece un nuevo tamaño para el archivo. Un punto negativo
66
Escribir
[0x00404888]> w?
| w6 [de] base64 / hex escribir base64 [d] ecoded o [e] cadena ncoded
| wa [?] ebp empuje escribir código de operación, separados por ';' (Uso '"' alrededor del comando)
| WAO [?] op modificar código de operación (cambiar condicional de salto. nop, etc)
| wc [?] [IR *?] escribir deshacer caché / commit / reset / lista (io.cache)
| wd [off] [n] duplicar N bytes desde el desplazamiento actual en buscar (memcpy) (ver y?)
| nos [nNsxX] [arg] extender las operaciones de escritura (inserte en lugar de reemplazar) [?] | WF - | archivo
| wm F0FF establecer binario hexpair máscara para ser utilizado como máscara de escritura cíclica
| [?] En peso [f] presentar [sz] escribir en el archivo (de la corriente de buscar, de bloque o SZ bytes) | WTS host: puerto [SZ] enviar datos al host
escribir amplia cadena 'f \ x00o \ x00o \ x00b \ x00a \ x00r \ x00'
| wx [?] [FS] 9090 escribir dos NOP Intel (desde wxfile o wxseek)
Algunos ejemplos:
Durante escribir
los wo comando (escribir sobre) tiene muchas subcomandos, cada uno combina los datos existentes con los nuevos datos
utilizando un operador. El comando se aplica al bloque actual. operadores compatibles incluyen: XOR, ADD, SUB ...
67
Escribir
[0x4A13B8C0]> wo?
| wox 0x0203; act bloque XOR con 0203 | WOA 02 03; añadir [0203] [0203] [...] a
curblk | ay 02 03
| operaciones soportadas:
| wow == escritura bucle valor (alias 'wb') | WOA + = Además | WOS - = resta | WOM *
[0x7fcd6a891630]> px
- compensar - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
0x7fcd6a891630 4889 e7e8 6839 0000 4989 1622 c48b 05ef H ... h9..I ......" 0x7fcd6a891640 005a 488d 24C4 29c2 5248 89d6 4989
E548 .ZH. $.). RH..I..H F048 0x7fcd6a891650 83e4 8b3d 061A 498D 2200 4cd5 1049 ... H. = .. ". IL.I 0x7fcd6a891660 8d55 0831
[0x7fcd6a891630]> wox 90
[0x7fcd6a891630]> px
- compensar - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
0x7fcd6a891630 d819 d919 7778 541B 90ca d81d c2d8 1946 ..wx..T ........ F 0x7fcd6a891640 1374 60d8 B290 d91d 1dc5 98a1 9090
d81d .t` ............. 0x7fcd6a891650 90DC 197c 9f8f 1490 95d9 d81d 9f8f 1490 ... | ............ 0x7fcd6a891660 13d7 9491 9f8f 1490 13ss
[0x7fcd6a891630]> WOA 01 02
[0x7fcd6a891630]> px
- compensar - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
0x7fcd6a891630 d91b 787a 91cc d91f 1476 61da 1ec7 99a3 ..xz ..... ..... va 0x7fcd6a891640 91de 1a7e d91f 96dB 14d9 9593 1401
9593 ... ~ ............ 0x7fcd6a891650 c4da D959 E89A 1a6d 9192 9159 1cb1 D959 ... m ... Y ... Y ... Y 0x7fcd6a891660 9192 79cb
68
Escribir
69
Enfocar
Enfocar
El zoom es un modo de impresión que le permite obtener una visión global de todo el archivo o un mapa de memoria en una sola
pantalla. En este modo, cada byte representa bytes del archivo. Utilizarpzel
file_size / block_size de comandos, o uso justo
Z en el modo
visual para cambiar el modo de zoom. El cursor se puede utilizar para desplazarse más rápido a través de la Alejar vista.
[0x004048c5]> pz?
dirección final
70
Enfocar
0x00000000 7f00 0000 e200 0000 146e 6f74 0300 0000 ......... .... no 0x00000010 0000 0000 0068 2102 2024 00ff e8f0 007a
..... h! ... $ ... z 0x00000020 8c00 18c2 ffff 0080 4421 1500 41c4 5dff ........ D! Un ...]. 0x00000030 FF10 0018 0fc8 031A 000C
8484 E970 8648 ............. pH 0x00000040 d68b 3148 348b 03a0 8b0f c200 5D25 7074 ..1H4 .......]% pt 0x00000050 7500
pz // o pzp
0x00000000 2f47 0609 070A 0917 1e9e a4bd 2a1b 2c27 /G..........*.,' 0x00000010 322d 5671 8788 8182 5679 7568 82a2
7d89 2-Vq .... Vyuh ..}. 0x00000020 8173 7f7b 727a 9588 a07b 5c7d 8daf 836d .s. {Rz ... {\} ... m 0x00000030 b167 6192
a67d 8aa2 6246 856e 8c9b 999f .ga .. ..} bF.n .... 0x00000040 A774 96c3 b1a4 6c8e a07c 6a8f 8983 6a62 .t .... l .. | j ... jb
0x00000050 7d66 625F 7ea4 7ea6 b4b6 8b57 a19f 71a2} FB_ ~ ~ .... W..q..
Pzf
0x00406e65 48d0 80f9 360f 8745 ffff ffeb ae66 0f1f H ... 6..E ..... f .. 0x00406e75 4400 0083 F801 0f85 3FFF ffff 410f B600 D
.......? ... Una ... 0x00406e85 3c78 0f87 6301 0000 0fb6 c8ff 24cd 0026 <X..C ....... .. $ 4100 y 0x00406e95 660F 1f84 0000
0000 0084 C074 043c Af ......... t. <0x00406ea5 3a75 18b8 0500 0000 83f8 060f 95c0 e9cd: u .............. 0x00406eb5 feff FF0F
1f84 0000 0000 0041 8801 4983 ........... A..I. 0x00406ec5 C001 4983 C201 4983 C101 e9ec feff FF0F ..I ... me .........
pO // o Pzf
0x00000000 0000 0000 0000 0000 0000 0000 0000 0000 0000 ................ 0x00000010 2b5c 5757 3a14 331f 1b23 0315 1d18
+ .. \ WW: 0,3 .. # .... 0x00000020 222a 2330 2b31 2e2a 1714 200d 1512 383D "* # 0 + 1. * .. ... 8 = 0x00000030 1E1A 181b
0a10 1a21 2a36 281E 1d1c 0e11 .......! * 6 (..... 0x00000040 1B2a 2F22 2229 181e 231E 181c 1913 262b. * / "") .. # ..... y +
0x00000050 apartado 2B30 4741 422f 382a 1e22 0f17 0f10 3913 + 0GAB / 8 *. ".... 9.
Puede limitar el zoom a una serie de bytes en lugar de toda la bytespace. Cambio
71
Enfocar
72
Yank / Pegar
Yank / Pegar
interfaz de línea de comandos. Estos comandos operan en un buffer interno que almacena copias de bytes tomadas a partir
de la corriente buscan posición. Puede escribir este buffer que desea buscar la posición utilizandoyydiferentes
mando:
[0x00000000]> y?
| yf 64 0x200 copia de archivo de 64 bytes a partir de 0x200 de archivo (se abre w / io), utilice -1 para todos en tes
| copia de archivos YFA copiar todos los bytes a partir del archivo (se abre w / io)
sesión de ejemplo:
Puede realizar un tirón y pegar en una sola línea sólo por el uso
yt comando
de la (yank-a). La sintaxis es la siguiente:
[0x4A13B8C0]> x
c7e8 e2ff ... 9 ........ 0x4A13B8CC, ffff 81c3 eea6 0100 8b83 08ff ......... ... 0x4A13B8D8, ffff 5a8d
2484 29c2
. . Z. $.).
[0x4A13B8C0]> x
c7e8 e2ff ... 9 ........ 0x4A13B8CC, 89e0 E839 0700 08ff 0089 8b83 ... 9 ..... ... 0x4A13B8D8, ffff
. . Z. $.).
73
Yank / Pegar
74
comparando Bytes
comparando Bytes
c( abreviatura de "comparar") le permite comparar las matrices de bytes de diferentes fuentes. El comando acepta la entrada en
una serie de formatos, y luego se la compara con los valores que se encuentran en la posición actual buscar.
[0x00404888]> c?
| cuerda C] Comparación de una llanura con una cuerda caracteres escapado (r2 comandos de salida)
| ccc [a] [(a)] Igual que el anterior, pero sólo muestran líneas diferentes
| cu [?] [dir] @at Comparar hexdumps memoria de $$ y el horario de verano en diff unificado
Para comparar los contenidos de la memoria en la posición de búsqueda actual contra dada cadena de valores, el uso
cx:
[0x08048000]> p8 4 7f 45 4c 46
iguales
Otra de subcomando
do comando es
cc que significa "comparar el código". Para comparar una secuencia de bytes con una
secuencia en la memoria:
75
comparando Bytes
c8 compara una palabra cuádruple de la corriente buscan (en el ejemplo de abajo, 0x00000000) en contra de una expresión
matemática:
[0x00000000]> c8 4
0x00000000 (byte = 01) 7f '' -> 04 '' 0x00000001 (byte = 02) 45 'E' -> 00 ''
El parámetro número puede por supuesto también ser una de las expresiones matemáticas que utiliza nombres bandera etc:
[0x00000000]> cx 7f469046
0x00000001 (byte = 02) 45 'E' -> 46 'F' 0x00000002 (byte = 03) 4c 'L' -> 90
''
Puede utilizar el comando comparar para encontrar diferencias entre un bloque actual y un archivo previamente descargado en
un disco:
bytes iguales
76
SDB
SDB
** k
k anal / **
k*
anal k / *
k foo = bar
foo k
consultas útiles
k syscall / * ~ ^ 0x
77
SDB
78
modo visual
Modo visual
El modo visual es un fácil de usar interfaz alternativa más al indicador de línea de comandos de radare2. Utiliza las teclas de flecha
para hjkl o moverse de datos y código, tiene un modo de cursor para seleccionar bytes, y ofrece numerosas combinaciones de teclas
El modo Visual utiliza "modos de impresión", que son básicamente diferente del panel que se puede girar. Por defecto estos son:
↻ Panel hexdump -> panel de desmontaje → Panel depurador → palabras hexadecimales de volteo del panel → He
Observe que la parte superior del panel contiene el comando que se utiliza, por ejemplo, para el desmontaje del panel:
79
modo visual
Obteniendo ayuda
Para ver ayuda en todas las combinaciones de teclas definidas para el modo visual, pulse? :
ps asm.pseudo de palanca
[1-9] seguir JMP / llamada identificada por acceso directo (similares; [1])
(A) código
Automóvil club británico ssemble, visual (A) ssembler
O de palanca asm.esil
r actualización de la pantalla / en modo de cursor navegar por los comentarios // buscar información y comunicación anal
80
modo visual
xX Mostrar referencias externas / árbitros de la función actual desde / a los datos / código
F2 F4 punto de interrupción de
solo F8 paso
paso sobre F9
continuar,
81
visual Desmontaje
Navegación visual
Desmontaje
Desplazarse dentro del desmontaje usando
flechaso hjkl. Utilizaro a buscar directamente a una bandera o una compensación, escribirla cuando sea
númerode su teclado0-9]
[ y el número a la derecha en el desmontaje de seguir una llamada o un salto. En este ejemplo la
tipificación
1 en el teclado seguiría a la llamada a
y por
libc_start_main sym.imp .__ lo tanto, buscar en el desplazamiento de este símbolo.
re como definir
re se puede utilizar para cambiar el tipo de datos del bloque actual, varios tipos básicos / estructuras están
d → ...
d→b
d→d
0x004048f7 48c1 e83f 4801 C648 d1fe 7415 B800 0000 H ..? H..H..t .....
. . .
Para mejorar la legibilidad del código puede cambiar la forma radare2 presenta valores numéricos en el desmontaje, por defecto la
mayoría de desmontaje valor numérico pantalla como hexadecimal. Puede ser que desee para visualizarla como un decimal, binario o
incluso personalizado definido constante. Para cambiar el formato de valor que puede
re seguido
usar poryo a continuación, elija lo que
82
visual Desmontaje
d → → i ... 0x004048f7
d → i → 10 0x004048f7
d → i → 2 0x004048f7
Recuerde que, para ser capaz de editar archivos cargados en realidad radare2, usted tiene que comenzar
w opción.
conDe
el lo
-
El cursor se utiliza para seleccionar un rango de bytes o simplemente para que apunte a un byte. Puede utilizar el cursor para crear una bandera
con nombre en la ubicación specifc. Para ello, busque en la posición requerida, a continuación,
F e introduzca
pulse un nombre para una bandera. Si
w bandera o el
O + de comandos, también puede utilizar el cursor para sobrescribir un rango seleccionado con nuevos valores. Para ello,
datos. Los datos se repiten según sea necesario para llenar el rango seleccionado. Por ejemplo:
Los 10 bytes que ha seleccionado se cambiará a "12 34 12 34 12 ...". El Visual ensamblador es una característica que proporciona
una vista previa en vivo mientras se escribe en las nuevas instrucciones para parchear en el desmontaje. Para usarlo, solicitar o
colocar el cursor en la posición deseada y pulsa la tecla 'A'. Para proporcionar múltiples instrucciones, separar con punto y coma,
;.
83
visual Desmontaje
REFX
Cuando radare2 ha descubierto un XREF durante el análisis, se le mostrará la información en el Visual Desmontaje
utilizandoREFX etiqueta:
Añadir un comentario
Buscar
el HUDS
El "Userfriendly HUD"
El "Userfriendly HUD" se puede acceder mediante el ?? combinación de teclas. Este HUD actúa como una hoja de trucos interactiva
que se puede utilizar para encontrar más fácilmente y ejecutar comandos. Este HUD es particularmente útil para los recién llegados.
Para los usuarios experimentados, el otro HUDS que son más actividad específica puede ser más útil.
84
visual Desmontaje
Este HUD se puede visualizar mediante el _ clave, se muestra una lista de todas las opciones definidas y le permite saltar a ellos.
Utilizando el teclado se puede filtrar rápidamente la lista a una bandera que contiene un patrón específico.
Ajustar el desmontaje
look-and-feel del desmontaje se controla mediante las teclas de configuración. * "asm, que se pueden cambiar
mi mando.
mediante el
Todas las claves de configuración también se pueden editar a través del editor de configuración visual.
configuración del radare2 fácilmente. Por ejemplo, si desea cambiar algo en la pantalla desmontaje,
asmseleccione
de la
85
visual Desmontaje
86
visual Desmontaje
87
visual Desmontaje
Los siguientes son algunos ejemplos de variables eval relacionados con el desmontaje.
Ejemplos
88
visual Desmontaje
e asm.arch = Dalvik
; [0]
e asm.bits = 16
Esta última operación también se puede hacer uso de & en el modo visual.
e asm.pseudo = true
e asm.syntax = att
89
visual Desmontaje
e asm.describe = true
siva o
om src a dst
om src a dst
90
visual ensamblador
visual ensamblador
por unaJMP:
91
visual ensamblador
Recuerde que parchear los archivos en modo de depuración único parche no la memoria del archivo.
92
Editor de configuración visual
ve o mi en el modo visual le permite editar la configuración radare2 visualmente. Por ejemplo, si desea cambiar la visualización del
93
Editor de configuración visual
94
Editor de configuración visual
95
bytes búsqueda
La búsqueda de Bytes
El motor de búsqueda radare2 se basa en el trabajo realizado por Esteve, además de múltiples características implementadas en la parte superior
de la misma. Es compatible con múltiples búsquedas por palabra clave, máscaras binarias y valores hexadecimales. Se crea automáticamente
[0x00000000]> /?
| Uso: / [arg] Buscar cosas [AMX /] (ver 'e ?? búsqueda' para las opciones) | / Foo \ x00
| / H [t] [picadillo] [len] encontrar bloque coincidente este hash. Ver /#? | / A eax JMP
| archivo / f [OFF] [SZ] búsqueda contenido del fichero de tamaño y desplazamiento | / I foo
Porque todo se trata como un archivo en radare2, no importa si desea buscar en un zócalo, un dispositivo remoto, en el
96
bytes búsqueda
97
Búsquedas básicas
Búsqueda básica
Una búsqueda básica para una cadena de texto sin formato en un archivo sería algo así como:
Como puede verse en la salida anterior, radare2 genera una bandera "hit" para cada entrada encontrada. A continuación,
PDpuede utilizar la
comando para ver las cadenas almacenadas en las compensaciones marcados por las banderas de este grupo, Athey ll haves nombres
de la forma
hit0_ <índice>:
[0x00404888]> / ls
. . .
Puede buscar cadenas de todo el carbón de leña (por ejemplo, cartas Unicode) utilizando
w mando:
el /
Para realizar una búsqueda sensible a las mayúsculas para el uso de cadenas
yo : /
[0x0040488f]> / i Stallman
Busca 8 bytes de 0x00400238 a 0x0040488f: 53 74 61 6c 6c 6d 61 6e [#] muestras: 004 138 <0x0040488f golpea = 0
Es posible especificar secuencias de escape hexadecimales en la cadena de búsqueda anteponiendo con "\ x":
[0x00000000]> / \ x7FELF
98
Búsquedas básicas
Pero, si usted está en busca de una cadena de valores hexadecimales, usted es probablemente mejor de
x mando:
utilizar el /
[0x00000000]> / x 7F454C46
Una vez que la búsqueda se hace, los resultados se almacenan en el espacio de bandera.
búsquedas
[0x00000000]> fs 0
0. instrumentos de cuerda
1 0. símbolos
2 6. búsquedas
Para extraer un "éxito" banderas después de que no los necesita más, golpe
utilizar
f- *mando.
el A menudo, durante las
largas sesiones de búsqueda, tendrá que lanzar la última búsqueda más de una vez. Puede utilizar la // comando para
99
Configurando la búsqueda
El motor de búsqueda radare2 se puede configurar a través de varias variables de configuración, modificable con
el mi mando.
e search.in = [foo]; buscar límite de alcance. Los valores admitidos: crudo, bloque, archivo, secció n
e search.align = 4 ; Mostrar sólo los resultados de búsqueda alineados por el límite especificado.
e search.asmstr = 0; buscar cadena en lugar de e search.flags montaje = true; si está activado, crear banderas
en éxitos
los search.alignvariable se utiliza para limitar válidos resultados de búsqueda a cierta alineación. Por ejemplo, con= verá
e search.align 4 sólo los
toques que se encuentran en las compensaciones de 4 bytes alineados. los variable booleana indica al motor de búsqueda a los
search.flags
resultados de bandera para que puedan ser referenciados más adelante. Si una búsqueda actualmente en ejecución se interrumpe
Ctrl-C secuencia
con
100
patrón de búsqueda
Los / pag comando le permite aplicar las búsquedas de patrones repetidos en IO almacenamiento de back-end. Es posible
identificar secuencias de bytes repetidos sin especificar explícitamente. El único parámetro de comando establece patrón de
[0x00000000]> / p 10
Esta salida del comando se mostrará diferentes patrones que se encuentran y cuántas veces cada uno de ellos se encuentra.
101
Automatización
Buscar Automatización
los cmd.hitvariables eval se utiliza para definir un comando radare2 a ser ejecutado cuando una entrada coincidente, apreciada
por el motor de búsqueda. Si desea ejecutar varios comandos, separarlos con; . Alternativamente, se puede organizar en una
31ed4989d15e4889
102
Buscar hacia atrás
103
Buscar en la Asamblea
ensamblador Buscar
El comando un
/ jmp eaxmonta una cadena de código de máquina y, a continuación, busca los bytes resultantes:
104
La búsqueda de AES Keys
Gracias a Victor Muñoz, radare2 ahora cuenta con el apoyo del algoritmo que desarrolló, capaz de encontrar claves AES
expandidas conCalifornia
/ mando. Se busca a partir de búsqueda actual posición hasta la límite, o hasta que se
search.distance
[0x00000000]> / Ca 0 claves
AES encontrado
105
firmas
Radare2 tiene su propio formato de las firmas, lo que permite tanto la carga / aplicar y crear sobre la marcha. Están
disponibles bajo la
z comando de espacio de nombres:
[0x000100b0]> z?
Mostrar zignatures
Para cargar el archivo de la firma creada tiene que cargar desde un archivo usando
zo comandos
SDB o desde el archivo
Para crear la firma que necesita para hacer la función en primer lugar, a continuación, se puede crear a partir de la función:
r2 / bin / ls
[0x000051c0]> aaa # esto crea funciones, entre ellas 'Entry0' [0x000051c0]> ZAF Entry0 entrada [0x000051c0]>
z de entrada:
. . . . . . . f4
0x000051c0 [0x000051c0]>
106
firmas
[0x000051c0]> zj ~} {[
"Name": "entrada",
"grafico": {
"1"},
"Compensación": 20928
"árbitros": []}]
[0x000051c0]>
comandos usando SDB Entonces podemos aplicarlas. Vamos a abrir un archivo nuevo:
myentry zos.
r2 / bin / ls
. . . . . . . f4
0x000051c0 [0x000051c0]>
coincidentes:
[0x000051c0]> ZC
función resultados: 1
[0x000051c0]>
todos los que tenemos que hacer una cosa poco diferente. No es un momento importante, sin embargo, si lo ejecutas "tal cual" - no lo puedo
encontrar nada:
107
firmas
[0x000051c0]> z /
Hits: 0
[0x000051c0]>
Tenga en cuenta la dirección de la búsqueda - esto es porque necesitamos ajustar la búsqueda variar primero:
función resultados: 1
[0x000051c0]>
estamos actualmente en el . sección por supuesto). Ahora podemos comprobar, lo radare2 encontrado por nosotros:
texto
[0x000051c0]> pd 5
; - Entry0:
; - sign.bytes.entry_0: 0x000051c0
[0x000051c0]>
que
sign.bytes.entry_0, es exactamente el resultado de hacer coincidir la firma. configuración de firmas almacenadas
108
firmas
109
Desmontaje
Desmontaje
Desmontaje de radare es sólo una manera de representar una matriz de bytes. Se maneja como un modo de impresión
especial dentro
pag mando.
En los viejos tiempos, cuando el núcleo radare era más pequeño, el desensamblador fue manejada por un archivo de RSC externa. Es decir,
objdumpconfigurado para desmontar para Intel, ARM, etc ... Fue una solución de trabajo, pero fue ineficaz, ya que repetía las mismas
acciones una y otra vez, porque no había cachés. Como resultado, el desplazamiento era terriblemente lento. Hoy en día, el apoyo
desensamblador es una de las características básicas de radare. Ahora cuenta con muchas opciones, incluyendo sabor arquitectura
objetivo y las variantes desensamblador, entre otras cosas. Para ver el desmontaje, pd
utilizar
mando.el Se acepta un argumento
numérico para especificar el número de códigos de operación de la secuencia actual se desea ver. La mayoría de los comandos de
radare consideran el tamaño del bloque actual como límite predeterminado para la entrada de datos. Si desea desmontar más bytes,
operación.
La sintaxis "pseudo" puede ser algo más fácil para un ser humano de entender que las anotaciones de ensamblador por defecto. Pero
puede llegar a ser molesto si usted lee un montón de código. Para jugar con él:
110
Desmontaje
111
Adición de metadatos
El trabajo típico involucrados en la reversión de los archivos binarios hace poderosos capabailities anotación esencial. Radare
ofrece varias formas de almacenar y recuperar dichos metadatos. Siguiendo los principios básicos comunes * NIX, es fácil
importarlo en radare. Por ejemplo, echar un vistazo aenviado con radare2ida . Para usarlo, invocar idc2r.py
idc2r.py como file.idc> file.r2.
Se
lee un archivo IDC exportado desde una base de datos IDA Pro y produce una secuencia de comandos R2 que contiene los
mismos comentarios, nombres de funciones, etc Usted puede importar el 'file.r2' resultante mediante el uso del punto . mando de
radare:
[0x00000000]>. file.r2
los . comando se utiliza para interpretar los comandos Radare de fuentes externas, incluyendo archivos y salida del programa. Por ejemplo,
para omitir la generación de un archivo intermedio e importar directamente la secuencia de comandos que puede utilizar esta combinación:
los do comando se utiliza para gestionar los comentarios y las conversiones de datos. Se puede definir un rango de bytes del programa debe
ser interpretado como cualquiera de código, datos binarios o cadena. También es posible ejecutar código externo en todos los puntos de la
bandera especificada con el fin de buscar un poco de metadatos, como un comentario, desde un archivo externo o base de datos. Aquí
está la ayuda:
112
Adición de metadatos
[0x00404cc0]> C?
mi
| CL [-] [*] [archivo: Línea] [dir] mostrar o añadir 'línea de código' de la información (
bininfo)
, etc ..
| CPBa [-a] | [a] [Texto] [@addr] añadir / quitar comentario en la dirección dada
[10])
| Cf [-] [SZ] [?] [0 | cnt] [fmt] [a0 a1 ...] [@addr] memoria de formato (ver PF?) | CF [SZ] [FCN-signo ..] [@addr]
firma de la función
| Cm [-] [SZ] [FMT ..] [@addr] análisis sintáctico mágica (ver pm?)
[0x00404cc0]>
[0x00000000]> pd 2
los ¿DO? familia de comandos le permite marcar un rango como una de varias clases de tipos. Tres tipos básicos son: código (desmontaje se
La anotación de los tipos de datos se realiza más fácilmente en el modo visual, utilizando la tecla "D", abreviatura de "cambiar el tipo de
datos". Para primer lugar, utilizar el cursor para seleccionar un rango de bytes
do tecla
(pulse
para cambiar el modo de cursor y utilice las
teclas hjkl para expandir la selección), luego presione 'd' para obtener un menú de posibles acciones / tipos. Por ejemplo, para marcar el
rango como una cadena, utilice la opción 's' en el menú. Se puede lograr el mismo resultado de la cáscaracsutilizando
mando: el
string_foo
113
Adición de metadatos
los cf comando se utiliza para definir una cadena de formato de memoria (la misma sintaxis utilizada por el
;-- DEP:
0x7fd9f13ae630 [0] {
= 14696}
0x7fd9f13ae638 [1] {
571,928,325}} 16
independiente del tamaño de la estructura dat definir por la cadena de formato. Esto puede parecer confuso, pero tiene varios usos.
Por ejemplo, es posible que desee ver el structue formato que se muestra en el desmontaje, pero todavía tienen visibles esos lugares
como compensaciones y con bytes sin formato. A veces, se encuentran grandes estructuras, pero únicamente se han identificado
algunos campos, o sólo está interesado en campos específicos. Entonces, se puede decir R2 para mostrar sólo los campos, usando la
cadena de formato y uso de 'saltar' campos, y también tienen el desmontaje continuar después de toda la estructura, dándole a
114
ESIL
ESIL
ESIL significa 'evaluable Cuerdas lenguaje intermedio'. Su objetivo es describir una Adelante ) -como representación semántica para
cada código de operación de la CPU de destino. representaciones esil pueden ser evaluados (interpretado) con el fin de emular las
instrucciones individuales. Cada comando de una expresión ESIL está separado por una coma. Su máquina virtual puede ser descrito
como esto:
si (word.isOperator ()) {
esil.push (palabra); }
nextCommand (); }
Como podemos ver ESIL utiliza un intérprete basado en pila similar a lo que se utiliza comúnmente para calculadoras. Tiene dos
categorías de entradas: valores y operaciones. Un valor simplemente es empujado en la pila, un operador continuación aparece
valores (sus argumentos si se quiere) de la pila, realiza su operación y empuja sus resultados (si los hay) de nuevo. Podemos
pensar en ESIL como una notación post-fix de las operaciones que queremos hacer. Así que vamos a ver un ejemplo:
¿Puedes adivinar que es esto? Si tomamos esta notación post-fix y transformar de nuevo en-fix obtenemos
esp - 4 =
operaciones comunes realizadas por las CPUs, como las operaciones aritméticas binarias, las cargas de memoria y tiendas, llamadas al sistema
de procesamiento, etc. De esta manera si podemos transformar las instrucciones para ESIL podemos ver lo que hace un programa mientras se
se está ejecutando incluso para las arquitecturas más crípticos que definitivamente no tiene un dispositivo para depurar el.
uso ESIL
115
ESIL
Hay 2 variables de entorno que son importantes para la observación de lo que hace un programa:
asm.emustr = true
"Asm.emu" dice R2 si desea información ESIL que se mostrará. Si se establece en true verá comentarios aparecen a la
derecha de su desmontaje que indican cómo los contenidos de los registros y las direcciones de memoria se cambian por
la instrucción actual. Por ejemplo, si tiene una instrucción que resta un valor de un registro que le dice lo que el valor era
antes y lo que se hace después. Esto es súper útil por lo que no tiene que sentarse allí mismo y realizar un seguimiento de
Un problema con esto es que se trata de una gran cantidad de información para tomar en una vez y, a veces simplemente no lo
necesita. R2 tiene un buen compromiso para esto. Eso es lo que la variable "asm.emustr" es para. En lugar de esta salida muy
detallado con cada valor de registro, esto sólo se suma información realmente útil a la salida, por ejemplo, cadenas que se encuentran
en las direcciones de un programa utiliza o si un salto es probable que sea tomada o no.
La tercera variable importante es "asm.esil". Esto cambia su desmontaje ya no se muestran las instrucciones
desmontadas reales, sino que ahora muestra expresiones Esil que describen lo que hace que la instrucción
correspondiente. Así que si quieres echar un vistazo a cómo se expresan en las instrucciones ESIL basta con establecer
"asm.esil" true.
Comandos Esil
[0x00000000]>
[0x00000000]> aes
[0x00000000]> 10aes
116
ESIL
[0x00000000]> AESO
[0x00000000]> 10aeso
[0x00001019]>
ESIL
Nombre Operación ejemplo
código de operación Operandos
- src)
117
ESIL
[0x00000000]> "ae
apilar = (dst> src); 1,5,> "0x1
Más grande
[0x00000000]>" ae
> src, dst (comparación
update_eflags (dst
firmado)
- src) 5,5,>"
0x0
[0x00000000]> "ae
Mayor o igual pila = (dst> = src); 1,5,> = "0x1
(comparación update_eflags (dst [0x00000000]>" ae
>= src, dst
firmado)
- src) 5,5,> ="
0x1
[0x00000000]> "ae
1,1, << "0x2
[0x00000000]>" ae
<< src, dst desviación a la izquierda pila = DST << src
2,1, <<"
0x4
[0x00000000]> "ae
1,4, >> "0x2
[0x00000000]>" ae
>> src, dst apilar
desplazamiento a la derecha = DST >> src
2,4, >>"
0x1
[0x00000000]> "ae
31,1, <<< "0x80000000
apilar = dst ROL src [0x00000000]>" ae
<<< src, dst Girar a la izquierda
32,1, <<<"
0x1
[0x00000000]> "ae
1,1, >>> "0x80000000
pila = dst ROR src [0x00000000]>" ae
>>> src, dst Gira a la derecha
32,1, >>>"
0x1
[0x00000000]> "ae
1,1, y "0x1
[0x00000000]>" ae
1,0, y "0x0
[0x00000000]>" ae
y src, dst Y apilar = dst & src
0,1, y"
0x0
118
ESIL
0,0, y"
0x0
[0x00000000]> "ae
1,1, | "0x1
[0x00000000]>" ae
1,0, | "0x1
[0x00000000]>" ae
| src, dst O apilar = DST | src
0,1, | "0x1
[0x00000000]>" ae
0,0, |"
0x0
[0x00000000]> "ae
1,1, ^ "0x0
[0x00000000]>" ae
1,0, ^ "0x1
[0x00000000]>" ae
^ src, dst XOR pila = dst ^ src
0,1, ^ "0x1
[0x00000000]>" ae
0,0, ^"
0x0
[0x00000000]> "ae
3,4, + "0x7
[0x00000000]>" ae
+ src, dst AÑADIR apilar = dst + src
5,5, +"
0xa
[0x00000000]> "ae
3,4, - "0x1
[0x00000000]>" ae
4,3, -"
0xffffffffffffffff
[0x00000000]> "ae
3,4, * "0xc
[0x00000000]>" ae
* src, dst MUL apilar = DST * src
5,5, *"
0x19
119
ESIL
2,4, / "0x2
[0x00000000]>" ae
5,9, /"
0x1
[0x00000000]> "ae
2,4,% "0x0
[0x00000000]>" ae
5,9,%"
0x4
[0x00000000]> ar r_00 = 0; ar
r_00 0x00000000
[0x00000000]> "ae r_00, ++"
0x1 [0x00000000]> ar r_00
0x00000000 [0x00000000]>
++ src Cª apilar = src ++ "ae
1, ++"
0x2
[0x00000000]> ar r_00 = 5; ar
r_00 0x00000005
[0x00000000]> "ae r_00, -" 0x4
[0x00000000]> ar r_00
0x00000005 [0x00000000]>
-- src DIC apilar = src--
"ae 5, -" 0x4 [0x00000000]> ar
r_01 = 5 ; ar r_00 = 0; ar r_00
0x00000000
120
ESIL
5, r_00, + ="[0x00000000]> ar
r_00 0x0000000a
3, r_00, - ="[0x00000000]> ar
r_00 0x00000001
[0x00000000]> ar r_01 = 3; ar
r_00 = 5; ar r_00 0x00000005
[0x00000000]> "ae r_01, r_00,
* =" [0x00000000]> ar r_00
0x0000000F [0x00000000]>
"ae
*= src, reg eq MUL reg reg = * src
2, r_00, * ="[0x00000000]> ar
r_00 0X0000001E
[0x00000000]> ar r_01 = 3; ar
r_00 = 6; ar r_00 0x00000006
[0x00000000]> "ae r_01, r_00,
/ =" [0x00000000]> ar r_00
0x00000002 [0x00000000]>
"ae
/= src, reg eq DIV reg = reg / src
1, r_00, / ="[0x00000000]> ar
r_00 0x00000002
[0x00000000]> ar r_01 = 3; ar
r_00 = 7; ar r_00 0x00000007
[0x00000000]> "ae r_01,
r_00,% =" [0x00000000]> ar
r_00 0x00000001
[0x00000000]> ar
121
ESIL
0x00000009
[0x00000000]> "ae
5, r_00,% ="[0x00000000]> ar
r_00 0x00000004
[0x00000000]> ar r_00 = 1; ar
r_01 = 1; ar r_01 0x00000001
[0x00000000]> "ae r_00, r_01,
<< =" [0x00000000]> ar r_01
0x00000002 [0x00000000]>
"ae
<< = src, reg reg
Desviación a la izquierda eq = reg << src
[0x00000000]> ar r_00 = 1; ar
r_01 = 8; ar r_01 0x00000008
[0x00000000]> "ae r_00, r_01,
>> =" [0x00000000]> ar r_01
0x00000004 [0x00000000]>
Shift derecho eq "ae
>> = src, reg reg = reg << src
[0x00000000]> ar r_00 = 2; ar
r_01 = 6; ar r_01 0x00000006
[0x00000000]> "ae r_00, r_01,
y =" [0x00000000]> ar r_01
0x00000002 [0x00000000]>
"ae
2, r_01, y = "[0x00000000]> ar
r_01 0x00000002
[0x00000000]>" ae
1, r_01, y = "[0x00000000]> ar
r_01 0x00000000
[0x00000000]> ar r_00 = 2; ar
r_01 = 1; ar r_01 0x00000001
[0x00000000]>" ae
122
ESIL
4, r_01, | ="[0x00000000]> ar
r_01 0x00000007
[0x00000000]> ar r_00 = 2; ar
r_01 = 0xab; ar r_01
0x000000ab [0x00000000]>
"ae r_00, r_01, ^ ="
[0x00000000]> ar r_01
0x000000a9 [0x00000000]>
^= src, reg eq XOR reg = reg ^ src
"ae
2, r_01, ^ ="[0x00000000]> ar
r_01 0x000000ab
[0x00000000]> ar r_00 = 4; ar
r_00 0x00000004
[0x00000000]> "ae r_00, ++ ="
++ = reg eq INC reg = reg + 1 [0x00000000]> ar r_00
0x00000005
[0x00000000]> ar r_00 = 4; ar
r_00 0x00000004
[0x00000000]> "ae r_00, - ="
-- = reg eq diciembre reg = reg - 1 [0x00000000]> ar r_00
0x00000003
[0x00000000]> ar r_00 = 4; ar
r_00 0x00000004
[0x00000000]> "! Ae r_00, ="
[0x00000000]> ar r_00
0x00000000 [0x00000000]> "!
!= reg NO eq reg =! reg Ae r_00, =" [0x00000000]> ar
r_00 0x00000001
------------------------------
--- --- --- ---
----------------
[0x00010000]> "ae
0xLOQUESEA, 0x10000, =
123
ESIL
[0x00010000]> PXW 4 @
= [] =
0x10000 0x00010000
[*] =
0xLOQUESEA ....
[1] =
src, dst meter * Dst = src [0x00010000]> "ae
[2] =
0x0,0x10000, = [4],"
[4] =
[0x00010000]> PXW 4 @
[8]
0x10000 0x00010000
0x00000000
[0x00010000]> w prueba
@ 0x10000
[] [*] [0x00010000]> "ae
[1] 0x10000, [4],"
[2] 0x74736574
src ojeada apilar = * src
[4] [0x00010000]> ar r_00 =
[8] 0x10000 [0x00010000]>
"ae r_00, [4],"
0x74736574
| = [] | =
[1] | =
[0x00000000]>
[2] | = reg nombre código
[0x00000000]>
[4] | =
[8]
Intercambiar dos
INTERCAMBIAR Intercambiar INTERCAMBIAR
elementos principales
Escoja n-ésimo
Selección
RPICK metro elemento de la base de 0, RPICK
inversa
la pila
Duplicar elemento
DUP Duplicar DUP
superior en la pila
Detiene la
DESCANSO Descanso DESCANSO
emulación ESIL
Salta a la enésima
124
ESIL
Detiene la ejecución
(razón: la expresión ESIL
QUE HACER Que hacer QUE HACER
no se ha completado)
Banderas Esil
ESIL VM tiene un banderas de estado internas que son de sólo lectura y se pueden utilizar para exportar los valores de los indicadores de CPU de
destino subyacentes. Es debido a que la ESIL VM siempre calcula los cambios de pabellón, mientras que las CPU de destino sólo se actualizan
segundo - prestado, esto requiere que se especifique de qué bit (ejemplo: $ b4 - Comprueba si bor
fila de 4) c bit
o - rebosar
pag - paridad
r - regsize (asm.bits / 8)
s - firmar
[0-9] * - Se utiliza para configurar las banderas y registros sin tener efectos secundarios,
es decir, el establecimiento de esil_cur, esil_old y esil_lastsz. (Ejemplo: "$ 0, de, =" para
Sintaxis y comandos
Un código de operación objetivo se traduce en una lista separada por comas de expresiones esil.
tamaño del operando por defecto está determinado por el tamaño de destino de la operación.
125
ESIL
Los ? operador utiliza el valor de su argumento para decidir si para calcular la expresión entre llaves.
Espacios en blanco, saltos de línea y otros caracteres se ignoran. Así que lo primero cuando se procesa un programa ESIL es
eliminar espacios:
Llamadas al sistema necesitan un tratamiento especial. Se indican con '$' al comienzo de una expresión. Puede pasar un valor numérico
opcional para especificar un número de llamada al sistema. Un emulador ESIL debe manejar llamadas al sistema. Ver (r_esil_syscall).
a, b, - b-a
a, b, / = b/=a
instrucciones especiales
PON están representados como cadenas vacías. Como se dijo anteriormente, llamadas al sistema están marcados por el comando '$'. Por ejemplo,
'0x80, $'. Se emulación de delegados de la máquina ESIL a una devolución de llamada que implementa llamadas al sistema para un OS / kernel
específica.
126
ESIL
Trampas se implementan con la < TRAPmando. Se utilizan para lanzar excepciones de instrucciones no válidas, la división
code>,
Análisis rápida
Aquí está una lista de algunas comprobaciones rápidas para recuperar información de una cadena ESIL. La información relevante se
indexOf ( "PC, =") - > modifica contador de programa (rama, salto, llamada)
indexOf ( "sp, =") - > modifica la pila (¿y si nos encontramos SP + = o = SP-?)
índice de(":") - > Esil desconocido, código de operación en bruto por delante
Compruebe dstreg
Compruebe srcreg
Obtener destinaion Es
salto es condicional
evalúa se syscall
Banderas de CPU
banderas de CPU normalmente se definen como registros de bits individuales en el perfil RREG. Ellos ya veces
Variables
1. No tienen ancho de bits predefinido. Esta forma en que debe ser fácil de extenderlas a 128, 256 y 512 bits más tarde, por
127
ESIL
3. Los nombres de Registro no tienen una sintaxis específica. Ellos son sólo cadenas.
4. Los números pueden ser especificados en cualquier base de apoyo de rnum (dec, hex, oct, binario ...)
5. Cada backend ESIL debe tener un perfil asociado RREG para describir las especificaciones de registro Esil.
Qué hacer con ellos? ¿Qué pasa con las aritméticas bits si las variables de uso en lugar de registros?
aritmética
1. ADD ( "+")
2. MUL ( "*")
3. SUB ( "-")
4. DIV ( "/")
5. MOD ( "%")
Aritmética bits
1. Y "y"
2. O "|"
3. XOR "^"
4. SHL "<<"
5. SHR ">>"
6. ROL "<<<"
7. ROR ">>>"
8. NEG "!"
QUE HACER
ESIL especifica que los comandos de control de flujo de análisis sintáctico debe estar en mayúsculas. Tenga en cuenta que algunas arquitecturas
tienen nombres de registro en mayúsculas. El perfil de registro correspondiente debe tener cuidado de no volver a utilizar cualquiera de los siguientes:
128
ESIL
Ejemplo de uso:
CMPSB representante
! Cx,, {, rotura,}, ESI, [1], EDI, [1], == {,?, rotura,}, esi, ++, EDI, ++, CX, -, 0, IR
Los que se expresan con el comando 'TODO'. que actúa como un 'break', pero muestra un mensaje de advertencia que
describe una instrucción que no está implementada y no ser emulado. Por ejemplo:
129
ESIL
r @ Entry0
; [0] va = 0x1000010f8 pa = 0x000010f8 sz = 13299 vsz = 13299 rwx = -rx 0 .__ texto
┌─── <0x100001138 7f1a sf, de,, ^, zf,, y ,? {, 0x1154, rasgar, =,};! [2]
Introspección
Para facilitar el análisis ESIL debemos tener una manera de expresar las expresiones de introspección para extraer los datos que queremos. Por
ejemplo, es posible que desee obtener la dirección de destino de un salto. El analizador de expresiones Esil debe ofrecer API para que sea
rasgar, =
Necesitamos una manera de recuperar el valor numérico de 'estafa'. Este es un ejemplo muy sencillo, pero hay más compleja, como las
destino de salto
130
ESIL
API ganchos
Es importante para la emulación sea capaz de ganchos de instalación en analizador, por lo que se puede extender a aplicar análisis sin tener
que cambiar de programa de análisis y otra vez. Es decir, cada vez que una operación está a punto de ser ejecutado, un gancho de usuario se
va a cambiar, o si las actualizaciones de instrucción de pila, etc. Posteriormente, podemos dividir esa devolución de llamada en varios más para
tener una API basada en el análisis de eventos que pueden extenderse en js como este:
anular la acción tomada para una devolución de llamada. la memoria, por ejemplo, negar lee en una región, o anular la memoria
escribe, haciendo efectiva de sólo lectura. Return false o 0 si desea realizar un seguimiento de expresión ESIL análisis.
Otras operaciones que requieren fijaciones externas a funcionalidades para trabajar. En r_ref
este caso,
Io Get / Set
hacha, 44
44, hacha,: ou
ds, eax, =
131
scripting
Radare2 ofrece un amplio conjunto de una serie de características para automatizar el trabajo aburrido. Se extiende desde la simple
secuenciación de los comandos a los guiones de llamada / otros programas a través de IPC (comunicación entre procesos), llamados r2pipe.
Como se ha mencionado un par de veces antes de que haya una capacidad de secuenciar comandos usando; operador de punto y coma.
[0x00404800]> pd 1; ao 1
Dirección: 0x404800
5 Tipo: mov
Simplemente ejecuta el segundo comando después de terminar la primera, como en una concha. La segunda forma
ao | dirección de grep
Nota, la | tubo solamente puede dar salida a la tubería de r2 manda externa (shell) comandos, como programas de sistema o
comandos shell incorporado. Hay una manera similar a la secuencia de la R2 comandos, usando el operador de comilla invertida `
command`.
La parte citada se someterá a la sustitución de comandos y la salida será utilizado como un argumento de la línea de comandos.
Por ejemplo, queremos ver unos pocos bytes de la memoria en la dirección mencionada por el 'mov eax, addr' instrucción. Podemos
132
scripting
[0x00404800]> pd 1
0x404800
5 Tipo: mov
nulo: cpu
tab..inter
[0x00404800]>
Y por supuesto que es posible redirigir la salida de un comando r2 en un archivo, utilizando el > y >> comandos
La? $? comando describe varias variables votos que puede utilizar para hacer acciones similares, incluso con mayor facilidad,
v como el $
133
bucles
Una de las tareas más comunes en la automatización es un bucle a través de algo, hay varias maneras de hacer esto en radare2.
[0x004047d6]> afi
0x004047d0 42 realsz: 42
StackFrame: 0
llamar-convención: amd64
ciclomática-complejidad: 1 bits: 64
llamar-refs: 0x00402450 C
[0x004047d6]>
Ahora vamos a decir, por ejemplo, que nos gustaría ver a un campo particular de esta salida para todas las funciones que se encuentran por el análisis.
Podemos hacer eso con un bucle para todas las banderas de función (cuyos nombres comienzan
FCN. ): con
*.
También podemos bucle sobre una lista de desplazamientos, utilizando la siguiente sintaxis:
@@ = 1 2 3 ... N
134
bucles
Por ejemplo, decimos que queremos ver la información de código de operación para 2 compensaciones: el actual, y al actual + 2:
[0x004047d6]> ao @@ = $$ $$ + 2 Dirección:
[0x004047d6]>
Tenga en cuenta que estamos usando el $$ variable que se evalúa como el desplazamiento actual. También tenga en cuenta
2 que $$ +
se evalúa antes de bucle, por lo que podemos utilizar las expresiones aritméticas sencillas. Una tercera forma de bucle es por tener los desplazamientos
pueden cargar desde un archivo. Este archivo debe contener un desplazamiento por línea.
RDX
135
bucles
Entry0 42 │
I..ATL.% .. "
S..H ...." @
0x4027e0 │
╘ 0x004047f9 f4 HLT
@@ k sdbquery -iterar sobre todos los desplazamientos devueltos por que sdbquery
@@segundo -iterar sobre todos los bloques básicos de la función actual (ver AFB)
El último tipo de bucle que permite recorrer los tipos predefinidos de iterador:
símbolos
importaciones
registros
136
bucles
hilos comenta
banderas
funciones
Esto se hace mediante el @@@ mando. El ejemplo anterior de la inclusión de información sobre las funciones también se
Esto extraerá
nombrecampo deAFI producción y dará salida a una gran lista de nombres de función. Podemos elegir sólo la
137
macros
Aparte de secuenciación simple y bucle, radare2 permite escribir macros simples, usando esta construcción:
Esto va a definir una macro llamada 'qwe' que se extiende secuencialmente primero 'pd 4' y luego 'ao'. Llamando a la macro utilizando la
sintaxis . macro)
( es simple:
(Qwe)
Dirección: 0x404800
5 Tipo: mov
[0x00404800]> (* (qwe, pd 4,
ao)
Y si quieren eliminar algunos macro, sólo tiene que añadir '-' antes del nombre:
eliminado. [0x00404800]>
Por otra parte, es posible crear una macro que toma argumentos, que viene muy bien en algunas situaciones de secuencias de
comandos simples. Para crear una macro que toma argumentos simplemente añadirlos a la definición de macro. Sin duda, si
estás usando personajes como ';', por citar a todo el comando adecuado para el análisis.
138
macros
[0x00404800]
; - Entry0: 0x004047d0
[0x004047d6]>
Como se puede ver, los argumentos son nombrados por el índice, a partir de 0: 0 $, $ 1, ...
139
R2pipe
R2pipe
La API r2pipe fue diseñado inicialmente para NodeJS con el fin de apoyar la reutilización de API r2.js de la web desde la línea de
comandos. Los permisos módulo r2pipe que interactúan con las instancias de R2 en diferentes métodos:
nodejs x x x x x-x
pitón x x -x xxx
rápido x x x x - -x
punto net x x x x - - -
Haskell x x -x - -x
Java - x -x - - -
golang x x - - - -x
rubí x x - - - -x
moho x x - - - -x
vala - x x - - - -
Erlang x x - - - - -
newLISP x - - - - - -
dlang x - - - - -x
perl x - - - - - -
Ejemplos de
Python
importar r2pipe
r2 = r2pipe.open ( "/ bin / ls" ) R2.cmd ( 'Automóvil club británico' () de impresión (r2.cmd "AFL" )) de impresión (r2.cmdj
140
R2pipe
NodeJS
console.log (o);
r.quit ()
}); });
doSomeStuff);
Ir
$ R2pm -i r2pipe-go
- - go-repo r2pipe
141
R2pipe
paquete principal
importar (
"FMT"
"Github.com/radare/r2pipe-go"
func principal() {
Si err! = nulo {
pánico (Err)}
aplazar r2p.Close ()
Si err! = nulo {
pánico (Err)}
Si err! = nulo {
pánico (Err)}
fmt.Println (buf0)
Si err! = nulo {
pánico (Err)}
fmt.Println (buf1)
Si err! = nulo {
pánico (Err)}
fmt.Println (BUF2)}
Moho
$ Cat Cargo.toml
. . .
[Dependencias] r2pipe =
"*"
142
R2pipe
# [Macro_use]
fn principal () {
dejar que mut R2P = open_pipe! ( Algunos ( "/ bin / ls" )).desenvolver();
// cerrado y listo!
r2p.close (); }
Rubí
exigir 'R2pipe'
pone '===================='
r2p.quit
Perl
143
R2pipe
estricta;
( "PD 5") "\ n"; print $ r-> cmd ( "64 px") "\ n".; $ R-> quit ();
Erlang
permitir
%% hr -sNOMBRE
- modo (compilar) .
R2pipePATH = Nombre del archivo: dirname (Escript: SCRIPT_NAME ()) ++ "/ Ebin" ,
Haskell
144
R2pipe
importar R2pipe
principal = hacer
- - Ejecutar r2 localmente
- - Conectarse a r2 a través de HTTP (por ejemplo, si "R2 -QC = H / bin / ls" se está ejecutando)
Punto net
145
R2pipe
utilizando Sistema;
utilizando System.Collections.Generic;
utilizando System.Linq;
utilizando System.Text;
utilizando System.Threading.Tasks;
utilizando r2pipe;
clase Programa
# Si __MonoCS__
# más
#terminara si
Console.WriteLine ( "Hola r2!" + Pipe.RunCommand ( "? V" )); tarea < cuerda > asíncrono =
Java
146
R2pipe
importar org.radare.r2pipe.R2Pipe;
tratar {
Rápido
} más {
}});
Vala
147
R2pipe
var = R2P nuevo R2Pipe ( "/ bin / ls" ); r2p.cmd ( "Pi 4" , (X) => {
stdout .printf ( "DISASM ((% s)) \ n" , x); r2p.cmd ( "es decir" , (X) =>
}); });
loop.run ();
regreso 0 ; }
newLISP
(carga "R2pipe.lsp" ) (Println "PD 3: \ n" (r2pipe: cmd "Pd 3" )) (salida)
Dlang
importar std.stdio;
importar r2pipe;
vacío principal() {
auto r2 = r2pipe.open (); writeln ( "Hola " ~ R2.cmd ( "? E Mundial" ));
cuerda uri = r2.cmdj ( "Ij" ) [ "núcleo" ] [ "URI" ] .str; writeln ( "Uri" , Uri);
148
Rabin2
Bajo este nombre conejito-árabe-como, radare esconde una poderosa herramienta para manejar archivos binarios, para obtener información sobre las
importaciones, las secciones, encabezados etc. Rabin2 puede presentar en varios formatos aceptados por otras herramientas, incluyendo radare2 sí.
Rabin2 entiende muchos formatos de archivo: Clase Java, ELF, PE, Mach-O, etc., y es capaz de obtener símbolo de importación / exportación, las
dependencias de bibliotecas, cadenas de secciones de datos, referencias externas, la dirección del punto de entrada, secciones, tipo de arquitectura.
$ Rabin2 -h
Uso: rabin2 [-AcdeEghHiIjlLMqrRsSvVxzZ] [- @ at] [-a arco] [bits de -b] [addr -B]
[-CF: C: D] [-f str] [-m addr] [-n str] [-N m: M] [-P [-P] pdb] [-o str] [-O str] [ consulta -k] [-D lang symname] |
archivo
- do lista clases
- C [fmt: C: D] crear [elf, mach0, pe] con el código y los datos hexpairs (ver -a)
- Nombre D lang demangle nombre de símbolo (-D todo por bin.demangle = true)
- mi punto de entrada
- F [binfmt] la fuerza para utilizar ese plugin bin (ignorar comprobación de cabecera)
- yo información binaria
- j salida en JSON
- l bibliotecas vinculadas
- N [min: max] fuerza min: número máximo de caracteres por cadena (ver -z y -zz)
- o [str] archivo de salida / carpeta para las operaciones de escritura (por defecto)
149
Rabin2
- r salida radare
- R reubicaciones
- s símbolos
- S secciones
- X [fmt] [f] .. paquete de contenido de grasa o zip los archivos y contenedores estén impresos en archivos
- zzz volcar cuerdas primas a la salida estándar (para archivos de gran tamaño)
. . . . . .
150
La identificación del archivo
/ Tipo / bin ls
clase
arco los
bits x86 64
Para que la información de salida rabin2 en el formato que el programa principal, radare2, puede entender,
IR opción
pase -
a la misma:
151
Punto de entrada
los - mi opciones transferida a rabin2 mostrará puntos de entrada para binario dado. Dos ejemplos:
entrada]
1 puntos de entrada
152
Las importaciones
Las importaciones
Rabin2 es capaz de encontrar objetos importados por un ejecutable, así como sus desplazamientos en el PLT. Esta información
es útil, por ejemplo, para entender cuál es la función externa es invocado por
llamadainstrucción. Pasaryo- bandera a Rabin para obtener una lista de las importaciones. Un ejemplo:
ordinal = 001 plt = 0x000021b0 bind = tipo GLOBAL = nombre FUNC = __ ctype_toupper_loc ordinal = 002 plt = 0x000021c0 bind =
tipo GLOBAL = nombre FUNC = __ uflow ordinal = 003 plt = 0x000021d0 bind = tipo GLOBAL = FUNC name = getenv ordinal = 004
plt = 0x000021e0 bind = tipo GLOBAL = FUNC name = sigprocmask ordinal = 005 plt = 0x000021f0 bind = tipo GLOBAL = nombre
FUNC = elevar ordinal = 006 plt = 0x00002210 bind = tipo GLOBAL = FUNC name = localtime ordinal = 007 plt = 0x00002220 bind =
tipo GLOBAL = nombre FUNC = __ mempcpy_chk ordinal = 008 plt = 0x00002230 bind = tipo GLOBAL = nombre FUNC = abortar
ordinal = 009 plt = 0x00002240 bind = tipo GLOBAL = nombre FUNC = __ errno_location (...)
153
Las importaciones
exportaciones
vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 000 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $
vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 001 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $
vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 002 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $
vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 003 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $
154
Símbolos (exportaciones)
Símbolos (Exportaciones)
addr = 0x0021a610 off = 0x0021a610 ord = 114 fwd = NONE sz = 8 bind = tipo GLOBAL = nombre de objeto = STDO ut
addr = 0x0021a600 off = 0x0021a600 ord = 115 fwd = NONE sz = 0 bind = tipo GLOBAL = nombre notype = _eda ta
addr = 0x0021b388 off = 0x0021b388 ord = 116 fwd = NONE sz = 0 bind = tipo GLOBAL = nombre notype = _END addr = 0x0021a600 off = 0x0021a600 ord
addr = 0x0021a630 off = 0x0021a630 ord = 119 fwd = NONE sz = 8 bind = tipo desconocido = nombre de objeto = pro gram_invocation_name
addr = 0x0021a600 off = 0x0021a600 ord = 121 fwd = NONE sz = 0 bind = tipo GLOBAL = nombre notype = __ s ancho s_start
addr = 0x0021a630 off = 0x0021a630 ord = 122 fwd = NONE sz = 8 bind = tipo GLOBAL = nombre de objeto = __ pr ogname_full
addr = 0x0021a600 off = 0x0021a600 ord = 123 fwd = NONE sz = 8 bind = tipo desconocido = nombre de objeto = pro gram_invocation_short_name
addr = 0x00002178 off = 0x00002178 ord = 124 fwd = NONE sz = 0 bind = tipo GLOBAL = nombre FUNC = _init
Con el -sr rabin2 opción produce un guión radare2 lugar. Más tarde se puede pasar al núcleo de bandera automáticamente todos los
símbolos y para definir intervalos de bytes correspondientes como funciones y bloques de datos.
símbolos fs
Cd 8 @ 0x0021a610
@ 0x0021a600
0x0021a630
0x0021a600
155
bibliotecas
Bibliotecas lista
Vinculados] libselinux.so.1
4 bibliotecas
razón es que rabin2 no sigue y no muestra las dependencias de bibliotecas. Sólo se muestran las dependencias
binarias directos.
156
Instrumentos de cuerda
Instrumentos de cuerda
los - z opción se utiliza para enumerar las cadenas legibles que se encuentran en la sección de .rodata binarios ELF, o la sección .text de
addr = 0x00012487 off = 0x00012487 ordinal = 000 sz = 9 len = 9 sección = tipo .rodata = Una cadena = sr c / ls.c
dir = 0x00012490 0x00012490 = off ordinal = 001 SZ = 26 len = 26 = sección tipo .rodata = Una cadena = sort_type! = sort_version
addr = 0x000124aa off = 0x000124aa ordinal = 002 sz = 5 len = 5 sección = tipo .rodata = Una cadena =% lu
addr = 0x000124b0 off = ordinal 0x000124b0 = 003 sz = 7 len = 14 sección = tipo .rodata = W cadena =%
* Lu?
addr = 0x000124ba off = 0x000124ba ordinal = 004 sz = 8 len = 8 sección = tipo .rodata = Una cadena =% s% * s
addr = 0x000124c5 off = 0x000124c5 ordinal = 005 sz = 10 len = 10 sección = tipo .rodata = Una cadena =% * s,% * s
addr = 0x000124cf off = ordinal 0x000124cf = 006 sz = 5 len = 5 sección = tipo .rodata = Una cadena = -
>
addr = 0x000124d4 off = 0x000124d4 ordinal = 007 sz = 17 len = 17 sección = tipo .rodata = Una cadena = no se puede acceder a% s
dir = 0x000124e5 apagado = 0x000124e5 ordinal = 008 SZ = 29 len = 29 = sección tipo .rodata = Una cadena = No se puede leer el enlace simbólico% s
addr = 0x00012502 off = 0x00012502 ordinal = 009 sz = 10 len = 10 sección = tipo .rodata = Una cadena = no marcado
Con el -zr opción, esta información se representa como una lista de comandos radare2. Se puede utilizar en una sesión radare2 para crear
automáticamente un espacio indicador denominado "cadenas" pre-pobladas con banderas de todas las cadenas que se encuentran por rabin2.
Por otra parte, este script va a marcar niveles de bytes correspondientes como cadenas en lugar de código.
0x000124aa Cs 5 @ 0x000124aa
0x000124b0
157
Instrumentos de cuerda
158
Las partes del programa
Rabin2 llamada con elS -opción proporciona información completa acerca de las secciones de un archivo ejecutable. Para
cada sección del índice, offset, tamaño, alineación, tipo y permisos, se muestran. El siguiente ejemplo demuestra esto:
idx = 00 addr = 0x00000238 0x00000238 apagado = SZ = 28 = 28 vsz perm = -r-- name = .interp idx = 01 addr = 0x00000254 0x00000254 = off SZ = 32
= 32 vsz perm = -r-- name = .Nota .ABI_tag idx = 02 addr = 0x00000274 off = 0x00000274 sz = 36 vsz = 36 perm = -r-- name = .note.gnu.build_id idx = 03
addr = 0x00000298 off = 0x00000298 sz = 104 vsz = 104 perm = -r - name = .gnu.hash idx = 04 addr = 0x00000300 0x00000300 = off SZ = 3096 = 3096
vsz perm = -r-- name = .dynsym idx = 05 = addr apagado = 0x00000f18 0x00000f18 SZ = 1427 = 1427 vsz perm = -r-- name = .dynstr idx = 06 addr =
0x000014ac off = 0x000014ac sz = 258 vsz = 258 perm = -r-- name = .gnu.version idx = 07 addr = 0x000015b0 off = 0x000015b0 sz = 160 vsz = 160
perm = -r-- name = .gnu.version_r idx = 08 addr = 0x00001650 0x00001650 apagado = SZ = 168 = 168 vsz perm = -r-- name = .rela.dyn idx = 09 = addr
apagado = 0x000016f8 0x000016f8 SZ = 2688 vsz = 2,688 perm = -r-- name = .rela.plt idx = 10 addr = 0x00002178 OFF = 0x00002178 sz = 26 vsz = 26
perm = -rx name = .init idx = 11 addr = 0x000021a0 off = 0x000021a0 sz = 1,808 vsz = 1,808 perm = -rx name = .plt idx = 12 addr = 0x000028b0 off =
0x000028b0 sz = 64444 vsz = 64444 perm = -rx name = .text idx = 13 addr = 0x0001246c off = 0x0001246c sz = 9 vsz = 9 perm = -rx name = .fini idx =
14 addr = 0x00012480 fuera = 0x00012480 sz = 20764 vsz = 20764 perm = -r-- name = .rodata idx = 15 addr = 0x0001759c off = 0x0001759c sz = 1,820
vsz = 1,820 perm = -r-- name = .eh_frame_hdr idx = 16 addr = 0x00017cb8 off = 0x00017cb8 sz = 8,460 vsz = 8,460 perm = -r-- name = .eh_frame idx =
17 addr = 0x00019dd8 off = 0x00019dd8 sz = 8 vsz = 8 perm = -rw- name = .init_array idx = 18 addr = 0x00019de0 off = 0x00019de0 sz = 8 vsz = 8 perm
= -rw- name = .fini_array idx = 19 addr = 0x00019de8 off = 0x00019de8 sz = 8 vsz = 8 perm = -rw- name = .jcr idx = 20 addr = 0x00019df0 off =
0x00019df0 sz = 512 = 512 vsz perm = name = -rw-.dinámica idx = 21 addr = 0x00019ff0 off = 0x00019ff0 sz = 16 vsz = 16 perm = -rw- name = .got idx =
22 addr = 0x0001a000 off = 0x0001a000 sz = 920 vsz = 920 perm = -rw- name = .got. plt idx = 23 addr = 0x0001a3a0 off = 0x0001a3a0 sz = 608 vsz =
608 perm = -rw- name = .data idx = 24 addr = 0x0001a600 off = 0x0001a600 sz = 3,464 vsz = 3,464 perm = -rw- name = idx .bss = 25 addr =
0x0001a600 off = 0x0001a600 sz = 8 vsz = 8 perm = ---- name = .gnu_debuglink idx = 26 addr = 0x0001a608 off = 0x0001a608 sz = 254 vsz = 254 perm
= ---- name = .shstrtabgnu_debuglink idx = 26 addr = 0x0001a608 off = 0x0001a608 sz = 254 vsz = 254 perm = ---- name = .shstrtabgnu_debuglink idx =
26 addr = 0x0001a608 off = 0x0001a608 sz = 254 vsz = 254 perm = ---- name = .shstrtab
27 secciones
Con el -sr opción, indicador rabin2 voluntad el inicio / final de cada sección, y pasará el resto de la información como un
comentario.
159
Las partes del programa
section_end..interp 0 0x00000254
CC [00] va = 0x00000238 pa = 0x00000238 sz = 28 vsz = 28 rwx = -r-- .interp @ 0x00000238 S 0x00000254 0x00000254 0x00000020
CC [01] va = 0x00000254 pa = 0x00000254 sz = 32 vsz = 32 rwx = -r-- .note.ABI_tag @ 0x00000254 S 0x00000274 0x00000274 0x00000024
section_end..gnu.hash 0 0x00000300
CC [03] va = 0x00000298 pa = 0x00000298 sz = 104 vsz = 104 rwx = -r-- .gnu.hash @ 0x00000298 S 0x00000300 0x00000300 0x00000c18
CC [04] va = 0x00000300 pa = 0x00000300 sz = 3,096 vsz = 3,096 rwx = -r-- .dynsym @ 0x00000300 S 0x00000f18 0x00000f18 0x00000593
CC [05] va = 0x00000f18 pa = 0x00000f18 sz = 1,427 vsz = 1,427 rwx = -r-- .dynstr @ 0x00000f18 S 0x000014ac 0x000014ac 0x00000102
160
binaria diffing
binaria diffing
Esta sección se basa en la http://radare.today artículo " Diferenciando binaria "Sin ningúnradiff2
parámetro,
muestra
9090909090 0x0007c805
eax sete al
Para el procesamiento a granel, es posible que desee tener una visión general de alto nivel de las diferencias. Esta es la razón por
743
Si desea que los datos más concretos, también es posible contar las diferencias,
do con el -
opción:
le dará tres columnas para todas las funciones: "En primer desplazamiento de archivo", "Porcentaje de coincidencia" y "Segundo
desplazamiento archivo".
161
binaria diffing
sym.imp .__ libc_start_main 0x401190 | PARTIDO (1.000000) | 0x401190 sym.imp .__ libc _start_main
fcn.00401196 0x401196 | PARTIDO (1.000000) | 0x401196 fcn.00401196 fcn.0040103c 0x40103c | PARTIDO (1.000000) |
fcn.0040103c 0x40103c fcn.00401046 0x401046 | PARTIDO (1.000000) | 0x401046 fcn.00401046 fcn.000045e0 24 0x45e0 |
24 fcn.000045f0
. . .
Por otra parte, podemos pedir radiff2 para realizar análisis primera - laUN
adición
opción- se ejecutará
aaa en los binarios. Y podemos
$ Radiff2 -AC -a x86 / bin / true / bin / false | grep UNMATCH [x] Analizar todas las banderas comenzando
con sym. y Entry0 (aa) [x] Analizar len bytes de instrucciones para referencias (AAR) [x] Analizar las
[] [*] Uso -AA o AAAA para llevar a cabo análisis experimental adicional. [X] La construcción de un nombre de función para FCN. * Y
sym.func. * Funciones (aan)) [x] Analizar todas las banderas comenzando con sym. y Entry0 (aa) [x] Analizar len bytes de instrucciones
[] [*] Uso -AA o AAAA para llevar a cabo análisis experimental adicional. [X] La construcción de un nombre de función para FCN. * Y
6 sub.fileno_510
0 sub.fileno_450
4 sub.setlocale_fb0
0 fcn.00003a60
opción. Usted puede darle un nombre de símbolo, de especificar dos desplazamientos, si la función que desea Diff es un
la función de Unix
ciertoy falso
162
binaria diffing
Partes amarillas indican que algunas compensaciones no coinciden. La pieza gris significa una combinación perfecta.
El rojo pone de manifiesto una diferencia fuerte. Si se mira de cerca, verá que la parte izquierda de laediimagen tiene
mientras
mov, 0x1; llamar sym.imp.exit, que la derecha tiene
edi xor, EDI; llamar sym.imp.exit.
Diferenciando binario es una característica importante para la ingeniería inversa. Puede ser utilizado para analizar
actualizaciones de seguridad , Los binarios infectados, los cambios de firmware y más ...
Sólo hemos mostrado el análisis de código diffing funcionalidad, pero radare2 soporta otros tipos de diffing entre dos
binarios: a nivel de byte, similitudes deltified, y más por venir. Tenemos planes para implementar más tipos de algoritmos
bindiffing en r2, y por qué no, añadir soporte para el gráfico arte ASCII diffing y una mejor integración con el resto de la
caja de herramientas.
163
Rasm2
Rasm2
$ Rasm2 -h
Uso: rasm2 [-CdDehLBvw] [arco -a] [bits de -b] [-o addr] [sintaxis -s]
[-f archivo] [-F fil: ter] [skip -i] [len -l] 'código' | hexagonal | -
- b [bits de] Conjunto cpu tamaño registro (8, 16, 32, 64) (RASM2_BITS)
- do Salida en formato C
Si el valor '-l' es mayor que la longitud de salida, la salida se rellena con NOP Si el último argumento es '-' lee de la entrada
estándar
164
Rasm2
$ -L rasm2 _D 16
ad 32 bf LGPL3 Brainfuck
Tenga en cuenta que "ad" en la primera columna significa tanto ensamblador y desensamblador son ofrecidos por un plugin correspondiente.
165
Armar
Ensamblador
rasm2se puede utilizar desde la línea de comandos para hexpairs que representan una instrucción de máquina dada pegado copian
rápidamente.
El ensamblador comprende los siguientes idiomas de entrada y sus sabores: x86 (Intel y variantes de AT & T), Olly (sintaxis
OllyDbg), PowerPC (PowerPC), el brazo y java. Para conocer la sintaxis de Intel, rasm2 trata de imitar NASM o gas.
Hay varios ejemplos en el directorio del código fuente rasm2. Consulte a comprender cómo se puede montar un archivo
166
Armar
$ Selfstop.rasm gato;
; --pancake;
. arquitectura x86
selfstop:
empujar 0x8048000
Pusha
0x80
popa ret;
; La inyección llamada;
retirado
a.rasm` [0x00000000]> PD 20
0x00000005 60 PUSHAD
61 POPAD
0x0000001c c3 retirado
0x0000001d c3 retirado
167
Desmontar
desensamblador
pasando el re
- opción de rasm2 le permite desmontar una cadena hexpair:
168
Ragg2
Propósito
ragg2 compila los programas escritos en un simple lenguaje de alto nivel en pequeños binarios para x86, x86-64, y ARM.
Sintaxis de la lengua
El código de r_egg se compila como en un flujo. Es un compilador de una sola pasada; esto
significa que usted tiene que definir el tamaño adecuado entorno de pila al comienzo de la
función, y hay que definir las funciones con el fin de evitar que los errores de compilación.
El compilador genera código ensamblador para x86 {32,64} y el brazo. Pero tiene como objetivo apoyar más
plataformas. Este código se compila con la r_asm y se inyecta en una pequeña binario con r_bin.
Es posible que quiera utilizar r_egg para crear binarios independientes, huevos crudos
El código generado aún no está optimizado, pero es seguro para ser ejecutado en cualquier lugar en
el código.
preprocesador
alias
A veces sólo necesita reemplazar en tiempo de compilación una sola entidad en múltiples lugares. Los
alias se traducen en declaraciones 'EQU' en lenguaje ensamblador. Esto es sólo una palabra clave de
169
Ragg2
incluye
Utilizargato (1)o el preprocesador para concatenar varios archivos para ser compilado.
sys-osx.r@include (INCDIR);
Hashbang
$ Cabeza n1 hello.r
$ ./hello.r
Hola Mundo!
Principal
La ejecución del código se realiza como en un flujo. La primera función para ser definido será el
primero en ser ejecutado. Si desea ejecutar main () simplemente hacer como esto:
principal();
. . .
. . .
definición de la función
Es posible que quiera dividir el código en varios bloques de código. Estos bloques están unidos a una
firmas de función
170
Ragg2
obtener
stackframesize: el espacio de pila para almacenar las variables locales
obtener
staticframesize: el espacio de pila para almacenar variables estáticas (cadenas)
tipos de funciones
llamadas al sistema
r_egg ofrece un azúcar sintaxis para definir llamadas al sistema. La sintaxis es la siguiente:
@syscall () {
`: Mov eax,.arg```
: Int 0x80
@ mundial principal () {
de salida (0);
bibliotecas
Por el momento no hay soporte para vincular los programas r_egg a las bibliotecas del sistema. pero
si se inyecta el código en un programa (disco / memoria) se puede definir la dirección de cada función
biblioteca central
171
Ragg2
Variables
. arg
. arg0
. arg1
. arg2
. var0
. var2
. fijar
. pb
. ordenador personal
. sp
símbolos variables.
Las matrices
Rastreo
A veces los programas r_egg se romperán o simplemente no funcionar como se espera. Utilizar la arquitectura 'traza' para
punteros
registros virtuales
operaciones matemáticas
172
Ragg2
+ - */Y|^
El valor de retorno se almacena en el registro a0, este registro se establece cuando se llama a una
$ Test.r gato
. var0;
@ mundial principal () {
añadir (3,4);
$ ./test
$ $ Eco?
trampas
Cada arquitectura tiene una instrucción diferente para romper la ejecución del programa. idioma Regg capta
las llamadas a 'break ()' para ejecutar la devolución de llamada emit_trap del arco seleccionado. los
compila
descanso() ; -> en 'int3' en x86
ensamblado en línea
Las líneas que comienzan con ':' carbón son sólo entre líneas en el conjunto de salida.
: JMP 0x8048400
173
Ragg2
: 33,44 .byte
Etiquetas
Puede definir las etiquetas mediante el: la palabra clave de la siguiente manera:
:Nombre de etiqueta:
/ * Bucle infinito * /
Goto (LABEL_NAME)
Flujo de control
while (cond)
si (cond)
comentarios
174
Análisis
Hay diferentes comandos para realizar análisis de datos y código, para extraer información útil a partir de un sistema binario, como punteros,
referencias de cadenas, bloques básicos, datos de código de operación, destinos de salto, referencias externas, etc. Estas operaciones son
manejadas por el
un ( analizar) de la familia de comandos:
| Automóvil club británico[?] analizar todos (fcns + bbs) (AA0 para evitar sub cambio de nombre)
Ejemplos:
section..data
. ad t t + ts @ d: ds
175
Análisis de código
Análisis de código
análisis de código es una técnica común que se utiliza para extraer información de código de montaje. Radare utiliza estructuras de
datos internas para identificar bloques básicos, árboles de función, para extraer la información de nivel de opcode etc. La secuencia
[0x08048440]> aa
;-- principal:
487cf |
| | sym..imp.puts ()
| | sym..imp.abort ()
hisprogram_; 0x0804880c |
| | sym..imp.puts ()
| | sym..imp.abort ()
176
Análisis de código
\ 0x080486d4 c3 retirado
función (pdf).
177
Rahash2
Para calcular una suma de comprobación del bloque actual cuando se ejecuta radare2, utilice el comando 'PH'. Pasar un nombre de
d2994c75adaa58392f953a448de5fba7
los ph comando acepta un parámetro opcional para especificar la longitud del intervalo de bytes esté encriptado, en lugar de tamaño de
[0x08049A80]> ph md5 32
9b9012b00ef7a94b5824105b7aaad83b [0x08049A80]> ph
md5 64 a71b087d8166c99869c9781e2edcf183
a933cc94cd705f09a41ecc80c0041def [0x08049A80]>
178
Rahash2
179
Herramienta Rahash
Rahash2
La herramienta rahash2 puede ser utilizado para calcular las sumas de comprobación y tiene funciones de flujos de bytes, archivos, cadenas de texto.
$ Rahash2 -h
Uso: rahash2 [-rBhLkv] [-b sz] [-a algo] [-s str] [-f de] [-t a] [archivo] ...
- b bsize especificar el tamaño del bloque (en lugar del archivo completo)
5eb63bbbe01eeed093cb22bb8f5acdc3
Es posible calcular los valores hash para el contenido de los archivos. Pero no intente hacerlo por archivos muy grandes, porque rahash2
amortigua toda la entrada en la memoria antes de calcular el hash. Para aplicar todos los algoritmos conocidos para rahash2,
todas comoel uso
un nombre de algoritmo:
180
Herramienta Rahash
24fee289ed1d266b0
c381aa929dd222709e4cf7a800b25fbc7d06fe3b184933845
bin / ls: 0x00000000-0x0001ae08 xorpair: 59 / bin / ls: paridad 0x00000000-0x0001ae08: 01 / bin / ls: 0x00000000
-0x0001ae08 entropía: 0567f925 / bin / ls: 0x00000000-0x0001ae08 hamdist: 00 / bin / ls: 0x00000000-0x0001ae08
PCPRINT: 23 / bin / ls: 0x00000000-0x0001ae08 mod255: 1e / bin / ls: 0x00000000-0x0001ae08 xxhash: 138c936d / bin /
181
depurador
depurador
Depuradores se implementan como plugins IO. Por lo tanto, radare puede manejar diferentes tipos de URI para el desove,
depuración r_d Depurar un programa o pid. dbg: /// bin / ls, dbg: // 1388 (LGPL3)
RWD gDB Adjuntar a gdbserver, 'qemu -s', el BGF: // localhost: 1234 (LGPL3)
Existen diferentes sistemas de apoyo para muchas arquitecturas y sistemas operativos de destino, por ejemplo, GNU / Linux, Windows,
Mac OS X, (, libre, abierto neto) BSD y Solaris. memoria del proceso es tratado como un archivo normal. Todas las páginas de memoria
asignadas de un programa depurado y sus bibliotecas pueden ser leídos e interpretados como un código, estructuras de datos, etc. La
comunicación entre radare y la capa IO depurador se envuelve enllama, que acepta una cadena como un argumento, y lo ejecuta
sistema()
como un comando. Una respuesta está tamponada a continuación, en la consola de salida, su contenido puede ser adicionalmente
procesadas por un guión. El acceso al sistema se consigue con IO =! . La mayoría de los plugins IO proporcionan ayudaayuda
con. = !? o =!
Por ejemplo:
$ R2 -d / bin / ls
. . .
En general, los comandos del depurador son portables entre arquitecturas y sistemas operativos. Sin embargo, como radare trata de apoyar la
misma funcionalidad para todas las arquitecturas y sistemas operativos de destino, ciertas cosas tienen que ser manejados por separado. Ellos
incluyen la inyección de shellcodes y manejo de excepciones. Por ejemplo, en los objetivos de MIPS no hay ninguna característica de un solo
paso a paso hardwaresupported. En este caso, radare2 proporciona su propia implementación de un solo paso mediante el uso de una
combinación de análisis de código y puntos de interrupción de software. Para obtener ayuda básica para el depurador, tipo 'd?':
182
depurador
de [-SC] [rwx] [RM] [e] de depuración con ESIL (véase de?) dg <archivo>
doo [args] Vuelva a abrir en modo de depurador con args (alias de 'ood')
183
Empezando
Empezando
Abre
r2 -d / bin / ls: radare2 con el archivo
bin // lsen el modo de depuración utilizando el depurador nativo radare2, pero no se
ejecuta el programa. Usted verá un indicador (radare2) - todos los ejemplos son de este indicador.
bandera db:colocar un punto de interrupción en la bandera, donde la bandera puede ser una dirección o un nombre de función
db - Bandera:eliminar el punto de interrupción en bandera, donde la bandera puede ser una dirección o un nombre de función
Enviar
dk <señal>: señal KILL a hijo
vuelva
ood arg1 arg2: a abrir en modo de depuración con arg1 y arg2
184
La migración de ida, el BGF o WinDBG
r2 -d / bin / ls iniciar
- en modo depurador => [ vídeo ]
r2 -d <pid>adjuntar
- a procesar
r2 ptrace: // pidIgual
- que el anterior, pero sólo para io (no depurador backend enganchado)
cerca
[0x7fff6ad90028]> O-225 - fd = 225 (enumeradosOen
~ [1]: 0)
adjuntar
r2 -D GDB GDB: // localhost: 1234 - a gdbserver
Utilizarrarun2 (Libpath = $ PWD: / tmp / lib, arg2 = hola, setenv = FOO =ver
BARrarun2
...) -h / hombre rarun2
ejecutar
r2 -I <archivo de guión> ... - un script antes de cargar el archivo
R2 -C $ @ | awk $ @ ejecutar
- a través de asm awk obtener de la función => [ enlazar ]
interpretar
[0x80480423]>. archivo de comandos - este archivo => [ vídeo ]
[0x80480423]> #! introducir
C- C repl (ver #! para listar todos los plugins disponibles RLang) => [ vídeo ], Todo tiene que ser hecho de
encuadernaciones
185
La migración de ida, el BGF o WinDBG
atajos
Análisis
Navegación
Editar
186
La migración de ida, el BGF o WinDBG
depurador
Despegar ? o- ? despegar
entrar en F7 ds s norte
paso en 4
? ds 4 F7 n4
instrucciones
información
En Windows Se muestra en el modo
eax pantalla dr? eax registra eax
Registro Visual
$$ afi -
información de la función
función de visualización
? de visualización de la ? ?
addr + N
corriente compensada ($$ )
desmontaje
hacia adelante
N/A pd vp DISA
desmontaje
instrucciones de
N/A pd X vp x/i
desmontaje N
desmontaje N
DISA <ao>
(hacia atrás) N/A pd -X vp
187
La migración de ida, el BGF o WinDBG
La información sobre la
papelera
es oS
secciones del secciones de
Secciones / regiones menú (Anexar j para N/A
información maint
JSON)
backtrace
DBT
Backtrace parcial (más
N/A ( dbg.btdepth dbg.btalgo) N/A bt
interna)
DBT
Backtrace parcial (más
N/A ( dbg.btdepth dbg.btalgo) N/A BT -
externa)
enhebrar
StackTrace para todos los
N/A DBT @ t N/A aplicar todo bt
hilos
información puntos de
lista de punto de interrupción Ctrl + Alt + B db ? interrupción
Trapos
marcos
cualquier
números de bastidor N/A ? N/A
comando bt
Parámetros / locales
Datos
parámetros de visualización N/A AFV N/A
locales
Monitor
Datos
parámetros / locales en N/A afvj N/A locales
JSON
Lista de direcciones
donde se accede a N/A afvR / afvW N/A ?
vars (R / W)
188
La migración de ida, el BGF o WinDBG
proyecto Relacionados
informaciones
Pi [Archivo] ?
espectáculo de proyectos
Diverso
Seleccione la zona
buscar menú de búsqueda /? con el cursor
do entonces /
2. usar entonces
dp para seleccionar cuál es el proceso que desea depurar.
Características comunes
R2 puede hacer la carga básica de archivos del núcleo ELF de la caja y conMDMP
MDMPenchufar r2pm
( -i MDMP)
189
registros
registros
Los registros son parte de un área de usuario almacenada en la estructura de contexto utilizado por el planificador. Esta estructura puede ser
manipulado para obtener y establecer los valores de esos registros, y, por ejemplo, en máquinas Intel, es posible manipular directamente
Hay diferentes comandos para obtener los valores de los registros. Para el uso general los utilizan:
[0x4A13B8C0]> dr r15 =
= 0x00000000 r9 = 0x00000000 r8 =
0x7fff515923c0
La interacción entre un plugin y el núcleo se realiza mediante comandos que devuelven las instrucciones radare. Esto se utiliza, por ejemplo,
para establecer banderas en el núcleo para establecer los valores de los registros.
190
registros
Una vieja copia de los registros se almacena todo el tiempo para realizar un seguimiento de los cambios realizados durante la ejecución de un
programa que se está analizando. Esta copia de edad se puede acceder con
oregs.
191
registros
0x00000000 r9 = 0x00000000 r8 =
Para guardar y restaurar los valores de registro sólo puede volcar la salida de 'dr *' comando en el disco y volver a interpretar de
nuevo:
regs.saved; restaurar
192
registros
EFLAGS pueden ser alterados de manera similar. Por ejemplo, el establecimiento de indicadores seleccionados:
= azsti
Puede obtener una cadena que representa últimos cambios de registros utilizando
DRD (registros de comando diff):
[0x4A13B8C0]> DRD
Éax = 0x0000003B era 0x00000000 delta 59 rip = 0x7f00e71282d0 era 0x00000000 delta
-418217264 rflags = 0x00000200 fue 0x00000000 delta 512 RSP = 0x7fffe85a09c0 era
193
Depuración inversa
Depuración inversa
Radare2 tiene depurador inversa, que puede buscar el contador de programa hacia atrás. (Por ejemplo reversenext, inversamente continúa
en GDB) En primer lugar es necesario guardar el estado del programa en el punto en que desea iniciar la grabación. La sintaxis para la
grabación es:
[0x004028a0]> DTS +
Puedes usardts los comandos de grabación y gestión de los programas estados. Después de registrar los estados, puede solicitar la PC de ida y
vuelta a cualquier dirección de los puntos después de guardado. Así que después de la grabación, puede tratar solo paso atrás:
0x004028ae dr estafa
[0x004028a0]> bss
0x004028a2 dr estafa
Cuando se ejecuta
bss, depurador inversa restaurar el estado anterior registrado y ejecutar el programa de él hasta el punto
0x004028a2 dr estafa
DCB busca contador de programa hasta golpear el último punto de interrupción. Así que una vez establecido un punto de interrupción, se puede volver a
[0x004028a0]> dts
194
Depuración inversa
NOTA: Registros del programa se pueden guardar en cualquier momento. Estos son formato de estilo diff que guardar sólo es diferente el
área de memoria anterior. Se ahorra espacio de memoria en lugar de todo volcado. Y también puede añadir comentario:
descifrado"
Usted puede dejar notas para cada uno de los registros para mantener en su
bssmente.
y DCB comandos recuperan el estado del programa del último
disco si hay muchos registros. los registros del programa pueden exportarse a presentar y, por supuesto importarlo. registros de exportación /
Sesión guarda en records_for_test.session y volcado en records_for_test.dump [0x004028c2]> DTSF sesión records_for_test: 0, diffs
Por otra parte, se puede realizar la depuración en modo inverso ESIL. En el modo ESIL, estado del programa puede ser administrado
AETS por
comandos.
[0x00404870]> + AETS
0x00404870
195
Las capacidades de comunicación remota
Radare se puede ejecutar localmente, o se puede iniciar como un proceso de servidor que se controla mediante un proceso
radare2 local. Esto es posible porque todo utiliza el subsistema IO de radare que abstrae el acceso al sistema (), cmd () y todas
[0x00405a04]> =?
comandos de rap: | =
| = [Fd] cmd cmd en Exec remoto 'fd' (la última es abierta por defecto)
| = + [Proto: //] Agregar host del host (por defecto = rap: //, tcp: //, UDP: //) | = - [fd]
| == [fd] sesión remota abierta con el anfitrión 'fd', 'q' para salir
servidor de rap: | =:
servidor http: | = H
gdbserver:
| = G! archivo de puerto Igual que el anterior, pero de depuración mensajes de protocolo (como gdbserver --remo
te-depuración)
Usted puede aprender capacidades remotas radare2 visualizando la lista de plugins IO soportados:
radare2 -L.
Un pequeño ejemplo debería hacer esto más claro. Una sesión remota típica podría tener este aspecto: En la sistpral1 remoto:
196
Las capacidades de comunicación remota
Al host2 remoto:
En localhost:
radare2 $ -
; Añadir anfitriones
[0x004048c5]> =
Puede abrir archivos remotos en modo de depuración (o el uso de ningún plugin IO) que especifica el URI al agregar hosts:
[0x004048c5]> = + = + rap: // <host2>: 1234 / dbg: /// bin / ls Conectado a: <host2> 1234 en el
/// bin / ls
[0x004048c5]> = 0 px [0x004048c5]> = s
0x666
. . .
FD: 6> q
197
Las capacidades de comunicación remota
[0x004048c5]> = -
También puede redirigir la salida radare a un puerto TCP o UDP del servidor (por
ncejemplo,
-l). En primer lugar, agregue el servidor con '= +
tcp: //' o '= + UDP: //', entonces se puede redirigir la salida de un comando que se envía al servidor:
especificado).
198
GDB remoto
radare2 permite la depuración remota a través del protocolo remoto BGF. Para que pueda ejecutar un gdbserver y conectarse a él con
O si el gdbserver se está ejecutando en modo extendido, se puede asociar a un proceso en el host con:
radare2 todavía no se carga símbolos de gdbserver, por lo que necesita el binario a ser localmente presente para cargar símbolos de ella. E
caso de que los símbolos no están cargados, incluso si el binario está presente, puede intentar especificar la ruta de acceso con
e dbg.exe.path:
Si los símbolos se cargan en una dirección base incorrecta, puede intentar especificar la dirección base con demasiado
e bin.baddr:
Por lo general, la gdbserver informa del tamaño máximo de paquete que soporta. De lo contrario, radare2 recurre a los valores iniciales
adecuados. Sin embargo, puede especificar el tamaño máximo de paquete con la variableR2_GDB_PKTSZ.
de entorno También puede comprobar y
establecer el tamaño máximo del paquete durante una sesión con el sistema IO, =! .
64 bytes
199
GDB remoto
El sistema gdb IO proporciona comandos útiles que podrían no caber en cualquier comandos estándar radare2. Usted puede
obtener una lista de estos comandos con = !? . (Recuerde, =! Accede a la subyacente IOsistema
plug-in()).de
cmd = pid
=! Cmd del monitor - comando monitor y pasar para apuntar intérprete hex-encode
! = Exec_file [pid] - obtener el archivo que fue ejecutado por pid actual / especificado
$ R2 -
[0x00000000]> =?
. . .
gdbserver:
| = Fichero port g [args] escuchar en 'puerto' depuración 'Archivo' usando gdbserver | = G! archivo de puerto [args] mismo que el anterior, pero los mensajes
$ R2 -
Y luego conectarse a él como lo haría con cualquier gdbserver. Por ejemplo, con radare2:
200
plugins
plugins
plugins IO
Todo el acceso a los archivos, red, depurador, etc. está envuelto por una capa de abstracción que permite IO radare para tratar todos los datos
plugins IO son las que se usan para envolver al aire libre, leer, escribir y 'sistema' en sistemas de archivos virtuales. Puede hacer radare
entiende nada como un archivo normal. Por ejemplo, una conexión de socket, una sesión radare remoto, un archivo, un proceso, un
dispositivo, una sesión de GDB, etc .. Por lo tanto, cuando radare lee un bloque de bytes, es la tarea de un plugin de IO para obtener estos
bytes desde cualquier lugar y ponerlos en buffer interno. Un plugin de IO es elegido por el URI de un archivo que se abrirá. Algunos
ejemplos:
URI de depuración
sesiones remotas
virtuales
$ R2 malloc: // 512 $ atajo para R2 Puede obtener una lista de los plugins
radare IO escribiendo
radare2 -L:
201
plugins
postal r2 $ -L rw_
. clase, muestran los archivos con: Código postal: //foo.apk/, abrir todos los archivos con zipall: // (BSD) RWD windbg
rw_ escasa asignación de memoria intermedia escasa (escasa: // 1.024 escasa: //) (LGPL3)
rap rw_ protocolo de red radare (rap: //: puerto de rap: // host: puerto / archivo) (LGPL3)
ptrace RWD ptrace y / proc / PID / mem (si está disponible) io (LGPL3)
RWD gDB Adjuntar a gdbserver, 'qemu -s', el BGF: // localhost: 1234 (LGPL3)
depuración r_d Depurar un programa o pid. dbg: /// bin / ls, dbg: // 1388 (LGPL3)
radare2 divide la lógica de una CPU en varios módulos. Usted debe escribir más de un plugin para obtener soporte
La característica más básica normalmente se quiere apoyar de una arquitectura específica es el desensamblador. Primero
tiene que leer en un formato legible por humanos en los bytes allí. Tenga en cuenta que los plugins pueden ser compilados
estática o dinámicamente, esto significa que el arco se incrusta dentro de las bibliotecas del núcleo o se distribuye como una
biblioteca compartida separado. Para configurar los plugins que desea compilar el uso ./ script que acepta las
configurar-plugins
banderas --shared y --static para especificar ellos. También puede añadir manualmente en el interior y del
plugins.def.cfg luego
eliminar el
plugins.cfgy correr ./
configurar-plugins
202
plugins
La forma oficial de hacer plugins de terceros es para distribuirlos en un repositorio separado. Este es un plugin
muestra disasm:
$ Cd mycpu $ cat Makefile NOMBRE = mycpu R2_PLUGIN_PATH = $ (R2 hh cáscara | LIBR_PLUGINS grep | awk '{print
$$ 2}')
OBJS = $ (NOMBRE) .o SO_EXT = $ (Shell uname | grep -q Darwin && echo dylib || eco de modo)
todas: $ (LIB)
limpiar:
rm -f $ (LIB) $ (OBJS)
$ (LIB): $ (OBJS)
instalar:
desinstalar:
$ Mycpu.c gato
# incluir <r_asm.h>
# incluir <r_lib.h>
# definir OPS 17
"Nop" , NULO ,
"Si" , "R" ,
"añadir" , "Rr" ,
"CMP" , "Rr" ,
"Br" , "R" ,
203
plugins
"retirado" , NULO ,
"sys" , "yo"
};
la longitud
carbonizarse arg [ 32 ];
Si (idx> = (OPS * 2 )) {
regreso -1 ; }
Si (Ops [idx + 1 ]) {
(pag, "R" )) {
Si (* Arg) {
RAsmPlugin r_asm_plugin_mycpu = {
. name = "Mycpu" ,
. arco = "Mycpu" ,
. licencia = "LGPL3" ,
. bits = 32 ,
};
# ifndef CORELIB
. type = R_LIB_TYPE_ASM,
204
plugins
};
#terminara si
Para construir e instalar este plugin sólo tiene que escribir esto:
$ make
Probando el plugin
Este plugin es utilizado por rasm2 y r2. Puede verificar que el complemento se carga correctamente con este comando:
Vamos a abrir un archivo vacío usando el arco 'mycpu' y escribir un código aleatorio allí.
$ R2 -
- - Canje I endians
WOR [0x00000000]> PD 10
205
plugins
Empujar una nueva arquitectura en la rama principal de R2 requiere modificar varios archivos con el fin de que se ajuste a la forma en
añadir
plugins.def.cfg: la cadena de nombre asm.mycpu plugin de ahí
instrucciones
LiBr / asm / p / mycpu.mk: de construcción
implementación
LiBr / asm / p / asm_mycpu.c:
añadir
LiBr / include / r_asm.h: la definición struct allí Comprueba cómo se implementó la CPU NIOS II
https://github.com/radare/radare2/commit/933dc0ef6ddfe44c88bbb261165bf8f8b531476b
https://github.com/radare/radare2/commit/ad430f0d52fbe933e0830c49ee607e9b0e4ac8f2
Pitón
En un primer momento, para poder escribir plugins en Python para radare2 es necesario instalar el plugin r2lang. Si vas a
Nota
-i-lang python3. - En los siguientes ejemplos hay funciones que faltan de la decodificación real para facilitar la lectura! Para
1. r2lang importación
y de r2lang importación Rpara
( las constantes)
206
plugins
regreso [ 1 , 2 , 3 , 4 ]
tratar :
[opcode] [ 1 ]
regreso [ 4 , Opstr]
excepto :
regreso [ 4 , "desconocido" ]
desmontar
regreso {
"nombre" : "Mycpu" ,
"arco" : "Mycpu" ,
"bits" : 32 ,
"Endian" : "pequeño" ,
"licencia" : "GPL" ,
"armar" : Montar,
"desmontar" : Desmonte,}
207
plugins
def set_reg_profile () :
"= SP sp \ n" + \
"GPR r0 . 32 0 0 \ n" + \
"GPR r1 . 32 4 0 \ n" + \
"GPR r2 . 32 8 0 \ n" + \
"GPR R3 . 32 12 0 \ n" + \
"GPR R5 . 32 20 0 \ n" + \
"GPR sp . 32 24 0 \ n" + \
"GPR . 32
ordenador personal 28 0 \ n"
regreso perfil
analop = {
"tipo" : R.R_ANAL_OP_TYPE_NULL,
"ciclos" : 0 ,
"Stackop" : 0 ,
"Stackptr" : 0 ,
"PTR" : -1 ,
"saltar" : -1 ,
"Addr" : 0 ,
"EOB" : Falso ,
"Esil" : "" ,
tratar :
[opcode] [ 2 ]
excepto :
resultado = analop
regreso [ 4 , Resultado]
208
plugins
regreso {
"nombre" : "Mycpu" ,
"arco" : "Mycpu" ,
"bits" : 32 ,
"licencia" : "GPL" ,
"Esil" : 1 ,
"Set_reg_profile" : Set_reg_profile,
"Op" : Op,}
respectivamente
r2 -i mycpu.py some_file.bin
Ver también:
Javascript
Python
Adición de los registros del depurador perfil en el SHLR / GDB / src / core.c
Adición de los registros de perfil y apoyo arquitectura en el LiBr / debug / p / debug_native.c y LiBr / debug / p /
debug_gdb.c
Si desea agregar soporte para el BGF, se puede ver el perfil de registro en la sesión gdb usando comando activo
registros
de impresión maint.
209
plugins
Extensa:
https://github.com/radare/radare2/commit/6f1655c49160fe9a287020537afe0fb8049085 d7
Malbolge: https://github.com/radare/radare2/pull/579
6502: https://github.com/radare/radare2/pull/656
h8300: https://github.com/radare/radare2/pull/664
GBA: https://github.com/radare/radare2/pull/702
https://github.com/radare/radare2/pull/726
Xcore:
https://github.com/radare/radare2/commit/bb16d1737ca5a471142f16ccfa7d444d2713a5 4d
LH5801 aguda:
https://github.com/neuschaefer/radare2/commit/f4993cca634161ce6f82a64596fce45fe6 b818e7
MSP430: https://github.com/radare/radare2/pull/1426
HP PA-RISC:
https://github.com/radare/radare2/commit/f8384feb6ba019b91229adb8fd6e0314b0656f 7b
V810: https://github.com/radare/radare2/pull/2899
TMS320: https://github.com/radare/radare2/pull/596
Ejemplo:
Z80:
https://github.com/radare/radare2/commit/8ff6a92f65331cf8ad74cd0f44a60c258b137a0 6
210
plugins
NAME = anal_snes R2_PLUGIN_PATH = $ (R2 hh cáscara | LIBR_PLUGINS grep | awk '{print $$ 2}')
OBJS = $ (NOMBRE) .o SO_EXT = $ (Shell uname | grep -q Darwin && echo dylib || eco de modo)
todas: $ (LIB)
limpiar:
rm -f $ (LIB) $ (OBJS)
$ (LIB): $ (OBJS)
instalar:
desinstalar:
anal_snes.c:
211
plugins
# incluir <string.h>
# incluir <r_types.h>
# incluir <r_lib.h>
# incluir <r_asm.h>
# incluir <r_anal.h>
#incluir
incluir"Snes_op_table.h"
"Snes_op_table.h"
static int snes_anop (* RANAL anal, RAnalOp * op, addr ut64, const * ut8 datos, int len) {
cambiar (datos[ 0 ]) {
caso 0xEA :
descanso ; }
. name = "SNES" ,
. licencia = "LGPL3" ,
. arco = R_SYS_ARCH_NONE,
. bits = dieciséis ,
. init = NULO ,
. Fini = NULO ,
. op = & snes_anop,
. set_reg_profile = NULO ,
. fingerprint_bb = NULO ,
. fingerprint_fcn = NULO ,
. diff_bb = NULO ,
. diff_fcn = NULO ,
. diff_eval = NULO
};
# ifndef CORELIB
. type = R_LIB_TYPE_ANAL,
. version = R2_VERSION};
#terminara si
212
plugins
snes_op_table. marido:
https://github.com/radare/radare2/blob/master/libr/asm/arch/snes/snes_op_table.h
Ejemplo:
6502:
https://github.com/radare/radare2/commit/64636e9505f9ca8b408958d3c01ac8e3ce254 A9b
SNES:
https://github.com/radare/radare2/commit/60d6e5a1b9d244c7085b22ae8985d0002762 4b49
Crear una carpeta con el nombre del archivo en formato LiBr / bin / formato
Makefile:
NAME = bin_nes R2_PLUGIN_PATH = $ (R2 hh cáscara | LIBR_PLUGINS grep | awk '{print $$ 2}')
OBJS = $ (NOMBRE) .o SO_EXT = $ (Shell uname | grep -q Darwin && echo dylib || eco de modo)
todas: $ (LIB)
limpiar:
rm -f $ (LIB) $ (OBJS)
$ (LIB): $ (OBJS)
instalar:
desinstalar:
bin_nes.c:
213
plugins
# incluir <r_bin.h>
hoyo estatico * load_bytes (* RBinFile arco, const ut8 * buf, SZ ut64, loadaddr ut64, SDB Sdb *) {
regreso R_NOTNULL; }
const ut8 \ * = bytes arco? r_buf_buffer (arch-> buf): NULO ; ut64 SZ = arco? r_buf_size (arch-> buf): 0 ;
gratis (retirado);
regreso NULO ; }
ret-> file = strdup (arch-> file); ret-> type = strdup ( "ROM" ); ret->
regreso retirado; }
. name = "ne" ,
. desc = "NES" ,
. licencia = "BSD" ,
. init = NULO ,
. Fini = NULO ,
. get_sdb = NULO ,
. load = NULO ,
214
plugins
. baddr = NULO ,
. entradas = NULO ,
. secciones = NULO ,
. info = e información,};
# ifndef CORELIB
. type = R_LIB_TYPE_BIN,
. version = R2_VERSION};
#terminara si
Algunos ejemplos
XBE - https://github.com/radare/radare2/pull/972
COFF - https://github.com/radare/radare2/pull/645
TE - https://github.com/radare/radare2/pull/61
Zimgz -
https://github.com/radare/radare2/commit/d1351cf836df3e2e63043a6dc728e880316f00 eb
OMF -
https://github.com/radare/radare2/commit/44fd8b2555a0446ea759901a94c06f20566bb c40
Nota - En los siguientes ejemplos hay funciones que faltan de la decodificación real para facilitar la lectura!
1. r2lang importación
load_bytes carga
destruyen
check_bytes baddr
entradas secciones
215
plugins
importaciones
reubicaciones
información
binsym
regreso [ 0 ]
tratar :
Si buf [ 0 ] == 77 y buf [ 1 ] == 90 :
regreso [ 1 ]
regreso [ 0 ]
excepto :
regreso [ 0 ]
y así. Por favor asegúrese de los parámetros de cada función y el formato de los retornos. Tenga en cuenta, que las
con un tipo diferente. Hay una función especial, que devuelve información sobre elInfo:
archivo -
regreso [{
"tipo" : "Le" ,
"Bclass" : "Le" ,
"Rclass" : "Le" ,
"subsistema" : "CLI" ,
"máquina" : "IBM" ,
"Has_va" : 0 ,
"bits" : 32 ,
"BIG_ENDIAN" : 0 ,
"Dbg_info" : 0 ,}]
desmontar
216
plugins
regreso {
"nombre" : "Le" ,
"licencia" : "GPL" ,
"carga" : carga,
"load_bytes" : load_bytes,
"destruir" : Destruir,
"check_bytes" : check_bytes,
"Baddr" : Baddr,
"entradas" : entradas,
"secciones" : secciones,
"importaciones" Importaciones,
"símbolos" : símbolos,
"reubicaciones" : reubicaciones,
"Binsym" : Binsym,
"Info" : Información,}
217
Crackmes
Crackmes
Crackmes (de "Agriéteme" desafío) son el campo de entrenamiento para la gente de ingeniería inversa. Esta sección
218
IOLI
IOLI CrackMes
El crackme IOLI es un buen punto de partida para el aprendizaje r2. Se trata de un conjunto de tutoriales basados en el tutorial dustri
219
IOLI 0x00
IOLI 0x00
$ ./crackme0x00
El primero que hay que comprobar es si la contraseña es sólo texto plano dentro del archivo. En este caso, no es necesario hacer ningún
desmontaje, y sólo podemos utilizar rabin2 con la bandera -z para buscar cadenas en el binario.
$ Rabin2 -z ./crackme0x00
vaddr = 0x08048568 PADDR = 0x00000568 ordinal = 000 sz = 25 len = 24 sección = tipo .rodata = a stri ng = IOLI Crackme Nivel 0x00 \ n
vaddr = 0x08048581 PADDR = 0x00000581 ordinal = 001 sz = 11 len = 10 sección = tipo .rodata = a ng stri = Contraseña:
vaddr = 0x0804858f PADDR = 0x0000058f ordinal = 002 sz = 7 len = 6 sección = tipo .rodata = una cadena = 250382
vaddr = 0x08048596 PADDR = 0x00000596 ordinal = 003 sz = 19 len = 18 sección = tipo .rodata = a ng stri = Contraseña no válida! \ n
vaddr = 0x080485a9 PADDR = 0x000005a9 ordinal = 004 sz = 16 len = 15 sección = tipo .rodata = a ng stri = Contraseña OK:) \ n
Así que sabemos lo que la siguiente sección es, esta sección es la cabecera se muestra cuando se ejecuta la aplicación.
vaddr = 0x08048568 PADDR = 0x00000568 ordinal = 000 sz = 25 len = 24 sección = tipo .rodata = a stri ng = IOLI Crackme Nivel 0x00 \ n
vaddr = 0x08048581 PADDR = 0x00000581 ordinal = 001 sz = 11 len = 10 sección = tipo .rodata = a ng stri = Contraseña:
vaddr = 0x08048596 PADDR = 0x00000596 ordinal = 003 sz = 19 len = 18 sección = tipo .rodata = a ng stri = Contraseña no válida! \ n
220
IOLI 0x00
vaddr = 0x080485a9 PADDR = 0x000005a9 ordinal = 004 sz = 16 len = 15 sección = tipo .rodata = a ng stri = Contraseña OK:) \ n
¿Pero qué es esto? Es una cadena, pero no lo hemos visto en el funcionamiento de la aplicación todavía.
vaddr = 0x0804858f PADDR = 0x0000058f ordinal = 002 sz = 7 len = 6 sección = tipo .rodata = una cadena = 250382
$ ./crackme0x00
250382 Contraseña OK :)
Así que ahora sabemos que 250.382 es la contraseña, y hemos completado este crackme.
221
IOLI 0x01
IOLI 0x01
$ ./crackme0x01
$ Rabin2 -z ./crackme0x01
vaddr = 0x08048528 PADDR = 0x00000528 ordinal = 000 sz = 25 len = 24 sección = tipo .rodata = a stri ng = IOLI Crackme Nivel 0x01 \ n
vaddr = 0x08048541 PADDR = 0x00000541 ordinal = 001 sz = 11 len = 10 sección = tipo .rodata = a ng stri = Contraseña:
vaddr = 0x0804854f PADDR = 0x0000054f ordinal = 002 sz = 19 len = 18 sección = tipo .rodata = a ng stri = Contraseña no válida! \ n
vaddr = 0x08048562 PADDR = 0x00000562 ordinal = 003 sz = 16 len = 15 sección = tipo .rodata = a ng stri = Contraseña OK:) \ n
Esto no va a ser tan fácil como 0x00. Vamos a tratar de desmontaje con R2.
222
IOLI 0x01
$ R2 ./crackme0x01 - Use `zoom.byte = printable` en el modo de zoom ( 'z' en el modo visual) a cadenas ind f [0x08048330]> a bis [0x08048330]> pdf @
| sym.imp.printf (unk)
| sym.imp.printf ()
| sym.imp.scanf ()
| | sym.imp.printf ()
| | sym.imp.printf ()
| 0x08048453 C9 salir
\ 0x08048454 c3 retirado
"Aa" dice r2 analizar todo el binario, que le consigue los nombres de símbolos, entre las cosas. "Pdf" significa
223
IOLI 0x01
Impresión
Función
Desmonte
Esto imprimirá el desmontaje de la función principal, o el que todo el mundo sabe. Se puede ver varias cosas así:
principal()
"diablillo." siglas de las importaciones. Esos símbolos son importados, como printf () "str." es sinónimo de cadenas. Esos
[0x08048330]>? 0x149a
5274 012232 0x149a 5.2k 0000: 049a 5274 10011010 5.274,0 0.000000
Así que ahora sabemos que es 0x149a 5274 en decimal. Vamos a tratar esto como una contraseña.
$ ./crackme0x01
5274 Contraseña OK :)
Bingo, la contraseña era 5274. En este caso, la función de contraseña en 0x0804842b estaba comparando la entrada contra el valor, 0x149a en
hexadecimal. Desde la entrada del usuario suele ser decimal, que era una apuesta segura que la entrada estaba destinado a ser en decimal o
5274. Ahora, ya que somos los piratas informáticos, y la curiosidad que nos mueve, vamos a ver lo que sucede cuando la entrada en
hexadecimal.
$ ./crackme0x01
entrada como siendo realmente el valor hex. Y con esto concluye IOLI 0x01.
224
IOLI 0x01
225
IOLI 0x01
.Introducción
Después de algunos años de dejar de lado los juegos de guerra en Hacktivity , Este año por fin he encontrado el momento de
empezar, y casi terminar (sí, estoy muy avergonzado de que webhack sin terminar :)) uno de ellos. Hubo 3 juegos diferentes
en el conf, y he elegido el que fue proporcionada por avatao . Consistía en 8 desafíos, la mayoría de ellos web básico piratería
cosas, una caja de arena de escape, una sencilla desbordamiento del búfer de la explotación, y había dos ejercicios de
https://platform.avatao.com .
226
IOLI 0x01
.radare2
Me he decidido a resolver los retos de marcha atrás utilizando radare2 , Una fuente libre y abierto, con el sistema de ingeniería. He
aprendido primero sobre r2 terminada en 2011 durante un proyecto enorme, donde tenía que revertir una 11MB enlazado
estáticamente ELF masiva,. Simplemente necesitaba algo que podría fácilmente parchear ELF Linux con. Por supuesto, en ese
entonces he utilizado R2 junto con la AIF, y sólo para tareas más pequeñas, pero me encantó el concepto a primera vista. Desde
entonces, radare2 evolucionado mucho, y yo estaba planeando desde hace algún tiempo para resolver algunos crackmes con el
marco, y escribir los relatos acerca de ellos. Pues bien, este CTF me dio la oportunidad perfecta :)
Debido a que esta valoración crítica pretende mostrar algunas de las características de r2, además de cómo se pueden resolver los crackmes, voy a
explicar todos los comandos r2 que utilizo en los párrafos BlockQuote como éste:
punta r2:
Siempre usa ? o -h para obtener más información!
Si conoces a r2, y sólo está interesado en el crackme, puede saltarse las partes! También hay que tener en cuenta por favor, que a causa
de este estilo tutorial voy a hacer un montón de cosas que simplemente no se hace durante un CTF, porque no hay tiempo para llevar la
contabilidad adecuada (por ejemplo, la bandera de cada área de memoria en función de su propósito), y con tan pequeños ejecutables
Algunos consejos si usted está interesado en aprender radare2 (y francamente, si usted está en el RE, usted debe estar interesado
en aprender r2 :)):
El marco tiene una gran cantidad de ejecutables suplementarios y una gran cantidad de funcionalidad y ellos están muy bien
documentados. Me animo a leer los documentos disponibles, y utilizar la ayuda integrada (si se añade un? A cualquier
227
IOLI 0x01
[0x00000000]>?
[.]: Uso [veces] [cmd] [~ grep] [! @ [@ Iter] addr tamaño] [|> tubería]; ... Adjuntar '?' a cualquier comando de
carbón para obtener ayuda detallada Prefijo con el número de veces para repetir comandos N (f.ex: 3x) |% var =
| . [- |! (M) | f | sh | cmd] Definir macro o de carga R2, cparse o archivo rlang | = [Cmd]
. . .
[0x00000000]> a?
| Automóvil club británico analizar todos (fcns + bbs) (AA0 para evitar sub cambio de nombre)
. . .
Además, el proyecto está en fuerte desarrollo, no hay día sin que se compromete con el repositorio GitHub. Así que, como
dice el readme, se debe utilizar siempre la versión git! Algunos materiales de lectura muy recomendable:
Radare2 Wiki
228
IOLI 0x01
.primeros pasos
OK, suficiente de alabar r2, vamos a empezar a revertir esto. En primer lugar, usted tiene que conocer al enemigo:
falso
canario cierto nx
cierto
VA falsa cripto
cierto
ELF64
lang do
arco x86
los bits 64
Linux
lsyms verdaderos
falso
NINGUNA
binsz 8620
rabin2 es una de las herramientas útiles que viene con radare2. Se puede utilizar para extraer información
punta r2:
(importaciones, símbolos, bibliotecas, etc.) sobre binarios ejecutables. Como siempre, verifique la ayuda (-h rabin2)!
Por lo tanto, es una forma dinámica ligada, despojado, Linux de 64 bits ejecutable - nada especial aquí. Vamos a tratar de ejecutarlo:
pamparam incorrecto!
[0x00 avatao] $ "\ x01 \ x00 \ x00 \ x00" | Tamaño ./reverse4 de datos: 1
229
IOLI 0x01
Aceptar, por lo que se lee un número como el tamaño de la entrada estándar en primer lugar, que lee más, probablemente bytes
"tamaño" / caracteres, procesa esta entrada y salidas, ya sea "incorrecto!", Nada o algo más, presumiblemente nuestra bandera.
Pero no perder más tiempo monkeyfuzzing el ejecutable, vamos a iniciar r2, porque en asm confiamos!
- - Heisenbug: Un error que desaparece o altera su comportamiento cuando se intenta sondear o aislarlo. [0x00400720]>
punta r2: aaacomando en principio a analizar todo el código de referencia, por lo que tendrá funciones, cuerdas,
El parámetro -A corre
referencias externas, etc. justo al principio. Como de costumbre, puede obtener ayuda con?.
Es una buena práctica para crear un proyecto, por lo que puede salvar nuestro progreso, y que puede volver en un momento posterior:
[0x00400720]>
Puede guardar un proyecto utilizando Sal [Archivo], y cargar uno usando Po [Archivo]. Con la opción -p, se puede
punta r2:
0x00400e98 7 str.Wrong_
str.Your_getting_closer_ [0x00400720]>
R2 pone llamados banderas en las compensaciones importantes / interesantes, y organiza estas banderas en flagspaces
punta r2:
(cadenas, funciones, símbolos, etc.) Puede enumerar todos los flagspaces fs,
usando
OK, las cuerdas se ve interesante, sobre todo el de 0x00400f92. Parece dar a entender que este crackme se basa en una
230
IOLI 0x01
Estas cadenas pueden ser un buen punto de partida si estábamos hablando de una aplicación en la vida real con muchas-muchas
características. Pero estamos hablando de un crackme, y tienden a ser pequeños y simples, y se centró alrededor del problema a
resolver. Así que por lo general sólo echar un vistazo en el punto (s) de entrada y ver si puedo averiguar algo de allí. Sin embargo,
str.Your_getting_closer_
utilizar axfpara listar las referencias de la dirección). El @@ es un iterador, que sólo se ejecuta el comando una vez para cada
ejecutable conF,y utiliza el comando interno grep ~ para seleccionar sólo la primera columna
0])que contiene
([ las direcciones de las
cuerdas.
231
IOLI 0x01
.principal
A lo que iba, por lo general a echar un vistazo en el punto de entrada, así que vamos a hacer lo siguiente:
[0x00400720]> s principal
[0x00400c63]>
punta r2: s
Usted puede ir a cualquier desplazamiento, bandera, expresión, etc., en el ejecutable mediante el
comando (buscar). Puede utilizar referencias, como $$ (offset actual), puede deshacer
s-)o rehacer
( (s +)busca, cadenas de
búsqueda (s / [cadena])
o valores hexadecimaless(/ x 4142),
y un montón de otras cosas útiles. Asegúrese de revisar
s ?!
algo mucho más fresco: tiene un modo visual, y puede mostrar gráficos similares a la AIF, pero mucho más frías, ya que son los
La familia de comandos
punta r2: pagse utiliza para imprimir cosas. Por ejemplo, puede mostrar desmontaje
pd),desmontaje
(
de la función actualpdf),
( (cadenas de impresión
PD),hexdump (px),base64 codificar / decodificar datos ( P6D),
p6e, o imprimir
bytes primas (PR)por lo que puede, por ejemplo, volcar partes del binario a otros archivos. Hay muchas más funcionalidades,
comprobar?!
R2 también tiene una vista minimapa que es increíblemente útil para obtener una visión general de una función:
232
IOLI 0x01
233
IOLI 0x01
con el comandoVpuede introducir el llamado modo visual, que tiene varios puntos de vista. Se puede
punta r2:
el indicador). golpear
pagen la vista gráfica se abre el minimapa. Muestra los elementos básicos y las conexiones entre
ellos en la función actual, y también muestra el desmontaje del bloque actualmente seleccionado (marcado con
@@@@@ en el minimapa). Puede seleccionar el siguiente o el bloque anterior utilizando el * \ * y las teclas * \\ *
obuscar.
Es posible que aparezca el símbolo en modo visual utilizando la llave, y se puede utilizar
Podemos ver que el programa lee una palabra (2 bytes) en la variable local llamada
[0x00400c63]>? 0xbb8
3000 0xbb8 05670 2.9k 0000: 3000 10111000 0bb8 3000.0 0.000000f 0.000000
punta r2:
sip,? evaluará expresiones, e imprimir el resultado en varios formatos.
234
IOLI 0x01
En primer lugar, el "Tamaño de datos:" mensaje que vio cuando se corre el programa está impreso. Así que ahora sabemos que la variable
local local_10_6
es el tamaño de los datos de entrada - por lo que permite nombrar en consecuencia: (recuerde, usted puede abrir la concha r2
los affamilia comando se utiliza para analizar funciones. Esto incluye la manipulación de argumentos y variables locales
punta r2:
235
IOLI 0x01
input_size
Después de esto una bytes trozo largo memoria se asigna, y se llena con datos de la entrada estándar. La dirección
de nuevo:
Casi hemos terminado con este bloque, sólo hay dos cosas se mantuvieron. En primer lugar, un 512 (0x200) bytes trozo de memoria se
pone a cero a cabo en 0x00602120 offset. Un rápido vistazo a las referencias externas a esta dirección revela que esta memoria se
zona de memoria a largo bytes 0x200 en 0x602120. También es posible eliminar ( renombrar (fr [de edad] [nuevo]),
f-nombre), agregar
Mientras estamos aquí, también debe declarar ese pedazo de memoria como datos, por lo que se mostrará como un hexdump en vista de
desmontaje:
La familia de comandos
punta r2: dose utiliza para gestionar los metadatos. Puede configurar
CC)o (editar (CC)comentarios, declaran
Lo único que queda en este bloque es una llamada a la función 0x400a45 con los datos de entrada como un argumento. valor de
retorno de la función se compara con "*", y un salto condicional está ejecutado en función del resultado.
Antes he dicho que este crackme se basa probablemente en una máquina virtual. Pues bien, con esta información en mente, se puede
adivinar que esta función será bucle principal de la máquina virtual, y los datos de entrada es las instrucciones de la máquina virtual se
236
IOLI 0x01
función vmloop,
y rebautizadodatos de entrada
a código de bytes
y input_size
a bytecode_length.
Esto no es realmente necesario en un pequeño proyecto como este, pero es una buena práctica para nombrar las cosas de acuerdo a su
código de bytes
los afcomando se utiliza para analizar una función con un nombre dado en la dirección indicada. Los otros
punta r2:
Después de cambiar el nombre de las variables locales, marcar esa área de memoria, y cambiar el nombre de la función de bucle VM el
desmontaje se ve así:
nuestra bandera. Obviamente no queremos eso, así que seguimos la rama falsa.
237
IOLI 0x01
Ahora vemos que una cadena en esa área de memoria de 512 sym.memory)
bytes ( obtiene en comparación con "Tal VM!
Aceptar, por lo que ahora sabemos que tenemos que proporcionar un código de bytes que generará esa cadena cuando es ejecutado. Como
podemos ver en el minimapa, todavía hay unas cuantas más ramificaciones por delante, lo que probablemente significa más condiciones a
vmloop!
Si se echa un vistazo en el minimapa de toda la función, es probable que pueda reconocer que hay una especie de
[ 0d34]
[ 0d65]
[ 0d3d]
[ 0d61]
Estas son las fichas de montaje de los bloques. El primero pone 0 en la variable local
local_10_4:
Y éste se comparalocal_10_4
a 8, y la ejecución de un salto condicional en función del resultado:
238
IOLI 0x01
Es bastante obvio que es el contador del bucle, por lo que permite nombrarlo en consecuencia:
local_10_4
El área de memoria en 0x6020e0 es tratada como una matriz de dwords (4 valores de bytes), y se comprueba si el valor
239
IOLI 0x01
Se imprime el siguiente mensaje: Utilice todo "Como hemos establecido anteriormente, se trata de una máquina virtual En ese contexto
este mensaje probablemente significa que tenemos que utilizar cada instrucciones disponibles Ya sea que ejecuta una instrucción o no
es!.. almacenado en 0x6020e0 - por lo que permite la bandera de esa área de memoria:
Suponiendo que no rompemos y el bucle se completa, nos estamos moviendo encendido a más comprobaciones:
Esta pieza de código puede parecer un poco extraño si no está familiarizado con la materia específica x86_64. En particular, estamos hablando de
RIP-direccionamiento relativo, donde se describen los desplazamientos como desplazamientos desde el puntero de instrucción en curso, lo que
hace que la implementación de PIE más fácil. De todas formas, r2 es lo suficientemente bueno para mostrar la dirección real (0x602104). Consiguió
240
IOLI 0x01
Tenga en cuenta, sin embargo, que si se utiliza RIP-direccionamiento relativo, banderas no aparecerán directamente en el desmontaje,
Si sym.good_if_ne_zero
es cero, obtenemos un mensaje ( "Su cada vez más cerca!"), y el programa se cierra. Si es distinto de
Aquí, el programa compara un valor DWORD en 0x6020f0 (de nuevo, RIP-direccionamiento relativo) a 9. Si su mayor que 9, se
obtiene la misma "Su cada vez más cerca!" mensaje, pero si es menor o igual a
241
IOLI 0x01
Pues bien, parece que hemos invertido completamente la función principal. Para resumir: el programa lee un código de bytes de la
entrada estándar, y la alimenta a una máquina virtual. Después de la ejecución de VM, el estado del programa tienen que satisfacer
vmloop'
s valor de retorno tiene que ser "*"
sym.memory sym.instr_dirty
tiene que contener la cadena "Tal VM! CUÁNTO reV3rse!" los 9 elementos de array no debe
ser cero (probablemente significa que todas las instrucciones se tuvieron que utilizar al menos una vez)
Con esto concluye nuestro análisis de la función principal, podemos ahora pasar a la propia máquina virtual.
242
IOLI 0x01
.vmloop
[Desplazamiento]> fcn.vmloop
Bueno, eso parece decepcionantemente corta, pero no se preocupe, sin embargo, tenemos un montón de revertir. El caso es que esta
y R2 no puede reconocer tablas de salto ( Edición 3201 ), Por lo que el análisis de esta función es un poco incompleta. Esto significa
que en realidad no podemos usar la vista de gráfico ahora, para que ya sea que sólo tiene que utilizar el modo visual, o fijar esos
bloques básicos. La función entera está a sólo 542 bytes de longitud, por lo que sin duda podría revertir sin la ayuda del modo gráfico,
pero ya que esta valoración crítica pretende incluir tanta sabiduría r2 como sea posible, voy a mostrar cómo definir bloques básicos.
243
IOLI 0x01
todo correcto), y también sabemos que s primer argumento es el código de bytes. Por lo que permite cambiar el nombre de local_3:
vmloop'
Siguiente, sym.memory
se pone en otra variable local RBP-8
en R2 que no reconoció. Así que vamos a definir él!
de [nombre] y escriba [tipo]. También puede eliminar las variables locales utilizandomando.
el
afv- [idx]
En el siguiente bloque, el programa comprueba un byte de código de bytes, y si es 0, la función devuelve con 1.
Si ese byte no es cero, el programa resta 0x41 de ella, y compara el resultado con 0x17. Si es superior a 0x17,
obtenemos el temido "mal!" mensaje, y la función devuelve con 0. Esto significa básicamente que bytecodes válidos son
caracteres ASCII en el rango de "A" (0x41) a través de "X" (0x41 + 0x17). Si el código de bytes es válida, se llega a la
La base de la tabla de saltos está en 0x400ec0, por lo que permite definir esa área de memoria como una serie de QWords:
244
IOLI 0x01
[0x00400a74]> s 0x00400ec0
[0x00400ec0]> Cd 8 @@ = `? S $$ $$ + 8 * 0x17 8`
punta r2:
Excepto por el ?s,todas las partes de este comando deben estar familiarizados ahora, pero vamos a recapitular
Discos él!
compactos
define un área de memoria como datos, y 8 es el tamaño de esa área de memoria. @@ es un iterador que hacen la
carrera comando anterior para cada elemento que tiene @@. En este ejemplo se lleva a cabo una serie generadasmando.
utilizando el?
? ssimplemente genera una serie de la corriente de buscar ($$) para buscar la 0x17
actual($$
+8 8+ 0x17)con un paso de 8.
[0x00400ec0]> pd 0x18
0x0000000000400c04 0x00400f70.
Como podemos ver, la 0x400c04 dirección se usa mucho, y además de eso hay 9 direcciones diferentes. Vamos a ver que
0x400c04 primero!
245
IOLI 0x01
Obtenemos el mensaje "Wrong!", Y la función sólo devuelve 0. Esto significa que los que no son válidos (instrucciones de código de bytes
que son válidas sin embargo, pueden ser, por ejemplo parámetros!) Bandera Debemos 0x400c04 en consecuencia:
En cuanto a las otras compensaciones, todos parecen estar haciendo algo significativo, por lo que podemos suponer que pertenecen a las
Ok, por lo que estos desplazamientos no estaban en el gráfico, por lo que es el momento de definir los bloques básicos para ellos!
pertenece el bloque a, ¿de dónde empezar, y cuál es su tamaño. Si el bloque termina en un salto, tiene que especificar
dónde saltar también. Si el salto es un salto condicional, dirección de destino de la falsa rama debe especificarse
también.
Podemos obtener las direcciones de inicio y final de estos bloques básicos de la disasm llena de
vmloop.
246
IOLI 0x01
247
IOLI 0x01
Como he mencionado anteriormente, la función en sí es bastante corto y fácil de leer, especialmente con nuestras anotaciones. Pero
una promesa es una promesa, por lo que aquí es cómo podemos crear los bloques Bačić que faltan para las instrucciones:
También es evidente desde el desmontaje que además de las instrucciones que hay tres bloques básicos. Vamos a crear
ellos también!
[0x00400ec0]> AFB + 0x00400a45 0x00400c15 0x00400c2d-0x00400c15 0x400c3c 0x00400c2d [0x00400ec0]> AFB + 0x00400a45 0x00400c2d
Tenga en cuenta que los elementos básicos a partir de las 0x00400c15 y 0x00400c2d que termina en un salto condicional, así que tuvimos que
establecer el destino de la rama falsa también! Y aquí está el gráfico en todo su esplendor después de un poco de la reestructuración del manual:
248
IOLI 0x01
Creo que vale la pena, ¿verdad? :) (Bueno, la reestructuración realmente no vale la pena, ya que al parecer no se guarda
Se puede mover el nodo seleccionado en torno a la vista gráfico usando las teclas hjkl.
punta r2:
Por cierto, aquí es cómo gráfica de esta misma función de la AIF se ve como para la comparación:
249
IOLI 0x01
instr_LETTER
A medida que navega por el desmontaje de la elementos básicos, que deben darse cuenta de algunas cosas. La primera:
sym.instr_dirty
Se hizo evidente ahora que las 9 en dwords No son simplemente indicadores que consiguió una instrucción se
sym.good_if_le_9
ejecuta, sino que se utilizan para contar cuántas veces una instrucción fue llamado. También me he dado cuenta de que antes
(0x6020f0) es parte de esta matriz 9 DWORD, pero sí, bueno, yo no, tengo que vivir con ello ... De todas formas, lo que la
veces:
Otra similitud de las instrucciones es que 7 de ellos llama a una función, ya sea con uno o dos parámetros, donde los
parámetros son los próximos, o los próximos dos códigos de bytes. ejemplo un parámetro:
250
IOLI 0x01
También debemos darnos cuenta de que estos bloques indican que el número de bytes que se comen del código de bytes (1 byte de
instrucción + 1 o 2 bytes argumentos = 2 ó 3) en una variable local en 0xc. R2 no reconoció este var, por lo que permite hacerlo de forma
manual!
Si nos fijamos eninstr_Jpodemos ver que esto es una excepción a la regla anterior, ya que pone el valor de retorno de la función
de llamada eninstr_ptr_step
en lugar de una constante de 2 o 3:
Y hablando de excepciones, aquí están las dos instrucciones que no invocan funciones:
251
IOLI 0x01
VM retirado
instrucción, y sabemos que tiene que volver "*", por lo que "R *" deben ser los dos últimos bytes de nuestro código
vmloop
Esta es una instrucción de un argumento, y pone a su argumento 0x6020c0. Bandera esa dirección!
por el compilador. De todas formas, hasta ahora tenemos estas dos instrucciones:
instr_I
instr_D
instr_P
instr_X
instr_J
instr_A
instr_S
Lo que queda es la reversión de las siete funciones que son llamadas por las instrucciones, y, finalmente, la construcción de un
instr_A
La función de esta instrucción es llama en el desplazamiento 0x40080d, por lo que permite buscar allí!
[Desplazamiento]> 0x40080d
252
IOLI 0x01
punta r2:
En el modo visual puede simplemente presionar \ cuando la línea actual es un salto o una llamada, y r2 se tratará de la
dirección de destino.
Si buscamos a esa dirección desde el modo gráfico, se nos presenta con un mensaje que dice "No de una función. Tipo 'df' para
definir aquí. Esto es debido a que la función se llama desde un r2 bloque básico no reconoció, así que R2 no pudo encontrar la
df!Una función se crea de hecho, pero queremos un nombre significativo para él. Así
Drmientras
prensa que aún en modo visual, y el
Usted debe darse cuenta de que estos comandos son parte del mismo sistema de menú en el modo visual que estaba hablando
punta r2:
Ok, ahora tenemos nuestro nuevo y brillante vamos a invertirlo! Podemos ver en la forma del minimapa que probablemente hay
fcn.instr_A,
algún tipo de conexión en cascada si-entonces-elif, o una declaración switch de los casos implicados en esta función. Esta es una de las
razones que el minimapa es tan útil: se puede reconocer algunos patrones a simple vista, lo que le puede ayudar en su análisis Así, el
minimapa es fresco y útil (recuerde que el fácilmente reconocible para el bucle de unos pocos párrafos antes?) , pero me acabo de dar
cuenta que no tenía todavía a mostrar el modo gráfico completo, por lo que voy a hacer esto utilizando el gráfico completo. Los primeros
bloques básicos:
253
IOLI 0x01
Los dos argumentos de la función ( y RSI)se almacenan en las variables locales, y la primera se compara con 0. Si es así, la
RDI
función devuelve (se puede ver en el minimapa), de lo contrario la misma comprobación se ejecuta en el segundo argumento. La
función devuelve desde aquí también, si el argumento es cero. Aunque esta función es muy pequeño, voy a seguir con mi
local_2 arg2
Y hemos llegado a la sentencia switch de los casos se predijo, y podemos ver que
arg1'valor s se comprueba con
254
IOLI 0x01
la zona en la que tenemos que construir la "Tal VM! reV3rse tanto!" cuerda. Es seguro asumir que de alguna manera
sym.memory,
seremos capaces de modificar el valor almacenado en 0x602088, por lo que esta rama "M" será capaz de modificar otros bytes que
255
IOLI 0x01
sym.current_memory_ptr:
Sí, esta es la pieza de código que nos permite modificar se añade arg2
lo.
instr_S
Esta función no está reconocido, ya sea, por lo que tenemos que definir manualmente como lo hicimos con
instr_A.Después de que hacemos, y echar un vistazo al minimapa, desplazarse a través de los elementos básicos, es bastante obvio que
radiff2
estas dos funciones son muy-muy similar. Nosotros podemos usarpara ver la diferencia.
punta r2:
radiff2 se utiliza para comparar los archivos binarios. Hay algunas opciones que podemos controlar el tipo de diffing binario
Utilidad de la herramienta, y en qué tipo de formato de salida que desee. Una de las características interesantes es que puede generar DarumGrim
gramo
al estilo de gráficos utilizando el BinDiff -
opción.
256
IOLI 0x01
Desde ahora queremos diferencia de dos funciones del mismo binario, especificamos las compensaciones
gramo,con -
y utilizar reverse4 tanto para los binarios. Además, creamos los gráficos para comparar
a
instr_A
257
IOLI 0x01
Una triste verdad se revela después de un rápido vistazo a estos gráficos: radiff2 es un mentiroso! En teoría, las cajas grises deben ser idénticos,
los amarillos deben sólo se diferencian en algunos desplazamientos, y los rojos deben diferir en serio. Bueno, esto es obviamente no es el caso aquí
- por ejemplo, las cajas grises más grandes no son claramente idénticos. Esto es algo que definitivamente voy a echar un vistazo más profundo a
De todas formas, después de recibir el impacto de ser mentido, podemos reconocer fácilmente
instr_Ses
quebásicamente una
inversa instr_A:
cuando este último hace Además, el primero hace resta. Para resumir esta:
instr_I
258
IOLI 0x01
instr_D
instr_P
259
IOLI 0x01
Esta función también es bastante sencillo, pero hay una rareza: const_M nunca se utiliza. No sé por qué está allí - tal vez se
supone que debe haber algún tipo de distracción? De todas formas, esta función escribe simplemente
arg1a sym.current_memory_ptr,
siguiente byte. Hasta ahora esto parecería la instrucción ideal para construir la mayor parte del "Tal VM! ReV3rse tanto!"
cadena, pero recuerda, esto también es el que puede ser utilizado sólo 9 veces!
instr_X
instr_J
260
IOLI 0x01
Éste no es tan simple como los anteriores, pero no es tan complicado tampoco. Desde Obviamente estoy obsesionado con el cambio
de nombre de variable:
arg1 y 0x3f
Después de que el resultado de arg1 y 0x40
se pone en una variable local, arg1_and_0x3f
se compara con 0. Si no es cero,
es negado:
261
IOLI 0x01
de lo contrario se compruebaarg1_and_0x3f
si es un número negativo,
y si lo es, sym.good_if_ne_zero
se incrementa en 1:
262
IOLI 0x01
263
IOLI 0x01
.conjunto de instrucciones
Ahora hemos invertido todas las instrucciones de máquina virtual, y tener un conocimiento completo acerca de cómo funciona. Aquí es el conjunto de
+ + *sym.good_if_ne_zero; volver
arg1_and_0x3f; } Else return 2;
264
IOLI 0x01
.código de bytes
Bueno, lo hicimos la parte de ingeniería inversa, ahora tenemos que escribir un programa para la máquina virtual con el conjunto de
instrucciones se describe en el párrafo anterior. Aquí es las especificaciones funcionales del programa:
tiene que contener la cadena "Tal VM! CUÁNTO reV3rse!" después de la ejecución en los 9 instrucciones tienen
sym.memory
Desde este documento se trata de invertir, voy a dejar la parte de programación para el lector compañero :) Pero no voy a dejar con
las manos vacías, te voy a dar un consejo: A excepción de "J", la totalidad de la las instrucciones son simples, fáciles de usar, y que
no debería ser un problema para la construcción del "Tal VM! reV3rse tanto!" utilizarlos. "J", sin embargo es un poco complicado en
comparación con los otros. Uno debe darse cuenta de que su único propósito sym.good_if_ne_zero
es hacer mayor que cero, lo cual
sym.written_by_instr_C
no debe ser 0 cuando "J" se llama. Esto significa que "C", las instrucciones de "SC" "AC", o se
debe ser negativo en caso de control. Desde bit de signo de 0x3f es cero, no importa
arg1_and_0x3f arg1esqué
decir, el resultado de 0x3f será siempre no negativo. Pero recuerde que niega
arg1 y "J" Si arg1 y
arg1_and_0x3f 0x40
arg1_and_0x3f
no puede ser 0 o bien, al menos unoarg1'
de s 0 ª, 1º, 2º, 3º, 4º o 5º trozos deben ser 1 (0x3f =
00111111b).
Creo que esto es suficiente información, puede ir ahora y escribir ese programa. O, usted podría alterar el diseño del
\ X90 \ x00PSAMuAP \ x01AMcAP \ x01AMhAP \ x01AM AP \ x01AMVAP \ x01AMMAP \ x01AM! AP \ x01AM AP \ x01AMMA P \ x01AMuAP \ x01AMCAP \
x01AMHAP \ x01AM AP \ x01AMrAP \ x01AMeAP \ x01AMVAP \ x01AM3AP \ x01AMrAP \ x01 AMsAP \ x01AMeIPAM! X \ x00CAJ \ xc1SC \ x00DCR *
Tenga en cuenta, sin embargo, que fue escrito en la marcha, paralelo a la fase de marcha atrás - por ejemplo, hay partes
que se escriben sin el conocimiento de todas las instrucciones posibles. Esto significa que el código es feo y ineficiente.
265
IOLI 0x01
266
IOLI 0x01
.outro
¿Bien, qué puedo decir? Dicha máquina virtual, mucho más atrás! :)
Lo que comenzó como una valoración crítica simple para una sencilla crackme, se convirtió en algo muy largo writeup / r2 tutorial, así que
felicitaciones si usted ha leído a través de él. Espero que te haya gustado (Sé que lo hice), y tal vez incluso hayan aprendido algo de ella.
he aquí yo he aprendido mucho sobre R2 durante el proceso, e incluso he aportado algunos pequeños parches, y tengo algunas ideas de
267
Tarjeta de referencia
referencia
Mando Descripción
Flagspaces
Mando Descripción
fs flagspaces de visualización
banderas
Mando Descripción
F Lista de banderas
268
Tarjeta de referencia
Información
Mando Descripción
es secciones de visualización
IR reubicaciones de visualización
cadena de impresión
Mando Descripción
modo visual
Mando Descripción
269
Tarjeta de referencia
i/a/A (I) nsert hex, (a) código ssemble, visual (A) ssembler
buscando
270
Tarjeta de referencia
Mando Descripción
Ahorro
Mando Descripción
271
Tarjeta de referencia
Mando Descripción
$b Tamaño de bloque
$S sección desplazada
$ SS tamaño de la sección
Licencia
En este capítulo se basa en la tarjeta de referencia Radare 2 por Thanat0s, que está bajo la GNU GPL. licencia original es
el siguiente:
Esta tarjeta puede ser distribuido libremente bajo los términos de la licencia GNU público en general - Copyright C •••• por
Thanat0s - v0.1 -
272
Tarjeta de referencia
273