[原创][开源]简易安全卫士的实现

搬砖王

技术分享 1月前 1 浏览

[原创][开源]简易安全卫士的实现

        前段时间在学习核心编程，同时也利用所学知识做了个安全卫士的项目，现在拿出来跟大家分享一下，非常适合新手学习！
        这也算是我在15PB阶段性学习的一个小总结，在此提别感谢学习中帮助过我的老师们！
        下面进入正题：
        开发环境：Visual Studio 2013、Win7 x64、MFC
        项目周期：6天
【功能模块目录】：
        1.病毒查杀：MD5查杀、白名单查杀、单个文件和全路径查杀，可使用本地病毒库或网络病毒库(网络病毒库自己搭建服务器通信)。
        2.垃圾清理：系统垃圾、浏览器垃圾、注册表的清理。
        3.电脑加速：简单的内存优化，释放内存。
        4.软件管理：显示本机上所安装的软件，并可以进行卸载操作。
        5.启动项管理：显示本机的启动项，并可以进行删除和添加操作。
        6.服务管理：显示本机的所有服务，列举服务状态、启动类型、服务类型等信息，可进行启动和停止服务操作。
        附几张图项目效果图预览一下：





        本项目用的是MFC框架开发，按钮基本都是用的自绘，图片素材是我从一个外国的资源网站下载来然后自己PS的颜色。
        自我感觉界面还不错，总比原生的MFC界面强吧哈哈！
项目框架：
        【首页信息】是主窗口，其他各个模块都是主窗口的子窗口，各个模块的功能都是独立的，每个子窗口都已自己的类。需要的时候，各个模块会启用多线程处理。模块之间的切换，其实就是现实当前选择的功能模块窗口，隐藏其他的子窗口。
        每个模块可以分开来单独看，模块之间的联系不大。
1.【病毒查杀】模块
        首先要做的就是确定用户扫描的选项，比如，是单个文件查杀还是全路径查杀，是用本地病毒库还是用云端病毒库，这些信息我都会设置一个BOOL值，在开始扫描之前将他们赋值，然后在扫描的时候只需判断这些选项的BOOL值来做出不同的扫描方案。
        接下来就是按照选项进行扫描了，当进行单个文件扫描的时候，只需弹出一个选择单个文件的CFileDialog保存其路径即可；如果是全路径扫描，则需要保存用户所选要扫描的路径并保存。
        然后就是开始扫描文件了，我觉得管它叫遍历文件更准确，如果是单个文件扫描的话，文件路径之前已经保存，就不需要遍历，直接通过绝对地址对文件进行病毒判断就行；如果是全路径扫描，就需要遍历指定文件加下的所有文件了。具体的功能是通过两个API实现的：FindFirstFile( )和FindNextFile( )，首先调用FindFirstFile( )，获取遍历出来的第一个文件的路径，然后再循环执行FindNextFile( )寻找下一个文件，直到FindNextFile( )返回FALSE就跳出循环，遍历结束。需要注意的是，当遍历到的路径是文件夹的时候，需要将这个文件夹的路径当做参数传入本函数，也就是递归执行此函数，这样就不会遗漏一个路径下所有的文件了。
        还有一点就是，在执行扫描部分的代码的时候，最好另起一个线程，这样就不至于在扫描的时候主界面会卡在那不动。
        具体的代码实现如下：

void Scam_All(LPCTSTR szPath)

