qiling v1.4.11 — A True Instrumentable Binary Emulation Framework

Cas d'utilisation de Qiling, blog et travaux connexes

Qiling est un framework avancé d'émulation binaire, avec les fonctionnalités suivantes :

Émuler multi-plateformes : Windows, macOS, Linux, Android, BSD, UEFI, DOS, MBR.
Émuler multi-architectures : 8086, X86, X86_64, ARM, ARM64, MIPS, RISC-V, PowerPC.
Prend en charge plusieurs formats de fichiers : PE, Mach-O, ELF, COM, MBR.
Prend en charge les pilotes Windows (.sys), les modules noyau Linux (.ko) et les extensions noyau macOS (.kext) via Demigod.
Émule et isole le code dans un environnement cloisonné.
Fournit un sandbox entièrement configurable.
Fournit une API approfondie au niveau mémoire, registre, système d'exploitation et système de fichiers.
Instrumentation fine : permet de placer des hooks à différents niveaux (instruction / bloc de base / accès mémoire / exception / appel système / E/S, etc.)
Fournit des API de niveau machine virtuelle telles que la sauvegarde et la restauration de l'état d'exécution actuel.
Prend en charge les capacités de débogage cross-architecture et cross-platform.
Débogueur intégré avec capacité de débogage inversé.
Permet le hot patch dynamique du code en cours d'exécution, y compris la bibliothèque chargée.
Véritable framework en Python, facilitant la construction d'outils d'analyse de sécurité personnalisés.

Qiling s'est également fait une place dans diverses conférences internationales.

2022 :

2021 :

2020 :

2019 :

Qiling est soutenu par Unicorn Engine.

Visitez notre site web pour plus d'informations.

Licence

Ce programme est un logiciel libre ; vous pouvez le redistribuer et/ou le modifier selon les termes de la GNU General Public License telle que publiée par la Free Software Foundation ; soit la version 2 de la Licence, ou (à votre choix) toute version ultérieure.

Qiling vs. autres émulateurs

Il existe de nombreux émulateurs open-source, mais deux projets sont les plus proches de Qiling : Unicorn et QEMU user mode. Cette section explique les principales différences entre Qiling et eux.

Qiling vs. Unicorn engine

Construit sur Unicorn, mais Qiling et Unicorn sont deux animaux différents.

Unicorn est simplement un émulateur de CPU, donc il se concentre sur l'émulation des instructions CPU, qui peut comprendre la mémoire de l'émulateur. Au-delà, Unicorn ne connaît pas les concepts de haut niveau, tels que les bibliothèques dynamiques, les appels système, la gestion des E/S ou les formats exécutables comme PE, Mach-O ou ELF. En conséquence, Unicorn ne peut émuler que des instructions machine brutes, sans contexte de système d'exploitation (OS).
Qiling est conçu comme un framework de plus haut niveau, qui exploite Unicorn pour émuler les instructions CPU, mais peut comprendre l'OS : il dispose de chargeurs de formats exécutables (pour PE, Mach-O et ELF actuellement), d'éditeurs de liens dynamiques (pour charger et relocaliser les bibliothèques partagées), de gestionnaires d'appels système et d'E/S. Pour cette raison, Qiling peut exécuter un binaire exécutable sans nécessiter son OS natif.

Qiling vs. QEMU user mode

QEMU user mode fait une chose similaire à notre émulateur, c'est-à-dire émuler des binaires exécutables entiers de manière cross-architecture. Cependant, Qiling offre quelques différences importantes par rapport à QEMU user mode :

