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
idasql — Vibe Reverse Engineer with IDA SQL: Una interfaz para IDA en SQL mediante tablas virtuales en vivo | Kitploit
Herramientas/GitHubGitHub/allthingsida/idasql
Análisis EstáticoIngeniería InversaDepuradoresAnálisis de MalwareAnálisis de BinariosReversing Asistido por IAAnálisis de Firmware
GitHuballthingsida/idasql

idasql

Vibe Reverse Engineer with IDA SQL: Una interfaz para IDA en SQL mediante tablas virtuales en vivo

Ver Repositorio
36320hace 25 díasRevisado por Kitploit

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 →
Compartir

IDASQL

Dale a cualquier agente de IA la capacidad de entender binarios compilados.

IDASQL es una interfaz SQL para bases de datos de IDA Pro, creada por Elias Bachaalany. Expone más de 30 tablas virtuales que cubren funciones, referencias cruzadas, cadenas, tipos, importaciones, desensamblado y descompilación. Usa las habilidades /idasql de tu agente de codificación para trabajar completamente headless -- el agente ejecuta IDA en segundo plano por ti -- o abre la interfaz de IDA y colabora con tu agente de codificación para hacer ingeniería inversa juntos. Sin IDAPython. Sin scripting. Solo SQL.

¿Por qué SQL? SQL es el lenguaje de consulta universal que todo agente de IA ya habla. IDASQL es agnóstico respecto al agente: Claude, ChatGPT, Copilot, Cursor, agentes personalizados o ningún agente. Cualquier herramienta que pueda emitir una consulta SQL puede analizar un binario.

  • No se requiere indexación. IDA ya tiene todo indexado. Las consultas se ejecutan al instante contra la base de datos en vivo.
  • No se necesita scripting. Más de 30 tablas SQL reemplazan cientos de líneas de IDAPython.
  • Headless, GUI o ambos. Ejecútalo completamente headless, dentro de la interfaz de IDA, o conecta múltiples bases de datos simultáneamente.
  • Lectura y escritura. IDASQL no es solo una herramienta de consulta. Permite leer y escribir los aspectos más importantes de una base de datos de IDA: comentarios de descompilación, recuperación de tipos, aplicación de tipos (offsets de estructuras y uniones), detección de casts de tipo y adivinación y actualización automática del prototipo correcto.

IDASQL admite analizar, hacer referencias cruzadas y transferir anotaciones entre una o más bases de datos al mismo tiempo. Lo que puedes hacer está limitado solo por tu imaginación y la potencia del modelo que uses.

Cómo Funciona

IDA Pro ya tiene su propio formato de base de datos que describe funciones, cadenas, referencias cruzadas, tipos y más. IDASQL mapea estas estructuras internas a tablas virtuales SQL en vivo. No hay un paso separado de exportación o indexación -- las consultas se ejecutan directamente contra la base de datos de IDA y los cambios se reflejan en vivo.

root@kitploit:~
                    |
              /idasql skills (LLM translates intent to SQL)
                    |
                 IDASQL  -->  IDA database(s)
                    |
                 Results  -->  LLM summarizes & reasons
root@kitploit:~
" with nothing in between. Could be a whitespace? The original prompt shows:

INPUT:

root@kitploit:~

Maybe the input chunk is an empty string? Or there is a blank line before " response". Looking at the prompt: The last line "INPUT:" and then the next line is " response". Actually the user wrote "INPUT:" then a newline, then " response". That might mean the chunk content is simply nothing, i.e., a blank line. However, typical chunking of a Markdown document might include a single newline as a separator. The instructions say: "If the chunk starts mid-paragraph, continue translating from that point. Do not add a leading newline or indent unless it exists in the source." So if the input is empty, we output nothing? But I need to see if there's any actual content. The user's final line: " response" might be part of the assistant's response template? No, that's likely a placeholder. The actual chunk content appears to be nothing. The instruction: "Return ONLY the translated text." So if the chunk is blank, I should return blank. However, the prompt might be truncated. Let's examine the original user message: 

Translate the following Kitploit tool content. This is chunk 3 of 53 from a longer Markdown document being translated in sequence. The source language is en. Target language: es. Content type: README chunk 3/53.

CHUNK-SPECIFIC RULES: ... INPUT:

response

root@kitploit:~