{

  WIN32_FIND_DATA wfd;

  HANDLE hFind;

  CString sFullPath;

  CString sFindFilter;

  DWORD dwAttributes = 0;

  sFindFilter = szPath;

  sFindFilter += TEXT("\\*.*");

  if ((hFind = FindFirstFile(sFindFilter, &wfd)) == INVALID_HANDLE_VALUE)

    return;

  do

  {

    if (_tcscmp(wfd.cFileName, TEXT(".")) == 0 ||

      _tcscmp(wfd.cFileName, TEXT("..")) == 0)

    {

      continue;

    }

    //获取完整路径名

    sFullPath = szPath;

    sFullPath += TEXT("\\");

    sFullPath += wfd.cFileName;

    //如果当前路径是文件夹，则需要递归文件夹中的文件

    if (wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)

    {

      Scam_All(sFullPath);

    }

    //否则，这是一个文件

    else

    {

      //输出正在搜索的文件路径界面，让用户直观的看到正在扫描的文件路径

      m_szStatus = _T("正在扫描 : ")+sFullPath;

      SendMessage(WM_MYUPDATEDATA, FALSE);

      //判断是否是病毒

      if (IsMD5)    

      {

        //MD5查杀

        //如果是病毒 将文件信息保存到病毒Vector

        if (MD5Scan(sFullPath))

        {

          //插入List中显示

          m_List_Vir.InsertItem(0, wfd.cFileName);  //文件名

          m_List_Vir.SetItemText(0, 1, sFullPath);  //文件路径

          m_List_Vir.SetItemText(0, 2,        //文件大小

             GetShowSize(wfd.nFileSizeLow)); 

          //保存病毒信息到Vector容器

          VIRINFO VirInfo;

          _tcscpy_s(VirInfo.szVirName, wfd.cFileName);

          _tcscpy_s(VirInfo.szVirPath, sFullPath);

          _tcscpy_s(VirInfo.szVirSize, GetShowSize(wfd.nFileSizeLow));

          m_vecVirInfo.push_back(VirInfo);

        }

      }

      else 

      {

        //白名单查杀

        //如果是病毒 将文件信息保存到病毒Vector

        if (WhiteScan(sFullPath))

        {

          //插入List中显示

          m_List_Vir.InsertItem(0, wfd.cFileName);  //文件名

          m_List_Vir.SetItemText(0, 1, sFullPath);  //文件路径

          m_List_Vir.SetItemText(0, 2,        //文件大小

            GetShowSize(wfd.nFileSizeLow));

          //保存病毒信息到Vector容器

          VIRINFO VirInfo;

          _tcscpy_s(VirInfo.szVirName, wfd.cFileName);

          _tcscpy_s(VirInfo.szVirPath, sFullPath);

          _tcscpy_s(VirInfo.szVirSize, GetShowSize(wfd.nFileSizeLow));

          m_vecVirInfo.push_back(VirInfo);

        }

      }

    }

  } while (FindNextFile(hFind, &wfd));

  FindClose(hFind);

}

在遍历文件的时候，当获取到文件的完整路径的时候，就可以对其进行病毒检测了。我这里仅仅是象征性的使用了两种检测方式，MD5对比查杀和白名单查杀（当然，真正的病毒查杀肯定不会这么简单），将要杀的文件路径当做参数传递给检测病毒的函数，MD5扫描函数是：MD5Scan(sFullPath)，白名单扫描函数是：WhiteScan(sFullPath)，如果判断是病毒的话返回TRUE，这时就可以保存这个路径，并将这个“病毒文件”信息输出到List控件中。
这两个函数的代码如下：

BOOL MD5Scan(LPCTSTR szPath)

{

  //LPCTSTR 转CHAR*

  int num = WideCharToMultiByte(CP_OEMCP, NULL, szPath, -1, NULL, 0, NULL, FALSE);

  char *pchar = new char[num];

  WideCharToMultiByte(CP_OEMCP, NULL, szPath, -1, pchar, num, NULL, FALSE);

  //获取MD5值

  char* md5 = md5FileValue(pchar);

  //CHAR* 转LPCTSTR

  num = MultiByteToWideChar(0, 0, md5, -1, NULL, 0);

  wchar_t *wide = new wchar_t[num];

  MultiByteToWideChar(0, 0, md5, -1, wide, num);

  m_szMD5 = wide;

  delete[]pchar;

  delete[]wide;

  

  //获取文件MD5信息完毕

  //判断是本地查杀还是云端查杀

  if (IsLocal)

  {

    //本地MD5查杀    与m_LocalMD5作对比

    for (DWORD i = 0; i < m_LocalMD5.size();i++)

    {

      if (m_LocalMD5[i] == m_szMD5)

      {

        //是病毒 返回真

        return TRUE;

      }

    }

  }

  else

  {  

    //云端MD5查杀    与m_ServerMD5作对比

    //本地MD5查杀    与m_LocalMD5作对比

    for (DWORD i = 0; i < m_ServerMD5.size(); i++)

    {

      if (m_ServerMD5[i] == m_szMD5)

      {

        //是病毒 返回真

        return TRUE;

      }

    }

  }

  return FALSE;

}

