r2frida

# r2frida

Radare2 e Frida melhores 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>

## Descrição

Plugin autónomo para [radare2](https://www.radare.org) que inclui
[frida](https://www.frida.re) e permite instrumentar processos locais ou remotos
usando comandos r2 em vez de (mas não limitado a) scripts Frida.

O projeto radare fornece uma cadeia de ferramentas completa para engenharia reversa,
é mantido ativamente e fornece funcionalidades bem mantidas
e estende as suas funcionalidades com outras linguagens de programação e ferramentas.

Frida é um kit de ferramentas de instrumentação dinâmica que facilita a inspeção
e manipulação de processos em execução ao injetar o seu próprio JavaScript, e
opcionalmente também comunicar com os seus scripts.

## Funcionalidades

* Executar scripts Frida não modificados (Use o comando `:.`)
* Executar snippets em C, Javascript ou TypeScript em qualquer processo
* Pode anexar, gerar ou lançar em sistemas locais ou remotos
* Listar secções, símbolos, exportações, protocolos, classes, métodos
* Procurar valores na memória dentro do agente ou a partir do host
* Substituir implementações de métodos ou criar hooks com comandos curtos
* Carregar bibliotecas e frameworks no processo alvo
* Suporta interfaces Dalvik, Java, ObjC, Swift e C
* Manipular descritores de ficheiros e variáveis de ambiente
* Enviar sinais para o processo, continuar, breakpoints
* O plugin io do r2frida é também um backend de sistema de ficheiros **fs** e **debug**
* Automatizar r2 e frida usando r2pipe
* Ler/Escrever memória do processo
* Chamar funções, syscalls e snippets de código bruto
* Conectar ao frida-server via usb ou tcp/ip
* Enumerar apps e processos
* Rastrear registos, argumentos de funções
* Testado em x64, arm32 e arm64 para Linux, Windows, macOS, iOS e Android
* Não requer que o frida esteja instalado no host (não precisa de frida-tools)
* Estender os comandos r2frida com plugins que correm no agente
* Alterar permissões de página, aplicar patches a código e dados
* Resolver símbolos por nome ou endereço e importá-los como flags para o r2
* Executar comandos r2 no host a partir do agente
* Usar APIs r2 e executar comandos r2 dentro do processo alvo remoto.
* Breakpoints nativos usando a API `:db`
* Aceder a sistemas de ficheiros remotos usando a API `r_fs`.

## Instalação

A forma recomendada de instalar o r2frida é via r2pm:

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

Compilações binárias que não requerem compilação serão brevemente suportadas no
`r2pm` e `r2env`. Entretanto, sinta-se à vontade para descarregar as últimas compilações
da [página de Releases](https://github.com/nowsecure/r2frida/releases).

## Compilação

### Dependências

* radare2
* pkg-config (não necessário no windows)
* curl ou wget
* make, gcc
* npm, nodejs (será brevemente removido)

Em GNU/Debian precisará de instalar os seguintes pacotes:

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

### Instruções

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

### Windows

* Instalar meson e Visual Studio
* Descompactar o último zip de lançamento do radare2 no diretório raiz do r2frida
* Renomeá-lo para `radare2` (em vez de radare2-x.y.z)
* Para tornar o compilador VS disponível no PATH (`preconfigure.bat`)
* Executar `configure.bat` e depois `make.bat`

## Utilização

Para testar, use `r2 frida://0`, pois anexar ao pid0 no frida é uma sessão
especial que corre localmente. Agora pode executar o comando `:?` para obter a lista
de comandos disponíveis.

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

### Exemplos

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

Pode anexar, gerar ou lançar para qualquer programa por nome ou pid. A seguinte linha irá anexar ao primeiro processo chamado `rax2` (execute `rax2 -` noutro terminal para testar esta linha)

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

Usar o caminho absoluto de um binário para gerar irá gerar o processo:

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

Também funciona com argumentos:

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

Para depuração USB de apps iOS/Android use estas ações. Note que `spawn`
pode ser substituído por `launch` ou `attach`, e o nome do processo pode ser
o bundleid ou o 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

Estes são os comandos mais frequentes, por isso deve aprendê-los e acrescentar o sufixo `?` para obter ajuda sobre 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

Os plugins r2frida correm no lado do agente e são registados com a API `r2frida.pluginRegister`.

Veja o diretório `plugins/` para mais alguns exemplos 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
```

O comando `:.` funciona como o comando `.` do r2, mas corre dentro do 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

Se estiver disposto a instalar e usar o r2frida nativamente no Android via Termux, existem algumas ressalvas com as dependências de bibliotecas devido a algumas resoluções de símbolos. A forma de fazer isto funcionar é estendendo o ambiente `LD_LIBRARY_PATH` para apontar para o diretório do sistema *antes* do libdir do termux.

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

## Resolução de problemas

Certifique-se de que está a usar uma versão moderna do r2 (preferencialmente a última versão ou git).

O CI testa a versão **radare2 6.2.2** e o git master. Os auxiliares de compatibilidade preservam a deteção de caminhos absolutos do Windows e nomes de ficheiros de scripts entre aspas em ABIs mais antigas do radare2.

Execute `r2 -L | grep frida` para verificar se o plugin está carregado; se nada for impresso, use a variável de ambiente `R2_DEBUG=1` para obter algumas mensagens de depuração e descobrir a razão.

Se tiver problemas a compilar o r2frida pode usar `r2env` ou obter as compilações de lançamento da página de releases do GitHub; tenha em conta que apenas a versão MAJOR.MINOR tem de corresponder, isto é, r2-5.7.6 pode carregar qualquer plugin compilado em qualquer versão entre 5.7.0 e 5.7.8.

## Design

```
 +---------+
 | 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 foi desenvolvido por pancake, também conhecido como Sergi Alvarez (o autor do
radare2) para a NowSecure.

Gostaria de agradecer ao Ole André por escrever e manter o Frida, bem
como por ser tão amável ao corrigir proativamente bugs e discutir detalhes técnicos
sobre tudo o que é necessário para fazer esta união funcionar. Kudos