← retour aux outils back to tools

# Radare2

Framework open-source de rétro-ingénierie. Désassemblage, débogage, patching et analyse binaire avec une interface en ligne de commande puissante et une API de scripting. Open-source reverse engineering framework. Disassembly, debugging, patching, and binary analysis with a powerful command-line interface and scripting API.

↗ https://radare.org

## Overview

Radare2 (r2) is a portable reverse engineering framework with disassembly, debugging, binary patching, data carving, and code analysis. It has a steep learning curve but is extremely powerful. `Cutter` provides a GUI frontend. `rizin` is its community fork with a cleaner API.

## Opening Binaries

Open binary for analysis

    r2 binary

Open with automatic analysis

    r2 -A binary

    # Open for debugging
    r2 -d binary
    r2 -d ./binary arg1 arg2

Open a remote process

    r2 -d gdb://127.0.0.1:1234

Open without analysis (fast, for big binaries)

    r2 -n binary

Write mode (for patching)

    r2 -w binary

## Basic Navigation

    # Analyze all (also: aaa for more thorough)
    > aa

    # List functions
    > afl

    # Go to main function
    > s main
    > s sym.main

    # Go to address
    > s 0x401234

    # Print disassembly at current position
    > pd 20        # 20 instructions
    > pdf          # entire function

    # Print C-like pseudo-code (decompiler)
    > pdc
    > pdg          # With Ghidra engine (if rz-ghidra installed)

## Visual Mode

    # Enter visual mode
    > V

    # Visual disassembly (toggle hex/disasm)
    > VV           # Graph view
    > v            # Visual panels

    # In visual mode:
    p / P          # Cycle views
    Enter          # Follow jump/call
    u              # Undo navigation
    g              # Go to address
    n              # Rename current function/symbol
    ;              # Add comment

## Searching

    # Search for string
    > / password
    > /ia password   # Case-insensitive

Search for byte sequence

    > /x 90909090    # Find NOP sled

Search for ROP gadgets

    > /R pop rdi; ret

    > axt 0x401234   # Cross-references to

    > axf 0x401234   # Cross-references from

## Strings & Info

    # List all strings
    > iz
    > izz    # Search entire binary including data sections

    # Binary info
    > i
    > iI     # Detailed info (arch, bits, OS, etc.)

Imports

    > ii

Exports

    > iE

Sections

    > iS

Symbols

    > is

## Debugging

    # Set breakpoint
    > db 0x401234
    > db main

List breakpoints

    > dbl

Continue execution

    > dc

    # Step into / step over
    > ds
    > dso

Print registers

    > dr

Print stack

    > pxr @ rsp

Watch memory at address

    > drr

## Patching

    # Write bytes at address (write mode: r2 -w)
    > s 0x401234
    > wx 9090     # Write NOP bytes

    # Write assembly instruction
    > wa nop
    > wa jmp 0x401234

Assemble code

    > pa "mov eax, 1; ret"

## Scripting (r2pipe)

    import r2pipe
    r2 = r2pipe.open("./binary")
    r2.cmd("aaa")
    print(r2.cmd("afl"))    # List functions
    print(r2.cmdj("aflj"))  # JSON output
    r2.quit()

## Tips

- `aaa` is more thorough analysis than `aa` but takes longer
- `s` (seek) is the primary navigation command
- Use `?` after any command for help: `a?`, `p?`, `d?`
- `Cutter` (GUI) makes radare2 much more approachable for beginners

Command categories

    a   Analysis
    b   Blocks
    c   Code/compare
    d   Debug
    f   Flags
    g   Go/seek
    i   Info
    o   Open
    p   Print
    q   Quit
    r   Resize/radiff
    s   Seek
    t   Types
    u   Undo
    v   Visual
    w   Write
    x   Cross-references
    ?   Help

## Vue d’ensemble

Radare2 (r2) est un framework de rétro-ingénierie portable avec désassemblage, débogage, patching binaire, extraction de données et analyse de code. Il a une courbe d’apprentissage raide mais est extrêmement puissant. `Cutter` fournit une interface graphique. `rizin` est son fork communautaire avec une API plus propre.

