Analisi del Ransomware Cy3toc

Autore: Fabio De filippo (Malware analysist e Reverse engineer)

Analisi statica del codice sorgente del malware di tipologia ransomware denominato .c3ytok che ha colpito ad Agosto 2022 una società per azioni italiana.

Note di rilevanza

IP – URL:

NAME:    icanhazip.com

Address:    104.18.115.97

Address:    104.18.114.97

Address:    2606:4700::6812:7261

Address:    2606:4700::6812:7361

DNS:

www.icanhazip.com

6.icanhazip.com

4.icanhazip.com

ipv4.icanhazip.com

ipv6.icanhazip.com

Entry Point:

YzTymtbtgFABHvJvj\kbQIvXvEZvl.cs private static void Main(string[] OGTiaaHkEo)

Metodi di Crittografia:

public static Rfc2898DeriveBytes SacGfDIczRMIB(byte[] GutBmrkESARla, byte[] jrCfMwWaNikDb)

{

    return new Rfc2898DeriveBytes(GutBmrkESARla, jrCfMwWaNikDb, 52768);

}

46.png

Inizializzazione

L’analisi è stata svolta su una virtual machine VirtualBox con Windows 11 Trial. Una volta avviato l’eseguibile, vengono monitorati subito i seguenti parametri:

  • Il tempo trascorso;
  • Lo stato di esecuzione dell’eseguibile;
2.png

A questo punto del codice si procede alla creazione di un Mutex (Mutual Exclusion) globale con il nome ‘afd1418c-2aac-41d1-bd2d-98c31a06eef7’, ossia un indicatore che permette al malware di comprendere se l’host sia già stato infettato, così da non dover riavviare nuovamente l’operazione.

Il metodo WaitOne permette di attendere che il Mutex globale torni disponibile, qualora un altro thread lo stesse controllando; se per ipotesi il Mutex tornasse disponibile, il thread corrente riceverebbe un segnale e il metodo fornirebbe in output il valore booleano true, ossia che gli permetta di proseguire con l’infezione, altrimenti il processo stesso terminerà: 

3-0.png

Da notare che Global è uno spazio dei nomi che permette di condividere l’oggetto di sincronizzazione con i processi di sistema.

3.png

Qui di seguito mostro il metodo citato:

3-1.png

Questa funzione esegue un controllo sul valore public static string DcTMAxKEfG = “YES”.

4.png

Nel metodo public static void mWjVoAcGStSKku() della classe fVuTzVzWNoNY, la chiamata al thread inizializza un ciclo infinito che elabora due liste di stringhe sotto mostrate:

4-0.png
4-1.png

Mentre la seconda lista di stringhe, List<string>fVuTzVzWNoNY.MhtLjTyxWican, contiene i seguenti valori:

4-2.png
4-3.png

A sua volta passa i parametri nel metodo public static bool IWSSsKOQpACQ(ProcessBoPMnDZuzIuj, stringcpgcxdbDTAijKgueZ) della classe LxGBAwCNTHTX, la quale controlla se il nome del processo passato come primo argomento contenga il valore del secondo parametro passato.

4-4.png

Successivamente punta al metodo TrGAwBQDeHp() in cui si riprendono alcune dinamiche di enumerazione del noto ransomware “LOCKBIT”: avvia il processo cmd.exe e svolge il ping all’indirizzo ip di localhost, in attesa che il binario termini le sue operazioni, lo sovrascrive al fine di bypassare l’analisi forense e infine lo cancella:

4-5.png

Qualora il metodo public static bool IWSSsKOQpACQ(ProcessBoPMnDZuzIuj, stringcpgcxdbDTAijKgueZ) restituisse true, probabilmente il processo verrebbe terminato. I predetti meccanismi avvengono in un ciclo infinito, avviato inizialmente dal metodo public static void mWjVoAcGStSKku(), come già specificato prima.

Tornando con la nostra analisi al kbQIvXvEZvl.Main(), il malware richiama una funzione alquanto particolare:

5.png

Il metodo in questione punta alla funzione “SetProcessShutdownParameters” della libreria “kernel32.dll”, capace di arrestare il processo chiamante (CIT. “Sets shutdown parameters for the currently calling process.”). Questa operazione la svolge con privilegi elevati rispetto ad altri processi di sistema, questo anche grazie ai valori uint 0 passati:

