
Vibe Reverse Engineer with IDA SQL: Una interfaz para IDA en SQL mediante tablas virtuales en vivo
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.
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.
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.
|
/idasql skills (LLM translates intent to SQL)
|
IDASQL --> IDA database(s)
|
Results --> LLM summarizes & reasons
" with nothing in between. Could be a whitespace? The original prompt shows:
INPUT:
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
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.
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.
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.
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.
### 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?
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
Ahora IDASQL y tu UI de IDA están conectados y funcionando juntos.
Las habilidades de IDASQL le dan a tu agente de codificación control total sobre las bases de datos de IDA mediante lenguaje natural.
allthingsida/idasql-skills.ida.exe en Windows, ida en macOS/Linux)idasql --version debería funcionar desde la línea de comandosDentro de Claude Code, ejecuta:```text /plugin marketplace add allthingsida/idasql-skills
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.
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!
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:
| Modo | Cómo iniciar | Ideal para |
|---|
| CLI independiente | idasql -s binary.i64 -i | SQL directo, scripting, pipelines |
| Plugin de IDA | Selecciona idasql en el menú desplegable de CLI de IDA | SQL dentro de la GUI, base de datos en vivo |
| Flujo de trabajo con skills | /idasql:connect en tu CLI de codificación | Análisis impulsado por IA -- el agente emite consultas SQL de forma autónoma |
| You / Agent --> Natural language or SQL |
| Opción | Predeterminado | Descripción |
|---|---|---|
IDASQL_WITH_MCP | ON | Compila 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_CLI | ON | Compila la herramienta independiente de línea de comandos idasql. |
IDASQL_BUILD_PLUGIN | ON | Compila el plugin de IDA. |
IDASQL_BUILD_EXAMPLES | ON | Compila los programas de ejemplo en examples/. |
Notas:
--http desde la CLI o .http start desde la CLI del REPL/plugin.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.Más de 30 tablas virtuales que cubren funciones, cadenas, tipos, referencias cruzadas, desensamblado, descompilación y más.
| Tabla | Descripción |
|---|---|
funcs | Funciones - nombre, addr, tamaño, addr final, flags (INSERT/UPDATE/DELETE) |
segments | Segmentos - nombre, addr inicial/final, permisos, clase (INSERT/UPDATE/DELETE) |
names | Ubicaciones con nombre - addr, nombre, flags (INSERT/UPDATE/DELETE) |
entries | Puntos de entrada - exportaciones/programa/callbacks TLS (ordinal, addr, nombre) |
imports | Importaciones - módulo, nombre, addr, ordinal |
xrefs | Referencias cruzadas - addr origen/destino, tipo, is_code |
blocks | Bloques básicos - addr inicial/final, func_addr, tamaño |
fchunks | Fragmentos de funciones - fragmentos split/tail con propietario |
instructions | Desensamblado - addr, mnemónico, operandos, itype, func_addr (UPDATE format_spec del operando / DELETE) |
instruction_operands | Operandos de instrucción normalizados - opnum, texto, tipo, valor; optimizado por addr y func_addr |
heads | Todos los elementos head (código + datos) - búsqueda de direcciones optimizada/navegación por rangos |
| Tabla | Descripción |
|---|---|
strings | Cadenas - addr, contenido, longitud, tipo |
bytes | Bytes 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) |
| Tabla | Descripción |
|---|---|
pseudocode | Pseudocódigo descompilado mediante Hex-Rays |
ctree | Nodos del AST ctree de Hex-Rays |
ctree_lvars | Variables locales de la descompilación de Hex-Rays |
ctree_call_args | Detalles de los argumentos de llamada de Hex-Rays por sitio de llamada |
ctree_labels | Etiquetas ctree de Hex-Rays (destinos goto) |
| Tabla | Descripción |
|---|---|
types | Librería de tipos - structs, unions, enums con miembros (INSERT/UPDATE/DELETE) |
types_members | Detalles de miembros de struct/union (INSERT/UPDATE/DELETE) |
types_enum_values | Valores de miembros de enum (INSERT/UPDATE/DELETE) |
types_func_args | Detalles de argumentos de tipos de función |
local_types | Entradas de la librería de tipos local |
| Tabla | Descripción |
|---|---|
comments | Comentarios - addr, comentarios regulares y repetibles (INSERT/UPDATE/DELETE) |
bookmarks | Marcadores - slot, addr, descripción (INSERT/UPDATE/DELETE) |
breakpoints | Puntos de interrupción - addr, tipo, habilitado, condición (CRUD completo) |
hidden_ranges | Rangos colapsados/ocultos - inicio/fin, descripción, cabecera, pie |
| Tabla | Descripción |
|---|---|
grep | Tabla de búsqueda unificada de entidades (pattern, name, kind, addr, ordinal, parent_name, full_name) |
| Tabla | Descripción |
|---|---|
binary | Resumen/visión general de la base de datos - procesador, arquitectura de bits, rango de direcciones, recuentos |
db_info | Pares clave-valor de metadatos de la base de datos |
ida_info | Pares clave-valor de información del análisis de IDA |
problems | Problemas/advertencias del análisis de IDA |
signatures | Estado de las firmas FLIRT |
fixups | Entradas de fixup/reubicación |
mappings | Mapeos del espacio de direcciones |
| Tabla | Descripción |
|---|---|
netnode_kv | Almacenamiento persistente clave-valor (netnode) |
| Tabla | Descripción |
|---|---|
disasm_calls | Grafo de llamadas - pares llamador/callee por función |
disasm_loops | Detección de bucles - bloques de cabecera y aristas de retroceso |
| Función | Descripció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 |
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;
## 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;"
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
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
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.
`.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)
.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..pin persisten solo cuando se inicia con -w/--write
(como cualquier otra edición del IDB).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
idasql -s database.i64 --mcp idasql -s database.i64 --mcp 9500 # specific port
idasql -s database.i64 -i .mcp start
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)
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
Información de depuración y datos del compilador
Núcleo
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.
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.