Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
Tools/GitHubGitHub/qilingframework/qiling
Penetrationstest-FrameworksDynamische Analyse (Sandboxing)ExploitationReverse EngineeringDebuggerFuzzingMalware-AnalyseBinäranalyseLernen & BildungFirmware-AnalyseTop in Firmware-Analyse Nr.19
6.1k796147vor 2 MonatenVon Kitploit geprüft
GitHubqilingframework/qiling

qiling

Ein echtes instrumentierbares Binary-Emulations-Framework

Repository anzeigenWebseite

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite, aber nur USB & plattformübergreifend.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer ist eine Open-Source-Plattform für Privileged Access Management (PAM), die DevOps- und IT-Teams bedarfsgesteuerten und sicheren Zugriff auf SSH-, RDP-, Kubernetes-, Datenbank- und RemoteApp-Endpunkte über einen Webbrowser bietet.

    412
  • 6

    SafeLine

    chaitin/safeline

    Selbst gehosteter WAF und Reverse Proxy, der bösartigen HTTP-Verkehr filtert, SQL-Injection, XSS und Bot-Angriffe blockiert, mit Ratenbegrenzung und dynamischer HTML/JS-Verschlüsselung.

    360

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen
[![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>

[Qilings Anwendungsfall, Blog und verwandte Arbeiten](https://github.com/qilingframework/qiling/issues/134)

Qiling ist ein fortschrittliches Binary-Emulations-Framework mit den folgenden Funktionen:

- Emuliert mehrere Plattformen: Windows, macOS, Linux, Android, BSD, UEFI, DOS, MBR.
- Emuliert mehrere Architekturen: 8086, X86, X86_64, ARM, ARM64, MIPS, RISC-V, PowerPC.
- Unterstützt mehrere Dateiformate: PE, Mach-O, ELF, COM, MBR.
- Unterstützt Windows-Treiber (.sys), Linux-Kernel-Module (.ko) und macOS-Kernel (.kext) über [Demigod](https://groundx.io/demigod/).
- Emuliert und sandboxt Code in einer isolierten Umgebung.
- Bietet eine vollständig konfigurierbare Sandbox.
- Bietet detaillierte APIs auf Speicher-, Register-, Betriebssystem- und Dateisystemebene.
- Feingranulare Instrumentierung: ermöglicht Hooks auf verschiedenen Ebenen (Instruktion/Basic-Block/Speicherzugriff/Ausnahme/Syscall/IO/usw.)
- Bietet APIs auf virtueller Maschinenebene, wie das Speichern und Wiederherstellen des aktuellen Ausführungszustands.
- Unterstützt plattform- und architekturübergreifende Debugging-Fähigkeiten.
- Integrierter Debugger mit Reverse-Debugging-Fähigkeit.
- Ermöglicht dynamisches Hot-Patching von laufendem Code, einschließlich geladener Bibliotheken.
- Echtes Framework in Python, das es einfach macht, darauf maßgeschneiderte Sicherheitsanalysetools zu erstellen.

Qiling hat auch seinen Weg zu verschiedenen internationalen Konferenzen gefunden.

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 wird von der [Unicorn Engine](http://www.unicorn-engine.org) unterstützt.

Besuchen Sie unsere [Website](https://www.qiling.io) für weitere Informationen.

---
#### Lizenz

Dieses Programm ist freie Software; Sie können es unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation veröffentlicht, weitergeben und/oder modifizieren; entweder gemäß Version 2 der Lizenz oder (nach Ihrer Wahl) jeder späteren Version.

---

#### Qiling im Vergleich zu anderen Emulatoren

Es gibt viele Open-Source-Emulatoren, aber die beiden Projekte, die Qiling am nächsten kommen, sind [Unicorn](http://www.unicorn-engine.org) und [QEMU user mode](https://qemu.org). In diesem Abschnitt werden die Hauptunterschiede von Qiling zu diesen erläutert.

##### Qiling vs. Unicorn Engine

Auf Unicorn aufbauend, aber Qiling und Unicorn sind zwei verschiedene Paar Schuhe.

- Unicorn ist nur ein CPU-Emulator, konzentriert sich also auf die Emulation von CPU-Instruktionen und kann den Emulator-Speicher verstehen. Darüber hinaus kennt Unicorn keine höheren Konzepte wie dynamische Bibliotheken, Systemaufrufe, I/O-Behandlung oder ausführbare Formate wie PE, Mach-O oder ELF. Daher kann Unicorn nur rohe Maschineninstruktionen ohne Betriebssystemkontext emulieren.
- Qiling ist als Framework auf höherer Ebene konzipiert, das Unicorn zur Emulation von CPU-Instruktionen nutzt, aber auch das Betriebssystem versteht: Es verfügt über Lader für ausführbare Formate (derzeit für PE, Mach-O und ELF), dynamische Linker (um gemeinsam genutzte Bibliotheken zu laden und zu verschieben) sowie Syscall- und I/O-Handler. Aus diesem Grund kann Qiling ausführbare Binärdateien ohne ihr natives Betriebssystem ausführen.

##### Qiling vs. QEMU user mode

Der QEMU-Benutzermodus macht etwas Ähnliches wie unser Emulator, nämlich die Emulation ganzer ausführbarer Binärdateien auf architekturübergreifende Weise. Allerdings bietet Qiling einige wichtige Unterschiede zum QEMU-Benutzermodus:

- Qiling ist ein echtes Analyse-Framework, mit dem Sie Ihre eigenen dynamischen Analysetools darauf aufbauen können (in Python). QEMU hingegen ist nur ein Werkzeug, kein Framework.
- Qiling kann dynamische Instrumentierung durchführen und sogar Code zur Laufzeit hot-pachen. QEMU kann keines von beidem.
- Qiling ist nicht nur architekturübergreifend, sondern auch plattformübergreifend. Sie können beispielsweise eine Linux-ELF-Datei unter Windows ausführen. Im Gegensatz dazu führt der QEMU-Benutzermodus nur Binärdateien desselben Betriebssystems aus, wie Linux-ELF unter Linux, aufgrund der Art und Weise, wie er Syscalls von emuliertem Code an das native Betriebssystem weiterleitet.
- Qiling unterstützt mehr Plattformen, darunter Windows, macOS, Linux und BSD. Der QEMU-Benutzermodus kann nur Linux und BSD verarbeiten.

---

#### Installation

Bitte lesen Sie die [Setup-Anleitung](https://github.com/qilingframework/qiling/wiki/Installation) zur Installation des Qiling Frameworks.

---

#### Beispiele

Das folgende Beispiel zeigt, wie man das Qiling Framework auf die einfachste Weise verwendet, um eine Windows-ausführbare Datei zu emulieren.

```python
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()
```

- Das folgende Beispiel zeigt, wie ein Windows-Crackme dynamisch gepatcht werden kann, um stets den „Gratulation“-Dialog anzuzeigen.

```python
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()
```

Das folgende YouTube-Video zeigt, wie das obige Beispiel funktioniert.

#### Emulieren von ARM-Router-Firmware auf einem Ubuntu x64-Host

Qiling Framework hot-patchet und emuliert das `/usr/bin/httpd` eines ARM-Routers auf einem x86_64-Ubuntu-Host.

[![Qiling Tutorial: Emulating and Fuzz ARM router firmware](https://raw.githubusercontent.com/qilingframework/theme.qiling.io/master/source/img/fuzzer.jpg?raw=true)](https://www.youtube.com/watch?v=e3_T3KLh2NU)

#### Qilings IDA-Pro-Plugin: Instrumentieren und Entschlüsseln von Mirais Geheimnis

Dieses Video demonstriert, wie das IDA-Pro-Plugin von Qiling es IDA Pro ermöglicht, mit der Qiling-Instrumentierungs-Engine zu laufen.

[![Qiling's IDA Pro Plugin: Instrument and Decrypt Mirai's Secret](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](http://www.youtube.com/watch?v=ZWMWTq2WTXk)

#### GDB-Server mit IDA-Pro-Demo

Lösen einer einfachen CTF-Herausforderung mit Qiling Framework und IDA Pro

[Solving a simple CTF challenge with Qiling Framework and IDA Pro](https://www.youtube.com/watch?v=SPjVAt2FkKA)


#### Emulieren von MBR

Qiling Framework emuliert MBR

[![Qiling DEMO: Emulating 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 bietet auch ein benutzerfreundliches Tool namens `qltool`, um schnell Shellcode und ausführbare Binärdateien zu emulieren.

Mit qltool kann eine einfache Ausführung durchgeführt werden:


Mit Shellcode:

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

Mit Binärdatei:

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

Mit Binärdatei und aktiviertem GDB-Debugger:

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

Mit Code-Coverage-Erfassung (derzeit nur UEFI):

```
$ ./qltool run -f examples/rootfs/x8664_efi/bin/TcgPlatformSetupPolicy --rootfs examples/rootfs/x8664_efi --coverage-format drcov --coverage-file TcgPlatformSetupPolicy.cov
```

Mit JSON-Ausgabe (hauptsächlich Windows):

```
$ ./qltool run -f examples/rootfs/x86_windows/bin/x86_hello.exe --rootfs  examples/rootfs/x86_windows/ --console False --json
```
---


#### Kontakt

Die neuesten Informationen erhalten Sie auf unserer Website https://www.qiling.io

Kontaktieren Sie uns per E-Mail an [email protected] oder über Twitter [@qiling_io](https://twitter.com/qiling_io).

---

#### Hauptentwickler, Hauptbeitragende usw.

Bitte beachten Sie die [CREDITS.md](https://github.com/qilingframework/qiling/blob/dev/CREDITS.md).
Tool herunterladen