# Pontos de Extração — IDA 5, IDA 6.6, IDA 7 e Ghidra

Documento de referência sobre quais dados de análise estática são extraíveis via script de cada engine, com a utilidade de cada ponto e grau de dificuldade.

---

## Tabela Resumo

| # | Dado | Utilidade | IDA 5 (IDC) | IDA 6.6 (IDAPython) | IDA 7+ (IDAPython) | Ghidra (Java/Python) |
|---|------|-----------|:-----------:|:--------------------:|:------------------:|:--------------------:|
| 1 | Funções (nome, endereço, assembly) | Navegação básica do binário | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 2 | Code references / Labels | Resolver alvos de jump/call | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 3 | Xrefs de entrada (callers) | Grafo de chamadas reverso | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 4 | Entry point | Saber onde o binário inicia | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 5 | Tipo de xref (CALL vs JUMP vs DATA) | Diferencia saltos de chamadas | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 6 | Flags da função (library, thunk, far) | Classificar tipo de função | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 7 | Segmentos (.text, .data, .rdata) | Mapa de memória do binário | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 8 | Tamanho/fim da função | Delimitar escopo da função | ✅ **Implementado** | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 9 | Strings referenciadas | Entender mensagens, nomes, paths | ✅ Médio | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 10 | Imports / APIs externas (DLLs) | Saber quais libs externas são usadas | ✅ Médio | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 11 | Frame da função (vars locais, args) | Estrutura da stack frame | ✅ Médio | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 12 | Comentários do IDA/Ghidra | Anotações automáticas do disassembler | ✅ Médio | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |
| 13 | Data xrefs (leitura/escrita em globais) | Quem acessa cada variável global | ⚠️ Limitado | ✅ **Implementado** | ✅ Médio | ✅ Médio |
| 14 | Tipos e assinaturas de funções | Parâmetros, retorno, calling convention | ❌ Não viável | ✅ **Implementado** | ✅ Médio | ✅ Fácil |
| 15 | Estruturas e enums | Layout de structs usadas pelo binário | ❌ Não viável | ✅ **Implementado** | ⚠️ Limitado | ✅ Médio |
| 16 | Decompilação (pseudocódigo) | Código de alto nível reconstruído | ❌ Não existe | ✅ Fácil | ✅ Fácil | ✅ Fácil |
| 17 | Call graph / Fluxo de controle (CFG) | Visualização de blocos e branches | ⚠️ Limitado | ✅ **Implementado** | ✅ Médio | ✅ Médio |
| 18 | Nomes de variáveis globais | Labels simbólicos de dados | ✅ Médio | ✅ **Implementado** | ✅ Fácil | ✅ Fácil |

---

## 1. Funções (nome, endereço, assembly) ✅ Implementado

**O que é:** Lista de todas as funções reconhecidas pelo disassembler, com nome, endereço de início e o texto do assembly.

**Para que serve:** É a base de toda navegação. Permite listar funções, buscar por nome, e exibir o código de cada uma.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `NextFunction()`, `GetFunctionName()`, `GetDisasm()`, `ItemSize()` | ✅ **Já implementado** |
| IDA 6.6 | `idc.NextFunction(ea)`, `idc.GetFunctionName(ea)`, `idc.GetDisasm(ea)`, `idc.ItemSize(ea)` | ✅ **Já implementado** |
| IDA 7 | `ida_funcs.get_funcs()`, `ida_lines.generate_disasm_line()` | ✅ Trivial |
| Ghidra | `currentProgram.getFunctionManager().getFunctions()`, `listing.getInstructions()` | ✅ Trivial |

---

## 2. Code References / Labels ✅ Implementado

**O que é:** Para cada instrução de jump/call, o endereço de destino e o nome (label) associado a ele.

**Para que serve:** Permite que o frontend resolva labels (`loc_28D`, `sub_402000`) para endereços reais e ofereça navegação por clique.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `Rfirst(ea)`, `Rnext(ea, ref)`, `Name(ref)` | ✅ **Já implementado** |
| IDA 6.6 | `idautils.XrefsFrom(curr_inst)` iterando instruções da função, `idc.Name(xref.to)` | ✅ **Já implementado** |
| IDA 7 | `ida_xref.xrefblk_t()` com `iscode=True` | ✅ Trivial |
| Ghidra | `instruction.getReferencesFrom()`, `ref.getToAddress()` | ✅ Trivial |