1.png

Per questa funzione si fa riferimento alla documentezione ufficiale Microsoft https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-setprocessshutdownparameters:

BOOL SetProcessShutdownParameters(

  [in] DWORD dwLevel,

  [in] DWORD dwFlags

);

Rimanendo con la nostra analisi all’interno del metodo kbQIvXvEZvl.Main(), vengono controllati i privilegi di Administrator,  eseguendo in background i seguenti comandi:

6.png

Dal kbQIvXvEZvl.Main() viene eseguito il metodo public static void tiyhJJZwNLu(string[] ssfZHQvxLYTDF) della classe asXsYOANrzEIz, che elabora l’array string PFFHDAwoyhOd:

6-2.png

Il metodo AweoaQxTdeQBi fa le dovute decodifiche come da screenshot sopra raffigurati:

6-1.png

Nella chiamata public static string MpkqlRFRejsb(), della classe asXsYOANrzEIz, vengono creati dinamicamente due file difficilmente rilevabili nel codice sorgente poiché opportunamente offuscati, il nome di uno dei due viene poi dato a string (vedi sopra); da notare il messaggio Console.WriteLine(“Rkit is being loaded…”) che, probabilmente, potrebbe fare riferimento al fatto che le variabili s e s2 contengano un rootkit e che questo stia per essere creato nel sistema per mezzo del metodo statico File.WriteAllBytes():

6-3a.png
6-3b.png

Nello screenshot appena sopra vediamo che il processo scrive il nome del file (il RootKit) appena creato nel campo public static string xxemfVpsFwlEjNAk = string.Empty della classe kbQIvXvEZvl (principale), in modo che sia poi richiamabile dal metodo public static void tiyhJJZwNLu(string[] ssfZHQvxLYTDF) della classe asXsYOANrzEIz.

6-2.png

Questi comandi appena visti vengono eseguiti all’interno del ciclo infinito descritto in precedenza. Il FileName è il file creato da public static string MpkqlRFRejsb(), mentre gli argomenti vengono passati uno ad uno al secondo parametro di public static string cfCKsvnforMo(stringYeYXToigxt = “”, stringLFgdUbxsGoiZ = “”):

Il FileName ha quindi il valore del campo public static string xxemfVpsFwlEjNAk della classe principale kbQIvXvEZvl, ossia il binario (il Rootkit) creato dal metodo public static string MpkqlRFRejsb(), con l’indizio del Console.WriteLine(“Rkit is being loaded…”):

6-4.png

Ritornando al kbQIvXvEZvl.Main(), i passaggi successivi sono i seguenti:

  • richiama 4 volte il metodo kbQIvXvEZvl.AweoaQxTdeQBi:
7.png

In questo punto del codice vengono richiamate molte funzioni enumerative specifiche allo scopo di leggere informazioni dai processi tramite i loro ID:

7-1.png
7-2.png
  • esegue un secondo controllo sullo stato dei privilegi, eseguendo, in caso di privilegi elevati, la chiamata al metodo kbQIvXvEZvl.wGYtDPIMQexE:
8a.png
  • Ricontrolla i privilegi di ‘Administrator’ lkIfjPcyPYEKtxQz.DtRfJoGJgIMwI(), costruendo in maniera dinamica la classe UwXbesTiQXNTI() e chiamando il metodo qrieSGahUlMHRj():
9.png
10.png

Il metodo qrieSGahUlMHRj() crea una sottochiave nel registro di sistema e disabilita il Task Manager:

10a.png

La chiamata AlkIfjPcyPYEKtxQz.jYuRBDDRDPdEDK(), ossia public static void jYuRBDDRDPdEDK(), fa sì che il processo entri in Debug Mode e richiami la funzione “NtSetInformationProcess” della libreria “ntdll.dll“, che permette di settare il processo con lo status “CRITICO” grazie al valore passato 29, ossia 0x1D, al parametro ‘PROCESS_INFORMATION_CLASS’:

10b.png

L’operazione di creazione della chiave del registro di sistema si ripete, ma un nuovo metodo entra in gioco:

10.png

Il metodo UwXbesTiQXNTI().QVYAqoNnKB() setta i permessi negati ad “ALL USER”, usando il WellKnownSidType.WorldSid.

10b.png

