Quokka

imagem gerada por DALL-E

---

Índice

• Introdução
• Instalação
• Uso
• Compilação
• Documentação
• FAQ

Introdução

Quokka é um exportador de binários: a partir da desmontagem de um programa, ele gera um arquivo de exportação que pode ser usado sem o desmontador. Atualmente, ele suporta IDA Pro, Ghidra e Binary Ninja como backends de desmontagem.

O principal objetivo do Quokka é permitir manipular completamente o binário sem nunca abrir um desmontador após a exportação inicial. Além disso, ele abstrai a API do desmontador para expor uma interface limpa aos usuários.

Quokka é fortemente inspirado pelo BinExport, o exportador de binários usado pelo BinDiff.

Arquitetura

     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)

Instalação

Plugin Python

O plugin é construído no CI e está disponível no registro.

Deve ser possível instalar diretamente pelo PIP usando um comando deste tipo:

$ pip install quokka-project

Plugin IDA

Nota: O plugin do IDA não é necessário para ler um arquivo gerado por Quokka. Ele é usado apenas para gerá-los.

Quokka é compatível com IDA 9.1+.

Via o gerenciador de plugins do IDA (IDA 9.2+)

Quokka é publicado no repositório de plugins da Hex-Rays e pode ser instalado com hcli:

user@host:~$ hcli plugin install quokka

Manualmente

O plugin também é construído no CI e está disponível na aba Releases.

Para baixar o plugin, obtenha o arquivo chamado quokka_plugin.so (ou o arquivo quokka-ida<version>.zip para a sua versão do IDA) e copie-o para o diretório plugins do seu IDA.

Extensão Ghidra

Quokka também suporta exportação a partir do Ghidra (>= 12.0.3) por meio de uma extensão dedicada. Ela produz os mesmos arquivos protobuf .quokka que a biblioteca Python pode carregar.

Para instruções de compilação, instalação e detalhes de uso, consulte o README da extensão Ghidra.

Extensão BinaryNinja

Quokka também suporta exportação a partir do Binary Ninja por meio de um plugin Python. Ele produz os mesmos arquivos protobuf .quokka que a biblioteca Python pode carregar.

Para detalhes de instalação e uso, consulte o README da extensão BinaryNinja.

Uso

Exportação via GUI

A primeira forma manual de exportar um binário é usar o plugin dentro do IDA Pro. O atalho padrão no IDA é Alt+A. Ele abre o seguinte diálogo:

Os modos disponíveis são:

• LIGHT: Exporta apenas dados em nível de bloco (as instruções são decodificadas em tempo de execução pelo Capstone a partir dos bytes originais do binário)
• FULL: Exporta instruções e operandos (modo autocontido, não requer o binário original para desmontagem)

Nota: O modo FULL ainda não foi implementado. Apenas o modo LIGHT é funcional atualmente.

Exportação em modo headless

IDA

Nota: Isso requer uma instalação funcional do IDA.

$ idat -OQuokkaAuto:true -OQuokkaDecompiled:true -A /path/to/hello.i64

Todas as opções disponíveis estão descritas em Uso.

Nota: idat é usado em vez de ida para aumentar a velocidade de exportação, pois a interface gráfica não é necessária.

Ghidra

$ 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 o README da extensão Ghidra para mais detalhes.

Binary Ninja

Nota: o uso headless da API do Binary Ninja requer uma licença comercial. Sem uma, use o comando de exportação dentro da interface do Binary Ninja.

$ python binaryninja_extension/export_headless.py /path/to/binary \
    -o /path/to/output.quokka --mode LIGHT

Consulte o README da extensão BinaryNinja para mais detalhes.

Exportação via CLI

Quokka fornece uma ferramenta utilitária de CLI para exportar automaticamente um ou mais arquivos e/ou diretórios (todos os arquivos executáveis em cada diretório) em paralelo. Ele suporta tanto os backends IDA Pro quanto 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 padrão, o arquivo .quokka é colocado ao lado do binário de entrada (por exemplo, /usr/bin/ls produz /usr/bin/ls.quokka). Use -o para substituir isso por um caminho literal ou um modelo expandido por arquivo (%f = stem, %F = nome do arquivo, %p = diretório pai, %P = caminho completo, %e = extensão, %% = % literal).

Execute quokka-cli --help para ver todas as opções. Os principais flags incluem:

• -b, --backend para escolher o backend do desmontador (ida, ghidra ou auto)
• -i, --ida-path para fornecer o caminho do diretório de instalação do IDA (a pasta que contém idat)
• --ghidra-path para fornecer o diretório de instalação do Ghidra (substitui GHIDRA_INSTALL_DIR)
• -o, --output para definir o caminho de saída ou modelo (padrão: %F.quokka)
• -m, --mode para escolher o modo de exportação (light ou full)
• --decompiled para habilitar a exportação de código decompilado (apenas IDA)
• -v, --verbose para habilitar o log detalhado

Carregando um arquivo de exportação

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

Editando e adicionando tipos

# 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)