bootleg/ret-syncret-sync ist eine Sammlung von Plugins, die dabei hilft, eine Debugging-Sitzung (WinDbg/GDB/LLDB/OllyDbg2/x64dbg) mit den Disassemblern IDA/Ghidra/Binary Ninja zu synchronisieren.
ret-sync steht für Reverse-Engineering Tools Synchronisation (Synchronisierung von Reverse-Engineering-Werkzeugen). Es handelt sich um eine Reihe von Plugins, die die Synchronisation einer Debugging-Sitzung (WinDbg/GDB/LLDB/OllyDbg/OllyDbg2/x64dbg) mit einem Disassembler (IDA/Ghidra/Binary Ninja) ermöglichen. Die zugrundeliegende Idee ist einfach: das Beste aus beiden Welten (statische und dynamische Analyse) nutzen.
Debugger und dynamische Analyse bieten uns:
!peb, !drvobj, !address, usw.)Disassembler und statische Analyse bieten uns:
Hauptfunktionen:
ret-sync ist ein Fork von qb-sync, den ich während meines Aufenthalts bei Quarkslab entwickelt und gewartet habe.
Die Debugger-Plugins:
ext_windbg/sync: WinDbg-Erweiterungsquellen, nach dem Bau: sync.dllext_gdb/sync.py: GDB-Pluginext_lldb/sync.py: LLDB-Pluginext_olly1: OllyDbg 1.10-Pluginext_olly2: OllyDbg v2-Pluginext_x64dbg: x64dbg-PluginDie Disassembler-Plugins:
ext_ida/SyncPlugin.pyext_ghidra/dist/ghidra_*_retsync.zip: Ghidra-Pluginext_bn/retsync: Binary Ninja-PluginUnd das Bibliotheks-Plugin:
ext_lib/sync.py: eigenständige Python-BibliothekIDA- und GDB-Plugins benötigen eine funktionierende Python-Umgebung. Python 2 (>=2.7) und Python 3 werden unterstützt.
Vorgefertigte Binärdateien für WinDbg/OllyDbg/OllyDbg2/x64dbg-Debugger werden über eine Azure DevOps-Pipeline bereitgestellt:
Wählen Sie den letzten Build aus und überprüfen Sie die Artefakte im Bereich Related: 6 published.
Ein vorgefertigtes Plugin-Archiv des Ghidra-Plugins wird in ext_ghidra/dist bereitgestellt.
ret-sync sollte für die meisten Benutzer mit einer typischen Einrichtung sofort funktionieren: Debugger und Disassembler auf demselben Host, Modulnamen stimmen überein.
In einigen Szenarien kann dennoch eine spezifische Konfiguration erforderlich sein. Dazu suchen Erweiterungen und Plugins optional nach einer globalen Konfigurationsdatei namens .sync im Home-Verzeichnis des Benutzers. Sie muss eine gültige .INI-Datei sein.
Zusätzlich suchen die IDA- und Ghidra-Plugins auch zuerst im IDB- oder Projektverzeichnis (<project>.rep) nach der Konfigurationsdatei, um lokale, pro-IDB/Projekt-Einstellungen zu ermöglichen. Wenn eine lokale Konfigurationsdatei vorhanden ist, wird die globale Konfigurationsdatei ignoriert.
Werte, die in diesen Konfigurationsdateien deklariert sind, überschreiben die Standardwerte. Bitte beachten Sie, dass standardmäßig keine .sync-Datei erstellt wird.
Im Folgenden beschreiben wir drei häufige Szenarien, in denen eine Konfigurationsdatei nützlich/notwendig ist:
Der Abschnitt [INTERFACE] wird verwendet, um netzwerkbezogene Einstellungen anzupassen. Angenommen, man möchte IDA mit einem Debugger synchronisieren, der auf einer virtuellen Maschine (oder einfach einem anderen Host) läuft – ein häufiges Szenario beim entfernten Kernel-Debugging.
Erstellen Sie einfach zwei .sync-Dateien:
Es weist das **ret-sync** ``IDA``-Plugin an, auf dem Interface ``192.168.128.1`` mit Port ``9234`` zu lauschen. Es versteht sich von selbst, dass dieses Interface vom entfernten Host oder der virtuellen Maschine aus erreichbar sein muss.
* eines auf dem Rechner, auf dem der Debugger ausgeführt wird, im Home-Verzeichnis des Benutzers:```
[INTERFACE]
host=192.168.128.1
port=9234
Es teilt dem ret-sync Debugger-Plugin mit, sich mit dem zuvor konfigurierten ret-sync IDA-Plugin zu verbinden, das auf diesem Interface lauscht.
HINWEIS: Sie müssen hier eine echte IP angeben und nicht 0.0.0.0 verwenden. Dies liegt daran, dass die Variable von mehreren Quellen sowohl zum Binden als auch zum Verbinden verwendet wird. Die Verwendung von 0.0.0.0 führt daher zu seltsamen Fehlern.
[ALIASES] ntoskrnl_vuln.exe=ntkrnlmp.exe
Der Abschnitt ``[ALIASES]`` wird verwendet, um den Namen anzupassen, der von einem Disassembler (IDA/Ghidra) verwendet wird, um ein Modul bei seinem Dispatcher/Programm-Manager zu registrieren.
Standardmäßig verwenden Disassembler-Plugins den Namen der Eingabedatei. Allerdings kann es vorkommen, dass man die Datei vorher umbenannt hat und sie nicht mehr mit dem Namen des tatsächlichen Prozesses oder geladenen Moduls übereinstimmt, wie er vom Debugger gesehen wird.
Hier teilen wir dem Dispatcher einfach mit, dass er den Namen `ntkrnlmp.exe` (echter Name) anstelle von `ntoskrnl_vuln.exe` (IDB-Name) verwenden soll.
## gdb mit Qt Creator Debugging-Frontend
Das Qt Creator Debugging-Frontend ändert die Art und Weise, wie die gdb-Befehlsausgabe protokolliert wird. Da dies die Synchronisation beeinträchtigen würde, gibt es eine Option, die rohe gdb-Ausgabe für die Synchronisation anstelle einer temporären Datei zu verwenden. In der .sync-Konfigurationsdatei verwende```
[GENERAL]
use_tmp_logging_file=false
falls Sie das Qt-Debugging-Frontend für das Ziel verwenden möchten.
/proc/<pid>/mapsIn einigen Szenarien, wie dem Debuggen eingebetteter Geräte über serielle Verbindung oder Roh-Firmware in QEMU, ist gdb die PID nicht bekannt und kann nicht auf /proc/<pid>/maps zugreifen.
In diesen Fällen wird der Abschnitt [INIT] verwendet, um einen benutzerdefinierten Kontext an das Plugin zu übergeben. Es ermöglicht das Überschreiben einiger Felder wie der PID und der Speicherzuordnungen.
.sync Inhaltsauszug:```
[INIT]
context = {
"pid": 200,
"mappings": [ [0x400000, 0x7A81158, 0x7681158, "asav941-200.qcow2|lina"] ]
}
Jeder Eintrag in den Mappings ist: ``mem_base``, ``mem_end``, ``mem_size``, ``mem_name``.
## Umgehen der automatischen Adressverschiebung
In einigen Szenarien, wie dem Debuggen von eingebetteten Geräten oder der Verbindung zu minimalistischen Debug-Schnittstellen, kann es bequemer sein, die in den Disassembler-Plugins implementierte automatische Adressverschiebung zu umgehen.
Die Option `use_raw_addr` wird derzeit nur für Ghidra unterstützt. Verwenden Sie in der .sync-Konfigurationsdatei:```
[GENERAL]
use_raw_addr=true
IDA 9.2+ ist erforderlich. Für ältere Versionen bitte das Projekt vor dem Tag ida9.2 aus den verfügbaren Tags auschecken.
Für die IDA-Installation kopieren Sie Syncplugin.py und den Ordner retsync aus ext_ida in das IDA-Plugins-Verzeichnis, zum Beispiel:
C:\Program Files\IDA Pro 7.4\plugins%APPDATA%\Hex-Rays\IDA Pro\plugins~/.idapro/pluginsAlt-Shift-S) oder Edit -> Plugins -> ``ret-sync`````
[sync] default idb name: ld.exe
[sync] sync enabled
[sync] cmdline: "C:\Program Files\Python38\python.exe" -u "C:\Users\user\AppData\Roaming\Hex-Rays\IDA Pro\plugins\retsync\broker.py" --idb "target.exe"
[sync] module base 0x100400000
[sync] hexrays #7.3.0.190614 found
[sync] broker started
[sync] plugin loaded
[sync] << broker << dispatcher not found, trying to run it
[sync] << broker << dispatcher now runs with pid: 6544
[sync] << broker << connected to dispatcher
[sync] << broker << listening on port 63107### Fehlerbehebung für IDA-Plugin
Um Probleme mit der IDA-Erweiterung zu beheben, stehen in der Datei `retsync/rsconfig.py` zwei Optionen zur Verfügung:```
LOG_LEVEL = logging.INFO
LOG_TO_FILE_ENABLE = False
Setting LOG_LEVEL value to logging.DEBUG makes the plugin more verbose.
Setting LOG_TO_FILE_ENABLE value to True triggers the logging of exception
information from broker.py and dispatcher.py into dedicated files. Log file
are generated in the %TMP% folder with a name pattern retsync.%s.err .
Either use the pre-built version from the ext_ghidra/dist folder or follow the instruction to build it.
Each extension build only supports the version of Ghidra specified in the plugin's file name.
E.g. ghidra_9.1_PUBLIC_20191104_retsync.zip is for Ghidra 9.1 Public.
3. Erweiterung für Ihre Ghidra-Installation erstellen (ersetzen Sie `$GHIDRA_DIR` durch Ihr Installationsverzeichnis)```bash
cd ext_ghidra
gradle -PGHIDRA_INSTALL_DIR=$GHIDRA_DIR
File -> Install Extensions..., klicken Sie auf das +-Zeichen und wählen Sie die ext_ghidra/dist/ghidra_*_retsync.zip aus und klicken Sie auf OK. Dadurch wird der Ordner retsync aus der ZIP-Datei in $GHIDRA_DIR/Extensions/Ghidra/ extrahiert.4. Vom Ghidra-CodeBrowser-Werkzeug: Verwenden Sie die Symbolleistensymbole oder Tastenkombinationen, um die Synchronisation zu aktivieren (``Alt+s``)/deaktivieren (``Alt+Shift+s``)/neu zu starten (``Alt+r``).
Ein Statusfenster ist auch über ``Windows`` -> ``RetSyncPlugin`` verfügbar. Es empfiehlt sich, es an der Seite abzulegen, um es in die Ghidra-Umgebungsfenster zu integrieren.
## Binary Ninja Erweiterung
Die Unterstützung für Binary Ninja ist experimentell; sichern Sie unbedingt Ihre Analysedatenbanken.
### Voraussetzungen für Binary Ninja
**ret-sync** erfordert mindestens Binary Ninja Version 2.2 sowie Python 3 (Python 2 wird nicht unterstützt).
### Installieren der Binary Ninja Erweiterung
**ret-sync** ist noch nicht über den Plugin-Manager von Binary Ninja verteilt; eine manuelle Installation ist erforderlich. Kopieren Sie einfach den Inhalt des Ordners `ext_bn` in den Plugin-Ordner von Binary Ninja, zum Beispiel:
`%APPDATA%\Binary Ninja\plugins`
Nach einem Neustart von Binary Ninja sollte die folgende Ausgabe im Konsolenfenster erscheinen:```
[sync] commands added
Loaded python3 plugin 'retsync'
Verwenden Sie die in ext_windbg bereitgestellte Visual Studio 2017-Projektmappe. Visual Studio Community Edition 2017 und 2026 wurden erfolgreich getestet (dazwischenliegende Versionen sollten ebenfalls funktionieren).
Dadurch wird die Datei x64\release\sync.dll erstellt.
Sie müssen die resultierende sync.dll-Datei in den entsprechenden Windbg-Erweiterungspfad kopieren.
Bei älteren Versionen von Windbg sieht dies in etwa so aus (achten Sie auf die Varianten x86/x64), zum Beispiel
C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\winext\sync.dll
Der Ordner zum Speichern der Erweiterung scheint auf dem PATH zu basieren, daher müssen Sie sie an einem der abgefragten Speicherorte ablegen.
Ein Beispiel ist, sie hier abzulegen:
C:\Users\user\AppData\Local\Microsoft\WindowsApps\sync.dll
.load)```
0:000> .load sync
[sync.dll] DebugExtensionInitialize, ExtensionApis loaded3. WinDbg synchronisieren```
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
z.B. in IDA's Output window``` [] << 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
Wenn das aktuelle Modul von Windbg mit dem Dateinamen von IDA übereinstimmt```
[sync] idb is enabled with the idb client matching the module name.
Hinweis: Wenn Sie den folgenden Fehler erhalten, liegt es daran, dass Sie die Datei in den obigen Schritten nicht in den richtigen Ordner kopiert haben.``` 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.
Der unten stehende Fehler bedeutet normalerweise, dass Windbg versucht hat, die falsche Variante
der Erweiterung zu laden, z.B. ``x64`` anstelle der ``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.
Da WinDbg Preview beide Plugins (x86 und x64) aus demselben Verzeichnis lädt, kann man die x86-Datei sync32.dll umbenennen.```
0:000> .load sync32
## GNU gdb (GDB) Installation
1. Kopieren Sie die Datei `ext_gdb/sync.py` in das Verzeichnis Ihrer Wahl
2. Laden Sie die Erweiterung (siehe auto-load-scripts)```
gdb> source sync.py
[sync] configuration file loaded 192.168.52.1:9100
[sync] commands added
LLDB-Unterstützung ist experimentell, jedoch:
~/.lldbinit hinzugefügt werden)```
lldb> command script import sync## OllyDbg 1.10 Installation
Die Unterstützung von OllyDbg 1.10 ist experimentell, jedoch:
1. Baue das Plugin mit der VS-Lösung (optional, siehe vorgefertigte Binärdateien)
2. Kopiere die DLL in das Plugin-Verzeichnis von OllyDbg
## OllyDbg2 Installation
Die Unterstützung von OllyDbg2 ist experimentell, jedoch:
1. Baue das Plugin mit der VS-Lösung (optional, siehe vorgefertigte Binärdateien)
2. Kopiere die DLL in das Plugin-Verzeichnis von OllyDbg2
## x64dbg Installation
Basiert auf testplugin, https://github.com/x64dbg/testplugin. Die Unterstützung von x64dbg ist experimentell, jedoch:
1. Baue das Plugin mit der VS-Lösung (optional, siehe vorgefertigte Binärdateien).
Falls Sie eine andere Version des Plugin-SDK benötigen,
eine Kopie kann in jeder Veröffentlichung von x64dbg gefunden werden.
Fügen Sie das ``pluginsdk``-Verzeichnis in ``ext_x64dbg\x64dbg_sync`` ein.
2. Kopieren Sie die DLL (Erweiterung ist ``.d32`` oder ``.dp64``) in das Plugin-Verzeichnis von x64dbg.
# Verwendung
## **ret-sync** Debugger-Befehle
Für befehlszeilenorientierte Debugger (hauptsächlich WinDbg und GDB) wird von **ret-sync** eine Reihe von Befehlen bereitgestellt, um die Reverse-Engineering-Aufgabe zu unterstützen.
Die untenstehenden Befehle sind generisch (WinDbg und GDB), bitte beachten Sie, dass auf WinDbg ein `!`-Präfix benötigt wird (z.B.: `sync` in GDB, `!sync` in WinDbg).
| Debugger-Befehl | Beschreibung |
|---------------------------|--------------------------------------------------------------------------------------------|
| `synchelp` | Zeigt die Liste der verfügbaren Befehle mit kurzer Erklärung an |
| `sync` | Startet die Synchronisation |
| `syncoff` | Stoppt die Synchronisation |
| `cmt [-a address] <string>` | Fügt einen Kommentar an der aktuellen IP im Disassembler hinzu |
| `rcmt [-a address]` | Setzt den Kommentar an der aktuellen IP im Disassembler zurück |
| `fcmt [-a address] <string>` | Fügt einen Funktionskommentar für die Funktion hinzu, in der sich die aktuelle IP befindet |
| `raddr <expression>` | Fügt einen Kommentar mit der aus dem Ausdruck evaluierten neubasierten Adresse hinzu |
| `rln <expression>` | Holt das Symbol vom Disassembler für die angegebene Adresse |
| `lbl [-a address] <string>` | Fügt einen Labelnamen an der aktuellen IP im Disassembler hinzu |
| `cmd <string>` | Führt einen Befehl im Debugger aus und fügt seine Ausgabe als Kommentar an der aktuellen IP im Disassembler hinzu |
| `bc <\|\|on\|off\|set 0xBBGGRR>` | Aktiviert/Deaktiviert die Pfadfärbung im Disassembler |
| `idblist` | Holt die Liste aller IDB-Clients, die mit dem Dispatcher verbunden sind |
| `syncmodauto <on\|off>` | Aktiviert/Deaktiviert das automatische Umschalten des Disassemblers basierend auf dem Modulnamen |
| `idbn <n>` | Setzt die aktive IDB auf den n-ten Client |
| `jmpto <expression>` | |
| `jmpraw <expression>` | Wenn eine IDB aktiviert ist, wird die Ansicht des Disassemblers mit der resultierenden Adresse synchronisiert. |
| `translate <base> <addr> <mod>` | Basieren Sie eine Adresse neu bezüglich des Modulnamens und Offsets |
WinDbg-spezifische Befehle:
| Debugger-Befehl | Beschreibung |
|---------------------------|--------------------------------------------------------------------------------------------|
| `curmod` | Zeigt Modulinformationen für den aktuellen Befehls-Offset an (zur Fehlersuche) |
| `modlist` | Debugger Markup Language (DML)-erweiterte Modulliste für sanfteres Umschalten der aktiven IDB |
| `idb <module name>` | Setzt das angegebene Modul als aktive IDB (siehe `modlist` erweiterte Version von `lm`) |
| `modmap <base> <size> <name>` | Ein synthetisches ("gefälschtes") Modul (definiert durch Basisadresse und Größe) wird zur internen Liste des Debuggers hinzugefügt |
| `modunmap <base>` | Entfernt ein zuvor abgebildetes synthetisches Modul an der Basisadresse |
| `modcheck <\|\|md5>` | Verwenden, um zu prüfen, ob das aktuelle Modul wirklich mit der IDB-Datei übereinstimmt (z.B. Modul wurde aktualisiert) |
| `bpcmds <\|\|save\|load\|>` | **bpcmds**-Wrapper, speichert und lädt die **.bpcmds**-Ausgabe (Befehlssatz für Haltepunkte) in die aktuelle IDB |
| `ks` | Debugger Markup Language (DML)-erweiterte Ausgabe des **kv**-Befehls |
GDB-spezifische Befehle:
| Debugger-Befehl | Beschreibung |
|---------------------------|--------------------------------------------------------------------------------------------|
| `bbt` | Schöner Backtrace. Ähnlich wie **bt** in GDB, fordert aber Symbole vom Disassembler an |
| `patch` | Patchen von Bytes im Disassembler basierend auf dem Live-Kontext |
| `bx` | Ähnlich wie GDB **x**, aber unter Verwendung eines Symbols. Das Symbol wird vom Disassembler aufgelöst |
| `cc` | Weiter zum Cursor im Disassembler |
## IDA-Verwendung
### GUI des IDA-Plugins
Das Eingabefeld ``Overwrite idb name`` dient dazu, den Standard-IDB-Namen zu ändern. Es ist der Name, der vom Plugin verwendet wird, um sich beim Dispatcher zu registrieren. Das automatische Umschalten der IDB basiert auf der Übereinstimmung des Modulnamens. Bei widersprüchlichen Namen (wie ``foo.exe`` und ``foo.dll``) kann dies verwendet werden, um die Übereinstimmung zu erleichtern. Bitte beachten Sie: Wenn Sie das Eingabefeld ändern, während die Synchronisation aktiv ist, müssen Sie sich erneut beim Dispatcher registrieren; dies kann einfach über die Schaltfläche ``Restart`` erfolgen. Zur Erinnerung: Es ist möglich, standardmäßig Aliase über die Konfigurationsdatei ``.sync`` zu verwenden.
### IDA globale Tastenkombinationen
**ret-sync** definiert diese globalen Tastenkombinationen in IDA:
* ``Alt-Shift-S`` - Führe **ret-sync** Plugin aus
* ``Ctrl-Shift-S`` - Umschalten der globalen Synchronisation
* ``Ctrl-H`` - Umschalten der Hex-Rays Synchronisation
Zwei Schaltflächen sind auch in der Debug-Symbolleiste verfügbar, um die globale und Hex-Rays Synchronisation umzuschalten.
### IDA-Bindungen über Debugger-Befehle
``Syncplugin.py`` registriert auch Hotkeys für Debugger-Befehlswrapper.
* ``F2`` - Setze Haltepunkt an der Cursor-Adresse
* ``F3`` - Setze einmaligen Haltepunkt an der Cursor-Adresse
* ``Ctrl-F2`` - Setze Hardware-Haltepunkt an der Cursor-Adresse
* ``Ctrl-F3`` - Setze einmaligen Hardware-Haltepunkt an der Cursor-Adresse
* ``Alt-F2`` - Übersetze (neubasiere im Debugger) aktuelle Cursor-Adresse
* ``Alt-F5`` - Los
* ``Ctrl-Alt-F5`` - Ausführen (nur GDB)
* ``F10`` - Einzelschritt
* ``F11`` - Einzeltrace
Diese Befehle sind nur verfügbar, wenn die aktuelle IDB aktiv ist. Wenn möglich, wurden sie auch für andere Debugger implementiert.
## Ghidra-Verwendung
### GUI des Ghidra-Plugins
Sobald das RetSyncPlugin geöffnet ist, können Sie es per einfachem Drag'n'Drop zum CodeBrowser-Fenster hinzufügen:
Wenn Sie mehrere Module anzeigen möchten, müssen die Dateien im selben CodeBrowser-Viewer geöffnet sein; ziehen Sie einfach die zusätzlichen per Drag'n'Drop in das CodeBrowser-Fenster, um das obige Ergebnis zu erhalten.
### Ghidra globale Tastenkombinationen
**ret-sync** definiert diese globalen Tastenkombinationen in Ghidra:
* ``Alt-S`` - Synchronisation aktivieren
* ``Alt-Shift-S`` - Synchronisation deaktivieren
* ``Alt-R`` - Synchronisation neu starten
* ``Alt-Shift-R`` - Konfiguration neu laden
### Ghidra-Bindungen über Debugger-Befehle
Bindungen über Debugger-Befehle sind ebenfalls implementiert. Sie ähneln denen der IDA-Erweiterung (außer dem Befehl "Los").
* ``F2`` - Setze Haltepunkt an der Cursor-Adresse
* ``Ctrl-F2`` - Setze Hardware-Haltepunkt an der Cursor-Adresse
* ``Alt-F3`` - Setze einmaligen Haltepunkt an der Cursor-Adresse
* ``Ctrl-F3`` - Setze einmaligen Hardware-Haltepunkt an der Cursor-Adresse
* ``Alt-F2`` - Übersetze (neubasiere im Debugger) aktuelle Cursor-Adresse
* ``F5`` - Los
* ``Alt-F5`` - Ausführen (nur GDB)
* ``F10`` - Einzelschritt
* ``F11`` - Einzeltrace
## Binary Ninja-Verwendung
### Binary Ninja globale Tastenkombinationen
**ret-sync** definiert diese globalen Tastenkombinationen in Binary Ninja:
* ``Alt-S`` - Synchronisation aktivieren
* ``Alt-Shift-S`` - Synchronisation deaktivieren
### Binary Ninja Tastenkombinationen
Bindungen über Debugger-Befehle sind ebenfalls implementiert. Sie ähneln denen der IDA-Erweiterung.
* ``F2`` - Setze Haltepunkt an der Cursor-Adresse
* ``Ctrl-F2`` - Setze Hardware-Haltepunkt an der Cursor-Adresse
* ``Alt-F3`` - Setze einmaligen Haltepunkt an der Cursor-Adresse
* ``Ctrl-F3`` - Setze einmaligen Hardware-Haltepunkt an der Cursor-Adresse
* ``Alt-F2`` - Übersetze (neubasiere im Debugger) aktuelle Cursor-Adresse
* ``Alt-F5`` - Los
* ``F10`` - Einzelschritt
* ``F11`` - Einzeltrace
## WinDbg-Verwendung
### WinDbg Plugin-Befehle
* **!sync**: Startet die Synchronisation
* **!syncoff**: Stoppt die Synchronisation
* **!synchelp**: Zeigt die Liste der verfügbaren Befehle mit kurzer Erklärung an.
* **!cmt [-a address] <string>**: Fügt einen Kommentar an der aktuellen IP in IDA hinzu```
[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]: Kommentar an aktueller IP in IDA zurücksetzen``` [WinDbg] 0:000:x86> !rcmt [sync] !rcmt called
[IDA] .text:00430DB1 push edi
* **!fcmt [-a address] <string>**: Füge einen Funktionskommentar für die Funktion hinzu, in der sich die aktuelle IP befindet```
[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
Hinweis: Das Aufrufen dieses Befehls ohne Argument setzt den Kommentar der Funktion zurück.
!raddr : Fügt einen Kommentar mit der aus dem Ausdruck evaluierten rebasierten Adresse hinzu
!rln : Holt das Symbol vom Disassembler für die angegebene Adresse
!lbl [-a address] : Fügt einen Labelnamen an der aktuellen IP im Disassembler hinzu``` [WinDbg] 0:000:x86> !lbl meaningful_label [sync] !lbl called
[IDA] .text:000000000040271E meaningful_label: .text:000000000040271E mov rdx, rsp
* **!cmd <string>**: Führt einen Befehl in WinDbg aus und fügt dessen Ausgabe als Kommentar an der aktuellen IP im Disassembler hinzu```
[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
currently connected idb(s): [0] target.exe
* **!syncmodauto <on|off>**: Aktivieren/Deaktivieren des automatischen Wechsels des Disassemblers basierend auf dem Modulnamen:```
[WinDbg]
0:000> !syncmodauto off
[IDA]
[*] << broker << dispatcher msg: sync mode auto set to off
current idb set to 0
In diesem Beispiel wäre der aktuell aktive IDB-Client gesetzt worden auf:```
[0] target.exe.
Alt-F2), basiert eine Adresse in Bezug auf den Modulnamen und -Offset neu.Die Befehle !cmt, !rcmt und !fcmt unterstützen eine optionale Adressoption: -a oder --address.
Die Adresse sollte als hexadezimaler Wert übergeben werden. Die Befehlsanalyse basiert auf Pythons
argparse-Modul. Um die Zeilenanalyse zu stoppen, verwenden Sie --.```
[WinDbg]
0:000:x86> !cmt -a 0x430DB2 comment
Die Adresse muss eine gültige Befehlsadresse sein.
## GNU gdb (GDB) Verwendung
Synchronisieren mit dem Host:```
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".
Verwenden Sie Befehle, ohne "!"-Präfix``` (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**: Holt das Symbol aus der IDB für die angegebene Adresse
* **bbt**: Schöner Backtrace. Ähnlich wie **bt**, fordert aber Symbole vom Disassembler an```
(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: Patche Bytes im Disassembler basierend auf dem Live-Kontext
bx: Schöne Anzeige. Ähnlich wie x, aber mit einem Symbol. Das Symbol wird vom Disassembler aufgelöst.
cc: Weiter bis zum Cursor im Disassembler. Dies ist eine Alternative zur Verwendung von F3 zum Setzen eines einmaligen Haltepunkts und F5 zum Fortsetzen. Dies ist nützlich, wenn Sie es lieber von gdb aus machen.```
(gdb) b* 0xA91A73
Breakpoint 1 at 0xa91a73
(gdb) c
Continuing.
Breakpoint 1, 0x0000000000a91a73 in ?? () (gdb) cc [sync] current cursor: 0xa91a7f [sync] reached successfully (gdb)
## LLDB Verwendung
1. Synchronisiere mit Host```
lldb> process launch -s
lldb> sync
[sync] connecting to localhost
[sync] sync is now enabled with host localhost
[sync] event handler started
sync = synchronize with or the default value syncoff = stop synchronization cmt = add comment at current eip in IDA rcmt = reset comments at current eip in IDA fcmt = add a function comment for 'f = get_func(eip)' in IDA cmd = execute command 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
## OllyDbg 1.10 Verwendung
1. Verwenden Sie das Plugins-Menü oder Tastenkombinationen, um die Synchronisation zu aktivieren (``Alt+s``)/deaktivieren (``Alt+u``).
## OllyDbg2 Verwendung
1. Verwenden Sie das Plugins-Menü oder Tastenkombinationen, um die Synchronisation zu aktivieren (``Ctrl+s``)/deaktivieren (``Ctrl+u``).
Aufgrund des Beta-Status der OllyDbg2-API wurden nur die folgenden Funktionen implementiert:
- Graph-Sync [verwenden Sie ``F7``; ``F8`` für Schrittausführung]
- Kommentar [verwenden Sie ``CTRL+;``]
- Label [verwenden Sie ``CTRL+:``]
## x64dbg Verwendung
1. Verwenden Sie das Plugins-Menü oder Befehle, um die Synchronisation zu aktivieren ("``!sync"``) oder zu deaktivieren ("``!syncoff``").
2. Verwenden Sie Befehle```
[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.
Hinweis: Die Verwendung des !translate-Befehls aus einem Disassembler (IDA/Ghidra, Alt-F2-Tastenkombination) bewirkt, dass das Disassembler-Fenster zur spezifischen Adresse "springt" (entspricht der Ausführung von disasm in der x64dbg-Befehlszeile).
Man möchte möglicherweise die Kernfunktionen von ret-sync (Positionssynchronisation mit einem Disassembler, Symbolauflösung) nutzen, auch wenn keine vollständige Debugging-Umgebung verfügbar ist oder mit einem benutzerdefinierten Tool. Zu diesem Zweck wurde eine minimalistische Python-Bibliothek extrahiert.
Das folgende Beispiel veranschaulicht die Verwendung der Python-Bibliothek mit einem Skript, das die Ausgabe eines ereignisbasierten Protokollierungs-/Trace-Tools durchläuft.```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()
# Erweiterung
Während es zunächst auf dynamische Analyse (Debugger) ausgerichtet war, ist es selbstverständlich möglich, das Plugin-Set zu erweitern und in andere Tools zu integrieren.
- Integration mit der **REVEN** Timeless Analysis and Debugging Platform von [Tetrane](https://www.tetrane.com/):
- http://blog.tetrane.com/2015/02/reven-in-your-toolkit.html
- https://twitter.com/tetrane/status/1374768014193799175
- Integration mit dem **EFI DXE Emulator** von Assaf Carlsbad ([@assaf_carlsbad](https://twitter.com/assaf_carlsbad)):
- https://twitter.com/assaf_carlsbad/status/1242114356881641474
- https://github.com/assafcarlsbad/efi_dxe_emulator
Weitere Ressource(n):
- "*Combining static and dynamic binary analysis - ret-sync*" von Jean-Christophe Delaunay
- https://www.synacktiv.com/ressources/bieresecu1_ret-sync_en.pdf
# TODO
- Sicher.
# Bekannte Fehler/Einschränkungen
- Getestet mit Python 2.7/3.7, IDA 7.7 (Windows, Linux und Mac OS X), Ghidra 10.1.1, Binary Ninja 3.0.3225-dev, GNU gdb (GDB) 8.1.0 (Debian), lldb 310.2.37.
- Es gibt **KEINERLEI AUTHENTIFIZIERUNG/VERSCHLÜSSELUNG** zwischen den Parteien; du bist auf dich allein gestellt.
- Selbstmodifizierender Code liegt außerhalb des Anwendungsbereichs.
Mit GDB:
- es scheint, dass das Stop-Ereignis nicht aufgerufen wird, wenn der Befehl 'return' verwendet wird.
- Multithreading-Debugging hat Probleme mit Signalen.
Mit WinDbg:
- Das Client-Plugin von IDA wird benachrichtigt, obwohl der angetroffene Breakpoint eine Befehlszeichenfolge verwendet, die ihn fortsetzen lässt ('``g``'). Dies kann zu einer erheblichen Verlangsamung führen, wenn es zu viele dieser Ereignisse gibt. Eine begrenzte Behebung wurde implementiert, die beste Lösung ist jedoch, vorübergehend die Synchronisation auszuschalten.
- Mögliche Race Condition
Mit Ghidra:
- Tastenkombinationen funktionieren im Decompiler-Widget nicht wie erwartet.
Mit IDA:
- Das Neuzeichnen des Graph-Fensters ist bei großen Graphen recht langsam.
- **ret-sync** Tastenkombinationen kollidieren in Linux-Umgebungen.
Konflikt(e):
- Die Logitech Updater-Software verwendet bekanntermaßen denselben Standard-Port (9100). Eine Lösung ist die Verwendung einer globalen `.sync`-Konfigurationsdatei, um einen anderen Port zu definieren.```
[INTERFACE]
host=127.0.0.1
port=9234
ret-sync ist freie Software: Sie können es weiterverbreiten und/oder modifizieren unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation veröffentlicht, entweder Version 3 der Lizenz oder (nach Ihrer Wahl) jeder späteren Version.
Dieses Programm wird in der Hoffnung bereitgestellt, dass es nützlich sein wird, jedoch OHNE JEGLICHE GARANTIE; selbst ohne die stillschweigende Garantie der MARKTGÄNGIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK. Siehe die GNU General Public License für weitere Details.
Sie sollten eine Kopie der GNU General Public License zusammen mit diesem Programm erhalten haben. Falls nicht, siehe http://www.gnu.org/licenses/.
Das Binary-Ninja-Plugin wird unter der MIT-Lizenz veröffentlicht.
Hochachtung an Bruce Dang, StalkR, @Ivanlef0u, Damien Aumaître, Sébastien Renaud und Kévin Szkudlapski, @m00dy, @saidelike, Xavier Mehrenberger, ben64, Raphaël Rigo, Jiss für ihre Freundlichkeit, Hilfe, Rückmeldungen und Gedanken. Ilfak Guilfanov, Igor Skochinsky und Arnaud Diederen für ihre Hilfe bei den Interna von IDA und herausragende Unterstützung. Danke an Jordan Wiens und Vector 35. Schließlich danke auch an alle Mitwirkenden und jeden, der Probleme/Fehler gemeldet hat.