quarkslab/quokkaExporte le désassemblage d'IDA Pro, Ghidra et Binary Ninja vers des fichiers protobuf compacts pour une analyse binaire rapide et autonome et la manipulation de programmes via les bindings Python.
image générée par DALL-E
Quokka est un exportateur de binaires : à partir du désassemblage d'un programme, il génère un fichier d'export qui peut être utilisé sans le désassembleur. Il prend actuellement en charge IDA Pro, Ghidra et Binary Ninja comme moteurs de désassemblage.
L'objectif principal de Quokka est de permettre de manipuler entièrement le binaire sans jamais ouvrir de désassembleur après l'export initial. De plus, il fait abstraction de l'API du désassembleur pour exposer une interface propre aux utilisateurs.
Quokka s'inspire fortement de BinExport, l'exportateur de binaires utilisé par BinDiff.
IDA Pro Ghidra Binary Ninja
│ │ │
IDA Plugin (C++) Ghidra Plugin (Java) BinaryNinja Plugin (Python)
│ │ │
└────────────── quokka.proto ─────────────────┘
(protobuf schema)
│
.quokka files
│
Python bindings (quokka.Program)
├── Capstone backend (primary)
└── Pypcode backend (optional)
Le plugin est compilé dans le CI et disponible dans le registre.
Il devrait être possible de l'installer directement via PIP avec une commande de ce type :
$ pip install quokka-project
Note : le plugin IDA n'est pas nécessaire pour lire un fichier généré par Quokka. Il sert uniquement à les générer.
Quokka est compatible avec IDA 9.1+.
Quokka est publié dans le dépôt de plugins Hex-Rays et peut être installé avec hcli :
user@host:~$ hcli plugin install quokka
Le plugin est également compilé dans le CI et disponible dans l'onglet Releases.
Pour télécharger le plugin, récupérez le fichier nommé quokka_plugin.so (ou l'archive quokka-ida<version>.zip pour votre version d'IDA) et copiez-le dans votre répertoire plugins d'IDA.
Quokka prend également en charge l'export depuis Ghidra (>= 12.0.3) via une extension dédiée. Il produit les mêmes fichiers protobuf .quokka que la bibliothèque Python peut charger.
Pour les instructions de compilation, d'installation et les détails d'utilisation, consultez le README de l'extension Ghidra.
Quokka prend également en charge l'export depuis Binary Ninja via un plugin Python. Il produit les mêmes fichiers protobuf .quokka que la bibliothèque Python peut charger.
Pour les détails d'installation et d'utilisation, consultez le README de l'extension BinaryNinja.
La première méthode manuelle pour exporter un binaire consiste à utiliser le plugin dans IDA Pro. Le raccourci par défaut dans IDA est Alt+A. Il ouvre la boîte de dialogue suivante :
Les modes disponibles sont :
Note : le mode FULL n'est pas encore implémenté. Seul le mode LIGHT est actuellement fonctionnel.
Note : cela nécessite une installation IDA fonctionnelle.
$ idat -OQuokkaAuto:true -OQuokkaDecompiled:true -A /path/to/hello.i64
Toutes les options disponibles sont décrites dans la page Utilisation.
Note : idat est utilisé à la place de ida pour accélérer l'export, car l'interface graphique n'est pas nécessaire.
$ analyzeHeadless /tmp/proj Test \
-import /path/to/binary \
-scriptPath ghidra_extension/src/script/ghidra_scripts \
-postScript QuokkaExportHeadless.java \
--out=/path/to/output.quokka --mode=LIGHT
Voir le README de l'extension Ghidra pour plus de détails.
Note : l'utilisation en mode headless de l'API Binary Ninja nécessite une licence commerciale. Sans licence, utilisez plutôt la commande d'export dans l'interface de Binary Ninja.
$ python binaryninja_extension/export_headless.py /path/to/binary \
-o /path/to/output.quokka --mode LIGHT
Voir le README de l'extension BinaryNinja pour plus de détails.
Quokka fournit un utilitaire en ligne de commande pour exporter automatiquement un ou plusieurs fichiers et/ou répertoires (tous les fichiers exécutables de chaque répertoire) en parallèle. Il prend en charge les moteurs IDA Pro et Ghidra :
$ quokka-cli --backend ghidra -t 8 dir/
$ quokka-cli --backend ida --ida-path /opt/ida -t 8 dir/
$ quokka-cli -t 8 dir/ # auto-detect backend
$ quokka-cli -o "%p/exports/%f.quokka" binary # custom output directory
$ quokka-cli -b ida -o %F_ida.quokka -t 4 dir/ # Using relative path
$ quokka-cli -t 8 dir1/ dir2/ binary1 binary2 # multiple inputs
Par défaut, le fichier .quokka est placé à côté du binaire d'entrée (par ex. /usr/bin/ls produit /usr/bin/ls.quokka). Utilisez -o pour remplacer ce comportement par un chemin littéral ou un modèle développé pour chaque fichier (%f = nom sans extension, %F = nom de fichier, %p = répertoire parent, %P = chemin complet, %e = extension, %% = % littéral).
Exécutez quokka-cli --help pour voir toutes les options. Les principaux paramètres sont :
-b, --backend : pour choisir le moteur de désassemblage (ida, ghidra ou auto)-i, --ida-path : pour fournir le chemin du répertoire d'installation d'IDA (le dossier contenant idat)--ghidra-path : pour fournir le répertoire d'installation de Ghidra (remplace GHIDRA_INSTALL_DIR)-o, --output : pour définir le chemin ou le modèle de sortie (défaut : %F.quokka)-m, --mode : pour choisir le mode d'export ( ou )import quokka
from quokka.types import Disassembler
# Directly from the binary (auto-detects available backend)
prog = quokka.Program.from_binary("/bin/ls")
# Explicitly choose a backend
prog = quokka.Program.from_binary("/bin/ls", disassembler=Disassembler.GHIDRA)
prog = quokka.Program.from_binary("/bin/ls", disassembler=Disassembler.IDA)
# From the exported file
prog = quokka.Program("ls.quokka", # the exported file
"/bin/ls") # the original binary
# Add new types from C declarations
prog.add_type("struct context { int id; char name[64]; };")
prog.add_type("enum status { OK=0, ERROR=1 };")
# Save the .quokka file
prog.write()
# Or apply changes (including new types) back to the IDA database
prog.commit(database_file="ls.i64", overwrite=True)
Consultez la documentation complète sur la modification pour plus de détails sur le renommage des fonctions, la définition des prototypes, etc.
Le processus de compilation dépend de la version du SDK IDA que vous utilisez. Ces deux modes sont également appelés le nouveau mode et l'ancien mode.
Le SDK IDA a finalement été publié en open source, il n'est donc plus nécessaire de le télécharger séparément.
Vous pouvez utiliser l'option cmake -DIDA_VERSION=<major>.<minor> pour le synchroniser automatiquement depuis GitHub.
user@host:~/quokka$ cmake -B build \ # Where to build
-S . \ # Where are the sources
-DIDA_VERSION=9.2 \ # IDA SDK version
-DCMAKE_BUILD_TYPE:STRING=Release \ # Build Type
user@host:~/quokka$ cmake --build build -- -j
Étant donné que le SDK IDA est encore un code propriétaire, vous devez le récupérer vous-même et fournir son chemin à cmake via l'option -DIdaSdk_ROOT_DIR:STRING=path/to/sdk
REMARQUE : cela fonctionnera également avec les versions plus récentes, mais cela demande plus d'étapes aux utilisateurs, qui devront télécharger le SDK eux-mêmes.
user@host:~/quokka$ cmake -B build \ # Where to build
-S . \ # Where are the sources
-DIdaSdk_ROOT_DIR:STRING=path/to/ida_sdk \ # Path to IDA SDK
-DCMAKE_BUILD_TYPE:STRING=Release \ # Build Type
user@host:~/quokka$ cmake --build build --target quokka_plugin -- -j
Pour installer le plugin :
user@host:~/quokka$ cmake --install build
Dans tous les cas, le plugin se trouvera également dans build/quokka-install. Vous pouvez le copier dans le répertoire des plugins utilisateur d'IDA.
user@host:~/quokka$ cp build/quokka-install/quokka_plugin.so $HOME/.idapro/plugins/
Pour des informations plus détaillées sur la compilation, consultez Compilation
La documentation est disponible en ligne à l'adresse documentation
Vous pouvez consulter une liste de questions ici : FAQ
Note : seul le mode LIGHT est actuellement implémenté. Le mode FULL (autonome) est prévu mais pas encore fonctionnel.
Quokka propose deux modes pour exporter l'analyse du désassemblage : le mode léger et le mode autonome.
Le mode léger se concentre sur l'export d'informations essentielles uniquement, produisant des fichiers rapides et légers. Dans ce mode, aucune information au niveau des instructions ou en dessous n'est exportée ; le moteur capstone est donc utilisé à l'exécution pour obtenir le désassemblage des instructions.
Le mode autonome, quant à lui, exporte le désassemblage complet, exactement comme le désassembleur backend l'affiche. Cela produit des fichiers plus lourds, mais ne nécessite pas de dépendre de désassembleurs tiers à l'exécution.
Il est important de noter que les deux modes offrent la même API dans les bindings Python.
[!WARNING] Depuis le mode autonome, il est toujours possible d'obtenir l'objet d'instruction capstone, mais attention : le désassemblage capstone peut différer de celui exporté par quokka (les instructions peuvent être divisées, fusionnées, non prises en charge, avoir des mnémoniques différentes, etc.). En général, différentes plateformes d'analyse binaire produisent des désassemblages différents ; gardez cela à l'esprit lorsque vous mélangez capstone avec le mode autonome.
Pour un aperçu complet des différences entre les deux modes, consultez le tableau ci-dessous :
¹ Activé en option
² Actuellement non pris en charge
lightfull--decompiled : pour activer l'export du code décompilé (IDA uniquement)-v, --verbose : pour activer les journaux détaillés| Mode léger | Mode autonome |
|---|
| Fonctions | ✅ | ✅ |
| Blocs de base | ✅ | ✅ |
| Instructions | ❌ | ✅ |
| Opérandes | ❌ | ✅ |
| Références de données | ✅ | ✅ |
| Références croisées | ✅ | ✅ |
| Sections/Disposition | ✅ | ✅ |
| Décompilation | ✅¹ | ✅¹ |
| Coordonnées de tracé du CFG | ✅¹² | ✅¹² |