quarkslab/quokkaQuokka: Ein schneller und präziser Binär-Exporter
Bild erzeugt von DALL-E
Quokka ist ein Binärdatei-Exporter: Aus der Disassemblierung eines Programms erzeugt er eine Exportdatei, die ohne den Disassembler verwendet werden kann. Derzeit werden IDA Pro, Ghidra und Binary Ninja als Disassemblierungs-Backends unterstützt.
Das Hauptziel von Quokka ist es, die vollständige Manipulation der Binärdatei zu ermöglichen, ohne nach dem anfänglichen Export jemals einen Disassembler zu öffnen. Darüber hinaus abstrahiert es die API des Disassemblers, um den Benutzern eine saubere Schnittstelle zu bieten.
Quokka ist stark von BinExport inspiriert, dem Binär-Exporter, der von BinDiff verwendet wird.
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)
Das Plugin wird in der CI erstellt und ist in der Registry verfügbar.
Es sollte möglich sein, es direkt über PIP mit einem Befehl wie diesem zu installieren:
$ pip install quokka-project
Hinweis: Das IDA-Plugin wird nicht benötigt, um eine mit Quokka erzeugte Datei zu lesen. Es wird nur zur Erzeugung verwendet.
Quokka ist mit IDA 9.1+ kompatibel.
Quokka wird im Hex-Rays-Plugin-Repository veröffentlicht und kann mit hcli installiert werden:
user@host:~$ hcli plugin install quokka
Das Plugin wird ebenfalls in der CI erstellt und ist im Tab Releases verfügbar.
Laden Sie zum Herunterladen des Plugins die Datei quokka_plugin.so (oder das Archiv quokka-ida<version>.zip für Ihre IDA-Version) herunter und kopieren Sie sie in Ihr IDA-Verzeichnis plugins.
Quokka unterstützt auch den Export aus Ghidra (>= 12.0.3) über eine eigene Erweiterung. Sie erzeugt dieselben .quokka-Protobuf-Dateien, die die Python-Bibliothek laden kann.
Anweisungen zum Erstellen, zur Installation und zur Verwendung finden Sie in der README der Ghidra-Erweiterung.
Quokka unterstützt auch den Export aus Binary Ninja über ein Python-Plugin. Es erzeugt dieselben .quokka-Protobuf-Dateien, die die Python-Bibliothek laden kann.
Details zur Installation und Verwendung finden Sie in der README der BinaryNinja-Erweiterung.
Die erste manuelle Möglichkeit, eine Binärdatei zu exportieren, ist die Verwendung des Plugins in IDA Pro. Die Standard-Tastenkombination in IDA ist Alt+A. Es öffnet sich der folgende Dialog:
Verfügbare Modi sind:
Hinweis: Der FULL-Modus ist noch nicht implementiert. Derzeit ist nur der LIGHT-Modus funktionsfähig.
Hinweis: Hierfür ist eine funktionierende IDA-Installation erforderlich.
$ idat -OQuokkaAuto:true -OQuokkaDecompiled:true -A /path/to/hello.i64
Alle verfügbaren Optionen sind in der Verwendung beschrieben.
Hinweis: idat wird anstelle von ida verwendet, um die Exportgeschwindigkeit zu erhöhen, da keine grafische Oberfläche benötigt wird.
$ 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
Weitere Einzelheiten finden Sie in der README der Ghidra-Erweiterung.
Hinweis: Die Headless-Nutzung der Binary Ninja API erfordert eine kommerzielle Lizenz. Ohne eine solche verwenden Sie stattdessen den Exportbefehl in der Binary Ninja-Benutzeroberfläche.
$ python binaryninja_extension/export_headless.py /path/to/binary \
-o /path/to/output.quokka --mode LIGHT
Weitere Einzelheiten finden Sie in der README der BinaryNinja-Erweiterung.
Quokka stellt ein CLI-Dienstprogramm bereit, um eine oder mehrere Dateien und/oder Verzeichnisse (alle ausführbaren Dateien in jedem Verzeichnis) automatisch parallel zu exportieren. Es unterstützt sowohl IDA Pro als auch Ghidra als Backends:
$ 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
Standardmäßig wird die .quokka-Datei neben der Eingabebinärdatei abgelegt (z. B. erzeugt /usr/bin/ls die Datei /usr/bin/ls.quokka). Mit -o können Sie dies durch einen direkten Pfad oder eine Vorlage überschreiben, die pro Datei expandiert wird (%f = Stammname, %F = Dateiname, %p = übergeordnetes Verzeichnis, %P = vollständiger Pfad, %e = Erweiterung, %% = literales %).
Führen Sie quokka-cli --help aus, um alle Optionen zu sehen. Die wichtigsten Flags sind:
-b, --backend: wählt das Disassembler-Backend (ida, ghidra oder auto)-i, --ida-path: Pfad zum IDA-Installationsverzeichnis (der Ordner, der idat enthält)--ghidra-path: Pfad zum Ghidra-Installationsverzeichnis (überschreibt GHIDRA_INSTALL_DIR)-o, --output: legt den Ausgabepfad oder die Vorlage fest (Standard: %F.quokka)-m, --mode: wählt den Exportmodus (light oder full)--decompiled: aktiviert den Export dekompilierten Codes (nur IDA)-v, --verbose: aktiviert ausführliche Protokollierungimport 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)
Die vollständige Dokumentation zum Bearbeiten enthält Details zum Umbenennen von Funktionen, Festlegen von Prototypen und mehr.
Der Erstellungsprozess hängt von der verwendeten Version des IDA SDK ab. Diese beiden Modi werden auch als der neue Modus und der alte Modus bezeichnet.
Das IDA SDK wurde endlich als Open Source veröffentlicht, sodass es nicht mehr separat heruntergeladen werden muss.
Sie können die CMake-Option -DIDA_VERSION=<major>.<minor> verwenden, um es automatisch von GitHub zu synchronisieren.
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
Da das IDA SDK weiterhin proprietärer Code ist, müssen Sie es selbst herunterladen und seinen Pfad über die Option -DIdaSdk_ROOT_DIR:STRING=path/to/sdk an CMake übergeben.
HINWEIS: Dies funktioniert auch mit neueren Versionen, erfordert aber mehr Schritte vom Benutzer, da dieser das SDK selbst herunterladen muss.
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
Um das Plugin zu installieren:
user@host:~/quokka$ cmake --install build
In jedem Fall befindet sich das Plugin auch in build/quokka-install. Sie können es in das Benutzer-Plugin-Verzeichnis von IDA kopieren.
user@host:~/quokka$ cp build/quokka-install/quokka_plugin.so $HOME/.idapro/plugins/
Weitere detaillierte Informationen zum Erstellen finden Sie unter Erstellen
Die Dokumentation ist online unter Dokumentation verfügbar.
Eine Liste von Fragen finden Sie hier: FAQ
Hinweis: Derzeit ist nur der LIGHT-Modus implementiert. Der FULL-Modus (in sich geschlossen) ist geplant, aber noch nicht funktionsfähig.
Quokka bietet zwei Modi zum Exportieren der Disassemblierungs-Analyse: den Light-Modus und den Self-contained-Modus.
Der Light-Modus konzentriert sich auf den Export nur der wesentlichen Informationen und erzeugt schnelle und schlanke Dateien. In diesem Modus werden keine Informationen auf Anweisungsebene oder darunter exportiert, sodass die Capstone-Engine zur Laufzeit verwendet wird, um die Disassemblierung der Anweisungen zu erhalten.
Der Self-contained-Modus exportiert dagegen die vollständige Disassemblierung, genau so, wie das Backend-Disassembler sie anzeigt. Dies erzeugt schwerere Dateien, erfordert aber keine Abhängigkeit von Drittanbieter-Disassemblern zur Laufzeit.
Es ist wichtig zu beachten, dass beide Modi in den Python-Bindings dieselbe API bieten.
[!WARNING] Aus dem Self-contained-Modus ist es weiterhin möglich, das Capstone-Instruktionsobjekt zu erhalten, aber beachten Sie, dass die Capstone-Disassemblierung von der durch Quokka exportierten abweichen kann (Anweisungen können aufgeteilt, zusammengeführt, nicht unterstützt, mit anderen Mnemonics usw. sein). Im Allgemeinen erzeugen verschiedene Binäranalyse-Plattformen unterschiedliche Disassemblierungen; denken Sie daran, wenn Sie Capstone mit dem Self-contained-Modus kombinieren.
Eine vollständige Übersicht über die Unterschiede zwischen den beiden Modi finden Sie in der folgenden Tabelle:
| Light-Modus | Self-contained-Modus | |
|---|---|---|
| Funktionen | ✅ | ✅ |
| Basisblöcke | ✅ | ✅ |
| Anweisungen | ❌ | ✅ |
| Operanden | ❌ | ✅ |
| Datenreferenzen | ✅ | ✅ |
| Querverweise | ✅ | ✅ |
| Abschnitte/Layout | ✅ | ✅ |
| Dekompilierung | ✅¹ | ✅¹ |
| CFG-Zeichnungskoordinaten | ✅¹² | ✅¹² |
¹ Optional aktivierbar
² Derzeit nicht unterstützt