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
Strumenti/GitHubGitHub/dmaivel/covirt
Analisi StaticaAnalisi Dinamica (Sandboxing)Analisi del CodiceReverse EngineeringAnalisi MalwareAnalisi di Binari
GitHubdmaivel/covirt

covirt

Un virtualizzatore di codice x86-64 per offuscamento basato su VM

Vedi Repository
2483821 anno 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

covirt license

Un virtualizzatore di codice x86-64 per offuscamento basato su VM.

Caratteristiche

  • Architettura di macchina virtuale basata su stack
  • Offuscamento MBA (Mixed Boolean Arithmetic) e codice auto-modificante
  • Supporto per binari PE* ed ELF
  • Marcatori di codice per definire le regioni protette

*Il supporto PE è stato testato solo su binari compilati tramite MinGW-w64

Per iniziare

Dipendenze

CMake scaricherà tutte queste dipendenze, quindi non è necessario installarle manualmente.

Scarica lo strumento
NomeVersione
CMake3.25+
Zydis4.1.0+
zasmUltima
LIEF0.15.1+

Compilazione

È necessario un compilatore compatibile con C++23 per compilare.

root@kitploit:~
git clone https://github.com/dmaivel/covirt.git
cd covirt
mkdir build
cd build
cmake ..
cmake --build . --config Release

Se stai compilando su Windows tramite Visual Studio, devi usare clang-cl: cmake .. -T ClangCL -A x64.

Utilizzo

root@kitploit:~
Usage: covirt [--help] [--version] [--output OUTPUT_PATH] [--vm_code_size MAX] [--vm_stack_size SIZE] [--no_self_modifying_code] [--no_mixed_boolean_arith] [--show_dump_table] INPUT_PATH

Code virtualizer for x86-64 ELF & PE binaries

Positional arguments:
  INPUT_PATH                         path to input binary to virtualize 

Optional arguments:
  -h, --help                         shows help message and exits 
  -v, --version                      prints version information and exits 
  -o, --output OUTPUT_PATH           specify the output file [default: INPUT_PATH.covirt] 
  -vcode, --vm_code_size MAX         specify the maximum allowed total lifted bytes [default: 2048]
  -vstack, --vm_stack_size SIZE      specify the size of the virtual stack [default: 2048]
  -no_smc, --no_self_modifying_code  disable smc pass 
  -no_mba, --no_mixed_boolean_arith  disable mba pass 
  -d, --show_dump_table              show disassembly of the vm instructions

Marcatori di codice

Affinché covirt sappia quali funzioni devono essere virtualizzate, devi aggiungere i marcatori di inizio e fine nel tuo codice sorgente, in questo modo:

root@kitploit:~
#include "covirt_stub.h"

int my_function(...)
{
    int result = 0;
  
    __covirt_vm_start();
    // ...
    __covirt_vm_end();

    return result;
}

[!IMPORTANTE]

  • Non posizionare __covirt_vm_end in punti irraggiungibili (ad esempio dopo un return), poiché impedirà l'emissione dello stub di fine
  • Gli stub __covirt_vm_...(); non funzionano con MSVC perché usano assembly inline
  • È richiesto il supporto SSE4

Demo

root@kitploit:~
#include <covirt_stub.h>
#include <stdio.h>

int calculate(int a, int b)
{
    int result = 0;

    __covirt_vm_start();
    
    for (int i = 0; i < 10; i++)
        if (i > 5)
            result += result + a;
        else
            result += (result >> 1) + b;
    printf("result = %d\n", result);

    __covirt_vm_end();

    return result;
}

int main()
{
    calculate(5, 12);
}

L'esempio sopra è stato virtualizzato usando covirt a.out -d, che produce un dump delle istruzioni VM dopo offuscamento e virtualizzazione. L'attuale implementazione VM spinge la maggior parte degli operandi nello stack per elaborarli, riducendo la complessità di codifica delle istruzioni VM. Per le istruzioni che non hanno un gestore VM definito, vengono eseguite nativamente (vm_exit -> istruzione nativa -> vm_enter). La chiamata a funzioni segue lo stesso flusso: usciamo, chiamiamo la funzione e rientriamo nella VM. Tutte queste trasformazioni fanno crescere notevolmente la dimensione dei binari:

  • a.out come ELF: 15.5 kB -> 1.0 MB
  • a.out come PE: 259.3 kB -> 1.3 MB

Offuscamento

DescrizioneIDA
Decompilazione IDA di vm_entry, offuscata solo con il passaggio MBA. Il decompilatore ha generato oltre 27k righe di codice.cpp
Disassemblaggio IDA di vm_entry, offuscata con i passaggi MBA e SMC. La decompilazione non funziona.cpp

Problemi noti

  • Non è possibile chiamare un'altra funzione protetta dalla VM all'interno di una regione protetta
    • Causa segfault se la VM è offuscata
    • Nessun valore di ritorno se la VM non è offuscata