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
dragon-tales — Libreria di analisi binaria basata su LLVM per il disassemblaggio, il lifting e l'esecuzione simbolica di codice macchina su x86, ARM e RISC-V, con recupero del CFG e risoluzione tramite Z3. | Kitploit
Strumenti/GitHubGitHub/fare9/dragon-tales
Analisi StaticaAnalisi delle VulnerabilitàAnalisi del CodiceReverse EngineeringAnalisi MalwareUtilità e FrameworkAnalisi di BinariBinary Exploitation
GitHubfare9/dragon-tales

dragon-tales

Libreria di analisi binaria basata su LLVM per il disassemblaggio, il lifting e l'esecuzione simbolica di codice macchina su x86, ARM e RISC-V, con recupero del CFG e risoluzione tramite Z3.

4410643 giorni faRevisionato da Kitploit
Vedi Repository

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

dragon-tales

Una libreria di analisi binaria per il disassemblaggio, l'assemblaggio e l'analisi del codice macchina su più architetture. Basata su LLVM 21.

Funzionalità:

  • Disassemblaggio (linear sweep e recursive traversal) e assemblaggio su sei architetture
  • Recupero di CFG e funzioni
  • IGNIL — un linguaggio intermedio leggero per l'analisi indipendente dall'architettura
  • IGNIL peephole simplifier — constant folding a livello di blocco, identità algebriche, eliminazione dei Temp morti
  • Backward slicer — propaga i valori attraverso i CFG IGNIL senza attraversare i nodi di join
  • LLVMLifter — solleva una Function recuperata, o un singolo blocco IGNIL appiattito (senza bisogno di CFG), a LLVM IR, con una pipeline di ottimizzazione (mem2reg/instcombine/GVN/DCE) al di sopra
  • Integrazione Z3 — abbassa un'espressione slicizzata a una formula bitvector Z3, enumera i valori concreti che può assumere, o risolve per uno unico
  • Esecuzione simbolica — esegue un blocco IGNIL su bitvector Z3 con registri e memoria inizializzati in modo concreto o simbolico: risolve per un input che fa passare un controllo, dimostra cosa calcola realmente un'espressione offuscata, e risolve un salto calcolato (jump table, dispatch VM) agli indirizzi concreti che può raggiungere
  • SwitchDetector — riconosce un pattern di branch indiretto a jump-table da un target di salto slicizzato e legge i suoi target di caso concreti
  • Corrispondenza di firme compatibile con FLIRT — identifica funzioni note da database di firme .pat
  • Trace lifting — solleva una sequenza arbitraria di istruzioni lineari (ad es. una traccia di esecuzione catturata) direttamente a IGNIL, bypassando completamente l'analisi di validità di CFG/funzione/blocco
  • Binary loader — analizza un file ELF o PE/COFF (o byte in memoria) direttamente in un LoadedImage: sezioni e segmenti ELF PT_LOAD ai loro indirizzi virtuali con permessi R/W/X, entry point, image base, simboli con flag di import/export, e l'architettura rilevata automaticamente dall'header (senza bisogno di specificarla). loader::disassembleImage va da un file a un Graph popolato in una sola chiamata. Basato su llvm::object di LLVM, quindi nessuna dipendenza aggiuntiva
  • CLI disassembler — uno strumento da riga di comando che carica un binario ELF o PE e mostra il disassemblaggio, utile per un'ispezione rapida e per gli script
  • Shim C (dragon_c.h) e API Python (cffi) che coprono la maggior parte delle funzionalità sopra (alcuni angoli solo C++ — template DSL di pattern-matching, helper di classificazione delle istruzioni specifici per architettura, e simili — sono documentati come tali in docs/cpp_api.md)

