Migração de Símbolos Entre Versões (Diferença Binária)

Quando Usar

• Um programa foi atualizado e anotações/símbolos antigos precisam ser migrados para a nova compilação.
• Recuperando funções alteradas entre duas versões de um binário "strippado" (sem símbolos).

Âmbito de Aplicação

Use esta habilidade quando a tarefa se enquadrar nos seguintes cenários:

1. Kernel/Driver sem PDB — Possui símbolos da versão antiga do ntoskrnl.exe, o PDB da nova versão foi descontinuado pela Microsoft, e é necessário usar os símbolos da versão antiga para inferir o endereço de funções não exportadas da nova versão.
2. Migração de Símbolos após Atualização de Programa — Você já fez a engenharia reversa de um programa, ele foi atualizado, e você não quer refazer tudo. Use os resultados da versão antiga para migrar em lote.
3. Atualização de Mecanismo de Proteção — A versão antiga possui resultados completos de engenharia reversa, e a nova versão precisa localizar rapidamente o novo deslocamento da mesma função.
4. Qualquer Cenário de Comparação Binária "com Símbolos Antigos + Nova Versão sem Símbolos"

Divisão de Tarefas com Outras Habilidades

Vantagens Principais

Comparado a soluções tradicionais:

Princípio Central

旧版函数（有符号）          新版同一函数（无符号）
    ↓                              ↓
导出反汇编 + 伪代码          导出反汇编 + 伪代码
    ↓                              ↓
    └──────── LLM 结构化比对 ────────┘
                    ↓
         输出 YAML（符号映射表）
                    ↓
         程序化解析 → 批量应用到新版 IDB

Pontos chave:

• O prompt é um modelo fixo, preenchido programaticamente.
• O formato de entrada e saída é definido, analisado programaticamente.
• O LLM é responsável apenas pela etapa de "olhar dois trechos de código e encontrar a relação correspondente".
• Custo de tempo e custo de tokens são extremamente baixos.

Modelo de Prompt

Prompt de Comparação Padrão

I have disassembly outputs and procedure code of the same function.

This is the function for reference:

**Disassembly for Reference**
```c
{disasm_for_reference}

Procedure code for Reference

{procedure_for_reference}

This is the function you need to reverse-engineering:

Disassembly to reverse-engineering

{disasm_code}

Procedure code to reverse-engineering

{procedure}

What you need to do is to collect all references to "{symbol_name_list}" in the function you need to reverse-engineering and output those references as YAML.

Example:

found_vcall: # Isso é para chamadas indiretas a funções virtuais ou busca de ponteiros de função virtual.
  - insn_va: '0x180777700' # Sempre será a instrução com deslocamento
    insn_disasm: call [rax+68h] # Sempre será a instrução com deslocamento
    vfunc_offset: '0x68'
    func_name: ILoopMode_OnLoopActivate
  - insn_va: '0x180777778' # Sempre será a instrução com deslocamento
    insn_disasm: mov rax, [rax+80h] # Sempre será a instrução com deslocamento
    vfunc_offset: '0x80'
    func_name: INetworkMessages_GetNetworkGroupCount

found_call: # Isso é para chamadas diretas a funções regulares não virtuais.
  - insn_va: '0x180888800'
    insn_disasm: call sub_180999900
    func_name: CLoopMode_RegisterEventMapInternal
  - insn_va: '0x180888880'
    insn_disasm: call sub_180555500
    func_name: CLoopMode_SetSystemState

found_funcptr: # Isso é para ponteiros de função regulares não virtuais.
  - insn_va: '0x180666600' # Deve carregar/referenciar o endereço alvo do ponteiro de função
    insn_disasm: lea rdx, sub_15BC910 # Deve carregar/referenciar o endereço alvo do ponteiro de função
    funcptr_name: CLoopMode_OnClientPollNetworking

found_gv: # Isso é para referências a variáveis globais.
  - insn_va: '0x180444400'
    insn_disasm: mov rcx, cs:qword_180666600 # Deve carregar/referenciar a variável global
    gv_name: g_pNetworkMessages
  - insn_va: '0x180333300'
    insn_disasm: lea rax, unk_180222200 # Deve carregar/referenciar a variável global
    gv_name: s_EventManager

found_struct_offset: # Isso é para referências a deslocamentos de estrutura. OBSERVE QUE ponteiros de função virtual NÃO devem estar aqui! Ponteiros de função virtual devem SEMPRE estar em found_vcall!
  - insn_va: '0x1801BA12A' # Sempre será a instrução com deslocamento
    insn_disasm: mov rcx, [r14+58h] # Sempre será a instrução com deslocamento
    offset: '0x58'
    size: 8
    struct_name: CResourceService
    member_name: m_pEntitySystem

If nothing found, output an empty YAML. DO NOT output anything other than the desired YAML. DO NOT collect unrelated symbols.

### Descrição das Variáveis

| Variável | Origem | Descrição |
|------|------|------|
| `{disasm_for_reference}` | Exportado do IDA da versão antiga | Desmontagem com símbolos |
| `{procedure_for_reference}` | Exportado do IDA da versão antiga | Pseudocódigo com símbolos |
| `{disasm_code}` | Exportado do IDA da nova versão | Desmontagem sem símbolos |
| `{procedure}` | Exportado do IDA da nova versão | Pseudocódigo sem símbolos |
| `{symbol_name_list}` | Extraído da versão antiga | Lista de símbolos a serem localizados na nova versão |

## Fluxo de Trabalho

### Fluxo Completo

```text
Passo 1: Preparar Dados
  - Carregar binário da versão antiga no IDA (com PDB/símbolos)
  - Carregar binário da nova versão no IDA (sem símbolos)
  - Encontrar funções âncora comuns entre as duas versões (funções exportadas, referências a strings, etc.)

Passo 2: Exportar em Lote
  - Da versão antiga: Desmontagem + pseudocódigo da função âncora (com nomes de símbolos)
  - Da nova versão: Desmontagem + pseudocódigo da mesma função âncora (sem nomes de símbolos)

Passo 3: Comparação com LLM
  - Preencher o modelo de prompt com os dados

…