bootleg/ret-syncret-sync è un insieme di plugin che aiuta a sincronizzare una sessione di debugging (WinDbg/GDB/LLDB/OllyDbg2/x64dbg) con i disassemblatori IDA/Ghidra/Binary Ninja.
ret-sync sta per Reverse-Engineering Tools SYNChronization. È un insieme di plugin che aiutano a sincronizzare una sessione di debug (WinDbg/GDB/LLDB/OllyDbg/OllyDbg2/x64dbg) con un disassemblatore (IDA/Ghidra/Binary Ninja). L'idea di base è semplice: prendere il meglio da entrambi i mondi (analisi statica e dinamica).
I debugger e l'analisi dinamica ci forniscono:
!peb, !drvobj,
!address, ecc.)I disassemblatori e l'analisi statica ci forniscono:
Funzionalità principali:
ret-sync è un fork di qb-sync che ho sviluppato e mantenuto durante la mia permanenza presso Quarkslab.
I plugin per debugger:
ext_windbg/sync: file sorgente dell'estensione WinDbg, una volta compilata: sync.dllext_gdb/sync.py: plugin GDBext_lldb/sync.py: plugin LLDBext_olly1: plugin OllyDbg 1.10ext_olly2: plugin OllyDbg v2ext_x64dbg: plugin x64dbgI plugin per disassemblatori:
ext_ida/SyncPlugin.pyext_ghidra/dist/ghidra_*_retsync.zip: plugin Ghidraext_bn/retsync: plugin Binary NinjaE il plugin libreria:
ext_lib/sync.py: libreria Python standaloneI plugin per IDA e GDB richiedono un ambiente Python funzionante. Sono supportati Python 2 (>=2.7) e Python 3.
Binari precompilati per i debugger WinDbg/OllyDbg/OllyDbg2/x64dbg sono forniti
tramite una pipeline Azure DevOps:
Seleziona l'ultima build e controlla gli artefatti nella sezione Related: 6 pubblicati.
Un archivio precompilato del plugin Ghidra è fornito in ext_ghidra/dist.
ret-sync dovrebbe funzionare immediatamente per la maggior parte degli utenti con una configurazione tipica: debugger e disassemblatore(i) sullo stesso host, nomi dei moduli corrispondenti.
Tuttavia, in alcuni scenari potrebbe essere utile una configurazione specifica. Per questo,
le estensioni e i plugin cercano un file di configurazione globale opzionale chiamato
.sync nella directory home dell'utente. Deve essere un file .INI valido.
Inoltre, i plugin per IDA e Ghidra cercano anche il file di configurazione
nella directory IDB o del progetto (<project>.rep) per primi, per consentire impostazioni
locali, per-IDB/progetto. Se è presente un file di configurazione locale, il
file di configurazione globale viene ignorato.
I valori dichiarati in questi file di configurazione sovrascrivono i valori predefiniti. Si noti
che nessun file .sync viene creato per impostazione predefinita.
Di seguito dettagliamo tre scenari comuni in cui un file di configurazione è utile/necessario:
La sezione [INTERFACE] viene utilizzata per personalizzare le impostazioni relative alla rete.
Supponiamo di voler sincronizzare IDA con un debugger in esecuzione all'interno di una
macchina virtuale (o semplicemente un altro host), scenario comune di debug remoto del kernel.
Creare semplicemente due file .sync:
Dice al plugin **ret-sync** ``IDA`` di ascoltare sull'interfaccia
``192.168.128.1`` con porta ``9234``. Inutile dire che questa
interfaccia deve essere raggiungibile dall'host remoto o dalla macchina virtuale.
* una sulla macchina dove viene eseguito il debugger, nella home directory dell'utente:```
[INTERFACE]
host=192.168.128.1
port=9234
Dice al plugin debugger ret-sync di connettersi al plugin ret-sync IDA
configurato in precedenza per ascoltare su questa interfaccia.
NOTA: Devi specificare un IP reale qui, e non usare 0.0.0.0. Questo perché
la variabile è utilizzata da più sorgenti sia per il binding che per la
connessione, quindi l'uso di 0.0.0.0 provocherà errori strani.
[ALIASES] ntoskrnl_vuln.exe=ntkrnlmp.exe
La sezione ``[ALIASES]`` viene utilizzata per personalizzare il nome utilizzato da un disassemblatore (IDA/Ghidra) per registrare un modulo al suo dispatcher/gestore di programmi.
Per impostazione predefinita, i plugin dei disassemblatori utilizzano il nome del file di input. Tuttavia, è possibile che il file sia stato rinominato in precedenza e non corrisponda più al nome del processo effettivo o del modulo caricato come visto dal debugger.
Qui diciamo semplicemente al dispatcher di corrispondere al nome `ntkrnlmp.exe` (nome reale) invece di `ntoskrnl_vuln.exe` (nome IDB).
## gdb con frontend di debug Qt Creator
Il frontend di debug di Qt Creator modifica il modo in cui viene registrato l'output dei comandi di gdb. Poiché ciò interferirebbe con la sincronizzazione, esiste un'opzione per utilizzare l'output grezzo di gdb per la sincronizzazione invece di un file temporaneo. Nel file di configurazione .sync utilizzare```
[GENERAL]
use_tmp_logging_file=false
if you wish to use the Qt debugging frontend for the target.
/proc/<pid>/mapsIn alcuni scenari, come il debug di dispositivi embedded tramite seriale o firmware raw in QEMU, gdb non è a conoscenza del PID e non può accedere a /proc/<pid>/maps.
In questi casi, la sezione [INIT] viene utilizzata per passare un contesto personalizzato al plugin. Permette di sovrascrivere alcuni campi come il PID e i mapping di memoria.
.sync estratto del contenuto:```
[INIT]
context = {
"pid": 200,
"mappings": [ [0x400000, 0x7A81158, 0x7681158, "asav941-200.qcow2|lina"] ]
}
Ogni voce nelle mappature è: ``mem_base``, ``mem_end``, ``mem_size``, ``mem_name``.
## Bypass del rebasing automatico degli indirizzi
In alcuni scenari, come il debug di dispositivi embedded o la connessione a
interfacce di debug minimaliste, può essere più comodo bypassare la
funzionalità di rebasing automatico degli indirizzi implementata nei plugin del disassemblatore.
L'opzione `use_raw_addr` è attualmente supportata solo per Ghidra. Nel
file di configurazione .sync usare:```
[GENERAL]
use_raw_addr=true
È richiesta IDA 9.2+. Per versioni precedenti, si prega di fare checkout del progetto prima del tag ida9.2 dai Tags disponibili.
Per l'installazione di IDA, copia Syncplugin.py e la cartella retsync da
ext_ida nella directory dei plugin di IDA, ad esempio:
C:\Program Files\IDA Pro 7.4\plugins%APPDATA%\Hex-Rays\IDA Pro\plugins~/.idapro/pluginsAlt-Shift-S) o 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### Risoluzione dei problemi del plugin IDA
Per risolvere i problemi con l'estensione IDA, due opzioni sono disponibili nel file `retsync/rsconfig.py`:```
LOG_LEVEL = logging.INFO
LOG_TO_FILE_ENABLE = False
Impostare il valore LOG_LEVEL su logging.DEBUG rende il plugin più verboso.
Impostare LOG_TO_FILE_ENABLE su True attiva la registrazione delle informazioni sulle eccezioni da broker.py e dispatcher.py in file dedicati. I file di log vengono generati nella cartella %TMP% con un pattern di nome retsync.%s.err .
Utilizza la versione precompilata dalla cartella ext_ghidra/dist oppure segui le istruzioni per compilarla.
Ogni build dell'estensione supporta solo la versione di Ghidra specificata nel nome del file del plugin.
Ad esempio, ghidra_9.1_PUBLIC_20191104_retsync.zip è per Ghidra 9.1 Public.
3. Costruisci l'estensione per la tua installazione di Ghidra (sostituisci `$GHIDRA_DIR` con la tua directory di installazione)```bash
cd ext_ghidra
gradle -PGHIDRA_INSTALL_DIR=$GHIDRA_DIR
File -> Install Extensions..., clicca sul
segno + e seleziona il file ext_ghidra/dist/ghidra_*_retsync.zip e fai clic su OK.
Questo estrarrà effettivamente la cartella retsync dallo zip in
$GHIDRA_DIR/Extensions/Ghidra/4. Dallo strumento Ghidra CodeBrowser: utilizzare le icone della barra degli strumenti o le scorciatoie per abilitare (``Alt+s``)/disabilitare (``Alt+Shift+s``)/riavviare (``Alt+r``) la sincronizzazione.
È anche disponibile una finestra di stato da ``Windows`` -> ``RetSyncPlugin``. Di solito si desidera posizionarla lateralmente per integrarla con le finestre dell'ambiente Ghidra.
## Estensione Binary Ninja
Il supporto per Binary Ninja è sperimentale, assicurati di eseguire il backup dei tuoi database di analisi.
### Prerequisiti di Binary Ninja
**ret-sync** richiede Binary Ninja versione 2.2 come minimo e Python 3 (Python 2 non è supportato).
### Installare l'estensione Binary Ninja
**ret-sync** non è ancora distribuito tramite il Plugin Manager di Binary Ninja; è necessaria un'installazione manuale. Copia semplicemente il contenuto della cartella `ext_bn` nella cartella dei plugin di Binary Ninja, ad esempio:
`%APPDATA%\Binary Ninja\plugins`
Dopo aver riavviato Binary Ninja, il seguente output dovrebbe essere presente nella finestra della console:```
[sync] commands added
Loaded python3 plugin 'retsync'
Utilizza la soluzione Visual Studio 2017
fornita in ext_windbg. Visual Studio Community Edition
2017 e 2026 sono state testate con successo (le versioni intermedie dovrebbero funzionare ugualmente).
Questo compilerà il file x64\release\sync.dll.
Dovrai copiare il file sync.dll risultante nel percorso appropriato dell'estensione Windbg.
Per le versioni precedenti di Windbg, questo è qualcosa del genere (fare attenzione alle versioni x86/x64), ad esempio
C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\winext\sync.dll
La cartella per memorizzare l'estensione sembra basarsi sul PATH, quindi devi inserirla in una delle posizioni interrogate.
Un esempio è inserirla qui:
C:\Users\user\AppData\Local\Microsoft\WindowsApps\sync.dll
.load)```
0:000> .load sync
[sync.dll] DebugExtensionInitialize, ExtensionApis loaded3. Sincronizza 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
Ad es. nella finestra Output di 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
Se il modulo corrente di Windbg corrisponde al nome del file IDA```
[sync] idb is enabled with the idb client matching the module name.
Nota: Se si verifica il seguente errore, è perché non hai copiato il file nella cartella corretta nei passaggi precedenti.``` 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'errore qui sotto di solito significa che WinDbg ha tentato di caricare la versione errata dell'estensione, ad esempio: ``x64`` al posto della ``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.
Poiché WinDbg Preview carica entrambi i plugin (x86 e x64) dalla stessa directory, è possibile rinominare il file x86 sync32.dll.```
0:000> .load sync32
## Installazione di GNU gdb (GDB)
1. Copia `ext_gdb/sync.py` nella directory che preferisci
2. Carica l'estensione (vedi auto-load-scripts)```
gdb> source sync.py
[sync] configuration file loaded 192.168.52.1:9100
[sync] commands added
Il supporto LLDB è sperimentale, comunque:
~/.lldbinit)```
lldb> command script import sync## Installazione di OllyDbg 1.10
Il supporto per OllyDbg 1.10 è sperimentale, tuttavia:
1. Compila il plugin utilizzando la soluzione VS (opzionale, vedi i binari precompilati)
2. Copia la dll nella directory dei plugin di OllyDbg
## Installazione di OllyDbg2
Il supporto per OllyDbg2 è sperimentale, tuttavia:
1. Compila il plugin utilizzando la soluzione VS (opzionale, vedi i binari precompilati)
2. Copia la dll nella directory dei plugin di OllyDbg2
## Installazione di x64dbg
Basato su testplugin, https://github.com/x64dbg/testplugin. Il supporto per x64dbg è sperimentale, tuttavia:
1. Compila il plugin utilizzando la soluzione VS (opzionale, vedi i binari precompilati).
Potresti aver bisogno di una versione diversa dell'SDK del plugin,
una copia si trova in ogni release di x64dbg.
Incolla la directory "``pluginsdk``" in "``ext_x64dbg\x64dbg_sync``"
2. Copia la dll (l'estensione è ``.d32`` o ``.dp64``) nella directory dei plugin di x64dbg.
# Utilizzo
## Comandi del debugger **ret-sync**
Per debugger orientati alla riga di comando (principalmente Windbg e GDB), **ret-sync** espone un insieme di comandi per assistere nel compito di reverse engineering.
I comandi seguenti sono generici (Windbg e GDB), nota che su WinDbg è necessario un prefisso `!` (es.: `sync` in GDB, `!sync` in Windbg).
| Comando del debugger | Descrizione |
|----------------------------|-------------------------------------------------------------------------------------------|
| `synchelp` | Mostra l'elenco dei comandi disponibili con una breve spiegazione |
| `sync` | Avvia la sincronizzazione |
| `syncoff` | Ferma la sincronizzazione |
| `cmt [-a address] <string>` | Aggiungi un commento all'ip corrente nel disassemblatore |
| `rcmt [-a address]` | Reimposta il commento all'ip corrente nel disassemblatore |
| `fcmt [-a address] <string>` | Aggiungi un commento di funzione per la funzione in cui si trova l'ip corrente |
| `raddr <expression>` | Aggiungi un commento con l'indirizzo ribasato valutato dall'espressione |
| `rln <expression>` | Ottieni il simbolo dal disassemblatore per l'indirizzo dato |
| `lbl [-a address] <string>` | Aggiungi un nome di etichetta all'ip corrente nel disassemblatore |
| `cmd <string>` | Esegui un comando nel debugger e aggiungi il suo output come commento all'ip corrente nel disassemblatore |
| `bc <\|\|on\|off\|set 0xBBGGRR>` | Abilita/disabilita la colorazione del percorso nel disassemblatore |
| `idblist` | Ottieni l'elenco di tutti i client IDB connessi al dispatcher |
| `syncmodauto <on\|off>` | Abilita/disabilita il cambio automatico del disassemblatore basato sul nome del modulo |
| `idbn <n>` | Imposta l'IDB attivo all'n-esimo client |
| `jmpto <expression>` | |
| `jmpraw <expression>` | Se un IDB è abilitato, la vista del disassemblatore viene sincronizzata con l'indirizzo risultante. |
| `translate <base> <addr> <mod>` | ribasa un indirizzo rispetto al nome del suo modulo e all'offset |
Comandi specifici per WinDbg:
| Comando del debugger | Descrizione |
|----------------------------|-------------------------------------------------------------------------------------------|
| `curmod` | Mostra le informazioni del modulo per l'offset dell'istruzione corrente (per risoluzione problemi) |
| `modlist` | Elenco moduli migliorato con Debugger Markup Language (DML) pensato per un cambio di IDB attivo più fluido |
| `idb <nome modulo>` | Imposta il modulo dato come IDB attivo (vedi la versione migliorata di `lm` tramite `modlist`) |
| `modmap <base> <size> <nome>` | Un modulo sintetico ("finto") (definito usando il suo indirizzo base e la dimensione) viene aggiunto alla lista interna del debugger |
| `modunmap <base>` | Rimuove un modulo sintetico precedentemente mappato all'indirizzo base |
| `modcheck <\|\|md5>` | Usato per verificare se il modulo corrente corrisponde effettivamente al file IDB (es: il modulo è stato aggiornato) |
| `bpcmds <\|\|save\|load\|>` | Wrapper per **bpcmds**, salva e ricarica l'output di **.bpcmds** (elenco comandi breakpoint) nell'IDB corrente |
| `ks` | Output migliorato del comando **kv** con Debugger Markup Language (DML) |
Comandi specifici per GDB:
| Comando del debugger | Descrizione |
|----------------------------|-------------------------------------------------------------------------------------------|
|`bbt` | Backtrace migliorato. Simile a **bt** in GDB ma richiede simboli dal disassemblatore |
| `patch` | Applica patch ai byte nel disassemblatore basandosi sul contesto live |
| `bx` | Simile a **x** di GDB ma usando un simbolo. Il simbolo verrà risolto dal disassemblatore |
| `cc` | Continua fino al cursore nel disassemblatore |
## Utilizzo di IDA
### GUI del plugin di IDA
Il campo di input ``Overwrite idb name`` è pensato per cambiare il nome IDB predefinito. È il nome utilizzato dal plugin per registrarsi presso il dispatcher. Il cambio automatico dell'IDB si basa sulla corrispondenza del nome del modulo. In caso di nomi in conflitto (come un ``foo.exe`` e ``foo.dll``), questo può essere usato per agevolare la corrispondenza. Nota: se modifichi il campo di input mentre la sincronizzazione è attiva, devi ri-registrarti presso il dispatcher; puoi farlo semplicemente usando il pulsante "``Restart``".
Come promemoria, è possibile creare alias predefiniti utilizzando il file di configurazione ``.sync``.
### Scorciatoie globali di IDA
**ret-sync** definisce queste scorciatoie globali in IDA:
* ``Alt-Shift-S`` - Esegui il plugin **ret-sync**
* ``Ctrl-Shift-S`` - Attiva/disattiva sincronizzazione globale
* ``Ctrl-H`` - Attiva/disattiva sincronizzazione Hex-Rays
Due pulsanti sono disponibili anche nella barra degli strumenti Debug per attivare/disattivare la sincronizzazione globale e Hex-Rays.
### Collegamenti IDA ai comandi del debugger
``Syncplugin.py`` registra anche hotkey wrapper per comandi del debugger.
* ``F2`` - Imposta breakpoint all'indirizzo del cursore
* ``F3`` - Imposta breakpoint monouso all'indirizzo del cursore
* ``Ctrl-F2`` - Imposta breakpoint hardware all'indirizzo del cursore
* ``Ctrl-F3`` - Imposta breakpoint hardware monouso all'indirizzo del cursore
* ``Alt-F2`` - Traduci (ribasa nel debugger) l'indirizzo corrente del cursore
* ``Alt-F5`` - Vai
* ``Ctrl-Alt-F5`` - Esegui (solo GDB)
* ``F10`` - Passo singolo
* ``F11`` - Traccia singola
Questi comandi sono disponibili solo quando l'IDB corrente è attivo. Quando possibile, sono stati implementati anche per altri debugger.
## Utilizzo di Ghidra
### GUI del plugin di Ghidra
Una volta aperto RetSyncPlugin, puoi aggiungerlo alla finestra CodeBrowser con un semplice trascinamento:
Se desideri visualizzare più moduli, i file devono essere aperti nello stesso visualizzatore CodeBrowser; basta trascinare quelli aggiuntivi nella finestra CodeBrowser per ottenere il risultato come sopra.
### Scorciatoie globali di Ghidra
**ret-sync** definisce queste scorciatoie globali in Ghidra:
* ``Alt-S`` - Abilita sincronizzazione
* ``Alt-Shift-S`` - Disabilita sincronizzazione
* ``Alt-R`` - Riavvia sincronizzazione
* ``Alt-Shift-R`` - Ricarica configurazione
### Collegamenti Ghidra ai comandi del debugger
Sono implementati anche i collegamenti ai comandi del debugger. Sono simili a quelli dell'estensione di IDA (tranne il comando "Go").
* ``F2`` - Imposta breakpoint all'indirizzo del cursore
* ``Ctrl-F2`` - Imposta breakpoint hardware all'indirizzo del cursore
* ``Alt-F3`` - Imposta breakpoint monouso all'indirizzo del cursore
* ``Ctrl-F3`` - Imposta breakpoint hardware monouso all'indirizzo del cursore
* ``Alt-F2`` - Traduci (ribasa nel debugger) l'indirizzo corrente del cursore
* ``F5`` - Vai
* ``Alt-F5`` - Esegui (solo GDB)
* ``F10`` - Passo singolo
* ``F11`` - Traccia singola
## Utilizzo di Binary Ninja
### Scorciatoie globali di Binary Ninja
**ret-sync** definisce queste scorciatoie globali in Binary Ninja:
* ``Alt-S`` - Abilita sincronizzazione
* ``Alt-Shift-S`` - Disabilita sincronizzazione
### Scorciatoie di Binary Ninja
Sono implementati anche i collegamenti ai comandi del debugger. Sono simili a quelli dell'estensione di IDA.
* ``F2`` - Imposta breakpoint all'indirizzo del cursore
* ``Ctrl-F2`` - Imposta breakpoint hardware all'indirizzo del cursore
* ``Alt-F3`` - Imposta breakpoint monouso all'indirizzo del cursore
* ``Ctrl-F3`` - Imposta breakpoint hardware monouso all'indirizzo del cursore
* ``Alt-F2`` - Traduci (ribasa nel debugger) l'indirizzo corrente del cursore
* ``Alt-F5`` - Vai
* ``F10`` - Passo singolo
* ``F11`` - Traccia singola
## Utilizzo di WinDbg
### Comandi del plugin WinDbg
* **!sync**: Avvia sincronizzazione
* **!syncoff**: Ferma sincronizzazione
* **!synchelp**: Mostra l'elenco dei comandi disponibili con una breve spiegazione.
* **!cmt [-a address] <string>**: Aggiungi commento all'ip corrente in 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]: Resetta commento all'IP corrente in IDA``` [WinDbg] 0:000:x86> !rcmt [sync] !rcmt called
[IDA] .text:00430DB1 push edi
* **!fcmt [-a address] <string>**: Aggiungi un commento funzione per la funzione in cui si trova l'IP corrente```
[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: chiamare questo comando senza argomento reimposta il commento della funzione.
!raddr : Aggiunge un commento con l'indirizzo rebasato valutato dall'espressione
!rln : Ottiene il simbolo dal disassembler per l'indirizzo specificato
!lbl [-a address] : Aggiunge un nome di etichetta all'ip corrente nel disassembler``` [WinDbg] 0:000:x86> !lbl meaningful_label [sync] !lbl called
[IDA] .text:000000000040271E meaningful_label: .text:000000000040271E mov rdx, rsp
* **!cmd <string>**: Esegue un comando in WinDbg e aggiunge il suo output come commento all'ip corrente nel disassemblatore```
[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>**: Abilita/disabilita la commutazione automatica del disassembler basata sul nome del modulo:```
[WinDbg]
0:000> !syncmodauto off
[IDA]
[*] << broker << dispatcher msg: sync mode auto set to off
current idb set to 0
In questo esempio, il client IDB attualmente attivo sarebbe stato impostato a:```
[0] target.exe.
Alt-F2), ri-basa un indirizzo rispetto al nome del modulo e all'offset.I comandi !cmt, !rcmt e !fcmt supportano un'opzione facoltativa per l'indirizzo: -a o --address.
L'indirizzo deve essere passato come valore esadecimale. Il parsing dei comandi è basato sul modulo argparse di Python.
Per interrompere il parsing della riga, usa --.```
[WinDbg]
0:000:x86> !cmt -a 0x430DB2 comment
L'indirizzo deve essere un indirizzo di un'istruzione valida.
## GNU gdb (GDB) uso
Sincronizza con l'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".
Usa i comandi, senza il prefisso "!"``` (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**: Ottieni simbolo dall'IDB per l'indirizzo dato
* **bbt**: Bellissimo backtrace. Simile a **bt** ma richiede simboli dal disassemblatore```
(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: Applica patch ai byte nel disassemblatore basandosi sul contesto live
bx: Visualizzazione elegante. Simile a x ma usando un simbolo. Il simbolo verrà risolto dal disassemblatore.
cc: Continua fino al cursore nel disassemblatore. Questa è un'alternativa all'uso di F3 per impostare un breakpoint monouso e F5 per continuare. È utile se preferisci farlo da 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)
## Utilizzo di LLDB
1. Sincronizza con l'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
## Utilizzo di OllyDbg 1.10
1. Utilizzare il menu Plugin o le scorciatoie per abilitare (`Alt+s`)/disabilitare (`Alt+u`)
la sincronizzazione.
## Utilizzo di OllyDbg2
1. Utilizzare il menu Plugin o le scorciatoie per abilitare (`Ctrl+s`)/disabilitare (`Ctrl+u`)
la sincronizzazione.
A causa dello stato beta dell'API di OllyDbg2, sono state implementate solo le seguenti funzionalità:
- Sincronizzazione grafico [usa `F7`; `F8` per passi]
- Commento [usa `CTRL+;`]
- Etichetta [usa `CTRL+:``]
## Utilizzo di x64dbg
1. Utilizzare il menu Plugin o i comandi per abilitare (`"!sync"`) o disabilitare (`"!syncoff"`) la sincronizzazione.
2. Utilizzare i comandi```
[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.
Nota: usando il comando !translate da un disassemblatore (IDA/Ghidra,
scorciatoia Alt-F2), farà sì che la finestra del disassemblatore "salti" all'indirizzo specifico (equivalente all'esecuzione del comando disasm nella riga di comando di x64dbg).
Potrebbe essere utile utilizzare le funzionalità principali di ret-sync (sincronizzazione della posizione con un disassemblatore, risoluzione dei simboli) anche quando un ambiente di debug completo non è disponibile o con uno strumento personalizzato. A tal fine, è stata estratta una libreria Python minimalista.
L'esempio seguente illustra l'utilizzo della libreria Python con uno script che analizza l'output di uno strumento di logging/tracing basato su eventi.```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()
# Estensione
Sebbene inizialmente focalizzato sull'analisi dinamica (debugger), è ovviamente possibile estendere il set di plugin e integrarsi con altri strumenti.
- Integrazione con la piattaforma **REVEN** Timeless Analysis and Debugging di [Tetrane](https://www.tetrane.com/):
- http://blog.tetrane.com/2015/02/reven-in-your-toolkit.html
- https://twitter.com/tetrane/status/1374768014193799175
- Integrazione con **EFI DXE Emulator** di Assaf Carlsbad ([@assaf_carlsbad](https://twitter.com/assaf_carlsbad)):
- https://twitter.com/assaf_carlsbad/status/1242114356881641474
- https://github.com/assafcarlsbad/efi_dxe_emulator
Altre risorse:
- "*Combinare l'analisi binaria statica e dinamica - ret-sync*" di Jean-Christophe Delaunay
- https://www.synacktiv.com/ressources/bieresecu1_ret-sync_en.pdf
# TODO
Certo.
# Bug/Limitazioni noti
- Testato con Python 2.7/3.7, IDA 7.7 (Windows, Linux e Mac OS X), Ghidra 10.1.1, Binary Ninja 3.0.3225-dev, GNU gdb (GDB) 8.1.0 (Debian), lldb 310.2.37.
- **NON C'È AUTENTICAZIONE/CRITTOGRAFIA** tra le parti; sei da solo.
- Il codice auto-modificante è fuori portata.
Con GDB:
- sembra che l'evento di stop non venga chiamato quando si usa il comando 'return'.
- il debugging multi-thread presenta problemi con i segnali.
Con WinDbg:
- Il plugin client di IDA viene notificato anche se il breakpoint incontrato usa una stringa di comando che lo fa continuare ('``g``'). Questo può causare un notevole rallentamento se ci sono troppi di questi eventi. È stata implementata una correzione limitata; la soluzione migliore è ancora quella di disattivare la sincronizzazione temporaneamente.
- Possibile race condition
Con Ghidra:
- Le scorciatoie non funzionano come previsto nel widget decompilatore.
Con IDA:
- Il ridisegno della finestra del grafo è piuttosto lento per grafi grandi.
- I conflitti delle scorciatoie di **ret-sync** negli ambienti Linux.
Conflitto/i:
- È noto che il software Logitech Updater utilizza la stessa porta predefinita (9100). Una soluzione è usare un file di configurazione globale `.sync` per definire una porta diversa.```
[INTERFACE]
host=127.0.0.1
port=9234
ret-sync è un software libero: puoi ridistribuirlo e/o modificarlo secondo i termini della GNU General Public License pubblicata dalla Free Software Foundation, versione 3 o, a tua scelta, qualsiasi versione successiva.
Questo programma è distribuito nella speranza che sia utile, ma SENZA ALCUNA GARANZIA; senza neppure la garanzia implicita di COMMERCIABILITÀ o IDONEITÀ PER UN PARTICOLARE SCOPO. Si veda la GNU General Public License per maggiori dettagli.
Dovresti aver ricevuto una copia della GNU General Public License insieme a questo programma. In caso contrario, visita http://www.gnu.org/licenses/.
Il plugin per Binary Ninja è rilasciato sotto licenza MIT.
Un ringraziamento a Bruce Dang, StalkR, @Ivanlef0u, Damien Aumaître, Sébastien Renaud e Kévin Szkudlapski, @m00dy, @saidelike, Xavier Mehrenberger, ben64, Raphaël Rigo, Jiss per la loro gentilezza, aiuto, feedback e pensieri. A Ilfak Guilfanov, Igor Skochinsky e Arnaud Diederen per il loro aiuto con gli internals di IDA e il loro eccezionale supporto. Grazie a Jordan Wiens e Vector 35. Infine, grazie anche a tutti i contributori e a chiunque abbia segnalato problemi/errori.