浅谈拒绝服务攻击的原理与防御（2）：反射型DDOS

随便、先森。

*本文作者：黑戈爾，转载自FreeBuf.COM

0×01 前言

前几天提交了一篇关于DDOS攻击的文章到今天下午才审核通过发表出来，所以晚上闲来无事在接着写下面的内容，今天我就不多说废话了直接来干货。

目前来说流量型反射DDOS攻击都是以UDP为载体的，毕竟TCP的三次握手就让伪造源地址反射大流量变得不现实（tcp反射ACK倒是还行- -！）

下面来看看一般能用于反射放大的协议以及放大倍数吧

现在TFTP也被利用来进行DDOS反射了，据说放大倍数也很可观，根据表中显示看来NTP放大倍数最高。不过NTP服务器不多，而且开了monlist的更少了，我倒是扫描到过一两个，但是DNS和snmp可就是多如牛毛了，而且SNMP的放大倍数也不是他说的那么小，我今天刚测试发送一个140字节左右的报文能收到1400多字节的恢复，因为我那本破SNMP的书没细说SNMP报文的详细构造，我没能精确的构造SNMP的报文，只能去找了一个现成的，好今天我主要就讲NTP、SNMP和DNS的反射攻击和反射资源的扫描。


0×02 反射放大攻击的原理

很多协议的请求包要远小于回复包，以一个字节的数据换十个字节的数据回来，这就是一种放大，但是你这单纯的放大攻击的是自己啊，所以说想要攻击别人就要在发送请求包时把源地址写成要攻击的人的地址，这样回复的大字节报文就去你要攻击的人那里了，这都是很简单的道理我想也不用我多说

这里放大主要利用的是NTP的monlist（listpeers也行）、DNS的AXFR（ANY也行）、SNMP的getbulkrequest

monlist是返回最近600个与当前NTP服务器通信过的IP地址

AXFR是区域传送（有地方叫域传送），比如freebuf.com下的所有域名返回给请求者

SNMPV2版本中新加的getbulkrequest用于一次请求大量的信息，减少管理站与被管理设备的交互次数

这些协议都是UDP下的协议，我就不详细说了，不然能讲一星期，有兴趣的去找一本TCP/IP的书看看，上面都有详细的介绍。下面直接上扫描这些东西的代码

1. #-*- coding: UTF-8 -*-
   
2. import socket
   
3. import struct
   
4. import thread
   
5.    
   
6.    
   
7. change = lambda x:sum([256**j*int(i) for j,i in enumerate(x.split('.')[::-1])])   
   
8.    
   
9. def NTPscan(IP):
   
10.     str_monlist=#空的，各位自己填上NTP的payload吧
    
11.     str_listpeers=#空的，各位自己填上NTP的payload吧
    