Sempre nella classe principale passa a questo blocco di codice, e verifica le seguenti condizioni (se una di queste fosse vera, il processo terminerebbe la sua esecuzione):

  • La dimensione di volume massima (61000000000L); 
  • Se il sistema operativo è Windows XP;
  • Se l’esecuzione avviene su Virtual Machine;
10d.png

Qui di seguito la parte di codice interessata:

10c.png

PERSISTENCE 

Il malware sfrutta la cartella STARTUP in modo che, qualora il sistema operativo venisse arrestato, la sessione verrebbe eseguita ad ogni riavvio, garantendone oltretutto una proprietà importante per gli exploit, ossia la PERSISTENZA:

12.png

Il thread parallelo invia messaggi di errore, quali ‘This program requires Microsoft .NET Framework v. 4.82 or superior to run properly’, con titolo ‘Information…’.

11a.png

kbQIvXvEZvl.GzelMooQpnCw è un metodo che sfrutta la classe RNGCryptoServiceProvider per generare in modo sicuro un valore pseudo-randomico:

12a.png
12b.png

BACKUP

In questa parte di codice vengono inviati diversi comandi con relativi argomenti:

14.png
15.png

Successivamente passa alla cancellazione dei file di backup:

43.png

Qui di seguito possiamo notare il metodo che gestisce l’effettiva operazione di cancellazione dei dati:

12c.png

Successivamente, crea il file Config.enc, scrive all’interno l’id della vittima e altri dati utili per la fase di crittografia, subito dopo li cancella immediatamente.

Da notare la presenza dei parametri gestiti in fase di decrittografia dal Decryptor e come non venga gestito il parsing in modo corretto, usando, per esempio, il metodo “CONTAINS” della classe string, al posto del metodo più indicato in questa circostanza “STARTSWITH”:

17.png
18.png
19.png
20.png
21.png
22.png
23.png
45.png

La gestione dei messaggi tramite la console lascia molti dubbi in merito, non solo per la loro presenza in fase di esecuzione, ma anche per il fatto che non venga utilizzato il corretto STD.

Il loro utilizzo fa pensare che il malware venga utilizzato e gestito da remoto, tramite shell definendo l’appartenenza ad una botnet e che i messaggi siano visibili dal criminale informatico durante l’esecuzione.

Da notare, inoltre, che questo malware non utilizzi nessun argomento, o meglio che l’array string[] OGTiaaHkEo degli argomenti passati da riga di comando non venga mai utilizzato:

24.png

Andando avanti nel codice vedremo che alcune operazioni vengono ripetute nel tempo:

25.png

Inoltre si può notare la cancellazione del contenuto del cestino, la disattivazione del firewall e lo sharing di file e stampanti:

26.png

Infine la disattivazione del monitoraggio in tempo reale di Windows Defender:

42.png

Terminate queste disattivazioni, passa alla scrittura di ulteriori chiavi nel registro di sistema:

29.png

A questo punto scrive le stringhe di testo nel file di avvertimento alla vittima, puntando ad un servizio online di recupero dell’IP pubblico dal dominio di riferimento:

30.png

CRITTOGRAFIA 

In questa parte di codice si passa alla crittografia dei file, qui vengono richiamate 4832 estensioni, alcune sconosciute (per motivi di lunghezza del testo di analisi non tutte verranno elencate):

e-0.png
32.png
33.png

Qui il codice della crittografia:

e-1.png
e-2.png
e-3.png
e-4.png

E qui il completamento del file di avvertimento:

34.png
35.png
36.png
37.png
39.png
40.png

Le informazioni sulla chiave e sul vettore di inizializzazione nell’algoritmo di cifratura simmetrica (AES) vengono salvati in più stringhe BASE64, Suddivise da ‘LQ==’, ossia ‘-‘, e ‘Lw==’, cioè ‘+’, organizzate all’interno del footer dell’eseguibile:

47a.png
47b.png
47c.png
47d.png

Dll importate:

__________________________________________________

FILE c3ytok:

Nell’esempio riportato dell’header e footer, vediamo l’header di un file PDF crittografato:

Mentre nel footer, vediamo la stringa in BASE64 suddivisa da i caratteri ‘-‘ e ‘+’ che saranno comuni a tutti i file crittografati:

Tags:

No responses yet

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Latest Comments

Nessun commento da mostrare.