
Qiling é uma estrutura de emulação binária avançada, com os seguintes recursos:
- Plataforma cruzada: Windows, MacOS, Linux, BSD
- Arquitetura cruzada: X86, X86_64, Arm, Arm64, Mips
- Vários formatos de arquivo: PE, MachO, ELF
- Emular e sandbox o código de máquina em um ambiente isolado
- Forneça API de alto nível para instalar e configurar a sandbox
- Instrumentação refinada: permita ganchos em vários níveis (instrução / bloco básico / acesso à memória / exceção / syscall / IO / etc)
- Permitir código de execução dinâmica de hotpatch on-the-fly, incluindo a biblioteca carregada
- Verdadeira estrutura em Python, facilitando a criação de ferramentas personalizadas de análise de segurança
O Qiling é suportado pelo mecanismo Unicorn .
Visite o site https://www.qiling.io para obter mais informações.
Qiling versus outros emuladores
Existem muitos emuladores de código aberto, mas dois projetos mais próximos ao Qiling são o modo de usuário Unicorn & Qemu . Esta seção explica as principais diferenças do Qiling contra eles.
Mecanismo Qiling vs Unicorn
Construído sobre o Unicorn, mas Qiling e Unicorn são dois animais diferentes.
- O Unicorn é apenas um emulador de CPU, portanto, ele se concentra na emulação de instruções da CPU, que podem entender a memória do emulador . Além disso, o 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, MachO ou ELF. Como resultado, o Unicorn só pode emular instruções brutas da máquina, sem o contexto do sistema operacional (SO).
- O Qiling foi projetado como uma estrutura de nível superior, que utiliza o Unicorn para emular instruções da CPU, mas pode entender o SO: possui carregadores de formatos executáveis (para PE, MachO e ELF no momento), vinculadores dinâmicos (para que possamos carregar e realocar bibliotecas compartilhadas ), syscall e manipuladores de IO. Por esse motivo, o Qiling pode executar o binário executável sem exigir seu SO nativo.
Modo de
usuário Qiling vs Qemu O modo de usuário Qemu faz algo semelhante ao nosso emulador, que é emular binários executáveis inteiros de maneira entre arquiteturas. No entanto, o Qiling oferece algumas diferenças importantes no modo de usuário do Qemu.
- O Qiling é uma estrutura de análise verdadeira, que permite que você construa suas próprias ferramentas de análise dinâmica no topo (na linguagem amigável do Python). Enquanto isso, o Qemu é apenas uma ferramenta, não uma estrutura.
- O Qiling pode executar instrumentação dinâmica e pode até mesmo hotpatch código em tempo de execução. O Qemu também não.
- Não apenas trabalhando com arquitetura cruzada, o Qiling também é multiplataforma, portanto, por exemplo, você pode executar o arquivo Linux ELF sobre o Windows. Por outro lado, o modo de usuário Qemu executa apenas binário do mesmo sistema operacional, como o Linux ELF no Linux, devido à maneira como encaminha o syscall do código emulado para o sistema operacional nativo.
- O Qiling suporta mais plataformas, incluindo Windows, MacOS, Linux e BSD. O modo de usuário do Qemu pode lidar apenas com Linux e BSD.
Instalar
Execute abaixo da linha de comando para instalar o Qiling (é necessário o Python3).
python3 setup.py install
Exemplos
- O exemplo abaixo mostra como usar a estrutura Qiling para emular um EXE do Windows em uma máquina Linux.
from qiling import *
# sandbox to emulate the EXE
def my_sandbox(path, rootfs):
# setup Qiling engine
ql = Qiling(path, rootfs)
# now emulate the EXE
ql.run()
if __name__ == "__main__":
# execute Windows EXE under our rootfs
my_sandbox(["examples/rootfs/x86_windows/bin/x86-windows-hello.exe"], "examples/rootfs/x86_windows")
- O exemplo abaixo mostra como usar a estrutura Qiling para corrigir dinamicamente um crackme do Windows, para que ele sempre exiba a caixa de diálogo “Parabéns”.
from qiling import *
def force_call_dialog_func(ql):
# get DialogFunc address
lpDialogFunc = ql.unpack32(ql.mem_read(ql.sp - 0x8, 4))
# setup stack memory for DialogFunc
ql.stack_push(0)
ql.stack_push(1001)
ql.stack_push(273)
ql.stack_push(0)
ql.stack_push(0x0401018)
# force EIP to DialogFunc
ql.pc = lpDialogFunc
def my_sandbox(path, rootfs):
ql = Qiling(path, rootfs)
# 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(0x00401016, force_call_dialog_func)
ql.run()
if __name__ == "__main__":
my_sandbox(["rootfs/x86_windows/bin/Easy_CrackMe.exe"], "rootfs/x86_windows")
Desenvolvedores principais
- LAU kaijern (xwings) kj@qiling.io
- NGUYEN Anh Quynh aquynh@gmail.com
- DING tianZe (D1iv3) dddliv3@gmail.com
- SUN bowen (w1tcher) w1tcher.bupt@gmail.com
- CHEN huitao (null) null@qiling.io
- YU tong (sp1ke) spikeinhouse@gmail.com