r2frida

# r2frida

Radare2 et Frida, mieux ensemble [![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>

## Description

Plugin autonome pour [radare2](https://www.radare.org) qui embarque
[frida](https://www.frida.re) et permet d'instrumenter des processus locaux ou distants
à l'aide de commandes r2 au lieu (mais sans s'y limiter) de scripts Frida.

Le projet radare fournit une chaîne d'outils complète pour le reverse engineering,
il est activement maintenu et propose des fonctionnalités bien entretenues
et étend ses capacités avec d'autres langages de programmation et outils.

Frida est une boîte à outils d'instrumentation dynamique qui facilite l'inspection
et la manipulation de processus en cours d'exécution en injectant votre propre JavaScript, et
permet également, en option, de communiquer avec vos scripts.

## Fonctionnalités

* Exécuter des scripts Frida non modifiés (utilisez la commande `:.`)
* Exécuter des extraits en C, Javascript ou TypeScript dans n'importe quel processus
* Peut s'attacher, lancer ou démarrer sur des systèmes locaux ou distants
* Lister les sections, symboles, exports, protocoles, classes, méthodes
* Rechercher des valeurs en mémoire dans l'agent ou depuis l'hôte
* Remplacer des implémentations de méthodes ou créer des hooks avec de courtes commandes
* Charger des bibliothèques et frameworks dans le processus cible
* Prise en charge des interfaces Dalvik, Java, ObjC, Swift et C
* Manipuler les descripteurs de fichiers et les variables d'environnement
* Envoyer des signaux au processus, continuer, points d'arrêt
* Le plugin io r2frida est aussi un backend **fs** et **debug**
* Automatiser r2 et frida avec r2pipe
* Lire/écrire la mémoire du processus
* Appeler des fonctions, des appels système et des extraits de code brut
* Se connecter à frida-server via usb ou tcp/ip
* Énumérer les applications et les processus
* Tracer les registres, les arguments des fonctions
* Testé sur x64, arm32 et arm64 pour Linux, Windows, macOS, iOS et Android
* Ne nécessite pas que frida soit installé sur l'hôte (pas besoin de frida-tools)
* Étendre les commandes r2frida avec des plugins qui s'exécutent dans l'agent
* Modifier les permissions de page, patcher le code et les données
* Résoudre les symboles par nom ou adresse et les importer comme flags dans r2
* Exécuter des commandes r2 sur l'hôte depuis l'agent
* Utiliser les API r2 et exécuter des commandes r2 à l'intérieur du processus cible distant.
* Points d'arrêt natifs via l'API `:db`
* Accéder aux systèmes de fichiers distants via l'API `r_fs`.

## Installation

La méthode recommandée pour installer r2frida est via r2pm :

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

Les builds binaires ne nécessitant pas de compilation seront bientôt pris en charge dans
`r2pm` et `r2env`. En attendant, n'hésitez pas à télécharger les derniers builds
depuis la [page Releases](https://github.com/nowsecure/r2frida/releases).

## Compilation

### Dépendances

* radare2
* pkg-config (non requis sous windows)
* curl ou wget
* make, gcc
* npm, nodejs (sera bientôt supprimé)

Sous GNU/Debian, vous devrez installer les paquets suivants :

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

### Instructions

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

### Windows

* Installer meson et Visual Studio
* Décompresser le dernier zip de radare2 dans le répertoire racine de r2frida
* Le renommer en `radare2` (au lieu de radare2-x.y.z)
* Pour rendre le compilateur VS disponible dans le PATH (`preconfigure.bat`)
* Exécuter `configure.bat` puis `make.bat`

## Utilisation

Pour tester, utilisez `r2 frida://0`, car s'attacher au pid0 dans frida est une session
spéciale qui s'exécute en local. Vous pouvez maintenant exécuter la commande `:?` pour obtenir la liste
des commandes 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
```

### Exemples

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

Vous pouvez vous attacher, lancer ou démarrer n'importe quel programme par nom ou pid. La ligne suivante s'attachera au premier processus nommé `rax2` (exécutez `rax2 -` dans un autre terminal pour tester cette ligne)

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

Utiliser le chemin absolu d'un binaire pour le lancer démarrera le processus :

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

Fonctionne aussi avec des arguments :

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

Pour le débogage USB d'applications iOS/Android, utilisez ces actions. Notez que `spawn`
peut être remplacé par `launch` ou `attach`, et que le nom du processus peut être
le bundleid ou le 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
```

### Commandes

Voici les commandes les plus fréquentes, vous devez donc les apprendre et les suffixer avec `?` pour obtenir l'aide des sous-commandes.

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

Les plugins r2frida s'exécutent côté agent et sont enregistrés avec l'API `r2frida.pluginRegister`.

Consultez le répertoire `plugins/` pour d'autres exemples 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
```

La commande `:.` fonctionne comme la commande `.` de r2, mais s'exécute à l'intérieur de l'agent.

```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 vous souhaitez installer et utiliser r2frida nativement sur Android via Termux, il existe quelques mises en garde concernant les dépendances de bibliothèques en raison de certaines résolutions de symboles. La façon de faire fonctionner cela est d'étendre la variable d'environnement `LD_LIBRARY_PATH` pour pointer vers le répertoire système *avant* le libdir de termux.

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

## Dépannage

Assurez-vous d'utiliser une version moderne de r2 (de préférence la dernière release ou git).

La CI teste la version **radare2 6.2.2** et git master. Les aides de compatibilité préservent la détection des chemins absolus Windows et les noms de fichiers de scripts entre guillemets sur les anciens ABI de radare2.

Exécutez `r2 -L | grep frida` pour vérifier si le plugin est chargé ; si rien n'est affiché, utilisez la variable d'environnement `R2_DEBUG=1` pour obtenir des messages de débogage afin de trouver la raison.

Si vous rencontrez des problèmes pour compiler r2frida, vous pouvez utiliser `r2env` ou récupérer les builds de release depuis la page des releases GitHub. Gardez à l'esprit que seule la version MAJEUR.MINEUR doit correspondre, c'est-à-dire que r2-5.7.6 peut charger n'importe quel plugin compilé sur n'importe quelle version entre 5.7.0 et 5.7.8.

## Conception

```
 +---------+
 | 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édits

Ce plugin a été développé par pancake alias Sergi Alvarez (l'auteur de
radare2) pour NowSecure.

Je tiens à remercier Ole André pour avoir écrit et maintenu Frida ainsi
que pour sa gentillesse à corriger proactivement les bugs et à discuter des détails techniques sur
tout ce qui est nécessaire pour faire fonctionner cette union. Kudos