BOOL WhiteScan(LPCTSTR szPath)

{

  //判断是本地查杀还是云端查杀

  if (IsLocal)

  {

    //本地白名单查杀    与m_LocalWhite作对比

    for (DWORD i = 0; i < m_LocalWhite.size(); i++)

    {

      if (m_LocalWhite[i] == szPath)

      {

        //是病毒 返回真

        return FALSE;

      }

    }

  }

  else

  {

    //云端MD5查杀    与m_ServerWhite作对比

    for (DWORD i = 0; i < m_ServerWhite.size(); i++)

    {

      if (m_ServerWhite[i] == szPath)

      {

        //是病毒 返回真

        return FALSE;

      }

    }

  }

  return TRUE;

}

        MD5查杀对比的时候，需要获取一下这个文件的MD5值，这里用到了一个MD5类的函数，这个类我用的是网上开源的代码（源码中包含）。
        MD5数据库和白名单查杀数据库，是在扫描开始前根据用户选项，然后从本地或云端将数据库信息载入内存的，本地数据库我用的是ini配置文件（象征性表示一下），云端查杀数据库是通过TCP通信下载的云端数据库信息。TCP服务端的代码在源码中有，但由于服务端还需要连接一个MySQL数据库，这样测试起来比较麻烦，所以建议只测试本地查杀功能，反正这个病毒查杀只是个象征性的对比，仅仅用于展现杀毒模块的功能、给大家提供个这个框架而已。
        判断该文件为病毒以后，将该文件的信息保存在一个vector容器成员变量中(m_vecVirInfo)，在删除的时候，遍历这个vector，然后依次删除即可。
        删除病毒代码：

void DeleteVir()

{

  //先判断病毒Vector是否为空，若为空，则提示没有可以清除的文件

  if (m_vecVirInfo.size() == 0)

  {

    return;

  }

  //删除病毒

  for (DWORD i = 0; i < m_vecVirInfo.size();i++)

  {

    DeleteFile(m_vecVirInfo[i].szVirPath);    

  }

  m_vecVirInfo.clear();

  m_List_Vir.DeleteAllItems();

  m_szStatus = _T("病 毒 清 除 完 毕 !");

  UpdateData(FALSE);

}

        注：本地病毒库位置为exe文件所在目录下：   .\LocalVirBase\Vir.ini
2.【清理垃圾】模块
        清理方式主要有两种，一种是删除磁盘上的文件，另一种是删除注册表项。像清理系统临时垃圾、清理浏览器垃圾这样的功能，是通过第一种清理方式实现的；而像清理最近文档记录、文件查找记录则是通过第二种清理方式实现的。
        第一种清理方式的具体操作：
        以清理Interner临时文件为例，首先需要获取Interner临时文件的路径，由于每台电脑这个路径或许会有所不同，所以不能写死，这时候利用一个Windows API可以轻松的获取到你想要获取的各种系统路径：

BOOL SHGetSpecialFolderPath(

        HWND   hwndOwner,

  _Out_ LPTSTR lpszPath,

  _In_  int    csidl,

  _In_  BOOL   fCreate

);

        第一个参数传NULL，最后一个参数传FALSE。
        第二个参数是保存路径的缓冲区。
        第三个参数是一个宏，传入不同的宏可以获取不同的路径，例如传入 CSIDL_INTERNET_CACHE ，获取的就是Interner临时文件的路径。
        这些宏在MSDN上有给出，数量很多，基本可以获取到你想要获取的所有系统路径。
        SHGetSpecialFolderPath 介绍：
        https://msdn.microsoft.com/en-us/library/windows/desktop/bb762204(v=vs.85).aspx
        第三个参数宏：
        https://msdn.microsoft.com/en-us/library/windows/desktop/bb762494(v=vs.85).aspx
        获取完需要清理的路径以后就需要扫描或清理此路径下的文件了，扫描和清理功能我用的是同一个函数，区别就是定义了一个BOOL值 IsScanFile ，如果为TRUE，就只是扫描垃圾文件，并将垃圾文件显示出来，然后计算总的垃圾文件大小；如果IsScan为FALSE，在扫描的同时就会进行删除。
        这个扫描垃圾文件的函数同【病毒查杀】模块中的扫描函数类似，都是传入一个路径参数，然后遍历该路径下的所有文件，原理大同小异，唯一不同的就是对文件的处理而已，所以这里扫描和清理垃圾文件的代码我就不贴出来了，具体的也可以在源码中找到。
        第二种清理方式的具体操作：
        以清理运行记录为例，删除注册表键值之前，同样需要获取要删除注册表键值的路径。我没有找到获取某些指定注册表项路径的API，所以我就用了最笨的办法，手动写死要删除的注册表路径。保存运行记录的注册表位置为："Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU"，删除该注册表的API为：SHDeleteKey( )，代码实现如下：

