Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
qiling — Um Verdadeiro Framework de Emulação Binária Instrumentável | Kitploit
Ferramentas/GitHubGitHub/qilingframework/qiling
Frameworks de Testes de PenetraçãoAnálise Dinâmica (Sandboxing)ExploraçãoEngenharia ReversaDepuradoresFuzzingAnálise de MalwareAnálise de BináriosAprendizado e EducaçãoAnálise de FirmwareTop em Análise de Firmware nº19
6.1k796147há 2 mesesRevisado pelo Kitploit
GitHubqilingframework/qiling

qiling

Um Verdadeiro Framework de Emulação Binária Instrumentável

Ver RepositórioSite

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite, mas apenas USB e multiplataforma.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer é uma plataforma de código aberto de Gerenciamento de Acesso Privilegiado (PAM) que fornece às equipes de DevOps e TI acesso seguro e sob demanda a endpoints SSH, RDP, Kubernetes, Banco de Dados e RemoteApp através de um navegador web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hospedado e proxy reverso que filtra tráfego HTTP malicioso, bloqueia injeção SQL, XSS e ataques de bots, com limitação de taxa e criptografia dinâmica de HTML/JS.

    360

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar
[![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>

[Casos de uso do Qiling, blog e trabalhos relacionados](https://github.com/qilingframework/qiling/issues/134)

Qiling é um framework avançado de emulação binária, com as seguintes funcionalidades:

- Emular múltiplas plataformas: Windows, macOS, Linux, Android, BSD, UEFI, DOS, MBR.
- Emular múltiplas arquiteturas: 8086, X86, X86_64, ARM, ARM64, MIPS, RISC-V, PowerPC.
- Suportar múltiplos formatos de arquivo: PE, Mach-O, ELF, COM, MBR.
- Suportar Driver Windows (.sys), Módulo de Kernel Linux (.ko) e Kernel macOS (.kext) via [Demigod](https://groundx.io/demigod/).
- Emula e isola código em um ambiente isolado.
- Fornece um sandbox totalmente configurável.
- Fornece APIs detalhadas de memória, registradores, nível de sistema operacional e sistema de arquivos.
- Instrumentação de granulação fina: permite hooks em vários níveis (instrução/bloco básico/acesso à memória/exceção/syscall/E/S/etc.).
- Fornece API de nível de máquina virtual, como salvar e restaurar o estado atual de execução.
- Suporta capacidades de depuração entre arquiteturas e plataformas.
- Depurador integrado com capacidade de depuração reversa.
- Permite hot patch dinâmico em código em execução, incluindo bibliotecas carregadas.
- Framework verdadeiro em Python, facilitando a construção de ferramentas de análise de segurança personalizadas.

Qiling também marcou presença em várias conferências internacionais.

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 é apoiado pelo [Unicorn Engine](http://www.unicorn-engine.org).

Visite nosso [site](https://www.qiling.io) para mais informações.

---
#### Licença

Este programa é software livre; você pode redistribuí-lo e/ou modificá-lo sob os termos da GNU General Public License conforme publicada pela Free Software Foundation; seja a versão 2 da Licença, ou (a seu critério) qualquer versão posterior.

---

#### Qiling vs. outros Emuladores

Existem muitos emuladores de código aberto, mas dois projetos mais próximos do Qiling são [Unicorn](http://www.unicorn-engine.org) e [QEMU user mode](https://qemu.org). Esta seção explica as principais diferenças do Qiling em relação a eles.

##### Qiling vs. Unicorn engine

Construído sobre o Unicorn, mas Qiling e Unicorn são dois animais diferentes.

- Unicorn é apenas um emulador de CPU, então foca em emular instruções de CPU, que podem entender a memória do emulador. Além disso, Unicorn não tem conhecimento de conceitos de nível superior, como bibliotecas dinâmicas, chamadas de sistema, manipulação de E/S ou formatos executáveis como PE, Mach-O ou ELF. Como resultado, Unicorn só pode emular instruções de máquina brutas, sem contexto de Sistema Operacional (SO).
- Qiling foi projetado como um framework de nível superior, que aproveita o Unicorn para emular instruções de CPU, mas pode entender o SO: ele possui carregadores de formato executável (atualmente para PE, Mach-O e ELF), vinculadores dinâmicos (para carregar e realocar bibliotecas compartilhadas), manipuladores de syscall e E/S. Por essa razão, o Qiling pode executar binários executáveis sem exigir seu SO nativo.

##### Qiling vs. QEMU user mode

O modo de usuário do QEMU faz algo semelhante ao nosso emulador, ou seja, emular binários executáveis completos de forma cross-architecture. No entanto, o Qiling oferece algumas diferenças importantes em relação ao modo de usuário do QEMU:

- Qiling é um verdadeiro framework de análise, que permite construir suas próprias ferramentas de análise dinâmica em cima (em Python). Enquanto isso, QEMU é apenas uma ferramenta, não um framework.
- Qiling pode realizar instrumentação dinâmica e até mesmo hot patch de código em tempo de execução. O QEMU não faz nenhum dos dois.
- Não apenas funciona cross-architecture, mas o Qiling também é cross-platform. Por exemplo, você pode executar um arquivo ELF Linux no Windows. Em contraste, o modo de usuário do QEMU só executa binários do mesmo SO, como ELF Linux no Linux, devido à forma como encaminha syscalls do código emulado para o SO nativo.
- Qiling suporta mais plataformas, incluindo Windows, macOS, Linux e BSD. O modo de usuário do QEMU só pode lidar com Linux e BSD.

---

#### Instalação

Por favor, consulte o [guia de instalação](https://github.com/qilingframework/qiling/wiki/Installation) para saber como instalar o Qiling Framework.

---

#### Exemplos

O exemplo abaixo mostra como usar o framework Qiling da maneira mais direta para emular um executável 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()
```

- O exemplo a seguir mostra como um crackme do Windows pode ser corrigido dinamicamente para sempre exibir a caixa de diálogo "Congratulation".

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

O vídeo do YouTube abaixo mostra como o exemplo acima funciona.

#### Emulando firmware de roteador ARM no host Ubuntu x64

O Qiling Framework faz hot-patch e emula o `/usr/bin/httpd` de um roteador ARM em um host Ubuntu x86_64.

[![Tutorial Qiling: Emulando e Fazendo Fuzz de Firmware de Roteador 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 do Qiling para IDA Pro: Instrumentar e Decifrar o Segredo do Mirai

Este vídeo demonstra como o plugin do Qiling para IDA Pro pode fazer o IDA Pro rodar com o motor de instrumentação do Qiling.

[![Plugin do Qiling para IDA Pro: Instrumentar e Decifrar o Segredo do Mirai](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](http://www.youtube.com/watch?v=ZWMWTq2WTXk)

#### Servidor GDB com demonstração do IDA Pro

Resolvendo um desafio CTF simples com Qiling Framework e IDA Pro

[Resolvendo um desafio CTF simples com Qiling Framework e IDA Pro](https://www.youtube.com/watch?v=SPjVAt2FkKA)


#### Emulando MBR

Qiling Framework emula MBR

[![Demonstração Qiling: Emulando MBR](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 também fornece uma ferramenta amigável chamada `qltool` para emular rapidamente shellcode e binários executáveis.

Com o qltool, a execução fácil pode ser realizada:


Com shellcode:

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

Com arquivo binário:

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

Com binário e depurador GDB habilitado:

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

Com coleta de cobertura de código (apenas UEFI por enquanto):

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

Com saída JSON (principalmente Windows):

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


#### Contato

Obtenha as informações mais recentes em nosso site https://www.qiling.io

Contate-nos pelo e-mail [email protected], via Twitter [@qiling_io](https://twitter.com/qiling_io).

---

#### Desenvolvedores principais, Principais Contribuidores etc.

Por favor, consulte [CREDITS.md](https://github.com/qilingframework/qiling/blob/dev/CREDITS.md).
Baixar ferramenta