Analisi del Ransomware Cy3toc

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);

}

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;

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à:

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

Qui di seguito mostro il metodo citato:

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

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:

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

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.

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:

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:

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:

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:

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

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

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():

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.

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…”):

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

richiama 4 volte il metodo kbQIvXvEZvl.AweoaQxTdeQBi:

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

esegue un secondo controllo sullo stato dei privilegi, eseguendo, in caso di privilegi elevati, la chiamata al metodo kbQIvXvEZvl.wGYtDPIMQexE:

Ricontrolla i privilegi di ‘Administrator’ lkIfjPcyPYEKtxQz.DtRfJoGJgIMwI(), costruendo in maniera dinamica la classe UwXbesTiQXNTI() e chiamando il metodo qrieSGahUlMHRj():

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

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’:

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

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

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;

Qui di seguito la parte di codice interessata:

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:

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…’.

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

BACKUP

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

Successivamente passa alla cancellazione dei file di backup:

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

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”:

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:

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

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

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

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

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:

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):

Qui il codice della crittografia:

E qui il completamento del file di avvertimento:

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: