AntiEvilToolsDlg.cpp
上传用户:shouhua
上传日期:2014-12-06
资源大小:5685k
文件大小:12k
源码类别:

杀毒

开发平台:

Visual C++

  1. // AntiEvilToolsDlg.cpp : implementation file
  2. //
  3. #include "stdafx.h"
  4. #include "AntiEvilTools.h"
  5. #include "AntiEvilToolsDlg.h"
  6. #ifdef _DEBUG
  7. #define new DEBUG_NEW
  8. #undef THIS_FILE
  9. static char THIS_FILE[] = __FILE__;
  10. #endif
  11. /////////////////////////////////////////////////////////////////////////////
  12. // CAboutDlg dialog used for App About
  13. BOOL InstallDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName, IN LPCTSTR ServiceExe )
  14. {
  15.     SC_HANDLE  schService;
  16.     //
  17.     // NOTE: This creates an entry for a standalone driver. If this
  18.     //       is modified for use with a driver that requires a Tag,
  19.     //       Group, and/or Dependencies, it may be necessary to
  20.     //       query the registry for existing driver information
  21.     //       (in order to determine a unique Tag, etc.).
  22.     //
  23.     schService = CreateService( SchSCManager,          // SCManager database
  24.                                 DriverName,           // name of service
  25.                                 DriverName,           // name to display
  26.                                 SERVICE_ALL_ACCESS,    // desired access
  27.                                 SERVICE_KERNEL_DRIVER, // service type
  28.                                 SERVICE_BOOT_START ,  // start type
  29.                                 SERVICE_ERROR_NORMAL,  // error control type
  30.                                 ServiceExe,            // service's binary
  31.                                 NULL,                  // no load ordering group
  32.                                 NULL,                  // no tag identifier
  33.                                 NULL,                  // no dependencies
  34.                                 NULL,                  // LocalSystem account
  35.                                 NULL                   // no password
  36.                                 );
  37.     if ( schService == NULL )
  38.     {
  39.   return FALSE;
  40. }
  41.     CloseServiceHandle( schService );
  42.     return TRUE;
  43. }
  44. /****************************************************************************
  45. *
  46. *    FUNCTION: StartDriver( IN SC_HANDLE, IN LPCTSTR)
  47. *
  48. *    PURPOSE: Starts the driver service.
  49. *
  50. ****************************************************************************/
  51. BOOL StartDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
  52. {
  53.     SC_HANDLE  schService;
  54.     BOOL       ret;
  55.     schService = OpenService( SchSCManager,
  56.                               DriverName,
  57.                               SERVICE_ALL_ACCESS
  58.                               );
  59.     if ( schService == NULL )
  60.     {
  61.   return FALSE;
  62. }
  63.     ret = StartService( schService, 0, NULL )
  64.        || GetLastError() == ERROR_SERVICE_ALREADY_RUNNING 
  65.    || GetLastError() == ERROR_SERVICE_DISABLED;
  66. CloseServiceHandle( schService );
  67.     return ret;
  68. }
  69. /****************************************************************************
  70. *
  71. *    FUNCTION: StopDriver( IN SC_HANDLE, IN LPCTSTR)
  72. *
  73. *    PURPOSE: Has the configuration manager stop the driver (unload it)
  74. *
  75. ****************************************************************************/
  76. BOOL StopDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
  77. {
  78.     SC_HANDLE       schService;
  79.     BOOL            ret;
  80.     SERVICE_STATUS  serviceStatus;
  81.     schService = OpenService( SchSCManager, DriverName, SERVICE_ALL_ACCESS );
  82.     if ( schService == NULL )
  83.         return FALSE;
  84.     ret = ControlService( schService, SERVICE_CONTROL_STOP, &serviceStatus );
  85.     CloseServiceHandle( schService );
  86.     return ret;
  87. }
  88. /****************************************************************************
  89. *
  90. *    FUNCTION: RemoveDriver( IN SC_HANDLE, IN LPCTSTR)
  91. *
  92. *    PURPOSE: Deletes the driver service.
  93. *
  94. ****************************************************************************/
  95. BOOL RemoveDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
  96. {
  97.     SC_HANDLE  schService;
  98.     BOOL       ret;
  99.     schService = OpenService( SchSCManager,
  100.                               DriverName,
  101.                               SERVICE_ALL_ACCESS
  102.                               );
  103.     if ( schService == NULL )
  104.         return FALSE;
  105.     ret = DeleteService( schService );
  106.     CloseServiceHandle( schService );
  107.     return ret;
  108. }
  109. /****************************************************************************
  110. *
  111. *    FUNCTION: UnloadDeviceDriver( const TCHAR *)
  112. *
  113. *    PURPOSE: Stops the driver and has the configuration manager unload it.
  114. *
  115. ****************************************************************************/
  116. BOOL UnloadDeviceDriver( const TCHAR * Name )
  117. {
  118. SC_HANDLE schSCManager;
  119. schSCManager = OpenSCManager( NULL,                 // machine (NULL == local)
  120.                                NULL,                 // database (NULL == default)
  121. SC_MANAGER_ALL_ACCESS // access required
  122. );
  123. StopDriver( schSCManager, Name );
  124. RemoveDriver( schSCManager, Name );
  125.  
  126. CloseServiceHandle( schSCManager );
  127. return TRUE;
  128. }
  129. /****************************************************************************
  130. *
  131. *    FUNCTION: LoadDeviceDriver( const TCHAR, const TCHAR, HANDLE *)
  132. *
  133. *    PURPOSE: Registers a driver with the system configuration manager 
  134. *  and then loads it.
  135. *
  136. ****************************************************************************/
  137. BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path, PDWORD Error )
  138. {
  139. SC_HANDLE schSCManager;
  140. BOOL okay;
  141. schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
  142. if(schSCManager)
  143. {
  144. // Remove previous instance
  145. // RemoveDriver( schSCManager, Name );
  146. // Ignore success of installation: it may already be installed.
  147. InstallDriver( schSCManager, Name, Path );
  148. // Ignore success of start: it may already be started.
  149. okay = StartDriver( schSCManager, Name );
  150. *Error = GetLastError();
  151.    CloseServiceHandle( schSCManager );
  152. }
  153. return okay;
  154. }
  155. class CAboutDlg : public CDialog
  156. {
  157. public:
  158. CAboutDlg();
  159. // Dialog Data
  160. //{{AFX_DATA(CAboutDlg)
  161. enum { IDD = IDD_ABOUTBOX };
  162. //}}AFX_DATA
  163. // ClassWizard generated virtual function overrides
  164. //{{AFX_VIRTUAL(CAboutDlg)
  165. protected:
  166. virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
  167. //}}AFX_VIRTUAL
  168. // Implementation
  169. protected:
  170. //{{AFX_MSG(CAboutDlg)
  171. //}}AFX_MSG
  172. DECLARE_MESSAGE_MAP()
  173. };
  174. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
  175. {
  176. //{{AFX_DATA_INIT(CAboutDlg)
  177. //}}AFX_DATA_INIT
  178. }
  179. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  180. {
  181. CDialog::DoDataExchange(pDX);
  182. //{{AFX_DATA_MAP(CAboutDlg)
  183. //}}AFX_DATA_MAP
  184. }
  185. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
  186. //{{AFX_MSG_MAP(CAboutDlg)
  187. // No message handlers
  188. //}}AFX_MSG_MAP
  189. END_MESSAGE_MAP()
  190. /////////////////////////////////////////////////////////////////////////////
  191. // CAntiEvilToolsDlg dialog
  192. CAntiEvilToolsDlg::CAntiEvilToolsDlg(CWnd* pParent /*=NULL*/)
  193. : CDialog(CAntiEvilToolsDlg::IDD, pParent)
  194. {
  195. //{{AFX_DATA_INIT(CAntiEvilToolsDlg)
  196. // NOTE: the ClassWizard will add member initialization here
  197. //}}AFX_DATA_INIT
  198. // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
  199. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  200. }
  201. void CAntiEvilToolsDlg::DoDataExchange(CDataExchange* pDX)
  202. {
  203. CDialog::DoDataExchange(pDX);
  204. //{{AFX_DATA_MAP(CAntiEvilToolsDlg)
  205. // NOTE: the ClassWizard will add DDX and DDV calls here
  206. //}}AFX_DATA_MAP
  207. }
  208. BEGIN_MESSAGE_MAP(CAntiEvilToolsDlg, CDialog)
  209. //{{AFX_MSG_MAP(CAntiEvilToolsDlg)
  210. ON_WM_SYSCOMMAND()
  211. ON_WM_PAINT()
  212. ON_WM_QUERYDRAGICON()
  213. //}}AFX_MSG_MAP
  214. END_MESSAGE_MAP()
  215. /////////////////////////////////////////////////////////////////////////////
  216. // CAntiEvilToolsDlg message handlers
  217. BOOL CAntiEvilToolsDlg::OnInitDialog()
  218. {
  219. CDialog::OnInitDialog();
  220.     ULONG   bytesReturned;
  221. // Add "About..." menu item to system menu.
  222. // IDM_ABOUTBOX must be in the system command range.
  223. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  224. ASSERT(IDM_ABOUTBOX < 0xF000);
  225. CMenu* pSysMenu = GetSystemMenu(FALSE);
  226. if (pSysMenu != NULL)
  227. {
  228. CString strAboutMenu;
  229. strAboutMenu.LoadString(IDS_ABOUTBOX);
  230. if (!strAboutMenu.IsEmpty())
  231. {
  232. pSysMenu->AppendMenu(MF_SEPARATOR);
  233. pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
  234. }
  235. }
  236. // Set the icon for this dialog.  The framework does this automatically
  237. //  when the application's main window is not a dialog
  238. SetIcon(m_hIcon, TRUE); // Set big icon
  239. SetIcon(m_hIcon, FALSE); // Set small icon
  240. CString str;
  241. srand(GetTickCount());
  242. DWORD a=rand();
  243. DWORD b=rand();
  244. str.Format("%04x%04x",a,b);
  245. SetWindowText(str);
  246. m_sheet.AddPage(&m_MenuPage);
  247. m_sheet.AddPage(&m_ShaDuPage);
  248. m_sheet.AddPage(&m_ProcessPage);
  249. m_sheet.AddPage(&m_FilePage);
  250. m_sheet.AddPage(&m_ServicePage);
  251. m_sheet.AddPage(&m_ModulePage);
  252. m_sheet.AddPage(&m_NetPage);
  253. m_sheet.AddPage(&m_ProcessViewPage);
  254. m_sheet.Create(this, WS_CHILD | WS_VISIBLE, WS_EX_CONTROLPARENT);
  255. m_sheet.SetWindowPos(NULL,0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
  256. /*hDevice = CreateFile( "\\.\AntiEvilTools",
  257.                           GENERIC_READ | GENERIC_WRITE,
  258.                           0,
  259.                           NULL,
  260.                           OPEN_EXISTING,
  261.                           FILE_ATTRIBUTE_NORMAL,
  262.                           NULL
  263.                           );*/
  264. LoadDriver();
  265. m_FilePage.SetHandle(hDevice);
  266. m_ProcessPage.SetHandle(hDevice);
  267. m_ShaDuPage.SetHandle(hDevice);
  268. // TODO: Add extra initialization here
  269. DeviceIoControl(hDevice,(DWORD)IOCTL_MT_PROTECTME,NULL,0,NULL,0,&bytesReturned,NULL);
  270. return TRUE;  // return TRUE  unless you set the focus to a control
  271. }
  272. void CAntiEvilToolsDlg::OnSysCommand(UINT nID, LPARAM lParam)
  273. {
  274. if ((nID & 0xFFF0) == IDM_ABOUTBOX)
  275. {
  276. CAboutDlg dlgAbout;
  277. dlgAbout.DoModal();
  278. }
  279. else
  280. {
  281. CDialog::OnSysCommand(nID, lParam);
  282. }
  283. }
  284. // If you add a minimize button to your dialog, you will need the code below
  285. //  to draw the icon.  For MFC applications using the document/view model,
  286. //  this is automatically done for you by the framework.
  287. void CAntiEvilToolsDlg::OnPaint() 
  288. {
  289. if (IsIconic())
  290. {
  291. CPaintDC dc(this); // device context for painting
  292. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  293. // Center icon in client rectangle
  294. int cxIcon = GetSystemMetrics(SM_CXICON);
  295. int cyIcon = GetSystemMetrics(SM_CYICON);
  296. CRect rect;
  297. GetClientRect(&rect);
  298. int x = (rect.Width() - cxIcon + 1) / 2;
  299. int y = (rect.Height() - cyIcon + 1) / 2;
  300. // Draw the icon
  301. dc.DrawIcon(x, y, m_hIcon);
  302. }
  303. else
  304. {
  305. CDialog::OnPaint();
  306. }
  307. }
  308. // The system calls this to obtain the cursor to display while the user drags
  309. //  the minimized window.
  310. HCURSOR CAntiEvilToolsDlg::OnQueryDragIcon()
  311. {
  312. return (HCURSOR) m_hIcon;
  313. }
  314. LRESULT CAntiEvilToolsDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  315. {
  316. // TODO: Add your specialized code here and/or call the base class
  317. switch ( message )
  318. case WM_CLOSE:
  319. {
  320. if(AfxMessageBox("确定退出吗?",MB_OK|MB_OKCANCEL,0)!=IDOK)
  321. return 0;
  322. else
  323. {
  324. ULONG    bytesReturned;
  325. DeviceIoControl(hDevice,(DWORD)IOCTL_MT_UNPROTECTME,NULL,0,NULL,0,&bytesReturned,NULL);
  326.     CloseHandle(hDevice);
  327. //UnloadDeviceDriver("AntiEvilTools");
  328. }
  329. }
  330. return CDialog::WindowProc(message, wParam, lParam);
  331. }
  332. void CAntiEvilToolsDlg::LoadDriver()
  333. {
  334.     DWORD dwError;
  335. TCHAR Path[MAX_PATH];
  336.     DWORD dwRet;
  337.     dwRet = GetCurrentDirectory(MAX_PATH, Path);
  338. wsprintf(Path+lstrlen(Path), _T("\%s"), _T("AntiEvilTools.sys") );
  339.     if(!LoadDeviceDriver( "AntiEvilTools",Path, &dwError) )
  340. {
  341. MessageBox("加载内核失败");
  342. }
  343. hDevice = CreateFile( "\\.\AntiEvilTools",
  344.                           GENERIC_READ | GENERIC_WRITE,
  345.                           0,
  346.                           NULL,
  347.                           OPEN_EXISTING,
  348.                           FILE_ATTRIBUTE_NORMAL,
  349.                           NULL
  350.                           );
  351.     if ( hDevice == ((HANDLE)-1) )
  352.     {
  353.   return ;
  354. }
  355. }