Il indique au plugin **ret-sync** ``IDA`` d'écouter sur l'interface
``192.168.128.1`` avec le port ``9234``. Il va sans dire que cette
interface doit être accessible depuis la machine distante ou la machine virtuelle.

* une sur la machine où le débogueur est exécuté, dans le répertoire personnel de l'utilisateur :```
[INTERFACE]
host=192.168.128.1
port=9234

La section ``[ALIASES]`` permet de personnaliser le nom utilisé par un désassembleur (IDA/Ghidra) pour enregistrer un module auprès de son répartiteur/gestionnaire de programme.

Par défaut, les plugins de désassembleur utilisent le nom du fichier d'entrée. Cependant, on peut avoir renommé le fichier au préalable et celui-ci ne correspond plus au nom du processus réel ou du module chargé tel que vu par le débogueur.

Ici, on indique simplement au répartiteur de correspondre au nom `ntkrnlmp.exe` (nom réel) au lieu de `ntoskrnl_vuln.exe` (nom IDB).


## gdb avec le frontal de débogage Qt Creator

Le frontal de débogage Qt Creator modifie la manière dont la sortie des commandes gdb est journalisée. Cela pouvant interférer avec la synchronisation, une option existe pour utiliser la sortie brute de gdb pour la synchronisation au lieu d'un fichier temporaire. Dans le fichier de configuration .sync, utiliser```
[GENERAL]
use_tmp_logging_file=false

Chaque entrée dans les correspondances est : ``mem_base``, ``mem_end``, ``mem_size``, ``mem_name``.


## Contournement du rebasage automatique d'adresse

Dans certains scénarios, comme le débogage de dispositifs embarqués ou la connexion à
des interfaces de débogage minimalistes, il peut être plus pratique de contourner la
fonctionnalité de rebasage automatique d'adresse implémentée dans les plugins du désassembleur.

L'option `use_raw_addr` est actuellement prise en charge uniquement pour Ghidra. Dans
le fichier de configuration .sync, utilisez :```
[GENERAL]
use_raw_addr=true

### Dépannage du plugin IDA

Pour dépanner les problèmes avec l'extension IDA, deux options sont disponibles dans le fichier `retsync/rsconfig.py` :```
LOG_LEVEL = logging.INFO
LOG_TO_FILE_ENABLE = False

3. Construisez l'extension pour votre installation de Ghidra (remplacez `$GHIDRA_DIR` par votre répertoire d'installation)```bash
cd ext_ghidra
gradle -PGHIDRA_INSTALL_DIR=$GHIDRA_DIR

[*] retsync init
[>] programOpened: tm.sys
    imageBase: 0x1c0000000
```
4. Depuis l'outil Ghidra CodeBrowser : utilisez les icônes de la barre d'outils ou les raccourcis pour activer (``Alt+s``)/désactiver (``Alt+Shift+s``)/redémarrer (``Alt+r``) la synchronisation.

Une fenêtre d'état est également disponible via ``Windows`` -> ``RetSyncPlugin``. Il est généralement préférable de la déposer sur le côté pour l'intégrer aux fenêtres de l'environnement Ghidra.

## Extension Binary Ninja

La prise en charge de Binary Ninja est expérimentale, assurez-vous de sauvegarder vos bases de données d'analyse.

### Prérequis Binary Ninja

