Anda di halaman 1dari 273

Traslate by SoftDat CLS

Tabla de contenido

Introducción 1.1

Introducción 1.2

Historia general 1.2.1

radare2 Conseguir 1.2.2

1.2.3

La recopilación y compilación de 1.2.4

Portabilidad en Windows Banderas de 1.2.5

línea de comandos básicos Formato 1.2.6

Comando Uso Expresiones Rax2 1.2.7

1.2.8

1.2.9

1.2.10

Depurador Sesión básicos que 1.2.11

contribuyen a la configuración radare2 1.2.12

1.3

Colores 1.3.1

Variables de configuración de comandos 1.3.2

básicos comunes 1.4

Buscando tamaño de bloque 1.4.1

Secciones modos de impresión 1.4.2

de archivos de asignación de 1.4.3

Banderas Escribir zoom yanqui 1.4.4

/ Pegar Comparando modo 1.4.5

Visual Bytes SDB 1.4.6

1.4.7

1.4.8

1.4.9

1.4.10

1.4.11

1.5

2
Desmontaje visual visual 1.5.1

ensamblador Visual Editor de 1.5.2

configuración de búsqueda bytes 1.5.3

1.6

Búsquedas básicas 1.6.1

Configurando el Patrón de 1.6.2

búsqueda Búsqueda de 1.6.3

automatización hacia atrás Buscar 1.6.4

Buscar en la Asamblea Buscando 1.6.5

AES Keys 1.6.6

1.6.7

firmas 1.7

Las firmas 1.7.1

que desmontan 1.8

Adición de metadatos 1.8.1

ESIL Scripting 1.8.2

1.9

Macros 1.9.1

bucles 1.9.2

R2pipe 1.9.3

Rabin2 1.10

Las importaciones presentar 1.10.1

identificación Punto de 1.10.2

entrada Imports 1.10.3

1.10.4

Símbolos (exportaciones) 1.10.5

Cuerdas Bibliotecas 1.10.6

1.10.7

Las partes del programa 1.10.8

Radiff2 1.11

Binaria diffing 1.11.1

Rasm2 1.12

montar 1.12.1

Desmontar 1.12.2

3
Análisis 1.13

Ragg2 1.14

Código Análisis 1.14.1

Rahash2 1.15

Rahash herramienta 1.15.1

depurador 1.16

Empezando 1.16.1

La migración de ida, GDB o WINDBG Registros 1.16.2

1.16.3

Depuración inversa 1.16.4

Capacidades de acceso remoto 1.17

Las capacidades de comunicación 1.17.1

remota GDB remoto 1.17.2

plugins 1.18

Plugins 1.18.1

Crackmes 1.19

IOLI 1.19.1

IOLI 0x00 1.19.1.1

0x01 IOLI 1.19.1.2

Avatao 1.19.2

R3v3rs3 4 1.19.2.1

.Introducción 1.19.2.1.1

.radare2 1.19.2.1.2

. primeros pasos 1.19.2.1.3

. principal 1.19.2.1.4

. vmloop 1.19.2.1.5

. conjunto de instrucciones 1.19.2.1.6

. código de bytes 1.19.2.1.7

. outro 1.19.2.1.8

Tarjeta de referencia 1.20

4
Introducción

R2 "libro"

Bienvenido al libro Radare2


Página web: https://www.gitbook.com/book/radare/radare2book/details

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

Reelaborar por Maijin de los colaboradores del libro radare

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

El libro original de radare

autor original y saludos de El libro radare : Crepe

Dios. también conocido como Flying Spaghetti Monster

