Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
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.

··Feeds·Contato·Privacidade·© 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.1k7967há 1 diaRevisado 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.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Documentation Status Downloads Chat on Telegram

Casos de uso do Qiling, blog e trabalhos relacionados

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.
  • 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
    • Black Hat, MEA

    2021:

    • Black Hat, USA
    • Hack In The Box, Amsterdam
    • Black Hat, Asia

    2020:

    • Black Hat, Europe
    • Black Hat, USA
    • Black Hat, USA (Demigod)
    • Black Hat, Asia
    • Hack In The Box, Lockdown 001
    • Hack In The Box, Lockdown 002
    • Hack In The Box, Cyberweek
    • Nullcon

    2019:

    • DEFCON, USA
    • Hitcon
    • Zeronights

    Qiling é apoiado pelo Unicorn Engine.

    Visite nosso site 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 e QEMU user mode. 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 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.

    root@kitploit:~
    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".
    root@kitploit:~
    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

    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

    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

    Emulando MBR

    Qiling Framework emula MBR

    Demonstração Qiling: Emulando MBR

    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:

    root@kitploit:~
    $ ./qltool code --os linux --arch arm --format hex -f examples/shellcodes/linarm32_tcp_reverse_shell.hex

    Com arquivo binário:

    root@kitploit:~
    $ ./qltool run -f examples/rootfs/x8664_linux/bin/x8664_hello --rootfs  examples/rootfs/x8664_linux/

    Com binário e depurador GDB habilitado:

    root@kitploit:~
    $ ./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):

    root@kitploit:~
    $ ./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):

    root@kitploit:~
    $ ./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.

    Desenvolvedores principais, Principais Contribuidores etc.

    Por favor, consulte CREDITS.md.

    Baixar ferramenta