Un verdadero framework de emulación binaria instrumentable
[](https://docs.qiling.io)
[](https://pepy.tech/project/qiling)
[](https://t.me/qilingframework)
---
<p align="center">
<img width="150" height="150" src="https://assets.kitploit.com/production/public/readmes/3159/adf57fddbda367ffba0fd5d69ca8efee6d89d296269a38dba5d23e4feeda22d8/67a3885438f12bafd77a6df1d19c4a79a6b63eb2d3044f2e1e046e634c1af49a-display-v1.webp">
</p>
[El caso de uso de Qiling, blog y trabajo relacionado](https://github.com/qilingframework/qiling/issues/134)
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](https://groundx.io/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:
- [Black Hat, EU](https://www.blackhat.com/eu-22/arsenal/schedule/#reversing-mcu-with-firmware-emulation-29553)
- [Black Hat, MEA](https://blackhatmea.com/node/724)
2021:
- [Black Hat, USA](https://www.blackhat.com/us-21/arsenal/schedule/index.html#bringing-the-x-complete-re-experience-to-smart-contract-24119)
- [Hack In The Box, Amsterdam](https://conference.hitb.org/hitbsecconf2021ams/sessions/when-qiling-framework-meets-symbolic-execution/)
- [Black Hat, Asia](https://www.blackhat.com/asia-21/arsenal/schedule/index.html#qiling-smart-analysis-for-smart-contract-22643)
2020:
- [Black Hat, Europe](https://www.blackhat.com/eu-20/arsenal/schedule/index.html#qiling-framework-deep-dive-into-obfuscated-binary-analysis-21781)
- [Black Hat, USA](https://www.blackhat.com/us-20/arsenal/schedule/index.html#qiling-framework-from-dark-to-dawn-----enlightening-the-analysis-of-the-most-mysterious-iot-firmware--21062)
- [Black Hat, USA (Demigod)](https://www.blackhat.com/us-20/briefings/schedule/#demigod-the-art-of-emulating-kernel-rootkits-20009)
- [Black Hat, Asia](https://www.blackhat.com/asia-20/arsenal/schedule/index.html#qiling-lightweight-advanced-binary-analyzer-19245)
- [Hack In The Box, Lockdown 001](https://conference.hitb.org/lockdown-livestream/)
- [Hack In The Box, Lockdown 002](https://conference.hitb.org/hitb-lockdown002/virtual-labs/virtual-lab-qiling-framework-learn-how-to-build-a-fuzzer-based-on-a-1day-bug/)
- [Hack In The Box, Cyberweek](https://cyberweek.ae/2020/lab-qiling-framework/)
- [Nullcon](https://nullcon.net/website/goa-2020/speakers/kaijern-lau.php)
2019:
- [DEFCON, USA](https://www.defcon.org/html/defcon-27/dc-27-demolabs.html#QiLing)
- [Hitcon](https://hitcon.org/2019/CMT/agenda)
- [Zeronights](https://zeronights.ru/report-en/qiling-io-advanced-binary-emulation-framework/)
Qiling está respaldado por [Unicorn Engine](http://www.unicorn-engine.org).
Visita nuestro [sitio web](https://www.qiling.io) 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](http://www.unicorn-engine.org) y [QEMU user mode](https://qemu.org).
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](https://github.com/qilingframework/qiling/wiki/Installation) 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.
```python
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".
```python
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.
[](https://www.youtube.com/watch?v=e3_T3KLh2NU)
#### 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.
[](http://www.youtube.com/watch?v=ZWMWTq2WTXk)
#### Servidor GDB con demo de IDA Pro
Resolviendo un desafío CTF simple con Qiling Framework e IDA Pro
[Resolviendo un desafío CTF simple con Qiling Framework e IDA Pro](https://www.youtube.com/watch?v=SPjVAt2FkKA)
#### Emulación de MBR
Qiling Framework emula MBR
[](https://github.com/qilingframework/theme.qiling.io/blob/master/source/img/mbr.png?raw=true)
---
#### 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](https://twitter.com/qiling_io).
---
#### Desarrolladores principales, colaboradores clave, etc.
Consulta [CREDITS.md](https://github.com/qilingframework/qiling/blob/dev/CREDITS.md).