qiling v1.4.11 — A True Instrumentable Binary Emulation Framework

El caso de uso de Qiling, blog y trabajo relacionado

Qiling es un framework avanzado de emulación binaria, con las siguientes características:

Emula múltiples plataformas: Windows, macOS, Linux, Android, BSD, UEFI, DOS, MBR.
Emula múltiples arquitecturas: 8086, X86, X86_64, ARM, ARM64, MIPS, RISC-V, PowerPC.
Soporta múltiples formatos de archivo: PE, Mach-O, ELF, COM, MBR.
Soporta controladores de Windows (.sys), módulos del kernel de Linux (.ko) y kernel de macOS (.kext) a través de Demigod.
Emula y aísla código en un entorno controlado.
Proporciona un entorno de pruebas completamente configurable.
Proporciona API detalladas a nivel de memoria, registros, sistema operativo y sistema de archivos.
Instrumentación de grano fino: permite hooks en varios niveles (instrucción/bloque básico/acceso a memoria/excepción/syscall/IO/etc.).
Proporciona API a nivel de máquina virtual, como guardar y restaurar el estado de ejecución actual.
Soporta capacidades de depuración entre arquitecturas y plataformas.
Depurador integrado con capacidad de depuración inversa.
Permite parches dinámicos en caliente sobre el código en ejecución, incluyendo librerías cargadas.
Framework real en Python, facilitando la creación de herramientas personalizadas de análisis de seguridad.

Qiling también ha estado presente en varias conferencias internacionales.

2022:

2021:

2020:

2019:

Qiling está respaldado por Unicorn Engine.

Visita nuestro sitio web para más información.

Licencia

Este programa es software libre; puedes redistribuirlo y/o modificarlo bajo los términos de la GNU General Public License publicada por la Free Software Foundation; ya sea la versión 2 de la Licencia, o (a tu elección) cualquier versión posterior.

Qiling vs. otros Emuladores

Hay muchos emuladores de código abierto, pero los dos proyectos más cercanos a Qiling son Unicorn y QEMU user mode. Esta sección explica las principales diferencias de Qiling con respecto a ellos.

Qiling vs. Unicorn engine

Construido sobre Unicorn, pero Qiling y Unicorn son dos animales diferentes.

Unicorn es solo un emulador de CPU, por lo que se centra en emular instrucciones de CPU, y puede entender la memoria del emulador. Más allá de eso, Unicorn no conoce conceptos de alto nivel, como librerías dinámicas, llamadas al sistema, manejo de E/S o formatos ejecutables como PE, Mach-O o ELF. Como resultado, Unicorn solo puede emular instrucciones de máquina en bruto, sin contexto de Sistema Operativo (SO).
Qiling está diseñado como un framework de nivel superior, que aprovecha Unicorn para emular instrucciones de CPU, pero puede entender el SO: tiene cargadores de formatos ejecutables (para PE, Mach-O y ELF actualmente), enlazadores dinámicos (para cargar y reubicar librerías compartidas), manejadores de syscall y E/S. Por esta razón, Qiling puede ejecutar binarios ejecutables sin necesidad de su SO nativo.

Qiling vs. QEMU user mode

QEMU user mode hace algo similar a nuestro emulador, es decir, emular binarios ejecutables completos de manera entre arquitecturas. Sin embargo, Qiling ofrece algunas diferencias importantes frente a QEMU user mode:

Qiling es un framework de análisis real, que permite construir tus propias herramientas de análisis dinámico sobre él (en Python). Mientras tanto, QEMU es solo una herramienta, no un framework.
Qiling puede realizar instrumentación dinámica, e incluso puede parchear código en caliente en tiempo de ejecución. QEMU no hace ninguna de las dos.
No solo funciona entre arquitecturas, Qiling también es multiplataforma. Por ejemplo, puedes ejecutar un archivo ELF de Linux sobre Windows. En contraste, QEMU user mode solo ejecuta binarios del mismo SO, como ELF de Linux en Linux, debido a la forma en que reenvía syscalls del código emulado al SO nativo.
Qiling soporta más plataformas, incluyendo Windows, macOS, Linux y BSD. QEMU user mode solo puede manejar Linux y BSD.

Instalación

Consulta la guía de instalación para saber cómo instalar Qiling Framework.

Ejemplos

El siguiente ejemplo muestra cómo usar Qiling framework de la manera más directa para emular un ejecutable de 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()

El siguiente ejemplo muestra cómo un crackme de Windows puede ser parcheado dinámicamente para que siempre muestre el diálogo de "Felicidades".

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

El siguiente video de YouTube muestra cómo funciona el ejemplo anterior.

Emulación de firmware de router ARM en host Ubuntu x64

Qiling Framework realiza parches en caliente y emula el /usr/bin/httpd de un router ARM en un host x86_64 Ubuntu.

Plugin de Qiling para IDA Pro: Instrumentar y descifrar el secreto de Mirai

Este video demuestra cómo el plugin de Qiling para IDA Pro permite que IDA Pro funcione con el motor de instrumentación de Qiling.

Servidor GDB con demo de IDA Pro

Resolviendo un desafío CTF simple con Qiling Framework e IDA Pro

Emulación de MBR

Qiling Framework emula MBR

Qltool

Qiling también proporciona una herramienta amigable llamada qltool para emular rápidamente shellcode y binarios ejecutables.

Con qltool, se puede realizar una ejecución fácil:

Con shellcode:

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

Con archivo binario:

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

Con binario y depurador GDB habilitado:

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

Con recolección de cobertura de código (solo UEFI por ahora):

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

Con salida JSON (principalmente Windows):

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

Contacto

Obtén la información más reciente de nuestro sitio web https://www.qiling.io

Contáctanos por correo electrónico a [email protected], vía Twitter @qiling_io.

Desarrolladores principales, colaboradores clave, etc.

Consulta CREDITS.md.