12.     str_dns=(#空的，各位自己填上DNS的payload吧)
    
13.             
    
14.     str_snmp=('\x30'+'\x3b'+'\x02'+'\x01'+'\x01'+'\x04'+'\x06'+'\x70'+'\x75'+'\x62'+'\x6c'
    
15.               +'\x69'+'\x63'+'\xa5'+'\x2e'+'\x02'+'\x04'+'\x4e'+'\x73'+'\x68'+'\xe1'+'\x02'
    
16.               +'\x01'+'\x00'+'\x02'+'\x01'+'\x0a'+'\x30'+'\x20'+'\x30'+'\x0e'+'\x06'+'\x0a'
    
17.               +'\x2b'+'\x06'+'\x01'+'\x02'+'\x01'+'\x19'+'\x03'+'\x03'+'\x01'+'\x01'+'\x05'
    
18.               +'\x00'+'\x30'+'\x0e'+'\x06'+'\x0a'+'\x2b'+'\x06'+'\x01'+'\x02'+'\x01'+'\x19'
    
19.               +'\x03'+'\x03'+'\x01'+'\x02'+'\x05'+'\x00')
    
20.    
    
21.    
    
22.     port_ntp=123
    
23.     port_echo=7
    
24.     port_ch=13
    
25.     port_dns=53
    
26.     port_snmp=161
    
27.     NTP1=(port_ntp,str_monlist)
    
28.     NTP2=(port_ntp,str_listpeers)
    
29.     CHANGE=(port_ch,str_ch)
    
30.     DNS=(port_dns,str_dns)
    
31.     SNMP=(port_snmp,str_snmp)
    
32.     port_pool=(NTP1,CHANGE,DNS,SNMP)
    
33.    
    
34.     for i in range(len(port_pool)):
    
35.         s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    
36.         s.settimeout(1)
    
37.         port_str=port_pool[i]
    
38.         s.sendto(port_str[1],(IP,port_str[0]))
    
39.    
    
40.         try:
    
41.             recvbuff=s.recvfrom(1024)
    
42.             addr=recvbuff[1]
    
43.             data=recvbuff[0]
    
44.             port=addr[1]
    
45.             ip=addr[0]
    
46.             if port in [7,13,53,123,161]:
    
47.                 if port==123:
    
48.                     if len(data)>200:
    
49.                         ip_x=(ip,port,len(data))
    
50.                         ip_pool.append(ip_x)
    
51. 
    
52.                 elif port==53:
    
53.                     if len(data)>100:
    
54.                         ip_x=(ip,port,len(data))
    
55.                         ip_pool.append(ip_x)
    
56. 
    
57.                 elif port==161:
    
58.                     if len(data)>200:
    
59.                         ip_x=(ip,port,len(data))
    
60.                         ip_pool.append(ip_x)
    
61.                 else:        
    
62.                     #print ip,':',port,' ',len(data),'\n'
    
63.                     ip_x=(ip,port,len(data))
    
64.                     ip_pool.append(ip_x)
    
65. 
    
66.         except:
    
67.             pass           
    
68.         s.close()                  
    
69. 
    
70. def main():
    
71.     IP=raw_input("输入IP：")
    
72.     threads=int(input("线程数threads："))
    
73.     IP_a=[]
    
74.     locks=[]
    
75.     if IP.find(',') != -1: #检查是否有，
    
76.         IP_a=IP.split(',') #按，分割字符串成一个数组
    
77. 
    
78.     elif IP.find('-') != -1: #检查是否有-
    
79.         IP_b=IP.split('-')
    
80.         IP_start=IP_b[0] #设定起始IP地址
    
81.         IP_end=IP_b[1]
    
82.         IP_start_num=change(IP_start)
    
83.         IP_end_num=change(IP_end)
    
84.         num=IP_start_num
    
85.         while num <= IP_end_num:
    
86.           ip_i=socket.inet_ntoa(struct.pack('I',socket.htonl(num))) #把数字转换成ip
    
87.       
    
88.           IP_a.append(ip_i)
    
89.           #print IP_a
    
90.           num+=1
    
91.     else:
    
92.         IP_a.append(IP)
    
93. 
    
94. 
    
95.     for i in range(threads):  
    
96.         lock = thread.allocate_lock()   #创建锁对象  
    
97.         lock.acquire()                  #获取锁对象 加锁  
    
98.         locks.append(lock)
    
99.     for i in range(threads):
    
100.         thread.start_new_thread(scan,(IP_a,i,locks[i],threads))
     
101.     for i in range(threads):
     
102.         while locks[i].locked():
     
103.             pass   
     
104. def scan(IP_a,i,lock,threads):
     
105.    
     
106.     while i<len(IP_a):
     
107.         NTPscan(IP_a[i])
     
108.         #print addrs[q]
     
109.         i=i+threads
     
110.     lock.release()
     
111. ip_pool=[]
     
112. 
     
113. if __name__ == '__main__':   
     
114.     main()
     
115. 
     
116. print "所有线程运行结束success！"
     
117. print "-----IP--------port---len"
     
118. #a=open('d:\\address.txt','w')
     
119. #a.writelines(ip_pool)
     
120. #a.close()
     
121. for i in ip_pool:
     
122.     print i
     
123. exitt=raw_input("输入任意键exit：")
     
124. exit()   
     

复制代码

用python打开，只能在windows下，因为这个多线程thread在linux下好像不能用，输入IP的时候可以输入 x.x.x.x-x.x.x.x形式，或者以逗号分隔 x.x.x.x，a.a.a.a，s.s.s.s又或者只输入一个ip也行，线程数要是扫描1.1.0.0-1.2.0.0 这样大段的话推荐1000-2000线程就可以，要是扫描2.0.0.0-3.0.0.0这样一千多万地址，你直接上10000线程吧，不然慢死，我编程水平比较low，所以代码写的很杂乱，大家别嘲笑我啊，还有为了防止大家去做坏事我吧DNS和NTP的payload删掉了，留下了SNMP的，大家自己去学习学习这俩协议，自己补全payload吧，就算是家庭作业了。

攻击代码我也写好了，只不过嘿嘿……现在还不发呢，下期再发吧。