---

## 3. Xrefs de entrada (callers) ✅ Implementado

**O que é:** Lista de funções que chamam/referenciam a função atual.

**Para que serve:** Constrói o grafo reverso de chamadas — "quem me chama". Essencial para entender o fluxo do programa.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `RfirstB(ea)`, `RnextB(ea, xref)` | ✅ **Já implementado** |
| IDA 6.6 | `idautils.XrefsTo(ea)` com filtro por tipo (`FL_CF`, `FL_CN`, `FL_JF`, `FL_JN`) | ✅ **Já implementado** |
| IDA 7 | `ida_xref.xrefs_to(ea)` | ✅ Trivial |
| Ghidra | `function.getCallingFunctions(TaskMonitor.DUMMY)` ou via reference manager | ✅ Trivial |

---

## 4. Entry Point ✅ Implementado

**O que é:** O endereço onde a execução do binário começa. Pode ser o stub da CRT (`start`) ou diretamente `main`/`WinMain`.

**Para que serve:** Ponto de partida da análise. O analista sabe por onde começar a ler o código. Em modo headless do frontend, pode ser usado como âncora inicial.

**Implementação:** `BeginEA()` + `Name()` no `extract.idc` (IDA 5) / `idc.MinEA()` + `idc.Name()` no `extract.py` (IDA 6.6) → campo `entryPoint` no `AnalysisResult` → coluna `entry_point` em `static_analysis` → exposto via `AnalysisResponse` e injetado no system prompt do chat (`[ENTRY POINT]`).

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `BeginEA()` retorna o entry point; `Name()` dá o label | ✅ **Implementado** |
| IDA 6.6 | `idc.MinEA()` retorna o menor endereço do binário (entry point); `idc.Name(ea)` dá o label | ✅ **Implementado** |
| IDA 7 | `ida_loader.get_entry_point()` ou `ida_entry.get_entry_ordinals()` | ✅ Trivial |
| Ghidra | `program.getListing().getInstructionAt(program.getImageBase().add(entryOffset))`; entry offset via `program.getExecutableFormat()` ou metadados do importador | ✅ Trivial |

---

## 5. Tipo de Xref (CALL vs JUMP vs DATA) ✅ Implementado

**O que é:** Classifica cada code reference como `CALL` (chamada de função), `JUMP` (salto condicional/incondicional) ou referência a dados.

**Para que serve:** Permite que o frontend diferencie visualmente chamadas de função de saltos locais. Essencial para coloração de syntax e navegação contextual.

**Implementação:** `XrefType()` em `extract.idc` (IDA 5) / `idautils.XrefsTo(ea)` com constantes `FL_CF`/`FL_CN`/`FL_JF`/`FL_JN` em `extract.py` (IDA 6.6) nos xrefs (`name:CALL`) e labels (`name:0xADDR:CALL`) → `XrefEntry(name, type)` + `LabelEntry.type` → `StaticXref.type` + `StaticLabel.type` → exposto via `XrefResponse.type` e `LabelResponse.type` → `ChatContextBuilder` exibe `name [CALL]`.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `XrefType()` retorna `fl_CF` (far call), `fl_CN` (near call), `fl_JF` (far jump), `fl_JN` (near jump) | ✅ **Implementado** |
| IDA 6.6 | `idautils.XrefsTo(ea)` / `idautils.XrefsFrom(curr_inst)`, cada xref tem `.type` com constantes `FL_CF`, `FL_CN`, `FL_JF`, `FL_JN` | ✅ **Implementado** |
| IDA 7 | `ida_xref.xrefblk_t().type` retorna `fl_CF/fl_CN/fl_JF/fl_JN` | ✅ Fácil |
| Ghidra | `ref.getReferenceType()` retorna `CALL`, `JUMP`, `DATA`, etc. | ✅ Fácil |

---

## 6. Flags da Função ✅ Implementado

**O que é:** Atributos da função como: é library function? é thunk? usa far calling convention? tem frame pointer?

**Para que serve:** Classificação automática de funções. Ex: marcar funções importadas de DLL como "library", diferenciar funções far/near em binários 16-bit, etc.

