Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
cfgrip — Desensambla binarios PE/ELF x86/x64, resuelve ramas indirectas a través de GOT, tablas de saltos y rastreo de registros, y exporta el grafo de flujo de control completo como JSON estructurado para análisis estático y parcheo. | Kitploit
Herramientas/GitLabGitLab/binaryhardening/cfgrip
Análisis EstáticoIngeniería InversaDepuradoresAnálisis de Binarios
GitLabbinaryhardening/cfgrip

cfgrip

Desensambla binarios PE/ELF x86/x64, resuelve ramas indirectas a través de GOT, tablas de saltos y rastreo de registros, y exporta el grafo de flujo de control completo como JSON estructurado para análisis estático y parcheo.

Ver Repositorio
24hace 1 mesAún no revisado

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Sitio web
Compartir

cfgrip

Extractor de CFG para PE/ELF x86/x64. Toma un binario, lo desensambla, resuelve cada salto y llamada (GOT, tablas de saltos, trazado de registros), y exporta el grafo de flujo de control completo como JSON estructurado.

por qué

Necesitas saber exactamente a dónde va cada rama. No para leer — para parchar. Alimenta el JSON en Zydis o AsmJit, localiza la instrucción exacta que necesitas enganchar o modificar, y escribe de vuelta. Los equipos anti-trampas lo usan para mapear binarios de juegos. Los analistas de RE lo usan para elevar código a sus propios pipelines de análisis. Los analistas de software trazan rutas de ejecución sin ejecutar el binario.

cfgrip te da el mapa. Lo que hagas con él depende de ti.

qué extrae

Para cada binario que cfgrip procesa, produce:

  • Lista de funciones con direcciones, dirección final opcional (desde .pdata), nombres (punto de entrada, exportaciones, descubiertas), y etiquetado de thunk (stubs PLT)
  • Bloques básicos por función — secuencias de instrucciones terminadas por ramas, llamadas, retornos o trampas
  • Aristas de flujo de control — sucesores de cada bloque (ramas directas, caída, destinos indirectos)
  • Tabla de importaciones — importaciones de bibliotecas resueltas con direcciones
  • Destinos indirectos — llamadas resueltas por GOT, entradas de tabla de saltos, ramas con trazado de registros, y las no resueltas (marcadas como tales)
  • Límites de funciones — múltiples pasadas de detección (patrones de prólogo, destinos de llamada, llamadas de cola, entradas .pdata, punteros a funciones en sección de datos) para máxima cobertura

Con --clean, adicionalmente:

  • Encadena saltos de jmp → jmp en aristas directas
  • Poda bloques básicos muertos (sin aristas entrantes)
  • Anota cada instrucción con stack_offset (delta de RSP desde la entrada de la función)
  • Construye una sección xrefs que mapea cada destino de llamada/salto de vuelta a sus llamantes

Maneja ramas indirectas mediante:

  1. Revisando la GOT (Tabla de Desplazamiento Global) para importaciones conocidas
  2. Escaneando hacia atrás en busca de instrucciones LEA para localizar tablas de saltos, luego leyendo las entradas de la tabla
  3. Trazando registros hacia atrás a través de cadenas mov/lea para encontrar direcciones concretas

uso

root@kitploit:~
cfgrip [--subs-only] [--clean] <binary>

Aliméntalo con un binario, obtén <binary>.cfg como salida.
Usa --subs-only para extraer solo funciones alcanzables desde el punto de entrada a través del grafo de llamadas — omite exportaciones no alcanzables y candidatos de prólogo.
Usa --clean para aplicar encadenamiento de saltos, poda de bloques muertos, seguimiento de desplazamientos de pila y análisis de referencias cruzadas.

Ejemplo:

