allthingsida/idasqlVibe Reverse Engineer with IDA SQL : une interface pour IDA en SQL via des tables virtuelles en direct
Donnez à n'importe quel agent d'IA la capacité de comprendre les binaires compilés.
IDASQL est une interface SQL pour les bases de données IDA Pro, créée par Elias Bachaalany. Il expose plus de 30 tables virtuelles couvrant les fonctions, les références croisées, les chaînes, les types, les importations, le désassemblage et la décompilation. Utilisez les compétences /idasql de votre agent de codage pour travailler entièrement en mode headless -- l'agent exécute IDA en arrière-plan pour vous -- ou ouvrez l'interface utilisateur d'IDA et collaborez avec votre agent de codage pour faire de la rétro-ingénierie ensemble. Pas d'IDAPython. Pas de script. Juste du SQL.
Pourquoi SQL ? SQL est le langage de requête universel que chaque agent d'IA parle déjà. IDASQL est indépendant de l'agent : Claude, ChatGPT, Copilot, Cursor, agents personnalisés, ou aucun agent du tout. Tout outil capable d'émettre une requête SQL peut analyser un binaire.
IDASQL prend en charge l'analyse, les références croisées et le transfert d'annotations entre une ou plusieurs bases de données à la fois. Ce que vous pouvez faire n'est limité que par votre imagination et la puissance du modèle que vous utilisez.
IDA Pro possède déjà son propre format de base de données décrivant les fonctions, les chaînes, les références croisées, les types, etc. IDASQL mappe ces structures internes vers des tables virtuelles SQL en direct. Il n'y a aucune étape d'exportation ou d'indexation séparée -- les requêtes s'exécutent directement sur la base de données d'IDA et les modifications sont reflétées en direct.
|
/idasql skills (LLM translates intent to SQL)
|
IDASQL --> IDA database(s)
|
Results --> LLM summarizes & reasons
> **🔧 Créez facilement des outils personnalisés** avec seulement quelques lignes de YAML et une approche pilotée par un système de tickets.
#### 🧠 Fonctionnalités
- **Multiples environnements** : Kubernetes (Helm + Krew), Docker, VM, AWS, et output
- **Création facile d'outils** : Utilisez de simples modèles YAML
- **Système de tickets** : Traitez, suivez et rejouez les tickets
- **Piloté par CI** : Surveillez les dépôts GitHub, les tags ou les releases
- **Graphe de dépendances** : Construisez les outils par étapes
#### ⚙️ Comment ça fonctionne
Trickest Workflow est construit comme une chaîne de montage d'usine - chaque ticket passe par des étapes prédéfinies :
Trigger → Enrich → Build → Test → Release → Deploy → Close
En coulisses, c'est une collection de scripts simples :
workflow.sh → scripts (trigger, enrich, build, stage-1/2/3, test, release, deploy, close)
Et pour accélérer les choses (beaucoup !), [GNU Parallel](https://www.gnu.org/software/parallel/) est utilisé.
#### 🧰 Créer des outils
Un outil n'est rien de plus que quelques lignes de YAML.
```yaml
name: tool-name # directory name (only lowercase, numbers, hyphens)
repo: github.com/org/repo # GitHub repository (other forges might be added in the future)
labels: [recon, discovery, windows] # choose from .github/labels.yml
type: [docker, kubernetes, vm, aws] # choose from .github/tool-types.yml
script: | # script that installs the tool
apt-get update
apt-get install -y tool-name
echo "TIP: use echo to print tool version!"
tool-name --version
$ 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)
*Une seule commande. Des résultats instantanés. Aucun script requis.*
## Démarrage rapide
Après [installation](#installation) du CLI et du plugin IDASQL, lancez votre agent de codage préféré et commencez la rétro-ingénierie par invites. IDASQL fonctionne entièrement en mode headless -- votre agent orchestre IDA Pro : démarrage, analyse, décompilation, annotation, sauvegarde -- ou est hébergé dans l'interface graphique d'IDA, où vous collaborez avec votre agent en temps réel.
### Pour commencer
Ouvrez votre agent de codage préféré (par exemple Claude Code) et tapez :```
/idasql:connect Please open sample_malware.exe in the background and let's analyze it together.
L'agent démarre IDASQL en arrière-plan, sans interface graphique. À partir de ce moment, discutez naturellement avec la base de données. Par exemple :``` /idasql:annotations Fully annotate the function I'm looking at, also use the decompiler skill.
Le modèle raisonne de manière autonome sur la meilleure approche pour comprendre la fonction, en fait la rétro-ingénierie complète et l'annote.
Une fois terminé, demandez à l'agent d'enregistrer et d'arrêter :```
/idasql:connect Please save all databases and shut down IDASQL.
Vous pouvez travailler avec deux bases de données ou plus simultanément. Invitez votre agent :``` /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.
Ensuite, suivez :```
Tell me, how many strings all these databases have in common?
L'agent travaille avec toutes les bases de données en même temps. Vous pouvez les recouper, les comparer et transférer des annotations entre elles.
Tout ce qui précède fonctionne également depuis l'interface graphique d'IDA. Pour faire appel à votre agent avec une session IDA ouverte :
idasql> d'IDA, tapez : ```
.http start
Now IDASQL and your IDA UI are connected and working together.
Les compétences IDASQL donnent à votre agent de codage un contrôle total sur les bases de données IDA via le langage naturel.
allthingsida/idasql-skills.ida.exe sur Windows, ida sur macOS/Linux)idasql --version doit fonctionner depuis la ligne de commandeDans Claude Code, exécutez :```text /plugin marketplace add allthingsida/idasql-skills
puis installez le plugin `idasql` depuis ce marketplace. Consultez le [README d'idasql-skills](https://github.com/allthingsida/idasql-skills#installation) pour Codex et les autres chemins d'installation.
#### Compétences
| Compétence | Description |
|-------|-------------|
| `connect` | Se connecter aux bases IDA : CLI, serveur HTTP, amorçage de session, routage des compétences, contrats globaux. |
| `disassembly` | Interroger le désassemblage IDA : fonctions, segments, instructions, blocs, opérandes, graphes. |
| `data` | Interroger les chaînes, octets et données binaires IDA : recherche, reconstruction, motifs d'octets. |
| `xrefs` | Analyser les références croisées IDA : appelants, appelés, imports, références de données, recherche grep. |
| `decompiler` | Décompiler les fonctions IDA : pseudocode, arbre ctree, variables locales, étiquettes. |
| `annotations` | Modifier les bases IDA : commentaires, renommages, types, signets, rendu des énumérations/structures. |
| `types` | Système de types IDA : créer/modifier/appliquer des structures, unions, énumérations, typedefs, parse_decls. |
| `debugger` | Débogueur IDA : points d'arrêt, correction d'octets, conditions, inventaire des correctifs. |
| `storage` | Stockage persistant clé-valeur dans les bases IDA via netnode_kv. |
| `idapython` | Exécuter IDAPython via idasql : extraits, bac à sable, capture de sortie. |
| `functions` | Catalogue de référence complet des fonctions SQL d'idasql. |
| `analysis` | Analyser les binaires IDA : triage, audit de sécurité, détection crypto/réseau, requêtes multi-tables. |
| `resource` | Re-sourcer les binaires IDA : annotation récursive, récupération de structures, reconstruction de types. |
| `ui-context` | Capturer le contexte d'interface IDA en direct : écran, sélection, focus des widgets, ancres d'adresses. |
#### Exemples de requêtes
puis installez le plugin `idasql` depuis ce marketplace. Consultez le [README d'idasql-skills](https://github.com/allthingsida/idasql-skills#installation) pour Codex et les autres chemins d'installation.
#### Compétences
| Compétence | Description |
|-------|-------------|
| `connect` | Se connecter aux bases IDA : CLI, serveur HTTP, amorçage de session, routage des compétences, contrats globaux. |
| `disassembly` | Interroger le désassemblage IDA : fonctions, segments, instructions, blocs, opérandes, graphes. |
| `data` | Interroger les chaînes, octets et données binaires IDA : recherche, reconstruction, motifs d'octets. |
| `xrefs` | Analyser les références croisées IDA : appelants, appelés, imports, références de données, recherche grep. |
| `decompiler` | Décompiler les fonctions IDA : pseudocode, arbre ctree, variables locales, étiquettes. |
| `annotations` | Modifier les bases IDA : commentaires, renommages, types, signets, rendu des énumérations/structures. |
| `types` | Système de types IDA : créer/modifier/appliquer des structures, unions, énumérations, typedefs, parse_decls. |
| `debugger` | Débogueur IDA : points d'arrêt, correction d'octets, conditions, inventaire des correctifs. |
| `storage` | Stockage persistant clé-valeur dans les bases IDA via netnode_kv. |
| `idapython` | Exécuter IDAPython via idasql : extraits, bac à sable, capture de sortie. |
| `functions` | Catalogue de référence complet des fonctions SQL d'idasql. |
| `analysis` | Analyser les binaires IDA : triage, audit de sécurité, détection crypto/réseau, requêtes multi-tables. |
| `resource` | Re-sourcer les binaires IDA : annotation récursive, récupération de structures, reconstruction de types. |
| `ui-context` | Capturer le contexte d'interface IDA en direct : écran, sélection, focus des widgets, ancres d'adresses. |
#### Exemples de requêtes```
/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.
Les skills /idasql pilotent l'analyse depuis votre CLI de codage -- aucun script IDAPython requis.
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!
Les anciennes entrées `.idb` 32 bits sont mises à niveau par idalib vers un `.i64` voisin. Lorsque cela
se produit, idasql se termine avant de servir le SQL, renvoie le code de sortie `3`, et imprime un
objet JSON sur stdout avec `status:"upgraded"` et `reopen_with`. Répétez la même
opération avec `-s <reopen_with>`.
</details>
### Compilation depuis les sources
#### Prérequis
- CMake 3.20+
- compilateur C++20
- IDA SDK 9.0+ (définissez la variable d'environnement `IDASDK`)```bash
cmake -S . -B build -DIDASQL_WITH_MCP=ON -DIDASQL_BUILD_EXAMPLES=OFF
cmake --build build --config Release
Options CMake utiles :
| Mode | Comment démarrer | Idéal pour |
|---|
| CLI autonome | idasql -s binary.i64 -i | SQL direct, scripts, pipelines |
| Plugin IDA | Sélectionnez idasql dans le menu déroulant CLI d'IDA | SQL dans l'interface graphique, base de données en direct |
| Workflow de compétence | /idasql:connect dans votre CLI de codage | Analyse pilotée par l'IA -- l'agent émet des requêtes SQL de manière autonome |
| You / Agent --> Natural language or SQL |
| Option | Défaut | Description |
|---|---|---|
IDASQL_WITH_MCP | ON | Construit la prise en charge du serveur MCP via fastmcpp. Désactivez pour une compilation plus légère/hors ligne ou lorsque vous n'avez pas besoin de --mcp / .mcp. |
IDASQL_BUILD_CLI | ON | Construit l'outil en ligne de commande autonome idasql. |
IDASQL_BUILD_PLUGIN | ON | Construit le plugin IDA. |
IDASQL_BUILD_EXAMPLES | ON | Construit les programmes d'exemple situés dans examples/. |
Notes :
--http depuis l'interface CLI ou .http start depuis la CLI du REPL/plugin.PRAGMA idasql.enable_idapython = 1;.IDASQL_WITH_MCP=ON récupère fastmcpp ; OFF supprime la prise en charge de MCP et les commandes --mcp / .mcp.XSQL_WITH_THINCLIENT est forcé à ON, et HTTPLIB_USE_OPENSSL_IF_AVAILABLE est forcé à OFF car IDASQL utilise du HTTP simple local.30+ tables virtuelles couvrant les fonctions, chaînes, types, références croisées, désassemblage, décompilation, et plus encore.
| Table | Description |
|---|---|
funcs | Fonctions - nom, addr, taille, adresse de fin, flags (INSERT/UPDATE/DELETE) |
segments | Segments - nom, adresse de début/fin, permissions, classe (INSERT/UPDATE/DELETE) |
names | Emplacements nommés - addr, nom, flags (INSERT/UPDATE/DELETE) |
entries | Points d'entrée - callbacks export/programme/tls (ordinal, addr, nom) |
imports | Imports - module, nom, addr, ordinal |
xrefs | Références croisées - adresse de départ/d'arrivée, type, is_code |
blocks | Blocs de base - adresse de début/fin, func_addr, taille |
fchunks | Chunks de fonction - chunks split/tail avec propriétaire |
instructions | Désassemblage - addr, mnémonique, opérandes, itype, func_addr (UPDATE operand format_spec / DELETE) |
instruction_operands | Opérandes d'instruction normalisés - opnum, texte, type, valeur ; optimisés par addr et func_addr |
heads | Tous les éléments head (code + données) - recherche d'adresse/navigation par plage optimisées |
| Table | Description |
|---|---|
strings | Chaînes - addr, contenu, longueur, type |
bytes | Octets bruts - value/word/dword/qword modifiables (UPDATE patch, DELETE rétablit), original_value, is_patched (énumération rapide des patchs via WHERE is_patched = 1) |
| Table | Description |
|---|---|
pseudocode | Pseudo-code décompilé via Hex-Rays |
ctree | Nœuds de l'AST ctree d'Hex-Rays |
ctree_lvars | Variables locales issues de la décompilation Hex-Rays |
ctree_call_args | Détails des arguments d'appel Hex-Rays par site d'appel |
ctree_labels | Étiquettes ctree Hex-Rays (cibles de goto) |
| Table | Description |
|---|---|
types | Bibliothèque de types - structures, unions, énumérations avec membres (INSERT/UPDATE/DELETE) |
types_members | Détails des membres de structure/union (INSERT/UPDATE/DELETE) |
types_enum_values | Valeurs des membres d'énumération (INSERT/UPDATE/DELETE) |
types_func_args | Détails des arguments de types de fonction |
local_types | Entrées de la bibliothèque de types locale |
| Table | Description |
|---|---|
comments | Commentaires - addr, commentaires normaux et répétables (INSERT/UPDATE/DELETE) |
bookmarks | Signets - emplacement, addr, description (INSERT/UPDATE/DELETE) |
breakpoints | Points d'arrêt - addr, type, activé, condition (CRUD complet) |
hidden_ranges | Plages réduites/masquées - début/fin, description, en-tête, pied de page |
| Table | Description |
|---|---|
grep | Table unifiée de recherche d'entités (pattern, name, kind, addr, ordinal, parent_name, full_name) |
| Table | Description |
|---|---|
binary | Résumé/vue d'ensemble de la base - processeur, bitness, plage d'adresses, compteurs |
db_info | Paires clé-valeur de métadonnées de la base de données |
ida_info | Paires clé-valeur des informations d'analyse IDA |
problems | Problèmes/avertissements de l'analyse IDA |
signatures | État des signatures FLIRT |
fixups | Entrées de fixup/relocalisation |
mappings | Mappages d'espaces d'adressage |
| Table | Description |
|---|---|
netnode_kv | Stockage persistant clé-valeur (netnode) |
| Table | Description |
|---|---|
disasm_calls | Graphe d'appels - paires appelant/appelé par fonction |
disasm_loops | Détection de boucles - blocs d'en-tête et arêtes de retour |
| Fonction | Description |
|---|---|
decompile(addr) | Décompile la fonction à l'adresse (renvoie le pseudo-code) |
disasm_at(addr) | Listing de désassemblage canonique à l'adresse |
get_ui_context_json() | JSON du contexte UI — actif dans le plugin GUI ; un stub "non applicable" sous CLI/idalib |
Utilisez la table grep pour des recherches SQL composables sur les fonctions nommées, les étiquettes, les segments, les types et les membres.```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;
## Intégration
### HTTP REST API
Serveur HTTP sans état pour une intégration simple. Aucune surcharge de protocole.```bash
idasql -s database.i64 --http 8080
The input chunk is empty — no source text was provided to translate. Please resend chunk 33 with the actual Markdown content.```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;"
Toutes les réponses `/query` utilisent l'enveloppe de script canonique — une seule instruction = tableau d'une entrée :```
{
"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
}
Fail-fast est le comportement par défaut; passez continue_on_error=true (par ex. ?continue_on_error=1) pour exécuter chaque instruction indépendamment des échecs antérieurs. Chaque results[i].error est canonique pour les échecs par instruction; first_error_index pointe vers le premier échec ou est null. En cas d'échec du séparateur (par ex. une citation non terminée), la réponse est success:false, statement_count:0, results:[], plus un parse_error de premier niveau.
Pour plusieurs bases de données, exécutez des instances séparées :```bash idasql -s malware.i64 --http 8080 idasql -s kernel.i64 --http 8082
Points de terminaison : `/status`, `/help`, `/query`, `/shutdown`
#### Serveur HTTP depuis le REPL
Démarrez un serveur HTTP de manière interactive depuis le REPL ou la CLI du plugin 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.
Dans le plugin IDA (non bloquant):``` idasql> .http start HTTP server started on port 8142 idasql> .http stop HTTP server stopped
Le serveur utilise un port aléatoire (8100-8199) pour éviter les conflits avec `--http`.
### Démarrage automatique (Épinglage)
`.pin` persiste une préférence de serveur dans l'IDB (netnode `$ idasql config`) afin que le **plugin IDA démarre automatiquement** un serveur HTTP ou MCP chaque fois que cette base de données est ouverte — pratique pour les configurations multi-instances où chaque base de données conserve un port stable et connu.```
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
Après l'épinglage, la réouverture de la base de données démarre automatiquement le serveur — vous verrez cela dans la fenêtre de sortie d'IDA au chargement :``` 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` (ou `.pin list`) affiche la configuration actuelle pour les deux services:```
idasql> .pin
Autostart pins:
http 127.0.0.1:8099 (autostart: on)
mcp (not set)
.pin elle-même fonctionne à la fois dans le CLI et le plugin (le CLI se contente de lire/écrire le pin)..http start / .mcp start sans port explicite réutilisent l'hôte/port épinglé..pin ne persistent que lorsqu'il est démarré avec -w/--write (comme toute autre modification IDB).Pour les clients compatibles MCP (Model Context Protocol, un standard pour l'intégration d'outils d'IA) :
--mcp et .mcp sont disponibles lors de la compilation avec -DIDASQL_WITH_MCP=ON, qui est la valeur par défaut. Compilez avec -DIDASQL_WITH_MCP=OFF pour omettre le support MCP.```bash
idasql -s database.i64 --mcp idasql -s database.i64 --mcp 9500 # specific port
idasql -s database.i64 -i .mcp start
Configurez votre client MCP :```json
{
"mcpServers": {
"idasql": { "url": "http://127.0.0.1:<port>/sse" }
}
}
Outils : idasql_query (requête SQL directe ou script séparé par des points-virgules)
IDASQL fait partie d'une famille d'outils qui exposent différentes plateformes d'analyse binaire et d'informations de débogage à travers la même interface SQL, tous construits sur le framework de tables virtuelles partagé libxsql. Une requête que vous apprenez sur un outil se transpose en grande partie aux autres — par ex. la même SELECT name, size FROM funcs ORDER BY size DESC LIMIT 10 s'exécute partout.
Plateformes de rétro-ingénierie
Informations de débogage et données du compilateur
Noyau
libxsql - Bibliothèque C++17 header-only pour exposer des structures de données C++ comme tables virtuelles SQLite. Fournit l'API de construction fluide pour définir des tables, le pushdown de contraintes, et le support de client léger HTTP.
fastmcpp - Implémentation facultative de serveur MCP utilisée lors de la compilation avec -DIDASQL_WITH_MCP=ON.
En bref : vous pouvez lire, compiler, évaluer, benchmarker, empaqueter et utiliser idasql non modifié, y compris commercialement, si vous conservez les mentions et respectez les termes de la licence. Vous pouvez le forker ou le patcher pour préparer des corrections de bugs, des optimisations, des fonctionnalités, des tests ou des améliorations de documentation pour une contribution en retour, dans le cadre des règles de la licence relatives à l'objectif de contribution.
Vous ne pouvez pas maintenir un fork privé divergent, un port, un rebranding, un clone, un remplacement compatible API, une implémentation concurrente, ni utiliser idasql comme entrée d'IA pour recréer ou améliorer une implémentation dérivée sans l'autorisation écrite préalable d'Elias Bachaalany. Les implémentations indépendantes qui ne sont pas copiées, dérivées matériellement ou substantiellement informées par idasql au sens défini par la licence ne sont pas interdites.
Demandes d'autorisation : ouvrez une issue GitHub sur allthingsida/idasql/issues.
Si idasql informe matériellement un projet distribué, préservez l'origine humaine : créditez idasql et Elias Bachaalany visiblement dans votre README/docs et dans l'interface À propos/credits le cas échéant. La licence inclut une section exemples/FAQ pour les utilisations courantes autorisées et celles nécessitant une autorisation. Les dépendances tierces (libxsql, l'IDA SDK et leurs dépendances transitives) restent sous leurs propres licences.
Voir la Human-Origin Source License v1.0 complète.