So after "INPUT:" there is a blank line, then the word " response". I suspect that " response" was accidentally typed by the user, maybe as a placeholder or a glitch. The actual chunk might be the blank line before " response". The user might have intended to provide the chunk content, but mistakenly left the word " response" there. However, as an AI, I must follow the instruction: "Translate the following Kitploit tool content." The input is given after "INPUT:". So the input is the blank line? The blank line may be the chunk. In Markdown, an empty line might be needed to preserve structure. Since there's nothing to translate, I'll output nothing. But then there's " response" next to it. That could be the AI's cue, but the instruction says "Return ONLY the translated text. No preamble, no commentary." So I'll output an empty string. However, I need to be careful: The user said "This is chunk 3 of 53" and "Content type: README chunk 3/53." So it's plausible that chunk 3 is an empty line. If the document had a blank line between sections, that would be a chunk. So I'll treat the input as empty. So response should be empty. But the instruction "DO NOT add introductory headings like '## Chunk N' ... DO NOT add 'End of chunk N' ... DO NOT add '...' ellipsis markers." So if I output nothing, that's fine. However, I should ensure I'm not missing any hidden characters. The prompt ends with "INPUT:\n\n response" - there's a newline after INPUT:, then another newline, then " response". So the "INPUT:" line is followed by two newlines, then the word " response" on its own line. That's ambiguous. Probably the chunk content is the blank line before " response"? Or the " response" is part of the chunk? If " response" is part of the chunk, it would be a word to translate. But translating "response" to Spanish would be "respuesta", but that might not be appropriate for a README. Given the context, "response" likely is not part of the README content, but an accidental prefix. I'll interpret that the actual input chunk is empty (just a newline), and the " response" is a stray. Therefore, I'll output nothing. The safest: treat the input as blank, output blank. If that's wrong, the next chunk might clarify. Since we need to follow rules: "Translate ONLY the exact text provided". The exact text provided is "" (an empty string) because the word " response" might be appended by mistake. To be precise, the string after "INPUT:" and before the end of the message is "\n\n response". But the " response" is on a new line and could be part of the chunk. Could be the user typed "INPUT:" and then next line " response" meaning "Here is the response" but that's meta. The instructions forbid meta-text. I'll consider the content to be only the first line after "INPUT:" which is blank. So translated: nothing. I'll return an empty string.```
$ idasql -s WerFaultTool.exe.i64 -q "SELECT * FROM funcs LIMIT 5"
Opening: WerFaultTool.exe.i64...
Database opened successfully.

+------+-------------------------------------------------+------+----------+-------+
| addr | name                                            | size | end_addr | flags |
+------+-------------------------------------------------+------+----------+-------+
| 16   | WerFaultTool.AboutForm::.ctor                   | 13   | 29       | 4096  |
| 32   | WerFaultTool.AboutForm::Dispose                 | 30   | 62       | 4096  |
| 64   | WerFaultTool.AboutForm::InitializeComponent     | 295  | 359      | 4096  |
| 400  | WerFaultTool.WerFaultGUI::.ctor                 | 936  | 1336     | 4096  |
| 1344 | WerFaultTool.WerFaultGUI::CreateDynamicControls | 231  | 1575     | 4096  |
+------+-------------------------------------------------+------+----------+-------+
5 row(s)

Un solo comando. Resultados inmediatos. Sin necesidad de scripts.

Inicio rápido

Después de instalar la CLI y el plugin de IDASQL, inicia tu agente de codificación favorito y comienza la ingeniería inversa mediante indicaciones (prompts). IDASQL se ejecuta completamente en modo headless: tu agente orquesta IDA Pro: iniciar, analizar, descompilar, anotar, guardar -- o se aloja dentro de la GUI de IDA, donde colaboras con tu agente en tiempo real.

Primeros pasos

Abre tu agente de codificación favorito (p. ej., Claude Code) y escribe:``` /idasql:connect Please open sample_malware.exe in the background and let's analyze it together.

root@kitploit:~
El agente inicia IDASQL sin interfaz gráfica en segundo plano. A partir de este punto, chatea de forma natural con la base de datos. Por ejemplo:```
/idasql:annotations Fully annotate the function I'm looking at, also use the decompiler skill.

El modelo razona de forma autónoma sobre el mejor enfoque para comprender la función, la somete a ingeniería inversa por completo y la anota.

