行为1：setup.exe创建了spoclsv.exe这样一个程序
行为2：删除了c盘和admin用户文件夹的默认共享（不考虑）
行为3：删除了安全类软件的自启动项（用户自行重装杀毒软件，不考虑）
行为4：在run键下创建了一个svcshare的自启动项，每次开机时病毒自动运行
行为5：在注册表下修改hidden\showall和hidden\showall\checkvalue两个键达到在文件管理器中即使查看隐藏文件夹也无法显现病毒
行为6：将自身拷贝c盘根目录下命名为setup.exe，并且创建autorun.inf用于病毒的启动
行为7：在某些文件夹中创建Desktop_.ini这样的文件
行为8：向内网外网发送数据，并连接局域网中的其他电脑（删除病毒本体解决，不考虑）

新建mfc程序

CRC32()：计算病毒程序的散列值

  1. DWORD CRC32(BYTE* ptr,DWORD Size)
  2. {   
  3.     DWORD crcTable[256],crcTmp1;   
  4.     //动态生成CRC-32表
  5.     for (int i=0; i<256; i++)
  6.     {
  7.         crcTmp1 = i;
  8.         for (int j=8; j>0; j--)
  9.         {
  10.             if (crcTmp1&1) crcTmp1 = (crcTmp1 >> 1) ^ 0xEDB88320L;
  11.             else crcTmp1 >>= 1;
  12.         }
  14.         crcTable[i] = crcTmp1;
  15.     }
  16.     //计算CRC32值
  17.     DWORD crcTmp2= 0xFFFFFFFF;
  18.     while(Size--)
  19.     {
  20.         crcTmp2 = ((crcTmp2>>8) & 0x00FFFFFF) ^ crcTable[ (crcTmp2^(*ptr)) & 0xFF ];
  21.         ptr++;
  22.     }   
  23.     return (crcTmp2^0xFFFFFFFF);
  24. }

FindVirProcess()：查找病毒进程

  1. BOOL FindVirProcess(char *pszProcessName,DWORD *dwPid)
  2. {
  3.     BOOL bFind = FALSE;
  5.     HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  6.     if (hProcessSnap == INVALID_HANDLE_VALUE)
  7.     {
  8.         return bFind;
  9.     }
  11.     PROCESSENTRY32 pe = { 0 };
  12.     pe.dwSize = sizeof(pe);
  14.     BOOL bRet = Process32First(hProcessSnap,&pe);
  15.     while (bRet)
  16.     {
  17.         if (lstrcmp(pe.szExeFile,pszProcessName) == 0)
  18.         {
  19.             *dwPid = pe.th32ProcessID;
  20.             bFind = TRUE;
  21.             break;
  22.         }
  23.         bRet = Process32Next(hProcessSnap,&pe);
  24.     }
  26.     CloseHandle(hProcessSnap);
  28.     return bFind;
  29. }

EnableDebugerPrivilege提升权限

  1. BOOL EnableDebugPrivilege(char *pszPrivilege)
  2. {
  3.     HANDLE hToken = INVALID_HANDLE_VALUE;
  4.     LUID luid;
  5.     TOKEN_PRIVILEGES tp;
  7.     BOOL bRet = OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,&hToken);
  8.     if (bRet == FALSE)
  9.     {
  10.         return bRet;
  11.     }
  13.     bRet = LookupPrivilegeValue(NULL,pszPrivilege,&luid);
  14.     if (bRet == FALSE)
  15.     {
  16.         return bRet;
  17.     }
  19.     tp.PrivilegeCount = 1;
  20.     tp.Privileges[0].Luid = luid;
  21.     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  23.     bRet = AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL);
  25.     return bRet;
  26. }