**ret-sync** nécessite au minimum Binary Ninja version 2.2 ainsi que Python 3 (Python 2 n'est pas pris en charge).

### Installer l'extension Binary Ninja

**ret-sync** n'est pas encore distribué via le gestionnaire de plugins de Binary Ninja ; une installation manuelle est nécessaire. Copiez simplement le contenu du dossier `ext_bn` dans le dossier des plugins de Binary Ninja, par exemple :

`%APPDATA%\Binary Ninja\plugins`

Après avoir redémarré Binary Ninja, la sortie suivante devrait apparaître dans la fenêtre de console :```
[sync] commands added
Loaded python3 plugin 'retsync'
```
## Extension WinDbg

### Construction de l'extension WinDbg

Utilisez la solution Visual Studio 2017 fournie dans ``ext_windbg``. Visual Studio [Community Edition](https://visualstudio.microsoft.com/fr/vs/community/) 2017 et 2026 ont été testés avec succès (les versions intermédiaires devraient également fonctionner).

Cela construira le fichier `x64\release\sync.dll`.

### Installation de l'extension WinDbg

Vous devrez copier le fichier `sync.dll` résultant dans le chemin approprié des extensions Windbg.

* WinDbg Classic :

Pour les versions antérieures de Windbg, cela ressemble à ceci (faites attention aux versions ``x86``/``x64``), par exemple

`C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\winext\sync.dll`

* Windbg Preview

Le dossier de stockage des extensions semble être basé sur le PATH, vous devez donc le placer dans l'un des emplacements interrogés.

Un exemple consiste à le placer ici :

`C:\Users\user\AppData\Local\Microsoft\WindowsApps\sync.dll`

### Exécution de l'extension WinDbg

1. Lancez WinDbg sur la cible
2. Chargez l'extension (commande ``.load``)```
    0:000> .load sync
    [sync.dll] DebugExtensionInitialize, ExtensionApis loaded
```
3. Synchroniser WinDbg```
      0:000> !sync
      [sync] No argument found, using default host (127.0.0.1:9100)
      [sync] sync success, sock 0x5a8
      [sync] probing sync
      [sync] sync is now enabled with host 127.0.0.1
```
p. ex. dans la fenêtre de sortie d'IDA```
      [*] << broker << dispatcher msg: add new client (listening on port 63898), nb client(s): 1
      [*] << broker << dispatcher msg: new debugger client: dbg connect - HostMachine\HostUser
      [sync] set debugger dialect to windbg, enabling hotkeys
```
Si le module actuel de Windbg correspond au nom du fichier IDA```
      [sync] idb is enabled with the idb client matching the module name.
```
### Dépannage de l'installation de WinDbg

Remarque : Si vous obtenez l'erreur suivante, c'est parce que vous n'avez pas copié le fichier
dans le bon dossier lors des étapes ci-dessus.```
0: kd> .load sync
The call to LoadLibrary(sync) failed, Win32 error 0n2
    "The system cannot find the file specified."
Please check your debugger configuration and/or network access.
```
L'erreur ci-dessous signifie généralement que Windbg a tenté de charger la mauvaise variante de l'extension, par ex. : ``x64`` au lieu de la ``x86`` `sync.dll`.```
0:000> .load sync
The call to LoadLibrary(sync) failed, Win32 error 0n193
    "%1 is not a valid Win32 application."
Please check your debugger configuration and/or network access.
```
Comme WinDbg Preview charge les deux plugins (``x86`` et  ``x64``) depuis le même répertoire, on peut renommer le fichier ``x86`` `sync32.dll`.```
0:000> .load sync32
```
## Installation de GNU gdb (GDB)

1. Copiez le fichier `ext_gdb/sync.py` dans le répertoire de votre choix
2. Chargez l'extension (voir auto-load-scripts)```
    gdb> source sync.py
    [sync] configuration file loaded 192.168.52.1:9100
    [sync] commands added
```
## Installation de LLDB

Le support de LLDB est expérimental, cependant :

1. Charger l'extension (peut également être ajoutée dans ``~/.lldbinit``)```
    lldb> command script import sync
```
## Installation d'OllyDbg 1.10

Le support d'OllyDbg 1.10 est expérimental, cependant :

1. Compilez le plugin avec la solution VS (facultatif, voir les binaires pré-compilés)
2. Copiez la dll dans le répertoire des plugins d'OllyDbg

## Installation d'OllyDbg2

Le support d'OllyDbg2 est expérimental, cependant :

1. Compilez le plugin avec la solution VS (facultatif, voir les binaires pré-compilés)
2. Copiez la dll dans le répertoire des plugins d'OllyDbg2

## Installation de x64dbg

Basé sur testplugin, https://github.com/x64dbg/testplugin. Le support de x64dbg est expérimental, cependant :

1. Compilez le plugin avec la solution VS (facultatif, voir les binaires pré-compilés).
   Vous aurez peut-être besoin d'une version différente du SDK du plugin,
   une copie est disponible dans chaque version de x64dbg.
   Collez le répertoire "``pluginsdk``" dans "``ext_x64dbg\x64dbg_sync``"
2. Copiez la dll (l'extension est ``.d32`` ou ``.dp64``) dans le répertoire des plugins de x64dbg.

# Utilisation

## Commandes **ret-sync** pour débogueur

Pour les débogueurs orientés ligne de commande (principalement Windbg et GDB), un ensemble de commandes
est exposé par **ret-sync** pour faciliter la tâche de rétro-ingénierie.

Les commandes ci-dessous sont génériques (Windbg et GDB), veuillez noter qu'un préfixe `!`
est nécessaire sur WinDbg (par exemple : `sync` dans GDB, `!sync` dans Windbg).

| Commande du débogueur           | Description                                                                               |
|----------------------------|-------------------------------------------------------------------------------------------|
| `synchelp`                   | Affiche la liste des commandes disponibles avec une courte explication                    |
| `sync`                       | Démarre la synchronisation                                                                     |
| `syncoff`                    | Arrête la synchronisation                                                                      |
| `cmt [-a address] <string>`  | Ajoute un commentaire à l'ip courante dans le désassembleur                                               |
| `rcmt [-a address]`          | Réinitialise le commentaire à l'ip courante dans le désassembleur                                               |
| `fcmt [-a address] <string>` | Ajoute un commentaire de fonction pour la fonction dans laquelle se trouve l'ip courante                        |
| `raddr <expression>`         | Ajoute un commentaire avec l'adresse rebasée évaluée à partir de l'expression                              |
| `rln <expression>`           | Obtient le symbole du désassembleur pour l'adresse donnée                                    |
| `lbl [-a address] <string>`  | Ajoute un nom d'étiquette à l'ip courante dans le désassembleur                                            |
| `cmd <string>`               | Exécute une commande dans le débogueur et ajoute sa sortie comme commentaire à l'ip courante dans le désassembleur |
| `bc <\|\|on\|off\|set 0xBBGGRR>` | Active/désactive la coloration du chemin dans le désassembleur                                              |
| `idblist`                    | Obtient la liste de tous les clients IDB connectés au répartiteur                                   |
| `syncmodauto <on\|off>`       | Active/désactive le basculement automatique du désassembleur basé sur le nom du module                              |
| `idbn <n>`                   | Définit l'IDB actif sur le n-ième client                                                          |
| `jmpto <expression>`         |                                                                                           |
| `jmpraw <expression>` | Si un IDB est activé, la vue du désassembleur est synchronisée avec l'adresse résultante.    |
| `translate <base> <addr> <mod>` | Rebase une adresse par rapport au nom de son module et à son décalage   |


Commandes spécifiques à WinDbg :

| Commande du débogueur           | Description                                                                               |
|----------------------------|-------------------------------------------------------------------------------------------|
| `curmod`  |  Affiche les informations du module pour le décalage d'instruction courant (pour le dépannage) |
| `modlist`  |  Liste des modules améliorée en langage de balisage du débogueur (DML) pour un basculement d'IDB actif plus fluide  |
| `idb <nom du module>`  |  Définit le module donné comme l'IDB actif (voir la version améliorée de `lm` par `modlist`) |
| `modmap <base> <size> <name>` |  Un module synthétique ("factice") (défini par son adresse de base et sa taille) est ajouté à la liste interne du débogueur  |
| `modunmap <base>` |  Supprime un module synthétique précédemment mappé à l'adresse de base  |
| `modcheck <\|\|md5>`  |  Permet de vérifier si le module actuel correspond vraiment au fichier de l'IDB (ex : module mis à jour)  |
| `bpcmds <\|\|save\|load\|>` |  Wrapper de **bpcmds**, sauvegarde et recharge la sortie de **.bpcmds** (liste des commandes de points d'arrêt) dans l'IDB actuel  |
| `ks` | Sortie améliorée en langage de balisage du débogueur (DML) de la commande **kv**   |


Commandes spécifiques à GDB :

| Commande du débogueur           | Description                                                                               |
|----------------------------|-------------------------------------------------------------------------------------------|
|`bbt` |  Beautiful backtrace. Similaire à **bt** dans GDB mais demande les symboles au désassembleur  |
| `patch`  |  Patch les octets dans le désassembleur en fonction du contexte en direct   |
| `bx` | Similaire à **x** de GDB mais en utilisant un symbole. Le symbole sera résolu par le désassembleur   |
| `cc` | Continue jusqu'au curseur dans le désassembleur  |


## Utilisation avec IDA

### Interface graphique du plugin IDA

Le champ de saisie ``Overwrite idb name`` est destiné à modifier le nom de l'IDB
par défaut. C'est le nom utilisé par le plugin pour s'enregistrer auprès du
répartiteur. Le basculement automatique de l'IDB est basé sur la correspondance du nom du module. En cas de
noms conflictuels (comme ``foo.exe`` et ``foo.dll``), cela peut être utilisé pour
faciliter la correspondance. Veuillez noter que si vous modifiez le champ de saisie alors que la synchronisation est
active, vous devez vous réenregistrer auprès du répartiteur ; cela peut être fait simplement
en utilisant le bouton "``Restart``".

Pour rappel, il est possible de définir un alias par défaut en utilisant le fichier de configuration ``.sync``.



### Raccourcis globaux d'IDA

**ret-sync** définit ces raccourcis globaux dans IDA :

* ``Alt-Shift-S``  - Exécute le plugin **ret-sync**
* ``Ctrl-Shift-S``  - Active/désactive la synchronisation globale
* ``Ctrl-H``  - Active/désactive la synchronisation Hex-Rays

Deux boutons sont également disponibles dans la barre d'outils de débogage pour activer/désactiver la
synchronisation globale et Hex-Rays.

### Liaisons IDA pour les commandes du débogueur

``Syncplugin.py`` enregistre également des touches de raccourci pour les wrappers de commandes du débogueur.

* ``F2`` - Définit un point d'arrêt à l'adresse du curseur
* ``F3`` - Définit un point d'arrêt unique à l'adresse du curseur
* ``Ctrl-F2`` - Définit un point d'arrêt matériel à l'adresse du curseur
* ``Ctrl-F3`` - Définit un point d'arrêt matériel unique à l'adresse du curseur
* ``Alt-F2`` - Traduit (rebascule dans le débogueur) l'adresse du curseur actuelle
* ``Alt-F5`` - Aller
* ``Ctrl-Alt-F5`` - Exécuter (GDB uniquement)
* ``F10`` - Pas à pas principal
* ``F11`` - Pas à pas détaillé

Ces commandes ne sont disponibles que lorsque l'IDB actuel est actif. Lorsque
possible, elles ont également été implémentées pour les autres débogueurs.

## Utilisation avec Ghidra

### Interface graphique du plugin Ghidra

Une fois le RetSyncPlugin ouvert, vous pouvez l'ajouter à la fenêtre CodeBrowser par simple
glisser-déposer :

![](https://assets.kitploit.com/production/public/readmes/3693/c6d122e27a256e4f99d0f760d2d6febb89648881dbdee9d6ffd84092bb0d9931.png)

Si vous souhaitez visualiser plusieurs modules, les fichiers doivent être ouverts dans le même visualiseur
CodeBrowser, il suffit de glisser-déposer les fichiers supplémentaires dans la fenêtre CodeBrowser pour obtenir
le résultat ci-dessus.

### Raccourcis globaux de Ghidra

**ret-sync** définit ces raccourcis globaux dans Ghidra :

* ``Alt-S``  - Active la synchronisation
* ``Alt-Shift-S``  - Désactive la synchronisation
* ``Alt-R``  - Redémarre la synchronisation
* ``Alt-Shift-R``  - Recharge la configuration

### Liaisons Ghidra pour les commandes du débogueur

Des liaisons pour les commandes du débogueur sont également implémentées. Elles sont similaires à
celles de l'extension IDA (sauf pour la commande "Go").

* ``F2``  - Définit un point d'arrêt à l'adresse du curseur
* ``Ctrl-F2`` - Définit un point d'arrêt matériel à l'adresse du curseur
* ``Alt-F3`` - Définit un point d'arrêt unique à l'adresse du curseur
* ``Ctrl-F3`` - Définit un point d'arrêt matériel unique à l'adresse du curseur
* ``Alt-F2`` - Traduit (rebascule dans le débogueur) l'adresse du curseur actuelle
* ``F5`` - Aller
* ``Alt-F5`` - Exécuter (GDB uniquement)
* ``F10`` - Pas à pas principal
* ``F11`` - Pas à pas détaillé


## Utilisation avec Binary Ninja

### Raccourcis globaux de Binary Ninja

**ret-sync** définit ces raccourcis globaux dans Binary Ninja :

* ``Alt-S``  - Active la synchronisation
* ``Alt-Shift-S``  - Désactive la synchronisation


### Raccourcis de Binary Ninja

Des liaisons pour les commandes du débogueur sont également implémentées. Elles sont similaires à
celles de l'extension IDA.

* ``F2``  - Définit un point d'arrêt à l'adresse du curseur
* ``Ctrl-F2`` - Définit un point d'arrêt matériel à l'adresse du curseur
* ``Alt-F3`` - Définit un point d'arrêt unique à l'adresse du curseur
* ``Ctrl-F3`` - Définit un point d'arrêt matériel unique à l'adresse du curseur
* ``Alt-F2`` - Traduit (rebascule dans le débogueur) l'adresse du curseur actuelle
* ``Alt-F5`` - Aller
* ``F10`` - Pas à pas principal
* ``F11`` - Pas à pas détaillé


## Utilisation avec WinDbg

### Commandes du plugin WinDbg

* **!sync**: Démarre la synchronisation
* **!syncoff**: Arrête la synchronisation
* **!synchelp**: Affiche la liste des commandes disponibles avec une courte explication.
* **!cmt [-a adresse] <string>**: Ajoute un commentaire à l'ip courante dans IDA```
    [WinDbg]
    0:000:x86> pr
    eax=00000032 ebx=00000032 ecx=00000032 edx=0028eebc esi=00000032 edi=00000064
    eip=00430db1 esp=0028ed94 ebp=00000000 iopl=0         nv up ei pl nz na po nc
    cs=0023  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00000202
    image00000000_00400000+0x30db1:
    00430db1 57    push    edi

    0:000:x86> dd esp 8
    0028ed94  00000000 00433845 0028eebc 00000032
    0028eda4  0028f88c 00000064 002b049e 00000110

    0:000:x86> !cmt 0028ed94  00000000 00433845 0028eebc 00000032
    [sync.dll]  !cmt called

    [IDA]
    .text:00430DB1    push    edi             ; 0028ed94  00000000 00433845 0028eebc 00000032
```
* **!rcmt [-a address]**: Réinitialiser le commentaire à l'ip actuelle dans IDA```
    [WinDbg]
    0:000:x86> !rcmt
    [sync] !rcmt called

    [IDA]
    .text:00430DB1    push    edi
```
* **!fcmt [-a address] <string>**: Ajouter un commentaire de fonction pour la fonction dans laquelle se trouve l'IP actuelle```
    [WinDbg]
    0:000:x86> !fcmt decodes buffer with key
    [sync] !fcmt called

    [IDA]
    .text:004012E0 ; decodes buffer with key
    .text:004012E0                 public decrypt_func
    .text:004012E0 decrypt_func    proc near
    .text:004012E0                 push    ebp
```
Note : appeler cette commande sans argument réinitialise le commentaire de la fonction.

* **!raddr <expression>** : Ajouter un commentaire avec l'adresse rebasée évaluée à partir de l'expression
* **!rln <expression>** : Obtenir le symbole du désassembleur pour l'adresse donnée
* **!lbl [-a address] <string>** : Ajouter un nom d'étiquette à l'ip actuelle dans le désassembleur```
    [WinDbg]
    0:000:x86> !lbl meaningful_label
    [sync] !lbl called

    [IDA]
    .text:000000000040271E meaningful_label:
    .text:000000000040271E    mov     rdx, rsp
```
* **!cmd <string>** : Exécuter une commande dans WinDbg et ajouter sa sortie en tant que commentaire à l'ip actuelle dans le désassembleur```
    [WinDbg]
    0:000:x86> pr
    eax=00000032 ebx=00000032 ecx=00000032 edx=0028eebc esi=00000032 edi=00000064
    eip=00430db1 esp=0028ed94 ebp=00000000 iopl=0         nv up ei pl nz na po nc
    cs=0023  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00000202
    image00000000_00400000+0x30db1:
    00430db1 57     push    edi
    [sync.dll]  !cmd r edi

    [IDA]
    .text:00430DB1    push    edi             ; edi=00000064
```
* **!bc <||on|off|set 0xBBGGRR>** : Activer/désactiver le coloriage de chemin dans le désassembleur.
  Ce n'est PAS un outil de traçage de code,
  il existe des outils efficaces pour cela. Chaque instruction exécutée manuellement est
  colorée dans le graphe. Colorie une seule instruction à l'ip actuelle si appelé
  sans argument.
  L'argument "set" est utilisé pour définir la couleur du chemin avec un nouveau code hex rgb (réinitialise la couleur
  si appelé avec une valeur > 0xFFFFFF).
* **!idblist**: Obtenir la liste de tous les clients IDB connectés au dispatcher :```
    [WinDbg]
    0:000> !idblist
    > currently connected idb(s):
        [0] target.exe
```
* **!syncmodauto <on|off>**: Activer/désactiver le basculement automatique du désassembleur en fonction du nom du module :```
    [WinDbg]
    0:000> !syncmodauto off

    [IDA]
    [*] << broker << dispatcher msg: sync mode auto set to off
```
* **!idbn <n>**: Définir l'IDB actif sur le n-ième client. n doit être une valeur décimale valide.
  Ceci est un mode semi-automatique (hommage personnel au formidable jj)```
    [WinDbg]
    0:000:> !idbn 0
    > current idb set to 0
```
Dans cet exemple, le client IDB actif actuel aurait été défini sur :```
	[0] target.exe.
```
* **!jmpto <expression>**: L'expression donnée en argument est évaluée dans le contexte de l'état actuel du débogueur.
  La vue du désassembleur est ensuite synchronisée avec l'adresse résultante si un module correspondant est enregistré.
  Cela peut être considéré comme une synchronisation manuelle, la relocalisation est effectuée automatiquement, à la volée.
  Particulièrement utile pour un binaire relocalisé aléatoirement.
* **!jmpraw <expression>**: L'expression donnée en argument est évaluée dans le contexte de l'état actuel du débogueur.
  Si une IDB est activée, la vue du désassembleur est synchronisée avec l'adresse résultante. L'adresse n'est pas rebasée
  et il n'y a pas de changement d'IDB.
  Particulièrement utile pour le code alloué/généré dynamiquement.
* **!modmap <base> <taille> <nom>**: Un module synthétique ("fictif") (défini par son adresse de base et sa taille) est ajouté à la liste interne du débogueur.
  D'après msdn : "Si tous les modules sont rechargés - par exemple, en appelant Reload avec le paramètre Module défini sur une chaîne vide - tous les modules synthétiques seront supprimés."
  Il peut être utilisé pour déboguer plus facilement du code alloué/généré dynamiquement.
* **!modunmap <base>**: Supprime un module synthétique précédemment mappé à l'adresse de base.
* **!modcheck <||md5>**: Utilisé pour vérifier si le module actuel correspond vraiment au fichier de l'IDB (ex : module a été mis à jour)
  Lorsqu'il est appelé sans argument, le GUID du pdb provenant du répertoire de débogage est utilisé. Il peut alternativement utiliser md5,
  mais seulement avec un déboguée local (pas en débogage de noyau distant).
* **!bpcmds <||save|load|>**: Wrapper **bpcmds**, sauvegarde et recharge la sortie de **.bpcmds** (liste des commandes de points d'arrêt) dans l'IDB courante.
  Affiche (mais n'exécute pas) les données sauvegardées si appelé sans argument.
  Le stockage persistant est réalisé en utilisant la fonctionnalité netnode d'IDA.
* **!ks**: Sortie améliorée du langage de balisage du débogueur (DML) de la commande **kv**. Les adresses de code sont cliquables (**!jmpto**) ainsi que les adresses de données (**dc**).
* **!translate <base> <addr> <mod>**: Destiné à être utilisé depuis IDA (raccourci ``Alt-F2``), rebase une adresse par rapport au nom et à l'offset de son module.

#### Argument d'adresse optionnel

Les commandes **!cmt**, **!rcmt** et **!fcmt** prennent en charge une option d'adresse facultative : ``-a`` ou ``--address``.
L'adresse doit être passée sous forme de valeur hexadécimale. L'analyse de la commande est basée sur le module
``argparse`` de Python. Pour arrêter l'analyse de ligne, utilisez ``--``.```
    [WinDbg]
    0:000:x86> !cmt -a 0x430DB2 comment
```
L'adresse doit être une adresse d'instruction valide.

## Utilisation de GNU gdb (GDB)

Synchronisation avec l'hôte :```
    gdb> sync
    [sync] sync is now enabled with host 192.168.52.1
    <not running>

    gdb> r
    Starting program: /bin/ls
    [Thread debugging using libthread_db enabled]
    Using host libthread_db library "/lib/libthread_db.so.1".
```
### Commandes du plugin GDB

Utilisez les commandes, **sans le préfixe "!"**```
    (gdb) cmd x/i $pc
    [sync] command output: => 0x8049ca3:    push   edi

    (gdb) synchelp
    [sync] extension commands help:
     > sync <host>
     > syncoff
     > cmt [-a address] <string>
     > rcmt [-a address] <string>
     > fcmt [-a address] <string>
     > cmd <string>
     > bc <on|off|>
     > rln <address>
     > bbt <symbol>
     > patch <addr> <count> <size>
     > bx /i <symbol>
     > cc
     > translate <base> <addr> <mod>
```
* **rln**: Obtenir le symbole de l'IDB pour l'adresse donnée
* **bbt**: Magnifique backtrace. Similaire à **bt** mais demande les symboles au désassembleur```
    (gdb) bt
    #0  0x0000000000a91a73 in ?? ()
    #1  0x0000000000a6d994 in ?? ()
    #2  0x0000000000a89125 in ?? ()
    #3  0x0000000000a8a574 in ?? ()
    #4  0x000000000044f83b in ?? ()
    #5  0x0000000000000000 in ?? ()
    (gdb) bbt
    #0 0x0000000000a91a73 in IKE_GetAssembledPkt ()
    #1 0x0000000000a6d994 in catcher ()
    #2 0x0000000000a89125 in IKEProcessMsg ()
    #3 0x0000000000a8a574 in IkeDaemon ()
    #4 0x000000000044f83b in sub_44F7D0 ()
    #5 0x0000000000000000 in  ()
```
* **patch** : Patcher des octets dans le désassembleur en fonction du contexte en direct
* **bx** : Affichage élégant. Similaire à **x** mais en utilisant un symbole. Le symbole
  sera résolu par le désassembleur.
* **cc** : Continuer jusqu'au curseur dans le désassembleur. C'est une alternative à l'utilisation de ``F3`` pour
  définir un point d'arrêt unique et de ``F5`` pour continuer. Cela est utile si vous préférez
  le faire depuis gdb.```
    (gdb) b* 0xA91A73
    Breakpoint 1 at 0xa91a73
    (gdb) c
    Continuing.

    Breakpoint 1, 0x0000000000a91a73 in ?? ()
    (gdb) cc
    [sync] current cursor: 0xa91a7f
    [sync] reached successfully
    (gdb)
```
## Utilisation de LLDB

1. Synchroniser avec l'hôte```
    lldb> process launch -s
    lldb> sync
    [sync] connecting to localhost
    [sync] sync is now enabled with host localhost
    [sync] event handler started
```
2. Utilisez des commandes```
    lldb> synchelp
    [sync] extension commands help:
     > sync <host>                   = synchronize with <host> or the default value
     > syncoff                       = stop synchronization
     > cmt <string>                  = add comment at current eip in IDA
     > rcmt <string>                 = reset comments at current eip in IDA
     > fcmt <string>                 = add a function comment for 'f = get_func(eip)' in IDA
     > cmd <string>                  = execute command <string> and add its output as comment at current eip in IDA
     > bc <on|off|>                  = enable/disable path coloring in IDA
                                       color a single instruction at current eip if called without argument
    lldb> cmt mooo
```
## Utilisation d'OllyDbg 1.10

1. Utilisez le menu Plugins ou les raccourcis pour activer (``Alt+s``)/désactiver (``Alt+u``)
   la synchronisation.

## Utilisation d'OllyDbg2

1. Utilisez le menu Plugins ou les raccourcis pour activer (``Ctrl+s``)/désactiver (``Ctrl+u``)
   la synchronisation.

En raison du statut bêta de l'API OllyDbg2, seules les fonctionnalités suivantes ont été implémentées :

- Synchronisation du graphe [utilisez ``F7`` ; ``F8`` pour le pas à pas]
- Commentaire   [utilisez ``CTRL+;``]
- Étiquette     [utilisez ``CTRL+:``]

## Utilisation de x64dbg

1. Utilisez le menu Plugins ou les commandes pour activer ("``!sync``") ou désactiver ("``!syncoff``") la synchronisation.

2. Utilisez les commandes```
[sync] synchelp command!
[sync] extension commands help:
 > !sync                          = synchronize with <host from conf> or the default value
 > !syncoff                       = stop synchronization
 > !syncmodauto <on | off>        = enable / disable idb auto switch based on module name
 > !synchelp                      = display this help
 > !cmt <string>                  = add comment at current eip in IDA
 > !rcmt <string>                 = reset comments at current eip in IDA
 > !idblist                       = display list of all IDB clients connected to the dispatcher
 > !idb <module name>             = set given module as the active idb (see !idblist)
 > !idbn <n>                      = set active idb to the n_th client. n should be a valid decimal value
 > !translate <base> <addr> <mod> = rebase an address with respect to local module's base
 > !insync                        = synchronize the selected instruction block in the disassembly window.
```
Remarque : l'utilisation de la commande **!translate** depuis un désassembleur (IDA/Ghidra, raccourci ``Alt-F2``) fera "sauter" la fenêtre du désassembleur vers l'adresse spécifique (équivalent de l'exécution de **disasm <rebased addr>** dans la ligne de commande de x64dbg).


## Utilisation de la bibliothèque Python

On peut vouloir utiliser les fonctionnalités principales de **ret-sync** (synchronisation de position avec un désassembleur, résolution de symboles) même si un environnement de débogage complet n'est pas disponible ou avec un outil personnalisé. À cette fin, une bibliothèque Python minimaliste a été extraite.

L'exemple ci-dessous illustre l'utilisation de la bibliothèque Python avec un script qui parcourt la sortie d'un outil de journalisation/traçage basé sur les événements.```python
from sync import *

HOST = '127.0.0.1'

MAPPINGS = [
    [0x555555400000, 0x555555402000,  0x2000, " /bin/tempfile"],
    [0x7ffff7dd3000, 0x7ffff7dfc000, 0x29000, " /lib/x86_64-linux-gnu/ld-2.27.so"],
    [0x7ffff7ff7000, 0x7ffff7ffb000,  0x4000, " [vvar]"],
    [0x7ffff7ffb000, 0x7ffff7ffc000,  0x1000, " [vdso]"],
    [0x7ffffffde000, 0x7ffffffff000, 0x21000, " [stack]"],
]

EVENTS = [
    [0x0000555555400e74, "malloc"],
    [0x0000555555400eb3, "open"],
    [0x0000555555400ee8, "exit"]
]

synctool = Sync(HOST, MAPPINGS)

for e in EVENTS:
    offset, name = e
    synctool.invoke(offset)
    print("    0x%08x - %s" % (offset, name))
    print("[>] press enter for next event")
    input()
```
# Étendre

Bien qu'initialement axé sur l'analyse dynamique (débogueurs), il est bien sûr possible d'étendre l'ensemble des plugins et de s'intégrer avec d'autres outils.

- Intégration avec la plateforme d'analyse et de débogage intemporel **REVEN** par [Tetrane](https://www.tetrane.com/) :
  - http://blog.tetrane.com/2015/02/reven-in-your-toolkit.html
  - https://twitter.com/tetrane/status/1374768014193799175
- Intégration avec l'émulateur **EFI DXE** par Assaf Carlsbad ([@assaf_carlsbad](https://twitter.com/assaf_carlsbad)) :
  - https://twitter.com/assaf_carlsbad/status/1242114356881641474
  - https://github.com/assafcarlsbad/efi_dxe_emulator

Autre(s) ressource(s) :

- "*Combinaison d'analyse binaire statique et dynamique - ret-sync*" par Jean-Christophe Delaunay
  - https://www.synacktiv.com/ressources/bieresecu1_ret-sync_en.pdf


# À faire

- Bien sûr.

# Bugs/Limitations connus

- Testé avec Python 2.7/3.7, IDA 7.7 (Windows, Linux et Mac OS X), Ghidra 10.1.1, Binary Ninja 3.0.3225-dev, GNU gdb (GDB) 8.1.0 (Debian), lldb 310.2.37.
- **IL N'Y A AUCUNE AUTHENTIFICATION/CHIFFREMENT** entre les parties ; vous êtes seul.
- Le code auto-modifiant est hors de portée.

Avec GDB :

- il semble que l'événement d'arrêt ne soit pas appelé lors de l'utilisation de la commande 'return'.
- le débogage multi-threading a des problèmes avec les signaux.

Avec WinDbg :

- Le plugin client d'IDA est notifié même si le point d'arrêt rencontré utilise une chaîne de commande qui le fait continuer ('``g``'). Cela peut provoquer un ralentissement important s'il y a trop de ces événements. Un correctif limité a été implémenté, la meilleure solution reste encore de se désynchroniser temporairement.
- Condition de course possible

Avec Ghidra :

- Les raccourcis ne fonctionnent pas comme prévu dans le widget de décompilation.

Avec IDA :

- Le redessinage de la fenêtre de graphe est assez lent pour les grands graphes.
- Les raccourcis **ret-sync** entrent en conflit dans les environnements Linux.

Conflit(s) :

- Le logiciel Logitech Updater est connu pour utiliser le même port par défaut (9100). Une solution consiste à utiliser un fichier de configuration global `.sync` pour définir un port différent.```
[INTERFACE]
host=127.0.0.1
port=9234
```
# Licence

**ret-sync** est un logiciel libre : vous pouvez le redistribuer et/ou le modifier selon les termes de la GNU General Public License telle que publiée par la Free Software Foundation, soit la version 3 de la Licence, soit (à votre choix) toute version ultérieure.

Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE ; sans même la garantie implicite de COMMERCIALISATION ou D'ADÉQUATION À UN USAGE PARTICULIER. Voir la GNU General Public License pour plus de détails.

Vous devriez avoir reçu une copie de la GNU General Public License avec ce programme. Sinon, consultez http://www.gnu.org/licenses/.

Le plugin Binary Ninja est distribué sous licence MIT.


# Remerciements

Salut à Bruce Dang, StalkR, @Ivanlef0u, Damien Aumaître, Sébastien Renaud et Kévin Szkudlapski, @_m00dy_, @saidelike, Xavier Mehrenberger, ben64, Raphaël Rigo, Jiss pour leur gentillesse, leur aide, leurs retours et leurs réflexions. Ilfak Guilfanov, Igor Skochinsky et Arnaud Diederen pour leur aide avec les mécanismes internes d'IDA et leur soutien exceptionnel. Merci à Jordan Wiens et Vector 35. Enfin, merci également à tous les contributeurs et à tous ceux qui ont signalé des problèmes/bogues.