**Implementação:** `GetFunctionFlags(ea)` em `extract.idc` (IDA 5) / `idc.GetFunctionFlags(ea)` em `extract.py` (IDA 6.6) testando bits `FUNC_LIB`, `FUNC_THUNK`, `FUNC_FAR`, `FUNC_FRAME` → campo `flags` em `FunctionResult` → coluna `flags` em `static_function` → exposto via `FunctionDetailResponse.flags` → incluído no chunk de embedding (`Flags: ...`) e no context builder do chat.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `GetFunctionFlags(ea)` retorna bits: `FUNC_LIB`, `FUNC_THUNK`, `FUNC_FAR`, `FUNC_FRAME`, etc. | ✅ **Implementado** |
| IDA 6.6 | `idc.GetFunctionFlags(ea)` — mesma API, acessível via `idc.FUNC_LIB`, `idc.FUNC_THUNK`, `idc.FUNC_FAR`, `idc.FUNC_FRAME` | ✅ **Implementado** |
| IDA 7 | `ida_funcs.get_func(ea).flags` | ✅ Fácil |
| Ghidra | `function.isThunk()`, `function.isLibrary()`, `function.getCallingConvention()` | ✅ Fácil |

---

## 7. Segmentos (.text, .data, .rdata, etc.) ✅ Implementado

**O que é:** Mapa de memória do binário — cada segmento com nome, endereço inicial, endereço final e classe (CODE, DATA, BSS, etc.).

**Para que serve:** Contexto para o frontend mostrar em qual região de memória cada função/string está. Permite filtrar funções por segmento (ex: "só .text").

**Implementação:** Loop `FirstSeg()`/`NextSeg()` no `extract.idc` (IDA 5) / `idc.FirstSeg()`/`idc.NextSeg()` no `extract.py` (IDA 6.6) → `SegmentEntry(name, startAddress, endAddress)` → tabela `static_segment` com FK para `static_analysis` → exposto via `GET /analysis/{id}/segments` → incluído no chunk `METADATA` do embedding.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `SegByName()`, `SegStart()`, `SegEnd()`, `SegName()`, iteração com `FirstSeg()`/`NextSeg()` | ✅ **Implementado** |
| IDA 6.6 | `idc.FirstSeg()`, `idc.NextSeg(seg)`, `idc.SegName(seg)`, `idc.SegStart(seg)`, `idc.SegEnd(seg)` — mesma API, namespace `idc` | ✅ **Implementado** |
| IDA 7 | `ida_segment.get_segm_list()`, `ida_segment.get_segm_by_name()` | ✅ Fácil |
| Ghidra | `program.getMemory().getBlocks()` | ✅ Fácil |

---

## 8. Tamanho / Fim da Função ✅ Implementado

**O que é:** Endereço final da função (`FindFuncEnd`), permitindo calcular tamanho em bytes e delimitar o escopo.

**Para que serve:** Já usado internamente no extract.idc. Expor no JSON permite ao frontend mostrar "tamanho: 245 bytes" ou destacar o range da função no mapa de memória.

**Implementação:** `FindFuncEnd(ea) - ea` no `extract.idc` (IDA 5) / `idc.FindFuncEnd(ea) - ea` no `extract.py` (IDA 6.6) → campo `int size` no `FunctionResult` → coluna `function_size` em `static_function` → exposto via `FunctionDetailResponse.size` → incluído nos chunks (`[FUNCTION] name at 0xADDR (67 bytes)`) e no context builder do chat.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `FindFuncEnd(ea)` | ✅ **Implementado** |
| IDA 6.6 | `idc.FindFuncEnd(ea)` — mesma API, namespace `idc` | ✅ **Implementado** |
| IDA 7 | `ida_funcs.get_func(ea).end_ea` | ✅ Trivial |
| Ghidra | `function.getBody().getMaxAddress()` | ✅ Trivial |

---

## 9. Strings ✅ Implementado (IDA 6.6)

**O que é:** Todas as strings contidas no binário (mensagens, nomes de arquivo, paths, nomes de classes, etc.) com endereço, conteúdo e tipo (ASCII, Unicode).

**Para que serve:** Essencial para entender o que o programa faz. Strings geralmente revelam funcionalidades, mensagens de erro, comandos, paths de arquivo. O frontend pode oferecer busca e filtro por strings.