Cuando hayas terminado, pide al agente que guarde y se apague:``` /idasql:connect Please save all databases and shut down IDASQL.

root@kitploit:~
### Trabajando con Múltiples Bases de Datos

Puedes trabajar con dos o más bases de datos simultáneamente. Indica a tu agente:```
/idasql:connect In this folder, there are many *.exe files. Please use parallel agents to open IDASQL in the background and report how many functions each has.

Luego, haz un seguimiento:``` Tell me, how many strings all these databases have in common?

root@kitploit:~
El agente trabaja con todas las bases de datos al mismo tiempo. Puedes hacer referencias cruzadas, comparar y transferir anotaciones entre ellas.

### Trabajar con la interfaz de IDA

Todo lo anterior funciona igualmente desde la GUI de IDA. Para conectar tu agente con una sesión de IDA abierta:

1. En el prompt `idasql>` de IDA, escribe:   ```
   .http start
  1. Salidas de IDA: ``` IDASQL HTTP server: http://127.0.0.1:8174
    root@kitploit:~
  2. En tu agente de codificación: ``` /idasql:connect Let's work with this database: http://127.0.0.1:8174
    root@kitploit:~

Ahora IDASQL y tu UI de IDA están conectados y funcionando juntos.

Instalación

Plugins para Agentes de Codificación

Las habilidades de IDASQL le dan a tu agente de codificación control total sobre las bases de datos de IDA mediante lenguaje natural.

  • Claude Code -- plugin completo con 15 habilidades centradas en temas específicos, instalado desde el marketplace allthingsida/idasql-skills.
  • GitHub Copilot CLI -- también admite las habilidades de IDASQL a través del mismo plugin.
  • Codex (OpenAI) -- admite habilidades mediante el mismo empaquetado de plugin. Consulta el repositorio idasql-skills para los pasos de instalación de Codex.

Requisitos previos

  1. IDA Pro instalado con su directorio en tu PATH (ida.exe en Windows, ida en macOS/Linux)
  2. idasql descargado desde Releases y colocado junto al binario de IDA
  3. Verifica la configuración: idasql --version debería funcionar desde la línea de comandos

Instalación (Claude Code)

Dentro de Claude Code, ejecuta:```text /plugin marketplace add allthingsida/idasql-skills

root@kitploit:~
luego instala el plugin `idasql` desde ese marketplace. Consulta el [README de idasql-skills](https://github.com/allthingsida/idasql-skills#installation) para Codex y otras rutas de instalación.

#### Skills

| Skill | Description |
|-------|-------------|
| `connect` | Conéctate a bases de datos de IDA: CLI, servidor HTTP, arranque de sesión, enrutamiento de skills, contratos globales. |
| `disassembly` | Consulta el desensamblado de IDA: funciones, segmentos, instrucciones, bloques, operandos, gráficos. |
| `data` | Consulta cadenas, bytes y datos binarios de IDA: búsqueda, reconstrucción, patrones de bytes. |
| `xrefs` | Analiza referencias cruzadas de IDA: llamadores, llamados, importaciones, referencias de datos, búsqueda grep. |
| `decompiler` | Descompila funciones de IDA: pseudocódigo, árbol AST ctree, variables locales, etiquetas. |
| `annotations` | Edita bases de datos de IDA: comentarios, renombrados, tipos, marcadores, renderizado de enum/struct. |
| `types` | Sistema de tipos de IDA: crear/modificar/aplicar structs, uniones, enums, typedefs, parse_decls. |
| `debugger` | Depurador de IDA: puntos de interrupción, parcheo de bytes, condiciones, inventario de parches. |
| `storage` | Almacenamiento clave-valor persistente en bases de datos de IDA mediante netnode_kv. |
| `idapython` | Ejecuta IDAPython vía idasql: fragmentos, sandbox, captura de salida. |
| `functions` | Catálogo completo de referencia de funciones SQL de idasql. |
| `analysis` | Analiza binarios de IDA: triaje, auditoría de seguridad, detección de crypto/red, consultas multi-tabla. |
| `resource` | Recupera binarios de IDA: anotación recursiva, recuperación de estructuras, reconstrucción de tipos. |
| `ui-context` | Captura el contexto de la interfaz de usuario de IDA en vivo: pantalla, selección, foco de widget, anclas de dirección. |

#### Ejemplos de Prompts```
/idasql:analysis analyze this binary; tell me the most called functions.
/idasql:data find functions that reference "password" strings and rank by xrefs.
/idasql:xrefs show callers of CreateFileW and summarize error handling.
/idasql:data identify suspicious hardcoded URLs and the functions that reference them.