Qiling est un véritable framework d'analyse, qui vous permet de construire vos propres outils d'analyse dynamique par-dessus (en Python). Pendant ce temps, QEMU est simplement un outil, pas un framework.
Qiling peut effectuer de l'instrumentation dynamique, et peut même patcher du code à chaud pendant l'exécution. QEMU ne fait ni l'un ni l'autre.
Non seulement il fonctionne en cross-architecture, mais Qiling est également cross-platform. Par exemple, vous pouvez exécuter un fichier ELF Linux sur Windows. En revanche, QEMU user mode n'exécute que des binaires du même système d'exploitation, comme ELF Linux sur Linux, en raison de la façon dont il transmet les appels système du code émulé à l'OS natif.
Qiling prend en charge plus de plateformes, notamment Windows, macOS, Linux et BSD. QEMU user mode ne peut gérer que Linux et BSD.

Installation

Veuillez consulter le guide d'installation pour savoir comment installer Qiling Framework.

Exemples

L'exemple ci-dessous montre comment utiliser le framework Qiling de la manière la plus simple pour émuler un exécutable Windows.

from qiling import Qiling

if __name__ == "__main__":
    # initialise l'instance Qiling, en spécifiant l'exécutable à émuler et la racine du système émulé.
    # notez que le répertoire de travail actuel est supposé être le répertoire Qiling
    ql = Qiling([r'examples/rootfs/x86_windows/bin/x86_hello.exe'], r'examples/rootfs/x86_windows')

    # démarre l'émulation
    ql.run()

L'exemple suivant montre comment un crackme Windows peut être patché dynamiquement pour toujours afficher la boîte de dialogue "Félicitations".

from qiling import Qiling

def force_call_dialog_func(ql: Qiling):
    # récupère l'adresse de DialogFunc depuis la pile actuelle
    lpDialogFunc = ql.stack_read(-8)

    # configure la mémoire de la pile pour DialogFunc
    ql.stack_push(0)
    ql.stack_push(1001)     # IDS_APPNAME
    ql.stack_push(0x111)    # WM_COMMAND
    ql.stack_push(0)

    # pousse l'adresse de retour
    ql.stack_push(0x0401018)

    # reprend l'émulation depuis l'adresse de DialogFunc
    ql.arch.regs.eip = lpDialogFunc


if __name__ == "__main__":
    # initialise l'instance Qiling
    ql = Qiling([r'rootfs/x86_windows/bin/Easy_CrackMe.exe'], r'rootfs/x86_windows')

    # NOP sur du 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')

    # accroche une adresse avec un rappel
    ql.hook_address(force_call_dialog_func, 0x00401016)
    ql.run()

La vidéo YouTube ci-dessous montre comment l'exemple ci-dessus fonctionne.

Émulation du firmware d'un routeur ARM sur un hôte Ubuntu x64

Qiling Framework patch à chaud et émule /usr/bin/httpd d'un routeur ARM sur un hôte Ubuntu x86_64.

Plugin IDA Pro de Qiling : Instrumenter et déchiffrer le secret de Mirai

Cette vidéo montre comment le plugin IDA Pro de Qiling peut faire fonctionner IDA Pro avec le moteur d'instrumentation Qiling.

Serveur GDB avec démo IDA Pro

Résolution d'un défi CTF simple avec Qiling Framework et IDA Pro

Émulation MBR

Qiling Framework émule le MBR

Qltool

Qiling fournit également un outil convivial nommé qltool pour émuler rapidement des shellcodes et des binaires exécutables.

Avec qltool, une exécution facile peut être effectuée :

Avec un shellcode :

$ ./qltool code --os linux --arch arm --format hex -f examples/shellcodes/linarm32_tcp_reverse_shell.hex

Avec un fichier binaire :

$ ./qltool run -f examples/rootfs/x8664_linux/bin/x8664_hello --rootfs  examples/rootfs/x8664_linux/

Avec un binaire et le débogueur GDB activé :

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

Avec collecte de couverture de code (UEFI seulement 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 sur notre site web https://www.qiling.io

Contactez-nous par email à [email protected], via Twitter @qiling_io.

Développeurs principaux, contributeurs clés, etc.

Veuillez vous référer à CREDITS.md.

Lire plus