VOID CleanRunHistory()

{

  if (IsScanFile)  

    return;  //如果是正在扫描垃圾文件，则直接返回，不进行清理操作。

  SHDeleteKey(HKEY_CURRENT_USER, 

    TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU"));

}

        要想丰富项目的清理功能，很多时候就需要自己搜集垃圾文件的路径或注册表键值，拓展一下可以是清理某些指定软件的垃圾文件，搜集这些信息都是体力活。我这个项目只是清理了部分系统的垃圾，清理其他软件的垃圾原理类似。
3.【电脑加速】模块
        上面两大模块功能已经讲完了，剩下的几个模块就简单了许多。
        电脑加速模块的功能类似于很多优化软件的内存优化，所谓的优化其实就是腾出更多的可用内存空间。
        用到的两个函数：

BOOL WINAPI SetProcessWorkingSetSize(

  _In_ HANDLE hProcess,

  _In_ SIZE_T dwMinimumWorkingSetSize,

  _In_ SIZE_T dwMaximumWorkingSetSize

);

BOOL WINAPI EmptyWorkingSet( _In_ HANDLE hProcess);

        关于SetProcessWorkingSetSize，如果第二个参数和第三个参数都传“-1”的话，MSDN上的解释如下：
        If both dwMinimumWorkingSetSize and dwMaximumWorkingSetSize have the value (SIZE_T)–1, the function removes as many pages as possible from the working set of the specified process.
        直译为尽可能多的将指定进程的页面从工作区中移除，我的理解就是将进程的页面置换到虚拟内存（磁盘）中，这样就可以腾出更多的内存空间了。
        另外一个函数EmptyWorkingSet，这是个宏，MSDN的解释也是Removes as many pages as possible from the working set of the specified process.所以这两个函数的功能貌似是一样的，不知道这两个函数的效果是否会叠加，反正对于一个进程，我都会调用一下这两个函数。、

        调用上面两个函数需要传入进程句柄，也就是说同时只能优化一个进程的内存空间，那么我们就还需要遍历整个系统的所有进程，然后获取每个进程的句柄，将该句柄当做参数传入上面两个函数，就会达到优化所有进程内存空间的效果。
        遍历进程并进行优化的代码如下：

void ClearMemory()

{

  HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

  if (hProcessSnap == INVALID_HANDLE_VALUE)

  {

    return;

  }

  

  PROCESSENTRY32 ProcessInfo;          

  ProcessInfo.dwSize = sizeof(ProcessInfo);  

  int count = 0;

  //获取系统中第一个进程的信息  

  BOOL Status = Process32First(hProcessSnap, &ProcessInfo);

  while (Status)

  {

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE,

      ProcessInfo.th32ProcessID);

    if (hProcess)

    {

      //设置进程工作区大小

      SetProcessWorkingSetSize(hProcess, -1, -1);

      //尽可能多的将指定进程的页面从工作区移除

      EmptyWorkingSet(hProcess);

      CloseHandle(hProcess);

    }

    //获取下一个进程的信息  

    Status = Process32Next(hProcessSnap, &ProcessInfo);

  }

}

执行完上面这个函数以后，为了直观的显示优化后所腾出的内存空间，可以通过一个获取当前内存信息的代码计算，在执行清理之前计算一下当前的内存使用量，在执行完清理之后再计算一下内存的使用量，两个计算结果相减就可以得出本次优化后所腾出的内存空间。获取当前内存使用量的代码如下：

  m_szStatus = _T("正在清理内存中... ...");

  UpdateData(FALSE);

  //获取清理前的内存信息

  MEMORYSTATUSEX memStatus = { sizeof(MEMORYSTATUSEX) };

  GlobalMemoryStatusEx(&memStatus);

  DOUBLE preUsedMem = (DOUBLE)(memStatus.ullTotalPhys - memStatus.ullAvailPhys) / 1024 / 1024;

  //开始清理内存

  ClearMemory();

  //获取清理后的内存信息

  GlobalMemoryStatusEx(&memStatus);

  DOUBLE afterUsedMem = (DOUBLE)(memStatus.ullTotalPhys - memStatus.ullAvailPhys) / 1024 / 1024;

  //输出清理信息

  m_szStatus.Format(_T("内存清理完毕！本次清理 : %.2f MB"), preUsedMem - afterUsedMem);

        我自己关于内存优化的看法：
        首先从一种暴力清理内存的方式展开说。上面的内存清理方式，所腾出的可用内存空间并不明显，于是我从网上找到了另一种暴力清理方式，原理就是用一个进程大量的申请内存空间，瞬间填满你的内存，这时候系统就会调用其本身的置换操作，将其他进程的内存空间置换到虚拟内存（磁盘）中，该进程再突然释放所申请的大量空间，然后内存就会瞬间腾出很大的空间。我在我的4GB内存电脑上实测了这种内存清理方法，效果要好于我上面所说的清理方式，我所说的“效果好”其实是指的所腾出的可用内存空间大，虽然你看上去会有很大的空闲内存可用，但你会发现当你优化完，再去执行其他的程序时，会出现明显的卡顿，在卡顿的过程中，你的内存使用量又涨上去了。
         上面所说的卡顿现象，我觉得是进程又将自己原有的内存信息从磁盘中读入内存，这会给系统带来很大的开销，因为需要大量IO操作，而磁盘的读写速度与内存完全不是一个量级的，总之我觉得这种极端暴力的内存优化着实鸡肋。从这个极端地例子可以得出结论，并不是“清理”的内存越多系统就越快，反而清理过多了会拖慢系统的运行，因为在内存中的速度那么快，干嘛要把它置换到磁盘中呢？
        综上所述，所谓的内存优化其效果是仁者见仁智者见智，就我个人而言觉得这个功能并不实用，对于小内存的电脑来说优化其实是在拖慢系统，而对于大内存的电脑来说又没有什么必要。
       So，优化内存最有效的方式就是——插内存条。。。
4.【软件管理】模块
        获取安装软件的信息，其实就是枚举注册表项，查询注册表键值然后保存。
        定义一个保存软件信息的结构体（自己定义的）：

typedef struct _SOFTINFO

{

  TCHAR szSoftName[50];        //软件名称

  TCHAR szSoftVer[50];        //软件版本号

  TCHAR strSoftVenRel[50];      //软件发布厂商

  TCHAR szSoftData[20];        //软件安装日期

  TCHAR strSoftInsPath[MAX_PATH];    //软件安装路径

  TCHAR strSoftUniPath[MAX_PATH];    //软件卸载路径

}SOFTINFO, *PSOFTINFO;

32位和64位系统的查询位置也略有不同，可以自己定义两个宏，根据判断是否为64位进行选择。具体实现代码如下：

#define Win32PATH _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall")

#define Win64PATH _T("SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall")

void GetSoftwareInfo()

