Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
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.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Manalyze — Analisador estático de executáveis PE com detecção baseada em plugins de empacotadores, compiladores, importações suspeitas, constantes criptográficas e assinaturas ClamAV. Suporta envio de hashes para o VirusTotal e verificação de authenticode. | Kitploit
Ferramentas/GitHubGitHub/justicerage/manalyze
Análise EstáticaAnálise de VulnerabilidadesEngenharia ReversaAnálise de MalwareAnálise de Binários
GitHubjusticerage/manalyze

Manalyze

Analisador estático de executáveis PE com detecção baseada em plugins de empacotadores, compiladores, importações suspeitas, constantes criptográficas e assinaturas ClamAV. Suporta envio de hashes para o VirusTotal e verificação de authenticode.

Ver Repositório
1.1k170há 8 diasRevisado pelo Kitploit

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

Manalyze Documentation

Introdução

O Manalyze é uma ferramenta de análise estática para arquivos PE que você pode usar para realizar uma avaliação primária de um executável (ou conjunto de executáveis). Ele coleta sinais fracos que podem indicar comportamento malicioso e exibe informações que podem ajudar em uma análise manual posterior.

Se quiser ver alguns exemplos de relatórios gerados pela ferramenta, sinta-se à vontade para experimentar o serviço web que criei para ela: manalyzer.org.

Índice

  • Um analisador estático para arquivos PE
  • Como compilar
  • Gerando regras do ClamAV
  • Uso
  • Pessoas usando o Manalyze
  • Contato

Um analisador estático para arquivos PE

O Manalyze foi escrito em C++ para Windows e Linux e é distribuído sob os termos da licença GPLv3. É um parser robusto para arquivos PE com uma arquitetura de plugins flexível que permite aos usuários analisar arquivos estaticamente em profundidade. O Manalyze...

  • Identifica o compilador de um PE
  • Detecta executáveis empacotados
  • Aplica assinaturas do ClamAV
  • Procura por strings suspeitas
  • Examina combinações de imports maliciosas (ex.: WriteProcessMemory + CreateRemoteThread)
  • Detecta constantes criptográficas (assim como o plugin findcrypt do IDA)
  • Pode enviar hashes para o VirusTotal
  • Verifica assinaturas authenticode (apenas no Windows)

Como compilar

Existem poucas coisas que odeio mais do que baixar um projeto open-source e passar duas horas tentando compilá-lo. Por isso, fiz o meu melhor para tornar o Manalyze o mais fácil de compilar possível. Se estas poucas linhas não funcionarem para você, então falhei no meu trabalho e você deve me avisar para que eu possa corrigir isso.

No Linux e BSD (testado no Debian Bullseye e FreeBSD 10.2)

root@kitploit:~
$> [sudo ou como root] apt-get install libboost-dev libboost-system-dev libssl-dev build-essential cmake git
$> [alternativamente, também sudo ou como root] pkg install boost libressl cmake git
$> git clone https://github.com/JusticeRage/Manalyze.git && cd Manalyze
$> cmake .
$> make -j5
$> cd bin && ./manalyze --version

Nota: o plugin VirusTotal é opcional e requer a biblioteca Boost.System.

Por fim, se quiser acessar o Manalyze de qualquer diretório na sua máquina, instale-o usando $> make install a partir da pasta raiz do projeto.

No Windows

  • Obtenha o Boost em boost.org (cabeçalhos) e instale o CMake.
  • Se quiser o plugin VirusTotal, compile a biblioteca Boost.System:
    • cd boost_1_XX_0 && ./bootstrap.bat && ./b2.exe --build-type=complete --with-system
  • Adicione uma variável de ambiente BOOST_ROOT que contenha o caminho para sua pasta boost_1_XX_0.
  • Baixe e instale o Git
  • git clone https://github.com/JusticeRage/Manalyze.git && cd Manalyze && cmake .
  • Um projeto do Visual Studio manalyze.sln deve ter aparecido na pasta Manalyze!

No OS X (testado no Mojave)

root@kitploit:~
# Pule estas duas linhas se você já tem um ambiente de compilação adequado
user$ xcode-select --install
user$ sudo installer -pkg /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg -target /

user$ git clone https://github.com/JusticeRage/Manalyze.git && cd Manalyze
user$ brew install openssl boost
user$ cmake . -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl/ && make -j5
user$ bin && ./manalyze --version

Compilações offline

Se precisar compilar o Manalyze em uma máquina sem acesso à internet, você precisa fazer checkout manual dos seguintes projetos:

  • Yara
  • hash-library