**Implementação:** `idautils.Strings()` + `idc.GetStringType(ea)` no `extract.py` (IDA 6.6) → `StringEntry(address, value, encoding, referencedBy)` → tabela `static_string` com FK para `static_analysis` → exposto via `GET /analysis/{id}/strings` → chunks de embedding individuais (`[STRING] at 0xADDR (encoding): "value"`) e top-20 strings incluídas no chunk `METADATA`. Xrefs de strings (quais funções referenciam cada string) extraídos via `idautils.XrefsTo(ea)` e armazenados no campo `referencedBy`.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | Iterar sobre segmentos de dados com `isLoaded(ea)` e `GetString(ea, -1, ASCSTR_C)`. Também é possível buscar "string literals" no segmento `.data`/`.rdata` com `GetStringType()`. | ✅ Médio (iteração manual sobre bytes) |
| IDA 6.6 | `idautils.Strings()` retorna lista de objetos string com conteúdo, endereço e tipo. `idc.GetStringType(ea)` para classificação ASCSTR_C/UNICODE. | ✅ Fácil |
| IDA 7 | `ida_bytes.get_strlit_contents()`, `ida_strlist.string_info_t()` — API nativa de strings | ✅ Fácil |
| Ghidra | `program.getListing().getDefinedData(true)` filtrado por `StringDataInstance` | ✅ Fácil |

---

## 10. Imports / APIs Externas (DLLs) ✅ Implementado (IDA 6.6)

**O que é:** Lista de funções externas importadas de DLLs (ex: `KERNEL32.CreateFileA`, `USER32.MessageBoxA`) com nome da DLL, nome da função e endereço na IAT.

**Para que serve:** Saber quais APIs do sistema operacional o binário usa. Permite inferir capacidades (ex: se importa `WS2_32`, usa rede; se importa `CRYPT32`, usa criptografia).

**Implementação:** `idaapi.get_import_module_qty()` + `idaapi.get_import_module_name()` + `idaapi.enum_import_names()` no `extract.py` (IDA 6.6) → `ImportEntry(dll, name, address, ordinal)` → tabela `static_import` com FK para `static_analysis` → exposto via `GET /analysis/{id}/imports` → chunks de embedding individuais (`[IMPORT] KERNEL32.CreateFileA`) e top-30 imports incluídos no chunk `METADATA`.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | Iterar segmentos externos (`SegByName(".idata")`) e usar `Name(ea)` nos endereços da IAT. Alternativa: parse da tabela de imports manualmente. | ✅ Médio (requer lógica de parse) |
| IDA 6.6 | `ida_nalt.get_import_module_name(ea)` e iteração sobre a IAT com `idautils.XrefsTo(ea)` filtrado por segmento externo. `idaapi.enum_import_names()` disponível. | ✅ Fácil |
| IDA 7 | `ida_nalt.get_import_module_name()`, `idaapi.enum_import_names()` | ✅ Fácil |
| Ghidra | `program.getExternalManager().getExternalLibraryNames()`, `getExternalLibraryFunctions()` | ✅ Fácil |

---

## 11. Frame da Função (variáveis locais, argumentos) ✅ Implementado (IDA 6.6)

**O que é:** Estrutura da stack frame: variáveis locais (com nome e offset negativo do bp), argumentos (offset positivo), saved registers, tamanho total do frame.

**Para que serve:** Entender a assinatura implícita da função (quantos args, quantas vars locais). O frontend pode exibir uma tabela de variáveis locais junto com o assembly.

**Implementação:** `idc.GetFrame(ea)` + `idc.GetStrucSize()` + iteração manual com `idc.GetFirstMember()` e `idc.GetMemberSize()` no `extract.py` (IDA 6.6) → array JSON de `{offset, size, name}` armazenado como string JSON no campo `FunctionResult.stackFrame` → coluna `stack_frame TEXT` em `static_function` → exposto como `List<FrameMemberResponse>` no `FunctionDetailResponse` → incluído nos chunks de embedding (`[STACK FRAME]`) e no `ChatContextBuilder`.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `GetFrame(ea)` retorna o id da estrutura, `GetStrucSize(id)`, iterar membros com `GetStrucMember()`/`GetMemberName()` | ✅ Médio (API de estruturas frágil no IDA 5) |
| IDA 6.6 | `ida_frame.get_frame(ea)` disponível via IDAPython; `ida_struct.get_struc_members(id)` para iterar vars locais e argumentos | ✅ Fácil |
| IDA 7 | `ida_frame.get_frame(ea)`, `ida_struct.get_struc_members()` | ✅ Fácil |
| Ghidra | `function.getStackFrame()`, `stackFrame.getStackVariables()` | ✅ Fácil |