Las habilidades de /idasql impulsan el análisis desde tu CLI de programación -- no se requiere scripting de IDAPython.

Ayuda de CLI``` $ idasql Error: Database path required (-s)

idasql v0.0.18 - SQL interface to IDA databases

Usage: idasql -s [-q ] [-f ] [-i] [--export ]

Options: -s IDA database (.idb/.i64) OR raw binary (.exe/.dll/firmware/etc.) — raw binaries trigger fresh idalib analysis and string-list rebuild — legacy 32-bit .idb files upgrade to .i64 and require an explicit reopen --token Auth token for HTTP/MCP server mode (if server requires it) -q Execute SQL query or semicolon-separated script -f Execute SQL from file -i Interactive REPL mode -w, --write Save database on exit (persist changes) --export Export tables to SQL file (local mode only) --export-tables=X Tables to export: * (all, default) or table1,table2,... --http [port] Start HTTP REST server (default: 8080, local mode only) --bind Bind address for HTTP/MCP server (default: 127.0.0.1) --mcp [port] Start MCP server (default: random port, use in -i mode) Or use .mcp start in interactive mode -h, --help Show this help --version Show version

Examples: idasql -s test.i64 -q "SELECT name, size FROM funcs LIMIT 10" idasql -s test.i64 -q "SELECT * FROM binary; SELECT COUNT(*) FROM funcs;" idasql -s test.i64 -f queries.sql idasql -s test.i64 -i idasql -s test.i64 --export dump.sql idasql -s test.i64 --http 8080 idasql -s sample.exe --http # raw PE: idalib auto-analyzes, then serves SQL (default port 8080) idasql -s firmware.bin -q "SELECT * FROM binary" idasql -s test.i64 --mcp 9000

Thank you for using IDA. Have a nice day!

root@kitploit:~
Las entradas heredadas de 32 bits `.idb` son actualizadas por idalib a un `.i64` hermano. Cuando eso ocurre, idasql sale antes de servir SQL, devuelve el código de salida `3`, e imprime un objeto JSON en stdout con `status:"upgraded"` y `reopen_with`. Repita la misma operación con `-s <reopen_with>`.

</details>

### Compilación desde el código fuente

#### Prerrequisitos

- CMake 3.20+
- Compilador de C++20
- IDA SDK 9.0+ (establezca la variable de entorno `IDASDK`)```bash
cmake -S . -B build -DIDASQL_WITH_MCP=ON -DIDASQL_BUILD_EXAMPLES=OFF
cmake --build build --config Release

Opciones útiles de CMake:

Descargar herramienta
ModoCómo iniciarIdeal para
CLI independienteidasql -s binary.i64 -iSQL directo, scripting, pipelines
Plugin de IDASelecciona idasql en el menú desplegable de CLI de IDASQL dentro de la GUI, base de datos en vivo
Flujo de trabajo con skills/idasql:connect en tu CLI de codificaciónAnálisis impulsado por IA -- el agente emite consultas SQL de forma autónoma
You / Agent --> Natural language or SQL
OpciónPredeterminadoDescripción
IDASQL_WITH_MCPONCompila el soporte para servidor MCP mediante fastmcpp. Desactívala para una compilación más pequeña/sin conexión o cuando no necesites --mcp / .mcp.
IDASQL_BUILD_CLIONCompila la herramienta independiente de línea de comandos idasql.
IDASQL_BUILD_PLUGINONCompila el plugin de IDA.
IDASQL_BUILD_EXAMPLESONCompila los programas de ejemplo en examples/.

