要防止自己的程式被關閉,通常有兩種方法1.像IcesWord一樣HOOK系統底層的函式2.使用執行緒保護。這裡我們主要學習執行緒保護的方法
執行緒保護的思路就是讓其它程式監視自己,如果自身程式退出了,那麼監視程式就重新啟動,這個過程我簡單畫了一個圖如圖1所示



跟據圖示1我們來分析一下執行緒守護的思路,並程式設計實現一個簡單的執行緒守護程式，本程式完成的功能是把監視程式碼插入到Notepad.exe程序
以監視程式本身，如果自身被關閉，Notepad.exe程序將重新啟動自身程式，以達到不死的效應,以下程式碼在VC6中編譯通過


現在我們重新整理一下思路，首先我們找一個其它程序做為我們的保護神並把自己程序的控制代碼傳保護神，保護神通過用WaitForSingleObject
函式來檢測控制代碼來判斷要保護的程序是否結束，如果結束就重新啟動我們的程式.跟據上面的思路我們來分析細節的實現



1.檢測並保護程式的遠端執行緒程式碼

因為保護自己的程式碼要注入到Notepad.exe程序，而執行在遠端執行緒程式碼的API都需要重新定位，為解決這個問題我們定義如下的結構
typedef struct _remoteparameter
{
    DWORD        rpWaitForSingleObject;
    DWORD        rpOpenProcess;
    DWORD       rpWinExec;
    DWORD        rpProcessPID;          
    HANDLE        rpProcessHandle;
    char        path[MAX_PATH];
}REMOTEPARAM;


這個結構中包的前三項為遠端執行緒中需要使用的API函式, rpProcessPID為要保護的程序PID,rpProcessHandle用來儲存要保護程序的控制代碼
path為當程式被關閉時需要啟動的程式路徑。遠端執行緒函式如下

DWORD WINAPI remote(LPVOID pvparam)
{
    REMOTEPARAM *rp=(REMOTEPARAM*)pvparam;  //傳遞進來的資訊

    typedef UINT            (WINAPI *EWinExec)                (LPCSTR, UINT);
    typedef HANDLE            (WINAPI *EOpenProcess)            (DWORD, BOOL, DWORD);
    typedef DWORD            (WINAPI *EWaitForSingleObject)    (HANDLE, DWORD);


    EWinExec                tWinExec;
    EOpenProcess            tOpenProcess;
    EWaitForSingleObject    tWaitForSingleObject;


    tOpenProcess            =(EOpenProcess)rp->rpOpenProcess;
    tWaitForSingleObject    =(EWaitForSingleObject)rp->rpWaitForSingleObject;
    tWinExec                =(EWinExec)rp->rpWinExec;


    rp->rpProcessHandle=tOpenProcess(PROCESS_ALL_ACCESS,FALSE,rp->rpProcessPID);//開啟要保護的程序

    tWaitForSingleObject(rp->rpProcessHandle,INFINITE);//要保護的程序是否結束
   
    tWinExec(rp->path, SW_SHOW);//如果結束就重新啟動程式
    return 0;
}


2.將remote函式程式碼注入Notepad.exe程序並啟動


這裡為了方便我定義成了一個函式，使用時只要提供要注入的程序名稱就可以完成執行緒守護的功能,它的返回值是遠端執行緒的控制代碼

其實現如下:


HANDLE CreateRemoteThreadProc(char* ProcessName)
{
        HANDLE    ThreadHandle;
        char    FilePath[MAX_PATH];

        GetModuleFileName(NULL,FilePath,MAX_PATH);//得到檔案所在路徑

        int procID=processtopid(ProcessName);
        printf("The process pid is %d/n",procID);


        HINSTANCE         hkernel32;
        HANDLE            rphandle;
        char             *remotethr;
        char             *remotepar;
        int               cb;

           rphandle=OpenProcess(PROCESS_CREATE_THREAD |    
                                   PROCESS_VM_OPERATION  |    
                                    PROCESS_VM_WRITE,          
                                 FALSE,procID);
        if(rphandle==NULL)
        {
               printf("Open Remote Process  is Error/n");
        }
        else
        {
            printf("open process is ok/n");
        }

        /*****************************************************************/
                        /*將遠端執行緒函式程式碼拷入目標程序*/
        /*****************************************************************/

        cb=sizeof(char)*4*1024;

        remotethr=(PTSTR)VirtualAllocEx(rphandle,NULL,cb,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
        if(remotethr==NULL)
        {
            printf("VirtualAllocEx for Thread Error/n");
            CloseHandle(rphandle);      
        }
        else
            printf("VirtualAllocEx is ok/n");


        if(WriteProcessMemory(rphandle,remotethr,(LPVOID)remote,cb,NULL)==FALSE)
        {
            printf("WriteProcessMemory for Thread Error/n");
            CloseHandle(rphandle);
        }
        else
            printf("WriteProcessMemory is ok/n");

        /*****************************************************************/
                        /*將遠端執行緒函式引數拷入目標程序*/
                        /*這裡需要重定位遠端執行緒需要的API*/
        /*****************************************************************/

        REMOTEPARAM rp;
        memset((char*)&rp,0,sizeof(rp));

        hkernel32=GetModuleHandle("kernel32.dll");

        if(hkernel32==NULL)
        {
            printf("hKernel32 is Error/n");
        }

        rp.rpProcessPID            =GetCurrentProcessId();
        rp.rpOpenProcess        =(DWORD)GetProcAddress(hkernel32,"OpenProcess");
        rp.rpWinExec            =(DWORD)GetProcAddress(hkernel32,"WinExec");
        rp.rpWaitForSingleObject=(DWORD)GetProcAddress(hkernel32,"WaitForSingleObject");
        _tcscpy(rp.path,FilePath);   


        cb=sizeof(char)*sizeof(rp);
        remotepar=(PTSTR)VirtualAllocEx(rphandle,NULL,cb,MEM_COMMIT,PAGE_READWRITE);
        if(remotepar==NULL)
        {
            printf("VirtualAllocEx for Parameter Error/n");
            CloseHandle(rphandle);
        }

        if(WriteProcessMemory(rphandle,remotepar,(LPVOID)&rp,cb,NULL)==FALSE)
        {
            printf("WriteProcessMemory for Parameter Error/n");
            CloseHandle(rphandle);
        }



        /*****************************************************************/
                        /*將遠端執行緒注入目標程序*/
        /*****************************************************************/

       
        ThreadHandle=CreateRemoteThread(rphandle,NULL,0,(LPTHREAD_START_ROUTINE)remotethr,(LPVOID)remotepar,0,NULL);
       
        if(ThreadHandle==NULL)
        {
            printf("CreateRemotThreadHandle Error/n");
            CloseHandle(rphandle);
        }
        else
            printf("CreateRemotThreadHandle is ok/n");

        return ThreadHandle;
}




3.其它自定義函式實現

其實CreateRemoteThreadProc函式就是最關鍵的實現了,最後介紹一個這個函式中的兩個自己定義函式

DWORD processtopid(char *processname)//跟據程序名稱取PID值
{
    DWORD    lpidprocesses[1024],cbneeded,cprocesses;
    HANDLE   hprocess;
    HMODULE  hmodule;
    UINT     i;
    TCHAR    normalname[MAX_PATH]=("UnknownProcess");
   
    if(!EnumProcesses(lpidprocesses,sizeof(lpidprocesses),&cbneeded))
    {
        return -1; 
    }
    cprocesses=cbneeded/sizeof(DWORD);
    for(i=0;i<cprocesses;i++)
    {
        hprocess=OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,FALSE,lpidprocesses[i]);
        if(hprocess)
        {
            if(EnumProcessModules(hprocess,&hmodule,sizeof(hmodule),&cbneeded))
            {
                GetModuleBaseName(hprocess,hmodule,normalname,sizeof(normalname));
                if(!strcmp(normalname,processname)) 
                {
                    CloseHandle(hprocess);
                    return (lpidprocesses[i]);
                }
            }
        }
    }
    CloseHandle(hprocess);
    return 0;
}

BOOL EnablePriv()//提升程序許可權
{
    HANDLE hToken;
    if ( OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&hToken) )
    {
        TOKEN_PRIVILEGES tkp;
       
        LookupPrivilegeValue( NULL,SE_DEBUG_NAME,&tkp.Privileges[0].Luid );    //修改程序許可權
        tkp.PrivilegeCount=1;
        tkp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges( hToken,FALSE,&tkp,sizeof tkp,NULL,NULL );    //通知系統修改程序許可權
    }
        return 0;
}



4.主函式的實現

功能都實現了主函式相對十分簡單其程式碼如下:

int main(int argc, char* argv[])
{
    HANDLE RemoteThreadHandle;

    EnablePriv();

    RemoteThreadHandle=CreateRemoteThreadProc("Notepad.exe");//注入程序

    WaitForSingleObject(RemoteThreadHandle,INFINITE);//等待結束

    return 0;
}


5.測試程式效果

測試開啟本文所屬的程式，測試會發現通過結束程序等方法無法關閉本程式，這是因為程式被關閉後Notepad.exe程式會重新啟動它
如果想關閉程式，只要先結束Notepad.exe就可以了



這樣執行緒守護就完成了,本程式很多地方參照了TOo2y大哥的三執行緒誘鼠器程式碼在此表示感謝,其實多執行緒最初在2002年無花果的"中國黑客"
病毒中使用，並廣為人知，到現在這個技術仍被大量使用著,像鴿子，凋零玫瑰的NCPH的服務端都有這樣的技術,如果你有不明白的地方
或者文章有錯誤歡迎你跟我交流我的QQ是 121121606