Página Inicial>Código fonte JSP>Outras categorias
Baixar

USECASE de Qiling, blog e trabalho relacionado

Qiling é uma estrutura avançada de emulação binária, com os seguintes recursos:

  • Emular várias plataformas: Windows, MacOS, Linux, Android, BSD, UEFI, DOS, MBR, Ethereum Virtual Machine
  • Emular Multi-Architectures: 8086, x86, x86_64, braço, arm64, mips, riscv, powerpc
  • Suportar vários formatos de arquivo: PE, Macho, Elf, Com, MBR
  • Suporte Windows Driver (.sys), módulo Linux Kernel (.ko) e kernel macOS (.Kext) via semideus
  • Emula e o código da caixa de areia em um ambiente isolado
  • Fornece uma caixa de areia totalmente configurável
  • Fornece memória aprofundada, registro, nível do sistema operacional e API no nível do sistema de arquivos
  • Instrumentação de grãos finos: permite ganchos em vários níveis (instrução/básico/acesso à memória/exceção/syscall/io/etc)
  • Fornece API de nível de máquina virtual, como salvar e restaurar o estado de execução atual
  • Suporta recursos de arquitetura cruzada e depuração da plataforma
  • Depurador embutido com capacidade de depuração reversa
  • Permite o código dinâmico de execução do Hotpatch on-the-fly, incluindo a biblioteca carregada
  • True Framework in Python, facilitando a criação de ferramentas de análise de segurança personalizadas no topo

Qiling também chegou a várias conferências internacionais.

2022:

  • Chapéu preto, UE
  • Chapéu preto, mea

2021:

  • Chapéu preto, EUA
  • Hack in the Box, Amsterdã
  • Chapéu preto, Ásia

2020:

  • Chapéu preto, Europa
  • Chapéu preto, EUA
  • Chapéu preto, EUA (semideus)
  • Chapéu preto, Ásia
  • Hackear na caixa, bloqueio 001
  • Hackear na caixa, bloqueio 002
  • Hack in the Box, Cyberweek
  • NullCon

2019:

  • Defcon, EUA
  • HitCon
  • Zeronights

Qiling é apoiado pelo motor unicórnio.

Visite nosso site https://www.qiling.io para obter mais informações.

Licença

Este projeto é lançado e distribuído sob licença de software livre GPLV2 e 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 & Qemu Usermode. Esta seção explica as principais diferenças de qiling contra eles.

Motor Qiling vs Unicorn

Construídos em cima do unicórnio, mas Qiling & Unicorn são dois animais diferentes.

  • O Unicorn é apenas um emulador de CPU, por isso se concentra em emular instruções da CPU, que podem entender a memória do emulador. Além disso, o Unicorn não está ciente de conceitos de nível superior, como bibliotecas dinâmicas, chamadas de sistema, manuseio de E/S ou formatos executáveis ​​como PE, machista ou elfo. Como resultado, o unicórnio só pode emular instruções de máquina crua, sem o contexto do sistema operacional (OS)
  • O QILING é projetado como uma estrutura de nível superior, que aproveita o Unicorn para imitar instruções da CPU, mas pode entender o sistema operacional: possui carregadores de formato executáveis ​​(para PE, Macho & Elf no momento), ligantes dinâmicos (para que possamos carregar e realocar bibliotecas compartilhadas), manipuladores SySCall e IO. Por esse motivo, o qiling pode executar binário executável sem exigir seu sistema operacional nativo
Qiling vs qemu Usermode

O Qemu Usermode faz coisas semelhantes ao nosso emulador, ou seja, para imitar binários executáveis ​​inteiros de maneira cruzada. No entanto, o Qiling oferece algumas diferenças importantes contra o Qemu Usermode.

  • O Qiling é uma estrutura de análise verdadeira, que permite criar 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é o código do hotpatch em tempo de execução. Qemu também não faz
  • Não apenas o trabalho cruzado, o Qiling também é de plataforma cruzada; portanto, por exemplo, você pode executar o arquivo elf Linux no topo do Windows. Por outro lado, o Qemu Usermode executa apenas o binário do mesmo sistema operacional, como o Linux Elf no Linux, devido à maneira como ele encaminha o syscall do código emulado para o SO nativo
  • O QILING suporta mais plataformas, incluindo Windows, MacOS, Linux e BSD. Qemu Usermode pode lidar apenas com Linux & BSD

Instalação

Consulte o arquivo do guia de configuração para instalar a estrutura QILING.

Exemplos

  • O exemplo abaixo mostra como usar a estrutura QILING na maneira mais Striiaghtforward de emular um executável do Windows. 
 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 Windows Crackme pode ser corrigido dinamicamente para fazê -lo sempre exibir a caixa de diálogo "Parabéns". 
 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 abaixo do YouTube mostra como o exemplo acima funciona.

Firmware do roteador de braço emulador na máquina Ubuntu X64

  • QILING Framework Hot-Patch e emula o roteador de braço/usr/bin/httpd em um x86_64bit ubuntu

Tutorial Qiling: Emulando e Fuzz Fuzz Arm Firmware

O plugin IDAPro de Qiling: instrumento e descriptografar o segredo de Mirai

  • Este vídeo demonstra como o plug -in IDAPro do Qiling é capaz de fazer o IDAPRO RUN With Qiling Instrumentation Engine

Gdbserver com demonstração IDAPRO

  • Resolvendo um desafio simples de CTF com Qiling Framework e IDAPRO

Emulando mbr

  • Qiling Framework emula MBR

Demo Qiling: Emulando MBR

Qltool

O Qiling também fornece uma ferramenta amigável chamada qltool para imitar rapidamente os binários de código de shell e 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 o depurador binário e GDB Ativar: 

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

Com a coleção 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 a saída JSON (principalmente o 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 do nosso site https://www.qiling.io

Entre em contato conosco em e -mail [email protected], ou via Twitter @qiling_io ou weibo

Desenvolvedores principais, principais colaboradores e etc

Consulte Credits.MD

Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos