Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/qilingframework/qiling
Frameworks per Penetration TestingAnalisi Dinamica (Sandboxing)ExploitReverse EngineeringDebuggerFuzzingAnalisi MalwareAnalisi di BinariApprendimento e FormazioneAnalisi del FirmwareTop in Analisi del Firmware n.19
6.1k7961472 mesi faRevisionato da Kitploit
GitHubqilingframework/qiling

qiling

Un vero framework di emulazione binaria strumentabile.

Vedi RepositorySito web

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite ma solo USB e multipiattaforma.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF self-hosted e reverse proxy che filtra il traffico HTTP malevolo, blocca SQL injection, XSS e attacchi bot, con limitazione del tasso e crittografia dinamica HTML/JS.

    360

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi
[![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>

[Casi d'uso, blog e lavori correlati di Qiling](https://github.com/qilingframework/qiling/issues/134)

Qiling è un framework avanzato di emulazione binaria, con le seguenti caratteristiche:

- Emula multi-piattaforma: Windows, macOS, Linux, Android, BSD, UEFI, DOS, MBR.
- Emula multi-architetture: 8086, X86, X86_64, ARM, ARM64, MIPS, RISC-V, PowerPC.
- Supporta molteplici formati di file: PE, Mach-O, ELF, COM, MBR.
- Supporta driver Windows (.sys), moduli kernel Linux (.ko) e kernel macOS (.kext) tramite [Demigod](https://groundx.io/demigod/).
- Emula e mette in sandbox il codice in un ambiente isolato.
- Fornisce una sandbox completamente configurabile.
- Fornisce API approfondite per memoria, registri, livello del sistema operativo e filesystem.
- Strumentazione a grana fine: permette hook a vari livelli (istruzione/blocco base/accesso memoria/eccezione/syscall/IO/ecc.)
- Fornisce API a livello di macchina virtuale come salvare e ripristinare lo stato di esecuzione corrente.
- Supporta capacità di debug cross-architettura e cross-piattaforma.
- Debugger integrato con capacità di debug inverso.
- Permette patch dinamico a caldo del codice in esecuzione, incluse le librerie caricate.
- Vero framework in Python, che rende facile costruire strumenti di analisi di sicurezza personalizzati sopra di esso.

Qiling si è anche fatto strada in varie conferenze internazionali.

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 è supportato da [Unicorn Engine](http://www.unicorn-engine.org).

Visita il nostro [sito web](https://www.qiling.io) per maggiori informazioni.

---
#### Licenza

Questo programma è software libero; puoi ridistribuirlo e/o modificarlo
secondo i termini della GNU General Public License come pubblicata dalla
Free Software Foundation; sia la versione 2 della Licenza, o
(a tua scelta) qualsiasi versione successiva.

---

#### Qiling vs. altri Emulatori

Esistono molti emulatori open-source, ma i due progetti più vicini a Qiling
sono [Unicorn](http://www.unicorn-engine.org) e [QEMU user mode](https://qemu.org).
Questa sezione spiega le principali differenze di Qiling rispetto a essi.

##### Qiling vs. Unicorn engine

Costruito sopra Unicorn, ma Qiling e Unicorn sono due animali diversi.

- Unicorn è solo un emulatore di CPU, quindi si concentra sull'emulazione delle istruzioni della CPU,
  che può comprendere la memoria dell'emulatore.
  Oltre a ciò, Unicorn non è a conoscenza di concetti di livello superiore, come librerie
  dinamiche, chiamate di sistema, gestione I/O o formati eseguibili come PE, Mach-O
  o ELF. Di conseguenza, Unicorn può emulare solo istruzioni macchina grezze,
  senza contesto del sistema operativo (OS).
- Qiling è progettato come un framework di livello superiore, che sfrutta Unicorn per
  emulare le istruzioni della CPU, ma può comprendere il sistema operativo: ha caricatori
  di formati eseguibili (per PE, Mach-O e ELF attualmente), linker dinamici (così possiamo
  caricare e rilocare librerie condivise), gestori di syscall e I/O. Per questo motivo,
  Qiling può eseguire binari eseguibili senza richiedere il loro sistema operativo nativo.

##### Qiling vs. QEMU user mode

QEMU user mode fa una cosa simile al nostro emulatore, ovvero emulare interi
binari eseguibili in modo cross-architettura. 
Tuttavia, Qiling offre alcune importanti differenze rispetto a QEMU user mode:

- Qiling è un vero framework di analisi,
  che ti permette di costruire i tuoi strumenti di analisi dinamica sopra (in Python).
  Nel frattempo, QEMU è solo uno strumento, non un framework.
- Qiling può eseguire strumentazione dinamica e può persino applicare patch a caldo al codice
  durante l'esecuzione. QEMU non fa nessuna delle due cose.
- Non solo funziona in modo cross-architettura, Qiling è anche cross-piattaforma.
  Ad esempio, puoi eseguire un file ELF Linux su Windows.
  Al contrario, QEMU user mode esegue solo binari dello stesso sistema operativo, come ELF
  Linux su Linux, a causa del modo in cui inoltra le syscall dal codice emulato al
  sistema operativo nativo.
- Qiling supporta più piattaforme, tra cui Windows, macOS, Linux e BSD. QEMU
  user mode può gestire solo Linux e BSD.

---

#### Installazione

Si prega di consultare il file [guida all'installazione](https://github.com/qilingframework/qiling/wiki/Installation) per come installare Qiling Framework.

---

#### Esempi

L'esempio seguente mostra come utilizzare Qiling framework nel modo più
diretto per emulare un eseguibile Windows.

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

- L'esempio seguente mostra come un crackme Windows può essere patchato dinamicamente
  per fargli visualizzare sempre la finestra di dialogo "Congratulazioni".

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

Il video YouTube qui sotto mostra come funziona l'esempio sopra.

#### Emulazione del firmware del router ARM su host Ubuntu x64

Qiling Framework applica patch a caldo ed emula `/usr/bin/httpd` di un router ARM su
un host Ubuntu x86_64.

[![Tutorial Qiling: Emulazione e Fuzzing del firmware di un router 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 di Qiling: Strumentazione e Decifratura del Segreto di Mirai

Questo video mostra come il plugin IDA Pro di Qiling può far funzionare IDA Pro con
il motore di strumentazione di Qiling.

[![Plugin IDA Pro di Qiling: Strumentazione e Decifratura del Segreto di Mirai](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](http://www.youtube.com/watch?v=ZWMWTq2WTXk)

#### Demo del server GDB con IDA Pro

Risoluzione di una semplice sfida CTF con Qiling Framework e IDA Pro

[Risoluzione di una semplice sfida CTF con Qiling Framework e IDA Pro](https://www.youtube.com/watch?v=SPjVAt2FkKA)


#### Emulazione MBR

Qiling Framework emula MBR

[![Emulazione MBR con Qiling](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 fornisce anche uno strumento amichevole chiamato `qltool` per emulare rapidamente shellcode e binari eseguibili.

Con qltool, è possibile eseguire facilmente:


Con shellcode:

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

Con file binario:

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

Con binario e debugger GDB abilitato:

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

Con raccolta di copertura del codice (solo UEFI per ora):

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

Con output JSON (principalmente Windows):

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


#### Contatti

Ottieni le ultime informazioni dal nostro sito web https://www.qiling.io

Contattaci via email [email protected],
tramite Twitter [@qiling_io](https://twitter.com/qiling_io).

---

#### Sviluppatori principali, Contributori chiave e altro

Si prega di fare riferimento a [CREDITS.md](https://github.com/qilingframework/qiling/blob/dev/CREDITS.md).
Scarica lo strumento