---

## 12. Comentários do Disassembler ✅ Implementado (IDA 6.6)

**O que é:** Comentários gerados automaticamente pelo disassembler (ex: `; CODE XREF: sub_1000+5A`, `; char` em loads de strings) e comentários manuais do analista.

**Para que serve:** Enriquece a exibição do assembly. Comentários automáticos do IDA/Ghidra dão dicas de tipos e cross-references que ajudam na leitura.

**Implementação:** `idc.GetCommentEx(ea, 0)` + `idc.GetCommentEx(ea, 1)` para iterar instruções da função no `extract.py` (IDA 6.6) → array JSON de `{address, text, repeatable}` armazenado como string JSON no campo `FunctionResult.comments` → coluna `comments TEXT` em `static_function` → exposto como `List<CommentResponse>` no `FunctionDetailResponse` → incluído nos chunks de embedding (`[COMMENTS]`) e no `ChatContextBuilder`.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `GetCommentEx(ea, 0)` para comentários regulares, `GetRptCmt(ea)` para comentários repetíveis | ✅ Médio (precisa testar quais flags funcionam) |
| IDA 6.6 | `idc.GetCommentEx(ea, 0)` e `idc.GetCommentEx(ea, 1)` (repetível) — mesma API, namespace `idc` | ✅ Fácil |
| IDA 7 | `ida_bytes.get_cmt(ea, False)`, `ida_bytes.get_cmt(ea, True)` | ✅ Fácil |
| Ghidra | `listing.getComment(CodeUnit.EOL_COMMENT, address)` e `PRE_COMMENT`, `POST_COMMENT` | ✅ Fácil |

---

## 13. Data Xrefs (leitura/escrita em globais) ✅ Implementado (IDA 6.6)

**O que é:** Referências de instruções para endereços de dados — quem lê e quem escreve cada variável global.

**Para que serve:** Entender o fluxo de dados. Ex: "a variável global `g_score` é escrita por `addPoints()` e lida por `drawHUD()`".

**Implementação:** `idautils.XrefsTo(ea)` com filtro por tipos `dr_O`/`dr_W`/`dr_R`/`dr_T` no `extract.py` (IDA 6.6) → array JSON de `{function, address, type}` armazenado como string JSON no campo `GlobalVarEntry.dataXrefs` → coluna `data_xrefs TEXT` em `static_data_label` → exposto como `List<DataXrefResponse>` dentro do `DataLabelResponse` → incluído nos chunks de embedding.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `Dfirst(ea)` e `Dnext(ea, ref)` retornam data xrefs. API existe mas suporte pode ser limitado. | ⚠️ Limitado (testar viabilidade) |
| IDA 6.6 | `idautils.XrefsTo(ea)` filtrando por `xref.type` não-code (`dr_O`, `dr_W`, `dr_R`). API mais madura que IDC 5. | ✅ Médio |
| IDA 7 | `ida_xref.xrefs_to(ea)` com filtro `data`, ou `ida_xref.xrefblk_t()` | ✅ Médio |
| Ghidra | `referenceManager.getReferencesTo(address)` e filtrar por tipo `DATA` | ✅ Médio |

---

## 14. Tipos e Assinaturas de Funções ✅ Implementado (IDA 6.6)

**O que é:** Tipo de retorno, parâmetros com nome e tipo, calling convention (`__cdecl`, `__stdcall`, `__fastcall`), tipo `void*`, tamanho de cada parâmetro.

**Para que serve:** Assinatura completa da função. Permite ao frontend mostrar "`int sub_1000(HWND hWnd, LPCSTR lpText)`" em vez de só o nome.

