Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
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.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Manalyze — Analizzatore statico per eseguibili PE con rilevamento basato su plugin di packer, compilatori, importazioni sospette, costanti crittografiche e firme ClamAV. Supporta l'invio di hash a VirusTotal e la verifica di authenticode. | Kitploit
Strumenti/GitHubGitHub/justicerage/manalyze
Analisi StaticaAnalisi delle VulnerabilitàReverse EngineeringAnalisi MalwareAnalisi di Binari
GitHubjusticerage/manalyze

Manalyze

Analizzatore statico per eseguibili PE con rilevamento basato su plugin di packer, compilatori, importazioni sospette, costanti crittografiche e firme ClamAV. Supporta l'invio di hash a VirusTotal e la verifica di authenticode.

Vedi Repository
1.1k1708 giorni faRevisionato da Kitploit

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

Manalyze Documentation

Introduzione

Manalyze è un tool di analisi statica per file PE che puoi utilizzare per condurre una valutazione primaria su un eseguibile (o un insieme di eseguibili). Raccoglie segnali deboli che potrebbero indicare un comportamento malevolo e mostra informazioni che possono aiutare una successiva analisi manuale.

Se vuoi vedere alcuni report di esempio generati dal tool, sentiti libero di provare il servizio web che ho creato per esso: manalyzer.org.

Indice

  • Un analizzatore statico per file PE
  • Come compilare
  • Generazione delle regole ClamAV
  • Utilizzo
  • Chi utilizza Manalyze
  • Contatti

Un analizzatore statico per file PE

Manalyze è stato scritto in C++ per Windows e Linux ed è rilasciato sotto i termini della licenza GPLv3. È un parser robusto per file PE con un'architettura flessibile a plugin che permette agli utenti di analizzare staticamente i file in profondità. Manalyze...

  • Identifica il compilatore di un PE
  • Rileva eseguibili packed
  • Applica le firme ClamAV
  • Cerca stringhe sospette
  • Cerca combinazioni di import dannose (es. WriteProcessMemory + CreateRemoteThread)
  • Rileva costanti crittografiche (proprio come il plugin findcrypt di IDA)
  • Può inviare hash a VirusTotal
  • Verifica le firme authenticode (solo su Windows)

Come compilare

Ci sono poche cose che odio più che fare il checkout di un progetto open-source e passare due ore a cercare di compilarlo. Ecco perché ho fatto del mio meglio per rendere Manalyze il più semplice possibile da compilare. Se queste poche righe non funzionano per te, allora ho fallito nel mio lavoro e dovresti scrivermi così posso risolvere il problema.

Su Linux e BSD (testato su Debian Bullseye e FreeBSD 10.2)

root@kitploit:~
$> [sudo o come root] apt-get install libboost-dev libboost-system-dev libssl-dev build-essential cmake git
$> [in alternativa, anche sudo o come 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: il plugin VirusTotal è opzionale e richiede la libreria Boost.System.

Infine, se vuoi accedere a Manalyze da qualsiasi directory della tua macchina, installalo usando $> make install dalla cartella radice del progetto.

Su Windows

  • Ottieni Boost da boost.org (header) e installa CMake.
  • Se vuoi il plugin VirusTotal, compila la libreria Boost.System:
    • cd boost_1_XX_0 && ./bootstrap.bat && ./b2.exe --build-type=complete --with-system
  • Aggiungi una variabile d'ambiente BOOST_ROOT che contiene il percorso alla tua cartella boost_1_XX_0.
  • Scarica e installa Git
  • git clone https://github.com/JusticeRage/Manalyze.git && cd Manalyze && cmake .
  • Dovrebbe apparire un progetto Visual Studio manalyze.sln nella cartella Manalyze!

Su OS X (testato su Mojave)

root@kitploit:~
# Salta queste due righe se hai già un ambiente di compilazione sano
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

Compilazioni offline

Se devi compilare Manalyze su una macchina senza accesso a Internet, devi fare il checkout manuale dei seguenti progetti:

  • Yara
  • hash-library

Posiziona le due cartelle nella cartella external rispettivamente come external/yara e external/hash-library. Poi esegui cmake . -DGitHub=OFF e continua normalmente.

Binari

  • Binari Windows x64

Immagine Docker

Un'immagine Docker per Manalyze è fornita dalla community. Esegui docker pull evanowe/manalyze e ottieni ulteriori informazioni qui.

Generazione delle regole ClamAV

Poiché le firme ClamAV sono voluminose e aggiornate regolarmente, non aveva molto senso distribuirle da GitHub o con il binario. Quando provi a utilizzare il plugin ClamAV per la prima volta, molto probabilmente incontrerai il seguente messaggio di errore: [!] Error: Could not load yara_rules/clamav.yara. Per generarli, esegui lo script Python update_clamav_signatures.py situato in bin/yara_rules (albero dei sorgenti) o ${CMAKE_INSTALL_DATADIR}/manalyze/yara_rules (installato, comunemente /usr/share/manalyze/yara_rules o /usr/local/share/manalyze/yara_rules).

Esegui lo script ogni volta che desideri aggiornare le firme. Le cache Yara compilate sono memorizzate in $XDG_CACHE_HOME/manalyze/yara_rules o ~/.cache/manalyze/yara_rules, e possono essere sovrascritte con MANALYZE_CACHE_DIR.

Percorsi e sovrascritture

Le posizioni di installazione predefinite (che onorano CMAKE_INSTALL_PREFIX) sono:

  • config: ${CMAKE_INSTALL_SYSCONFDIR}/manalyze/manalyze.conf (spesso /etc/manalyze/manalyze.conf o /usr/local/etc/manalyze/manalyze.conf)
  • rules: ${CMAKE_INSTALL_DATADIR}/manalyze/yara_rules (spesso /usr/share/manalyze/yara_rules o /usr/local/share/manalyze/yara_rules)
  • plugins: ${CMAKE_INSTALL_LIBDIR}/manalyze/plugins

Puoi sovrascriverli con le variabili d'ambiente: MANALYZE_CONFIG_DIR, MANALYZE_DATA_DIR, MANALYZE_PLUGIN_DIR, MANALYZE_CACHE_DIR.

Utilizzo

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)
I binding Python si trovano in `manapy/` e vengono importati come `manalyze`.

Dalla radice del repository:

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

Chi utilizza Manalyze

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

Contattami o apri una pull request se desideri essere aggiunto a questa lista!

Contatti

E-Mail Twitter GnuPG

Scarica lo strumento