qiling v1.4.11 — A True Instrumentable Binary Emulation Framework

Casi d'uso, blog e lavori correlati di Qiling

Qiling è un framework avanzato di emulazione binaria, con le seguenti caratteristiche:

Emula multi-piattaforma: Windows, macOS, Linux, Android, BSD, UEFI, DOS, MBR.
Emula multi-architetture: 8086, X86, X86_64, ARM, ARM64, MIPS, RISC-V, PowerPC.
Supporta molteplici formati di file: PE, Mach-O, ELF, COM, MBR.
Supporta driver Windows (.sys), moduli kernel Linux (.ko) e kernel macOS (.kext) tramite Demigod.
Emula e mette in sandbox il codice in un ambiente isolato.
Fornisce una sandbox completamente configurabile.
Fornisce API approfondite per memoria, registri, livello del sistema operativo e filesystem.
Strumentazione a grana fine: permette hook a vari livelli (istruzione/blocco base/accesso memoria/eccezione/syscall/IO/ecc.)
Fornisce API a livello di macchina virtuale come salvare e ripristinare lo stato di esecuzione corrente.
Supporta capacità di debug cross-architettura e cross-piattaforma.
Debugger integrato con capacità di debug inverso.
Permette patch dinamico a caldo del codice in esecuzione, incluse le librerie caricate.
Vero framework in Python, che rende facile costruire strumenti di analisi di sicurezza personalizzati sopra di esso.

Qiling si è anche fatto strada in varie conferenze internazionali.

2022:

2021:

2020:

2019:

Qiling è supportato da Unicorn Engine.

Visita il nostro sito web per maggiori informazioni.

Licenza

Questo programma è software libero; puoi ridistribuirlo e/o modificarlo secondo i termini della GNU General Public License come pubblicata dalla Free Software Foundation; sia la versione 2 della Licenza, o (a tua scelta) qualsiasi versione successiva.

Qiling vs. altri Emulatori

Esistono molti emulatori open-source, ma i due progetti più vicini a Qiling sono Unicorn e QEMU user mode. Questa sezione spiega le principali differenze di Qiling rispetto a essi.

Qiling vs. Unicorn engine

Costruito sopra Unicorn, ma Qiling e Unicorn sono due animali diversi.

Unicorn è solo un emulatore di CPU, quindi si concentra sull'emulazione delle istruzioni della CPU, che può comprendere la memoria dell'emulatore. Oltre a ciò, Unicorn non è a conoscenza di concetti di livello superiore, come librerie dinamiche, chiamate di sistema, gestione I/O o formati eseguibili come PE, Mach-O o ELF. Di conseguenza, Unicorn può emulare solo istruzioni macchina grezze, senza contesto del sistema operativo (OS).
Qiling è progettato come un framework di livello superiore, che sfrutta Unicorn per emulare le istruzioni della CPU, ma può comprendere il sistema operativo: ha caricatori di formati eseguibili (per PE, Mach-O e ELF attualmente), linker dinamici (così possiamo caricare e rilocare librerie condivise), gestori di syscall e I/O. Per questo motivo, Qiling può eseguire binari eseguibili senza richiedere il loro sistema operativo nativo.

Qiling vs. QEMU user mode

QEMU user mode fa una cosa simile al nostro emulatore, ovvero emulare interi binari eseguibili in modo cross-architettura. Tuttavia, Qiling offre alcune importanti differenze rispetto a QEMU user mode:

Qiling è un vero framework di analisi, che ti permette di costruire i tuoi strumenti di analisi dinamica sopra (in Python). Nel frattempo, QEMU è solo uno strumento, non un framework.
Qiling può eseguire strumentazione dinamica e può persino applicare patch a caldo al codice durante l'esecuzione. QEMU non fa nessuna delle due cose.
Non solo funziona in modo cross-architettura, Qiling è anche cross-piattaforma. Ad esempio, puoi eseguire un file ELF Linux su Windows. Al contrario, QEMU user mode esegue solo binari dello stesso sistema operativo, come ELF Linux su Linux, a causa del modo in cui inoltra le syscall dal codice emulato al sistema operativo nativo.
Qiling supporta più piattaforme, tra cui Windows, macOS, Linux e BSD. QEMU user mode può gestire solo Linux e BSD.

