Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
dragon-tales — Biblioteca de análise binária construída sobre LLVM para desmontagem, lifting e execução simbólica de código de máquina em x86, ARM e RISC-V, com recuperação de CFG e resolução via Z3. | Kitploit
Ferramentas/GitHubGitHub/fare9/dragon-tales
Análise EstáticaAnálise de VulnerabilidadesAnálise de CódigoEngenharia ReversaAnálise de MalwareUtilitários e FrameworksAnálise de BináriosExploração de Binários
GitHubfare9/dragon-tales

dragon-tales

Biblioteca de análise binária construída sobre LLVM para desmontagem, lifting e execução simbólica de código de máquina em x86, ARM e RISC-V, com recuperação de CFG e resolução via Z3.

441058há 3 diasRevisado pelo Kitploit
Ver Repositório

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

dragon-tales

Uma biblioteca de análise binária para desmontagem, montagem e análise de código de máquina em múltiplas arquiteturas. Construída sobre o LLVM 21.

Recursos:

  • Desmontagem (varredura linear e travessia recursiva) e montagem em seis arquiteturas
  • Recuperação de CFG e de funções
  • IGNIL — uma linguagem intermediária leve para análise independente de arquitetura
  • Simplificador peephole IGNIL — dobramento de constantes local ao bloco, identidades algébricas, eliminação de Temp morto
  • Fatiador reverso — propaga valores através de CFGs IGNIL sem cruzar nós de junção
  • LLVMLifter — eleva uma Function recuperada, ou um único bloco IGNIL achatado (sem necessidade de CFG), para LLVM IR, com um pipeline de otimização (mem2reg/instcombine/GVN/DCE) por cima
  • Integração com Z3 — rebaixa uma expressão fatiada para uma fórmula de bitvector Z3, enumera os valores concretos que ela pode assumir, ou resolve para um único valor
  • Execução simbólica — executa um bloco IGNIL sobre bitvectors Z3 com registradores e memória inicializados de forma concreta ou simbólica: resolve para uma entrada que faça uma verificação passar, prova o que uma expressão ofuscada realmente calcula, e resolve um salto computado (tabela de saltos, despacho de VM) para os endereços concretos que ele pode alcançar
  • SwitchDetector — reconhece um padrão de desvio indireto por tabela de saltos a partir de um alvo de salto fatiado e lê seus alvos de caso concretos
  • Correspondência de assinaturas compatível com FLIRT — identifica funções conhecidas a partir de bancos de assinaturas .pat
  • Elevação de trace — eleva uma sequência linear arbitrária de instruções (por exemplo, um trace de execução capturado) diretamente para IGNIL, contornando inteiramente a análise de CFG/função/validade de bloco
  • Carregador de binários — analisa um arquivo ELF ou PE/COFF (ou bytes em memória) diretamente em um LoadedImage: seções e segmentos PT_LOAD de ELF em seus endereços virtuais com permissões R/W/X, ponto de entrada, base da imagem, símbolos com flags de importação/exportação, e a arquitetura detectada automaticamente a partir do cabeçalho (sem necessidade de nomeá-la). loader::disassembleImage vai de um arquivo a um Graph populado em uma única chamada. Construído sobre o llvm::object do LLVM, portanto sem dependência extra
  • CLI disassembler — uma ferramenta de linha de comando que carrega um binário ELF ou PE e despeja a desmontagem, útil para inspeção rápida e scripts
  • Shim em C (dragon_c.h) e API Python (cffi) cobrindo a maior parte do conjunto de recursos acima (alguns cantos exclusivos de C++ — templates de DSL de correspondência de padrões, auxiliares de classificação de instruções específicos de arquitetura, e similares — estão documentados como tal em docs/cpp_api.md)

Requisitos

  • LLVM 21 (deve estar instalado no sistema)
  • CMake 3.20 ou posterior
  • Um compilador C++20
  • Python 3 com cffi (opcional, para a API Python)

Arquiteturas suportadas

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

Versões pré-compiladas

As versões marcadas com tag incluem um arquivo SDK autocontido por plataforma (dragon-<version>-{linux-x64,macos-arm64,windows-x64}.{tar.gz,zip}) na página de Releases do GitHub. O LLVM é vinculado estaticamente às bibliotecas, portanto não é necessária uma instalação do LLVM no sistema para usá-las; o Z3 é incluído junto. Cada arquivo contém:

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

Aponte a API Python para a biblioteca incluída com DRAGON_C_LIB=/path/to/lib/libdragon_c.so (.dylib/.dll conforme apropriado).

Para compilar a partir do código-fonte, em vez disso:

Compilação

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

Para executar os testes:

ctest --output-on-failure

Um punhado de testes de ida e volta semânticos x86 são caros: eles compilam JIT o IR levantado e emulam os bytes brutos sob o Unicorn através de um grande produto cartesiano de entradas de casos extremos (milhares de idas e voltas cada). Eles são marcados com [.][expensive], o que os oculta da execução padrão do ctest para que ela permaneça rápida. Execute-os explicitamente — normalmente em uma máquina mais potente ou em CI — com:

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

Compilação no Windows (Visual Studio + vcpkg)

No Windows, a descoberta de dependências em CMakeLists.txt precisa de algumas dicas, porque está escrita para layouts de pacotes Linux: o Z3 é localizado através do módulo FindZ3.cmake incluído no LLVM, e o Unicorn é localizado através do pkg-config. Nenhum dos mecanismos sabe onde o vcpkg instala as coisas, e o LLVM é encontrado via LLVM_DIR em vez do caminho do sistema. Fornecer três dicas resolve tudo.

Pré-requisitos

  • Visual Studio 2022 (ou as respetivas Build Tools) com a carga de trabalho Desktop development with C++
  • CMake 3.20+
  • LLVM 21 extraído em algum local, por exemplo C:\llvm-21 (a versão pré-compilada clang+llvm-*-x86_64-pc-windows-msvc funciona)
  • vcpkg

1. Instalar as bibliotecas com o vcpkg (o triplet x64-windows; o pkgconf fornece o executável pkg-config de que a descoberta do Unicorn precisa):

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

2. As três dicas que o CMake precisa

DicaFinalidadeValor de exemplo
LLVM_DIRlocalizar o LLVM 21C:/llvm-21/lib/cmake/llvm
CMAKE_PREFIX_PATHpermitir que FindZ3 veja a árvore do vcpkgC:/vcpkg/installed/x64-windows
PKG_CONFIG_EXECUTABLE + PKG_CONFIG_PATHpermitir que o Unicorn seja encontrado via pkg-config.../tools/pkgconf/pkgconf.exe e .../installed/x64-windows/lib/pkgconfig

3a. Configurar e compilar (um único 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

Uma configuração bem-sucedida imprime:

-- 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. Ou use um preset (recomendado)

Salve as configurações uma vez em um CMakeUserPresets.json ao lado de CMakeLists.txt, depois configure com uma única flag. Este arquivo contém caminhos específicos da máquina, então mantenha-o fora do controle de versão (ele é ignorado pelo 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

Notas

Baixar ferramenta