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

Baixar Qiling