r2frida

# r2frida

Radare2 und Frida besser zusammen [![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>

## Beschreibung

Eigenständiges Plugin für [radare2](https://www.radare.org), das
[frida](https://www.frida.re) mitliefert und es ermöglicht, lokale oder entfernte
Prozesse mit r2-Befehlen statt (aber nicht beschränkt auf) Frida-Skripten zu instrumentieren.

Das radare-Projekt bietet eine vollständige Toolchain für Reverse Engineering,
es wird aktiv gepflegt und stellt gut gewartete Funktionalitäten bereit
und erweitert seine Features mit anderen Programmiersprachen und Tools.

Frida ist ein dynamisches Instrumentierungs-Toolkit, das es einfach macht, laufende
Prozesse zu inspizieren und zu manipulieren, indem man eigenes JavaScript injiziert und
optional auch mit seinen Skripten kommuniziert.

## Features

* Unveränderte Frida-Skripte ausführen (Verwende den `:.`-Befehl)
* Snippets in C, Javascript oder TypeScript in jedem Prozess ausführen
* Kann in lokalen oder entfernten Systemen anhängen, spawnen oder starten
* Sections, Symbole, Exporte, Protokolle, Klassen, Methoden auflisten
* Nach Werten im Speicher innerhalb des Agenten oder vom Host aus suchen
* Methodenimplementierungen ersetzen oder Hooks mit kurzen Befehlen erstellen
* Bibliotheken und Frameworks in den Zielprozess laden
* Unterstützung für Dalvik-, Java-, ObjC-, Swift- und C-Schnittstellen
* Dateideskriptoren und Umgebungsvariablen manipulieren
* Signale an den Prozess senden, fortsetzen, Breakpoints
* Das r2frida-io-Plugin ist auch ein Dateisystem-**fs**- und **debug**-Backend
* r2 und frida mit r2pipe automatisieren
* Prozessspeicher lesen/schreiben
* Funktionen, Syscalls und rohe Code-Snippets aufrufen
* Verbindung zu frida-server über usb oder tcp/ip
* Apps und Prozesse auflisten
* Register, Argumente von Funktionen tracen
* Getestet auf x64, arm32 und arm64 für Linux, Windows, macOS, iOS und Android
* Erfordert keine Installation von frida auf dem Host (keine frida-tools nötig)
* Erweitere die r2frida-Befehle mit Plugins, die im Agenten laufen
* Seitenberechtigungen ändern, Code und Daten patchen
* Symbole nach Name oder Adresse auflösen und als Flags in r2 importieren
* r2-Befehle im Host vom Agenten aus ausführen
* r2-APIs verwenden und r2-Befehle innerhalb des entfernten Zielprozesses ausführen.
* Native Breakpoints mit der `:db`-API
* Auf entfernte Dateisysteme mit der `r_fs`-API zugreifen.

## Installation

Der empfohlene Weg, r2frida zu installieren, ist über r2pm:

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

Binär-Builds, die keine Kompilierung erfordern, werden bald in
`r2pm` und `r2env` unterstützt. In der Zwischenzeit kannst du gerne die letzten Builds
von der [Releases-Seite](https://github.com/nowsecure/r2frida/releases) herunterladen.

## Kompilierung

### Abhängigkeiten

* radare2
* pkg-config (unter Windows nicht erforderlich)
* curl oder wget
* make, gcc
* npm, nodejs (wird bald entfernt)

Unter GNU/Debian musst du die folgenden Pakete installieren:

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

### Anweisungen

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

### Windows

* Installiere meson und Visual Studio
* Entpacke das neueste radare2-Release-Zip im r2frida-Stammverzeichnis
* Benenne es in `radare2` um (statt radare2-x.y.z)
* Um den VS-Compiler in PATH verfügbar zu machen (`preconfigure.bat`)
* Führe `configure.bat` und dann `make.bat` aus

## Verwendung

Zum Testen verwende `r2 frida://0`, denn das Anhängen an die pid0 in frida ist eine spezielle
Sitzung, die lokal läuft. Jetzt kannst du den `:?`-Befehl ausführen, um die Liste
der verfügbaren Befehle zu erhalten.

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

### Beispiele

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

Du kannst an jedes Programm nach Name oder pid anhängen, spawnen oder starten. Die folgende Zeile hängt an den ersten Prozess namens `rax2` an (führe `rax2 -` in einem anderen Terminal aus, um diese Zeile zu testen)

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

Die Verwendung des absoluten Pfads einer Binärdatei zum Spawnen wird den Prozess spawnen:

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

Funktioniert auch mit Argumenten:

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

Für USB-Debugging von iOS/Android-Apps verwende diese Aktionen. Beachte, dass `spawn`
durch `launch` oder `attach` ersetzt werden kann und der Prozessname
die bundleid oder die PID sein kann.

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

### Befehle

Dies sind die häufigsten Befehle, also musst du sie lernen und mit `?` ergänzen, um Hilfe zu Unterbefehlen zu erhalten.

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

r2frida-Plugins laufen auf der Agenten-Seite und werden mit der `r2frida.pluginRegister`-API registriert.

Siehe das `plugins/`-Verzeichnis für weitere Beispiel-Plugin-Skripte.

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

Der `:.`-Befehl funktioniert wie der `.`-Befehl von r2, läuft aber innerhalb des Agenten.

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

Wenn du bereit bist, r2frida nativ auf Android über Termux zu installieren und zu verwenden, gibt es einige Einschränkungen bei den Bibliotheksabhängigkeiten aufgrund einiger Symbolauflösungen. Der Weg, dies zum Laufen zu bringen, besteht darin, die `LD_LIBRARY_PATH`-Umgebung zu erweitern, um auf das Systemverzeichnis *vor* dem termux-libdir zu zeigen.

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

## Fehlerbehebung

Stelle sicher, dass du eine moderne Version von r2 verwendest (vorzugsweise die letzte Version oder git).

CI testet das **radare2 6.2.2**-Release und git master. Kompatibilitätshelfer bewahren die Windows-Absolutpfad-Erkennung und zitierte Skriptdateinamen auf älteren radare2-ABIs.

Führe `r2 -L | grep frida` aus, um zu überprüfen, ob das Plugin geladen ist. Wenn nichts ausgegeben wird, verwende die `R2_DEBUG=1`-Umgebungsvariable, um einige Debug-Meldungen zu erhalten, um den Grund herauszufinden.

Wenn du Probleme beim Kompilieren von r2frida hast, kannst du `r2env` verwenden oder die Release-Builds von der GitHub-Releases-Seite herunterladen. Beachte, dass nur die MAJOR.MINOR-Version übereinstimmen muss, das heißt r2-5.7.6 kann jedes Plugin laden, das auf einer beliebigen Version zwischen 5.7.0 und 5.7.8 kompiliert wurde.

## 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
  +-------+
```

## Danksagungen

Dieses Plugin wurde von pancake aka Sergi Alvarez (dem Autor von
radare2) für NowSecure entwickelt.

Ich möchte Ole André dafür danken, dass er Frida geschrieben und gepflegt hat sowie
so freundlich war, proaktiv Bugs zu beheben und technische Details zu allem zu besprechen,
was nötig war, um diese Verbindung zum Laufen zu bringen. Kudos