CPP 163
As Guest on 11th February 2020 06:38:35 PM
  1. #include <winsock2.h>
  2. #include <windows.h>
  3. #include <iphlpapi.h>
  4. #include <stdio.h>
  5. #include <time.h>
  6. #include <tlhelp32.h>
  7. #include <psapi.h>
  8. #include <icmpapi.h>
  9. #include <io.h>
  10.  
  11. #include "hook.h"
  12. #include "blowfish.h"
  13. #include "resource.h"
  14. #include "Obfuscator.h"
  15.  
  16. #include "stdafx.h"
  17. #include "ThemidaSDK.h"
  18. #include "splash.h"
  19.  
  20. #pragma comment(lib, "User32.lib")
  21. #pragma comment(lib, "ws2_32.lib")
  22. #pragma comment(lib, "iphlpapi.lib")
  23. #pragma comment(lib, "psapi.lib")
  24.  
  25. struct TFontDrawInfo
  26. {
  27.         int font;
  28.         unsigned int color, u1, u2, u3, u4;
  29. };
  30.  
  31. struct TNetworkPacket
  32. {
  33.     unsigned char id, p1;
  34.     unsigned short int subid, size, p2;
  35.     unsigned char *data;
  36. };
  37.  
  38. struct TSpecialString
  39. {
  40.         bool isDraw;
  41.         TFontDrawInfo FontDrawInfo;
  42.         int x, y;
  43.         wchar_t text[64];
  44. };
  45.  
  46. #pragma pack(1)
  47. typedef struct _IDENTIFY_DATA
  48. {
  49.         USHORT GeneralConfiguration;
  50.     USHORT NumberOfCylinders;
  51.     USHORT Reserved1;
  52.     USHORT NumberOfHeads;
  53.     USHORT UnformattedBytesPerTrack;
  54.     USHORT UnformattedBytesPerSector;
  55.     USHORT SectorsPerTrack;
  56.     USHORT VendorUnique1[3];
  57.     USHORT SerialNumber[10];
  58.     USHORT BufferType;
  59.     USHORT BufferSectorSize;
  60.     USHORT NumberOfEccBytes;
  61.     USHORT FirmwareRevision[4];
  62.     USHORT ModelNumber[20];
  63.     UCHAR  MaximumBlockTransfer;
  64.     UCHAR  VendorUnique2;
  65.     USHORT DoubleWordIo;
  66.     USHORT Capabilities;
  67.     USHORT Reserved2;
  68.     UCHAR  VendorUnique3;
  69.     UCHAR  PioCycleTimingMode;
  70.     UCHAR  VendorUnique4;
  71.     UCHAR  DmaCycleTimingMode;
  72.     USHORT TranslationFieldsValid:1;
  73.     USHORT Reserved3:15;
  74.     USHORT NumberOfCurrentCylinders;
  75.     USHORT NumberOfCurrentHeads;
  76.     USHORT CurrentSectorsPerTrack;
  77.     ULONG  CurrentSectorCapacity;
  78.     USHORT CurrentMultiSectorSetting;
  79.     ULONG  UserAddressableSectors;
  80.     USHORT SingleWordDMASupport : 8;
  81.     USHORT SingleWordDMAActive : 8;
  82.     USHORT MultiWordDMASupport : 8;
  83.     USHORT MultiWordDMAActive : 8;
  84.     USHORT AdvancedPIOModes : 8;
  85.     USHORT Reserved4 : 8;
  86.     USHORT MinimumMWXferCycleTime;
  87.     USHORT RecommendedMWXferCycleTime;
  88.     USHORT MinimumPIOCycleTime;
  89.     USHORT MinimumPIOCycleTimeIORDY;
  90.     USHORT Reserved5[2];
  91.     USHORT ReleaseTimeOverlapped;
  92.     USHORT ReleaseTimeServiceCommand;
  93.     USHORT MajorRevision;
  94.     USHORT MinorRevision;
  95.     USHORT Reserved6[50];
  96.     USHORT SpecialFunctionsEnabled;
  97.     USHORT Reserved7[128];
  98. } IDENTIFY_DATA, *PIDENTIFY_DATA;
  99. #pragma pack()
  100.  
  101. typedef int (__stdcall *_connect) (SOCKET s, const struct sockaddr *name, int namelen);
  102. _connect true_connect;
  103.  
  104. typedef int (__fastcall *_AddNetworkQueue) (unsigned int This, unsigned int EDX, TNetworkPacket *NetworkPacket);
  105. _AddNetworkQueue true_AddNetworkQueue;
  106.  
  107. typedef void (__cdecl *_SendPacket) (unsigned int This, char *Format, ...);
  108. _SendPacket true_SendPacket;
  109.  
  110. typedef void (_fastcall *_MasterProcessPreRender) (unsigned int This, unsigned int EDX, unsigned int UCanvas);
  111. _MasterProcessPreRender true_MasterProcessPreRender;
  112.  
  113. typedef int (_fastcall *_DrawTextTTFToCanvas) (unsigned int This, unsigned int EDX, int X, int Y, wchar_t *text, TFontDrawInfo *FontDrawInfo, unsigned char, int, int, unsigned int FontDrawInfoSection);
  114. _DrawTextTTFToCanvas true_DrawTextTTFToCanvas;
  115.  
  116. typedef void (_fastcall *_Render) (unsigned int This, unsigned int EDX, unsigned int FRenderInterface);
  117. _Render true_Render;
  118.  
  119. RECT rc;
  120. HWND hWND;
  121. TSpecialString SpecialStrings[16];
  122. unsigned int Canvas, hEngineStart, hEngineEnd, mainThread, lastPing = 0, KiUserExceptDispADR, hNtDllStart, hNtDllEnd;
  123. HANDLE ghMutex;
  124.  
  125. void ErrorExit(char *msg)
  126. {
  127.         FILE *f;
  128.        
  129.         fopen_s(&f, "Protection.log", "a+");
  130.  
  131.         if (f != 0)
  132.         {
  133.                 fprintf(f, "%s\n", msg);
  134.                 fclose(f);
  135.         }
  136.  
  137.         ExitProcess(0);
  138. }
  139.  
  140. void Logger(char *msg)
  141. {
  142.         FILE *f;
  143.        
  144.         fopen_s(&f, "Debug.log", "a+");
  145.  
  146.         if (f != 0)
  147.         {
  148.                 fprintf(f, "%s\n", msg);
  149.                 fclose(f);
  150.         }
  151. }
  152.  
  153. bool SetPrivileges(HANDLE hProcess, DWORD dwPrivilegeCount, LPCTSTR *ppPrivilegeName)
  154. {
  155.         HANDLE hToken = 0;
  156.         if(!::OpenProcessToken(hProcess, TOKEN_ALL_ACCESS, &hToken))
  157.                 return false;
  158.  
  159.         PTOKEN_PRIVILEGES Privileges = (PTOKEN_PRIVILEGES)
  160.                 new char[sizeof(DWORD) + sizeof(LUID_AND_ATTRIBUTES) * dwPrivilegeCount];
  161.  
  162.         LUID_AND_ATTRIBUTES *LuidAndAttr = (LUID_AND_ATTRIBUTES *)(((char *)Privileges) + sizeof(DWORD));
  163.  
  164.         Privileges->PrivilegeCount = dwPrivilegeCount;
  165.  
  166.         for(DWORD i = 0; i < dwPrivilegeCount; i++)
  167.         {
  168.                 if(!::LookupPrivilegeValue(0,
  169.                         ppPrivilegeName[i],
  170.                         &LuidAndAttr[i].Luid))
  171.                 {
  172.                         ::CloseHandle(hToken);
  173.                         delete[]Privileges;
  174.                         return false;
  175.                 }
  176.  
  177.                 LuidAndAttr[i].Attributes = SE_PRIVILEGE_ENABLED;
  178.         }
  179.         if(!::AdjustTokenPrivileges(hToken, FALSE, Privileges, 0, 0, 0))
  180.         {
  181.                 ::CloseHandle(hToken);
  182.                 delete[]Privileges;
  183.                 return false;
  184.         }
  185.         ::CloseHandle(hToken);
  186.         delete[]Privileges;
  187.         return true;
  188. }
  189.  
  190. bool checkRun(char* NAmePorc)
  191. {
  192.     HANDLE hProcessSnap = NULL;
  193.     PROCESSENTRY32 pe32;
  194.     hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  195.     if(hProcessSnap == INVALID_HANDLE_VALUE)
  196.         {
  197.                 return true;
  198.         }
  199.     pe32.dwSize = sizeof(PROCESSENTRY32);
  200.     if(Process32First(hProcessSnap, &pe32))
  201.     {
  202.         while(Process32Next(hProcessSnap, &pe32));
  203.                 {
  204.                         if(strstr(NAmePorc, (char*)pe32.szExeFile))
  205.                         {
  206.                                 CloseHandle (hProcessSnap);
  207.                                 return true;
  208.                         }
  209.                 }
  210.     }
  211.     CloseHandle(hProcessSnap);
  212.     return false;
  213. }
  214.  
  215. int __stdcall new_connect(SOCKET s, const struct sockaddr *name, int namelen)
  216. {
  217.         struct sockaddr_in *name_in = (struct sockaddr_in*) name;
  218.         if (name_in->sin_port == htons(2106))
  219.         {
  220.                 name_in->sin_port = htons(2106);
  221.                 name_in->sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
  222.         }
  223.  
  224.         if (name_in->sin_port == htons(7777))
  225.         {
  226.                 name_in->sin_port = htons(7777);
  227.                 name_in->sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
  228.         }
  229.         return true_connect(s, name, namelen);
  230. }
  231.  
  232. void decodeKey(unsigned char *buf)
  233. {
  234.         unsigned char bfkey[16] =  {110, 36, 2, 15, -5, 17, 24, 23, 18, 45, 1, 21, 122, 16, -5, 12}; //STATIC KEY
  235.         unsigned char tmp[24];
  236.         Blowfish_CTX ctx;
  237.  
  238.         memcpy(tmp, buf, 16);
  239.  
  240.         Blowfish_Init(&ctx, bfkey, 16);
  241.         Blowfish_Decrypt(&ctx, tmp, 16);
  242.  
  243.         memcpy(buf, tmp, 16);
  244. }
  245. int __fastcall new_AddNetworkQueue(unsigned int This, unsigned int EDX, TNetworkPacket *NetworkPacket)
  246. {
  247. //      if ((*(unsigned int*) (KiUserExceptDispADR + 10) + KiUserExceptDispADR < hNtDllStart) || (*(unsigned int*) (KiUserExceptDispADR + 10) + KiUserExceptDispADR > hNtDllEnd))
  248. //              ErrorExit("Bot Program Detected #0!");
  249.  
  250.         unsigned int retAddr = *((unsigned int*) &NetworkPacket - 1);
  251.  
  252.         if ((retAddr < hEngineStart) || (retAddr > hEngineEnd))
  253.                 ErrorExit("Bot Program Detected #1!");
  254.  
  255.         printf("S->C Pakcet id: %d", NetworkPacket->id); //all packets
  256.         if (NetworkPacket->subid == 0xFFFF)
  257.         {
  258.                 switch (NetworkPacket->id)
  259.                 {
  260.                         case 0x74:
  261.                                 true_SendPacket(This, "cc", 0xcb, 104);
  262.                                 printf("SIUNCIA GG");
  263.                                 break;
  264.                         case 0x2E:
  265.                         //      decodeKey(NetworkPacket->data + 1);
  266.                                 break;
  267.                         case 0xB0:
  268.                                 memset(&SpecialStrings[NetworkPacket->data[0]].FontDrawInfo, 0, sizeof(TFontDrawInfo));
  269.                                 SpecialStrings[NetworkPacket->data[0]].isDraw = (NetworkPacket->data[1] == 1) ? true : false;
  270.                                 SpecialStrings[NetworkPacket->data[0]].FontDrawInfo.font = (char) NetworkPacket->data[2];
  271.                                 SpecialStrings[NetworkPacket->data[0]].x = *(int*) (NetworkPacket->data + 3);
  272.                                 SpecialStrings[NetworkPacket->data[0]].y = *(int*) (NetworkPacket->data + 7);
  273.                                 SpecialStrings[NetworkPacket->data[0]].FontDrawInfo.color = *(unsigned int*) (NetworkPacket->data + 11);
  274.                                 wcscpy_s(SpecialStrings[NetworkPacket->data[0]].text, (wchar_t*) (NetworkPacket->data + 15));
  275.                                 if (NetworkPacket->data[0] == 14)
  276.                                 {
  277.                                         HANDLE hIcmpFile = IcmpCreateFile();
  278.                                         ICMP_ECHO_REPLY Reply;
  279.                                         if (hIcmpFile != 0)
  280.                                         {
  281.                                                 if (IcmpSendEcho(hIcmpFile, inet_addr("127.0.0.1"), 0, 0, 0, &Reply, sizeof(ICMP_ECHO_REPLY), 500) != 0)
  282.                                                         lastPing = Reply.RoundTripTime;
  283.                                                 IcmpCloseHandle(hIcmpFile);
  284.                                         }
  285.                                         wsprintf(SpecialStrings[NetworkPacket->data[0]].text, L"%ls%d", (wchar_t*) (NetworkPacket->data + 15), lastPing);
  286.                                 }
  287.                                 break;
  288.                 }
  289.         }
  290.  
  291.         return true_AddNetworkQueue(This, EDX, NetworkPacket);
  292. }
  293.  
  294. bool getHWID(wchar_t *str)
  295. {
  296.         HW_PROFILE_INFO   HwProfInfo;
  297.         char HWID[1024];
  298.  
  299.         if (!GetCurrentHwProfile(&HwProfInfo))
  300.         {
  301.                 return false;
  302.         }
  303.         sprintf_s(HWID, 1000, "%02X%02X%02X%02X", HwProfInfo.szHwProfileGuid);
  304.         mbstowcs_s(0, str, 1000, HWID, 1000);
  305.  
  306.         return true;
  307. }
  308.  
  309. bool getMAC(wchar_t *str)
  310. {
  311.         IP_ADAPTER_INFO AdapterInfo[16];
  312.         PIP_ADAPTER_INFO pAdapterInfo;
  313.         unsigned long dwBufLen;
  314.         char MAC[1024];
  315.  
  316.         dwBufLen = sizeof(AdapterInfo);
  317.  
  318.         if (GetAdaptersInfo(AdapterInfo, &dwBufLen) != ERROR_SUCCESS)
  319.                 return false;
  320.  
  321.         pAdapterInfo = AdapterInfo;
  322.  
  323.         while ((pAdapterInfo->Address[0] == 0) && (pAdapterInfo->Address[1] == 0) && (pAdapterInfo->Address[2] == 0) &&(pAdapterInfo->Address[3] == 0) && (pAdapterInfo->Address[4] == 0) && (pAdapterInfo->Address[5] == 0))
  324.                 pAdapterInfo = pAdapterInfo->Next;
  325.  
  326.         sprintf_s(MAC, 1000, "%02X%02X%02X%02X%02X%02X", pAdapterInfo->Address[0], pAdapterInfo->Address[1], pAdapterInfo->Address[2], pAdapterInfo->Address[3], pAdapterInfo->Address[4], pAdapterInfo->Address[5]);
  327.  
  328.         mbstowcs_s(0, str, 1000, MAC, 1000);
  329.  
  330.         return true;
  331. }
  332.  
  333. char *flipAndCodeBytes (const char *str, int pos, int flip, char *buf)
  334. {
  335.         int i;
  336.         int j = 0;
  337.         int k = 0;
  338.  
  339.         buf[0] = '\0';
  340.  
  341.         if (pos <= 0)
  342.                 return buf;
  343.  
  344.         if (!j)
  345.         {
  346.                 char p = 0;
  347.  
  348.                 j = 1;
  349.                 k = 0;
  350.                 buf[k] = 0;
  351.  
  352.                 for (i = pos; j && str[i] != '\0'; ++i)
  353.                 {
  354.                         char c = tolower(str[i]);
  355.  
  356.                         if (isspace(c))
  357.                                 c = '0';
  358.  
  359.                         ++p;
  360.                         buf[k] <<= 4;
  361.  
  362.                         if (c >= '0' && c <= '9')
  363.                                 buf[k] |= (unsigned char) (c - '0');
  364.                         else if (c >= 'a' && c <= 'f')
  365.                                 buf[k] |= (unsigned char) (c - 'a' + 10);
  366.                         else
  367.                         {
  368.                                 j = 0;
  369.                                 break;
  370.                         }
  371.  
  372.                         if (p == 2)
  373.                         {
  374.                                 if (buf[k] != '\0' && ! isprint(buf[k]))
  375.                                 {
  376.                                         j = 0;
  377.                                         break;
  378.                                 }
  379.  
  380.                                 ++k;
  381.                                 p = 0;
  382.                                 buf[k] = 0;
  383.                         }
  384.                 }
  385.         }
  386.  
  387.         if (!j)
  388.         {
  389.                 j = 1;
  390.                 k = 0;
  391.  
  392.                 for (i = pos; j && str[i] != '\0'; ++i)
  393.                 {
  394.                         char c = str[i];
  395.  
  396.                         if ( ! isprint(c))
  397.                         {
  398.                                 j = 0;
  399.                                 break;
  400.                         }
  401.  
  402.                         buf[k++] = c;
  403.                 }
  404.         }
  405.  
  406.         if (!j)
  407.         {
  408.                 k = 0;
  409.         }
  410.  
  411.         buf[k] = '\0';
  412.  
  413.         if (flip)
  414.                 for (j = 0; j < k; j += 2)
  415.                 {
  416.                         char t = buf[j];
  417.                         buf[j] = buf[j + 1];
  418.                         buf[j + 1] = t;
  419.                 }
  420.  
  421.                 i = j = -1;
  422.  
  423.                 for (k = 0; buf[k] != '\0'; ++k)
  424.                 {
  425.                         if (! isspace(buf[k]))
  426.                         {
  427.                                 if (i < 0)
  428.                                         i = k;
  429.  
  430.                                 j = k;
  431.                         }
  432.                 }
  433.  
  434.                 if ((i >= 0) && (j >= 0))
  435.                 {
  436.                         for (k = i; (k <= j) && (buf[k] != '\0'); ++k)
  437.                                 buf[k - i] = buf[k];
  438.  
  439.                         buf[k - i] = '\0';
  440.                 }
  441.  
  442.                 return buf;
  443. }
  444.  
  445. bool getHDDSerialNumber(wchar_t *str)
  446. {
  447.         HANDLE hPhysicalDriveIOCTL = 0;
  448.         char serialNumber[1024], windir[256], filename[256];
  449.  
  450.         if (GetWindowsDirectoryA(windir, 256) == 0)
  451.                 return false;
  452.  
  453.         memset(filename, 0, 256);
  454.  
  455.         strcpy_s(filename, "\\\\.\\\\");
  456.         windir[2] = 0;
  457.         strcat_s(filename, windir);
  458.  
  459.         hPhysicalDriveIOCTL = CreateFileA(filename, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
  460.  
  461.         if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
  462.                 return false;
  463.  
  464.         STORAGE_PROPERTY_QUERY query;
  465.         unsigned long cbBytesReturned = 0;
  466.         char buffer[10000];
  467.  
  468.         memset ((void *) &query, 0, sizeof (query));
  469.         query.PropertyId = StorageDeviceProperty;
  470.         query.QueryType = PropertyStandardQuery;
  471.  
  472.         memset (buffer, 0, sizeof (buffer));
  473.  
  474.         if (!(DeviceIoControl(hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY, &query, sizeof(query), &buffer, sizeof(buffer), &cbBytesReturned, 0)))
  475.         {
  476.                 CloseHandle(hPhysicalDriveIOCTL);
  477.                 return false;
  478.         }
  479.  
  480.         STORAGE_DEVICE_DESCRIPTOR * descrip = (STORAGE_DEVICE_DESCRIPTOR *) & buffer;
  481.  
  482.         sprintf_s(serialNumber, 1000, "%02X%02X", flipAndCodeBytes(buffer, descrip->SerialNumberOffset, 1, serialNumber));
  483.  
  484.         mbstowcs_s(0, str, 1000, serialNumber, 1000);
  485.  
  486.         return true;
  487. }
  488.  
  489. bool getHwGuid(wchar_t *str)
  490. {
  491.         HW_PROFILE_INFOA HwProfInfo;
  492.         char HWID[1024];
  493.  
  494.         if (GetCurrentHwProfileA(&HwProfInfo) == 0)
  495.                 return false;
  496.  
  497.         sprintf_s(HWID, 1000, "%02X%02X", HwProfInfo.szHwProfileGuid);
  498.  
  499.         mbstowcs_s(0, str, 1000, HWID, 1000);
  500.  
  501.         return true;
  502. }
  503.  
  504. void __cdecl new_SendPacket(unsigned int This, char *Format, ...)
  505. {
  506. //      if ((*(unsigned int*) (KiUserExceptDispADR + 10) + KiUserExceptDispADR < hNtDllStart) || (*(unsigned int*) (KiUserExceptDispADR + 10) + KiUserExceptDispADR > hNtDllEnd))
  507. //              ErrorExit("Bot Program Detected #2!");
  508.  
  509.         unsigned int retAddr = *((unsigned int*) &This - 1);
  510.  
  511.         if ((retAddr < hEngineStart) || (retAddr > hEngineEnd))
  512.         {
  513.                 true_SendPacket(This, "cc", 0xA1, 0x01);
  514.                 ErrorExit("Bot Program Detected #3!");
  515.         }
  516.  
  517.         if (((unsigned int) Format < hEngineStart) || ( (unsigned int) Format > hEngineEnd))
  518.         {
  519.                 true_SendPacket(This, "cc", 0xA1, 0x02);
  520.                 ErrorExit("Bot Program Detected #4!");
  521.         }
  522.  
  523.         if (GetCurrentThreadId() != mainThread)
  524.         {
  525.                 true_SendPacket(This, "cc", 0xA1, 0x03);
  526.                 ErrorExit("Bot Program Detected #5!");
  527.         }
  528.        
  529.         unsigned char buf[10240];
  530.         int size = 0, len;
  531.         wchar_t *wstr;
  532.  
  533.     va_list args;
  534.         va_start(args, Format);
  535.  
  536.         while (*Format != 0)
  537.         {
  538.                 switch (*Format)
  539.                 {
  540.                         case 'c':
  541.                                 *(unsigned char*) (buf + size) = va_arg(args, unsigned char);
  542.                                 size++;
  543.                                 break;
  544.                         case 'h':
  545.                                 *(unsigned short int*) (buf + size) = va_arg(args, unsigned short int);
  546.                                 size += 2;
  547.                                 break;
  548.                         case 'd':
  549.                                 *(unsigned int*) (buf + size) = va_arg(args, unsigned int);
  550.                                 size += 4;
  551.                                 break;
  552.                         case 'Q':
  553.                                 *(unsigned __int64*) (buf + size) = va_arg(args, unsigned __int64);
  554.                                 size += 8;
  555.                                 break;
  556.                         case 'b':
  557.                                 len = va_arg(args, unsigned int);
  558.                                 memcpy(buf + size, va_arg(args, void*), len);
  559.                                 size += len;
  560.                                 break;                 
  561.                         case 'S':
  562.                                 wstr = va_arg(args, wchar_t*);
  563.                                 if (wstr == 0)
  564.                                 {
  565.                                         len = 2;
  566.                                         *(unsigned short int*) (buf + size) = 0;
  567.                                 }
  568.                                 else
  569.                                 {
  570.                                         len = wcslen(wstr) * 2 + 2;
  571.                                         memcpy(buf + size, wstr, len);
  572.                                 }
  573.                                 size += len;
  574.                                 break;
  575.                         default:
  576.                                 true_SendPacket(This, "cc", 0xA1, 0x04);
  577.                                 ErrorExit("Send Packet Unknown Format!");
  578.                                 break;
  579.                 }
  580.                 Format++;      
  581.         }
  582.  
  583.         va_end(args);
  584.  
  585.         switch(buf[0])
  586.         {
  587.                 case 0x0E:
  588.                         wchar_t serialNumber[1024], MAC[1024], HwGuid[1024];
  589.                         memset(serialNumber, 0, 1024 * 2);
  590.                         memset(MAC, 0, 1024 * 2);
  591.                         if (!getHDDSerialNumber(serialNumber))
  592.                         {
  593.                                 true_SendPacket(This, "cc", 0xA1, 0x05);
  594.                                 ErrorExit("Get HDD Serial Number Fail!");
  595.                                 return;
  596.                         }
  597.                         if (!getMAC(MAC))
  598.                         {
  599.                                 true_SendPacket(This, "cc", 0xA1, 0x06);
  600.                                 ErrorExit("Get MAC Fail!");
  601.                                 return;
  602.                         }
  603.                         if (!getHwGuid(HwGuid))
  604.                         {
  605.                                 true_SendPacket(This, "cc", 0xA1, 0x07);
  606.                                 ErrorExit("Get HWID Fail!\n");
  607.                         }
  608.                         if ((wcslen(MAC) == 0) || (wcslen(serialNumber) == 0) || (wcslen(HwGuid) == 0))
  609.                         {
  610.                                 true_SendPacket(This, "cc", 0xA1, 0x08);
  611.                                 ErrorExit("Wrong MAC / Serial Number / HWID!");
  612.                                 return;
  613.                         }
  614.  
  615.                         memcpy(buf + size, serialNumber, wcslen(serialNumber) * 2 + 2);
  616.                         size += wcslen(serialNumber) * 2 + 2;
  617.                         memcpy(buf + size, MAC, wcslen(MAC) * 2 + 2);
  618.                         size += wcslen(MAC) * 2 + 2;
  619.                         memcpy(buf + size, HwGuid, wcslen(HwGuid) * 2 + 2);
  620.                         size += wcslen(HwGuid) * 2 + 2;
  621.                         break;
  622.         }
  623.         true_SendPacket(This, "b", size, (int)buf);
  624. }
  625.  
  626.  
  627. void _fastcall new_Render(unsigned int This, unsigned int EDX, unsigned int FRenderInterface)
  628. {
  629.         mainThread = GetCurrentThreadId();
  630.  
  631.         RECT L2Rect;
  632.         HWND *L2hWND = (HWND*) GetProcAddress(LoadLibraryA("core.dll"), "?GTopWnd@@3PAUHWND__@@A");
  633.  
  634.         true_Render(This, EDX, FRenderInterface);
  635.  
  636.         GetClientRect(*L2hWND, &L2Rect);
  637.  
  638.         for (int i = 0; i < 16; i++)
  639.         {
  640.                 if (SpecialStrings[i].isDraw)
  641.                 {
  642.                         if (i == 15)
  643.                         {
  644.                                 time_t rawtime;
  645.                                 struct tm timeinfo;
  646.                                 wchar_t exstr[16], newstr[64];
  647.  
  648.                                 time(&rawtime);
  649.                                 localtime_s(&timeinfo, &rawtime);
  650.                                 wcsftime(exstr, 15, L"%H:%M", &timeinfo);
  651.                                 wcscpy_s(newstr, SpecialStrings[i].text);
  652.                                 wcscat_s(newstr, exstr);
  653.  
  654.                                 true_DrawTextTTFToCanvas(Canvas, 0, L2Rect.right - SpecialStrings[i].x, L2Rect.top + SpecialStrings[i].y, newstr, &SpecialStrings[i].FontDrawInfo, 0xFF, 0, 0, 0);
  655.                         }
  656.                         else
  657.                                 true_DrawTextTTFToCanvas(Canvas, 0, L2Rect.right - SpecialStrings[i].x, L2Rect.top + SpecialStrings[i].y, SpecialStrings[i].text, &SpecialStrings[i].FontDrawInfo, 0xFF, 0, 0, 0);
  658.                 }
  659.         }
  660. }
  661.  
  662. void _fastcall new_MasterProcessPreRender(unsigned int This, unsigned int EDX, unsigned int UCanvas)
  663. {
  664.         Canvas = UCanvas;
  665.  
  666.         true_MasterProcessPreRender(This, EDX, UCanvas);
  667. }
  668.  
  669. bool DisableGameGuard(void)
  670. {
  671.         unsigned long oldProtect;
  672.         unsigned char *GL2UseGameGuard;
  673.  
  674.         GL2UseGameGuard = (unsigned char *) GetProcAddress(LoadLibraryA("core.dll"), "?GL2UseGameGuard@@3HA");
  675.  
  676.         if(GL2UseGameGuard == 0)
  677.                 return false;
  678.        
  679.         if(!VirtualProtect(GL2UseGameGuard, 1, PAGE_READWRITE, &oldProtect))
  680.                 return false;
  681.  
  682.         *GL2UseGameGuard = 0;
  683.  
  684.         if(!VirtualProtect(GL2UseGameGuard, 1, oldProtect, &oldProtect))
  685.                 return false;
  686.  
  687.         return true;
  688. }
  689.  
  690. unsigned int GetSendPacketAddress(void)
  691. {
  692.         HMODULE hEngine = LoadLibraryA("engine.dll");
  693.  
  694.         unsigned int startVMT = (unsigned int) hEngine + 0x51F658;
  695.         unsigned int AddNetworkQueue = (unsigned int) GetProcAddress(hEngine, "?AddNetworkQueue@UNetworkHandler@@UAEHPAUNetworkPacket@@@Z");
  696.         unsigned int currVMT = startVMT;
  697.  
  698.         if (AddNetworkQueue == 0)
  699.         {
  700.                 return 0;
  701.         }
  702.  
  703.         while (true)
  704.         {
  705.                 if (*(unsigned int*) currVMT == AddNetworkQueue)
  706.                 {
  707.                         return *(unsigned int*) (currVMT - 0xA4);
  708.                 }
  709.  
  710.                 currVMT++;
  711.                 if (currVMT - startVMT > 10000)
  712.                 {
  713.                         return 0;
  714.                 }
  715.         }
  716.         return 0;
  717. }
  718.  
  719. void TitleReplaceHookThread(void *param)
  720. {
  721.         while(true)
  722.         {
  723.                 Sleep(50);
  724.                 HWND hWnd = FindWindow(NULL, L"Lineage II");
  725.                 if(hWnd)
  726.                 {
  727.                         SetWindowText(hWnd, L" ");
  728.                         break;
  729.                 }
  730.         }
  731. }
  732.  
  733. void TitleReplaceHook()
  734. {
  735.         _beginthread(TitleReplaceHookThread, 0, NULL);
  736.         CloseHandle(TitleReplaceHookThread);
  737. }
  738.  
  739. bool SetHooks(void)
  740. {
  741.         FARPROC addr;
  742.         HMODULE hEngine = LoadLibraryA("engine.dll"), hNtDlll = LoadLibraryA("ntdll.dll");
  743.         MODULEINFO modinfo;
  744.  
  745.         GetModuleInformation(GetCurrentProcess(), hEngine, &modinfo, sizeof(MODULEINFO));
  746.  
  747.         hEngineStart = (unsigned int) hEngine;
  748.         hEngineEnd = hEngineStart + modinfo.SizeOfImage - 1;
  749.  
  750.         GetModuleInformation(GetCurrentProcess(), hNtDlll, &modinfo, sizeof(MODULEINFO));
  751.  
  752.         hNtDllStart = (unsigned int) hNtDlll;
  753.         hNtDllEnd = hNtDllStart + modinfo.SizeOfImage - 1;
  754.  
  755.         if ((KiUserExceptDispADR = (unsigned int) GetProcAddress(LoadLibraryA("ntdll.dll"), "KiUserExceptionDispatcher")) == 0)
  756.                 return false;
  757.  
  758.         if (*(unsigned char*) (KiUserExceptDispADR) == 0xFC)
  759.                 KiUserExceptDispADR++;
  760.  
  761.         if ((addr = GetProcAddress(LoadLibraryA("ws2_32.dll"), "connect")) == 0)
  762.                 return false;
  763.  
  764.         true_connect = (_connect) splice((unsigned char*) addr, new_connect);
  765.  
  766.         if ((addr = GetProcAddress(hEngine, "?AddNetworkQueue@UNetworkHandler@@UAEHPAUNetworkPacket@@@Z")) == 0)
  767.                 return false;
  768.  
  769.         true_AddNetworkQueue = (_AddNetworkQueue) splice((unsigned char*) addr, new_AddNetworkQueue);
  770.  
  771.         if ((addr = (FARPROC) GetSendPacketAddress()) == 0)
  772.                 return false;
  773.  
  774.         true_SendPacket = (_SendPacket) splice((unsigned char*) addr, new_SendPacket);
  775.  
  776.         if ((addr = GetProcAddress(hEngine, "?MasterProcessPreRender@UInteractionMaster@@QAEXPAVUCanvas@@@Z")) == 0)
  777.                 return false;
  778.  
  779.         true_MasterProcessPreRender = (_MasterProcessPreRender) splice((unsigned char*) addr, new_MasterProcessPreRender);
  780.  
  781.         if ((addr = GetProcAddress(hEngine, "?DrawTextTTFToCanvas@UCanvas@@QAEHHHPB_WPBVFontDrawInfo@@EHHPBV?$TArray@PAVFontDrawInfoSection@@@@@Z")) == 0)
  782.                 return false;
  783.  
  784.         true_DrawTextTTFToCanvas = (_DrawTextTTFToCanvas) addr;
  785.  
  786.         if ((addr = GetProcAddress(hEngine, "?Render@FPlayerSceneNode@@UAEXPAVFRenderInterface@@@Z")) == 0)
  787.                 return false;
  788.  
  789.         true_Render = (_Render) splice((unsigned char*) addr, new_Render);
  790.  
  791.         TitleReplaceHook();
  792.         return true;
  793. }
  794.  
  795. LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  796. {
  797.         return DefWindowProc(hWnd, uMsg, wParam, lParam);
  798. }
  799.  
  800. DWORD GetCurrentIP()
  801. {
  802.         WSADATA wsaData;
  803.         WSAStartup(MAKEWORD(1,1), &wsaData);
  804.  
  805.         char HostName[1024];
  806.         DWORD m_HostIP = 0;
  807.  
  808.         if(!gethostname(HostName, 1024))
  809.         {
  810.                 if(LPHOSTENT lphost = gethostbyname(HostName))
  811.                         m_HostIP = ((LPIN_ADDR)lphost->h_addr)->s_addr;
  812.         }
  813.         WSACleanup();
  814.         return m_HostIP;
  815. }
  816. bool LoadTrayIcon(HINSTANCE hInst, unsigned int ID)
  817. {
  818.         ghMutex = CreateMutexA(0, false, "Protected on "/*+GetCurrentIP()*/);
  819.         if (GetLastError() == ERROR_ALREADY_EXISTS)
  820.         {
  821.                 CloseHandle(ghMutex);
  822.                 return true;
  823.         }
  824.  
  825.         WNDCLASSEXA wcx;
  826.         NOTIFYICONDATAA niData;
  827.  
  828.         memset(&wcx, 0, sizeof(WNDCLASSEXA));
  829.  
  830.         wcx.cbSize = sizeof(wcx);
  831.         wcx.lpfnWndProc = WndProc;
  832.         wcx.hInstance = hInst;
  833.         wcx.lpszClassName = "tray_icon";
  834.         if ((RegisterClassExA(&wcx) == 0) && (GetLastError() != ERROR_CLASS_ALREADY_EXISTS))
  835.                 return false;
  836.  
  837.         if ((hWND = CreateWindowExA(0, "tray_icon", 0, 0, 0, 0, 0, 0, 0, 0, hInst, 0)) == 0)
  838.                 return false;
  839.  
  840.         memset(&niData, 0, sizeof(NOTIFYICONDATAA));
  841.  
  842.         niData.cbSize = sizeof(NOTIFYICONDATAA);
  843.         niData.uID = ID;
  844.         niData.uFlags = NIF_ICON | NIF_TIP;
  845.         niData.hWnd = hWND;
  846.         strcpy_s(niData.szTip, "Protected on "/*+GetCurrentIP()*/);
  847.         niData.hIcon = (HICON) LoadImageA(hInst, MAKEINTRESOURCEA(IDI_TRAYICON), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR);
  848.         if (!Shell_NotifyIconA(NIM_ADD, &niData))
  849.                 return false;
  850.  
  851.         return true;
  852. }
  853.  
  854. void FreeTrayIcon(unsigned int ID)
  855. {
  856.         NOTIFYICONDATAA niData;
  857.  
  858.         memset(&niData, 0, sizeof(NOTIFYICONDATAA));
  859.         niData.cbSize = sizeof(NOTIFYICONDATAA);
  860.         niData.hWnd = hWND;
  861.         niData.uID = ID;
  862.  
  863.         Shell_NotifyIconA(NIM_DELETE, &niData);
  864.  
  865.         CloseHandle(ghMutex);
  866. }
  867.  
  868. int DirectXSetupGetVersion(void)
  869. {
  870.         return 0;
  871. }
  872.  
  873. void InitConsole(void)
  874. {
  875.         AllocConsole();
  876.  
  877.         HANDLE handle_out = GetStdHandle(STD_OUTPUT_HANDLE);
  878.         int hCrt = _open_osfhandle((long)handle_out, 0);
  879.         FILE* hf_out = _fdopen(hCrt, "w");
  880.         setvbuf(hf_out, NULL, _IONBF, 1);
  881.         *stdout = *hf_out;
  882.  
  883.         HANDLE handle_in = GetStdHandle(STD_INPUT_HANDLE);
  884.         hCrt = _open_osfhandle((long)handle_in, 0);
  885.         FILE* hf_in = _fdopen(hCrt, "r");
  886.         setvbuf(hf_in, NULL, _IONBF, 128);
  887.         *stdin = *hf_in;
  888. }
  889.  
  890. BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  891. {
  892.         if (fdwReason == DLL_PROCESS_ATTACH)
  893.         {
  894.                 InitConsole(); //console
  895.                 printf("ttttt");
  896.                 HBITMAP hBmp = LoadBitmap(hinstDLL,MAKEINTRESOURCE(102)); //Load bitmap
  897.                 if(hBmp)
  898.                 {
  899.                         CSplash splash; //Init class
  900.                         splash.SetBitmap(hBmp); //Set image(BMP + alpha)
  901.                         splash.SetTransparentColor(RGB(255, 255, 255)); //Select color for mask
  902.                         splash.ShowSplash(); //Show splash window and image
  903.                         Sleep(2000); //Sleep for freeze window
  904.                         splash.CloseSplash(); //Close class handler
  905.                 }
  906.  
  907.                 DisableThreadLibraryCalls(hinstDLL);
  908.  
  909.                 LoadTrayIcon(hinstDLL, 1);
  910.  
  911.                 if (!DisableGameGuard())
  912.                 {
  913.                         ErrorExit("Game Guard is not allow this client!");
  914.                         Sleep(INFINITE);
  915.                 }
  916.  
  917.                 if (!SetHooks())
  918.                 {
  919.                         ErrorExit("Protection is not attached this client!");
  920.                         Sleep(INFINITE);
  921.                 }
  922.         }
  923.  
  924.         if (fdwReason == DLL_PROCESS_DETACH)
  925.         {
  926.                 FreeTrayIcon(1);
  927.         }
  928.        
  929.         return true;
  930. }
Raw Paste

Login or Register to edit or fork this paste. It's free.