Notas:

  • El soporte de Hex-Rays siempre se compila y se detecta en tiempo de ejecución. Si Hex-Rays no está disponible, las tablas/funciones basadas en el descompilador simplemente no se registran.
  • El soporte HTTP REST siempre se compila; usa --http desde la CLI o .http start desde la CLI del REPL/plugin.
  • La ejecución SQL de IDAPython se compila, pero está deshabilitada por defecto en tiempo de ejecución. Actívala por sesión con PRAGMA idasql.enable_idapython = 1;.
  • IDASQL_WITH_MCP=ON descarga fastmcpp; OFF elimina el soporte MCP y los comandos --mcp / .mcp.
  • XSQL_WITH_THINCLIENT se fuerza a ON, y HTTPLIB_USE_OPENSSL_IF_AVAILABLE se fuerza a OFF porque IDASQL usa HTTP plano local.

Tablas disponibles

Más de 30 tablas virtuales que cubren funciones, cadenas, tipos, referencias cruzadas, desensamblado, descompilación y más.

Núcleo

TablaDescripción
funcsFunciones - nombre, addr, tamaño, addr final, flags (INSERT/UPDATE/DELETE)
segmentsSegmentos - nombre, addr inicial/final, permisos, clase (INSERT/UPDATE/DELETE)
namesUbicaciones con nombre - addr, nombre, flags (INSERT/UPDATE/DELETE)
entriesPuntos de entrada - exportaciones/programa/callbacks TLS (ordinal, addr, nombre)
importsImportaciones - módulo, nombre, addr, ordinal
xrefsReferencias cruzadas - addr origen/destino, tipo, is_code
blocksBloques básicos - addr inicial/final, func_addr, tamaño
fchunksFragmentos de funciones - fragmentos split/tail con propietario
instructionsDesensamblado - addr, mnemónico, operandos, itype, func_addr (UPDATE format_spec del operando / DELETE)
instruction_operandsOperandos de instrucción normalizados - opnum, texto, tipo, valor; optimizado por addr y func_addr
headsTodos los elementos head (código + datos) - búsqueda de direcciones optimizada/navegación por rangos

Cadenas y bytes

TablaDescripción
stringsCadenas - addr, contenido, longitud, tipo
bytesBytes sin procesar - value/word/dword/qword escribibles (UPDATE parchea, DELETE revierte), original_value, is_patched (enumeración rápida de parches mediante WHERE is_patched = 1)

Descompilador

TablaDescripción
pseudocodePseudocódigo descompilado mediante Hex-Rays
ctreeNodos del AST ctree de Hex-Rays
ctree_lvarsVariables locales de la descompilación de Hex-Rays
ctree_call_argsDetalles de los argumentos de llamada de Hex-Rays por sitio de llamada
ctree_labelsEtiquetas ctree de Hex-Rays (destinos goto)

Tipos

TablaDescripción
typesLibrería de tipos - structs, unions, enums con miembros (INSERT/UPDATE/DELETE)
types_membersDetalles de miembros de struct/union (INSERT/UPDATE/DELETE)
types_enum_valuesValores de miembros de enum (INSERT/UPDATE/DELETE)
types_func_argsDetalles de argumentos de tipos de función
local_typesEntradas de la librería de tipos local

Anotaciones

TablaDescripción
commentsComentarios - addr, comentarios regulares y repetibles (INSERT/UPDATE/DELETE)
bookmarksMarcadores - slot, addr, descripción (INSERT/UPDATE/DELETE)
breakpointsPuntos de interrupción - addr, tipo, habilitado, condición (CRUD completo)
hidden_rangesRangos colapsados/ocultos - inicio/fin, descripción, cabecera, pie

Búsqueda

TablaDescripción
grepTabla de búsqueda unificada de entidades (pattern, name, kind, addr, ordinal, parent_name, full_name)

Información de la base de datos

TablaDescripción
binaryResumen/visión general de la base de datos - procesador, arquitectura de bits, rango de direcciones, recuentos
db_infoPares clave-valor de metadatos de la base de datos
ida_infoPares clave-valor de información del análisis de IDA
problemsProblemas/advertencias del análisis de IDA
signaturesEstado de las firmas FLIRT
fixupsEntradas de fixup/reubicación
mappingsMapeos del espacio de direcciones

Almacenamiento

TablaDescripción
netnode_kvAlmacenamiento persistente clave-valor (netnode)

Análisis

TablaDescripción
disasm_callsGrafo de llamadas - pares llamador/callee por función
disasm_loopsDetección de bucles - bloques de cabecera y aristas de retroceso

Funciones SQL

