Máy sắp hết date, lưu lại chương trình này phòng sự cố.
Visual C++ Code:
  1. #include<Windows.h>
  2. #include<CommCtrl.h>
  3. #pragma comment (lib, "comctl32.lib")
  4.  
  5. /*
  6. Các bước tổng quát khi thêm một tác vụ thực hiện trên tiến trình khác :
  7.     1. Thêm 1 định danh ItemMenu ví dụ : IDM_FILE_COMMANDNAME
  8.     2. Trong WinMain chèn thêm ItemMenu : AppendMenu(hFilePopup, MF_STRING, IDM_FILE_COMMANDNAME, "&CommandName");
  9.     3. Thêm và viết mã cho 1 hàm luồng việc : DWORD WINAPI ThreadCommandName(PMYSTRUCT pRemote) {...}
  10.         Trong hàm này không được gọi các API trực tiếp mà phải qua con trỏ pRemote->
  11.     4. Nếu cần API nào đó mà chưa có trong các định nghĩa kiểu thì phải tạo kiểu mới :
  12.         typedef TYPE(WINAPI * PANYFUNCTION) (TYPE1, TYPE2, ...);
  13.     5. Nếu định nghĩa kiểu mới ở mục 4 thì
  14.         _ Trong cấu trúc MYSTRUCT thêm biến : PANYFUNCTION    fnAnyFunction;
  15.         _ Trong hàm WriteAllToProcess thêm khởi tạo :
  16.             pLocal->fnAnyFunction = (PANYFUNCTION)GetProcAddress(hModule, "AnyFunction");
  17.             Chú ý là AnyFunction có thể là AnyFunctionA nếu bên trong hModule là như vậy
  18.             nếu hModule là khác từ "user32.dll" thì phải dùng GetModuleHandle để lấy nó
  19.     6. Cũng trong WriteAllToProcess phải copy hàm mới :
  20.         CopyMemory((PBYTE)pLocal + REMOTEOBJECTSIZE * n, ThreadCommandName, REMOTEOBJECTSIZE);
  21.     7. Nếu trong hàm ThreadCommandName cần một giá trị trả về thì:
  22.         _ Thêm biến định nghĩa kiểu trả về trong cấu trúc MYSTRUCT : TYPE  typeReturn;
  23.         _ Dùng các lệnh để điền vào biến trả về : typeReturn = pRemote->fnAnyFunction(...);
  24.         _ Trong hàm tác vụ phải đọc lại bộ nhớ để lấy giá trị trả về tượng tự như hàm GetWndProcRemote
  25.     8. Nếu hàm ThreadCommandName không cần trị trả về thì tương tự như hàm CloseWindowRemote
  26. */
  27.  
  28. #define IDC_MYLISTVIEW          1001                                    // Định danh ListView
  29. #define IDM_FILE_ENUMWINDOW     40001                                   // Định danh MenuItem
  30. #define IDM_FILE_CLOSEWINDOW    40002                                   // Định danh MenuItem
  31. #define REMOTEOBJECTSIZE        100                                     // Chiều dài mặc định các đối tượng
  32. #define REMOTEOBJECTNUM         3                                       // Số đối tượng trong chương trình này là 3
  33. #define OBJECTTOTALSIZE         (REMOTEOBJECTNUM * REMOTEOBJECTSIZE)    // Kích thước tồng các đối tượng
  34.  
  35. typedef LONG(WINAPI * PGETWINDOWLONG) (HWND, int);                      // API: GetWindowLongA - user32.dll
  36. typedef LONG(WINAPI * PSETWINDOWLONG) (HWND, int, LONG);                // API: SetWindowLongA - user32.dll
  37. typedef BOOL(WINAPI * PPOSTMESSAGE) (HWND, UINT, WPARAM, LPARAM);       // API: PostMessageA - user32.dll
  38. typedef BOOL(WINAPI * PSENDMESSAGE) (HWND, UINT, WPARAM, LPARAM);       // API: SendMessageA - user32.dll
  39. typedef int(WINAPI * PMESSAGEBOX) (HWND, LPCTSTR, LPCTSTR, UINT);       // API: MessageBoxA - user32.dll
  40. typedef BOOL(WINAPI * PMESSAGEBEEP) (UINT);                             // API: MessageBeep - user32.dll
  41.  
  42. ///////////// Các đối tượng bên dưới sẽ được copy tới bộ nhớ của tiến trình khác ///////////////////
  43. typedef struct
  44. {
  45.     HWND            hVictim;                // Cửa sổ victim
  46.     WNDPROC         wpVictim;               // Thủ tục cửa sổ victim
  47.     PGETWINDOWLONG  fnGetWindowLong;        // GetWindowLong
  48.     PSETWINDOWLONG  fnSetWindowLong;        // SetWindowLong
  49.     PPOSTMESSAGE    fnPostMessage;          // PostMessage
  50.     PSENDMESSAGE    fnSendMessage;          // SendMessage
  51.     PMESSAGEBOX     fnMessageBox;           // MessageBox
  52.     PMESSAGEBEEP    fnMessageBeep;          // MessageBeep
  53. } MYSTRUCT, *PMYSTRUCT;
  54. DWORD WINAPI ThreadGetWndProc(PMYSTRUCT pRemote)
  55. {
  56.     pRemote->wpVictim = (WNDPROC)pRemote->fnGetWindowLong(pRemote->hVictim, GWLP_WNDPROC);
  57.     return 0;
  58. }
  59. DWORD WINAPI ThreadCloseWindow(PMYSTRUCT pRemote)
  60. {
  61.     pRemote->fnPostMessage(pRemote->hVictim, WM_CLOSE, 0, 0);
  62.     return 0;
  63. }
  64. ///////////// Chấm dứt các đối tượng được copy /////////////////////////////////////////////////////
  65.  
  66. PMYSTRUCT WriteAllToProcess(HANDLE hProcess, HWND hVictim)
  67. {
  68.     // Hình ảnh cấp phát và ghi dữ liệu bộ nhớ
  69.     // Offset 0000: Bắt đầu cấu trúc MYSTRUCT
  70.     // Offset 0100: Bắt đầu hàm ThreadGetWndProc
  71.     // Offset 0200: Bắt đầu hàm ThreadCloseWindow
  72.     // .....
  73.     HINSTANCE   hModule = GetModuleHandle("user32.dll");
  74.     PMYSTRUCT   pLocal = (PMYSTRUCT)malloc(OBJECTTOTALSIZE);
  75.     if (!pLocal)
  76.         return NULL;
  77.     pLocal->hVictim = hVictim;
  78.     pLocal->wpVictim = NULL;
  79.     pLocal->fnGetWindowLong = (PGETWINDOWLONG)GetProcAddress(hModule, "GetWindowLongA");
  80.     pLocal->fnSetWindowLong = (PSETWINDOWLONG)GetProcAddress(hModule, "SetWindowLongA");
  81.     pLocal->fnPostMessage = (PPOSTMESSAGE)GetProcAddress(hModule, "PostMessageA");
  82.     pLocal->fnSendMessage = (PSENDMESSAGE)GetProcAddress(hModule, "SendMessageA");
  83.     pLocal->fnMessageBox = (PMESSAGEBOX)GetProcAddress(hModule, "MessageBoxA");
  84.     pLocal->fnMessageBeep = (PMESSAGEBEEP)GetProcAddress(hModule, "MessageBeep");
  85.     CopyMemory((PBYTE)pLocal + REMOTEOBJECTSIZE, ThreadGetWndProc, REMOTEOBJECTSIZE);
  86.     CopyMemory((PBYTE)pLocal + REMOTEOBJECTSIZE * 2, ThreadCloseWindow, REMOTEOBJECTSIZE);
  87.     //
  88.     PMYSTRUCT       pRemote = (PMYSTRUCT)VirtualAllocEx(hProcess, 0, OBJECTTOTALSIZE, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
  89.     if (!pRemote)
  90.     {
  91.         free(pLocal);
  92.         return NULL;
  93.     }
  94.     // Copy
  95.     DWORD   dw;
  96.     if (!WriteProcessMemory(hProcess, pRemote, pLocal, OBJECTTOTALSIZE, &dw) || dw != OBJECTTOTALSIZE)
  97.     {
  98.         free(pLocal);
  99.         VirtualFreeEx(hProcess, pRemote, 0, MEM_RELEASE);
  100.         return NULL;
  101.     }
  102.     free(pLocal);
  103.     return pRemote;
  104. }
  105. BOOL ReadStructFromProcess(HANDLE hProcess, PMYSTRUCT pLocal, PMYSTRUCT pRemote)
  106. {
  107.     DWORD   dw;
  108.     BOOL    b = ReadProcessMemory(hProcess, pRemote, pLocal, sizeof(MYSTRUCT), &dw);
  109.     return (b && dw == sizeof(MYSTRUCT));
  110. }
  111. HANDLE GetProcessFromWindow(HWND hwnd)
  112. {
  113.     DWORD   dwProcessID;
  114.     GetWindowThreadProcessId(hwnd, &dwProcessID);
  115.     return OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessID);
  116. }
  117.  
  118. WNDPROC GetWndProcRemote(HWND hVictim)
  119. {
  120.     HANDLE  hProcess = GetProcessFromWindow(hVictim);
  121.     if (!hProcess)
  122.         return 0;
  123.     PMYSTRUCT   pRemote = WriteAllToProcess(hProcess, hVictim);
  124.     if (!pRemote)
  125.     {
  126.         CloseHandle(hProcess);
  127.         return 0;
  128.     }
  129.     // Chạy luồng việc để nhận wndproc
  130.     HANDLE  hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)((PBYTE)pRemote + REMOTEOBJECTSIZE), pRemote, 0, NULL);
  131.     if (!hThread)
  132.     {
  133.         VirtualFreeEx(hProcess, pRemote, 0, MEM_RELEASE);
  134.         CloseHandle(hProcess);
  135.         return 0;
  136.     }
  137.     WaitForSingleObject(hThread, INFINITE);
  138.     CloseHandle(hThread);
  139.  
  140.     MYSTRUCT    Local;
  141.     BOOL    b = ReadStructFromProcess(hProcess, &Local, pRemote);
  142.     VirtualFreeEx(hProcess, pRemote, 0, MEM_RELEASE);
  143.     CloseHandle(hProcess);
  144.     return (b ? Local.wpVictim : 0);
  145. }
  146. BOOL CloseWindowRemote(HWND hVictim)
  147. {
  148.     HANDLE  hProcess = GetProcessFromWindow(hVictim);
  149.     if (!hProcess)
  150.         return FALSE;
  151.     PMYSTRUCT   pRemote = WriteAllToProcess(hProcess, hVictim);
  152.     if (!pRemote)
  153.     {
  154.         CloseHandle(hProcess);
  155.         return FALSE;
  156.     }
  157.     // Chạy luồng việc để đóng cửa sổ
  158.     HANDLE  hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)((PBYTE)pRemote + REMOTEOBJECTSIZE * 2), pRemote, 0, NULL);
  159.     if (!hThread)
  160.     {
  161.         VirtualFreeEx(hProcess, pRemote, 0, MEM_RELEASE);
  162.         CloseHandle(hProcess);
  163.         return FALSE;
  164.     }
  165.     WaitForSingleObject(hThread, INFINITE);
  166.     VirtualFreeEx(hProcess, pRemote, 0, MEM_RELEASE);
  167.     CloseHandle(hProcess);
  168.     return TRUE;
  169. }
  170.  
  171. BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lparam)
  172. {
  173.     typedef BOOL(WINAPI * PISWOW64PROCESS) (HANDLE, PBOOL);
  174.     typedef VOID(WINAPI * PGETNATIVESYSTEMINFO) (LPSYSTEM_INFO);
  175.  
  176.     // Chỉ đếm cửa sổ hiển thị màn hình và có Caption - mục đích loại bỏ bớt các cửa sổ hệ thống
  177.     if (IsIconic(hwnd) || !IsWindowVisible(hwnd) || !(GetWindowLongPtr(hwnd, GWL_STYLE) & WS_CAPTION))
  178.         return TRUE;
  179.     DWORD   dwProcessID;
  180.     GetWindowThreadProcessId(hwnd, &dwProcessID);
  181.     HANDLE  hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessID);
  182.     BOOL    isWow64 = FALSE;
  183.     PISWOW64PROCESS fnIsWow64Process = (PISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"), "IsWow64Process");
  184.     if (fnIsWow64Process)
  185.         fnIsWow64Process(hProcess, &isWow64);
  186.     CloseHandle(hProcess);
  187.     BOOL    is64OS = FALSE;
  188.     PGETNATIVESYSTEMINFO fnGetNativeSystemInfo = (PGETNATIVESYSTEMINFO)GetProcAddress(GetModuleHandle("kernel32"), "GetNativeSystemInfo");
  189.     if (fnGetNativeSystemInfo)
  190.     {
  191.         SYSTEM_INFO stInfo = { 0 };
  192.         fnGetNativeSystemInfo(&stInfo);
  193.         if (stInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64 || stInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
  194.             is64OS = TRUE;
  195.     }
  196.     WNDPROC wp = 0;
  197.     if (isWow64 || !is64OS)             // Là cửa sổ trên tiến trình 32
  198.         wp = GetWndProcRemote(hwnd);
  199.  
  200.     CHAR    szText[MAX_PATH];
  201.     HWND    hList = (HWND)lparam;
  202.     LVITEM  lvi;
  203.  
  204.     lvi.mask = LVIF_TEXT;
  205.     lvi.pszText = szText;
  206.     lvi.iSubItem = 0;
  207.     wsprintf(szText, "%p", hwnd);
  208.     int     iIndex = ListView_InsertItem(hList, &lvi);      // HWND
  209.  
  210.     if (wp)
  211.     {
  212.         wsprintf(szText, "%p", wp);
  213.         ListView_SetItemText(hList, iIndex, 1, szText);     // WndProc
  214.     }
  215.  
  216.     GetWindowText(hwnd, szText, MAX_PATH - 1);
  217.     ListView_SetItemText(hList, iIndex, 2, szText);         // Caption
  218.  
  219.     lvi.mask = LVIF_PARAM;
  220.     lvi.iItem = iIndex;
  221.     lvi.iSubItem = 0;
  222.     lvi.lParam = (LPARAM)hwnd;
  223.     ListView_SetItem(hList, &lvi);                          // Lưu trữ thẻ cửa sổ
  224.  
  225.     return TRUE;
  226. }
  227. LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
  228. {
  229.     static  HWND    hList;
  230.  
  231.     switch (message)
  232.     {
  233.     case WM_CREATE: // Khởi tạo ListView
  234.     {
  235.         INITCOMMONCONTROLSEX    icx;
  236.         RECT                    r;
  237.         LVCOLUMN                lvc;
  238.  
  239.         icx.dwSize = sizeof(INITCOMMONCONTROLSEX);
  240.         icx.dwICC = ICC_LISTVIEW_CLASSES;
  241.         InitCommonControlsEx(&icx);
  242.         GetClientRect(hwnd, &r);
  243.         hList = CreateWindow(WC_LISTVIEW, NULL, WS_CHILD | WS_VISIBLE | LVS_REPORT, 10, 10, r.right - r.left - 20, r.bottom - r.top - 20, hwnd, (HMENU)IDC_MYLISTVIEW, ((LPCREATESTRUCT)lparam)->hInstance, NULL);
  244.         ListView_SetExtendedListViewStyle(hList, LVS_EX_FULLROWSELECT);
  245.         lvc.mask = LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  246.  
  247.         lvc.iSubItem = 0;
  248.         lvc.cx = 80;
  249.         lvc.pszText = "HWND";
  250.         ListView_InsertColumn(hList, 0, &lvc);
  251.  
  252.         lvc.iSubItem = 1;
  253.         lvc.cx = 80;
  254.         lvc.pszText = "WndProc";
  255.         ListView_InsertColumn(hList, 1, &lvc);
  256.  
  257.         lvc.iSubItem = 2;
  258.         lvc.cx = 200;
  259.         lvc.pszText = "Caption";
  260.         ListView_InsertColumn(hList, 2, &lvc);
  261.         return 0;
  262.     }
  263.     case WM_COMMAND:
  264.         switch (LOWORD(wparam))
  265.         {
  266.         case IDM_FILE_ENUMWINDOW:
  267.             ListView_DeleteAllItems(hList);
  268.             EnumWindows(EnumWindowsProc, (LPARAM)hList);
  269.             return 0;
  270.         case IDM_FILE_CLOSEWINDOW:
  271.         {
  272.             int     cItems = ListView_GetItemCount(hList);
  273.             LVITEM  lvi;
  274.             lvi.mask = LVIF_TEXT;
  275.             lvi.iSubItem = 0;
  276.             for (int i = cItems - 1; i >= 0; i--)
  277.             {
  278.                 if ((ListView_GetItemState(hList, i, LVIS_SELECTED)) == LVIS_SELECTED)  // Item này được chọn ?
  279.                 {
  280.                     CHAR    szText[MAX_PATH];
  281.                     ListView_GetItemText(hList, i, 1, szText, MAX_PATH);
  282.                     if (szText[0] == 0)
  283.                         continue;
  284.                     lvi.mask = LVIF_PARAM;
  285.                     lvi.iItem = i;
  286.                     lvi.iSubItem = 0;
  287.                     ListView_GetItem(hList, &lvi);
  288.                     HWND    hVictim = (HWND)lvi.lParam;
  289.                     // Cửa sổ vẫn còn hiển thị thì đóng nó và xóa chỉ mục Listview
  290.                     if (IsWindow(hVictim) && CloseWindowRemote(hVictim))
  291.                         ListView_DeleteItem(hList, i);
  292.                 }
  293.             }
  294.             return 0;
  295.         }
  296.         }
  297.         break;
  298.     case WM_DESTROY:
  299.         PostQuitMessage(0);
  300.         return 0;
  301.     }
  302.     return DefWindowProc(hwnd, message, wparam, lparam);
  303. }
  304. int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmd, int nShow)
  305. {
  306.     WNDCLASS        w;
  307.     HWND            hwnd;
  308.     MSG             msg;
  309.     RECT            r;
  310.     HMENU           hFilePopup = CreatePopupMenu();
  311.     HMENU           hMainMenu = CreateMenu();
  312.  
  313.     w.cbClsExtra = 0;
  314.     w.cbWndExtra = 0;
  315.     w.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH);
  316.     w.hCursor = LoadCursor(NULL, IDC_ARROW);
  317.     w.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  318.     w.hInstance = hInst;
  319.     w.lpfnWndProc = WndProc;
  320.     w.lpszClassName = "AttackProcess32";
  321.     w.lpszMenuName = 0;
  322.     w.style = CS_HREDRAW | CS_VREDRAW;
  323.     if (!RegisterClass(&w))
  324.         return 0;
  325.  
  326.     SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);    // Dùng r để canh chỉnh cửa sổ trên màn hình
  327.     hFilePopup = CreatePopupMenu();
  328.     hMainMenu = CreateMenu();
  329.     AppendMenu(hFilePopup, MF_STRING, IDM_FILE_ENUMWINDOW, "&EnumTopMostWindows");
  330.     AppendMenu(hFilePopup, MF_STRING, IDM_FILE_CLOSEWINDOW, "&CloseWindowRemote");
  331.     AppendMenu(hMainMenu, MF_POPUP | MF_STRING, (UINT_PTR)hFilePopup, "&Task");
  332.  
  333.     hwnd = CreateWindow(w.lpszClassName, w.lpszClassName, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU,
  334.         r.right - 400, 0, 400, r.bottom, NULL, hMainMenu, hInst, NULL);
  335.     if (!hwnd)
  336.         return 0;
  337.     ShowWindow(hwnd, nShow);
  338.     UpdateWindow(hwnd);
  339.     while (GetMessage(&msg, NULL, 0, 0))
  340.     {
  341.         TranslateMessage(&msg);
  342.         DispatchMessage(&msg);
  343.     }
  344.     return (int)msg.wParam;
  345. }