bootleg/ret-syncret-sync é um conjunto de plugins que ajuda a sincronizar uma sessão de depuração (WinDbg/GDB/LLDB/OllyDbg2/x64dbg) com desmontadores IDA/Ghidra/Binary Ninja.
ret-sync significa "Reverse-Engineering Tools SYNChronization". É um conjunto de plugins que ajudam a sincronizar uma sessão de depuração (WinDbg/GDB/LLDB/OllyDbg/OllyDbg2/x64dbg) com um desassemblador (IDA/Ghidra/Binary Ninja). A ideia subjacente é simples: aproveitar o melhor dos dois mundos (análise estática e dinâmica).
Depuradores e análise dinâmica nos fornecem:
!peb, !drvobj do WinDbg,
!address, etc.)Desassembladores e análise estática nos fornecem:
Principais recursos:
ret-sync é um fork do qb-sync que desenvolvi e mantive durante minha estadia no Quarkslab.
Os plugins do depurador:
ext_windbg/sync: arquivos fonte da extensão WinDbg, quando compilada: sync.dllext_gdb/sync.py: plugin GDBext_lldb/sync.py: plugin LLDBext_olly1: plugin OllyDbg 1.10ext_olly2: plugin OllyDbg v2ext_x64dbg: plugin x64dbgOs plugins do desassemblador:
ext_ida/SyncPlugin.pyext_ghidra/dist/ghidra_*_retsync.zip: plugin Ghidraext_bn/retsync: plugin Binary NinjaE o plugin da biblioteca:
ext_lib/sync.py: biblioteca Python independenteOs plugins IDA e GDB requerem uma configuração Python válida. Python 2 (>=2.7) e Python 3 são suportados.
Binários pré-compilados para os depuradores WinDbg/OllyDbg/OllyDbg2/x64dbg são fornecidos
através de um pipeline Azure DevOps:
Selecione a última compilação e verifique os artefatos na seção Related: 6 published.
Um arquivo pré-compilado do plugin Ghidra é fornecido em ext_ghidra/dist.
ret-sync deve funcionar imediatamente para a maioria dos usuários com uma configuração típica: depurador e desassemblador(s) na mesma máquina, nomes de módulo correspondentes.
Ainda assim, em alguns cenários uma configuração específica pode ser usada. Para isso,
as extensões e plugins verificam um arquivo de configuração global opcional chamado
.sync no diretório pessoal do usuário. Deve ser um arquivo .INI válido.
Além disso, os plugins IDA e Ghidra também procuram pelo arquivo de configuração
no diretório do IDB ou do projeto (<project>.rep) primeiro, para permitir
configurações locais, por IDB/projeto. Se um arquivo de configuração local estiver presente, o
arquivo de configuração global é ignorado.
Os valores declarados nesses arquivos de configuração substituem os valores padrão. Por favor,
note que nenhum arquivo .sync é criado por padrão.
Abaixo detalhamos três cenários comuns onde um arquivo de configuração é útil/necessário:
A seção [INTERFACE] é usada para personalizar configurações relacionadas à rede.
Vamos supor que alguém queira sincronizar IDA com um depurador rodando dentro de
uma máquina virtual (ou simplesmente outro host), cenário comum de depuração remota do kernel.
Simplesmente crie dois arquivos .sync:
Ele informa o plugin **ret-sync** do ``IDA`` para escutar na interface ``192.168.128.1`` com a porta ``9234``. É óbvio que essa interface deve estar acessível a partir do host remoto ou da máquina virtual.
* um na máquina onde o depurador é executado, no diretório home do usuário:```
[INTERFACE]
host=192.168.128.1
port=9234
Ele instrui o plugin de depurador ret-sync a conectar-se ao plugin IDA ret-sync configurado anteriormente para escutar nesta interface.
NOTA: Você deve especificar um IP real aqui, e não usar 0.0.0.0. Isso ocorre porque a variável é usada por múltiplas fontes tanto para vinculação quanto para conexão, então usar 0.0.0.0 resultará em erros estranhos.
[ALIASES] ntoskrnl_vuln.exe=ntkrnlmp.exe
A seção ``[ALIASES]`` é usada para personalizar o nome que é usado por um desmontador (IDA/Ghidra) para registrar um módulo em seu despachante/gerenciador de programas.
Por padrão, os plugins do desmontador usam o nome do arquivo de entrada. No entanto, pode-se ter renomeado o arquivo anteriormente e ele não corresponde mais ao nome do processo real ou módulo carregado como visto pelo depurador.
Aqui, simplesmente dizemos ao despachante para corresponder ao nome `ntkrnlmp.exe` (nome real) em vez de `ntoskrnl_vuln.exe` (nome IDB).
## gdb with Qt Creator debugging frontend
O frontend de depuração do Qt Creator altera a forma como a saída do comando gdb é registrada. Como isso interferiria na sincronização, existe uma opção para usar a saída bruta do gdb para sincronização em vez de um arquivo temporário. No arquivo de configuração .sync, use```
[GENERAL]
use_tmp_logging_file=false
se deseja usar o frontend de depuração Qt para o alvo.
/proc/<pid>/mapsEm alguns cenários, como depuração de dispositivos embarcados via serial ou firmware bruto no QEMU, o gdb não tem conhecimento do PID e não consegue acessar /proc/<pid>/maps.
Nesses casos, a seção [INIT] é usada para passar um contexto personalizado ao plugin. Ela permite sobrescrever alguns campos, como o PID e os mapeamentos de memória.
.sync extração de conteúdo:```
[INIT]
context = {
"pid": 200,
"mappings": [ [0x400000, 0x7A81158, 0x7681158, "asav941-200.qcow2|lina"] ]
}
Cada entrada nos mapeamentos é: ``mem_base``, ``mem_end``, ``mem_size``, ``mem_name``.
## Ignorando o reajuste automático de endereço
Em alguns cenários, como depuração de dispositivos embarcados ou conexão com
interfaces de depuração minimalistas, pode ser mais conveniente ignorar o
recurso de reajuste automático de endereço implementado nos plugins do desmontador.
A opção `use_raw_addr` é atualmente suportada apenas para o Ghidra. No
arquivo de configuração .sync use:```
[GENERAL]
use_raw_addr=true
IDA 9.2+ é necessário. Para versões mais antigas, por favor, faça checkout do projeto anterior à tag ida9.2 das Tags disponíveis.
Para instalação do IDA, copie Syncplugin.py e a pasta retsync de
ext_ida para o diretório de plugins do IDA, por exemplo:
C:\Program Files\IDA Pro 7.4\plugins%APPDATA%\Hex-Rays\IDA Pro\plugins~/.idapro/pluginsAlt-Shift-S) ou 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### Resolução de problemas do plugin IDA
Para solucionar problemas com a extensão IDA, duas opções estão disponíveis no
arquivo `retsync/rsconfig.py`:```
LOG_LEVEL = logging.INFO
LOG_TO_FILE_ENABLE = False
Definir o valor de LOG_LEVEL para logging.DEBUG torna o plugin mais detalhado.
Definir o valor de LOG_TO_FILE_ENABLE para True ativa o registro de informações de exceção de broker.py e dispatcher.py em arquivos dedicados. Os arquivos de log são gerados na pasta %TMP% com um padrão de nome retsync.%s.err .
Use a versão pré-construída da pasta ext_ghidra/dist ou siga as instruções para construí-la.
Cada compilação da extensão suporta apenas a versão do Ghidra especificada no nome do arquivo do plugin.
Exemplo: ghidra_9.1_PUBLIC_20191104_retsync.zip é para Ghidra 9.1 Public.
3. Construir extensão para sua instalação do Ghidra (substitua `$GHIDRA_DIR` pelo diretório de sua instalação)```bash
cd ext_ghidra
gradle -PGHIDRA_INSTALL_DIR=$GHIDRA_DIR
File -> Install Extensions..., clique no sinal + e selecione o ficheiro ext_ghidra/dist/ghidra_*_retsync.zip e clique em OK. Isto irá extrair a pasta retsync do zip para $GHIDRA_DIR/Extensions/Ghidra/4. Na ferramenta Ghidra CodeBrowser: use ícones da barra de ferramentas ou atalhos para ativar (``Alt+s``)/desativar (``Alt+Shift+s``)/reiniciar (``Alt+r``)
a sincronização.
Uma janela de status também está disponível em ``Windows`` -> ``RetSyncPlugin``. Geralmente
você deve colocá-la na lateral para integrá-la com as janelas do ambiente
Ghidra.
## Extensão Binary Ninja
O suporte ao Binary Ninja é experimental, certifique-se de fazer backup dos seus
bancos de dados de análise.
### Pré-requisitos do Binary Ninja
**ret-sync** requer pelo menos a versão 2.2 do Binary Ninja, bem como Python 3
(Python 2 não é suportado).
### Instalar a extensão do Binary Ninja
**ret-sync** ainda não é distribuído através do Gerenciador de Plugins do Binary Ninja;
é necessária uma instalação manual. Basta copiar o conteúdo da pasta `ext_bn`
para a pasta de plugins do Binary Ninja, por exemplo:
`%APPDATA%\Binary Ninja\plugins`
Após reiniciar o Binary Ninja, a seguinte saída deve aparecer na
janela do console:```
[sync] commands added
Loaded python3 plugin 'retsync'
Use a solução do Visual Studio 2017 fornecida em ext_windbg. Visual Studio Community Edition
2017 e 2026 foram testados com sucesso (versões intermediárias também devem funcionar).
Isso irá compilar o arquivo x64\release\sync.dll.
Você precisará copiar o arquivo sync.dll resultante para o caminho apropriado da extensão do WinDbg.
Para versões anteriores do WinDbg, é algo como isto (cuidado com as variações x86/x64), por exemplo
C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\winext\sync.dll
A pasta para armazenar a extensão parece ser baseada no PATH, então você precisa colocá-la em um dos locais consultados.
Um exemplo é colocá-la aqui:
C:\Users\user\AppData\Local\Microsoft\WindowsApps\sync.dll
.load)```
0:000> .load sync
[sync.dll] DebugExtensionInitialize, ExtensionApis loaded3. Sincronizar 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
Ex.: na janela Output do 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 o módulo atual do Windbg corresponder ao nome do arquivo IDA```
[sync] idb is enabled with the idb client matching the module name.
Nota: Se você obtiver o seguinte erro, é porque não copiou o arquivo para a pasta correta nas etapas acima.``` 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.
O erro abaixo geralmente significa que o Windbg tentou carregar a variante incorreta
da extensão, ex: ``x64`` no lugar da ``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.
Como o WinDbg Preview carrega ambos os plugins (x86 e x64) do mesmo diretório, pode-se renomear o arquivo x86 sync32.dll.```
0:000> .load sync32
## Instalação do GNU gdb (GDB)
1. Copie o `ext_gdb/sync.py` para o diretório de sua escolha
2. Carregue a extensão (veja auto-load-scripts)```
gdb> source sync.py
[sync] configuration file loaded 192.168.52.1:9100
[sync] commands added
O suporte LLDB é experimental, no entanto:
~/.lldbinit)```
lldb> command script import sync## Instalação do OllyDbg 1.10
O suporte ao OllyDbg 1.10 é experimental, no entanto:
1. Compile o plugin usando a solução VS (opcional, veja binários pré-compilados)
2. Copie a dll para o diretório de plugins do OllyDbg
## Instalação do OllyDbg2
O suporte ao OllyDbg2 é experimental, no entanto:
1. Compile o plugin usando a solução VS (opcional, veja binários pré-compilados)
2. Copie a dll para o diretório de plugins do OllyDbg2
## Instalação do x64dbg
Baseado no testplugin, https://github.com/x64dbg/testplugin. O suporte ao x64dbg é experimental, no entanto:
1. Compile o plugin usando a solução VS (opcional, veja binários pré-compilados).
Pode ser que necessite de uma versão diferente do SDK do plugin,
uma cópia pode ser encontrada em cada versão do x64dbg.
Cole o diretório "``pluginsdk``" em "``ext_x64dbg\x64dbg_sync``"
2. Copie a dll (extensão é ``.d32`` ou ``.dp64``) para o diretório de plugins do x64dbg.
# Uso
## Comandos do depurador **ret-sync**
Para depuradores orientados a linha de comando (principalmente Windbg e GDB) um conjunto de comandos
é exposto pelo **ret-sync** para auxiliar na tarefa de engenharia reversa.
Os comandos abaixo são genéricos (Windbg e GDB), note que um prefixo `!`
é necessário no WinDbg (ex.: `sync` no GDB, `!sync` no WinDbg).
| Comando do depurador | Descrição |
|----------------------------|-------------------------------------------------------------------------------------------|
| `synchelp` | Exibe a lista de comandos disponíveis com breve explicação |
| `sync` | Iniciar sincronização |
| `syncoff` | Parar sincronização |
| `cmt [-a address] <string>` | Adicionar um comentário no IP atual no desassemblador |
| `rcmt [-a address]` | Redefinir comentário no IP atual no desassemblador |
| `fcmt [-a address] <string>` | Adicionar um comentário de função para a função onde o IP atual está localizado |
| `raddr <expression>` | Adicionar um comentário com endereço recalculado avaliado a partir da expressão |
| `rln <expression>` | Obter símbolo do desassemblador para o endereço fornecido |
| `lbl [-a address] <string>` | Adicionar um nome de rótulo no IP atual no desassemblador |
| `cmd <string>` | Executar um comando no depurador e adicionar sua saída como comentário no IP atual no desassemblador |
| `bc <\|\|on\|off\|set 0xBBGGRR>` | Ativar/desativar coloração de caminho no desassemblador |
| `idblist` | Obter lista de todos os clientes IDB conectados ao dispatcher |
| `syncmodauto <on\|off>` | Ativar/desativar troca automática do desassemblador baseada no nome do módulo |
| `idbn <n>` | Definir IDB ativo para o enésimo cliente |
| `jmpto <expression>` | |
| `jmpraw <expression>` | Se um IDB estiver ativado, a visualização do desassemblador é sincronizada com o endereço resultante. |
| `translate <base> <addr> <mod>` | recalcular um endereço em relação ao nome e deslocamento do seu módulo |
Comandos específicos do WinDbg:
| Comando do depurador | Descrição |
|----------------------------|-------------------------------------------------------------------------------------------|
| `curmod` | Exibe informações do módulo para o deslocamento da instrução atual (para solução de problemas) |
| `modlist` | Lista de módulos aprimorada com DML (Debugger Markup Language) para alternância mais suave do IDB ativo |
| `idb <nome do módulo>` | Definir o módulo fornecido como IDB ativo (veja versão aprimorada de `lm` com `modlist`) |
| `modmap <base> <tamanho> <nome>` | Um módulo sintético ("falso") (definido usando seu endereço base e tamanho) é adicionado à lista interna do depurador |
| `modunmap <base>` | Remover um módulo sintético mapeado anteriormente no endereço base |
| `modcheck <\|\|md5>` | Usar para verificar se o módulo atual realmente corresponde ao arquivo do IDB (ex: módulo foi atualizado) |
| `bpcmds <\|\|save\|load\|>` | Invólucro do **bpcmds**, salvar e recarregar a saída do **.bpcmds** (breakpoints commands list) para o IDB atual |
| `ks` | Saída aprimorada com DML do comando **kv** |
Comandos específicos do GDB:
| Comando do depurador | Descrição |
|----------------------------|-------------------------------------------------------------------------------------------|
|`bbt` | Beautiful backtrace. Semelhante a **bt** no GDB, mas solicita símbolos do desassemblador |
| `patch` | Corrigir bytes no desassemblador com base no contexto ativo |
| `bx` | Semelhante a **x** do GDB, mas usando um símbolo. O símbolo será resolvido pelo desassemblador |
| `cc` | Continuar até o cursor no desassemblador |
## Uso no IDA
### GUI do plugin do IDA
O campo de entrada ``Overwrite idb name`` serve para alterar o nome padrão do IDB.
É o nome usado pelo plugin para se registrar no
dispatcher. A troca automática de IDB é baseada na correspondência de nomes de módulos. Em caso de
nomes conflitantes (como um ``foo.exe`` e ``foo.dll``), isso pode ser usado para
facilitar a correspondência. Note que, se você modificar o campo de entrada enquanto a sincronização estiver
ativa, você terá que se registrar novamente no dispatcher; isso pode ser feito simplesmente
usando o botão "``Restart``".
Como lembrete, é possível criar um alias por padrão usando o arquivo de configuração ``.sync``.
### Atalhos globais do IDA
**ret-sync** define estes atalhos globais no IDA:
* ``Alt-Shift-S`` - Executar o plugin **ret-sync**
* ``Ctrl-Shift-S`` - Alternar sincronização global
* ``Ctrl-H`` - Alternar sincronização do Hex-Rays
Dois botões também estão disponíveis na barra de ferramentas de Depuração para alternar a sincronização global e
do Hex-Rays.
### Ligações do IDA sobre comandos do depurador
``Syncplugin.py`` também registra teclas de atalho para invólucros de comandos do depurador.
* ``F2`` - Definir breakpoint no endereço do cursor
* ``F3`` - Definir breakpoint de uso único no endereço do cursor
* ``Ctrl-F2`` - Definir breakpoint de hardware no endereço do cursor
* ``Ctrl-F3`` - Definir breakpoint de hardware de uso único no endereço do cursor
* ``Alt-F2`` - Traduzir (recalcular no depurador) o endereço atual do cursor
* ``Alt-F5`` - Ir
* ``Ctrl-Alt-F5`` - Executar (apenas GDB)
* ``F10`` - Passo único
* ``F11`` - Traço único
Estes comandos estão disponíveis apenas quando o IDB atual está ativo. Quando
possível, eles também foram implementados para outros depuradores.
## Uso no Ghidra
### GUI do plugin do Ghidra
Assim que o RetSyncPlugin for aberto, você pode adicioná-lo à janela do CodeBrowser simplesmente
arrastando e soltando:
Se você quiser visualizar vários módulos, os arquivos precisam estar abertos no mesmo visualizador
do CodeBrowser, basta arrastar e soltar os adicionais na janela do CodeBrowser para obter
o resultado como acima.
### Atalhos globais do Ghidra
**ret-sync** define estes atalhos globais no Ghidra:
* ``Alt-S`` - Ativar sincronização
* ``Alt-Shift-S`` - Desativar sincronização
* ``Alt-R`` - Reiniciar sincronização
* ``Alt-Shift-R`` - Recarregar configuração
### Ligações do Ghidra sobre comandos do depurador
Ligações sobre comandos do depurador também são implementadas. São semelhantes às
da extensão do IDA (exceto o comando "Go").
* ``F2`` - Definir breakpoint no endereço do cursor
* ``Ctrl-F2`` - Definir breakpoint de hardware no endereço do cursor
* ``Alt-F3`` - Definir breakpoint de uso único no endereço do cursor
* ``Ctrl-F3`` - Definir breakpoint de hardware de uso único no endereço do cursor
* ``Alt-F2`` - Traduzir (recalcular no depurador) o endereço atual do cursor
* ``F5`` - Ir
* ``Alt-F5`` - Executar (apenas GDB)
* ``F10`` - Passo único
* ``F11`` - Traço único
## Uso no Binary Ninja
### Atalhos globais do Binary Ninja
**ret-sync** define estes atalhos globais no Binary Ninja:
* ``Alt-S`` - Ativar sincronização
* ``Alt-Shift-S`` - Desativar sincronização
### Atalhos do Binary Ninja
Ligações sobre comandos do depurador também são implementadas. São semelhantes às
da extensão do IDA.
* ``F2`` - Definir breakpoint no endereço do cursor
* ``Ctrl-F2`` - Definir breakpoint de hardware no endereço do cursor
* ``Alt-F3`` - Definir breakpoint de uso único no endereço do cursor
* ``Ctrl-F3`` - Definir breakpoint de hardware de uso único no endereço do cursor
* ``Alt-F2`` - Traduzir (recalcular no depurador) o endereço atual do cursor
* ``Alt-F5`` - Ir
* ``F10`` - Passo único
* ``F11`` - Traço único
## Uso no WinDbg
### Comandos do plugin WinDbg
* **!sync**: Iniciar sincronização
* **!syncoff**: Parar sincronização
* **!synchelp**: Exibir a lista de comandos disponíveis com breve explicação.
* **!cmt [-a address] <string>**: Adicionar comentário no IP atual no 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]: Redefinir comentário no ip atual no IDA``` [WinDbg] 0:000:x86> !rcmt [sync] !rcmt called
[IDA] .text:00430DB1 push edi
* **!fcmt [-a address] <string>**: Adicionar um comentário de função para a função na qual o ip atual está localizado.```
[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
Nota: chamar este comando sem argumento redefine o comentário da função.
!raddr : Adiciona um comentário com o endereço rebaseado avaliado a partir da expressão
!rln : Obtém o símbolo do desmontador para o endereço fornecido
!lbl [-a address] : Adiciona um nome de rótulo no IP atual no desmontador``` [WinDbg] 0:000:x86> !lbl meaningful_label [sync] !lbl called
[IDA] .text:000000000040271E meaningful_label: .text:000000000040271E mov rdx, rsp
* **!cmd <string>**: Executa um comando no WinDbg e adiciona sua saída como comentário no ip atual no desassemblador```
[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>**: Ativar/desativar a troca automática do desassemblador com base no nome do módulo:```
[WinDbg]
0:000> !syncmodauto off
[IDA]
[*] << broker << dispatcher msg: sync mode auto set to off
current idb set to 0
Neste exemplo, o cliente IDB ativo atual teria sido definido para:```
[0] target.exe.
Alt-F2), rebaixa um endereço em relação ao nome e offset do seu módulo.Os comandos !cmt, !rcmt e !fcmt suportam uma opção de endereço opcional: -a ou --address.
O endereço deve ser passado como um valor hexadecimal. O parsing do comando é baseado no módulo
argparse do Python. Para interromper o parsing da linha, use --.```
[WinDbg]
0:000:x86> !cmt -a 0x430DB2 comment
O endereço deve ser um endereço de instrução válido.
## Uso do GNU gdb (GDB)
Sincronizar com o 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".
Use comandos, sem o prefixo "!"``` (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**: Obter símbolo do IDB para o endereço fornecido
* **bbt**: Backtrace bonito. Similar ao **bt** mas solicita símbolos do disassembler```
(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: Aplicar patch em bytes no desassemblador com base no contexto ativo
bx: Exibição bonita. Similar a x mas usando um símbolo. O símbolo será resolvido pelo desassemblador.
cc: Continuar até o cursor no desassemblador. Esta é uma alternativa ao uso de F3 para
definir um breakpoint único e F5 para continuar. Isto é útil se preferir
fazê-lo a partir do 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)
## Uso do LLDB
1. Sincronizar com o 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
## Uso do OllyDbg 1.10
1. Use o menu Plugins ou atalhos para ativar (``Alt+s``)/desativar (``Alt+u``)
sincronização.
## Uso do OllyDbg2
1. Use o menu Plugins ou atalhos para ativar (``Ctrl+s``)/desativar (``Ctrl+u``)
sincronização.
Devido ao status beta da API do OllyDbg2, apenas os seguintes recursos foram implementados:
- Sincronização de gráfico [use ``F7``; ``F8`` para avanço passo a passo]
- Comentário [use ``CTRL+;``]
- Rótulo [use ``CTRL+:``]
## Uso do x64dbg
1. Use o menu Plugins ou comandos para ativar ("``!sync"``) ou desativar ("``!syncoff``") a sincronização.
2. Use comandos```
[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: usar o comando !translate de um desassemblador (IDA/Ghidra,
atalho Alt-F2), fará com que a janela do desassemblador "pule" para o
endereço específico (equivalente a executar disasm na
linha de comando do x64dbg).
Pode-se desejar usar os recursos principais do ret-sync (sincronização de posição com um desassemblador, resolução de símbolos) mesmo que um ambiente completo de depuração não esteja disponível ou com uma ferramenta personalizada. Para isso, uma biblioteca Python minimalista foi extraída.
O exemplo abaixo ilustra o uso da biblioteca Python com um script que percorre a saída de uma ferramenta de registro/rastreamento baseada em eventos.```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()
# Extend
Embora inicialmente focado em análise dinâmica (depuradores), é claro que é possível estender o conjunto de plugins e integrar com outras ferramentas.
- Integração com a plataforma **REVEN** Timeless Analysis and Debugging da [Tetrane](https://www.tetrane.com/):
- http://blog.tetrane.com/2015/02/reven-in-your-toolkit.html
- https://twitter.com/tetrane/status/1374768014193799175
- Integração com o **EFI DXE Emulator** de Assaf Carlsbad ([@assaf_carlsbad](https://twitter.com/assaf_carlsbad)):
- https://twitter.com/assaf_carlsbad/status/1242114356881641474
- https://github.com/assafcarlsbad/efi_dxe_emulator
Outro(s) recurso(s):
- "*Combining static and dynamic binary analysis - ret-sync*" por Jean-Christophe Delaunay
- https://www.synacktiv.com/ressources/bieresecu1_ret-sync_en.pdf
# TODO
- Claro.
# Known Bugs/Limitations
- Testado com 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.
- **NÃO HÁ AUTENTICAÇÃO/CRIPTOGRAFIA** alguma entre as partes; você está por sua conta.
- Código automodificante está fora do escopo.
Com GDB:
- parece que o evento de parada não é chamado ao usar o comando 'return'.
- a depuração multi-thread tem problemas com sinais.
Com WinDbg:
- O plugin cliente do IDA é notificado mesmo que um ponto de interrupção encontrado
use uma string de comando que o faça continuar ('``g``'). Isso pode causar grande lentidão
se houver muitos desses eventos. Uma correção limitada foi implementada, a
melhor solução ainda é desativar a sincronização temporariamente.
- Possível condição de corrida
Com Ghidra:
- Atalhos não estão funcionando como esperado no widget do descompilador.
Com IDA:
- A redesenho da janela do gráfico é bastante lento para gráficos grandes.
- Os atalhos do **ret-sync** conflitam em ambientes Linux.
Conflito(s):
- O software Logitech Updater é conhecido por usar a mesma porta padrão (9100). Uma solução
é usar um arquivo de configuração global `.sync` para definir uma porta diferente.```
[INTERFACE]
host=127.0.0.1
port=9234
ret-sync é um software livre: você pode redistribuí-lo e/ou modificá-lo sob os termos da GNU General Public License conforme publicada pela Free Software Foundation, seja a versão 3 da Licença, ou (a seu critério) qualquer versão posterior.
Este programa é distribuído na esperança de que seja útil, mas SEM QUALQUER GARANTIA; sem mesmo a garantia implícita de COMERCIALIZAÇÃO ou ADEQUAÇÃO A UM PROPÓSITO ESPECÍFICO. Consulte a GNU General Public License para mais detalhes.
Você deve ter recebido uma cópia da GNU General Public License junto com este programa. Caso contrário, veja http://www.gnu.org/licenses/.
O plugin do Binary Ninja é distribuído sob a licença MIT.
Saudações a Bruce Dang, StalkR, @Ivanlef0u, Damien Aumaître, Sébastien Renaud e Kévin Szkudlapski, @m00dy, @saidelike, Xavier Mehrenberger, ben64, Raphaël Rigo, Jiss pela gentileza, ajuda, feedbacks e pensamentos. Ilfak Guilfanov, Igor Skochinsky e Arnaud Diederen pela ajuda com os internals do IDA e suporte excepcional. Obrigado a Jordan Wiens e Vector 35. Finalmente, obrigado também a todos os contribuidores e a todos que reportaram issues/bugs.