root@kitploit:~
cfgrip.exe tests\example1.exe
format: PE
arch: x86-64
entry: 0x1400054bc
imports: 85
  0x140020000 EncodePointer (KERNEL32.dll)
  0x140020008 DecodePointer (KERNEL32.dll)
  0x140020010 EnterCriticalSection (KERNEL32.dll)
  0x140020018 LeaveCriticalSection (KERNEL32.dll)
  0x140020020 InitializeCriticalSectionEx (KERNEL32.dll)
  0x140020028 DeleteCriticalSection (KERNEL32.dll)
  0x140020030 MultiByteToWideChar (KERNEL32.dll)
  0x140020038 WideCharToMultiByte (KERNEL32.dll)
  0x140020040 LCMapStringEx (KERNEL32.dll)
  0x140020048 GetStringTypeW (KERNEL32.dll)
  0x140020050 GetCPInfo (KERNEL32.dll)
  0x140020058 RtlCaptureContext (KERNEL32.dll)
  0x140020060 RtlLookupFunctionEntry (KERNEL32.dll)
  0x140020068 RtlVirtualUnwind (KERNEL32.dll)
  0x140020070 UnhandledExceptionFilter (KERNEL32.dll)
  0x140020078 SetUnhandledExceptionFilter (KERNEL32.dll)
  0x140020080 GetCurrentProcess (KERNEL32.dll)
  0x140020088 TerminateProcess (KERNEL32.dll)
  0x140020090 IsProcessorFeaturePresent (KERNEL32.dll)
  0x140020098 QueryPerformanceCounter (KERNEL32.dll)
  0x1400200a0 GetCurrentProcessId (KERNEL32.dll)
  0x1400200a8 GetCurrentThreadId (KERNEL32.dll)
  0x1400200b0 GetSystemTimeAsFileTime (KERNEL32.dll)
  0x1400200b8 InitializeSListHead (KERNEL32.dll)
  0x1400200c0 IsDebuggerPresent (KERNEL32.dll)
  0x1400200c8 GetStartupInfoW (KERNEL32.dll)
  0x1400200d0 GetModuleHandleW (KERNEL32.dll)
  0x1400200d8 WriteConsoleW (KERNEL32.dll)
  0x1400200e0 RtlPcToFileHeader (KERNEL32.dll)
  0x1400200e8 RaiseException (KERNEL32.dll)
  0x1400200f0 RtlUnwindEx (KERNEL32.dll)
  0x1400200f8 GetLastError (KERNEL32.dll)
  0x140020100 SetLastError (KERNEL32.dll)
  0x140020108 InitializeCriticalSectionAndSpinCount (KERNEL32.dll)
  0x140020110 TlsAlloc (KERNEL32.dll)
  0x140020118 TlsGetValue (KERNEL32.dll)
  0x140020120 TlsSetValue (KERNEL32.dll)
  0x140020128 TlsFree (KERNEL32.dll)
  0x140020130 FreeLibrary (KERNEL32.dll)
  0x140020138 GetProcAddress (KERNEL32.dll)
  0x140020140 LoadLibraryExW (KERNEL32.dll)
  0x140020148 GetStdHandle (KERNEL32.dll)
  0x140020150 WriteFile (KERNEL32.dll)
  0x140020158 GetModuleFileNameW (KERNEL32.dll)
  0x140020160 ExitProcess (KERNEL32.dll)
  0x140020168 GetModuleHandleExW (KERNEL32.dll)
  0x140020170 GetCommandLineA (KERNEL32.dll)
  0x140020178 GetCommandLineW (KERNEL32.dll)
  0x140020180 HeapAlloc (KERNEL32.dll)
  0x140020188 HeapFree (KERNEL32.dll)
  0x140020190 FlsAlloc (KERNEL32.dll)
  0x140020198 FlsGetValue (KERNEL32.dll)
  0x1400201a0 FlsSetValue (KERNEL32.dll)
  0x1400201a8 FlsFree (KERNEL32.dll)
  0x1400201b0 VirtualProtect (KERNEL32.dll)
  0x1400201b8 CompareStringW (KERNEL32.dll)
  0x1400201c0 LCMapStringW (KERNEL32.dll)
  0x1400201c8 GetLocaleInfoW (KERNEL32.dll)
  0x1400201d0 IsValidLocale (KERNEL32.dll)
  0x1400201d8 GetUserDefaultLCID (KERNEL32.dll)
  0x1400201e0 EnumSystemLocalesW (KERNEL32.dll)
  0x1400201e8 GetFileType (KERNEL32.dll)
  0x1400201f0 CloseHandle (KERNEL32.dll)
  0x1400201f8 FlushFileBuffers (KERNEL32.dll)
  0x140020200 GetConsoleOutputCP (KERNEL32.dll)
  0x140020208 GetConsoleMode (KERNEL32.dll)
  0x140020210 ReadFile (KERNEL32.dll)
  0x140020218 GetFileSizeEx (KERNEL32.dll)
  0x140020220 SetFilePointerEx (KERNEL32.dll)
  0x140020228 ReadConsoleW (KERNEL32.dll)
  0x140020230 HeapReAlloc (KERNEL32.dll)
  0x140020238 FindClose (KERNEL32.dll)
  0x140020240 FindFirstFileExW (KERNEL32.dll)
  0x140020248 FindNextFileW (KERNEL32.dll)
  0x140020250 IsValidCodePage (KERNEL32.dll)
  0x140020258 GetACP (KERNEL32.dll)
  0x140020260 GetOEMCP (KERNEL32.dll)
  0x140020268 GetEnvironmentStringsW (KERNEL32.dll)
  0x140020270 FreeEnvironmentStringsW (KERNEL32.dll)
  0x140020278 SetEnvironmentVariableW (KERNEL32.dll)
  0x140020280 SetStdHandle (KERNEL32.dll)
  0x140020288 GetProcessHeap (KERNEL32.dll)
  0x140020290 HeapSize (KERNEL32.dll)
  0x140020298 CreateFileW (KERNEL32.dll)
  0x1400202a0 RtlUnwind (KERNEL32.dll)