Requisiti

  • LLVM 21 (deve essere installato sul sistema)
  • CMake 3.20 o successivo
  • Un compilatore C++20
  • Python 3 con cffi (opzionale, per l'API Python)

Architetture supportate

  • x86 (32-bit e 64-bit)
  • ARM (32-bit e 64-bit)
  • RISC-V (32-bit e 64-bit)

Release precompilate

Le release con tag includono un archivio SDK autonomo per piattaforma (dragon-<version>-{linux-x64,macos-arm64,windows-x64}.{tar.gz,zip}) sulla pagina GitHub Releases. LLVM è linkato staticamente nelle librerie, quindi non è richiesta un'installazione di LLVM di sistema per utilizzarle; Z3 è incluso insieme. Ogni archivio contiene:

lib/      libdragon + libdragon_c (shared) and the bundled Z3 runtime
bin/      the `disassembler` CLI (plus the DLLs on Windows)
include/  the C++ headers (dragon/...) and the C-shim header (dragon/dragon_c.h)
share/dragon/python/dragon.py   the Python API

Indica all'API Python la libreria inclusa con DRAGON_C_LIB=/path/to/lib/libdragon_c.so (.dylib/.dll a seconda dei casi).

Per compilare dai sorgenti, invece:

Compilazione

mkdir build && cd build
cmake ..
cmake --build .

Per eseguire i test:

ctest --output-on-failure

Un pugno di test semantici di round-trip x86 sono costosi: compilano JIT l'IR sollevato ed emulano i byte grezzi sotto Unicorn attraverso un ampio prodotto cartesiano di input di casi limite (migliaia di round-trip ciascuno). Sono contrassegnati con [.][expensive], il che li nasconde dall'esecuzione predefinita di ctest in modo che rimanga veloce. Eseguirli esplicitamente — tipicamente su una macchina più potente o in CI — con:

./build/bin/dragon_tests "[expensive]"

Compilazione su Windows (Visual Studio + vcpkg)

Su Windows il rilevamento delle dipendenze in CMakeLists.txt richiede alcuni suggerimenti, poiché è scritto per i layout dei pacchetti Linux: Z3 viene individuato tramite il modulo FindZ3.cmake incluso in LLVM, e Unicorn viene individuato tramite pkg-config. Nessuno dei due meccanismi sa dove vcpkg installa le cose, e LLVM viene trovato tramite LLVM_DIR anziché il percorso di sistema. Fornire tre suggerimenti risolve tutto.

Prerequisiti

  • Visual Studio 2022 (o i relativi Build Tools) con il carico di lavoro Sviluppo di applicazioni desktop con C++
  • CMake 3.20+
  • LLVM 21 estratto da qualche parte, ad es. C:\llvm-21 (la release precompilata clang+llvm-*-x86_64-pc-windows-msvc funziona)
  • vcpkg

1. Installare le librerie con vcpkg (il triplet x64-windows; pkgconf fornisce l'eseguibile pkg-config necessario al rilevamento di Unicorn):

vcpkg install z3:x64-windows unicorn:x64-windows pkgconf:x64-windows

2. I tre suggerimenti di cui CMake ha bisogno

SuggerimentoScopoValore di esempio
LLVM_DIRindividuare LLVM 21C:/llvm-21/lib/cmake/llvm
CMAKE_PREFIX_PATHconsentire a FindZ3 di vedere l'albero vcpkgC:/vcpkg/installed/x64-windows
PKG_CONFIG_EXECUTABLE + PKG_CONFIG_PATHconsentire a Unicorn di essere trovato tramite pkg-config.../tools/pkgconf/pkgconf.exe e .../installed/x64-windows/lib/pkgconfig

3a. Configurare e compilare (un solo comando)

$env:PKG_CONFIG_PATH = "C:/vcpkg/installed/x64-windows/lib/pkgconfig"
cmake -S . -B build `
  -DLLVM_DIR=C:/llvm-21/lib/cmake/llvm `
  -DCMAKE_PREFIX_PATH=C:/vcpkg/installed/x64-windows `
  -DPKG_CONFIG_EXECUTABLE=C:/vcpkg/installed/x64-windows/tools/pkgconf/pkgconf.exe `
  -DDRAGON_USE_Z3=ON -DDRAGON_USE_UNICORN=ON
cmake --build build --config Release

Una configurazione riuscita stampa:

-- Found LLVM 21.1.8 at C:/llvm-21/lib/cmake/llvm
-- Found Z3 5.0.0 at C:/vcpkg/installed/x64-windows/lib/libz3.lib
-- Found Unicorn 2.1.4

3b. Oppure usa un preset (consigliato)

Salva le impostazioni una volta in un file CMakeUserPresets.json accanto a CMakeLists.txt, poi configura con un singolo flag. Questo file contiene percorsi specifici della macchina, quindi tienilo fuori dal controllo di versione (è ignorato da git).

{
  "version": 3,
  "configurePresets": [
    {
      "name": "win-vcpkg",
      "generator": "Visual Studio 17 2022",
      "architecture": "x64",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "LLVM_DIR": "C:/llvm-21/lib/cmake/llvm",
        "CMAKE_PREFIX_PATH": "C:/vcpkg/installed/x64-windows",
        "PKG_CONFIG_EXECUTABLE": "C:/vcpkg/installed/x64-windows/tools/pkgconf/pkgconf.exe",
        "DRAGON_USE_Z3": "ON",
        "DRAGON_USE_UNICORN": "ON"
      },
      "environment": {
        "PKG_CONFIG_PATH": "C:/vcpkg/installed/x64-windows/lib/pkgconfig"
      }
    }
  ],
  "buildPresets": [
    { "name": "win-vcpkg", "configurePreset": "win-vcpkg", "configuration": "Release" }
  ]
}
cmake --preset win-vcpkg
cmake --build build --config Release

Note

Scarica lo strumento