quarkslab/quokkaQuokka: un exportador binario rápido y preciso
imagen generada por DALL-E
Quokka es un exportador de binarios: a partir del desensamblado de un programa, genera un archivo de exportación que se puede utilizar sin el desensamblador. Actualmente soporta IDA Pro, Ghidra y Binary Ninja como backends de desensamblado.
El objetivo principal de Quokka es permitir manipular completamente el binario sin tener que abrir nunca un desensamblador después de la exportación inicial. Además, abstrae la API del desensamblador para exponer una interfaz limpia a los usuarios.
Quokka está fuertemente inspirado en BinExport, el exportador de binarios utilizado por 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)
El plugin se compila en la CI y está disponible en el registro.
Debería ser posible instalarlo directamente desde PIP utilizando este tipo de comando:
$ pip install quokka-project
Nota: El plugin de IDA no es necesario para leer un archivo generado por Quokka. Solo se
utiliza para generarlos.
Quokka es compatible con IDA 9.1+.
Quokka se publica en el repositorio de plugins de Hex-Rays y se puede instalar con
hcli:
user@host:~$ hcli plugin install quokka
El plugin también se compila en la CI y está disponible en la pestaña Releases.
Para descargar el plugin, obtenga el archivo llamado quokka_plugin.so (o el
archivo quokka-ida<version>.zip para su versión de IDA) y cópielo en su
directorio plugins de IDA.
Quokka también admite la exportación desde Ghidra (>= 12.0.3) mediante una
extensión dedicada. Produce los mismos archivos protobuf .quokka que la
biblioteca de Python puede cargar.
Para obtener instrucciones de compilación, instalación y detalles de uso, consulte el README de la extensión de Ghidra.
Quokka también admite la exportación desde Binary Ninja mediante un plugin de Python.
Produce los mismos archivos protobuf .quokka que la biblioteca de Python puede cargar.
Para obtener detalles de instalación y uso, consulte el README de la extensión de BinaryNinja.
La primera forma manual de exportar un binario es utilizar el plugin dentro de IDA Pro.
El atajo predeterminado dentro de IDA es Alt+A. Abre el siguiente diálogo:
Los modos disponibles son:
Nota: El modo FULL aún no está implementado. Solo el modo LIGHT es funcional actualmente.
Nota: Esto requiere una instalación funcional de IDA.
$ idat -OQuokkaAuto:true -OQuokkaDecompiled:true -A /path/to/hello.i64
Todas las opciones disponibles se describen en Usage.
Nota: se utiliza idat en lugar de ida para aumentar la velocidad de exportación, ya que no se
necesita la interfaz gráfica.
$ 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
Consulte el README de la extensión de Ghidra para más detalles.
Nota: el uso headless de la API de Binary Ninja requiere una licencia comercial. Sin una, utilice el comando de exportación dentro de la interfaz de Binary Ninja.
$ python binaryninja_extension/export_headless.py /path/to/binary \
-o /path/to/output.quokka --mode LIGHT
Consulte el README de la extensión de BinaryNinja para más detalles.
Quokka proporciona una herramienta de utilidad CLI para exportar automáticamente uno o más archivos y/o directorios (todos los archivos ejecutables de cada directorio) en paralelo. Soporta tanto los backends de IDA Pro como el de 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
Por defecto, el archivo .quokka se coloca junto al binario de entrada (p. ej.
/usr/bin/ls produce /usr/bin/ls.quokka). Utilice -o para sobrescribir esto con una
ruta literal o una plantilla expandida por archivo (%f = nombre base, %F = nombre de archivo,
%p = directorio padre, %P = ruta completa, %e = extensión, %% = % literal).
Ejecute quokka-cli --help para ver todas las opciones. Las banderas clave incluyen:
-b, --backend para elegir el backend de desensamblado (ida, ghidra o auto)-i, --ida-path para proporcionar la ruta al directorio de instalación de IDA (la carpeta que contiene idat)--ghidra-path para proporcionar el directorio de instalación de Ghidra (sobrescribe GHIDRA_INSTALL_DIR)-o, --output para establecer la ruta o plantilla de salida (predeterminado: %F.quokka)-m, --mode para elegir el modo de exportación (light o full)--decompiled para habilitar la exportación de código descompilado (solo IDA)-v, --verbose para habilitar el registro detalladoimport 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)
Consulte la documentación de edición completa para obtener detalles sobre cómo renombrar funciones, establecer prototipos y más.
El proceso de compilación depende de la versión del SDK de IDA que esté utilizando. Estos dos modos también se denominan el modo nuevo y el modo antiguo.
El SDK de IDA finalmente ha sido publicado como código abierto, por lo que ya no es necesario descargarlo por separado.
Puede utilizar la opción de cmake -DIDA_VERSION=<major>.<minor> para sincronizarlo automáticamente desde 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
Dado que el SDK de IDA sigue siendo código propietario, debe obtenerlo usted mismo y proporcionar
su ruta a cmake mediante la opción -DIdaSdk_ROOT_DIR:STRING=path/to/sdk
NOTA: Esto también funcionará en versiones más recientes, pero requiere más pasos por parte de los usuarios, ya que tendrán que descargar el SDK ellos mismos.
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
Para instalar el plugin:
user@host:~/quokka$ cmake --install build
En cualquier caso, el plugin también estará en build/quokka-install. Puede
copiarlo al directorio de plugins de usuario de IDA.
user@host:~/quokka$ cp build/quokka-install/quokka_plugin.so $HOME/.idapro/plugins/
Para obtener información más detallada sobre la compilación, consulte Building
La documentación está disponible en línea en documentación
Puede ver una lista de preguntas aquí FAQ
Nota: Actualmente solo está implementado el modo LIGHT. El modo FULL (autocontenido) está planificado pero aún no es funcional.
Quokka ofrece dos modos para exportar el análisis del desensamblado: el modo ligero y el modo autocontenido.
El modo ligero se centra en exportar solo la información esencial, produciendo archivos rápidos y ligeros. En este modo no se exporta información a nivel de instrucción o inferior, por lo que el motor capstone se utilizará en tiempo de ejecución para obtener el desensamblado de las instrucciones.
El modo autocontenido, en cambio, exporta el desensamblado completo, exactamente como lo muestra el backend de desensamblado. Esto producirá archivos más pesados, pero no requiere depender de desensambladores de terceros en tiempo de ejecución.
Es importante señalar que ambos modos ofrecen la misma API en los bindings de Python.
[!WARNING] Desde el modo autocontenido todavía es posible obtener el objeto de instrucción de capstone, pero tenga en cuenta que el desensamblado de capstone puede diferir del exportado por quokka (las instrucciones pueden dividirse, fusionarse, no ser compatibles, tener diferentes mnemónicos, etc.). En general, diferentes plataformas de análisis de binarios producen desensamblados diferentes; tenga esto en cuenta al combinar capstone con el modo autocontenido.
Para una visión completa de la diferencia entre los dos modos, consulte la tabla siguiente:
| Light Mode | Self contained Mode | |
|---|---|---|
| Funciones | ✅ | ✅ |
| Bloques básicos | ✅ | ✅ |
| Instrucciones | ❌ | ✅ |
| Operandos | ❌ | ✅ |
| Referencias de datos | ✅ | ✅ |
| Referencias cruzadas | ✅ | ✅ |
| Secciones/Distribución | ✅ | ✅ |
| Descompilación | ✅¹ | ✅¹ |
| Coordenadas de dibujo del CFG | ✅¹² | ✅¹² |
¹ Habilitable opcionalmente
² Actualmente no soportado