FindFiles()：删除Desktop_.ini文件

  1. DWORD WINAPI FindFiles(LPVOID lpszPath)
  2. {
  3.         WIN32_FIND_DATA stFindFile;
  4.         HANDLE hFindFile;
  5.     // 扫描路径
  6.     char szPath[MAX_PATH];    
  7.     char szFindFile[MAX_PATH];
  8.     char szSearch[MAX_PATH];
  9.     char *szFilter;
  10.     int len;
  11.     int ret = 0;
  13.     szFilter = "*.*";
  14.     lstrcpy(szPath, (char *)lpszPath);
  16.     len = lstrlen(szPath);
  17.     if(szPath[len-1] != '\\')
  18.     {
  19.         szPath[len] = '\\';
  20.         szPath[len+1] = '\0';
  21.     }
  23.     lstrcpy(szSearch, szPath);
  24.     lstrcat(szSearch,szFilter);
  26.     hFindFile = FindFirstFile(szSearch, &stFindFile);
  27.     if(hFindFile != INVALID_HANDLE_VALUE)
  28.     {
  29.         do
  30.         {
  31.             lstrcpy(szFindFile, szPath);
  32.                     lstrcat(szFindFile, stFindFile.cFileName);
  34.             if(stFindFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  35.             {
  36.                 if(stFindFile.cFileName[0] != '.')
  37.                 {
  38.                     FindFiles(szFindFile);
  39.                 }
  40.             }
  41.             else
  42.             {
  43.                 if(!lstrcmp(stFindFile.cFileName,"Desktop_.ini"))
  44.                 {
  45.                                     // 去除文件的隐藏、系统以及只读属性
  46.                                     DWORD dwFileAttributes = GetFileAttributes(szFindFile);
  47.                                     dwFileAttributes &= ~FILE_ATTRIBUTE_HIDDEN;
  48.                                     dwFileAttributes &= ~FILE_ATTRIBUTE_SYSTEM;
  49.                                     dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
  50.                                     SetFileAttributes(szFindFile, dwFileAttributes);
  51.                                     // 删除Desktop_.ini
  52.                                     BOOL bRet = DeleteFile(szFindFile);    
  53.                                     csTxt += szFindFile;
  54.                                     if (bRet)
  55.                                     {
  56.                                         csTxt += _T("被删除！\r\n");
  57.                                     } 
  58.                                     else
  59.                                     {
  60.                                         csTxt += _T("无法删除\r\n");
  61.                                     }
  62.                 }
  63.             }
  64.             ret = FindNextFile(hFindFile, &stFindFile);
  65.         }while(ret != 0);
  66.     }
  68.     FindClose(hFindFile);
  70.     return 0;
  71. }

OnBtnKill()：主程序

  1. void CKillWhBoyDlg::OnBtnKill() 
  2. {
  3.     // TODO: Add your control notification handler code here
  4.     BOOL bRet = FALSE;
  5.     DWORD dwPid = 0; 
  6. ///
  7. //  结束spoclsv.exe进程，并删除病毒程序本身
  8. ///
  9.     bRet = FindTargetProcess("spoclsv.exe", &dwPid);
  10.     if (bRet == TRUE)
  11.     {
  12.         csTxt = _T("检查系统内存...\r\n");
  13.         csTxt += _T("系统中存在病毒进程:spoclsv.exe\r\n");
  14.         csTxt += _T("准备进行查杀...\r\n");
  15.         SetDlgItemText(IDC_LIST,csTxt);   
  16.         // 提升权限
  17.         bRet = EnableDebugPrivilege(SE_DEBUG_NAME);
  18.         if (bRet == FALSE)
  19.         {
  20.             csTxt += _T("提升权限失败\r\n");
  21.         }
  22.         else
  23.         {
  24.             csTxt += _T("提升权限成功！\r\n");
  25.         }
  26.         SetDlgItemText(IDC_LIST,csTxt);
  27.         // 打开并尝试结束病毒进程
  28.         HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwPid);
  29.         if (hProcess == INVALID_HANDLE_VALUE)
  30.         {
  31.             csTxt += _T("无法结束病毒进程\r\n");
  32.             return ;
  33.         }
  34.         bRet = TerminateProcess(hProcess,0);
  35.         if (bRet == FALSE)
  36.         {
  37.             csTxt += _T("无法结束病毒进程\r\n");
  38.             return ;
  39.         }
  40.         csTxt += _T("病毒进程已经结束\r\n");
  41.         SetDlgItemText(IDC_LIST,csTxt);
  42.         CloseHandle(hProcess);
  43.     }
  44.     else
  45.     {
  46.         csTxt += _T("系统中不存在spoclsv.exe病毒进程\r\n");
  47.     }
  49.     Sleep(10);
  50.     // 查杀磁盘中是否存在名为spoclsv.exe的病毒文件
  51.     char szSysPath[MAX_PATH] = { 0 };
  52.     GetSystemDirectory(szSysPath,MAX_PATH);
  54.     lstrcat(szSysPath,"\\drivers\\spoclsv.exe");
  56.     csTxt += _T("检查硬盘中是否存在spoclsv.exe文件...\r\n");
  58.     if (GetFileAttributes(szSysPath) == 0xFFFFFFFF)
  59.     {
  60.         csTxt += _T("spoclsv.exe病毒文件不存在\r\n");
  61.     }
  62.     else
  63.     {
  64.         csTxt += _T("spoclsv.exe病毒文件存在，正在计算散列值\r\n");
  66.         HANDLE hFile = CreateFile(szSysPath,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  67.         if (hFile == INVALID_HANDLE_VALUE)
  68.         {
  69.             AfxMessageBox("Create Error");
  70.             return ;
  71.         }
  72.         DWORD dwSize = GetFileSize(hFile,NULL);
  73.         if (dwSize == 0xFFFFFFFF)
  74.         {
  75.             AfxMessageBox("GetFileSize Error");
  76.             return ;
  77.         }
  78.         BYTE *pFile = (BYTE*)malloc(dwSize);
  79.         if (pFile == NULL)
  80.         {
  81.             AfxMessageBox("malloc Error");
  82.             return ;
  83.         }
  85.         DWORD dwNum = 0;
  86.         ReadFile(hFile,pFile,dwSize,&dwNum,NULL);
  87.         // 计算spoclsv.exe的散列值
  88.         DWORD dwCrc32 = CRC32(pFile,dwSize);
  90.         if (pFile != NULL)
  91.         {
  92.             free(pFile);
  93.             pFile = NULL;
  94.         }
  96.         CloseHandle(hFile);
  97.         // 0x89240FCD是“熊猫烧香”病毒的散列值
  98.         if (dwCrc32 != 0x89240FCD)
  99.         {
  100.             csTxt += _T("spoclsv.exe校验和验证失败\r\n");
  101.         }
  102.         else
  103.         {
  104.             csTxt += _T("spoclsv.exe校验和验证成功，正在删除...\r\n");
  105.             // 去除文件的隐藏、系统以及只读属性
  106.             DWORD dwFileAttributes = GetFileAttributes(szSysPath);
  107.             dwFileAttributes &= ~FILE_ATTRIBUTE_HIDDEN;
  108.             dwFileAttributes &= ~FILE_ATTRIBUTE_SYSTEM;
  109.             dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
  110.             SetFileAttributes(szSysPath, dwFileAttributes);
  111.             // 删除spoclsv.exe
  112.             bRet = DeleteFile(szSysPath);
  113.             if (bRet)
  114.             {
  115.                 csTxt += _T("spoclsv.exe病毒被删除！\r\n");
  116.             } 
  117.             else
  118.             {
  119.                 csTxt += _T("spoclsv.exe病毒无法删除\r\n");
  120.             }
  121.         }
  122.     }  
  123.     SetDlgItemText(IDC_LIST,csTxt);
  124.     Sleep(10);
  125. ///
  126. //  删除每个盘符下的setup.exe与autorun.inf，以及Desktop_.ini
  127. ///
  128.     char szDriverString[MAXBYTE] = { 0 };  
  129.     char *pTmp = NULL;  
  130.     //获取字符串类型的驱动器列表  
  131.     GetLogicalDriveStrings(MAXBYTE, szDriverString);  
  133.     pTmp = szDriverString;  
  135.     while( *pTmp )  
  136.     {  
  137.         char szAutorunPath[MAX_PATH] = { 0 };    
  138.         char szSetupPath[MAX_PATH] = { 0 };
  139.         lstrcat(szAutorunPath,pTmp);
  140.         lstrcat(szAutorunPath,"autorun.inf");
  141.         lstrcat(szSetupPath,pTmp);
  142.         lstrcat(szSetupPath,"setup.exe");
  144.         if (GetFileAttributes(szSetupPath) == 0xFFFFFFFF)
  145.         {
  146.             csTxt += pTmp;
  147.             csTxt += _T("setup.exe病毒文件不存在\r\n");
  148.         }
  149.         else
  150.         {
  151.             csTxt += pTmp;
  152.             csTxt += _T("setup.exe病毒文件存在，正在进行计算校验和...\r\n");
  153.             HANDLE hFile = CreateFile(szSetupPath,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  154.             if (hFile == INVALID_HANDLE_VALUE)
  155.             {
  156.                 AfxMessageBox("Create Error");
  157.                 return ;
  158.             }
  159.             DWORD dwSize = GetFileSize(hFile,NULL);
  160.             if (dwSize == 0xFFFFFFFF)
  161.             {
  162.                 AfxMessageBox("GetFileSize Error");
  163.                 return ;
  164.             }
  165.             BYTE *pFile = (BYTE*)malloc(dwSize);
  166.             if (pFile == NULL)
  167.             {
  168.                 AfxMessageBox("malloc Error");
  169.                 return ;
  170.             }         
  172.             DWORD dwNum = 0;
  173.             ReadFile(hFile,pFile,dwSize,&dwNum,NULL);
  175.             DWORD dwCrc32 = CRC32(pFile,dwSize);   
  176.             if (pFile != NULL)
  177.             {
  178.                 free(pFile);
  179.                 pFile = NULL;
  180.             }
  181.             CloseHandle(hFile);
  182.             if (dwCrc32 != 0x89240FCD)
  183.             {
  184.                 csTxt += _T("校验和验证失败\r\n");
  185.             }
  186.             else
  187.             {
  188.                 csTxt += _T("校验和验证成功，正在删除...\r\n"); 
  189.                 // 去除文件的隐藏、系统以及只读属性
  190.                 DWORD dwFileAttributes = GetFileAttributes(szSetupPath);
  191.                 dwFileAttributes &= ~FILE_ATTRIBUTE_HIDDEN;
  192.                 dwFileAttributes &= ~FILE_ATTRIBUTE_SYSTEM;
  193.                 dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
  194.                 SetFileAttributes(szSetupPath, dwFileAttributes);
  195.                 // 删除setup.exe
  196.                 bRet = DeleteFile(szSetupPath);    
  197.                 if (bRet)
  198.                 {
  199.                     csTxt += pTmp;
  200.                     csTxt += _T("setup.exe病毒被删除!\r\n");
  201.                 } 
  202.                 else
  203.                 {
  204.                     csTxt += pTmp;
  205.                     csTxt += _T("setup.exe病毒无法删除\r\n");
  206.                 }
  207.             }
  208.         }
  209.         // 去除文件的隐藏、系统以及只读属性
  210.         DWORD dwFileAttributes = GetFileAttributes(szAutorunPath);
  211.         dwFileAttributes &= ~FILE_ATTRIBUTE_HIDDEN;
  212.         dwFileAttributes &= ~FILE_ATTRIBUTE_SYSTEM;
  213.         dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
  214.         SetFileAttributes(szAutorunPath, dwFileAttributes);
  215.         // 删除autorun.inf
  216.         bRet = DeleteFile(szAutorunPath);    
  217.         csTxt += pTmp;
  218.         if (bRet)
  219.         {         
  220.             csTxt += _T("autorun.inf被删除!\r\n");
  221.         } 
  222.         else
  223.         {
  224.             csTxt += _T("autorun.inf不存在或无法删除\r\n");
  225.         }
  226.         // 删除Desktop_.ini
  227.         FindFiles(pTmp);
  228.         // 检查下一个盘符
  229.         pTmp += 4;  
  230.     }  
  231.     Sleep(10);
  232. ///
  233. //  修复注册表内容，删除病毒启动项并修复文件的隐藏显示
  234. ///
  235.     csTxt += _T("正在检查注册表...\r\n");
  236.     SetDlgItemText(IDC_LIST,csTxt);
  237.     // 首先检查启动项
  238.     char RegRun[] = "Software\\Microsoft\\Windows\\CurrentVersion\\Run";   
  239.     HKEY hKeyHKCU = NULL;    
  240.     LONG lSize = MAXBYTE;
  241.     char cData[MAXBYTE] = { 0 };
  243.     long lRet = RegOpenKey(HKEY_CURRENT_USER, RegRun, &hKeyHKCU);
  244.     if(lRet == ERROR_SUCCESS)
  245.     {
  246.         lRet = RegQueryValueEx(hKeyHKCU,"svcshare",NULL,NULL,(unsigned char *)cData,(unsigned long *)&lSize);
  247.         if ( lRet == ERROR_SUCCESS)
  248.         {
  249.             if (lstrcmp(cData,"C:\\WINDOWS\\system32\\drivers\\spoclsv.exe") == 0)
  250.             {
  251.                 csTxt += _T("注册表启动项中存在病毒信息\r\n");
  252.             }
  254.             lRet = RegDeleteValue(hKeyHKCU,"svcshare");
  255.             if (lRet == ERROR_SUCCESS)
  256.             {
  257.                 csTxt += _T("注册表启动项中的病毒信息已删除！\r\n");
  258.             }
  259.             else
  260.             {
  261.                 csTxt += _T("注册表启动项中的病毒信息无法删除\r\n");
  262.             }
  263.         }
  264.         else
  265.         {
  266.             csTxt += _T("注册表启动项中不存在病毒信息\r\n");
  267.         }
  268.         RegCloseKey(hKeyHKCU);
  269.     } 
  270.     else
  271.     {
  272.         csTxt += _T("注册表启动项信息读取失败\r\n");
  273.     }
  274.     // 接下来修复文件的隐藏显示，需要将CheckedValue的值设置为1
  275.     char RegHide[] = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced\\Folder\\Hidden\\SHOWALL"; 
  276.     HKEY hKeyHKLM = NULL; 
  277.     DWORD dwFlag = 1;
  279.     long lRetHide = RegOpenKey(HKEY_LOCAL_MACHINE, RegHide, &hKeyHKLM);
  280.     if(lRetHide == ERROR_SUCCESS)
  281.     {
  282.         csTxt += _T("检测注册表的文件隐藏选项...\r\n");
  283.         if( ERROR_SUCCESS == RegSetValueEx(
  284.                 hKeyHKLM,             //subkey handle  
  285.                             "CheckedValue",       //value name  
  286.                             0,                    //must be zero  
  287.                             REG_DWORD,            //value type  
  288.                             (CONST BYTE*)&dwFlag, //pointer to value data  
  289.                             4))                   //length of value data
  290.         {
  291.             csTxt += _T("注册表修复完毕！\r\n");
  292.         }
  293.         else
  294.         {
  295.             csTxt += _T("无法恢复注册表的文件隐藏选项\r\n");
  296.         }
  297.     }
  298. ///
  299. // 病毒查杀完成
  300. ///
  301.     csTxt += _T("病毒查杀完成，请使用专业杀毒软件进行全面扫描！\r\n");
  302.     SetDlgItemText(IDC_LIST,csTxt);
  303. }

项目

test11111.zip
image.png