Petit guide de survie pour radare2

[supersnail]

I - Introduction

Radare2 est, comme certains le savent peut-être, un outil d'analyse de binaires/shellcode assez puissant, supportant beaucoup d'architectures (il supporte même le brainfuck !), et permettant l'analyse statique et dynamique (i.e. le debugging) de programmes (je n'ai malheureusement pas encore expérimenté ce point).
Devant l'étendue des possibilités de radare2, je rédige donc ce petit guide permettant de démarrer en douceur et d'apprivoiser ce logiciel qui semble assez austère au premier abord.

Je présupposerai que vous avez donc une machine tourant sur GNU/Linux, avec la dernière version git de radare2 d'installée, afin de débuter notre randonnée.

II - Analysons notre premier programme

Pour lancer le désassamblage d'un programme, on le via la ligne de commande, avec "r2 monprogramme". Notre victime ici sera "/bin/ls" (ou /usr/bin/ls selon votre distribution), on tapera donc donc ceci:

Code :

$ r2 /bin/ls

Après un temps de chargement normalement court, vous devriez avoir dans votre terminal quelque chose comme ceci (avec des couleurs qui ne sont hélas pas affichées ici):

Code :

$ r2 /bin/ls
-- Your project name should contain an uppercase letter, 8 vowels, some numbers and the 5 first numbers of your private bitcoin key.
[0x004048bf]>

On se retrouve donc nez-à-nez avec un "motd" aléatoire, ainsi qu'à un prompt attendant une action de notre part.
Pour les plus courageux, vous pouvez toujours taper "?" pour avoir l'aide en anglais (et si vous êtes encore plus courageux vous arrêtez la lecture de ce petit guide pour partir seul à l'aventure :>), et pour les autres, on va lancer l'analyse de notre binaire simplement avec la commande af, qui aura pour fonction de lancer une analyse (comme IDA) du code et de permettre à radare2 de repérer les fonctions, chaînes de caractères, addresses et autre.
Puis on va ensuite afficher le listing assembleur de notre fonction, et pour cela, on utilise la commande pdf (pour "print disassembly function")

Nous avons donc quelque chose comme ceci normalement (les habitués du RE reconnaîtront un binaire x86_64):

Code :

[0x004048bf]> af
[0x004048bf]> pdf
/ (fcn) entry0 42
|          0x004048bf    31ed         xor ebp, ebp
|          0x004048c1    4989d1       mov r9, rdx
|          0x004048c4    5e           pop rsi
|          0x004048c5    4889e2       mov rdx, rsp
|          0x004048c8    4883e4f0     and rsp, 0xfffffffffffffff0
|          0x004048cc    50           push rax
|          0x004048cd    54           push rsp
|          0x004048ce    49c7c040224. mov r8, 0x412240 ;  0x00412240
|          0x004048d5    48c7c1d0214. mov rcx, fcn.004121d0 ;  0x004121d0
|          0x004048dc    48c7c7a0284. mov rdi, section..text ;  0x004028a0
|          0x004048e3    e818dcffff   call sym.imp.__libc_start_main
|             sym.imp.__libc_start_main(unk, unk, unk)
\          0x004048e8    f4           hlt