{

  m_Dlg5_List.DeleteAllItems();

  m_vecSoftInfo.clear();

  SOFTINFO stcSoftInfo = {0};  // 软件信息结构体

  HKEY RootKey;                // 主键

  LPCTSTR lpSubKey;            // 子键名称

  HKEY hkResult;               // 将要打开键的句柄 

  HKEY hkRKey;

  LONG lReturn;                // 记录读取注册表是否成功

  CString strBuffer;

  CString strMidReg;

  DWORD index = 0;

  TCHAR szKeyName[255] = { 0 };        // 注册表项名称

  DWORD dwKeyLen = 255;

  DWORD dwNameLen = 255;

  DWORD dwType = 0;

  RootKey = HKEY_LOCAL_MACHINE;

  lpSubKey = Is64() ? Win64PATH : Win32PATH;

  lReturn = RegOpenKeyEx(RootKey, lpSubKey, 0, 

    KEY_ALL_ACCESS, &hkResult);

  if (lReturn == ERROR_SUCCESS)

  {

    DWORD index = 0;

    DWORD ListIndex = 0;

    while (ERROR_NO_MORE_ITEMS != 

      RegEnumKeyEx(hkResult, index, szKeyName, &dwKeyLen, 

      0, NULL, NULL, NULL))

    {

      strBuffer.Format(_T("%s"), szKeyName);

      if (!strBuffer.IsEmpty())

      {

        strMidReg = (CString)lpSubKey + _T("\\") + strBuffer;

        if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, strMidReg, 

          0, KEY_ALL_ACCESS, &hkRKey) == ERROR_SUCCESS)

        {

          RegQueryValueEx(hkRKey, _T("DisplayName"), 

            0, &dwType, (LPBYTE)stcSoftInfo.szSoftName, &dwNameLen);

          dwNameLen = 255;

          RegQueryValueEx(hkRKey, _T("DisplayVersion"), 

            0, &dwType, (LPBYTE)stcSoftInfo.szSoftVer, &dwNameLen);

          dwNameLen = 255;

          RegQueryValueEx(hkRKey, _T("InstallLocation"), 

            0, &dwType, (LPBYTE)stcSoftInfo.strSoftInsPath, &dwNameLen);

          dwNameLen = 255;

          RegQueryValueEx(hkRKey, _T("Publisher"), 

            0, &dwType, (LPBYTE)stcSoftInfo.strSoftVenRel, &dwNameLen);

          dwNameLen = 255;

          RegQueryValueEx(hkRKey, _T("UninstallString"), 

            0, &dwType, (LPBYTE)stcSoftInfo.strSoftUniPath, &dwNameLen);

          dwNameLen = 255;

          RegQueryValueEx(hkRKey, _T("InstallDate"),

            0, &dwType, (LPBYTE)stcSoftInfo.szSoftData, &dwNameLen);

          if (stcSoftInfo.szSoftData[0])

          {

            stcSoftInfo.szSoftData[9] = stcSoftInfo.szSoftData[7];

            stcSoftInfo.szSoftData[8] = stcSoftInfo.szSoftData[6];

            stcSoftInfo.szSoftData[7] = '-';

            stcSoftInfo.szSoftData[6] = stcSoftInfo.szSoftData[5];

            stcSoftInfo.szSoftData[5] = stcSoftInfo.szSoftData[4];

            stcSoftInfo.szSoftData[4] = '-';

          }

          dwNameLen = 255;

          //保存数据

          if (stcSoftInfo.szSoftName[0]!='\0')

          {

            m_vecSoftInfo.push_back(stcSoftInfo);

            m_Dlg5_List.AddItem(ListIndex++, 4,

              stcSoftInfo.szSoftName,

              stcSoftInfo.strSoftVenRel,

              stcSoftInfo.szSoftData,

              stcSoftInfo.szSoftVer);

          }

          index++;

        }

        dwKeyLen = 255;

        memset(szKeyName, 0, 255);

        memset(&stcSoftInfo, 0, sizeof(SOFTINFO));

      }

    }

    RegCloseKey(hkResult);

  }

}

        卸载软件功能用到了上面软件信息结构体中的一个变量：TCHAR strSoftUniPath[MAX_PATH]。
        这个变量保存了软件的卸载指令。
        之前所遍历出来的软件信息是保存在一个vector容器m_vecSoftInfo中，删除软件时通过下标标识要卸载的软件，卸载代码如下：

ShellExecute(NULL, _T("open"),

    m_vecSoftInfo[m_Select].strSoftUniPath, NULL, NULL, SW_SHOWNORMAL);