Coloque as duas pastas na pasta external como external/yara e external/hash-library respectivamente. Em seguida, execute cmake . -DGitHub=OFF e continue normalmente.

Binários

  • Binários para Windows x64

Imagem Docker

Uma imagem Docker para o Manalyze é fornecida pela comunidade. Execute docker pull evanowe/manalyze e obtenha informações adicionais aqui.

Gerando regras do ClamAV

Como as assinaturas do ClamAV são volumosas e atualizadas regularmente, não fazia muito sentido distribuí-las pelo GitHub ou junto com o binário. Quando você tentar usar o plugin ClamAV pela primeira vez, provavelmente encontrará a seguinte mensagem de erro: [!] Error: Could not load yara_rules/clamav.yara. Para gerá-las, execute o script Python update_clamav_signatures.py localizado em bin/yara_rules (árvore de origem) ou ${CMAKE_INSTALL_DATADIR}/manalyze/yara_rules (instalado, comumente /usr/share/manalyze/yara_rules ou /usr/local/share/manalyze/yara_rules).

Execute o script sempre que quiser atualizar as assinaturas. Caches compilados do Yara são armazenados em $XDG_CACHE_HOME/manalyze/yara_rules ou ~/.cache/manalyze/yara_rules, e podem ser sobrescritos com MANALYZE_CACHE_DIR.

Caminhos e substituições

Os locais de instalação padrão (respeitando CMAKE_INSTALL_PREFIX) são:

  • config: ${CMAKE_INSTALL_SYSCONFDIR}/manalyze/manalyze.conf (geralmente /etc/manalyze/manalyze.conf ou /usr/local/etc/manalyze/manalyze.conf)
  • regras: ${CMAKE_INSTALL_DATADIR}/manalyze/yara_rules (geralmente /usr/share/manalyze/yara_rules ou /usr/local/share/manalyze/yara_rules)
  • plugins: ${CMAKE_INSTALL_LIBDIR}/manalyze/plugins

Você pode substituí-los com variáveis de ambiente: MANALYZE_CONFIG_DIR, MANALYZE_DATA_DIR, MANALYZE_PLUGIN_DIR, MANALYZE_CACHE_DIR.

Uso

root@kitploit:~
$ ./manalyze.exe --help
Usage:
  -h [ --help ]         Displays this message.
  -v [ --version ]      Prints the program's version.
  --pe arg              The PE to analyze. Also accepted as a positional
                        argument. Multiple files may be specified.
  -r [ --recursive ]    Scan all files in a directory (subdirectories will be
                        ignored).
  -o [ --output ] arg   The output format. May be 'raw' (default) or 'json'.
  -d [ --dump ] arg     Dump PE information. Available choices are any
                        combination of: all, summary, dos (dos header), pe (pe
                        header), opt (pe optional header), sections, imports,
                        exports, resources, version, debug, tls, config, delay, rich
  --hashes              Calculate various hashes of the file (may slow down the
                        analysis!)
  -x [ --extract ] arg  Extract the PE resources to the target directory.
  -p [ --plugins ] arg  Analyze the binary with additional plugins. (may slow
                        down the analysis!)

Available plugins:
  - clamav: Scans the binary with ClamAV virus definitions.
  - compilers: Tries to determine which compiler generated the binary.
  - peid: Returns the PEiD signature of the binary.
  - strings: Looks for suspicious strings (anti-VM, process names...).
  - findcrypt: Detects embedded cryptographic constants.
  - packer: Tries to structurally detect packer presence.

## Python bindings (manapy)
Python bindings live under `manapy/` and are imported as `manalyze`.

From the repository root:

cd manapy python -m pip install .

root@kitploit:~
  - imports: Looks for suspicious imports.
  - resources: Analyzes the program's resources.
  - mitigation: Displays the enabled exploit mitigation techniques (DEP, ASLR, etc.).
  - overlay: Analyzes data outside of the PE's boundaries.
  - authenticode: Checks if the digital signature of the PE is valid.
  - virustotal: Checks existing AV results on VirusTotal.
  - all: Run all the available plugins.

Examples:
  manalyze.exe program.exe
  manalyze.exe -dresources -dexports -x out/ program.exe
  manalyze.exe --dump=imports,sections --hashes program.exe
  manalyze.exe -r malwares/ --plugins=peid,clamav --dump all

Pessoas usando o Manalyze

  • ANY.RUN
  • CinCan
  • DFN-CERT
  • The Hive
  • Yomi
  • Threat.Zone

Entre em contato comigo ou abra um pull request se desejar ser adicionado a esta lista!

Contato

E-Mail Twitter GnuPG

Baixar ferramenta