Radare2book Spanish PDF

Tabla de contenido
Introducción 1.1
Historia 1.1.1
La Descarga de Marco radare2 1.1.2
Compilación y Portabilidad de 1.1.3
compilación en Windows interfaces de 1.1.4
usuario Primeros pasos 1.1.5
1.1.6
1.2
Banderas de línea de comandos 1.2.1
del comando expresiones de 1.2.2
formato 1.2.3
Depurador Sesión básicos que 1.2.4
contribuyen a la configuración radare2 1.2.5
1.3
Colores 1.3.1
Variables de configuración de archivos 1.3.2
1.3.3
Los comandos básicos 1.4
Buscando tamaño de 1.4.1
bloque Secciones 1.4.2
modos de impresión de 1.4.3
archivos de asignación 1.4.4
de Banderas Escribir 1.4.5
zoom 1.4.6
1.4.7
1.4.8
2
Yank / Pegar 1.4.9
Comparando modo Visual 1.4.10
Bytes SDB 1.4.11
1.5
Desmontaje visual visual 1.5.1
ensamblador 1.5.2
Visual Editor de Configuración paneles 1.5.3
visuales búsqueda bytes 1.5.4
1.6
Búsquedas básicas 1.6.1
Configurando el Patrón de búsqueda 1.6.2
Búsqueda de automatización hacia 1.6.3
atrás Buscar Buscar en la Asamblea 1.6.4
búsqueda para AES llaves que 1.6.5
desmontan 1.6.6
1.6.7
1.7
Adición de Análisis de 1.7.1
metadatos ESIL 1.7.2
1.8
Variables Tipos de 1.8.1
análisis de código 1.8.2
1.8.3
Convenciones de llamada 1.8.4
virtuales Tablas llamadas al 1.8.5
sistema de emulación 1.8.6
1.8.7
información de símbolos 1.8.8
Firmas comandos Gráfico 1.8.9
1.8.10
3
scripting 1.9
Macros 1.9.1
bucles 1.9.2
R2pipe 1.9.3
depurador 1.10
Empezando 1.10.1
La migración de ida, el BGF o WinDBG Registros mapas 1.10.2
de memoria archivos Montón 1.10.3
1.10.4
1.10.5
1.10.6
Revertir Depuración de 1.10.7
acceso remoto 1.11
Herramientas remotas GDB 1.11.1
remoto WinDBG de línea de 1.11.2
comandos 1.12
Rax2 1.12.1
Rafind2 1.12.2
Rarun2 1.12.3
Rabin2 1.12.4
Las exportaciones presentar 1.12.4.1
identificación Punto de 1.12.4.2
entrada Imports 1.12.4.3
1.12.4.4
Símbolos (exportaciones) 1.12.4.5
Cuerdas Bibliotecas 1.12.4.6
1.12.4.7
Las partes del programa 1.12.4.8
Radiff2 1.12.5
binaria diffing 1.12.5.1
4
Rasm2 1.12.6
Montar 1.12.6.1
Desmontar 1.12.6.2
configuración 1.12.6.3
Ragg2 1.12.7
idioma 1.12.7.1
Rahash2 1.12.8
Rahash herramienta 1.12.8.1
plugins 1.13
IO plugins plugins Asm 1.13.1
Análisis plugins Bin 1.13.2
complementos Otros 1.13.3
complementos de Python 1.13.4
plugins Prueba de 1.13.5
depuración de 1.13.6
empaquetado Crackmes 1.13.7
1.13.8
1.13.9
1.14
IOLI 1.14.1
IOLI 0x00 1.14.1.1
0x01 IOLI 1.14.1.2
Avatao 1.14.2
R3v3rs3 4 1.14.2.1
.Introducción 1.14.2.1.1
. radare2 1.14.2.1.2
. primeros pasos 1.14.2.1.3
. principal 1.14.2.1.4
. vmloop 1.14.2.1.5
. conjunto de instrucciones 1.14.2.1.6
5
. código de bytes 1.14.2.1.7
. outro 1.14.2.1.8
Agradecimientos tarjeta 1.15
de referencia 1.16
6
Introducción
Introducción
Este libro es una versión actualizada (iniciado por Maijin) del libro radare1 originales (escrito por panqueque). Que se mantiene activa y
actualizada por muchos contribuyentes a través de Internet.
Consulte el sitio Github para añadir nuevos contenidos o corregir faltas de ortografía:
Github: https://github.com/radare/radare2book
Gitbook: https://www.gitbook.com/book/radare/radare2book/details
Gitbook genera automáticamente HTML / PDF / EPUB / versiones MOBIL en aquí:
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
7
Historia
Historia
En 2006, Sergi Álvarez (también conocido como panqueques) trabajaba como analista forense. Dado que no se le permitió utilizar el software privado para sus
necesidades personales, decidió escribir un redactor con la herramienta-un pequeño hexadecimal características muy básicas:
sea extremadamente portátil (UNIX amable, línea de comandos, c, pequeños dispositivos de disco)
abiertos, esto es mediante la búsqueda desplazamientos de 64 bits para una cadena o hexpair
revisión y volcar los resultados en el disco
El editor fue diseñado originalmente para recuperar un archivo borrado de una partición HFS +.
Después de eso, panqueque decidió extender la herramienta para tener un io enchufable para poder asociar a los procesos e implementar las
funcionalidades del depurador, soporte para múltiples arquitecturas y análisis de código.
Desde entonces, el proyecto ha evolucionado para proporcionar un marco completo para el análisis de los binarios, mientras que haciendo uso de los
conceptos básicos de UNIX. Estos conceptos incluyen el famoso "todo es un archivo", "pequeños programas que interactúan utilizando stdin / stdout" y
"mantenerlo simple" paradigmas.
La necesidad de scripting mostró la fragilidad del diseño inicial: una herramienta monolítica hecha la API difícil de usar, por lo que se necesitaba una
refactorización de profundidad. En 2009 radare2 (r2) nació como un tenedor de radare1. El refactor añade flexibilidad y características dinámicas.
Esto permitió mucho mejor integración, allanando el camino para usar r2 de diferentes lenguajes de programación . Más tarde, el r2pipe API permitido
el acceso a radare2 a través de tuberías de cualquier idioma.
Lo que comenzó como un proyecto de un solo hombre, con algunas contribuciones eventuales, se convirtió progresivamente en un gran proyecto basado en la
comunidad en torno a 2014. El número de usuarios estaba creciendo rápidamente, y el autor y principal desarrollador tenido a cambiar los papeles del
codificador al administrador con el fin de integrar el trabajo de los diferentes desarrolladores que se incorpora al proyecto.
Indicar a los usuarios reportar sus problemas permite que el proyecto para definir nuevas direcciones para evolucionar. Todo se
gestiona GitHub de radare2 y discutido en el canal Telegram.
El proyecto se mantiene activo en el momento de escribir este libro, y hay varios proyectos secundarios que proporcionan, entre otras
cosas, una interfaz gráfica de usuario ( Cortador ), Un descompilador ( r2dec , RADECO ), La integración Frida ( r2frida ), Yara, unicornio,
Keystone, y muchos otros proyectos en el indexado r2pm (El gestor de paquetes radare2).
8
Historia
Desde 2016, la comunidad se reúne una vez al año r2con , Un congreso en torno radare2 que tiene lugar en Barcelona.
9
El marco
El marco
El proyecto Radare2 es un conjunto de pequeñas utilidades de línea de comandos que se pueden utilizar juntos o independientemente.
Este capítulo le dará una rápida comprensión de ellos, pero se puede comprobar las secciones dedicadas para cada herramienta al final de
este libro.
radare2
La herramienta principal de todo el marco. Utiliza 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, y visualizando. Puede ser escrito con una variedad de idiomas,
incluyendo Python, Ruby, JavaScript, Lua, y Perl.
rabin2
Un programa para extraer información de binarios ejecutables, tales como ELF, PE, Java CLASS, Mach-O, más cualquier formato soportado por plugins r2.
rabin2 es utilizado por el núcleo para obtener datos como símbolos exportados, importaciones, información de los archivos, referencias cruzadas (refx),
dependencias de la biblioteca, y secciones.
rasm2
Un ensamblador de línea de comandos y desensamblador para múltiples arquitecturas (incluyendo Intel x86 y x86-64, MIPS, ARM, PowerPC, Java
y otras muchas actuaciones).
Ejemplos
$ Rasm2 java -a 'nop' 00
$ Rasm2 -a -d x 86 '90' nop
10
El marco
$ Rasm2 -a -b x 86 32 'mov eax, 33' b821000000
$ Echo 'eax empuje; nop; nop' | rasm2 -f 509090
rahash2
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, y otros. rahash2 se puede utilizar para comprobar la integridad o el seguimiento de los cambios de archivos
de gran tamaño, volcados de memoria o discos.
Ejemplos
$ archivo rahash2
archivo: 0x00000000-0x00000007 sha256: 887cfbd0d44aaff69f7bdbedebd282ec96191cce9d7fa7336298 a18efc3c7a5a
$ 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 código-análisis diffing
para encontrar los cambios en los bloques de código básicas obtenidas a partir del análisis de código radare.
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.
11
El marco
Ejemplos
$ 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) {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:
Resolver crackmes de
pruebas Fuzzing
script de muestra de rarun2
$ Foo.rr2 gato
# ! / Usr / bin / programa rarun2
=. / PP400 = 10 arg0
stdin = foo.txt chdir = /
tmp
# = Chroot.
. /foo.rr2
12
El marco
Conexión de un programa con un zócalo
$ Nc -l 9999
del programa $ rarun2 = / bin / ls conectar = localhost: 9999
Depuración de un programa de Redireccionamiento de la stdio en 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 / bin / ls
rax2
A minimalista evaluador expresión matemática para la cáscara que es útil para hacer las conversiones de base entre los valores de coma
flotante, representaciones hexadecimales, cuerdas hexpair a ASCII, octal a un entero, y más. También es compatible con la configuración
endianness y se puede utilizar como un shell interactivo, si no se dan argumentos.
Ejemplos
13
El marco
$ Rax2 1337 0x539
$ Rax2 0x400000 4194304
$ 01.111.001 y rax2 -b
$ Rax2 -S radare2
72616461726532
$ Rax2 -s 617765736f6d65 impresionante
14
radare2 la descarga
radare2 la descarga
Puedes 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 pull en cualquier parte del árbol de código fuente radare2:
$ Git pull
Si tiene modificaciones locales de la fuente, puede volver ellos (y perderlos!) Con:
$ Git reset CABEZA --hard
O enviar 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
Construir con mesón + Ninja

15
radare2 la descarga
También hay un soporte de trabajo en curso para el Mesón.
El uso de sonido metálico y ld.gold hace que la acumulación más rápida:
CC = sonido metálico LDFLAGS = -fuse-ld = mesón de oro. liberación --buildtype = liberación --prefix ~ / .local / sto w / / release radare2 liberación Ninja -C
# Ninja -C liberar instalar
scripts de ayuda
Echar un vistazo a la sys / * guiones, los se utilizan para automatizar cosas relacionadas con la sincronización, la construcción y la 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.
Limpiar
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
dieciséis
radare2 la descarga
17
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), OS X, FreeBSD, NetBSD, y OpenBSD (Intel x86 y x86_64) ..
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
configurar opción de escritura al compilar radare2.
Observe que hay E / S conector que utilice el BGF, el BGF, WinDbg o vino como back-ends, y por lo tanto se basan en presencia de
herramientas de terceros correspondiente (en el caso de la depuración remota - sólo en el equipo de destino).
Para construir un sistema que utiliza acr y Hacer GNU ( 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 radare2 estáticamente, junto con todas las demás herramientas con el comando:
$ Sys / static.sh
Estibador
Radare2 barcos repositorio una Dockerfile que se puede utilizar con estibador.
18
Este dockerfile también es utilizado por la distribución REMnux de SANS, y está disponible en la ventana acoplable
registryhub .
Limpieza de instalaciones de hasta Viejo Radare2
. / Configure --prefix = / / r2 / prefijo / instalación de edad que purga
19
Compilación en Windows
ventanas
Radare2 se basa en el generador de sistema de construcción Mesón para apoyar la compilación en todas las plataformas, incluyendo Windows. Mesón generará
una solución de Visual Studio, todos los archivos necesarios para el proyecto, y el cable hasta el C ++ Visual compilador de Microsoft para usted.
Puede descargar los binarios noche desde https://bin.rada.re .
Requisitos previos
Visual Studio 2015 (o superior) Python
3 Mesón Git
Paso a paso
Instalar Visual Studio 2015 (o superior)
Visual Studio debe estar instalado con un compilador de C ++ Visual, el apoyo a las bibliotecas de C ++ y el SDK de Windows correspondiente
a la versión plataforma de destino.
En el Visual Studio 2015 instalador, asegurar Lenguajes de Programación> de Visual C ++ se selecciona instaladores En el Visual Studio
2017+, asegurar la desarrollo de escritorio con C ++ carga de trabajo se selecciona
Si necesita una copia de Visual Studio, las versiones de la comunidad son gratuitos y funcionan muy bien.
Descargar Visual Studio 2015 Comunidad (requiere registro) descargar Visual
Studio 2017 Comunidad
Instalar Python 3 y Meson través Conda
Se recomienda encarecidamente instalar Conda - un sistema de gestión del medio ambiente Python - cuando se trabaja con Python en
la plataforma Windows. Esto aislará el entorno de construcción Radare2 de otras versiones de Python instalado y minimizar los
conflictos potenciales.
20
Configurar Conda:
1. Descargar el Conda apropiado (Python 3.x) para su plataforma ( https://conda.io/miniconda.html )
2. Instalar Conda con los valores por defecto recomendados
Crear un entorno de Python para Radare2
Siga estos pasos para crear y activar un entorno de Conda llamado r2. Todas las instrucciones de este punto en adelante asumirán este
nombre coincida con el medio ambiente, pero puede cambiarlo si lo desea.
Preguntar 1. Inicio> Anaconda
2. conda crear -n r2 pitón = 3
3. activar r2
En cualquier momento que deseen entrar en este entorno, abra el símbolo del Anaconda y reedición activar r2.
A la inversa, desactivar dejará al medio ambiente.
instalar Mesón
Todas las versiones de Mesón iguales o inferiores a 0.47.1 tienen un error que impiden el uso normal en Windows. Porque no hay
versión oficial con las correcciones disponibles, debe instalar a partir de fuentes. Los siguientes pasos le guiará a través de este.
Vamos a actualizar esta documentación lo más pronto 0,48 es lanzado oficialmente.
1. Active el ambiente Radare2 Conda, si es necesario ( activar r2)
2. Descargar https://github.com/mesonbuild/meson/archive/master.zip
3. pip install \ ruta \ a \ descargado \ master.zip
4. Verificar Meson es la versión 0.48 o superior ( mesón -v)
Instalar Git para Windows
Todo el código Radare2 se gestiona a través del sistema de control de versiones Git y alojado en GitHub .
Siga estos pasos para instalar Git para Windows.
1. Descargar Git para Windows ( https://git-scm.com/download/win )
A medida que navega el asistente de instalación, se recomienda configurar estas opciones cuando aparecen:
Utilice una fuente TrueType en todas las ventanas de la consola
21
Usar Git desde el símbolo del sistema de Windows
Utilizar la biblioteca nativa de Windows canal seguro (en lugar de OpenSSL) Pedido de estilo de Windows,
comprometerse finales de línea al estilo Unix (core.autocrlf = true) ventana de la consola por defecto Uso de
Windows (en lugar de Mintty)
2. Cierre todas las ventanas de la consola previamente abiertas y volver a abrir para asegurar que reciban el nuevo PATH
3. Asegurar --version git trabajos
Obtener código Radare2
Siga estos pasos para clonar el repositorio git Radare2.
1. En su entorno Radare2 Conda, desplazarse a una ubicación donde se guardará el código y compilado. Esta ubicación necesita
aproximadamente 3-4GiB del espacio
2. Clonar el repositorio con git clone https://github.com/radare/radare2.git
Compilar Código Radare2
Siga estos pasos para compilar una versión de depuración de 32 bits (x86) de Radare2. (Si usted quiere construir una versión de 64 bits (x64) de Radare2,
reemplazar todas las instancias de x86 con x64. Del mismo modo, si usted quiere construir una versión de lanzamiento, reemplazar todas las instancias de depurar con lanzamiento
.)
binarios compilados se instalarán en el dest carpeta.
1. Active el ambiente Radare2 Conda
2. Vaya al directorio raíz de las fuentes Radare2 ( cd radare2)
3. Inicializar Estudio de herramientas de Visual mediante la ejecución del comando que coincide con la versión instalada en su máquina de
Visual Studio:
Visual Estudio 2015: "% ProgramFiles (x86)% \ Microsoft Visual Estudio
14,0 \ VC \ vcvarsall.bat" x86
Visual Estudio 2017: "% ProgramFiles (x86)% \ Microsoft Visual
Studio \ 2017 \ Enterprise \ VC \ Auxiliar \ Build \ vcvars32.bat"
Visual Estudio Avance: "% ProgramFiles (x86)% \ Microsoft Visual
Studio \ Vista preliminar \ Enterprise \ VC \ Auxiliar \ Build \ vcvars32.bat"
4. Generar el sistema de construcción con Mesón: mesón construir --buildtype depuración --backend vs2015 -
prefijo% CD% \ dest
22
Mesón requiere actualmente - prefijo para que apunte a una ruta absoluta. Usamos el% pseudovariable% de CD para obtener la ruta
absoluta al directorio de trabajo actual.
5. Iniciar una construcción: msbuild construir \ radare2.sln / p: Configuración = Depuración / m
Los / m [axcpucount] parámetro genera un proceso de trabajo MSBuild por procesador lógico en su máquina. Puede especificar un valor
numérico (por ejemplo / m: 2) para limitar el número de procesos de trabajo si es necesario. (Esto no se debe confundir con el
interruptor de Visual C ++ Compiler / MP).
6. Instalar en la carpeta de destino: mesón instalar -C construir --no-reconstruir
7. Para comprobar la versión Radare2: dest \ bin \ -v radare2.exe
23
Interfaces de usuario
Radare2 ha visto muchas interfaces de usuario diferentes están desarrollando en los últimos años.
El mantenimiento de una interfaz gráfica de usuario está lejos del alcance del desarrollo de la maquinaria central de un conjunto de herramientas de ingeniería
inversa: se prefiere tener un proyecto y la comunidad separada, permitiendo que ambos proyectos para colaborar y mejorar juntos - en lugar de forzar a los
desarrolladores de la CLI para pensar en los problemas de interfaz gráfica de usuario y tener que ir y venir entre el aspecto gráfico y la lógica de nivel bajo de las
implementaciones.
En el pasado, ha habido por lo menos 5 interfaces de usuario nativas diferentes (Ragui, r2gui, gradare, r2net, bokken), pero ninguno de ellos tiene el
poder suficiente para despegar el mantenimiento y todos ellos murieron.
Además, R2 tiene un servidor web integrado y barcos algunas interfaces de usuario básicas escritas en HTML / JS. Puede comenzar como esto:
$ R2 -C = H / bin / ls
Después de 3 años de desarrollo privado, Hugo Teso; el autor de Bokken (Python GUI-GTK de r2) dio a conocer al público en cualquier
otro frontal de r2, esta vez escrito en C ++ y Qt, que ha sido muy bien recibido por la comunidad.
Esta GUI fue nombrado Iaito, pero siempre y cuando él prefirió no seguir manteniéndola, Xarkes decidió que tenedor que bajo el nombre de
cortador (nombre votado por la comunidad), y dirigir el proyecto. Esto es como se ve:
https://github.com/radareorg/cutter .
24
25
Primeros pasos
Uso básico Radare2
La curva de aprendizaje es por lo general un poco caro 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 las diferentes herramientas radare ofertas. Se le anima a leer el resto de este libro para
entender cómo funcionan algunas cosas no triviales, y en última instancia, para mejorar sus habilidades.
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 abrevia como s y acepta una expresión como argumento. La expresión puede ser algo así como 10, + 0x25, o [ 0x100 +
ptr_table]. Si está trabajando con archivos basados en bloques, es posible que prefiera para establecer el tamaño de bloque a un valor requerido
con segundo mando, y buscar hacia adelante o hacia atrás con posiciones alineadas a la misma. Utilizar s ++ y s-- comandos para navegar por este
camino.
Si radare2 abre un archivo ejecutable, por defecto se abrirá el archivo en modo de direccionamiento virtual (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. Utilizando - norte opción que puede suprimir este comportamiento por defecto y pedir radare2 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.
26
Primeros pasos
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 frecuentes px para imprimir en formato hexadecimal, y pd para el desmontaje.
Que se le permitiera escribir archivos, especifique la - w opción de radare2 al abrir un archivo. los w comando se puede utilizar para escribir
secuencias, hexpairs ( X subcomando), o incluso opcodes de montaje ( una subcomando). Ejemplos:
> hola mundo w ; cuerda
> wx 90 90 90 90 ; hexpairs
> wa JMP 0x8048140 ; montar
> inline.bin WF ; escribir el contenido del archivo
Al añadir una? a un comando mostrará su mensaje de ayuda, por ejemplo, ¿pag? . Al añadir? * Mostrará comandos comenzando con la cadena
dada, por ejemplo, ¿pag?* .
Para entrar en el modo visual, pulse V <ENTER>. Utilizar q 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
quitarse o do llave. Para seleccionar un rango de bytes en modo de cursor, mantenga pulsada la tecla CAMBIO
y las claves principales de prensa de navegación hjkl para marcar su selección.
Mientras que 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. Presionando pag o PAG puede desplazarse a
diferentes representaciones modo visual. Hay un segundo modo visual más importante - la interfaz de paneles maldiciones similar, accesible con V!
mando.
27
Banderas de línea de comandos
Opciones de línea de comandos
El núcleo radare acepta muchas banderas de la línea de comandos.
Este es un extracto del mensaje de uso ayuda:
$ Radare2 -h
Uso: r2 [-ACdfLMnNqStuvwzX] [parche -P] [-p prj] [-a arco] [bits de -b] [-i archivo]
[-S addr] [-B baddr] [-m maddr] [-c cmd] [k = v -e] archivo | pid | - | - | =
- - radare2 funcionar sin necesidad de abrir cualquier archivo
- mismo que 'r2 malloc: // 512'
= leer el archivo de la entrada estándar (-i uso y -c para ejecutar CMDS)
- = realizar! =! comando para ejecutar todos los comandos de forma remota
- 0 print \ x00 después de init y todos los comandos
- 2 cerca de descriptor de archivo stderr (mensajes de aviso silencioso)
- un [arco] conjunto asm.arch
- UNA ejecutar 'AAA' 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 depurar el 'archivo' ejecutable o proceso que se ejecuta 'pid'
- 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
- F [binplug] fuerza para utilizar ese plugin rbin
- h, hh Mostrar mensaje de ayuda, hh por mucho tiempo
- H ([var]) variable DISPLAY
- i [Archivo] archivo de secuencia de comandos ejecutada
- I [archivo] ejecute el archivo script antes de que se abra el archivo
- k [OS / Kern] asm.os conjunto (Linux, MacOS, w32, NetBSD, ...)
- l [lib] archivo plugin de carga
- L Lista apoyado plugins IO
28
- m [addr] archivo de mapa en la dirección dada (loadaddr)
- METRO no demangle nombres de símbolos
- n, -nn no cargue información RBin (-nn estructuras del compartimiento de carga solamente)
- norte no cargue la configuración de usuario y scripts
- q el modo silencioso (sin preguntar) y se retiró después de -i
- Q el modo silencioso (sin preguntar) y salir más rápido (quickLeak = true)
- p [prj] proyecto de uso, lista si hay argumento, si no hay carga de archivos
- P [Archivo] solicitar el archivo y salga de rapatch
- r [rarun2] especificar el perfil rarun2 para cargar (igual que -e dbg.profile = X)
- R [rr2rule] especifica la directiva personalizada rarun2
- s [addr] iniciales obtengan
- S iniciar R2 en modo de recinto
- t cargar información rabin2 en hilo
- u establecer bin.filter = falsa para obtener prima sym / SEC / nombres cls
- V, -V versión espectáculo radare2 (-V muestran versiones lib)
- w archivo abierto en modo de escritura
- X abierta y sin exec-flag (asm.emu no funcionará), Ver io.exec
- X mismo que -e bin.usextr = false (útil para dyldcache)
- z, -zz no cargue cuerdas o cargarlos incluso en crudo
los patrones de uso común
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:
$ 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
29
Establecer la variable de configuración:
$ R2 = 0 -e scr.color BLAH.BIN
Depurar un programa:
$ Ls -d r2
Utilizar un archivo de proyecto existente:
prueba $ r2 -p
30
Formato de los comandos
Un formato general para los comandos radare2 es el siguiente:
[tiempos] [cmd] [~ grep] [@ [@ iter] addr tamaño!] [|> tubería] [.];
Las personas que usan Vim diariamente y están familiarizados con sus comandos se encontrarán como en casa. Verá este formato
utilizado en todo el libro. 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 desea utilizar la devolución de llamada cmd desde el plugin de E / S debe
prefijar con =! .
Tenga en cuenta que un solo signo de exclamación se ejecutará el comando e imprimir la salida a través de la API rcons. Esto significa que
la ejecución se bloquea y no interactiva. Utilizar los signos de exclamación dobles -
!! - para ejecutar una llamada al sistema estándar.
Todos el zócalo, las API del sistema de archivos y de ejecución pueden ser restringidos con el cfg.sandbox variable de configuración.
Algunos 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
La tubería estándar de UNIX | también está disponible en la cáscara radare2. Se puede utilizar para filtrar la salida de un comando r2 con cualquier
programa de shell que se lee de la entrada estándar, tales como grep, menos, wc. Si no desea que nada para desovar, o no puede, o el sistema de destino
no tiene las herramientas básicas que necesita UNIX (Windows o usuarios incrustados), también se puede utilizar el incorporado en grep (~ ).
31
Ver ? ~? en busca de ayuda.
el ~ carácter permite la función grep-como interno utilizado para filtrar la salida de cualquier comando:
pd 20 ~ llamada ; 20 desensamblar instrucciones y salida de grep para 'llamada'
Además, puede grep ya sea por columnas o filas para:
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
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 radare2 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. Referirse a bucles
sección (iteradores) para más información.
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 ejemplo, pd 5 @ 0x100000fce 5 de desmontar las instrucciones en la dirección 0x100000fce.
La mayoría de los comandos ofrecen apoyo terminación automática usando < TAB> clave, por ejemplo s eek o F desfases comandos. Ofrece terminación
automática utilizando todos los valores posibles, tomando nombres bandera en este caso. Observe que es posible ver la historia de los comandos
utilizando el! ~ ... comando - que ofrece un modo visual para desplazarse por el historial de comandos radare2.
Para extender el apoyo de autocompletar para manejar más comandos o habilitar el autocompletado a sus propios comandos definidos en
el núcleo, E / S plugins debe utilizar el !!! mando.
32
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? :
[0xb7f9d810]>? Vi 0x8048000 134512640
[0xv7f9d810]>? Vi 0x8048000 + 34 134 512 674
[0xb7f9d810]>? Vi 0x8048000 + 0x34 134512692
[0xb7f9d810]>? 1 + 2 + 3-4 * 3 hex
0xfffffffffffffffa octal
01777777777777777777772 unidad
17179869184.0G
fffff000 segmento: Int64 0ffa -6
cadena "\ xfa \ xff \ xff \ xff \ xff \ xff \ xff \ xff"
binaria fvalue 0b1111111111111111111111111111111111111111111111111111111111111010: -6,0 float: nanf doble: nan
trits 0t11112220022122120101211020120210210211201
operaciones aritméticas soportados son:
+ : adición
- : la resta
* : Multiplicación /:
división%: módulo
> : Desplazamiento
a la derecha <: desplazamiento a la izquierda
[0x00000000]>? Vi 1 + 2 + 3 6
Con el uso del operador lógico OR debe citar todo el comando para evitar la ejecución de la | tubo:
33
expresiones
[0x00000000]> "1 | 2?" Hexagonal
0x3
octal 03 unidad
segmento 0000: 0003 int32 3
cadena "\ x03" fvalue
0b00000011 binaria: 2.0
float: 0.000000f doble:
0,000000 trits 0t10
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
También puede utilizar variables y buscar posiciones para construir expresiones complejas.
Utilizar el PS comando para listar todos los comandos disponibles o leer el capítulo refcard de este libro.
$$ aquí (la corriente virtuales buscan) $ l
código de operación de
longitud $ s tamaño de
archivo $ j saltar la 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) $ b
tamaño de bloque
Algunos ejemplos más:
[0x4A13B8C0]>? + $ L $ m
140293837812900 0x7f98b45df4a4 03771426427372244 130658.0G 8b45d000: 04a4 140293837812900
10100100 140,293,837,812,900.0 -0.000000
[0x4A13B8C0]> pd 1 @ + $ l 0x4A13B8C2 llamar
0x4a13c000
34
expresiones
35
Sesión básica depurador
Para depurar un programa, comenzar con el radare - re opción. Tenga en cuenta que se puede 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 r2 -d 32220 $ -d / bin /
ls
$ R2 -a -b brazo 16 -d GDB: //192.168.1.43: 9090
. . .
En el segundo caso, el depurador se bifurcará y cargar el depurando un programa ls programa en la memoria.
Se hará una pausa en su ejecución a principios de ld.so enlazador dinámico. Como resultado de ello, aún no se verá el punto de entrada o cualquier bibliotecas
compartidas en este punto.
Puede anular este comportamiento estableciendo otro nombre para un punto de interrupción de entrada. Para ello, agregue un comando radare
e dbg.bep = entrada o e dbg.bep = main a su script de inicio, por lo general es
~ / .Config / radare2 / radare2rc.
Otra manera de continuar hasta que una dirección específica es el uso de la DCU mando. Lo que quiere decir: "depuración continuará hasta que"
tomar la dirección del lugar de parar en. Por ejemplo:
principal de la DCU
Ten en cuenta que cierto software malicioso u otros programas complicados en realidad puede ejecutar código antes principal() y por lo tanto no podrás
controlarlos. (Al igual que el constructor programa o los inicializadores TLS)
A continuación se muestra una lista de los comandos más comunes utilizados con depurador:
36
> ¿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; permisos de cambio de página en A y tamaño S
> dr eax = 33 ; conjunto de valores de registro. eax = 33
Hay otra opción para la depuración en radare, que puede ser más fácil: se utiliza el 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 modo de uso depurador visual VPP:
[0xb7f0c8c0]> Vpp
La vista inicial después de entrar en el modo visual es una vista hexdump del contador actual programa de destino (por ejemplo, EIP para x86).
Prensado pag se puede navegar a través del resto de puntos de vista modo visual. Puede pulsar pag y PAG para girar a través de los modos de impresión
más comunes. Uso F7 o s para entrar en y F8 o S a pasar por encima de la instrucción actual. Con el do 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ón con F2
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:
<Pulse ':'> 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, pulse
q.
Un comando es utilizado con frecuencia Dr , que se utiliza para leer o escribir valores de registros de propósito general del objetivo. Para una
representación más compacta valor del registro es posible utilizar dr = mando. También puede manipular el hardware y los registros de coma
flotante ampliada /.
37
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.
Ver https://github.com/radare/radare2/blob/master/DEVELOPERS.md para obtener ayuda general sobre la contribución a radare2.
38
Configuración
Configuración
El núcleo lee ~ /. config / radare2 / radare2rc mientras que a partir. Puedes añadir mi comandos de este archivo para sintonizar la configuración
radare2 a su gusto.
Para evitar radare2 de analizar este archivo en el arranque, pasarla a la - norte opción.
Toda la configuración de radare2 se realiza con la eval comandos. Un archivo de configuración inicial típica es el siguiente:
$ Cat ~ / .radare2rc e scr.color = 1 e
= dbg.bep cargador
La configuración también se puede cambiar con - mi opció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 ajustar scr.color y asm.syntax
la siguiente línea se puede utilizar:
$ Radare2 -N -e scr.color = 1 -e asm.syntax = Intel -d / bin / ls
Internamente, la configuración se almacena en una tabla hash. Las variables se agrupan en espacios de nombres: cfg. , expediente. , dbg. , SCR. y
así.
Para obtener una lista de todas las variables de configuración sólo tiene que escribir mi en la línea de comandos. Para limitar la salida a un espacio de nombres
seleccionado, pasarlo con un punto final a e. Por ejemplo, archivo de correo. mostrará todas las variables definidas dentro del espacio de nombres "archivo".
Para obtener ayuda acerca mi tipo de comando ¿mi? :
39
Configuración
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
Una alternativa más simple a la mi comando es accesible desde el modo visual. Tipo ve para entrar en él, utilice las flechas (arriba, abajo, izquierda,
derecha) para navegar por la configuración y q para salir de ella. La pantalla inicial para la configuración de edición visual se ve así:
[EvalSpace]
> 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
40
Configuración
41
Colores
Colores
acceso a la consola está envuelto en API que permite mostrar la salida de cualquier comando como ANSI, W32 consola o formatos HTML. Esto
permite que el núcleo de radare para funcionar dentro de los entornos con capacidades que muestran limitadas, como granos o dispositivos
incrustados. 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 = 1' >> ~ / .radare2rc
Tenga en cuenta que la activación de los colores no es una opción booleana. En cambio, es un número porque hay diferentes niveles de profundidad de color. Esto es:
0: blanco y negro 1: 16 colores
básicos ANSI 2: 256 escala colores
3: 24 bits de color verdadero
La razón de tener este tipo de opciones definidas por el usuario se debe a que no hay manera estándar o portátil para los programas de terminal para
consultar la consola para determinar la mejor configuración, lo mismo que las codificaciones de juegos de caracteres, por lo r2 le permite elegir que con la
mano.
Por lo general, las consolas en serie pueden trabajar con 0 o 1, mientras que xterms puede admitir hasta 3. rcons tratarán de encontrar la combinación
de colores más cercano para su tema cuando se elige una diferente con el eco mando.
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:
42
Colores
43
Colores
temas
Usted puede crear su propio tema de color, pero radare2 tener sus propios los predefinidos. Utilizar el eco
mandar a la lista o seleccionarlos.
En el modo visual utilizar el R clave para cambiar aleatoriamente colores o elegir el tema siguiente en la lista.
44
Variables de configuració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ón mi comando
sin argumentos. Por ejemplo, para ver todas las variables definidas en el "cfg" espacio de nombres, tema e cfg. ( mente el punto final). Usted puede obtener
ayuda en cualquier variable de configuración mediante el uso de eval ¿mi? cfg.
los ¿¿mi?? comando para obtener ayuda sobre todas las variables de configuración evaluables de radare2. Siempre que el resultado de este
comando es bastante grande que se puede combinar con el grep interna ~ filtrar por lo que busca:
El modo Visual cuenta con un navegador eval que es accesible a través de la VBE mando.
asm.arch
Define la arquitectura de la CPU de destino utilizado para desmontar ( PD, PD comandos) y análisis de código ( una mando). Puede
encontrar la lista de posibles valores observando el resultado de e asm.arch =? o
rasm2 -L. Es muy sencillo añadir nuevas 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 unos pocos los hechos
a mano.
asm.bits
Determina anchura en bits de los registros de 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 son Intel y att.
asm.pseudo
45
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, se mostrará eax = ebx
en vez de una mov eax, ebx.
asm.os
Selecciona un sistema operativo de destino de binario cargado actualmente. Por lo general, el sistema operativo detecta automáticamente
Rabin-ri. Todavía, asm.os se puede utilizar para cambiar a una mesa diferente syscall empleado por otro sistema operativo.
asm.flags
Si se define a "true", vista desensamblador tendrá columna de banderas.
asm.lines.call
Si se establece en "true", dibujar líneas a la 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 "verdadera", la vista desmontaje también dibujar líneas de flujo de control que van fuera 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 con el análisis de los programas de rastreo.
46
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.
cfg.newtab
Si se habilita esta variable, mensajes de ayuda se muestran junto con los nombres de comandos en la implementación del tabulador para
comandos.
scr.color
Esta variable especifica el modo para la salida de la pantalla coloreada: "falso" (o 0) significa que no hay colores, "verdadero" (o 1) significa modo
de 16 colores, 2 significa modo de 256 colores, 3 significa 16 modo millón-colores. Si su tema favorito se ve raro, tratar de subir esto.
scr.seek
Esta variable acepta una expresión con todas las funciones o un puntero / bandera (por ejemplo. EIP). Si se establece, radare establecerá 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.
cfg.fortunes.type
Fortunas se clasifican por tipo. Esta variable determina qué tipos están autorizados para la visualización cuando
cfg.fortunes es cierto , para que puedan ser afinados en lo que es apropiado para la audiencia deseada. tipos actuales son consejos,
diversión, nsfw, espeluznante.
47
archivos
archivos
Utilizar r2 -H para enumerar todas las variables de entorno que son importantes para saber dónde estará en busca de archivos. Esos caminos dependen de la
forma (y el sistema operativo) que han construido para r2.
R2_PREFIX = / usr
MAGICPATH = / usr / share / radare2 / 2.8.0-GIT / prefix = mágica / usr
INCDIR = / usr / include / LiBr LIBDIR = /
usr / lib64 LIBEXT = tan
RCONFIGHOME = / home / usuario / .config / radare2 RDATAHOME = /
home / usuario / .local / share / radare2 RCACHEHOME = / home / usuario
/ .cache / radare2 LIBR_PLUGINS = / usr / lib / radare2 / 2.8.0-GIT
USER_PLUGINS = / home / usuario / .local / share / radare2 / plugins USER_ZIGNS = / home /
usuario / .local / share / radare2 / zigns
archivos RC
archivos RC son scripts r2 que se cargan en tiempo de inicio. Estos archivos deben estar en 3 lugares diferentes:
Sistema
radare2 primero intentará cargar / usr / share / radare2 / radare2rc
Tu hogar
Cada usuario del sistema puede tener sus propios guiones R2 para ejecutar en el arranque para seleccionar la combinación de colores, y otras opciones
personalizadas por tener comandos r2 allí.
~ / .Radare2rc
~ / .Config / radare2 / radare2rc ~ / .config /
radare2 / radare2rc.d /
Archivo de destino
48
archivos
Si desea ejecutar una secuencia de comandos cada vez que se abre un archivo, basta con crear un archivo con el mismo nombre del archivo, pero añadiendo . r2 lo.
49
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, mientras que / x 90 90 se utiliza para buscar parejas hexadecimales.
El formato general para un comando válido (como se explica en el Formato de los comandos capítulo) es el siguiente:
[tiempos] [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 al plugin IO actualmente cargado (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 comando 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 del tamaño de bloque definido actualmente. Algunos comandos
aceptan las expresiones matemáticas o cadenas.
> px 0x17 ; mostrar 0x17 bytes en hexs a corriente buscar
> s base + 0x33; busca bandera 'base' más 0x33
> / lib ; buscar cadena 'lib'.
50
Los @ signo se utiliza para especificar una ubicación de desplazamiento temporal o buscar una 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: una 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 un punto y coma; :
> px; Dr
51
buscando
buscando
Para moverse por el archivo que se está inspeccionando tendremos que cambiar la compensación a la que estamos usando el
s mando.
El argumento es una expresión matemática que puede contener nombres de bandera, paréntesis, suma, resta, multiplicación de immediates de
contenido de la memoria utilizando soportes.
Algunos comandos de ejemplo:
[0x00000000]> S 0x10
[0x00000010]> s + 4 [0x00000014]>
s [0x00000010]> s + [0x00000014]>
Observe cómo el indicador de compensar los cambios. La primera línea se mueve el desplazamiento a la dirección actual 0x10.
El segundo sí busca un pariente 4 bytes hacia adelante.
Y, por último, los 2 últimos comandos están deshaciendo y rehaciendo la última operaciones de búsqueda.
En lugar de utilizar sólo números, podemos usar expresiones complejas u operaciones aritméticas básicas para representar la dirección a
buscar.
Para ello, compruebe el? $? mensaje de ayuda que describe las variables internas que pueden ser utilizados en las expresiones. Por ejemplo,
esto es lo mismo que hacer s + 4.
[0x00000000]> s $$ + 4
Desde el depurador (o al emular) también podemos utilizar los nombres de los registros como referencias. Se cargan como banderas
con el . Dr* de comandos, lo que ocurre bajo el capó.
> S RSP [0x00000000] + 0x40
Aquí está la ayuda total de la s mando. Vamos a explicar con más detalle a continuación.
52
buscando
[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
También hay subcomandos de? que muestran la salida en un formato específico (en base 10, base 16, ...). Ver ? v y? VI.
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
Como un archivo de prueba, vamos a utilizar un simple hello_world.c compilado en formato ELF Linux. Después compilamos que vamos a abrir con radare2:
53
buscando
$ R2 hola_mundo
Ahora tenemos el símbolo del sistema:
[0x00400410]>
Y es el momento de ir más profundo.
Buscando en cualquier posición
Todos los comandos que buscan que tienen una dirección como parámetro de comando pueden utilizar cualquier base numérica como hexadecimal, octal, binario o
decimal.
Buscará una dirección de 0x0. Un comando alternativo es simplemente 0x0
[0x00400410]> s 0x0
[0x00000000]>
Imprimir dirección actual:
0x0 [0x00000000]> s
[0x00000000]>
Hay 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]>
Estamos de vuelta en 0x00400410.
54
buscando
También hay un comando para mostrar la historia Solicita:
[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
55
Tamaño de bloque
Tamaño de bloque
El tamaño del bloque determina el número de bytes radare2 comandos de proceso 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 ejemplo 20 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 segundo comando 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
56
secciones
secciones
El concepto de secciones está ligada a la información extraída de los binarios. Podemos mostrar esta información mediante el uso de
la yo mando.
Visualización de información acerca de las secciones:
[0x00005310]> es
[Secciones]
00 0x00000000 0 0x00000000 0 ----
01 0x00000238 28 0x00000238 28 -r-- .interp
02 0x00000254 32 0x00000254 32 -r-- .note.ABI_tag
03 176 0x00000278 0x00000278 176 -r-- .gnu.hash 04 0x00000328 0x00000328 3000 3000 -r--
.dynsym 05 0x00000ee0 1412 0x00000ee0 1412 -r-- .dynstr 06 250 0x00001464 0x00001464 250 -r--
.gnu.version 07 0x00001560 112 112 0x00001560 -r-- .gnu.version_r 08 0x000015d0 4944
0x000015d0 4944 -r-- .rela.dyn 09 0x00002920 0x00002920 2448 2448 -r-- .rela.plt 10 0x000032b0
23 0x000032b0 23 .init -rx
. . .
Como usted sabe, los binarios tienen secciones y mapas. Las secciones definen el contenido de una parte del archivo que puede ser mapeado en
memoria (o no). Lo que está asignada está definida por los segmentos.
Antes de la refactorización IO hecho por condret, la S comando se utiliza para gestionar lo que ahora llamamos mapas. En la actualidad
el S comando es obsoleto debido es y om debería ser suficiente.
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, ofrece la radare es . Utilizar ¿es? para obtener el mensaje de ayuda. Para una lista de todas las secciones creadas utilizan es ( o ISj
para obtener el formato JSON). los iS = mostrará las barras región en ASCII-art.
Puede crear una nueva asignación utilizando la om subcomando como sigue:
om fd vaddr [tamaño] [PADDR] [rwx] [nombre]
Por ejemplo:
[0x0040100]> om 4 0x00000100 0x00400000 0x0001ae08 prueba rwx
57
secciones
También puedes usar om comando para ver la información acerca de las secciones asignadas:
[0x00401000]> om
6 fd: 4 + 0x0001ae08 0x00000100 - test rwx 0x004000ff 5 fd: 3 + 0x00000000 0x00000000 - 0x0000055f
r-- fmap.LOAD0 4 fd: 3 + 0x00001000 0x00001000 - 0x000011e4 rx fmap.LOAD1 3 fd: 3 + 0x00002000
0x00002000 - 0x0000211f r- - fmap.LOAD2 2 fd: 3 + 0x00002de8 0x00003de8 - 0x0000402f r--
fmap.LOAD3 1 fd: 4 + 0x00000000 0x00004030 - 0x00004037 rw- mmap.LOAD3
Utilizar om? para obtener todos los posibles subcomandos. Para una lista de todos utilizan los mapas definidos om ( o omj para obtener el formato JSON o om * para obtener el
formato de los comandos r2). Para obtener la vista ASCII Art uso om =.
También es posible borrar la sección asignada mediante el om-mapid mando.
Por ejemplo:
[0x00401000]> om-6
58
archivos de asignación
subsistema de E / S del Radare le permite mapear el contenido de archivos en el mismo espacio de E / S utilizado para contener un binario cargado. Los nuevos
contenidos se pueden colocar en desplazamientos aleatorios.
los o comando permite al usuario abrir un archivo, este se asigna en la posición 0 si no tiene un encabezado binario conocido y luego los mapas
se crean en direcciones virtuales.
A veces, queremos rebasar un binario, o tal vez queremos cargar o asignar el archivo en una dirección diferente.
Al poner en marcha r2, la dirección base se puede cambiar con el - segundo bandera. Pero hay que notar la diferencia al abrir archivos con
encabezados desconocidos, como gestores de arranque, por lo que necesitamos para mapear usando el - metro bandera (o especificar como
argumento a la o mando).
radare2 es capaz de abrir archivos y porciones mapa de ellos en lugares al azar en la memoria especificar atributos como permisos y nombre. Es la
herramienta básica perfecta para reproducir un entorno como un archivo central, una sesión de depuración, por También la carga y mapear todas
las bibliotecas de la binaria depende.
Apertura de archivos (y el mapeo de ellos) se realiza mediante el O ( ) La orden de abrir. Vamos a leer la ayuda:
59
[0x00000000]> O?
| Uso: o [com-] [ARCHIVO] ([desplazamiento]) | o
lista de archivos abiertos
| 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] rwx 0x4000 archivo de mapa en 0x4000
| OA [-] [A] [B] [nombre de archivo] Especifica el arco y los bits de archivo dado | oq
una lista de todos los archivos abiertos
|o* lista de archivos abiertos en los comandos r2
| o. [Len] abrir un malloc: // [len] copiando los bytes del desplazamiento actual
|o= Lista de archivos abiertos (barras ascii-art)
| ob [?] [lbdos] [...] Lista abrió archivos binarios respaldados por fd
| oc [Archivo] archivo de núcleo abierto, al igual que el relanzamiento de r2
| de [archivo] archivo abierto y asignarla al addr 0 como de sólo lectura
| 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 [r] [args] reabrir en el modo de depurador (con args)
| oo [bnm] [...] ver oo? en busca de ayuda
| op [fd] priorizar fd dado (véase también OB)
| buey fd fdx intercambiar los descs de fd y fdx y mantener el mapeo
Preparar un diseño simple:
$ 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:
60
[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. Pasar el descriptor de archivo requerido a ella como un argumento:
[0x00000000]> O-14
61
Modos de impresión
Modos de impresión
Una de las características clave de radare2 está mostrando la información en muchos formatos. El objetivo es ofrecer una selección de opciones de
visualización de interpretar en los mejores datos binarios posibles vías.
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, descompilación lista, ser el resultado de un procesamiento externo ...
A continuación se muestra una lista de los modos de impresión disponibles listados por ¿pag? :
[0x00005310]> p?
| Uso: p [= 68abcdDfiImrstuxz] [arg | len] [@addr] | p - [?] [JH] [Modo]
Barra | JSON | bloques de histograma (modo:? E search.in)
| p = [BEP] [N] [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
| pj [?] [len] imprimir como sangría JSON
| p [II] [DF] [len] impresión N ops / bytes (f = func) (véase pi? y PDI)
| p [kK] [len] tecla de impresión en randomart (K es para mosaico)
| pm [?] [mágica] libmagic los datos de impresión (ver pm? y / m?)
| pq [?] [iz] [len] imprimir el código QR con la primera nBytes del bloque actual
| pr [?] [GLX] [len] impresión N bytes primas (en líneas o hexblocks, 'g'unzip)
| 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
| pwd mostrar directorio de trabajo actual
| 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)
[0x00005310]>
62
Modos de impresión
Consejo: cuando se utiliza la salida JSON, puede anexar el ~ {} al comando para obtener una versión bastante impresa de la salida:
[0x00000000]> DO
[{ "Levantado": false, "fd": 563280, "URI": "malloc: // 512", "de": 0 "puede escribir": true, "tamaño": 512, "o verlaps": false }] [0x00000000]> DO ~} {[
"Levantado": false, "fd":
563280,
"Uri": "malloc: // 512", "de": 0,
"Escribible": true, "tamaño":
512, "solapamientos": false}]
Para más información sobre los poderes mágicos de ~ consulte la ayuda en? @? , y el Formato de los comandos capítulo anterior 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:
Mostrar las palabras hexadecimales volquete (32 bits)
63
Modos de impresión
8 bits Hexpair Lista de Bytes
[0x00404888]> p8 16
31ed4989d15e4889e24883e4f0505449
Mostrar Hexadecimal Quad-palabras volquete (64 bits)
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]> e cfg.bigendian = false [0x08048000]> pt 4
29: 04: 32.948 23:12:36 +0000
[0x08048000]> e 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 la salida, por ejemplo, por
año:
[0x08048000]> pt ~ 1974 | wc -l 15
[0x08048000]> pt ~ 2022 27: 04: 2022
16:15:43 +0000
64
Modos de impresión
El formato de fecha por defecto se puede configurar mediante el cfg.datefmt variable. Reglas de formato para que siga el (3) formato strftime bien
conocido. Compruebe la página de manual para más detalles, pero estos son los más importantes:
% 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. % 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). % 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). % M El mes como un número decimal (rango 01 a 12). % M El minuto como un número decimal (rango 00 a 59). % P O "AM" o
"PM", según el valor de tiempo especificado.
% 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 rango es
de hasta 60 para permitir fo r ocasionales segundos bisiestos.)
% T El tiempo en formato de 24 horas (% H:% M:% S). (SU)
% 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.
Tipos basicos
Hay modos de impresión disponibles para todos los tipos básicos. Si usted está interesado en una estructura más compleja, tipo PF ?? para los
caracteres de formato y PF ??? por ejemplo:
sesenta y cinco
Modos de impresión
[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)
|F valor doble (8 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
Utilice triple signo de interrogación PF ??? para obtener algunos ejemplos usando las cadenas de formato de impresión.
66
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 campos denominados
: '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, Troll
como los nombres respectivos de los campos | PF 0iwq foo bar trol
Igual que el anterior, pero se considera como una unió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 w
on sus nombres de campo | PF {entero}?
(BiFC) Los tiempos de impresión de números enteros con el siguiente formato
(BiFC)
| pf [4] w [7] i Imprimir una matriz de 4 palabras, y luego un arr
ay 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). Utilice 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:
ordenador personal do
ordenador personal* print 'WX' comandos r2
PCH C media-palabras (2 bytes)
PCW palabras C (4 byte)
pcd dwords C (8 byte)
PCA blob GAS .byte
pcA . bytes con las instrucciones de los comentarios
67
Modos de impresión
pcs cuerda
PCS shellscript que reconstruye el bin
PCJ JSON
PCJ javascript
PCP pitón
Si tenemos que crear un archivo .c contiene un blob binario, utilice el ordenador personal mando, que crea esta salida. El tamaño por defecto es como en
muchos otros comandos: el tamaño del bloque, que se puede cambiar con el segundo
mando.
Pero sólo podemos anular temporalmente el tamaño de bloque expresándola como un argumento.
[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, 0x81
, 0xC3, 0xd6, 0xA7, 0x01, 0x00, 0x8B, 0x83, 0x00, 0xff, 0xff, 0xff, 0x5a, 0x8d, 0x24, 0x
84, 0x29, 0xC2};
Cstring que se puede utilizar en muchos lenguajes de programación, no sólo C.
[0x7fcd6a891630]> PC
"\ X48 \ x89 \ XE7 \ XE8 \ x68 \ x39 \ x00 \ x00 \ x49 \ x89 \ XC4 \ X8b \ x05 \ XEF \ x16 \ x22 \ x00 \ X5a \ x48 \ x8d \ x24 \ xc 4 \ 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 a la hora de empezar a aplicar ingeniería inversa a un programa, ya que suelen
hacer referencia a la información sobre las acciones de funciones (afirma, depuración o INFO mensajes ...). Por lo tanto, radare soporta varios formatos de serie:
68
Modos de impresión
[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. A continuación se presenta 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 la llamada 'abierta', que es una cadena terminada en cero, lo que podemos inspeccionar el uso PSZ.
[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 la PF mando:
[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 para pf, y en el tiempo de cambio de posición buscan la corriente / desplazamiento utilizando
@. También es posible definir conjuntos de estructuras de pf. Para ello, el prefijo de la cadena de formato con una
69
Modos de impresión
valor numérico. También puede definir un nombre para cada campo de la estructura añadiéndolos como una lista de argumentos spaceseparated.
[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 uso de PF en una binaria de un complemento de GStreamer:
$ 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 códigos de operación recuento de opcodes
D: asm.arch desensamblador bsize bytes
[0x00404888]> pd 1
; - Entry0: 0x00404888
31ed xor ebp, ebp
70
Modos de impresión
Selección de Arquitectura de destino
El sabor arquitectura para el desensamblador se define por la asm.arch variables eval. Puedes usar e asm.arch = ?? para enumerar todas las
arquitecturas disponibles.
[0x00005310]> e asm.arch = ?? _dAe _8_16
6502 LGPL3 6502 CPU / NES / C64 / Tamagotchi / T-1000
_dAe _8 8051 PD 8051 CPU Intel
_dA_ _16_32 arco GPL3 Argonaut RISC Core
a___ _16_32_64 arm.as LGPL3 como ARM ensamblador (uso ARM_AS medio ambiente)
adae _16_32_64 brazo BSD desensamblador Capstone ARM
_dA_ _16_32_64 arm.gnu GPL3 Acorn RISC CPU de la máquina
_d__ _16_32 desensamblador ARM arm.winedbg LGPL2 WineDBG
adae _8_16 avr GPL Atmel AVR
adae bf _16_32_64 LGPL3 Brainfuck
_dA_ _32 Chip8 desensamblador LGPL3 Chip8
_dA_ _16 CR16 Plugin de desmontaje LGPL3 CR16
_dA_ _32 cris GPL3 Axis Communications 32-bit procesador embebido
adA_ _32_64 Dalvik LGPL3 AndroidVM Dalvik
ad__ _16 dcpu16 PD de Mojang DCPU-16
_dA_ _32_64 EBC LGPL3 EFI Bytecode
adae _16 gb LGPL3 GameBoy (TM) (z80-like)
_dAe _16 h8300 LGPL3 H8 / 300 plugin de desmontaje
_dAe _32 hexágono LGPL3 Qualcomm Hexágono (QDSP6) V6
_d__ _32 hppa GPL3 HP PA-RISC
_dAe _0 i4004 LGPL3 Intel 4004 microprocesador
_dA_ _8 i8080 BSD Intel 8080 CPU
adA_ _32 Java código de bytes de Java Apache
_d__ _32 Lanai GPL3 LANAI
. . .
Configuración del desensamblador
Hay varias opciones que se pueden utilizar para configurar la salida del desensamblador. Todas estas opciones se describen en ¿mi?
asm.
71
Modos de impresión
[0x00005310]> e? asm.
asm.anal: Analizar código y árbitros, mientras que el desmontaje (ver anal.strings) asm.arch: Establecer el arco para ser
utilizado por asm
asm.assembler: Establecer el nombre del plugin para utilizar en el montaje de asm.bbline: Mostrar línea en blanco
después de cada asm.bits bloques básicos: tamaño de la palabra en bits en asm.bytes ensamblador: muestra los bytes
de cada asm.bytespace instrucción: bytes hexadecimales separados con un espacio en blanco asm.calls: información
relacionada con la función Mostrar destinatario de la llamada como comentarios en asm.capitalize disasm: uso en
CamelCase asm.cmt.col desmontaje: columna para alinear los comentarios
asm.cmt.flgrefs: banderas Mostrar comentario asociado a asm.cmt.fold referencia rama: Doblar los comentarios, alternar
con Vz
. . .
Actualmente existen 136 asm. variables de configuración así que no una lista de todos ellos.
desmontaje de sintaxis
los asm.syntax variable 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
También puede comprobar asm.pseudo, que es una vista pseudocódigo experimental, y asm.esil qué salidas ESIL ( 'Intermedio series de
idioma evaluable'). 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.
72
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 una bandera:
[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 el fs mando:
73
banderas
[0x00005310]> fs?
| fs uso: [*] [+ -] [flagspace | addr] # Administrar flagspaces | fs
flagspaces de visualización
| fs * visualización flagspaces como comandos r2
| fsj flagspaces visualización en JSON
| fs * seleccionar todos flagspaces
| fs flagspace seleccione flagspace o crear si no existe | fs-flagspace quitar flagspace | FS *
eliminar todos los flagspaces
| FS + foo empujar flagspace previo y conjunto
| FS pop a la anterior flagspace
| FS. eliminar el actual flagspace
| FSQ flagspaces de lista en modo silencioso
| FSM [addr] mover banderas en la dirección dada al flagspace actual
| SFS visualización flagspaces pila
| FSS * visualización flagspaces apilan en los comandos r2
| fssj visualización flagspaces apilan en JSON
| FSR newname cambiar el nombre de flagspace seleccionado
[0x00005310]> fs 0 439 * cuerdas 1 17 * Símbolos 2 54 * Secciones 3 20 *
segmentos 4 115 * reubicaciones 5 109 * importaciones [0x00005310]>
Aquí hay algunos ejemplos de comandos:
[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.
banderas locales
Cada nombre de bandera debe ser único para abordar razones. Pero es bastante común la necesidad de tener las banderas, por ejemplo,
dentro de las funciones, con nombres simples y ubicuos como lazo o regreso . Para este propósito se puede utilizar los llamados banderas
"locales", los cuales están ligados a la función en la que residen. Es posible añadirlos usando F. mando:
74
banderas
[0x00003a04]> pd 10 │
0x00003a04 48c705c9cc21. mov QWord [0x002206d8], 0xffffffffffffffff;
[0x2206d8: 8] = 0 │
0x00003a0f c60522cc2100. mov byte [0x00220638], 0 ; [0x220638: 1] = 0
│ 0x00003a16 83f802 cmp eax, 2
│ .─ <0x00003a19 0f84880d0000 je 0x47a7
│ │ 0x00003a1f 83f803 cmp eax, 3
│ .── <0x00003a22 740E 0x3a32 je
│ ││ 0x00003a24 83e801 sub eax, 1
│.─── <0x00003a27 0f84ed080000 je 0x431a
││││ 0x00003a2d e8fef8ffff sym.imp.abort llamada ; aborto (void)
││││; CÓDIGO XREF de principal (0x3a22) ││ ╰ ──> 0x00003a32
be07000000 mov esi, 7
[0x00003a04]> f. localflag @ 0x3a32 [0x00003a04]> f.
0x00003a32 localflag [principal + 210] [0x00003a04]> pd 10 │
0x00003a04 48c705c9cc21. mov QWord [0x002206d8], 0xffffffffffffffff;
[0x2206d8: 8] = 0 │
0x00003a0f c60522cc2100. mov byte [0x00220638], 0 ; [0x220638: 1] = 0
│ 0x00003a16 83f802 cmp eax, 2
│ .─ <0x00003a19 0f84880d0000 je 0x47a7
│ │ 0x00003a1f 83f803 cmp eax, 3
│ .── <0x00003a22 740E 0x3a32 je ; main.localflag
│ ││ 0x00003a24 83e801 sub eax, 1
│.─── <0x00003a27 0f84ed080000 je 0x431a
││││ 0x00003a2d e8fef8ffff sym.imp.abort llamada ; aborto (void)
││││; CÓDIGO REFX desde main (0x3a22) ││`──> .localflag:
││││; CÓDIGO REFX desde main (0x3a22) ││`──> 0x00003a32
be07000000 mov esi, 7
[0x00003a04]>
75
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 administrar como una amplia cuerdas, las 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 el w mando. Se acepta varios formatos de entrada como ensamblador en línea, endianfriendly DWords, archivos, archivos
hexpair, cadenas de ancho:
76
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 ';'
| de archivos FAT ensamblar archivos y escribir bytes
| WAO [?] op modificar código de operación (salto condicional. nop, etc)
| wA [?] r 0 alterar / modificar código de operación actual en buscar (WA?)
| 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 hasta aquí
| [?] Nosotros [nNsxX] [arg] extender las operaciones de escritura (inserte vs sustituir) | WF - | archivo
escribir el contenido del archivo en el desplazamiento actual
| WH r2 whereis / que comando shell
| wm F0FF establecer cyclick binaria hexpair máscara de escritura
| 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) [?] | WTS host: puerto [SZ] enviar
datos al host remoto: puerto a través de tcp: // | foobar ww
escribir amplia cadena
| 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 ...
77
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
| bytes aleatorios Wor (alias 'wr $ b' | WOR >> = desplazamiento a la
derecha | WOL << = desplazamiento a la izquierda
| WO2 2 = 2 bytes de intercambio endian | WO4 4 = 4
byte de intercambio endian
Es posible implementar cifrado-algoritmos usando primitivas de núcleo radare y wo. Un ejemplo de sesión xor rendimiento (90) + add
(01, 02):
[0x7fcd6a891630]> px
- compensar - 0123456789ABCDEF
0x7fcd6a891630 4889 e7e8 6839 0000 4989 1622 c48b 05ef 0x7fcd6a891640 005a 488d 24C4
29c2 5248 89d6 4989 E548 0x7fcd6a891650 83e4 F048 8b3d 061A 498D 2200 4cd5 1049
0x7fcd6a891660 8d55 0831 ede8 06e2 0000 488d 15cf e600 [0x7fcd6a891630]> wox 90
[0x7fcd6a891630]> px
0x7fcd6a891630 d819 d919 7778 541B 90ca d81d c2d8 1946 0x7fcd6a891640 1374 60d8 B290
d91d 1dc5 98a1 9090 d81d 0x7fcd6a891650 90DC 197c 9f8f 1490 d81d 95d9 9f8f 1490
0x7fcd6a891660 13d7 9491 9f8f 1490 13ss 9491 9f8f 1490 [0x7fcd6a891630]> WOA 01 02
[0x7fcd6a891630]> px
0x7fcd6a891630 d91b 787a 91cc d91f 1476 61da 1ec7 99a3 0x7fcd6a891640 91de 1a7e d91f 96dB
14d9 9593 1401 9593 0x7fcd6a891650 c4da 1a6d E89A D959 9192 9159 1cb1 D959
0x7fcd6a891660 9192 79cb 81da 1652 81da 1456 A252 7c77
78
Escribir
79
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 file_size / block_size bytes del archivo. Utilizar el pz
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. Prensado z de nuevo el zoom-in en la 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:
[0x08049790]> e zoom.byte = h [0x08049790]> pz // o defecto
PZH
0x00000000 7F00 0000 e200 0000 146e 6f74 0300 0000 0x00000010 0000 0000 0068 2102
00ff 2024 e8f0 007a 0x00000020 8c00 18c2 ffff 0080 4421 41c4 1500 5dff 0x00000030 FF10
0018 0fc8 031A 000C 8484 E970 8648 0x00000040 d68b 3148 348b 03a0 8b0f c200 5D25
7074 0x00000050 7500 00e1 ffe8 58fe 4dc4 00e0 dbc8 b885
[0x08049790]> e zoom.byte = p [0x08049790]>
pz // o pzp
0x00000000 2f47 0609 070A 0917 1e9e a4bd 2a1b 2c27 0x00000010 322d 5671 8788 8182
5679 7568 82a2 7d89 0x00000020 8173 7f7b 727a 9588 a07b 5c7d 8daf 836d 0x00000030
b167 6192 a67d 8aa2 6246 856e 8c9b 999f 0x00000040 A774 96c3 b1a4 6c8e a07c 6a8f
8983 6a62 0x00000050 7d66 625F 7ea4 7ea6 b4b6 8b57 a19f 71a2
80
Enfocar
[0x08049790]> eval zoom.byte = banderas [0x08049790]> pz // o
Pzf
0x00406e65 48d0 80f9 360f 8745 ffff ffeb ae66 0f1f 0x00406e75 4400 0083 F801 0f85 3FFF
ffff 410f B600 0x00406e85 3c78 0f87 6301 0000 0fb6 c8ff 24cd 0026 0x00406e95 4100 660F
1f84 0000 0000 0084 C074 043c 0x00406ea5 3a75 18b8 0500 0000 83f8 060f 95c0 e9cd
0x00406eb5 feff FF0F 1f84 0000 0000 0041 8801 4983 4983 0x00406ec5 C001 C201 C101
4983 e9ec feff FF0F
[0x08049790]> e zoom.byte = F [0x08049790]>
pO // o Pzf
0x00000000 0000 0000 0000 0000 0000 0000 0000 0000 0x00000010 0000 2b5c 5757 3a14
331f 1b23 0315 1d18 0x00000020 222a 2330 2b31 2e2a 1714 200d 1512 383D 0x00000030
1E1A 181b 0a10 1a21 2a36 281E 1d1c 0e11 0x00000040 1B2a 2F22 2229 181e 231E 181c
1913 262b 0x00000050 apartado 2B30 4741 422f 382a 1e22 0f17 0f10 3913
Puede limitar el zoom a una serie de bytes en lugar de toda la bytespace. Cambio zoom.from y
zoom.to las variables eval:
[0x00003a04]> e? enfocar.
zoom.byte: devolución de llamada zoom para calcular cada byte (Ver pz ayuda?) zoom.from: Zoom dirección de inicio
zoom.in: Especificar los límites de zoom.maxsz zoom: Zoom tamaño máximo de bloque zoom.to: Dirección de zoom
[0x00003a04 ]> e zoom. zoom.byte = h zoom.from = 0 zoom.in = io.map zoom.maxsz = 512 zoom.to = 0
81
Yank / Pegar
Yank / Pegar
Radare2 tiene un portapapeles interno para guardar y escribir porciones de memoria cargada desde la capa io actual.
Esta portapapeles se puede manipular con el y mando.
Las dos operaciones básicas son
copia (tirón)
pasta
La operación tirón leerá N bytes (especificado por el argumento) en el portapapeles. después podemos utilizar el yy comando para pegar lo
que leemos antes en un archivo.
Puede dar un tirón / pega bytes en el modo visual seleccionándolas con el modo de cursor ( vc) y a continuación, utilizando el
y y Y asociaciones de teclas que son alias para y y yy comandos de la interfaz de línea de comandos.
[0x00000000]> y?
| Uso: y [ptxy] [len] [[@] DIRECCIÓN] Ver # wd? para el establecimiento de memoria, lo mismo que 'yf'. | 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 copia 16 bytes en el portapapeles de 0x200 | yz [len]
copia de cadenas (de bloque actual) en el portapapeles
| yp contenido de la impresión del portapapeles
| yx contenido de la impresión del portapapeles en hexadecimal
| ys contenido de la impresión del portapapeles como cuerdas
| yt 64 0x200 copiar 64 bytes de la corriente tratan de 0x200
| archivo ytf volcar el portapapeles al archivo dado
| yf 64 0x200 copiar 64 bytes del archivo de 0x200
| YFA copia de archivos copiar todos los bytes 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
82
Yank / Pegar
Puede realizar un tirón y pegar en una sola línea sólo por el uso de la yt comando (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. $.).
83
comparando Bytes
comparando Bytes
Para la mayoría de las tareas de ingeniería inversa genéricos como encontrar las diferencias entre dos archivos binarios, lo que ha cambiado bytes,
encontrar diferencias en los gráficos de los resultados de análisis de código, y otras operaciones diffing sólo se puede utilizar radiff2:
$ Radiff2 -h
Dentro r2, las funcionalidades expuestas por radiff2 están disponibles con la do mando.
c( abreviatura de "comparar") le permite comparar las matrices de bytes de diferentes fuentes. El comando acepta la entrada en un número de
formatos y luego se lo 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] Igual que el anterior, pero la impresión comandos r2
| 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 [at] Compara en dos columnas hexdump de tamaño de bloque
| ccc [at] Igual que el anterior, pero sólo muestran líneas diferentes
| ccd [at] Compara en dos columnas DISASM de tamaño de bloque
| cf [Archivo] Comparar el contenido de archivo en la corriente buscar
| cg [?] [o] archivo actual [archivo] Graphdiff y [archivo]
| [Dir] @at Compare hexdumps memoria de $$ y el horario de verano en diff unificado cu [?] | bolo alimenticio [dir] @at disasm Diff
unificado de $$ y dirección dada | cv [1248] [hexpairs] @at Comparar 1,2,4,8-byte de valor | CV [1248] [addr] @at
Comparar el contenido de dirección 1,2,4,8-byte
| cw [?] [nosotros?] [...] Comparación de los observadores de memoria
| cx [hexpair] Comparar hexpair cadena (uso '' como comodín nibble)
| cx * [hexpair] Comparación hexpair cuerda (r2 comandos de salida) | cX [addr]
Como 'cc', pero utilizando la salida HexDiff
| CD [dir] chdir
| cl | cls | clara Borrar pantalla, (clear0 a Goto 0, 0 solamente)
Para comparar los contenidos de la memoria a la corriente buscar posición en contra de una determinada cadena de valores, el uso cx:
84
comparando Bytes
[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 subcomando de la 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:
[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, ser expresiones matemáticas que utilizan nombres de bandera y nada permitida en una expresión:
[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:
85
comparando Bytes
r2 / bin / true [0x08049A80]> s
[0x08048000]> cf / bin / true Comparar 512/512
bytes iguales
86
SDB
SDB
SDB significa Cadena base de datos. Es una sencilla base de datos clave-valor que sólo funciona con cadenas creadas por panqueque. Se utiliza en
muchas partes del r2 tener un disco y base de datos en memoria que es pequeño y rápido para gestionar su uso como una tabla hash en los esteroides.
SDB es una base de datos clave de cadena simple / valor en función de almacenamiento en disco cdb de djb y es compatible con JSON y matrices introspección.
Hay también los sdbtypes: una biblioteca vala que implementa varias estructuras de datos en la parte superior de un SDB o una instancia de Memcache.
SDB es compatible con:
espacios de nombres (varias rutas SDB) atómica sincronización de bases
de datos (nunca corrompido) enlaces para vala, luvit, newLISP y nodejs
interfaz de línea de comandos para bases de datos SDB cliente y servidor
memcache con el apoyo SDB matrices de back-end (azúcar sintaxis)
JSON analizador / captador
ejemplo de uso
Vamos a crear una base de datos!
$ SDB d = hola mundo $ SDB d
hola mundo
Utilización de matrices:
87
SDB
$ SDB - '[] list = 1,2' '[0] lista' '[0] list = foo' '[] lista' '[1] list = bar' 1 foo bar 2 2 foo
Vamos a jugar con JSON:
$ SDB d = g '{ "foo": 1, "bar": { "vaca": 3}}'? $ SDB d g bar.cow 3
$ SDB - user = '{ "id": 123}' id de usuario = 99 id de usuario 99??
Usando la línea de comandos sin ningún tipo de base de datos en disco:
$ SDB - foo = foo bar bar a = 3 + 4 3 -a una
$ SDB foo =
bar foo bar a
=3
+ Un
4
- un
3
Retire la base de datos
$ Rm -f d
Y qué ?
Por lo tanto, ahora se puede hacer esto dentro de sus sesiones radare2!
Vamos a echar un binario simple, y comprobar lo que ya es sdbized.
88
SDB
$ Test.c gato int main
() {
puts ( "Hola mundo \ n"); }
prueba test.c $ gcc -o
$ R2 -A ./test [0x08048320]> ** k
bin depuración syscall anal
[0x08048320]> k bin / ** fd.6
[0x08048320]> k bin / fd.6 / * arcos = 0: 0: x86:
32
El archivo correspondiente a la sexta descriptor de archivo es un archivo binario x86_32.
[0x08048320]> k anal / meta / * meta.s.0x80484d0 = 12,
SGVsbG8gd29ybGQ = [...]
[0x08048320]>? B64- SGVsbG8gd29ybGQ = Hola mundo
Las cadenas se almacenan codificado en base64.
Más ejemplos
espacios de nombres de la lista
** k
Lista de sub-espacios de nombres
k anal / **
89
SDB
Las teclas de lista
k*
anal k / *
Establecer una clave
k foo = bar
Obtener el valor de una clave
foo k
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
90
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. Permite una fácil navegación, 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, utilizar V mando. Para salir de nuevo al mando de línea, pulse q.
Navegación
La navegación se puede hacer usando hjkl o las flechas y las teclas Re Pág / PgDown. También entiende habituales teclas Inicio / Fin. Como
en Vim los movimientos pueden repetirse precediendo la tecla de navegación con el número, por ejemplo 5j se moverá hacia abajo por 5
líneas, o 2l se moverá 2 caracteres correctos.
Los modos de impresión aka paneles
91
modo visual
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
→ Hex-less 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
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
% en el modo de cursor encuentra pares, o autoblocksz toggle
@ actualización de la pantalla cada 1s (vista multiusuario)
^ buscará el principio de la función
! 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
\ el modo de separación visual de palanca
" 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])
, expediente 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)
Automóvil club británico código ssemble, visual (A) ssembler
segundo navegar por los símbolos, banderas, configuraciones, clases, ...
segundo punto de interrupción de palanca
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)
92
modo visual
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 asm.pseudo de palanca y 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 el modo / cursor de examinar los comentarios
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
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
93
visual Desmontaje
Navegación visual
Desmontaje
Desplazarse dentro del desmontaje utilizando las teclas de flecha o hjkl. Utilizar o a buscar directamente a una bandera o una compensación, escribirla
cuando sea solicitado por el símbolo: [ desplazamiento]>. Siga un salto o una llamada utilizando el número de su teclado [ 0-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 libc_start_main sym.imp .__ y por 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
. . .
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 usar re
seguido por yo a continuación, elija lo que la base para trabajar, esto es el equivalente a ahi:
94
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 con el - w
opción. De 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, pulse F e introduzca 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, pulse yo e 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, separarlos con
punto y coma,; .
95
visual Desmontaje
REFX
Cuando radare2 ha descubierto un XREF durante el análisis, se le mostrará la información en el Visual Desmontaje utilizando REFX
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.
pantalla argumento de la función
Para habilitar este uso VEW esta configuración var e dbg.funcarg = true
96
visual Desmontaje
Añadir un comentario
Para agregar un comentario de prensa; .
Escribir otros comandos
Tipo rápidamente a los comandos usando: .
Buscar
97
visual Desmontaje
/: 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 activityspecific puede ser más útil.
Las "banderas / comentario / funciones / HUD .."
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 mediante el mi mando.
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 el mi 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, seleccione asm de la lista, navegue hasta el
elemento que desea modificar, y luego seleccionarlo pulsando Enter. Si el artículo es una variable booleana, ésta cambia, de lo
contrario se le pedirá para proporcionar un nuevo valor.
98
visual Desmontaje
interruptor Ejemplo de seudo desmontaje:
99
visual Desmontaje
100
visual Desmontaje
Los siguientes son algunos ejemplos de variables eval relacionados con el desmontaje.
101
visual 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 =?
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%
102
visual Desmontaje
asm.describe: mostrar una descripción de código de operación
e asm.describe = true
0x00404870 ebp xor, ebp; lógica exclusiva o 0x00404872 r9 mov, RDX
; mueve los datos de src a dst
RSI pop 0x00404875 ; pops último elemento de la pila y almacena el resultado en argumen
0x00404876 RDX mov, RSP; mueve los datos de src a dst
0x00404879 y RSP, -0xf; binaria y operación entre src y dst, tiendas resultan en el horario de verano
103
visual ensamblador
visual ensamblador
Puede utilizar el modo visual para ensamblar código usando A . Por ejemplo vamos a reemplazar el empujar por una JMP:
Observe la vista previa del desmontaje y flechas:
104
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.
105
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.
106
interruptor Ejemplo de seudo desmontaje:
107
108
Los paneles visuales
Concepto paneles
visuales
Paneles visual se caracterizan por las siguientes funcionalidades básicas:
1. Pantalla dividida
2. visualizar las pantallas múltiples, tales como símbolos, registros, pila, así como paneles personalizados
3. Menú cubrirá todos los comandos de uso común para usted de modo que usted no tiene que memorizar alguna de ellas
CUI se reunió con algunos GUI útil como el menú, que es paneles visuales.
Los paneles se pueden acceder desde el modo visual mediante el uso de! .
Visión general
comandos
109
| Visuales paneles ASCII Art: | |
dividir el panel actual verticalmente
|- dividir el panel actual horizontalmente
|: r2 orden de marcha en el símbolo
|_ iniciar el modo de HUD
|? mostrar esta ayuda
| ?? mostrar el HUD fácil de usar
|! ejecutar el juego r2048
|. tratar de PC o punto de entrada
|* mostrar pseudo código / r2dec en el panel actual
|/ resaltar la palabra clave
| [1-9] siguen JMP / llamada identificada por acceso directo (similares; [1]) | ''
(espacio) gráfico de palanca / paneles
| lengüeta ir al siguiente panel
| segundo navegar por los símbolos, banderas, configuraciones, clases, ...
| do cursor de palanca
| do el color de palanca
| re definir en la dirección actual. Igual que Vd
| re espectáculo de desmontaje en el panel actual
| mi cambiar el título y dominio de panel actual
| sol Gráfico de la demostración en el panel actual
| yo inserte hexagonal
| hjkl moverse (izquierda-abajo-arriba-derecha) | J
paneles de desplazamiento hacia abajo de la página
|K paneles de desplazamiento hacia arriba de la página
| metro seleccione el panel del menú
| METRO abierta Marco Personalizado nueva
| nN crear nuevo panel con el comando dado
|o go / tratar de offset dado
| páginas tratar de scr.nkey siguiente o anterior
|q dejar de fumar, de nuevo a modo visual
|r de palanca jmphints / leahints
| sS paso en / pasar por encima
| uU deshacer / rehacer buscar
|w iniciar el modo de ventana
|V ir al modo de gráfico
|X panel de cierre actual
|z intercambiar panel actual con el primero
Uso básico
Utilizar lengüeta para desplazarse por los paneles hasta llegar al panel de destino. A continuación, utilice hjkl, Al igual que en vim, para desplazar el panel en el que
se encuentra actualmente. Utilizar S y s a pasar por encima de / en, y todos los paneles deben ser actualizados dinámicamente mientras se está depurando. Ya
sea en los paneles de registros o de pila, puede editar
110
los valores mediante la inserción de hex. Esto será explicado despues. mientras que golpea lengüeta puede ayudarle a moverse entre los paneles, se
recomienda utilizar metro para abrir el menú. Como de costumbre, puede utilizar hjkl para moverse por el menú y encontrará un montón de cosas útiles
allí.
Pantalla dividida
| es para el vertical y - es para la división horizontal. Puede eliminar cualquier panel pulsando X .
paneles de división se puede cambiar el tamaño de Modo de ventana, al que se accede con w.
Modo de la ventana de comandos
| Paneles modo de ventana de ayuda: | ?
mostrar esta ayuda
| ?? mostrar el HUD fácil de usar
| Introduzca iniciar el modo Zoom | do
cursor de palanca
| hjkl moverse (izquierda-abajo-arriba-derecha) | JK
cambiar el tamaño de los paneles verticalmente
| HL cambiar el tamaño de los paneles horizontalmente
|q salir del modo de ventana
Editar valores
Ya sea en el panel Registro o pila, puede editar los valores. Utilizar do para activar el modo de cursor y se puede mover el cursor pulsando hjkl, como
siempre. A continuación, golpeó yo , al igual que el modo de inserción de vim, para insertar un valor.
111
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.
112
bytes búsqueda
[0x00000000]> /?
| Uso: [! Bf] / [arg] Buscar cosas (ver 'e ?? búsqueda' para las opciones) | Uso io.va para la búsqueda en espacios
virtuales problema de la no | / 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, modificador de orden
| /! X 00 búsqueda inversa hexa (Encontrar primer byte! = 0x00)
| / + / Bin / sh construir la cadena con trozos
| // Repetir la última búsqueda
| / 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, modificador de orden, seguido de otro comando
| /SEGUNDO buscar las cabeceras RBin reconocidos
| / C JMP [esp] buscar por código asm coincidente con la cadena dada
| / Ce RSP, rbp búsqueda de expresiones Esil coincidente
| /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í
| /F delante de búsqueda, modificador de orden, seguido de otro comando
| / Archivo F [fuera] [sz] búsqueda contenido del fichero de tamaño y desplazamiento
| / G [g] [de] encontrar todos los caminos del gráfico de A a B (/ GG seguimiento saltos, ver search.coun
ty
anal.depth)
| / H [t] [picadillo] [len] encontrar bloque coincidente este hash. ver ph
| / I foo búsqueda de la cadena 'foo' caso ignorando
| / M magicfile buscar a juego Magic File (utilización de bloque)
| /METRO buscar sistemas de archivos conocidos y montarlos de forma automática
| /en] espectáculo de desplazamiento de n instrucciones de retroceso
| /En] mismo que E / S, pero con un repliegue diferente si no nos anal puede ser
ed
| / P patternsize buscar patrón de tamaño dado
| / Patternsize P buscar bloques similares
| [?] / R [erwx] 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-
|/s buscar todas las llamadas al sistema en una región (experimental)
| / 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.
113
bytes búsqueda
114
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, puede utilizar la PD comando
para ver las cadenas almacenadas en las compensaciones marcados por las banderas de este grupo, y tendrán 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 el / w mando:
[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":
115
Búsquedas básicas
[0x00000000]> / \ x7FELF
Pero, si usted está en busca de una cadena de valores hexadecimales, usted es probablemente mejor de utilizar el / X
mando:
[0x00000000]> / x 7F454C46
Una vez que la búsqueda se hace, los resultados se almacenan en el búsquedas espacio de bandera.
[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, utilizar el golpe f- * mando.
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
116
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]; pecify boundarie búsqueda. Los valores admitidos se enumeran en el mar e rch.in = ??
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.align variable se utiliza para limitar válidos resultados de búsqueda a cierta alineación. Por ejemplo, con e search.align = 4 verá sólo los toques que se
encuentran en las compensaciones de 4 bytes alineados.
los search.flags variable booleana indica al motor de búsqueda a los resultados de bandera para que puedan ser referenciados más adelante. Si una
búsqueda actualmente en ejecución se interrumpe con Ctrl-C secuencia de teclado, la posición de búsqueda actual está marcado con search_stop.
117
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.
118
Automatización
Buscar Automatización
los cmd.hit variable de configuración se utiliza para definir un comando radare2 a ser ejecutado cuando una entrada coincidente se
encuentra 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 con .
script de nombre de archivo mando. Por ejemplo:
[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
119
Buscar hacia atrás
buscar hacia atrás
A veces usted quiere encontrar una palabra clave al revés. Esto es, antes de que la corriente de polarización, al hacer esto usted puede buscar hacia atrás y buscar
hacia adelante mediante la adición de algunos search.from / a restricciones o bien utiliza el / segundo mando.
[0x100001200]> / nop
0x100004b15 hit0_0 .STUWabcdefghiklmnopqrstuvwxbin / ls. 0x100004f50 hit0_1
.STUWabcdefghiklmnopqrstuwx1] [archivo. [0x100001200]> / b nop
[0x100001200]> s 0x100004f50p [0x100004f50]> / b
nop
0x100004b15 hit2_0 .STUWabcdefghiklmnopqrstuvwxbin / ls. [0x100004f50]>
Tenga en cuenta que / segundo está haciendo lo mismo que / , Pero al revés, así que lo que si queremos usar / X ¿hacia atrás? Nosotros podemos usar / bx, y lo mismo
ocurre con otros subcomandos de búsqueda:
[0x100001200]> / x 90 0x100001a23
hit1_0 90 0x10000248f hit1_1 90
0x1000027b2 hit1_2 90 0x100002b2e
hit1_3 90 0x1000032b8 hit1_4 90
0x100003454 hit1_5 90 0x100003468
hit1_6 90 0x10000355b hit1_7 90
0x100003647 hit1_8 90 0x1000037ac
hit1_9 90 0x10000389c hit1_10 90
0x100003c5c hit1_11 90
[0x100001200]> / bx 90 [0x100001200]> s
0x10000355b [0x10000355b]> / bx 90
0x100003468 hit3_0 90 0x100003454 hit3_1 90
0x1000032b8 hit3_2 90 0x100002b2e hit3_3 90
0x1000027b2 hit3_4 90 0x10000248f hit3_5 90
0x100001a23 hit3_6 90 [0x10000355b]>
120
Buscar hacia atrás
121
Buscar en la Asamblea
ensamblador Buscar
Si desea buscar un cierto código en ensamblador, También se puede usar / do o / una comandos.
El comando / c JMP [esp] busca la categoría de mnemotécnica de montaje:
[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 eax monta 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
122
La búsqueda de AES Keys
La búsqueda de AES Keys
Gracias a Víctor Muñoz, radare2 ahora cuenta con el apoyo del algoritmo que desarrolló, capaz de encontrar claves AES expandidas
con / California mando. Se busca a partir de búsqueda actual posición hasta la
search.distance límite, o hasta que se 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
123
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 objdump configurado para desmontar para Intel, ARM u otras arquitecturas
soportadas.
Fue un trabajo y una solución amigable de Unix, pero fue ineficaz, ya que repetía las mismas acciones una y otra caros, porque no
había cachés. Como resultado, el desplazamiento era terriblemente lento.
Así que había una necesidad de crear una biblioteca desensamblador genérica para soportar múltiples plugins para diferentes arquitecturas. Podemos enumerar
los plugins cargados con los actuales
$ -L rasm2
O desde el interior radare2:
> e asm.arch = ??
Esto fue muchos años antes de que apareció coronamiento. Así r2 utilizaba udis86 y Olly desensambladores, muchos de GNU (de binutils).
Hoy en día, el apoyo desensamblador es una de las características básicas de radare. Ahora tiene muchas opciones, endianness, incluyendo
sabor arquitectura objetivo y las variantes desensamblador, entre otras cosas.
Para ver el desmontaje, utilizar el pd mando. 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 segundo mando.
[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
124
Desmontaje
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:
[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
488b9424a80. mov RDX, [RSP + 0x2a8]
0x00405e24 64483314252. RDX xor, [FS: 0x28]
0x00405e2d 4889d8 mov rax, RBX
[0x00405e1c]> e asm.syntax = att [0x00405e1c]> pd 3
488b9424a80. mov 0x2a8 (% RSP),% RDX
0x00405e24 64483314252. xor% fs: 0x28, RDX%
0x00405e2d 4889d8 mov% rbx,% rax
125
Adición de metadatos
Adición de metadatos para Desmontaje
El trabajo típico involucrados en la reversión de los archivos binarios hace potentes capacidades de anotación esencial. Radare ofrece varias formas
de almacenar y recuperar dichos metadatos.
Siguiendo los principios básicos comunes de UNIX, es fácil escribir una pequeña utilidad en un lenguaje de script que usa objdump, otool o
cualquier otra utilidad existente para obtener información de un binario y para importar en radare. Por ejemplo, echar un vistazo a idc2r.py enviado
con radare2ida . Para usarlo, invocar como idc2r.py 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 y otros datos. 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
Por favor, tenga en cuenta que la importación de IDA Pro metadatos de volcado IDC es el mecanismo en desuso y puede no funcionar en el
futuro. El método recomendado para hacerlo - el uso python-BID -basado ida2r2.py que abre archivos BID directamente sin IDA Pro instalado.
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.
Hay muchos diferentes comandos de manipulación de metadatos, aquí es la visión de todos ellos:
126
[0x00404cc0]> C?
| Uso: [? *] C [? -LCvsdfm *] [...] gestión de metadatos # | do
Información de la lista meta en forma amigable humana
| DO* Información de la lista de comandos meta r2
| C [Chsdmf] Lista comentarios / oculto / cuerdas / datos / magia / formateado en huma
n forma amigable | C
[Chsdmf] * Lista comentarios / oculto / cuerdas / datos / magia / formateado en r2 c
ommands
| C- [len] [[@] addr] eliminar metadatos en el rango de direcciones dado
| CL [-] [*] [archivo: Línea] espectáculo [dir] o añadir 'código de línea' 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 comentarios única | Cv [BSR] [?]
añadir comentarios a args
| Cs [?] [-] [tamaño] [@addr] agregar una cadena
| Cz [@addr] agregar una cadena (ver Cs?)
| 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] de análisis magia (?
Ver pm)
Basta con añadir el comentario a una determinada línea / en direcciones puede utilizar California mando:
[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. Utilizar el cs
COMAND para definir una cadena, utilice el Discos compactos comando para la definición de una matriz de elementos de datos, y el uso de la
cf comando 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". En primer
lugar, utilizar el cursor para seleccionar un rango de bytes (pulse do tecla 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áscara utilizando el cs mando:
127
[0x00000000]> f string_foo @ 0x800 [0x00000000]> Cs 10 @
string_foo
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]> 16 Cf foo bar 2xi [0x7fd9f13ae630]> pd; -
RIP:
0x7fd9f13ae630 formato de barra de 2xi foo {0x7fd9f13ae630
[0] {
foo: 0x7fd9f13ae630 = 0xe8e78948 barra: 0x7fd9f13ae634 =
14696}
0x7fd9f13ae638 [1] {
foo: 0x7fd9f13ae638 = 0x8bc48949 barra: 0x7fd9f13ae63c =
571.928.325}
} dieciséis
0x7fd9f13ae633 0x7fd9f13b1fa0 e868390000 llamada
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 de datos definida por la cadena de formato. Esto puede parecer confuso, pero tiene varios usos. Por ejemplo, es posible
que desee ver la estructura con 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 la
SZ argumento.
Utilizando cf, es fácil de definir estructuras complejas con oneliners simples. Ver PF? para más
información. Recuerde que todos estos do comandos también se puede acceder desde el modo visual pulsando el d ( conversión de datos) clave.
Tenga en cuenta que a diferencia de t comandos cf no cambia los resultados del análisis. Sólo es una gran ayuda visual.
A veces, sólo la adición de una sola línea de comentarios no es suficiente, en este caso radare2 le permite crear un vínculo para un archivo de
texto en particular. Se puede utilizar con CC, mando o pulsando , Clave en el modo visual. Esto abrirá un $ EDITOR para crear un nuevo archivo, o si
existe el nombre de archivo, se acaba de crear un enlace. Se verá en los comentarios de desmontaje:
128
[0x00003af7 11% 290 / bin / ls]> pd $ r @ principal + 55 # 0x3af7 sym.imp.setlocale │0x00003af7
llamada ; [1]; , (Locale-help.txt); char * setlocale (i
nt categoría, const char * locale)
│0x00003afc RSI lea, str.usr_share_locale; 0x179cc; "/ Usr / share / locale" RDI │0x00003b03 lea, [0x000179b2]
; "coreutils"
llamada │0x00003b0a sym.imp.bindtextdomain; [2]; char * bindtextdomain (char * nombre de dominio, char * nombredir)
Nota , ( locale-help.txt) aparecido en los comentarios, si apretamos , de nuevo en el modo visual, se abrirá el archivo. El uso de este mecanismo
podemos crear unas largas descripciones de algunos lugares en particular en el desmontaje, hojas de datos de enlace o artículos relacionados.
129
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 empujar! ¿No es genial? El objetivo es ser capaz de expresar la mayoría de las operaciones
comunes realizadas por CPUs, como operaciones aritméticas binarias, cargas de memoria y tiendas, llamadas al sistema de procesamiento. De esta
manera si podemos transformar las instrucciones para ESIL podemos ver lo que hace un programa mientras se está ejecutando incluso para las
arquitecturas más crípticos que definitivamente no tiene un dispositivo para depurar el.
usando ESIL
130
ESIL
de modo visual R2 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 = true # asm.emustr para la versión 2.2 y anteriores [0x00000000]> e = true # asm.emu.str para la
versión 2.3 y anteriores
asm.emu dice R2 si desea información ESIL que se mostrará. Si se establece en true, podrás ver los 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 el emu.str variable es para ( asm.emustr en
2.2 y anteriores). 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 es importante 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.
131
ESIL
[0x00000000]> aes
[0x00000000]> 10aes
"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 Código
operandos Nombre Operación ejemplo
de operación
TRAMPA src Trampa señal de trampa
PS src syscall syscall
Obtener la dirección de la
dirección de la pila instrucción actual =

$$ src
instrucción dirección de la instrucción
apilar = (dst == src);

update_eflags (dst
== src, dst Comparar
- src)
apilar = (dst <src) [0x0000000]> "ae 1,5, <"

Menor
132
ESIL
< src, dst (Comparación con update_eflags (dst 0x0

signo) - src) > "Ae 5,5"
0x0"
[0x0000000]> "ae 1,5, <"

apilar = (dst <= src);
Menor o 0x0
update_eflags (dst
<= src, dst Igualdad (comparación
firmado) > "Ae 5,5"

- src) 0x1"
apilar = (dst> src); > "Ae 1,5,>" 0x1

Más grande
> src, dst
(comparación firmado) update_eflags (dst > "Ae 5,5,>" 0x0
- src)
pila = (dst> = src); > "Ae 1,5,> =" 0x1

Más grande o
update_eflags (dst
>= src, dst Igualdad (comparación
> "Ae 5,5,> =" 0x1
firmado)
- src)
> "Ae 1,1, <<" 0x2
<< src, dst desviación a la izquierda pila = DST << src

> "Ae 2,1, <<" 0x4
> "Ae 1,4, >>" 0x2
>> src, dst desplazamiento a la derecha apilar = DST >> src

> "Ae 2,4, >>" 0x1
> "Ae 31,1, <<<"

0x80000000
<<< src, dst Girar a la izquierda apilar = dst ROL src
> 0x1 "ae 32,1, <<<"
> "Ae 1,1, >>>"

0x80000000
>>> src, dst Gira a la derecha pila = dst ROR src
> 0x1 "ae 32,1, >>>"
> "Ae 1,1, y" 0x1
> "Ae 1,0, y" 0x0
y src, dst Y apilar = dst & src

> "Ae 0,1, y" 0x0
> "Ae 0,0, y" 0x0
> "Ae 1,1, |" 0x1
133
ESIL
> "Ae 1,0, |" 0x1
| src, dst O apilar = DST | src

> "Ae 0,1, |" 0x1
> "Ae 0,0, |" 0x0
> "Ae 1,1, ^" 0x0
> "Ae 1,0, ^" 0x1
^ src, dst XOR pila = dst ^ src

> "Ae 0,1, ^" 0x1
> "Ae 0,0, ^" 0x0
> "Ae 3,4, +" 0x7
+ src, dst AÑADIR apilar = dst + src

> "Ae 5,5, +" 0xa
> "Ae 3,4, -" 0x1
> "Ae 5,5, -" 0x0

- src, dst SUB apilar = dst - src
> "Ae 4,3, -"

0xffffffffffffffff
> "Ae 3,4, *" 0xc
* src, dst MUL apilar = DST * src

> "Ae 5,5, *"
0x19
> "Ae 2,4, /" 0x2
> "Ae 5,5, /" 0x1

/ src, dst DIV apilar = dst / src
> "Ae 5,9, /" 0x1
> "Ae 2,4,%" 0x0
> "Ae 5,5,%" 0x0

% src, dst MOD apilar = dst% src
> "Ae 5,9,%" 0x4
> "Ae 1 ,!"

0x0
> "Ae 4 ,!"

0x0
! src NEG apilar = src !!!
134
ESIL
> "Ae 0 ,!"

0x1
> Ar r_00 = 0; ar r_00

0x00000000
> "Ae r_00, ++" 0x1
++ src CÍA apilar = src ++

> Ar r_00
0x00000000
> "Ae 1, ++" 0x2
> Ar r_00 = 5; ar r_00

0x00000005
> "R_00 ae, -" 0x4
-- src DIC apilar = src--

> Ar r_00
0x00000005
> "Ae 5, -" 0x4
> "Ae 3, r_00, ="

> Aer
0x00000003
r_00
= src, reg EQU reg = src
> "Ae r_00, r_01, ="
> Aer
0x00000003
r_01
> ar r_01 = 5; ar
r_00 = 0; ar r_00
0x00000000
> "Ae r_01, r_00, + ="
+= src, reg AÑADIR eq reg = reg + src > Ar r_00
0x00000005
> "Ae 5, r_00, + ="

> Ar r_00
0x0000000a
> "Ae r_01, r_00, - ="

> Ar r_00
0x00000004
-= src, reg eq SUB reg = reg - src
> "Ae 3, r_00, - ="
> Ar r_00
0x00000001
> ar r_01 = 3; ar
r_00 = 5; ar r_00
0x00000005
> "R_01 ae, r_00, * ="
*= src, reg eq MUL reg reg = * src > Ar r_00
0x0000000F
135
ESIL
> "Ae 2, r_00, * ="

> Ar r_00
0X0000001E
> ar r_01 = 3; ar
r_00 = 6; ar r_00
0x00000006
> "Ae r_01, r_00, / ="
/= src, reg eq DIV reg = reg / src > Ar r_00
0x00000002
> "Ae 1, r_00, / ="

> Ar r_00
0x00000002
> ar r_01 = 3; ar
r_00 = 7; ar r_00
0x00000007
> "Ae r_01, r_00,% ="
> Ar r_00
0x00000001
%= src, reg eq MOD reg = reg% src
> Ar r_00 = 9; ar r_00
0x00000009
> "Ae 5, r_00,% ="

> Ar r_00
0x00000004
> ar r_00 = 1; ar
r_01 = 1; ar r_01
0x00000001
> "Ae r_00, r_01, << ="
<< = src, reg Desviación a la izquierda eq reg = reg << src > Ar r_01
0x00000002
> "Ae 2, r_01, << ="

> Ar r_01
0x00000008
> ar r_00 = 1; ar
r_01 = 8; ar r_01
0x00000008
> "Ae r_00, r_01, >> ="
>>= src, reg Shift derecho eq reg = reg << src > Ar r_01
0x00000004
> "Ae 2, r_01, >> ="

> Ar r_01
0x00000001
> ar r_00 = 2; ar
r_01 = 6; ar r_01
0x00000006
> "Ae r_00, r_01, y ="
> R_01 ar
136
ESIL
> Ar r_01
y= src, reg Y eq reg = reg & src 0x00000002
> "Ae 2, r_01, y ="

> Ar r_01
0x00000002
> "Ae 1, r_01, y ="

> Ar r_01
0x00000000
> ar r_00 = 2; ar
r_01 = 1; ar r_01
0x00000001
> "R_00 ae, r_01, | ="
|= src, reg O eq reg = reg | src > Ar r_01
0x00000003
> "Ae 4, r_01, | ="

> Ar r_01
0x00000007
> ar r_00 = 2; ar
r_01 = 0xab; ar r_01
0x000000ab
> "Ae r_00, r_01, ^ ="
^= src, reg eq XOR reg = reg ^ src > Ar r_01
0x000000a9
> "Ae 2, r_01, ^ ="

> Ar r_01
0x000000ab
> Ar r_00 = 4; ar r_00

0x00000004
++= reg eq INC reg = reg + 1 > "Ae r_00, ++ ="

> Ar r_00
0x00000005
> Ar r_00 = 4; ar r_00

0x00000004
-- = reg eq diciembre reg = reg - 1 > "Ae r_00, - ="

> Ar r_00
0x00000003
> Ar r_00 = 4; ar r_00

0x00000004
> "Ae r_00,! ="

> Ar r_00
!= reg NO eq reg =! reg 0x00000000
> "Ae r_00,! ="

> Ar r_00
0x00000001
---------------------------
--- --- --- ---
137
ESIL
> "ae
0xLOQUESEA, 0x10000, = [4],"
= [] =
> PXW 4 @ 0x10000
[*] = 0x00010000
[1] = 0xLOQUESEA ....
src, dst meter * Dst = src
[2] =
[4] =
> "Ae 0x0,0x10000, = [4],"
[8]
> PXW 4 @ 0x10000

0x00010000 0x00000000
> W @ prueba 0x10000
[] [*]
[1] > "Ae 0x10000, [4],"
0x74736574
[2]
src ojeada apilar = * src
[4]
[8] > Ar r_00 = 0x10000
> "Ae r_00, [4],"

0x74736574
| = [] | =
[1] | =
>
[2] | = reg nombre código
>
[4] | =
[8]
Intercambiar dos parte superior

INTERCAMBIAR Intercambiar INTERCAMBIAR
elementos
Escoja elemento n-ésimo de la
RECOGER norte Recoger parte superior de la pila 2, Pick
Escoja n-ésimo
RPICK metro Selección inversa elemento de la base de 0, RPICK
la pila
Duplicar parte superior

DUP Duplicar DUP
elemento en la pila
Si la alta elemento es una

referencia (registro
nombre,
138
ESIL
eliminar la referencia y
empujar su valor real
CLARO Claro claro pila CLARO
paradas ESIL
DESCANSO Descanso DESCANSO
emulación
saltos a enésima
IR norte Ir GOTO 5
palabra ESIL
Detiene la ejecución
(razón: ESIL
QUE HACER Que hacer QUE HACER
expresión no
terminado)
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 borro
w 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, =
139
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.
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, la implementación actual funciona así:
140
ESIL
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.
Las trampas se implementan con el TRAMPA mando. Se utilizan para lanzar excepciones de instrucciones no válidas, la división por cero, la memoria
Error de lectura, o cualquier otra necesaria para arquitecturas específicas.
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 ( "= [") -> escritura 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 indexOf ( '-') -> cuenta a cero indexOf ( "{?")
-> equalsTo condicional ( "")
- > cadena vacía, también conocido como nop (mal, si añadimos la PC + = x)
las operaciones más comunes:
Compruebe dstreg
comprobar srcreg
Obtener destinaion Es
salto
Está condicionada
Evaluar
141
ESIL
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.
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 "!"
142
ESIL
6. ROL "<<<"
7. ROR ">>>"
8. NEG "!"
Floating Point Unidad de Apoyo
En el momento de escribir estas líneas, ESIL todavía no soporta la FPU. Pero se puede implementar el soporte para instrucciones no compatibles utilizando
r2pipe. Con el tiempo vamos a obtener el soporte adecuado para aplicaciones multimedia y de punto flotante.
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:
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'. Actúan 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:
143
ESIL
[0x1000010f8]> e asm.esil = true [0x1000010f8]> pd $
r @ Entry0 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, =
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 una 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
destino de un salto
144
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 el analizador, por lo que se puede extender a aplicar el análisis sin tener
que cambiar una 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
por ejemplo para determinar si DEP va a cambiar, o si la instrucción actualiza la pila. Más tarde, podemos dividir esa devolución de llamada en
varios más para tener una API análisis eventbased que puede ser extendido en JavaScript como esto:
esil.on ( 'regset', function () {..
esil.on ( 'syscall', function () {esil.regset ( 'RIP'
Para el API en las funciones hook_flag_read (), hook_execute () y hook_mem_read (). Una devolución de llamada debe devolver verdadero o 1 si
desea anular la acción que se necesita. 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 requieren enlaces con funcionalidades externas al trabajo. En este caso, r_ref y r_io.
Esto se debe definir al inicializar la ESIL VM.
Io Get / Set
hacha, 44
44, hacha,: ou
Selectores (cs, ds, gs ...)
eax Mov, ds: [ebp + 8] Ebp, 8, + ,:
ds, eax, =
145
Análisis
Datos y análisis de código
Radare2 tiene un muy amplio conjunto de comandos y opciones de configuración para llevar a cabo el 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 cruzadas y
mucho más. Estas operaciones son manejadas por el una ( analizar) de la familia de comandos:
| Uso: un [abdefFghoprxstc] [...] | Automóvil club
británico[?] analizar todos (fcns + bbs) (AA0 para evitar sub cambio de nombre)
| a8 [hexpairs] analizar los bytes
| ab [b] [addr] analizar bloque en dirección dada
| abb [len] analizar N bloques básicos en [len] (section.size por defecto)
| ABT [addr] encontrar caminos en el gráfico de la función de desplazamiento actual bb al anuncio dado
vestido
| 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 [?] analizar Funciones
| aF Igual que el anterior, pero utilizando anal.depth = 1
| ag [?] [opciones] dibujar gráficos en varios formatos
| 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, ...)
| un [nombre] [@addr] mostrar / renombrar / crear cualquier bandera / función se utiliza en addr | ao [?] [len]
analizar Opcodes (o emular)
| aO [?] [len] Analizar N instrucciones en M bytes
| ap encontrar preludio de desplazamiento actual
| Arkansas[?] como 'doctor', pero para el vm esil. (registros)
| como [?] [num] analizar usando syscall dbg.reg
| av [?] [.] Mostrar vtables
| hacha[?] gestionar árbitros / referencias externas (véase también AFX?)
De hecho, una espacio de nombres es una de las más grandes de herramienta radare2 y permite controlar muy diferentes partes del análisis:
flujo Código referencias análisis de los
datos El análisis usando símbolos
cargados
La gestión de diferentes tipos de gráficos, como CFG y gráfico de llamadas Manejo de las
variables Administrar tipos
Emulación usando ESIL VM
146
Análisis
la introspección de código de operación
Información sobre objetos, como tablas virtuales
147
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.
Radare2 tiene diferentes técnicas de análisis de código implementados en el núcleo y disponibles en diferentes órdenes.
Mientras el conjunto de funcionalidades de r2 están disponibles con la API, así como el uso de comandos. Esto le da la capacidad de
implementar su propio análisis de bucles utilizando cualquier lenguaje de programación, incluso con oneliners r2, shellscripts, o análisis o plugins
nativos centrales.
El análisis mostrará las estructuras de datos internas para identificar bloques básicos, árboles de funciones y para extraer información a nivel de código de
operación.
La secuencia de comandos análisis radare2 más común es aa, que significa "analizar todos". Que todo se refiere a todos los símbolos
y puntos de entrada. Si se elimina el binario que tendrá que utilizar otros comandos como AAA, AAB, AAR, aac más o menos.
Tómese su tiempo para entender lo que hace cada comando y los resultados después de ejecutar ellos para encontrar la mejor opción para sus necesidades.
[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
| ; CÓDIGO (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)
148
| 0x0804868a 85c0 eax prueba, eax
| , = <0x0804868c 7911 jns 0x804869f
| | 0x0804868e c70424cf870. mov dword [esp], str.Don_tuseadebuguer_; 0x080487cf
| | 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.Youmustgiveapasswordforusethisprog
RAM_ ; 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
| 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 jubilado
En este ejemplo, se analiza todo el archivo ( aa) y luego imprimir el desmontaje de la principal() función ( pdf). los Automóvil club británico comando pertenece
a la familia de los comandos de análisis de automóviles y sólo tendrá la mayor cantidad de pasos básicos de análisis automático. En radare2
hay muchos tipos diferentes de los comandos de análisis automático con una profundidad de análisis diferente, incluyendo emulación parcial: AA,
AAA, AAB, AAAA, ... También hay un mapeo de esas órdenes a las opciones r2 de la CLI: r2 -A, r2 -AA, y así.
Es un sentido común que el análisis totalmente automatizado puede producir resultados no Sequitur, así radare2 proporciona comandos
separados para las etapas particulares del análisis que permite el control de grano fino del proceso de análisis. Por otra parte, hay un
tesoro de variables de configuración para el control de los resultados de análisis. Los puedes encontrar en anal.* y emú.* espacios de nombres
de variables cfg.
Uno de los comandos de análisis más importantes "básicas" es el conjunto de af subcomandos. af significa "función Analizar".
Usando este comando puede o permitir el análisis automático de la función particular o realizar uno completamente manual.
149
[0x00000000]> af? | Uso: af
| af ([nombre]) ([addr]) analizar las funciones (o comienzan en addr $$)
| AFR ([nombre]) ([addr]) analizar las funciones de forma recursiva
| af + addr nombre [tipo] [diff] arte de la mano una función (requiere AFB +) | AF [addr]
limpia todos los datos de análisis de la función (o función en addr)
| AFB + FCNA BBA sz [j] [f] ([T] ([d])) añadir bb a la función @ fcnaddr | AFB [?] [dir]
Listar los bloques básicos de la función dada
| AFB 16 ajustar la función actual como pulgar (asm.bits cambio)
| AFC [LC] ([dir]) @ [dir] calcular los ciclos (AFC) o Ciclomática Complejidad (AFCC) | AFC [?] type @ [dir]
establecer el convenio de llamada para la función
| afd [addr] mostrar la función + delta para offset dado
| aff volver a ajustar los límites de funciones para adaptarse
| aff [1 | 0 |] plegar / desplegar / toggle
| afi [addr | fcn.name] función de presentación (s) información (AFL detallado)
| AFL [l *] [FCN] funciones de lista de nombres (dir, tamaño, bbs, nombre) (ver afll) [?] | nombre del AFM
combinar dos funciones
| nombre del AFM funciones de impresión mapa
| AFN [?] nombre [dir] renombrar el nombre de la función en la dirección (indicador de cambio también)
| afna sugerir nombres automática de desplazamiento actual
| afo [fcn.name] Dirección del espectáculo para la función llamada como esto
| AFS [addr] [fcnsign] obtener / establecer firma de función en la dirección actual
| AFS [STACK_SIZE] establecer el tamaño de marco de pila para la función en la dirección actual
| en popa[?] Tipo de juego, el tipo de propagación
| Afu [addr] cambiar el tamaño y analizar la función de la dirección actual hasta addr
| AFV [BSRA]? manipular args, registros y variables en función de
| AFX referencias de las funciones lista
Algunas de las tareas más difíciles mientras realiza un análisis de la función son unir, cortar y cambiar el tamaño. Al igual que con otros
comandos de análisis tiene dos modos: semi-automático y manual. Para el semiautomática, puede utilizar AFM <nombre de función> para
combinar la función actual por el especificado por el nombre como un argumento, aff para reajustar la función después de los cambios de
análisis o ediciones de función, Afu
<Dirección> para hacer el cambio de tamaño y el análisis de la función actual hasta la dirección especificada.
Aparte de esos modos semiautomáticos para editar / analizar la función, puede arte de la mano en el modo manual con af + mando y
editar bloques básicos de la misma utilizando AFB comandos. Antes de cambiar los bloques básicos de la función que se recomienda
comprobar los ya presentados los:
[0x00003ac0]> AFB
0x00003ac0 0x00003b7f 01: 001A 191 f 0x00003b7f 0x00003b7f 0x00003b84 00: 0000 5 j 0x00003b92 f
0x00003b84 0x00003b84 0x00003b8d 00: 0000 9 f 0x00003b8d 0x00003b8d 0x00003b92 00: 0000 5
0x00003b92 0x00003ba8 01: 0030 22 j 0x00003ba8 0x00003ba8 0x00003bf9 00:
0000 81
150
Hay dos comandos muy importantes para esto: AFC y AFB. Este último es un comando debe de conocer algunas plataformas como ARM.
Proporciona una manera de cambiar el "valor de bits" de la función en particular. Básicamente, lo que permite seleccionar entre los modos de
pulgar ARM y.
AFC por otro lado, permite especificar manualmente convención de llamada función. Puede encontrar más información sobre su uso
en calling_conventions .
El análisis recursivo
Hay 4 importantes ancho comandos análisis de media automatizado programa:
aab - realizar análisis-bloque básico ( "Nucleus" algoritmo)
aac - analizar las llamadas de función de uno (función seleccionada o corriente)
aaf - analizar todas las llamadas a funciones
AAR - analizar las referencias de datos
aad - analizar los punteros a punteros referencias
Esos son solamente los algoritmos de búsqueda de referencia semi-automatizados genéricos. Radare2 ofrece una amplia selección de la creación de cualquier
tipo referencias manuales. Para este control de grano fino se puede utilizar hacha comandos.
| Uso: [? Dl *] hacha # consulta 'AFX?' | hacha
lista refs
| hacha* radare comandos de salida
| hacha addr [at] agregar código ref señalando addr (de curseek)
| AX [at] limpiar todas las refs / árbitros de addr
| hacha-* limpiar todas las refs / refs
| axc addr [at] añadir ref código genérico | addr AXC [at] añadir código
de llamada ref | AXG [addr]
Mostrar conexiones referencias externas para llegar a la función actual
| axgj [addr] Mostrar conexiones referencias externas para llegar a la función actual en formato JSON
| addr AXD [at] añadir los datos ref | AXQ
refs listado en formato tranquila / legible
| AXJ árbitros de la lista en formato JSON
| axf [flg-glob] encontrar datos / referencias de códigos de banderas | axt [addr]
encontrar referencias de datos / código a esta dirección
| axf [addr] encontrar datos / referencias de código de esta dirección
| addr AXS [at] añadir ref string
El más utilizado hacha son comandos axt y axf, especialmente como parte de diversos guiones r2pipe. Digamos que vemos la cadena en los datos
o una sección de código y queremos encontrar todos los lugares que se hace referencia desde, debemos utilizar axt:
151
[0x0001783a]> pd 2; - str.02x:
; XREF STRING de 0x00005de0 (sub.strlen_d50); CÓDIGO XREF de 0x00017838
(str .._ s_s_s + 7) 0x0001783a
. cadena "%%% 02x"; len = 7
; - str.src_ls.c:
; STRING XREF de 0x0000541b (sub.free_b04)
; STRING XREF de 0x0000543a (sub .__ assert_fail_41f + 27); XREF STRING de 0x00005459 (sub .__
assert_fail_41f + 58); XREF STRING de 0x00005f9e (sub._setjmp_e30); CÓDIGO XREF de 0x0001783f
(str.02x + 5) 0x00017841 .string "src / ls.c"; len = 9 [0x0001783a]> axt
sub.strlen_d50 0x5de0 [STRING] lea rcx, str.02x (nofunc) 0x17838 [CÓDIGO] str.02x
jae
Aparte de algoritmos predefinidos para identificar las funciones que hay una forma de especificar un preludio función con una opción de
configuración anal.prelude. Por ejemplo, como e anal.prelude = 0x554889e5 lo que significa
empujar RBP mov
RBP, RSP
en la plataforma x86_64. Conviene precisar antes de comandos de cualquier análisis.
Configuración
Radare2 permite cambiar el comportamiento de casi cualquier etapas de análisis o comandos. Hay diferentes tipos de opciones de
configuración:
Control de flujo
Las referencias básicas bloques
de control controlan IO / Rangos
Opciones específicas de control de salto análisis
de tablas de plataforma / destino
configuración de flujo de control
Dos opciones más comúnmente utilizadas para cambiar el comportamiento de análisis de flujo de control en radare2 son
anal.hasnext y anal.afterjump. El primero permite forzar radare2 para continuar el análisis después del final de la función, incluso si la
siguiente parte del código no fue llamado en cualquier lugar, por lo tanto el análisis
152
todas las funciones disponibles. Este último permite forzar radare2 para continuar el análisis, incluso después de saltos incondicionales.
Además de los que también podemos establecer anal.ijmp seguir los saltos indirectos, análisis continuo;
anal.pushret analizar empujar ...; jubilado secuencia como un salto; anal.nopskip para omitir las secuencias de NOP en un principio de
función.
Por ahora, radare2 también le permite cambiar el tamaño máximo del bloque básico con anal.bb.maxsize
opción . El valor por defecto simplemente funciona en la mayoría de los casos de uso, pero es útil para aumentar la que, por ejemplo, cuando se trata de código
ofuscado. Ten en cuenta que algunas de las opciones básicas de bloques de control pueden desaparecer en un futuro a favor de formas más automatizado para
configurar los.
Para algunos binarios o metas inusuales, hay una opción anal.noncode. Radare2 no trata de analizar las secciones de datos como un código por defecto. Sin
embargo, en algunos casos -, binarios empaquetados de malware, binarios para sistemas embebidos, a menudo es un caso. Por lo tanto - esta opción.
control de referencia
Las opciones más importantes que cambian drásticamente los resultados del análisis. A veces, algunos se puede desactivar para ahorrar el tiempo y la
memoria al analizar grandes binarios.
anal.jmpref - para permitir la creación de referencias para los saltos incondicionales
anal.cjmpref - mismo, pero para los saltos condicionales
anal.datarefs - seguir las referencias de datos en código
anal.refstr - buscar cadenas en las referencias de datos
anal.strings - búsqueda de cadenas y la creación de referencias
Tenga en cuenta que el control de cadenas de referencias está desactivado por defecto, ya que aumenta el tiempo de análisis.
gamas de análisis
Hay algunas opciones para esto:
anal.limits - permite que los límites del rango para las operaciones de análisis
anal.from - dirección de inicio de la gama límite
anal.to - el extremo correspondiente de la gama de límite
anal.in - especificar los límites de búsqueda para el análisis ( io.maps, io.sections.exec, dbg.maps
y muchos más - véase e anal.in =? para la lista completa)
tablas de salto
153
tablas de salto son uno de los objetivos más difíciles en la ingeniería inversa binaria. Hay cientos de diferentes tipos, el resultado final en función de las
fases del compilador / enlazador y LTO de optimización. Por lo tanto radare2 permite habilitar algunas tablas de saltos de algoritmos de detección
experimentales utilizando anal.jmptbl opción. Con el tiempo, los algoritmos se movieron en el análisis por defecto bucles una vez que empiezan a trabajar en
todas las plataformas / target / caso_prueba compatible. Dos opciones más pueden afectar a las tablas de saltos de análisis de los resultados también:
anal.ijmp - seguir los saltos indirectos, algunas tablas de salto dependen de ellos
anal.datarefs - siga las referencias de datos, algunas tablas de salto utilizan los
controles específicos de la plataforma
Hay dos problemas comunes al analizar objetivos embebidos: / detección del pulgar ARM y MIPS valor GP. En el caso de los binarios de
ARM radare2 soporta algunas detección automática de los interruptores de modo ARM / pulgar, pero cuidado que utiliza la emulación
parcial ESIL, frenando así el proceso de análisis. Si no te gusta el resultado, el modo de funciones particulares se puede reemplazar con AFB
mando.
El problema MIPS GP es aún más difícil. Es un conocimiento básico de que el valor GP puede ser diferente no sólo para todo el programa, sino
también para algunas funciones. Para resolver parcialmente que hay opciones anal.gp
y anal.gp2. El primero establece el valor médico de cabecera para todo el programa o función en particular. Este último permite "constantify" el valor
médico de cabecera si algún código está dispuesto a cambiar su valor, siempre reiniciarlo si el caso. Esos son en gran medida experimental y
podría cambiar en el futuro a favor de los análisis más automatizado.
visuales
Uno de la forma más fácil de ver y comprobar los cambios de los comandos de análisis y las es llevar a cabo un desplazamiento en una vv el modo visual
especial, lo que permite una vista previa de las funciones:
Cuando queremos comprobar cómo los cambios afectan el resultado del análisis en el caso de las grandes funciones, podemos utilizar minimapa lugar, lo que permite
ver un gráfico de flujo más grande en el mismo tamaño de pantalla. Para entrar en el modo de tipo mini mapa VV entonces presione pag dos veces:
154
Este modo le permite ver el desmontaje de cada nodo separado, simplemente navegar entre ellas el uso de
Lengüeta llave.
consejos de análisis
No es un caso poco común de que los resultados del análisis no son perfectos, incluso después de que ha intentado todas las opciones de configuración única. Aquí es
donde el "indicios de análisis" mecanismo de radare2 entra en acción. Permite para anular algunas de las propiedades básicas de código de operación o
meta-información, o incluso volver a escribir toda la cadena de código de operación. Estos comandos se encuentran debajo ah espacio de nombres:
155
| Uso: ah [lba-] Análisis Consejos | ah?
mostrar esta ayuda
| ah? compensar muestran indicio de offset dado
| ah consejos de lista en formato legible
| ah. consejos de lista en formato legible a partir local actual
| AH eliminar todos los consejos
| AH compensar [tamaño] alude a eliminar offset dado | ah * compensado
Lista insinúa en radare comandos de formato
| AHA ppc 51 establecer arco para una gama de N bytes
| AHB 16 @ $$ 16bit fuerza para la instrucción en curso
| AHC 0x804804 llamada sustitución de dirección / salto
| Ahe 3, eax, + = El análisis conjunto de cadena vm
| AHF 0x804840 invalidar la dirección de retorno para la llamada
| ahh 0x804840 poner de relieve este desplazamiento en disasm adrress
| ahi [?] 10 definir base numérica para immediates (1, 8, 10, 16, s)
| AHJ consejos de lista en JSON
| aho foo a0,33 reemplazará la cadena de código de operación
| addr AHP juego de pista puntero
| Ahr val sugerencia para establecer el valor de retorno de una función
| AHS 4 tamaño del conjunto de código de operación = 4
| JZ AHS establecer asm.syntax = jz para este código de operación
Uno de los casos más comunes es la de establecer una base numérica particular para immediates:
[]> 0x00003d54 ahi?
| Ahi Uso [sbodh] [@ compensados] Definir base numérica | ahi [base] establecer base
numérica (1, 2, 8, 10, 16) | ahi b
base del conjunto a binario (2)
| d ahi base del conjunto a decimal (10)
| ahi h base del conjunto a hexadecimal (16)
| ahi o base del conjunto a octal (8)
| ahi p base del conjunto a htons (puerto) (3)
| i ahi base del conjunto de dirección IP (32)
| ahi S base del conjunto a syscall (80)
| ahi s base del conjunto de cadena (1)
[0x00003d54]> pd 2 0x00003d54
0583000000 add eax, 0x83
0x00003d59 3d13010000 cmp eax, 0x113
[0x00003d54]> ahi d
[0x00003d54]> pd 2 0x00003d54
0583000000 add eax, 131
0x00003d59 3d13010000 cmp eax, 0x113
[0x00003d54]> ahi b
[0x00003d54]> pd 2 0x00003d54
0583000000 add eax, 10000011b
0x00003d59 3d13010000 cmp eax, 0x113
156
Es notable que algunas etapas de análisis o comandos agregan los consejos de análisis internos, que se pueden comprobar con ah mando:
[0x00003d54]> ah
0x00003d54 - 0x00003d54 => immbase = 2 [0x00003d54]> ah *
ahi 2 @ 0x3d54
A veces tenemos que anular salto o dirección de llamada, por ejemplo en caso de reubicación complicado, que es desconocida para radare2, por lo
tanto podemos cambiar el valor manualmente. El análisis de la información actual acerca de un código de operación particular, se puede comprobar con ao
mando. Nosotros podemos usar AHC comandos para realizar tal cambio:
157
[0x00003cee]> pd 2 0x00003cee
e83d080100 sub llamada .__ errno_location_530
0x00003cf3 85c0 eax prueba, eax
[0x00003cee]> ao dirección: opcode
0x3cee: llamar 0x14530 mnemónico:
prefijo de llamada: 0 id: 56
bytes: e83d080100 refptr: 0
Tamaño: 5 muestra: tipo falso:
ciclos de llamadas: 3
Esil: 83.248, estafa, 8, RSP, - =, RSP, = [], RIP, = saltar: 0x00014530
dirección: exec fallan: 0x00003cf3 pila: Familia nulo: cpu stackop: null
[0x00003cee]> AHC 0x5382 [0x00003cee]>
pd 2 0x00003cee
e83d080100 sub llamada .__ errno_location_530
0x00003cf3 85c0 eax prueba, eax
[0x00003cee]> ao dirección: opcode
0x3cee: llamar 0x14530 mnemónico:
prefijo de llamada: 0 id: 56
bytes: e83d080100 refptr: 0
Tamaño: 5 muestra: tipo falso:
ciclos de llamadas: 3
Esil: 83.248, estafa, 8, RSP, - =, RSP, = [], RIP, = saltar: 0x00005382
dirección: exec fallan: 0x00003cf3 pila: Familia nulo: cpu stackop: null
[0x00003cee]> ah
0x00003cee - 0x00003cee => salto: 0x5382
158
Como se puede ver, a pesar del desmontaje sin cambios ver la dirección de salto de código de operación se ha cambiado ( saltar opción).
Si algo de la descrita anteriormente no ayuda, puede simplemente anular desmontaje se muestra con todo lo que quieras:
[0x00003d54]> pd 2 0x00003d54
0583000000 add eax, 10000011b
0x00003d59 3d13010000 cmp eax, 0x113
[0x00003d54]> "aho myopcode bla, foo" [0x00003d54]> pd 2
0x00003d54
myopcode bla, foo
0x00003d55 830000 añadir DWORD [rax], 0
159
Variables
La gestión de las variables
Radare2 permite que las variables locales que administran, sin importar su ubicación, pila o registros. El análisis automático de las variables está habilitada
por defecto, pero puede desactivarse con anal.vars opción de configuración.
Las principales variables comandos se encuentran en AFV espacio de nombres:
| Uso: AFV [RBS] | afvr [?]
manipular los argumentos basados registro
| afvb [?] manipular los argumentos / locales basados pb
| AFV [?] manipular los argumentos basados sp / locales
| AFV * r2 comando de salida para añadir args / locales a flagspace
| afvR [varname] Lista de direcciones donde se accede a VARs (LEA)
| afvW [varname] Lista de direcciones donde se accede a VARs (escritura)
| AFVA analizar los argumentos de la función / locales
| nombre afvd r2 salida de comando para mostrar el valor de args / locales
en el
depurador
| AFVN [nombre_viejo] [new_name] cambiar el nombre de argumento / local | afvt [nombre]
[NEW_TYPE] Tipo de cambio de argumento dado / local
| afv - ([nombre]) eliminar todo o var dada
afvr, afvb y AFV comandos son uniformes pero permiten la manipulación de argumentos basados en registros y variables, argumentos y
variables basadas en FP BP / y argumentos basados en SP y variables respectivamente. Si comprobamos la ayuda de afvr obtendremos la
manera en que otros dos comandos funciona también:
| Uso: afvr [reg] [tipo] [nombre] | afvr
argumentos basados en la lista de registros
| afvr * mismo que afvr pero en comandos r2
| afvr [reg] [nombre] ([tipo]) definen registrarse argumentos | afvrj
lista de argumentos de devoluciones en formato JSON
| afvr- [nombre] eliminar argumentos de registro en el índice dado
| afvrg [reg] [addr] definir argumento de referencia get
| afvrs [reg] [addr] definir argumento de referencia conjunto
Al igual que muchas otras cosas variables de detección se realiza por radare2 de forma automática, pero los resultados se puede cambiar con esos
argumentos / variables controlan los comandos. Este tipo de análisis se basa principalmente en los prototipos de funciones precargados y la
convención de llamada, por lo tanto símbolos de carga puede mejorarlo. Por otra parte, después de cambiar algo que puede volver a ejecutar el
análisis de las variables con AFVA mando. Muy a menudo el análisis de las variables se acompaña con análisis tipos , ver afta mando.
160
Variables
El aspecto más importante de la ingeniería inversa - nombrar las cosas. Por supuesto, puede renombrar variables también, que afecta a todos
los lugares que se hace referencia. Esto se puede lograr con AFVN para alguna tipo de argumento o variable. O simplemente puede eliminar la
variable o discusión con afv- mando.
Como se mencionó antes del bucle análisis se basa en gran medida de la información en el desempeño de tipos etapas de análisis de variables. De
este modo viene a continuación comando muy importante - afvt, lo que le permite cambiar el tipo de variable:
[0x00003b92]> AFV
var int local_8h @ RSP + 0x8 var int local_10h @ RSP + 0x10
var int local_28h @ RSP + 0x28 var int local_30h @ RSP +
0x30 var int local_32h @ RSP + 0x32 var int local_38h @ RSP
+ 0x38 var int local_45h @ RSP + 0x45 var int local_46h @
RSP + 0x46 var int local_47h @ RSP + 0x47 var int local_48h
@ RSP + 0x48 [0x00003b92]> afvt local_10h char *
[0x00003b92]> AFV
var int local_8h @ RSP + 0x8 var char * local_10h @
RSP + 0x10 var int local_28h @ RSP + 0x28 var int
local_30h @ RSP + 0x30 var int local_32h @ RSP +
0x32 var int local_38h @ RSP + 0x38 var int local_45h
@ RSP + 0x45 var int local_46h @ RSP + 0x46 var int
local_47h @ RSP + 0x47 var int local_48h @ RSP +
0x48
distinción entre las variables que se lee y se escribe - función, que todavía está en fase de desarrollo pesada utiliza con menos frecuencia. Se
pueden listar los que están siendo leídos con afvR mando y los que están siendo escritos con afvW mando. Ambos comandos proporcionan una
lista de los lugares se realizan las operaciones de:
161
Variables
[0x00003b92]> afvR local_48h
0x48ee
0x3c93,0x520b local_30h, 0x52ea, 0x532c, 0x5400,0x3cfb 0x4b53,0x5225,0x53bd local_10h,
0x50cc
local_8h 0x4d40,0x4d99,0x5221,0x53b9,0x50c8,0x4620 local_28h 0x503a, 0x51d8,0x51fa,
local_38h 0x52d3,0x531b
local_45h 0x50a1 local_47h
local_46h
local_32h 0x3cb1 [0x00003b92]>
afvW local_48h 0x3adf
local_30h 0x3d3e, 0x4868,0x5030 local_10h 0x3d0e,
0x5035 local_8h 0x3d13,0x4d39,0x5025
local_28h 0x4d00,0x52dc, 0x53af, 0x5060,0x507a, 0x508b local_38h 0x486d
local_45h 0x5014,0x5068 local_47h 0x501b
0x5083 local_46h local_32h [0x00003b92]>
La inferencia de tipos
La inferencia de tipos de variables y argumentos locales está bien integrado con el comando afta.
Veamos un ejemplo de esto con un simple Hola Mundo binario
162
Variables
[0x000007aa]> pdf |
;-- principal:
/ (FCN) sym.main 157 | sym.main ();
| ; var int local_20h @ RBP-0x20 | ; var int local_1ch @ RBP-0x1C
| ; var int local_18h @ RBP-0x18 | ; var int local_10h @ RBP-0x10
| ; var int local_8h @ RBP-0x8 | ; DATOS REFX de Entry0 (0x6bd)
| 0x000007aa empujar RBP | 0x000007ab RBP mov, RSP |
0x000007ae sub RSP, 0x20 | 0x000007b2 rax lea, str.Hello
; 0x8d4; "Hola"
| 0x000007b9 mov QWord [local_18h], rax | 0x000007bd rax lea,
str.r2_folks ; 0x8da; "R2-gente"
| 0x000007c4 mov QWord [local_10h], rax | 0x000007c8 rax mov, QWord
[local_18h] | 0x000007cc mov RDI, rax
| 0x000007cf sym.imp.strlen de llamadas ; size_t strlen (const char * s)
después de aplicar afta
[0x000007aa]> afta
[0x000007aa]> pdf | ; - principal: |
;-- Dep:
/ (FCN) sym.main 157 | sym.main ();
| ; var size_t local_20h @ RBP-0x20 | ; var size_t tamaño @
RBP-0x1C | ; var char * src @ RBP-0x18 | ; var char * s2 @
RBP-0x10 | ; var char * dest @ RBP-0x8 | ; DATOS REFX de
Entry0 (0x6bd) | 0x000007aa empujar RBP | 0x000007ab RBP
mov, RSP | 0x000007ae sub RSP, 0x20 | 0x000007b2 rax lea,
str.Hello
; 0x8d4; "Hola"
| 0x000007b9 mov QWord [fuente], rax | 0x000007bd rax lea,
str.r2_folks ; 0x8da; "R2-gente"
| QWord 0x000007c4 mov [s2], rax | 0x000007c8 rax mov,
QWord [fuente] | 0x000007cc mov RDI, rax
; const char * s
| 0x000007cf sym.imp.strlen de llamadas ; size_t strlen (const char * s)
163
Variables
También extrae información de tipo de cadenas de formato como printf ( "fmt:% s,% u,% d", ...), las especificaciones de formato se
extraen de anal / d / spec.sdb
Se puede crear un nuevo perfil para especificar un conjunto de caracteres de formato en función de diferentes bibliotecas / sistemas operativos /
lenguajes de programación como esta:
Win = especificación
spec.win.u32 = unsigned int
A continuación, cambiar su especificación predeterminada por una recién creada utilizando esta variable de configuración e = anal.spec victoria
Para obtener más información acerca de los tipos primitivos y definidos por el usuario apoyar en radare2 consulte tipos capítulo.
164
tipos
tipos
Radare2 apoya la C-sintaxis Descripción tipos de datos. Esos tipos son analizados por un analizador compatible-C11 y se almacenan en la
SDB interna, por lo tanto son introspectable con k mando.
La mayoría de los comandos relacionados se encuentran en t espacio de nombres:
[0x000051c0]> t?
| Uso: comandos tipos t # cparse | t
Enumerar todos los tipos cargados
| TJ Enumerar todos los tipos cargados como JSON
| t <type> Tipos de espectáculos en la sintaxis 'pf'
|t* información tipos de lista de comandos r2
| t <nombre> Eliminar tipos por su nombre
|t* Eliminar todos los tipos
| ta <type> Marca de inmediato como un tipo de desplazamiento
| tc ([cctype]) convenciones de llamada de cotización y manipulaciones | te [?]
Una lista de todas las enumeraciones cargados
| td <cadena> Tipos de carga de la cadena [?] | tf
Una lista de todas las funciones de firmas cargadas
| tk <SDB-consulta> Realizar consulta SDB | tl [?]
Tipo de mostrar / enlace a una dirección
| [?] [-] tn [dir] gestionar la función NoReturn atributos y marcas | a -
cfg.editor abierta para cargar tipos
| a <ruta> Tipos de carga de archivo de cabecera C
| tos <ruta> Tipos de carga de la base de datos analizada Sdb
| tp <tipo> [addr | code] arrojado datos en <dirección> a <tipo> e imprimirlo | tpx <type> <hexpairs>
Mostrar valor para el tipo de secuencia de bytes especificado
| ts [?] impresión cargado tipos struct
| ma [?] impresión cargado tipos de unión
| tt [?] Una lista de todos typedefs cargados
Tenga en cuenta que los (atómicos) tipos básicos no son los de la norma C - No char, _Bool, o corto .
Debido a que esos tipos pueden ser diferentes de una plataforma a otra, radare2 usos definido tipos similares,
int8_t o uint64_t y convertirá En t a int32_t o int64_t dependiendo de la plataforma / compilador binario o depurado.
tipos básicos se pueden enumerar utilizando t mando, para los tipos estructurados es necesario utilizar ts, ma o Te
para enumeraciones:
165
tipos
[0x000051c0]> t Char char
* int
int16_t
int32_t
int64_t int8_t
larga
largo largo
. . .
tipos de carga
Hay tres maneras fáciles de definir un nuevo tipo:
Directamente de la cadena usando td Desde el comando de archivo usando a <nombre de
archivo> Abrir un comando $ EDITOR para escribir las definiciones en su lugar usando a -
[0x000051c0]> "td struct foo {char * a; int b;}" [0x000051c0]> cat ~ / radare2-regresiones / contenedores
/ cabeceras / s3.h struct {S1
int x [3]; int y [4];
int z; };
[0x000051c0]> a ~ / radare2-regresiones / contenedores / cabeceras / s3.h [0x000051c0]> ts foo S1
También cuenta que hay una opción de configuración para especificar directorios de inclusión para los tipos de análisis sintáctico
[0x00000000]> e ~ ?? dir.type
dir.types: Ruta predeterminada para buscar archivos de tipo cparse [0x00000000]> e dir.types /
usr / include
tipos de impresión
Aviso A continuación hemos utilizado ts comando, que básicamente convierte la descripción de tipo C (o para ser más precisos que es la
representación SDB) en la secuencia de PF comandos. Ver más sobre formato de impresión .
166
tipos
los tp comando utiliza el PF cadena para imprimir todos los miembros de tipo en la actual dirección de desplazamiento / dada:
[0x000051c0]> ts foo pf zd a b
[0x000051c0]> tp foo a: 0x000051c0 = 'hola'
b: 0x000051cc = 10
[0x000051c0]> tp foo 0x000053c0 a: 0x000053c0 =
'mundo' b: 0x000053cc = 20
También, usted podría llenar sus propios datos en la estructura e imprimirlo usando TPX mando
[0x000051c0]> tpx foo 4141414144141414141442001000000 a: 0x000051c0 = AAAAD ..... B b:
0x000051cc = 16
La vinculación de los tipos
los tp orden de la misma realiza una conversión temporal. Pero si queremos enlazar alguna dirección o variable con el tipo elegido, podemos
utilizar tl comando para almacenar la relación de SDB.
[0x000051c0]> tl S1 = 0x51cf [0x000051c0]> tl (S1)
x: 0x000051cf = [2315619660, 1207959810, 34803085] y: 0x000051db = [2370306049, 4293315645, 3860201471,
4093649307] z: 0x000051eb = 4464399
Por otra parte, el enlace se muestra en la salida de desmontaje o el modo visual:
167
tipos
[0x000051c0 15% 300 / bin / ls]> pd $ r @ Entry0; - Entry0: 0x000051c0
xor ebp, ebp
0x000051c2 mov r9, RDX
0x000051c5 RSI pop
0x000051c6 mov RDX, RSP
0x000051c9 y RSP, 0xfffffffffffffff0
0x000051cd empuje rax
0x000051ce empuje RSP
(S1)
x: 0x000051cf = [2315619660, 1207959810, 34803085] y: 0x000051db = [2370306049, 4293315645, 3860201471,
4093649307] z: 0x000051eb = 4464399 0x000051f0
lea RDI, loc._edata ; 0x21f248
0x000051f7 empuje RBP
0x000051f8 lea rax, loc._edata ; 0x21f248
0x000051ff cmp rax, RDI
0x00005202 mov RBP, RSP
Una vez que la estructura está vinculada, radare2 trata de propagar desplazamiento en la función en la estructura actual de compensación, para ejecutar este programa
de análisis en su totalidad o en cualquiera de las funciones previstas después de todas las estructuras están vinculados usted tiene
taa mando:
[0x00000000]> ta? | taa [FCN]
Analizar todos / función dada para convertir inmediata a structur vinculados
e compensaciones (ver tl?)
Nota veces la emulación puede no ser exacta, por ejemplo, de la siguiente manera:
| 0x000006da empujar RBP | 0x000006db mov RBP,
RSP | 0x000006de sub RSP, 0x10 | 0x000006e2 mov
edi, 0x20
; "@"
| Sym.imp.malloc llamada 0x000006e7 ; void * malloc (tamaño size_t)
| 0x000006ec mov QWord [local_8h], rax | 0x000006f0 mov rax,
QWord [local_8h]
El valor de retorno de malloc pueden diferir entre dos emulaciones, así que hay que establecer el valor de retorno sugerencia para utilizar manualmente Ahr de
comandos, así que corre tl o taa de comandos después de instalar la pista valor de retorno.
[0x000006da]> ah? | Ahr val
sugerencia para establecer el valor de retorno de una función
168
tipos
estructura Immediates
Hay un aspecto más importante del uso de tipos de radare2 - usando ejército de reserva se puede cambiar el código de operación inmediata en el que la estructura de
compensación. Veamos un ejemplo sencillo de [R] SI-direccionamiento relativo
[0x000052f0]> pd 1 0x000052f0
mov rax, QWord [RSI + 8] ; [0x8: 8] = 0
aquí 8 - se compensó en cierta medida en la memoria, en donde RSI Probablemente produce algún puntero estructura. Imaginemos que tenemos las siguientes
estructuras
[0x000052f0]> "ms struct td {char [8] b; int miembro1; int member2;};" [0x000052f0]> "td estructura MS1 {uint64_t a; int
miembro1;};" [0x000052f0]> "td struct ms2 {uint16_t a; int64_t b; int miembro1;};"
Ahora tenemos que configurar en lugar de compensar el buen miembro de estructura 8 En esta instrucción. En un primer momento, necesitamos una lista de tipos
disponibles que coincidan con este offset:
[0x000052f0]> tas 8 ms.member1
ms1.member1
Tenga en cuenta que MS2 no aparece en la lista, ya que no tiene miembros con desplazamiento 8. Después de enumerar las opciones disponibles podemos vincularlo a los
elegidos desplazamiento en la dirección actual:
[0x000052f0]> ta ms1.member1 [0x000052f0]> pd
1 0x000052f0
488b4608 mov rax, QWord [RSI + ms1.member1] ; [0x8: 8] = 0
La gestión de las enumeraciones
Impresión de todos los campos de enumeración utilizando Te mando
[0x00000000]> "td enum Foo {COW = 1, BAR = 2};" [0x00000000]> te Foo
COW = 0x1 BAR = 0x2
Encontrar miembro de la enumeración dada a juego de campo de bits y viceversa
169
tipos
[0x00000000]> te VACA Foo 0x1
[0x00000000]> TEB Foo 0x1 VACA
Representación interna
Para ver la representación interna de los tipos que se pueden utilizar tk mando:
[0x000051c0]> tk ~ S1 S1 = struct
struct.S1 = x, y, z
struct.S1.x = int32_t, 0,3 struct.S1.x.meta =
4 struct.S1.y = int32_t, 12,4 struct.S1.y.meta
= 4 struct.S1.z = int32_t, 28, 0
struct.S1.z.meta = 0 [0x000051c0]>
Definición de tipos primitivos requiere una comprensión básica de PF formatos, usted puede encontrar toda la lista de especificador de formato de PF ?? :
170
tipos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
| formato | explicación |
| ------------------------------------------------- - | | segundo
| byte (sin firmar) |
| do | char (byte con signo) |
| re | 0x %% valor 08x hexadecimal (4 bytes) |
|F | valor flotante (4 bytes) |
| yo | %% i número entero de valor (4 bytes) |
|o | 0x %% 08o valor octal (4 byte) |
| pag | referencia de puntero (2, 4 u 8 bytes) |
|q | palabra cuádruple (8 bytes) |
|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 %% valor hexadecimal 08x y la bandera (fd @ dir) |
|X | Mostrar formato hexpairs |
|z | \ 0 cadena terminada |
|Z | \ 0 cadena de ancho terminado |
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
hay básicamente 3 llaves obligatorias para la definición de los datos básicos tipos: X = Tipo
type.X = format_specifier type.X.size = size_in_bits Por ejemplo, vamos a definir UNIDAD, de acuerdo a
documentación de microsoft .aspx # UINT) UINT es sólo equivalente de la norma C unsigned int ( o
uint32_t en términos de motor TCC). Se define como:
UINT = tipo
type.UINT = d
type.UINT.size = 32
Ahora hay una entrada opcional:
X.type.pointto = Y
Éste sólo se puede utilizar en caso de puntero type.X = p, Un buen ejemplo es la definición LPFILETIME, es un puntero a _ FILETIME que
pasa a ser una estructura. Suponiendo que estamos apuntando única máquina Windows de 32 bits, que se define como la
siguiente:
LPFILETIME = tipo type.LPFILETIME = p
type.LPFILETIME.size = 32
type.LPFILETIME.pointto = _FILETIME
171
tipos
Este último campo no es obligatorio porque a veces las partes internas de estructura de datos serán de propiedad, y no vamos a tener una
representación limpia para ello.
También hay una entrada más opcional:
type.UINT.meta = 4
Esta entrada es para la integración con C analizador y lleva la información de la clase tipo: tamaño entero, firmado / unsigned, etc.
estructuras
Esas son las claves básicas para estructuras (con sólo dos elementos):
X = struct struct.X = a,
struct.Xa = a_type, a_offset, a_number_of_elements struct.Xb = b_type, b_offset,
b_number_of_elements
La primera línea se utiliza para definir una estructura llamada X , la segunda línea define los elementos de X como valores separados por comas. Después de eso, lo
único que definimos cada elemento de información.
Por ejemplo. podemos tener una estructura como la siguiente:
_FILETIME struct {
DWORD dwLowDateTime; DWORD
dwHighDateTime; }
asumiendo que tenemos DWORD definido, la estructura se verá así
_FILETIME = struct
struct._FILETIME = dwLowDateTime, dwHighDateTime
struct._FILETIME.dwLowDateTime = DWORD, 0,0
struct._FILETIME.dwHighDateTime = DWORD, 4,0
Tenga en cuenta que el número de elementos archivados se utiliza en el caso de las matrices sólo para identificar cuántos elementos hay en matrices, aparte de
que es cero por defecto.
sindicatos
172
tipos
Los sindicatos se definen exactamente como estructuras, la única diferencia es que va a sustituir la palabra struct
con la palabra Unión .
prototipos de funciones
representación prototipos de las funciones es el más orientado al detalle y el más importante de todos ellos. En realidad, esta es la que se utiliza
directamente para el tipo de juego
X = func
func.X.args = NumberOfArgs func.x.arg0 =
ARG_TYPE, arg_name
func.X.ret = return_type func.X.cc =
calling_convention
Debe explicarse por sí mismo. Vamos a hacer strncasecmp como un ejemplo de la arquitectura x86 para máquinas Linux. De acuerdo con las páginas
man, strncasecmp se define como la siguiente:
int strcasecmp (const char * s1, const char * s2, size_t n);
Cuando se convierte en su representación sdb que se verá como la siguiente:
strcasecmp = func
func.strcasecmp.args = 3
func.strcasecmp.arg0 = char *, s1
func.strcasecmp.arg1 = char *, s2
func.strcasecmp.arg2 = size_t, n func.strcasecmp.ret =
int func.strcasecmp.cc = cdecl
Tenga en cuenta que la . cc parte es opcional y si no existiera el valor por defecto de llamadas de convención para su arquitectura objetivo se utiliza
en su lugar. Hay una llave extra opcional
func.x.noreturn = verdadero / falso
Esta clave se utiliza para marcar las funciones que no volverá una vez llamados, como salida y _ salida .
173
tipos
174
convenciones de llamada
Radare2 utiliza convenciones de llamada para ayudar en la identificación de la función argumentos formales y tipos de retorno. Se utiliza también como una guía
para el prototipo de la función básica y tipo de propagación.
[0x00000000]> AFC? | Uso: AFC
[AGL?]
| AFC convención establece manualmente el convenio de llamada para la función actual | AFC
Mostrar convención de llamada para la función actual
| AFCR [j] Mostrar uso de registro para la función actual
| afca Analizar la función de búsqueda de la convención de llamada actual
| nombre AFCF Grabados vuelven función de tipo (arg1, arg2 ...)
| AFCL Enumerar todas las convenciones de llamada disponibles
| ruta afco SDB perfil convención de llamada abierta de ruta dada
[0x00000000]>
Para una lista de todas las convenciones de llamada disponibles para la arquitectura actual utilizando AFCL mando
[0x00000000]> AFCL ms amd64
Para mostrar la función prototipo de las funciones de la biblioteca estándar que tiene AFCF mando
[0x00000000]> AFCF printf int printf (const char *
formato) [0x00000000]> AFCF fgets
char * fgets (char * s, int size, FILE * stream)
Toda esta información se carga a través de SDB en / LiBr / anal / d / cc- [arco] - [bits de] .sdb
default.cc = amd64
ms = cc
cc.ms.name = ms
cc.ms.arg1 = rcx
cc.ms.arg2 = RDX
cc.ms.arg3 = r8
cc.ms.arg3 = r9
cc.ms.argn = pila
cc.ms.ret = rax
175
cc.x.argi = rax se utiliza para establecer el argumento i de esta convención de llamada para registrar el nombre rax
cc.x.argn = pila significa que todos los argumentos (o el resto de ellos en caso de que hubiera Argi para cualquier i como número de seguimiento) será
almacenado en la pila de izquierda a derecha
cc.x.argn = stack_rev igual que cc.x.argn = pila a excepción de que significa argumento se pasan de derecha a izquierda
176
Las tablas virtuales
Las tablas virtuales
Hay un soporte básico de tablas virtuales análisis sintáctico (RTTI y otros). Lo más importante antes de empezar a realizar este tipo de
análisis es comprobar si el anal.cpp.abi opción se establece correctamente, y cambiar si es necesario.
Todos los comandos para trabajar con tablas virtuales se encuentran en el AV espacio de nombres. Actualmente, el soporte es muy básico, lo que le permite sólo para
inspeccionar las tablas de analizada.
| Uso: av [? Jr *] C ++ vtables y RTTI | AV
buscar vtables en secciones de datos y mostrar los resultados
| AVJ al igual av, sino como JSON
| AV* al igual av, pero como comandos r2
| avr [j @ addr] intenta analizar RTTI en addr vtable (ver anal.cpp.abi) | avra [j]
buscar vtables y tratar de analizar RTTI en cada una de ellas
Los principales comandos aquí están AV y AVR. AV enumera todas las tablas virtuales que se encuentran cuando R2 abre el archivo. Si no está satisfecho
con el resultado puede que desee para tratar de analizar mesa virtual en una dirección particular con avr mando. Avra realiza la búsqueda y el análisis de
todas las tablas virtuales en el binario, como r2 hace durante la apertura de archivos.
177
llamadas al sistema
llamadas al sistema
Radare2 permite la búsqueda manual de código ensamblador que parece una operación de llamada al sistema. Por ejemplo en la plataforma ARM
generalmente están representados por la SVC instrucción, en los demás puede ser una diferente
instrucciones, por ejemplo, syscall en x86 PC.
[0x0001ece0]> / c SVC
. . .
0x000187c2 # 2: SVC 0x76 0x000189ea # 2:
SVC 0xa9 0x00018a0e # 2: SVC 0x82
. . .
detección de llamadas al sistema es accionado por asm.os, asm.bits, y asm.arch. Asegúrese de configurar los
opciones de configuración en consecuencia. Puedes usar asl comando para comprobar si el soporte para llamadas al sistema está configurado correctamente y según lo
previsto. Las llamadas al sistema comando lista compatibles para su plataforma.
[0x0001ece0]> asl
. . .
sd_softdevice_enable = 0x80.16 sd_softdevice_disable =
0x80.17 sd_softdevice_is_enabled = 0x80.18
. . .
Si la configuración de apilarlas con ESIL AEI o AEIM, puedes usar / como mandar a buscar las direcciones donde se encontraron llamadas al sistema en
particular y hacer una lista.
[0x0001ece0]> AEI
[0x0001ece0]> / as
0x000187c2 sd_ble_gap_disconnect 0x000189ea
sd_ble_gatts_sys_attr_set 0x00018a0e sd_ble_gap_sec_info_reply
. . .
Para reducir el tiempo de búsqueda es posible restringir la búsqueda rango para sólo segmentos ejecutables o secciones con / como
@e: search.in = io.maps.x
Utilizando la emulación ESIL radare2 puede imprimir argumentos syscall en la salida de desmontaje. Para permitir que el lineal (pero muy áspera) el
uso de emulación asm.emu variable de configuración:
178
llamadas al sistema
[0x0001ece0]> e asm.emu = true [0x0001ece0]> s
0x000187c2 [0x000187c2]> pdf ~ SVC
0x000187c2 SVC 0x76; 118 = sd_ble_gap_disconnect [0x000187c2]>
En el caso de la ejecución AAE ( o AAAA que llama AAE) radare2 comando empujará encontrado llamadas al sistema a un especial syscall. flagspace,
que puede ser útil para fines de automatización:
[0x000187c2]> fs 0
0 * 1 importaciones
0 * Símbolos 2 1523 * Funciones
3 420 cuerdas * 4 183 * syscalls
[0x000187c2]> f ~ syscall
. . .
0x000187c2 1 syscall.sd_ble_gap_disconnect.0 0x000189ea 1
syscall.sd_ble_gatts_sys_attr_set 0x00018a0e 1 syscall.sd_ble_gap_sec_info_reply
. . .
También se puede navegar de forma interactiva a través dentro del modo de HUD ( V_)
0> syscall.sd_ble_gap_disconnect
- 0x000187b2 syscall.sd_ble_gap_disconnect 0x000187c2
syscall.sd_ble_gap_disconnect.0 0x00018a16 syscall.sd_ble_gap_disconnect.1
0x00018b32 syscall.sd_ble_gap_disconnect.2 0x0002ac36
syscall.sd_ble_gap_disconnect.3
179
Emulación
Emulación
Una de las cosas más importantes a tener en cuenta en la ingeniería inversa es una diferencia básica entre el análisis estático y análisis
dinámico. Como muchos ya saben, el análisis estático sufre del problema de explosión de ruta, lo cual es imposible de resolver, incluso en
la forma más básica sin al menos una emulación parcial.
Así, muchas herramientas profesionales de ingeniería inversa utilizan la emulación de código mientras se realiza un análisis de código binario, y
radare2 hay diferencia aquí.
Para la emulación parcial (o emulación completa imprecisa) radare2 utiliza su propio ESIL lenguaje intermedio y la máquina virtual.
Radare2 apoya este tipo de emulación parcial para todas las plataformas que implementan ESIL edificante (x86 / x86_64, ARM,
arm64, MIPS, PowerPC, SPARC, AVR, 8051, Gameboy, ...).
Uno de los usos más comunes de este tipo de emulación es calcular saltos indirectos y saltos condicionales.
Para ver la representación ESIL del programa se puede utilizar el ao ordenar o permitir que el asm.esil
variable de configuración, para comprobar si el programa levantada correctamente, y para comprender cómo funciona ESIL:
180
Emulación
[0x00001660]> pdf
. (FCN) fcn.00001660 40 │
fcn.00001660 (); │
; LLAMADA XREF de 0x00001713 (entry2.fini) │
0x00001660 lea RDI, obj .__ progname ; 0x207220
│ 0x00001667 empuje RBP │
0x00001668 lea rax, obj .__ progname ; 0x207220
│ 0x0000166f cmp rax, RDI │
0x00001672 mov RBP, RSP │ .─
<0x00001675 je 0x1690
│ │ 0x00001677 mov rax, QWord [reloc._ITM_deregisterTMCloneTable]; [0x206fd8: 8] RBP = 0 │ │ 0x0000167e rax prueba, rax │.── <0x00001681 je
0x1690 │││ 0x00001683 pop RBP │││ 0x00001684 JMP rax │``─> 0x00001690 pop `
ret 0x00001691
[0x00001660]> e asm.esil = true [0x00001660]> pdf
. (FCN) fcn.00001660 40 │
fcn.00001660 (); │
0x00001660 0x205bb9, rasgar, +, RDI, = │
0x00001667 RBP, 8, RSP, - =, RSP, = [8] │
0x00001668 0x205bb1, rasgar, +, rax, = │
0x0000166f RDI, rax, ==, $ z, ZF, =, $ b64, cf, =, $ p, PF, =, $ s, sf, =, $ O, de, = │
RSP 0x00001672, RBP, = │ .─ <0x00001675 zf,? {, 5776, RIP, =,}
│ │ 0x00001677 0x20595a, rip, +, [8], rax, =
│ │ 0x0000167e 0, rax, rax, y, ==, $ z, zf, =, $ p, pf, =, $ s, sf, =, $ 0, cf, =, $ 0, de, = │.── <0x00001681 zf,? {, 5776, RIP, =,} │││
0x00001683 RSP, [8], RBP, =, 8, RSP, + = │││ 0x00001684 rax, rip, =
│``─> 0x00001690 RSP, [8], RBP, =, 8, RSP, + = `
0x00001691 RSP, [8], RIP, =, 8, RSP, + =
Para configurar manualmente la emulación imprecisa ESIL necesita ejecutar esta secuencia de comandos:
AEI para inicializar ESIL VM
AEIM Para inicializar la memoria ESIL VM (pila)
AEIP para establecer el VM IP inicial ESIL (puntero de instrucción) una secuencia de aer comandos
para establecer los valores iniciales de registro.
Mientras se realiza la emulación, por favor recuerde, que ESIL máquina virtual no puede emular las llamadas externas o llamadas al sistema,
junto con instrucciones SIMD. Así, el escenario más común es emular sólo una pequeña porción del código, como el cifrado / descifrado,
desembalaje o calcular algo.
181
Emulación
Después de configurar correctamente la ESIL VM podemos interactuar con él como con un modo de depuración de costumbre. interfaz de
comandos para ESIL VM es casi idéntica a la depuración uno:
aes al paso (o s tecla en el modo visual)
AESI a pasar por encima de las llamadas a funciones
AESU <dirección> al paso hasta que alguna dirección especificada
aesue <expresión ESIL> al paso hasta que alguna expresión ESIL especificado cumplido
AEC continuar hasta la rotura (Ctrl-C), éste se utiliza muy poco, sin embargo, debido a la omnipresencia de llamadas externas
AECU <dirección> continuar hasta que alguna dirección especificada
En el modo visual, todas las teclas de acceso rápido de depuración va a funcionar también en modo de emulación ESIL.
Junto con la emulación de costumbre, hay una posibilidad de que el modo de grabación y reproducción:
AETS para enumerar todos los actuales sesiones ESIL R & R
AETS + para crear uno nuevo
AESB dar un paso atrás en la sesión actual ESIL R & R
Más acerca de este modo de funcionamiento se puede leer en Depuración inversa capítulo.
Emulación en bucle análisis
Aparte del modo de emulación manual, que puede ser utilizado de forma automática en el bucle de análisis. Por ejemplo, el AAAA comando
realiza la etapa de emulación ESIL bien con los demás. Para activar o desactivar su uso puede utilizar anal.esil variable de configuración.
Hay una opción más importante, aunque estableciendo que podría ser muy peligroso, especialmente en el caso de malware - emu.write que
permite ESIL VM para modificar la memoria. A veces se requiere, sin embargo, especialmente en el proceso de desembalaje
deobfuscating o código.
Para mostrar el proceso de emulación puede establecer asm.emu variable, que mostrará los valores de registro y memoria calculados en los
comentarios de desmontaje:
182
Emulación
[0x00001660]> e asm.emu = true [0x00001660]>
pdf
. (FCN) fcn.00001660 40 │
fcn.00001660 (); │
0x00001660 lea RDI, obj .__ progname; 0x207220; RDI = 0x207220 -> 0x464c457f │
0x00001667 empujar RBP ; rsp = 0xfffffffffffffff8
│ 0x00001668 lea rax, obj .__ progname; 0x207220; rax = 0x207220 -> 0x464c457f │
0x0000166f cmp rax, RDI ; ZF = 0x1 -> 0x2464c45; cf = 0x0; PF = 0x1 -> 0x2
464c45; sf = 0x0; de = 0x0 │
0x00001672 mov RBP, RSP ; RBP = 0xfffffffffffffff8
│ .─ <je 0x1690 0x00001675 ; RIP = 0x1690 -> 0x1f0fc35d; probable
│ │ 0x00001677 mov rax, QWord [reloc._ITM_deregisterTMCloneTable]; [0x206fd8: 8] = 0; rax = 0x0
│ │ rax prueba 0x0000167e, rax ; ZF = 0x1 -> 0x2464c45; PF = 0x1 -> 0x2464c45;
sf = 0x0; cf = 0x0; de = 0x0 │.── <0x00001681 je
0x1690 ; RIP = 0x1690 -> 0x1f0fc35d; probable
│││ 0x00001683 RBP pop ; RBP = 0xffffffffffffffff -> 0x4c457fff; rsp = 0
x0
│││ 0x00001684 JMP rax ; rip = 0x0 ..
│``─> 0x00001690 RBP pop ; RBP = 0x10102464c457f; RSP = 0x8 -> 0x464c457f
` ret 0x00001691 ; rasgar = 0x0; RSP = 0x10 -> 0x3e0003
Nota aquí probable comentarios, lo que indica que la emulación ESIL previsto para determinado salto condicional a suceder.
Además de la configuración básica ESIL VM, puede cambiar el comportamiento con otras opciones ubicadas en emú.
y Esil. espacios de nombres de configuración.
Para la manipulación de ESIL trabajar con la memoria y la pila puede utilizar las siguientes opciones:
esil.stack para activar o desactivar la pila temporal para asm.emu modo
esil.stack.addr para establecer la dirección de pila en ESIL VM (como AEIM mando)
esil.stack.size para establecer el tamaño de pila en ESIL VM (como AEIM mando)
esil.stack.depth limita el número de operaciones de empuje en la pila
esil.romem especifica acceso de sólo lectura a la memoria ESIL
esil.fillstack y esil.stack.pattern le permite usar un vario patrón para el llenado pila ESIL VM en la inicialización
esil.nonull cuando se fija detiene la ejecución ESIL al puntero NULL leer o escribir.
183
información de símbolos
símbolos
Radare2 analiza automáticamente las importaciones disponibles y exporta secciones en el binario, sino que, además, se puede cargar información adicional de
depuración si está presente. Dos formatos principales son compatibles: enano y AP (para los binarios de Windows). Tenga en cuenta que, a diferencia de muchas
herramientas radare2 no se basa en la API de Windows para analizar archivos PDB, por lo que se pueden cargar en cualquier otra plataforma apoyado - por
ejemplo, Linux o OS X.
cargas de información de depuración DWARF automáticamente por defecto porque por lo general se almacena justo en el archivo ejecutable. PDB es un poco de
un animal diferente - siempre se almacena como un binario independiente, así la diferente lógica de manipulación.
Al principio, uno de los escenarios más comunes es analizar el archivo de distribución de Windows. En este caso, todos los archivos de AP están disponibles en el
servidor de Microsoft, que por defecto se encuentra en las opciones. Ver todas las opciones pdb en radare2:
pdb.autoload = 0 pdb.extract
=1
pdb.server = https://msdl.microsoft.com/download/symbols pdb.useragent =
Microsoft-Símbolo-Servidor / 6.11.0001.402
El uso de la variable pdb.server se puede cambiar la dirección donde radare2 intentará descargar el archivo PDB por el GUID almacenado en la cabecera del
ejecutable. Por lo general, no hay ninguna razón para cambiar de forma predeterminada
pdb.useragent, pero quién sabe dónde podría ser útil?
Porque esos archivos PDB se almacenan como archivos "Cab" en el servidor, pdb.extract = 1 dice que
extraer automáticamente.
Tenga en cuenta que para la descarga automática funcione es necesario función "cabextract", y wget / rizo instalados.
A veces no es necesario hacerlo desde el radare2 en sí, por lo tanto - dos opciones rabin2 prácticos:
- PAG espectáculo de depuración / información de AP
- PÁGINAS descargar el archivo pdb para binario
dónde - PÁGINAS descarga automáticamente el AP para el binaria seleccionada, utilizando los pdb. * opciones de configuración.
- PAG volcará el contenido del archivo PDB, que es útil a veces para una rápida comprensión de los símbolos
almacenados en ella.
184
Aparte del escenario básico de sólo abrir un archivo, información de AP puede ser, además, manipulado por el carné de identidad comandos:
[0x000051c0]> ID?
| Uso: Identificación de información de depuración |
Modo de salida: | '*'
La producción en los comandos radare
| carné de identidad Las líneas de fuentes
| IDP [file.pdb] información del archivo de carga AP | IDPI [file.pdb] Mostrar
información del archivo pdb | IDPD
Descargar archivo PDB en el servidor remoto
Dónde IDPI es básicamente el mismo que rabin2 -P. Tenga en cuenta que IDP también se puede utilizar no sólo en el modo de análisis estático, sino también en el
modo de depuración, incluso si está conectado a través de WinDbg.
Para simplificar las PDBs de carga, especialmente para los procesos con muchos archivos DLL vinculados, radare2 puede cargar automáticamente todas
PDBs requerida de forma automática - Sólo se necesita establecer el e pdb.autoload = true opción. A continuación, si se carga algún archivo en el modo de
depuración en Windows, usando file.exe r2 -d o r2 -d 2345 ( se unen a pid 2345), todos los archivos PDB relacionados serán cargados automáticamente.
DWARF de carga de información, por otra parte, es completamente automatizado. No es necesario para ejecutar cualquier comando / cambiar ningún
parámetro:
r2 `que rabin2`
[0x00002437 8% 300 / usr / / bin / rabin2 local] jne> pd $ r 0x00002437 0x2468
[1];
0x00002439 cmp QWord reloc .__ cxa_finalize_224, 0 0x00002441 empuje RBP
0x00002442 mov RBP, RSP 0x00002445 je 0x2453
[2];
0x00002447 lea RDI, obj .__ dso_handle; 0x207c40; "@ |" Llamada 0x2360 0x0000244e
[3];
0x00002453 sym.deregister_tm_clones de llamadas; [4]
0x00002458 byte mov [obj.completed.6991], 1; obj .__ TMC_END__; [0x2082f0: 1] = 0 0x0000245f pop RBP 0x00002460 ret
0x00002461 nop dword [rax] 0x00002468 ret
0x0000246a nop palabra [+ rax rax]; - entry1.init:; -
frame_dummy: 0x00002470 0x00002471 empuje RBP
RBP mov, RSP 0x00002474 pop RBP
0x00002475 sym.register_tm_clones JMP; [5]; - blob_version:
185
0x0000247a empujar RBP ; ../blob/version.c:18
0x0000247b RBP mov, RSP 0x0000247e sub
RSP, 0x10
0x00002482 mov QWord [RBP - 8], RDI 0x00002486 mov eax,
0x32 ; ../blob/version.c:24; '2'
0x0000248b al ensayo, al ; ../blob/version.c:19
0x0000248d 0x2498 je [6];
0x0000248f lea rax, str.2.0.1_182_gf1aa3aa4d; 0x60b8; "2.0.1-182-gf1aa3aa4d" 0x00002496 JMP 0x249f
[7];
0x00002498 rax lea, 0x000060cd RSI 0x0000249f mov, QWord
[RBP - 8] r8 0x000024a3 mov, rax 0x000024a6 mov ecx, 0x40
; section_end.ehdr
0x000024ab MOV EDX, 0x40c0
0x000024b0 lea RDI, str._s_2.1.0_git__d ___ linux_x86__d_git._s_n; 0x60d0; "% S 2.1.0-gi t% d @ linux-x86% d git.% S \ n" mov eax 0x000024b7, 0 0x000024bc
llamada 0x2350
[8];
0x000024c1 mov eax, 0x66 ; ../blob/version.c:25; 'F'
0x000024c6 prueba al, al 0x000024c8 je
0x24d6 [9];
0x000024ca RDI lea, str.commit: _f1aa3aa4d2599c1ad60e3ecbe5f4d8261b282385_build: _2017_11 _06__12: 18: 39; ../blob/version.c:26; 0x60f8;
"Comprometerse: f1aa3aa4d2599c1ad60e3ecbe5f4d82 61b282385 construcción: 2017-11-06__1 0x000024d1 sym.imp.puts de llamadas
[?]
0x000024d6 mov eax, 0 ; ../blob/version.c:28
licencia 0x000024db ; ../blob/version.c:29
0x000024dc ret; - rabin_show_help:
0x000024dd empujar RBP
; .//rabin2.c:27
Como se puede ver, se carga nombres de las funciones y la información de línea de origen.
186
firmas
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 SDB zo comandos 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 entrada de una función Entry0. Se puede mostrar en formato JSON también, que puede ser útil
para secuencias de comandos:
187
firmas
[0x000051c0]> zj ~} {[
"Name": "entrada",
"bytes": "31ed4989d15e4889e24883e4f050544c ............ ............ 48 48 ............ ff
. . . . . . . . . . f4" ,
"gráfico": {
"CC": "1", "NBBS": "1",
"bordes": "0", "reflujos":
"1"},
"Compensación": 20928
"árbitros": []}]
[0x000051c0]>
Para eliminar esto justamente se z-entrada Pero si desea guardar todas las firmas creadas, es necesario guardarlo en el archivo de comandos usando
SDB myentry zos. Entonces podemos aplicarlas. Vamos a abrir un archivo nuevo:
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 archivo myentry y ahora podemos buscar funciones coincidentes:
[0x000051c0]> ZC
[+] Buscar 0x000051c0 - 0x000052c0 [+] buscar métricas de
función resultados: 1
[0x000051c0]>
188
firmas
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:
[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 expediente por defecto) para buscar en la sección actual (suponiendo que estamos actualmente
en el . texto sección por supuesto). Ahora podemos comprobar, lo radare2 encontrado por nosotros:
[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 comentario de Entry0, que se toma de la análisis sintáctico ELF, sino también la
sign.bytes.entry_0, que es exactamente el resultado de hacer coincidir la firma.
configuración de firmas almacenadas en la Zign. Las variables de configuración de espacio de nombres:
189
firmas
[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]>
190
gráfico comandos
gráfico comandos
Al analizar los datos por lo general es útil tener diferentes formas de representarlo con el fin de obtener nuevas perspectivas para permitir al
analista a entender cómo las diferentes partes del programa de Interact.
Que representan bordes de los bloques básicos, llamadas a funciones, referencias de cadena como gráficos muestran una visión muy clara de esta información.
Radare2 soporta varios tipos de gráfico disponible a través de comandos empezando con AG:
[0x00005000]> ag?
| Uso: AG <GraphType> <formato> [dir] | Gráfico comandos:
| agc [formato] [FCN addr] callgraph función | AGF [formato] [FCN addr] básicos bloques de
funciones gráficas | AGX [formato] [dir]
Las referencias cruzadas gráfico
| agr [formato] [FCN addr] Referencias gráfico | aga [formato] [FCN addr] Referencias
de datos gráfica | AGD [formato] [FCN addr] Dif gráfico | AGI [formato]
Las importaciones gráfico
| AGC [formato] callgraph mundial
| AGR [formato] referencias globales gráfico
| AGA [formato] global gráfico referencias de datos
| agg [formato] gráfica personalizada
| ag- Desactive la gráfica personalizada
| AGN [?] cuerpo del título Añadir un nodo a la gráfica personalizada
| la edad [?] título1 title2 Añadir un borde a la gráfica personalizada
| Los formatos de salida: | <En
blanco> arte ASCII
|v arte ASCII interactivo
|t arte ASCII minúscula
| re punto graphviz
|j JSON ( 'J' para el desmontaje formateado)
| sol Gráfico Modeling Language (GML)
|k SDB-valor de la clave
|* comandos r2
|w Web / imagen (ver graph.extension y graph.web)
La estructura de los comandos es la siguiente: ag <tipo de gráfico> <formato de salida>.
Por ejemplo, IGDA Muestra el gráfico importaciones en formato de punto, mientras aggj da salida a la gráfica personalizada en formato JSON.
191
gráfico comandos
He aquí una breve descripción de cada formato de salida disponibles:
ASCII Art ** (por ejemplo, AGF)
Muestra el gráfico directamente a la salida estándar utilizando el arte ASCII para representar bloques y bordes.
Advertencia: se presentan grandes gráficos directamente a la salida estándar podría llegar a ser computacionalmente caro y hará que R2 no
responde por algún tiempo. En caso de duda, prefieren utilizar la vista interactiva (explicado más adelante).
Interactivo ASCII Art (por ejemplo, agfv)
Muestra el gráfico ASCII en una vista interactiva similar a VV que permite mover la pantalla, hacer zoom in / zoom out, ...
Ascii Tiny Art (por ejemplo, agft)
Muestra el gráfico ASCII directamente a la salida estándar en el modo de pequeña (que es el mismo que el de alcanzar el zoom máximo nivel en la
vista interactiva).
Graphviz punto (por ejemplo, AGFD)
Imprime el código fuente punto que representa el gráfico, que puede ser interpretado por programas como
graphviz o espectadores en línea como esta
JSON (por ejemplo, agfj)
Imprime una cadena JSON que representa el gráfico.
En el caso de la F formato (bloques básicos de la función), se tendrá información detallada sobre la función y tendrá
también el desmontaje de la función (uso J formato para el desmontaje formateado.
En todos los demás casos, sólo tendrá información básica sobre los nodos del grafo (ID, el título, el cuerpo, y los bordes).
Gráfico Modeling Language (por ejemplo, de Innstant.com)
Imprime el código fuente GML que representa el gráfico, que puede ser interpretado por programas como yEd
192
gráfico comandos
SDB-valor de la clave (por ejemplo, agfk)
Grabados cadenas de valores clave que representan el gráfico que fue almacenada por SDB (base de datos de cadena de radare2).
R2 comandos gráfico personalizado (por ejemplo, AGF *)
Prints R2 comandos que recrear el gráfico deseado. Los comandos para construir el gráfico se
AGN [title] [cuerpo] añadir un nodo y la edad [título1] [title2] para agregar un borde. Los [ cuerpo] campo se puede expresar en base64 para
incluir un formato especial (como saltos de línea).
Para ejecutar los comandos fácilmente impresos, es posible anteponer un punto al comando ( . AGF *).
Web / imagen (por ejemplo, agfw)
Radare2 convertirá el gráfico en formato de punto, utilice el punto programa para convertirlo en una . gif imagen y luego tratar de encontrar
un espectador ya instalado en su sistema ( xdg-abierta, abierta, ...) y visualizar el gráfico allí.
La extensión de la imagen de salida se puede ajustar con el graph.extension variable de configuración. Extensiones disponibles son png,
jpg, gif, pdf, ps.
Nota: debido a que grandes gráficos, la extensión más recomendada es SVG ya que producirá imágenes de tamaño mucho más pequeño
Si graph.web variable de configuración está habilitada, radare2 tratará de mostrar el gráfico usando el navegador ( esta característica es experimental y
sin terminar, y desactivados por defecto.)
193
scripting
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:
194
scripting
[0x00404800]> pd 1
0x00404800 b827e66100 mov eax, 0x61e627 ; "lengüeta"
[0x00404800]> Dirección ao:
0x404800
5 Tipo: mov
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
los PS comando describe varias variables votos que puede utilizar para hacer acciones similares, incluso con mayor facilidad, como el $ v " valor inmediato"
variable o el $ metro la memoria de código de operación variable de referencia.
195
bucles
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 con AFI 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 con FCN. ):
[0x004047d6]> afi @@ FCN. * ~ Nombre
Este comando extraerá el nombre ámbito de la AFI salida de cada marca con un nombre que coincida con la expresión regular FCN. *.
196
bucles
También podemos bucle sobre una lista de desplazamientos, utilizando la siguiente sintaxis:
@@ = 1 2 3 ... N
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:
Familia nulo: cpu
Dirección: 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 que $$ + 2 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.
197
bucles
[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 cada construcciones para bucle. Uno de los más útiles es de bucle a través de todas las instrucciones de
una función:
[0x004047d0]> pdf ╒ (FCN)
Entry0 42
│; XREF UNKNOWN de 0x00400018 (unk) │; DATOS XREF de 0x004064bf
(sub.strlen_460) │; DATOS XREF de 0x00406511 (sub.strlen_460) │; DATOS
XREF de 0x0040b080 (unk) │; DATOS REFX de 0x0040b0ef (unk) │0x004047d0
xor ebp, mov ebp │0x004047d2 r9, RDX │0x004047d5 RSI pop │0x004047d6
mov RDX, RSP
│0x004047d9 y RSP, 0xfffffffffffffff0 │0x004047dd empujan rax
│0x004047de empuje RSP
│0x004047df mov r8, 0x4136c0 │0x004047e6 mov RCX,
0x413660 ; "AWA..AVI..AUI..ATL.% .."
0A..AVI..AUI.
│0x004047ed RDI mov, principal ; "AWAVAUATUH..S..H ...." @
│0x004047f4 llamar sym.imp .__ libc_start_main ╘0x004047f9 HLT
[0x004047d0]> pi 1 @@ i mov R9, RSI RDX pop
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
198
bucles
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 de las
importaciones
registra hilos
comentarios
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 uso de la
@@@ mando:
[0x004047d6]> afi @@@ funciones ~ nombre
Esto extraerá nombre campo de AFI 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]
199
macros
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 mov eax, 0x61e627 ; "lengüeta"
0x00404805 empujar RBP
0x00404806 sub rax, section_end.LOAD1 0x0040480c mov RBP,
RSP
Dirección: 0x404800
5 Tipo: mov
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]>
200
macros
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.
[0x00404800]
[0x004047d0]> "(foo x y, Pd $ 0; s + $ 1)" [0x004047d0]> (foo 5 6); -
Entry0:. 0x004047d0
xor ebp, ebp
0x004047d2 mov r9, RDX
0x004047d5 RSI pop
0x004047d6 mov RDX, RSP
0x004047d9 y RSP, 0xfffffffffffffff0
[0x004047d6]>
Como se puede ver, los argumentos son nombrados por el índice, a partir de 0: 0 $, $ 1, ...
201
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)
consultas HTTP (nube amistoso) 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 X xx
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
202
R2pipe
NodeJS
Utilice este comando para instalar las fijaciones r2pipe
$ NPM instalar r2pipe
He aquí una muestra de hola mundo
r2pipe const = require ( 'r2pipe'); r2pipe.open ( '/ bin / ls', (err, res) =>
si (err) {throw err; }
r2.cmd ( 'af @ Entry0', function (o) {r2.cmd ( "pdf @ Entry0", la
función (o) {
console.log (o);
r.quit ()
}); });
});
Checkout del repositorio GIT para más ejemplos y detalles.
https://github.com/radare/radare2-r2pipe/blob/master/nodejs/r2pipe/README.md
Ir
$ R2pm -i r2pipe-go
https://github.com/radare/r2pipe-go
paquete principal
importar (
"FMT"
"Github.com/radare/r2pipe-go"
203
R2pipe
func principal() {
R2P, err: = r2pipe.NewPipe ( "/ bin / ls" )
Si err! = nulo {
pánico (Err)}
aplazar r2p.Close () buf1, err: = r2p.Cmd ( "? E Hello World" )
Si err! = nulo {
pánico (Err)}
fmt.Println (buf1)}
Moho
$ Cat Cargo.toml
. . .
[Dependencias] r2pipe =
"*"
# [Macro_use]
externo caja r2pipe;
utilizar r2pipe :: R2Pipe;
fn principal () {
dejar mut R2P = open_pipe! ( Algunos ( "/ bin / ls" )).desenvolver();
println! ( "{:}?" , R2p.cmd ( "? E Hello World" ));
dejar json = r2p.cmdj ( "Ij" ).desenvolver();
println! ( "{}" , Json.pretty ());
println! ( "ARCO {}" , Json.find_path (y [ "compartimiento" , "arco" ]).desenvolver()); r2p.close (); }
Rubí
$ Gem install r2pipe
204
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
# ! / Usr / bin / perl
utilizar R2 :: Pipe;
utilizar estricto;
mi $ R = R2 :: sobre tubería> nueva ( "/ bin / ls" );
impresión $ R-> cmd ( "Pd 5" ). "\norte" ;
impresión $ R-> cmd ( "64 px" ). "\norte" ; $ R-> quit ();
Erlang
205
R2pipe
# ! / 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
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
206
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 {
estático vacío 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
207
R2pipe
importar org.radare.r2pipe.R2Pipe;
público clase Prueba {
público hoyo estatico principal (args String []) {
tratar {
R2Pipe R2P = nuevo R2Pipe ( "/ bin / ls" );
// nueva 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 dejar R2P = R2Pipe (url: nulo ) {r2p.cmd ( "? V" , El
cierre: {(str: String?) en si 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
208
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 ( "Desmontaje: \ n% s \ n" , X); r2p.cmd ( "es decir" , (X) => {
stdout .printf ( "Punto de entrada: \ n% s \ n" , X); r2p.cmd ( "Q" );
}); });
ChildWatch.add (r2p.child_pid, (PID, estado) => {
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);
209
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 con r2
- L. Los 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 estructuras de código o de datos.
La comunicación entre radare y la capa de IO depurador se envuelve en sistema() llama, que acepta una cadena como un argumento, y lo ejecuta
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 ayuda con = !? o =! ayuda . 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 hardware
compatible. 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?':
210
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
211
Empezando
Empezando
Pequeña sesión de depurador radare2
r2 -d / bin / ls: Abre radare2 con el archivo / bin / ls en 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
dk <señal>: Enviar señal KILL a hijo
ood: vuelva a abrir en modo de depuración
ood arg1 arg2: vuelva a abrir en modo de depuración con arg1 y arg2
212
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: // pid - Igual que el anterior, pero sólo para io (no depurador backend enganchado)
[0x7fff6ad90028]> O-225 - cerca fd = 225 (enumerados en O ~ [1]: 0)
r2 -D GDB GDB: // localhost: 1234 - adjuntar a gdbserver
Cómo establecer la variable args / medio / cargar un librerías

específicas para la sesión de depuración de radare
Utilizar rarun2 (Libpath = $ PWD: / tmp / lib, arg2 = hola, setenv = FOO = BAR ...) ver rarun2 -h / hombre rarun2
Cómo guión radare2?
r2 -i <archivo de guión> ... - ejecutar un script después cargar el archivo => [ vídeo ]
r2 -I <archivo de guión> ... - ejecutar un script antes de cargar el archivo
R2 -C $ @ | awk $ @ - ejecutar a través de asm awk obtener de la función => [ enlazar ]
[0x80480423]>. archivo de comandos - interpretar este archivo => [ vídeo ]
213
[0x80480423]> #! C - introducir 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
Cómo mostrar el código fuente como en la lista de GDB?
CL @ sym.main - aunque la característica es altamente experimental
atajos
Mando IDA Pro radare2 r2 (modo visual) BGF
Análisis
puesto en marcha de aaa o -A (AAAA o -AA para

Análisis de forma automática al abrir el análisis incluso
N/A N/A
todo una experimental)
binario
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 entrar o0-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
214
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 UNA Cs [tamaño] ds N/A
definir como struct Alt + Q Cf [tamaño] dF N/A
depurador
comienzo Proceso /
F9 corriente continua F9 r y
ejecución Continuar
terminar un proceso de Ctrl + F2 dk 9 ? matar
Despegar ? o- ? despegar
entrar en F7 ds s norte
paso dentro 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 registrar Se muestra en el modo

Registro de visualización dr todo
Windows Visual registros
En registrar Se muestra en el modo

eax pantalla dr? eax registra eax
Windows Visual
mostrar el estado antiguo de

? dro ? ?
todos los registros
$$ afi - monitor
215
monitor función información de la

? ? ?
addr + N función de
corriente compensar
($$ )
estado marco de la pantalla ? RBP-RSP RSP PXW @ ? Si
Como paso hasta que la

? DSi ? ?
condición es verdadera
Actualizar un valor de registro

? dr rasgar = 0x456 ?
$ Rip = 0x456
desmontaje
hacia adelante
N/A pd vp DISA
desmontaje
desmontaje norte
N/A pd X vp x/i
instrucciones
desmontaje norte DISA <ao> <a>

N/A pd -X vp
(hacia atrás)
Información en
deposito
Menú es o S maint seccio

Secciones / regiones N/A
secciones (Anexar j para JSON) info
Cargar archivo de símbolos
asm.dwarf.file, pdb.XX) archivo de

Secciones / regiones menú AP N/A
complemento símbolo
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 N/A bt
interna)
dbg.btalgo)
DBT
Backtrace parcial (más
N/A ( dbg.btdepth N/A BT -
externa)
dbg.btalgo)
StackTrace para todos los

N/A DBT @ t N/A aplicar todos
hilos bt
216
Los puntos de interrupción
lista de punto de interrupción Ctrl + Alt + B db ?

los puntos de 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
alguna bt
números de bastidor N/A ? N/A
mando
Seleccione el fotograma N/A ? N/A cuadro
Parámetros / locales
parámetros de visualización N/A AFV N/A Otros detalles args
parámetros de visualización N/A AFV N/A

locales
Monitor
parámetros / locales en N/A afvj N/A
locales
JSON
Lista de direcciones donde
VARs son N/A afvR / afvW N/A ?
visitada (R / W)
proyecto Relacionados
proyecto abierto Po [Archivo] ?
Guardar proyecto automático Ps [Archivo] ?
espectáculo proyecto
Pi [Archivo] ?
informaciones
Diverso
Volcado matriz de bytes Char (JSON,

¿ordenador personal? C,
N/A Vpppp x / bc
char, etc.)
opciones menú de opciones ¿mi? mi
Seleccionar la zona con el

buscar menú de búsqueda /? cursor do
entonces /
217
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
R2 se puede conectar al BGF, LLVM y WinDBG r2 puede escribir /
parche en su lugar
R2 tienen cautivos, 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 MDMP (minivolcados de Windows)
218
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]> rasgón dr; 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.
219
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.
[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
220
registros
Estado actual de registros
[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 reinterpretar de nuevo:
[0x4A13B8C0]> dr *> regs.saved; guardar los registros [0x4A13B8C0]> DRP
regs.saved; restaurar
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
221
registros
222
Mapas de memoria
Mapas de memoria
La capacidad de comprender y manipular los mapas de memoria de un programa depurado es importante por muchas diferentes tareas de
ingeniería inversa. radare2 ofrece un rico conjunto de comandos para manejar mapas de memoria en el binario. Esto incluye una lista de los mapas
de memoria de la binaria Actualmente depurado, la eliminación de mapas de memoria, manejo de bibliotecas cargadas y más.
En primer lugar, vamos a ver el mensaje de ayuda para dm, el comando que es responsable del manejo de mapas de memoria:
[0x55f2104cf620]> DM?
| Uso: dm # Memoria mapas de comandos | dm
Lista de mapas de memoria de proceso de destino
| tamaño dm addr Asignar <tamaño> bytes en <dirección> (en cualquier lugar si la dirección es -1) en chil
el procedimiento
d | dm = Lista de mapas de memoria de proceso de destino (barras ascii-art)
| dm. Muestre el mapa de dirección actual
| dm * memmaps lista de comandos radare
| dirección DM- Mapa de liberar memoria de <dirección>
| DMD [a] [archivo] volcado actual (todos) de depuración región del mapa a un archivo (de-to.dmp) (ver Sd) | DMH [?]
Ver mapa del montón
| DMI. Lista de símbolos más cercano a la dirección actual
| dmiv Demostración de la dirección del símbolo dado para lib dada
| dmj memmaps listado en formato JSON
| DML <archivo> Cargar contenido del archivo en la región del mapa actual (ver Sl)
| dmm [?] [j *] Lista de módulos (bibliotecas, archivos binarios cargados en la memoria)
| DMI [addr | libname] [symname] Lista de símbolos de lib objetivo
| DMI * [addr | libname] [symname] Lista de símbolos de lib objetivo de comandos radare
| DMP [?] <dirección> <tamaño> <permanentes> Cambiar la página en <dirección> con <tamaño>, la protección <por ms> (rwx)
| DMS [?] <id> <mapaddr> Tomar instantáneas de memoria
| DMS <id> <mapaddr> Restaurar la memoria instantánea
| DMS [addr | libname] [sectname] Lista de secciones lib objetivo
| DMS * [addr | libname] [] sectname secciones lista de comandos lib objetivo en radare
En este capítulo, vamos a repasar algunos de los más útiles de subcomandos dm utilizando ejemplos simples. Para los siguientes ejemplos,
usaremos un sencillo Hola Mundo programa para Linux pero será el mismo para todos los binarios.
Lo primero es lo primero - abrir un programa en el modo de depuración:
223
Mapas de memoria
holamundo $ r2 -d
Proceso con PID 20304 comenzó ... = adjuntar 20304 20304
bin.baddr 0x56136b475000 Usando 0x56136b475000
asm.bits 64
[0x7f133f022fb0]>
Tenga en cuenta que pasamos "HelloWorld" a radare2 sin "./". radare2 tratará de encontrar este programa en el directorio actual y luego
en $ PATH, aunque "./" no se pasa. Esto es contradictorio con los sistemas UNIX, pero hace que el comportamiento consistente para
los usuarios de Windows
Vamos a utilizar dm para imprimir los mapas de memoria del binario que acabamos de abrir:
[0x7f133f022fb0]> dm
0x0000563a0113a000 - usr 4K s rx / tmp / holamundo / tmp / holamundo; map.tmp_helloworld
. r_x
0x0000563a0133a000 - usr 8K s rw- / tmp / holamundo / tmp / holamundo; map.tmp_helloworld
. rw
0x00007f133f022000 * usr 148K s rx /usr/lib/ld-2.27.so /usr/lib/ld-2.27.so; map.usr_li b_ld_2.27.so.r_x
0x00007f133f246000 - usr 8K s rw- /usr/lib/ld-2.27.so /usr/lib/ld-2.27.so; map.usr_li b_ld_2.27.so.rw
0x00007f133f248000 - usr 4K s rw- unk0 unk0; map.unk0.rw 0x00007fffd25ce000 - usr 132K s rw- [pila] [apilar]; map.stack_.rw
0x00007fffd25f6000 - usr 12K s r-- [vvar] [vvar]; map.vvar_.r 0x00007fffd25f9000 - usr rx 8K s [vdso] [vdso]; map.vdso_.r_x 0xffffffffff600000 -
usr 4K s rx [vsyscall] [vsyscall]; map.vsyscall_.r_x
Para aquellos de ustedes que prefieren una forma más visual, puede utilizar dm = para ver los mapas de memoria utilizando un barras del arte ASCII.
Esto será útil cuando se desea ver cómo estos mapas se encuentran en la memoria.
Si desea conocer el mapa de memoria que se encuentra actualmente, el uso dm. :
[0x7f133f022fb0]> dm.
0x00007f947eed9000 # 0x00007f947eefe000 * usr 148K s rx /usr/lib/ld-2.27.so / usr / lib / ld-2.27.so; map.usr_lib_ld_2.27.so.r_x
Utilizando dmm podemos "módulos de la lista (bibliotecas, archivos binarios cargados en la memoria)", esto es un comando muy útil para ver qué
módulos se cargaron.
224
Mapas de memoria
[0x7fa80a19dfb0]> dmm
0x55ca23a4a000 / tmp / holamundo 0x7fa80a19d000
/usr/lib/ld-2.27.so
Tenga en cuenta que la salida de dm subcomandos, y dmm específicamente, podría ser diferente en diversos sistemas y diferentes
binarios.
Podemos ver que junto con nuestro Hola Mundo sí binario, otra biblioteca se cargó que es ld-
2.27.so. No vemos libc sin embargo, y esto es porque se rompe antes de radare2 libc se carga en la memoria. Vamos a utilizar DCU ( re ebug do ontinuac u
asta) para ejecutar el programa hasta que el punto de entrada del programa, que radare banderas como Entry0.
[0x7fa80a19dfb0]> DCU Entry0
Continúe hasta 0x55ca23a4a520 usando 1 bpsize golpe punto de ruptura en:
55ca23a4a518 [0x55ca23a4a520]> dmm
0x55ca23a4a000 / tmp / holamundo 0x7fa809de1000
/usr/lib/libc-2.27.so 0x7fa80a19d000 /usr/lib/ld-2.27.so
Ahora podemos ver que libc-2.27.so se cargó así, genial!
Hablando de libc, una tarea popular para la explotación binaria es encontrar la dirección de un símbolo específico en una biblioteca. Con esta
información en mano, se puede construir, por ejemplo, un exploit que utiliza ROP. Esto se puede lograr usando el DMI mando. Así que si
queremos, por ejemplo, para encontrar la dirección de sistema() en el cargado libc, simplemente podemos ejecutar el siguiente comando:
[0x55ca23a4a520]> DMI libc sistema
514 0x00000000 0x7fa809de1000 archivo local 0 system.c
515 0x00043750 0x7fa809e24750 FUNC LOCAL 1221 do_system 4468 0x001285a0 0x7fa809f095a0 LOCAL FUNC
100 svcerr_systemerr 5841 0x001285a0 0x7fa809f095a0 FUNC LOCAL 100 svcerr_systemerr 6427 0x00043d10
0x7fa809e24d10 WEAK sistema FUNC 45 7094 0x00043d10 0x7fa809e24d10 GLBAL FUNC 45 sistema 7480
0x001285a0 0x7fa809f095a0 GLBAL FUNC 100 svcerr_systemerr
Similar a dm. mando, con DMI. se puede ver el símbolo más cercano a la dirección actual.
Otro comando útil es una lista de las secciones de una biblioteca específica. En el siguiente ejemplo vamos a enumerar las secciones de ld-2.27.so:
225
Mapas de memoria
[0x55a7ebf09520]> DMS-ld 2.27 [Secciones]
00 0x00000000 0 0x00000000 0 ---- ld-2.27.so.
01 0x000001c8 36 0x4652d1c8 36 -r-- ld-2.27.so..note.gnu.build_id
02 0x000001f0 352 0x4652d1f0 352 -r-- ld-2.27.so..hash 03 0x00000350 412 0x4652d350 412 -r--
ld-2.27.so..gnu.hash 04 0x000004f0 816 0x4652d4f0 816 -r-- ld-2.27.so ..dynsym 05 0x00000820 548
0x4652d820 548 -r-- ld-06 2.27.so..dynstr 0x00000a44
68 0x4652da44 68 -r-- ld-2.27.so..gnu.version
07 0x00000a88 164 0x4652da88 164 -r-- ld-08 2.27.so..gnu.version_d 0x00000b30 1152 0x4652db30 1152 -r-- ld-09
2.27.so..rela.dyn 0x00000fb0 11497 11497 0x4652dfb0 -rx ld-2.27.so ..text 10 0x0001d0e0 17760 0x4654a0e0 17760 -r--
ld-2.27.so..rodata 11 0x00021640 1716 0x4654e640 1716 -r-- ld-2.27.so..eh_frame_hdr 12 0x00021cf8 9876 0x4654ecf8
9876 -r-- ld-2.27. so..eh_frame 13 0x00024660 2020 0x46751660 2020 -rw- ld-2.27.so..data.rel.ro 14 0x00024e48 336
0x46751e48 336 -rw- ld-2.27.so..dynamic 15 0x00024f98
96 0x46751f98 96 -rw- ld-2.27.so..got
16 0x00025000 3960 0x46752000 3960 -rw- ld-2.27.so..data 17 0x00025f78
0 0x46752f80 376 -rw- ld-2.27.so..bss
18 0x00025f78 17 0x00000000 17 ---- ld-2.27.so..comment
19 0x00025fa0 63 0x00000000 63 ---- ld-2.27.so..gnu.warning.llseek
20 0x00025fe0 13272 0x00000000 13,272 ---- ld-2.27.so..symtab 21 0x000293b8 7101 0x00000000 7101 ----
ld-2.27.so..strtab 22 0x0002af75 215 0x00000000 215 ---- ld-2.27.so .. shstrtab
226
Montón
Montón
radare2 de dm subcomandos también pueden mostrar un mapa de la pila, que es útil para aquellos que son interesantes en la inspección de la
pila y su contenido. Basta con ejecutar DMH para mostrar un mapa de la pila:
[0x7fae46236ca6]> DMH
Malloc trozo @ 0x55a7ecbce250 [tamaño: 0x411] [asignado]
Top trozo @ 0x55a7ecbce660 - [brk_start: 0x55a7ecbce000, brk_end: 0x55a7ecbef000]
También puede ver un diseño gráfico de la pila:
[0x7fae46236ca6]> DMHG Montón
diseño
. ────────────────────────────────────.
│ Malloc trozo @ 0x55a7ecbce000 │ │ Tamaño: 0x251
│ fd: 0x0, bk: 0x0 │
`────────────────────────────────────'
. ─ ─ ─ '│
│
. ─────────────────────────────────────────────.
│ @ trozo malloc 0x55a7ecbce250 │
│ Tamaño: 0x411 │
│ FD: 0x57202c6f6c6c6548, bk: 0xa21646c726f │
`──────────────────────────────────────── ─────'
. ─ ─ ─ '│
│
. ────────────────────────────────────────────────────.
│ Top trozo @ 0x55a7ecbce660 │
│ [brk_start: 0x55a7ecbce000, brk_end: 0x55a7ecbef000] │
`────────────────────────────────────── ──────────────'
Otros comandos de montón se pueden encontrar en DMH, comprobar DMH? para la lista completa.
227
Montón
[0x00000000]> DMH?
| Uso: DMH # mapa de memoria heap | DMH
trozos mencionados de segmento montón
| dmh [malloc_state] trozos Lista montón de una arena especial | DMHA
Enumerar todas las instancias malloc_state en aplicaciones
| DMHB Mostrar toda la lista ligada doble analizada de contenedores de main_arena instanc
mi
| DMHB [BIN_NUM | BIN_NUM: malloc_state] Display analizado lista doblemente enlazada de contenedores
ejemplo, de una arena especial | dmhbg [BIN_NUM]
Doble display gráfico de lista enlazada de bin main_arena [Bajo desa
pemnt]
| DMHC @ [chunk_addr] struct Display malloc_chunk por un trozo malloc dada | DMHF
Mostrar todos fastbins analizados de ejemplo fastbinY de main_arena
| DMHF [fastbin_num | fastbin_num: malloc_state] Pantalla analiza lista enlazada única instancia en Biny rápidamente de una arena especial | DMHG
gráfico Display montón de segmento montón
| DMHG [malloc_state] gráfico Display montón de una arena especial | dmhi @ [malloc_state] estructura de visualización heap_info /
estructuras para un escenario determinado | dmhm
Enumerar todos los elementos de malloc_state estructura del hilo principal (main_aren
una)
| dmhm [malloc_state] Lista todas las instancias malloc_state de una arena especial | dmht
Mostrar todos los contenedores de caché de la culata en T analizados de instanc TcAChE de main_arena
mi
| DMH? Mostrar ayuda mapa del montón
228
archivos
archivos
El depurador radare2 permite al usuario mostrar y manipular los descriptores de archivos desde el proceso de destino.
Esta es una característica útil, que no se encuentra en otros depuradores, la funcionalidad es similar a la herramienta de línea de comando lsof.
Pero tienen subcomandos adicionales para cambiar la buscan, cerrar o duplicarlas.
Por lo tanto, en cualquier momento de la sesión de depuración puede reemplazar los descriptores de fichero stdio utilizar sockets de red creados por r2, o
reemplazar una conexión de socket de red para secuestrarlo.
Esta funcionalidad también está disponible en r2frida utilizando el comando dd precedido de una barra invertida. En R2 es posible que desee para ver la salida
del dd? para los detalles apropiados.
229
Depuración inversa
Depuración inversa
Radare2 tiene depurador inversa, que puede buscar el contador de programa hacia atrás. (Por ejemplo inversa siguiente, reversecontinue 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 usar dts 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:
230
Depuración inversa
[0x004028a0]> dts
sesión: 0 a: 0x004028a0 "" sesión: 1 en: 0x004028c2 ""
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 mente. bss 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 por AETS 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
231
Depuración inversa
232
Acceso remoto
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 Exec a distancia '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
| =: Host: puerto de comando Run 'cmd' en el servidor remoto |
otros servidores: | = h [?]
escuchar las conexiones HTTP
| = G [?] utilizando gdbserver
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:
Al sistpral1 remoto:
$ Radare2 rap: //: 1234
Al host2 remoto:
$ Radare2 rap: //: 1234
233
Acceso remoto
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):
[0x004048c5]> = -
También puede redirigir la salida radare a un puerto TCP o UDP del servidor (por ejemplo, nc -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:
234
Acceso remoto
[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 de cmd para el número de conexión remoto N (o el último usado si ningún id
especificado).
235
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:
$ R2 -d GDB: // <host>: <puerto>
Tenga en cuenta que el siguiente comando hace lo mismo, r2 usará el plugin de depuración especificado por el URI si se encuentra.
$ -D r2 GDB GDB: // <host>: <puerto>
El plug-in de depuración se puede cambiar en tiempo de ejecución utilizando los comandos dL o LD.
O si el gdbserver se está ejecutando en modo extendido, se puede asociar a un proceso en el host con:
$ R2 -d GDB: // <host>: <puerto> / <pid>
Después de conectar, puede utilizar los comandos de depuración R2 estándar 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. En 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: // <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: // <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 variable de entorno
R2_GDB_PKTSZ. También puede comprobar y establecer el tamaño máximo del paquete durante una sesión con el sistema IO,
=! .
236
GDB remoto
$ Exportación R2_GDB_PKTSZ = 512 $ r2 -d
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
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 IO plug-in de
sistema ()).
[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]> = g?
| Uso: = [g] [...] # servidor GDB | 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 --rem ota-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:
237
GDB remoto
$ R2 -d GDB: // localhost: 8000
238
WinDBG remoto
WinDBG
El apoyo WinDBG para R2 le permite adjuntar a la máquina virtual con Windows utilizando un archivo llamado zócalo (OI apoyará más en el futuro)
para depurar un cuadro de ventanas utilizando la interfaz de KD a través del puerto serie.
Tenga en cuenta que el apoyo WinDBG todavía es un trabajo en progreso, y esto es sólo una implementación inicial que va a mejorar con el
tiempo.
También es posible utilizar la interfaz de GDB remoto para conectarse y depurar kernels de Windows sin depender de las capacidades de
Windows.
Habilitar el soporte WinDBG en Windows Vista y más como esto:
bcdedit / depuración en
bcdedit / dbgsettings debugport de serie: 1 velocidad en baudios: 115200
A partir de Windows 8 no hay manera de hacer cumplir la depuración para cada arranque, pero es posible mostrar siempre las opciones de
arranque avanzadas, lo que permite habilitar la depuración del núcleo:
bcedit / set {} GlobalSettings AdvancedOptions verdadera
O como esta para Windows XP: boot.ini abierto y añadir / debug / debugport = COM1 / velocidad de transmisión = 115200:
[Boot loader] timeout =
30
default = multi (0) disk (0) rdisk (0) partición (1) \ [sistemas operativos] VENTANAS
multi (0) disk (0) rdisk (0) partición (1) \ WINDOWS = "Depuración con cable" / fastdetect / debug / d ebugport = COM1 / velocidad de transmisión = 57600
En caso de VMWare
Máquinas virtuales Configuración -> Añadir -> Serial Port Estado del dispositivo:
[V] Conectar al encender el equipo de
conexión:
[V] Utilice el zócalo (tubería con nombre) [_ / tmp /
windbg.pipe ________] De: Servidor A: Virtual Machine
239
WinDBG remoto
Configurar la máquina VirtualBox como esto:
Preferencias -> Puertos serie -> Puerto 1
[V] Habilitar Puerto Serie Número de puerto: [_COM1
_______ [v]] modo de puerto: [_Host_Pipe __ [v]]
[V] Crear Pipe
Ruta Puerto / Archivo: [_ / tmp / windbg.pipe ____]
O simplemente generar la máquina virtual con qemu como este:
Toma de -chardev, id = serial0, $-system-x86_64 qemu \
path = / tmp / windbg.pipe, nowait, servidor \
- chardev serie: serial0 -hda Windows7-VM.vdi
Radare2 utilizará el 'windbg' io plugin para conectarse a un archivo de socket creado por VirtualBox o qemu. Además, el depurador 'windbg'
plugin y que debe especificar el x86-32 también. (32 y 64 de depuración de bits es compatible)
$ R2 x 86 -a -b 32 -D windbg windbg: ///tmp/windbg.pipe
En Windows se debe ejecutar la siguiente línea:
$ -D radare2 windbg windbg:. // \\ \ pipe \ com_1
En este punto, vamos a quedarnos atrapados aquí:
[0x828997b8]> pd 20
; - EIP:
0x828997b8 cc int3
0x828997b9 c20400 ret 4
0x828997bc cc int3
0x828997bd 90 nop
0x828997be c3 jubilado
0x828997bf 90 nop
Con el fin de omitir esa trampa tendremos que cambiar EIP y correr 'dc' dos veces:
240
WinDBG remoto
dr EIP = EIP + 1 dc
dr EIP = EIP + 1 dc
Ahora la máquina virtual de Windows será interactiva de nuevo. Tendremos que matar a r2 y conecte de nuevo para volver a controlar el kernel.
además, el dp comando se puede utilizar para enumerar todos los procesos, y dpa o dp = para insertarse en el proceso. Esto mostrará la
dirección base del proceso en el diseño de memoria física.
241
Herramientas de línea de comandos
Herramientas
Radare2 no es sólo la única herramienta proporcionada por el proyecto radare2. El resto, si capítulos de este libro se centran en explicar el uso de
la herramienta radare2, este capítulo se centrará en explicar todos los demás instrumentos complementarios que se incluyen dentro del proyecto
radare2.
Todas las funcionalidades proporcionadas por las diferentes APIs y plugins tienen también herramientas diferentes para permitir a utilizarlas desde la
línea de comandos e integrarlos con shellscripts fácilmente.
Gracias al diseño ortogonal del marco, es posible hacer todas las cosas que R2 es capaz de distintos lugares:
estas herramientas compañero
nativo API de biblioteca de
secuencias de comandos con la
cáscara r2pipe r2
242
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.
Este es el mensaje de ayuda de rax2, esta herramienta se puede utilizar en la línea de comandos o de forma interactiva (la lectura de los valores de la entrada estándar),
por lo que se puede utilizar como una calculadora de base múltiple.
Dentro R2, la funcionalidad de rax2 está disponible bajo la? mando. Por ejemplo:
[0x00000000]>? 3 + 4
Como se puede ver, las expresiones numéricas pueden contener expresiones matemáticas como suma, resta, .. así como las
operaciones de grupo con paréntesis.
La sintaxis en el que se representan los números de definir la base, por ejemplo:
3: decimal, la base 10
0xface: hexadecimales, base 16 0472:
octal, la base 8 2M: unidades, 2
megabytes
.. .
Este es el mensaje de ayuda en -H rax2, que le mostrará un montón más sintaxis
243
Rax2
$ Rax2 -h
Uso: rax2 [opciones] [expr ...]
= [Base] ; rax2 = 10 0x46 -> salida en base 10
En t - > maleficio ; rax2 10
maleficio - > En t ; 0xa rax2
- En t - > maleficio ; rax2 -77
- maleficio - > En t ; rax2 0xffffffb3
En t - > compartimiento ; b30 rax2
En t - > ternario ; t42 rax2
compartimiento - > En t ; 1010D rax2
ternaria -> int ; rax2 1010dt
flotar -> hexagonal ; 3.33f rax2
maleficio - > flotador ; rax2 Fx40551ed8
oct - > maleficio ; 35o rax2
maleficio - > oct ; rax2 OX12 (O es una carta)
compartimiento - > maleficio ; rax2 1100011b
maleficio - > compartimiento ; rax2 BX63
ternaria -> hexagonal ; 212T rax2
maleficio - > ternario ; rax2 Tx23
crudo - > maleficio ; rax2 -S </ binfile
maleficio - > crudo ; rax2 -s 414141
- l ; añadir nueva línea de salida (por -E / D / r / ..
- una Mostrar tabla ascii ; rax2 -a
- 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 endianness de intercambio ; rax2 -e 0x33
- re decodificación base 64 ;
- mi codificar base64 ;
- F punto flotante ; rax2 -f 6,3 + 2,1
- F stdin hex código SLURP; rax2 -F <shellcode. [C / py / js]
- h ayuda ; rax2 -h
- yo volcar como matriz de bytes C; rax2 -i <bytes
- k mantener la base ; rax2 -k 33 + 3 -> 36
- K randomart ; rax2 -K 0x34 1020304050
- L bin -> hex (bignum); rax2 -L 111111111 # 0x1ff
- norte número binario ; rax2 -n 0x1234 # 34120000
- norte número binario ; rax2 -N 0x1234 # \ x34 \ x12 \ x00 \ x00
- r salida de 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
Algunos ejemplos:
244
Rax2
$ 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 |
| |
| |
| |
| |
+- - - - - - - - - - - - - - - - - +
245
Rax2
246
Rafind2
rafind2
Rafind2 es la línea de comandos de la fachada r_search biblioteca. Que le permite buscar cadenas, secuencias de bytes con
máscaras binarias, etc.
$ Rafind2 -h
Uso: rafind2 [-mXnzZhqv] [align -a] [-b sz] [-f / t / a] [- [e | s | S] str] [-x hex] fil e | dir ..
- un [align] accesos acepte solamente alineados
- b [tamaño] tamaño de bloque de conjunto
- e [expresiones regulares] buscar coincidencias de expresiones regulares (se puede utilizar varias veces)
- f [de] iniciar la búsqueda de la dirección 'de'
- h mostrar esta ayuda
- yo identificar el tipo de archivo (archivo -nqcpm r2)
- metro Búsqueda magia, de tipo de archivo tallador
- M [str] establece una máscara binaria para ser aplicado en las palabras clave
- norte no se detienen en casos de errores
- r imprimir utilizando comandos radare
- s [str] buscar una cadena específica (se puede utilizar varias veces)
- S [str] buscar una cadena específica de ancho (se puede utilizar varias veces)
- t [a] detener la búsqueda en la dirección 'a'
- q calma - no muestran partidas (nombres de archivo) sobre el juego contenidos (por defecto fo
r buscando un único archivo)
- v Versión de impresión y salir
- x [hex] búsqueda de cadena hexpair (909.090) (se puede utilizar varias veces)
- X mostrar hexdump de resultados de búsqueda
- z búsqueda de cero terminados en cadenas
- Z Mostrar cadena de encontrar en cada golpe de búsqueda
Eso es cómo usarlo, primero vamos a buscar "lib" dentro de la / bin / ls binario.
$ Rafind2 -s lib / bin / ls 0x5f9 0x675 0x679
. . .
PS
Tenga en cuenta que la salida es bastante escaso, y muestra los desplazamientos en la cadena lib es encontrado. entonces podemos utilizar esta salida para alimentar a
otras herramientas.
Contando resultados:
247
Rafind2
$ Rafind2 -s lib / bin / ls | wc -l
Viendo los resultados con el contexto:
$ Export F = / bin / ls
$ Para un rafind2 en `lib -s $ F`; hacer \
r2 ns $ -qc'x un 32' $ F; hecho
0x000005f9 6c69 622f 6479 6c64 .. lib / dyld ........ 0x00000675 6c69 622f 6c69 6275 .. lib /
libutil.dyli 0x00000679 6c69 6275 7469 6c2e .. libutil.dylib ... 0x00000683 6c69 6200 000c
0000 .. lib ...... 8 ...... 0x000006a5 6c69 622f 6c69 626e .. lib / libncurses.5 0x000006a9 6c69
626e 6375 7273 .. libncurses.5.4.d 0x000006ba 6c69 6200 0000 0C00 .. lib .... ... 8 .....
0x000006dd 6c69 622f 6c69 6253 .. lib / libSystem.B. 0x000006e1 6c69 6253 7973 7465 ..
libSystem.B.dyli 0x000006ef 6c69 6200 0000 0000 .. lib ...... y ......
Pero rafind2 puede también ser utilizado como un sustituto de expediente para identificar los tipo MIME de un archivo usando la base de datos interna de la magia
radare2.
$ Rafind2 -i / bin / ls 0x00000000 1
Mach-O
También funciona como una instrumentos de cuerda reemplazo, similar a lo que haces con -z rabin2, pero sin preocuparse de analizar las cabeceras y obedecer
secciones binarios.
$ Rafind2 -z / bin / ls | grep HTTP
0x000076e5% http: //www.apple.com/appleca/root.crl0 \ r 0x00007ae6
https://www.apple.com/appleca/0 0x00007fa9) http://www.apple.com/certificateauthority0
0x000080ab $ http: //crl.apple.com/codesigning.crl0
248
Rarun2
Rarun2
Rarun2 es una herramienta que permite configurar un entorno de ejecución especificada - redefinir stdin / stdout, tuberías, cambiar las variables de
entorno y otros ajustes útiles para elaborar las condiciones de contorno que necesita para ejecutar un binario para la depuración.
$ Rarun2 -h
Uso: rarun2 -v | -t | script.rr2 [Directiva ..]
Se necesita el archivo de texto en formato clave = valor para especificar el entorno de ejecución. Rarun2 se puede utilizar tanto como herramienta
independiente o como parte de radare2. Para cargar el perfil rarun2 en radare2 necesita utilizar cualquiera -
r para cargar el perfil desde un archivo o - R para especificar la directiva de la cadena.
El formato del perfil es muy simple. Tenga en cuenta las claves más importantes - programa y arg *
Uno de los casos de uso más comunes - redirigir la salida del programa depurado en radare2. Para ello, tiene que usar stdio, stdout,
stdin, de entrada, y un par claves similares.
Aquí está el ejemplo básico perfil:
249
Rarun2
programa = / bin / ls arg1 =
/ bin
# arg2 = hola
# arg3 = "hola \ Nworld"
# arg4 =: 048490184058104849
# arg5 = :! ragg2 -p n50 -d 10: 0x8048123
# arg6=@arg.txt
# Arg7 = @ 300 @ ABCD # 300 caracteres rellenos de patrón ABCD
# sistema = r2 -
# ASLR = no
setenv = FOO = BAR
# unsetenv = FOO
# clearenv = true
# envfile = environ.txt timeout = 3
# timeoutsig = SIGTERM # o 15
# conecte = localhost: 8080
# listen = 8080
# pty = false
# tenedor = true
# bits = 32
# pid = 0
# pidfile = / tmp / foo.pid
# # sueño = 0
# # maxfd = 0
# # execve = false
# # maxproc = 0
# # maxstack = 0
# # núcleo = false
# # stdio = blah.txt
# # stderr = foo.txt
# stdout = foo.txt
# stdin = entrada.txt # o programa! a redirigir la entrada de otro programa
# entrada = input.txt
# chdir = /
# chroot = / mnt / chroot
# libpath = $ PWD: / tmp / lib
# r2preload = yes
# precarga = / lib / libfoo.so
# setuid = 2000
# seteuid = 2000
# setgid = 2001
# setegid = 2001
# agradables = 5
250
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 y otros datos. 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 o cualquier formato soportado por los plugins, y es capaz de obtener símbolo de
importación / exportación, las dependencias de bibliotecas, las cadenas de secciones de datos, referencias externas, la dirección del punto de entrada, secciones,
arquitectura tipo.
$ 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] |
expediente
- @ [Addr] mostrar la sección, símbolo o importación en addr
- UNA 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)
- sol mismo que -SMZIHVResizcld (mostrar toda la información)
- G [addr] dirección de carga. desplazamiento a la cabecera
- h este mensaje de ayuda
- H 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
251
Rabin2
- 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)
- 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
. . . . . .
252
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 un tipo binario, al igual que su codificación,
endianness, la clase, el sistema operativo:
$ Rabin2 -I / bin / ls arco
x86
binsz 128456
bintype bits de elf
64
canario clase verdadera
ELF64
cripto falsa endian poco
havecode cierto INTRP
Microesfera
/lib64/ld-linux-x86-64.so.2
lang do
lineNum falsas lsyms
falso
máquina AMD arquitectura x86-64 maxopsz 16 minopsz 1
nx
cierto
OS Linux
pcalign 0 pic
cierto
reubicaciones falsa
RELRO parcial
rpath NINGUNA
falsa estática despojado
verdaderos SUBSYS VA
Linux
cierto
Para que la información de salida rabin2 en el formato que el programa principal, radare2, puede entender, pase -
IR opción a la misma:
253
La identificación del archivo
$ Rabin2 -iR / bin / ls e cfg.bigendian =
e asm.bits falsas = 64 e asm.dwarf =
true e bin.lang = ce file.type = e
asm.os elf = Linux e asm.arch = x86 e
asm.pcalign = 0
254
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]
vaddr = 0x00005310 PADDR = 0x00005310 0x00000000 = baddr laddr = 0x00000000 0x00000018 = HAddr típico programa de e =
1 puntos de entrada
$ Rabin2 -er / bin / ls fs símbolos
f Entry0 1 @ 0x00005310 f entry0_haddr 1 @
0x00000018 s Entry0
255
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 llamada
instrucción. Pasar - yo bandera para rabin2 para obtener una lista de las importaciones. Un ejemplo:
$ Rabin2 -i / bin / ls [importaciones]
1 0x000032e0 GLOBAL __ctype_toupper_loc FUNC
2 0x000032f0 GLOBAL getenv FUNC
3 0x00003300 GLOBAL sigprocmask FUNC
4 0x00003310 GLOBAL __snprintf_chk FUNC
5 0x00003320 GLOBAL aumento FUNC
6 0x00000000 GLOBAL FUNC libre
7 0x00003330 GLOBAL FUNC aborto
8 0x00003340 GLOBAL __errno_location FUNC
9 0x00003350 GLOBAL strncmp FUNC
10 0x00000000 _ITM_deregisterTMCloneTable notype DEBIL
11 0x00003360 GLOBAL localtime_r FUNC
12 0x00003370 GLOBAL _exit FUNC
13 0x00003380 GLOBAL strcpy FUNC
14 0x00003390 GLOBAL __fpending FUNC
15 0x000033a0 GLOBAL isatty FUNC
16 0x000033b0 GLOBAL sigaction FUNC
17 0x000033c0 GLOBAL iswcntrl FUNC
18 0x000033d0 GLOBAL wcswidth FUNC
19 0x000033e0 GLOBAL localeconv FUNC
20 0x000033f0 GLOBAL mbstowcs FUNC
21 0x00003400 GLOBAL readlink FUNC
. . .
256
exportaciones
exportaciones
Rabin2 es capaz de encontrar las exportaciones. Por ejemplo:
$ Rabin2 -E /usr/lib/libr_bin.so | cabeza [exportaciones]
210 0x000ae1f0 0x000ae1f0 GLOBAL FUNC 200 r_bin_java_print_exceptions_attr_summary 211 0x000afc90 0x000afc90 GLOBAL FUNC 135
r_bin_java_get_args
212 0x000b18e0 0x000b18e0 GLOBAL FUNC 35 r_bin_java_get_item_desc_from_bin_cp_list 213 0x00022d90 0x00022d90 GLOBAL FUNC 204
r_bin_class_add_method 214 0x000ae600 0x000ae600 GLOBAL FUNC 175 r_bin_java_print_fieldref_cp_summary 215 0x000ad880 0x000ad880 GLOBAL FUNC
144 r_bin_java_print_constant_value_attr_summar y
216 0x000b7330 0x000b7330 GLOBAL FUNC 679 r_bin_java_print_element_value_summary 217 0x000af170 0x000af170 GLOBAL FUNC 65
r_bin_java_create_method_fq_str 218 0x00079b00 0x00079b00 GLOBAL FUNC 15 LZ4_createStreamDecode
257
Símbolos (exportaciones)
Símbolos (Exportaciones)
Con rabin2, el formato de la lista de símbolos generado es similar a la lista de importaciones. Utilizar el - s opción para conseguirlo:
rabin2 -s / bin / ls | cabeza [símbolos]
110 0x000150a0 0x000150a0 GLOBAL FUNC 56 _obstack_allocated_p 111 0x0001f600 0x0021f600 GLOBAL OBJ 8
program_name 112 0x0001f620 0x0021f620 GLOBAL OBJ 8 stderr 113 0x00014f90 0x00014f90 GLOBAL FUNC 21
_obstack_begin_1 114 0x0001f600 0x0021f600 WEAK OBJ 8 program_invocation_name 115 0x0001f5c0 0x0021f5c0
GLOBAL OBJ 8 alloc_failed_handler 116 0x0001f5f8 0x0021f5f8 GLOBAL OBJ 8 OPTARG 117 0x0001f5e8
0x0021f5e8 GLOBAL OBJ 8 stdout 118 0x0001f5e0 0x0021f5e0 GLOBAL OBJ 8 program_short_name
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 de cabeza fs
f sym.obstack_allocated_p 56 0x000150a0 f sym.program_invocation_name
8 0x0021f600 f sym.stderr 8 0x0021f620
f sym.obstack_begin_1 21 0x00014f90 f sym.program_invocation_name 8 0x0021f600
f sym.obstack_alloc_failed_handler 8 0x0021f5c0 f sym.optarg 8 0x0021f5f8 f
sym.stdout 8 0x0021f5e8
f sym.program_invocation_short_name 8 0x0021f5e0
258
bibliotecas
Bibliotecas lista
Rabin2 puede listar las bibliotecas utilizadas por un binario con el - l opción:
-L $ rabin2 `cuales r2` [Linked
bibliotecas] libr_core.so libr_parse.so
libr_search.so libr_cons.so libr_config.so
libr_bin.so libr_debug.so libr_anal.so
libr_reg.so libr_bp.so libr_io.so libr_fs.so
libr_asm. por lo libr_syscall.so
libr_hash.so libr_magic.so libr_flag.so
libr_egg.so libr_crypto.so libr_util.so
libpthread.so.0 libc.so.6
22 bibliotecas
Vamos a comprobar la salida con LDD mando:
259
bibliotecas
$ Ldd `cuales r2`
linux-vdso.so.1 (0x00007fffba38e000)
libr_core.so => /usr/lib64/libr_core.so (0x00007f94b4678000) libr_parse.so => /usr/lib64/libr_parse.so (0x00007f94b4425000) libr_search.so =>
/usr/lib64/libr_search.so (0x00007f94b421f000) libr_cons. so => /usr/lib64/libr_cons.so (0x00007f94b4000000) libr_config.so => /usr/lib64/libr_config.so
(0x00007f94b3dfa000) libr_bin.so => /usr/lib64/libr_bin.so (0x00007f94b3afd000) libr_debug.so = > /usr/lib64/libr_debug.so (0x00007f94b38d2000) libr_anal.so
=> /usr/lib64/libr_anal.so (0x00007f94b2fbd000) libr_reg.so => /usr/lib64/libr_reg.so (0x00007f94b2db4000) libr_bp.so => / usr / lib64 / libr_bp.so
(0x00007f94b2baf000) libr_io.so => /usr/lib64/libr_io.so (0x00007f94b2944000) libr_fs.so => /usr/lib64/libr_fs.so (0x00007f94b270e000) libr_asm.so => / usr /
lib64 / libr_asm.so (0x00007f94b1c69000) libr_syscall.so =>/usr/lib64/libr_syscall.so (0x00007f94b1a63000) libr_hash.so => /usr/lib64/libr_hash.so
(0x00007f94b185a000) libr_magic.so => /usr/lib64/libr_magic.so (0x00007f94b164d000) libr_flag.so => / usr /lib64/libr_flag.so (0x00007f94b1446000) libr_egg.so
=> /usr/lib64/libr_egg.so (0x00007f94b1236000) libr_crypto.so => /usr/lib64/libr_crypto.so (0x00007f94b1016000) libr_util.so => / usr / lib64 /libr_util.so
(0x00007f94b0d35000) libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f94b0b15000) libc.so.6 => /lib64/libc.so.6 (0x00007f94b074d000) libr_lang.so => / usr
/lib64/libr_lang.so (0x00007f94b0546000) libr_socket.so => /usr/lib64/libr_socket.so (0x00007f94b0339000) libm.so.6 => /lib64/libm.so.6 (0x00007f94affaf000)
libdl.so.2 => /lib64/libdl.so.2 (0x00007f94afdab000) /lib64/ld-linux-x86-64.so.2 (0x00007f94b4c79000)tan (0x00007f94b1a63000) libr_hash.so =>
/usr/lib64/libr_hash.so (0x00007f94b185a000) libr_magic.so => /usr/lib64/libr_magic.so (0x00007f94b164d000) libr_flag.so => /usr/lib64/libr_flag.so (
0x00007f94b1446000) libr_egg.so => /usr/lib64/libr_egg.so (0x00007f94b1236000) libr_crypto.so => /usr/lib64/libr_crypto.so (0x00007f94b1016000) libr_util.so
=> /usr/lib64/libr_util.so (0x00007f94b0d35000) libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f94b0b15000) libc.so.6 => /lib64/libc.so.6
(0x00007f94b074d000) libr_lang.so => /usr/lib64/libr_lang.so ( 0x00007f94b0546000) libr_socket.so => /usr/lib64/libr_socket.so (0x00007f94b0339000) libm.so.6
=> /lib64/libm.so.6 (0x00007f94affaf000) libdl.so.2 => /lib64/libdl.so. 2 (0x00007f94afdab000) /lib64/ld-linux-x86-64.so.2 (0x00007f94b4c79000)tan
(0x00007f94b1a63000) libr_hash.so => /usr/lib64/libr_hash.so (0x00007f94b185a000) libr_magic.so => /usr/lib64/libr_magic.so (0x00007f94b164d000)
libr_flag.so => /usr/lib64/libr_flag.so ( 0x00007f94b1446000) libr_egg.so => /usr/lib64/libr_egg.so (0x00007f94b1236000) libr_crypto.so => /usr/lib64/libr_crypto.so
(0x00007f94b1016000) libr_util.so => /usr/lib64/libr_util.so (0x00007f94b0d35000) libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f94b0b15000) libc.so.6 =>
/lib64/libc.so.6 (0x00007f94b074d000) libr_lang.so => /usr/lib64/libr_lang.so ( 0x00007f94b0546000) libr_socket.so => /usr/lib64/libr_socket.so
(0x00007f94b0339000) libm.so.6 => /lib64/libm.so.6 (0x00007f94affaf000) libdl.so.2 => /lib64/libdl.so. 2 (0x00007f94afdab000) /lib64/ld-linux-x86-64.so.2
(0x00007f94b4c79000)so => /usr/lib64/libr_hash.so (0x00007f94b185a000) libr_magic.so => /usr/lib64/libr_magic.so (0x00007f94b164d000) libr_flag.so =>
/usr/lib64/libr_flag.so (0x00007f94b1446000) libr_egg.so = > /usr/lib64/libr_egg.so (0x00007f94b1236000) libr_crypto.so => /usr/lib64/libr_crypto.so
(0x00007f94b1016000) libr_util.so => /usr/lib64/libr_util.so (0x00007f94b0d35000) libpthread.so.0 = > /lib64/libpthread.so.0 (0x00007f94b0b15000) libc.so.6 =>
/lib64/libc.so.6 (0x00007f94b074d000) libr_lang.so => /usr/lib64/libr_lang.so (0x00007f94b0546000) libr_socket.so = > /usr/lib64/libr_socket.so
(0x00007f94b0339000) libm.so.6 => /lib64/libm.so.6 (0x00007f94affaf000) libdl.so.2 => /lib64/libdl.so.2 (0x00007f94afdab000) / lib64 /ld-linux-x86-64.so.2
(0x00007f94b4c79000)so => /usr/lib64/libr_hash.so (0x00007f94b185a000) libr_magic.so => /usr/lib64/libr_magic.so (0x00007f94b164d000) libr_flag.so => /usr/lib64/libr_flag.so (0x00007f94b1446000) libr_egg.so = > /usr/lib64/libr_egg.so (0x
libssl.so.1.0.0 => /usr/lib64/libssl.so.1.0.0 (0x00007f94afb3c000) libcrypto.so.1.0.0 => /usr/lib64/libcrypto.so.1.0.0
(0x00007f94af702000) libutil. SO.1 => /lib64/libutil.so.1 (0x00007f94af4ff000) libz.so.1 => /lib64/libz.so.1 (0x00007f94af2e8000)
Si se comparan los resultados de rabin2 -l y LDD, notará que rabin2 enumera un menor número de bibliotecas que LDD. La razón es que
rabin2 no sigue y no muestra las dependencias de bibliotecas. Sólo se muestran las dependencias binarias directos.
260
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
000 0x000160f8 0x000160f8 11 12 (.rodata) ascii dev_ino_pop 001 0x00016188 0x00016188 10 11 (.rodata)
ascii sort_files 002 0x00016193 0x00016193 6 7 (.rodata) ascii posix003 0x0001619a 0x0001619a 4 5 (.rodata)
ascii principal 004 0x00016250 0x00016250 10 11 (. Rodata) ascii? pcdb-lswd
005 0x00016260 0x00016260 65 66 (.rodata) archivo de configuración ASCII # para dircolors, una utilidad para ayudarle a configurar el
006 0x000162a2 0x000162a2 72 73 (.rodata) Variable ASCII # LS_COLORS entorno de ls de GNU con la opción -color.
007 0x000162eb 0x000162eb 56 57 (.rodata) ascii # Copyright (C) 1996-2018 gratuito Softwar e Foundation, Inc.
008 0x00016324 0x00016324 70 71 (.rodata) ascii # copia y distribución de este fil
e, con o sin modificación,
009 0x0001636b 0x0001636b 76 77 (.rodata) se permiten ascii # siempre que el aviso de copyright y este aviso se conservan.
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
stringsf fs str.dev_ino_pop 12 @ 0x000160f8 Cs 12 @ 0x000160f8
f str.sort_files 11 @ 0x00016188 Cs 11 @ 0x00016188
f str.posix 7 @ 0x00016193 Cs 7 @
0x00016193
f str.main 5 @ 0x0001619a Cs 5 @
0x0001619a
f str.pcdb_lswd 11 @ 0x00016250 Cs 11 @ 0x00016250
261
Las partes del programa
Rabin2 llamada con el - S 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]
00 0x00000000 0 0x00000000 0 ----
01 0x00000238 28 0x00000238 28 -r-- .interp
02 0x00000254 32 0x00000254 32 -r-- .note.ABI_tag
03 176 0x00000278 0x00000278 176 -r-- .gnu.hash 04 0x00000328 0x00000328 3000 3000 -r--
.dynsym 05 0x00000ee0 1412 0x00000ee0 1412 -r-- .dynstr 06 250 0x00001464 0x00001464 250 -r--
.gnu.version 07 0x00001560 112 112 0x00001560 -r-- .gnu.version_r 08 0x000015d0 4944
0x000015d0 4944 -r-- .rela.dyn 09 0x00002920 0x00002920 2448 2448 -r-- .rela.plt 10 0x000032b0
23 0x000032b0 23 .init -rx
11 0x000032d0 1648 0x000032d0 1648 -rx .plt 12 0x00003940
24 0x00003940 24 -rx .plt.got
13 0x00003960 73931 0x00003960 73931 -rx .text 14 0x00015a2c
9 0x00015a2c 9 -rx .fini
15 0x00015a40 20201 0x00015a40 20201 -r-- .rodata 16 0x0001a92c 2164 0x0001a92c 2164 -r--
.eh_frame_hdr 17 0x0001b1a0 11384 0x0001b1a0 11384 -r-- .eh_frame 18 0x0001e390
8 0x0021e390 8 -rw- .init_array
19 0x0001e398 8 0x0021e398 8 -rw- .fini_array
20 0x0001e3a0 2616 0x0021e3a0 2616 -rw- .data.rel.ro 21 0x0001edd8 480 0x0021edd8 480 -rw-
.dynamic 22 0x0001efb8
56 0x0021efb8 56 -rw- .got
23 0x0001f000 840 0x0021f000 840 -rw- .got.plt 24 0x0001f360 616 0x0021f360 616 -rw-
.data 25 0x0001f5c8
0 0x0021f5e0 4824 -rw- .bss
26 0x0001f5c8 232 0x00000000 232 ---- .shstrtab
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.
262
$ Rabin2 -SR / bin / ls | secciones de cabeza fs
S 0x00000000 0x00000000 0x00000000 0x00000000 0 sección f. 0 0x00000000 f
section_end. 1 0x00000000
la sección CC 0 va = 0x00000000 pa = 0x00000000 sz = 0 vsz = 0 rwx = ---- @ 0x00000000 S 0x00000238 0x00000238 0x0000001c
0x0000001c .interp 4 f section..interp 28 0x00000238 f section_end..interp 1 0x00000254
la sección CC 1 va = 0x00000238 pa = 0x00000238 sz = 28 vsz = 28 rwx = -r-- .interp @ 0x00000238 S 0x00000254 0x00000254 0x00000020
0x00000020 .note.ABI_tag 4
263
Radiff2
Radiff2
Radiff2 es una herramienta diseñada para comparar archivos binarios, similar a la forma habitual diff compara archivos de texto.
$ Radiff2 -h
Uso: radiff2 [-abBcCdjrspOxuUvV] [-A [A]] [-g sym] [-t%] [archivo] [archivo]
- un [arco] especificar la arquitectura plugin para usar (x86, brazo, ..)
- A [-a] ejecutar aaa o AAAA después de cargar cada uno binario (ver -C)
- b [bits de] especifican regístrese tamaño para el arco (16 (pulgar), 32, 64, ..)
- segundo salida en diff binario (GDIFF)
- do recuento de los cambios
- do código graphdiff (columnas: off-A, fósforo-ratio, off-B) (véase -A)
- re Diferenciando uso delta
- re disasm mostrar en lugar de hexpairs
- e [k = v] establecer el valor var config eval para todas las instancias RCore
- g [sym | DES1, DES2] diff gráfico de símbolo dado, o entre dos desplazamientos
- G [cmd] ejecutar un comando R2 en cada caso RCore creado
- yo diff importaciones de archivos de destino (véase -u, -U y -z)
- j salida en formato JSON
- norte imprimir direcciones desnudos solamente (diff.bare = 1)
- O diffing código de bytes de código de operación con sólo
- pag utilizar direccionamiento físico (io.va = 0)
- q el modo silencioso (desactivar colores, reducir la producción)
- r salida en los comandos radare
- s Calcular distancia de edición (sin sustitución, Eugene W. Myers' O (ND) diff algorit
hm)
- ss calcular Levenshtein distancia de edición (se permite la sustitución, O (N ^ 2))
- S [nombre] diff código de clasificación (nombre, nameLen, addr, tamaño, tipo, dist) (sólo para -C o -g)
- t [0-100] establecer el umbral para diff código (por defecto es 70%)
- X mostrar dos columnas hexdump diffing
- u salida unificada (--- +++)
- T unificado de salida usando el sistema 'diff'
- v información de concierto versión
- V ser prolijo (corriente sólo para -s)
- z diff en cadenas extraídas
264
binaria diffing
binaria diffing
Esta sección se basa en la http://radare.today artículo " Diferenciando binaria "
Sin ningún parámetro, radiff2 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 con el - s opción:
$ 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, con el - do opción:
$ Radiff2 -c genuina agrietado 2
Si no está seguro de si se trata de binarios similares, con - do 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".
265
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_s tart_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 - la adición - UNA 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 86
sub.fileno_510
sub .__ freading_4c0 59 0x44c0 | UNMATCH (0.949153) | 0x44d0 59
sub .__ freading_4d0
sub.fileno_440 120 0x4440 | UNMATCH (0.200000) | 0x4450 120
sub.fileno_450
sub.setlocale_fa0 64 0x3fa0 | UNMATCH (0.104651) | 0x3fb0 64
sub.setlocale_fb0
fcn.00003a50 120 0x3a50 | UNMATCH (0.125000) | 0x3a60 120
fcn.00003a60
Y ahora una característica interesante: radare2 apoya gráfico-diffing, a la DarunGrim , con el - sol 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, radiff2 -g principal / bin / true / bin / false | xdot - mostrará las diferencias en principal() la función de Unix cierto y falso programas.
Se puede comparar a radiff2
- g principal / bin / false / bin / true ( Observe el orden de los argumentos) para obtener las dos versiones. Este es el resultado:
266
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 la imagen tiene
edi mov, 0x1; llamar sym.imp.exit, mientras 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.
267
Rasm2
Rasm2
rasm2 es un ensamblador / desensamblador. Inicialmente, rasm herramienta fue diseñada para ser utilizado para parchear binarios. Su función principal es
conseguir bytes correspondientes al código de instrucción máquina determinada.
$ Rasm2 -h
Uso: rasm2 [-ACdDehLBvw] [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)
- UNA Análisis de información de concierto hexpairs dados
- b [bits de] Conjunto cpu tamaño registro (8, 16, 32, 64) (RASM2_BITS)
- segundo Binaria de entrada / salida (-l es obligatorio para la entrada binaria)
- 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
- mi expresión de visualización ESIL (misma entrada como en -d)
- f [Archivo] Leer datos de archivo
- F [en: Fuera] Especificar entrada y / o filtros de salida (att2intel, x86.pseudo, ...)
- h, hh Mostrar esta ayuda, hh por mucho tiempo
- i [len] ignorar / omitir N bytes de la memoria intermedia de entrada
- j salida en formato JSON
- k [kernel] Seleccionar sistema operativo (Linux, Windows, Darwin, ..)
- l [len] Entrada / Salida de longitud
- L plugins Lista Asm: (a = asm, d = disasm, A = analizar, e = ESIL)
- 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)
- pag Ejecutar SPP sobre la entrada para el montaje
- q Modo silencioso
- r salida en los comandos radare
- s [sintaxis] Select sintaxis (Intel, att)
- 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 '-' se lee de la entrada
estándar para el Medio Ambiente:
RASM2_NOPLUGINS no se cargan los plugins compartidos (carga aceleración) RASM2_ARCH
mismo que -a rasm2
RASM2_BITS mismo que -b rasm2
R_DEBUG Si se define, mostrar mensajes de error y señal de choque
Plugins para arquitecturas de destino soportadas pueden ser listados con la - L opción. Conociendo un nombre del plugin, se puede usar
especificando su nombre a la - una opción
268
Rasm2
$ -L rasm2 _dAe 8 16
6502 LGPL3 6502 CPU / NES / C64 / Tamagotchi / T-1000
_dAe 8 8051 PD 8051 CPU Intel
_dA_ 16 32 arco GPL3 Argonaut RISC Core
a___ 16 32 64 arm.as LGPL3 como ARM ensamblador (uso ARM_AS medio ambiente)
Adae brazo 16 32 64 BSD desensamblador Capstone ARM
_dA_ 16 32 64 arm.gnu GPL3 Acorn RISC CPU de la máquina
_d__ 16 32 desensamblador ARM arm.winedbg LGPL2 WineDBG
Adae 8 16 avr GPL Atmel AVR
Adae 16 32 64 bf LGPL3 Brainfuck (por pancake, nibble) v4.0.0
_dA_ 32 Chip8 desensamblador LGPL3 Chip8
_dA_ 16 CR16 Plugin de desmontaje LGPL3 CR16
_dA_ 32 cris GPL3 Axis Communications 32-bit procesador embebido
adA_ 32 64 Dalvik LGPL3 AndroidVM Dalvik
ad__ 16 dcpu16 PD de Mojang DCPU-16
_dA_ 32 64 EBC LGPL3 EFI Bytecode
adae 16 gb LGPL3 GameBoy (TM) (z80-like)
_dAe 16 h8300 LGPL3 H8 / 300 plugin de desmontaje
_dAe 32 hexágono LGPL3 Qualcomm Hexágono (QDSP6) V6
_d__ 32 hppa GPL3 HP PA-RISC
_dAe i4004 LGPL3 Intel 4004 microprocesador
_dA_ 8 i8080 BSD Intel 8080 CPU
adA_ 32 Java código de bytes de Java Apache
_d__ 32 Lanai GPL3 LANAI
_d__ 8 lh5801 desensamblador LGPL3 SHARP LH5801
_d__ 32 LM32 BSD plug-in para el desmontaje del enrejado Micro 32 ISA
_dA_ 16 32 m68k BSD desensamblador Capstone M68K
_dA_ 32 Malbolge LGPL3 Malbolge ternario VM
_d__ 16 mcs96 coche LGPL3 condrets
Adae 16 32 64 MIPS BSD desensamblador Capstone MIPS
Adae 32 64 mips.gnu GPL3 CPU MIPS
_dA_ 16 msp430 LGPL3 complemento msp430 desmontaje
_dA_ 32 nios2 GPL3 NIOS II procesador integrado
_dAe 8 Foto desensamblador LGPL3 PIC
_dAe 32 64 ppc BSD desensamblador Capstone PowerPC
_dA_ 32 64 ppc.gnu GPL3 PowerPC
_d__ 32 hélice LGPL3 plugin de hélice desmontaje
_dA_ 32 64 riscv GPL RISC-V
_dAe 32 RSP Procesador de señal LGPL3 Realidad
_dAe 32 sh GPL3 SuperH-4 CPU
_dA_ 8 16 SNES CPU LGPL3 SuperNES
_dAe 32 64 SPARC BSD desensamblador Capstone SPARC
_dA_ 32 64 sparc.gnu GPL3 Escalable arquitectura del procesador
_d__ 16 SPC700 SPC700, el chip de sonido de SNES' LGPL3
_d__ 32 sysz BSD Systemz desensamblador CPU
_dA_ 32 TMS320 LGPLv3 familia TMS320 DSP (C54x, C55x, C55x +, C64x)
_d__ 32 tricore GPL3 CPU Siemens TriCore
_dAe 32 v810 LGPL3 complemento v810 desmontaje
_dAe 32 V850 LGPL3 complemento V850 desmontaje
_dAe 8 32 VAX GPL VAX
269
Rasm2
adA_ 32 era m MIT WebAssembly (por cgvwzq) v0.1.0
_dA_ 32 ws Los espacios en blanco LGPL3 esotéricos VM
a___ 16 32 64 x86.as LGPL3 Intel X86 GNU Assembler
_dAe 16 32 64 X 86 BSD desensamblador Capstone X86
a___ 16 32 64 x86.nasm LGPL3 X86 ensamblador nasm
a___ 16 32 64 x86.nz LGPL3 x86 ensamblador hecho a mano
_dA_ 16 XAP PD XAP4 RISC (CSR)
_dA_ 32 Xcore BSD desensamblador Capstone Xcore
_dAe 32 Xtensa GPL3 CPU Xtensa
adA_ 8 z80 GPL 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.
270
Montar
Ensamblador
Montaje es la acción a realizar una instrucción de ordenador en forma legible por humanos (uso de las sentencias) y convertir eso en un montón de
bytes que puede ser ejecutado por una máquina.
En radare2, la lógica ensamblador y desensamblador se implementa en el r asm * API, y puede ser utilizado con los comandos de PA y de
ratón de la línea de comandos así como el uso rasm2.
Rasm2 se puede utilizar para hexpairs que representan una instrucción de máquina dada pegado copian rápidamente. La siguiente línea es el
montaje de esta instrucción mov para x86 / 32.
$ Rasm2 -a -b x 86 32 'mov eax, 33' b821000000
Aparte de la especificación de la entrada como un argumento, también puede canalizarlo a rasm2:
$ Echo 'eax empuje; nop; nop' | rasm2 -f 5090
Como se ha visto, rasm2 puede montar una o muchas instrucciones. En línea separándolas con un punto y coma; , Pero también se puede leer que a
partir de un archivo, utilizando genérica nasm / gas / .. sintaxis y directivas. Puede comprobar la página de manual rasm2 para más detalles sobre
esto.
los Pensilvania y almohadilla son un subcomandos de impresión, lo que significa que sólo se imprimirán montaje o desmontaje. En caso de que quiera
escribir realmente la instrucción que se requiere para utilizar Washington o wx
comandos con la cadena de montaje o bytes anexa.
El ensamblador comprende los siguientes idiomas de entrada y sus sabores: X 86 ( Intel y AT & T variantes), Olly ( OllyDbg sintaxis), PowerPC
( PowerPC), 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.
Vamos a crear un archivo de ensamblaje llamado selfstop.rasm:
271
Montar
; 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;
jubilado
Ahora podemos ensamblarlo en su lugar:
[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 jubilado
0x0000001d c3 jubilado
272
Montar
modo visual
Montaje también es accesible en modo visual radare2 mediante presión UNA clave para insertar el conjunto en el desplazamiento actual.
Lo bueno de escribir ensamblaje utilizando la interfaz ensamblador visual que los cambios se realizan en la memoria hasta que se pulsa
enter.
Para que pueda comprobar el tamaño del código y qué instrucciones se coloque por encima antes de comprometerse a los cambios.
273
Desmontar
desensamblador
Desmontan es la acción inversa de montaje. Rasm2 toma hexpair como una entrada (pero también puede tener un archivo en formato binario) y
mostrar el formato legible por humanos.
Para ello podemos utilizar el - re opción de rasm2 como este:
$ Rasm2 -a -b x 86 32 -d '90' nop
Rasm2 también tienen la - re la bandera para mostrar el desmontaje como - re lo hace, sino que incluye offset y bytes.
En radare2 hay muchos comandos para realizar un desmontaje de un lugar específico en la memoria.
Que podría estar interesado en probar si usted quiere diversas salidas para su posterior análisis con las secuencias de comandos, o simplemente grep para
encontrar lo que busca:
pd N
Desmontar instrucciones N
pD N
Desmontar N bytes
pda
Desmontar todas las instrucciones (en busca de 1 byte, o el tamaño mínimo de instrucciones de alineación), que pueden ser útiles para la ROP
PI, PI
Igual que pd y pd, pero utilizando una salida simple.
274
Configuración
Configuración desensamblador
El ensamblador y desensamblador tienen muchos pequeños interruptores de ajustar la salida.
Esas configuraciones están disponibles a través de la mi mando. Aquí están los más comunes:
asm.bytes - mostrar / ocultar bytes asm.offset
- mostrar / ocultar asm.lines offset - líneas
mostrar / ocultar
asm.ucase - Mostrar disasm en mayúsculas
.. .
Utilizar el e ?? asm. para más detalles.
275
Ragg2
ragg2
ragg2 significa radare2 huevo, este es el bloque básico para construir fragmentos reubicables de código para ser utilizado para la inyección en los procesos
de destino cuando se hace explotar.
ragg2 compila los programas escritos en un simple lenguaje de alto nivel en pequeños binarios para x86, x86-64, y ARM.
Por defecto se compilará su propia ragg2 idioma, pero también se puede compilar código C usando GCC o shellcodes Clang dependiendo de la
extensión de archivo. Vamos a crear el archivo denominado C AC:
En t principal () {
escribir( 1 , "Hola mundo \ n" , 13 );
regreso 0 ; }
$ Ragg2 -a x 86 -b32 ac
e900000000488d3516000000bf01000000b80400000248c7c20d0000000f0531c0c348656c6c6f20576f726c 640a00
$ Rasm2 -a -b x 86 32 -D e900000000488d3516000000bf01000000b80400000248c7c20d0000000f0531 c0c348656c6c6f20576f726c640a00 0x00000000 5
e900000000 JMP 5
0x00000005 1 48 diciembre eax
0x00000006 6 8d3516000000 lea ESI, [0x16]
0x0000000c 5 bf01000000 mov edi, 1
0x00000011 5 b804000002 mov eax, 0x2000004
0x00000017 6 c7c20d000000 MOV EDX, 0xd
0x0000001d 2 syscall 0f05
0x0000001f 2 31c0 xor eax, eax
0x00000021 1 ret c3
0x00000023 2 656C byte InSb es: [edi], dx
0x00000025 1 6c byte InSb es: [edi], dx
0x00000026 1 6f outsd dx, dword [ESI]
0x00000027 3 20576f y el byte [edi + 0x6F], dl
0x0000002a 2 726c jb 0x98
0x0000002c 3 640a00 o al, fs byte: [eax]
Compilar ejemplo ragg2

276
Ragg2
$ Hello.r gato salida @
syscall (1);
@ mundial principal () {
de salida (2); }
$ Ragg2 -a -b x 86 64 hello.r
48c7c00200000050488b3c2448c7c0010000000f054883c408c3 0x00000000 1
48 diciembre eax
0x00000001 6 c7c002000000 mov eax, 2
0x00000007 1 50 empuje eax
0x00000009 3 8b3c24 MOV EDI, DWORD [esp]
0x0000000c 1 48 diciembre eax
0x0000000d 6 c7c001000000 mov eax, 1
0x00000013 2 syscall 0f05
0x00000016 3 83c408 añaden ESP, 8
0x00000019 1 ret c3
$ Rasm2 -a -b x 86 64 -D 48c7c00200000050488b3c2448c7c0010000000f054883c408c3 0x00000000 7
48c7c002000000 rax mov, 2
0x00000007 1 50 empuje rax
0x00000008 4 488b3c24 mov RDI, QWord [RSP]
0x0000000c 7 48c7c001000000 rax mov, 1
0x00000013 2 syscall 0f05
0x00000015 4 4883c408 añadir RSP, 8
0x00000019 1 ret c3
binarios minúsculos
Se pueden crear utilizando la - F bandera en ragg2, o la - do en rabin2.
277
Idioma
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 en el entorno de pila
comienzo de la función, y hay que definir las funciones de
Para evitar recibir errores de compilación.
El compilador genera código ensamblador para x86 {32,64} y el brazo. Pero su objetivo
soporte para 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, posición-
huevos crudos independientes para ser inyectados en los procesos en ejecución o para parche
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 en una sola entidad
múltiples lugares. Los alias se traducen en equ '' declaraciones de ensamblaje
idioma. Esto es sólo una palabra clave de redefinición a nivel de ensamblador.
AF_INET @ alias (2);
printf @ alias (0x8053940);
incluye
Utilizar gato (1) o el preprocesador para concatenar varios archivos para ser compilado.
278
Idioma
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 sea
definido será el primero en ser ejecutado. Si desea ejecutar main ()
acaba de 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. esos bloques
están obligados 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
stackframesize: obtener el espacio de pila para almacenar las variables locales
279
Idioma
staticframesize: obtener 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
de salida (0);
bibliotecas
Por el momento no hay soporte para vincular los programas r_egg al sistema de
bibliotecas. 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
280
Idioma
Hay un trabajo en progreso libc-como biblioteca escrito completamente en r_egg
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 el
encima de la pila, los símbolos no 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 el
'Traza' la arquitectura 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
281
Idioma
TODO: A0, A1, A2, A3, SP, FP, BP, PC
operaciones matemáticas
Ragg2 apoya la asignación de variables locales operativo matemáticas, incluyendo
los siguientes operadores:
+ - * /Y|^
Los valores de retorno
El valor de retorno se almacena en el registro a0, este registro se establece cuando
llamar a una función o al escribir un nombre de variable sin asignación.
$ Cat test.r añadir @
mundial (4) {
. var0 = .arg0 + .arg1;
. var0; }
añadir (3,4); }
$ Ragg2 -F -o test.r prueba ./test $ $ echo $?
trampas
Cada arquitectura tiene una instrucción diferente para romper la ejecución de
el programa. idioma Regg capta las llamadas a 'break ()' para ejecutar el emit_trap
de devolución de llamada del arco seleccionado. los
rotura() ; -> compila en 'int3' en x86
descanso; -> compila en 'int3' en x86
ensamblado en línea
282
Idioma
Las líneas que comienzan con ':' carbón son sólo entre líneas en el conjunto de salida.
: JMP 0x8048400
: 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}
rotura () - 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
283
Rahash2
rahash2
La herramienta rahash2 se puede utilizar para calcular las sumas de comprobación de archivos, dispositivos de disco o cadenas. Por bloques o en su totalidad utilizando
diversos algoritmos hash.
Esta herramienta también es capaz de hacer algunas operaciones de codificación / decodificación como base64 y codificación XOR.
Este es un ejemplo de uso:
$ Rahash2 -a -s MD5 "hola mundo"
Tenga en cuenta que rahash2 también permite leer de la entrada estándar en una corriente, por lo que no es necesario 4 GB de RAM para calcular el hash de un archivo
de 4 GB.
Hash por bloques
Al hacer la medicina forense, es útil para calcular las sumas de comprobación parciales. La razón de esto es porque es posible que desee dividir un archivo grande
en pequeñas porciones que son más fáciles de identificar por su contenido o regiones en el disco.
Esto se dará el mismo hash de bloques que contienen el mismo contenido. Por ejemplo, si se llena con ceros.
Pero, además, se puede utilizar para encontrar qué bloques han cambiado entre más de un vertedero de muestra.
Esto puede ser útil en el análisis de carnero volcados desde una máquina virtual, por ejemplo. Utilice este comando para esto:
$ 1M rahash2 -B -b -a SHA256 / bin / ls
Hash con rabin2
La herramienta rabin2 analiza las cabeceras binarios de los archivos, sino que también tienen la capacidad de utilizar los plugins rhash para calcular la suma de
comprobación de secciones en el binario.
$ Rabin2 -K md5 -s / bin / ls
284
Rahash2
La obtención de los hashes dentro sesión radare2
Para calcular una suma de comprobación del bloque actual cuando se ejecuta radare2, utilice el ph mando. 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:
285
Rahash2
[0x00000000]> ph? md5 sha1
sha256 sha384 sha512 xor
md4
xorpair
paridad
entropía
hamdist
PCPRINT
mod255
xxhash
Adler32 luhn
crc8smbus
crc15can
CRC16
crc16hdlc
crc16usb
crc16citt crc24
crc32 crc32c
crc32ecma267
crc32bzip2 crc32d
crc32mpeg2
crc32posix crc32q
crc32jamcrc
crc32xfer crc64
crc64ecma
crc64we crc64xz
crc64iso
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:
286
Rahash2
[0x08049A80]> md5 pH 32
9b9012b00ef7a94b5824105b7aaad83b [0x08049A80]>
md5 pH 64
a71b087d8166c99869c9781e2edcf183 [0x08049A80]> ph
MD5 1024 a933cc94cd705f09a41ecc80c0041def
287
Herramienta Rahash
Ejemplos
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 S] [-a A] [H-c] [-E A] [-s S] [-f O] [-t O] [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
- c hachís Comparar con este hash
- mi endian swap (utilizar poco endian)
- E algo cifrar. -S utilizar para establecer clave y -I para establecer IV
- algo D descifrar. -S utilizar para establecer clave y -I para establecer IV
- f desde iniciar hash en la dirección dada
- i num repetición de hash de N iteraciones
- me iv utilizar dar vector de inicialización (IV) (hexa o s: string)
- S semilla utilizar semillas dado (o hexa s: string) utiliza a ^ prefijo (clave para -E) (- sorber será la clave de la entrada
estándar, los puntos @ prefijo a un archivo
- k mostrar utilizando el algoritmo de hash randomkey del openssh
- q ejecutar en modo silencioso (-qq para mostrar sólo el hash)
- 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
- x hexstr hash de esta cadena hexpair en lugar de archivos
- v información de concierto versión
Para obtener un valor hash MD5 de una cadena de texto, utilice el - s opción:
$ 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, el uso todos como un nombre de algoritmo:
288
Herramienta Rahash
$ Rahash2 -a todos / bin / ls
/ / bin ls: 0x00000000-0x000268c7 md5: 767f0fff116bc6584dbfc1af6fd48fc7 / bin / ls: 0x00000000-0x000268c7 sha1:
404303f3960f196f42f8c2c12970ab0d49e28971 / bin / ls: 0x00000000-0x000268c7 sha256: deb278e17396354
74ea05150acf311484bddd19c608aa02e6bf3332a0f0805a4
/ / bin ls: 0x00000000-0x000268c7 SHA384: c6f811287514ceeeaabe73b5b2f54545036d6fd3a192ea5d6
a1fcd494d46151df4117e1c62de0884cbc174c8db008ed1
/ / bin ls: 0x00000000-0x000268c7 sha512: 53e4950a150f06d7922a2ed732060e291bf0e1c2ac20bc72a
41b9303e1f2837d50643761030d8b918ed05d12993d9515e1ac46676bc0d15ac94d93d8e446fa09 / bin / ls: 0x00000000-0x000268c7 md4:
fdfe7c7118a57c1ff8c88a51b16fc78c / bin / ls: xor 0x00000000-0x000268c7: 42 / bin / ls: xorpair 0x00000000-0x000268c7: ls d391 / bin /: paridad
0x00000000-0x000268c7: 00 / bin / ls: entropía 0x00000000-0x000268c7: 5.95471783 / bin / ls: hamdist 0x00000000-0x000268c7: 00 / bin / ls: PCPRINT
0x00000000-0x000268c7: 22 / bin / ls: mod255 0x00000000-0x000268c7: ef / / bin ls: xxhash 0x00000000-0x000268c7: 76554666 / bin / ls: Adler32
0x00000000-0x000268c7: 7704fe60 / bin / ls: 0x00000000-0x000268c7 luhn: 01 / bin / ls: crc8smbus 0x00000000-0x000268c7: 8d / bin / ls: 0x00000000
-0x000268c7 crc15can: 1cd5 / bin / ls: CRC16 0x00000000-0x000268c7: d940 / bin / ls: crc16hdlc 0x00000000-0x000268c7:7847 / bin / ls: crc16usb
0x00000000-0x000268c7: 17bb / bin / ls: crc16citt 0x00000000-0x000268c7: 67f7 / bin / ls: crc24 0x00000000-0x000268c7: 3e7053 / bin / ls: CRC32
0x00000000-0x000268c7: c713f78f / bin / ls: 0x00000000-0x000268c7 crc32c: 6cfba67c / bin / ls: crc32ecma267 0x00000000-0x000268c7: b4c809d6 / bin / ls:
crc32bzip2 0x00000000-0x000268c7: a1884a09 / bin / ls: crc32d 0x00000000-0x000268c7: d1a9533c / bin / ls: crc32mpeg2 0x00000000-0x000268c7: 5e77b5f6
/ / bin ls: 0x00000000-0x000268c7 crc32posix: 6ba0dec3 / bin / ls: crc32q 0x00000000-0x000268c7: 3166085c / bin / ls: crc32jamcrc 0x00000000-0x000268c7:
38ec0870 / bin / ls: crc32xfer 0x00000000-0x000268c7: ls 7504089d / bin /: 0x00000000 -0x000268c7 crc64: b6471d3093d94241 / bin / ls: crc64ecma
0x00000000-0x000268c7: b6471d3093d94241 / bin / ls: crc64we 0x00000000-0x000268c7: 8fe37d44a47157bd / bin / ls: crc64xz
0x00000000-0x000268c7:ea83e12c719e0d79 / bin / ls: crc64iso 0x00000000-0x000268c7: d243106d9853221c
289
plugins
plugins
radare2 se implementa en la parte superior de un montón de bibliotecas, casi todas de esas bibliotecas apoyar plugins para ampliar las capacidades de
la biblioteca o añadir soporte para diferentes objetivos.
Esta sección tiene como objetivo explicar lo que son los plugins, la forma de escribir y usarlos
Tipos de plugins
$ Ls LiBr / * / p | grep: | awk -F / '{print $ 2}' anal
# plugins de análisis
asm # ensamblador / desensamblador plugins
compartimiento # plugins de análisis de formato binario
pb # plugins de punto de interrupción
núcleo # complementos del núcleo (implementan nuevos comandos)
cripto # cifrar / descifrar / almohadilla / ...
depurar # backends depurador
huevo # shellcode codificadores, etc.
fs # sistemas de ficheros y tablas de particiones
io # plugins io
lang # lenguajes de script incrustado
analizar gramaticalmente# plugins de análisis desensamblador
reg # lógica de registro de arco
Añadir plugins
Algunas herramientas R2 tienen los - L bandera para listar todos los plugins asociados a la funcionalidad.
rasm2 -L # plugins lista asm
R2 -L # una lista de plugins io
rabin2 -L # lista los plugins de basura
# Lista de hash rahash2 -L / crypto / codificación plugins
Hay más plugins en r2land, podemos enumerar desde el interior r2, y esto se hace mediante el uso de la L
sufijo.
Esos son algunos de los comandos:
290
plugins
L # plugins lista básica
Illinois # plugins lista de basura
dl # plugins lista de depuración
ml # Lista fs plugins
ph # soporte de impresión algoriths de hash
Sino también con el? valor en el eval asociado vars.
e asm.arch =? # Lista de ensamblador / desensamblador plugins e anal.arch =? # plugins de
análisis de la lista
notas
Tenga en cuenta que hay algunas inconsistencias que muy probablemente se solucionarán en las futuras versiones radare2.
291
plugins IO
plugins IO
Todo el acceso a los archivos, red, depurador y toda la entrada / salida, en general, 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.
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 <br /> $ r2 pid: // 1927
Las sesiones remotas
$ R2 rap: //: 1234 <br /> $ r2 rap: // <host>: 1234 // bin
/ ls
Los modos virtuales
$ R2 malloc: // 512 <br /> acceso directo
por $ r2 -
Usted puede obtener una lista de los plugins IO radare escribiendo radare2 -L:
292
plugins IO
$ R2 -L rw_ ar
archivos lib / ar abiertas [ar | lib]: // [archivo // ruta] (LGPL3)
rw_ bfdbg BrainFuck depurador (bfdbg: // ruta / a / archivo) (LGPL3)
RWD bochs Adjuntar a un depurador BOCHS (LGPL3)
depuración r_d depurador nativo (dbg: /// bin / ls dbg: // 1388 pidof: // waitfor: //) (LGPL3)
panqueque v0.2.0
rw_ predeterminado abrir archivos locales utilizando def_mmap: // (LGPL3) RWD GDB
Adjuntar a gdbserver, 'qemu -s', el BGF: // localhost: 1234 (LGPL3)
rw_ gprobe conexión gprobe abierto usando gprobe: // (LGPL3) rw_ gzip
leer / escribir ficheros comprimidos (LGPL3)
http rw_ HTTP GET (http://rada.re/) (LGPL3)
ihex rw_ archivo de Intel HEX (ihex: //eeproms.hex) (LGPL)
mach r__ io mach de depuración (no soportado en esta plataforma) (LGPL)
asignación de memoria malloc rw_ (malloc: // 1024 hex: // cd8090) (LGPL3) mmap rw_
archivo abierto mediante mmap: // (LGPL3)
rw_ nula nula-plugin (null: // 23) (LGPL3)
rw_ procpid / proc / pid / mem io (LGPL3)
rwd ptrace ptrace y / proc / pid / mem (si está disponible) io (LGPL3) QNX rwd
Conectar a instancia pdebug QNX, QNX: // host: 1234 (LGPL3)
rw_ r2k kernel io acceso a la API (r2k: //) (LGPL3)
rw_ r2pipe r2pipe io Plugin (MIT) rw_ r2web
r2web cliente io (r2web: //cloud.rada.re/cmd/) (LGPL3)
rap rw_ protocolo de red radare (rap: //: puerto de rap: // host: puerto / archivo) (LGPL3)
rw_ RBUF RBuffer IO plugin: RBUF: // (LGPL)
auto rw_ leer la memoria de mi mismo usando 'auto: //' (LGPL3)
rw_ SHM recursos de memoria compartida (SHM: // llave) (LGPL3)
rw_ asignación de memoria intermedia escasa escasa (escasa: // 1.024 escasa: //) (LGPL3) tcp rw_
archivos de carga a través de TCP (escuchar o conectarse) (LGPL3)
rwd WinDBG Adjuntar a un depurador KD (windbg: // socket) (LGPL3) rwd winedbg Wine-dbg io y debug.io Plugin
para r2 (MIT) postal rw_
Abrir archivos ZIP [apk | IPA | zip | zipall]: // [archivo // path] (BSD)
293
plugins asm
La implementación de un nuevo plugin desmontaje
Radare2 tiene una arquitectura modular, lo que añade soporte para una nueva arquitectura es muy fácil, si usted es fluido en C. Por varias
razones puede ser que sea más fácil de implementar fuera del árbol. Para esto necesitaremos para crear una sola fila C, llamado asm_mycpu.c y
makefile para ello.
La clave de rasm plugin es una estructura
RAsmPlugin r_asm_plugin_mycpu = {
. name = "Mycpu" ,
. licencia = "LGPL3" ,
. desc = "MYCPU desmontaje plug-in" ,
. arco = "Mycpu" ,
. bits = 32 ,
. endian = R_SYS_ENDIAN_LITTLE,
. desmontar = & desmontar};
dónde . desmontar es un puntero a la función de desmontaje, que acepta el tampón de bytes y la longitud:
estático En t desmontar (Rasm * a, RAsmOp * op, const ut8 * buf, En t len)
Makefile
294
plugins asm
NAME = asm_snes R2_PLUGIN_PATH = $ (Shell r2 -H | USER_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 asm_mycpu. $ (SO_EXT) $ (R2_PLUGIN_PATH)
desinstalar:
rm -f $ (R2_PLUGIN_PATH) / asm_mycpu. $ (SO_EXT)
asm_mycpu.c
295
plugins asm
/ * Radare - LGPL - Copyright 2018 - usuario * /
# incluir <stdio.h>
# incluir <string.h>
# incluir <r_types.h>
# incluir <r_lib.h>
# incluir <r_asm.h>
estático En t desmontar (Rasm * a, RAsmOp * op, const ut8 * buf, En t len) {
struct op_cmd cmd = {
. instr = "" ,
. operandos = ""
};
Si (Len < 2 ) regreso -1 ;
En t ret = decode_opcode (buf, len, y cmd);
Si (Ret> 0 ) {
snprintf (OP> buf_asm, R_ASM_BUFSIZE, "% S% s" , cmd.instr, cmd.operands);
regreso op-> size = ret; }
RAsmPlugin r_asm_plugin_mycpu = {
. name = "Mycpu" ,
. desc = "MYCPU desmontaje plug-in" ,
. arco = "Mycpu" ,
. bits = 32 ,
. endian = R_SYS_ENDIAN_LITTLE,
. desmontar = & desmontar};
# ifndef CORELIB
RLibStruct radare_plugin = {
. type = R_LIB_TYPE_ASM,
. datos = & r_asm_plugin_mycpu,
. version = R2_VERSION};
# terminara si
Después de compilar radare2 enumerará este plugin en la salida:
_d__ _8_32 mycpu LGPL3 MYCPU
Mover plug-in en el árbol
296
plugins asm
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:
plugins.def.cfg: añade el asm.mycpu cadena del nombre del plug-in de allí
LiBr / asm / p / mycpu.mk: instrucciones de construcción
LiBr / asm / p / asm_mycpu.c: implementación
LiBr / include / r_asm.h: añadir la definición struct allí
Comprueba cómo el plugin CPU desmontaje NIOS II se llevó a cabo mediante la lectura de esas confirmaciones:
Implementar rasm enchufar:
https://github.com/radare/radare2/commit/933dc0ef6ddfe44c88bbb261165bf8f8b531476b
Implementar RANAL enchufar:
https://github.com/radare/radare2/commit/ad430f0d52fbe933e0830c49ee607e9b0e4ac8f2
297
plugins de análisis
La implementación de un nuevo plugin análisis
Después de implementar el plugin desmontaje, usted puede haber notado que la producción está lejos de ser buena - sin resaltado adecuada, no
hay líneas de referencia y así sucesivamente. Esto se debe a radare2 requiere que cada arquitectura de plugins para proporcionar también
información de análisis de cada código de operación. Por el momento se separa la aplicación de desmontaje y opcodes análisis entre dos
módulos - Rasm y Rañal. Por lo tanto tenemos que escribir un plugin de análisis también. El principio es muy similar - sólo tiene que crear un
archivo de C y que corresponde Makefile.
Ellos estructura del RANAL complemento parece
RAnalPlugin r_anal_plugin_v810 = {
. name = "Mycpu" ,
. desc = "Análisis plugin de código MYCPU" ,
. arco = "Mycpu" ,
. bits = 32 ,
. op = mycpu_op,
. Esil = cierto ,
. set_reg_profile = set_reg_profile,};
Al igual que con el plugin desmontaje no es una función clave - mycpu_op que escanea el código de operación y construye la estructura RAnalOp.
Por otro lado, en este ejemplo el análisis plugins también realiza el elevar a ESIL, que está habilitado en . esil = true declaración. Así, mycpu_op obligado
a llenar el campo RAnalOp ESIL correspondiente a los códigos de operación. La segunda cosa importante para ESIL edificante y emulación -
registro de perfil, al igual que en el depurador, que se encuentra dentro de set_reg_profile función.
Makefile
298
NAME = anal_snes R2_PLUGIN_PATH = $ (Shell r2 -H | USER_PLUGINS grep | awk '{print $$ 2}')
CFLAGS = -g -fPIC $ (Shell pkg-config --cflags r_anal)
LDFLAGS = -shared $ (Shell pkg-config --libs r_anal)
todas: $ (LIB)
limpiar:
$ (LIB): $ (OBJS)
instalar:
cp -f anal_snes. $ (SO_EXT) $ (R2_PLUGIN_PATH)
desinstalar:
rm -f $ (R2_PLUGIN_PATH) / anal_snes. $ (SO_EXT)
anal_snes.c:
299
/ * 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 "Snes_op_table.h"
estático En t snes_anop (* RANAL anal, RAnalOp * op, addr ut64, const * ut8 datos, En t 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" ,
. 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,
# terminara si
Después de compilar radare2 enumerará este plugin en la salida:
300
_dA_ _8_16 SNES CPU LGPL3 SuperNES
snes_op_table. h: https://github.com/radare/radare2/blob/master/libr/asm/arch/snes/snes_op_table.h
Ejemplo:
6502: https://github.com/radare/radare2/commit/64636e9505f9ca8b408958d3c01ac8e3ce254a9b
SNES: https://github.com/radare/radare2/commit/60d6e5a1b9d244c7085b22ae8985d00027624b49
301
plugins bin
La implementación de un nuevo formato
Para habilitar el direccionamiento virtual
En info añadir et-> has_va = 1; y ptr-> srwx con el R_BIN_SCN_MAP; atributo
Crear una carpeta con el nombre del archivo en formato LiBr / bin / formato
Makefile:
NAME = bin_nes R2_PLUGIN_PATH = $ (Shell r2 hh | grep R2_LIBR_PLUGINS | awk '{print $$ 2}')
CFLAGS = -g -fPIC $ (Shell pkg-config --cflags r_bin)
LDFLAGS = -shared $ (Shell pkg-config --libs r_bin)
todas: $ (LIB)
limpiar:
$ (LIB): $ (OBJS)
instalar:
cp -f $ (NAME). $ (SO_EXT) $ (R2_PLUGIN_PATH)
desinstalar:
rm -f $ (R2_PLUGIN_PATH) / $ (NAME). $ (SO_EXT)
bin_nes.c:
# incluir <r_bin.h>
estático En t comprobar (* RBinFile arco) ;
estático En t check_bytes ( const ut8 * buf, longitud ut64) ;
estático vacío * load_bytes (* RBinFile arco, const ut8 * buf, SZ ut64, loadaddr ut64, SDB * sd
segundo) {
check_bytes (BUF, sz);
regreso R_NOTNULL; }
302
plugins bin
estático En t 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); }
estático En t 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 (!jubilado) regreso NULO ;
Si (! Arco ||! Arch-> buf) {
gratis (jubilado);
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 jubilado; }
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,
. comprobar = & comprobar,
. baddr = NULO ,
. check_bytes = & check_bytes,
. entradas = NULO ,
. secciones = NULO ,
. info = e información,};
# ifndef CORELIB
303
plugins bin
struct r_lib_struct_t radare_plugin = {
. type = R_LIB_TYPE_BIN,
. de datos = & r_bin_plugin_nes,
# 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/d1351cf836df3e2e63043a6dc728e880316f00eb
OMF - https://github.com/radare/radare2/commit/44fd8b2555a0446ea759901a94c06f20566bbc40
304
otros complementos
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.
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/6f1655c49160fe9a287020537afe0fb8049085d7
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/ && 726 Xcore: https://github.com/radare/radare2/commit/bb16d1737ca5a471142f1
SharpLH5801:
https://github.com/neuschaefer/radare2/commit/f4993cca634161ce6f82a64596fce45fe6b818e7
MSP430: https://github.com/radare/radare2/pull/1426
HP-PA-RISC:
https://github.com/radare/radare2/commit/f8384feb6ba019b91229adb8fd6e0314b0656f7b
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
Este es un plugin simple para Z80 que se puede usar como ejemplo:
https://github.com/radare/radare2/commit/8ff6a92f65331cf8ad74cd0f44a60c258b137a06
305
otros complementos
306
plugins Python
plugins Python
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 r2pm -i lang-python2, de lo contrario (y recomendado) - instalar la versión de Python 3:
r2pm -i-lang python3. Nota - En los siguientes ejemplos no faltan
funciones 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 R ( para las constantes)
2. Hacer una función con 2 subfunciones - montar y desmontar y el plugin de regresar
estructura - plug-in para rasm
def mycpu (una) :
def montar (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 - montar y desmontar
regreso {
"nombre" : "Mycpu" ,
"arco" : "Mycpu" ,
"bits" : 32 ,
"Endian" : "pequeño" ,
"licencia" : "GPL" ,
"Desc" : "Disasm MYCPU" ,
"montar" : Montar,
"desmontar" : Desmonte,}
1. Hacer una función con 2 subfunciones - set_reg_profile y op y devolver la estructura plug-in -
para RANAL plug-in
307
plugins Python
def mycpu_anal (una) :
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 - set_reg_profile y op
308
plugins Python
regreso {
"nombre" : "Mycpu" ,
"arco" : "Mycpu" ,
"bits" : 32 ,
"Desc" : "Anal MYCPU" ,
"Esil" : 1 ,
"Set_reg_profile" : Set_reg_profile,
"Op" : Op,}
1. A continuación, registre los que utilizan r2lang.plugin ( "asm") y r2lang.plugin ( "anal") 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 some_file.bin mycpu.py
O se puede cargar desde el shell R2: #! mycpu.py pitón
Ver también:
Javascript
Python
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:
carga
load_bytes
destruyen
309
plugins Python
check_bytes baddr
entradas secciones
importaciones
reubicaciones binsym
información
y devolver la estructura Plugin - Plugin para rasm
def le_format (una) :
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 funciones entradas, secciones,
las importaciones, las reubicaciones devuelve una lista de los diccionarios especiales formados cada uno con un tipo diferente de. Otras funciones
devuelven sólo una lista de valores numéricos, incluso si uno solo elemento. Hay una función especial, que devuelve información sobre el
archivo - Info:
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 ,}]
310
plugins Python
3. Esta estructura debe contener una punteros a las funciones más importantes como check_bytes, carga
y load_bytes, items, reubicaciones, las importaciones.
regreso {
"nombre" : "Le" ,
"Desc" : "Formato / 2 LE / LX OS" ,
"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))
311
depuración
depuración
Es común tener un problemas al escribir un plugin, sobre todo si lo hace por primera vez. Esta es la razón por la depuración de ellos es muy
importante. El primer paso para la depuración es establecer una variable de entorno cuando se ejecuta ejemplo radare2:
= sí ls / bin / R_DEBUG r2
Cargando /usr/local/lib/radare2/2.2.0-git//bin_xtr_dyldcache.so
No se puede encontrar el símbolo 'radare_plugin' en la biblioteca '/usr/local/lib/radare2/2.2.0-git//bin_xtr _dyldcache.so'
No se puede abrir /usr/local/lib/radare2/2.2.0-git//2.2.0-git Cargando
/home/user/.config/radare2/plugins/asm_mips_ks.so PLUGIN OK 0x55b205ea6070 FCN
0x7f298de08762
Cargando /home/user/.config/radare2/plugins/asm_sparc_ks.so PLUGIN OK 0x55b205ea6070 FCN
0x7f298de08762 No se puede abrir /home/user/.config/radare2/plugins/pimp No se puede
/home/user/.config/radare2/plugins/ abierto yara Cargando
/home/user/.config/radare2/plugins/asm_arm_ks.so PLUGIN OK 0x55b205ea6070 FCN 0x7f298de08762
Cargando /home/user/.config/radare2/plugins/core_yara.so
versión de módulo de desajuste /home/user/.config/radare2/plugins/core_yara.so (2.1.0) vs (2.2. 0-GIT)
Cargando /home/user/.config/radare2/plugins/asm_ppc_ks.so PLUGIN OK 0x55b205ea6070 FCN
0x7f298de08762
Cargando /home/user/.config/radare2/plugins/lang_python3.so PLUGIN OK 0x55b205ea5ed0 FCN
0x7f298de08692
Cargando /usr/local/lib/radare2/2.2.0-git/bin_xtr_dyldcache.so
No se puede encontrar el símbolo 'radare_plugin' en la biblioteca 'dyldcache.so /usr/local/lib/radare2/2.2.0-git/bin_xtr_'
No se puede abrir /usr/local/lib/radare2/2.2.0-git/2.2.0-git no puede '/usr/local/lib/radare2-extras/2.2.0-git' Open
Directory No se puede abrir el directorio '/ usr / / lib / radare2-bindings / 2.2.0-git' usuario local de configuración
cargadas de /home/user/.config/radare2/radare2rc
- - En el modo visual de prensa 'c' para cambiar el modo de cursor. Utilice la pestaña para navegar [0x00005520]>
312
Pruebas
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 jubilado
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 jubilado
¡Hurra! funciona .. y la oneliner obligatoria también!
r2 -nqamycpu -cwoR -cpd' 10' -
313
embalaje
Creación de un paquete r2pm del plugin
Como se acuerde radare2 tiene su propio gestor de envases y podemos añadir fácilmente plug-in recién escrito para todos el acceso.
Todos los paquetes se encuentran en radare2-pm repositorio, y tienen formato de texto muy simple.
R2PM_BEGIN
R2PM_GIT "https://github.com/user/mycpu"
R2PM_DESC "[r2-ARCH] desensamblador MYCPU y analizador plugins"
R2PM_INSTALL () {
$ {} MAKE limpia
$ {} MAKE todo || la salida 1
$ {} REALIZAR instalar R2PM_PLUGDIR = "$ {} R2PM_PLUGDIR"}
R2PM_UNINSTALL () {
rm -f "$ {} R2PM_PLUGDIR / asm_mycpu." * rm -f "$ {}
R2PM_PLUGDIR / anal_mycpu." *}
R2PM_END
A continuación, añadir que en el / db directorio de radare2-pm repositorio y enviar una solicitud de extracción a la línea principal.
314
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.
315
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
316
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 = una cadena = IOLI Crackme Nivel 0x00 \ n
vaddr = 0x08048581 0x00000581 = PADDR ordinal = 001 SZ = 11 len = 10 = sección tipo .rodata = una cadena = Contraseña:
vaddr = 0x0804858f PADDR = 0x0000058f ordinal = 002 sz = 7 len = 6 sección = tipo .rodata = una cadena = 2 50 382
vaddr = 0x08048596 0x00000596 = PADDR ordinal = 003 SZ = 19 len = 18 = sección tipo .rodata = una cadena = Contraseña no válida! \ n
vaddr = 0x080485a9 PADDR = 0x000005a9 ordinal = 004 SZ = 16 len = 15 = sección tipo .rodata = una cadena = 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.
Aquí tenemos la solicitud de la contraseña.
Este es el error al entrar una contraseña no válida.
vaddr = 0x08048596 0x00000596 = PADDR ordinal = 003 SZ = 19 len = 18 = sección tipo .rodata = una cadena = Contraseña no válida! \ n
317
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 = una cadena = 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 = 2 50 382
Vamos a darle a este un tiro.
$ ./crackme0x00
250382 Contraseña OK :)
Así que ahora sabemos que 250.382 es la contraseña, y hemos completado este crackme.
318
IOLI 0x01
IOLI 0x01
Este es el segundo crackme IOLI.
$ ./crackme0x01
prueba Contraseña no válida!
Vamos a comprobar para cuerdas con rabin2.
$ Rabin2 -z ./crackme0x01
vaddr = 0x0804854f PADDR = 0x0000054f = 002 ordinal SZ = 19 len = 18 = sección tipo .rodata = una cadena = Contraseña no válida! \ n
vaddr = 0x08048562 0x00000562 = PADDR ordinal = 003 SZ = 16 len = 15 = sección tipo .rodata = una cadena = Contraseña OK:) \ n
Esto no va a ser tan fácil como 0x00. Vamos a tratar de desmontaje con R2.
319
IOLI 0x01
$ R2 ./crackme0x01
- - Use `zoom.byte = printable` en el modo de zoom ( 'z' en el modo visual) para buscar cadenas [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] = 0x7
3736150; "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] = 0x49006
425; "% 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; [0x8048
54f: 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; [0x8048562
: 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 jubilado
"Aa" dice r2 analizar todo el binario, que le consigue los nombres de símbolos, entre las cosas.
320
IOLI 0x01
"Pdf" significa
Impresión
Desmontar
Función
Esto imprimirá el desmontaje de la función principal, o el principal() que todo el mundo sabe. Se puede ver varias cosas así: 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á una cmp 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
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
0x149a Contraseña no válida!
321
IOLI 0x01
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.
322
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 .
323
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:
324
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
| una 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
325
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
punta r2: rabin2 es una de las herramientas útiles que viene con radare2. Se puede utilizar para extraer información (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
326
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: El parámetro -A corre aaa comando en principio a analizar todo el código de referencia, por lo que tendrá funciones, cuerdas, 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]>
punta r2: Puede guardar un proyecto utilizando Sal [Archivo], y cargar uno usando Po [Archivo]. Con la opción -p, se puede 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]>
punta r2: R2 pone llamados banderas en las compensaciones importantes / interesantes, y organiza estas banderas en flagspaces (cadenas,
funciones, símbolos, etc.) Puede enumerar todos los flagspaces usando fs, y cambiar el actual usando fs [flagspace] ( el valor predeterminado es
*, lo que significa que todos los flagspaces). El comando
F imprime todas las banderas de la flagspace (s) seleccionado en ese momento.
327
IOLI 0x01
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!
Estas cadenas pueden ser un buen punto de partida si estábamos hablando de una aplicación en la vida real con características manymany.
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_
punta r2: Podemos enumerar referencias cruzadas a las direcciones utilizando el axt [addr] comando (de manera similar, podemos utilizar axf para 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 de la orden f ~ [0]. En él se enumeran las cuerdas desde el ejecutable con F, y utiliza el
comando interno grep ~ para seleccionar sólo la primera columna ([ 0]) que contiene las direcciones de las cuerdas.
328
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: Usted puede ir a cualquier desplazamiento, bandera, expresión, etc., en el ejecutable mediante el s comando (buscar). Puede utilizar
referencias, como $$ (offset actual), puede deshacer ( s-) o rehacer ( s +) busca, cadenas de búsqueda ( s / [cadena]) o valores hexadecimales ( s /
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íamos utilizar pag para mostrar un desmontaje ( pd, pdf),
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 :)
punta r2: La familia de comandos pag se utiliza para imprimir cosas. Por ejemplo, puede mostrar desmontaje ( pd),
desmontaje de la función actual ( pdf), (cadenas de impresión PD), hexdump ( px), base64 codificar / decodificar datos ( p6e, P6D), 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:
329
IOLI 0x01
330
IOLI 0x01
punta r2: con el comando V puede introducir el llamado modo visual, que tiene varios puntos de vista. Se puede cambiar entre ellos
utilizando pag y pag. La vista gráfica puede visualizarse pulsando V en el modo visual (o usando VV en el indicador).
golpear pag en 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 la t y el F llaves.
Es posible que aparezca el símbolo en modo visual utilizando la llave, y se puede utilizar o buscar.
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 local_10_6, y que lo compara con 0xbb8. Eso es
3000 en decimal, por cierto:
[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.
331
IOLI 0x01
Si el valor es mayor que 3000, entonces se verá obligado a ser 3000:
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
332
IOLI 0x01
punta r2: los af familia comando se utiliza para analizar funciones. Esto incluye la manipulación de argumentos y variables locales también, que es
accesible a través de la AFV comandos. Puede enumerar los argumentos de funciones ( afa), (variables locales AFV), o incluso se puede cambiar el
nombre de ellos ( afan, AFVN). Por supuesto que hay muchas otras características también - como de costumbre: utilizar el, Lucas "?"!
Después de esto una input_size 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 almacena en local_10 - tiempo para usar AFVN otra vez:
:> 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
punta r2: Las banderas pueden ser gestionados mediante el F familia 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 ( fname), renombrar ( fr [de edad] [nuevo]), 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
punta r2: La familia de comandos do se utiliza para gestionar los metadatos. Puede configurar ( CC) o editar ( CC)
comentarios, declaran áreas de memoria como datos ( Discos compactos), (cuerdas Cs), etc. Estos comandos también se pueden emitir a través de un menú en
el modo visual invocado presionando re.
333
IOLI 0x01
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 llamado esta función vmloop, y rebautizado
datos 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
punta r2: los af comando se utiliza para analizar una función con un nombre dado en la dirección indicada. Los otros 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í:
334
IOLI 0x01
Así, de nuevo a ese salto condicional. Si vmloop 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.
Ahora vemos que una cadena en esa área de memoria de 512 bytes ( sym.memory) 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 [ 0d34], y se trata de los siguientes nodos:
[ 0d34]
[ 0d65]
[ 0d3d]
[ 0d61]
Estas son las fichas de montaje de los bloques. El primero pone 0 en la variable local local_10_4:
335
IOLI 0x01
Y éste se compara local_10_4 a 8, y la ejecución de un salto condicional en función del resultado:
Es bastante obvio que local_10_4 es el contador del bucle, por lo que permite nombrarlo en consecuencia:
:> AFVN local_10_4 i
bloque siguiente es el cuerpo del bucle real:
336
IOLI 0x01
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:
Si el valor es cero, se rompe el bucle y este bloque es ejecutado antes de salir:
337
IOLI 0x01
Se imprime el siguiente mensaje: Utilice todo "Como hemos establecido anteriormente, se trata de una máquina virtual En ese contexto, este
mensaje probablemente significa que tenemos que utilizar cada instrucciones disponibles Ya sea que ejecuta una instrucción o no es!.. almacenado
en 0x6020e0 - por lo que permite la bandera de esa área de memoria:
:> 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
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:
338
IOLI 0x01
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:
339
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 tiene que contener la cadena "Tal VM! CUÁNTO reV3rse!" los 9 elementos de sym.instr_dirty array no debe ser cero (probablemente
significa que todas las instrucciones se tuvieron que utilizar al menos una vez)
sym.good_if_ne_zero no debe ser cero
sym.good_if_le_9 tiene que ser menor o igual a 9
Con esto concluye nuestro análisis de la función principal, podemos ahora pasar a la propia máquina virtual.
340
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.
341
IOLI 0x01
Pero primero, vamos a analizar lo que ya tenemos! Primero, RDI se pone en local_3. Dado que la aplicación es un ejecutable de Linux de 64
bits, sabemos que RDI es el primer argumento de la función (como puede haber reconocido, el análisis automático de los argumentos y variables
locales no era del todo correcto), y también sabemos que
vmloop' s primer argumento es el código de bytes. Por lo que permite cambiar el nombre de local_3:
:> AFVN local_3 código de bytes
Siguiente, sym.memory se pone en otra variable local en RBP-8 R2 que no reconoció. Así que vamos a definir él!
:> AFV QWord memoria de 8
punta r2: los afv [idx] [nombre] [tipo] comando se utiliza para definir la variable local en [idx puntero de marco] con el nombre de
[nombre] y escriba [tipo]. También puede eliminar las variables locales utilizando el afv [idx] mando.
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:
342
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 él! Discos 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 generada utilizando el? s mando. ? s simplemente
genera una serie de la corriente de buscar ($$) para buscar la actual + 8 0x17 ($$ + 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
0x0000000000400b42 0x00400f40 .qword 0x0000000000400c04
0x00400f48 .qword 0x0000000000400be5 0x00400f50 .qword
0x0000000000400ab6 0x00400f58 .qword 0x0000000000400c04
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!
343
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: Se pueden definir bloques básicos utilizando el AFB + 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.
344
IOLI 0x01
345
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:
346
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.)
punta r2: Se puede mover el nodo seleccionado en torno a la vista gráfico usando las teclas hjkl.
Por cierto, aquí es cómo gráfica de esta misma función de la AIF se ve como para la comparación:
347
IOLI 0x01
A medida que navega por el desmontaje de la instr_LETTER elementos básicos, que deben darse cuenta de algunas cosas. La primera: todas las
instrucciones comienza con una secuencia como estos:
Se hizo evidente ahora que las 9 en dwords sym.instr_dirty No son simplemente indicadores que consiguió una instrucción se ejecuta, sino que
se utilizan para contar cuántas veces una instrucción fue llamado. También me he dado cuenta de que antes sym.good_if_le_9 ( 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 tiene
que ser menor o igual 9" realmente significa es que instr_P no 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:
348
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 en instr_J podemos ver que esto es una excepción a la regla anterior, ya que pone el valor de retorno de la función de llamada en instr_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:
349
IOLI 0x01
Éste simplemente pone el siguiente código de bytes (el primer argumento) en eax, y salta hasta el final de
vmloop. Así que este es el VM jubilado instrucción, y sabemos que vmloop tiene que volver "*", por lo que "R *" deben ser los dos últimos bytes de nuestro
código 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 de que instr_C 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:
instr_R (a1): regresa con a1 instr_C (a1): escribe A1 a 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
350
IOLI 0x01
La función de esta instrucción es llama en el desplazamiento 0x40080d, por lo que permite buscar allí!
[Desplazamiento]> 0x40080d
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í prensa Dr mientras que aún en modo
visual, y el nombre de esta función
instr_A!
punta r2: Usted debe darse cuenta de que estos comandos son parte del mismo sistema de menú en el modo visual que estaba hablando cuando se utilizó
por primera vez Discos compactos declarar sym.memory como datos.
Ok, ahora tenemos nuestro nuevo y brillante fcn.instr_A, vamos a invertirlo! Podemos ver en la forma del minimapa que probablemente hay 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 en una
351
IOLI 0x01
vista, lo que le puede ayudar en su análisis (recordemos el fácilmente reconocible para el bucle de unos pocos párrafos antes?) Por lo tanto, el minimapa
es fresco y útil, pero yo sólo he dado cuenta de que yo no todavía a mostrar el modo gráfico completo, así que voy a hacer esto utilizando el gráfico
completo. Los primeros bloques básicos:
Los dos argumentos de la función ( RDI y RSI) se almacenan en las variables locales, y la primera se compara con 0. Si es así, la 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".
352
IOLI 0x01
Esta es la rama "M":
Básicamente, se carga una dirección de desplazamiento y suma 0x602088 arg2 al byte en esa dirección. Como r2 nos muestra amablemente en un
comentario, 0x602088 inicialmente contiene la dirección de sym.memory, la zona en la que tenemos que construir la "Tal VM! reV3rse tanto!" cuerda.
Es seguro asumir que de alguna manera 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:
353
IOLI 0x01
:> F sym.current_memory_ptr 8 @ 0x602088
Pasando a la rama "P":
Sí, esta es la pieza de código que nos permite modificar sym.current_memory_ptr: se añade arg2 lo.
Por último, la "C" rama:
Bueno, resultó que instr_C no es la única instrucción que modifica sym.written_by_instr_C: esta pieza de código añade arg2 lo.
Y eso fue instr_A, vamos a resumir ella! Dependiendo del primer argumento, esta instrucción hace lo siguiente:
arg1 == " M ": agrega arg2 para el byte en sym.current_memory_ptr. arg1 == " P ":
pasos sym.current_memory_ptr por arg2 bytes.
arg1 == " C ": agrega arg2 al valor en sym.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 estas dos funciones son muy-muy similar. Nosotros podemos usar radiff2
para ver la diferencia.
354
IOLI 0x01
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 al estilo de
gráficos utilizando el BinDiff - sol opción.
Desde ahora queremos diferencia de dos funciones del mismo binario, especificamos las compensaciones con - sol, y utilizar reverse4 tanto
para los binarios. Además, creamos los gráficos para comparar instr_A a instr_S y para comparar instr_S a instr_A.
[0x00 ~] $ radiff2 -g 0x40080d, 0x40089f reverse4 reverse4 | xdot -
[0x00 ~] $ radiff2 -g 0x40089f, 0x40080d reverse4 reverse4 | xdot -
355
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 que instr_S es básicamente una inversa instr_A: cuando
este último hace Además, el primero hace resta. Para resumir esta:
arg1 == " M ": Resta arg2 desde el byte en sym.current_memory_ptr. arg1 == " P ": pasos sym.current_memory_ptr
hacia atrás arg2 bytes.
arg1 == " C ": Resta arg2 a partir del valor en sym.written_by_instr_C.
instr_I
356
IOLI 0x01
Éste es simple, sólo llama instr_A (arg1, 1). Como se habrán dado cuenta de la llamada a la función se parece
llamar fcn.0040080d en lugar de llamar 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
Una vez más, simple: se llama instr_S (arg1, 1).
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
357
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 arg1 a sym.current_memory_ptr, y que las llamadas instr_I
( "P"). Esto significa básicamente que instr_P se 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
358
IOLI 0x01
Esta función XOR en el valor sym.current_memory_ptr con arg1.
instr_J
É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
Después de que el resultado de arg1 y 0x3f se pone en una variable local, arg1 y 0x40 se compara con 0. Si no es cero, arg1_and_0x3f es
negado:
359
IOLI 0x01
El siguiente bifurcación: si arg1 > = 0, entonces la función devuelve arg1_and_0x3f,
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 comprueba si arg1_and_0x3f es un número negativo,
360
IOLI 0x01
y si lo es, sym.good_if_ne_zero se incrementa en 1:
Después de todo esto, la función devuelve con arg1_and_0x3f:
361
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?
"UNA" "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)
362
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 "*"
sym.memory tiene que contener la cadena "Tal VM! CUÁNTO reV3rse!" después de la ejecución en los 9 instrucciones tienen que
ser utilizado al menos una vez
sym.good_if_ne_zero no debe ser no está permitido cero instr_P para
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 es hacer sym.good_if_ne_zero 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:
arg1 debe 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".
arg1_and_0x3f debe ser negativo en caso de control. Desde bit de signo de 0x3f es cero, no importa qué
arg1 es decir, el resultado de arg1 y 0x3f será siempre no negativo. Pero recuerde que niega "J"
arg1_and_0x3f Si arg1 y 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 uno de arg1' 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 \ x01AMMAP \ x01AMuAP \ x01AMCAP \
x01AMHAP \ x01AM AP \ x01AMrAP \ x01AMeAP \ x01AMVAP \ x01AM3AP \ x01AMrAP \ x01AMsA P \ 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.
363
IOLI 0x01
364
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.
365
Tarjeta de referencia
Tarjeta de referencia Radare2
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
de Thanat0s - v0.1 -
Guía de supervivencia
Esos son los comandos básicos que se quieren conocer y utilizar para moverse por un binario y obtener información al respecto.
Mando Descripción
s (pestaña) Buscará un lugar diferente
x [nbytes] Hexdump de nbytes, $ b por defecto
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] ~ grep cadenas de impresión y grep para una
arf [bandera] Encuentra referencia cruzada de una bandera
banderas
Las banderas son como marcadores, pero llevan alguna información extra, como el tamaño, las etiquetas o flagspace asociado. Utilizar el F comando a la lista,
conjunto, conseguirlos.
366
Mando Descripción
F Lista de banderas
fd $$ Describir un desplazamiento
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
Flagspaces
Banderas se crean en un flagspace, por defecto se selecciona ninguno, y una lista de banderas aparecerá una lista de todos ellos. Para mostrar un subconjunto de
indicadores que puede utilizar el fs mando a restringirlo.
Mando Descripción
fs flagspaces de visualización
fs * Seleccionar todos flagspaces
fs [secciones] Seleccione uno flagspace
Información
Los archivos binarios tienen información almacenada dentro de las cabeceras. los yo comando utiliza el API RBin y nos permite las mismas cosas
rabin2 hacer. Esos son los más comunes.
367
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
iz cadenas de la lista (Izz, ZZZ)
cadena de impresión
Hay diferentes maneras de representar una cadena en la memoria. los PD comando nos permite imprimir en UTF
16, Pascal, cero terminados, .. formatos.
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
El modo visual es la interfaz interactiva estándar de radare2.
Para entrar en el modo de utilizar el visual v o V del sistema y te es suficiente con pulsar las teclas para obtener las acciones suceden en lugar de
comandos.
Mando Descripción
V Entre en el modo visual
páginas Rotar los modos (hex, disasm, depuración, es decir, buf)
368
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
; [-] cmt Añadir / eliminar comentarios
x + - / [] 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
369
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
Hay muchas situaciones en las que tenemos que encontrar un valor dentro de una binaria o en algunas regiones específicas. Utilizar el e
search.in =? de control para elegir donde el / comando puede buscar el valor dado.
370
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
/UNA 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
371
Por defecto, cuando se abre un archivo en modo escritura ( r2 -w) todos los cambios serán escritos directamente en el archivo. No hay historial de deshacer se
guarda por defecto.
Utilizar e io.cache.write = true y el baño programa para manejar la caché de escritura la historia cambia. Para deshacer, rehacer, comprometerse a
escribir los cambios en el archivo ..
Pero, si queremos guardar los datos de análisis, comentarios, banderas y otros metadatos creados por el usuario, es posible que desee
utilizar con proyectos -p r2 y el PAG mando.
Mando Descripción
Po [Archivo] Proyecto abierto
Ps [Archivo] Guardar proyecto
Pi [Archivo] Mostrar información del proyecto
las variables que pueden utilizarse en la expresión
los PS comando mostrará las variables que se pueden utilizar en cualquier operación matemática dentro de la cáscara r2. Por ejemplo,
utilizando el? $$ mando para evaluar un número o? v a sólo el valor en un formato.
Todos los comandos en R2 que aceptan una serie apoya el uso de esas variables.
Mando Descripción
$$ aquí (virtual actual búsqueda)
$$$ buscar actual virtuales no temporal
PS último valor de comparación
$ Alias = valor alias comandos (macros simples)
$b tamaño de bloque
$B dirección base (alineado dirección mapa más bajo)
$f saltar fallar la dirección (por ejemplo, JZ 0x10 => siguiente instrucción)
$ FL longitud de la bandera (tamaño) en la dirección actual (fla; pD $ l @ Entry0)
$F tamaño función actual
$ FB comenzar de la función
372
$ Fb dirección del bloque básico actual
$ Fs tamaño del bloque básico actual
$ FE final de la función
$ FS tamaño de la función
$ Fj la función del destino de salto
$ FF función falsa destino
$ FI instrucciones de función
$ C, $ r obtener la anchura y la altura del terminal de
$ Cn Lo llaman enésima de la función
$ Dn obtener datos de referencia del número n de la función
$D dirección de depuración mapa base actual? v $ D @ RSP
$ DD tamaño actual mapa de depuración
$e 1 si el extremo del bloque, de lo contrario 0
$j saltar dirección (por ejemplo JMP 0x10, 0x10 jz => 0x10)
$ Ja obtener salto enésima de la función
$ Xn obtener referencias externas enésima de la función
$l longitud de código de operación
$m opcode referencia de memoria (por ejemplo, mov eax, [0x10] => 0x10)
$M dirección del mapa (el más bajo dirección del mapa)
$O aquí (corriente de disco io offset)
$p getpid ()
$P pid de los niños (sólo en depuración)
$s tamaño del archivo
$S sección desplazada
$ SS tamaño de la sección
$v opcode valor inmediato (por ejemplo, Lui a0,0x8010 => 0x8010)
373
$w obtener tamaño de la palabra, 4 si asm.bits = 32, 8 Si 64, ...
$ {Ev} obtener el valor de la variable de configuración eval
$ R {reg} obtener el valor de registro llamado
$ K {kv} obtener el valor de un valor de la consulta SDB
$ S {bandera} obtener el tamaño de la bandera
rnum $ las variables que pueden usarse en expresiones matemáticas
374
Expresiones de gratitud
Autores y Colaboradores
Este libro no sería posible sin la ayuda de una larga lista de colaboradores que han estado revisando, escritura y presentación de informes
insectos y otras cosas en el proyecto radare2, así como en este libro.
El libro radare2
Este libro fue iniciado por Maijin como una nueva versión del libro original escrito por radare panqueque.
Viejo libro radare1 http://www.radare.org/get/radare.pdf
Muchas gracias a todos los que han estado involucrados con el gitbook:
Adrian Studer, Ahmed Mohamed Abd El-MAwgood, Akshay Krishnan R, Andrew Hoog, Anton Kochkov, Antonio Sánchez,
Austin Hartzheim, Bob131, DZ_ruyk, David Tomaschik, Eric, Fangrui Song, Francesco Tamagni, FreeArtMan, Gerardo García
Peña, Giuseppe, Grigory Rechistov, Hui Peng, ITAYC0HEN, Itay Cohen, Jeffrey Crowell, John, Juez Dredd (6E23685A clave),
Júpiter, Kevin GRANDEMANGE, Kevin Laeufer, Luca Di Bartolomeo, Lukas Dresel, Maijin, Michael Scherer, Mike, Nikita
Abdullin, Paul, Paweł Łukasik, Peter C, RandomLive, Ren Kimura, Reto Schneider, SchumBlubBlub, SkUaTeR, Solomon,
Srimanta Barua, Sushant Dinesh, TDKPS, Thanat0s, Vanellope, Vex Woo, Vorlent, XYlearn, Yuri Slobodyanyuk, ali, aoighost,
condret, hdznrrd, izhuer , jvoisin, kij, madblobfish, muzlightbeer, crepe, Polym (Tim), puddl3glum, radare, sghctoma, shakreiner,
sivaramaaa, taiyu, vane11ope,xarkes.
375

Radare2book Spanish PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Radare2book Spanish PDF

Caricato da

Copyright:

Formati disponibili

Tabla de contenido

La Descarga de Marco radare2 1.1.2

Compilación y Portabilidad de 1.1.3

compilación en Windows interfaces de 1.1.4

usuario Primeros pasos 1.1.5

Banderas de línea de comandos 1.2.1

del comando expresiones de 1.2.2

Depurador Sesión básicos que 1.2.4

contribuyen a la configuración radare2 1.2.5

Variables de configuración de archivos 1.3.2

Los comandos básicos 1.4

Buscando tamaño de 1.4.1

bloque Secciones 1.4.2

modos de impresión de 1.4.3

archivos de asignación 1.4.4

de Banderas Escribir 1.4.5

Comparando modo Visual 1.4.10

Bytes SDB 1.4.11

Desmontaje visual visual 1.5.1

Visual Editor de Configuración paneles 1.5.3

visuales búsqueda bytes 1.5.4

Búsquedas básicas 1.6.1

Configurando el Patrón de búsqueda 1.6.2

Búsqueda de automatización hacia 1.6.3

atrás Buscar Buscar en la Asamblea 1.6.4

búsqueda para AES llaves que 1.6.5

Adición de Análisis de 1.7.1

metadatos ESIL 1.7.2

Variables Tipos de 1.8.1

análisis de código 1.8.2

Convenciones de llamada 1.8.4

virtuales Tablas llamadas al 1.8.5

sistema de emulación 1.8.6

información de símbolos 1.8.8

Firmas comandos Gráfico 1.8.9

La migración de ida, el BGF o WinDBG Registros mapas 1.10.2

de memoria archivos Montón 1.10.3

Revertir Depuración de 1.10.7

acceso remoto 1.11

Herramientas remotas GDB 1.11.1

remoto WinDBG de línea de 1.11.2

Las exportaciones presentar 1.12.4.1

identificación Punto de 1.12.4.2

entrada Imports 1.12.4.3

Símbolos (exportaciones) 1.12.4.5

Cuerdas Bibliotecas 1.12.4.6

Las partes del programa 1.12.4.8

binaria diffing 1.12.5.1

Rahash herramienta 1.12.8.1

IO plugins plugins Asm 1.13.1

Análisis plugins Bin 1.13.2

complementos Otros 1.13.3

complementos de Python 1.13.4

plugins Prueba de 1.13.5

empaquetado Crackmes 1.13.7

IOLI 0x00 1.14.1.1

0x01 IOLI 1.14.1.2

. primeros pasos 1.14.2.1.3

. conjunto de instrucciones 1.14.2.1.6

Agradecimientos tarjeta 1.15

actualizada por muchos contribuyentes a través de Internet.

Gitbook genera automáticamente HTML / PDF / EPUB / versiones MOBIL en aquí:

revisión y volcar los resultados en el disco