## Ouverture de binaires

    # Ouvrir un binaire pour analyse
    r2 binary

    # Ouvrir avec analyse automatique
    r2 -A binary

    # Ouvrir pour débogage
    r2 -d binary
    r2 -d ./binary arg1 arg2

    # Ouvrir un processus distant
    r2 -d gdb://127.0.0.1:1234

    # Ouvrir sans analyse (rapide, pour les gros binaires)
    r2 -n binary

    # Mode écriture (pour le patching)
    r2 -w binary

## Navigation basique

    # Analyser tout (aussi : aaa pour plus de rigueur)
    > aa

    # Lister les fonctions
    > afl

    # Aller à la fonction main
    > s main
    > s sym.main

    # Aller à une adresse
    > s 0x401234

    # Afficher le désassemblage à la position courante
    > pd 20        # 20 instructions
    > pdf          # fonction entière

    # Afficher le pseudo-code façon C (décompilateur)
    > pdc
    > pdg          # avec le moteur Ghidra (si rz-ghidra est installé)

## Mode visuel

    # Entrer en mode visuel
    > V

    # Désassemblage visuel (bascule hex/désassemblage)
    > VV           # Vue graphe
    > v            # Panneaux visuels

    # En mode visuel :
    p / P          # Cycler entre les vues
    Enter          # Suivre un jump/call
    u              # Annuler la navigation
    g              # Aller à une adresse
    n              # Renommer la fonction/symbole courant
    ;              # Ajouter un commentaire

## Recherche

    # Rechercher une chaîne
    > / password
    > /ia password   # Insensible à la casse

    # Rechercher une séquence d'octets
    > /x 90909090    # Trouver un NOP sled

    # Rechercher des gadgets ROP
    > /R pop rdi; ret

    > axt 0x401234   # Références croisées vers

    > axf 0x401234   # Références croisées depuis

## Chaînes et informations

    # Lister toutes les chaînes
    > iz
    > izz    # Chercher dans tout le binaire, y compris les sections de données

    # Informations sur le binaire
    > i
    > iI     # Informations détaillées (architecture, bits, OS, etc.)

    # Imports
    > ii

    # Exports
    > iE

    # Sections
    > iS

    # Symboles
    > is

## Débogage

    # Placer un point d'arrêt
    > db 0x401234
    > db main

    # Lister les points d'arrêt
    > dbl

    # Poursuivre l'exécution
    > dc

    # Pas à pas (step into / step over)
    > ds
    > dso

    # Afficher les registres
    > dr

    # Afficher la pile
    > pxr @ rsp

    # Surveiller la mémoire à une adresse
    > drr

## Patching

    # Écrire des octets à une adresse (mode écriture : r2 -w)
    > s 0x401234
    > wx 9090     # Écrire des octets NOP

    # Écrire une instruction assembleur
    > wa nop
    > wa jmp 0x401234

    # Assembler du code
    > pa "mov eax, 1; ret"

## Scripting (r2pipe)

    import r2pipe
    r2 = r2pipe.open("./binary")
    r2.cmd("aaa")
    print(r2.cmd("afl"))    # Lister les fonctions
    print(r2.cmdj("aflj"))  # Sortie JSON
    r2.quit()

## Conseils

- `aaa` est une analyse plus poussée que `aa` mais prend plus de temps
- `s` (seek) est la commande de navigation principale
- Utiliser `?` après n’importe quelle commande pour l’aide : `a?`, `p?`, `d?`
- `Cutter` (GUI) rend radare2 beaucoup plus accessible aux débutants

Catégories de commandes

    a   Analysis
    b   Blocks
    c   Code/compare
    d   Debug
    f   Flags
    g   Go/seek
    i   Info
    o   Open
    p   Print
    q   Quit
    r   Resize/radiff
    s   Seek
    t   Types
    u   Undo
    v   Visual
    w   Write
    x   Cross-references
    ?   Help