**Implementação:** `idc.GetType(ea)` + fallback `idc.GuessType(ea)` no `extract.py` (IDA 6.6) → campo `FunctionResult.signature` (string de declaração C) → coluna `signature` existente em `static_function` → exposto via `FunctionDetailResponse.signature` → incluído no chunk de embedding (`Signature: ...`) e no `ChatContextBuilder`. Sem Hex-Rays necessário — APIs core do IDA.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | Suporte a tipos muito limitado. `GetType()` pode retornar string, mas raramente populado. | ❌ **Não viável** |
| IDA 6.6 | `ida_typeinf.get_tinfo(ea)` e `ida_typeinf.print_tinfo(tif, ...)` disponíveis via IDAPython. Suporte a tipos é mais maduro que IDA 5. | ✅ Médio |
| IDA 7 | `ida_typeinf.get_tinfo(ea)`, `ida_typeinf.print_tinfo()` | ✅ Médio |
| Ghidra | `function.getReturnType()`, `function.getParameters()`, `function.getSignature()` | ✅ Fácil |

---

## 15. Estruturas e Enums ✅ Implementado (IDA 6.6)

**O que é:** Layout de structs e enums reconhecidos pelo disassembler, com nomes de campos e tipos.

**Para que serve:** Entender estruturas de dados usadas pelo binário. Ex: mostrar que `[ebp+8]` acessa `struct Player.name`.

**Implementação:** `idc.GetFirstStrucIdx()`/`GetNextStrucIdx()` + `idc.GetFirstMember()`/`GetStrucNextOff()` no `extract.py` (IDA 6.6) para estruturas. `idc.GetEnumQty()`/`GetnEnum()` + `GetFirstConst()`/`GetNextConst()` para enums → `StructEntry(name, size, isUnion, members)` + `EnumEntry(name, width, constants)` → tabelas `static_struct` e `static_enum` → exposto via `GET /analysis/{id}/structures` e `GET /analysis/{id}/enums` → chunks de embedding individuais (`[STRUCT]`, `[ENUM]`) e top-20 de cada no chunk `METADATA`. Tipos de membros via `GetMemberFlag()` mascarados por `0xF0000000` (BYTE, WORD, DWORD, STRUCT aninhado...).

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `GetStrucId()`, `GetStrucName()` — API existe mas tipos raramente aplicados pelo IDA 5 | ❌ **Não viável** |
| IDA 6.6 | `ida_struct.get_struc_list()` e `ida_typeinf` disponíveis. Depende da qualidade da análise de tipos do IDA. | ⚠️ Limitado (depende da análise do IDA) |
| IDA 7 | `ida_struct.get_struc_list()`, `ida_typeinf` para tipos locais | ⚠️ Limitado (depende da análise do IDA) |
| Ghidra | `program.getDataTypeManager().getAllStructures()` | ✅ Médio |

---

## 16. Decompilação (Pseudocódigo)

**O que é:** Código de alto nível reconstruído a partir do assembly — `if/else`, `while`, chamadas de função com nomes de parâmetros.

**Para que serve:** Leitura muito mais rápida do que assembly. É o principal diferencial do Ghidra e IDA 6.6+ sobre o IDA 5.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | Não tem decompiler (Hex-Rays só a partir do IDA 6.6+) | ❌ **Não existe** |
| IDA 6.6 | `ida_hexrays.decompile(ea)` retorna AST, `cfunc.print()` gera string. Plugin `hexrays.plw` incluso na engine. | ✅ Fácil (requer licença Hex-Rays) |
| IDA 7 | `ida_hexrays.decompile(ea)` retorna AST, `cfunc.print()` gera string | ✅ Fácil (requer licença Hex-Rays) |
| Ghidra | `decompInterface.decompileFunction(function, timeout, monitor)` → `decompResults.getDecompiledFunction().getC()` | ✅ Fácil (nativo e gratuito) |

---

## 17. Call Graph / Control Flow Graph (CFG) ✅ Implementado (IDA 6.6)

**O que é:** Grafo direcionado de blocos básicos dentro de cada função (CFG) com arestas representando branches condicionais e incondicionais.

**Para que serve:** Visualização gráfica do fluxo de controle da função. O frontend pode renderizar um grafo interativo de blocos e arestas (jumps, fall-throughs, retornos).

