Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
qiling — Un verdadero framework de emulación binaria instrumentable | Kitploit
Herramientas/GitHubGitHub/qilingframework/qiling
Frameworks de Pruebas de PenetraciónAnálisis Dinámico (Sandboxing)ExplotaciónIngeniería InversaDepuradoresFuzzingAnálisis de MalwareAnálisis de BinariosAprendizaje y EducaciónAnálisis de FirmwareTop en Análisis de Firmware #19
6.1k796147hace 2 mesesRevisado por Kitploit
GitHubqilingframework/qiling

qiling

Un verdadero framework de emulación binaria instrumentable

Ver RepositorioSitio web

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite pero solo USB y multiplataforma.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer es una plataforma de gestión de accesos privilegiados (PAM) de código abierto que proporciona a los equipos de DevOps y TI acceso seguro y bajo demanda a endpoints SSH, RDP, Kubernetes, base de datos y RemoteApp a través de un navegador web.

    412
  • 6

    SafeLine

    chaitin/safeline

    Proxy inverso y WAF autoalojado que filtra tráfico HTTP malicioso, bloquea inyecciones SQL, XSS y ataques de bots, con limitación de velocidad y cifrado dinámico de HTML/JS.

    360

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir
[![Documentation Status](https://readthedocs.org/projects/qilingframework/badge/?version=latest)](https://docs.qiling.io)
[![Downloads](https://pepy.tech/badge/qiling)](https://pepy.tech/project/qiling)
[![Chat on Telegram](https://img.shields.io/badge/Chat%20on-Telegram-brightgreen.svg)](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.

[![Tutorial de Qiling: Emular y fuzzear firmware de router ARM](https://raw.githubusercontent.com/qilingframework/theme.qiling.io/master/source/img/fuzzer.jpg?raw=true)](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.

[![Plugin de Qiling para IDA Pro: Instrumentar y descifrar el secreto de Mirai](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](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

[![Emulación de MBR con Qiling](https://raw.githubusercontent.com/qilingframework/theme.qiling.io/master/source/img/mbr.png?raw=true)](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).
Descargar herramienta