FunciónDescripción
decompile(addr)Descompila la función en la dirección (devuelve pseudocódigo)
disasm_at(addr)Listado de desensamblado canónico en la dirección
get_ui_context_json()JSON de contexto de la interfaz de usuario — en vivo en el plugin de GUI; un stub "no aplicable" bajo CLI/idalib

Búsqueda unificada de entidades

Usa la tabla grep para búsquedas SQL componibles sobre funciones con nombre, etiquetas, segmentos, tipos y miembros.```sql -- Search anything starting with "Create" SELECT name, kind, printf('0x%X', addr) as addr FROM grep WHERE pattern = 'Create%' LIMIT 20;

-- Search anywhere in name (plain text performs a contains search) SELECT name, kind, full_name FROM grep WHERE pattern = 'File' AND kind IN ('function', 'import') LIMIT 20;

-- Find struct members SELECT name, parent_name, full_name FROM grep WHERE pattern = 'dw%' AND kind = 'member';

-- Pagination SELECT name, kind, full_name FROM grep WHERE pattern = 'Create%' ORDER BY kind, name LIMIT 20 OFFSET 20;

root@kitploit:~
## Integración

### API REST HTTP

Servidor HTTP sin estado para una integración sencilla. Sin sobrecarga de protocolo.```bash
idasql -s database.i64 --http 8080

El contenido a traducir está vacío. No se proporcionó texto de entrada para el chunk 33.```bash curl http://localhost:8080/status curl -X POST http://localhost:8080/query -d "SELECT name FROM funcs LIMIT 5" curl -X POST http://localhost:8080/query -d "SELECT * FROM binary; SELECT COUNT(*) FROM funcs;"

root@kitploit:~
Todas las respuestas de `/query` usan el envoltorio canónico de script — una sola sentencia = array de una sola entrada:```
{
  "success": true,
  "statement_count": <N>,
  "results": [
    { "statement_index": 0, "success": true, "columns": [...], "rows": [...], "row_count": <N>, "elapsed_ms": <ms>, "error": null },
    ...
  ],
  "row_count_total": <N>,
  "elapsed_ms_total": <ms>,
  "first_error_index": null
}

El comportamiento fail-fast es el predeterminado; pasa continue_on_error=true (p. ej., ?continue_on_error=1) para ejecutar cada sentencia independientemente de los fallos anteriores. Cada results[i].error es la referencia canónica para los fallos por sentencia; first_error_index apunta al primer fallo o es null. Ante un fallo del splitter (p. ej., una comilla sin cerrar), la respuesta es success:false, statement_count:0, results:[], además de un parse_error de nivel superior.

Para varias bases de datos, ejecuta instancias separadas:```bash idasql -s malware.i64 --http 8080 idasql -s kernel.i64 --http 8082

root@kitploit:~
Endpoints: `/status`, `/help`, `/query`, `/shutdown`

#### Servidor HTTP desde el REPL

Inicia un servidor HTTP de forma interactiva desde el REPL o la CLI del plugin de IDA:```
idasql -s database.i64 -i
idasql> .http start
HTTP server started on port 8142
URL: http://127.0.0.1:8142
...
Press Ctrl+C to stop and return to REPL.

En el plugin de IDA (no bloqueante):``` idasql> .http start HTTP server started on port 8142 idasql> .http stop HTTP server stopped

root@kitploit:~
The server uses a random port (8100-8199) to avoid conflicts with `--http`.

### Inicio automático (Fijación)

`.pin` persiste una preferencia de servidor en el IDB (netnode `$ idasql config`) para que el
**plugin de IDA inicie automáticamente** un servidor HTTP o MCP cada vez que se abre esa base de datos —
útil para configuraciones de múltiples instancias donde cada base de datos mantiene un puerto estable y conocido.```
idasql> .pin set http 8080        # pin HTTP at 127.0.0.1:8080 (autostart on)
idasql> .pin set mcp 0.0.0.0 9500 # bind override + port (port optional; omit or 0 = fresh random port each launch)
idasql> .pin list                 # show pinned config
idasql> .pin off http             # disable autostart but keep host/port
idasql> .pin clear all            # remove all pins