Installazione

Si prega di consultare il file guida all'installazione per come installare Qiling Framework.

Esempi

L'esempio seguente mostra come utilizzare Qiling framework nel modo più diretto per emulare un eseguibile Windows.

from qiling import Qiling

if __name__ == "__main__":
    # initialize Qiling instance, specifying the executable to emulate and the emulated system root.
    # note that the current working directory is assumed to be Qiling home
    ql = Qiling([r'examples/rootfs/x86_windows/bin/x86_hello.exe'], r'examples/rootfs/x86_windows')

    # start emulation
    ql.run()

L'esempio seguente mostra come un crackme Windows può essere patchato dinamicamente per fargli visualizzare sempre la finestra di dialogo "Congratulazioni".

from qiling import Qiling

def force_call_dialog_func(ql: Qiling):
    # get DialogFunc address from current stack frame
    lpDialogFunc = ql.stack_read(-8)

    # setup stack memory for DialogFunc
    ql.stack_push(0)
    ql.stack_push(1001)     # IDS_APPNAME
    ql.stack_push(0x111)    # WM_COMMAND
    ql.stack_push(0)

    # push return address
    ql.stack_push(0x0401018)

    # resume emulation from DialogFunc address
    ql.arch.regs.eip = lpDialogFunc


if __name__ == "__main__":
    # initialize Qiling instance
    ql = Qiling([r'rootfs/x86_windows/bin/Easy_CrackMe.exe'], r'rootfs/x86_windows')

    # NOP out some code
    ql.patch(0x004010B5, b'\x90\x90')
    ql.patch(0x004010CD, b'\x90\x90')
    ql.patch(0x0040110B, b'\x90\x90')
    ql.patch(0x00401112, b'\x90\x90')

    # hook at an address with a callback
    ql.hook_address(force_call_dialog_func, 0x00401016)
    ql.run()

Il video YouTube qui sotto mostra come funziona l'esempio sopra.

Emulazione del firmware del router ARM su host Ubuntu x64

Qiling Framework applica patch a caldo ed emula /usr/bin/httpd di un router ARM su un host Ubuntu x86_64.

Plugin IDA Pro di Qiling: Strumentazione e Decifratura del Segreto di Mirai

Questo video mostra come il plugin IDA Pro di Qiling può far funzionare IDA Pro con il motore di strumentazione di Qiling.

Demo del server GDB con IDA Pro

Risoluzione di una semplice sfida CTF con Qiling Framework e IDA Pro

Emulazione MBR

Qiling Framework emula MBR

Qltool

Qiling fornisce anche uno strumento amichevole chiamato qltool per emulare rapidamente shellcode e binari eseguibili.

Con qltool, è possibile eseguire facilmente:

Con shellcode:

$ ./qltool code --os linux --arch arm --format hex -f examples/shellcodes/linarm32_tcp_reverse_shell.hex

Con file binario:

$ ./qltool run -f examples/rootfs/x8664_linux/bin/x8664_hello --rootfs  examples/rootfs/x8664_linux/

Con binario e debugger GDB abilitato:

$ ./qltool run -f examples/rootfs/x8664_linux/bin/x8664_hello --gdb 127.0.0.1:9999 --rootfs examples/rootfs/x8664_linux

Con raccolta di copertura del codice (solo UEFI per ora):

$ ./qltool run -f examples/rootfs/x8664_efi/bin/TcgPlatformSetupPolicy --rootfs examples/rootfs/x8664_efi --coverage-format drcov --coverage-file TcgPlatformSetupPolicy.cov

Con output JSON (principalmente Windows):

$ ./qltool run -f examples/rootfs/x86_windows/bin/x86_hello.exe --rootfs  examples/rootfs/x86_windows/ --console False --json

Contatti

Ottieni le ultime informazioni dal nostro sito web https://www.qiling.io

Contattaci via email [email protected], tramite Twitter @qiling_io.

Sviluppatori principali, Contributori chiave e altro

Si prega di fare riferimento a CREDITS.md.