Usecase, blog et travail connexe de Qiling
Qiling est un cadre d'émulation binaire avancé, avec les caractéristiques suivantes:
- Imiter plusieurs plates-formes: Windows, MacOS, Linux, Android, BSD, UEFI, DOS, MBR, Ethereum Virtual Machine
- Imiter les architectures multi-architectes: 8086, x86, x86_64, arm, arm64, mips, RISCV, powerpc
- Prise en charge de plusieurs formats de fichiers: PE, Macho, Elf, Com, MBR
- Prise en charge du pilote Windows (.SYS), du module de noyau Linux (.ko) et du noyau macOS (.kext) via Demigod
- Émule et code bac à sable dans un environnement isolé
- Fournit un bac à sable entièrement configurable
- Fournit une mémoire approfondie, un enregistrement, un niveau de système d'exploitation et une API au niveau du système de fichiers
- Instrumentation à grains fines: permet des crochets à différents niveaux (instruction / bloc de base / mémoire / exception / syscall / io / etc.)
- Fournit une API de niveau de machine virtuelle telle que la sauvegarde et la restauration de l'état d'exécution actuel
- Prend en charge l'architecture croisée et les capacités de débogage de la plate-forme
- Débogueur intégré avec capacité de débogage inversé
- Permet un code d'exécution dynamique à la volée, y compris la bibliothèque chargée
- True Framework dans Python, ce qui facilite la création d'outils d'analyse de sécurité personnalisés en haut
Qiling a également fait son chemin vers diverses conférences internationales.
2022:
- Chapeau noir, UE
- Chapeau noir, mea
2021:
- Chapeau noir, USA
- Pirater dans la boîte, Amsterdam
- Chapeau noir, Asie
2020:
- Chapeau noir, Europe
- Chapeau noir, USA
- Black Hat, États-Unis (demi-dieu)
- Chapeau noir, Asie
- Pirater dans la boîte, verrouillage 001
- Pirater dans la boîte, verrouillage 002
- Pirater dans la boîte, CyberWeek
- Nullcon
2019:
- DEFCON, USA
- Hitcon
- Zéronights
Qiling est soutenu par un moteur Unicorn.
Visitez notre site Web https://www.qiling.io pour plus d'informations.
Licence
Ce projet est publié et distribué sous la licence de logiciels gratuits GPLV2 et version ultérieure.
Qiling vs d'autres émulateurs
Il existe de nombreux émulateurs open source, mais deux projets les plus proches de Qiling sont la mode Unicorn et Qemu. Cette section explique les principales différences de Qilant contre eux.
Moteur Qiling vs Unicorn
Construit sur la licorne, mais Qiling & Unicorn sont deux animaux différents.
- Unicorn n'est qu'un émulateur de processeur, il se concentre donc sur l'émulation des instructions du processeur, qui peuvent comprendre la mémoire de l'émulateur. Au-delà de cela, Unicorn n'est pas conscient de concepts de niveau supérieur, tels que les bibliothèques dynamiques, les appels système, la manipulation d'E / S ou des formats exécutables comme PE, Macho ou ELF. En conséquence, la licorne ne peut imiter les instructions de la machine brute, sans contexte de système d'exploitation (OS)
- Qiling est conçu comme un cadre de niveau supérieur, qui exploite Unicorn pour imiter les instructions du processeur, mais peut comprendre le système d'exploitation: il a des chargeurs de format exécutables (pour PE, Macho & Elf en ce moment), Dynamic Linkers (afin que nous puissions charger et déplacer des bibliothèques partagées), Syscall & IO Handlers. Pour cette raison, Qiling peut exécuter un binaire exécutable sans nécessiter son système d'exploitation natif
Qiling vs Qemu Usermode
Qemu Usermode fait une chose similaire à notre émulateur, c'est-à-dire d'imiter des binaires exécutables entiers de manière inter-architecture. Cependant, Qiling propose des différences importantes contre le Qemu Usermode.
- Qiling est un véritable cadre d'analyse, qui vous permet de créer vos propres outils d'analyse dynamique en haut (en langue python amicale). Pendant ce temps, Qemu n'est qu'un outil, pas un cadre
- Qiling peut effectuer une instrumentation dynamique et peut même le code hotpatch au moment de l'exécution. Qemu ne fait pas non plus
- Non seulement fonctionne-architecture, mais Qilant est également multiplateforme, donc par exemple, vous pouvez exécuter le fichier ELF Linux en haut de Windows. En revanche, Qemu Usermode ne fonctionne que du binaire du même système d'exploitation, comme Linux Elf sur Linux, en raison de la façon dont il transmet le système de code imité au système d'exploitation natif
- Qiling prend en charge plus de plates-formes, notamment Windows, MacOS, Linux et BSD. Qemu Usermode ne peut gérer que Linux et BSD
Installation
Veuillez consulter le fichier de guide de configuration pour installer le framework Qiling.
Exemples
- L'exemple ci-dessous montre comment utiliser le framework Qiling dans la manière la plus strime pour imiter un exécutable 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 ()- L'exemple suivant montre comment un CrackMe Windows peut être corrigé dynamiquement pour qu'il affiche toujours la boîte de dialogue "Félicitations".
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 () La vidéo YouTube ci-dessous montre comment fonctionne l'exemple ci-dessus.
Firmware de routeur à bras émulé sur la machine Ubuntu X64
- Framework Qiling Patch et émule le routeur des bras / usr / bin / httpd sur un x86_64bit ubuntu
Plugin Idapro de Qiling: Instrument et décrypter le secret de Mirai
- Cette vidéo montre comment le plugin IDAPro de Qiling est capable de faire fonctionner IDAPRO avec le moteur d'instrumentation Qiling
GdbServer avec démo idapro
- Résoudre un simple défi CTF avec Qiling Framework et IDAPRO
Imiter MBR
- Le cadre Qiling émule MBR
Qltool
Qiling fournit également un outil convivial nommé qltool pour imiter rapidement Shellcode et les binaires exécutables.
Avec QLTool, une exécution facile peut être effectuée:
Avec shellcode:
$ ./qltool code --os linux --arch arm --format hex -f examples/shellcodes/linarm32_tcp_reverse_shell.hex
Avec fichier binaire:
$ ./qltool run -f examples/rootfs/x8664_linux/bin/x8664_hello --rootfs examples/rootfs/x8664_linux/
Avec le débogueur binaire et GDB activer:
$ ./qltool run -f examples/rootfs/x8664_linux/bin/x8664_hello --gdb 127.0.0.1:9999 --rootfs examples/rootfs/x8664_linux
Avec la collection de couverture du code (UEFI uniquement pour l'instant):
$ ./qltool run -f examples/rootfs/x8664_efi/bin/TcgPlatformSetupPolicy --rootfs examples/rootfs/x8664_efi --coverage-format drcov --coverage-file TcgPlatformSetupPolicy.cov
Avec sortie JSON (Windows principalement):
$ ./qltool run -f examples/rootfs/x86_windows/bin/x86_hello.exe --rootfs examples/rootfs/x86_windows/ --console False --json
Contact
Obtenez les dernières informations de notre site Web https://www.qiling.io
Contactez-nous sur email [email protected], ou via Twitter @qiling_io ou Weibo
Développeurs de base, contributeurs clés et etc.
Veuillez vous référer à crédits.md