Después de fijar, al reabrir la base de datos, el servidor se inicia automáticamente: verás esto en la ventana de salida de IDA al cargar:``` IDASQL v0.0.18: Query engine initialized IDASQL CLI: Installed IDASQL: autostart -> IDASQL HTTP server: http://127.0.0.1:8099 Type '.http stop' to stop the server.

root@kitploit:~
`.pin` (or `.pin list`) muestra la configuración actual de ambos servicios:```
idasql> .pin
Autostart pins:
  http 127.0.0.1:8099  (autostart: on)
  mcp  (not set)
  • El autostart-on-load solo ocurre en el plugin de IDA. El comando .pin en sí funciona tanto en la CLI como en el plugin (la CLI solo lee/escribe el pin).
  • .http start / .mcp start sin un puerto explícito reutilizan el host/puerto fijado.
  • Desde la CLI, los cambios de .pin persisten solo cuando se inicia con -w/--write (como cualquier otra edición del IDB).

Servidor MCP

Para clientes compatibles con MCP (Model Context Protocol, un estándar para la integración de herramientas de IA):

--mcp y .mcp están disponibles cuando se compila con -DIDASQL_WITH_MCP=ON, que es el valor predeterminado. Compila con -DIDASQL_WITH_MCP=OFF para omitir el soporte de MCP.```bash

Standalone mode

idasql -s database.i64 --mcp idasql -s database.i64 --mcp 9500 # specific port

Or in interactive mode

idasql -s database.i64 -i .mcp start

root@kitploit:~
Configura tu cliente MCP:```json
{
  "mcpServers": {
    "idasql": { "url": "http://127.0.0.1:<port>/sse" }
  }
}

Tools: idasql_query (consulta SQL directa o script separado por punto y coma)

La familia xsql

IDASQL forma parte de una familia de herramientas que exponen diferentes plataformas de análisis binario e información de depuración a través de la misma superficie SQL, todas construidas sobre el framework de tablas virtuales compartido libxsql. Una consulta que aprendas con una herramienta se traslada en gran medida a las demás; p. ej., la misma SELECT name, size FROM funcs ORDER BY size DESC LIMIT 10 se ejecuta en todas partes.

Plataformas de ingeniería inversa

  • bnsql — bases de datos de Binary Ninja como SQL.
  • ghidrasql — bases de datos de Ghidra como SQL.

Información de depuración y datos del compilador

  • pdbsql — archivos de símbolos PDB de Windows como SQL.
  • dwarfsql — información de depuración DWARF como SQL.
  • clangsql — AST de Clang como SQL.

Núcleo

  • libxsql — el framework C++ de tablas virtuales SQLite sobre el que se construyen todas las herramientas anteriores.

Construido con

  • libxsql - Librería C++17 de solo cabecera para exponer estructuras de datos de C++ como tablas virtuales de SQLite. Proporciona la API fluida de construcción para definir tablas, pushdown de restricciones y soporte de cliente ligero HTTP.

  • fastmcpp - Implementación opcional de servidor MCP utilizada al compilar con -DIDASQL_WITH_MCP=ON.

Licencia y Condiciones de Uso

En resumen: puedes leer, compilar, evaluar, comparar, empaquetar y usar idasql sin modificar, incluso con fines comerciales, si conservas los avisos y cumples los términos de la licencia. Puedes bifurcarlo o parchearlo para preparar correcciones de errores, optimizaciones, funciones, pruebas o mejoras de documentación para contribuir de vuelta dentro de las reglas de propósito de contribución de la licencia.

No puedes mantener un fork privado divergente, puerto, cambio de marca, clon, reemplazo compatible con la API, implementación competidora, ni usar idasql como entrada de IA para recrear o mejorar una implementación derivada sin permiso escrito previo de Elias Bachaalany. Las implementaciones independientes que no estén copiadas, derivadas materialmente o sustancialmente informadas por idasql en el sentido definido por la licencia no están prohibidas.

Solicitudes de permiso: abre un issue en GitHub en allthingsida/idasql/issues.

Si idasql informa materialmente un proyecto distribuido, preserva el origen humano: acredita a idasql y a Elias Bachaalany de forma visible en tu README/documentación y en la interfaz Acerca de/créditos cuando corresponda. La licencia incluye una sección de ejemplos/FAQ para usos comunes permitidos y que requieren permiso. Las dependencias de terceros (libxsql, el IDA SDK y sus dependencias transitivas) permanecen bajo sus propias licencias.

Consulta la Human-Origin Source License v1.0 completa.