**Implementação:** `idaapi.FlowChart(idaapi.get_func(ea), flags=FC_PREDS)` no `extract.py` (IDA 6.6) → array JSON de `{id, start, end, type, succs, preds}` armazenado como string JSON no campo `FunctionResult.cfgBlocks` → coluna `cfg_blocks TEXT` em `static_function` → exposto como `List<CfgBlockResponse>` no `FunctionDetailResponse` → incluído nos chunks de embedding (`[CFG]`) e no `ChatContextBuilder`. Tipos de bloco: `fcb_normal` (0), `fcb_indjump`, `fcb_ret`, `fcb_cndret`, `fcb_noret`, `fcb_enoret`, `fcb_extern`, `fcb_error`.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | `GetFchunkAttr(ea, FUNCATTR_START)` e iteração sobre chunks. `FlowChart` não disponível no IDC 5. | ⚠️ Limitado (possível via chunks) |
| IDA 6.6 | `ida_gdl.FlowChart(f)` disponível via IDAPython, retorna nós e arestas. `idautils.Chunks(ea)` para iteração over function chunks. | ✅ Médio |
| IDA 7 | `ida_gdl.FlowChart(f)` retorna nós e arestas; `ida_gdl.gen_flow_graph()` | ✅ Médio |
| Ghidra | `BasicBlockModel` + iteração sobre `function.getBody()` → blocos, `function.getCalledFunctions()` → call graph | ✅ Médio |

---

## 18. Nomes de Variáveis Globais ✅ Implementado (IDA 6.6)

**O que é:** Labels/names atribuídos a endereços de dados globais (ex: `g_score`, `aHelloWorld`).

**Para que serve:** Dar significado a acessos de memória. Transforma `mov eax, dword_403000` em `mov eax, g_score`.

**Implementação:** `idautils.Names()` + `idc.isData(idc.GetFlags(ea))` no `extract.py` (IDA 6.6) → `GlobalVarEntry(name, address, segment, size, dataXrefs)` → tabela `static_data_label` com FK para `static_analysis` → exposto via `GET /analysis/{id}/global-vars` com data xrefs inline → chunks de embedding individuais (`[GLOBAL VAR] name at 0xADDR (segment, size)`) e top-30 globais incluídos no chunk `METADATA`. Data xrefs (item 13) embutidos no campo `dataXrefs` com tipo de acesso (READ/WRITE/OFFSET/TEXT) por instrução.

| Engine | API | Viabilidade |
|--------|-----|:-----------:|
| IDA 5 | Iterar segmentos de dados e usar `Name(ea)` + `isData(GetFlags(ea))` | ✅ Médio |
| IDA 6.6 | `ida_name.get_name_list()` disponível via IDAPython; `ida_bytes.is_data(ida_bytes.get_flags(ea))` para filtrar labels de dados | ✅ Fácil |
| IDA 7 | `ida_name.get_name_list()`, `ida_bytes.is_data()` | ✅ Fácil |
| Ghidra | `program.getSymbolTable().getGlobalSymbols()`, `listing.getDataAt()` | ✅ Fácil |

---

## Prioridades Recomendadas

1. ✅ ~~Entry point + Tipo de xref + Flags~~ — **concluído**, baixo esforço, alto valor, fecha o básico
2. ✅ ~~Strings~~ — **concluído (IDA 6.6)**, baixo/médio esforço (via IDAPython), altíssimo valor para entendimento do binário
3. ✅ ~~Imports~~ — **concluído (IDA 6.6)**, esforço médio (via IDAPython), altíssimo valor para entendimento do binário
4. ✅ ~~Segmentos + Tamanho da função~~ — **concluído**, baixo esforço, enriquece o contexto
5. **Decompilação** (IDA 6.6/IDA 7/Ghidra) — esforço médio, é o grande diferencial
6. ✅ ~~Frame + Comentários~~ — **concluído (IDA 6.6)**, enriquece a visualização de cada função
7. ✅ ~~Global Vars + Data Xrefs~~ — **concluído (IDA 6.6)**, baixo/médio esforço, completa o mapa de dados
8. ✅ ~~Tipos e Assinaturas~~ — **concluído (IDA 6.6)**, esforço baixo, enriquece a visualização de cada função
9. ✅ ~~CFG~~ — **concluído (IDA 6.6)**, esforço médio, habilita visualização gráfica no frontend
10. ✅ ~~Estruturas e Enums~~ — **concluído (IDA 6.6)**, esforço médio, completa o mapa de tipos