On a ici un .start généré par ld, notre linker préféré, qui appelle une fonction __libc_start_main, qui prend en premier paramètre notre fonction "main", stockée dans le registre rdi (convention adoptée par les *nix-like). On va donc imprimer les 10 premières instructions de notre fonction "main" non détectée comme telle (elle est appellée "section..text" suite à l'analyse, comme le programme a été strippé chez moi), avec la commande pd 10.
Ce qui devrait donner comme résultat:

Code :

[0x004048bf]> pd 10 @section..text
           ; DATA XREF from 0x004048dc (entry0)
   ;      [12] va=0x004028a0 pa=0x000028a0 sz=63961 vsz=63961 rwx=-r-x .text
/ (fcn) section..text 7720
|          0x004028a0    4157         push r15
|          0x004028a2    4156         push r14
|          0x004028a4    4155         push r13
|          0x004028a6    4154         push r12
|          0x004028a8    55           push rbp
|          0x004028a9    53           push rbx
|          0x004028aa    89fb         mov ebx, edi
|          0x004028ac    4889f5       mov rbp, rsi
|          0x004028af    4881ec98030. sub rsp, 0x398
|          0x004028b6    488b3e       mov rdi, [rsi]

On peut aussi se "repositionner" à une addresse précise avec:

Code :

[0x004048bf]> 0x004121d0

ou encore:

Code :

[0x004048bf]> s 0x004121d0

ou

Code :

[0x004048bf]> s section..text

(il semblerait que ça ne marche pas à tout les coups, d'utiliser le nom du symbole).
Comme je trouve le nom "section..text" peu explicite, je vous propose de renommer cette fonction. On a deux options:

• Soit on se positionne sur main, et on tape afn main
  
• Soit on reste où on est et on fait afn main @section..text
  

Dans cette partie, nous avons vu comment nous déplacer dans le code, et lister le code assembleur de plusieurs fonctions. Avant de passer à la section suivante, observons comment sont construites les commandes radare2.

Si vous avez lu l'aide, vous avez sûrement remarqué que les commandes étaient "classées" par catégories, pour laquelle était assignée une lettre. Ainsi "p" donne accès aux commandes de formattage/affichage (et taper "p?" vous donnera l'aide de ces commandes), tandis que "S" donne accès aux commandes permettant de manipuler les sections du binaire (s'il y en a), et "a" regroupe les fonctions d'analyse. Chaque lettre (appelée "mnémonique") permet ainsi de parcourir l'arborescence des commandes radare2.

A titre d'exercice, je vous laisse trouver à quoi correspond la commande "pxe"

III - Le mode visuel / Mot de la fin

Nous avons vu précédemment que l'on pouvait désassembler, et naviguer dans le code en tapant des commandes dans le prompt de radare2. Cependant, cela n'est pas forcément très pratique à utiliser, et peut rendre l'analyse relativement fastidieuse et désagréable; et ceux qui connaissent OllyDBG souhaiteraient sûrement pouvoir naviguer dans le code d'une manière similaire.
Fort heureusement, radare2 propose un "visual mode", qui, toujours en ligne de commande, permet d'apporter une interface dont pourraient rêver les amateurs d'OllyDBG ! (et qui permet en plus de jouer à 2048, mais ce n'est pas le propos du guide :]).

Pour entrer dans ce monde merveilleux, il suffit de taper "V" dans le prompt de radare2.
Il est possible que vous aterrissiez alors sur un hexdump géant (ce qui est mon cas), dans ce cas n'hésitez pas à appuyer sur "p" jusqu'à ce que le listing revienne. Vous avez devant vos yeux ébahis le listing de la fonction "courante". De plus vous pouvez vous déplacer via les touches directionnelles, en scrollant à la souris, et octet par octet avec les touches "k" et "l". Pour entrer dans une fonction, il suffit de se positionner dessus puis d'appuyer sur "Entrée", et pour en sortir, taper "u". Pour aller à une addresse précise, pressez "o" et pour avoir l'aide, le traditionnel "?". A noter qu'on peut toujours saisir des commandes radare2, il suffit pour cela de la faire précéder d'un ":" (les connaisseurs de vi(m) reconnaîtront ).

Voilà donc pour ce petit guide de survie, qui sera peut-être mis à jour ultérieurement, sous licence Beerware (oui j'aime les licences à la con). En annexe, je fournis un petit récapitulatif des commandes utiles:

Code :

Mode normal:
- af: analyse les fonctions en partant de là où on est (généralement le point d'entrée)
- pdf: affiche le listing d'une fonction
- pd xx [@addr]: affiche xx lignes de listing de la fonction à l'adresse "addr" si définie (sinon c'est l'adresse courante)
- x [@addr]: dump hexa de addr (ou l'adresse courante si addr n'est pas défini)
- afn name [@addr]: renomme une fonction
- Ps projet.project: sauvegarde une session radare2
- Po projet.project: restaure une session radare2

Mode visuel:
- o addr: va à l'addresse "addr"
- p/P : permettent de switch entre plusieurs vues (désassemblage, debug, hexdump, et d'autres trucs)
- : : donne un prompt r2 pour exécuter des commandes
- ; : permet de définir un commentaire
- u : permet de revenir à l'adresse précédente
- U : revient à l'adresse suivante
- [Entrée]: saute à la fonction "surlignée"

Si vous remarquez des fautes/imprécisions ou trucs pas clairs, n'hésitez pas à poser la question !
En espérant que ce guide vous sera utile

[gruik]

ça poutre

[thxer]

Cool !

[ZeR0-@bSoLu]

Useful tool Merci pour cette intoduction