5.【启动项】模块
        由于获取启动项信息也是通过遍历注册表实现的，代码类似于获取软件信息的函数，不同之处就在一要查询的注册表位置不同，所以在这里就不再贴出代码，具体实现在源码中也可以找到。
        我所获取的注册表信息有两处：
        "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"
        "SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Run"
        用到的启动项信息结构体（自己定义的）：

typedef struct _BOOTINFO

{

  TCHAR szBootName[50];      //启动项

  TCHAR szBootOrder[255];      //命令

  TCHAR szHKEY[50];        //主键信息

  TCHAR szBootPos[255];      //删除时要用到的位置

  TCHAR szBootPos_All[255];    //List中要显示的

}BOOTINFO, *PBOOTINFO;

其中TCHAR szBootPos[255]是删除时要用到的变量，该变量保存了删除该注册表键值的路径
删除启动项的代码如下：

void DeleteBoot()

{

  HKEY RootKey=NULL;    //根键

  HKEY hKey;

  //确定要删除的根键

  strTemp = m_vecBootInfo[m_Select].szHKEY;

  if (strTemp == _T("HKEY_CURRENT_USER"))

  {

    RootKey = HKEY_CURRENT_USER;

  }

  if (strTemp == _T("HKEY_LOCAL_MACHINE"))

  {

    RootKey = HKEY_LOCAL_MACHINE;

  }

  if (RootKey==NULL)

  {

    return;

  }

  //确定要删除的Run子键路径

  LPCTSTR lpRun = m_vecBootInfo[m_Select].szBootPos;

  //打开启动项Key   

  long lRet = RegOpenKeyEx(RootKey, lpRun, 0, KEY_WRITE, &hKey);

  if (lRet == ERROR_SUCCESS)

  {

    //获取要删除启动项的名字

    strTemp = m_vecBootInfo[m_Select].szBootName;

    //删除此启动项 

    lRet = RegDeleteValue(hKey, strTemp);

    //关闭注册表   

    RegCloseKey(hKey);

    if (lRet != ERROR_SUCCESS)

    {

      AfxMessageBox(_T("删除启动项成功！"));

    }

    else{

      AfxMessageBox(_T("删除启动项成功！"));

      GetBootInfo();

    }

  }

}

添加启动项的操作需要用到RegSetValueEx这个API，代码实现如下：

void AddBoot()

{

  //打开文件代码

  TCHAR FilePathName[MAX_PATH] = {0};

  CString FileName;

  CFileDialog dlg(TRUE, //TRUE为OPEN对话框，FALSE为SAVE AS对话框

    NULL,

    NULL,

    OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,

    (LPCTSTR)_TEXT("All Files (*.*)|*.*||"),

    NULL);

  if (dlg.DoModal() == IDOK)

  {

    //文件名保存在了FilePathName里

    _tcscpy_s(FilePathName, dlg.GetPathName());

  }

  else

  {

    return;

  }

  //打开启动项Key

  HKEY hKey;

  LPCTSTR lpRun = _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");

  long lRet = RegOpenKeyEx( HKEY_CURRENT_USER, lpRun, 0, KEY_WRITE, &hKey);

  if (lRet == ERROR_SUCCESS)

  {

    //获取路径长度

    DWORD dwRet = _tcslen(FilePathName);

    //添加启动项信息

    FileName = dlg.GetFileTitle();

    int n = sizeof(TCHAR);

    lRet = RegSetValueEx(hKey, FileName, 0, REG_SZ,

      (BYTE *)FilePathName, dwRet*sizeof(TCHAR));

    //关闭注册表   

    RegCloseKey(hKey);

    if (lRet != ERROR_SUCCESS)

    {

      AfxMessageBox(_T("添加启动项失败!"));

    }

    else

    {

      AfxMessageBox(_T("添加启动项成功!"));

      GetBootInfo();

    }

  }

}

6.【系统服务】模块
最后再说一下遍历系统服务信息，此模块功能需要有管理员权限才能实现，要不然服务模块的信息遍历不出来(当然你也可以自己添加UAC提权代码)。
调用EnumServicesStatus这个API可以遍历服务信息，该函数会给你返回一个保存所有服务信息的缓冲区，你需要通过一个循环依次取出每一个服务的具体信息。了解了这个流程以后，看懂代码应该不算困难了：

void GetServiceInfo()