Nibble (puerto w32 depurador, syscallproxying, puntos de interrupción HW ..) chicos nopcode (por

los contras y atractivo pandas (ELF32 / 64 y PE analizador + montón de correcciones de errores y el

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

de código fuente son muy apreciadas.

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,

incluyendo Ruby, Python, Lua, y Perl.

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

bibliotecas, secciones, etc.

rasm2

Un ensamblador de línea de comandos y desensamblador para múltiples arquitecturas (incluyendo Intel x86 y x86-64,

MIPS, ARM, PowerPC y Java).

Ejemplos

$ Rasm2 java -a 'nop' 00

$ Rasm2 -a -d x 86 '90' nop

$ Rasm2 -a -b x 86 32 'mov eax, 33' b821000000

$ Echo 'eax empuje; nop; nop' | rasm2 -f 509090

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

archivo: 0x00000000-0x00000007 sha256: 887cfbd0d44aaff69f7bdbedebd282ec96191cce9d7fa73362 98a18efc3c7a5a

$ Archivo rahash2 -un MD5

archivo: MD5 0x00000000-0x00000007: d1833805515fc34b46c2b9de553f599d

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

de la AIF mediante el script idc2rdb RSC.

rafind2

Un programa para encontrar patrones de bytes en archivos.

ragg2

Un frontend para r_egg. ragg2 compila los programas escritos en un simple lenguaje de alto nivel en pequeños binarios para

x86, x86-64, y ARM.

Ejemplos

10
Visión de conjunto

$ Hi.r gato

/ * Hola mundo en r_egg * /

escribir @ syscall (4); // 64 de escritura @ syscall (1); salida @ syscall (1);

// x64 salida @ syscall (60);

@ mundial principal (128) {

. var0 = "hi \ n"; de escritura (1,

.var0, 4); de salida (0); }

$ Ragg2 -O -F hi.r $ ./hi Hola!

$ Hi.c gato

principal @ mundial (0,6) {

de escritura (1, "Hello0", 6); de salida

(0); }

$ Ragg2 hi.c $

./hi.c.bin Hola

rarun2

Un lanzador para ejecutar programas dentro de los diferentes entornos, con diferentes argumentos, permisos, directorios

y descriptores de archivo por defecto anulados. rarun2 es útil para:

Crackmes suites

de prueba

Fuzzing

script de muestra de rarun2

$ Foo.rr2 gato

#! / Usr / bin / programa rarun2

=. / PP400 arg0 = 10 = entrada

estándar foo.txt chdir = / tmp

# = Chroot.

. /foo.rr2

Conexión de un programa a un zócalo

11
Visión de conjunto

$ Nc -l 9999

del programa $ rarun2 = / bin / ls conectar = localhost: 9999

Depuración de un programa mediante la reorientación de IO a otro terminal

1 - abrir una nueva terminal y el tipo 'TTY' para obtener un nombre de terminal:

$ TTY; claro ; 999999 dormir / dev / ttyS010

2 - Crear un nuevo archivo con el siguiente perfil rarun2 foo.rr2 llamado:

# ! / Usr / bin / programa rarun2 =

/ bin / ls stdio = / dev / ttys010

3 - Poner en marcha el siguiente comando radare2: r2 -R foo.rr2 -d ls

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

$ Rax2 1337 0x539

$ Rax2 0x400000 4194304

$ 01.111.001 y rax2 -b

$ Rax2 -S radare2

72616461726532

$ Rax2 -s 617765736f6d65 impresionante

12
Visión de conjunto

13
radare2 conseguir

radare2 conseguir

Puede obtener radare de la página web, http://radare.org/ , O el repositorio GitHub,

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:

$ Git clone https://github.com/radare/radare2.git

Esto probablemente tomará un tiempo, por lo que tomar un café y seguir leyendo este libro. Para actualizar su copia local

del repositorio, el uso


git pullen cualquier parte del árbol de código fuente radare2:

$ Git pull

Si tiene modificaciones locales de la fuente, puede volver ellos (y perder ellos!) Con:

$ Git reset CABEZA --hard

O bien, enviando un parche:

$ Git diff> radare-foo.patch

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

objetos después de un cambio de ABI.

Los siguientes comandos pueden ayudarle a obtener el clon de git al día:

$ Git -xdf limpia $ git reset --hard @ ~ 10

$ git pull

Si desea quitar las instalaciones anteriores de su sistema, debe ejecutar los siguientes comandos:

$ ./configure --prefix = / usr / local $ maquillaje de purga

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

y arquitecturas (incluyendo TCC y SunStudio) diferentes.

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

(Intel x86 y x86_64). Hay planes para apoyar Solaris y MacOS X.

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):

$ ./configure --prefix = / usr $ gmake

$ Sudo GAsegúrese instalar

También hay un script sencillo para hacer esto de forma automática:

$ 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

distribución REMnux de SANS, y está disponible en la ventana acoplable registryhub .

dieciséis
Compilación y Portabilidad

Limpieza de instalaciones de hasta Viejo Radare2

. / Configure --prefix = / / r2 / prefijo / instalación de edad que purga

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

también requiere Ninja. Puede descargarlo desde aquí . ninja.exe


Dupdobinario en su carpeta radare2. Entonces corre
meson.baty

esperar hasta que se realiza la compilación.

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.

Utilizando MSBuild: Llamada


meson.bat --msbuild

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

mismo lugar. El comando de abajo recoger todo y ponerlo en


dist carpeta.
el

MI:\ radare2 > sys \ dist meson_install.bat

Ahora puede probar su binario radare2 recién hecha fácil:

18
Compilación en Windows

MI:\ radare2 > cd dist E : \ radare2 \ dist > radare2.exe - v

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

automática adecuada de coronamiento:

git config --global core.autocrlf cierto

git config --global core.filemode falso

El siguiente es un ejemplo de compilar con MinGW32 (es necesario tener instalado cremallera para ventanas):

CC = i486-mingw32-gcc ./configure make

hacer w32dist

zip -r w32-build.zip w32-build

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

hay un guión en fuentes radare2:

Simplemente
sys / mingw32.bat. ejecutarlo desde el cmd.exe (o ConEmu / cmd.exe). Se supone que se ha instalado en

Mingw32C: \ Mingwy en GitC: \ Archivos de programa (x86) \ Git.


Si desea utilizar otro instalaciones, acaba de establecer
MINGW_PATH y GIT_PATH

las variables correspondientemente:

establecer MINGW_PATH = D: \ Mingw32

set "GIT_PATH = E: \ Program and Stuff \ Git" sys \ mingw32.bat

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

pueden implementar en Windows o del vino:

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

automática adecuada de coronamiento:

git config --global core.autocrlf falso

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

compatible con más colores y símbolos Unicode si la acumulación usando el anterior.

Mingw-W64

Descargar la distribución MSYS2 desde el sitio oficial: http://msys2.github.io/

Configuración del proxy (si es necesario):

exportar http_proxy = <miusuario>: <mypassword> @ zz-wwwproxy-90-v: 8080

exportar https_proxy = $ http_proxy

exportar ftp_proxy = $ http_proxy

exportar RSYNC_PROXY = $ http_proxy

exportar RSYNC_PROXY = $ http_proxy

exportar no_proxy = "Localhost, 127.0.0.1, LocalAddress, .localdomain.com"

Los paquetes de actualización:

cadena pacman --needed -Sy golpe pacman pacman-espejos msys2-runtime MinGW-w64-x86_64-herramienta

Cierre MSYS2, ejecutarlo de nuevo desde el menú Inicio y actualizar el resto con

pacman -Su

Instalar los elementos esenciales de construcción:

pacman -S git maquillaje zip del parche gcc

20
Compilación en Windows

Compilar el radare2:

. / Configuración --with-ostype = ventanas; hacer ; hacer w32dist

encuadernaciones

Para construir enlaces de radare2, tendrá que instalar Vala (valac) para Windows

A continuación, descargue valabind y construirlo:

Git clon https://github.com/radare/valabind.git valabind

discos compactos valabind

hacer

make install

Después de que ha instalado valabind, se puede construir radare2-fijaciones, por ejemplo para Python y Perl:

Git clon https://github.com/radare/radare2-bindings.git radare2 encuadernaciones

discos compactos radare2 encuadernaciones

. / Configure --enable = Python, Perl maquillaje

make install

21
Banderas de línea de comandos

Opciones de línea de comandos

El núcleo radare acepta muchas banderas de línea de comandos. Un extracto

del mensaje de uso ayuda:

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

- un [arco] conjunto asm.arch

- UN ejecutar 'AA' de comandos para analizar todo el código de referencia

- b [bits de] asm.bits conjunto

- B [baddr] establecer dirección base para binarios PIE

- c 'cmd ..' ejecutar el comando radare

- do archivo es host: puerto (alias para -c + = http: //% s / cmd /)

- re utilizar 'archivo' como un programa de depuración

- el modo de depuración D [backend] habilitar (e cfg.debug = true)

- ek=v evaluar var config

- F tamaño de bloque = tamaño del archivo

- h, hh Mostrar mensaje de ayuda, hh por mucho tiempo

- i [Archivo] archivo de secuencia de comandos ejecutada

- k [kernel] establecer asm.os variable para asm y anal

- l [lib] archivo plugin de carga

- L Lista apoyado plugins IO

- m [addr] archivo de mapa en la dirección indicada

- norte análisis disable

- norte desactivar la configuración del usuario

- q el modo silencioso (sin puntual) y se retiró después de -i

- p [prj] archivo de proyecto conjunto

- P [Archivo] solicitar el archivo y salga de rapatch

- s [addr] iniciales obtengan

- S iniciar R2 en modo de recinto

- t cargar información rabin2 en hilo

- V, -V versión espectáculo radare2 (-V muestran versiones lib)

- w archivo abierto en modo de escritura

los patrones de uso comunes de opciones de línea de comandos.

Abrir un archivo en modo de escritura sin necesidad de analizar los encabezados de formato de archivo. archivo

$ r2 -nw

obtener rápidamente en una cáscara r2 sin necesidad de abrir cualquier archivo. $ R2 -

Especificar qué sub-binario que desea seleccionar al abrir un archivo fatbin:

22
Banderas de línea de comandos

$ R2 -a -b 32 ppc ls.fat

Ejecutar un script antes de mostrar indicador de línea de comandos interactivo:

$ R2 -i patch.r2 target.bin

Ejecutar un comando y salir sin entrar en el modo interactivo:

$ R2 -QC ij hi.bin> imports.json

Configurar una variable eval:

$ R2 = -e scr.color BLAH.BIN falsa

Depurar un programa:

$ Ls -d r2

Utilizar un archivo de proyecto existente:

prueba $ r2 -p

23
Uso básico

Uso básico Radare

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

una expresión como argumento. La expresión puede ser algo así


10,como o [0x100 + ptr_table].
+ 0x25, Si está trabajando con archivos

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

comandos para navegar por este camino.

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

frecuentespx para imprimir en formato hexadecimal,


pd para
y el desmontaje.

Que se le permitiera escribir archivos, especifique


w opción
la - de radare al abrir un archivo.w los

comando se puede utilizar para escribir secuencias, hexpairs


x subcomando),
( o incluso opcodes de montaje
un subcomando).
(

Ejemplos:

> hola mundo w ; cuerda

> wx 90 90 90 90 ; hexpairs

> wa JMP 0x8048140 ; armar

> inline.bin WF ; escribir el contenido del archivo

Al añadir una? a un comando mostrará su mensaje de ayuda, por ¿pag?


ejemplo,
.

Para entrar en el modo visual, pulse


V <ENTER>.Utilizarq para salir del modo visual y volver al indicador. En el modo visual puede utilizar las teclas para

navegar hjkl (izquierda, abajo, arriba, ya la derecha, respectivamente). Puede utilizar estas teclas en el modo de cursor
do llave.
quitarse
Para o

seleccionar un rango de bytes en modo de cursor, mantenga pulsadaCAMBIO


la tecla
y las claves principales de prensa de navegación hjkl para marcar

su selección. Mientras

24
Uso básico

en el modo visual, también se puede sobrescribir bytes pulsando


yo . Puede pulsar
LENGÜETA para cambiar entre el hexágono (medio) y

las columnas de cadena (derecha). Prensado


q dentro del panel hexagonal se vuelve al modo visual.

25
Formato de los comandos

Formato de los comandos

Un formato general para los comandos radare es el siguiente:

[tiempos] [cmd] [~ grep] [@ [@ iter] addr tamaño!] [|> tubería] [.];

Los comandos se identifican por un solo caso sensible carácter [a-zA-Z]. Repetir la ejecución de un comando,

el comando prefijo con un número:

px # ejecutar px

3px # ejecutar px 3 veces

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:

ds ; llame al comando 'paso' del depurador

@ 200 px esp ; mostrar 200 bytes hexadecimales en esp

PC> file.c ; volcar tampón como una matriz de bytes C a file.c

wx 90 @@ sym. * ; escribir una nop en cada símbolo

pd 2000 | eax grep ; grep códigos de operación que utilizan el 'EAX' registrarse

px 20; pd 3; px 40; varios comandos en una sola línea

Los @ carácter se utiliza para especificar un desplazamiento temporal en el que se ejecutará el comando a su izquierda. a

continuación, se restaura la posición original en buscar un archivo. Por pd


ejemplo, 5 de desmontar las instrucciones en
5 @ 0x100000fce

la dirección 0x100000fce. el ~ carácter permite la función grep-como interno utilizado para filtrar la salida de cualquier comando. Por

ejemplo:

pd 20 ~ llamada ; 20 desensamblar instrucciones y salida de grep para 'llamada'

Además, puede grep para las columnas o filas:

pd 20 ~ llamada: 0 ; obtener información de primera fila

pd 20 ~ llamada: 1 ; obtener la segunda fila

pd 20 ~ llamada [0] ; obtener la primera columna

pd 20 ~ llamada [1] ; obtener la segunda columna

26
Formato de los comandos

O incluso combinarlos:

pd 20 ~ llamada: 0 [0] ; grep la primera columna de la primera fila coincidente 'llamar'

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.

Tenga en cuenta, que es posible ver la historia de los comandos usando

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

con el comando? . Por ejemplo:

[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

[0xB7F9D810]>? 0x8048000 + 0x34

134512692 01001100064 0x8048034 128.0M 804000: 0034 134512692 00110100 134512692,0 0.00 0000

[0xB7F9D810]>? 1 + 2 + 3-4 * 3

- 6 0xfffffffffffffffa 01777777777777777777772 17179869183.0G fffff000: 0ffa -6

operaciones aritméticas soportados son:

+ : adición

- : la resta

* : Multiplicación /:

división%: módulo

> : Desplazamiento

a la derecha <: desplazamiento a la izquierda

El uso de lógica o debería ser escapó el uso de citas, o será confundido con un tubo de opeator:

[0x00000000]> "1 | 2?"

3 0x3 03 3 0000: 0003 3 "\ x03" 00000011 2.0 2.000000f 2.000000

Los números se pueden mostrar en varios formatos:

0x033: hexadecimal se puede mostrar 3334

: decimal

sym.fo: bandera determinación compensado 10K

: KBytes 10 * 1024 10M

MBytes: 10 * 1024 * 1024

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 ~ ??)

ps ; las variables show disponibles '$'

$$ ; aquí (la corriente virtual de búsqueda)

$l ; longitud de código de operación

$s ; tamaño del archivo

$j ; saltar dirección (por ejemplo JMP 0x10, 0x10 jz => 0x10)

$f ; saltar fallar la dirección (por ejemplo, JZ 0x10 => siguiente instrucción)

$m ; opcode referencia de memoria (por ejemplo, mov eax, [0x10] => 0x10)

Algunos ejemplos más:

[0x4A13B8C0]>? + $ L $ m

140293837812900 0x7f98b45df4a4 03771426427372244 130658.0G 8b45d000: 04a4 1402938378129

00 10100100 140,293,837,812,900.0 -0.000000

[0x4A13B8C0]> pd 1 @ + $ l 0x4A13B8C2 llamar

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

Uso: rax2 [opciones] [expr ...] = [base]

; rax2 = 10 0x46 -> salida en base 10

int -> hexagonal ; rax2 10

hex -> int ; 0xa rax2

- int -> hexagonal ; rax2 -77

- hex -> int ; rax2 0xffffffb3

int -> bin ; b30 rax2

int -> ternaria ; t42 rax2

bin -> int ; 1010D rax2

flotar -> hexagonal ; 3.33f rax2

hex -> float ; rax2 Fx40551ed8

Oct -> hexagonal ; 35o rax2

hex -> octubre ; rax2 OX12 (O es una carta)

bin -> hexagonal ; rax2 1100011b

hex -> bin ; rax2 BX63

hex -> ternaria ; rax2 Tx23

prima -> hexagonal ; rax2 -S </ binfile

hex -> cruda ; rax2 -s 414141

- segundo bin -> str ; rax2 -b 01000101 01110110

- segundo str -> bin ; rax2 -B hola

- re número entero fuerza ; rax2 -d 3 -> 3 en lugar de 0x3

- mi intercambiar endianness; rax2 -e 0x33

- mi codificar base64 ;

- F punto flotante ; rax2 -f 6,3 + 2,1

- F stdin hex SLURP C; rax2 -F <shellcode.c

- marido ayuda ; rax2 -h

- k mantener la base ; rax2 -k 33 + 3 -> 36

- K randomart ; rax2 -K 0x34 1020304050

- norte número binario ; rax2 -n 0x1234 # 34120000

- norte número binario ; rax2 -N 0x1234 # \ x34 \ x12 \ x00 \ x00

- r salida estilo r2; rax2 -r 0x1234

- s hexstr -> cruda ; rax2 -s 43 4a 50

- S prima -> hexstr ; rax2 -S </ bin / ls> ls.hex

- t tstamp -> str ; rax2 -t 1234567890

- x cadena de hash ; rax2 Linux -x OSX

- u unidades ; rax2 -u 389289238 # 317.0M

- w firmado palabra ; rax2 -w 16 0xffff

- v versión ; rax2 -v

30
Rax2

Algunos ejemplos:

$ Rax2 3 + 0x80 0x83

$ Rax2 0x80 + 3 131

$ Echo 0x80 + 3 | rax2 131

$ Rax2 -s 4142 AB

$ Rax2 -S AB 4142

$ Rax2 -S <bin.foo

. . .

$ Rax2 -e 33

0x21000000

$ Rax2 -e 0x21000000 33

$ Rax2 -K 90203010

+ - - [0x10302090] --- + | Eo. .

|.... |

| o |

| . |

| S |

| |

| |

| |

| |

+ -- - - - - - - - - - - - - - - - +

31
Sesión básica depurador

Sesión básica depurador

Para depurar un programa, comenzar con el radare


re opción.
- Se pueden adjuntar a un proceso que se ejecuta mediante la especificación

de su PID, o puede iniciar un nuevo programa especificando su nombre y parámetros:

$ Pidof MC 32220

$ R2 -d 32220

$ R2 -d / bin / ls

En el segundo caso, el depurador se bifurcará y cargar el depurador


ls programa en la memoria. Se hará una pausa en su ejecución a

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

radaree dbg.bep = entrada


o e dbg.bep = main
a su script de inicio, por lo general esradare2rc.
~ /. Se advierte sin embargo que ciertas software

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:

> ¿re? ; obtener ayuda sobre los comandos del depurador

> ds 3 ; Paso 3 veces

> db 0x8048920; configuración de un punto de interrupción

> db -0x8048920; eliminar un punto de interrupción

> corriente continua ; continuar la ejecución de procesos

> DCS ; continuará hasta syscall

> dd ; manipular los descriptores de fichero

> dm ; mapas de procesos espectáculo

> dmp A S rwx; cambiar de página en página con permisos de protección de tamaño S

> dr eax = 33; conjunto de valores de registro. eax = 33

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

ejemplo, EIP para x86). Prensado


pag se puede navegar a través del resto de puntos de vista modo visual. Puede
pagpulsar
y PAG

para girar a través de la impresión más comunes

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

Puede establecer puntos de interrupciónF2con


llave. En el modo visual puede introducir comandos regulares radare anteponiendo con: . Por

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

Un comando es utilizado con frecuencia


Dr , para leer o escribir valores de registros de propósito general del objetivo.

También puede manipular el hardware y registros de coma flotante ampliada /.

33
Contribuyendo a radare2

contribuyendo

Radare2 libro

Si quieres contribuir al libro Radare2, puede hacerlo en el repositorio de Github . contribuciones sugeridas

incluyen:

Crackme los relatos los

relatos CTF

Documentación sobre cómo utilizar Radare2 documentación sobre el desarrollo de

presentaciones de la conferencia Radare2 / talleres utilizando Radare2 Falta

contenido del libro Radare1 actualizado para Radare2

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

El núcleo lee ~ radare2rc


/. mientras que a partir. Puedes añadir
mi comandos de este archivo de configuración para sintonizar radare a

su gusto.

Para evitar radare de analizar este archivo en el arranque, pasarlo


norteopción.
- Toda la configuración de radare se

realiza con la
eval comandos. Un archivo de configuración inicial típica es el siguiente:

$ Cat ~ / .radare2rc e scr.color = true

e dbg.bep = cargador

La configuración también se puede cambiar mi


conopción
- de línea de comandos. De esta manera usted puede ajustar la configuración

de la línea de comandos, manteniendo el archivo .radare2rc intacta. Por ejemplo, para comenzar con la configuración vacía y luego

ajustarscr.colory asm.syntaxla siguiente línea se puede utilizar:

$ Radare2 -n -e scr.color = true -e asm.syntax = Intel -d / bin / ls

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

salida a un espacio de nombres seleccionado, pasarlo con un punto


e. Por
finalejemplo,
a archivo de correo.

mostrará todas las variables definidas en el interior del espacio de nombres "archivo". Para

obtener ayuda acerca


mi tipo de comando
¿mi? :

Uso: [?] E [var [= valor]] e?

mostrar esta ayuda

e? asm.bytes mostrar descripcion

¿¿mi?? lista de variables de configuración con la descripción

mi lista de variables de configuración

mi- reinicia variables de configuración

mi* config volcado vars en órdenes r

e! una invertir el valor booleano de 'a' var

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

obtener el valor de var 'a'

ea=b set var 'a' el valor 'b'

env [k [= v]] obtener / establecer la variable de entorno

35
Configuración

Una alternativa más simplemiacomando es accesible desde el modo visual. ve


Tipo
para entrar en él, utilice las flechas (arriba, abajo,

izquierda, derecha) para navegar por la configuración


q para
y salir de ella. La pantalla inicial para la configuración de edición visual se

ve así:

eval espacios:

> anal asm

scr bin asm

cfg diff dir

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:

[0x00000000]> e = scr.nkey? scr.nkey =

diversión, golpear, bandera

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:

$ Echo 'e scr.color = true' >> ~ / .radare2rc

Es posible configurar el color de casi cualquier elemento de salida de desmontaje. Para los terminales * NIX, R2 acepta especificación de color en

formato RGB. Para cambiar el color de la paleta de utilización de la consola


CE mando. Tipo
CE para obtener una lista de todos los colores que se

utilizan actualmente. Tipo


ECS para mostrar una paleta de colores a escoger los colores de:

37
Colores

tema xvilka

38
Colores

ec fnombre rgb: 0cf Etiqueta CE

rgb: 0f3 ec matemáticas RGB:

660 ec bin rgb: f90 ec llamada

RGB: f00 ec JMP rgb: 03f ec rgb

CJMP: 33c ec compensado

RGB: 366 ec comentario rgb: 0cf

ec empuje rgb: 0C0 ec rgb pop:

0C0 ec cmp RGB: 060 ec nop

RGB: 000 ec b0x00 RGB: 444 ec

b0x7f RGB: 555 ec b0xff RGB:

666 ec btext RGB: 777 ec otra

rgb: bbb ec num rgb: F03 ec reg

rgb: 6f0 ec fline rgb: FC0 rgb

flujo ec: 0F0

39
Variables de configuración común

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

Define arquitectura de la CPU de destino utilizado para desmontar


PD, PD comandos)
( y análisis de código
un mando).
(

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

destino son compatibles con todas las combinaciones de asm.bits.

asm.syntax

Los cambios de sabor sintaxis para desensamblador entre Intel y AT & T. Por el momento, este ajuste afecta Udis86

desensamblador para Intel 32 / Intel solamente 64 objetivos. Los valores admitidos


Intel son

y att.

asm.pseudo

Un valor booleano para elegir un motor de cadena de desmontaje. "Falso" indica un nativo, definido por la arquitectura actual,

"verdadero" activa un formato de cadenas de pseudocódigo; por ejemplo, seeax


mostrará
= ebxen lugar de un
mov eax, ebx.

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

Si se define a "true", vista desensamblador tendrá columna de banderas.

asm.lines.call

Si se establece en "true", dibujar líneas en la parte izquierda de la salida de desmonte


PD, PD comandos)
( para representar gráficamente los

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,

y es el que viene por defecto.

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

código de operación. Se utiliza para ayudar a los programas el análisis de trazas.

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

Esta variable booleana activa o desactiva la salida de la pantalla coloreada.

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

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

segundo carácter del nombre del comando. Por ejemplo,


foo es/un comando para buscar la cadena normal, mientrasx que
90 90/se

utiliza para buscar parejas hexadecimales.

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,

> 3s +1024 ; busca tres veces desde 1024 la corriente buscan

Si un comando comienza con =! , El resto de la cadena se pasa a cargado actualmente IO complemento (un depurador, por ejemplo). La

mayoría de los plugins proporcionan mensajes de ayuda con = !? o. =!


ayuda

$ R2 -d / bin / ls

> =! Ayuda ; manejado por el plugin IO

Si un comandos comienza con! , Posix_system () es llamado para pasar el comando a su concha. Compruebe!? para más

opciones y ejemplos de uso.

> ls! ; ejecutar `ls` en la cáscara

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.

Algunos comandos aceptan las expresiones matemáticas, o cadenas.

> px 0x17 ; mostrar 0x17 bytes de hexa a corriente buscar

> s base + 0x33; busca bandera 'base' más 0x33

> / lib ; buscar cadena 'lib'.

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.

> p8 10 @ 0x4010; mostrar 10 bytes en el desplazamiento 0x4010

> f patata @ 0x10; establecer el indicador 'patata' en desplazamiento 0x10

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

> / lib ; Búsqueda cadena 'lib'

> p8 20 @@ hit0_ *; mostrar 20 hexpairs en cada golpe de búsqueda

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'

> f> flags.txt; volcar lista de banderas a 'flags.txt'

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

como entrada a otro.

[0x4A13B8C0]> f | grep sección | grep texto 0x0805f3b0 512 section._text

0x080d24b0 512 section._text_end

Puede pasar varios comandos en una sola línea separándolos con punto y coma; :

> px; Dr

44
buscando

buscando

La posición de búsqueda actual se cambias con


mando. Se acepta una expresión matemática como argumento. La expresión puede estar

compuesto por las operaciones de cambio, operaciones matemáticas básicas, o las operaciones de acceso a memoria.

[0x00000000]> s? Uso: s [+ -] [dir]

imprimir dirección actual

s 0x320 buscar a esta dirección

s- deshacer buscar

s+ rehacer buscar

s* lista de deshacer buscar la historia

s ++ buscan los bytes de bloque hacia adelante

s-- buscar hacia atrás bytes Blocksize

s + 512 512 bytes buscar hacia adelante

s- 512 buscar hacia atrás 512 bytes

SG / SG seek comenzar (SG) o al final (SG) de la sección o archivo

s.hexoff Busque en honor a una base de núcleo-> compensado

sa [[+ -] a] [ASZ] buscan ASZ (o bsize) alineado a addr sn / sp

buscar siguiente / ant scr.nkey

s / DATOS buscar siguiente aparición de 'DATA'

s / x 9091 buscar siguiente aparición de \ x90 \ x91

sb seek alineados en bb inicio

así [num] tratar de N siguiente código de operación (s)

sf buscar a la siguiente función (f-> addr + f-> tamaño)

str sC tratar de comentar cadena coincidente dada

PC sr solicitar el registro

> 3s ++ ; 3 veces bloque de búsqueda

> s 10 + 0x80; buscar en 0x80 + 10

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.

> ? 0x100 + 200

0x1C8; 456d; 710o; 1100 1000

En el modo visual puede pulsar


u ( deshacer) o
T ( rehacer) dentro de la historia tratará de volver de nuevo a anterior o avanzar

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

abrirlo con radare2

hola_mundo r2

Ahora tenemos símbolo del sistema

[0x00400410]>

Ahora estamos listos para ir más profundo.

Buscando en cualquier posición

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.

Tratar de abordar 0x0, comando alternativo es0x0


sólo

[0x00400410]> s 0x0

[0x00000000]>

Imprimir dirección actual

0x0 [0x00000000]> s

[0x00000000]>

existe una forma alternativa de imprimir posición actual:?


v $$.

Seek N posiciones hacia adelante, el espacio es opcional

[0x00000000]> s + 128

[0x00000080]>

Deshacer dos últimos busca volver a la dirección inicial

[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

cadena encontrada. Recuerde que siempre puede volver


s-. con

[0x00400410]> s / hola

Buscando 5 bytes de 0x00400411 a 0x00600928: 48 65 6c 6c 6f buscar 5 bytes en [0x400411-0x600928] resultados:

1 hit0_0 .. hit0_0 0x004005b4 hit0_0 "Hola" [0x004005b4]> s [0x00400410]>

También hay un comando para mostrar la historia buscar:

[0x00400410]> s * f undo_3 @

0x400410 f undo_2 @ 0x40041a f

undo_1 @ 0x400410 f undo_0 @

0x400411

# posición de deshacer / rehacer actual. f redo_0 @

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.

[0xB7F9D810]> B? | Uso: b [f]

[arg] Obtener / Establecer

tamaño de bloque | segundo

mostrar tamaño de bloque actual

| b 33 establecer el tamaño de bloque de 33

|b+3 aumentar de bloque por 3

| b-16 disminuir blocksize por 16

| b EIP + 4 argumento numérico puede ser una expresión | establecer bf foo tamaño de

bloque de tamaño de la bandera | bm 1M

establecer el tamaño de bloque máximo

los segundocomando se utiliza para cambiar el tamaño de bloque:

[0x00000000]> b 0x100; tamaño de bloque = 0x100 [0x00000000]> b 16

; ... = 0x110

[0x00000000]> b -32 ; ... = 0xf0

los bf comando se utiliza para cambiar el tamaño de bloque de valor especificado por una bandera. Por ejemplo, en símbolos,

el tamaño de bloque de la bandera representa el tamaño de la función.

[0x00000000]> bf sym.main ; tamaño de bloque = sizeof (sym.main)

[0x00000000]> pd @ sym.main; sym.main desmontar

. . .

Se pueden combinar dos operaciones en una sola


pdf): (

[0x00000000]> pdf @ sym.main

48
secciones

secciones

imágenes de firmware, gestores de arranque y los archivos binarios suelen colocar varias secciones de un archivo binario en diferentes

direcciones en la memoria. Para representar este comportamiento, ofreceSlamando.


radareAquí está el mensaje de ayuda:

[0xB7EE8810]> S?

| Uso: - | [* = ADLR?.] [...] S S

secciones de la lista

| S. mostrar nombre de la sección actual

|S* secciones de lista (en comandos radare)

|S= secciones de la lista (barras ascii-arte) (io.va para mostrar PADDR o

vaddr)

| Sa [-] [A] [B] [[off]] Especificar arco y los bits de sección dada

| Sd [a] [archivo] dump (todos) sección actual a un archivo (ver DMD)

| Sl [Archivo] cargar contenido del archivo en la sección actual (ver DML)

| Sf [baddr] Alias para S 0 0 $ s $ s mrwx foo

| sj secciones de lista en JSON (alias para ISj)

| Sr [nombre] cambiar el nombre de la sección de la corriente de buscar

| S off va SZ nombre vsz mrwx añadir nueva sección (si (vsz) vsz = SZ!) | S- [id]

eliminar sección identificada por id

| S-. eliminar la sección en el núcleo-> desplazamiento (se puede cambiar por @)

| S * .- retirar todas las secciones en la corriente de offset

Puede especificar una sección en una sola línea:

# Añadir nueva sección

S [off] [Va] [sz] [vsz] [nombre] [mrwx]

Por ejemplo:

[0x00404888]> S 0x00000100 0x00400000 rwx 0x0001ae08 0001ae08 prueba

Visualización de información acerca de las secciones:

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

. . .

# secciones de la lista (en una zona de bares del arte ASCII)

[0xB7EEA810]> S =

. . .

25 0x0001a600 | ----------------------------- # | 0x0001a608 ---- .gnu_debuglink 26 0x0001a608 | ----------------------------- # | 0x0001a706 ----

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

Eliminar una definición de la parte con


S- mando.
el Pasar la sección de Identificación a ella como un argumento.

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

archivos de asignación se realiza mediante


O ( )el
La orden de abrir. Vamos a leer la ayuda:

[0x00000000]> O?

| Uso: o [com-] [ARCHIVO] ([desplazamiento]) | o

lista de archivos abiertos

|o= Lista de archivos abiertos (barras ascii-art)

|o* lista de archivos abiertos en los comandos r2

| OA [?] [dir] información bin abierta en la dirección indicada

| [?] Ob [lbdos] [...] lista de archivos binarios abierta respaldada por fd | oc [Archivo]

archivo de núcleo abierto, al igual que el relanzamiento de r2

| oi [- | idx] alias para la o, pero utilizando en lugar de índice de fd

| DO [?] lista de archivos abiertos en formato JSON

| oL listar todos los plugins registrados IO

| om [?] crear, lista, eliminar mapas IO

| en 0x4000 [archivo] mapa de archivos en bruto a 0x4000 (sin r_bin involucrado)

| oo [?] vuelva a abrir el archivo actual (matar + tenedor en depurador)

| oo + vuelva a abrir el archivo actual en lectura-escritura

| OOD [args] reabrir en el modo de depurador (con args)

| oo [bnm] [...] ver oo? en busca de ayuda

| op [por lo que] r2 abierta plugin nativo (ASM, bin, núcleo, ..)

|O4 Cambiar a abrir el archivo en fd 4

| O-1 cerca de descriptor de archivo 1

| * o- cerrar todos los archivos abiertos

| O- cierre todos los archivos, análisis, BINFILES, banderas, igual que r2! -

| o [Archivo] abrir el archivo [Archivo] de sólo lectura

| O + [Archivo] abrir el archivo en modo de lectura y escritura

| o [Archivo] 0x4000 archivo de mapa en 0x4000

Preparar un diseño simple:

51
archivos de asignación

$ Rabin2 -l / bin / ls [bibliotecas

Vinculados] libselinux.so.1

librt.so.1 libacl.so.1 libc.so.6

4 bibliotecas

Convertir un archivo:

[0x00001190]> o / bin / zsh 0x499999

Lista de archivos de mapeado:

[0x00000000]> o

- 6 / bin / ls @ 0x0; r

- 10 /lib/ld-linux.so.2 @ 0x100000000; r

- 14 / bin / zsh @ 0x499999; r

Imprimir los valores hexadecimales de / bin / zsh:

[0x00000000]> px @ 0x499999

archivos utilizando el unmap


o- mando. Pase descriptor de archivo requerido a ella como un argumento:

[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

resultado de un procesamiento externo ...

A continuación se muestra una lista de los modos de impresión disponibles listados


¿pag? : por

[0x08049AD0]> p?

| Uso: p [= 68abcdDfiImrstuxz] [arg | len] [@addr]

| p = [BEP] [] [BLKS len] [B] Mostrar entropía / chars imprimibles / chars bares [?] | p2 [len]

8x8 2bpp-azulejos

| p3 [Archivo] estereograma de impresión (3D)

| P6 [de] [len] base64 de decodificación / codificación

| p8 [?] [j] [len] 8bit lista hexpair de bytes

| pa [edD] [arg] PA: montar pa [dD]: disasm o PAE: esil de hexpairs

| pA [n_ops] Ver dirección y el tipo n_ops

| p [b | B | xb] [len] ([SKIP]) bindump N bits saltarse M

| pb [?] [n] flujo de bits de N bits

| pB [?] [n] flujo de bits de N bytes

| PC [?] [p] [len] (O pitón) formato de salida C

| pC [d] [filas] desmontaje de impresión en las columnas (ver hex.cols y PDI)

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

| ph [?] [= | picadillo] ([len]) el cálculo de hash para un bloque

| p [II] [DF] [len] impresión N ops / bytes (f = func) (véase pi? y PDI)

| pm [?] [mágica] libmagic los datos de impresión (ver pm? y / m?)

| pr [?] [GLX] [len] impresión N bytes primas (en líneas o hexblocks, 'g'unzip)

| p [kK] [len] tecla de impresión en randomart (K es para mosaico)

| ps [?] [PWZ] [len] pascal de impresión / / cadenas terminadas en cero de ancho

| pt [?] [DN] [len] imprimir diferentes marcas de tiempo

| pu [?] [w] [len] impresión N URL bytes codificados (w = ancho)

| pv [?] [JH] [Modo] mostrar la variable / puntero / valor en la memoria

| p - [?] [JH] [Modo] Barra | JSON | bloques de histograma (modo:? E search.in)

| px [?] [owq] [len] hexdump de N bytes (o = octal, w = 32 bits, q = 64 bits)

| pz [?] [len] Vista de zoom de impresión (consulte pz? en busca de ayuda)

| pwd mostrar directorio de trabajo actual

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 ~} {[

"Levantado": false, "fd":

563280,

"URI": "malloc: // 512", "de": 0 "puede

escribir": true, "tamaño": 512, "solapa":

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

dcff fff4 6690 662e 0f1f. (@ ..? .... y ss ..

Mostrar las palabras hexadecimales volquete (32 bits)

[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] e cfg.bigendian falsa>

[0x00404888]> e cfg.bigendian = true

[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

8 bits Hexpair Lista de Bytes

[0x00404888]> p8 16

31ed4989d15e4889e24883e4f0505449

Mostrar Hexadecimal Quad-palabras volquete (64 bits)

[0x08049A80]> PXQ

0x00001390 0x65625f6b63617473 0x646e6962006e6967 stack_begin.bind 0x000013a0 0x616d6f6474786574

0x7469727766006e69 textdomain.fwrit 0x000013b0 0x6b636f6c6e755f65 0x6d63727473006465 e_unlocked.strcm

. . .

Formatos de fecha / hora

modos de salida de marca de hora soportados actualmente son:

[0x00404888]> pt? | Uso: pt [?

Dn] | pt

Tiempo de impresión de UNIX (32 bits cfg.big_endian)

| PTD tiempo de dos de impresión (cfg.big_endian 32 bits)

| PTN NTFS Tiempo de impresión (64 bits! cfg.big_endian)

| pt? Mostrar mensaje de ayuda

Por ejemplo, se puede 'ver' el búfer en uso como marcas de tiempo en el momento NTFS:

[0x08048000]> eval cfg.bigendian = false [0x08048000]> pt 4 29: 04: 32

948 23:12:36 +0000

[0x08048000]> eval cfg.bigendian = true [0x08048000]> pt 4 20: 05: 13

001 09:29:21 +0000

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

ejemplo, por el valor del año:

[0x08048000]> pt | grep 1974 | wc -l 15

[0x08048000]> pt | grep 2022 27: 04: 2022

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

strftime bien conocido. Un extracto de la strftime (3) página de manual:

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

formato de fecha ISO 8601). (C99)

% 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

, ese año se utiliza en su lugar. (TZ)

% 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)

Modificador% O: utilizar formato alternativo, ver más abajo. (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)

% T El tiempo en formato de 24 horas (% H:% M:% S). (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)

% W El día de la semana como un decimal, rango de 0 a 6, siendo el domingo el 0. Véase también% 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)

% Z El nombre zona horaria o abreviatura.

% + 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

los caracteres de formato


PF y
??? por ejemplo:

[0x00499999]> PF ??

| PF: pf [.k [.f [= v]] | [v]] | [n] | [0 | cnt] [fmt] [a0 a1 ...] | Formato: | segundo

byte (sin firmar)

| segundo resolver campo de bits de enumeración (ver t?)

| do char (byte con signo)

| re 0x %% 08x valor hexadecimal (4 bytes) (ver %% i %% y x)

| re desensamblar un opcode

| mi temporalmente intercambiar endian

| mi resolver el nombre de enumeración (ver t?)

|F valor flotante (4 bytes)

| yo %% i firmado valor entero (4 bytes) (ver %% d y %% x)

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

|o 0x %% 08o valor octal (4 byte)

| pag referencia de puntero (2, 4 u 8 bytes)

|q palabra cuádruple (8 bytes)

|r registro de la CPU `pf r (eax) plop`

|s 32 bits puntero a la cadena (4 bytes)

|S 64 bits puntero a la cadena (8 bytes)

|t UNIX marca de tiempo (4 bytes)

|T mostrar diez primeros bytes de tampón

|u uleb128 (longitud variable)

|w de palabras (2 bytes corto sin signo en hexadecimal)

|x 0x %% 08x hex valor y la bandera (fd @ addr) (véase %% d y %% i)

|x Mostrar formato hexpairs

|z \ 0 cadena terminada

|Z \ 0 cadena de ancho terminado

|? estructura de datos `pf? (Struct_name) example_name`

|* junto char es puntero (honores asm.bits)

|+ Mostrar banderas de palanca para cada desplazamiento

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

ds: 'foo' como hexagonal, y 'barra' como int | pf B (BitFldType)

arg_name` tipo de campo de bits

| PF E (EnumType) arg_name` tipo de enumeración

| pf.obj xxdz anterior siguiente nombre de tamaño Definir el formato obj como xxdz

| pf obj = xxdz prev siguiente nombre de tamaño Lo mismo que arriba

| 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

Igual que el anterior, pero se considera como un unio

n (todos los campos en la posición 0) | pf.plop? (Trol)

MyStruct Uso estructura troll ha definido previamente

| cadena de longitud puntero PF 10xiz Imprimir un matriz de tamaño 10 de la struct Xiz

con sus nombres de campo | PF {entero}?

(BiFC) los tiempos de impresión de números enteros de la siguiente Forma

t (BiFC)

| pf [4] w [7] i Imprimir una matriz de 4 palabras, y luego una una

RRay de 7 enteros

| ? PF ic i ... foo bar "(PF XW yo foo) troll" yo Imprimir anidado structres anónimos | pfn2

impresión firmó valor a corto (2 bytes). Utilizar

N insted de n para la impresión de valores sin signo

Algunos ejemplos son los siguientes:

[0x4A13B8C0]> pf i 0x00404888 =

837634441

[0x4A13B8C0]> PF

0x00404888 = 837634432,000000

De alto nivel Idiomas Vistas

formatos de códigos de impresión válido para los idiomas legible por humanos son:

58
Modos de impresión

C
ordenador personal

pc * imprimir 'wx' r2 comandos PCH

C media-palabras (2 bytes) PCW

palabras C (4 byte) pcd

dwords C (8 byte) PCA

GAS .byte burbuja pcA

. bytes con las instrucciones en los comentarios de las PC

PCs de

cuerda shellscript que reconstruye la PCJ bin

JSON

PCJ PCP Javascript

pitón

[0xB7F8E810]> PC 32

# definir _BUFFER_SIZE 32

tampón unsigned char [_BUFFER_SIZE] = {

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

, 0x84, 0x29, 0xC2};

[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

radare soporta varios formatos de serie:

[0x00000000]> ps?

| Uso: ps [ZPW] [N] Imprimir Cadena | cadena de

impresión PS

| pss cadena de impresión en pantalla (ancho envoltura) | cadena de

impresión psi dentro curseek | psb cadenas de impresión en bloque actual |

Mostrar cadena de caracteres con PSX escapado | PSZ imprimir cadena

terminada en cero | Pascal cadena de impresión psp | PSU Unicode utf16 de

impresión (JSON) | PSW de impresión de 16 bits de ancho cadena | PSW de

impresión de 32 bits de ancho cadena | PSJ cadena de impresión en formato

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

la llamada al sistema, apuntadas por EBX%. En el caso de

59
Modos de impresión

la llamada 'abierta', que es una cadena terminada en cero, lo que podemos inspeccionar
PSZ. el uso

[0x4A13B8C0]> DCS abren

0x4a14fc24 syscall (5) abierto (0x4a151c91 0x00000000 0x00000000) = 0xffffffda [0x4A13B8C0]> dr

0xffffffda eax 0xffffffff esi EIP 0x4a14fc24

0x4a151c91 EBX edi 0x4a151be1 Éax 0x00000005

ecx 0x00000000 0xbfbedb1c esp eflags 0x200246

EDX 0x00000000 0xbfbedbb0 ebp cPaZstIdor0 (PZI)

[0x4A13B8C0]>

[0x4A13B8C0]> PSZ @ 0x4a151c91 /etc/ld.so.cache

Contenidos de la memoria de impresión

También es posible imprimir diferentes tipos de datos en paquete usando


PF mando:
la

[0xB7F08810]> PF xxS @ RSP 0x7fff0d29da30 =

0x00000001 0x00000000 = 0x7fff0d29da34

0x7fff0d29da38 = 0x7fff0d29da38 -> 0x0d29f7ee / bin / ls

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

memoria de formato' como argumento pf,


paray temporalmente buscan cambiar de posición / desplazamiento utilizando actual @ . También es

posible definir conjuntos de estructuras


pf. Para
de ello, el prefijo de la cadena de formato con un valor numérico. También puede definir un

nombre para cada campo de la estructura añadiéndolos como una lista de argumentos separados por espacios.

[0x4A13B8C0]> PF 2 * XW tipo de puntero @ esp 0x00404888 [0] {

puntero:

(* 0xffffffff8949ed31) Tipo: 0x00404888 = 0x8949ed31

0x00404890 = 0x48e2}

0x00404892 [1] {(*

0x50f0e483) Puntero: 0x00404892 = 0x50f0e483

Tipo: 0x0040489a = 0x2440}

Un ejemplo práctico para el usoPFdeen una binaria de un complemento de GStreamer:

60
Modos de impresión

$ Radare ~ / .gstreamer-0.10 / plugins / libgstflumms.so [0x000028A0]> buscan

sym.gst_plugin_desc

[0x000185E0]> PF iissxsssss Mayor Menor versión _init nombre desc \ fuente de origen del paquete de licencia

importante: 0x000185e0 = 0 menor:

0x000185e4 = 10

Nombre: 0x000185e8 = 0x000185e8 flumms desc: 0x000185ec = 0x000185ec Fluendo MMS

_init fuente: 0x000185f0 = 0x00002940 versión: 0x000185f4 = 0x000185f4 0.10.15.1 licencia:

0x000185f8 = 0x000185f8 fuente desconocida: 0x000185fc = 0x000185fc GST-Fluendo-mms

paquete: 0x00018600 0x00018600 = Fluendo MMS origen fuente: 0x00018604 = 0x00018604

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

debe ser desmontado. los


pD comando es similar pero en lugar de una serie de instrucciones, decompila un número

determinado de bytes.

d: desmontaje N opcodes recuento de opcodes D: asm.arch desensamblador

bsize bytes

[0x00404888]> pd 1

; - Entry0: 0x00404888

31ed xor ebp, ebp

Selección de Arquitectura de destino

El sabor de la arquitectura desensamblador se defineasm.arch


por la variables eval. Puedes usar para enumerar
e asm.arch =?

todas las arquitecturas disponibles.

61
Modos de impresión

[0xB7F08810]> e = asm.arch?

_D 16 8051 PD 8051 CPU Intel

_D 16 32 arco GPL3 Argonaut RISC Core

ad brazo 16 32 64 GPL3 Acorn RISC CPU de la máquina

_D 16 32 64 arm.cs BSD desensamblador Capstone ARM

_D 16 32 desensamblador ARM arm.winedbg LGPL2 WineDBG

_D 16 32 avr GPL Atmel AVR

ad 32 bf LGPL3 Brainfuck

_D 16 CR16 Plugin de desmontaje LGPL3 CR16

_D 16 RSE PD Cambridge Silicon Radio (CSR)

ad 32 64 Dalvik LGPL3 AndroidVM Dalvik

ad 16 dcpu16 PD de Mojang DCPU-16

_D 32 64 EBC LGPL3 EFI Bytecode

_D 8 gb LGPL3 GameBoy (TM) (z80-like)

_D 16 h8300 LGPL3 H8 / 300 plugin de desmontaje

_D 8 i8080 BSD Intel 8080 CPU

ad 32 Java código de bytes de Java Apache

_D 16 32 m68k BSD Motorola 68000

_D 32 Malbolge LGPL3 Malbolge ternario VM

ad 32 64 MIPS GPL3 CPU MIPS

_D 16 32 64 mips.cs BSD desensamblador Capstone MIPS

_D 16 32 64 msil PD . NET lenguaje intermedio de Microsoft

_D 32 nios2 GPL3 NIOS II procesador integrado

_D 32 64 ppc GPL3 PowerPC

_D 32 64 ppc.cs BSD desensamblador Capstone PowerPC

anuncio rar LGPL3 RAR VM

_D 32 sh GPL3 SuperH-4 CPU

_D 32 64 SPARC GPL3 Escalable arquitectura del procesador

_D 32 TMS320 LGPLv3 familia TMS320 DSP

_D 32 ws Los espacios en blanco LGPL3 esotéricos VM

_D 16 32 64 X 86 BSD udis86 x86-16,32,64

_D 16 32 64 x86.cs BSD desensamblador Capstone X86

a_ 32 64 x86.nz LGPL3 x86 ensamblador hecho a mano

ad 32 x86.olly GPL2 desensamblador OllyDbg X86

8 anuncio z80 NC-GPL2 Zilog Z80

Configuración del desensamblador

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.cmtflgrefs instrucción: banderas Mostrar comentario asociado a la rama referece

asm.cmtright: Mostrar comentarios derecha de desmontaje si encajan en asm.comments pantalla: Mostrar los comentarios en vista

de desmontaje

asm.decode: El uso de análisis de código como asm.dwarf desensamblador: Mostrar

comentario enana en asm.esil desmontaje: Mostrar ESIL en lugar de

mnemotécnica

asm.filter: Reemplazar números en el desmontaje usando banderas que contienen un punto en t

l nombre de desmontaje

asm.flags: Mostrar banderas

asm.lbytes: Alinear bytes DISASM a la izquierda

asm.lines: Si las líneas del arte ASCII muestran permitido en asm.linescall desmontaje: habilitar líneas

de llamada

asm.linesout: Si está activada la demostración de líneas de bloqueo

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.pseudo desmontaje: Habilitar la sintaxis seudo

asm.size: Mostrar el tamaño de los códigos de operación de desmontaje (pd) asm.stackptr:

puntero de pila Mostrar en el desmontaje

asm.cycles: Mostrar cpu-ciclos tomadas por instrucción en el desmontaje

asm.tabs: Use pestañas en asm.trace desmontaje: Mostrar trazas de ejecución para

cada código de operación asm.ucase: Uso de sintaxis en mayúsculas asm.varsub

desmontaje: las variables de sustitución en el desmontaje

asm.arch: Establecer el arco a ser usedd por asm.parser asm: Ajuste el

analizador asm para usar

asm.segoff: Mostrar dirección segmentada en el símbolo (x86-16)

asm.cpu: Establecer el tipo de CPU asm.arch

asm.profile: desensamblador de configuración (por defecto, simple, gas, inteligente, depuración, lleno

asm.xrefs: Mostrar referencias externas en asm.functions desmontaje:

Mostrar funciones de desmontaje

asm.syntax: Sintaxis Seleccionar ensamblaje

asm.nbytes: Número de bytes para cada código de operación en asm.bytespace desmontaje: bytes

hexadecimales separados con un espacio en blanco

asm.bits: tamaño de la palabra en bits en asm.lineswidth ensamblador: Número de columnas

para las flechas de flujo de programa

desmontaje de sintaxis

los asm.syntaxvariable se utiliza para cambiar el sabor de la sintaxis de montaje utilizado por un motor de

desensamblador. Para cambiar entre Intel y representaciones de AT & T:

e asm.syntax = Intel e asm.syntax =

att

63
Modos de impresión

También puede comprobar


asm.pseudo,que es una vista pseudocódigo experimental, y
asm.esil

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

similar. Ejemplos para espacios Bandera: secciones, registros, símbolos.

Para crear un tipo de marca:

[0x4A13B8C0]> f @ compensar flag_name

Se puede quitar una bandera añadiendo el - carácter de comando. La mayoría de los comandos aceptan

- como argumento prefijo como una indicación para borrar algo.

[0x4A13B8C0]> f-flag_name

Para cambiar entre o crear nuevos flagspaces utilizan


fs mando:
el

# espacios bandera lista

[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

; Lista sólo banderas en símbolos flagspace

[0x4A13B8C0]> fs * ; seleccionar todos flagspaces

[0x4A13B8C0]> f myflag; crear un nuevo indicador denominado 'myflag' [0x4A13B8C0]> f-myflag; eliminar la

bandera llamada 'myflag'

Puede cambiar el nombre con banderas


fr.

sesenta y cinco
Escribir

Los datos de escritura

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

truncará el archivo a la actual posición buscan bytes menos N.

R 1024 ; cambiar el tamaño del archivo a 1024 bytes

r -10 @ 33; banda 10 bytes en el offset 33

bytes de escritura utilizando


w mando.
el Se acepta varios formatos de entrada como ensamblador en línea, dwords endian-amigable,

archivos, archivos hexpair, cadenas de ancho:

66
Escribir

[0x00404888]> w?

| Uso: w [x] [str] [<archivo] [<< EOF] [@addr] | w [1248] [+ -] [n]

Valor mínimo de bytes / decremento, la palabra ..

| foobar w escribir cadena 'foobar'

| w0 [len] escribir 'len' bytes con el valor 0x00

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

| de archivos FAT ensamblar archivos y escribir bytes

| WAO [?] op modificar código de operación (cambiar condicional de salto. nop, etc)

| wA [?] r 0 alterar / modificar código de operación actual en buscar (ver wUn?)

| wb 010203 llenar bloque actual con hexpairs cíclicos

| wB [-] 0xVALUE establecer o los bits no definidas con valor dado

| baño una lista de todos los cambios de escritura

| 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

escribir el contenido del archivo en el desplazamiento actual

| WH r2 whereis / que comando shell

| wm F0FF establecer binario hexpair máscara para ser utilizado como máscara de escritura cíclica

| wo [?] hex escribir en el bloque con la operación. 'Wo?' FMI

| [?] WP - | archivo aplicar parche radare. Ver wp? FMI

| WR 10 escribir 10 bytes aleatorios

| PString ws escribir 1 byte para la longitud de la cadena y luego

| [?] 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

remoto: puerto a través de tcp: // | foobar ww

escribir amplia cadena 'f \ x00o \ x00o \ x00b \ x00a \ x00r \ x00'

| wx [?] [FS] 9090 escribir dos NOP Intel (desde wxfile o wxseek)

| wv [?] EIP + 34 escribir el valor de 32-64 bits

| cadena wz escribir cadena terminada en cero (como w + \ x00)

Algunos ejemplos:

[0x00000000]> wx 123456 @ 0x8048300 [0x00000000]> WV

0x8048123 @ 0x8049100 [0x00000000]> wa JMP 0x8048320

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?

| Uso: wo [asmdxoArl24] [hexpairs] @ addr [: bsize] | Ejemplo:

| wox 0x90; act bloque XOR con 0x90 | wox 90

; bloque cur xor con 0x90

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

= multiplicar | wod / = división | wox ^ = XOR | Woo | = o | WOA y = y

| WOR bytes aleatorios (alias 'wr $ b' | WOR >> = desplazamiento a la

derecha | WOL << = desplazamiento a la izquierda | WO2 2 = 2 bytes

de intercambio endian | WO4 4 = 4 bytes de intercambio endian

Es posible implementar cifrado-algoritmos usando primitivas de núcleowo.


radare
Un ejemplo
y de sesión xor rendimiento

(90) + add (01, 02):

[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

ede8 06e2 0000 488d 15cf e600 .U.1 ...... H .....

[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

9491 9f8f 1490 ................

[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

81da 1652 81da 1456 A252 7c77 ..Y .... R ... VR | w

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.

Prensadoz de nuevo el zoom-en donde en la nueva posición del cursor.

[0x004048c5]> pz?

| Uso: PZ [len] bloques de impresión ampliada (Tamaño de archivo / N) | e zoom.maxsz

tamaño máximo de bloque | e zoom.from dirección de inicio | e zoom.to

dirección final

| e zoom.byte especificar cómo calcular cada byte | pzp

número de caracteres imprimibles

| Pzf contar de banderas en el bloque

| pzs cuerdas en gama

| PZ0 número de bytes con un valor '0'

| Pzf número de bytes con un valor 0xFF

| PZE el cálculo de la entropía y expandirse a 0-255 gama

| PZH cabeza (primer valor de byte); Este es el modo por defecto

Veamos algunos ejemplos:

70
Enfocar

[0x08049790]> pz // o por defecto PZH

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

00e1 ffe8 58fe 4dc4 00e0 dbc8 b885 u ..... XM ......

[0x08049790]> e zoom.byte = p [0x08049790]>

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

[0x08049790]> eval zoom.byte = banderas [0x08049790]> pz // o

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

[0x08049790]> e zoom.byte = F [0x08049790]>

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

zoom.fromy zoom.tolas variables eval:

[0x465D8810]> e zoom. zoom.byte = f

zoom.from = 0 zoom.maxsz = 512

zoom.to = 118368 ???

71
Enfocar

72
Yank / Pegar

Yank / Pegar

Puede dar un tirón / bytes pegar en el modo visual utilizando


y y Y asociaciones
la de teclas que son alias para
y y yy comandos de

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?

| Uso: y [ptxy] [len] [[@] addr] | y

información de concierto búfer tirón (srcoff len bytes)

| y 16 16 bytes copiar en el portapapeles

| y 16 0x200 16 bytes copiar en el portapapeles de 0x200

| y 16 @ 0x200 16 bytes copiar en el portapapeles de 0x200

| yp contenido de la impresión del portapapeles

| yx contenido de la impresión del portapapeles en hexadecimal

| yt 64 0x200 copiar 64 bytes de la corriente tratan de 0x200

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

| 0x3344 yy portapapeles pasta

sesión de ejemplo:

[0x00000000]> s 0x100 ; buscar en 0x100

[0x00000100]> y 100 ; Yanks 100 bytes de aquí

[0x00000200]> s 0x200 ; buscar 0x200

[0x00000200]> aa ; pastas de 100 bytes

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

desplazamiento 0 1 2 3 4 5 6 7 8 9 AB 0123456789AB 0x4A13B8C0, E839 89e0 0700 0089

c7e8 e2ff ... 9 ........ 0x4A13B8CC, ffff 81c3 eea6 0100 8b83 08ff ......... ... 0x4A13B8D8, ffff 5a8d

2484 29c2

. . Z. $.).

[0x4A13B8C0]> yt 8 0x4A13B8CC @ 0x4A13B8C0

[0x4A13B8C0]> x

desplazamiento 0 1 2 3 4 5 6 7 8 9 AB 0123456789AB 0x4A13B8C0, E839 89e0 0.700 0.089

c7e8 e2ff ... 9 ........ 0x4A13B8CC, 89e0 E839 0700 08ff 0089 8b83 ... 9 ..... ... 0x4A13B8D8, ffff

5a8d 2484 29c2

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

| Uso: [? DFX] c [argumento] # Comparar | cuerda C]

Comparación de una llanura con una cuerda caracteres escapado

| cuerda C] Comparación de una llanura con una cuerda caracteres escapado (r2 comandos de salida)

| c4 [valor] Comparar una palabra doble a partir de una expresión matemática

| c8 [valor] Comparar una palabra cuádruple de una expresión matemática

| gato [archivo] Mostrar contenido del archivo (véase pwd, ls)

| cc [a] [(a)] Compara en dos columnas hexdump de tamaño de bloque

| ccc [a] [(a)] Igual que el anterior, pero sólo muestran líneas diferentes

| ccd [a] [(a)] Compara en dos columnas DISASM de tamaño de bloque

| cf [Archivo] Comparar el contenido de archivo en la corriente buscar

| cg [?] [o] [archivo] Graphdiff archivo actual y [archivo]

| cl | cls | clara Borrar pantalla, (clear0 a Goto 0, 0 solamente)

| cu [?] [dir] @at Comparar hexdumps memoria de $$ y el horario de verano en diff unificado

| CUD [addr] @at Unificada disasm diff de $$ y dirección dada

| cv [1248] [dir] @at Comparar 1,2,4,8-byte de valor | cw [?] [nosotros?] [...]

Comparación de los observadores de memoria

| cx [hexpair] Comparar hexpair cadena (uso '' como comodín nibble)

| cx * [hexpair] Comparar hexpair cadena (salida de comandos R2)

| cX [addr] Como 'cc', pero utilizando la salida HexDiff

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

[0x08048000]> cx 7f 45 90 46 Comparar 3/4 bytes

iguales

0x00000002 (byte = 03) 90 '' -> 4c 'L' [0x08048000]>

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:

[0x4A13B8C0]> cc 0x39e8e089 @ 0x4A13B8C0

Para comparar el contenido de dos funciones especificadas por sus nombres:

75
comparando Bytes

[0x08049A80]> cc sym.main2 @ sym.main

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

Comparar 1/8 bytes iguales (0%)

0x00000000 (byte = 01) 7f '' -> 04 '' 0x00000001 (byte = 02) 45 'E' -> 00 ''

0x00000002 (byte = 03) 4c 'L' -> 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

Comparar 2/4 bytes iguales

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:

r2 / bin / true [0x08049A80]> s

[0x08048000]> cf / bin / true Comparar 512/512

bytes iguales

76
SDB

SDB

espacios de nombres de la lista

** k

Lista de sub-espacios de nombres

k anal / **

Las teclas de lista

k*

anal k / *

Establecer una clave

k foo = bar

Obtener el valor de una clave

foo k

consultas útiles

Una lista de todas llamadas al sistema

k syscall / * ~ ^ 0x

Una lista de todos los comentarios

k anal / meta / * ~ .C.

Mostrar un comentario en offset dado:

k% anal / meta / [1] meta.C.0x100005000

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

para simplificar el uso del depurador. Para entrar en el modo visual,


V mando.
utilizar Para salir de nuevo al mando de línea, pulse
q.

Los modos de impresión aka paneles

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

panel de hexdump → análisis de panel mapa de color Op → Panel hexdump anotada ↺.

Observe que la parte superior del panel contiene el comando que se utiliza, por ejemplo, para el desmontaje del panel:

[0x00404890 16% 120 / bin / ls]> pd $ r @ Entry0

79
modo visual

Obteniendo ayuda

Para ver ayuda en todas las combinaciones de teclas definidas para el modo visual, pulse? :

el modo de ayuda visual:?

mostrar esta ayuda ??

mostrar el HUD fácil de usar

ps asm.pseudo de palanca

% en cursor modo hallazgos búsqueda de par, de otro modo de palanca autoblocksz

@ redibujar la pantalla cada 1s (ver multi-usuario), en posición de ajuste cursor

! entrará en el modo de paneles visual

_ introducir el indicador / comentario / funciones / HUD .. (igual que VF_)

= cmd.vprompt conjunto (fila superior)

| cmd.cprompt conjunto (columna derecha)

. tratar de contador de programa

" alternar el modo de columna (utiliza pc ..)

/ en busca el modo de cursor en el bloque actual

: cmd ejecutar comandos radare

[-] CMT añadir / eliminar comentario 0

tratar de comienzo de la función actual

[1-9] seguir JMP / llamada identificada por acceso directo (similares; [1])

, archivo añadir un enlace al archivo de texto

/ * + - [] cambio de tamaño de bloque, [] = cambiar el tamaño de hex.cols </>

seek alineados para bloquear tamaño (buscar cursor en modo de cursor)

(A) código
Automóvil club británico ssemble, visual (A) ssembler

segundo punto de interrupción de palanca

segundo enumerar e inspeccionar las clases

c/C toggle (c) ursor y olors (C)

d [f?] definir la función, los datos, código, ..

re entrar en el modo visual de diferencias (conjunto diff.from / a)

mi editar variables de configuración eval

f/F habilitar / deshabilitar las banderas o navegar. f- a desarmado, F para navegar, ..

gG ir a buscar para comenzar y al final del archivo (0- $ s)

hjkl moverse (o HJKL) (abajo a la izquierda-arriba-derecha)

yo inserte hexagonal o cadena (en hexdump) pestaña utilizar para alternar

mK / 'K marca / ir a Key (cualquier tecla)

METRO caminar por los sistemas de ficheros montados

n/N buscar la siguiente función / ant / bandera / HIT (scr.nkey)

o go / tratar de offset dado

O de palanca asm.esil

páginas gire modos de impresión (hex, disasm, depuración, es decir, buf)

q Volver a shell radare

r actualización de la pantalla / en modo de cursor navegar por los comentarios // buscar información y comunicación anal

entos / en modo de cursor = eliminar byte R

aleatorizar paleta de colores (ECR)

sS paso / pasar por encima

t navegar por tipos

T entrar en la consola de chat TextLog (TT)

uU deshacer / rehacer buscar

80
modo visual

v la función visual / vars menú de análisis de código

V (V) gráfico IEW usando cmd.graph (AGV?)

wW buscar el cursor a la palabra siguiente / ant

xX Mostrar referencias externas / árbitros de la función actual desde / a los datos / código

yY copiar y pegar la selección

z plegar / desplegar los comentarios de desmontaje

Z el modo de alternancia de zoom

Entrar siga la dirección de salto / llamada

Teclas de función: (Ver 'tecla e'), por defecto:

F2 F4 punto de interrupción de

palanca ejecutar al cursor F7

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

solicitado por el símbolo: [ Siga un salto o una llamada utilizando el


desplazamiento]>.

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.

0x00404894 e857dcffff llamar sym.imp .__ libc_start_main; [1]

Buscará volver a la ubicación anterior usando


T, U le permitirá volver a realizar la buscan.

re como definir

re se puede utilizar para cambiar el tipo de datos del bloque actual, varios tipos básicos / estructuras están

disponibles, así como una más avanzada utilizando


PF modelo:

d → ...

0x004048f7 48c1e83f SHR rax, 0x3f

d→b

0x004048f7 .byte 0x48 d → B

0x004048f7 .word 0xc148

d→d

0x004048f7 longitud hex = 165 delta = 0

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

la base para trabajar, esto es el equivalente


ahi: a

82
visual Desmontaje

d → → i ... 0x004048f7

48c1e83f SHR rax, 0x3f

d → i → 10 0x004048f7

48c1e83f SHR rax, 63

d → i → 2 0x004048f7

48c1e83f SHR rax, '?'

Uso del cursor para insertar / Aplicación de parches ...

Recuerde que, para ser capaz de editar archivos cargados en realidad radare2, usted tiene que comenzar
w opción.
conDe
el lo
-

contrario, se abre un archivo en modo de sólo lectura. minúscula presionando


do Alterna el modo de cursor. Cuando este modo está

activo, se pone de relieve el byte seleccionado actualmente (o intervalo de bytes).

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

el archivo se abre en modo de escritura mediante el -

w bandera o el
O + de comandos, también puede utilizar el cursor para sobrescribir un rango seleccionado con nuevos valores. Para ello,

seleccione un rango de bytes (con HJKL y tecla SHIFT pulsada), a continuación,


yo epulse
introduzca los valores hexpair para los nuevos

datos. Los datos se repiten según sea necesario para llenar el rango seleccionado. Por ejemplo:

<Seleccionar 10 bytes en el modo visual utilizando SHIFT + HJKL> <prensa 'i' y a

continuación, introduzca '12 34' >

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:

; DATOS REFX de 0x00402e0e (unk) str.David_MacKenzie:

Para ver donde esta cadena se llama, pulse


x , Si desea saltar a la ubicación en la que se utilizan los datos a continuación,

pulse el número correspondiente [0-9] en el teclado. (Esta funcionalidad es similar a


AXT)

x corresponde al alias operación inversa


axf.

Añadir un comentario

Para agregar un comentario de prensa; .

Escribir otros comandos

Tipo rápidamente a los comandos usando: .

Buscar

/: permite resaltar de cadenas en la pantalla actual.


cmd permite
: el uso de uno de los "/?" comandos que realizan

búsquedas más especializadas.

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.

Las "banderas / comentario / funciones / HUD .."

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.

Editor de configuración visual

Este HUD se puede acceder mediante


mi el
clave en el modo visual. El editor le permite examinar y cambiar la

configuración del radare2 fácilmente. Por ejemplo, si desea cambiar algo en la pantalla desmontaje,
asmseleccione
de la

lista, navegue hasta el elemento que desea modificar, y luego seleccionarloEnter.


pulsando
Si el artículo es una variable

booleana, ésta cambia, de lo contrario se le pedirá para proporcionar un nuevo valor.

85
visual Desmontaje

interruptor Ejemplo de seudo desmontaje:

86
visual Desmontaje

87
visual Desmontaje

Los siguientes son algunos ejemplos de variables eval relacionados con el desmontaje.

Ejemplos

asm.arch: Cambio Arquitectura && asm.bits: tamaño de la palabra en bits en


ensamblador

Puede ver la lista de todos arco utilizando


e asm.arch =?

88
visual Desmontaje

e asm.arch = Dalvik

0x00404870 31ed4989 CMP-larga V237, V73, v137

0x00404874 d15e4889 rsub-int v14, v5, 0x8948

0x00404878 e24883e4 ushr-int / lit8 V72, V131, 0xe4

0x0040487c f0505449c7c0 + invocar-objeto-init-gama {}, el método + 18772

; [0]

0x00404882 90244100 complemento int V36, V65, v0

e asm.bits = 16

0000: 4870 31ed xor pb, pb

0000: 4872 49 cx diciembre

0000: 4873 89d1 mov cx, dx

0000: 4875 5e Si emergente

0000: 4876 48 diciembre hacha

0000: 4877 89e2 mov dx, sp

Esta última operación también se puede hacer uso de & en el modo visual.

asm.pseudo: Activar sintaxis seudo

e asm.pseudo = true

0x00404870 31ed ebp = 0

0x00404872 4989d1 r9 = RDX

0x00404875 5e RSI pop

0x00404876 4889e2 RDX = RSP

0x00404879 4883e4f0 RSP y = 0xfffffffffffffff0

asm.syntax: Seleccionar la sintaxis de montaje (Intel, att, masm ...)

e asm.syntax = att

0x00404870 31ed xor% ebp,% ebp

0x00404872 4989d1 mov% RDX,% r9

0x00404875 5e pop% RSI

0x00404876 4889e2 mov% RSP,% RDX

0x00404879 4883e4f0 y $ 0xfffffffffffffff0, RSP%

asm.describe: mostrar una descripción de código de operación

89
visual Desmontaje

e asm.describe = true

0x00404870 31ed xor ebp, ebp ; exclu lógicas

siva o

0x00404872 4989d1 mov r9, RDX ; mueve los datos fr

om src a dst

0x00404875 5e RSI pop ; pops última ele

ción de la pila y almacena el resultado en el argumento

0x00404876 4889e2 mov RDX, RSP ; mueve los datos fr

om src a dst

0x00404879 4883e4f0 y RSP, 0xfffffffffffffff0; binaria y OP

ración entre src y dst, tiendas resultan en el horario de verano

90
visual ensamblador

visual ensamblador

Puede utilizar el modo visual para ensamblar código usando


A . Por ejemplo vamos a reemplazarempujar
el

por unaJMP:

Observe la vista previa del desmontaje y flechas:

91
visual ensamblador

Es necesario abrir el archivo en modo escritura


-w r2 o(oo +)con el fin de parchear el archivo. También puede utilizar el modo

de caché:e io.cache = true


y ¿baño? .

Recuerde que parchear los archivos en modo de depuración único parche no la memoria del archivo.

92
Editor de configuración visual

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

ensamblaje simplemente seleccione


asm en la lista y elegir el sabor de visualización del ensamblaje.

interruptor Ejemplo de seudo desmontaje:

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

banderas para la búsqueda golpearon lugares facilitar la referencia futura.

Buscar se inicia por / mando.

[0x00000000]> /?

| Uso: / [arg] Buscar cosas [AMX /] (ver 'e ?? búsqueda' para las opciones) | / Foo \ x00

buscar cadena 'foo \ 0'

| / J foo \ x00 búsqueda de la cadena 'foo \ 0' (salida JSON)

| /! ff búsqueda de la primera ocurrencia que no se ajuste

| / + / Bin / sh construir la cadena con trozos

| /! X 00 búsqueda inversa hexa (Encontrar primer byte! = 0x00)

| // Repetir la última búsqueda

| / H [t] [picadillo] [len] encontrar bloque coincidente este hash. Ver /#? | / A eax JMP

ensamblar código de operación y buscar sus bytes

| / A JMP encontrar instrucciones analizadas de este tipo (/ A? en busca de ayuda)

| /segundo buscar hacia atrás

| /SEGUNDO buscar las cabeceras RBin reconocidos

| / C JMP [esp] buscar por código asm

| /Coche] búsqueda de materiales criptográficos

| / D 101112 buscar una secuencia de bytes deltified

| / E / EF / i Concordancia de expresiones regulares

| / E-esil expr desplazamiento de adaptación de las expresiones dadas Esil %% = aquí

| archivo / f [OFF] [SZ] búsqueda contenido del fichero de tamaño y desplazamiento | / I foo

búsqueda de la cadena 'foo' caso ignorando

| / M magicfile buscar a juego Magic File (utilización de bloque)

|E/S VER desplazamiento de instrucción previa

| / P patternsize buscar patrón de tamaño dado

| / Patternsize P buscar bloques similares

| / R [e] sym.printf analizar referencia código de operación un desplazamiento (/ re para esil)

| / R [grepopcode] búsqueda de juego aparatos ROP, separados por punto y coma-

| / V [1248] Valor busque un valor de 32 bits cfg.bigendian` `

| / V [1248] min max busque un valor de 32 bits `cfg.bigendian` en el rango

| / Foo w búsqueda de la amplia cadena 'f \ 0o \ 0o \ 0'

| / Foo wi búsqueda de la cadena de ancho ignorando mayúsculas y minúsculas 'f \ 0o \ 0o \ 0'

| / X ff..33 búsqueda de cadena hexadecimal haciendo caso omiso de algunos bocados

| / X FF0033 búsqueda de cadena hexadecimal

| / X ff43 ffd0 buscar hexpair con la máscara

| / Z min max buscar cadenas de tamaño dado

Porque todo se trata como un archivo en radare2, no importa si desea buscar en un zócalo, un dispositivo remoto, en el

proceso de la memoria, o un archivo.

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:

$ R2 -q -c "/ lib" / bin / ls

Buscando 3 bytes de 0x00400000 a 0x0041ae08: 6c 69 62 hits: 9

0x00400239 hit0_0 "lib64 / ld-linux-x86-64.so.2" 0x00400f19 hit0_1 "libselinux.so.1"

0x00400fae hit0_2 "librt.so.1" 0x00400fc7 hit0_3 "libacl.so.1" 0x00401004 hit0_4

"libc.so 0.6" 0x004013ce hit0_5 "libc_start_main" 0x00416542 hit0_6 "libs /"

0x00417160 hit0_7 "lib / xstrtol.c" 0x00417578 hit0_8 "lib"

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

. . .

[0x00404888]> ps @ hit0_0 lseek

Puede buscar cadenas de todo el carbón de leña (por ejemplo, cartas Unicode) utilizando
w mando:
el /

[0x00000000]> / w Hola 0 resultados.

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

[0x00000000]> f 0x00000135 512

hit0_0 0x00000b71 512 hit0_1

0x00000bad 512 hit0_2 0x00000bdd

512 hit0_3 0x00000bfb 512 hit0_4

0x00000f2a 512 hit0_5

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

repetir la última búsqueda.

[0x00000f2a]> // ; Repetir la última búsqueda

99
Configurando la búsqueda

Configuración de las opciones de 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 cmd.hit = x ; radare2 mandato debe ejecutar en cada golpe de búsqueda

e search.distance = 0; distancia cadena de búsqueda

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.from = 0 ; dirección de inicio

e search.to = 0 ; dirección final

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

de teclado, la posición de búsqueda actual está marcado con


search_stop.

100
patrón de búsqueda

Patrón de búsqueda que coinciden

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

longitud mínima detectable. Aquí hay un ejemplo:

[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

secuencia de comandos por separado, y luego invocarlo en su conjunto


scriptcon .
de nombre mando. Por ejemplo:
de archivo

[0x00404888]> e cmd.hit = p8 8 [0x00404888]> / lib

Buscando 3 bytes de 0x00400000 a 0x0041ae08: 6c 69 62 hits: 9

0x00400239 hit4_0 "lib64 / ld-linux-x86-64.so.2" 31ed4989d15e4889

0x00400f19 hit4_1 31ed4989d15e4889 "libselinux.so.1"

0x00400fae hit4_2 31ed4989d15e4889 "librt.so.1"

0x00400fc7 hit4_3 31ed4989d15e4889 "libacl.so.1"

0x00401004 hit4_4 31ed4989d15e4889 "libc.so.6"

0x004013ce hit4_5 "libc_start_main" 31ed4989d15e4889

0x00416542 hit4_6 "libs /"

31ed4989d15e4889

0x00417160 hit4_7 "lib / xstrtol.c" 31ed4989d15e4889

0x00417578 hit4_8 "lib" 31ed4989d15e4889

102
Buscar hacia atrás

buscar hacia atrás

Para buscar hacia atrás, utilice segundo


el / mando.

103
Buscar en la Asamblea

ensamblador Buscar

Si desea buscar un cierto código en ensamblador, También se puede


dousar
o / un /

comandos. El comandoc JMP


/ [esp] busca la tecla de acceso especificada asm:

[0x00404888]> / c JMP QWord [RDX] f hit_0 @ 0x0040e50d # 2: QWord JMP

[RDX] f hit_1 @ 0x00418dbb # 2: QWord JMP [RDX] f hit_2 @ 0x00418fcb # 3:

QWord JMP [RDX] f hit_3 @ 0x004196ab # 6: QWord JMP [RDX] f hit_4 @

0x00419bf3 # 3: QWord JMP [RDX] f hit_5 @ 0x00419c1b # 3: QWord JMP

[RDX] f hit_6 @ 0x00419c43 # 3: QWord JMP [RDX]

El comando un
/ jmp eaxmonta una cadena de código de máquina y, a continuación, busca los bytes resultantes:

[0x00404888]> / a jmp eax hits: 1

0x004048e7 hit3_0 ffe00f1f8000000000b8

104
La búsqueda de AES Keys

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

alcanza el final del archivo. Se puede interrumpir la búsqueda actual pulsando


Ctrl-C. Por ejemplo, para buscar claves AES en la

memoria física de su sistema:

$ Sudo r2 / dev / mem

[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?

| Uso: Z [* j-AOF / cs] zignatures [args] # Administrar | z

Mostrar zignatures

|z* Mostrar zignatures en formato radare

| ZJ Mostrar zignatures en formato JSON

| z-zignature eliminar zignature | z *

eliminar todos los zignatures

| za [?] añadir zignature

| zo [?] gestionar archivos zignature

| ZF [?] gestionar firmas LIGÓN

| z / [?] zignatures de búsqueda

| ZC comprobar en dirección zignatures

| ZS [?] gestionar zignspaces

Para cargar el archivo de la firma creada tiene que cargar desde un archivo usando
zo comandos
SDB o desde el archivo

comprimido con SDB


zoz mando.

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:

bytes: 31ed4989d15e4889e24883e4f050544c ............ ............ 48 48 ff ............ ...

. . . . . . . f4

gráfico: CC = 1 NBBS = 1 cantos = 0 reflujos = 1 offset:

0x000051c0 [0x000051c0]>

Como se puede ver se hizo una nueva firma con un nombre


entradade una función
Entry0.Se puede mostrar en formato JSON también,

que puede ser útil para secuencias de comandos:

106
firmas

[0x000051c0]> zj ~} {[

"Name": "entrada",

"bytes": "31ed4989d15e4889e24883e4f050544c ............ ............ 48 48 ff ............ ..... ..... f4" ,

"grafico": {

"CC": "1", "NBBS": "1",

"bordes": "0", "reflujos":

"1"},

"Compensación": 20928

"árbitros": []}]

[0x000051c0]>

Para eliminar esto justamentez-entrada


se Pero si desea guardar todas las firmas creadas, es necesario guardarlo en el archivo de

comandos usando SDB Entonces podemos aplicarlas. Vamos a abrir un archivo nuevo:
myentry zos.

r2 / bin / ls

- - Acceder. En Hack. Anda a cualquier lado. Consigue todo. [0x000051c0]> zo

myentry [0x000051c0]> entrada z:

bytes: 31ed4989d15e4889e24883e4f050544c ............ ............ 48 48 ff ............ ...

. . . . . . . f4

gráfico: CC = 1 NBBS = 1 cantos = 0 reflujos = 1 offset:

0x000051c0 [0x000051c0]>

Esto significa que las firmas se cargan correctamente desde el myentry


archivoy ahora podemos buscar funciones

coincidentes:

[0x000051c0]> ZC

[+] Buscar 0x000051c0 - 0x000052c0 [+] buscar métricas de

función resultados: 1

[0x000051c0]>

Tenga en cuenta que


ZC solo comando comprueba las firmas en contra de la dirección de la corriente. Para buscar firmas a través del archivo de

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 /

[+] Buscar 0x0021dfd0 - 0x002203e8 [+] buscar métricas de función

Hits: 0

[0x000051c0]>

Tenga en cuenta la dirección de la búsqueda - esto es porque necesitamos ajustar la búsqueda variar primero:

[0x000051c0]> e search.in = io.section [0x000051c0]> z /

[+] Buscar 0x000038b0 - 0x00015898 [+] buscar métricas de

función resultados: 1

[0x000051c0]>

Estamos estableciendo el modo de búsqueda


io.section (era archivopor defecto) para buscar en la sección actual (suponiendo que

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

31ed xor ebp, ebp

0x000051c2 4989d1 mov r9, RDX

0x000051c5 5e RSI pop

0x000051c6 4889e2 mov RDX, RSP

0x000051c9 4883e4f0 y RSP, 0xfffffffffffffff0

[0x000051c0]>

Aquí podemos ver el comentarioEntry0,


de que se toma de la análisis sintáctico ELF, sino también la

que
sign.bytes.entry_0, es exactamente el resultado de hacer coincidir la firma. configuración de firmas almacenadas

en laZign. Las variables de configuración de espacio de nombres:

[0x000051c0]> e Zign. zign.bytes =

true zign.graph = true zign.maxsz =

500 zign.mincc = 10 zign.minsz = 16

zign.offset = true zign.prefix signo =

zign.refs = true [0x000051c0]>

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,

radare vierten primer bloque actual en un archivo, y luego simplemente se llama

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,

establecer un nuevo tamaño de bloque con el mando.


segundo

[0x00000000]> b 100 ; establecer el tamaño de bloque de 100

[0x00000000]> pd ; desmontar 100 bytes

[0x00000000]> pd 3 ; desmonte 3 opcodes

[0x00000000]> PD 30 ; desensamblar 30 bytes

los pD comando funciona como


pd pero acepta el número de bytes de entrada como su argumento, en lugar del número de códigos de

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

[0x00405e1c]> e asm.pseudo = true [0x00405e1c]> pd 3

; JMP XREF de 0x00405dfa 0x00405e1c (fcn.00404531)

488b9424a80. RDX = [RSP + 0x2a8]

0x00405e24 64483314252. RDX ^ = [FS: 0x28]

0x00405e2d 4889d8 rax = rbx

[0x00405e1c]> e asm.syntax = Intel [0x00405e1c]> pd 3

; JMP XREF de 0x00405dfa 0x00405e1c (fcn.00404531)

488b9424a80. mov RDX, [RSP + 0x2a8]

0x00405e24 64483314252. RDX xor, [FS: 0x28]

0x00405e2d 4889d8 mov rax, RBX

[0x00405e1c]> e asm.syntax = att [0x00405e1c]> pd 3

; JMP XREF de 0x00405dfa 0x00405e1c (fcn.00404531)

488b9424a80. mov 0x2a8 (% RSP),% RDX

0x00405e24 64483314252. xor% fs: 0x28, RDX%

0x00405e2d 4889d8 mov% rbx,% rax

111
Adición de metadatos

Adición de metadatos para Desmontaje

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

escribir una pequeña utilidad en un lenguaje de script que usa otool,


objdump, etc., para obtener información de un binario y para

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:

[0x00000000]>.! Idc2r.py <file.idc

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?

| Uso: [? *] C [? -LCvsdfm *] [...] gestión de metadatos # | DO*

Información de la lista de comandos meta r2

| C- [len] [[@] addr] eliminar metadatos en Rang dirección indicada

mi

| CL [-] [*] [archivo: Línea] [dir] mostrar o añadir 'línea de código' de la información (

bininfo)

| CS [-] [espacio] gestionar los meta-espacios para filtrar los comentarios

, etc ..

| CC [?] [-] [Comentario de texto] [@addr] añadir / eliminar comentarios

| CC. [Addr] Mostrar comentario en la dirección actual

| CC! [@addr] Editar comentario con $ EDITOR

| CPBa [-a] | [a] [Texto] [@addr] añadir / quitar comentario en la dirección dada

| CCU [comentario de texto] [@addr] Añadir comentario único

| Cv [BSR] [?] añadir comentarios a args

| Cs [?] [-] [tamaño] [@addr] agregar una cadena

| Cz [@addr] complemento cadena terminada en cero

| Ch [-] [tamaño] [@addr] ocultar datos

| Cd [-] [tamaño] [repetir] [@addr] matriz de datos hexdump (Cd 4 10 dword ==

[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]> CPBa 0x0000002 este tipo parece de fiar

[0x00000000]> pd 2

0x00000000 0000 añadir [rax], al

; este tipo parece de fiar 0x00000002

0000 añadir [rax], al

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

realiza mediante asm.arch), datos (un conjunto de elementos de datos) o cadena.


cs COMAND
Utilizar el para definir una cadena, utilice el
Discos

compactoscomando para la definición de una matriz de elementos de datos, y elcfuso


comando
de la para definir estructuras de datos más

complejas como estructuras.

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

[0x00000000]> f string_foo @ 0x800 [0x00000000]> Cs 10 @

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

PF mando). He aquí un ejemplo:

[0x7fd9f13ae630]> Cf 16 2xi foo bar [0x7fd9f13ae630]> pd

;-- DEP:

0x7fd9f13ae630 formato de barra de 2xi foo {

0x7fd9f13ae630 [0] {

foo: 0x7fd9f13ae630 = 0xe8e78948 barra: 0x7fd9f13ae634

= 14696}

0x7fd9f13ae638 [1] {

foo: 0x7fd9f13ae638 = 0x8bc48949 bar: 0x7fd9f13ae63c =

571,928,325}} 16

0x7fd9f13ae633 0x7fd9f13b1fa0 e868390000 llamada

0x7fd9f13b1fa0 (); rasgar

0x7fd9f13ae638 4989c4 mov r12, rax

Los [sz] argumento para


cf se utiliza para definir el número de bytes de la estructura debe asumir en el desmontaje, y es completamente

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

tamaño completo utilizando


SZla
argumento. Utilizando
cf, es fácil de definir para definir estructuras complejas con oneliners simples.
PF? Ver

para más información. Recuerde que todos do


estos
comandos también se puede acceder desde el modo visual

pulsando eld ( conversión de datos) clave.

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:

while ((palabra = haveCommand ())) {

si (word.isOperator ()) {

esilOperators [palabra] (esil); } Else {

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:

4, esp, - =, ebp, esp, = [4]

¿Puedes adivinar que es esto? Si tomamos esta notación post-fix y transformar de nuevo en-fix obtenemos

esp - 4 =

4bytes (DWORD) [esp] = ebp

Podemos ver que esto corresponde a la instrucción x86


ebp ¿No es genial? El objetivo es ser capaz de expresar la mayor parte de las
empujar!

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

Usando el modo visual es grande para inspeccionar las evaluaciones Esil.

Hay 2 variables de entorno que son importantes para la observación de lo que hace un programa:

[0x00000000]> e asm.emu = true [0x00000000]> e

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

qué valor va a donde.

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.

[0x00000000]> e asm.esil = true

En el modo visual también se puede alternar este simplemente escribiendo


O.

Comandos Esil

"AE": Evaluar la expresión ESIL.

[0x00000000]> "ae 1,1, +" 0x2

[0x00000000]>

"AES": ESIL paso.

[0x00000000]> aes

[0x00000000]> 10aes

116
ESIL

"AESO": Paso a paso por ESIL.

[0x00000000]> AESO

[0x00000000]> 10aeso

"AESU": ESIL paso hasta.

[0x00001000]> AESU 0x1035 ADDR PAUSA

[0x00001019]>

"Ar": Muestra / modifica el registro ESIL

[0x00001ec7]> ar r_00 = 0x1035 [0x00001ec7]> ar

r_00 0x00001035 [0x00001019]>

ESIL conjunto de instrucciones

Éste es el conjunto completo de instrucciones utilizado por la ESIL VM:

ESIL
Nombre Operación ejemplo
código de operación Operandos

TRAMPA src Trampa señal de trampa

ps src syscall syscall

Obtener la dirección de la pila


dirección de la instrucción actual = dirección
$$ src
instrucción de la instrucción

apilar = (dst == src);


update_eflags (dst
== src, dst Comparar

- src)

[0x0000000]> "ae 1,5, <" 0x0


apilar = (dst <src); [0x00000000]> "ae
Más pequeña
< src, dst (comparación
update_eflags (dst
firmado)
- src) 5,5"
0x0"

[0x0000000]> "ae 1,5, <" 0x0


Menor o igual apilar = (dst <=
src);

117
ESIL

(Comparación con update_eflags (dst [0x00000000]> "ae


signo) - src) 5,5"
0x1"

[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

0x0 [0x00000000]> "ae

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

- src, dst SUB apilar = dst - src 5,5, - "0x0


[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

/ src, dst DIV apilar = dst / src 5,5, / "0x1


[0x00000000]>" ae

5,9, /"
0x1

[0x00000000]> "ae
2,4,% "0x0
[0x00000000]>" ae

% src, dst MOD apilar = dst% src 5,5,% "0x0


[0x00000000]>" ae

5,9,%"
0x4

[0x00000000]> "ae 1 ,!" 0x0


[0x00000000]> "ae 4 ,!" 0x0
[0x00000000]> "ae 0 ,!" 0x1
! src NEG apilar = src !!!

[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

[0x00000000]> "ae r_01, r_00,


+ =" [0x00000000]> ar r_00
+= src, reg AÑADIR eq reg = reg + src 0x00000005 [0x00000000]>
"ae

5, r_00, + ="[0x00000000]> ar
r_00 0x0000000a

[0x00000000]> "ae r_01, r_00,


- =" [0x00000000]> ar r_00
0x00000004 [0x00000000]>
"ae
-= src, reg eq SUB reg = reg - src

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

%= src, reg eq MOD reg = reg% src

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

2, r_01, << ="[0x00000000]>


ar r_01 0x00000008

[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

2, r_01, >> ="[0x00000000]>


ar r_01 0x00000001

[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

y= src, reg Y eq reg = reg & src

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

[0x00000000]> "ae r_00, r_01,


|= src, reg O eq reg = reg | src | =" [0x00000000]> ar r_01
0x00000003 [0x00000000]>
"ae

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 elemento n-ésimo de

RECOGER norte Recoger la parte superior de la pila 2, Pick

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

Si la alta elemento es una


referencia (registrar su
nombre, etiqueta, etc.),
NUM Numérico eliminar la referencia y NUM
empujar su valor real

CLARO Claro claro pila CLARO

Detiene la
DESCANSO Descanso DESCANSO
emulación ESIL

Salta a la enésima

124
ESIL

IR norte Ir Salta a la enésima GOTO 5


palabra 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

las banderas bajo ciertas condiciones o en instrucciones específicas.

indicadores internos tienen el prefijo $ personaje.

z - bandera cero, sólo se establece si el resultado de una operación es 0

segundo - prestado, esto requiere que se especifique de qué bit (ejemplo: $ b4 - Comprueba si bor

fila de 4) c bit

- llevar, igual como antes (ejemplo: $ C7 - comprueba si acarreo desde el bit 7)

o - rebosar

pag - paridad

r - regsize (asm.bits / 8)

s - firmar

ds - estado hueco de retardo

jt - destino del salto

js - de ajuste de referencia de salto

[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

restablecer el indicador de desbordamiento)

Sintaxis y comandos

Un código de operación objetivo se traduce en una lista separada por comas de expresiones esil.

xor eax, eax - > 0, eax, =, 1, zf, =

acceso a la memoria se define por la operación entre paréntesis:

mov eax, [0x80480] -> 0x80480, [], eax, =

tamaño del operando por defecto está determinado por el tamaño de destino de la operación.

125
ESIL

movb $ 0, 0x80480 - > 0,0x80480, = [1]

Los ? operador utiliza el valor de su argumento para decidir si para calcular la expresión entre llaves.

1. ¿Está el valor cero? -> evitarlo.

2. ¿Es el valor que no sea cero? -> evaluarlo.

cmp eax, 123 -> 123, EAX, ==, $ z, ZF, = jz eax

- > ZF, {, EAX, EIP, =,}

Si desea ejecutar varias expresiones bajo un condicional, ponerlos entre llaves:

? ZF, {, EIP, esp, = [], eax, EIP, =, $ r, esp, - =,}

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:

esil = r_str_replace (esil, "", "", R_TRUE);

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

Los argumentos para que las operaciones no


asociativo

Como se discutió en el IRC, implementación actual funciona así:

a, b, - b-a

a, b, / = b/=a

Este enfoque es más fácil de leer, pero es menos pila de usar.

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

por cero, error de lectura de la memoria, etc.

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

encuentra probablemente en la primera expresión de la lista.

índice de('[') - > tienen referencias de memoria

indexOf ( "= [") - > escribir en la memoria

indexOf ( "PC, =") - > modifica contador de programa (rama, salto, llamada)

indexOf ( "sp, =") - > modifica la pila (¿y si nos encontramos SP + = o = SP-?)

indexOf ( "=") - > recuperar src y dst

índice de(":") - > Esil desconocido, código de operación en bruto por delante

indexOf ( "$") - > accesos banderas esil vm interna ex: $ z

indexOf ( "$") - > ex syscall: 1, $

indexOf ( "trampa") - > pueden atrapar

indexOf ( '++') - > tiene iterador

índice de('--') - > cuenta a cero

índice de("?{") - > condicional

igual a("") - > cadena vacía, significa: nop (mal, si añadimos la PC + = x)

las operaciones más comunes:

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

encuentran bajo el tipo 'FLG' registro.

Variables

Propiedades de las variables VM:

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

ejemplo, para MMX, SSE, AVX, neón SIMD.

2. No puede ser el número de variables no unido. Se lleva a cabo la compatibilidad SSA-forma.

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.

Las matrices de bits

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 "!"

Flotante Punto de Apoyo

QUE HACER

Manipulación x 86 REP Prefijo en Esil

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

3, PASE - skip instrucciones N. se utiliza para hacer GOTOs adelante relativos

3, GOTO - instrucción Goto 3 BUCLE

- alias para 0, GOTO

DESCANSO - dejar de evaluar la expresión

APILAR - volcar contenido de la pila a la pantalla

CLARO - pila clara

Ejemplo de uso:

CMPSB representante

! Cx,, {, rotura,}, ESI, [1], EDI, [1], == {,?, rotura,}, esi, ++, EDI, ++, CX, -, 0, IR

Instrucciones de no implementadas / no controladas

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:

fmulp ST (1), ST (0) => TODO, fmulp ST (1), ST (0)

ESIL Desmontaje Ejemplo:

129
ESIL

[0x1000010f8]> e asm.esil = true [0x1000010f8]> pd $

r @ Entry0

; [0] va = 0x1000010f8 pa = 0x000010f8 sz = 13299 vsz = 13299 rwx = -rx 0 .__ texto

; - section.0 .__ texto: 0x1000010f8

55 8, RSP, - =, RBP, RSP, = [8]

0x1000010f9 4889e5 RSP, RBP, =

0x1000010fc 4883c768 104, RDI, + =

0x100001100 4883c668 104, RSI, + =

0x100001104 5d RSP, [8], RBP, =, 8, RSP, + =

┌─ <0x100001105 e950350000 0x465a, rip, = [1];

│ 0x10000110a 55 8, RSP, - =, RBP, RSP, = [8]

│ 0x10000110b 4889e5 RSP, RBP, =

│ 0x10000110e 488d4668 RSI, 104, +, rax, =

│ 0x100001112 488d7768 RDI, 104, +, RSI, =

│ 0x100001116 4889c7 rax, RDI, =

│ 0x100001119 5d RSP, [8], RBP, =, 8, RSP, + =

┌── <0x10000111a e93b350000 0x465a, rip, = [1];

││ 0x10000111f 55 8, RSP, - =, RBP, RSP, = [8]

││ 0x100001120 4889e5 RSP, RBP, =

││ 0x100001123 488b4f60 RDI, 96, +, [8], RCX, =

││ 0x100001127 4c8b4130 rcx, 48, +, [8], r8, =

││ 0x10000112b 488b5660 RSI, 96, +, [8], RDX, =

││ 0x10000112f b801000000 1, eax, =; 0x00000001

││ 0x100001134 4c394230 RDX, 48, +, [8], r8, ==, cz,? =

┌─── <0x100001138 7f1a sf, de,, ^, zf,, y ,? {, 0x1154, rasgar, =,};! [2]

┌──── <0x10000113a 7d07 de,, sf, ^ {,?, 0x1143, rasgar,};! [3]

││││ 0x10000113c b8ffffffff 0xFFFFFFFF, eax, =; 0xffffffff

┌───── <0x100001141 EB11 0x1154, rip, = [2];

│└────> 0x100001143 488b4938 rcx, 56, +, [8], RCX, =

│ │││ 0x100001147 48394a38 RDX, 56, +, [8], RCX, ==, cz,? =

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

posible la extracción de información mediante el análisis de las expresiones fácilmente.

> ao ~ esil, código de operación de código de

operación: JMP 0x10000465a Esil: 0x10000465a,

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

condicionales. Necesitamos expresiones para ser capaz de obtener:

Tipo de código de operación de

destino de salto

130
ESIL

condición depende de todas las reglas

modificadas (escritura), reglas todos los

que se accede (leer)

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

llama. Se puede utilizar para determinar si


q.e.p.d.

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:

esil.on ( 'regset', function () {..

esil.on ( 'syscall', function () {esil.regset ( 'RIP'

Para el API en funciones Una


hook_flag_read (), hook_execute (), hook_mem_read (). devolución de llamada debe devolver verdadero si desea

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,

y r_io. Esto se debe definir en la inicialización de VM esil.

Io Get / Set

hacha, 44

44, hacha,: ou

Selectores (cs, ds, gs ...)

eax Mov, ds: [ebp + 8] Ebp, 8, + ,:

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

0x00404800 b827e66100 mov eax, 0x61e627 ; "lengüeta"

Dirección: 0x404800

opcode: eax mov, 0x61e627 prefijo: 0

bytes: b827e66100 ptr:

0x0061e627 refptr: 0 Tamaño:

5 Tipo: mov

Esil: 6415911, rax, = pila: Familia

nulo: cpu [0x00404800]>

Simplemente ejecuta el segundo comando después de terminar la primera, como en una concha. La segunda forma

importante de la secuencia de los comandos es con un simple tubo |

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

hacer eso sin saltar a la misma, utilizando una secuencia de comandos:

132
scripting

[0x00404800]> pd 1

0x00404800 b827e66100 mov eax, 0x61e627 ; "lengüeta"

[0x00404800]> Dirección ao:

0x404800

opcode: eax mov, 0x61e627 prefijo: 0

bytes: b827e66100 ptr:

0x0061e627 refptr: 0 Tamaño:

5 Tipo: mov

Esil: 6415911, rax, = pila: Familia

nulo: cpu

[0x00404800]> ao ~ ptr [1] 0x0061e627 0

[0x00404800]> 10 px @ `ptr ao ~ [1]`

- compensar - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF 0x0061e627 7461 6200 2e69 6e74 6572

tab..inter

[0x00404800]>

Y por supuesto que es posible redirigir la salida de un comando r2 en un archivo, utilizando el > y >> comandos

[0x00404800]> 10 px @ `ptr ao ~ [1]`> example.txt [0x00404800]> 10 px @ `~ ao ptr

[1]` >> example.txt

La? $? comando describe varias variables votos que puede utilizar para hacer acciones similares, incluso con mayor facilidad,
v como el $

" valor inmediato" variable ometro


el $la memoria de código de operación variable de referencia.

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.

Podemos bucle sobre banderas:

@@ flagname en expresiones regulares

Por ejemplo, queremos ver información de la función


AFI con
mando:

[0x004047d6]> afi

offset: tamaño Entry0:: Nombre

0x004047d0 42 realsz: 42

StackFrame: 0

llamar-convención: amd64

ciclomática-complejidad: 1 bits: 64

Tipo: fcn [nuevo] núm-bbs:

1 Bordes: 0 finales bbs: 1

llamar-refs: 0x00402450 C

ficha árbitros: 0x004136c0 0x00413660 0x004027e0 código-refx: data-refx:

clientes locales: 0: 0 args

diff: Tipo: nueva

[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

[0x004047d6]> afi @@ FCN. * ~ Nombre

Este comando extraeránombre


el ámbito de la
AFI salida de cada marca con un nombre que coincida con la expresiónFCN.
regular

*.

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:

opcode 0x4047d6: RDX mov, RSP prefijo: 0

bytes: 4889e2 refptr: 0 Tamaño: 3 Tipo: mov

esil: RSP, RDX, = pila: null familia: la

dirección de CPU: opcode 0x4047d8:

bucle 0x404822 prefijo: 0 bytes: refptr

E248: 0 Tamaño: 2 Tipo: CJMP

Esil: 1, RCX, - =, RCX, {, 4.212.770, rasgar, =,} salto:? 0x00404822

fallar: 0x004047da apilar: cond nulo: otros familiares: cpu

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

[0x004047d0]>? V $$> offsets.txt [0x004047d0]>? V $$ + 2 >>

offsets.txt [0x004047d0]>! Offsets.txt gato 4047d2 4047d0

[0x004047d0]> pi 1 @@. Offsets.txt ebp xor, ebp mov r9,

RDX

radare2 también ofrece diversas


para cadaconstrucciones para bucle. Uno de los más útiles es de bucle a través de todas las

instrucciones de una función:

135
bucles

[0x004047d0]> ╒ pdf (FCN)

Entry0 42 │

; UNKNOWN XREF de 0x00400018 (unk)

│ ; DATOS XREF de 0x004064bf (sub.strlen_460)

│ ; DATOS XREF de 0x00406511 (sub.strlen_460)

│ ; DATOS XREF de 0x0040b080 (unk)

│ ; DATOS XREF de 0x0040b0ef (unk)

│ 0x004047d0 31ed xor ebp, ebp

│ 0x004047d2 4989d1 mov r9, RDX

│ 0x004047d5 5e RSI pop

│ 0x004047d6 4889e2 mov RDX, RSP

│ 0x004047d9 4883e4f0 y RSP, 0xfffffffffffffff0

│ 0x004047dd 50 empuje rax

│ 0x004047de 54 empuje RSP

│ 0x004047df 49c7c0c03641. mov r8, 0x4136c0

│ 0x004047e6 48c7c1603641. mov RCX, 0x413660 ; "AWA..AVI..AU

I..ATL.% .. "

0x00413660; "AWA..AVI..AUI..ATL.% .." │

0x004047ed 48c7c7e02740. mov RDI, principal ; "AWAVAUATUH ..

S..H ...." @

0x4027e0 │

0x004047f4 e857dcffff llamar sym.imp .__ libc_start_main

╘ 0x004047f9 f4 HLT

[0x004047d0]> pi 1 @@ i mov r9, RDX

pop RSI mov RDX, RSP

y RSP, empuje 0xfffffffffffffff0 rax empuje RSP

r8 mov, 0x4136c0 mov RCX,

0x413660 mov RDI, principal

llamar sym.imp .__ libc_start_main hlt

En este ejemplo, el comando


PI 1 corre sobre todas las instrucciones de la función actual (Entry0). Hay otras opciones

(lista no completa, comprobar @@? para más información):

@@ k sdbquery -iterar sobre todos los desplazamientos devueltos por que sdbquery

@@ t - iterar sobre todos los temas (véase DP)

@@segundo -iterar sobre todos los bloques básicos de la función actual (ver AFB)

@@F - iterar sobre todas las funciones (ver aflq)

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

puede hacer con el comando @@@:

[0x004047d6]> afi @@@ funciones ~ nombre

Esto extraerá
nombrecampo deAFI producción y dará salida a una gran lista de nombres de función. Podemos elegir sólo la

segunda columna, para eliminar la redundancia


nombre:en cada línea:

[0x004047d6]> afi @@@ funciones ~ nombre [1]

137
macros

Aparte de secuenciación simple y bucle, radare2 permite escribir macros simples, usando esta construcción:

[0x00404800]> (qwe, pd 4, ao)

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:

[0x00404800]> (qwe, pd 4, ao) [0x00404800]>.

(Qwe)

0x00404800 b827e66100 mov eax, 0x61e627 ; "lengüeta"

0x00404805 55 empuje RBP

0x00404806 482d20e66100 sub rax, section_end.LOAD1

0x0040480c 4889e5 mov RBP, RSP

Dirección: 0x404800

opcode: eax mov, 0x61e627 prefijo: 0

bytes: b827e66100 ptr:

0x0061e627 refptr: 0 Tamaño:

5 Tipo: mov

Esil: 6415911, rax, = pila: Familia

nulo: cpu [0x00404800]>

Para una lista de macroses disponibles simplemente llaman (*:

[0x00404800]> (* (qwe, pd 4,

ao)

Y si quieren eliminar algunos macro, sólo tiene que añadir '-' antes del nombre:

[0x00404800]> (-qwe) Macro 'qwe'

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]

[0x004047d0]> "(foo x y, Pd $ 0; s + $ 1)". [0x004047d0]> (foo 5 6)

; - Entry0: 0x004047d0

31ed xor ebp, ebp

0x004047d2 4989d1 mov r9, RDX

0x004047d5 5e RSI pop

0x004047d6 4889e2 mov RDX, RSP

0x004047d9 4883e4f0 y RSP, 0xfffffffffffffff0

[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:

tuberías de regeneración (r2 -0) http

consultas (nube amable) socket TCP (r2 -c)

desove tubería asíncrono http TCP rap JSON

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

$ PIP instalar r2pipe

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

( "Aflj" )) # Evalúa JSONs y devuelve un objeto

140
R2pipe

NodeJS

$ NPM instalar r2pipe

var r2jsapi = "./r2.js"; var r2node = require ( "./");

var file = "/ bin / ls";

función doSomeStuff (r) {

var r2 = require (r2jsapi) (r); r2.analOp ( "Entry0", la función (op)

console.log (op.size, op.opcode, op.esil); });

r2.cmd ( 'af @ Entry0', function (o) {

r2.cmd ( "pdf @ Entry0", la función (o) {

console.log (o);

r.quit ()

}); });

r2node.pipe (archivo, doSomeStuff); r2node.launch (archivo,

doSomeStuff);

Completa documentación del API: https://github.com/radare/radare2bindings/blob/master/r2pipe/nodejs/README.md

Ir

$ R2pm -i r2pipe-go

- - go-repo r2pipe

141
R2pipe

paquete principal

importar (

"FMT"

"Github.com/radare/r2pipe-go"

func principal() {

R2P, err: = r2pipe.NewPipe ( "/ bin / ls" )

Si err! = nulo {

pánico (Err)}

aplazar r2p.Close ()

_, Err = r2p.Cmd ( "Aaaa" )

Si err! = nulo {

pánico (Err)}

buf0, err: = r2p.Cmd ( "S *" )

Si err! = nulo {

pánico (Err)}

fmt.Println (buf0)

buf1, err: = r2p.Cmd ( "Pi 10" )

Si err! = nulo {

pánico (Err)}

fmt.Println (buf1)

BUF2, err: = r2p.Cmd ( "64 px" )

Si err! = nulo {

pánico (Err)}

fmt.Println (BUF2)}

Moho

$ Cat Cargo.toml

. . .

[Dependencias] r2pipe =

"*"

142
R2pipe

# [Macro_use]

externo caja r2pipe;

utilizar r2pipe :: R2Pipe;

fn principal () {

// Iniciar una nueva tubería

dejar que mut R2P = open_pipe! ( Algunos ( "/ bin / ls" )).desenvolver();

// r2p.cmd () para enviar un comando a r2

println! ( "{:}?" , R2p.cmd ( "? E Hello World" ));

// r2p.cmdj () para enviar un comando y analizar el JSON devuelto

dejar json = r2p.cmdj ( "Ij" ).desenvolver();

println! ( "{}" , Json.pretty ());

println! ( "ARCO {}" , Json.find_path (y [ "compartimiento" , "arco" ]).desenvolver());

// cerrado y listo!

r2p.close (); }

Rubí

$ Gem install r2pipe

exigir 'R2pipe'

pone 'Rubí r2pipe API de demostración'

pone '===================='

R2P = R2Pipe.new '/ bin / ls'

pone r2p.cmd 'Pi 5'

pone r2p.cmd 'Pij 1'

pone r2p.json (r2p.cmd 'Pij 1' ) Pone r2p.cmd 'Px 64'

r2p.quit

Perl

143
R2pipe

# ! / Usr / bin / perl

uso R2 :: Pipe; utilizar

estricta;

mi $ r = R2 :: sobre tubería> new ( "/ bin / ls"); . Print $ r-> cmd

( "PD 5") "\ n"; print $ r-> cmd ( "64 px") "\ n".; $ R-> quit ();

Erlang

# ! / Usr / bin / env Escript

%% - * - Erlang - * %%! -smp

permitir

%% hr -sNOMBRE

- modo (compilar) .

- exportar ([Principal / 1]) .

principal (_Args) ->

%% añadiendo r2pipe a ModulePath, ponerlo en su ubicación r2pipe_erl

R2pipePATH = Nombre del archivo: dirname (Escript: SCRIPT_NAME ()) ++ "/ Ebin" ,

cierto = Código: add_pathz (R2pipePATH),

%% inicializar el enlace con r2

H = r2pipe: init (lpipe),

%% todo el trabajo va aquí

io: formato ( "~ s" , [R2pipe: cmd (H, "yo" )]).

Haskell

144
R2pipe

importar R2pipe

importar calificado Data.ByteString.Lazy como L

showMainFunction ctx = hacer

cmd ctx "S Main"

L.putStr = << cmd ctx "PD` `fl $$"

principal = hacer

- - Ejecutar r2 localmente

abierto "/ bin / ls" >> = showMainFunction

- - Conectarse a r2 a través de HTTP (por ejemplo, si "R2 -QC = H / bin / ls" se está ejecutando)

abierto "Http://127.0.0.1:9090" >> = showMainFunction

Punto net

145
R2pipe

utilizando Sistema;

utilizando System.Collections.Generic;

utilizando Diagnostico del sistema;

utilizando System.Linq;

utilizando System.Text;

utilizando System.Threading.Tasks;

utilizando r2pipe;

espacio de nombres LocalExample

clase Programa

hoyo estatico Principal ( cuerda [] Args )

# Si __MonoCS__

utilizando (Tubo de IR2Pipe = nuevo R2Pipe ( "/ bin / ls" ))

# más

utilizando (Tubo de IR2Pipe = nuevo R2Pipe ( @ "C: \ Windows \ notepad.exe" ,

@ "C: \ radare2 \ radare2.exe" ))

#terminara si

Console.WriteLine ( "Hola r2!" + Pipe.RunCommand ( "? V" )); tarea < cuerda > asíncrono =

Pipe.RunCommandAsync ( "? V" ); Console.WriteLine ( "Hola r2 asíncrono!" + asíncrono .Resultado);

QueuedR2Pipe QR2 = nuevo QueuedR2Pipe (tubo);

qr2.Enqueue ( nuevo R2Command ( "x" , ( cuerda resultado) => {

Console.WriteLine ( "Resultado de la x: \ n {0}" , Dan como resultado); }));

qr2.Enqueue ( nuevo R2Command ( "Pi 10" , ( cuerda resultado) => {

Console.WriteLine ( "Resultado de la PI 10: \ n {0}" , Dan como resultado); }));

qr2.ExecuteCommands (); }}}}

Java

146
R2pipe

importar org.radare.r2pipe.R2Pipe;

público clase Prueba {

public static void principal (args String []) {

tratar {

R2Pipe R2P = nuevo R2Pipe ( "/ bin / ls" );

// R2Pipe R2P = new R2Pipe ( "http://cloud.rada.re/cmd/", true);

System.out.println (r2p.cmd ( "PD 10" )); System.out.println (r2p.cmd ( "32

px" )); r2p.quit (); } captura (Excepción e) {

System.err.println (e); }}}

Rápido

si se deja R2P = R2Pipe (url: nulo ) {r2p.cmd ( "? V" , El

cierre: {(str: String?) en caso de dejar s = str

impresión ( "Versión: \ (s)" ); salida ( 0 );

} más {

debugPrint ( "R2PIPE. Error" ); salida ( 1 );

}});

NSRunLoop.currentRunLoop run () ().; } más {

impresión ( "Needs a correr desde r2" )

Vala

147
R2pipe

público static int principal ( cuerda [] Args) {

MainLoop loop = nuevo Bucle principal ();

var = R2P nuevo R2Pipe ( "/ bin / ls" ); r2p.cmd ( "Pi 4" , (X) => {

stdout .printf ( "DISASM ((% s)) \ n" , x); r2p.cmd ( "es decir" , (X) =>

stdout .printf ( "Entrada ((% s)) \ n" , x); r2p.cmd ( "Q" );

}); });

ChildWatch.add (r2p.child_pid, (PID, estado) => {

// Se activa cuando el niño indicado por las salidas child_pid

Process.close_pid (pid); loop.quit (); });

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" ));

writeln ( "Hola " ~ R2.cmd ( "? E trabaja" ));

cuerda uri = r2.cmdj ( "Ij" ) [ "núcleo" ] [ "URI" ] .str; writeln ( "Uri" , Uri);

148
Rabin2

Rabin2 - Mostrar propiedades de un Binario

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

- @ [Addr] mostrar la sección, símbolo o importación en addr

- UN lista de sub-binarios y sus pares de arco-bits

- un [arco] arco conjunto (x86, brazo, .. o <arch> _ <puntas>)

- b [bits de] los bits de ajuste (32, 64 ...)

- B [addr] dirección de base de anulación (bins PIE)

- do lista clases

- C [fmt: C: D] crear [elf, mach0, pe] con el código y los datos hexpairs (ver -a)

- re espectáculo de depuración / información enana

- Nombre D lang demangle nombre de símbolo (-D todo por bin.demangle = true)

- mi punto de entrada

- mi símbolos globalmente exportables

- f [str] seleccionar sub-compartimiento llamado str

- F [binfmt] la fuerza para utilizar ese plugin bin (ignorar comprobación de cabecera)

- gramo mismo que -SMZIHVResizcld (mostrar toda la información)

- G [addr] dirección de carga. desplazamiento a la cabecera

- marido este mensaje de ayuda

- MARIDO campos de cabecera

- yo importaciones (símbolos importados de bibliotecas)

- yo información binaria

- j salida en JSON

- k [SDB-query] ejecución de la consulta SDB. por ejemplo: '*'

- K [algo] calcular sumas de comprobación (MD5, SHA1, ..)

- l bibliotecas vinculadas

- L [Plugin] Lista apoyado plugins BIN o detalles de plugin

- m [addr] mostrar línea de fuente en addr

- METRO principal (demostración de la dirección del símbolo principal)

- n [str] sección muestran, símbolo o str importación designado

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

- O [str] escribir / operaciones de extracto (= O ayuda)

- pag mostrar direcciones físicas

- PAG espectáculo de depuración / información de AP

- PÁGINAS descargar el archivo pdb para binario

- q estar en silencio, simplemente mostrar un menor número de datos

- qq mostrar menos información (sin desplazamiento / tamaño para -z por ej.)

- Q dirección Mostrar carga utilizado por dlopen (libs no ASLR)

149
Rabin2

- r salida radare

- R reubicaciones

- s símbolos

- S secciones

- u sin filtrar (no hay símbolos de cambio de nombre duplicado / secciones)

- v mostrar la versión y salir

- V Mostrar información de la versión binaria

- x bins extracto contenido en el archivo

- X [fmt] [f] .. paquete de contenido de grasa o zip los archivos y contenedores estén impresos en archivos

- z cuerdas (de la sección de datos)

- zz cuerdas (de contenedores primas [e bin.rawstr = 1])

- zzz volcar cuerdas primas a la salida estándar (para archivos de gran tamaño)

- Z adivinar el tamaño del programa binario

. . . . . .

150
La identificación del archivo

Presentar identificación Propiedades

Identificación del tipo de archivos se realiza utilizando


YO . Con
- esta opción, rabin2 imprime información sobre el tipo de un sistema binario,

su codificación, endianness, clase, sistema operativo, etc .:

$ Archivo rabin2 -I / bin / ls

/ Tipo / bin ls

EXEC (archivo ejecutable) pic falsa

has_va verdadera raíz

clase

duende ELF64 lang

arco los

bits x86 64

SUBSYS máquina AMD x86-64 la arquitectura del

sistema operativo Linux Linux pequeña franja

verdaderos falsa lineNum falsas lsyms estáticas endian

falsas reubicaciones falsa rpath NINGUNO

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:

$ Rabin2 -iR / bin / ls e file.type = elf e

cfg.bigendian = false e asm.os = Linux

e asm.arch = x86 e anal.arch = x86 e

asm.bits = 64 e asm.dwarf = true

151
Punto de entrada

código de puntos de entrada

los - mi opciones transferida a rabin2 mostrará puntos de entrada para binario dado. Dos ejemplos:

$ Rabin2 -e / bin / ls [puntos de

entrada]

addr = 0x00004888 off = 0x00004888 baddr = 0x00000000

1 puntos de entrada

$ Rabin2 -er / bin / ls fs símbolos

f Entry0 @ 0x00004888 s Entry0

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:

$ Rabin2 -i / bin / ls | cabeza [importaciones]

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

Rabin2 es capaz de encontrar exportaciones. Un ejemplo:

$ Rabin2 -E RtmPal.dll | cabeza [exportaciones]

vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 000 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $

@ $ 0bC 0BG @@ @@ priv @ spl_v18 YAHXZ

vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 001 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $

@ $ 0bC 0BH @@ @@ priv @ spl_v18 YAHXZ

vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 002 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $

@ $ 0bC 0BI @@ @@ priv @ spl_v18 YAHXZ

vaddr = 0x100955c0 PADDR = 0x000949c0 ord = 003 = NONE FWD sz = 0 = se unen tipo GLOBAL = nombre FUNC = Rtm Pal.dll _ ?? $ check_version @ $

@ $ 0bC 0BJ @@ @@ priv @ spl_v18 YAHXZ (...)

154
Símbolos (exportaciones)

Símbolos (Exportaciones)

Con rabin2, el formato de la lista de símbolos generado es similar a la lista de importaciones.


s Utilizar el -

opción para conseguirlo:

-s $ rabin2 / bin / ls | cabeza [símbolos]

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

= 117 fwd = NONE sz = 8 bind = tipo GLOBAL = nombre de objeto = __ pr ogname

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.

$ rabin2 -SR / bin / ls

símbolos fs

Cd 8 @ 0x0021a610

f sym.stdout 8 0x0021a610 f sym._edata 0

0x0021a600 f sym._end 0 0x0021b388 Cd 8

@ 0x0021a600

f sym .__ progname 8 0x0021a600 Cd 8 @

0x0021a630

f sym.program_invocation_name 8 0x0021a630 f sym .__ bss_start 0

0x0021a600

155
bibliotecas

Bibliotecas lista

Rabin2 puede listar las bibliotecas utilizadas por un binario lcon


opción:
el -

$ Rabin2 -l / bin / ls [bibliotecas

Vinculados] libselinux.so.1

librt.so.1 libacl.so.1 libc.so.6

4 bibliotecas

Si se comparan los resultados rabin2


de -ly LDD, notará que rabin2 enumera un menor número de bibliotecas
LDD. La
que

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

archivos PE. Ejemplo:

$ Rabin2 -z / bin / ls | cabeza

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.

$ Rabin2 -ZR / bin / ls | cabeza fs cuerdas

f str.src_ls.c 9 @ 0x00012487 Cs 9 @ 0x00012487

f str.sort_type__sort_version 26 @ 0x00012490 Cs 26 @ 0x00012490 f str._lu 5 @

0x000124aa Cs 5 @ 0x000124aa

f str .__ lu_ 14 @ 0x000124b0 Cs 7 @

0x000124b0

f str._s__s 8 @ 0x000124ba (...)

157
Instrumentos de cuerda

158
Las partes del programa

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:

$ Rabin2 -S / bin / ls [Secciones]

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

$ Rabin2 -SR / bin / ls secciones fs

S 0x00000238 0x00000238 0x0000001c 0x0000001c .interp 4 f section..interp 28 0x00000238 f

section_end..interp 0 0x00000254

CC [00] va = 0x00000238 pa = 0x00000238 sz = 28 vsz = 28 rwx = -r-- .interp @ 0x00000238 S 0x00000254 0x00000254 0x00000020

0x00000020 .note.ABI_tag 4 f section..note.ABI_tag 32 0x00000254 f section_end..note .ABI_tag 0 0x00000274

CC [01] va = 0x00000254 pa = 0x00000254 sz = 32 vsz = 32 rwx = -r-- .note.ABI_tag @ 0x00000254 S 0x00000274 0x00000274 0x00000024

0x00000024 .note.gnu.build_id 4 f section..note.gnu.build_id 36 0x00000274 f section_end..note.gnu.build_id 0 0x00000298

CC [02] va = 0x00000274 pa = 0x00000274 sz = 36 vsz = 36 rwx = -r-- .note.gnu.build_id @ 0x00000 274

S 0x00000298 0x00000298 0x00000068 0x00000068 .gnu.hash 4 f section..gnu.hash 104 0x00000298 f

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

0x00000c18 .dynsym 4 f section..dynsym 3096 0x00000300 f section_end..dynsym 0 0x00000f18

CC [04] va = 0x00000300 pa = 0x00000300 sz = 3,096 vsz = 3,096 rwx = -r-- .dynsym @ 0x00000300 S 0x00000f18 0x00000f18 0x00000593

0x00000593 .dynstr 4 f section..dynstr 1427 0x00000f18 f section_end..dynstr 0 0x000014ab

CC [05] va = 0x00000f18 pa = 0x00000f18 sz = 1,427 vsz = 1,427 rwx = -r-- .dynstr @ 0x00000f18 S 0x000014ac 0x000014ac 0x00000102

0x00000102 .gnu.version 4 f section..gnu.version 258 0x000014ac f section_end..gnu .version 0 0x000015ae (...)

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

por defecto lo bytes se cambian y sus compensaciones correspondientes:

$ Radiff2 genuina agrietado

0x000081e0 85c00f94c0 => 9090909090 0x000081e0 0x0007c805 85c00f84c0 =>

9090909090 0x0007c805

$ Rasm2 -d 85c00f94c0 eax prueba,

eax sete al

Observe cómo se nop'ed los dos saltos.

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

radare2 es capaz de calcular la distancia y el porcentaje de similitud entre dos archivos


s opción:
con el -

$ Radiff2 -s / bin / true / bin / false similitud: 0,97 Distancia:

743

Si desea que los datos más concretos, también es posible contar las diferencias,
do con el -

opción:

$ Radiff2 -c genuina agrietado 2

Si no está seguro de si se trata de binarios similares,docon


bandera
- puede comprobar hay funciones coincidentes. Es este modo, se

le dará tres columnas para todas las funciones: "En primer desplazamiento de archivo", "Porcentaje de coincidencia" y "Segundo

desplazamiento archivo".

161
binaria diffing

$ Radiff2 -C / bin / false / bin / true

Entry0 0x4013e8 | PARTIDO (0.904762) | Entry0 0x4013e2

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 |

UNMATCH (0.916667) | 0x45f0

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

especificar la arquitectura binarios para este análisis también usando

$ 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

llamadas de función (aac)

[] [*] 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

para referencias (AAR) [x] Analizar las llamadas de función (aac)

[] [*] 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))

sub.fileno_500 86 0x4500 | UNMATCH (0.965116) | 0x4510 8

6 sub.fileno_510

sub .__ freading_4c0 59 0x44c0 | UNMATCH (0.949153) | 0x44d0 5

9 sub .__ freading_4d0

sub.fileno_440 120 0x4440 | UNMATCH (0.200000) | 0x4450 12

0 sub.fileno_450

sub.setlocale_fa0 64 0x3fa0 | UNMATCH (0.104651) | 0x3fb0 6

4 sub.setlocale_fb0

fcn.00003a50 120 0x3a50 | UNMATCH (0.125000) | 0x3a60 12

0 fcn.00003a60

Y ahora una característica interesante: radare2 apoya gráfico-diffing, a la DarunGrim , con el -


gramo

opción. Usted puede darle un nombre de símbolo, de especificar dos desplazamientos, si la función que desea Diff es un

nombre diferente en archivos comparados. Por ejemplo, mostrará


radiff2 -g principal / bin / true / bin / false | xdot - las diferencias principal()
en

la función de Unix
ciertoy falso

programas. Se puede comparar a -g principal / bin / false / bin / true


radiff2 Observe
( el orden de los argumentos) para obtener las

dos versiones. Este es el resultado:

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 es un ensamblador / desensamblador. Inicialmente,


rasm herramienta fue diseñada para ser utilizado para parchear binarios. Es función

principal es conseguir bytes correspondientes al código de instrucción máquina determinada.

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

- un [arco] Arquitectura del conjunto de montar / desmontar (ver -L)

- b [bits de] Conjunto cpu tamaño registro (8, 16, 32, 64) (RASM2_BITS)

- c [cpu] Seleccione la CPU específica (depende de arco)

- do Salida en formato C

- d, -D Desmonte los bytes hexpair (D) muestran hexpairs

- mi Utilice big endian en lugar de Little Endian

- f [Archivo] Leer datos de archivo

- F [en: Fuera] Especificar entrada y / o filtros de salida (att2intel, x86.pseudo, ...)

- marido Mostrar esta ayuda

- i [len] ignorar / omitir N bytes de la memoria intermedia de entrada

- k [kernel] Seleccionar sistema operativo (Linux, Windows, Darwin, ..)

- l [len] Entrada / Salida de longitud

- L Lista apoyado plugins asm

- o [desplazamiento] Juego de dirección inicial para el código (por defecto 0)

- O [Archivo] Nombre del archivo de salida (rasm2 -bf a.asm -O a)

- s [sintaxis] Select sintaxis (Intel, att)

- segundo Binaria de entrada / salida (-l es obligatorio para la entrada binaria)

- v Mostrar información de versión

- w ¿Qué es esta instrucción para? describir código de operación

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

Plugins para arquitecturas de destino soportadas pueden ser listadosL opción.


con la - Conociendo un nombre del plugin, se

puede usar especificando su nombre aunla


opción
-

164
Rasm2

$ -L rasm2 _D 16

8051 PD 8051 CPU Intel

_D 16 32 arco GPL3 Argonaut RISC Core

ad brazo 16 32 64 GPL3 Acorn RISC CPU de la máquina

_D 16 32 64 arm.cs BSD desensamblador Capstone ARM

_D 16 32 desensamblador ARM arm.winedbg LGPL2 WineDBG

_D 16 32 avr GPL Atmel AVR

ad 32 bf LGPL3 Brainfuck

_D 16 CR16 Plugin de desmontaje LGPL3 CR16

_D 16 RSE PD Cambridge Silicon Radio (CSR)

ad 32 64 Dalvik LGPL3 AndroidVM Dalvik

ad 16 dcpu16 PD de Mojang DCPU-16

_D 32 64 EBC LGPL3 EFI Bytecode

_D 8 gb LGPL3 GameBoy (TM) (z80-like)

_D 16 h8300 LGPL3 H8 / 300 plugin de desmontaje

_D 8 i8080 BSD Intel 8080 CPU

ad 32 Java código de bytes de Java Apache

_D 32 m68k BSD Motorola 68000

_D 32 Malbolge LGPL3 Malbolge ternario VM

ad 32 64 MIPS GPL3 CPU MIPS

_D 16 32 64 mips.cs BSD desensamblador Capstone MIPS

_D 32 nios2 GPL3 NIOS II procesador integrado

_D 32 64 ppc GPL3 PowerPC

_D 32 64 ppc.cs BSD desensamblador Capstone PowerPC

anuncio rar LGPL3 RAR VM

_D 32 sh GPL3 SuperH-4 CPU

_D 32 64 SPARC GPL3 Escalable arquitectura del procesador

_D 32 TMS320 LGPLv3 familia TMS320 DSP

_D 32 ws Los espacios en blanco LGPL3 esotéricos VM

_D 16 32 64 X 86 BSD udis86 x86-16,32,64

_D 16 32 64 x86.cs BSD desensamblador Capstone X86

a_ 32 64 x86.nz LGPL3 x86 ensamblador hecho a mano

ad 32 x86.olly GPL2 desensamblador OllyDbg X86

8 anuncio z80 NC-GPL2 Zilog Z80

Tenga en cuenta que "ad" en la primera columna significa tanto ensamblador y desensamblador son ofrecidos por un plugin correspondiente.

" d" indica desensamblador, "a"


significa solamente ensamblador está disponible.

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.

$ Rasm2 -a -b x 86 32 'mov eax, 33' b821000000

$ Echo 'eax empuje; nop; nop' | rasm2 -f 5090

Rasm2 es utilizado por el núcleo radare2 escribir usandoWashington


bytes mando.

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

binario de una descripción rasm2.

166
Armar

$ Selfstop.rasm gato;

; Auto-Stop código shell escrito en rasm para x86;

; --pancake;

. arquitectura x86

. 0x8048000 base de equ

. org 0x8048000; el desplazamiento en el que se inyectan la JMP 5 bytes

selfstop:

empujar 0x8048000

Pusha

eax mov, 20 int

0x80

mov ebx, eax mov ecx,

19 eax mov, 37 int 0x80

popa ret;

; La inyección llamada;

retirado

[0x00000000]> e asm.bits = 32 [0x00000000]> wx `! Rasm2 -f

a.rasm` [0x00000000]> PD 20

0x00000000 6800800408 empuje 0x8048000; 0x08048000

0x00000005 60 PUSHAD

0x00000006 b814000000 eax mov, 0x14; 0x00000014

0x0000000B CD80 int 0x80

syscall [0x80] [0] =? 0x0000000d

89c3 mov ebx, eax

0x0000000F b913000000 mov ecx, 0x13; 0x00000013

0x00000014 b825000000 eax mov, 0x25; 0x00000025

0x00000019 CD80 int 0x80

syscall [0x80] [0] =? 0x0000001b

61 POPAD

0x0000001c c3 retirado

0x0000001d c3 retirado

167
Desmontar

desensamblador

pasando el re
- opción de rasm2 le permite desmontar una cadena hexpair:

$ Rasm2 -a -b x 86 32 -d '90' nop

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

positionindependent a inyectar en los procesos en ejecución o para parchear binarios en el disco.

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

redefinición a nivel de ensamblador.

AF_INET @ alias (2);

printf @ alias (0x8053940);

169
Ragg2

incluye

Utilizargato (1)o el preprocesador para concatenar varios archivos para ser compilado.

INCDIR @ alias ( "/ usr / include / ragg2");

sys-osx.r@include (INCDIR);

Hashbang

huevos pueden utilizar un Hashbang para que sean ejecutables.

$ Cabeza n1 hello.r

# ! / Usr / bin / ragg2 -X

$ ./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:

# ! / Usr / bin / ragg2 -X

principal();

. . .

@ mundial principal (128,64) {

. . .

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

etiqueta seguida de soportes root '{...}'

firmas de función

Tipo de nombre @ (stackframesize, staticframesize) {cuerpo}

nombre :nombre de la función de definir

tipo :ver los tipos de función debajo

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)

cuerpo :código de la función

tipos de funciones

alias Se utiliza para crear alias

datos; el cuerpo del bloque se define en .data

en línea ;el cuerpo de la función se colocarán en línea cuando se le llama

mundial;hacer que el símbolo mundial

fastcall;función que se llama usando la convención de llamada rápida

syscall; definir la firma convención de llamada syscall

llamadas al sistema

r_egg ofrece un azúcar sintaxis para definir llamadas al sistema. La sintaxis es la siguiente:

salida @ syscall (1);

@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

utilizando la sintaxis @alias.

biblioteca central

Hay un trabajo en progreso libc-como biblioteca escrito completamente en r_egg

171
Ragg2

Variables

. arg

. arg0

. arg1

. arg2

. var0

. var2

. fijar

. ret; eax para x86, r0 para el brazo

. pb

. ordenador personal

. sp

Atención: Todos los números después


var y. .arg significar el desplazamiento con la parte superior de la pila, no

símbolos variables.

Las matrices

Se admite como punteros primas. TODO: mejorar esta característica

Rastreo

A veces los programas r_egg se romperán o simplemente no funcionar como se espera. Utilizar la arquitectura 'traza' para

obtener un rastreo de llamada arco-backend:

$ Ragg2 -a -s traza yourprogram.r

punteros

TODO: Teóricamente '*' se utiliza para obtener contenidos de un puntero de memoria.

registros virtuales

TODO: A0, A1, A2, A3, SP, FP, BP, PC

operaciones matemáticas

Ragg2 apoya la asignación de variables locales operativo matemáticas, incluyendo

172
Ragg2

los siguientes operadores:

+ - */Y|^

Los valores de retorno

El valor de retorno se almacena en el registro a0, este registro se establece cuando se llama a una

función o al escribir un nombre de variable sin asignación.

$ Test.r gato

añada @ mundial (4) {

. var0 = .arg0 + .arg1;

. var0;

@ mundial principal () {

añadir (3,4);

$ Ragg2 -F -o test.r prueba

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

descanso; ->compila 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

Goto (addr) -ejecución rama

while (cond)

si (cond)

si (cond) {cuerpo} else {body}

descanso () -ejecuta una instrucción de trampa

comentarios

sintaxis soportada por los comentarios son:

/ * Comentario de varias líneas * /'

// comentario de una sola línea

# comentario de una sola línea

174
Análisis

Datos y análisis de código

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:

| Uso: un [abdefFghoprxstc] [...] | ab [hexpairs]

analizar los bytes

| abb [len] analizar N bloques básicos en [len] (section.size por defecto)

| Automóvil club británico[?] analizar todos (fcns + bbs) (AA0 para evitar sub cambio de nombre)

| ac [ciclos] analizar que op podría ser ejecutado en [ciclos]

| anuncio[?] analizar trampolín de datos (WIP)

| anuncio [de] [a] analizar punteros de datos a (desde-hasta) | ae [?] [expr]

analizar la expresión de opcode eval (ver ao)

| af [?] analizar Funciones

| aF Igual que el anterior, pero utilizando anal.depth = 1

| ag [opciones] salida de código Graphviz [?] | ah [?]

consejos de análisis (tamaño de la fuerza de código de operación, ...)

| ai [addr] información de la dirección (Mostrar permanentes, pila, montón, ...)

| ao [?] [len] analizar Opcodes (o emular)

| aO Analizar N instrucciones en M bytes

| Arkansas[?] como 'doctor', pero para el vm esil. (registros)

| ap encontrar preludio de desplazamiento actual

| hacha[?] gestionar árbitros / referencias externas (véase también AFX?)

| como [?] [num] analizar usando syscall dbg.reg

| a[?] [.] analizar trazas de ejecución

| av [?] [.] Mostrar vtables

Ejemplos:

f ts @ `S * ~ texto: 0 [3]`; f t @ section..text ds f @ `S * ~ datos: 0 [3]`; f d @

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

de comando de análisis radare2 más común es:

[0x08048440]> aa

[0x08048440]> pdf @ principal

; DATOS XREF de 0x08048457 (Entry0)

/ (FCN) fcn.08048648 141 |

;-- principal:

| 0x08048648 8d4c2404 lea ecx, [esp + 0x4]

| 0x0804864c 83e4f0 y ESP, 0xfffffff0

| 0x0804864f ff71fc empuje dword [ecx-0x4]

| 0x08048652 55 empuje ebp

| ; CODE (CALL) XREF de 0x08048734 (fcn.080486e5)

| 0x08048653 89e5 mov ebp, esp

| 0x08048655 83ec28 sub esp, 0x28

| 0x08048658 894df4 mov [ebp-0xc], ecx

| 0x0804865b 895df8 mov [ebp-0x8], ebx

| 0x0804865e 8975fc mov [ebp-0x4], esi

| 0x08048661 8b19 mov ebx, [ecx]

| 0x08048663 8b7104 mov esi, [ecx + 0x4]

| 0x08048666 c744240c000. mov dword [esp + 0xc], 0x0

| 0x0804866e c7442408010. mov dword [esp + 0x8], 0x1; 0x00000001

| 0x08048676 c7442404000. mov dword [esp + 0x4], 0x0

| 0x0804867e c7042400000. mov dword [esp], 0x0

| 0x08048685 sym..imp.ptrace llamada e852fdffff

| sym..imp.ptrace (unk, unk)

| 0x0804868a 85c0 eax prueba, eax

| , = <0x0804868c 7911 jns 0x804869f

| | 0x0804868e c70424cf870. mov dword [esp], str.Don_tuseadebuguer_; 0x080

487cf |

| 0x08048695 sym..imp.puts llamada e882fdffff

| | sym..imp.puts ()

| | 0x0804869a sym..imp.abort llamada e80dfdffff

| | sym..imp.abort ()

| `-> 0x0804869f 83fb02 cmp EBX, 0x2

| , == <0x080486a2 7411 0x80486b5 je

| | 0x080486a4 c704240c880. mov dword [esp], str.Youmustgiveapasswordforuset

hisprogram_; 0x0804880c |

| 0x080486ab sym..imp.puts llamada e86cfdffff

| | sym..imp.puts ()

| | 0x080486b0 sym..imp.abort llamada e8f7fcffff

| | sym..imp.abort ()

| `-> 0x080486b5 8b4604 mov eax, [ESI + 0x4]

| 0x080486b8 890424 mov [esp], eax

| 0x080486bb fcn.080485a5 llamada e8e5feffff

176
Análisis de código

| fcn.080485a5 (); fcn.080484c6 + 223

| 0x080486c0 b800000000 mov eax, 0x0

| 0x080486c5 8b4df4 mov ecx, [ebp-0xc]

| 0x080486c8 8b5df8 mov ebx, [ebp-0x8]

| 0x080486cb 8b75fc mov esi, [ebp-0x4]

| 0x080486ce 89ec mov esp, ebp

| 0x080486d0 5d ebp pop

| 0x080486d1 8d61fc lea esp, [ecx-0x4]

\ 0x080486d4 c3 retirado

En este ejemplo, se analiza todo el archivo


aa) y( luego imprimir el desmontaje de la
principal()

función (pdf).

177
Rahash2

La obtención de valores hash dentro Radare2 Sesión

Para calcular una suma de comprobación del bloque actual cuando se ejecuta radare2, utilice el comando 'PH'. Pasar un nombre de

algoritmo a ella como un parámetro. Una sesión de ejemplo:

$ Radare2 / bin / ls [0x08049790]> bf

Entry0 [0x08049790]> MD5 ph

d2994c75adaa58392f953a448de5fba7

Puede utilizar todos los algoritmos hash soportados por


rahash2:

[0x00404890]> ph? md5 sha1

sha256 sha384 sha512 CRC16

crc32 md4 xor xorpair paridad

entropía hamdist PCPRINT

mod255 xxhash Adler32 luhn

los ph comando acepta un parámetro opcional para especificar la longitud del intervalo de bytes esté encriptado, en lugar de tamaño de

bloque predeterminado. Por ejemplo:

[0x08049A80]> ph md5 32

9b9012b00ef7a94b5824105b7aaad83b [0x08049A80]> ph

md5 64 a71b087d8166c99869c9781e2edcf183

[0x08049A80]> ph md5 1024

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

- un algo coma lista de algoritmos (por defecto es 'sha256') separados

- b bsize especificar el tamaño del bloque (en lugar del archivo completo)

- segundo Mostrar por bloque de hash

- mi endian swap (utilizar poco endian)

- f desde iniciar hash en la dirección dada

- i num repetición de hash de N iteraciones

- S semilla utilizar semillas dado (hexa o s: string) usar ^ para prefijar

- k mostrar utilizando el algoritmo de hash randomkey del openssh

- q ejecutar en modo silencioso (sólo muestran los resultados)

- L enumerar todos los algoritmos disponibles (ver -a)

- r radare comandos de salida

- s cadena de reconsiderar esto cadena en lugar de archivos

- ta dejar de hash en la dirección dada

- v información de concierto versión

Para obtener un valor hash MD5 de una cadena de texto, utilice


s opción:
el -

$ Rahash2 -q -a MD5 -s 'hola mundo'

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

$ Rahash2 -a todos / bin / ls

/ / Bin ls: 0x00000000-0x0001ae08 md5: b5607b4dc7d896c0fab5c4a308239161 / bin / ls: 0x00000000-0x0001ae08 sha1:

c8f5032c2dce807c9182597082b94f01a3bec495 / bin / ls: 0x00000000-0x0001ae08 sha256: 978317d58e3ed046305df92a19f7d3e0bfcb3c70cad979f

24fee289ed1d266b0

/ / bin ls: 0x00000000-0x0001ae08 SHA384: 9e946efdbebb4e0ca00c86129ce2a71ee734ac30b620336

c381aa929dd222709e4cf7a800b25fbc7d06fe3b184933845

/ / bin ls: 0x00000000-0x0001ae08 sha512: 076806cedb5281fd15c21e493e12655c55c52537fc1f36e

641b57648f7512282c03264cf5402b1b15cf03a20c9a60edfd2b4f76d4905fcec777c297d3134f41f / bin / ls: 0x00000000-0x0001ae08 CRC16: 4b83 / bin / ls:

0x00000000-0x0001ae08 CRC32: 6e316348

/ / Bin ls: 0x00000000-0x0001ae08 md4: 3a75f925a6a197d26bc650213f12b074 / bin / ls: 0x00000000-0x0001ae08 xor: 3e /

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 /

ls: 0x00000000-0x0001ae08 Adler32: fca7131b

181
depurador

depurador

Depuradores se implementan como plugins IO. Por lo tanto, radare puede manejar diferentes tipos de URI para el desove,

adjuntando y los procesos de control. La lista completa de plugins IO se puede ver


R2 -L. Los
con
que tienen "d" en la primera

columna ( "RWD") depuración apoyo. Por ejemplo:

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

. . .

! [0x7fc15afa3cc0]> = help Uso: = args cmd!

= Ptrace -! Uso ptrace io = mem

- utilizar / proc / PID / mem io si es posible

=! Pid - pid espectáculo dirigido

= Pid <#> - seleccione nuevo pid

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

Uso: D # comandos de depuración db [?]

comandos puntos de ruptura

DBT [?] Pantalla trazado inverso basado en dbg.btdepth y dbg.btalgo

corriente continua[?] continuar la ejecución

dd [?] Los descriptores de archivo (! fd en R1)

de [-SC] [rwx] [RM] [e] de depuración con ESIL (véase de?) dg <archivo>

Generar un archivo de núcleo (WIP)

dH [controlador] proceso del trasplante a un nuevo controlador

di [?] información de concierto depurador backend (Ver dh)

dk [?] Lista, enviar, recibir, conjunto, los gestores de señales de niño

dl [controlador] Lista o grupo controlador depurador

dm [?] Mostrar mapas de memoria

hacer[?] proceso abierto (recarga, alias 'oo')

doo [args] Vuelva a abrir en modo de depurador con args (alias de 'ood')

dp [?] Lista, asociar al proceso o hilo ID

Dr[?] registros de la CPU

ds [?] Paso, sobre, línea de fuente

dt [?] rastros de instrucciones de la pantalla (DTR = reset)

dw <pid> símbolo del bloque hasta que muere pid

dx [?] Inyectar y ejecutar código en proceso de destino (Ver gs)

Para reiniciar la sesión de depuración, puede escribir


oo o oo +,dependiendo del comportamiento deseado.

oo vuelva a abrir el archivo actual (matar + tenedor en depurador)

oo + vuelva a abrir el archivo actual en lectura-escritura

183
Empezando

Empezando

Pequeña sesión de depurador radare2

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

db: lista de punto de interrupción mostrar

DC: ejecuta el programa

Dr : Mostrar estado de registros

RRD: Mostrar registros de referencias (telescópicos) (como peda)

DS: Entra en la instrucción

DSO: Pasar por encima de la instrucción

DBT: pantalla traza inversa

dm: Mostrar mapas de memoria

Enviar
dk <señal>: señal KILL a hijo

ood: vuelva a abrir en modo de depuración

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

La migración de ida, el BGF o WinDBG Cómo ejecutar

el programa con el depurador

r2 -d / bin / ls iniciar
- en modo depurador => [ vídeo ]

¿Cómo adjunto / desconexión al proceso que se ejecuta? (Gdb -p)

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

Cómo establecer la variable args / Environnement / cargar un librerías


específicas para la sesión de depuración de radare

Utilizarrarun2 (Libpath = $ PWD: / tmp / lib, arg2 = hola, setenv = FOO =ver
BARrarun2
...) -h / hombre rarun2

Cómo guión radare2?

r2 -i <archivo de guión> ejecutar


... - un script después cargar el archivo => [ vídeo ]

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

una oneliner o un archivo .c debe ser pasado como argumento. Llegar


pitón y mucho
#! más, sólo la construcción radare2

encuadernaciones

185
La migración de ida, el BGF o WinDBG

Cómo mostrar el código fuente como en la lista de GDB?

CL TODO, véase # 1783

atajos

Mando IDA Pro radare2 r2 (modo visual) BGF

Análisis

puesto en marcha aaa o -A (AAAA o -AA para


Análisis de automáticamente cuando se el análisis incluso
N/A N/A
abre un archivo binario experimental)
todo

Navegación

referencia externa a x axt x N/A

referencia externa de ctrl + j axf x N/A

xref para representar gráficamente ? AGT [desplazamiento] ? N/A

xref de gráfico ? AGF [desplazamiento] ? N/A

funciones de lista alt + 1 AFL; es t N/A

listado alt + 2 pdf pag N/A

modo hexadecimal alt + 3 pxa PAG N/A

importaciones alt + 6 ii : ii N/A

exportaciones alt + 7 es ~ FUNC ? N/A

siga JMP / llamada entrar s compensado entraro 0 - 9 N/A

deshacer buscar Esc s- u N/A

rehacer buscar Ctrl + Enter s+ T N/A

Mostrar conexiones espacio AGV V N/A

Editar

rebautizar norte AFN Dr N/A

vista de gráfico espacio AGV V N/A

definir como datos re Cd [tamaño] dd, db, dw, dW N/A

definir como código do C- [tamaño] re- o du N/A

definir como indefinido u C- [tamaño] re- o du N/A

definir como cadena UN Cs [tamaño] ds N/A

186
La migración de ida, el BGF o WinDBG

definir como struct Alt + Q Cf [tamaño] dF N/A

depurador

Iniciar Proceso / Continuar


F9 corriente continua F9 r y
la ejecución

terminar un proceso de Ctrl + F2 dk 9 ? matar

Despegar ? o- ? despegar

entrar en F7 ds s norte

paso en 4
? ds 4 F7 n4
instrucciones

pasar por encima F8 DSO S s

paso hasta una dirección


? ESD <dir> ? s
específica

Correr hasta el regreso Ctrl + F7 DCR ? terminar

Correr hasta que el cursor F4 # 249 # 249 N/A

Mostrar Backtrace ? DBT ? bt

En Windows Se muestra en el modo registros info


Registro de visualización dr todo
Registro Visual

información
En Windows Se muestra en el modo
eax pantalla dr? eax registra eax
Registro Visual

mostrar el estado antiguo de


? dro ? ?
todos los registros

$$ afi -

información de la función
función de visualización
? de visualización de la ? ?
addr + N
corriente compensada ($$ )

estado marco de la pantalla ? RBP-RSP RSP PXW @ ? Si

Como paso hasta que la


? DSi ? ?
condición es verdadera

Actualizar un valor de conjunto $ rip =


? dr rasgar = 0x456 ? 0x456
registro

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)

Cargar archivo de símbolos

asm.dwarf.file, pdb.XX) add-símbolo-archivo


Secciones / regiones menú AP N/A

backtrace

Seguimiento de la pila N/A DBT N/A bt

Seguimiento de la pila en Json N / A dbtj N/A

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

Los puntos de interrupción

información puntos de
lista de punto de interrupción Ctrl + Alt + B db ? interrupción

añadir punto de interrupción F2 db [desplazamiento] F2 descanso

Trapos

Cambiar al hilo menú hilo dp N/A hilo <N>

marcos

cualquier
números de bastidor N/A ? N/A
comando bt

Seleccione el fotograma N/A ? N/A marco

Parámetros / locales

parámetros de visualización N/A AFV N/A Otros detalles args

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

proyecto abierto Po [Archivo] ?

Guardar proyecto automático Ps [Archivo] ?

informaciones
Pi [Archivo] ?
espectáculo de proyectos

Diverso

Volcado matriz de bytes ¿ordenador personal? json,


(
N/A Vpppp x / bc
Char C, char, etc.)

opciones menú de opciones ¿mi? mi

Seleccione la zona
buscar menú de búsqueda /? con el cursor
do entonces /

Equivalente del comando "set-seguimiento-modo de tenedor" GDB

Esto se puede hacer usando 2 comandos:

1. DCF - hasta que un tenedor suceder

2. usar entonces
dp para seleccionar cuál es el proceso que desea depurar.

Características comunes

R2 acepta firmas LIGÓN (antes de la AIF versión 6.8) r2 puede conectar el

BGF y WinDBG R2 pueden escribir / parche en su lugar

R2 tienen fortuna y [s] huevos de Pascua [/ s] bolas de acero.

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

DR0-DR7 registros de hardware para establecer puntos de interrupción de hardware.

Hay diferentes comandos para obtener los valores de los registros. Para el uso general los utilizan:

[0x4A13B8C0]> dr r15 =

0x00000000 r14 = 0x00000000 r13

= 0x00000000 r12 = 0x00000000

RBP = 0x00000000 rbx =

0x00000000 r11 = 0x00000000 r10

= 0x00000000 r9 = 0x00000000 r8 =

0x00000000 rax = 0x00000000 rcx =

0x00000000 RDX = 0x00000000

RSI = 0x00000000 RDI =

0x00000000 Éax = 0x0000003b =

rasgar 0x7f20bf5df630 RSP =

0x7fff515923c0

? [0x7f0f2dbae630]> dr rasgar; obtener el valor de 0x7f0f2dbae630 'RIP'

[0x4A13B8C0]> dr rip = ESP; set 'RIP' como esp

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

[0x7f0f2dbae630]> dr * ; Al añadir? '*' Mostrará los comandos radare

f r15 r14 f 1 0x0 1 0x0 f

r13 1 0x0 f r12 1 0x0 f

RBP 1 0x0 f rbx 1 0x0 f

r11 1 0x0 f r10 1 0x0 f

r9 1 0x0 f r8 1 0x0 f rax

1 0x0 f rcx 1 0x0 f RDX

1 0x0 f RSI 1 0x0 f RDI

1 0x0 f Éax 1 0x3B

f rasgar 1 0x7fff73557940 rflags f 1

0x200 f RSP 1 0x7fff73557940

[0x4A13B8C0]> .dr *; incluir valores de los registros comunes en las banderas

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

[0x7f1fab84c630]> dro r15 =

0x00000000 r14 = 0x00000000 r13 =

0x00000000 r12 = 0x00000000 RBP =

0x00000000 rbx = 0x00000000 r11 =

0x00000000 r10 = 0x00000000 r9 =

0x00000000 r8 = 0x00000000 rax =

0x00000000 rcx = 0x00000000 RDX =

0x00000000 RSI = 0x00000000 RDI =

0x00000000 Éax = 0x0000003b =

rasgar 0x7f1fab84c630 rflags =

0x00000200 RSP = 0x7fff386b5080

[0x7f1fab84c630]> dr r15 = 0x00000000 r14 =

0x00000000 r13 = 0x00000000 r12 =

0x00000000 RBP = 0x00000000 rbx =

0x00000000 r11 = 0x00000000 r10 =

0x00000000 r9 = 0x00000000 r8 =

0x00000000 rax = 0x00000000 rcx =

0x00000000 RDX = 0x00000000 RSI =

0x00000000 RDI = 0x7fff386b5080 Éax =

0xffffffffffffffff rasgar = 0x7f1fab84c633 rflags =

0x00000202 RSP = 0x7fff386b5080

Los valores almacenados en eax, Éax y EIP han cambiado.

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:

[0x4A13B8C0]> dr *> regs.saved; guardar los registros [0x4A13B8C0]> DRP

regs.saved; restaurar

192
registros

EFLAGS pueden ser alterados de manera similar. Por ejemplo, el establecimiento de indicadores seleccionados:

[0x4A13B8C0]> eflags dr = pst [0x4A13B8C0]> dr eflags

= 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

0x00000000 delta -396,752,448

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:

[0x004028a0]> 2dso [0x004028a0]>

0x004028ae dr estafa

[0x004028a0]> bss

continuará hasta 0x004028a2 golpe punto de

ruptura en: 4028a2 [0x004028a0]>

0x004028a2 dr estafa

Cuando se ejecuta
bss, depurador inversa restaurar el estado anterior registrado y ejecutar el programa de él hasta el punto

deseado. O también puede intentar seguir hacia atrás:

[0x004028a0]> db 0x004028a2 [0x004028a0]>

10dso [0x004028a0]> dr 0x004028b9 estafa

[0x004028a0]> DCB [0x004028a0]>

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

ella en cualquier momento.

Se puede ver los estados actuales de programas grabados utilizando


DTS:

[0x004028a0]> dts

sesión: 0 a: 0x004028a0 "" sesión: 1 en: 0x004028c2 ""

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:

[0x004028c2]> start DTSC programa 0 [0x004028c2]> DTSC 1

descifrado se inicia [0x004028c2]> dts

sesión: 0 a: 0x004028a0 "iniciar programa" sesión: 1 en: 0x004028c2 "inicio de

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 /

importación a / desde un archivo:

[0x004028c2]> dtst records_for_test

Sesión guarda en records_for_test.session y volcado en records_for_test.dump [0x004028c2]> DTSF sesión records_for_test: 0, diffs

0x4028a0: 0: 1 sesión, 0x4028c2 diffs: 0

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

Y un paso atrás por


AESB:

[0x00404870]> aer rasgar

0x00404870

[0x00404870]> 5aeso [0x00404870]>

aer rasgar 0x0040487d

[0x00404870]> AESB [0x00404870]>

aer rasgar 0x00404879

195
Las capacidades de comunicación remota

Capacidades de acceso remoto

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

las operaciones básicas IO por lo que trabajar en una red.

Ayuda para los comandos útiles para el acceso remoto a radare:

[0x00405a04]> =?

| Uso: = [: + - = hh] [...] # radare protocolo de ejecución remota de comandos |

comandos de rap: | =

una lista de todas las conexiones abiertas

| = <[Fd] cmd enviar la salida de mando a distancia local para fd

| = [Fd] cmd cmd en Exec remoto 'fd' (la última es abierta por defecto)

| =! cmd ejecutar comandos a través de r_io_system

| = + [Proto: //] Agregar host del host (por defecto = rap: //, tcp: //, UDP: //) | = - [fd]

eliminar todos los hosts o de acogida 'fd'

| == [fd] sesión remota abierta con el anfitrión 'fd', 'q' para salir

| =! = desactivar el modo cmd remoto

| ! =! activar el modo remoto cmd

servidor de rap: | =:

Puerto escuchar en el puerto determinado mediante el protocolo de rap (o rap: // 9999)

| = &: Puerto iniciar el servidor de rap en el fondo

| =: Cmd puerto: host orden de marcha 'cmd' en el servidor remoto

servidor http: | = H

puerto escuchar las conexiones HTTP (r2 -QC = H / bin / ls)

| = h- dejar de servidor web de fondo

|=H* servidor web actual reinicio

| = H & puerto iniciar el servidor http en el fondo)

| = Puerto H iniciar el navegador y escuche http

| = H & puerto iniciar el navegador y escuche http en el fondo

gdbserver:

| = Archivo de puerto g escuchar en 'archivo' 'puerto' depuración utilizando 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

$ Radare2 rap: //: 1234

Al host2 remoto:

$ Radare2 rap: //: 1234

En localhost:

radare2 $ -

; Añadir anfitriones

[0x004048c5]> = + rap: // <host1>: 1234 // bin / ls Conectado a: <host1> 1234

en el puerto esperando ... ok

[0x004048c5]> =

0 - rap: // <host1>: 1234 // bin / ls

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

puerto esperando ... ok

0 - rap: // <host1>: 1234 // bin / ls 1 - rap: // <Host2>: 1234 / dbg:

/// bin / ls

Para ejecutar comandos en host1:

[0x004048c5]> = 0 px [0x004048c5]> = s

0x666

Para abrir una sesión con host2:

[0x004048c5]> == 1 fd: 6> pi 1

. . .

FD: 6> q

Para eliminar anfitriones (y conexiones cercanas):

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:

[0x004048c5]> = + tcp: // <host>: <puerto> / Conectado a: <host>

en el puerto <puerto> 5 - tcp: // <host>: <puerto> / [0x004048c5]> =

<5 cmd ...

Los = <'comando enviar el resultado de la ejecución


cmd`
de para el número de conexión remoto N (o el último usado si ningún id

especificado).

198
GDB remoto

Depuración con gdbserver

radare2 permite la depuración remota a través del protocolo remoto BGF. Para que pueda ejecutar un gdbserver y conectarse a él con

radare2 para la depuración remota. La sintaxis para la conexión es:

$ -D r2 GDB GDB: // <host>: <puerto>

O si el gdbserver se está ejecutando en modo extendido, se puede asociar a un proceso en el host con:

$ -D r2 GDB GDB: // <host>: <puerto> / <pid>

Después de conectar, depuración funciona con normalidad.

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:

$ R2 = -e dbg.exe.path <ruta> -D GDB GDB: // <host>: <puerto>

Si los símbolos se cargan en una dirección base incorrecta, puede intentar especificar la dirección base con demasiado
e bin.baddr:

$ R2 = -e bin.baddr <baddr> -e dbg.exe.path = <ruta> -D GDB GDB: // <host>: <puerto>

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, =! .

$ Exportación R2_GDB_PKTSZ = 512 $ -D r2 GDB

GDB: // <host>: <puerto> = adjuntar <pid> <tid>

Suponiendo FilePath <ruta / a / exe> [0x7ff659d9fcc0]>

= paquetes pktsz tamaño: 512 bytes [0x7ff659d9fcc0]> =

pktsz 64 [0x7ff659d9fcc0]> = tamaño de paquete pktsz:!

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

[0x7ff659d9fcc0]> = !? Uso:!! = Args

cmd = pid

- pid espectáculo dirigido

=! S PKT - enviar el paquete 's'

=! Cmd del monitor - comando monitor y pasar para apuntar intérprete hex-encode

=! Desprenderse [pid] - desprenderse de distancia / separar específica pid

=! Inv.reg - invalidar caché reg

=! Pktsz - obtener el tamaño máximo del paquete utilizado

=! Bytes pktsz - establecer máx. tamaño de paquete como bytes 'bytes'

! = Exec_file [pid] - obtener el archivo que fue ejecutado por pid actual / especificado

radare2 también proporciona su propia implementación gdbserver:

$ 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

de protocolo de depuración (como gdbserver --re mote-debug)

Lo que puede empezar como:

$ R2 -

[0x00000000]> = g 8000 / bin / radare2 -

Y luego conectarse a él como lo haría con cualquier gdbserver. Por ejemplo, con radare2:

$ -D r2 GDB GDB: // localhost: 8000

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

como si se tratara de un archivo.

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

$ R2 dbg: /// bin / ls $ r2 pid: // 1927 Las

sesiones remotas

$ R2 rap: //: 1234 $ r2 rap: //: 1234 // bin / ls modos

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_

Abrir archivos zip apk: //foo.apk//MANIFEST o postal: //foo.apk//theclass/fun

. clase, muestran los archivos con: Código postal: //foo.apk/, abrir todos los archivos con zipall: // (BSD) RWD windbg

Adjuntar a un depurador KD (LGPL3)

rw_ escasa asignación de memoria intermedia escasa (escasa: // 1.024 escasa: //) (LGPL3)

rw_ SHM recursos de memoria compartida (SHM: // llave) (LGPL3)

auto rw_ leer la memoria de mi mismo usando 'auto: //' (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)

rw_ procpid / Proc / pid / mem io (LGPL3)

mmap rw_ archivo abierto mediante mmap: // (LGPL3)

malloc rw_ asignación de memoria (malloc: // 1024 hexadecimal: // cd8090) (LGPL3)

mach r__ io mach de depuración (no soportado en esta plataforma) (LGPL)

ihex rw_ archivo de Intel HEX (ihex: //eeproms.hex) (LGPL)

http rw_ HTTP GET (http://radare.org/) (LGPL3)

gzip rw_ leer / escribir ficheros comprimidos (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)

rw_ bfdbg BrainFuck depurador (bfdbg: // ruta / a / archivo) (LGPL3)

La implementación de una nueva arquitectura

radare2 divide la lógica de una CPU en varios módulos. Usted debe escribir más de un plugin para obtener soporte

completo para un arco específico. Veamos cuales son los:

r_asm: ensamblador y desensamblador r_anal: análisis de

código (código de operación, el tipo, esil, ..) r_reg: registros

r_syscall: sistema llama r_debug: depurador

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

de nuevo para actualizarLiBr


la / config.mky LiBr / config.h.

Usted puede encontrar algunos ejemplos de complementos externos en radare2-extras repositorio.

Escribir el plugin r_asm

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}')

CFLAGS = -g -fPIC $ (Shell pkg-config --cflags r_asm)

LDFLAGS = -shared $ (Shell pkg-config --libs r_asm)

OBJS = $ (NOMBRE) .o SO_EXT = $ (Shell uname | grep -q Darwin && echo dylib || eco de modo)

LIB = $ (NOMBRE) . $ (SO_EXT)

todas: $ (LIB)

limpiar:

rm -f $ (LIB) $ (OBJS)

$ (LIB): $ (OBJS)

$ (CC) $ (CFLAGS) $ (LDFLAGS) $ (OBJS) -o $ (LIB)

instalar:

cp -f $ (NAME). $ (SO_EXT) $ (R2_PLUGIN_PATH)

desinstalar:

rm -f $ (R2_PLUGIN_PATH) / $ (NAME). $ (SO_EXT)

$ Mycpu.c gato

/ * Ejemplo r_asm plugin pancake en 2014 * /

# incluir <r_asm.h>

# incluir <r_lib.h>

# definir OPS 17

estático const char * ops [OPS * 2 ] = {

"Nop" , NULO ,

"Si" , "R" ,

"si no" , "R" ,

"añadir" , "Rr" ,

"adi" , "Rhode Island" ,

"sub" , "Rhode Island" ,

"Neg" , "Rhode Island" ,

"XOR" , "Rhode Island" ,

"Mov" , "Rhode Island" ,

"CMP" , "Rr" ,

"carga" , "Rhode Island" ,

"almacenar" , "Rhode Island" ,

"SHL" , "Rhode Island" ,

"Br" , "R" ,

203
plugins

"licenciado en Derecho" , "R" ,

"retirado" , NULO ,

"sys" , "yo"

};

/ * Función principal para el desmontaje * / // B para byte, l para

la longitud

static int desmontar (Rasm * a, RAsmOp * op, const ut8 * b, int l) {

carbonizarse arg [ 32 ];

int idx = (b [ 0 ] y 0xf ) \ * 2 ; OP> size = 2 ;

Si (idx> = (OPS * 2 )) {

strcpy (OP> buf_asm, "inválido" );

regreso -1 ; }

strcpy (Op-> buf_asm, ops [idx]);

Si (Ops [idx + 1 ]) {

const char \ * P = ops [idx + 1 ]; arg [ 0 ] = 0 ;

Si (! strcmp (pag, "Rr" )) {

sprintf (Arg, "% D r, r% d" , B [ 1 ] >> 4 , B [ 1 ] y 0xf );

} else if (! strcmp (pag, "yo" )) {

sprintf (Arg, "%re" , ( carbonizarse )segundo[ 1 ]); } else if (! strcmp

(pag, "R" )) {

sprintf (Arg, "% D r, r% d" , B [ 1 ] >> 4 , B [ 1 ] y 0xf );

} else if (! strcmp (pag, "Rhode Island" )) {

sprintf (Arg, "R% d,% d" , B [ 1 ] >> 4 , ( carbonizarse )segundo[ 1 ] y 0xf );

Si (* Arg) {

strcat (OP> buf_asm, "" );

strcat (Op-> buf_asm, arg); }}

regreso OP> Tamaño; }

/ * Estructura de las funciones exportadas y los datos * /

RAsmPlugin r_asm_plugin_mycpu = {

. name = "Mycpu" ,

. arco = "Mycpu" ,

. licencia = "LGPL3" ,

. bits = 32 ,

. desc = "Mi CPU desensamblador" ,

. desmontar = & desmontar,

};

# ifndef CORELIB

struct r_lib_struct_t radare_plugin = {

. type = R_LIB_TYPE_ASM,

. datos = & r_asm_plugin_mycpu

204
plugins

};

#terminara si

Para construir e instalar este plugin sólo tiene que escribir esto:

$ make

$ Sudo make install

Probando el plugin

Este plugin es utilizado por rasm2 y r2. Puede verificar que el complemento se carga correctamente con este comando:

$ Rasm2 -L | grep mycpu _D mycpu

Mi CPU desensamblador (LGPL3)

Vamos a abrir un archivo vacío usando el arco 'mycpu' y escribir un código aleatorio allí.

$ R2 -

- - Canje I endians

[0x00000000]> e asm.arch = mycpu [0x00000000]>

WOR [0x00000000]> PD 10

0x00000000 888E mov r8, 14

0x00000002 b2a5 ifnot R10, R5

0x00000004 3f67 retirado

0x00000006 7ef6 bl R15, R6

0x00000008 2701 xor r0, 1

0x0000000a 9826 mov r2, 6

0x0000000c 478d xor r8, 13

0x0000000E 6b6b tienda de R6, 11

0x00000010 1382 añadir r8, r2

0x00000012 7f15 retirado

¡Hurra! funciona .. y la oneliner obligatoria también!

r2 -nqamycpu -cwoR -cpd' 10' -

Escribir el plugin r_anal

Entonces es el momento para plug-in de análisis

205
plugins

plugins estáticas en núcleo

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

que el resto de los plugins se construyen. Lista de archivos afectados:

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

mediante la lectura de esas confirmaciones: Implementar complemento rasm:

https://github.com/radare/radare2/commit/933dc0ef6ddfe44c88bbb261165bf8f8b531476b

Implementar RANAL plugin:

https://github.com/radare/radare2/commit/ad430f0d52fbe933e0830c49ee607e9b0e4ac8f2

Escribir un plugin desensamblador con otro lenguaje de


programación

Pitón

En un primer momento, para poder escribir plugins en Python para radare2 es necesario instalar el plugin r2lang. Si vas a

usar Python 2, a continuación, utilizar de lo contrario (y recomendado) - instalar la versión de Python


r2pm -i lang-python2, r2pm 3:

Nota
-i-lang python3. - En los siguientes ejemplos hay funciones que faltan de la decodificación real para facilitar la lectura! Para

ello, tiene que hacer lo siguiente:

1. r2lang importación
y de r2lang importación Rpara
( las constantes)

2. Hacer una función con 2 subfunciones - y desmontary el plugin de regresar


armar

estructura - plug-in para rasm

206
plugins

def mycpu (un) :

def armar (S) :

regreso [ 1 , 2 , 3 , 4 ]

def desmontar (BUF) :

tratar :

opcode = get_opcode (BUF) opstr = optbl

[opcode] [ 1 ]

regreso [ 4 , Opstr]

excepto :

regreso [ 4 , "desconocido" ]

3. Esta estructura debe contener una punteros a estas 2 funciones


armary -

desmontar

regreso {

"nombre" : "Mycpu" ,

"arco" : "Mycpu" ,

"bits" : 32 ,

"Endian" : "pequeño" ,

"licencia" : "GPL" ,

"Desc" : "Disasm MYCPU" ,

"armar" : Montar,

"desmontar" : Desmonte,}

1. Hacer una función con 2 subfunciones - y op y el plugin de regresar


set_reg_profile

estructura - para RANAL plug-in

207
plugins

def mycpu_anal (un) :

def set_reg_profile () :

perfil = "= PC pc \ n" + \

"= 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 R4 . 32 dieciséis 0 \ n" + \

"GPR R5 . 32 20 0 \ n" + \

"GPR sp . 32 24 0 \ n" + \

"GPR . 32
ordenador personal 28 0 \ n"

regreso perfil

def op (Addr, buf) :

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 = get_opcode (BUF) esilstr = optbl

[opcode] [ 2 ]

Si optbl [opcode] [ 0 ] == "J" : # Es salto

analop [ "tipo" ] = R.R_ANAL_OP_TYPE_JMP analop [ "saltar" ] = Decode_jump

(opcode, j_mask) esilstr = jump_esil (esilstr, opcode, j_mask)

excepto :

resultado = analop

# No se olvide de volver tamaño de la instrucción apropiada!

regreso [ 4 , Resultado]

1. Esta estructura debe contener una punteros a estas 2 funciones - y op


set_reg_profile

208
plugins

regreso {

"nombre" : "Mycpu" ,

"arco" : "Mycpu" ,

"bits" : 32 ,

"licencia" : "GPL" ,

"Desc" : "Anal MYCPU" ,

"Esil" : 1 ,

"Set_reg_profile" : Set_reg_profile,

"Op" : Op,}

1. A continuación, registre los que utilizan y r2lang.plugin ( "anal")


r2lang.plugin ( "asm")

respectivamente

impresión( "Registro de plug-in MYCPU disasm ..." ) De impresión (r2lang.plugin ( "Asm"

, Mycpu)) impresión ( "Registro de análisis complemento MYCPU ..." ) De impresión

(r2lang.plugin ( "anal" , Mycpu_anal))

Se pueden combinar todo en un archivo y cargarlo usando


yo opción:
-

r2 -i mycpu.py some_file.bin

O se puede cargar desde el shell R2:mycpu.py


#! pitón

Ver también:

Javascript

Python

Más ejemplos para venir ...

Escribir un plugin depurador

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

Agregue el código para aplicar los perfiles en la función


r_debug_gdb_attach (RDebug * dbg, int pid)

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

Más por venir..

Artículo relacionado: http://radare.today/posts/extending-r2-with-new-plugins/

Algunos compromete relacionados con "La implementación de una nueva arquitectura"

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

CR16: https://github.com/radare/radare2/pull/721/ &&

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

La implementación de una nueva arquitectura de pseudo

Ejemplo:

Z80:

https://github.com/radare/radare2/commit/8ff6a92f65331cf8ad74cd0f44a60c258b137a0 6

La implementación de un nuevo plugin análisis

210
plugins

NAME = anal_snes R2_PLUGIN_PATH = $ (R2 hh cáscara | LIBR_PLUGINS grep | awk '{print $$ 2}')

CFLAGS = -g -fPIC $ (Shell pkg-config --cflags r_anal)

LDFLAGS = -shared $ (Shell pkg-config --libs r_anal)

OBJS = $ (NOMBRE) .o SO_EXT = $ (Shell uname | grep -q Darwin && echo dylib || eco de modo)

LIB = $ (NOMBRE) . $ (SO_EXT)

todas: $ (LIB)

limpiar:

rm -f $ (LIB) $ (OBJS)

$ (LIB): $ (OBJS)

$ (CC) $ (CFLAGS) $ (LDFLAGS) $ (OBJS) -o $ (LIB)

instalar:

cp -f anal_snes. $ (SO_EXT) $ (R2_PLUGIN_PATH)

desinstalar:

rm -f $ (R2_PLUGIN_PATH) / anal_snes. $ (SO_EXT)

anal_snes.c:

211
plugins

/ * Radare - LGPL - Copyright 2015 - condret * /

# 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) {

memset (Op, '\ 0' , tamaño de (RAnalOp)); op-> size = snes_op

[datos [ 0 .]] Len; op-> addr = addr;

op-> type = R_ANAL_OP_TYPE_UNK;

cambiar (datos[ 0 ]) {

caso 0xEA :

op-> type = R_ANAL_OP_TYPE_NOP;

descanso ; }

regreso OP> Tamaño; }

struct r_anal_plugin_t r_anal_plugin_snes = {

. name = "SNES" ,

. desc = "Plugin análisis 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

struct r_lib_struct_t radare_plugin = {

. type = R_LIB_TYPE_ANAL,

. de datos = & r_anal_plugin_snes,

. version = R2_VERSION};

#terminara si

Después de compilar radare2 enumerará este plugin en la salida:

_d__ _8_16 SNES CPU LGPL3 SuperNES

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

La implementación de un nuevo formato

Para habilitar el direccionamiento virtual

En info añadiret-> has_va = 1;


y ptr-> srwxcon elR_BIN_SCN_MAP; atributo

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}')

CFLAGS = -g -fPIC $ (Shell pkg-config --cflags r_bin)

LDFLAGS = -shared $ (Shell pkg-config --libs r_bin)

OBJS = $ (NOMBRE) .o SO_EXT = $ (Shell uname | grep -q Darwin && echo dylib || eco de modo)

LIB = $ (NOMBRE) . $ (SO_EXT)

todas: $ (LIB)

limpiar:

rm -f $ (LIB) $ (OBJS)

$ (LIB): $ (OBJS)

$ (CC) $ (CFLAGS) $ (LDFLAGS) $ (OBJS) -o $ (LIB)

instalar:

cp -f $ (NAME). $ (SO_EXT) $ (R2_PLUGIN_PATH)

desinstalar:

rm -f $ (R2_PLUGIN_PATH) / $ (NAME). $ (SO_EXT)

bin_nes.c:

213
plugins

# incluir <r_bin.h>

static int comprobar (* RBinFile arco) ;

static int check_bytes ( const ut8 * buf, longitud ut64) ;

hoyo estatico * load_bytes (* RBinFile arco, const ut8 * buf, SZ ut64, loadaddr ut64, SDB Sdb *) {

check_bytes (BUF, sz);

regreso R_NOTNULL; }

static int comprobar (* RBinFile arco) {

const ut8 \ * = bytes arco? r_buf_buffer (arch-> buf): NULO ; ut64 SZ = arco? r_buf_size (arch-> buf): 0 ;

regreso check_bytes (bytes, SZ); }

static int check_bytes ( const ut8 * buf, longitud ut64) {

Si (! Buf || longitud < 4 ) regreso falso ;

regreso (! memcmp (Buf, "\ X4E \ x45 \ x53 \ X1A" , 4 ));

estático RBinInfo * info (* RBinFile arco) {

RBinInfo \ * ret = R_NEW0 (RBinInfo);

Si (!retirado) regreso NULO ;

Si (! Arco ||! Arch-> buf) {

gratis (retirado);

regreso NULO ; }

ret-> file = strdup (arch-> file); ret-> type = strdup ( "ROM" ); ret->

máquina = strdup ( "Nintendo NES" ); ret-> os = strdup ( "ne" ); ret-> arco

= strdup ( "6502" ); ret-> bits = 8 ;

regreso retirado; }

struct r_bin_plugin_t r_bin_plugin_nes = {

. name = "ne" ,

. desc = "NES" ,

. licencia = "BSD" ,

. init = NULO ,

. Fini = NULO ,

. get_sdb = NULO ,

. load = NULO ,

. load_bytes = & load_bytes,

214
plugins

. comprobar = & comprobar,

. baddr = NULO ,

. check_bytes = & check_bytes,

. entradas = NULO ,

. secciones = NULO ,

. info = e información,};

# ifndef CORELIB

struct r_lib_struct_t radare_plugin = {

. type = R_LIB_TYPE_BIN,

. de datos = & r_bin_plugin_nes,

. 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

La implementación de nuevo plugin de formato en Python

Nota - En los siguientes ejemplos hay funciones que faltan de la decodificación real para facilitar la lectura!

Para ello, tiene que hacer lo siguiente:

1. r2lang importación

2. Hacer una función con funciones parciales:

load_bytes carga

destruyen

check_bytes baddr

entradas secciones

215
plugins

importaciones

reubicaciones

información

binsym

y devolver la estructura Plugin - Plugin para rasm

def le_format (un) :

def carga (BinF) :

regreso [ 0 ]

def check_bytes (BUF) :

tratar :

Si buf [ 0 ] == 77 y buf [ 1 ] == 90 :

lx_off, = struct.unpack ( "<I" , Buf [ 0x3C : 0x40 ])

Si buf [lx_off] == 76 y buf [lx_off + 1 ] == 88 :

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

funcionesentradas, secciones, las importaciones, las reubicaciones


devuelve una lista de los diccionarios especiales formados de - cada uno

con un tipo diferente. Hay una función especial, que devuelve información sobre elInfo:
archivo -

def info (BinF) :

regreso [{

"tipo" : "Le" ,

"Bclass" : "Le" ,

"Rclass" : "Le" ,

"OS" : "OS / 2" ,

"subsistema" : "CLI" ,

"máquina" : "IBM" ,

"arco" : "X 86" ,

"Has_va" : 0 ,

"bits" : 32 ,

"BIG_ENDIAN" : 0 ,

"Dbg_info" : 0 ,}]

3. Esta estructura debe contener una punteros a estas 2 funciones


armary -

desmontar

216
plugins

regreso {

"nombre" : "Le" ,

"Desc" : "Formato / 2 LE / LX OS" ,

"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,}

1. Luego hay que registrarlo como un plugin de formato de archivo:

impresión( "Registro de OS / 2 LE / LX plug-in ..." ) De impresión

(r2lang.plugin ( "compartimiento" , Le_format))

217
Crackmes

Crackmes

Crackmes (de "Agriéteme" desafío) son el campo de entrenamiento para la gente de ingeniería inversa. Esta sección

repasará tutoriales sobre cómo derrotar a varios crackmes utilizando r2.

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

Los crackmes IOLI están disponibles a un anfitrión local espejo

219
IOLI 0x00

IOLI 0x00

Esta es la primera crackme IOLI, y la más fácil.

$ ./crackme0x00

IOLI Crackme Nivel 0x00 Contraseña:

1234 Contraseña no válida!

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

Aquí tenemos la solicitud de la contraseña.

vaddr = 0x08048581 PADDR = 0x00000581 ordinal = 001 sz = 11 len = 10 sección = tipo .rodata = a ng stri = Contraseña:

Este es el error al entrar una contraseña no válida.

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

Este es el mensaje de la contraseña siendo aceptada.

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

Vamos a darle a este un tiro.

$ ./crackme0x00

IOLI Crackme Nivel 0x00 Contraseña:

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

Este es el segundo crackme IOLI.

$ ./crackme0x01

IOLI Crackme Nivel 0x01 Contraseña:

prueba Contraseña no válida!

Vamos a comprobar para cuerdas con rabin2.

$ 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 @

principal / (FCN) principal 113 |

; var int local_4 @ ebp-0x4

| ; DATOS XREF de 0x08048347 (Entry0)

| 0x080483e4 55 empuje ebp

| 0x080483e5 89e5 mov ebp, esp

| 0x080483e7 83ec18 sub esp, 0x18

| 0x080483ea 83e4f0 y ESP, -0x10

| 0x080483ed b800000000 mov eax, 0

| 0x080483f2 83c00f add eax, 0xf

| 0x080483f5 83c00f add eax, 0xf

| 0x080483f8 c1e804 shr eax, 4

| 0x080483fb c1e004 shl eax, 4

| 0x080483fe 29c4 sub esp, eax

| 0x08048400 c7042428850. mov dword [esp], str.IOLI_Crackme_Level_0x01_n;

[0x8048528: 4] = 0x494c4f49; "IOLI Crackme Nivel 0x01". @ 0x8048528 |

0x08048407 sym.imp.printf llamada e810ffffff

| sym.imp.printf (unk)

| 0x0804840c c7042441850. mov dword [esp], str.Password_; [0x8048541: 4] = 0

x73736150; "Contraseña:" @ 0x8048541 |

0x08048413 sym.imp.printf llamada e804ffffff

| sym.imp.printf ()

| 0x08048418 8d45fc eax lea, dword [ebp + 0xfffffffc]

| 0x0804841b 89442404 mov dword [esp + 4], eax; [0x4: 4] = 0x10101

| 0x0804841f c704244c850. mov dword [esp], 0x804854c; [0x804854c: 4] = 0x490

06425; "% D" @ 0x804854c |

0x08048426 sym.imp.scanf llamada e8e1feffff

| sym.imp.scanf ()

| 0x0804842b 817dfc9a140. cmp dword [ebp + 0xfffffffc], 0x149a

| , = <0x08048432 740E 0x8048442 je

| | 0x08048434 c704244f850. mov dword [esp], str.Invalid_Password__n; [0x80

4854f: 4] = 0x61766e49; "¡Contraseña invalida!." @ 0x804854f |

| 0x0804843b sym.imp.printf llamada e8dcfeffff

| | sym.imp.printf ()

| , == <0x08048440 eb0c JMP 0x804844e; (principal)

| || ; JMP REFX de 0x08048432 (principal) |

| `-> 0x08048442 c7042462850. mov dword [esp], str.Password_OK ____ n; [0x80485

62: 4] = 0x73736150; "Contraseña OK :)". @ 0x8048562 |

| 0x08048449 sym.imp.printf llamada e8cefeffff

| | sym.imp.printf ()

| | ; JMP XREF de 0x08048440 (principal)

| `-> 0x0804844e b800000000 mov eax, 0

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

nombres extraños, flechas, etc.

"diablillo." siglas de las importaciones. Esos símbolos son importados, como printf () "str." es sinónimo de cadenas. Esos

son cadenas (obviamente). Si se mira con cuidado, verá


cmpuna
instrucción, con una constante, 0x149a.
cmp es un x86 comparar

la instrucción, y el 0x delante de él especifica que es en base 16, o hex (hexadecimal).

0x0804842b 817dfc9a140. cmp dword [ebp + 0xfffffffc], 0x149a

Se puede utilizar de radare2? comandar conseguirlo en otra base numérica.

[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

IOLI Crackme Nivel 0x01 Contraseña:

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

IOLI Crackme Nivel 0x01 Contraseña:

0x149a Contraseña no válida!

Era digno de un tiro, pero no funciona. Eso es porque


scanf ()tomará el 0 en 0x149a sea un cero, en lugar de aceptar la

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

ingeniería inversa también. Puede encontrar estos desafíos en

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

que puede tener éxito sin hacer estas cosas.

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

comando) ampliamente! P.ej:

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 =

valueAlias para el comando 'env' | * Off [= [0x] valor]

Puntero de lectura de datos / valores / escritura (véase? V, wx, WV)

| (Arg1 arg0 macro) Manejo de macros de script

| . [- |! (M) | f | sh | cmd] Definir macro o de carga R2, cparse o archivo rlang | = [Cmd]

Ejecutar este comando a través de rap: //

|/ Búsqueda de bytes, las expresiones regulares, patrones, ..

| ! [Cmd] Ejecutar orden dada como en el sistema (3)

| # [Algo] [len] Calcula la suma de comprobación hash del bloque actual

| #! Lang [..] Hashbang ejecutar un script rlang

| un Realizar análisis de código

| segundo Obtener o cambiar el tamaño de bloque

. . .

[0x00000000]> a?

| Uso: un [abdefFghoprxstc] [...] | ab [hexpairs]

analizar los bytes

| Automóvil club británico analizar todos (fcns + bbs) (AA0 para evitar sub cambio de nombre)

| ac [ciclos] analizar que op podría ser ejecutado en [ciclos]

| anuncio analizar trampolín de datos (WIP)

| ad [de] [a] analizar los punteros de datos a (desde-hasta)

| ae [expr] analizar la expresión de opcode eval (ver ao)

| af [rnbcsl + -? *] analizar Funciones

| aF Igual que el anterior, pero utilizando anal.depth = 1

. . .

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:

Cheatsheet por pwntester

Radare2 libro Radare2 Blog

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:

[0x00 avatao] $ rabin2 -I reverse4 pic

falso

canario cierto nx

cierto

VA falsa cripto

cierto

INTRP Microesfera /lib64/ld-linux-x86-64.so.2

bintype clase elf

ELF64

lang do

arco x86

los bits 64

máquina de AMD arquitectura x86-64 OS

Linux

SUBSYS endian Linux

poco despojado falsa

lineNum estática falsas

lsyms verdaderos

falso

reubicaciones falsa rPath

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:

[0x00 avatao] $ ./reverse4?

Tamaño de datos: 2623

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!

reverse4 [0x00 avatao] $ -A r2

- - 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]> Sal avatao_reverse4 avatao_reverse4

[0x00400720]>

Puede guardar un proyecto utilizando Sal [Archivo], y cargar uno usando Po [Archivo]. Con la opción -p, se puede
punta r2:

cargar un proyecto al iniciar r2.

Podemos enumerar todas las cadenas R2 encontrado:

[0x00400720]> cadenas fs [0x00400720]> f

0x00400e98 7 str.Wrong_

0x00400e9f 27 str.We_are_in_the_outer_space_ 0x00400f80 18

str.Size_of_data: __ u_n 0x00400f92 23 str.Such_VM__MuCH_reV3rse_

0x00400fa9 16 str.Use_everything_ 0x00400fbb 9 str.flag.txt

0x00400fc7 26 str.You_won__The_flag_is: __ s_n 0x00400fe1 21

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

fs [flagspace]el(valor predeterminado es *, lo que significa que todos los flagspaces). El comando


y cambiar el actual usando Fimprime

todas las banderas de la flagspace (s) seleccionado en ese momento.

OK, las cuerdas se ve interesante, sobre todo el de 0x00400f92. Parece dar a entender que este crackme se basa en una

máquina virtual. ¡Mantenlo en mente!

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,

te voy a mostrar cómo encontrar donde se utilizan estas cadenas:

[0x00400720]> axt @@ = `f ~ [0]`

d 0x400cb5 edi mov, str.Size_of_data: __ u_n d 0x400d1d mov esi,

str.Such_VM__MuCH_reV3rse_ d 0x400d4d mov edi, str.Use_everything_ d

0x400d85 mov edi, str.flag.txt

d 0x400db4 MOV EDI, str.You_won__The_flag_is: __ s_n d 0x400dd2 mov edi,

str.Your_getting_closer_

Podemos enumerar referencias cruzadas a las direcciones utilizando


punta r2: el comando (de manera similar, podemos
axt [addr]

utilizar axfpara listar las referencias de la dirección). El @@ es un iterador, que sólo se ejecuta el comando una vez para cada

argumentos mencionados. La lista de argumentos en este caso proviene def ~


la [0].
orden
En él se enumeran las cuerdas desde el

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 ?!

Ahora que estamos al inicio de la función principal, podríamospag


utilizar
para mostrar un desmontaje ( pdf),
pd, pero R2 puede hacer

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

gráficos del arte ASCII :)

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:

cambiar entre ellos utilizando


pagy PAG.La vista gráfica puede visualizarse pulsando
Ven el modo visual (o usando
VVen

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 * \\ *

respectivamente. También puede seleccionar la verdadera o la falsa ramas utilizando


ty el Fllaves.
la

obuscar.
Es posible que aparezca el símbolo en modo visual utilizando la llave, y se puede utilizar

Vamos a leer nodo por nodo principal! El primer bloque es el siguiente:

Podemos ver que el programa lee una palabra (2 bytes) en la variable local llamada

y que lo compara con 0xbb8. Eso es 3000 en decimal, por cierto:


local_10_6,

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

Si el valor es mayor que 3000, entonces se verá obligado a ser 3000:

234
IOLI 0x01

Hay algunas cosas que suceden en el siguiente bloque:

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

desde el modo visual utilizando la tecla:!)

:> AFVN local_10_6 input_size

los affamilia comando se utiliza para analizar funciones. Esto incluye la manipulación de argumentos y variables locales
punta r2:

también, que es accesible a través deAFV


la comandos. Puede enumerar los argumentos de funciones
afa),(variables
( localesAFV),o

incluso se puede cambiar el nombre de ellos ( AFVN).


afan, Por supuesto que hay muchas otras características también - como de

costumbre: utilizar el, Lucas "?"!

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 este trozo de memoria se almacenalocal_10


en -
tiempo AFVN
para usar

de nuevo:

:> AFVN local_10 capturar_datos

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

utiliza de hecho en algún lugar de la aplicación:

:> 0x00602120 axt

d 0x400cfe mov edi, 0x602120 d 0x400d22 mov

edi, 0x602120 d 0x400dde mov edi, 0x602120

d 0x400a51 mov QWord [RBP - 8], 0x602120

Ya que probablemente será importante más adelante, debemos etiqueta que:

:> Sym.memory f 0x200 0x602120

Las banderas pueden ser gestionados mediante


punta r2: Ffamilia
el de órdenes. Acabamos de agregar el sym.memory bandera a una

zona de memoria a largo bytes 0x200 en 0x602120. También es posible eliminar ( renombrar (fr [de edad] [nuevo]),
f-nombre), agregar

comentario (fC [nombre] [cmt])


o incluso el color fc
( [nombre] [color])
banderas.

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:

:> Cd 0x200 @ sym.memory

La familia de comandos
punta r2: dose utiliza para gestionar los metadatos. Puede configurar
CC)o (editar (CC)comentarios, declaran

áreas de memoria como datos (


Discos (cuerdas Cs),etc. Estos comandos también se pueden emitir a través de un menú en
compactos),

el modo visual invocado presionando


re.

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

ejecutará. En base a este presentimiento, He nombrado este

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

propósito (al igual que cuando usted está escribiendo programas).

:> Af vmloop 0x400a45

:> AFVN input_size bytecode_length:> AFVN capturar_datos

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:

dos comandos deben estar familiarizados de antes.

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í:

Así, de nuevo a ese salto condicional.vmloop


Si devuelve cualquier otra cosa que no sea "*", el programa simplemente sale sin darnos

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!

reV3rse tanto!". Si no son iguales, el programa imprime el código de bytes, y sale:

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

cumplir. Vamos a investigar antes de profundizar en

vmloop!

Si se echa un vistazo en el minimapa de toda la función, es probable que pueda reconocer que hay una especie de

bucle empieza por el bloque [ y se trata de los siguientes nodos:


0d34],

[ 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

:> AFVN local_10_4 i

bloque siguiente es el cuerpo del bucle real:

El área de memoria en 0x6020e0 es tratada como una matriz de dwords (4 valores de bytes), y se comprueba si el valor

i-ésimo de ella es cero. Si no es así, el bucle continúa simplemente:

239
IOLI 0x01

Si el valor es cero, se rompe el bucle y este bloque es ejecutado antes de salir:

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:

:> F sym.instr_dirty 4 * 9 0x6020e0

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ó

la dirección, bandera él!

:> Sym.good_if_ne_zero f 4 0x602104

240
IOLI 0x01

Tenga en cuenta, sin embargo, que si se utiliza RIP-direccionamiento relativo, banderas no aparecerán directamente en el desmontaje,

pero r2 los muestra como comentarios:

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

cero, se pasa a la última comprobación:

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

9, por fin llegamos a nuestro destino, y conseguir la bandera:

241
IOLI 0x01

Como de costumbre, debemos 0x6020f0 bandera:

:> Sym.good_if_le_9 f 4 0x6020f0

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

estas condiciones con el fin de alcanzar el código goodboy:

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)

no debe ser cero


sym.good_if_ne_zero
tiene que ser menor o igual a 9
sym.good_if_le_9

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

función utiliza una tabla de saltos en 0x00400a74,

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.

RDIse pone en local_3. Dado que la aplicación es un ejecutable de Linux


Pero primero, vamos a analizar lo que ya tenemos! Primero,

de 64 bits, sabemos que


RDIes el primer argumento de la función (como puede haber reconocido, el análisis automático de los

argumentos y variables locales no era

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'

:> AFVN local_3 código de bytes

Siguiente, sym.memory
se pone en otra variable local RBP-8
en R2 que no reconoció. Así que vamos a definir él!

:> AFV QWord memoria de 8

los afv [idx] [nombre] [tipo]


punta r2: comando se utiliza para definir la variable local en [puntero de marco - idx] con el nombre

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

pieza de código que utiliza la tabla de saltos:

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.

Así es como el desmontaje parece después añadimos estos metadatos:

[0x00400ec0]> pd 0x18

; DATOS XREF de 0x00400a76 (unk) 0x00400ec0 .qword

0x0000000000400a80 0x00400ec8 .qword 0x0000000000400c04

0x00400ed0 .qword 0x0000000000400b6d 0x00400ed8 .qword

0x0000000000400b17 0x00400ee0 .qword 0x0000000000400c04

0x00400ee8 .qword 0x0000000000400c04 0x00400ef0 .qword

0x0000000000400c04 0x00400ef8 .qword 0x0000000000400c04

0x00400f00 .qword 0x0000000000400aec 0x00400f08 .qword

0x0000000000400bc1 0x00400f10 .qword 0x0000000000400c04

0x00400f18 .qword 0x0000000000400c04 0x00400f20 .qword

0x0000000000400c04 0x00400f28 .qword 0x0000000000400c04

0x00400f30 .qword 0x0000000000400c04 0x00400f38 .qword

0x0000000000400b42 0x00400f40 .qword 0x0000000000400c04

0x00400f48 .qword 0x0000000000400be5 0x00400f50 .qword

0x0000000000400ab6 0x00400f58 .qword 0x0000000000400c04

0x00400f60 .qword 0x0000000000400c04 0x00400f68 .qword

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:

[0x00400ec0]> f not_instr @ 0x0000000000400c04

En cuanto a las otras compensaciones, todos parecen estar haciendo algo significativo, por lo que podemos suponer que pertenecen a las

instrucciones vigentes. Voy a marcarlos utilizando valores ASCII las instrucciones a:

[0x00400ec0]> f instr_A @ 0x0000000000400a80 [0x00400ec0]> f instr_C @

0x0000000000400b6d [0x00400ec0]> f instr_D @ 0x0000000000400b17

[0x00400ec0]> f instr_I @ 0x0000000000400aec [0x00400ec0]> f instr_J @

0x0000000000400bc1 [0x00400ec0]> f instr_P @ 0x0000000000400b42

[0x00400ec0 ]> f instr_R @ 0x0000000000400be5 [0x00400ec0]> f instr_S @

0x0000000000400ab6 [0x00400ec0]> f instr_X @ 0x0000000000400b99

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!

punta r2: AFB


Se pueden definir bloques básicos utilizando el +mando. Usted tiene que suministrar lo que la función

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:

[0x00400ec0]> AFB + 0x00400a45 0x00400a80 0x00400ab6-0x00400a80 0x400c15 [0x00400ec0]> AFB + 0x00400a45

0x00400ab6 0x00400aec-0x00400ab6 0x400c15 [0x00400ec0]> AFB + 0x00400a45 0x00400aec 0x00400b17-0x00400aec

0x400c15 [0x00400ec0]> AFB + 0x00400a45 0x00400b17 0x00400b42-0x00400b17 0x400c15 [0x00400ec0]> AFB +

0x00400a45 0x00400b42 0x00400b6d-0x00400b42 0x400c15 [0x00400ec0]> AFB + 0x00400a45 0x00400b6d

0x00400b99-0x00400b6d 0x400c15 [0x00400ec0]> AFB + 0x00400a45 0x00400b99 0x00400bc1-0x00400b99 0x400c15

[0x00400ec0]> AFB + 0x00400a45 0x00400bc1 0x00400be5-0x00400bc1 0x400c15 [0x00400ec0]> AFB + 0x00400a45

0x00400be5 0x00400c04-0x00400be5 0x400c15

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

0x00400c3c-0x00400c2d 0x400c4d 0x00400c3c [0x00400ec0]> AFB + 0x00400a45 0x00400c3c 0x00400c4d-0x00400c3c 0x400c61

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

cuando se guarda el proyecto.)

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:

todas las instrucciones comienza con una secuencia como estos:

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

condición "sym.good_if_le_9 instr_P


tiene que ser menor o igual 9" realmente significa es queno puede ser ejecutado a más de 9

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

Y un ejemplo de dos parámetros:

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!

:> AFV 0xc instr_ptr_step DWORD

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

Éste simplemente pone el siguiente código de bytes (el primer argumento)


eax,y salta
en hasta el final de Así que este es el
vmloop.

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

de bytes. El siguiente que no llama a una función:

Esta es una instrucción de un argumento, y pone a su argumento 0x6020c0. Bandera esa dirección!

:> F sym.written_by_instr_C 4 @ 0x6020c0

Ah, y por cierto, yo tengo el presentimiento deinstr_C


que También tenía una llamada de función en el código original, pero quedó inlined

por el compilador. De todas formas, hasta ahora tenemos estas dos instrucciones:

regresa cona1 instr_C (a1):


instr_R (a1): escribe A1a sym.written_by_instr_C

Y también sabemos que éstos aceptan un argumento,

instr_I

instr_D

instr_P

instr_X

instr_J

y estos aceptan dos:

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

código de bytes válidos que nos da la bandera.

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

función tampoco. Vamos a obedecer, y el tipo

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

nombre de esta función


instr_A!

Usted debe darse cuenta de que estos comandos son parte del mismo sistema de menú en el modo visual que estaba hablando
punta r2:

cuando se utilizó por primera vez declarar sym.memory


Discos compactos como datos.

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

metodología, y cambiar el nombre de los VARs locales:

:> AFVN local_1 arg1:> AFVN

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

"M", "P", y "C".

254
IOLI 0x01

Esta es la rama "M":

Básicamente, se carga una dirección de desplazamiento y suma 0x602088


arg2al byte en esa dirección. Como r2 nos muestra

amablemente en un comentario, 0x602088 inicialmente contiene la dirección de

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

el primero. Sobre la base de este supuesto, voy a marcar como 0x602088


sym.current_memory_ptr:

:> F sym.current_memory_ptr 8 @ 0x602088

255
IOLI 0x01

Pasando a la rama "P":

sym.current_memory_ptr:
Sí, esta es la pieza de código que nos permite modificar se añade arg2

lo.

Por último, la "C" rama:

Bueno, resultó queinstr_C


no es la única instrucción que modifica

esta pieza de código añade


sym.written_by_instr_C: arg2lo. Y eso fue instr_A,
vamos a resumir ella! Dependiendo del

primer argumento, esta instrucción hace lo siguiente:

arg1 ==M"": agregaarg2para el byte ensym.current_memory_ptr. arg1


P ":
== "
pasos sym.current_memory_ptr
por arg2bytes.

arg1 ==C"": agregaarg2al valor ensym.written_by_instr_C.

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

instr_Sy para compararinstr_Sa instr_A.

[0x00 ~] $ radiff2 -g 0x40080d, 0x40089f reverse4 reverse4 | xdot -

[0x00 ~] $ radiff2 -g 0x40089f, 0x40080d reverse4 reverse4 | xdot -

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

después de que haya terminado esta valoración crítica.

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:

arg1 ==M"": Resta arg2desde el byte ensym.current_memory_ptr. arg1


P ":
== pasos
" sym.current_memory_ptr
hacia atrásarg2bytes.

arg1 ==C"": Resta arg2a partir del valor en


sym.written_by_instr_C.

instr_I

258
IOLI 0x01

Éste es simple, sólo llama


instr_A (arg1, Como
1). se habrán dado cuenta de la llamada a la función se parece
llamar

fcn.0040080den lugar dellamar fcn.instr_A.


Esto se debe a que al guardar y abrir un proyecto, nombres de funciones se pierden

- otra cosa a examinar y parche en R2!

instr_D

instr_S (arg1, 1).


Una vez más, simple: se llama

instr_P

Es hora de cambiar el nombre var otra vez!

:> AFVN local_0_1 const_M:> AFVN

local_0_2 const_P:> AFVN local_3 arg1

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,

y que las llamadasinstr_I ( "P").


Esto significa básicamente que
instr_Pse utiliza para escribir un byte, y poner el puntero al

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

Otro sencillo, cambiar el nombre de VARs locales de todos modos!

:> AFVN local_1 arg1

Esta función XOR en el valor con arg1.


sym.current_memory_ptr

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:

:> AFVN local_3 arg1

:> AFVN local_0_4 arg1_and_0x3f

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:

El siguiente bifurcación: arg1


si > 0,
= entonces la función devuelve
arg1_and_0x3f,

261
IOLI 0x01

de lo contrario las ramas de la función de nuevo, basado en el valor de


sym.written_by_instr_C:

Si es cero, la función devuelve 2,

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

Después de todo esto, la función devuelvearg1_and_0x3f:


con

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

instrucciones de la máquina virtual:

Instrucción primero arg 2º argumento ¿Qué hace?

"UN" "METRO" arg2 *sym.current_memory_ptr + = arg2

"PAG" arg2 sym.current_memory_ptr + = arg2

"DO" arg2 sym.written_by_instr_C + = arg2

"S" "METRO" arg2 *sym.current_memory_ptr - = arg2

"PAG" arg2 sym.current_memory_ptr - = arg2

"DO" arg2 sym.written_by_instr_C - = arg2

"YO" arg1 n/A instr_A (arg1, 1)

"RE" arg1 n/A instr_S (arg1, 1)

"PAG" arg1 n/A *sym.current_memory_ptr = arg1; instr_I ( "P")

"X" arg1 n/A *sym.current_memory_ptr ^ = arg1

arg1_and_0x3f = arg1 y 0x3F; si (arg1 y 0x40 = 0)


arg1_and_0x3f * = -1 si (arg1> = 0) de retorno
arg1_and_0x3f; else if (* sym.written_by_instr_C!
= 0) {if (arg1_and_0x3f <0)
"J" arg1 n/A

+ + *sym.good_if_ne_zero; volver
arg1_and_0x3f; } Else return 2;

"DO" arg1 n/A *sym.written_by_instr_C = arg1

"R" arg1 n/A retorno (arg1)

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:

el programa debe volver "*"

tiene que contener la cadena "Tal VM! CUÁNTO reV3rse!" después de la ejecución en los 9 instrucciones tienen
sym.memory

que ser utilizado al menos una vez

no debe ser no está permitido cero instr_P para


sym.good_if_ne_zero
ser utilizado más de 9 veces

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

es un requisito para acceder a la bandera. Con el fin de incrementar


sym.good_if_ne_zero,

tres condiciones deben cumplirse:

arg1debe ser un número negativo, de lo contrario nos volvemos temprano

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 utilizar antes de llamar a "J".

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

no es cero. Esto significa básicamente que


arg1's sexto bit debe ser 1 (0x40 = 01000000b). También porque

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

quick'n'dirty que he utilizado durante el CTF:

\ 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

más mejoras posibles.

267
Tarjeta de referencia

Guía de supervivencia Radare2 Tarjeta de

referencia

Mando Descripción

Automóvil club británico analizar Auto

pdf @ FCN (Tab) Desmonte la función

FCN f (Tab) funciones de lista

str f (Tab) Lista de cadenas

fr [flagname] [newname] Cambiar el nombre de la bandera

PSZ [desplazamiento] cadena de impresión

arf [bandera] Encuentra referencia cruzada de una bandera

Flagspaces

Mando Descripción

fs flagspaces de visualización

fs * Seleccionar todos flagspaces

fs [secciones] Seleccione uno flagspace

banderas

Mando Descripción

F Lista de banderas

fs * Seleccionar todos flagspaces

fs [secciones] Seleccione uno flagspace

fj banderas de visualización en JSON

Florida Duración del espectáculo bandera

fx Mostrar hexdump de la bandera

FC [nombre] [comentario] Conjunto de la bandera comentario

268
Tarjeta de referencia

Información

Mando Descripción

ii Información sobre las importaciones

iI Información sobre binaria

es decir visualización del punto de entrada

es secciones de visualización

IR reubicaciones de visualización

cadena de impresión

Mando Descripción

PSZ [desplazamiento] Imprimir cadena terminada en cero

psb [desplazamiento] cadenas de impresión en bloque actual

PSX [desplazamiento] Mostrar cadena con caracteres scaped

psp [desplazamiento] Imprimir cadena de pascal

PSW [desplazamiento] Imprimir amplia cadena

modo visual

Mando Descripción

V Entre en el modo visual

páginas Rotar los modos (hex, disasm, depuración, es decir, buf)

do Toggle (c) ursor

q Volver a shell Radare

hjkl Moverse (o HJKL) (abajo a la izquierda-arriba-derecha)

Entrar Siga la dirección de salto / llamada

sS Paso / pasar por encima

o Ir / tratar de offset dado

. Tratar de contador de programa

/ En el modo de cursor, buscar en el bloque actual

: cmd radare ejecutar comandos

269
Tarjeta de referencia

; [-] cmt Añadir / eliminar comentarios

/ * + - [] Cambiar tamaño de bloque, [] = cambiar el tamaño hex.cols

> || < Seek alineados para bloquear tamaño

i/a/A (I) nsert hex, (a) código ssemble, visual (A) ssembler

cama y desayuno punto de interrupción Toggle / tamaño de bloque automático

d [f?] función, los datos, el código de definir, ..

re Entre en el modo visual de diferencias (conjunto diff.from / a)

mi Edición de variables de configuración eval

f/F Set / unset bandera

gG Ir a buscar para comenzar y al final del archivo (0- $ s)

mK / 'K Marcar / ir a Key (cualquier tecla)

METRO Caminar por los sistemas de ficheros montados

n/N Buscar la siguiente función / ant / bandera / HIT (scr.nkey)

o Ir / tratar de offset dado

do Toggle (C) olors

R Selección aleatoria de paleta de colores (ECR)

t banderas de la pista (símbolos, funciones de navegación de ..)

T Explorar información y comentarios anal

v menú de análisis de código de Visual

V/W (V) gráfico IEW (AGV?), Abierto (W) ebUI

uU Deshacer / rehacer buscar

x Mostrar referencias externas a buscar entre ellos

yY Copiar y pegar la selección

z Activar el modo de zoom

buscando

270
Tarjeta de referencia

Mando Descripción

/ Foo \ 00 Buscar cadena 'foo \ 0'

/segundo buscar hacia atrás

// Repetir la última búsqueda

/ Foo w Buscar amplia cadena 'f \ 0o \ 0o \ 0'

/ Foo wi Buscar amplia caso haciendo caso omiso de la cadena

/! ff Búsqueda de primera ocurrencia que no se ajuste

/ I foo Buscar cadena 'foo' caso ignorando

/ E / EF / i Concordancia de expresiones regulares

/ X ff0.23 Búsqueda de cadena hexadecimal

/ X ff..33 Búsqueda de cadena hexadecimal haciendo caso omiso de algunos bocados

/ X ff43 ffd0 Buscar hexpair con la máscara

/ D 101112 Buscar una secuencia de bytes deltified

/! X 00 búsqueda inversa hexa (Encontrar primer byte! = 0x00)

/ C JMP [esp] Buscar por código asm (ver search.asmstr)

/ A eax JMP Montar código de operación y buscar sus bytes

/UN Búsqueda de claves AES ampliadas

/ R sym.printf Analizar referencia código de operación un desplazamiento

/R Buscar gadgets ROP

/PAG VER desplazamiento de instrucción previa

/ M magicfile Buscar a juego magia archivo

/ P patternsize Buscar patrón de tamaño dado

/ Z min max Buscar cadenas de tamaño dado

/ V [? 248] num Busque un valor de 32 bits asm.bigendian

Ahorro

Mando Descripción

Po [Archivo] Proyecto abierto

Ps [Archivo] Guardar proyecto

Pi [Archivo] Mostrar información del proyecto

271
Tarjeta de referencia

las variables que pueden utilizarse en la expresión

Mando Descripción

$$ Aquí (virtual actual búsqueda)

$O Aquí (corriente de disco io offset)

$s Tamaño del archivo

$b Tamaño de bloque

$w Obtener tamaño de palabra, 4 si asm.bits = 32, 8 si 64

$ C, $ r Obtener el ancho y la altura de la terminal

$S sección desplazada

$ SS tamaño de la sección

$j Saltar electrónico (JMP 0x10, 0x10 jz => 0x10)

$f Salto falle la dirección (JZ 0x10 => siguiente instrucción)

$I Número de instrucciones de función actual

$F tamaño función actual

$ Jn Obtener salto enésima de la función

$ Cn Obtener llamada enésima de la función

$ Dn Obtener datos de referencia del número n de la función

$ Xn Obtener referencia externa enésima de la función

$m referencia de memoria de código de operación (mov eax, [0x10] => 0x10)

$l longitud de código de operación

$e 1 si el extremo del bloque, de lo contrario 0

$ ev Obtener el valor de la variable de configuración eval

ps Último valor de comparació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