r2frida

# r2frida

Radare2 y Frida mejor juntos [![ci](https://github.com/nowsecure/r2frida/actions/workflows/ci.yml/badge.svg)](https://github.com/nowsecure/r2frida/actions/workflows/ci.yml)
[![radare2](https://img.shields.io/badge/radare2-6.2.2-green)](https://github.com/radareorg/radare2)

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/6368/cb1a7ba58f6ff64ad947e97c41037ba99ae04d10530e310971849f025e9e3351.png" width="414px" height="248px">
</p>

## Descripción

Plugin autocontenido para [radare2](https://www.radare.org) que incluye
[frida](https://www.frida.re) y permite instrumentar procesos locales o remotos
usando comandos de r2 en lugar de (pero no limitado a) scripts de Frida.

El proyecto radare proporciona una cadena de herramientas completa para ingeniería inversa,
se mantiene activamente y ofrece funcionalidades bien mantenidas
y extiende sus características con otros lenguajes de programación y herramientas.

Frida es un kit de herramientas de instrumentación dinámica que facilita la inspección
y manipulación de procesos en ejecución mediante la inyección de tu propio JavaScript, y
opcionalmente también comunicarse con tus scripts.

## Características

* Ejecutar scripts de Frida sin modificaciones (Usa el comando `:.`)
* Ejecutar fragmentos en C, Javascript o TypeScript en cualquier proceso
* Puede adjuntarse, generar o lanzar en sistemas locales o remotos
* Listar secciones, símbolos, exportaciones, protocolos, clases, métodos
* Buscar valores en memoria dentro del agente o desde el host
* Reemplazar implementaciones de métodos o crear hooks con comandos cortos
* Cargar bibliotecas y frameworks en el proceso objetivo
* Soporte para interfaces Dalvik, Java, ObjC, Swift y C
* Manipular descriptores de archivo y variables de entorno
* Enviar señales al proceso, continuar, puntos de interrupción
* El plugin io de r2frida también es un backend de sistema de archivos **fs** y **debug**
* Automatizar r2 y frida usando r2pipe
* Leer/Escribir memoria del proceso
* Llamar funciones, syscalls y fragmentos de código sin procesar
* Conectar a frida-server vía usb o tcp/ip
* Enumerar aplicaciones y procesos
* Rastrear registros, argumentos de funciones
* Probado en x64, arm32 y arm64 para Linux, Windows, macOS, iOS y Android
* No requiere que frida esté instalado en el host (no necesita frida-tools)
* Extender los comandos de r2frida con plugins que se ejecutan en el agente
* Cambiar permisos de página, parchear código y datos
* Resolver símbolos por nombre o dirección e importarlos como flags en r2
* Ejecutar comandos de r2 en el host desde el agente
* Usar las APIs de r2 y ejecutar comandos de r2 dentro del proceso objetivo remoto.
* Puntos de interrupción nativos usando la api `:db`
* Acceder a sistemas de archivos remotos usando la api `r_fs`.

## Instalación

La forma recomendada de instalar r2frida es a través de r2pm:

```sh
$ r2pm -ci r2frida
```

Las compilaciones binarias que no requieren compilación serán pronto compatibles en
`r2pm` y `r2env`. Mientras tanto, siéntete libre de descargar las últimas compilaciones
desde la [página de Releases](https://github.com/nowsecure/r2frida/releases).

## Compilación

### Dependencias

* radare2
* pkg-config (no requerido en windows)
* curl o wget
* make, gcc
* npm, nodejs (será eliminado pronto)

En GNU/Debian necesitarás instalar los siguientes paquetes:

```sh
$ sudo apt install -y make gcc libzip-dev nodejs npm curl pkg-config git
```

### Instrucciones

```
$ git clone https://github.com/nowsecure/r2frida.git
$ cd r2frida
$ make
$ make user-install
```

### Windows

* Instalar meson y Visual Studio
* Descomprimir el último zip de la versión de radare2 en el directorio raíz de r2frida
* Renombrarlo a `radare2` (en lugar de radare2-x.y.z)
* Para que el compilador de VS esté disponible en PATH (`preconfigure.bat`)
* Ejecutar `configure.bat` y luego `make.bat`

## Uso

Para probar, usa `r2 frida://0`, ya que adjuntarse al pid0 en frida es una sesión
especial que se ejecuta en local. Ahora puedes ejecutar el comando `:?` para obtener la lista
de comandos disponibles.

```
$ r2 'frida://?'
r2 frida://[action]/[link]/[device]/[target]
* action = list | apps | attach | spawn | launch
* link   = local | usb | remote host:port
* device = '' | host:port | device-id
* target = pid | appname | process-name | program-in-path | abspath
Local:
* frida://?                        # show this help
* frida://                         # list local processes
* frida://0                        # attach to frida-helper (no spawn needed)
* frida:///usr/local/bin/rax2      # abspath to spawn
* frida://rax2                     # same as above, considering local/bin is in PATH
* frida://spawn/$(program)         # spawn a new process in the current system
* frida://attach/(target)          # attach to target PID in current host
USB:
* frida://list/usb//               # list processes in the first usb device
* frida://apps/usb//               # list apps in the first usb device
* frida://attach/usb//12345        # attach to given pid in the first usb device
* frida://spawn/usb//appname       # spawn an app in the first resolved usb device
* frida://launch/usb//appname      # spawn+resume an app in the first usb device
Remote:
* frida://attach/remote/10.0.0.3:9999/558 # attach to pid 558 on tcp remote frida-server
Environment: (Use the `%` command to change the environment at runtime)
  R2FRIDA_SAFE_IO=0|1              # Workaround a Frida bug on Android/thumb
  R2FRIDA_DEBUG=0|1                # Used to debug argument parsing behaviour
  R2FRIDA_COMPILER_DISABLE=0|1     # Disable the new frida typescript compiler (`:. foo.ts`)
  R2FRIDA_AGENT_SCRIPT=[file]      # path to file of the r2frida agent
```

### Ejemplos

```sh
$ r2 frida://0     # same as frida -p 0, connects to a local session
```

Puedes adjuntarte, generar o lanzar cualquier programa por nombre o pid. La siguiente línea se adjuntará al primer proceso llamado `rax2` (ejecuta `rax2 -` en otra terminal para probar esta línea)

```sh
$ r2 frida://rax2  # attach to the first process named `rax2`
$ r2 frida://1234  # attach to the given pid
```

Usar la ruta absoluta de un binario para generar generará el proceso:

```sh
$ r2 frida:///bin/ls
[0x00000000]> :dc        # continue the execution of the target program
```

También funciona con argumentos:

```sh
$ r2 frida://"/bin/ls -al"
```

Para depurar aplicaciones iOS/Android por USB usa estas acciones. Ten en cuenta que `spawn`
puede reemplazarse con `launch` o `attach`, y el nombre del proceso puede ser
el bundleid o el PID.

```sh
$ r2 frida://spawn/usb/         # enumerate devices
$ r2 frida://spawn/usb//        # enumerate apps in the first iOS device
$ r2 frida://spawn/usb//Weather # Run the weather app
```

### Comandos

Estos son los comandos más frecuentes, así que debes aprenderlos y añadirles el sufijo `?` para obtener la ayuda de los subcomandos.

```
:i        # get information of the target (pid, name, home, arch, bits, ..)
.:i*      # import the target process details into local r2
:?        # show all the available commands
:dm       # list maps. Use ':dm|head' and seek to the program base address
:iE       # list the exports of the current binary (seek)
:dt fread # trace the 'fread' function
:dt-*     # delete all traces
```

### Plugins

Los plugins de r2frida se ejecutan en el lado del agente y se registran con la API `r2frida.pluginRegister`.

Consulta el directorio `plugins/` para ver más ejemplos de scripts de plugins.

```js
[0x00000000]> cat example.js
r2frida.pluginRegister('test', function(name) {
  if (name === 'test') {
    return function(args) {
      console.log('Hello Args From r2frida plugin', args);
      return 'Things Happen';
    }
  }
});
[0x00000000]> :. example.js   # load the plugin script
```

El comando `:.` funciona como el comando `.` de r2, pero se ejecuta dentro del agente.

```sh
:. a.js  # run script which registers a plugin
:.       # list plugins
:.-test  # unload a plugin by name
:.. a.js # eternalize script (keeps running after detach)
```

## Termux

Si estás dispuesto a instalar y usar r2frida de forma nativa en Android a través de Termux, hay algunas advertencias con las dependencias de bibliotecas debido a algunas resoluciones de símbolos. La forma de hacer que esto funcione es extendiendo el entorno `LD_LIBRARY_PATH` para que apunte al directorio del sistema *antes* del libdir de termux.

`$ LD_LIBRARY_PATH=/system/lib64:$LD_LIBRARY_PATH r2 frida://...`

## Solución de problemas

Asegúrate de estar usando una versión moderna de r2 (preferiblemente la última versión o git).

CI prueba la versión **radare2 6.2.2** y git master. Los ayudantes de compatibilidad preservan la detección de rutas absolutas de Windows y los nombres de archivo de scripts entrecomillados en ABIs de radare2 más antiguas.

Ejecuta `r2 -L | grep frida` para verificar si el plugin está cargado; si no se imprime nada, usa la variable de entorno `R2_DEBUG=1` para obtener algunos mensajes de depuración y averiguar la razón.

Si tienes problemas para compilar r2frida puedes usar `r2env` o descargar las compilaciones de la página de releases de GitHub; ten en cuenta que solo la versión MAJOR.MINOR debe coincidir, es decir, r2-5.7.6 puede cargar cualquier plugin compilado en cualquier versión entre 5.7.0 y 5.7.8.

## Diseño

```
 +---------+
 | radare2 |     The radare2 tool, on top of the rest
 +---------+
      :
 +----------+
 | io_frida |    r2frida io plugin
 +----------+
      :
 +---------+
 |  frida  |     Frida host APIs and logic to interact with target
 +---------+
      :
  +-------+
  |  app  |      Target process instrumented by Frida with Javascript
  +-------+
```

## Créditos

Este plugin ha sido desarrollado por pancake, alias Sergi Alvarez (el autor de
radare2) para NowSecure.

Me gustaría agradecer a Ole André por escribir y mantener Frida, así
como por ser tan amable de corregir proactivamente errores y discutir detalles técnicos sobre
todo lo necesario para que esta unión funcione. Kudos