Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/qilingframework/qiling
Frameworks de Tests d'IntrusionAnalyse Dynamique (Sandboxing)ExploitationRétro-ingénierieDébogueursFuzzingAnalyse de MalwareAnalyse de BinairesApprentissage et ÉducationAnalyse de MicrologicielTop en Analyse de Micrologiciel n°19
6.1k796147il y a 2 moisVérifié par Kitploit
GitHubqilingframework/qiling

qiling

Un véritable framework d'émulation binaire instrumentable

Voir le dépôtSite web

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite mais uniquement USB et multiplateforme.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer est une plateforme open-source de Gestion des Accès Privilégiés (PAM) qui offre aux équipes DevOps et IT un accès sécurisé et à la demande aux terminaux SSH, RDP, Kubernetes, bases de données et RemoteApp via un navigateur web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hébergé et proxy inverse qui filtre le trafic HTTP malveillant, bloque les injections SQL, les XSS et les attaques de robots, avec limitation de débit et chiffrement dynamique HTML/JS.

    360

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager
[![Documentation Status](https://readthedocs.org/projects/qilingframework/badge/?version=latest)](https://docs.qiling.io)
[![Downloads](https://pepy.tech/badge/qiling)](https://pepy.tech/project/qiling)
[![Chat on Telegram](https://img.shields.io/badge/Chat%20on-Telegram-brightgreen.svg)](https://t.me/qilingframework)

---

<p align="center">
<img width="150" height="150" src="https://assets.kitploit.com/production/public/readmes/3159/adf57fddbda367ffba0fd5d69ca8efee6d89d296269a38dba5d23e4feeda22d8/67a3885438f12bafd77a6df1d19c4a79a6b63eb2d3044f2e1e046e634c1af49a-display-v1.webp">
</p>

[Cas d'utilisation de Qiling, blog et travaux connexes](https://github.com/qilingframework/qiling/issues/134)

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](https://groundx.io/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 :
- [Black Hat, EU](https://www.blackhat.com/eu-22/arsenal/schedule/#reversing-mcu-with-firmware-emulation-29553)
- [Black Hat, MEA](https://blackhatmea.com/node/724)

2021 :
- [Black Hat, USA](https://www.blackhat.com/us-21/arsenal/schedule/index.html#bringing-the-x-complete-re-experience-to-smart-contract-24119)
- [Hack In The Box, Amsterdam](https://conference.hitb.org/hitbsecconf2021ams/sessions/when-qiling-framework-meets-symbolic-execution/)
- [Black Hat, Asia](https://www.blackhat.com/asia-21/arsenal/schedule/index.html#qiling-smart-analysis-for-smart-contract-22643)

2020 :
- [Black Hat, Europe](https://www.blackhat.com/eu-20/arsenal/schedule/index.html#qiling-framework-deep-dive-into-obfuscated-binary-analysis-21781)
- [Black Hat, USA](https://www.blackhat.com/us-20/arsenal/schedule/index.html#qiling-framework-from-dark-to-dawn-----enlightening-the-analysis-of-the-most-mysterious-iot-firmware--21062)
- [Black Hat, USA (Demigod)](https://www.blackhat.com/us-20/briefings/schedule/#demigod-the-art-of-emulating-kernel-rootkits-20009)
- [Black Hat, Asia](https://www.blackhat.com/asia-20/arsenal/schedule/index.html#qiling-lightweight-advanced-binary-analyzer-19245)
- [Hack In The Box, Lockdown 001](https://conference.hitb.org/lockdown-livestream/)
- [Hack In The Box, Lockdown 002](https://conference.hitb.org/hitb-lockdown002/virtual-labs/virtual-lab-qiling-framework-learn-how-to-build-a-fuzzer-based-on-a-1day-bug/)
- [Hack In The Box, Cyberweek](https://cyberweek.ae/2020/lab-qiling-framework/)
- [Nullcon](https://nullcon.net/website/goa-2020/speakers/kaijern-lau.php)
    
2019 :

- [DEFCON, USA](https://www.defcon.org/html/defcon-27/dc-27-demolabs.html#QiLing)
- [Hitcon](https://hitcon.org/2019/CMT/agenda)
- [Zeronights](https://zeronights.ru/report-en/qiling-io-advanced-binary-emulation-framework/)


Qiling est soutenu par [Unicorn Engine](http://www.unicorn-engine.org).

Visitez notre [site web](https://www.qiling.io) 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](http://www.unicorn-engine.org) et [QEMU user mode](https://qemu.org).
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](https://github.com/qilingframework/qiling/wiki/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.

```python
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".

```python
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.

[![Tutoriel Qiling : Émuler et fuzzer le firmware d'un routeur ARM](https://raw.githubusercontent.com/qilingframework/theme.qiling.io/master/source/img/fuzzer.jpg?raw=true)](https://www.youtube.com/watch?v=e3_T3KLh2NU)

#### 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.

[![Plugin IDA Pro de Qiling : Instrumenter et déchiffrer le secret de Mirai](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](http://www.youtube.com/watch?v=ZWMWTq2WTXk)

#### Serveur GDB avec démo IDA Pro

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

[Résolution d'un défi CTF simple avec Qiling Framework et IDA Pro](https://www.youtube.com/watch?v=SPjVAt2FkKA)


#### Émulation MBR

Qiling Framework émule le MBR

[![Démo Qiling : Émulation MBR](https://raw.githubusercontent.com/qilingframework/theme.qiling.io/master/source/img/mbr.png?raw=true)](https://github.com/qilingframework/theme.qiling.io/blob/master/source/img/mbr.png?raw=true)

---

#### 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](https://twitter.com/qiling_io).

---

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

Veuillez vous référer à [CREDITS.md](https://github.com/qilingframework/qiling/blob/dev/CREDITS.md).
Télécharger l’outil