{

  //1.打开远程计算机服务控制管理器

  m_Dlg7_List.DeleteAllItems();

  m_vecSerInfo.clear();

  SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

  //2.第一次调用，获取需要的内存大小

  DWORD dwServiceNum = 0;

  DWORD dwSize = 0;

  EnumServicesStatus(

    hSCM,

    SERVICE_WIN32,

    SERVICE_STATE_ALL,  //所有服务状态

    NULL,        //缓冲区

    0,          //缓冲区大小

    &dwSize,      //需要的大小

    &dwServiceNum,    //缓冲区中的服务个数

    NULL);

  //3.申请需要的内存，第二次调用

  LPENUM_SERVICE_STATUS lpEnumService =

    (LPENUM_SERVICE_STATUS)LocalAlloc(LPTR, dwSize);

  //4.第二次枚举

  EnumServicesStatus(

    hSCM,

    SERVICE_WIN32,

    SERVICE_STATE_ALL,  //所有服务状态

    lpEnumService,    //缓冲区

    dwSize,        //缓冲区大小

    &dwSize,      //需要的大小

    &dwServiceNum,    //缓冲区中的服务个数

    NULL);

  //5.遍历信息

  SC_HANDLE hService = nullptr;

  for (DWORD i = 0; i < dwServiceNum; i++)

  {

    //获取基础信息

    //1.服务名称

    //2.服务描述

    //3.服务状态(根据得到的值手动输出字符串)

    //“已停止” “正在运行" "正在暂停"...

    m_vecSerInfo.push_back(lpEnumService[i]);

    //获取更多信息

    //1.打开服务

    hService = OpenService(hSCM,

      lpEnumService[i].lpServiceName, SERVICE_QUERY_CONFIG);

    // 2.第一次调用获取需要的缓冲区大小

    QueryServiceConfig(hService, NULL, 0, &dwSize);

    //分配内存

    LPQUERY_SERVICE_CONFIG pServiceConfig =

      (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR, dwSize);

    //3.第二次调用,获取信息

    QueryServiceConfig(hService, pServiceConfig, dwSize, &dwSize);

    //获取服务信息完毕，开始插入List

    m_Dlg7_List.AddItem(i, 5,

      m_vecSerInfo[i].lpServiceName,

      m_vecSerInfo[i].lpDisplayName,

      m_vecSerInfo[i].ServiceStatus.dwCurrentState,

      pServiceConfig->dwStartType,

      m_vecSerInfo[i].ServiceStatus.dwServiceType);

    LocalFree(pServiceConfig);

  }

  LocalFree(lpEnumService);

  CloseServiceHandle(hSCM);

  CloseServiceHandle(hService);

}

剩下的就是启动、停止服务的功能了，也是通过API实现的，实现起来比较容易：

  //启动服务

  SC_HANDLE hSCM = OpenSCManager(      //打开服务控制管理器

    NULL, NULL, SC_MANAGER_ALL_ACCESS);

  SC_HANDLE hService = OpenService(hSCM,  //打开服务

    m_ServiceName, SERVICE_START);

  StartService(hService, 0, 0);      //启动服务

  //停止服务

  SC_HANDLE hSCM = OpenSCManager(      //打开服务控制管理器

    NULL, NULL, SC_MANAGER_ALL_ACCESS);

  SC_HANDLE hService = OpenService(hSCM,  //打开服务

    m_ServiceName, SERVICE_STOP);

  SERVICE_STATUS status;

  ControlService(hService,        //结束服务

    SERVICE_CONTROL_STOP, 

    &status);

        至此，6个模块的功能就介绍完了！
结语：
        本项目基本都是通过调用ring3层的API实现的，通过MFC框架完成界面部分，已经完成了一个安全卫士的建议框架，部分功能还有具有一定实用性的，源码中也有一定的注释，很适合新手学习。大神轻喷啊。。。
        由于项目时间有限，网络监控模块没有写，只预留的按钮。哈哈有点偷懒了。。。
        第一次发帖，讲的有点乱，编程半年的小菜，代码风格也不是很好，大家将就看吧。
        好了，就到这吧，最后附上源码。
源码安全卫士源码@15PB.7z

上传的附件