functions: 1975
indirect targets: 3453
cfg written to: tests\example1.exe.cfg

el formato de salida

El archivo .cfg es JSON estructurado. Esto es lo que parece:

root@kitploit:~
{
  "binary": "tests\\example1.exe",
  "mode": "full",
  "arch": "x86-64",
  "format": "PE",
  "entry_point": "0x1400054bc",
  "imports": [
    {
      "address": "0x140020000",
      "name": "EncodePointer",
      "library": "KERNEL32.dll"
    },
    {
      "address": "0x140020008",
      "name": "DecodePointer",
      "library": "KERNEL32.dll"
    },
    {
      "address": "0x140020010",
      "name": "EnterCriticalSection",
      "library": "KERNEL32.dll"
    },
    {
      "address": "0x140020018",
      "name": "LeaveCriticalSection",
      "library": "KERNEL32.dll"
    },
    {
      "address": "0x140020020",
      "name": "InitializeCriticalSectionEx",
      "library": "KERNEL32.dll"
    },
    ...
    ...
    ...
  "functions": [
    {
      "address": "0x1400054bc",
      "name": "entry",
      "blocks": [
        {
          "address": "0x1400054bc",
          "size": 4,
          "is_prolog": false,
          "is_epilog": false,
          "instructions": [
            {
              "address": "0x1400054bc",
              "size": 4,
              "mnemonic": "sub",
              "operands": "rsp, 0x28"
            },
            {
              "address": "0x1400054c0",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x140005d30"
            },
            {
              "address": "0x1400054c5",
              "size": 4,
              "mnemonic": "add",
              "operands": "rsp, 0x28"
            },
            {
              "address": "0x1400054c9",
              "size": 5,
              "mnemonic": "jmp",
              "operands": "0x140005340"
            }
          ],
          "successors": [
            "0x140005340"
          ]
        },
        {
          "address": "0x140005340",
          "size": 8,
          "is_prolog": false,
          "is_epilog": false,
          "instructions": [
            {
              "address": "0x140005340",
              "size": 5,
              "mnemonic": "mov",
              "operands": "qword ptr [rsp + 8], rbx"
            },
            {
              "address": "0x140005345",
              "size": 5,
              "mnemonic": "mov",
              "operands": "qword ptr [rsp + 0x10], rsi"
            },
            {
              "address": "0x14000534a",
              "size": 1,
              "mnemonic": "push",
              "operands": "rdi"
            },
            {
              "address": "0x14000534b",
              "size": 4,
              "mnemonic": "sub",
              "operands": "rsp, 0x30"
            },
            {
              "address": "0x14000534f",
              "size": 5,
              "mnemonic": "mov",
              "operands": "ecx, 1"
            },
            {
              "address": "0x140005354",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x14000550c"
            },
            {
              "address": "0x140005359",
              "size": 2,
              "mnemonic": "test",
              "operands": "al, al"
            },
            {
              "address": "0x14000535b",
              "size": 6,
              "mnemonic": "je",
              "operands": "0x140005497"
            }
          ],
          "successors": [
            "0x140005497",
            "0x140005361"
          ]
        },
        {
          "address": "0x140005497",
          "size": 15,
          "is_prolog": false,
          "is_epilog": false,
          "instructions": [
            {
              "address": "0x140005497",
              "size": 5,
              "mnemonic": "mov",
              "operands": "ecx, 7"
            },
            {
              "address": "0x14000549c",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x140005e44"
            },
            {
              "address": "0x1400054a1",
              "size": 1,
              "mnemonic": "nop",
              "operands": ""
            },
            {
              "address": "0x1400054a2",
              "size": 5,
              "mnemonic": "mov",
              "operands": "ecx, 7"
            },
            {
              "address": "0x1400054a7",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x140005e44"
            },
            {
              "address": "0x1400054ac",
              "size": 2,
              "mnemonic": "mov",
              "operands": "ecx, ebx"
            },
            {
              "address": "0x1400054ae",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x14000ec14"
            },
            {
              "address": "0x1400054b3",
              "size": 1,
              "mnemonic": "nop",
              "operands": ""
            },
            {
              "address": "0x1400054b4",
              "size": 2,
              "mnemonic": "mov",
              "operands": "ecx, ebx"
            },
            {
              "address": "0x1400054b6",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x14000ebcc"
            },
            {
              "address": "0x1400054bb",
              "size": 1,
              "mnemonic": "nop",
              "operands": ""
            },
            {
              "address": "0x1400054bc",
              "size": 4,
              "mnemonic": "sub",
              "operands": "rsp, 0x28"
            },
            {
              "address": "0x1400054c0",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x140005d30"
            },
            {
              "address": "0x1400054c5",
              "size": 4,
              "mnemonic": "add",
              "operands": "rsp, 0x28"
            },
            {
              "address": "0x1400054c9",
              "size": 5,
              "mnemonic": "jmp",
              "operands": "0x140005340"
            }
          ],
          "successors": [
            "0x140005340"
          ]
        },
        ...
        ...
        ...

Cada función ahora incluye campos opcionales:

  • end_address — final preciso de la función cuando esté disponible (desde la tabla de excepciones .pdata de PE), de lo contrario se calcula como la dirección de instrucción máxima entre todos los bloques
  • is_thunk — true para stubs PLT y thunks de importación (funciones que solo redirigen a otra dirección)

Salida de --subs-only

root@kitploit:~
{
  "binary": "C:\\binaries\\target.exe",
  "mode": "subs-only",
  "arch": "x86-64",
  "format": "PE",
  "entry_point": "0x1400054bc",
  "imports": [ ... ],
  "indirect_targets": [ ... ],
  "functions": [
    {
      "address": "0x1400054bc",
      "name": "entry",
      "blocks": [ ... ]
    },
    ...
  ]
}

El campo "mode": "subs-only" indica a las herramientas posteriores que este CFG solo contiene funciones alcanzables desde el punto de entrada. Las exportaciones no alcanzables y los candidatos de prólogo se excluyen — menos funciones, superficie de análisis más limpia.

Salida de --clean

root@kitploit:~
{
  "binary": "C:\\binaries\\target.exe",
  "mode": "full+clean",
  "arch": "x86-64",
  "format": "PE",
  "entry_point": "0x1400054bc",
  "imports": [ ... ],
  "indirect_targets": [ ... ],
  "functions": [
    {
      "address": "0x1400054bc",
      "name": "entry",
      "blocks": [
        {
          "address": "0x1400054bc",
          "size": 4,
          "is_prolog": false,
          "is_epilog": false,
          "instructions": [
            {
              "address": "0x1400054bc",
              "size": 4,
              "mnemonic": "sub",
              "operands": "rsp, 0x28",
              "stack_offset": 0
            },
            {
              "address": "0x1400054c0",
              "size": 5,
              "mnemonic": "call",
              "operands": "0x140005d30",
              "stack_offset": -40
            },
            {
              "address": "0x1400054c5",
              "size": 4,
              "mnemonic": "add",
              "operands": "rsp, 0x28",
              "stack_offset": -40
            },
            {
              "address": "0x1400054c9",
              "size": 5,
              "mnemonic": "jmp",
              "operands": "0x140005340",
              "stack_offset": 0
            }
          ],
          "successors": [ "0x140005340" ]
        },
        ...
      ]
    },
    ...
  ],
  "xrefs": [
    {
      "target": "0x140011b00",
      "callers": [
        { "address": "0x14001a30f", "type": "call" },
        { "address": "0x140019ec1", "type": "call" },
        ...
      ]
    },
    {
      "target": "0x140007394",
      "callers": [
        { "address": "0x14001a31a", "type": "call" },
        ...
      ]
    },
    ...
  ]
}

Cada instrucción en el modo --clean incluye stack_offset — el delta de RSP desde la entrada de la función en ese punto de instrucción. La sección xrefs mapea cada destino de llamada/salto de vuelta a cada instrucción que lo referencia.

Salida combinada de --subs-only --clean

root@kitploit:~
{
  "binary": "C:\\binaries\\target.exe",
  "mode": "subs-only+clean",
  ...
}

Misma estructura que --clean, pero con "mode": "subs-only+clean" para indicar que se aplicaron ambos filtros. El recuento de funciones se reduce solo a funciones alcanzables desde el punto de entrada, y las funciones restantes tienen desplazamientos de pila y referencias cruzadas.

detección de límites de funciones

cfgrip descubre funciones mediante múltiples pasadas de detección:

PaseQué detectaCubre
Escaneo de prólogopush rbp, push r15/r14/r13/r12/rbx/rdi/rsi, sub rsp, >=0x20, enterMSVC x64, GCC, funciones hoja, CET (endbr64)
Destinos de llamadaCada destino de instrucción call es un inicio de funciónLlamadas directas e indirectas resueltas por GOT
Llamadas de colaInstrucciones jmp que apuntan a candidatos de prólogoCadenas de llamadas de cola optimizadas
.pdata (PE)Entradas de función de tiempo de ejecución desde la tabla de manejadores de excepcionesInicio/fin preciso para cada función x64 PE
Punteros de datosValores de 8 bytes en .rdata/.data que apuntan a código ejecutablePunteros a funciones, tablas virtuales, callbacks

Las funciones con is_thunk: true son stubs PLT o thunks de importación — funciones de un solo bloque que redirigen a otra dirección.

compilación

Requiere CMake y un compilador C++17. Capstone se obtiene automáticamente.

root@kitploit:~
cmake -B build
cmake --build build --config Release
./build/cfgrip <binary>

O en Windows con Visual Studio:

root@kitploit:~
cmake -B build -S .
cmake --build build --config Release
.\build\Release\cfgrip.exe <binary>

alt text alt text

qué soporta

FormatosPE (32/64 bits)YES
ELF (64 bits)YES
Arquitecturasx86YES
x86-64YES
Llamadas indirectasResolución GOTYES
Detección de tablas de saltosYES
Trazado de registros hacia atrásYES
Descubrimiento de funcionesPunto de entradaYES
ExportacionesYES
Destinos callYES
Escaneo de prólogo (MSVC x64, GCC, CET endbr64)YES
Detección de llamadas de cola (jmp → función)YES
PE .pdata (tabla de manejadores de excepciones)YES
Escaneo de punteros a funciones en sección de datosYES
Detección de thunksStubs PLT / thunks de importación (is_thunk)YES
Límites de funcionesend_address desde .pdata o instrucción máximaYES
Modo solo subfuncionesIndicador --subs-onlyYES
Limpieza de CFG--clean (encadenamiento de saltos, poda de bloques muertos, deltas de pila, referencias cruzadas)YES

investigación

La detección de límites de funciones en esta herramienta se basa en el enfoque descrito en "Function Boundary Detection in Stripped Binaries" (Alves-Foss & Song, 2019), que introduce un algoritmo multiheurístico para localizar inicios y fines de funciones en binarios despojados x86/x64.

El artículo está disponible en papers/Function_Boundary_Detection_in_Stripped_Binaries.pdf.

Cómo se mapea nuestra implementación con las heurísticas del artículo:

HeurísticaDescripción del artículoNuestra implementación
H1–H4Firmas de prólogo (push rbp, registros preservados por callee, sub de pila, enter)isProlog() en disasm/engine.cpp — detecta push rbp, push r15..rbx, sub rsp >= 0x20, enter
H5Siembra de destinos de llamadaCada destino directo de call es un inicio de función
H6Detección de salto-a-función (llamada de cola)jmp a candidatos de prólogo añade el destino a la cola de funciones
H7Análisis de tabla de excepcionesLas entradas RUNTIME_FUNCTION de PE .pdata dan inicio/fin precisos
H8Análisis de referencias de datosscanDataPointers() recorre secciones de datos en busca de punteros a código

La idea clave del artículo es que las heurísticas algorítmicas — sin aprendizaje automático — pueden lograr alta precisión en binarios despojados. Nuestra implementación sigue esta filosofía, utilizando un enfoque de múltiples pasadas donde cada pasada captura funciones que las otras podrían pasar por alto.

Descargar herramienta